@lovrozagar/honey 0.7.3 → 1.0.0-rc.1

package/dist/input/accepts.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The supported type the request's Accept header prefers, as `supported` spells it; `null` when
+ * the client accepts none of them. No Accept header, or one with no usable range, takes the first.
+ */
+export declare function accepts<const T extends string>(req: Request, supported: readonly T[]): T | null;

package/dist/input/accepts.js

@@ -0,0 +1,105 @@
+/**
+ * Content negotiation over the Accept header (RFC 9110 §12.5.1): which of the types a handler can
+ * answer with the client prefers. Each supported type takes the weight of the most specific range
+ * that matches it, so `text/html;q=0, *\/*` excludes `text/html`; equal weights go to the server's
+ * order. A plain function: nothing is registered, nothing is cached.
+ */
+import { parseMediaType } from "../response/media-type.js";
+/* RFC 9110 §12.4.2 qvalue, lenient on the digit count and a missing leading zero */
+const QVALUE = /^(?:0(?:\.\d*)?|1(?:\.0*)?|\.\d+)$/;
+/** A weight, or 0 for one out of range or malformed: such a range is unusable, never q=1. */
+function weight(raw) {
+    return QVALUE.test(raw) ? Number(raw) : 0;
+}
+function unquote(value) {
+    return value.length >= 2 && value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
+}
+/** One comma-separated part of the header, or `null` when it is no media range (`*\/html` included). */
+function parseRange(part) {
+    const segments = part.split(";");
+    const head = segments[0].trim().toLowerCase();
+    const slash = head.indexOf("/");
+    if (slash <= 0 || slash === head.length - 1)
+        return null;
+    const type = head.slice(0, slash);
+    const subtype = head.slice(slash + 1);
+    if (type === "*" && subtype !== "*")
+        return null;
+    const params = new Map();
+    let q = 1;
+    for (const segment of segments.slice(1)) {
+        const eq = segment.indexOf("=");
+        if (eq === -1)
+            continue;
+        const name = segment.slice(0, eq).trim().toLowerCase();
+        const value = segment.slice(eq + 1).trim();
+        /* what follows q is an accept extension, never a media-type parameter */
+        if (name === "q") {
+            q = weight(value);
+            break;
+        }
+        params.set(name, unquote(value));
+    }
+    return { params, q, subtype, type };
+}
+function parseAccept(header) {
+    const ranges = [];
+    for (const part of header.split(",")) {
+        const range = part.trim().length === 0 ? null : parseRange(part);
+        if (range !== null)
+            ranges.push(range);
+    }
+    return ranges;
+}
+/** How specifically `range` matches the supported type: 0 not at all, higher the more specific. */
+function specificity(range, type, subtype, params) {
+    if (range.type === "*")
+        return 1;
+    if (range.type !== type)
+        return 0;
+    if (range.subtype === "*")
+        return 2;
+    if (range.subtype !== subtype)
+        return 0;
+    for (const [name, value] of range.params) {
+        if (params[name] !== value)
+            return 0;
+    }
+    return 3 + range.params.size;
+}
+/** The weight the client gives `supported`: that of its most specific matching range, or -1 for none. */
+function weightOf(ranges, supported) {
+    const media = parseMediaType(supported);
+    if (media === null)
+        return -1;
+    let best = 0;
+    let q = -1;
+    for (const range of ranges) {
+        const spec = specificity(range, media.type, media.subtype, media.params);
+        if (spec > best) {
+            best = spec;
+            q = range.q;
+        }
+    }
+    return q;
+}
+/**
+ * The supported type the request's Accept header prefers, as `supported` spells it; `null` when
+ * the client accepts none of them. No Accept header, or one with no usable range, takes the first.
+ */
+export function accepts(req, supported) {
+    const header = req.headers.get("accept");
+    const ranges = header === null ? [] : parseAccept(header);
+    if (ranges.length === 0)
+        return supported[0] ?? null;
+    let match = null;
+    let top = 0;
+    for (const type of supported) {
+        const q = weightOf(ranges, type);
+        if (q > top) {
+            top = q;
+            match = type;
+        }
+    }
+    return match;
+}

package/dist/input/binary.d.ts

