@lovrozagar/honey 0.1.0 → 0.2.0

package/dist/tree.d.ts

@@ -0,0 +1,90 @@
+import type { HttpMethod, InputSchemasDef, OutputSchemaDef } from "./types.ts";
+import type { WSHandler } from "./ws/cloudflare.ts";
+export type { HttpMethod };
+export type OutputValidator = (statusKey: string, data: unknown) => Promise<void>;
+export type RouteHandler = {
+    /** cached compiled middleware chain (set lazily at first request) */
+    _compiled?: (ctx: object) => Response | Promise<Response>;
+    /** internal route — excluded from codegen output */
+    _skip?: boolean;
+    /** boundary error key — wraps undeclared/unexpected errors (null = use default or internal_server_error) */
+    bek: string | null;
+    /** pre-computed error factory subset (null = use global factory) */
+    ef: Record<string, (...args: never[]) => unknown> | null;
+    /** declared error keys for this route — used for runtime enforcement */
+    ek: Set<string>;
+    /** handler function */
+    fn: (ctx: unknown) => Response | Promise<Response>;
+    /** input validation schemas (null = no input validation) */
+    iv: InputSchemasDef | null;
+    /** route metadata — frozen object, accessible via ctx.meta */
+    mt: Record<string, unknown> | null;
+    /** middleware chain — same as RuntimeMiddleware, inlined to avoid circular dep */
+    mw: Array<(ctx: Record<string, unknown>, next: (additions?: Record<string, unknown>) => Promise<Response>) => Promise<Response>>;
+    /** output schemas by content-type (null = no output validation) */
+    os: OutputSchemaDef | null;
+    /** output validator function — validates response body against schema */
+    ov: OutputValidator | null;
+    /** registered path pattern (e.g. "/users/:id") */
+    rp: string;
+};
+export type { OutputSchemaDef };
+export type WSRouteHandler = {
+    bek: string | null;
+    ek: Set<string>;
+    fn: WSHandler<unknown>;
+    iv: InputSchemasDef | null;
+    mt: Record<string, unknown> | null;
+    mw: Array<(ctx: Record<string, unknown>, next: (additions?: Record<string, unknown>) => Promise<Response>) => Promise<Response>>;
+    /** registered ws path pattern — used by scoped-mw prefix filter */
+    rp: string;
+};
+export type TreeNode = {
+    /** dynamic param child — { n: param name, c: child subtree } */
+    d: {
+        c: TreeNode;
+        n: string;
+    } | null;
+    /** route-graph generation — bumped on insert/merge so served specs can invalidate */
+    g?: number;
+    /** method handlers — maps HTTP method (or ALL) to route handler */
+    m: Record<HttpMethod | "ALL", RouteHandler> | null;
+    /** static children — maps literal path segment to child subtree */
+    s: Record<string, TreeNode>;
+    /** wildcard handler — { n: wildcard name, m: method→handler map } */
+    w: {
+        m: Record<HttpMethod | "ALL", RouteHandler>;
+        n: string;
+    } | null;
+    /** websocket handler for this path */
+    ws: WSRouteHandler | null;
+};
+export declare function bumpGeneration(root: TreeNode): number;
+export type MatchResult = {
+    allowed: HttpMethod[];
+    matched: false;
+} | {
+    handler: RouteHandler;
+    matched: true;
+    params: Record<string, string>;
+} | null;
+export interface RouteMeta {
+}
+export type RouteTree = {
+    handlers?: Record<string, RouteHandler>;
+    meta: Record<string, RouteMeta>;
+    root: TreeNode;
+};
+export declare function createNode(): TreeNode;
+export declare function insertRoute(root: TreeNode, method: HttpMethod | "ALL", path: string, handler: RouteHandler): void;
+export declare function matchRoute(root: TreeNode, method: HttpMethod, path: string): MatchResult;
+export declare function insertWsRoute(root: TreeNode, path: string, handler: WSRouteHandler): void;
+export declare function matchWsRoute(root: TreeNode, path: string): {
+    handler: WSRouteHandler;
+    params: Record<string, string>;
+} | null;
+/** Merge source tree nodes into target tree (mutates target) */
+export declare function mergeInto(target: TreeNode, source: TreeNode): void;
+type TreeInput = RouteTree | [RouteTree, Record<string, unknown>];
+export declare function mergeTree(...trees: TreeInput[]): RouteTree;
+//# sourceMappingURL=tree.d.ts.map

