@lovrozagar/honey 0.7.3 → 1.0.0-rc.3

package/dist/response/sse.js

@@ -0,0 +1,73 @@
+/**
+ * The `text/event-stream` emitter behind `ctx.res.sse()`: event framing, the retry and id
+ * directives, keepalive heartbeats, and the stream a callback writes events into.
+ */
+import { producerStream } from "../streaming/producer-stream.js";
+/* no `connection: keep-alive`: HTTP/1.1 keeps the connection anyway, the header would override a
+ * client's `Connection: close`, and HTTP/2 forbids it */
+export const SSE_HEADERS = /* @__PURE__ */ Object.freeze({
+    "cache-control": "no-cache",
+    "content-type": "text/event-stream",
+});
+const NEWLINE = /[\r\n]/;
+const LINE_BREAK = /\r\n|\r|\n/;
+const HEARTBEAT = ": heartbeat\n\n";
+function swallow() { }
+function isRetry(value) {
+    return value !== undefined && Number.isFinite(value) && value >= 0;
+}
+/** One event on the wire. A newline in the name or the id would start another field: it throws. */
+export function encodeEvent(event) {
+    if (NEWLINE.test(event.event))
+        throw new Error("SSE event name must not contain newlines");
+    if (event.id !== undefined && NEWLINE.test(event.id))
+        throw new Error("SSE id must not contain newlines");
+    const data = typeof event.data === "string" ? event.data : JSON.stringify(event.data);
+    let out = `event: ${event.event}\n`;
+    for (const line of data.split(LINE_BREAK))
+        out += `data: ${line}\n`;
+    if (event.id !== undefined)
+        out += event.id === "" ? "id:\n" : `id: ${event.id}\n`;
+    if (isRetry(event.retry))
+        out += `retry: ${Math.floor(event.retry)}\n`;
+    return `${out}\n`;
+}
+/**
+ * Heartbeats while the stream is open. At most one waits for the reader: a client that stopped
+ * reading never has heartbeats piling up behind it.
+ */
+function keepAlive(sink, every, encoder) {
+    const heartbeat = encoder.encode(HEARTBEAT);
+    let waiting = false;
+    const timer = setInterval(() => {
+        if (waiting)
+            return;
+        waiting = true;
+        sink.write(heartbeat).then(() => {
+            waiting = false;
+        }, swallow);
+    }, every);
+    sink.onEnd(() => clearInterval(timer));
+}
+/** The body an SSE callback writes into; it ends when the callback settles, the client leaves, or the request ends. */
+export function sseBody(callback, options, producer) {
+    const encoder = new TextEncoder();
+    return producerStream((sink) => {
+        const stream = {
+            close: () => sink.close(),
+            get closed() {
+                return sink.closed;
+            },
+            lastEventId: options.lastEventId,
+            send: (event) => sink.write(encoder.encode(encodeEvent(event))),
+            signal: sink.signal,
+        };
+        if (isRetry(options.defaultRetry)) {
+            /* a failed write means the stream ended: the producer's own end reports it */
+            sink.write(encoder.encode(`retry: ${Math.floor(options.defaultRetry)}\n\n`)).catch(swallow);
+        }
+        if (options.keepalive !== undefined && options.keepalive > 0)
+            keepAlive(sink, options.keepalive, encoder);
+        return callback(stream);
+    }, producer);
+}

package/dist/response/static.d.ts

@@ -0,0 +1,20 @@
+import { type MiddlewareFn } from "../middleware/middleware.ts";
+import { type RangeBody } from "./range.ts";
+/** What `resolve` may find: a Response to send as it is, or a body to type and range. */
+export type StaticFile = RangeBody | Response;
+export type StaticConfig<TCtx> = {
+    /** Extra response headers; a function gets the path `resolve` got. */
+    headers?: Record<string, string> | ((filePath: string) => Record<string, string>);
+    /** Serve a `.br` or `.gz` sibling to a client that accepts it. Default false: one lookup per request. */
+    precompressed?: boolean;
+    /** Mount point, matched on whole segments: `/assets` serves `/assets/x`, never `/assets-private/x`. */
+    prefix?: string;
+    /** The file for `filePath`, or `null` to fall through to the next handler. */
+    resolve: (ctx: TCtx, filePath: string) => Promise<StaticFile | null> | StaticFile | null;
+    /** Rewrite the decoded path before `resolve` (`/` → `/index.html`); the result is checked again. */
+    rewritePath?: (filePath: string, ctx: TCtx) => string;
+};
+export declare function staticFiles<TCtx extends {
+    readonly path: string;
+    readonly req: Request;
+}>(config: StaticConfig<TCtx>): MiddlewareFn<TCtx>;