@@ -0,0 +1,20 @@
+/** The media types a route takes as a binary body: one, or a list; each `type/subtype` or `type/*`. */
+export type BinaryTypes = `${string}/${string}` | readonly `${string}/${string}`[];
+/** The body as ctx.input.binary carries it. */
+export type BinaryBody<T extends string = string> = {
+    readonly bytes: Uint8Array<ArrayBuffer>;
+    readonly type: T;
+};
+/** One declared type: an exact essence, or a `type/*` range. */
+type Range = {
+    readonly essence: string;
+} | {
+    readonly type: string;
+};
+/** The declared types as ranges; one that is no media type or range throws, naming the route. */
+export declare function binaryRanges(declared: BinaryTypes, method: string, path: string): readonly Range[];
+/** The request's essence when a declared range takes it; anything else, none included, is a 415. */
+export declare function binaryType(ranges: readonly Range[], contentType: string | null): string;
+/** The body read once as bytes, with the media type it was sent as. */
+export declare function binaryInput(req: Request, type: string): Promise<BinaryBody>;
+export {};

package/dist/input/binary.js

@@ -0,0 +1,40 @@
+/**
+ * A raw body as `.input({ binary })` declares it (A1): bytes of a declared media type, an upload
+ * of an image or a file. The declared types are exact essences or `type/*` ranges; a request
+ * whose media type matches none answers 415 before its body is read, and the one that matched is
+ * handed on beside the bytes. Size is bodyLimit's or the server's cap, not a knob of its own.
+ */
+import { EK, HoneyError } from "../errors/error.js";
+import { parseMediaType } from "../response/media-type.js";
+/** A declared type as a range, or `null` when it is neither `type/subtype` nor `type/*` (no parameters). */
+function rangeOf(declared) {
+    const text = declared.trim().toLowerCase();
+    if (text.includes(";"))
+        return null;
+    if (text.endsWith("/*")) {
+        const mt = parseMediaType(`${text.slice(0, -2)}/x`);
+        return mt === null || mt.type === "*" ? null : { type: mt.type };
+    }
+    const mt = parseMediaType(text);
+    return mt === null || mt.type === "*" ? null : { essence: mt.essence };
+}
+/** The declared types as ranges; one that is no media type or range throws, naming the route. */
+export function binaryRanges(declared, method, path) {
+    return (typeof declared === "string" ? [declared] : declared).map((type) => {
+        const range = rangeOf(type);
+        if (range !== null)
+            return range;
+        throw new Error(`${method} ${path} declares binary type ${JSON.stringify(type)}: a binary type is type/subtype or type/*.`);
+    });
+}
+/** The request's essence when a declared range takes it; anything else, none included, is a 415. */
+export function binaryType(ranges, contentType) {
+    const mt = parseMediaType(contentType);
+    if (mt !== null && ranges.some((r) => ("essence" in r ? r.essence === mt.essence : r.type === mt.type)))
+        return mt.essence;
+    throw new HoneyError({ errorKey: EK.unsupported_media_type, status: "unsupported_media_type" });
+}
+/** The body read once as bytes, with the media type it was sent as. */
+export async function binaryInput(req, type) {
+    return { bytes: new Uint8Array(await req.arrayBuffer()), type };
+}

package/dist/input/body-kind.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `buffered`: the whole body is in memory, or its length is declared, so reading it is bounded.
+ * `stream`: anything else that has a body; a middleware must never buffer it. `empty`: no body.
+ */
+export type BodyKind = "buffered" | "empty" | "stream";
+/** `response`'s body kind; its content type is never consulted (SSE and NDJSON carry one). */
+export declare function bodyKind(response: Response): BodyKind;
+/** Cancel `response`'s body, unread, unless it is one honey kept: an answer about to go out without it. */
+export declare function discardBody(response: Response): void;
+/**
+ * The answer to a HEAD request: GET's status and headers, no body. A body honey built keeps its
+ * length in `content-length`, so HEAD states what GET would send; any other body is cancelled
+ * unread, so a producer never starts (or stops if it already did).
+ */
+export declare function headResponse(response: Response): Response;

package/dist/input/body-kind.js