package/dist/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../src/tree.ts"],"names":[],"mappings":"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"}

package/dist/ts-type-emitter.d.ts

@@ -0,0 +1,4 @@
+/** JSON Schema IR → TypeScript type string emitter. Mirrors jsonSchemaToTS logic case-for-case. */
+import type { IRSchema } from "./codegen-ir.ts";
+export declare function irToTs(ir: IRSchema, depth?: number): string;
+//# sourceMappingURL=ts-type-emitter.d.ts.map

package/dist/ts-type-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-type-emitter.d.ts","sourceRoot":"","sources":["../src/ts-type-emitter.ts"],"names":[],"mappings":"AAAA,mGAAmG;AAEnG,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AA2E/C,wBAAgB,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,SAAI,GAAG,MAAM,CA8CtD"}

package/dist/type-emitter.d.ts

@@ -0,0 +1,8 @@
+import type { StandardSchemaLike } from "./types.ts";
+/**
+ * Emit a TypeScript type string from a Standard Schema compatible schema.
+ * Supports Zod (+ mini), Valibot, ArkType, Yup, and Effect.
+ * Unknown vendors return "unknown".
+ */
+export declare function emitSchemaType(schema: StandardSchemaLike): string;
+//# sourceMappingURL=type-emitter.d.ts.map

package/dist/type-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-emitter.d.ts","sourceRoot":"","sources":["../src/type-emitter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAapD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM,CAQjE"}

package/dist/type-extractor.d.ts

@@ -0,0 +1,39 @@
+export type ExtractedBaseCtx = {
+    envType: string;
+    middlewareType: string | null;
+    tapsType: string | null;
+};
+/**
+ * Uses ts-morph to extract the middleware context type from a Honey app export.
+ * Returns inline type strings so the gen file has zero imports from user code.
+ */
+export declare function extractBaseCtx(options: {
+    entryPath: string;
+    exportName: string;
+    outputDir?: string;
+    tsconfigPath?: string;
+}): Promise<ExtractedBaseCtx>;
+export type ExtractedChainTypes = {
+    base: ExtractedBaseCtx;
+    /** per-route middleware additions keyed by "method /path" */
+    routeMiddleware: Record<string, string>;
+    /** structured per-property middleware data for sub-type dedup */
+    routeMiddlewareProps: Record<string, Array<{
+        name: string;
+        opt: boolean;
+        type: string;
+    }>>;
+};
+/**
+ * Extracts base ctx and per-route middleware additions from sub-chains.
+ * Traces HTTP method calls (`.get()`, `.post()`, etc.) back to their
+ * Honey instance receiver, computes the ctx diff vs the base export,
+ * and returns per-route additions keyed by "method /path".
+ */
+export declare function extractChainTypes(options: {
+    entryPath: string;
+    exportName: string;
+    outputDir?: string;
+    tsconfigPath?: string;
+}): Promise<ExtractedChainTypes>;
+//# sourceMappingURL=type-extractor.d.ts.map

package/dist/type-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-extractor.d.ts","sourceRoot":"","sources":["../src/type-extractor.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,gBAAgB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACvB,CAAA;AAcD;;;GAGG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE;IAC7C,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,MAAM,CAAA;CACrB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAkE5B;AAoYD,MAAM,MAAM,mBAAmB,GAAG;IACjC,IAAI,EAAE,gBAAgB,CAAA;IACtB,6DAA6D;IAC7D,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvC,iEAAiE;IACjE,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAA;CACzF,CAAA;AAID;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE;IAChD,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,MAAM,CAAA;CACrB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAwK/B"}

