@lovrozagar/honey 0.7.3 → 1.0.0-rc.3

package/dist/index.d.ts

@@ -1,748 +1,32 @@
-import { HoneyContext } from "./context.ts";
-import { type TrustSetting } from "./client-info.ts";
-import type { TrustProxy } from "./trust.ts";
-import { HoneyError } from "./error.ts";
-import { ERROR_META } from "./errors.ts";
-import type { ChainErrorConverter, MiddlewareFn, RuntimeMiddleware } from "./middleware.ts";
-import type { ProxyConfig } from "./proxy.ts";
-import type { CustomErrorFormatter, ErrorFormatter, ResponseOptions, TypedResponse } from "./response.ts";
-import { type HoneyRes } from "./response.ts";
-import type { RouteId, Segment } from "./pattern.ts";
-import type { RouteEntry, RouteHandler, RouteTree, TreeNode, WSRouteHandler } from "./tree.ts";
-import type { RealtimeBus } from "./realtime/bus.ts";
-import type { RealtimeConfig, RealtimeRouteOpts } from "./realtime/route.ts";
-import type { RealtimePublisher } from "./realtime/server.ts";
-import type { ComputeErrorsByStatus, DefaultMeta, ExtractSchemas, HttpMethod, InferInputMap, InferOutput, HoneyMetaSpec, InputSchemasDef, MergePath, MergeRoute, MetaSpecConfig, OutputSchemaDef, ParamsFromPath, PrefixRoutes, StandardSchemaLike, TapContext } from "./types.ts";
-import type { WSAdapter, WSHandler } from "./ws/cloudflare.ts";
-import { type WSOriginPolicy } from "./ws-origin.ts";
-import type { MetaSpecSource } from "./meta-spec-merge.ts";
-import type { HoneyServeOptions, ServeHandle } from "./serve.ts";
-export { clientInfo, HoneyContext } from "./context.ts";
-export { toFetchRequest } from "./fetch-request.ts";
-export type { WSOriginPolicy } from "./ws-origin.ts";
-export type { ClientInfo } from "./client-info.ts";
-export type { TrustProxy } from "./trust.ts";
-/** HoneyContext without internal backing fields — use this for consumer-facing types */
-export type HoneyCtx<TEnv = Record<string, unknown>> = Omit<import("./context.ts").HoneyContext<TEnv>, "_errorToResponse" | "_isErrorResponse" | "_lzClient" | "_lzCookies" | "_lzHeaders" | "_lzSearch" | "_lzSearchAll" | "_lzUrlFn" | "_rq" | "_setErrors">;
-export { HoneyError } from "./error.ts";
-export { defineErrors, ERROR_META } from "./errors.ts";
-export type { ErrorMetaEntry } from "./errors.ts";
-export type { MiddlewareFn } from "./middleware.ts";
-export { createMiddleware, defineMiddleware } from "./middleware.ts";
-export type { ProxyConfig } from "./proxy.ts";
-export type { PendingTap, TapContext, TapHandler } from "./types.ts";
-export type { CookieOptions, CustomErrorFormatter, ErrorFormatter, ResponseOptions, SSEEvent, SSEOptions, SSEStream, TypedResponse, } from "./response.ts";
-export { createErrorResponse, HoneyRes } from "./response.ts";
-export { mergeTree } from "./tree.ts";
-export type { DefaultMeta, HoneyCodegen, HoneyMeta, InferBasePath, InferCtx, InferEnv, InferErrorFactory, InferInputMap, InferMeta, InferMethods, InferOutput, InferRouteCtx, InferRouteErrors, InferRouteInput, InferRouteMeta, InferRouteMethods, InferRouteOutput, InferRoutePaths, InferRoutes, InputSchemasDef, MergePath, PrefixRoutes, HoneyMetaSpec, MetaSpecConfig, MetaSpecContext, MetaSpecEntry, MetaSpecMergeConflict, MetaSpecExpand, MetaSpecProfile, MetaSpecSchemaEntry, MetaSpecSchemaSearch, MetaSpecSchemaSource, MetaSpecSingle, MetaSpecStrictness, MetaSpecTarget, OpenApiMeta, OutputSchemaDef, Overwrite, ComputeErrorsByStatus, RouteRecord, StandardSchemaLike, StatusKey, SuccessStatusKey, } from "./types.ts";
-export type { WSAdapter, WSAdapterOptions, WSContext, WSHandler, WSPreUpgrade } from "./ws/cloudflare.ts";
-export type { ConnContext, RealtimeLimits, RealtimeRouteOpts } from "./realtime/route.ts";
-export type { RealtimePublisher } from "./realtime/server.ts";
-export type { RealtimeBus } from "./realtime/bus.ts";
-export type { HoneyServeOptions, ServeHandle } from "./serve.ts";
-export type { ServeRuntime } from "./detect-runtime.ts";
-export { detectRuntime } from "./detect-runtime.ts";
-type TelemetryAdapter = {
-    onError?(ctx: {
-        duration: number;
-        error: HoneyError;
-        method: string;
-        path: string;
-    }): void;
-    /** `path` is the request path; `route` the matched pattern (`/users/:id`). */
-    onHandler?(ctx: {
-        duration: number;
-        method: string;
-        path: string;
-        route: string;
-        status: number;
-    }): void;
-    onMethodNotAllowed?(ctx: {
-        allowed: string[];
-        method: string;
-        path: string;
-        req: Request;
-    }): void;
-    onMiddleware?(ctx: {
-        duration: number;
-        error?: unknown;
-        name: string;
-    }): void;
-    onNotFound?(ctx: {
-        method: string;
-        path: string;
-        req: Request;
-    }): void;
-    onRequest?(ctx: {
-        env: unknown;
-        req: Request;
-    }): void;
-    /** Fires exactly once per request that fired `onRequest`, whichever way it exits. */
-    onResponse?(ctx: {
-        duration: number;
-        req: Request;
-        status: number;
-    }): void;
-    /** `path` is the request path; `route` the matched pattern (`/users/:id`). */
-    onRoute?(ctx: {
-        method: string;
-        params: Record<string, string>;
-        path: string;
-        req: Request;
-        route: string;
-    }): void;
-};
-type ErrorI18nConfig<TEnv> = {
-    errors?: Record<string, Record<string, string>>;
-    fieldNames?: Record<string, Record<string, string>>;
-    resolveLocale: (ctx: {
-        cookies: Record<string, string>;
-        env: TEnv;
-        headers: Record<string, string>;
-        params: Record<string, string>;
-        req: Request;
-        search: Record<string, string>;
-    }) => string | Promise<string>;
-};
-/** The warn side of a structured logger (`warn(obj, msg)` or `warn(msg)`), e.g. honey/logger. */
-type Logger = {
-    warn?(objOrMsg: Record<string, unknown> | string, msg?: string): void;
-};
-type ErrorCtx<TEnv> = {
-    env: TEnv;
-    jsonFromError: (err: HoneyError) => Response;
-    req: Request;
-};
-type OnErrorFn<TEnv> = (error: unknown, ctx: ErrorCtx<TEnv>) => HoneyError | Response | Promise<HoneyError | Response | undefined | void> | undefined | void;
-type OnMethodNotAllowedFn<TEnv> = (ctx: ErrorCtx<TEnv> & {
-    allowed: string[];
-}) => Response | Promise<Response>;
-type OnNotFoundFn<TEnv> = (ctx: ErrorCtx<TEnv>) => Response | Promise<Response>;
-type TapFn<TEnv> = (ctx: TapContext<TEnv>, payload: unknown) => void | Promise<void>;
-type ErrorFactoryRecord = Record<string, (...args: never[]) => unknown>;
-type OutputValidationMode = "always" | "dev" | "off";
-/**
- * Settings of one app — shared by every handle derived from it (`use()`, `basePath()`,
- * `context()`, `meta()`), so a setter called on any handle applies to all of them and
- * serving any handle behaves the same. Records point at the settings of the app they were
- * registered on, so a mounted sub-app's routes keep their own error factory, default errors,
- * boundary and output validation.
- */
-type AppSettings<TEnv = unknown> = {
-    customErrorFormatter: CustomErrorFormatter | null;
-    customErrorSchema: StandardSchemaLike | null;
-    defaultBoundaryKey: string | null;
-    defaultErrorKeys: Set<string>;
-    errorFactory: ErrorFactoryRecord | null;
-    errorFormatter: ErrorFormatterFn;
-    errorI18n: ErrorI18nConfig<TEnv> | null;
-    errorSchema: StandardSchemaLike | null;
-    logger: Logger | null;
-    onError: OnErrorFn<TEnv> | null;
-    onMethodNotAllowed: OnMethodNotAllowedFn<TEnv> | null;
-    onNotFound: OnNotFoundFn<TEnv> | null;
-    /** null = never set: a mounted route follows the mounting app's mode */
-    outputValidation: OutputValidationMode | null;
-    stripPrefix: string | null;
-    taps: Map<string, TapFn<TEnv>> | null;
-    telemetry: TelemetryAdapter | null;
-    trailingSlash: "enforce" | "ignore" | "strip";
-    encodedSlashes: "allow" | "reject";
-    trust: TrustSetting;
-    wsAdapter: WSAdapter | null;
-};
-/**
- * Everything a matched route runs, compiled once at finalize: the record (with its resolved
- * error keys, meta and chain) and one function that runs chain + handler and never rejects.
- */
-type Plan = {
-    /** `.context()` values copied onto each request context */
-    cv: Record<string, unknown> | null;
-    /** declared error keys are enforced (the route, its middleware or the app declared any) */
-    enf: boolean;
-    /** preflight runner — chain without input validation or handler; compiled on first preflight */
-    pf: CompiledChain | null;
-    /** what the preflight runner runs */
-    pfChain: RuntimeMiddleware[];
-    r: RouteHandler | WSRouteHandler;
-    /** realtime route config when this is a realtime route */
-    rt: RealtimeConfig | null;
-    run: CompiledChain;
-    /** taps of the serving app, plus those of the app the route came from */
-    taps: Map<string, TapFn<unknown>> | null;
-};
-type CompiledChain = (ctx: object) => Response | Promise<Response>;
-/** What one app graph serves, resolved at finalize from records and the loaded tree. */
-type FinalTable = {
-    byId: Map<RouteId, RouteHandler>;
-    convert: ChainErrorConverter;
-    epoch: number;
-    /** 404 / 405: the middleware every route runs, plus the scopes covering the request path */
-    miss: Plan;
-    plans: Map<RouteId, Plan>;
-    /** `METHOD /path` → plan, for routes without params or wildcards */
-    statics: Record<string, Plan>;
-    wsById: Map<RouteId, WSRouteHandler>;
-    wsPlans: Map<RouteId, Plan>;
-};
-/** One `app.use(mw)` — the handle it returns has to register a route, or `mw` runs nowhere. */
-type ChainNode = {
-    mw: RuntimeMiddleware;
-    parent: ChainNode | null;
-    used: boolean;
-};
-/** A route builder still waiting for `.handler()` — reported at finalize. */
-type PendingRoute = {
-    id: string;
-};
-/** @internal — runtime entry for a scoped middleware */
-type ScopedEntry = {
-    /** cached from mw.errors at registration; undefined when none */
-    errors: readonly string[] | undefined;
-    /** the middleware behind a request-path check, for routes the scope covers only partly */
-    guard: RuntimeMiddleware;
-    mw: RuntimeMiddleware;
-    /** canonical full-path pattern (already rebased against basePath at .use time) */
-    prefix: string;
-    segs: Segment[];
-};
-/**
- * One app graph — shared by every handle derived with `use()`, `basePath()`, `context()`,
- * `meta()`. Records are per graph, keyed by `RouteId`; the tree holds ids only, so a loaded
- * (shared, frozen) tree never carries another app's handlers.
- */
-type HoneyGraph = {
-    /** metaSpec policies of mounted sub-apps, merged under `metaSpec` when codegen reads it */
-    absorbedMetaSpecs: MetaSpecSource[];
-    /** gateway catch-alls by method — root wildcards registered over a loaded tree that lacks them */
-    catchAll: Map<string, RouteHandler>;
-    /** every `use(mw)` handle — one that never registers a route is reported at finalize */
-    chains: ChainNode[];
-    /** bumped by every registration; finalize re-runs when it moves */
-    epoch: number;
-    final: FinalTable | null;
-    /** app-wide middleware that runs before every chain (serve({ cors })), keyed so a re-serve replaces it */
-    global: Map<string, RuntimeMiddleware>;
-    hasWs: boolean;
-    /** route data of the loaded tree (per-graph copies) — null when no tree was loaded */
-    loaded: Map<RouteId, RouteEntry> | null;
-    /** Codegen-time meta → OpenAPI policy declared on this app. Never read on the request path */
-    metaSpec: MetaSpecConfig | null;
-    /** route builders still waiting for `.handler()` */
-    pending: Set<PendingRoute>;
-    realtimeBus: RealtimeBus | null;
-    /** `ctx.realtime`, shared by every request of this graph */
-    realtimeCtx: RealtimePublisher | null;
-    realtimeRoutes: Map<string, RealtimeConfig>;
-    records: Map<RouteId, RouteHandler>;
-    root: TreeNode;
-    /** root is a loaded tree (frozen, possibly shared by other apps) — copy before inserting */
-    rootShared: boolean;
-    /** path-scoped middleware, in registration order */
-    scoped: ScopedEntry[];
-    /** chains of the handles that served a request — decide what 404 and 405 run when there are no routes */
-    served: Set<RuntimeMiddleware[]>;
-    settings: AppSettings<unknown>;
-    /** registered after routeTree() with no leaf in the loaded tree — stale generated file */
-    unexpected: Set<RouteId>;
-    /** the loaded tree came in while `honey generate` loaded the app: a stale one is replaced, not fatal */
-    unloadIfStale: boolean;
-    wsRecords: Map<RouteId, WSRouteHandler>;
-};
-type ErrorFormatterFn = ErrorFormatter;
-export declare class Honey<TEnv, TCtx = HoneyContext<TEnv>, TRoutes = {}, TMeta = never, TErrorFactory = never, TDefaultErrors extends string = never, TBasePath extends string = "/", TTaps extends Record<string, unknown> = {}, TScopedMw extends readonly ScopedMwEntry[] = []> {
-    readonly $basePath: TBasePath;
-    readonly $ctx: TCtx;
-    readonly $env: TEnv;
-    readonly $errorFactory: TErrorFactory;
-    readonly $meta: TMeta;
-    readonly $routes: TRoutes;
-    readonly $taps: TTaps;
-    private _basePath;
-    private _chain;
-    private _chainMeta;
-    private _contextValues;
-    private _graph;
-    /** the `use(mw)` call that created this chain — null on the root handle */
-    private _node;
-    constructor(opts?: {
-        graph?: HoneyGraph;
-    });
-    private get _s();
-    /**
-     * @internal — read by codegen through `metaSpecOf()`: the declared policy and every mounted
-     * sub-app's, unmerged. Merged on read, so `metaSpec()` may come before or after `route(sub)`;
-     * the merge lives with codegen so a served app never loads it.
-     */
-    private get _metaSpecSource();
-    /** @internal — read by codegen and OpenAPI */
-    get _errorFactory(): ErrorFactoryRecord | null;
-    set _errorFactory(factory: ErrorFactoryRecord | null);
-    /** @internal — read by OpenAPI */
-    get _errorSchema(): StandardSchemaLike | null;
-    /** @internal — read by OpenAPI */
-    get _customErrorSchema(): StandardSchemaLike | null;
-    private get _root();
-    private get _realtimeBus();
-    /** A new handle on the same graph, carrying this handle's view. */
-    private _derive;
-    /** This handle registers, mounts or serves — every `use()` on its way here is in use. */
-    private _markUsed;
-    /** @internal — used by RouteBuilder for pre-filtered error factory */
-    get _factory(): unknown;
-    /** @internal — used by runtime error boundary */
-    get _boundaryKey(): string | null;
-    /** Convert an unknown thrown value to a plain error Response — no boundary, no onError. */
-    private _toErrorResponse;
-    private _createBoundaryError;
-    private _createError;
-    /**
-     * The i18n-resolved copy of `honeyError`: message from the locale's template for its
-     * errorKey, field paths from the locale's field names. Returns `honeyError` itself when
-     * i18n is not configured or nothing matches. Never mutates it: an error instance can be
-     * thrown again, on another request, in another locale.
-     */
-    private _resolveI18n;
-    /**
-     * The error boundary of every `next()`: turns what a handler or middleware threw into the
-     * Response that replaces it, so every middleware around it sees a Response. Never rejects.
-     */
-    private _convertError;
-    /** Last resort when even the configured formatter throws. */
-    private _safeErrorResponse;
-    /**
-     * Convert thrown value into an error Response — resolves boundary wrapping, i18n
-     * translation, the onError callback, and error telemetry. `onResponse` telemetry is not
-     * fired here: the request fires it exactly once, on the way out.
-     */
-    private _resolveErrorResponse;
-    basePath<P extends string>(prefix: P): Honey<TEnv, TCtx, TRoutes, TMeta, TErrorFactory, TDefaultErrors, MergePath<TBasePath, P>, TTaps, TScopedMw>;
-    context<TAdds extends Record<string, unknown>>(values: TAdds): Honey<TEnv, TCtx & Readonly<TAdds>, TRoutes, TMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    logger(logger: Logger): this;
-    outputValidation(mode: OutputValidationMode): this;
-    trailingSlash(mode: "enforce" | "ignore" | "strip"): this;
-    /**
-     * Request paths containing an encoded `/` or `\` (`%2F`, `%5C`) answer 400 by default.
-     * `"allow"` keeps them encoded in the path, so they decode into a param value
-     * (`/repos/:id` with `/repos/group%2Fproject` gives `id === "group/project"`). Only allow
-     * them when nothing downstream (a `proxy()` upstream, a file resolver) treats a decoded
-     * slash as a separator.
-     */
-    encodedSlashes(mode: "allow" | "reject"): this;
-    /**
-     * Which reverse proxies in front of the app to believe. Decides `ctx.ip`, `clientInfo()`,
-     * `ipRestrict`, and every other feature that needs the client's address, scheme or host.
-     *
-     * - `false` (default): the peer address the runtime reports is the client; `X-Forwarded-*`
-     *   headers are ignored, since any client can send them.
-     * - a hop count: exactly that many proxies, each appending its peer to `X-Forwarded-For`
-     *   (nginx `$proxy_add_x_forwarded_for`, most load balancers). The client is the entry the
-     *   outermost proxy wrote.
-     * - addresses and CIDR ranges of your proxies: hops from those addresses are skipped; the
-     *   first other address is the client.
-     *
-     * A hop count or list needs `import "@lovrozagar/honey/trust"` in the app entry.
-     */
-    trustProxy(value: TrustProxy): this;
-    /** Strip a URL path prefix before route matching — boundary-safe (won't strip partial segments), paths without the prefix pass through unchanged */
-    stripPrefix(prefix: string): this;
-    wsAdapter(adapter: WSAdapter): this;
-    /**
-     * Serve this app's OpenAPI document at `${path}.json`, `.yaml` and `.yml` (default
-     * `/openapi`), and optionally a docs UI. Each call serves its own document: two calls with
-     * different options (say an internal and a public profile) never share a cache. Documents
-     * are generated once per route change, serialized once, and sent with an `ETag` and
-     * `Cache-Control: no-cache`. Pass `enabled: false` (for example in production) to mount
-     * nothing while keeping the call in place.
-     */
-    openapi(options: {
-        description?: string;
-        docs?: "scalar" | "swagger";
-        docsPath?: string;
-        /** Mount the document and docs routes. Default `true`. */
-        enabled?: boolean;
-        filterRoutes?: (route: {
-            meta: unknown;
-            method: string;
-            path: string;
-        }) => boolean;
-        path?: string;
-        /** Named metaSpec profile selecting which emitted keys this document carries */
-        profile?: string;
-        securitySchemes?: Record<string, unknown>;
-        title: string;
-        version: string;
-    }): this;
-    /**
-     * Serve the route manifest at `path` (default `/manifest.json`), filtered by the same
-     * visibility policy as the OpenAPI document. Cached per route change, sent with an `ETag`.
-     * `enabled: false` mounts nothing.
-     */
-    manifest(options?: {
-        enabled?: boolean;
-        path?: string;
-    }): this;
-    /** Mount a served document; a path another route or an earlier call owns is an error. */
-    private _mountArtifact;
-    serve(options?: HoneyServeOptions): Promise<ServeHandle>;
-    /**
-     * Mount an internal GET (spec, docs, manifest). Reports who owns the path when it cannot:
-     * a user route (`"user"`) or an earlier internal mount (`"internal"`). Only an exact leaf
-     * counts: a `/:slug` or `/*rest` route does not block a static internal path, which wins
-     * over it on precedence, with backtracking, in both the runtime and a loaded tree.
-     */
-    private _mountInternalGet;
-    private _bumpEpoch;
-    /** Place `id` at every leaf of `segments`, copying a shared (loaded) root first. */
-    private _placeLeaves;
-    /**
-     * @internal — register one route record. Over a loaded tree the record binds to the leaf
-     * the tree already holds for its id; a root wildcard the tree lacks becomes the gateway
-     * catch-all; any other unknown route marks the tree as stale (reported at finalize).
-     */
-    _addRoute(method: string, segments: readonly Segment[], record: RouteHandler): void;
-    /** @internal — register one websocket (or realtime) route record. */
-    _addWsRoute(segments: readonly Segment[], record: WSRouteHandler): void;
-    /**
-     * Resolve what this graph serves: registered records, live records carried by a loaded
-     * snapshot, and delegated leaves the gateway catch-all serves. Then resolve every record —
-     * its full chain (`chain → scoped → route → input validation`), error keys, meta and error
-     * factory — and compile it once. Re-runs whenever the graph's epoch moved. Throws, naming
-     * every route, when a loaded tree and the registered routes disagree (the generated file is
-     * stale), and when a `use(mw)` handle or a route builder was left unused (the middleware or
-     * route would silently be missing).
-     */
-    _finalize(): FinalTable;
-    /** `use(mw)` handles that never registered, mounted or served, and builders without `.handler()`. */
-    private _assertNothingDiscarded;
-    /**
-     * Resolve a record against this graph: chain = captured chain, the scopes that cover its
-     * pattern (behind a request-path check where only some of its paths are inside), then its
-     * route middleware. Error keys and contributed meta come from that chain, in run order.
-     * The error factory, default errors and boundary come from the app the route was
-     * registered on when that app has a factory, else from this one.
-     */
-    private _resolve;
-    /** Wrap each middleware for `telemetry.onMiddleware`, once per finalize. */
-    private _timed;
-    private _planRoute;
-    private _planWs;
-    /**
-     * 404 and 405 run through the same pipeline as a route: the middleware every route of this
-     * graph starts with (with no routes: every handle that served a request), then every scope
-     * (behind its request-path check), then the 404/405 answer. So a logger or CORS policy on the whole app also covers unknown paths, and a
-     * scope's guard answers before "not found" leaks what exists under it.
-     */
-    private _planMiss;
-    /**
-     * @internal — every served route as one entry per leaf (an optional param yields two
-     * paths), in tree order. Codegen and OpenAPI read routes through this.
-     */
-    _collectRoutes(includeSkipped?: boolean): Array<{
-        handler: RouteHandler;
-        method: string;
-        path: string;
-    }>;
-    /** @internal — websocket routes, one entry per leaf. */
-    _collectWsRoutes(): Array<{
-        handler: WSRouteHandler;
-        path: string;
-    }>;
-    /** @internal — the route-graph epoch; served documents cache against it. */
-    get _epoch(): number;
-    defaultErrorFormatter<TSchema extends StandardSchemaLike>(schema: TSchema, fn: (error: HoneyError) => InferOutput<TSchema>): this;
-    defaultErrorFormatter(fn: ErrorFormatterFn): this;
-    customErrorFormatter<TSchema extends StandardSchemaLike>(schema: TSchema, fn: (error: HoneyError, data: Record<string, unknown>) => InferOutput<TSchema>): this;
-    customErrorFormatter(fn: CustomErrorFormatter): this;
-    errorI18n(config: ErrorI18nConfig<TEnv>): this;
-    onError(handler: OnErrorFn<TEnv>): this;
-    onMethodNotAllowed(handler: OnMethodNotAllowedFn<TEnv>): this;
-    onNotFound(handler: OnNotFoundFn<TEnv>): this;
-    /** Register a tap handler keyed by name — fires after successful handler response */
-    tap<K extends string>(key: K, handler: (ctx: TapContext<TEnv>, payload: K extends keyof TTaps ? TTaps[K] : unknown) => void | Promise<void>): this;
-    telemetry(adapter: TelemetryAdapter): this;
-    /**
-     * Load a route tree — a generated `routes.gen.ts`, an `app.toRouteTree()` snapshot, or a
-     * `mergeTree()` of either. The tree supplies the router topology; what each route runs
-     * comes from the routes this app registers afterwards (bound by `RouteId`), from live
-     * records in a snapshot, or — for leaves with neither — from a root wildcard the app
-     * registers as its gateway catch-all. Must be called before any route is registered.
-     */
-    routeTree(tree: RouteTree): this;
-    /**
-     * Snapshot this app's routes as a tree: a copy of the topology plus, per route, its data
-     * and its live record. Internal routes (spec, docs, manifest) are left out. Loading the
-     * snapshot into another app serves these records; nothing in it is shared with this app.
-     * Each record keeps this app's settings (error factory, defaults, boundary) and context
-     * values, and carries the scoped middleware that covers it here as part of its chain —
-     * scopes themselves do not travel in a tree.
-     */
-    toRouteTree(): RouteTree;
-    /** A resolved record as a standalone source: its resolved chain minus route middleware becomes its chain. */
-    private _bake;
-    /**
-     * @internal — generate-time: copy input/output schemas and the error factory from `source`
-     * onto this app's routes that lack them (a gateway serves its generated tree, which carries
-     * none). A downstream route's error keys resolve against its own app's factory, so the
-     * gateway documents each under the status that app gives it.
-     */
-    _overlaySchemas(source: RouteTree): void;
-    /**
-     * @internal — generate-time: the route tree a gateway serves. `source` is the merged
-     * downstream tree (`codegen.mergeTree`); the gateway's own registered routes join it as
-     * ordinary leaves, while its root wildcards stay out of the tree — they are the catch-all
-     * the downstream leaves delegate to. An own route that is also a downstream route, or
-     * whose topology conflicts with one, throws here instead of at request time. The app is
-     * rebound to the result, so codegen that runs next (OpenAPI, manifest) sees what it serves.
-     */
-    _gatewayTree(source: RouteTree): RouteTree;
-    /** @internal — drop the loaded tree and route by the registered routes alone. */
-    _unloadTree(): void;
-    /** @internal — swap the loaded tree, re-binding every registered route to it. */
-    _replaceLoadedTree(tree: RouteTree): void;
-    /**
-     * Set the app's error factory. Like every app setting it applies to every handle of this
-     * app, whenever it is called; routes mounted from another app keep that app's factory.
-     */
-    errorFactory<TFactory extends Record<string, (...args: never[]) => unknown>>(factory: TFactory): Honey<TEnv, TCtx, TRoutes, TMeta, TFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    /** Error keys every route of this app declares — applies to routes registered before and after the call. */
-    defaultErrors<TKeys extends ([TErrorFactory] extends [never] ? never : keyof TErrorFactory & string)>(...keys: TKeys[]): Honey<TEnv, TCtx, TRoutes, TMeta, TErrorFactory, TDefaultErrors | TKeys, TBasePath, TTaps, TScopedMw>;
-    defaultBoundary<TKey extends ([TErrorFactory] extends [never] ? never : keyof TErrorFactory & string)>(key: TKey): Honey<TEnv, TCtx, TRoutes, TMeta, TErrorFactory, TDefaultErrors | TKey, TBasePath, TTaps, TScopedMw>;
-    /** Phantom overload — constrains what route-level .meta() accepts */
-    meta<TNewMeta extends Record<string, unknown>>(): Honey<TEnv, TCtx, TRoutes, TNewMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    /** Typed chain-level default meta — constrains route meta and sets runtime defaults in one call */
-    meta<TNewMeta extends Record<string, unknown>, TValues extends Partial<DefaultMeta> & Partial<TNewMeta>>(values: TValues): Honey<TEnv, TCtx, TRoutes, TNewMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    /** Chain-level default meta — merged into every route registered on this chain */
-    meta<TValues extends Partial<DefaultMeta> & ([TMeta] extends [never] ? {} : Partial<TMeta>)>(values: TValues): Honey<TEnv, TCtx, TRoutes, TMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    /**
-     * Declare what flows from route meta and route schemas into the OpenAPI document.
-     * Codegen-time only — never consulted on the request path. See docs/meta-spec.md.
-     */
-    metaSpec<TSpec extends HoneyMetaSpec<TMeta>>(spec: TSpec): this;
-    /** Declare tap payload types — auto-extends meta with Partial<T> for meta-driven taps */
-    taps<TNewTaps extends Record<string, unknown>>(): Honey<TEnv, Omit<TCtx, "tap"> & {
-        tap<K extends keyof TNewTaps>(key: K, payload: TNewTaps[K]): void;
-    }, TRoutes, [
-        TMeta
-    ] extends [never] ? Partial<TNewTaps> : TMeta & Partial<TNewTaps>, TErrorFactory, TDefaultErrors, TBasePath, TNewTaps, TScopedMw>;
-    use<TAdds>(mw: MiddlewareFn<TCtx, TAdds>): Honey<TEnv, TCtx & TAdds, TRoutes, TMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    use<const TPath extends string, TAdds>(path: TPath, mw: MiddlewareFn<TCtx, TAdds>): Honey<TEnv, TCtx, TRoutes, TMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, readonly [...TScopedMw, {
-        readonly path: MergePath<TBasePath, TPath>;
-        readonly adds: TAdds;
-    }]>;
-    /**
-     * Mount a sub-app: its routes are served under this handle's basePath (and under `prefix`
-     * when given — `app.route("/v1", sub)` is `app.basePath("/v1").route(sub)`), and this
-     * handle's chain runs before theirs. The sub's own basePath stays part of each path.
-     */
-    route<TSubRoutes, TSubMeta, TSubErrorFactory, TSubDefaultErrors extends string, TSubBasePath extends string>(sub: Honey<TEnv, TCtx, TSubRoutes, TSubMeta, TSubErrorFactory, TSubDefaultErrors, TSubBasePath>): Honey<TEnv, TCtx, TRoutes & PrefixRoutes<TBasePath, TSubRoutes>, TMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    route<const TPrefix extends string, TSubRoutes, TSubMeta, TSubErrorFactory, TSubDefaultErrors extends string, TSubBasePath extends string>(prefix: TPrefix, sub: Honey<TEnv, TCtx, TSubRoutes, TSubMeta, TSubErrorFactory, TSubDefaultErrors, TSubBasePath>): Honey<TEnv, TCtx, TRoutes & PrefixRoutes<MergePath<TBasePath, TPrefix>, TSubRoutes>, TMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    private _mount;
-    private _setBus;
-    private _registerRoute;
-    /** @internal — set (or clear, with null) one app-wide middleware; used by `serve()` */
-    _setGlobal(key: string, mw: RuntimeMiddleware | null): void;
-    /** @internal — what a route registered through this handle captures */
-    _view(): {
-        chain: RuntimeMiddleware[];
-        cv: Record<string, unknown> | null;
-        own: AppSettings<unknown>;
-    };
-    /** @internal — a builder got its handler (or was abandoned on purpose) */
-    _settle(pending: PendingRoute): void;
-    on<const TPath extends string, const TMethods extends readonly [HttpMethod | "ALL", ...(HttpMethod | "ALL")[]]>(methods: TMethods, path: TPath): BuilderChain<TEnv, TCtx & ApplyScoped<TScopedMw, MergePath<TBasePath, TPath>>, {}, never, {}, MergePath<TBasePath, TPath>, TMethods[number], TRoutes, never, TCtx, TMeta, InitAccMeta<TMeta>, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    all<const TPath extends string>(path: TPath): BuilderChain<TEnv, TCtx & ApplyScoped<TScopedMw, MergePath<TBasePath, TPath>>, {}, never, {}, MergePath<TBasePath, TPath>, "ALL", TRoutes, never, TCtx, TMeta, InitAccMeta<TMeta>, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    delete<const TPath extends string>(path: TPath): BuilderChain<TEnv, TCtx & ApplyScoped<TScopedMw, MergePath<TBasePath, TPath>>, {}, never, {}, MergePath<TBasePath, TPath>, "DELETE", TRoutes, never, TCtx, TMeta, InitAccMeta<TMeta>, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    get<const TPath extends string>(path: TPath): BuilderChain<TEnv, TCtx & ApplyScoped<TScopedMw, MergePath<TBasePath, TPath>>, {}, never, {}, MergePath<TBasePath, TPath>, "GET", TRoutes, never, TCtx, TMeta, InitAccMeta<TMeta>, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    head<const TPath extends string>(path: TPath): BuilderChain<TEnv, TCtx & ApplyScoped<TScopedMw, MergePath<TBasePath, TPath>>, {}, never, {}, MergePath<TBasePath, TPath>, "HEAD", TRoutes, never, TCtx, TMeta, InitAccMeta<TMeta>, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    options<const TPath extends string>(path: TPath): BuilderChain<TEnv, TCtx & ApplyScoped<TScopedMw, MergePath<TBasePath, TPath>>, {}, never, {}, MergePath<TBasePath, TPath>, "OPTIONS", TRoutes, never, TCtx, TMeta, InitAccMeta<TMeta>, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    patch<const TPath extends string>(path: TPath): BuilderChain<TEnv, TCtx & ApplyScoped<TScopedMw, MergePath<TBasePath, TPath>>, {}, never, {}, MergePath<TBasePath, TPath>, "PATCH", TRoutes, never, TCtx, TMeta, InitAccMeta<TMeta>, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    post<const TPath extends string>(path: TPath): BuilderChain<TEnv, TCtx & ApplyScoped<TScopedMw, MergePath<TBasePath, TPath>>, {}, never, {}, MergePath<TBasePath, TPath>, "POST", TRoutes, never, TCtx, TMeta, InitAccMeta<TMeta>, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    put<const TPath extends string>(path: TPath): BuilderChain<TEnv, TCtx & ApplyScoped<TScopedMw, MergePath<TBasePath, TPath>>, {}, never, {}, MergePath<TBasePath, TPath>, "PUT", TRoutes, never, TCtx, TMeta, InitAccMeta<TMeta>, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    ws<const TPath extends string>(path: TPath): WSRouteBuilder<TEnv, TCtx & ApplyScoped<TScopedMw, MergePath<TBasePath, TPath>>, {}, never, Honey<TEnv, TCtx, TRoutes, TMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>>;
-    realtime<const TPath extends string>(path: TPath, opts: RealtimeRouteOpts<TCtx & ApplyScoped<TScopedMw, MergePath<TBasePath, TPath>>>): this;
-    /**
-     * Deno must call `Deno.upgradeWebSocket` in the same turn as the serve
-     * callback. When the adapter implements `preUpgrade`, we do that here
-     * and return the 101 response before any middleware Promise.
-     */
-    fetch(request: Request, env: TEnv, executionCtx?: {
-        waitUntil?: (p: Promise<unknown>) => void;
-    }): Response | Promise<Response>;
-    /** @internal 400 for a request path the normalization policy rejects (see `normalizePath`), or an invalid `Host`. */
-    _badRequestTarget(): Response;
-    private trailingSlashRedirects;
-    private pathAfterPrefix;
-    private _doFetch;
-    private _route;
-    private _matchWs;
-    private _dispatchRecord;
-    private _makeErrorCtx;
-    /** A request context for `plan`: route data, context values, `ctx.errors`, `ctx.realtime`. */
-    private _newCtx;
-    private _handleWs;
-    /** Reject a cross-origin upgrade the route's origin policy does not allow (403). */
-    /** The websocket session runtime; a cross-origin upgrade the route does not allow is a 403. */
-    private _wsSession;
-    private _wsUpgrade;
-    /** Terminal of a realtime route's chain: identify, upgrade, and attach the connection to the bus. */
-    private _realtimeUpgrade;
-    /**
-     * 404 (`allowed === null`) and 405: one pipeline with a synthetic record — full context,
-     * the app-wide middleware and the scopes covering the path run once, telemetry fires once.
-     */
-    private _handleMiss;
-    /** Fire `onResponse` once for the request's one exit and return. A dispatch that rejects
-     * (an adapter failure past every error boundary) still ends the request: it reports 500. */
-    private _withOnResponse;
-    private _make404;
-    private _make405;
-    /**
-     * CORS preflight for a path that has no OPTIONS route: run the chain of the route the
-     * preflight asks about (`Access-Control-Request-Method`) — chain, scoped and route
-     * middleware, never input validation or the handler. Middleware that answers the
-     * preflight (cors) short-circuits; otherwise the answer is the 405 with `Allow`.
-     */
-    private _handlePreflight;
-    private _handleMatched;
-    /** Output validation, inside the chain: an invalid body becomes an error response the middleware sees. */
-    private _validateOutput;
-    private _finishMatched;
-}
 /**
- * When content type IS declared → narrow the method (constrain status keys + body).
- * When content type NOT declared → remove the method (Omit).
- * Narrowed methods return TypedResponse<CT, K> for compile-time CT+SK safety.
+ * `@lovrozagar/honey`: the app (`honey()`), its context, errors, middleware and responses, the tree merge, and the
+ * types an app is read through. Everything optional is its own subpath; nothing here registers itself (H23).
  */