@@ -0,0 +1,47 @@
+/**
+ * What body an answer carries, decided without reading it, and the answer to a HEAD request.
+ * Honey tags its answers at creation: a buffered one by its raw body, a produced stream (sse,
+ * stream, generate) by its tag. Neither ever reads `.body` off a buffered HoneyResponse, which on
+ * Node would build a stream for it.
+ */
+import { isHoneyResponse, isProducedStream, rawBodyOf, replaceResponse } from "../response/builder.js";
+/** `response`'s body kind; its content type is never consulted (SSE and NDJSON carry one). */
+export function bodyKind(response) {
+    if (rawBodyOf(response) !== null)
+        return "buffered";
+    if (isProducedStream(response))
+        return "stream";
+    /* a HoneyResponse without a raw body hands out its stream, or null, without building one */
+    if (response.body === null)
+        return "empty";
+    if (isHoneyResponse(response))
+        return "stream";
+    const length = response.headers.get("content-length");
+    return length !== null && /^\d+$/.test(length.trim()) ? "buffered" : "stream";
+}
+// per-process-constant: text-codec
+const encoder = /* @__PURE__ */ new TextEncoder();
+function noop() { }
+/** Cancel `response`'s body, unread, unless it is one honey kept: an answer about to go out without it. */
+export function discardBody(response) {
+    if (rawBodyOf(response) !== null)
+        return;
+    const body = response.body;
+    /* the body is never sent: a cancel failing changes nothing the client sees */
+    if (body !== null && !body.locked)
+        body.cancel().catch(noop);
+}
+/**
+ * The answer to a HEAD request: GET's status and headers, no body. A body honey built keeps its
+ * length in `content-length`, so HEAD states what GET would send; any other body is cancelled
+ * unread, so a producer never starts (or stops if it already did).
+ */
+export function headResponse(response) {
+    const raw = rawBodyOf(response);
+    const headers = new Headers(response.headers);
+    discardBody(response);
+    if (raw !== null && !headers.has("content-length")) {
+        headers.set("content-length", String(typeof raw === "string" ? encoder.encode(raw).byteLength : raw.byteLength));
+    }
+    return replaceResponse(response, { body: null, headers });
+}

package/dist/input/body-limit.d.ts

@@ -0,0 +1,21 @@
+import { type MiddlewareFn } from "../middleware/middleware.ts";
+export type BodyLimitOptions = {
+    /**
+     * Limits by media type, read from the request's parsed media type: an essence key
+     * (`"application/json"`) takes that type alone, a family key ending in `/` (`"multipart/"`)
+     * every subtype of its type. An essence key wins over its family.
+     */
+    limits?: Readonly<Record<string, number>>;
+    /** The cap for a body no `limits` key matches, in bytes. */
+    maxSize: number;
+    /**
+     * Take a declared Content-Length within the cap at its word and count nothing. HTTP/1.1 and
+     * HTTP/2 framing keep a body to its declared length, but only where the transport enforces
+     * it; by default every byte is counted. A body with no declared length is always counted.
+     */
+    trustContentLength?: boolean;
+};
+/** Limit the request body to `options.maxSize` bytes, or to the `limits` entry for its media type. */
+export declare function bodyLimit(options: BodyLimitOptions): MiddlewareFn<{
+    req: Request;
+}, {}, "content_too_large">;

package/dist/input/body-limit.js