package/dist/response/static.js

@@ -0,0 +1,181 @@
+/**
+ * `staticFiles({ resolve, prefix?, headers?, rewritePath?, precompressed? })`: serve GET and HEAD
+ * requests from wherever `resolve` finds a file (a Workers ASSETS binding, `Bun.file`, node's
+ * `fs.openAsBlob`, a KV store). A Response it answers goes out as it is, since the binding or
+ * fetch did its own range and caching; a body (a Blob, a range source, bytes) is typed by its
+ * extension and answered through `rangeResponse`, so a `Range` is honored. `null` falls through to
+ * the app's routes. Conditional GET is bit 08's.
+ *
+ * The path `resolve` gets is the router's normalized `ctx.path` under `prefix` (matched on a whole
+ * segment), decoded once, with no `.`, `..`, empty, NUL, `:` or separator-bearing segment: joined
+ * onto a root directory it cannot leave that root, on POSIX or Windows. A `rewritePath` result is
+ * checked again. With `precompressed`, a client that accepts br or gzip gets the `.br` or `.gz`
+ * sibling when one exists (Vary: Accept-Encoding either way); a range then covers the encoded bytes.
+ *
+ * It is miss-chain middleware: a files-only app must register at least one route on the handle
+ * (typically its SPA or catch-all fallback) for the chain to run at all.
+ */
+import { acceptsCoding } from "../middleware/compress.js";
+import { namedMiddleware } from "../middleware/middleware.js";
+import { normalizePath } from "../routing/request-path.js";
+import { rangeResponse } from "./range.js";
+import { addVary, withHeaders } from "./with-headers.js";
+/** The web's own types by extension (A1); anything else is a Blob's own type or octet-stream. */
+const TYPES = /* @__PURE__ */ Object.freeze({
+    avif: "image/avif",
+    css: "text/css; charset=utf-8",
+    gif: "image/gif",
+    htm: "text/html; charset=utf-8",
+    html: "text/html; charset=utf-8",
+    ico: "image/x-icon",
+    jpeg: "image/jpeg",
+    jpg: "image/jpeg",
+    js: "text/javascript; charset=utf-8",
+    json: "application/json",
+    map: "application/json",
+    mjs: "text/javascript; charset=utf-8",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    otf: "font/otf",
+    pdf: "application/pdf",
+    png: "image/png",
+    svg: "image/svg+xml",
+    ttf: "font/ttf",
+    txt: "text/plain; charset=utf-8",
+    wasm: "application/wasm",
+    webm: "video/webm",
+    webmanifest: "application/manifest+json",
+    webp: "image/webp",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    xml: "application/xml",
+});
+function typeOf(filePath) {
+    const name = filePath.slice(filePath.lastIndexOf("/") + 1);
+    const dot = name.lastIndexOf(".");
+    const ext = dot === -1 ? "" : name.slice(dot + 1).toLowerCase();
+    return Object.hasOwn(TYPES, ext) ? TYPES[ext] : undefined;
+}
+function normalizePrefix(prefix) {
+    const normalized = normalizePath(prefix.startsWith("/") ? prefix : `/${prefix}`);
+    if (normalized === null)
+        throw new TypeError(`staticFiles: invalid prefix ${JSON.stringify(prefix)}`);
+    return normalized.length > 1 && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function isSafeSegment(segment) {
+    if (segment === "" || segment === "." || segment === "..")
+        return false;
+    /* `:` makes a Windows drive (`C:`) or an alternate data stream (`a.txt::$DATA`) */
+    return !segment.includes("/") && !segment.includes("\\") && !segment.includes("\0") && !segment.includes(":");
+}
+/** Decode one segment, or `null` for malformed percent-encoding. */
+function decodeSegment(part) {
+    try {
+        return decodeURIComponent(part);
+    }
+    catch {
+        /* the answer, not a failure: a malformed escape names no file, so the request falls through */
+        return null;
+    }
+}
+/** The decoded path, or `null` when a segment is malformed or names something a file system treats specially. */
+function safeFilePath(encoded) {
+    const parts = encoded.split("/");
+    const out = [];
+    for (let i = 1; i < parts.length; i++) {
+        const part = parts[i];
+        /* a trailing empty segment is a directory request */
+        if (part === "" && i === parts.length - 1)
+            continue;
+        const segment = decodeSegment(part);
+        if (segment === null || !isSafeSegment(segment))
+            return null;
+        out.push(segment);
+    }
+    const joined = `/${out.join("/")}`;
+    return out.length > 0 && encoded.endsWith("/") ? `${joined}/` : joined;
+}
+/** A `rewritePath` result, if it is the same safe shape `resolve` would get without one. */
+function safeRewrite(path) {
+    if (!path.startsWith("/"))
+        return null;
+    const parts = path.split("/");
+    for (let i = 1; i < parts.length; i++) {
+        if (!(parts[i] === "" && i === parts.length - 1) && !isSafeSegment(parts[i]))
+            return null;
+    }
+    return path;
+}
+/** The rest of `path` under `prefix`, or `null` when the path is not under it. */
+function under(prefix, path) {
+    if (prefix === "/")
+        return path;
+    if (path === prefix)
+        return "/";
+    return path.startsWith(prefix) && path.charCodeAt(prefix.length) === 47 ? path.slice(prefix.length) : null;
+}
+/** The file to send: a precompressed sibling the client accepts, else the file itself. */
+async function find(config, ctx, filePath, accept) {
+    if (config.precompressed === true) {
+        if (acceptsCoding(accept, "br")) {
+            const file = await config.resolve(ctx, `${filePath}.br`);
+            if (file !== null)
+                return { encoding: "br", file };
+        }
+        if (acceptsCoding(accept, "gzip")) {
+            const file = await config.resolve(ctx, `${filePath}.gz`);
+            if (file !== null)
+                return { encoding: "gzip", file };
+        }
+    }
+    const file = await config.resolve(ctx, filePath);
+    return file === null ? null : { encoding: null, file };
+}
+/** A Response found: as it is, unless there is something to add (on immutable headers too). */
+function fromResponse(response, encoding, answer) {
+    const { extra, precompressed, type } = answer;
+    if (encoding === null && !precompressed && Object.keys(extra).length === 0)
+        return response;
+    return withHeaders(response, (headers) => {
+        if (encoding !== null) {
+            headers.set("content-encoding", encoding);
+            /* the sibling's own type describes the encoded file; the client wants the original's */
+            if (type !== undefined)
+                headers.set("content-type", type);
+        }
+        if (precompressed)
+            addVary(headers, "accept-encoding");
+        for (const name of Object.keys(extra))
+            headers.set(name, extra[name]);
+    });
+}
+function respond(request, found, answer) {
+    const { encoding, file } = found;
+    if (file instanceof Response)
+        return fromResponse(file, encoding, answer);
+    const headers = { ...answer.extra };
+    if (encoding !== null)
+        headers["content-encoding"] = encoding;
+    if (answer.precompressed)
+        headers.vary = "accept-encoding";
+    const init = answer.type === undefined ? { headers } : { contentType: answer.type, headers };
+    return rangeResponse(request, file, init);
+}
+export function staticFiles(config) {
+    const prefix = normalizePrefix(config.prefix ?? "/");
+    return namedMiddleware("staticFiles", async (ctx, next) => {
+        const req = ctx.req;
+        if (req.method !== "GET" && req.method !== "HEAD")
+            return next();
+        const rest = under(prefix, ctx.path);
+        const decoded = rest === null ? null : safeFilePath(rest);
+        const filePath = decoded === null || !config.rewritePath ? decoded : safeRewrite(config.rewritePath(decoded, ctx));
+        if (filePath === null)
+            return next();
+        const found = await find(config, ctx, filePath, req.headers.get("accept-encoding"));
+        if (found === null)
+            return next();
+        const extra = typeof config.headers === "function" ? config.headers(filePath) : (config.headers ?? {});
+        return respond(req, found, { extra, precompressed: config.precompressed === true, type: typeOf(filePath) });
+    });
+}

package/dist/response/status.d.ts

@@ -0,0 +1,5 @@
+/** The status vocabulary: every 2xx–5xx status as the snake_case key handlers and errors name it by. */
+export type StatusKey = "accepted" | "already_reported" | "created" | "im_used" | "multi_status" | "no_content" | "non_authoritative_information" | "ok" | "partial_content" | "reset_content" | "found" | "moved_permanently" | "multiple_choices" | "not_modified" | "permanent_redirect" | "see_other" | "temporary_redirect" | "bad_request" | "conflict" | "expectation_failed" | "failed_dependency" | "forbidden" | "gone" | "im_a_teapot" | "length_required" | "locked" | "method_not_allowed" | "misdirected_request" | "not_acceptable" | "not_found" | "content_too_large" | "payment_required" | "precondition_failed" | "precondition_required" | "proxy_authentication_required" | "range_not_satisfiable" | "request_header_fields_too_large" | "request_timeout" | "too_early" | "too_many_requests" | "unauthorized" | "unavailable_for_legal_reasons" | "unprocessable_entity" | "unsupported_media_type" | "upgrade_required" | "uri_too_long" | "bad_gateway" | "gateway_timeout" | "http_version_not_supported" | "insufficient_storage" | "internal_server_error" | "loop_detected" | "network_authentication_required" | "not_extended" | "not_implemented" | "service_unavailable" | "variant_also_negotiates";
+export declare const statusKeyToCode: Readonly<Record<StatusKey, number>>;
+/** HTTP code → status key; `undefined` for a code outside the vocabulary. */
+export declare const codeToStatusKey: Readonly<Record<number, StatusKey>>;

package/dist/response/status.js

@@ -0,0 +1,68 @@
+/** The status vocabulary: every 2xx–5xx status as the snake_case key handlers and errors name it by. */
+export const statusKeyToCode = /* @__PURE__ */ Object.freeze({
+    accepted: 202,
+    already_reported: 208,
+    bad_gateway: 502,
+    bad_request: 400,
+    conflict: 409,
+    content_too_large: 413,
+    created: 201,
+    expectation_failed: 417,
+    failed_dependency: 424,
+    forbidden: 403,
+    found: 302,
+    gateway_timeout: 504,
+    gone: 410,
+    http_version_not_supported: 505,
+    im_a_teapot: 418,
+    im_used: 226,
+    insufficient_storage: 507,
+    internal_server_error: 500,
+    length_required: 411,
+    locked: 423,
+    loop_detected: 508,
+    method_not_allowed: 405,
+    misdirected_request: 421,
+    moved_permanently: 301,
+    multi_status: 207,
+    multiple_choices: 300,
+    network_authentication_required: 511,
+    no_content: 204,
+    non_authoritative_information: 203,
+    not_acceptable: 406,
+    not_extended: 510,
+    not_found: 404,
+    not_implemented: 501,
+    not_modified: 304,
+    ok: 200,
+    partial_content: 206,
+    payment_required: 402,
+    permanent_redirect: 308,
+    precondition_failed: 412,
+    precondition_required: 428,
+    proxy_authentication_required: 407,
+    range_not_satisfiable: 416,
+    request_header_fields_too_large: 431,
+    request_timeout: 408,
+    reset_content: 205,
+    see_other: 303,
+    service_unavailable: 503,
+    temporary_redirect: 307,
+    too_early: 425,
+    too_many_requests: 429,
+    unauthorized: 401,
+    unavailable_for_legal_reasons: 451,
+    unprocessable_entity: 422,
+    unsupported_media_type: 415,
+    upgrade_required: 426,
+    uri_too_long: 414,
+    variant_also_negotiates: 506,
+});
+function invert(map) {
+    const out = Object.create(null);
+    for (const key of Object.keys(map))
+        out[map[key]] = key;
+    return Object.freeze(out);
+}
+/** HTTP code → status key; `undefined` for a code outside the vocabulary. */
+export const codeToStatusKey = /* @__PURE__ */ invert(statusKeyToCode);

package/dist/response/with-headers.d.ts

@@ -0,0 +1,11 @@
+/** What an edit may do to the headers: read, set and delete, never walk them. */
+export type HeaderEdit = {
+    delete(name: string): void;
+    get(name: string): string | null;
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+};
+/** `response` with `edit` applied to its headers; `edit` must not read the body. */
+export declare function withHeaders(response: Response, edit: (headers: HeaderEdit) => void): Response;
+/** Add `token` to `Vary` unless it is already listed, case-insensitively, or `Vary` is `*`. */
+export declare function addVary(headers: HeaderEdit, token: string): void;

package/dist/response/with-headers.js

@@ -0,0 +1,47 @@
+/**
+ * Header edits on a response a middleware got back from `next()`, without leaving the fast path:
+ * a HoneyResponse is edited on its plain header map (`HoneyOutHeaders.set`/`delete`), so no native
+ * `Headers` is built. A plain native response is edited in place; one whose headers are immutable
+ * (`fetch()`, `Response.redirect()`) is copied first; a 101 upgrade is never touched.
+ */
+import { isHoneyResponse, rawBodyOf } from "./builder.js";
+/* a header name no one sends: writing to immutable Headers throws */
+const PROBE = "x-honey-mutability-probe";
+function hasImmutableHeaders(response) {
+    try {
+        response.headers.delete(PROBE);
+        return false;
+    }
+    catch {
+        /* the answer, not a failure: these headers are the runtime's own and cannot change */
+        return true;
+    }
+}
+/** `response` with `edit` applied to its headers; `edit` must not read the body. */
+export function withHeaders(response, edit) {
+    /* an upgrade belongs to the runtime: rebuilding it throws or drops the socket */
+    if (response.status === 101)
+        return response;
+    /* a raw body means honey built it, so its headers are its own: no probe (a native delete per edit) */
+    if (isHoneyResponse(response) || rawBodyOf(response) !== null || !hasImmutableHeaders(response)) {
+        edit(response.headers);
+        return response;
+    }
+    const copy = new Response(response.body, {
+        headers: new Headers(response.headers),
+        status: response.status,
+        statusText: response.statusText,
+    });
+    edit(copy.headers);
+    return copy;
+}
+/** Add `token` to `Vary` unless it is already listed, case-insensitively, or `Vary` is `*`. */
+export function addVary(headers, token) {
+    const current = headers.get("vary");
+    if (current === null || current.trim() === "")
+        return headers.set("vary", token);
+    const listed = current.split(",").map((item) => item.trim().toLowerCase());
+    if (listed.includes("*") || listed.includes(token.toLowerCase()))
+        return;
+    headers.set("vary", `${current}, ${token}`);
+}

package/dist/routing/app-types.d.ts

@@ -0,0 +1,175 @@
+/** The app's type machinery: the handler ctx, each route's record, and the `Infer*` ladder. Type-only. */
+import type { HoneyContext, REQUEST } from "../context/context.ts";
+import type { Honey } from "./app.ts";
+import type { RouteSelectorOf } from "./codegen-types.ts";
+import type { ApplyOutput } from "./output-types.ts";
+import type { DeclaredMeta, RouteMeta, WithChainMeta } from "./meta-types.ts";
+import type { TapMethod } from "./tap.ts";
+import type { StatusKey } from "../response/status.ts";
+import type { InferOutput, StandardSchemaLike } from "../validation/standard-schema.ts";
+/** The request context a handler or middleware sees, without the framework's internal slot. */
+export type HoneyCtx<TEnv = Record<string, unknown>> = Omit<HoneyContext<TEnv>, typeof REQUEST>;
+/** Built-in route meta keys. */
+export type OpenApiMeta = {
+    deprecated?: boolean;
+    description?: string;
+    /** Escape hatch: emitted verbatim at the highest precedence. */
+    extensions?: Record<`x-${string}`, unknown>;
+    /** an internal route never appears in generated artifacts */
+    internal?: boolean;
+    invalidate?: readonly RouteSelectorOf[] | null;
+    mcp?: boolean;
+    operationId?: string;
+    security?: Array<Record<string, string[]>> | string | string[];
+    summary?: string;
+    tags?: string | string[];
+};
+export type DefaultMeta = OpenApiMeta;
+/**
+ * The handle's meta after the one-call `meta<T>(values)`: every declared key counts as set, since one call
+ * cannot know which it set (TypeScript has no partial type-argument inference). The two-call form records the
+ * values it was given, so a key nothing set stays required there.
+ */
+export type AllChainMeta<TMeta> = WithChainMeta<TMeta, Partial<DefaultMeta> & Partial<TMeta>>;
+/**
+ * The route meta a consumer declares: the OpenAPI keys and its own. 0.7.3's public alias, kept because a consumer
+ * names it wherever it declares route meta (`app.meta<HoneyMeta<RouteMeta>>()`), and `invalidate` — v0's third
+ * member — is an OpenAPI key now.
+ */
+export type HoneyMeta<T = {}> = OpenApiMeta & T;
+/** A middleware scoped by path at the type level: what it adds to routes under `path`. */
+export type ScopedMwEntry = {
+    readonly adds: unknown;
+    readonly path: string;
+};
+/** The additions of every scoped middleware at `TFullPath` or an ancestor; a widened scope path is skipped. */
+export type ApplyScoped<TScopedMw extends readonly ScopedMwEntry[], TFullPath extends string> = TScopedMw extends readonly [infer Head extends ScopedMwEntry, ...infer Rest extends readonly ScopedMwEntry[]] ? (string extends Head["path"] ? {} : Head["path"] extends "/" ? Head["adds"] : TFullPath extends Head["path"] ? Head["adds"] : TFullPath extends `${Head["path"] & string}/${string}` ? Head["adds"] : {}) & ApplyScoped<Rest, TFullPath> : {};
+/** Typed `ctx.params` when the route pattern names params. */
+export type ApplyParams<TCtx, TParams> = [keyof TParams] extends [string] ? string extends keyof TParams ? TCtx : TCtx & {
+    readonly params: TParams;
+} : TCtx;
+/** The handler ctx: params, meta, pattern, declared errors (as at runtime), input, ctx.res narrowed by output. */
+export type HandlerCtx<TCtx, TParams, TAccMeta = {}, TErrorFactory = never, TErrorKeys extends string = never, TPath extends string = string, TTaps = {}, TInput = never, TOutput = never> = ApplyOutput<ApplyParams<[
+    TErrorFactory
+] extends [never] ? [keyof TTaps] extends [never] ? TCtx : Omit<TCtx, "tap"> : Omit<TCtx, [keyof TTaps] extends [never] ? "errors" : "errors" | "tap">, TParams> & ([keyof TTaps] extends [never] ? {} : TapMethod<TTaps>) & {
+    readonly meta: Readonly<Omit<RouteMeta<TAccMeta>, "openApi">>;
+    readonly routePattern: TPath;
+} & ([TErrorFactory] extends [never] ? {} : [TErrorKeys] extends [never] ? {
+    readonly errors: TErrorFactory;
+} : {
+    readonly errors: Pick<TErrorFactory, TErrorKeys & keyof TErrorFactory>;
+}) & ([TInput] extends [never] ? {} : {
+    readonly input: TInput;
+}), TOutput>;
+/** One route at the type level, for the RPC client and codegen; `request` (what a client sends) is its input. */
+export type RouteRecord<TMethod extends string, TPath extends string, TInput, TOutput, TCtx = unknown, TErrors extends string = never, TErrorsByStatus = never> = {
+    [P in TPath]: {
+        [M in Lowercase<TMethod>]: {
+            ctx: TCtx;
+            errors: TErrors;
+            errorsByStatus: TErrorsByStatus;
+            input: TInput;
+            output: TOutput;
+            request: TInput;
+        };
+    };
+};
+/** Add one route to the accumulated routes (a flat intersection); `request` is what a client sends. */
+export type MergeRoute<TRoutes, TPath extends string, TMethod extends string, TInput, TOutput, TCtx, TMeta = {}, TErrors extends string = never, TErrorsByStatus = never, TRequest = TInput> = TRoutes & {
+    [P in TPath]: {
+        [M in Lowercase<TMethod>]: {
+            ctx: TCtx;
+            errors: TErrors;
+            errorsByStatus: TErrorsByStatus;
+            input: TInput;
+            meta: TMeta;
+            output: TOutput;
+            request: TRequest;
+        };
+    };
+};
+export type { ChainSupplied, DeclaredMeta, InitAccMeta, RouteMeta, SkipRouteRecord, WithChainMeta, } from "./meta-types.ts";
+/** The status codes `errorsByStatus` is keyed by; another status key falls back to `number`. */
+type CodeOf = {
+    accepted: 202;
+    bad_gateway: 502;
+    bad_request: 400;
+    conflict: 409;
+    created: 201;
+    forbidden: 403;
+    gateway_timeout: 504;
+    gone: 410;
+    internal_server_error: 500;
+    method_not_allowed: 405;
+    no_content: 204;
+    not_acceptable: 406;
+    not_found: 404;
+    not_implemented: 501;
+    ok: 200;
+    payment_required: 402;
+    service_unavailable: 503;
+    too_many_requests: 429;
+    unauthorized: 401;
+    unprocessable_entity: 422;
+};
+type StatusKeyToCode<SK extends StatusKey> = SK extends keyof CodeOf ? CodeOf[SK] : number;
+type ErrorMetaMap = Record<string, {
+    schema: unknown;
+    statusKey: unknown;
+}>;
+/** The status keys the declared error keys answer with. */
+type UsedStatusKeys<TMeta extends ErrorMetaMap, TKeys extends string> = TKeys extends keyof TMeta ? TMeta[TKeys]["statusKey"] : never;
+/** The body shapes of the declared error keys that answer with `TSK`: a schema's output, else `null`. */
+type ShapesForStatus<TMeta extends ErrorMetaMap, TKeys extends string, TSK extends StatusKey> = TKeys extends keyof TMeta ? TMeta[TKeys]["statusKey"] extends TSK ? TMeta[TKeys]["schema"] extends StandardSchemaLike ? InferOutput<TMeta[TKeys]["schema"]> : null : never : never;
+/** `{ [statusCode]: bodyShape }` from an error factory and the declared keys, for client-side discrimination. */
+export type ComputeErrorsByStatus<TFactory, TErrorKeys extends string, TMetaSymbol extends symbol> = TFactory extends {
+    readonly [K in TMetaSymbol]: infer TMeta;
+} ? TMeta extends ErrorMetaMap ? {
+    [SK in UsedStatusKeys<TMeta, TErrorKeys> & StatusKey as StatusKeyToCode<SK>]: ShapesForStatus<TMeta, TErrorKeys, SK>;
+} : never : never;
+/** The routes an app accumulated. */
+export type InferRoutes<T> = T extends {
+    readonly $routes: infer R;
+} ? R : never;
+/** The chain's context; `res` is left out so a handler ctx is assignable into services. */
+export type InferCtx<T> = T extends {
+    readonly $ctx: infer TCtx;
+} ? Omit<TCtx, "res"> : never;
+export type InferEnv<T> = T extends {
+    readonly $env: infer TEnv;
+} ? TEnv : never;
+/** Every HTTP method any route uses. */
+export type InferMethods<T> = InferRoutes<T> extends infer R ? {
+    [P in keyof R]: keyof R[P] & string;
+}[keyof R] : never;
+export type InferRoutePaths<T> = keyof InferRoutes<T> & string;
+export type InferRouteMethods<T, TPath extends InferRoutePaths<T>> = InferRoutes<T>[TPath] extends infer M ? keyof M & string : never;
+type RouteLookup<T, TPath extends string, TMethod extends string> = InferRoutes<T> extends infer R ? TPath extends keyof R ? TMethod extends keyof R[TPath] ? R[TPath][TMethod] : never : never : never;
+export type InferMeta<T> = T extends {
+    readonly $meta: infer M;
+} ? DeclaredMeta<M> : never;
+export type InferRouteCtx<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> = RouteLookup<T, TPath, TMethod> extends {
+    ctx: infer C;
+} ? C : never;
+export type InferRouteInput<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> = RouteLookup<T, TPath, TMethod> extends {
+    input: infer I;
+} ? I : never;
+export type InferRouteMeta<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> = RouteLookup<T, TPath, TMethod> extends {
+    meta: infer M;
+} ? M : never;
+export type InferRouteOutput<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> = RouteLookup<T, TPath, TMethod> extends {
+    output: infer O;
+} ? O : never;
+export type InferRouteErrors<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> = RouteLookup<T, TPath, TMethod> extends {
+    errors: infer E;
+} ? E : never;
+export type InferErrorFactory<T> = T extends {
+    readonly $errorFactory: infer F;
+} ? F : never;
+export type InferBasePath<T> = T extends {
+    readonly $basePath: infer P;
+} ? P : never;
+/** `H` with tap payloads `TNewTaps` declared: they join its taps, and route meta may carry any of them. */
+export type WithTaps<H, TNewTaps extends Record<string, unknown>> = H extends Honey<infer TEnv, infer TCtx, infer TRoutes, infer TMeta, infer TFactory, infer TDefaults extends string, infer TBase extends string, infer TTaps extends Record<string, unknown>, infer TScoped extends readonly ScopedMwEntry[]> ? Honey<TEnv, TCtx, TRoutes, [
+    TMeta
+] extends [never] ? Partial<TNewTaps> : TMeta & Partial<TNewTaps>, TFactory, TDefaults, TBase, TTaps & TNewTaps, TScoped> : never;

package/dist/routing/app-types.js

@@ -0,0 +1 @@
+export {};