Handler Binding & Content Negotiation

A multipart/form-data body is a run of boundary-delimited parts, each with its own headers naming the form field and, for files, a filename. The framework walks them in arrival order as field values or file handles.

Handler parameters bind from captured path segments, the query string, headers, cookies, form fields, or the parsed body. The framework picks the source from an explicit marker on the parameter, or infers it from the parameter's name and type.

The returned value models the body, not the whole response. The framework picks a writer for the negotiated media type, serializes the value, synthesises Content-Type and framing, then applies a default success status, conventionally 200.

A URL carries only text. The binder finds a converter for the parameter's declared type, runs it on the raw string, and passes the result in. A failed conversion ends the request as a client error before the handler runs.

A registry of renderers each declares the media types it can produce. The framework keeps those the route allows and that can write the returned value, ranks the survivors against the request's Accept header, and uses the best match.

The framework strips parameters from the Content-Type value, lowercases the type and subtype, and looks that key up in a parser registry, falling back to a structured suffix or a wildcard. A miss yields 415 before the handler runs.

An explicit marker states the source and the wire name, so binding is fixed by the declaration. Inference derives it from the parameter's name and type — shorter, but it changes silently when a name, type or route template changes.

A default substitutes a value when the parameter is absent, so the handler cannot tell silence from a client sending that same value. A nullable parameter passes the absence through, so the handler branches on it.

At least four: a per-part cap, a whole-request cap, a maximum part count, and caps on header blocks and in-memory field values. Counters run as bytes arrive, so 413 goes out mid-body, not after.

Switch to a wrapper as soon as anything beyond the body varies: a status the default cannot reach, a header derived from the result, or several outcomes from one handler. A redirect result packages status and target together.

Its default. A missing Accept header and a wildcard both mean no client preference, so the framework falls back to a configured default type, the route's first declared produced type, or the highest-priority renderer available.

The framework maps a token in the URL - a path suffix or a format query parameter - to a media type and feeds it to renderer selection in place of Accept, making the representation a property of the link.

From the charset parameter on the Content-Type header when present, otherwise a configured default, which on modern servers is UTF-8. Some formats mandate their own encoding, so the parser ignores or rejects a conflicting charset parameter.

Memory is the scarce shared resource: small parts are cheap to hold, so past a configured byte threshold the parser writes the part to a temporary file instead, trading disk and copying for a bounded memory footprint.

Almost nothing reliable. Both are strings the client wrote into the part's headers and the server copies through unverified: claims, not facts. Treat them as untrusted display metadata and derive storage identity and real type server-side.

A missing required value should fail with 400, naming the parameter and its source; a missing optional one should reach the handler as an explicit absence. A path capture cannot be missing: a non-matching template gives 404 instead.

With no returned value there is no body model to serialize, so the framework sends an empty response: some frameworks use status 204, others an empty 200. Mapping is skipped entirely when the response is already marked handled.

The handler's registration decides, not the string's contents: a page-oriented handler treats it as a view name for the template layer, a data-oriented one writes it as the body. Declare the shape and the ambiguity disappears.

A query string expresses several values by repeating the key or by delimiting one value. Neither spelling is defined by the URL grammar, so the framework picks a convention and runs the element converter on every element.

Capture the Accept header the server actually received, then dump the candidate renderers and the winner for that route. The newcomer either entered an undeclared route's candidate set or outranked the incumbent for those clients' headers.

Count bytes while reading and abort the moment the cap is passed, rather than buffering the body and checking afterwards. Answer 413, and handle a client that is still uploading so it receives the status instead of a connection reset.

A spilled part's temporary file is deleted by a hook tied to the end of the request. Disk fills on the endings that skip it: client aborts, parses stopped by a limit, handlers that move the file, and crashes.

No cross-framework standard exists: some order the sources, others merge query and form into one map where one silently overwrites the other. The danger is two layers reading different copies of the name and disagreeing.

Conversion runs in the binder, upstream of the handler, so the framework's own fallback answers instead of the team's error mapping. Unify them by mapping binding failures at framework scope into the same envelope as every other client error.

Register one when the same textual form appears on many routes: the signature then carries the domain type and every route rejects bad text identically. Keep the converter pure, fast and free of lookups.

Only for a value with no security or billing weight, where a client genuinely cannot send the canonical source. Govern it by naming one canonical source, folding the alias into it early in one place, and rejecting conflicting copies.

Decide it once per surface and write it down: leniency is contract you can add but rarely withdraw. Be forgiving where humans type the value, strict where machines call, and never accept an ambiguous form.

Treat an empty body as absent rather than as a null value, and let the handler's declaration decide whether absence is an error. Reject trailing bytes after a complete value: leftover data means the two parties disagree about the message.

Make every route declare what it produces, so a route only offers representations it opted into; give renderers explicit priorities instead of registration order; and set the unmatched-Accept policy per route class, not application-wide.