@@ -0,0 +1,99 @@
+/**
+ * `bodyLimit(options)`: a cap on the request body, in bytes. A declared Content-Length over the
+ * cap answers 413 before anything is read; otherwise the body is counted as it is read, whatever
+ * the length claims, and the read that passes the cap fails with 413. Every method that carries a
+ * body is limited, extension methods too; a request with no body and no declared length is not.
+ */
+import { withBody } from "../adapters/fetch-request.js";
+import { EK, HoneyError } from "../errors/error.js";
+import { namedMiddleware } from "../middleware/middleware.js";
+import { replaceRequest } from "../context/context.js";
+import { parseMediaType } from "../response/media-type.js";
+/* after an overflow the rest is read and dropped, so the client sees the 413 rather than a reset,
+ * but no further than this: past it the body is cancelled, so an endless one cannot hold the socket */
+const DRAIN_LIMIT = 1_048_576;
+function tooLarge() {
+    return new HoneyError({ errorKey: EK.content_too_large, status: "content_too_large" });
+}
+/** The cap for `contentType` under `limits`: its essence's key, else its family's; `maxSize` when none. */
+function capFor(limits, maxSize, contentType) {
+    const mt = parseMediaType(contentType);
+    if (mt === null)
+        return maxSize;
+    return limits[mt.essence] ?? limits[`${mt.type}/`] ?? maxSize;
+}
+/** A declared length, or `null` when it is absent or not a whole number of bytes. */
+function declaredLength(header) {
+    if (header === null || !/^\d+$/.test(header.trim()))
+        return null;
+    return Number(header);
+}
+/** Read and drop what is left after an overflow, up to DRAIN_LIMIT, then cancel the rest. */
+async function drain(reader) {
+    let drained = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            drained += value.byteLength;
+            if (drained > DRAIN_LIMIT)
+                return void (await reader.cancel());
+        }
+    }
+    catch {
+        /* the body failed or was already done: nothing left to drop */
+    }
+}
+/**
+ * `body` counted against `cap`: the read that passes it errors with 413 and the rest is drained.
+ * Drained, not cancelled, so a FormData body still being encoded (undici) is left to finish.
+ */
+function counted(body, cap) {
+    const reader = body.getReader();
+    let received = 0;
+    return new ReadableStream({
+        cancel() {
+            void drain(reader);
+        },
+        async pull(controller) {
+            let result;
+            try {
+                result = await reader.read();
+            }
+            catch (error) {
+                return controller.error(error);
+            }
+            if (result.done)
+                return controller.close();
+            received += result.value.byteLength;
+            if (received <= cap)
+                return controller.enqueue(result.value);
+            controller.error(tooLarge());
+            void drain(reader);
+        },
+    });
+}
+/** Limit the request body to `options.maxSize` bytes, or to the `limits` entry for its media type. */
+export function bodyLimit(options) {
+    const { maxSize, trustContentLength = false } = options;
+    /* keys lowercased once, on a record with no prototype: a media type never finds a prototype member */
+    const limits = Object.create(null);
+    for (const [key, cap] of Object.entries(options.limits ?? {}))
+        limits[key.trim().toLowerCase()] = cap;
+    const mw = (ctx, next) => {
+        const req = ctx.req;
+        const declared = declaredLength(req.headers.get("content-length"));
+        const body = req.body;
+        if (body === null && declared === null)
+            return next();
+        const cap = capFor(limits, maxSize, req.headers.get("content-type"));
+        if (declared !== null && declared > cap)
+            throw tooLarge();
+        if (body === null || (trustContentLength && declared !== null))
+            return next();
+        replaceRequest(ctx, withBody(req, counted(body, cap)));
+        return next();
+    };
+    return namedMiddleware("bodyLimit", mw);
+}

package/dist/input/cookies.d.ts

@@ -0,0 +1,7 @@
+/** The cookies as `.input({ cookies })` declares them. */
+import type { StandardSchemaLike } from "../validation/standard-schema.ts";
+/**
+ * The cookies (ctx.cookies: the first of a repeated name, as RFC 6265 sends the most specific one
+ * first) validated by `schema`. Without a schema (a `readableStream()` entry) they pass as they are.
+ */
+export declare function cookiesInput(schema: StandardSchemaLike | null, cookies: Record<string, string>): unknown;

package/dist/input/cookies.js

@@ -0,0 +1,8 @@
+import { runSchema } from "../validation/validate-input.js";
+/**
+ * The cookies (ctx.cookies: the first of a repeated name, as RFC 6265 sends the most specific one
+ * first) validated by `schema`. Without a schema (a `readableStream()` entry) they pass as they are.
+ */
+export function cookiesInput(schema, cookies) {
+    return schema === null ? cookies : runSchema(schema, cookies, "cookies");
+}

package/dist/input/form.d.ts

@@ -0,0 +1,10 @@
+/** A form body as `.input({ form })` declares it. */
+import type { BodyParser } from "../response/media-type.ts";
+import type { StandardSchemaLike } from "../validation/standard-schema.ts";
+import { type Shape } from "../validation/validate-input.ts";
+/**
+ * The body read once as an urlencoded or multipart form and validated by `schema`. Repeated keys
+ * follow `shape` (the schema's, computed once per route; the query's policy), and `__proto__`,
+ * `constructor` and `prototype` never reach it.
+ */
+export declare function formInput(schema: StandardSchemaLike, req: Request, parser: Exclude<BodyParser, "json">, shape?: Shape | null): Promise<unknown>;

package/dist/input/form.js