package/dist/types.d.ts

@@ -0,0 +1,451 @@
+export type HttpMethod = "DELETE" | "GET" | "HEAD" | "OPTIONS" | "PATCH" | "POST" | "PUT";
+/** Overwrite keys in T with keys from U -- used by .use() to support narrowing middleware */
+export type Overwrite<T, U> = Omit<T, keyof U> & U;
+export type WSReadyState = 0 | 1 | 2 | 3;
+/** All HTTP status codes 2xx–5xx as snake_case keys */
+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: Record<StatusKey, number>;
+export declare const codeToStatusKey: Record<number, StatusKey>;
+/** Framework error keys — centralized to prevent typo-induced silent failures */
+export declare const EK: {
+    readonly bad_gateway: "bad_gateway";
+    readonly content_too_large: "content_too_large";
+    readonly forbidden: "forbidden";
+    readonly gateway_timeout: "gateway_timeout";
+    readonly internal_server_error: "internal_server_error";
+    readonly method_not_allowed: "method_not_allowed";
+    readonly not_found: "not_found";
+    readonly output_content_type_mismatch: "output_content_type_mismatch";
+    readonly output_validation_failed: "output_validation_failed";
+    readonly request_timeout: "request_timeout";
+    readonly too_many_requests: "too_many_requests";
+    readonly unsupported_media_type: "unsupported_media_type";
+    readonly validation_failed: "validation_failed";
+};
+/** Framework status keys — centralized subset of StatusKey used internally */
+export declare const SK: {
+    readonly bad_gateway: "bad_gateway";
+    readonly bad_request: "bad_request";
+    readonly content_too_large: "content_too_large";
+    readonly forbidden: "forbidden";
+    readonly gateway_timeout: "gateway_timeout";
+    readonly internal_server_error: "internal_server_error";
+    readonly method_not_allowed: "method_not_allowed";
+    readonly not_found: "not_found";
+    readonly unprocessable_entity: "unprocessable_entity";
+    readonly unsupported_media_type: "unsupported_media_type";
+};
+export type FieldError = {
+    error_key: string;
+    message: string;
+    path: string;
+};
+export declare const EMPTY_OBJ: Record<string, never>;
+export declare const EMPTY_FIELDS: Record<string, FieldError[]>;
+export type NormalizedIssue = {
+    code: string;
+    message: string;
+    meta: {
+        expected?: string;
+        field?: string;
+        max?: number;
+        min?: number;
+        multipleOf?: number;
+        received?: string;
+    };
+    path: PropertyKey[];
+};
+export type SchemaDefinition = {
+    input: unknown;
+    output: unknown;
+};
+/**
+ * Minimal Standard Schema interface (StandardSchemaV1).
+ * Compatible with Zod, Valibot, ArkType, etc.
+ */
+export type StandardSchemaLike = {
+    readonly "~standard": {
+        readonly types?: {
+            readonly input: unknown;
+            readonly output: unknown;
+        } | undefined;
+        readonly validate: (value: unknown) => {
+            readonly issues?: ReadonlyArray<StandardSchemaIssue> | undefined;
+            readonly value?: unknown;
+        } | Promise<{
+            readonly issues?: ReadonlyArray<StandardSchemaIssue> | undefined;
+            readonly value?: unknown;
+        }>;
+        readonly vendor: string;
+        readonly version: number;
+    };
+};
+export type StandardSchemaIssue = {
+    readonly message: string;
+    readonly path?: ReadonlyArray<PropertyKey | {
+        readonly key: PropertyKey;
+    }> | undefined;
+};
+/** Extract the output type from a Standard Schema compatible schema */
+export type InferOutput<T> = T extends {
+    readonly "~standard": {
+        readonly types?: infer TTypes;
+    };
+} ? NonNullable<TTypes> extends {
+    readonly output: infer O;
+} ? O : unknown : unknown;
+/** Map input schema definitions to their inferred output types, dropping undefined keys */
+export type InferInputMap<T> = {
+    [K in keyof T as T[K] extends undefined | null ? never : K]-?: InferOutput<UnwrapInputSchema<NonNullable<T[K]>>>;
+};
+/**
+ * Extract param names from a route path string.
+ * "/users/:id/posts/:postId" → "id" | "postId"
+ * Handles optional params (:id?) and wildcards (*name)
+ */
+export type ParamKeys<Path extends string> = Path extends `${string}:${infer Param}/${infer Rest}` ? ParamKey<Param> | ParamKeys<`/${Rest}`> : Path extends `${string}:${infer Param}` ? ParamKey<Param> : Path extends `${string}*${infer Name}` ? Name extends "" ? "*" : Name : never;
+type ParamKey<T extends string> = T extends `${infer Name}?` ? Name : T;
+/** Build a params record from a route path string */
+export type ParamsFromPath<Path extends string> = [ParamKeys<Path>] extends [never] ? Record<string, string> : {
+    [K in ParamKeys<Path>]: string;
+};
+/** Tagged schema wrapper for runtime behavior control */
+type TaggedSchema = {
+    readonly _tag: "readableStream";
+    readonly schema: StandardSchemaLike;
+};
+/** A schema entry: plain StandardSchema or wrapped with readableStream() */
+export type InputSchemaEntry = StandardSchemaLike | TaggedSchema;
+/** Unwrap tagged schemas to get the inner StandardSchemaLike for type inference */
+type UnwrapInputSchema<T> = T extends {
+    readonly _tag: string;
+    readonly schema: infer S;
+} ? S : T;
+/** Non-body input sources — combine freely */
+type InputNonBody = {
+    cookies?: InputSchemaEntry;
+    headers?: InputSchemaEntry;
+    params?: InputSchemaEntry;
+    search?: InputSchemaEntry;
+};
+/** Input schema definition — json and form are mutually exclusive (one Content-Type per request) */
+export type InputSchemasDef = (InputNonBody & {
+    form?: InputSchemaEntry;
+    json?: never;
+}) | (InputNonBody & {
+    form?: never;
+    json?: InputSchemaEntry;
+});
+/** 2xx-only status keys for output declarations */
+export type SuccessStatusKey = "accepted" | "already_reported" | "created" | "im_used" | "multi_status" | "no_content" | "non_authoritative_information" | "ok" | "partial_content" | "reset_content";
+/** Status-key → schema map for a single content type (2xx only) */
+type StatusSchemaMap = Partial<Record<SuccessStatusKey, StandardSchemaLike>>;
+/** 3xx redirect status keys (excludes not_modified — cache, not redirect) */
+export type RedirectStatusKey = "found" | "moved_permanently" | "multiple_choices" | "permanent_redirect" | "see_other" | "temporary_redirect";
+/** Redirect declaration map — no body schema, just status keys */
+type RedirectSchemaMap = Partial<Record<RedirectStatusKey, true>>;
+/** Output schema definition — maps content-type → status-key → schema */
+export type OutputSchemaDef = {
+    "application/cbor"?: StatusSchemaMap;
+    "application/json"?: StatusSchemaMap;
+    "application/msgpack"?: StatusSchemaMap;
+    "application/octet-stream"?: StatusSchemaMap;
+    "application/pdf"?: StatusSchemaMap;
+    "application/xml"?: StatusSchemaMap;
+    redirect?: RedirectSchemaMap;
+    "text/csv"?: StatusSchemaMap;
+    "text/event-stream"?: StatusSchemaMap;
+    "text/html"?: StatusSchemaMap;
+    "text/plain"?: StatusSchemaMap;
+};
+/** Maps content-type strings to HoneyRes method names */
+export type ContentTypeMethodMap = {
+    "application/json": "json";
+    "application/octet-stream": "binary";
+    "application/xml": "xml";
+    "text/csv": "csv";
+    "text/event-stream": "sse";
+    "text/html": "html";
+    "text/plain": "text";
+};
+/** Methods always available on ctx.res regardless of output declaration */
+export type UniversalResMethods = "noContent" | "raw" | "redirect" | "stream";
+/** Derive allowed response methods from declared output content types */
+export type AllowedResMethods<TOutput> = {
+    [CT in keyof ContentTypeMethodMap]: CT extends keyof TOutput ? ContentTypeMethodMap[CT] : never;
+}[keyof ContentTypeMethodMap];
+/** Extract schemas for any content type from an OutputSchemaDef */
+export type ExtractSchemas<T, CT extends string> = T extends {
+    [K in CT]: infer S extends Record<string, unknown>;
+} ? S : never;
+/** Extract JSON output schemas from an OutputSchemaDef */
+export type ExtractJsonSchemas<T> = ExtractSchemas<T, "application/json">;
+/** Infer output types from a JSON output schema map */
+export type InferJsonOutputMap<T extends Record<string, StandardSchemaLike>> = {
+    [K in keyof T]: InferOutput<T[K]>;
+};
+/** OpenAPI operation-level metadata (also serves as built-in meta base) */
+export type OpenApiMeta = {
+    internal?: boolean;
+    deprecated?: boolean;
+    description?: string;
+    /** Escape hatch — emitted verbatim at the highest precedence. Prefer a `.metaSpec()` entry. */
+    extensions?: Record<`x-${string}`, unknown>;
+    invalidate?: readonly string[] | null;
+    mcp?: boolean;
+    operationId?: string;
+    security?: Array<Record<string, string[]>> | string | string[];
+    summary?: string;
+    tags?: string | string[];
+};
+/** Which operation kinds a policy entry applies to */
+export type MetaSpecTarget = "both" | "http" | "ws";
+/** Where a schema-derived policy entry reads its source key from */
+export type MetaSpecSchemaSource = "input.cookies" | "input.form" | "input.headers" | "input.json" | "input.search" | "output";
+/** Passed to a policy entry's `map` / `expand` */
+export type MetaSpecContext = {
+    meta: Record<string, unknown>;
+    method: string;
+    path: string;
+    profile: string;
+    /** Where the source value came from — `"meta"`, or the schema source for schema entries */
+    source: "meta" | MetaSpecSchemaSource;
+};
+type MetaSpecEntryBase = {
+    /** Which operation kinds this entry applies to. Default `"both"` */
+    on?: MetaSpecTarget;
+    /** Restrict this entry to named profiles. Default: every profile */
+    profiles?: readonly string[];
+    /** Validates the produced value at codegen time. A failure is a build error */
+    schema?: StandardSchemaLike;
+};
+/** Policy entry writing one operation key */
+export type MetaSpecSingle<TValue = unknown> = MetaSpecEntryBase & {
+    /** Target operation key — an `x-*` extension or an allowed standard field */
+    key: string;
+    /** Transform the source value. Returning `undefined` omits the key for that operation */
+    map?: (value: TValue, ctx: MetaSpecContext) => unknown;
+};
+/** Policy entry fanning one source value out to several operation keys */
+export type MetaSpecExpand<TValue = unknown> = MetaSpecEntryBase & {
+    /** Returns operation keys → values. `undefined` (returned or per key) omits */
+    expand: (value: TValue, ctx: MetaSpecContext) => Record<string, unknown> | undefined;
+};
+/** One policy entry: hidden (`false`), verbatim (`"x-foo"`), single target, or fan-out */
+export type MetaSpecEntry<TValue = unknown> = false | MetaSpecExpand<TValue> | MetaSpecSingle<TValue> | string;
+/**
+ * How deeply to look for a schema-metadata key.
+ * `"root"` reads the schema root, reading through one level of `items` for a bare array output.
+ * `"deep"` walks the schema (properties, items, composition members) and takes the shallowest
+ * match — for envelope shapes like `{ articles: [Article], nextCursor, count }`.
+ */
+export type MetaSpecSchemaSearch = "deep" | "root";
+/** Refuse a descriptor whose publisher contract version is newer than this policy understands */
+export type MetaSpecVersionGuard = {
+    /** Field carrying the contract version. Default `"v"` */
+    field?: string;
+    /** Highest version this entry's `map`/`expand` was written against */
+    max: number;
+};
+/**
+ * Policy entry reading its source key off a route schema instead of route meta.
+ *
+ * The object key names the entry; `read` says which schema-metadata key it reads, so several
+ * entries can read one reserved key — the shape a publisher takes when it stamps a
+ * discriminated union under a single key.
+ */
+export type MetaSpecSchemaEntry<TValue = unknown> = (MetaSpecExpand<TValue> | MetaSpecSingle<TValue>) & {
+    /** Schema sources to search, in order. First one carrying a matching descriptor wins */
+    from?: readonly MetaSpecSchemaSource[];
+    /**
+     * Shallow subset the descriptor must satisfy for this entry to claim it — the discriminant
+     * of a union, e.g. `{ kind: "entity" }`. A descriptor found under `read` that satisfies no
+     * entry's `match` is a build error, never a silently missing tag.
+     */
+    match?: Record<string, unknown>;
+    /** Schema-metadata key to read. Defaults to this entry's own name */
+    read?: string;
+    /** Where in the schema to look. Default `"root"` */
+    search?: MetaSpecSchemaSearch;
+    /** Fail the build on a descriptor from a newer publisher contract than this entry handles */
+    version?: MetaSpecVersionGuard;
+};
+/** Per-document filter over emitted operation keys */
+export type MetaSpecProfile = {
+    /** Denylist of emitted keys */
+    exclude?: readonly string[];
+    /** Allowlist of emitted `x-*` keys — standard fields are always kept unless excluded */
+    include?: readonly string[];
+};
+/** How an unmapped meta key is reported at codegen time */
+export type MetaSpecStrictness = "error" | "off" | "warn";
+type MetaSpecSections<TMetaSection> = {
+    /** Route-meta entries, keyed by meta key */
+    meta?: TMetaSection;
+    /** Named per-document filters. `"default"` filters nothing */
+    profiles?: Record<string, MetaSpecProfile>;
+    /** Schema-derived entries, keyed by the key read off the schema's metadata */
+    schema?: Record<string, MetaSpecSchemaEntry<never>>;
+    /** How to report a meta key with no entry. Default `"error"` */
+    strict?: MetaSpecStrictness;
+};
+/** Built-in meta keys ship with a default policy — overriding them is optional */
+type MetaSpecOptionalKeys<TMeta> = {
+    [K in Extract<keyof TMeta, keyof OpenApiMeta>]?: MetaSpecEntry<Exclude<TMeta[K], undefined>>;
+};
+/** Every app-defined meta key must have an entry — a missing key is a type error */
+type MetaSpecRequiredKeys<TMeta> = {
+    [K in Exclude<keyof TMeta, keyof OpenApiMeta>]-?: MetaSpecEntry<Exclude<TMeta[K], undefined>>;
+};
+/** Declarative policy for what flows from route meta and route schemas into the document */
+export type HoneyMetaSpec<TMeta = unknown> = [TMeta] extends [never] ? MetaSpecSections<Record<string, MetaSpecEntry>> : TMeta extends Record<string, unknown> ? MetaSpecSections<MetaSpecOptionalKeys<TMeta> & MetaSpecRequiredKeys<TMeta>> : MetaSpecSections<Record<string, MetaSpecEntry>>;
+/** Erased runtime shape of a resolved policy — what codegen consumes */
+export type MetaSpecConfig = {
+    meta?: Record<string, MetaSpecEntry>;
+    profiles?: Record<string, MetaSpecProfile>;
+    schema?: Record<string, MetaSpecSchemaEntry>;
+    strict?: MetaSpecStrictness;
+};
+/** Built-in meta shape — always available on .meta() */
+export type DefaultMeta = OpenApiMeta;
+/** Augmented by generated code per-app to narrow invalidate selectors */
+export interface HoneyCodegen {
+}
+type ResolveSelector = HoneyCodegen extends {
+    routeSelector: infer R;
+} ? (R extends string ? R : string) : string;
+/** Utility: merges built-in meta, custom meta T, and type-safe invalidate from codegen */
+export type HoneyMeta<T = {}> = DefaultMeta & T & {
+    invalidate?: readonly ResolveSelector[] | null;
+};
+/** Accumulated route schema entry for RPC client generation */
+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;
+        };
+    };
+};
+/** Merge a new route record into accumulated routes via flat intersection */
+export type MergeRoute<TRoutes, TPath extends string, TMethod extends string, TInput, TOutput, TCtx, TMeta = {}, TErrors extends string = never, TErrorsByStatus = never> = TRoutes & {
+    [P in TPath]: {
+        [M in Lowercase<TMethod>]: {
+            ctx: TCtx;
+            errors: TErrors;
+            errorsByStatus: TErrorsByStatus;
+            input: TInput;
+            meta: TMeta;
+            output: TOutput;
+        };
+    };
+};
+/** Extract accumulated routes from a Honey instance type */
+export type InferRoutes<T> = T extends {
+    readonly $routes: infer R;
+} ? R : never;
+/** Extract accumulated middleware context. `res` is omitted so handler ctx is assignable into services. Use InferRouteCtx for the route's constrained `res`. */
+export type InferCtx<T> = T extends {
+    readonly $ctx: infer TCtx;
+} ? Omit<TCtx, "res"> : never;
+/** Extract environment type (TEnv) from a Honey instance */
+export type InferEnv<T> = T extends {
+    readonly $env: infer TEnv;
+} ? TEnv : never;
+/** All HTTP methods used across all routes */
+export type InferMethods<T> = InferRoutes<T> extends infer R ? {
+    [P in keyof R]: keyof R[P] & string;
+}[keyof R] : never;
+/** Available route paths registered on a Honey instance */
+export type InferRoutePaths<T> = keyof InferRoutes<T> & string;
+/** Available methods for a given path ("get", "post", etc.) */
+export type InferRouteMethods<T, TPath extends InferRoutePaths<T>> = InferRoutes<T>[TPath] extends infer M ? keyof M & string : never;
+/** Lookup a specific route's record from the accumulated route map */
+type RouteLookup<T, TPath extends string, TMethod extends string> = InferRoutes<T> extends infer R ? TPath extends keyof R ? R[TPath] extends infer Methods ? TMethod extends keyof Methods ? Methods[TMethod] : never : never : never : never;
+/** Extract the meta type generic (TMeta) from a Honey instance */
+export type InferMeta<T> = T extends {
+    readonly $meta: infer M;
+} ? M : never;
+/** Extract the full handler context type for a specific route */
+export type InferRouteCtx<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> = RouteLookup<T, TPath, TMethod> extends {
+    ctx: infer C;
+} ? C : never;
+/** Extract input type for a specific route */
+export type InferRouteInput<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> = RouteLookup<T, TPath, TMethod> extends {
+    input: infer I;
+} ? I : never;
+/** Extract meta type for a specific route */
+export type InferRouteMeta<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> = RouteLookup<T, TPath, TMethod> extends {
+    meta: infer M;
+} ? M : never;
+/** Extract output type for a specific route */
+export type InferRouteOutput<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> = RouteLookup<T, TPath, TMethod> extends {
+    output: infer O;
+} ? O : never;
+/** Extract error keys for a specific route */
+export type InferRouteErrors<T, TPath extends InferRoutePaths<T>, TMethod extends InferRouteMethods<T, TPath>> = RouteLookup<T, TPath, TMethod> extends {
+    errors: infer E;
+} ? E : never;
+/** Extract the error factory type from a Honey instance */
+export type InferErrorFactory<T> = T extends {
+    readonly $errorFactory: infer F;
+} ? F : never;
+/**
+ * Compute errorsByStatus from error factory + declared error keys.
+ * Maps status codes to body shapes for client-side discrimination.
+ */
+export type ComputeErrorsByStatus<TFactory, TErrorKeys extends string, TMetaSymbol extends symbol> = TFactory extends {
+    readonly [K in TMetaSymbol]: infer TMeta;
+} ? TMeta extends Record<string, {
+    schema: infer _S;
+    statusKey: infer _SK;
+}> ? _BuildByStatus<TMeta, TErrorKeys> : never : never;
+/** Internal: build { [statusCode]: bodyShape } from meta + error keys */
+type _BuildByStatus<TMeta extends Record<string, {
+    schema: unknown;
+    statusKey: unknown;
+}>, TKeys extends string> = {
+    [SK in _UsedStatusKeys<TMeta, TKeys> & StatusKey as StatusKeyToCodeType<SK>]: _ShapesForStatus<TMeta, TKeys, SK>;
+};
+/** Internal: collect all statusKeys used by the declared error keys */
+type _UsedStatusKeys<TMeta extends Record<string, {
+    schema: unknown;
+    statusKey: unknown;
+}>, TKeys extends string> = TKeys extends keyof TMeta ? TMeta[TKeys]["statusKey"] : never;
+/** Internal: union of shapes for all error keys that map to a given statusKey */
+type _ShapesForStatus<TMeta extends Record<string, {
+    schema: unknown;
+    statusKey: unknown;
+}>, 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;
+/** Map StatusKey string to numeric status code at the type level */
+type StatusKeyToCodeType<SK extends StatusKey> = SK extends "ok" ? 200 : SK extends "created" ? 201 : SK extends "accepted" ? 202 : SK extends "no_content" ? 204 : SK extends "bad_request" ? 400 : SK extends "unauthorized" ? 401 : SK extends "payment_required" ? 402 : SK extends "forbidden" ? 403 : SK extends "not_found" ? 404 : SK extends "method_not_allowed" ? 405 : SK extends "not_acceptable" ? 406 : SK extends "conflict" ? 409 : SK extends "gone" ? 410 : SK extends "unprocessable_entity" ? 422 : SK extends "too_many_requests" ? 429 : SK extends "internal_server_error" ? 500 : SK extends "not_implemented" ? 501 : SK extends "bad_gateway" ? 502 : SK extends "service_unavailable" ? 503 : SK extends "gateway_timeout" ? 504 : number;
+/** Extract the base path type from a Honey instance */
+export type InferBasePath<T> = T extends {
+    readonly $basePath: infer P;
+} ? P : never;
+/** Merge two path segments — "/" is identity */
+export type MergePath<A extends string, B extends string> = A extends "/" ? B : B extends "/" ? A : `${A}${B}`;
+/** Queued side-effect emitted by c.tap() inside a handler */
+export type PendingTap = {
+    key: string;
+    payload: unknown;
+};
+/** Handler registered via app.tap(key, handler) — receives context + payload */
+export type TapHandler<TEnv = unknown> = (ctx: TapContext<TEnv>, payload: unknown) => void | Promise<void>;
+/** Subset of HoneyContext exposed to tap handlers — no res, no recursive tap */
+export type TapContext<TEnv = unknown> = {
+    readonly background: (p: Promise<unknown>) => void;
+    readonly env: TEnv;
+    readonly headers: Record<string, string>;
+    readonly meta: Record<string, unknown>;
+    readonly params: Record<string, string>;
+    readonly path: string;
+    readonly req: Request;
+    readonly routePattern: string;
+    readonly search: Record<string, string>;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map