-/** Resolve body type: schema → InferOutput, plain type → use as-is */
-type ResolveBody<T, TBody> = TBody extends "infer" ? (T extends StandardSchemaLike ? InferOutput<T> : T) : TBody;
-type NarrowMethod<TRes, TSchemas, Method extends string, CT extends string, TBody> = [TSchemas] extends [never] ? Omit<TRes, Method> : TSchemas extends Record<string, unknown> ? Omit<TRes, Method> & {
-    [M in Method]: <K extends keyof TSchemas & string>(statusKey: K, body: ResolveBody<TSchemas[K], TBody>, opts?: ResponseOptions) => TypedResponse<CT, K>;
-} : Omit<TRes, Method>;
-/**
- * SSE uses a callback signature, not statusKey+body like other methods.
- * Gate presence on text/event-stream declaration, preserve original signature.
- */
-type NarrowSSE<TOutput> = [ExtractSchemas<TOutput, "text/event-stream">] extends [never] ? {} : {
-    sse: HoneyRes["sse"];
-};
-/** Universal methods — always available, not gated by output declaration */
-type UniversalRes = Pick<HoneyRes, "noContent" | "raw" | "redirect" | "stream">;
-/**
- * Constrain ctx.res when output schemas are declared.
- * Declared content types → method constrained (status keys + body type).
- * Undeclared content types → method removed.
- * Universal methods (noContent, redirect, stream, raw) always available.
- * HoneyContext has no private brand, so Omit<TCtx, "res"> replaces the wide HoneyRes.
- */
-type ApplyOutput<TCtx, TOutput> = [keyof TOutput] extends [never] ? TCtx : Omit<TCtx, "res"> & {
-    readonly res: UniversalRes & NarrowMethod<{}, ExtractSchemas<TOutput, "application/json">, "json", "application/json", "infer"> & NarrowMethod<{}, ExtractSchemas<TOutput, "text/plain">, "text", "text/plain", string> & NarrowMethod<{}, ExtractSchemas<TOutput, "text/html">, "html", "text/html", string> & NarrowMethod<{}, ExtractSchemas<TOutput, "application/xml">, "xml", "application/xml", string> & NarrowMethod<{}, ExtractSchemas<TOutput, "text/csv">, "csv", "text/csv", string> & NarrowMethod<{}, ExtractSchemas<TOutput, "application/octet-stream">, "binary", "application/octet-stream", ArrayBuffer | Uint8Array<ArrayBuffer>> & NarrowSSE<TOutput>;
-};
-/** Public alias for codegen — applies output schema constraints to a context type */
-export type WithOutput<TCtx, TOutput> = ApplyOutput<TCtx, TOutput>;
-/** @internal — tuple entry describing a scoped middleware at the type level */
-type ScopedMwEntry = {
-    readonly path: string;
-    readonly adds: unknown;
-};
-/**
- * Walk TScopedMw tuple, intersect `adds` for every entry whose `path` is a prefix of TFullPath.
- * Prefix semantics: TFullPath extends `${P}` (exact) | `${P}/${string}` (descendant).
- *
- * Non-literal-path guard: if Head["path"] is the base `string` type (happens when
- * the user passes a widened variable), skip the entry via `string extends Head["path"] ? {}`.
- * This prevents the always-true `'/anywhere' extends string` from polluting every route.
- */
-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"] ? {} : TFullPath extends Head["path"] ? Head["adds"] : TFullPath extends `${Head["path"] & string}/${string}` ? Head["adds"] : {}) & ApplyScoped<Rest, TFullPath> : {};
-/** Apply typed params — override params with specific keys when route has :param segments */
-type ApplyParams<TCtx, TParams> = [keyof TParams] extends [string] ? string extends keyof TParams ? TCtx : TCtx & {
-    readonly params: TParams;
-} : TCtx;
-/** Typed tap method — constrained to registered tap keys when TTaps is non-empty */
-type TypedTap<TTaps extends Record<string, unknown>> = [keyof TTaps] extends [never] ? {
-    tap(key: string, payload: unknown): void;
-} : {
-    tap<K extends string & keyof TTaps>(key: K, payload: TTaps[K]): void;
-};
-/** Build the full handler context: base ctx + params + input + meta + errors + taps + output-constrained methods */
-type HandlerCtx<TCtx, TInput, TOutput, TParams, TAccMeta = {}, TErrorFactory = never, TErrorKeys extends string = never, TPath extends string = string, TTaps extends Record<string, unknown> = {}> = ApplyOutput<ApplyParams<[keyof TInput] extends [never] ? TCtx : TCtx & {
-    input: TInput;
-}, TParams> & {
-    readonly meta: Readonly<Omit<TAccMeta, "openApi">>;
-    readonly routePattern: TPath;
-} & ([TErrorFactory] extends [never] ? {} : [TErrorKeys] extends [never] ? {
-    readonly errors: TErrorFactory;
-} : {
-    readonly errors: Pick<TErrorFactory, TErrorKeys & keyof TErrorFactory>;
-}) & TypedTap<TTaps>, TOutput>;
-type RouteBuilderState<TParent> = {
-    boundaryErrorKey: string | null;
-    /** keys the route declares itself (`.errors()`, `.boundary()`) */
-    errorKeys: Set<string>;
-    extraMethods: (HttpMethod | "ALL")[] | null;
-    inputSchemas: InputSchemasDef | null;
-    /** explicit meta — chain `.meta()` overlaid by route `.meta()` */
-    meta: Record<string, unknown> | null;
-    method: HttpMethod | "ALL";
-    /** route-level middleware */
-    middlewares: RuntimeMiddleware[];
-    outputSchemas: OutputSchemaDef | null;
-    parent: TParent;
-    /** canonical full pattern */
-    path: string;
-    /** reported at finalize until `.handler()` runs */
-    pending: PendingRoute;
-};
-/** Honey.TMeta defaults to never; never & X is never, so start acc meta at {}. */
-type InitAccMeta<TMeta> = [TMeta] extends [never] ? {} : TMeta;
-/** Skip $routes merge only for a real `{ internal: true }` meta — not for `never`. */
-type SkipRouteRecord<TAccMeta> = [TAccMeta] extends [never] ? false : [TAccMeta] extends [{
-    internal: true;
-}] ? true : false;
-/** Return type for handler() — extracted to avoid 3x duplication */
-type HandlerReturn<TEnv, TBaseCtx, TRoutes, TPath extends string, TMethod extends string, TInput, TOutput, TCtx, TAccMeta, TErrorFactory, _TErrorKeys extends string, TDefaultErrors extends string, TMeta, TBasePath extends string = "/", TTaps extends Record<string, unknown> = {}, TScopedMw extends readonly ScopedMwEntry[] = []> = Honey<TEnv, TBaseCtx, SkipRouteRecord<TAccMeta> extends true ? TRoutes : MergeRoute<TRoutes, TPath, TMethod, TInput, TOutput, HandlerCtx<TCtx, TInput, TOutput, ParamsFromPath<TPath>, TAccMeta, TErrorFactory, _TErrorKeys | TDefaultErrors, TPath, TTaps>, TAccMeta, _TErrorKeys | TDefaultErrors, ComputeErrorsByStatus<TErrorFactory, _TErrorKeys | TDefaultErrors, typeof ERROR_META>>, TMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-type OneShotKey = "boundary" | "errors" | "input" | "meta" | "output";
-type BuilderChain<TEnv, TCtx, TInput, TErrorKeys extends string, TOutput, TPath extends string, TMethod extends string, TRoutes, TUsed extends string, TBaseCtx, TMeta, TAccMeta, TErrorFactory, TDefaultErrors extends string, TBasePath extends string, TTaps extends Record<string, unknown> = {}, TScopedMw extends readonly ScopedMwEntry[] = []> = Omit<RouteBuilder<TEnv, TCtx, TInput, TErrorKeys, TOutput, TPath, TMethod, TRoutes, TUsed, TBaseCtx, TMeta, TAccMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>, TUsed & OneShotKey>;
-declare class RouteBuilder<TEnv, TCtx, TInput = {}, _TErrorKeys extends string = never, TOutput = {}, TPath extends string = string, TMethod extends string = string, TRoutes = {}, TUsed extends string = never, TBaseCtx = TCtx, TMeta = never, TAccMeta = {}, TErrorFactory = never, TDefaultErrors extends string = never, TBasePath extends string = "/", TTaps extends Record<string, unknown> = {}, TScopedMw extends readonly ScopedMwEntry[] = []> {
-    private _s;
-    constructor(state: RouteBuilderState<Honey<TEnv, TBaseCtx, TRoutes, TMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>>);
-    errors<TFactory extends Record<string, (...args: never[]) => unknown>, TKeys extends Exclude<keyof TFactory & string, TDefaultErrors>>(factory: TFactory, ...keys: TKeys[]): BuilderChain<TEnv, TCtx, TInput, _TErrorKeys | TKeys, TOutput, TPath, TMethod, TRoutes, TUsed | "errors", TBaseCtx, TMeta, TAccMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    errors<TKeys extends ([TErrorFactory] extends [never] ? never : Exclude<keyof TErrorFactory & string, TDefaultErrors>)>(...keys: TKeys[]): BuilderChain<TEnv, TCtx, TInput, _TErrorKeys | TKeys, TOutput, TPath, TMethod, TRoutes, TUsed | "errors", TBaseCtx, TMeta, TAccMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    boundary<TKey extends ([TErrorFactory] extends [never] ? never : Exclude<keyof TErrorFactory & string, TDefaultErrors>)>(key: TKey): BuilderChain<TEnv, TCtx, TInput, _TErrorKeys | TKey, TOutput, TPath, TMethod, TRoutes, TUsed | "boundary", TBaseCtx, TMeta, TAccMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    handler(fn: (ctx: HandlerCtx<TCtx, TInput, TOutput, ParamsFromPath<TPath>, TAccMeta, TErrorFactory, _TErrorKeys | TDefaultErrors, TPath, TTaps>) => TypedResponse | Promise<TypedResponse>): HandlerReturn<TEnv, TBaseCtx, TRoutes, TPath, TMethod, TInput, TOutput, TCtx, TAccMeta, TErrorFactory, _TErrorKeys, TDefaultErrors, TMeta, TBasePath, TTaps, TScopedMw>;
-    proxy(config: ProxyConfig<HandlerCtx<TCtx, TInput, TOutput, ParamsFromPath<TPath>, TAccMeta, TErrorFactory, _TErrorKeys | TDefaultErrors, TPath, TTaps>>): HandlerReturn<TEnv, TBaseCtx, TRoutes, TPath, TMethod, TInput, TOutput, TCtx, TAccMeta, TErrorFactory, _TErrorKeys, TDefaultErrors, TMeta, TBasePath, TTaps, TScopedMw>;
-    input<TSchemas extends InputSchemasDef>(schemas: TSchemas): BuilderChain<TEnv, TCtx, TInput & InferInputMap<TSchemas>, _TErrorKeys, TOutput, TPath, TMethod, TRoutes, TUsed | "input", TBaseCtx, TMeta, TAccMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    meta<TRouteMeta extends Partial<DefaultMeta> & ([TMeta] extends [never] ? {} : TMeta)>(meta: TRouteMeta): BuilderChain<TEnv, TCtx, TInput, _TErrorKeys, TOutput, TPath, TMethod, TRoutes, TUsed | "meta", TBaseCtx, TMeta, TAccMeta & TRouteMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    output<TOutputSchemas extends OutputSchemaDef>(_schemas: TOutputSchemas): BuilderChain<TEnv, TCtx, TInput, _TErrorKeys, TOutputSchemas, TPath, TMethod, TRoutes, TUsed | "output", TBaseCtx, TMeta, TAccMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-    use<TAdds>(mw: MiddlewareFn<TCtx, TAdds>): BuilderChain<TEnv, TCtx & TAdds, TInput, _TErrorKeys, TOutput, TPath, TMethod, TRoutes, TUsed, TBaseCtx, TMeta, TAccMeta, TErrorFactory, TDefaultErrors, TBasePath, TTaps, TScopedMw>;
-}
-type WSRouteBuilderState<TParent> = {
-    errorKeys: Set<string>;
-    inputSchemas: InputSchemasDef | null;
-    origins: WSOriginPolicy | null;
-    meta: Record<string, unknown> | null;
-    middlewares: RuntimeMiddleware[];
-    parent: TParent;
-    path: string;
-    pending: PendingRoute;
-};
-declare class WSRouteBuilder<TEnv, TCtx, TInput = {}, _TErrorKeys extends string = never, TParent = unknown> {
-    private _s;
-    constructor(state: WSRouteBuilderState<TParent>);
-    errors<TFactory extends Record<string, (...args: never[]) => unknown>>(factory: TFactory, ...keys: Array<keyof TFactory & string>): WSRouteBuilder<TEnv, TCtx, TInput, _TErrorKeys | (keyof TFactory & string), TParent>;
-    handler(wsHandler: WSHandler<TCtx>): TParent;
-    input<TSchemas extends Pick<InputSchemasDef, "cookies" | "headers" | "search">>(schemas: TSchemas): WSRouteBuilder<TEnv, TCtx, TInput & InferInputMap<TSchemas>, _TErrorKeys, TParent>;
-    meta(meta: Record<string, unknown>): this;
-    /**
-     * Browser origins allowed to open this socket: `"*"`, a list of origins
-     * (`https://app.example.com`), or a predicate. Same-origin always passes. Without it, a
-     * cross-origin upgrade that carries `Cookie` or `Authorization` gets 403.
-     */
-    origins(policy: WSOriginPolicy): WSRouteBuilder<TEnv, TCtx, TInput, _TErrorKeys, TParent>;
-    use<TAdds>(mw: MiddlewareFn<TCtx, TAdds>): WSRouteBuilder<TEnv, TCtx & TAdds, TInput, _TErrorKeys, TParent>;
-}
-export declare function honey<TEnv>(): Honey<TEnv>;
-//# sourceMappingURL=index.d.ts.map
+export { toFetchRequest } from "./adapters/fetch-request.ts";
+export type { ServeHandle } from "./adapters/serve.ts";
+export { HoneyContext } from "./context/context.ts";
+export type { CookieOptions } from "./context/cookie.ts";
+export { HoneyError } from "./errors/error.ts";
+export { defineErrors, ERROR_META, type ErrorMetaEntry } from "./errors/errors.ts";
+export { createErrorResponse, type CustomErrorFormatter, type ErrorFormatter } from "./errors/projector.ts";
+export type { InferInputMap } from "./input/input.ts";
+export type { HoneyMetaSpec, MetaSpecConfig, MetaSpecContext, MetaSpecEntry, MetaSpecExpand, MetaSpecMergeConflict, MetaSpecProfile, MetaSpecSchemaEntry, MetaSpecSchemaSearch, MetaSpecSchemaSource, MetaSpecSingle, MetaSpecStrictness, } from "./meta/meta-spec-merge.ts";
+export { createMiddleware, defineMiddleware, type MiddlewareFn } from "./middleware/middleware.ts";
+export type { ProxyConfig } from "./proxy/proxy.ts";
+export type { RealtimeBus } from "./realtime/bus.ts";
+export type { ConnContext, RealtimeLimits } from "./realtime/route.ts";
+export type { RealtimePublisher } from "./realtime/server.ts";
+export { HoneyRes, type ResponseOptions, type TypedResponse } from "./response/response.ts";
+export type { SSEEvent, SSEOptions, SSEStream } from "./response/sse.ts";
+export type { StatusKey } from "./response/status.ts";
+export { Honey, honey } from "./routing/app.ts";
+export type { ComputeErrorsByStatus, DefaultMeta, HoneyCtx, HoneyMeta, InferBasePath, InferCtx, InferEnv, InferErrorFactory, InferMeta, InferMethods, InferRouteCtx, InferRouteErrors, InferRouteInput, InferRouteMeta, InferRouteMethods, InferRouteOutput, InferRoutePaths, InferRoutes, OpenApiMeta, RouteRecord, } from "./routing/app-types.ts";
+export type { HoneyCodegen, RouteSelectorOf, WithOutput } from "./routing/codegen-types.ts";
+export type { TapContext, TapHandler } from "./routing/tap.ts";
+export { mergeTree } from "./routing/tree-merge.ts";
+export type { MergePath, PrefixRoutes } from "./routing/types.ts";
+export { detectRuntime, type ServeRuntime } from "./runtime/detect-runtime.ts";
+export type { InferOutput, StandardSchemaLike } from "./validation/standard-schema.ts";
+export type { WSAdapter, WSContext, WSHandler } from "./ws/contract.ts";
+export type { WSOriginPolicy } from "./ws/origin.ts";
+export type { WSAdapterOptions } from "./ws/shared.ts";