@@ -0,0 +1,24 @@
+import { runSchema, shapedRecord, shapeOf } from "../validation/validate-input.js";
+import { malformedBody } from "./json.js";
+/** The multipart body's fields and files; a body that is not multipart is a 400 `malformed_body`. */
+async function parts(req) {
+    /* read the bytes first: an error while reading passes through, only parsing them is the client's */
+    const bytes = await req.arrayBuffer();
+    /* the multipart parser was chosen from this header, so it is present: it carries the boundary */
+    const contentType = req.headers.get("content-type");
+    try {
+        return await new Response(bytes, { headers: { "content-type": contentType } }).formData();
+    }
+    catch (error) {
+        throw malformedBody("multipart", error);
+    }
+}
+/**
+ * The body read once as an urlencoded or multipart form and validated by `schema`. Repeated keys
+ * follow `shape` (the schema's, computed once per route; the query's policy), and `__proto__`,
+ * `constructor` and `prototype` never reach it.
+ */
+export async function formInput(schema, req, parser, shape = shapeOf(schema)) {
+    const entries = parser === "urlencoded" ? new URLSearchParams(await req.text()) : await parts(req);
+    return runSchema(schema, shapedRecord(entries, shape), "form");
+}

package/dist/input/headers.d.ts

@@ -0,0 +1,7 @@
+/** The request headers as `.input({ headers })` declares them. */
+import type { StandardSchemaLike } from "../validation/standard-schema.ts";
+/**
+ * The request headers (ctx.headers: lowercased names, repeated values joined as Fetch joins them)
+ * validated by `schema`. Without a schema (a `readableStream()` entry) they pass as they are.
+ */
+export declare function headersInput(schema: StandardSchemaLike | null, headers: Record<string, string>): unknown;

package/dist/input/headers.js

@@ -0,0 +1,8 @@
+import { runSchema } from "../validation/validate-input.js";
+/**
+ * The request headers (ctx.headers: lowercased names, repeated values joined as Fetch joins them)
+ * validated by `schema`. Without a schema (a `readableStream()` entry) they pass as they are.
+ */
+export function headersInput(schema, headers) {
+    return schema === null ? headers : runSchema(schema, headers, "headers");
+}

package/dist/input/input.d.ts

@@ -0,0 +1,91 @@
+/**
+ * `.input()`: what a route declares about the request it takes, compiled once into one step that
+ * runs after the route's middleware and before its handler. Sources are read in order (params,
+ * search, headers, cookies, then the body), and the first that fails answers. The step stays
+ * synchronous until a validator or the body has to wait (F6): a route with only sync validators
+ * and no body schema answers without a microtask, and only the route that declares one pays.
+ */
+import type { MaybePromise } from "../middleware/middleware.ts";
+import { type BinaryBody, type BinaryTypes } from "./binary.ts";
+import type { InferInput, InferOutput, StandardSchemaLike } from "../validation/standard-schema.ts";
+/**
+ * A source whose schema documents the shape (for the client and docs) but is not run: a body is
+ * left unread for the handler to stream from `ctx.req`, a non-body source passes as parsed.
+ */
+export type ReadableStreamSchema<S> = {
+    readonly _tag: "readableStream";
+    readonly schema: S;
+};
+/** Hand the source on unvalidated: see {@link ReadableStreamSchema}. */
+export declare function readableStream<S extends StandardSchemaLike>(schema: S): ReadableStreamSchema<S>;
+/** A source's schema, or its `readableStream()` wrapper. */
+export type InputEntry = StandardSchemaLike | ReadableStreamSchema<StandardSchemaLike>;
+/** The non-body sources: all a WebSocket route may declare, since an upgrade has no body. */
+export type NonBodyInput = {
+    readonly cookies?: InputEntry;
+    readonly headers?: InputEntry;
+    readonly params?: InputEntry;
+    readonly search?: InputEntry;
+};
+/** What `.input()` takes: json, form and binary are exclusive, as a request carries one body. */
+export type InputSchemas = (NonBodyInput & {
+    readonly binary?: never;
+    readonly form?: InputEntry;
+    readonly json?: never;
+}) | (NonBodyInput & {
+    readonly binary?: never;
+    readonly form?: never;
+    readonly json?: InputEntry;
+}) | (NonBodyInput & {
+    readonly binary?: BinaryTypes;
+    readonly form?: never;
+    readonly json?: never;
+});
+/** The media type ctx.input.binary names: a declared essence, or any subtype of a `type/*` range. */
+type BinaryTypeOf<T> = (T extends readonly (infer U)[] ? U : T) extends infer E ? E extends `${infer Type}/*` ? `${Type}/${string}` : E : never;
+/** What an unvalidated non-body source carries: the record as parsed. */
+type RawSource<K> = K extends "search" ? Record<string, string | string[]> : Record<string, string>;
+/** One source on ctx.input: the schema's output, or the raw record a `readableStream()` entry passes. */
+type SourceValue<K, E> = K extends "binary" ? BinaryBody<Extract<BinaryTypeOf<E>, string>> : E extends ReadableStreamSchema<unknown> ? RawSource<K> : InferOutput<E>;
+/** The keys ctx.input carries: every declared source except a body left unread. */
+type InputKey<T> = {
+    [K in keyof T]-?: [NonNullable<T[K]>] extends [never] ? never : K extends "form" | "json" ? NonNullable<T[K]> extends ReadableStreamSchema<unknown> ? never : K : K;
+}[keyof T];
+/** ctx.input for a declaration: each source as validated, typed by its schema. */
+export type InferInputMap<T> = {
+    readonly [K in InputKey<T>]: SourceValue<K, NonNullable<T[K]>>;
+};
+/** One source as a client sends it: the schema's input type, a `readableStream()` entry by the schema it wraps. */
+type RequestValue<K, E> = K extends "binary" ? BinaryBody<Extract<BinaryTypeOf<E>, string>> : InferInput<E extends ReadableStreamSchema<infer S> ? S : E>;
+/** The keys a client sends: every declared source, a body left unread included. */
+type RequestKey<T> = {
+    [K in keyof T]-?: [NonNullable<T[K]>] extends [never] ? never : K;
+}[keyof T];
+/** What a client sends for a declaration (the route record's `request`): `readableStream()` entries unwrapped. */
+export type InferRequestMap<T> = {
+    readonly [K in RequestKey<T>]: RequestValue<K, NonNullable<T[K]>>;
+};
+/** What `.input()` records at the type level: the handler's ctx.input and the client's request. */
+export type InputTypes<T> = {
+    input: InferInputMap<T>;
+    request: InferRequestMap<T>;
+};
+/** What the input step reads off a request context. */
+type InputCtx = {
+    readonly cookies: Record<string, string>;
+    readonly headers: Record<string, string>;
+    input?: unknown;
+    readonly params: Record<string, string>;
+    readonly req: Request;
+    readonly searchAll: Record<string, string[]>;
+};
+/** The compiled step: sets ctx.input, or a promise of having set it when something had to wait. */
+export type InputStep = (ctx: InputCtx) => Promise<void> | undefined;
+/**
+ * Compile `schemas` for a route at `path` reached by `methods`. A body schema on a route only GET
+ * or HEAD reach, or json and form together, throws here, at registration.
+ */
+export declare function compileInput(schemas: InputSchemas, methods: readonly string[], path: string): InputStep;
+/** `handler` behind `step`: the handler runs once ctx.input is set, synchronously when the step was. */
+export declare function withInput(step: InputStep, handler: (ctx: object) => MaybePromise<Response>): (ctx: object) => MaybePromise<Response>;
+export {};

package/dist/input/input.js

@@ -0,0 +1,88 @@
+import { assertBodySchemaAllowed, assertRequestContentType } from "../validation/content-type.js";
+import { binaryInput, binaryRanges, binaryType } from "./binary.js";
+import { shapeOf } from "../validation/validate-input.js";
+import { cookiesInput } from "./cookies.js";
+import { formInput } from "./form.js";
+import { headersInput } from "./headers.js";
+import { jsonInput } from "./json.js";
+import { paramsInput } from "./params.js";
+import { searchInput } from "./query.js";
+/** Hand the source on unvalidated: see {@link ReadableStreamSchema}. */
+export function readableStream(schema) {
+    return { _tag: "readableStream", schema };
+}
+function compile(entry) {
+    if (entry === undefined)
+        return null;
+    const schema = "_tag" in entry ? null : entry;
+    return { schema, shape: schema === null ? null : shapeOf(schema) };
+}
+/** A body left unread for the handler: no ctx.input key. */
+const UNREAD = /* @__PURE__ */ Symbol("honey.unread");
+/** The body source, read once, or UNREAD for a `readableStream()` body. */
+function readBody(body, ctx, parser) {
+    if (body.schema === null)
+        return UNREAD;
+    return parser === "json" ? jsonInput(body.schema, ctx.req) : formInput(body.schema, ctx.req, parser, body.shape);
+}
+/**
+ * Compile `schemas` for a route at `path` reached by `methods`. A body schema on a route only GET
+ * or HEAD reach, or json and form together, throws here, at registration.
+ */
+export function compileInput(schemas, methods, path) {
+    assertBodySchemaAllowed(schemas, methods, path);
+    const params = compile(schemas.params);
+    const search = compile(schemas.search);
+    const headers = compile(schemas.headers);
+    const cookies = compile(schemas.cookies);
+    const json = compile(schemas.json);
+    const form = compile(schemas.form);
+    const reads = [];
+    if (params !== null)
+        reads.push(["params", (ctx) => paramsInput(params.schema, ctx.params)]);
+    if (search !== null)
+        reads.push(["search", (ctx) => searchInput(search.schema, ctx.searchAll, search.shape)]);
+    if (headers !== null)
+        reads.push(["headers", (ctx) => headersInput(headers.schema, ctx.headers)]);
+    if (cookies !== null)
+        reads.push(["cookies", (ctx) => cookiesInput(cookies.schema, ctx.cookies)]);
+    const body = json ?? form;
+    if (schemas.binary !== undefined) {
+        const ranges = binaryRanges(schemas.binary, methods[0], path);
+        reads.push(["binary", (ctx) => binaryInput(ctx.req, binaryType(ranges, ctx.req.headers.get("content-type")))]);
+    }
+    else if (body !== null) {
+        reads.push([
+            json !== null ? "json" : "form",
+            (ctx) => readBody(body, ctx, assertRequestContentType(schemas, ctx.req.headers.get("content-type"))),
+        ]);
+    }
+    return (ctx) => run(reads, 0, ctx, {});
+}
+/**
+ * Run `reads` from `from`: synchronously while each answers at once, then after each that has to
+ * wait. ctx.input is set once every source passed, so code after a failed step never sees a part.
+ */
+function run(reads, from, ctx, input) {
+    for (let i = from; i < reads.length; i++) {
+        const [key, read] = reads[i];
+        const value = read(ctx);
+        if (value instanceof Promise) {
+            return value.then((settled) => {
+                input[key] = settled;
+                return run(reads, i + 1, ctx, input);
+            });
+        }
+        if (value !== UNREAD)
+            input[key] = value;
+    }
+    ctx.input = input;
+    return undefined;
+}
+/** `handler` behind `step`: the handler runs once ctx.input is set, synchronously when the step was. */
+export function withInput(step, handler) {
+    return (ctx) => {
+        const pending = step(ctx);
+        return pending === undefined ? handler(ctx) : pending.then(() => handler(ctx));
+    };
+}

package/dist/input/json.d.ts

@@ -0,0 +1,10 @@
+/** A JSON body as `.input({ json })` declares it. */
+import { HoneyError } from "../errors/error.ts";
+import type { StandardSchemaLike } from "../validation/standard-schema.ts";
+/** A body the declared parser cannot read: the client's mistake, a 400, never a 500. */
+export declare function malformedBody(format: "json" | "multipart", cause: unknown): HoneyError;
+/**
+ * The body read once as JSON and validated by `schema`. An empty or unparseable body is a 400
+ * `malformed_body`; an error while reading it (a size limit, a client abort) passes through.
+ */
+export declare function jsonInput(schema: StandardSchemaLike, req: Request): Promise<unknown>;

package/dist/input/json.js

@@ -0,0 +1,22 @@
+/** A JSON body as `.input({ json })` declares it. */
+import { EK, HoneyError } from "../errors/error.js";
+import { runSchema } from "../validation/validate-input.js";
+/** A body the declared parser cannot read: the client's mistake, a 400, never a 500. */
+export function malformedBody(format, cause) {
+    return new HoneyError({ cause, errorKey: EK.malformed_body, status: "bad_request", vars: { format } });
+}
+function parse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw malformedBody("json", error);
+    }
+}
+/**
+ * The body read once as JSON and validated by `schema`. An empty or unparseable body is a 400
+ * `malformed_body`; an error while reading it (a size limit, a client abort) passes through.
+ */
+export async function jsonInput(schema, req) {
+    return runSchema(schema, parse(await req.text()), "json");
+}

package/dist/input/params.d.ts

@@ -0,0 +1,7 @@
+/** The route's params as `.input({ params })` declares them. */
+import type { StandardSchemaLike } from "../validation/standard-schema.ts";
+/**
+ * `params` validated by `schema`: what the schema produced, a promise of it only for an async
+ * validator. Without a schema (a `readableStream()` entry) the params pass as they are.
+ */
+export declare function paramsInput(schema: StandardSchemaLike | null, params: Record<string, string>): unknown;