@lovrozagar/honey 0.6.8 → 0.7.0

package/dist/codegen.js

@@ -0,0 +1,4610 @@
+import { InternPool } from "./codegen-route-tree-intern.js";
+import { deriveErrorEnvelopeName, deriveSchemaName, isErrorEnvelope, sanitizeComponentName, shortHash, } from "./codegen-schema-naming.js";
+import { effectJsonSchemaFn, loadEffectJsonSchema, loadToJSONSchema, toJSONSchemaFn } from "./codegen-loaders.js";
+import { sanitizeZodJsonSchema } from "./codegen-sanitize.js";
+import { bodiesOf, irErrorEnvelope, irResolver, methodsOf, namespacesOf, openApiPathParams, schemaToIR, toIR, } from "./codegen-ir.js";
+import { isJsonMedia, isTextMedia, mediaEssence } from "./codegen-sdk-model.js";
+import { ERROR_META } from "./errors.js";
+import { publishableMetaKeys } from "./meta-spec.js";
+import { metaSpecOf } from "./meta-spec-merge.js";
+import { generateOpenApiFromTree, } from "./openapi/document.js";
+import { getJsonSchemaConverter, setJsonSchemaConverter } from "./openapi/json-schema-slot.js";
+import { collectRoutes, extractParams } from "./openapi/collect.js";
+import { parsePattern, patternParams } from "./pattern.js";
+import { forEachLeaf, ROUTE_TREE_VERSION } from "./tree.js";
+import { irToTs } from "./ts-type-emitter.js";
+import { createTypeEmitState, emitSchemaType, quoteKey } from "./type-emitter.js";
+import { EMPTY_OBJ, statusKeyToCode } from "./types.js";
+import { CROSS_ORIGIN_SAFE_HEADERS } from "./client/redirect-policy.js";
+export { prepareCodegen } from "./codegen-loaders.js";
+export { toYaml, yamlSiblingPath } from "./yaml.js";
+export { DEFAULT_ERROR_JSON_SCHEMA } from "./openapi/document.js";
+/* Status → typed error subclass. Single source of truth shared between the
+ * emitted client (class declarations + status map + footer re-exports) and
+ * the index.gen.ts import/export. Order is deterministic for stable output. */
+const STATUS_ERROR_CLASSES = [
+    { name: "BadRequestError", status: 400 },
+    { name: "UnauthorizedError", status: 401 },
+    { name: "ForbiddenError", status: 403 },
+    { name: "NotFoundError", status: 404 },
+    { name: "ConflictError", status: 409 },
+    { name: "UnprocessableEntityError", status: 422 },
+    { name: "RateLimitError", status: 429 },
+    { name: "InternalServerError", status: 500 },
+    { name: "BadGatewayError", status: 502 },
+    { name: "ServiceUnavailableError", status: 503 },
+    { name: "GatewayTimeoutError", status: 504 },
+];
+const ERROR_EXPORT_NAMES = [
+    "ClientError",
+    ...STATUS_ERROR_CLASSES.map((c) => c.name),
+    "isClientError",
+];
+/** Wrappers that make an object entry optional. */
+const VALIBOT_OPTIONAL = new Set(["exact_optional", "nullish", "optional", "undefinedable"]);
+/** Pipe actions with a JSON Schema equivalent. Anything else constrains nothing in the document. */
+function applyValibotPipe(schema, json) {
+    const pipe = schema.pipe;
+    if (!Array.isArray(pipe))
+        return json;
+    const formats = {
+        email: "email",
+        ipv4: "ipv4",
+        ipv6: "ipv6",
+        iso_date: "date",
+        iso_date_time: "date-time",
+        iso_timestamp: "date-time",
+        url: "uri",
+        uuid: "uuid",
+    };
+    for (const action of pipe.slice(1)) {
+        const type = action.type;
+        const req = action.requirement;
+        if (type in formats)
+            json.format = formats[type];
+        else if (type === "integer")
+            json.type = "integer";
+        else if (type === "regex" && req instanceof RegExp)
+            json.pattern = req.source;
+        else if (type === "min_length" && typeof req === "number")
+            json[json.type === "array" ? "minItems" : "minLength"] = req;
+        else if (type === "max_length" && typeof req === "number")
+            json[json.type === "array" ? "maxItems" : "maxLength"] = req;
+        else if (type === "length" && typeof req === "number") {
+            json[json.type === "array" ? "minItems" : "minLength"] = req;
+            json[json.type === "array" ? "maxItems" : "maxLength"] = req;
+        }
+        else if (type === "min_value" && typeof req === "number")
+            json.minimum = req;
+        else if (type === "max_value" && typeof req === "number")
+            json.maximum = req;
+        else if (type === "description" && typeof action.description === "string")
+            json.description = action.description;
+    }
+    return json;
+}
+function valibotObject(s, depth) {
+    const entries = s.entries;
+    if (Object.keys(entries).length === 0 && s.type === "object")
+        return { type: "object" };
+    const properties = {};
+    const required = [];
+    for (const k of Object.keys(entries)) {
+        const entry = entries[k];
+        properties[k] = valibotToJsonSchema(entry, depth + 1);
+        if (!VALIBOT_OPTIONAL.has(entry.type))
+            required.push(k);
+    }
+    const result = { properties, type: "object" };
+    if (required.length > 0)
+        result.required = required;
+    if (s.type === "strict_object")
+        result.additionalProperties = false;
+    else if (s.type === "object_with_rest")
+        result.additionalProperties = valibotToJsonSchema(s.rest, depth + 1);
+    return result;
+}
+function valibotToJsonSchema(schema, depth = 0) {
+    /* a lazy schema can recurse without end; past this depth the node is unconstrained */
+    if (depth > 32)
+        return {};
+    const s = schema;
+    const walk = (child) => valibotToJsonSchema(child, depth + 1);
+    switch (s.type) {
+        case "string":
+            return applyValibotPipe(s, { type: "string" });
+        case "number":
+            return applyValibotPipe(s, { type: "number" });
+        case "boolean":
+            return { type: "boolean" };
+        case "bigint":
+            return { format: "int64", type: "integer" };
+        case "date":
+            return { format: "date-time", type: "string" };
+        case "file":
+        case "blob":
+            return { contentEncoding: "binary", format: "binary", type: "string" };
+        case "undefined":
+        case "void":
+            return {};
+        case "null":
+            return { type: "null" };
+        case "any":
+        case "unknown":
+            return {};
+        case "literal":
+            return { const: s.literal };
+        case "object":
+        case "strict_object":
+        case "loose_object":
+        case "object_with_rest":
+            return valibotObject(s, depth);
+        case "array":
+            return applyValibotPipe(s, { items: walk(s.item), type: "array" });
+        case "optional":
+        case "exact_optional":
+        case "undefinedable":
+        case "non_nullable":
+        case "non_nullish":
+        case "non_optional": {
+            const inner = walk(s.wrapped);
+            const fallback = s.default;
+            return fallback === undefined || typeof fallback === "function" ? inner : { ...inner, default: fallback };
+        }
+        case "nullable":
+        case "nullish":
+            return { anyOf: [walk(s.wrapped), { type: "null" }] };
+        case "union":
+        case "variant":
+            return { anyOf: s.options.map(walk) };
+        case "intersect":
+            return { allOf: s.options.map(walk) };
+        case "picklist":
+            return { enum: s.options };
+        case "enum": {
+            const enumObj = s.enum;
+            /* a TS numeric enum carries reverse mappings — keep the values */
+            return {
+                enum: Object.keys(enumObj)
+                    .filter((k) => typeof enumObj[enumObj[k]] !== "number")
+                    .map((k) => enumObj[k]),
+            };
+        }
+        case "record":
+            return { additionalProperties: walk(s.value), type: "object" };
+        case "tuple":
+        case "strict_tuple":
+        case "loose_tuple":
+        case "tuple_with_rest": {
+            const items = s.items.map(walk);
+            const result = { minItems: items.length, prefixItems: items, type: "array" };
+            if (s.type === "tuple_with_rest")
+                result.items = walk(s.rest);
+            else if (s.type !== "loose_tuple") {
+                result.items = false;
+                result.maxItems = items.length;
+            }
+            return result;
+        }
+        case "lazy": {
+            const getter = s.getter;
+            return typeof getter === "function" ? walk(getter(undefined)) : {};
+        }
+        default:
+            return {};
+    }
+}
+/* ---- ArkType → JSON Schema converter ---- */
+function arkTypeToJsonSchema(schema) {
+    const s = schema;
+    if (typeof s.toJsonSchema === "function") {
+        try {
+            return s.toJsonSchema();
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    return {};
+}
+function yupToJsonSchema(schema) {
+    const s = schema;
+    if (typeof s.describe !== "function")
+        return {};
+    const desc = s.describe();
+    return yupDescToJsonSchema(desc);
+}
+function yupDescToJsonSchema(desc) {
+    const base = yupDescBase(desc);
+    if (desc.nullable) {
+        return { anyOf: [base, { type: "null" }] };
+    }
+    return base;
+}
+function yupDescBase(desc) {
+    switch (desc.type) {
+        case "string":
+            return { type: "string" };
+        case "number":
+            return { type: "number" };
+        case "boolean":
+            return { type: "boolean" };
+        case "date":
+            return { format: "date-time", type: "string" };
+        case "object": {
+            if (!desc.fields)
+                return { type: "object" };
+            const keys = Object.keys(desc.fields);
+            if (keys.length === 0)
+                return { type: "object" };
+            const properties = {};
+            const required = [];
+            for (const k of keys) {
+                const field = desc.fields[k];
+                properties[k] = yupDescToJsonSchema(field);
+                if (!field.optional)
+                    required.push(k);
+            }
+            const result = { properties, type: "object" };
+            if (required.length > 0)
+                result.required = required;
+            return result;
+        }
+        case "array": {
+            if (!desc.innerType || Array.isArray(desc.innerType))
+                return { type: "array" };
+            return { items: yupDescToJsonSchema(desc.innerType), type: "array" };
+        }
+        case "tuple": {
+            if (!Array.isArray(desc.innerType))
+                return { type: "array" };
+            const items = desc.innerType.map((i) => yupDescToJsonSchema(i));
+            return {
+                items: false,
+                maxItems: items.length,
+                minItems: items.length,
+                prefixItems: items,
+                type: "array",
+            };
+        }
+        case "mixed": {
+            if (desc.oneOf && desc.oneOf.length > 0)
+                return { enum: desc.oneOf };
+            return {};
+        }
+        default:
+            return {};
+    }
+}
+/* ---- Effect → JSON Schema converter ---- */
+function effectToJsonSchema(schema) {
+    if (effectJsonSchemaFn) {
+        try {
+            return effectJsonSchemaFn(schema);
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    return {};
+}
+function isMetaInternal(handler) {
+    return handler.mt?.internal === true;
+}
+/* Longest suffix first so `*_not_found` wins over `*_found` (302). */
+const STATUS_KEYS_BY_LENGTH = Object.keys(statusKeyToCode).sort((a, b) => b.length - a.length);
+/*
+ * Composed apps keep declared keys on the handler but may not carry the worker
+ * factory. Infer HTTP status from a trailing status-key suffix so the document
+ * still lists what `c.errors.<key>` actually writes.
+ */
+function inferErrorInfo(errorKey) {
+    const exact = statusKeyToCode[errorKey];
+    if (exact !== undefined) {
+        if (exact < 400)
+            return null;
+        return { errorKey, status: exact, statusKey: errorKey };
+    }
+    for (const statusKey of STATUS_KEYS_BY_LENGTH) {
+        if (!errorKey.endsWith(`_${statusKey}`))
+            continue;
+        const status = statusKeyToCode[statusKey];
+        if (status < 400)
+            continue;
+        return { errorKey, status, statusKey };
+    }
+    return null;
+}
+function resolveErrorInfo(errorKey, factory) {
+    if (factory?.[errorKey]) {
+        try {
+            const err = factory[errorKey]();
+            return { errorKey, status: err.status, statusKey: err.statusKey };
+        }
+        catch {
+            /* factory call failed — fall through to suffix inference */
+        }
+    }
+    return inferErrorInfo(errorKey) ?? { errorKey, status: 0, statusKey: "unknown" };
+}
+function getErrorFactory(app) {
+    return app._errorFactory;
+}
+function getErrorMeta(factory) {
+    if (!factory)
+        return null;
+    return factory[ERROR_META] ?? null;
+}
+function unwrapEntry(entry) {
+    if ("_tag" in entry) {
+        return entry.schema;
+    }
+    return entry;
+}
+function introspectSchema(schema) {
+    const std = schema["~standard"];
+    return {
+        types: std.types,
+        vendor: std.vendor,
+        version: std.version,
+    };
+}
+export { normalizeSecurity } from "./meta-spec.js";
+/** Locale-independent string order (UTF-16 code units), so output is the same on every machine. */
+export function compareCodeUnits(a, b) {
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+}
+export function canonicalizeSchema(schema) {
+    return JSON.stringify(schema, (_, value) => {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            return Object.fromEntries(Object.entries(value).sort(([a], [b]) => compareCodeUnits(a, b)));
+        }
+        return value;
+    });
+}
+function isObjectSchema(schema) {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema))
+        return false;
+    const s = schema;
+    if (typeof s.$ref === "string")
+        return false;
+    return s.type === "object" || (typeof s.properties === "object" && s.properties !== null);
+}
+/**
+ * A response key as a number: `"200"` → 200, `"default"` → 0, `"4XX"` → 400. Never `NaN`, which
+ * would name a schema `…ResponseNaN` and make every `default` response collide.
+ */
+function statusNumber(key) {
+    if (/^[1-5][0-9][0-9]$/.test(key))
+        return Number(key);
+    if (/^[1-5]XX$/i.test(key))
+        return Number(key[0]) * 100;
+    return 0;
+}
+function collectSchemaSlots(paths) {
+    const slots = [];
+    for (const [pathKey, methods] of Object.entries(paths)) {
+        for (const [method, operation] of Object.entries(methods)) {
+            const op = operation;
+            const m = method.toLowerCase();
+            const requestBody = op.requestBody;
+            if (requestBody) {
+                const content = requestBody.content;
+                if (content) {
+                    for (const [contentType, mediaType] of Object.entries(content)) {
+                        const schema = mediaType.schema;
+                        if (schema && !schema.$ref) {
+                            const context = { method: m, path: pathKey, role: "request" };
+                            slots.push({ canonical: canonicalizeSchema(schema), contentType, context, pathKey, schema });
+                        }
+                    }
+                }
+            }
+            const responses = op.responses;
+            if (responses) {
+                for (const [status, response] of Object.entries(responses)) {
+                    const content = response.content;
+                    if (content) {
+                        for (const [contentType, mediaType] of Object.entries(content)) {
+                            const schema = mediaType.schema;
+                            if (schema && !schema.$ref) {
+                                const statusNum = statusNumber(status);
+                                const context = {
+                                    method: m,
+                                    path: pathKey,
+                                    role: "response",
+                                    status: statusNum,
+                                };
+                                slots.push({ canonical: canonicalizeSchema(schema), contentType, context, pathKey, schema });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return slots;
+}
+/**
+ * A component name nobody holds yet. A clash gets the content hash, and a clash on the
+ * hashed name (24 bits collide) a counter — a name is never handed out twice.
+ */
+function uniqueName(base, canonical, taken) {
+    if (!taken(base))
+        return base;
+    const hashed = `${base}_${shortHash(canonical)}`;
+    if (!taken(hashed))
+        return hashed;
+    for (let n = 2;; n++) {
+        const candidate = `${hashed}_${n}`;
+        if (!taken(candidate))
+            return candidate;
+    }
+}
+function walkNestedObjects(schema, slotName, fieldPath, nestedMap, isEnvelopeOwner) {
+    const props = schema.properties;
+    if (!props)
+        return;
+    for (const key of Object.keys(props)) {
+        const val = props[key];
+        if (!isObjectSchema(val))
+            continue;
+        const child = val;
+        const childPath = [...fieldPath, key];
+        const canonical = canonicalizeSchema(child);
+        const existing = nestedMap.get(canonical);
+        if (existing) {
+            existing.count++;
+            existing.samples.push({ fieldPath: childPath, isEnvelopeOwner, slotName });
+        }
+        else {
+            nestedMap.set(canonical, {
+                count: 1,
+                samples: [{ fieldPath: childPath, isEnvelopeOwner, slotName }],
+                schema: child,
+            });
+        }
+        walkNestedObjects(child, slotName, childPath, nestedMap, isEnvelopeOwner);
+    }
+}
+function collectHoistedSchemas(slots, slotNames, taken) {
+    const nestedMap = new Map();
+    for (const slot of slots) {
+        const slotName = slotNames.get(slot);
+        /* Mark slots whose schema is an error envelope — their nested objects (e.g. `fields`)
+         * are env-specific and must not be named after the parent envelope's owner slot. */
+        if (slotName)
+            walkNestedObjects(slot.schema, slotName, [], nestedMap, isErrorEnvelope(slot.schema));
+    }
+    const schemas = {};
+    const canonicalToName = new Map();
+    for (const [canonical, entry] of nestedMap) {
+        if (entry.count < 2)
+            continue;
+        /* Skip hoisting nested objects that live exclusively inside Tier 2 error envelopes.
+         * Their names would be derived from whichever envelope "wins" the lex sort, and that
+         * winner differs per-spec — causing merge conflicts when multiple specs are combined. */
+        if (entry.samples.every((s) => s.isEnvelopeOwner))
+            continue;
+        const owner = entry.samples.slice().sort((a, b) => {
+            const na = a.slotName + a.fieldPath.join("");
+            const nb = b.slotName + b.fieldPath.join("");
+            return compareCodeUnits(na, nb);
+        })[0];
+        const fieldPart = owner.fieldPath
+            .map((f) => sanitizeComponentName(f))
+            .map((f) => f.charAt(0).toUpperCase() + f.slice(1))
+            .join("");
+        const name = uniqueName(sanitizeComponentName(`${owner.slotName}${fieldPart}`), canonical, (n) => taken(n) || Object.hasOwn(schemas, n));
+        schemas[name] = entry.schema;
+        canonicalToName.set(canonical, name);
+    }
+    /* nested hoists inside a hoisted schema point at their component too */
+    for (const name of Object.keys(schemas))
+        schemas[name] = rewriteNestedRefs(schemas[name], canonicalToName);
+    return { canonicalToName, schemas };
+}
+/*
+ * Builds a new paths object by shallow-copying only the containers that need schema
+ * replacement. Avoids structuredClone (which fails on arktype schemas containing
+ * native functions). Original schema objects are dropped; only $ref objects are new.
+ * Also rewrites nested inline object properties that were hoisted (canonicalToName),
+ * at any depth — a hoisted name nothing points at would be an orphan component.
+ */
+function rewriteNestedRefs(schema, canonicalToName) {
+    const props = schema.properties;
+    if (!props)
+        return schema;
+    let newProps;
+    for (const key of Object.keys(props)) {
+        const val = props[key];
+        if (!isObjectSchema(val))
+            continue;
+        const child = val;
+        const name = canonicalToName.get(canonicalizeSchema(child));
+        const next = name ? { $ref: `#/components/schemas/${name}` } : rewriteNestedRefs(child, canonicalToName);
+        if (next === child)
+            continue;
+        if (!newProps)
+            newProps = { ...props };
+        newProps[key] = next;
+    }
+    if (!newProps)
+        return schema;
+    return { ...schema, properties: newProps };
+}
+function slotKey(pathKey, method, role, status, contentType) {
+    return `${pathKey}::${method}::${role}::${status ?? ""}::${contentType}`;
+}
+function rewritePathsToRefs(paths, slots, slotNames, hoistedCanonicalToName) {
+    /* keyed by operation + status + content type: JSON and XML bodies of one status are two slots */
+    const lookup = new Map();
+    for (const slot of slots) {
+        const name = slotNames.get(slot);
+        if (!name)
+            continue;
+        const status = slot.context.role === "response" ? slot.context.status : undefined;
+        lookup.set(slotKey(slot.pathKey, slot.context.method, slot.context.role, status, slot.contentType), name);
+    }
+    const rewriteContent = (content, keyFor) => {
+        const newContent = {};
+        let changed = false;
+        for (const [ct, mediaType] of Object.entries(content)) {
+            const schema = mediaType.schema;
+            if (!schema || schema.$ref) {
+                newContent[ct] = mediaType;
+                continue;
+            }
+            const name = lookup.get(keyFor(ct));
+            if (name) {
+                newContent[ct] = { ...mediaType, schema: { $ref: `#/components/schemas/${name}` } };
+                changed = true;
+                continue;
+            }
+            const rewritten = hoistedCanonicalToName.size > 0 ? rewriteNestedRefs(schema, hoistedCanonicalToName) : schema;
+            if (rewritten !== schema) {
+                newContent[ct] = { ...mediaType, schema: rewritten };
+                changed = true;
+            }
+            else {
+                newContent[ct] = mediaType;
+            }
+        }
+        return changed ? newContent : null;
+    };
+    const newPaths = {};
+    for (const [pathKey, methods] of Object.entries(paths)) {
+        const newMethods = {};
+        for (const [method, operation] of Object.entries(methods)) {
+            const op = operation;
+            const m = method.toLowerCase();
+            let newOp = op;
+            const requestBody = op.requestBody;
+            const reqContent = requestBody?.content;
+            if (requestBody && reqContent) {
+                const next = rewriteContent(reqContent, (ct) => slotKey(pathKey, m, "request", undefined, ct));
+                if (next)
+                    newOp = { ...op, requestBody: { ...requestBody, content: next } };
+            }
+            const responses = newOp.responses;
+            if (responses) {
+                let newResponses;
+                for (const [status, response] of Object.entries(responses)) {
+                    const content = response.content;
+                    if (!content)
+                        continue;
+                    const statusNum = statusNumber(status);
+                    const next = rewriteContent(content, (ct) => slotKey(pathKey, m, "response", statusNum, ct));
+                    if (!next)
+                        continue;
+                    if (!newResponses)
+                        newResponses = { ...responses };
+                    newResponses[status] = { ...response, content: next };
+                }
+                if (newResponses)
+                    newOp = { ...newOp, responses: newResponses };
+            }
+            newMethods[method] = newOp;
+        }
+        newPaths[pathKey] = newMethods;
+    }
+    return newPaths;
+}
+/** Every `#/components/schemas/<name>` a value refers to. */
+function collectComponentRefs(value, out) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectComponentRefs(item, out);
+        return;
+    }
+    if (value === null || typeof value !== "object")
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        if (key === "$ref" && typeof child === "string" && child.startsWith("#/components/schemas/")) {
+            out.add(child.slice("#/components/schemas/".length));
+        }
+        else {
+            collectComponentRefs(child, out);
+        }
+    }
+}
+export function deduplicateSchemas(spec) {
+    /* Sort paths lexicographically for determinism — input order must not affect output. */
+    const sortedPaths = {};
+    for (const key of Object.keys(spec.paths).sort())
+        sortedPaths[key] = spec.paths[key];
+    const slots = collectSchemaSlots(sortedPaths);
+    const existing = spec.components?.schemas ?? {};
+    /* Group slots by canonical shape — same shape = one component. */
+    const groups = new Map();
+    for (const slot of slots) {
+        const group = groups.get(slot.canonical);
+        if (group)
+            group.push(slot);
+        else
+            groups.set(slot.canonical, [slot]);
+    }
+    /*
+     * Tier resolution per canonical group:
+     *   Tier 1: unique shape (group.length === 1) → operation-derived name
+     *   Tier 2: shared error envelope → Err{status}* name
+     *   Tier 3: shared non-error → first-slot operation-derived name
+     * Collision (two canonicals → same tier name, or a name an existing component holds) →
+     * hash suffix, re-checked until free.
+     */
+    const canonicalToName = new Map();
+    const nameToCanonical = new Map();
+    for (const [canonical, groupSlots] of groups) {
+        const firstSlot = groupSlots[0];
+        let base;
+        if (groupSlots.length > 1 && isErrorEnvelope(firstSlot.schema)) {
+            const fallbackStatus = firstSlot.context.role === "response" ? firstSlot.context.status : undefined;
+            base = deriveErrorEnvelopeName(firstSlot.schema, fallbackStatus);
+        }
+        else {
+            base = deriveSchemaName(firstSlot.context);
+        }
+        const name = uniqueName(base, canonical, (n) => Object.hasOwn(existing, n) || (nameToCanonical.has(n) && nameToCanonical.get(n) !== canonical));
+        nameToCanonical.set(name, canonical);
+        canonicalToName.set(canonical, name);
+    }
+    /* Build slotNames map (SchemaSlot → resolved name) for hoisting + path rewriting. */
+    const slotNames = new Map();
+    for (const slot of slots) {
+        const name = canonicalToName.get(slot.canonical);
+        if (name)
+            slotNames.set(slot, name);
+    }
+    /* Nested hoisting: collect shared nested objects, then rewrite inline → $ref.
+     * Error envelope slots (any tier) mark their nested schemas as envelope-owned so
+     * envelope-exclusive nesting (e.g. `fields`) is not hoisted under a per-spec name. */
+    const { schemas: hoistedSchemas, canonicalToName: hoistedCanonicalToName } = collectHoistedSchemas(slots, slotNames, (n) => Object.hasOwn(existing, n) || nameToCanonical.has(n));
+    /* Build components map, rewriting nested fields → $refs where hoisted */
+    const extractedSchemas = {};
+    for (const slot of slots) {
+        const name = slotNames.get(slot);
+        if (name && !Object.hasOwn(extractedSchemas, name)) {
+            extractedSchemas[name] =
+                hoistedCanonicalToName.size > 0 ? rewriteNestedRefs(slot.schema, hoistedCanonicalToName) : slot.schema;
+        }
+    }
+    const hasNewSchemas = Object.keys(extractedSchemas).length > 0 || Object.keys(hoistedSchemas).length > 0;
+    /* Nothing to extract and no existing components — return unchanged */
+    if (!hasNewSchemas && !spec.components)
+        return spec;
+    const paths = slotNames.size > 0 || hoistedCanonicalToName.size > 0
+        ? rewritePathsToRefs(sortedPaths, slots, slotNames, hoistedCanonicalToName)
+        : sortedPaths;
+    const mergedSchemas = { ...existing, ...extractedSchemas };
+    /* a hoisted nested schema whose every user became a component $ref is still referenced from
+       that component; one referenced from nowhere is dropped */
+    const referenced = new Set();
+    collectComponentRefs(paths, referenced);
+    collectComponentRefs(mergedSchemas, referenced);
+    for (const [name, schema] of Object.entries(hoistedSchemas)) {
+        if (referenced.has(name))
+            mergedSchemas[name] = schema;
+    }
+    const components = {
+        ...spec.components,
+        ...(Object.keys(mergedSchemas).length > 0 ? { schemas: mergedSchemas } : {}),
+    };
+    return { ...spec, components, paths };
+}
+export function sanitizeOpenApiSpec(spec, options) {
+    const result = cloneJson(spec);
+    if (options.stripSecuritySchemes?.length && result.components?.securitySchemes) {
+        for (const name of options.stripSecuritySchemes) {
+            delete result.components.securitySchemes[name];
+        }
+        if (Object.keys(result.components.securitySchemes).length === 0) {
+            delete result.components.securitySchemes;
+        }
+    }
+    for (const methods of Object.values(result.paths)) {
+        for (const operation of Object.values(methods)) {
+            const op = operation;
+            if (options.stripSecurityRequirements?.length && Array.isArray(op.security)) {
+                op.security = op.security.filter((s) => !options.stripSecurityRequirements?.some((name) => name in s));
+                if (op.security.length === 0)
+                    delete op.security;
+            }
+            if (options.stripXExtensions) {
+                const targets = options.stripXExtensions === true
+                    ? Object.keys(op).filter((k) => k.startsWith("x-"))
+                    : options.stripXExtensions;
+                for (const ext of targets)
+                    delete op[ext];
+            }
+        }
+    }
+    return result;
+}
+function cloneJson(value) {
+    try {
+        return structuredClone(value);
+    }
+    catch {
+        return JSON.parse(JSON.stringify(value));
+    }
+}
+/* Inlining expands each $ref; a graph of shared refs can grow exponentially (`L30` with two
+   fields that both point at `L29`, …), so the output is bounded and generation fails loudly. */
+const MAX_INLINED_SCHEMA_NODES = 200_000;
+function chargeInline(budget) {
+    if (++budget.nodes > MAX_INLINED_SCHEMA_NODES) {
+        throw new Error(`SDK codegen: inlined schemas exceed ${MAX_INLINED_SCHEMA_NODES} nodes (deeply shared $refs); ` +
+            "flatten the shared component chain");
+    }
+}
+function resolveSchema(schema, schemas, budget, visited = new Set()) {
+    if (typeof schema.$ref === "string" && schema.$ref.startsWith("#/components/schemas/")) {
+        const name = schema.$ref.slice("#/components/schemas/".length);
+        /* circular ref guard — return empty schema which maps to unknown in IR */
+        if (visited.has(name))
+            return {};
+        const resolved = Object.hasOwn(schemas, name) ? schemas[name] : undefined;
+        if (!resolved)
+            throw new Error(`$ref points to nonexistent component: ${schema.$ref}`);
+        const next = new Set(visited);
+        next.add(name);
+        return resolveSchemaDeep(cloneJson(resolved), schemas, budget, next);
+    }
+    return resolveSchemaDeep(schema, schemas, budget, visited);
+}
+function resolveSchemaDeep(schema, schemas, budget, visited) {
+    chargeInline(budget);
+    for (const key of ["oneOf", "anyOf", "allOf"]) {
+        const arr = schema[key];
+        if (Array.isArray(arr)) {
+            schema[key] = arr.map((item) => {
+                if (item && typeof item === "object" && !Array.isArray(item)) {
+                    return resolveSchema(item, schemas, budget, visited);
+                }
+                return item;
+            });
+        }
+    }
+    /* resolve array items */
+    if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+        schema.items = resolveSchema(schema.items, schemas, budget, visited);
+    }
+    /* resolve object properties */
+    if (schema.properties && typeof schema.properties === "object") {
+        const props = schema.properties;
+        for (const [k, v] of Object.entries(props)) {
+            if (v && typeof v === "object" && !Array.isArray(v)) {
+                props[k] = resolveSchema(v, schemas, budget, visited);
+            }
+        }
+    }
+    /* resolve additionalProperties */
+    if (schema.additionalProperties &&
+        typeof schema.additionalProperties === "object" &&
+        !Array.isArray(schema.additionalProperties)) {
+        schema.additionalProperties = resolveSchema(schema.additionalProperties, schemas, budget, visited);
+    }
+    return schema;
+}
+export function resolveRefs(spec) {
+    const schemas = spec.components?.schemas;
+    if (!schemas || Object.keys(schemas).length === 0)
+        return spec;
+    const paths = cloneJson(spec.paths);
+    const budget = { nodes: 0 };
+    for (const methods of Object.values(paths)) {
+        for (const operation of Object.values(methods)) {
+            const op = operation;
+            const requestBody = op.requestBody;
+            if (requestBody) {
+                const content = requestBody.content;
+                if (content) {
+                    for (const [ct, mediaType] of Object.entries(content)) {
+                        const schema = mediaType.schema;
+                        if (schema)
+                            content[ct] = { ...mediaType, schema: resolveSchema(schema, schemas, budget) };
+                    }
+                }
+            }
+            const responses = op.responses;
+            if (responses) {
+                for (const [status, response] of Object.entries(responses)) {
+                    const content = response.content;
+                    if (!content)
+                        continue;
+                    /* every content type resolved, not only the last one written */
+                    const resolved = {};
+                    for (const [ct, mediaType] of Object.entries(content)) {
+                        const schema = mediaType.schema;
+                        resolved[ct] = schema ? { ...mediaType, schema: resolveSchema(schema, schemas, budget) } : mediaType;
+                    }
+                    responses[status] = { ...response, content: resolved };
+                }
+            }
+        }
+    }
+    const { schemas: _schemas, ...restComponents } = spec.components ?? {};
+    const components = Object.keys(restComponents).length > 0 ? restComponents : undefined;
+    return { ...spec, components, paths };
+}
+/**
+ * Zod node kinds JSON Schema has no word for. Zod emits `{}` for each of them under
+ * `unrepresentable: "any"`; the degrade is per node, and the rest of the schema survives.
+ */
+const ZOD_UNREPRESENTABLE = new Set(["custom", "function", "map", "nan", "promise", "set", "symbol", "transform"]);
+/** `override` for Zod's converter: give `Date` and `BigInt` their wire shape, record what degraded. */
+function zodOverride(degraded) {
+    return (ctx) => {
+        const def = zodDefOf(ctx.zodSchema);
+        const kind = String(def?.type ?? "");
+        if (kind === "date") {
+            /* JSON.stringify writes a Date as an ISO string */
+            ctx.jsonSchema.format = "date-time";
+            ctx.jsonSchema.type = "string";
+            return;
+        }
+        if (kind === "bigint") {
+            ctx.jsonSchema.format = "int64";
+            ctx.jsonSchema.type = "integer";
+            return;
+        }
+        if (ZOD_UNREPRESENTABLE.has(kind) && Object.keys(ctx.jsonSchema).length === 0)
+            degraded.add(kind);
+    };
+}
+/** Zod 4 puts converters on the schema instance. Use those first so Workers
+ * (where `import("zod")` does not resolve) still emit real JSON Schema. */
+function zodInstanceToJsonSchema(schema, io, degraded) {
+    const libraryOptions = { override: zodOverride(degraded), unrepresentable: "any" };
+    const jsonSchema = schema["~standard"].jsonSchema;
+    const fromStandard = jsonSchema?.[io];
+    if (typeof fromStandard === "function") {
+        const result = fromStandard({ libraryOptions, target: "draft-2020-12" });
+        if (result && typeof result === "object")
+            return result;
+    }
+    const inst = schema.toJSONSchema;
+    if (typeof inst === "function") {
+        const result = inst.call(schema, { ...libraryOptions, io });
+        if (result && typeof result === "object")
+            return result;
+    }
+    if (toJSONSchemaFn) {
+        const convert = toJSONSchemaFn;
+        const result = convert(schema, { ...libraryOptions, io });
+        if (result && typeof result === "object")
+            return result;
+    }
+    return undefined;
+}
+function applyZodBag(schema, json) {
+    const bag = schema._zod?.bag;
+    if (!bag)
+        return json;
+    if (typeof bag.format === "string") {
+        if (bag.format === "safeint")
+            json.type = "integer";
+        else
+            json.format = bag.format;
+    }
+    if (json.type === "string") {
+        if (typeof bag.minimum === "number")
+            json.minLength = bag.minimum;
+        if (typeof bag.maximum === "number")
+            json.maxLength = bag.maximum;
+    }
+    if (json.type === "number" || json.type === "integer") {
+        if (typeof bag.minimum === "number")
+            json.minimum = bag.minimum;
+        if (typeof bag.maximum === "number")
+            json.maximum = bag.maximum;
+    }
+    return json;
+}
+function zodDefOf(schema) {
+    const s = schema;
+    return s._def ?? s.def ?? s._zod?.def;
+}
+function zodDefIsOptional(def, io) {
+    const t = String(def.typeName ?? def.type ?? "");
+    if (t === "ZodOptional" || t === "optional")
+        return true;
+    /* a default fills the value in: optional on the way in, always present on the way out */
+    if ((t === "ZodDefault" || t === "default" || t === "prefault") && io === "input")
+        return true;
+    if (t === "ZodNullable" ||
+        t === "nullable" ||
+        t === "ZodDefault" ||
+        t === "default" ||
+        t === "prefault" ||
+        t === "ZodCatch" ||
+        t === "catch" ||
+        t === "ZodReadonly" ||
+        t === "readonly") {
+        const inner = def.innerType;
+        if (inner) {
+            const innerDef = zodDefOf(inner);
+            if (innerDef)
+                return zodDefIsOptional(innerDef, io);
+        }
+    }
+    return false;
+}
+function literalSchema(values) {
+    if (values.length === 1)
+        return { const: values[0] };
+    return { enum: [...values] };
+}
+/** Walk Zod 3/4 internals. Survives Workers bundles that drop `toJSONSchema`. */
+function zodDefToJsonSchema(schema, io = "output", depth = 0) {
+    if (depth > 24)
+        return {};
+    const def = zodDefOf(schema);
+    if (!def)
+        return undefined;
+    const typeName = String(def.typeName ?? def.type ?? "");
+    const walk = (child) => zodDefToJsonSchema(child, io, depth + 1) ?? {};
+    switch (typeName) {
+        case "ZodString":
+        case "string":
+            return applyZodBag(schema, { type: "string" });
+        case "ZodNumber":
+        case "number":
+            return applyZodBag(schema, { type: "number" });
+        case "ZodBoolean":
+        case "boolean":
+            return { type: "boolean" };
+        case "ZodBigInt":
+        case "bigint":
+            return { format: "int64", type: "integer" };
+        case "ZodDate":
+        case "date":
+            return { format: "date-time", type: "string" };
+        case "ZodFile":
+        case "file":
+            /* so form emit can see format:binary when toJSONSchema is unavailable */
+            return { contentEncoding: "binary", format: "binary", type: "string" };
+        case "ZodNull":
+        case "null":
+            return { type: "null" };
+        case "ZodUndefined":
+        case "ZodVoid":
+        case "undefined":
+        case "void":
+        case "ZodAny":
+        case "ZodUnknown":
+        case "any":
+        case "unknown":
+            return {};
+        case "ZodLiteral":
+        case "literal": {
+            const values = Array.isArray(def.values) ? def.values : [def.value];
+            return literalSchema(values.map((v) => (typeof v === "bigint" ? Number(v) : v)));
+        }
+        case "ZodEnum":
+        case "enum": {
+            const raw = (def.values ?? def.entries);
+            let list;
+            if (Array.isArray(raw))
+                list = raw;
+            else {
+                /* a TS numeric enum carries reverse mappings: { A: 0, "0": "A" } — keep the values */
+                const entries = raw;
+                list = Object.keys(entries)
+                    .filter((k) => typeof entries[entries[k]] !== "number")
+                    .map((k) => entries[k]);
+            }
+            const types = new Set(list.map((v) => typeof v));
+            if (types.size === 1 && types.has("string"))
+                return { enum: list, type: "string" };
+            if (types.size === 1 && types.has("number"))
+                return { enum: list, type: "number" };
+            return { enum: list };
+        }
+        case "ZodObject":
+        case "object": {
+            const rawShape = def.shape;
+            const shape = typeof rawShape === "function" ? rawShape() : rawShape;
+            if (!shape)
+                return { type: "object" };
+            const properties = {};
+            const required = [];
+            for (const key of Object.keys(shape)) {
+                const prop = shape[key];
+                properties[key] = walk(prop);
+                const propDef = zodDefOf(prop);
+                if (!propDef || !zodDefIsOptional(propDef, io))
+                    required.push(key);
+            }
+            const result = { properties, type: "object" };
+            if (io === "output")
+                result.additionalProperties = false;
+            if (required.length > 0)
+                result.required = required;
+            return result;
+        }
+        case "ZodArray":
+        case "array":
+            return { items: walk(def.element ?? def.type), type: "array" };
+        case "ZodOptional":
+        case "optional":
+            return zodDefToJsonSchema(def.innerType, io, depth + 1);
+        case "ZodNullable":
+        case "nullable":
+            return { anyOf: [walk(def.innerType), { type: "null" }] };
+        case "ZodUnion":
+        case "ZodDiscriminatedUnion":
+        case "union":
+            return { anyOf: (def.options ?? []).map(walk) };
+        case "ZodIntersection":
+        case "intersection":
+            return { allOf: [walk(def.left), walk(def.right)] };
+        case "ZodRecord":
+        case "record":
+            return { additionalProperties: walk(def.valueType), type: "object" };
+        case "ZodTuple":
+        case "tuple": {
+            const items = (def.items ?? []).map(walk);
+            const out = { prefixItems: items, type: "array" };
+            if (def.rest)
+                out.items = walk(def.rest);
+            else {
+                out.items = false;
+                out.maxItems = items.length;
+            }
+            out.minItems = items.length;
+            return out;
+        }
+        case "ZodDefault":
+        case "default":
+        case "prefault": {
+            const inner = walk(def.innerType);
+            const value = def.defaultValue;
+            const resolved = typeof value === "function" ? undefined : value;
+            return resolved === undefined ? inner : { ...inner, default: resolved };
+        }
+        case "ZodCatch":
+        case "catch":
+        case "ZodReadonly":
+        case "readonly":
+            return zodDefToJsonSchema(def.innerType, io, depth + 1);
+        case "ZodPipeline":
+        case "pipe":
+            /* a pipe validates `in` and returns `out` */
+            return zodDefToJsonSchema(io === "input" ? def.in : def.out, io, depth + 1);
+        case "ZodBranded":
+            return zodDefToJsonSchema(def.type, io, depth + 1);
+        case "ZodLazy":
+        case "lazy": {
+            const getter = def.getter;
+            return typeof getter === "function" ? zodDefToJsonSchema(getter(), io, depth + 1) : {};
+        }
+        default:
+            return undefined;
+    }
+}
+/** How a schema that cannot be converted at all is handled. Set per `generateOpenApi` call. */
+let schemaFailureMode = "throw";
+function schemaConversionFailed(what, io, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const text = `[honey:codegen] schemaToJsonSchema could not convert ${what} (io=${io}): ${msg}`;
+    if (schemaFailureMode === "throw")
+        throw new Error(text);
+    console.warn(`${text}. Documented as an unconstrained schema.`);
+    return {};
+}
+function schemaToJsonSchema(schema, io = "output") {
+    /* Pre-serialized JSON-schema blob or non-schema value — no ~standard marker.
+     * Arktype schemas are functions but still carry the marker, so pass those through too. */
+    if (schema === null ||
+        (typeof schema !== "object" && typeof schema !== "function") ||
+        !("~standard" in schema)) {
+        return schema;
+    }
+    const vendor = schema["~standard"].vendor;
+    if (vendor === "zod") {
+        const kind = schema?._zod?.def?.type ?? "unknown";
+        const degraded = new Set();
+        let result;
+        try {
+            result = zodInstanceToJsonSchema(schema, io, degraded) ?? zodDefToJsonSchema(schema, io);
+        }
+        catch (err) {
+            return schemaConversionFailed(`zod/${kind}`, io, err);
+        }
+        if (!result)
+            return schemaConversionFailed(`zod/${kind}`, io, new Error("no converter available"));
+        if (degraded.size > 0) {
+            console.warn(`[honey:codegen] schemaToJsonSchema: zod/${kind} (io=${io}) has ${[...degraded].sort().join(", ")} ` +
+                "node(s) JSON Schema cannot express; each is documented as an unconstrained schema. " +
+                'Describe them with .meta({ ... }) or z.toJSONSchema\'s "override".');
+        }
+        return sanitizeZodJsonSchema(result);
+    }
+    try {
+        if (vendor === "valibot")
+            return valibotToJsonSchema(schema);
+        if (vendor === "arktype")
+            return arkTypeToJsonSchema(schema);
+        if (vendor === "yup")
+            return yupToJsonSchema(schema);
+        if (vendor === "effect")
+            return effectToJsonSchema(schema);
+    }
+    catch (err) {
+        return schemaConversionFailed(vendor, io, err);
+    }
+    /* no converter for this vendor: say so once per schema, never emit the introspection object */
+    console.warn(`[honey:codegen] schemaToJsonSchema: no JSON Schema converter for vendor "${vendor}"; ` +
+        "documented as an unconstrained schema.");
+    return {};
+}
+export function generateManifest(app, options = {}) {
+    const factory = getErrorFactory(app);
+    const published = options.visibility === "published";
+    const publishable = published ? publishableMetaKeys(metaSpecOf(app)) : null;
+    const collected = collectRoutes(app).filter(({ handler, method, path }) => {
+        if (published && isMetaInternal(handler))
+            return false;
+        return !options.filterRoutes || options.filterRoutes({ meta: handler.mt ?? EMPTY_OBJ, method, path });
+    });
+    /* each key resolved against the factory of a route that declares it — a mounted sub-app keeps its own */
+    const allErrorKeys = new Map();
+    const routes = collected.map(({ handler, method, path }) => {
+        const entry = {
+            errors: Array.from(handler.ek),
+            meta: publishable
+                ? Object.fromEntries(Object.entries(handler.mt ?? EMPTY_OBJ).filter(([key]) => publishable(key)))
+                : (handler.mt ?? EMPTY_OBJ),
+            method,
+            middleware: handler.mw.map((mw) => mw.name || "anonymous"),
+            params: extractParams(path),
+            path,
+        };
+        const routeFactory = handler.fac ?? factory;
+        for (const ek of handler.ek) {
+            if (!allErrorKeys.has(ek))
+                allErrorKeys.set(ek, routeFactory);
+        }
+        if (handler.iv) {
+            entry.input = Object.fromEntries(Object.entries(handler.iv)
+                .filter(([, v]) => v !== undefined)
+                .map(([k, v]) => [k, introspectSchema(unwrapEntry(v))]));
+        }
+        if (handler.os) {
+            entry.output = Object.fromEntries(Object.entries(handler.os)
+                .filter(([, v]) => v !== undefined)
+                .map(([contentType, schemas]) => {
+                if (contentType === "redirect") {
+                    return [contentType, schemas];
+                }
+                return [
+                    contentType,
+                    Object.fromEntries(Object.entries(schemas)
+                        .filter(([, s]) => s !== undefined)
+                        .map(([statusKey, s]) => [statusKey, introspectSchema(s)])),
+                ];
+            }));
+        }
+        return entry;
+    });
+    return {
+        errors: Array.from(allErrorKeys).map(([key, keyFactory]) => resolveErrorInfo(key, keyFactory)),
+        routes,
+    };
+}
+/* ---- OpenAPI generation ---- */
+export async function generateOpenApi(app, options) {
+    await Promise.all([loadToJSONSchema(), loadEffectJsonSchema()]);
+    const prev = getJsonSchemaConverter();
+    const prevMode = schemaFailureMode;
+    schemaFailureMode = options.onSchemaError ?? "throw";
+    setJsonSchemaConverter((schema, io) => schemaToJsonSchema(schema, io));
+    try {
+        const { onSchemaError: _mode, ...rest } = options;
+        const spec = generateOpenApiFromTree(app, rest);
+        return deduplicateSchemas(spec);
+    }
+    finally {
+        setJsonSchemaConverter(prev);
+        schemaFailureMode = prevMode;
+    }
+}
+export function extractSchemas(app) {
+    const collected = collectRoutes(app);
+    const result = {};
+    for (const { handler, method, path } of collected) {
+        const key = `${method} ${path}`;
+        result[key] = {};
+        if (handler.iv) {
+            result[key].input = Object.fromEntries(Object.entries(handler.iv)
+                .filter(([, v]) => v !== undefined)
+                .map(([k, v]) => [k, introspectSchema(unwrapEntry(v))]));
+        }
+        if (handler.os) {
+            result[key].output = Object.fromEntries(Object.entries(handler.os)
+                .filter(([, v]) => v !== undefined)
+                .map(([contentType, schemas]) => [
+                contentType,
+                Object.fromEntries(Object.entries(schemas)
+                    .filter(([, s]) => s !== undefined)
+                    .map(([statusKey, s]) => [statusKey, introspectSchema(s)])),
+            ]));
+        }
+    }
+    return result;
+}
+/* ---- Static route tree codegen ---- */
+/**
+ * Reject meta a generated file cannot reproduce. A route tree is JSON plus topology: a value
+ * JSON cannot round-trip (`Date`, `RegExp`, `NaN`, `BigInt`, class instances) would be
+ * emitted as something else, or interned together with a different value.
+ */
+function assertJsonValue(value, where, path) {
+    const fail = (what) => {
+        throw new Error(`${where}: ${path} is ${what} — route trees carry JSON values only`);
+    };
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            fail(String(value));
+        return;
+    }
+    if (value === undefined)
+        return;
+    if (typeof value !== "object")
+        fail(`a ${typeof value}`);
+    if (Array.isArray(value)) {
+        for (let k = 0; k < value.length; k++)
+            assertJsonValue(value[k], where, `${path}[${k}]`);
+        return;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) {
+        const name = value.constructor?.name ?? "an object";
+        fail(`a ${name}`);
+    }
+    for (const key of Object.keys(value)) {
+        assertJsonValue(value[key], where, `${path}.${key}`);
+    }
+}
+/** Object-literal key that defines an own property even for `__proto__`. */
+function keyExpr(key) {
+    return key === "__proto__" ? '["__proto__"]' : JSON.stringify(key);
+}
+function methodMapExpr(m, intern) {
+    const parts = Object.keys(m).map((method) => `${keyExpr(method)}: ${intern.expr(m[method])}`);
+    return `S({ ${parts.join(", ")} })`;
+}
+function serializeNode(node, intern) {
+    const statics = Object.keys(node.s);
+    const sExpr = statics.length > 0
+        ? `S({ ${statics.map((k) => `${keyExpr(k)}: ${serializeNode(node.s[k], intern)}`).join(", ")} })`
+        : "undefined";
+    const args = [
+        sExpr,
+        node.m !== null ? methodMapExpr(node.m, intern) : "null",
+        node.d !== null ? `{ n: ${JSON.stringify(node.d.n)}, c: ${serializeNode(node.d.c, intern)} }` : "null",
+        node.w !== null ? `{ n: ${JSON.stringify(node.w.n)}, m: ${methodMapExpr(node.w.m, intern)} }` : "null",
+        node.ws !== null ? intern.expr(node.ws) : "null",
+    ];
+    while (args.length > 0 && (args[args.length - 1] === "null" || args[args.length - 1] === "undefined"))
+        args.pop();
+    return `N(${args.join(", ")})`;
+}
+function collectMetaShape(entries) {
+    const allKeys = new Map();
+    const keyCount = new Map();
+    let metaHandlerCount = 0;
+    for (const { mt } of entries) {
+        if (mt === null || mt === undefined)
+            continue;
+        metaHandlerCount++;
+        for (const [k, v] of Object.entries(mt)) {
+            if (!allKeys.has(k))
+                allKeys.set(k, new Set());
+            allKeys.get(k)?.add(emitLiteral(v));
+            keyCount.set(k, (keyCount.get(k) ?? 0) + 1);
+        }
+    }
+    return { allKeys, keyCount, metaHandlerCount };
+}
+function emitMetaShapeType(shape) {
+    if (shape.allKeys.size === 0)
+        return "";
+    const props = [...shape.allKeys.entries()]
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([key, types]) => {
+        const optional = (shape.keyCount.get(key) ?? 0) < shape.metaHandlerCount ? "?" : "";
+        const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+        return `\t${safeKey}${optional}: ${[...types].join(" | ")}`;
+    });
+    return `export type MetaShape = {\n${props.join("\n")}\n} & Record<string, unknown>\n`;
+}
+/**
+ * Emit a route tree module: topology with `RouteId` leaves plus per-route data (meta, error
+ * keys, boundary key). No handler fields — the app that loads the tree registers its routes,
+ * which bind to these ids; leaves it does not register are delegated to its catch-all.
+ */
+function emitRouteTree(tree) {
+    const order = [];
+    const seen = new Set();
+    forEachLeaf(tree.root, (_method, _path, id) => {
+        if (!seen.has(id)) {
+            seen.add(id);
+            order.push(id);
+        }
+    });
+    const entries = [];
+    for (const id of order) {
+        const entry = tree.routes[id];
+        if (entry === undefined)
+            throw new Error(`route tree leaf ${id} has no route entry`);
+        const mt = entry.mt ?? null;
+        if (mt !== null)
+            assertJsonValue(mt, `Route meta for ${id}`, "meta");
+        entries.push({
+            bek: entry.bek ?? null,
+            ek: [...(entry.ek ?? [])],
+            id,
+            internalMeta: mt?.internal === true,
+            mt,
+        });
+    }
+    const intern = new InternPool();
+    for (const e of entries) {
+        intern.count(e.bek);
+        if (e.ek.length > 0)
+            intern.count(e.ek);
+        intern.count(e.mt);
+        intern.count(e.id);
+    }
+    for (const e of entries) {
+        intern.force(e.mt, "M");
+        intern.force(e.id, "P");
+    }
+    intern.seal();
+    const metaShape = collectMetaShape(entries);
+    const hasMetaShape = metaShape.allKeys.size > 0;
+    const lines = [];
+    lines.push('import type { RouteTree, TreeNode } from "@lovrozagar/honey/tree"');
+    lines.push("");
+    lines.push("function S<T>(o: Record<string, T>): Record<string, T> {");
+    lines.push("\treturn Object.assign(Object.create(null) as Record<string, T>, o)");
+    lines.push("}");
+    lines.push('function N(s: Record<string, TreeNode> = S({}), m: Record<string, string> | null = null, d: TreeNode["d"] = null, w: TreeNode["w"] = null, ws: string | null = null): TreeNode {');
+    lines.push("\treturn { d, m, s, w, ws }");
+    lines.push("}");
+    const consts = intern.emitConstLines();
+    if (consts.length > 0) {
+        lines.push("");
+        for (const line of consts) {
+            if (hasMetaShape && /^const M\d+ = /.test(line))
+                lines.push(`${line} as unknown as MetaShape`);
+            else
+                lines.push(line);
+        }
+    }
+    lines.push("");
+    lines.push(`export const tree: TreeNode = ${serializeNode(tree.root, intern)}`);
+    lines.push("");
+    const routeLines = entries.map((e) => {
+        const parts = [];
+        if (e.bek !== null)
+            parts.push(`bek: ${intern.expr(e.bek)}`);
+        if (e.ek.length > 0)
+            parts.push(`ek: ${intern.expr(e.ek)}`);
+        if (e.mt !== null)
+            parts.push(`mt: ${intern.expr(e.mt)}`);
+        return `\t[${intern.expr(e.id)}]: ${parts.length > 0 ? `{ ${parts.join(", ")} }` : "{}"}`;
+    });
+    lines.push(`export const routes: RouteTree["routes"] = S({\n${routeLines.join(",\n")}\n})`);
+    lines.push("");
+    let code = lines.join("\n");
+    if (hasMetaShape)
+        code += `\n${emitMetaShapeType(metaShape)}\n`;
+    const selectors = entries.filter((e) => !e.id.startsWith("WS ") && !e.internalMeta).map((e) => e.id);
+    if (selectors.length > 0) {
+        const sorted = [...new Set(selectors)].sort();
+        const parts = sorted.map((sel) => {
+            const ref = intern.id(sel);
+            return ref !== undefined ? `typeof ${ref}` : JSON.stringify(sel);
+        });
+        code += `\nexport type RouteSelector = ${parts.join(" | ")}\n`;
+    }
+    const metaEntries = entries
+        .filter((e) => e.mt !== null && Object.keys(e.mt).length > 0)
+        .map((e) => `\t[${intern.expr(e.id)}]: ${intern.expr(e.mt)}`);
+    const metaType = hasMetaShape ? "Record<string, MetaShape>" : "Record<string, Record<string, unknown>>";
+    if (metaEntries.length > 0) {
+        code += `export const meta: ${metaType} = S({\n${metaEntries.join(",\n")}\n})\n`;
+    }
+    code += `export const routeTree: RouteTree = { v: ${ROUTE_TREE_VERSION}, root: tree, routes, ${metaEntries.length > 0 ? "meta" : "meta: {}"} }\n`;
+    return code;
+}
+/** Emit a route tree module from a tree (a `mergeTree` result or an `app.toRouteTree()` snapshot). */
+export function generateRouteTree(tree) {
+    return emitRouteTree(tree);
+}
+export function generateRouteTreeFromApp(app) {
+    return emitRouteTree(app.toRouteTree());
+}
+/**
+ * Generate static route tree code from a pre-built RouteTree.
+ * Supports gateway patterns: import service trees → enrich meta → mergeTree → generate.
+ */
+export function generateRouteTreeFromRouteTree(rt) {
+    return emitRouteTree(rt);
+}
+function emitInputType(handler, state) {
+    if (!handler.iv)
+        return "{}";
+    const entries = [];
+    for (const [source, schema] of Object.entries(handler.iv)) {
+        if (schema === undefined)
+            continue;
+        const unwrapped = unwrapEntry(schema);
+        entries.push(`${source}: ${emitSchemaType(unwrapped, state)}`);
+    }
+    if (entries.length === 0)
+        return "{}";
+    return `{ ${entries.join("; ")} }`;
+}
+function emitOutputType(handler, state) {
+    if (!handler.os)
+        return "{}";
+    const ctEntries = [];
+    for (const [contentType, schemas] of Object.entries(handler.os)) {
+        if (schemas === undefined)
+            continue;
+        if (contentType === "redirect") {
+            const keys = Object.keys(schemas).filter((k) => schemas[k]);
+            if (keys.length > 0) {
+                ctEntries.push(`"redirect": { ${keys.map((k) => `${quoteKey(k)}: true`).join("; ")} }`);
+            }
+            continue;
+        }
+        const statusEntries = [];
+        for (const [statusKey, schema] of Object.entries(schemas)) {
+            if (schema === undefined)
+                continue;
+            statusEntries.push(`${quoteKey(statusKey)}: ${emitSchemaType(schema, state)}`);
+        }
+        if (statusEntries.length > 0) {
+            ctEntries.push(`${JSON.stringify(contentType)}: { ${statusEntries.join("; ")} }`);
+        }
+    }
+    if (ctEntries.length === 0)
+        return "{}";
+    return `{ ${ctEntries.join("; ")} }`;
+}
+function emitMetaType(handler) {
+    if (!handler.mt)
+        return "{}";
+    const entries = [];
+    for (const [k, v] of Object.entries(handler.mt)) {
+        entries.push(`${quoteKey(k)}: ${emitLiteral(v)}`);
+    }
+    if (entries.length === 0)
+        return "{}";
+    return `{ ${entries.join("; ")} }`;
+}
+function emitLiteral(value) {
+    if (value === null)
+        return "null";
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number")
+        return Number.isFinite(value) ? String(value) : "number";
+    if (typeof value === "boolean")
+        return String(value);
+    if (typeof value === "bigint")
+        return `${value}n`;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return "[]";
+        return `[${value.map((v) => emitLiteral(v)).join(", ")}]`;
+    }
+    if (typeof value === "object") {
+        const obj = value;
+        const keys = Object.keys(obj);
+        if (keys.length === 0)
+            return "{}";
+        return `{ ${keys.map((k) => `${JSON.stringify(k)}: ${emitLiteral(obj[k])}`).join("; ")} }`;
+    }
+    return "unknown";
+}
+function emitErrorType(handler) {
+    if (handler.ek.size === 0)
+        return "never";
+    return Array.from(handler.ek)
+        .sort()
+        .map((k) => JSON.stringify(k))
+        .join(" | ");
+}
+function emitErrorShapes(handler, meta, state) {
+    if (handler.ek.size === 0)
+        return null;
+    const entries = [];
+    for (const key of Array.from(handler.ek).sort()) {
+        const entry = meta?.[key];
+        if (entry?.schema) {
+            const schemaType = emitSchemaType(entry.schema, state);
+            entries.push(`${quoteKey(key)}: ${schemaType}`);
+        }
+        else {
+            entries.push(`${quoteKey(key)}: null`);
+        }
+    }
+    return `{ ${entries.join("; ")} }`;
+}
+function emitErrorsByStatus(handler, meta, factory, state) {
+    if (handler.ek.size === 0)
+        return null;
+    const byStatus = new Map();
+    for (const key of handler.ek) {
+        const info = resolveErrorInfo(key, factory);
+        if (info.status > 0) {
+            let keys = byStatus.get(info.status);
+            if (!keys) {
+                keys = [];
+                byStatus.set(info.status, keys);
+            }
+            keys.push(key);
+        }
+    }
+    const entries = [];
+    for (const [status, keys] of Array.from(byStatus.entries()).sort((a, b) => a[0] - b[0])) {
+        /* build shape union for this status code */
+        const shapes = [];
+        for (const key of keys.sort()) {
+            const entry = meta?.[key];
+            if (entry?.schema) {
+                shapes.push(emitSchemaType(entry.schema, state));
+            }
+            else {
+                shapes.push("null");
+            }
+        }
+        const shapeType = shapes.length === 1 ? shapes[0] : shapes.join(" | ");
+        entries.push(`${status}: ${shapeType}`);
+    }
+    return `{ ${entries.join("; ")} }`;
+}
+function emitErrorsCtxType(handler) {
+    if (handler.ek.size === 0)
+        return "";
+    const entries = Array.from(handler.ek)
+        .sort()
+        .map((k) => `${quoteKey(k)}: (opts?: { cause?: unknown; fields?: Record<string, { error_key: string; message: string; path: string }[]>; headers?: Record<string, string>; vars?: Record<string, string | number> }) => HoneyError`);
+    return `readonly errors: { ${entries.join("; ")} }`;
+}
+/**
+ * Per-route middleware type additions. The type extractor keys routes by their full path —
+ * basePath included — exactly as the router registers them, so the lookup is exact: a route
+ * with no entry gets the base ctx, never another route's additions.
+ */
+function resolveRouteMiddleware(routeMiddleware, method, fullPath) {
+    if (!routeMiddleware)
+        return undefined;
+    const key = `${method} ${fullPath}`;
+    return Object.hasOwn(routeMiddleware, key) ? routeMiddleware[key] : undefined;
+}
+export function generateTypes(app, options) {
+    const collected = collectRoutes(app, true);
+    const factory = getErrorFactory(app);
+    const errorMeta = getErrorMeta(factory);
+    const baseCtxName = options.baseCtxName ?? "BaseCtx";
+    const hasErrors = collected.some(({ handler }) => handler.ek.size > 0);
+    const lines = [];
+    const importParts = ["HoneyContext", "WithOutput"];
+    if (hasErrors)
+        importParts.push("HoneyError");
+    lines.push(`import type { ${importParts.join(", ")} } from "@lovrozagar/honey"`);
+    lines.push("");
+    const envType = options.inlineEnvType ?? "Record<string, unknown>";
+    const mwPart = options.inlineMiddlewareType ? ` & ${options.inlineMiddlewareType}` : "";
+    if (options.inlineTapsType) {
+        lines.push(`type TapMap = ${options.inlineTapsType}`);
+        lines.push("");
+    }
+    const ctxBase = options.inlineTapsType ? `Omit<HoneyContext<${envType}>, "tap">` : `HoneyContext<${envType}>`;
+    const tapPart = options.inlineTapsType ? " & { tap<K extends keyof TapMap>(key: K, payload: TapMap[K]): void }" : "";
+    lines.push(`export type ${baseCtxName} = ${ctxBase}${mwPart}${tapPart}`);
+    lines.push("");
+    /* group routes by path */
+    const byPath = new Map();
+    for (const { handler, method, path } of collected) {
+        let group = byPath.get(path);
+        if (!group) {
+            group = [];
+            byPath.set(path, group);
+        }
+        group.push({ handler, method: method.toLowerCase() });
+    }
+    /* emit RouteSelector union from route graph */
+    const selectors = new Set();
+    for (const { handler, method, path } of collected) {
+        if (handler._skip || isMetaInternal(handler))
+            continue;
+        selectors.add(`${method} ${path}`);
+    }
+    if (selectors.size > 0) {
+        const sorted = [...selectors].sort();
+        lines.push(`export type RouteSelector = ${sorted.map((s) => JSON.stringify(s)).join(" | ")}`);
+        lines.push("");
+        /* augment the module consumers import — an augmentation of any other name silently applies to nothing */
+        lines.push('declare module "@lovrozagar/honey" {');
+        lines.push("\tinterface HoneyCodegen {");
+        lines.push(`\t\trouteSelector: RouteSelector`);
+        lines.push("\t}");
+        lines.push("}");
+        lines.push("");
+    }
+    /* deduplicate per-route middleware additions into named types,
+     * with sub-property dedup for large repeated property types (e.g. Drizzle DB schemas) */
+    const mwTypeMap = new Map();
+    let mwTypeCounter = 0;
+    /* use structured property data from type-extractor for sub-type dedup */
+    const routeProps = options.routeMiddlewareProps;
+    const propTypeCount = new Map();
+    if (routeProps) {
+        for (const props of Object.values(routeProps)) {
+            for (const prop of props) {
+                if (prop.type.length >= 512) {
+                    propTypeCount.set(prop.type, (propTypeCount.get(prop.type) ?? 0) + 1);
+                }
+            }
+        }
+    }
+    /* emit shared sub-type aliases for duplicated property types */
+    const subTypeMap = new Map();
+    let subTypeCounter = 0;
+    for (const [typeStr, count] of propTypeCount) {
+        if (count >= 2) {
+            const alias = `_MW${subTypeCounter++}`;
+            subTypeMap.set(typeStr, alias);
+            lines.push(`type ${alias} = ${typeStr}`);
+            lines.push("");
+        }
+    }
+    function buildMwType(method, path) {
+        const key = `${method} ${path}`;
+        const props = routeProps && Object.hasOwn(routeProps, key) ? routeProps[key] : undefined;
+        if (props?.length) {
+            const entries = props.map((p) => {
+                const typeStr = subTypeMap.get(p.type) ?? p.type;
+                return `${p.name}${p.opt ? "?" : ""}: ${typeStr}`;
+            });
+            return `{ ${entries.join("; ")} }`;
+        }
+        /* fallback to raw string if no structured data */
+        return resolveRouteMiddleware(options.routeMiddleware, method, path);
+    }
+    function dedupeRouteMiddleware(method, path) {
+        const mwType = buildMwType(method, path);
+        if (!mwType)
+            return undefined;
+        let alias = mwTypeMap.get(mwType);
+        if (!alias) {
+            alias = `MwCtx${mwTypeCounter++}`;
+            mwTypeMap.set(mwType, alias);
+            lines.push(`type ${alias} = ${mwType}`);
+            lines.push("");
+        }
+        return alias;
+    }
+    /* pre-scan all routes to emit deduplicated middleware types before Routes */
+    for (const [path, methods] of byPath) {
+        for (const { method } of methods) {
+            dedupeRouteMiddleware(method, path);
+        }
+    }
+    const emitState = createTypeEmitState();
+    const routesLines = [];
+    routesLines.push("export type Routes = {");
+    for (const [path, methods] of byPath) {
+        routesLines.push(`\t${JSON.stringify(path)}: {`);
+        for (const { handler, method } of methods) {
+            const mwType = buildMwType(method, path);
+            const mwAlias = mwType ? mwTypeMap.get(mwType) : undefined;
+            const basePart = mwAlias ? `${baseCtxName} & ${mwAlias}` : baseCtxName;
+            const additions = [];
+            const inputType = emitInputType(handler, emitState);
+            if (inputType !== "{}")
+                additions.push(`input: ${inputType}`);
+            /* the names ctx.params carries at runtime — an unnamed wildcard is "*" */
+            const params = patternParams(parsePattern(path));
+            if (params.length > 0) {
+                const paramEntries = params.map((p) => `${quoteKey(p)}: string`).join("; ");
+                additions.push(`readonly params: { ${paramEntries} }`);
+            }
+            const errorsCtx = emitErrorsCtxType(handler);
+            if (errorsCtx)
+                additions.push(errorsCtx);
+            const ctxType = additions.length === 0 ? basePart : `${basePart} & { ${additions.join("; ")} }`;
+            const errorType = emitErrorType(handler);
+            const metaType = emitMetaType(handler);
+            const outputType = emitOutputType(handler, emitState);
+            routesLines.push(`\t\t${quoteKey(method)}: {`);
+            routesLines.push(`\t\t\tctx: WithOutput<${ctxType}, ${outputType}>`);
+            routesLines.push(`\t\t\terrors: ${errorType}`);
+            /* a mounted sub-app's route keeps its own error factory */
+            const routeFactory = handler.fac ?? factory;
+            const routeErrorMeta = routeFactory === factory ? errorMeta : getErrorMeta(routeFactory);
+            const shapesType = emitErrorShapes(handler, routeErrorMeta, emitState);
+            if (shapesType) {
+                routesLines.push(`\t\t\terrorShapes: ${shapesType}`);
+                const byStatusType = emitErrorsByStatus(handler, routeErrorMeta, routeFactory, emitState);
+                if (byStatusType) {
+                    routesLines.push(`\t\t\terrorsByStatus: ${byStatusType}`);
+                }
+            }
+            routesLines.push(`\t\t\tinput: ${inputType}`);
+            routesLines.push(`\t\t\tmeta: ${metaType}`);
+            routesLines.push(`\t\t\toutput: ${outputType}`);
+            routesLines.push("\t\t}");
+        }
+        routesLines.push("\t}");
+    }
+    routesLines.push("}");
+    routesLines.push("");
+    for (const [name, body] of emitState.aliases) {
+        lines.push(`type ${name} = ${body}`);
+        lines.push("");
+    }
+    lines.push(...routesLines);
+    /* route-specific type extractors — services use these instead of typeof app */
+    lines.push("export type RouteCtx<");
+    lines.push("\tTPath extends keyof Routes,");
+    lines.push("\tTMethod extends keyof Routes[TPath] & string");
+    lines.push("> = Routes[TPath][TMethod] extends { ctx: infer C } ? C : never");
+    lines.push("");
+    lines.push("export type RouteInput<");
+    lines.push("\tTPath extends keyof Routes,");
+    lines.push("\tTMethod extends keyof Routes[TPath] & string");
+    lines.push("> = Routes[TPath][TMethod] extends { input: infer I } ? I : never");
+    lines.push("");
+    lines.push("export type RouteOutput<");
+    lines.push("\tTPath extends keyof Routes,");
+    lines.push("\tTMethod extends keyof Routes[TPath] & string");
+    lines.push("> = Routes[TPath][TMethod] extends { output: infer O } ? O : never");
+    lines.push("");
+    lines.push("export type RouteErrors<");
+    lines.push("\tTPath extends keyof Routes,");
+    lines.push("\tTMethod extends keyof Routes[TPath] & string");
+    lines.push("> = Routes[TPath][TMethod] extends { errors: infer E } ? E : never");
+    lines.push("");
+    lines.push("export type RouteErrorShapes<");
+    lines.push("\tTPath extends keyof Routes,");
+    lines.push("\tTMethod extends keyof Routes[TPath] & string");
+    lines.push("> = Routes[TPath][TMethod] extends { errorShapes: infer S } ? S : never");
+    lines.push("");
+    lines.push("export type RouteErrorsByStatus<");
+    lines.push("\tTPath extends keyof Routes,");
+    lines.push("\tTMethod extends keyof Routes[TPath] & string");
+    lines.push("> = Routes[TPath][TMethod] extends { errorsByStatus: infer S } ? S : never");
+    lines.push("");
+    lines.push("export type RouteMeta<");
+    lines.push("\tTPath extends keyof Routes,");
+    lines.push("\tTMethod extends keyof Routes[TPath] & string");
+    lines.push("> = Routes[TPath][TMethod] extends { meta: infer M } ? M : never");
+    lines.push("");
+    return lines.join("\n");
+}
+export function mergeSpecs(...specs) {
+    const merged = {
+        info: specs[0]?.info ?? { title: "", version: "" },
+        openapi: specs[0]?.openapi ?? "3.1.0",
+        paths: {},
+    };
+    let mergedComponents;
+    for (const spec of specs) {
+        for (const [path, methods] of Object.entries(spec.paths)) {
+            if (merged.paths[path] === undefined) {
+                merged.paths[path] = {};
+            }
+            for (const [method, operation] of Object.entries(methods)) {
+                if (merged.paths[path][method] !== undefined) {
+                    throw new Error(`Merge conflict: duplicate ${method.toUpperCase()} ${path}`);
+                }
+                merged.paths[path][method] = operation;
+            }
+        }
+        if (spec.components) {
+            if (!mergedComponents)
+                mergedComponents = {};
+            if (spec.components.schemas) {
+                if (!mergedComponents.schemas)
+                    mergedComponents.schemas = {};
+                for (const [name, schema] of Object.entries(spec.components.schemas)) {
+                    if (mergedComponents.schemas[name] !== undefined) {
+                        /* allow identical schemas (same content-hash name from same app) */
+                        if (canonicalizeSchema(mergedComponents.schemas[name]) !== canonicalizeSchema(schema)) {
+                            throw new Error(`Merge conflict: duplicate component schema "${name}"`);
+                        }
+                    }
+                    else {
+                        mergedComponents.schemas[name] = schema;
+                    }
+                }
+            }
+            if (spec.components.securitySchemes) {
+                if (!mergedComponents.securitySchemes)
+                    mergedComponents.securitySchemes = {};
+                for (const [name, scheme] of Object.entries(spec.components.securitySchemes)) {
+                    mergedComponents.securitySchemes[name] = scheme;
+                }
+            }
+        }
+    }
+    if (mergedComponents)
+        merged.components = mergedComponents;
+    return merged;
+}
+export function scopeSpec(spec, filter) {
+    const result = {
+        info: spec.info,
+        openapi: spec.openapi,
+        paths: {},
+    };
+    const hasFilter = filter.tags !== undefined ||
+        filter.excludeTags !== undefined ||
+        filter.pathPrefix !== undefined ||
+        filter.operationIds !== undefined;
+    if (spec.components)
+        result.components = spec.components;
+    if (!hasFilter) {
+        result.paths = { ...spec.paths };
+        return result;
+    }
+    for (const [path, methods] of Object.entries(spec.paths)) {
+        if (filter.pathPrefix && !path.startsWith(filter.pathPrefix))
+            continue;
+        for (const [method, operation] of Object.entries(methods)) {
+            const op = operation;
+            const opTags = (op.tags ?? []);
+            const opId = op.operationId;
+            if (filter.tags && !opTags.some((t) => filter.tags?.includes(t)))
+                continue;
+            if (filter.excludeTags && opTags.some((t) => filter.excludeTags?.includes(t)))
+                continue;
+            if (filter.operationIds && (!opId || !filter.operationIds.includes(opId)))
+                continue;
+            if (result.paths[path] === undefined) {
+                result.paths[path] = {};
+            }
+            result.paths[path][method] = operation;
+        }
+    }
+    return result;
+}
+export function extractOpenApiPathParams(path) {
+    const params = [];
+    /* any name between braces — `{user-id}` is one parameter, not `{user}` and a literal `-id` */
+    const re = /\{([^{}/]+)\}/g;
+    let match = re.exec(path);
+    while (match !== null) {
+        params.push(match[1]);
+        match = re.exec(path);
+    }
+    return params;
+}
+export function isSSEOperation(operation) {
+    const responses = operation.responses;
+    if (!responses)
+        return false;
+    for (const response of Object.values(responses)) {
+        const content = response.content;
+        if (content && "text/event-stream" in content)
+            return true;
+    }
+    return false;
+}
+/** JSON Schema → TypeScript type string (shim — delegates to IR pipeline). */
+export function jsonSchemaToTS(schema, depth = 0, binary = "string") {
+    if (!schema || depth > 8)
+        return "unknown";
+    return irToTs(schemaToIR(schema), depth, binary);
+}
+/* a file part of a multipart body is sent as a Blob/File; the runtime appends it to FormData as is */
+const FORM_BINARY_TS = "Blob";
+/* the TS SDK input field a request body fills, by its media type */
+function sdkBodyField(body) {
+    if (body.kind === "stream")
+        return "body";
+    if (body.kind === "multipart")
+        return "form";
+    const essence = mediaEssence(body.contentType);
+    if (isJsonMedia(body.contentType))
+        return "json";
+    if (essence === "multipart/form-data" || essence === "application/x-www-form-urlencoded")
+        return "form";
+    return null;
+}
+/* extract input type for an operation */
+function emitSDKInputType(op) {
+    const mandatoryParts = [];
+    const optionalParts = [];
+    /* path params — always required */
+    if (op.params.path.length > 0) {
+        const entries = op.params.path.map((p) => `${sdkSafeName(p.name)}: ${irToTs(p.schema)}`).join("; ");
+        mandatoryParts.push(`params: { ${entries} }`);
+    }
+    /* query params */
+    if (op.params.query.length > 0) {
+        const entries = op.params.query
+            .slice()
+            .sort((a, b) => compareCodeUnits(a.name, b.name))
+            .map((p) => `${sdkSafeName(p.name)}${p.required === true ? "" : "?"}: ${irToTs(p.schema)}`);
+        const searchEntry = `search: { ${entries.join("; ")} }`;
+        if (op.params.query.some((p) => p.required === true))
+            mandatoryParts.push(searchEntry);
+        else
+            optionalParts.push(searchEntry);
+    }
+    /* header and cookie params — typed on top of the free-form per-call `headers` / `cookies` */
+    for (const [declared, field] of [
+        [op.params.header, "headers"],
+        [op.params.cookie ?? [], "cookies"],
+    ]) {
+        if (declared.length === 0)
+            continue;
+        const entries = declared
+            .slice()
+            .sort((a, b) => compareCodeUnits(a.name, b.name))
+            .map((p) => {
+            /* sent as text: a header or cookie value is a string on the wire */
+            const tsType = p.schema.kind === "scalar" && p.schema.enum ? irToTs(p.schema) : "string";
+            return `${quoteKey(p.name)}${p.required === true ? "" : "?"}: ${tsType}`;
+        });
+        const entry = `${field}: { ${entries.join("; ")} }`;
+        if (declared.some((p) => p.required === true))
+            mandatoryParts.push(entry);
+        else
+            optionalParts.push(entry);
+    }
+    /* request body: one input field per kind; the preferred content type of each kind wins */
+    const byField = new Map();
+    for (const body of bodiesOf(op)) {
+        const field = sdkBodyField(body);
+        if (field && !byField.has(field))
+            byField.set(field, body);
+    }
+    /* raw bytes first, then json, then form: the order the fields always had */
+    for (const field of ["body", "json", "form"]) {
+        const body = byField.get(field);
+        if (!body)
+            continue;
+        let entry;
+        if (field === "body")
+            entry = "body: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array";
+        else if (field === "json")
+            entry = `json: ${body.kind === "raw" ? irToTs(body.schema) : "unknown"}`;
+        else {
+            const schema = body.kind === "raw" ? body.schema : body.kind === "multipart" ? body.schema : undefined;
+            entry = `form: ${schema ? irToTs(schema, 0, FORM_BINARY_TS) : "Record<string, unknown>"}`;
+        }
+        if (body.required)
+            mandatoryParts.push(entry);
+        else
+            optionalParts.push(entry);
+    }
+    const allParts = [...mandatoryParts, ...optionalParts];
+    const type = allParts.length === 0 ? "{}" : `{ ${allParts.join("; ")} }`;
+    return { hasMandatory: mandatoryParts.length > 0, type };
+}
+/* extract response type for an operation */
+function emitSDKResponseType(op) {
+    /* SSE — shape mirrors runtime _SSEEvent (event/id/retry all optional) */
+    if (op.extensions.sse)
+        return "AsyncIterable<{ data: string; event?: string; id?: string; retry?: number }>";
+    /* collect success response types (2xx) — `default` and `4XX`-style keys are never success */
+    const successTypes = [];
+    for (const [status, response] of Object.entries(op.responses)) {
+        if (!/^2(?:[0-9][0-9]|XX)$/i.test(status))
+            continue;
+        const code = /^2XX$/i.test(status) ? 200 : Number(status);
+        if (code === 204 || code === 205 || !response.contentType) {
+            successTypes.push("null");
+            continue;
+        }
+        /* the same classes the runtime's body parser reads: JSON, text, otherwise bytes */
+        if (isJsonMedia(response.contentType)) {
+            successTypes.push(response.schema ? irToTs(response.schema) : "unknown");
+        }
+        else if (isTextMedia(response.contentType)) {
+            successTypes.push("string");
+        }
+        else {
+            successTypes.push("ArrayBuffer");
+        }
+    }
+    if (successTypes.length === 0)
+        return "void";
+    return [...new Set(successTypes)].join(" | ");
+}
+/* detect whether a JSON schema matches the standard error envelope shape */
+export function isStandardErrEnvelope(schema) {
+    const props = schema.properties;
+    if (!props)
+        return null;
+    const successConst = props.success?.const;
+    if (successConst !== false)
+        return null;
+    const msg = props.message;
+    if (msg?.type !== "string")
+        return null;
+    const sk = props.status_key;
+    if (sk?.type !== "string")
+        return null;
+    const fieldsSchema = props.fields;
+    if (fieldsSchema?.type !== "object")
+        return null;
+    const addl = fieldsSchema?.additionalProperties;
+    if (addl?.type !== "array")
+        return null;
+    const itemSchema = addl?.items;
+    if (itemSchema?.type !== "object")
+        return null;
+    const itemProps = itemSchema?.properties;
+    for (const k of ["error_key", "message", "path"]) {
+        if (itemProps?.[k]?.type !== "string")
+            return null;
+    }
+    const statusEnum = props.status?.enum;
+    if (!Array.isArray(statusEnum) || statusEnum.length !== 1)
+        return null;
+    const statusVal = statusEnum[0];
+    if (typeof statusVal !== "number")
+        return null;
+    const errKeyEnum = props.error_key?.enum;
+    if (!Array.isArray(errKeyEnum) || errKeyEnum.length === 0)
+        return null;
+    if (!errKeyEnum.every((k) => typeof k === "string"))
+        return null;
+    return { keys: errKeyEnum, status: statusVal };
+}
+/* extract error types by status code for an operation (non-2xx responses) */
+function emitSDKErrorsByStatusType(op, resolve) {
+    const entries = [];
+    for (const [status, response] of Object.entries(op.responses)) {
+        /* only concrete error statuses: `default` and `4XX` have no single status to key on */
+        if (!/^[45][0-9][0-9]$/.test(status))
+            continue;
+        if (!response.schema || !response.contentType || !isJsonMedia(response.contentType))
+            continue;
+        const code = Number(status);
+        const envelope = irErrorEnvelope(response.schema, resolve);
+        if (envelope) {
+            const keyUnion = envelope.keys.map((k) => JSON.stringify(k)).join(" | ");
+            entries.push(`${code}: _ErrEnvelope<${envelope.status}, ${keyUnion}>`);
+        }
+        else {
+            entries.push(`${code}: ${irToTs(response.schema)}`);
+        }
+    }
+    if (entries.length === 0)
+        return null;
+    return `{ ${entries.join("; ")} }`;
+}
+/*
+ * Whether a response type string is worth hoisting into a `_Res\d` alias.
+ * Skip primitives, void/null, ArrayBuffer, and plain strings — only object or
+ * array shapes benefit from dedupe.
+ */
+function isHoistableResponseType(t) {
+    if (!t)
+        return false;
+    if (t === "void" || t === "null" || t === "string" || t === "ArrayBuffer")
+        return false;
+    const head = t.trimStart()[0];
+    return head === "{" || head === "[";
+}
+function buildMethodSig(m, inpAliases, errAliases, resAliases) {
+    let suffixType;
+    if (m.ws)
+        suffixType = "_WsOpts";
+    else if (m.sse)
+        suffixType = "_SseOpts";
+    else
+        suffixType = "_HttpOpts";
+    const inpAlias = inpAliases.get(m.inputType);
+    const resolvedInp = inpAlias ? `_Expand<${inpAlias}>` : m.inputType;
+    const fullInputType = resolvedInp === "{}" ? suffixType : `${resolvedInp} & ${suffixType}`;
+    const inputArg = `${m.inputHasMandatory ? "input" : "input?"}: ${fullInputType}`;
+    let resolvedErr = null;
+    if (m.errorsByStatusType) {
+        const errAlias = errAliases.get(m.errorsByStatusType);
+        resolvedErr = errAlias ? `_Expand<${errAlias}>` : m.errorsByStatusType;
+    }
+    const resAlias = resAliases.get(m.responseType);
+    const resolvedRes = resAlias ? `_Expand<${resAlias}>` : m.responseType;
+    let returnType;
+    if (m.ws)
+        returnType = "TypedWebSocket";
+    else if (m.sse)
+        returnType = m.responseType;
+    else if (resolvedErr)
+        returnType = `TThrow extends true ? Promise<${resolvedRes}> : Promise<SDKResult<${resolvedRes}, ${resolvedErr}>>`;
+    else
+        returnType = `TThrow extends true ? Promise<${resolvedRes}> : Promise<SDKResult<${resolvedRes}>>`;
+    return { inputArg, returnType };
+}
+function buildTypeAliases(types, prefix, minCount) {
+    const counts = new Map();
+    for (const t of types)
+        counts.set(t, (counts.get(t) ?? 0) + 1);
+    const aliases = new Map();
+    const lines = [];
+    let idx = 0;
+    for (const [typeStr, count] of [...counts.entries()].sort(([a], [b]) => compareCodeUnits(a, b))) {
+        if (count >= minCount || typeStr.length > 200) {
+            const alias = `${prefix}${idx++}`;
+            aliases.set(typeStr, alias);
+            lines.push(`type ${alias} = ${typeStr}`);
+        }
+    }
+    return { aliases, lines };
+}
+/* TS reserved words that must be quoted when used as object/interface property keys */
+const SDK_TS_RESERVED = new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+    "let",
+    "static",
+    "implements",
+    "interface",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "abstract",
+    "as",
+    "async",
+    "await",
+    "constructor",
+    "declare",
+    "from",
+    "get",
+    "infer",
+    "is",
+    "keyof",
+    "module",
+    "namespace",
+    "never",
+    "of",
+    "readonly",
+    "require",
+    "set",
+    "satisfies",
+    "symbol",
+    "type",
+    "unique",
+    "unknown",
+    "override",
+]);
+function sdkSafeName(name) {
+    if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) || SDK_TS_RESERVED.has(name)) {
+        return JSON.stringify(name);
+    }
+    return name;
+}
+function buildSDKTypes(sdkName, sdkMethods, tree, methodLookup) {
+    const n = sdkName;
+    const l = [];
+    /* shared error aliases (reduce repetition for standard envelope shape) */
+    l.push("type _ErrField = { error_key: string; message: string; path: string }");
+    l.push("type _ErrEnvelope<TStatus extends number, TKey extends string> = {");
+    l.push("\terror_key: TKey");
+    l.push("\tfields: Record<string, _ErrField[]>");
+    l.push("\tmessage: string");
+    l.push("\tstatus: TStatus");
+    l.push("\tstatus_key: string");
+    l.push("\tsuccess: false");
+    l.push("}");
+    l.push("");
+    /* dedupe repeated errorsByStatusType strings — the primary source of file bloat */
+    const { aliases: errAliases, lines: errLines } = buildTypeAliases(sdkMethods.flatMap((m) => (m.errorsByStatusType ? [m.errorsByStatusType] : [])), "_Errs", 2);
+    if (errLines.length > 0) {
+        for (const line of errLines)
+            l.push(line);
+        l.push("");
+    }
+    /*
+     * Dedupe response type shapes used by non-SSE/WS methods. Each method inlines
+     * its response type TWICE (throw branch + safe branch), so hoisting once per
+     * shape roughly halves the per-method cost. Hoist when count >= 2 OR when a
+     * single literal is long enough (>200 chars) to dominate the line.
+     */
+    const { aliases: resAliases, lines: resLines } = buildTypeAliases(sdkMethods.filter((m) => !m.ws && !m.sse && isHoistableResponseType(m.responseType)).map((m) => m.responseType), "_Res", 2);
+    const { aliases: inpAliases, lines: inpLines } = buildTypeAliases(sdkMethods.filter((m) => m.inputType !== "{}" && isHoistableResponseType(m.inputType)).map((m) => m.inputType), "_Inp", 2);
+    if (resLines.length > 0 || errAliases.size > 0 || inpLines.length > 0) {
+        /*
+         * _Expand forces TS to eagerly resolve aliases in hover tooltips. Without
+         * it, `const b = await sdk.x.y(...)` would show `SDKResult<_Res33, _Errs0>`
+         * instead of the full shape. The mapped type + `& {}` intersection is a
+         * well-known trick: TS evaluates the mapped type for display but keeps the
+         * emitted reference compact, so byte-dedupe is preserved. Two levels deep
+         * so error records (`{ 400: _ErrEnvelope<...>; ... }`) expand their
+         * envelope instantiations too, not just the top-level status keys.
+         */
+        l.push("type _ExpandShallow<T> = T extends object ? { [K in keyof T]: T[K] } & {} : T");
+        l.push("type _Expand<T> = T extends object ? { [K in keyof T]: _ExpandShallow<T[K]> } & {} : T");
+        for (const line of resLines)
+            l.push(line);
+        for (const line of inpLines)
+            l.push(line);
+        l.push("");
+    }
+    /* SDKResult — typed branch trusts TErrorsByStatus to cover every error status (no unknown fallback) */
+    l.push("export type SDKResult<T, TErrorsByStatus = never> =");
+    l.push("\t| { data: T; error: null; response: Response; status: number }");
+    l.push("\t| ([TErrorsByStatus] extends [never]");
+    l.push("\t\t? { data: null; error: unknown; response: Response; status: number }");
+    l.push("\t\t: { [S in keyof TErrorsByStatus & number]: { data: null; error: TErrorsByStatus[S]; response: Response; status: S } }[keyof TErrorsByStatus & number])");
+    l.push("");
+    /* TypedWebSocket */
+    l.push("export type TypedWebSocket = {");
+    l.push("\tclose(code?: number, reason?: string): void");
+    l.push('\toff(event: "close" | "error" | "message" | "open", handler: (...args: never[]) => void): void');
+    l.push('\ton(event: "close", handler: (code: number, reason: string) => void): void');
+    l.push('\ton(event: "error", handler: (error: unknown) => void): void');
+    l.push('\ton(event: "message", handler: (data: string) => void): void');
+    l.push('\ton(event: "open", handler: () => void): void');
+    l.push("\treadonly readyState: number");
+    l.push("\tsend(data: ArrayBuffer | ArrayBufferView | object | string): void");
+    l.push("}");
+    l.push("");
+    /* config type */
+    l.push(`export type ${n}Config<TThrow extends boolean = false> = {`);
+    l.push("\tbaseURL: string");
+    l.push("\tbuildSearchParams?: (query: Record<string, unknown>) => URLSearchParams");
+    l.push("\tcredentials?: RequestCredentials");
+    l.push("\tfetch?: typeof fetch");
+    l.push(`\theaders?: Record<string, string> | ((ctx: { method: string; path: string }) => Record<string, string | undefined> | Promise<Record<string, string | undefined>>)`);
+    l.push("\tinvalidation?: { maxSourcesPerTarget?: number; staleMaxEntries?: number; staleTime: number }");
+    l.push("\tmaxErrorMessageChars?: number");
+    l.push("\tmode?: RequestMode");
+    l.push(`\tonRequest?: Array<(ctx: { body?: BodyInit; headers: Headers; invalidatedBy?: string[]; isStale?: boolean; method: string; path: string; selector?: string; state: Record<string, unknown>; url: string }) => void | Promise<void>>`);
+    l.push(`\tonResponse?: Array<(ctx: { invalidatedBy?: string[]; isRetry: boolean; isStale?: boolean; method: string; path: string; request: Request; response: Response; retry: () => Promise<Response>; selector?: string; state: Record<string, unknown>; url: string }) => Response | undefined | Promise<Response | undefined>>`);
+    l.push("\tonAuthExpired?: (ctx: { rejectedToken: string | null }) => Promise<string | null>");
+    l.push("\tauthHeaderName?: string");
+    l.push("\tauthHeaderPrefix?: string");
+    l.push("\tonLog?: (entry: _LogEntry) => void");
+    l.push('\tredirect?: "error" | "follow" | "manual" | "same-origin"');
+    l.push("\tsortSearchParams?: boolean");
+    l.push("\tsseMaxBufferChars?: number");
+    l.push("\tstate?: Record<string, unknown>");
+    l.push("\tthrowOnError?: TThrow");
+    l.push("\ttimeout?: number");
+    l.push("}");
+    l.push("");
+    l.push(`export type _LogEntry = { level: "debug" | "info" | "warn" | "error"; event: "request_start" | "response_received" | "error" | "hook_executed"; operation: string; duration_ms: number; status?: number; error?: unknown }`);
+    l.push("export type _HttpOpts = { cookies?: Record<string, string>; headers?: Record<string, string>; idempotencyKey?: string; signal?: AbortSignal; timeout?: number }");
+    l.push("export type _SseOpts = { cookies?: Record<string, string>; headers?: Record<string, string>; lastEventId?: string; signal?: AbortSignal; timeout?: number }");
+    l.push("export type _WsOpts = { protocols?: string | string[]; reconnectToken?: string }");
+    l.push("");
+    /* recursive interface emitter — walks IRNamespace tree */
+    function emitNsInterface(ns, indent) {
+        const methods = methodsOf(ns);
+        const namespaces = namespacesOf(ns);
+        for (const [name, op] of methods) {
+            const m = methodLookup.get(op.id);
+            if (!m)
+                continue;
+            /* #R6-27: single _call action → promote resource to callable at top level */
+            if (name === "_call")
+                continue; /* handled by namespace _call promotion below */
+            const { inputArg, returnType } = buildMethodSig(m, inpAliases, errAliases, resAliases);
+            l.push(`${indent}${sdkSafeName(name)}(${inputArg}): ${returnType}`);
+        }
+        for (const [name, childNs] of namespaces) {
+            const childMethods = methodsOf(childNs);
+            /* #R6-27: single _call method in namespace → promote namespace to callable */
+            if (childMethods.length === 1 && childMethods[0] && childMethods[0][0] === "_call") {
+                const [, op] = childMethods[0];
+                const m = methodLookup.get(op.id);
+                if (m) {
+                    const { inputArg, returnType } = buildMethodSig(m, inpAliases, errAliases, resAliases);
+                    l.push(`${indent}${sdkSafeName(name)}(${inputArg}): ${returnType}`);
+                    continue;
+                }
+            }
+            l.push(`${indent}${sdkSafeName(name)}: {`);
+            emitNsInterface(childNs, `${indent}\t`);
+            l.push(`${indent}}`);
+        }
+    }
+    l.push(`export interface ${n}<TThrow extends boolean = false> {`);
+    l.push("\tstate: Record<string, unknown>");
+    l.push("\tdispose(): void");
+    emitNsInterface(tree, "\t");
+    l.push("}");
+    l.push("");
+    return l.join("\n");
+}
+function emitNestedMapNode(node, indent) {
+    if (node.kind === "leaf") {
+        const entry = node.entry;
+        const parts = [`method: ${JSON.stringify(entry.method)}`, `path: ${JSON.stringify(entry.path)}`];
+        if (entry.params)
+            parts.push(`params: ${JSON.stringify(entry.params)}`);
+        if (entry.sse)
+            parts.push("sse: true");
+        if (entry.wildcard)
+            parts.push(`wildcard: ${JSON.stringify(entry.wildcard)}`);
+        if (entry.ws)
+            parts.push("ws: true");
+        if (entry.idempotent)
+            parts.push("idempotent: true");
+        if (entry.invalidate)
+            parts.push(`invalidate: ${JSON.stringify(entry.invalidate)}`);
+        return [`{ ${parts.join(", ")} }`];
+    }
+    const lines = ["{"];
+    for (const [key, child] of [...node.children.entries()].sort(([a], [b]) => compareCodeUnits(a, b))) {
+        const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+        const childLines = emitNestedMapNode(child, `${indent}\t`);
+        if (childLines.length === 1) {
+            lines.push(`${indent}\t${safeKey}: ${childLines[0]},`);
+        }
+        else {
+            lines.push(`${indent}\t${safeKey}: ${childLines[0]}`);
+            for (let i = 1; i < childLines.length - 1; i++)
+                lines.push(childLines[i] ?? "");
+            lines.push(`${indent}\t${childLines[childLines.length - 1]},`);
+        }
+    }
+    lines.push(`${indent}}`);
+    return lines;
+}
+function buildSDKMap(nestedMap) {
+    const l = [];
+    l.push("export const serviceMap = {");
+    for (const [key, node] of [...nestedMap.entries()].sort(([a], [b]) => compareCodeUnits(a, b))) {
+        const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+        const childLines = emitNestedMapNode(node, "\t");
+        if (childLines.length === 1) {
+            l.push(`\t${safeKey}: ${childLines[0]},`);
+        }
+        else {
+            l.push(`\t${safeKey}: ${childLines[0]}`);
+            for (let i = 1; i < childLines.length - 1; i++)
+                l.push(childLines[i] ?? "");
+            l.push(`\t${childLines[childLines.length - 1]},`);
+        }
+    }
+    l.push("} as const");
+    l.push("");
+    return l.join("\n");
+}
+function buildSDKIndex(sdkName, stem) {
+    const n = sdkName;
+    const l = [];
+    const errorNames = ERROR_EXPORT_NAMES.join(", ");
+    l.push(`import { ${n} as _${n}Impl, ${errorNames} } from "./${stem}.client.gen"`);
+    l.push(`import type { ${n} as _${n}Interface } from "./${stem}.types.gen"`);
+    l.push("");
+    l.push(`/* declaration merge: Proxy-based class acquires typed resource methods */`);
+    l.push(`class ${n}<TThrow extends boolean = false> extends _${n}Impl<TThrow> {}`);
+    l.push(`interface ${n}<TThrow extends boolean = false> extends _${n}Interface<TThrow> {}`);
+    l.push("");
+    l.push(`export { ${n}, ${errorNames} }`);
+    l.push(`export { serviceMap } from "./${stem}.map.gen"`);
+    l.push(`export type { ${n}Config, SDKResult, TypedWebSocket } from "./${stem}.types.gen"`);
+    l.push("");
+    return l.join("\n");
+}
+function buildSDKClient(sdkName, stem) {
+    const n = sdkName;
+    return [
+        sdkClientHeader(n, stem),
+        sdkClientTypes(),
+        sdkClientClientError(),
+        sdkClientClass(n),
+        sdkClientConstructor(n),
+        sdkClientProxy(n),
+        sdkClientInterpolatePath(),
+        sdkClientToColonParams(),
+        sdkClientResolveInvalidationTargets(),
+        sdkClientPathMatchesPattern(),
+        sdkClientLookupStale(),
+        sdkClientCreateTypedWebSocket(),
+        sdkClientSerializeSearch(),
+        sdkClientResolveBaseURL(),
+        sdkClientBuildURL(),
+        sdkClientNewRequestId(),
+        sdkClientBuildHeaders(),
+        sdkClientDoRequest(),
+        sdkClientParseBody(),
+        sdkClientParseErrorBody(),
+        sdkClientParseAsClientError(),
+        sdkClientBuildSignal(),
+        sdkClientRequestThrow(),
+        sdkClientRequestSafe(),
+        sdkClientRequest(),
+        sdkClientRequestSSE(),
+        sdkClientConnectWS(),
+        sdkClientBuildRequestMeta(),
+        sdkClientMarkStale(),
+        sdkClientClearStale(),
+        sdkClientDispose(),
+        sdkClientDoSSE(),
+        sdkClientParseSSEBlock(),
+        sdkClientFooter(),
+    ].join("");
+}
+function buildSDKRuntime() {
+    return `/* ------------------------------------------------------------------ */
+/*  ServerFrame (inlined from protocol — zero external imports)         */
+/* ------------------------------------------------------------------ */
+
+export type ServerFrame =
+\t| { data: unknown; id: number; t: "msg" }
+\t| { t: "pong" }
+\t| { reason: string; t: "bye" }
+\t| { reconnectToken: string; t: "ready" }
+
+/* ------------------------------------------------------------------ */
+/*  Error hierarchy                                                    */
+/* ------------------------------------------------------------------ */
+
+export class RealtimeError extends Error {
+\treadonly reason: string
+
+\tconstructor(message: string, reason: string) {
+\t\tsuper(message)
+\t\tthis.reason = reason
+\t\tthis.name = "RealtimeError"
+\t}
+}
+
+export class RealtimeConnectError extends RealtimeError {
+\tconstructor(message: string, reason: string) {
+\t\tsuper(message, reason)
+\t\tthis.name = "RealtimeConnectError"
+\t}
+}
+
+export class RealtimeAuthError extends RealtimeError {
+\tconstructor(message: string, reason: string) {
+\t\tsuper(message, reason)
+\t\tthis.name = "RealtimeAuthError"
+\t}
+}
+
+export class RealtimeKickedError extends RealtimeError {
+\tconstructor(message: string, reason: string) {
+\t\tsuper(message, reason)
+\t\tthis.name = "RealtimeKickedError"
+\t}
+}
+
+export class RealtimeAbortError extends RealtimeError {
+\tconstructor(message: string, reason: string) {
+\t\tsuper(message, reason)
+\t\tthis.name = "RealtimeAbortError"
+\t}
+}
+
+/* ------------------------------------------------------------------ */
+/*  Types                                                              */
+/* ------------------------------------------------------------------ */
+
+export type Transport = "ws" | "sse" | "longpoll"
+export type ConnectionState = "idle" | "connecting" | "connected" | "draining" | "reconnecting" | "closed"
+
+export type TransportAdapter = {
+\tconnect(url: string, opts: TransportOpts): TransportConnection
+}
+
+export type TransportConnection = {
+\tsend(data: string): void
+\tclose(): void
+\tonFrame: (frame: ServerFrame) => void
+\tonClose: (reason: string) => void
+\tonError: (err: unknown) => void
+}
+
+export type TransportOpts = {
+\tsignal?: AbortSignal
+\theaders?: Record<string, string>
+\tlastId?: number
+\treconnectToken?: string
+}
+
+/* ------------------------------------------------------------------ */
+/*  KeepaliveLoop                                                      */
+/* ------------------------------------------------------------------ */
+
+export function createKeepaliveLoop(opts: {
+\ttransport: Transport
+\tsendPing: () => void
+\tonDead: () => void
+\tinterval?: number
+\ttimeout?: number
+}): { start(): void; stop(): void; onPong(): void; onFrame(): void } {
+\tconst interval = opts.interval ?? 25_000
+\tconst timeout = opts.timeout ?? 60_000
+\tconst transport = opts.transport
+
+\tlet pingTimer: ReturnType<typeof setInterval> | null = null
+\tlet deadTimer: ReturnType<typeof setTimeout> | null = null
+
+\tfunction clearAll(): void {
+\t\tif (pingTimer !== null) {
+\t\t\tclearInterval(pingTimer)
+\t\t\tpingTimer = null
+\t\t}
+\t\tif (deadTimer !== null) {
+\t\t\tclearTimeout(deadTimer)
+\t\t\tdeadTimer = null
+\t\t}
+\t}
+
+\tfunction resetDeadTimer(): void {
+\t\tif (deadTimer !== null) {
+\t\t\tclearTimeout(deadTimer)
+\t\t}
+\t\tdeadTimer = setTimeout(() => {
+\t\t\topts.onDead()
+\t\t}, timeout)
+\t}
+
+\tfunction start(): void {
+\t\tclearAll()
+\t\tif (transport === "longpoll") return
+\t\tif (transport === "ws") {
+\t\t\tpingTimer = setInterval(() => {
+\t\t\t\topts.sendPing()
+\t\t\t}, interval)
+\t\t\tresetDeadTimer()
+\t\t\treturn
+\t\t}
+\t\tif (transport === "sse") {
+\t\t\tresetDeadTimer()
+\t\t}
+\t}
+
+\tfunction stop(): void {
+\t\tclearAll()
+\t}
+
+\tfunction onPong(): void {
+\t\tif (deadTimer !== null) {
+\t\t\tresetDeadTimer()
+\t\t}
+\t}
+
+\tfunction onFrame(): void {
+\t\tif (transport === "sse" && deadTimer !== null) {
+\t\t\tresetDeadTimer()
+\t\t}
+\t}
+
+\treturn { onFrame, onPong, start, stop }
+}
+
+/* ------------------------------------------------------------------ */
+/*  FallbackChain                                                      */
+/* ------------------------------------------------------------------ */
+
+const DEFAULT_FALLBACK_TIMEOUT = 3000
+
+export function createFallbackChain(opts: {
+\ttransports: TransportAdapter[]
+\ttimeout?: number
+}): {
+\tconnect(url: string, transportOpts: TransportOpts): Promise<{ conn: TransportConnection; transport: Transport }>
+\treadonly provenTransport: Transport | null
+} {
+\tconst timeout = opts.timeout ?? DEFAULT_FALLBACK_TIMEOUT
+\tlet proven: Transport | null = null
+\tlet provenIndexStore: number | null = null
+
+\tfunction tryTransport(
+\t\tadapter: TransportAdapter,
+\t\turl: string,
+\t\ttransportOpts: TransportOpts,
+\t): Promise<TransportConnection> {
+\t\treturn new Promise((resolve, reject) => {
+\t\t\tconst conn = adapter.connect(url, transportOpts)
+
+\t\t\tconst timer = setTimeout(() => {
+\t\t\t\tconn.close()
+\t\t\t\treject(new Error("timeout"))
+\t\t\t}, timeout)
+
+\t\t\tconst originalOnFrame = conn.onFrame
+\t\t\tconn.onFrame = (frame: ServerFrame) => {
+\t\t\t\tif (frame.t === "ready") {
+\t\t\t\t\tclearTimeout(timer)
+\t\t\t\t\tconn.onFrame = originalOnFrame
+\t\t\t\t\tresolve(conn)
+\t\t\t\t} else {
+\t\t\t\t\toriginalOnFrame(frame)
+\t\t\t\t}
+\t\t\t}
+
+\t\t\tconn.onError = (err: unknown) => {
+\t\t\t\tclearTimeout(timer)
+\t\t\t\tconn.close()
+\t\t\t\treject(err)
+\t\t\t}
+
+\t\t\tconn.onClose = (reason: string) => {
+\t\t\t\tclearTimeout(timer)
+\t\t\t\treject(new Error(reason))
+\t\t\t}
+\t\t})
+\t}
+
+\tasync function connectInternal(
+\t\turl: string,
+\t\ttransportOpts: TransportOpts,
+\t\ttransports: TransportAdapter[],
+\t): Promise<{ conn: TransportConnection; transport: Transport }> {
+\t\tif (proven !== null) {
+\t\t\tif (provenIndexStore !== null && provenIndexStore < transports.length) {
+\t\t\t\ttry {
+\t\t\t\t\tconst conn = await tryTransport(transports[provenIndexStore], url, transportOpts)
+\t\t\t\t\treturn { conn, transport: proven }
+\t\t\t\t} catch {
+\t\t\t\t\t/* Proven transport failed — fall through to full chain */
+\t\t\t\t}
+\t\t\t}
+\t\t}
+
+\t\tfor (let i = 0; i < transports.length; i++) {
+\t\t\ttry {
+\t\t\t\tconst conn = await tryTransport(transports[i], url, transportOpts)
+\t\t\t\tlet transportName: Transport = "longpoll"
+\t\t\t\tif (i === 0) transportName = "ws"
+\t\t\t\telse if (i === 1) transportName = "sse"
+\t\t\t\tproven = transportName
+\t\t\t\tprovenIndexStore = i
+\t\t\t\treturn { conn, transport: transportName }
+\t\t\t} catch {
+\t\t\t\t/* Try next */
+\t\t\t}
+\t\t}
+
+\t\tthrow new RealtimeConnectError("All transports failed", "all_failed")
+\t}
+
+\tfunction connect(
+\t\turl: string,
+\t\ttransportOpts: TransportOpts,
+\t): Promise<{ conn: TransportConnection; transport: Transport }> {
+\t\tconst transports = opts.transports
+\t\tif (transports.length === 0) {
+\t\t\tconst p = Promise.reject(new RealtimeConnectError("No transports configured", "no_transports"))
+\t\t\tp.catch(() => {})
+\t\t\treturn p
+\t\t}
+\t\tconst p = connectInternal(url, transportOpts, transports)
+\t\tp.catch(() => {})
+\t\treturn p
+\t}
+
+\treturn {
+\t\tconnect,
+\t\tget provenTransport() {
+\t\t\treturn proven
+\t\t},
+\t}
+}
+
+/* ------------------------------------------------------------------ */
+/*  ResumableConnection                                                */
+/* ------------------------------------------------------------------ */
+
+export type ResumableConnectionOpts = {
+\turl: string
+\ttransports: TransportAdapter[]
+\ttoken?: () => string | Promise<string>
+\t/** 401 on a request: return a fresh token to retry it once (null = give up). \`rejectedToken\` is the token that failed, so concurrent 401s can share one refresh. */\n\tonAuthExpired?: (ctx: { rejectedToken: string | null }) => Promise<string | null>
+\tonReconnecting?: (attempt: number, transport: Transport) => void
+\tonReconnected?: () => void
+\tsignal?: AbortSignal
+\tkeepaliveInterval?: number
+\treconnectDelayMs?: number
+\tmaxReconnectAttempts?: number
+\tfallbackTimeout?: number
+\theaders?: Record<string, string>
+\treconnectToken?: string
+\tlastId?: number
+}
+
+type QueueEntry =
+\t| { type: "value"; value: unknown }
+\t| { type: "done" }
+\t| { type: "error"; error: unknown }
+
+export function createResumableConnection(opts: ResumableConnectionOpts): {
+\treadonly state: ConnectionState
+\treadonly provenTransport: Transport | null
+\tsend(data: unknown): void
+\tclose(reason?: string): void
+\t[Symbol.asyncIterator](): AsyncIterableIterator<unknown>
+} {
+\tconst reconnectDelayMs = opts.reconnectDelayMs ?? 1000
+\tconst maxReconnectAttempts = opts.maxReconnectAttempts ?? 5
+\tconst fallbackTimeout = opts.fallbackTimeout ?? 3000
+\tlet state: ConnectionState = "idle"
+\tlet currentConn: TransportConnection | null = null
+\tlet reconnectAttempts = 0
+\tlet provenIndex: number | null = null
+\tlet lastId: number | undefined = opts.lastId
+\tlet reconnectToken: string | undefined = opts.reconnectToken
+\tlet started = false
+\tlet closed = false
+
+\tfunction indexToTransport(i: number): Transport {
+\t\tif (i === 0) return "ws"
+\t\tif (i === 1) return "sse"
+\t\treturn "longpoll"
+\t}
+
+\tif (opts.signal?.aborted) {
+\t\tstate = "closed"
+\t\tclosed = true
+\t}
+
+\tconst queue: QueueEntry[] = []
+\tlet pending: {
+\t\tresolve: (result: IteratorResult<unknown>) => void
+\t\treject: (err: unknown) => void
+\t} | null = null
+
+\tfunction enqueue(entry: QueueEntry): void {
+\t\tif (pending) {
+\t\t\tconst { resolve, reject } = pending
+\t\t\tpending = null
+\t\t\tif (entry.type === "value") {
+\t\t\t\tresolve({ done: false, value: entry.value })
+\t\t\t} else if (entry.type === "done") {
+\t\t\t\tresolve({ done: true, value: undefined })
+\t\t\t} else {
+\t\t\t\treject(entry.error)
+\t\t\t}
+\t\t} else {
+\t\t\tqueue.push(entry)
+\t\t}
+\t}
+
+\tfunction detachConn(): void {
+\t\tif (!currentConn) return
+\t\tconst conn = currentConn
+\t\tcurrentConn = null
+\t\tconn.onFrame = () => {}
+\t\tconn.onError = () => {}
+\t\tconn.onClose = () => {}
+\t\ttry {
+\t\t\tconn.close()
+\t\t} catch {
+\t\t\t/* swallow — adapter close() is best-effort */
+\t\t}
+\t}
+
+\tfunction handleClose(): void {
+\t\tif (state === "closed") return
+\t\tstate = "closed"
+\t\tclosed = true
+\t\tdetachConn()
+\t\tenqueue({ type: "done" })
+\t}
+
+\tfunction handleAbort(): void {
+\t\tif (state === "closed") return
+\t\tstate = "closed"
+\t\tclosed = true
+\t\tdetachConn()
+\t\tenqueue({ error: new RealtimeAbortError("Connection aborted", "aborted"), type: "error" })
+\t}
+
+\tif (opts.signal && !opts.signal.aborted) {
+\t\topts.signal.addEventListener("abort", () => {
+\t\t\thandleAbort()
+\t\t}, { once: true })
+\t}
+
+\t/* tryAdapterAt dials a single adapter and wires its onFrame/onError/onClose
+\t * straight into the resumable queue + reconnect loop the moment the adapter
+\t * returns. No post-ready re-wire hop — frames that arrive between ready and
+\t * the caller's await-continuation can't be lost. Resolves when ready frame
+\t * seen, rejects on error/close/timeout. */
+\tfunction tryAdapterAt(index: number): Promise<TransportConnection> {
+\t\treturn new Promise((resolve, reject) => {
+\t\t\tconst adapter = opts.transports[index]
+\t\t\tif (!adapter) {
+\t\t\t\treject(new RealtimeConnectError("adapter index out of range", "no_adapter"))
+\t\t\t\treturn
+\t\t\t}
+\t\t\tconst transportOpts: TransportOpts = {
+\t\t\t\theaders: opts.headers,
+\t\t\t\tlastId,
+\t\t\t\treconnectToken,
+\t\t\t\tsignal: opts.signal,
+\t\t\t}
+\t\t\tconst conn = adapter.connect(opts.url, transportOpts)
+\t\t\tlet ready = false
+\t\t\tconst timer = setTimeout(() => {
+\t\t\t\tif (ready) return
+\t\t\t\ttry { conn.close() } catch { /* ignore */ }
+\t\t\t\treject(new RealtimeConnectError("transport open timeout", "timeout"))
+\t\t\t}, fallbackTimeout)
+\t\t\tconn.onFrame = (frame: ServerFrame) => {
+\t\t\t\tif (!ready && frame.t === "ready") {
+\t\t\t\t\tready = true
+\t\t\t\t\tclearTimeout(timer)
+\t\t\t\t\treconnectToken = frame.reconnectToken
+\t\t\t\t\tresolve(conn)
+\t\t\t\t\treturn
+\t\t\t\t}
+\t\t\t\tif (frame.t === "msg") {
+\t\t\t\t\tlastId = frame.id
+\t\t\t\t\tenqueue({ type: "value", value: frame.data })
+\t\t\t\t\treturn
+\t\t\t\t}
+\t\t\t\tif (frame.t === "ready") {
+\t\t\t\t\treconnectToken = frame.reconnectToken
+\t\t\t\t\treturn
+\t\t\t\t}
+\t\t\t\tif (frame.t === "bye") {
+\t\t\t\t\tif (ready) {
+\t\t\t\t\t\tdetachConn()
+\t\t\t\t\t\tscheduleReconnect(new RealtimeError("server closed connection: " + frame.reason, "bye"))
+\t\t\t\t\t}
+\t\t\t\t\treturn
+\t\t\t\t}
+\t\t\t}
+\t\t\tconn.onError = (err: unknown) => {
+\t\t\t\tclearTimeout(timer)
+\t\t\t\tif (!ready) {
+\t\t\t\t\ttry { conn.close() } catch { /* ignore */ }
+\t\t\t\t\treject(err)
+\t\t\t\t\treturn
+\t\t\t\t}
+\t\t\t\tdetachConn()
+\t\t\t\tscheduleReconnect(err)
+\t\t\t}
+\t\t\tconn.onClose = (reason: string) => {
+\t\t\t\tclearTimeout(timer)
+\t\t\t\tif (!ready) {
+\t\t\t\t\treject(new RealtimeConnectError("transport closed before ready: " + reason, "closed_early"))
+\t\t\t\t\treturn
+\t\t\t\t}
+\t\t\t\tdetachConn()
+\t\t\t\tscheduleReconnect(new RealtimeError("transport closed: " + reason, "closed"))
+\t\t\t}
+\t\t})
+\t}
+
+\tasync function openChain(): Promise<void> {
+\t\tif (opts.transports.length === 0) {
+\t\t\tthrow new RealtimeConnectError("No transports configured", "no_transports")
+\t\t}
+\t\t/* Try proven first if memoized */
+\t\tif (provenIndex !== null && provenIndex < opts.transports.length) {
+\t\t\ttry {
+\t\t\t\tconst conn = await tryAdapterAt(provenIndex)
+\t\t\t\tcurrentConn = conn
+\t\t\t\treturn
+\t\t\t} catch {
+\t\t\t\t/* fall through to full chain */
+\t\t\t}
+\t\t}
+\t\tlet lastErr: unknown = null
+\t\tfor (let i = 0; i < opts.transports.length; i++) {
+\t\t\ttry {
+\t\t\t\tconst conn = await tryAdapterAt(i)
+\t\t\t\tprovenIndex = i
+\t\t\t\tcurrentConn = conn
+\t\t\t\treturn
+\t\t\t} catch (err) {
+\t\t\t\tlastErr = err
+\t\t\t}
+\t\t}
+\t\tthrow lastErr ?? new RealtimeConnectError("All transports failed", "all_failed")
+\t}
+
+\tfunction scheduleReconnect(_err: unknown): void {
+\t\tif (closed) return
+\t\treconnectAttempts += 1
+\t\tif (maxReconnectAttempts > 0 && reconnectAttempts > maxReconnectAttempts) {
+\t\t\tstate = "closed"
+\t\t\tclosed = true
+\t\t\tenqueue({ type: "done" })
+\t\t\treturn
+\t\t}
+\t\tstate = "reconnecting"
+\t\t/* invalidate proven — a drop means that transport isn't healthy */
+\t\tprovenIndex = null
+\t\tif (opts.onReconnecting) {
+\t\t\ttry {
+\t\t\t\topts.onReconnecting(reconnectAttempts, indexToTransport(provenIndex ?? 0))
+\t\t\t} catch {
+\t\t\t\t/* user callback must not break the loop */
+\t\t\t}
+\t\t}
+\t\tsetTimeout(() => {
+\t\t\tif (closed) return
+\t\t\tvoid connectOnce()
+\t\t}, reconnectDelayMs)
+\t}
+
+\tasync function connectOnce(): Promise<void> {
+\t\tif (closed) return
+\t\tif (state === "idle" || state === "closed") state = "connecting"
+\t\ttry {
+\t\t\tawait openChain()
+\t\t\tif (closed) {
+\t\t\t\tdetachConn()
+\t\t\t\treturn
+\t\t\t}
+\t\t\tstate = "connected"
+\t\t\treconnectAttempts = 0
+\t\t\tif (opts.onReconnected) {
+\t\t\t\ttry { opts.onReconnected() } catch { /* user cb */ }
+\t\t\t}
+\t\t} catch (err) {
+\t\t\tscheduleReconnect(err)
+\t\t}
+\t}
+
+\tfunction startConnection(): void {
+\t\tif (started || closed) return
+\t\tstarted = true
+\t\tstate = "connecting"
+\t\tvoid connectOnce()
+\t}
+
+\tfunction send(data: unknown): void {
+\t\tif (closed || !currentConn) return
+\t\tcurrentConn.send(JSON.stringify(data))
+\t}
+
+\tfunction close(_reason?: string): void {
+\t\thandleClose()
+\t}
+
+\tfunction next(): Promise<IteratorResult<unknown>> {
+\t\tif (!started && !closed) {
+\t\t\tstartConnection()
+\t\t}
+\t\tif (queue.length > 0) {
+\t\t\tconst entry = queue.shift()
+\t\t\tif (!entry || entry.type === "done") {
+\t\t\t\treturn Promise.resolve({ done: true, value: undefined })
+\t\t\t}
+\t\t\tif (entry.type === "value") {
+\t\t\t\treturn Promise.resolve({ done: false, value: entry.value })
+\t\t\t}
+\t\t\treturn Promise.reject(entry.error)
+\t\t}
+\t\tif (closed) {
+\t\t\treturn Promise.resolve({ done: true, value: undefined })
+\t\t}
+\t\tconst promise = new Promise<IteratorResult<unknown>>((resolve, reject) => {
+\t\t\tpending = { reject, resolve }
+\t\t})
+\t\tpromise.catch(() => {})
+\t\treturn promise
+\t}
+
+\tfunction asyncIterator(): AsyncIterableIterator<unknown> {
+\t\treturn {
+\t\t\tnext,
+\t\t\t[Symbol.asyncIterator]() {
+\t\t\t\treturn this
+\t\t\t},
+\t\t}
+\t}
+
+\treturn {
+\t\t[Symbol.asyncIterator]: asyncIterator,
+\t\tclose,
+\t\tget provenTransport() {
+\t\t\treturn provenIndex === null ? null : indexToTransport(provenIndex)
+\t\t},
+\t\tsend,
+\t\tget state() {
+\t\t\treturn state
+\t\t},
+\t}
+}
+`;
+}
+function sdkClientHeader(n, stem) {
+    return `import type { ${n}Config } from "./${stem}.types.gen"
+import { serviceMap } from "./${stem}.map.gen"
+`;
+}
+function sdkClientTypes() {
+    return `
+type _SSEEvent = { data: string; event?: string; id?: string; retry?: number }
+
+type _TypedWebSocket = {
+\tclose(code?: number, reason?: string): void
+\toff(event: "close" | "error" | "message" | "open", handler: (...args: never[]) => void): void
+\ton(event: "close", handler: (code: number, reason: string) => void): void
+\ton(event: "error", handler: (error: unknown) => void): void
+\ton(event: "message", handler: (data: string) => void): void
+\ton(event: "open", handler: () => void): void
+\treadonly readyState: number
+\tsend(data: ArrayBuffer | ArrayBufferView | object | string): void
+}
+
+type _ServiceEntry = {
+\tidempotent?: boolean
+\tinvalidate?: readonly string[]
+\tmethod: string
+\tparams?: readonly string[]
+\tpath: string
+\tsse?: boolean
+\twildcard?: string
+\tws?: boolean
+}
+
+type _ServiceMapNode = _ServiceEntry | { [key: string]: _ServiceMapNode }
+type _ServiceMap = { [key: string]: _ServiceMapNode }
+
+type _RequestOptions = {
+\tbody?: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array
+\tcookies?: Record<string, string>
+\tform?: Record<string, unknown>
+\theaders?: Record<string, string>
+\tidempotencyKey?: string
+\tjson?: unknown
+\tlastEventId?: string
+\tparams?: Record<string, string>
+\tprotocols?: string | string[]
+\treconnectToken?: string
+\tsearch?: Record<string, unknown>
+\tsignal?: AbortSignal
+\ttimeout?: number
+}
+
+type _RequestMeta = {
+\tinvalidatedBy: string[]
+\tisStale: boolean
+\tselector: string
+\tseqSnapshot: number
+}
+
+type _StaleEntry = { by: string[]; refreshed?: Set<string>; seq: number; until: number }
+
+/* a path parameter value that would change the request's path once a URL parser normalizes it */
+class _PathParamError extends Error {
+\tconstructor(message: string) {
+\t\tsuper(message)
+\t\tthis.name = "PathParamError"
+\t}
+}
+`;
+}
+function sdkClientClientError() {
+    const subclassDecls = STATUS_ERROR_CLASSES.map(({ name }) => `class _${name} extends _ClientError { constructor(init: ConstructorParameters<typeof _ClientError>[0]) { super(init); this.name = "${name}" } }`).join("\n");
+    const mapEntries = STATUS_ERROR_CLASSES.map(({ name, status }) => `\t${status}: _${name},`).join("\n");
+    return `
+class _ClientError extends Error {
+\treadonly body: unknown
+\treadonly data: unknown
+\treadonly response: Response
+\treadonly status: number
+
+\tconstructor(init: { body: unknown; data: unknown; message: string; response: Response; status: number }) {
+\t\tsuper(init.message)
+\t\t;(Error as unknown as { captureStackTrace?: (t: object, c: Function) => void }).captureStackTrace?.(this, _ClientError)
+\t\tthis.name = "ClientError"
+\t\tthis.body = init.body
+\t\tthis.data = init.data
+\t\tthis.response = init.response
+\t\tthis.status = init.status
+\t}
+}
+
+${subclassDecls}
+
+const _STATUS_ERROR_MAP: Record<number, new (init: ConstructorParameters<typeof _ClientError>[0]) => _ClientError> = {
+${mapEntries}
+}
+`;
+}
+function sdkClientClass(n) {
+    return `
+export class ${n}<TThrow extends boolean = false> {
+\tstate: Record<string, unknown>
+\t#config: ${n}Config<TThrow>
+\t#fetchFn: typeof fetch
+\t#resourceCache = new Map<string, Record<string, unknown>>()
+\t#searchSerializer: (query: Record<string, unknown>) => URLSearchParams
+\t#staleTime: number
+\t#staleUntil: Map<string, _StaleEntry> | null
+\t#stalePatterns = new Map<string, Map<string, _StaleEntry>>()
+\t#patternRegexCache = new Map<string, RegExp>()
+\t#invalidationSeq = 0
+\t#staleMaxEntries: number
+\t#maxSourcesPerTarget: number
+\t#maxErrorMessageChars: number
+\t#sseMaxBufferChars: number
+\t#disposeCtrl = new AbortController()
+\t#disposed = false
+\t#refreshing: Promise<string | null> | null = null
+\t#token: string | null = null
+`;
+}
+function sdkClientConstructor(n) {
+    return `
+\tconstructor(config: ${n}Config<TThrow>) {
+\t\tconst ownState = config.state ?? {}
+\t\tthis.state = ownState
+\t\tthis.#config = { ...config, state: ownState }
+\t\tthis.#fetchFn = config.fetch ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : globalThis.fetch)
+\t\tthis.#searchSerializer = config.buildSearchParams ?? ((q: Record<string, unknown>) => this.#serializeSearch(q))
+\t\tthis.#staleTime = config.invalidation?.staleTime ?? 0
+\t\tthis.#staleUntil = this.#staleTime > 0 ? new Map<string, _StaleEntry>() : null
+\t\tthis.#staleMaxEntries = config.invalidation?.staleMaxEntries ?? 1000
+\t\tthis.#maxSourcesPerTarget = Math.max(config.invalidation?.maxSourcesPerTarget ?? 16, 1)
+\t\tthis.#maxErrorMessageChars = config.maxErrorMessageChars ?? 512
+\t\tthis.#sseMaxBufferChars = config.sseMaxBufferChars ?? 1024 * 1024
+`;
+}
+function sdkClientProxy(n) {
+    return `
+\t\tconst self = this
+\t\tconst callable = (entry: _ServiceEntry, name: string): ((input?: Record<string, unknown>) => unknown) => {
+\t\t\tconst entryPath = self.#toColonParams(entry.path, entry.wildcard)
+\t\t\tlet fn: (input?: Record<string, unknown>) => unknown
+\t\t\tif (entry.ws) {
+\t\t\t\tfn = (input?: Record<string, unknown>) => self.#connectWS(entry, entryPath, (input ?? {}) as _RequestOptions)
+\t\t\t} else if (entry.sse) {
+\t\t\t\tfn = (input?: Record<string, unknown>) => self.#requestSSE(entry, entryPath, (input ?? {}) as _RequestOptions)
+\t\t\t} else {
+\t\t\t\tfn = (input?: Record<string, unknown>) => self.#request(entry, input ?? {})
+\t\t\t}
+\t\t\tObject.defineProperty(fn, "name", { value: name })
+\t\t\treturn fn
+\t\t}
+\t\tconst isEntry = (node: unknown): node is _ServiceEntry =>
+\t\t\ttypeof node === "object" && node !== null && Object.hasOwn(node, "method") && typeof (node as Record<string, unknown>)["method"] === "string"
+\t\t/* only the map's own keys are operations — never toString, constructor or then */
+\t\tconst childOf = (node: _ServiceMapNode, key: string): _ServiceMapNode | undefined =>
+\t\t\tObject.hasOwn(node, key) ? (node as Record<string, _ServiceMapNode>)[key] : undefined
+
+\t\tfunction makeNodeProxy(node: _ServiceMapNode, path: string[]): object {
+\t\t\tconst actionCache = new Map<string, (input?: Record<string, unknown>) => unknown>()
+\t\t\tconst childCache = new Map<string, object>()
+\t\t\treturn new Proxy({} as Record<string, unknown>, {
+\t\t\t\tget: (target, key: string | symbol) => {
+\t\t\t\t\tif (typeof key === "symbol") return Reflect.get(target, key)
+\t\t\t\t\tconst child = childOf(node, key)
+\t\t\t\t\tif (child === undefined) return Reflect.get(target, key)
+
+\t\t\t\t\tif (isEntry(child)) {
+\t\t\t\t\t\tconst cached = actionCache.get(key)
+\t\t\t\t\t\tif (cached) return cached
+\t\t\t\t\t\tconst fn = callable(child, [...path, key].join("."))
+\t\t\t\t\t\tactionCache.set(key, fn)
+\t\t\t\t\t\treturn fn
+\t\t\t\t\t}
+
+\t\t\t\t\tconst cachedChild = childCache.get(key)
+\t\t\t\t\tif (cachedChild) return cachedChild
+\t\t\t\t\tconst childProxy = makeNodeProxy(child, [...path, key])
+\t\t\t\t\tchildCache.set(key, childProxy)
+\t\t\t\t\treturn childProxy
+\t\t\t\t},
+\t\t\t})
+\t\t}
+
+\t\treturn new Proxy(this, {
+\t\t\tget: (target, key: string | symbol) => {
+\t\t\t\t/* the client's own members (state, dispose, toString, ...) always win */
+\t\t\t\tif (typeof key === "symbol" || key in target) return Reflect.get(target, key)
+
+\t\t\t\tconst cached = target.#resourceCache.get(key)
+\t\t\t\tif (cached) return cached
+
+\t\t\t\tconst node = childOf(serviceMap as _ServiceMap, key)
+\t\t\t\tif (node === undefined) return undefined
+
+\t\t\t\t/* root-level leaf (single-segment operationId) */
+\t\t\t\tif (isEntry(node)) {
+\t\t\t\t\tconst fn = callable(node, key)
+\t\t\t\t\ttarget.#resourceCache.set(key, fn as unknown as Record<string, unknown>)
+\t\t\t\t\treturn fn
+\t\t\t\t}
+
+\t\t\t\t/* namespace node — check for single _call promotion */
+\t\t\t\tconst nodeKeys = Object.keys(node)
+\t\t\t\tconst only = childOf(node, "_call")
+\t\t\t\tif (nodeKeys.length === 1 && only !== undefined && isEntry(only)) {
+\t\t\t\t\tconst fn = callable(only, key)
+\t\t\t\t\ttarget.#resourceCache.set(key, fn as unknown as Record<string, unknown>)
+\t\t\t\t\treturn fn
+\t\t\t\t}
+
+\t\t\t\tconst proxy = makeNodeProxy(node, [key])
+\t\t\t\ttarget.#resourceCache.set(key, proxy as Record<string, unknown>)
+\t\t\t\treturn proxy
+\t\t\t},
+\t\t}) as ${n}<TThrow>
+\t}
+`;
+}
+function sdkClientInterpolatePath() {
+    return `
+\t/* Keep in sync with client/path.ts — :name (whole segment), *name (rest), {name} (inside a segment). */
+\t#encodeSegmentValue(key: string, value: string): string {
+\t\tif (value === "" || value === "." || value === "..") {
+\t\t\tthrow new _PathParamError(\`Invalid path param \${JSON.stringify(key)}: \${JSON.stringify(value)} is not a path segment\`)
+\t\t}
+\t\treturn encodeURIComponent(value)
+\t}
+
+\t#encodeWildcardValue(key: string, value: string): string {
+\t\tif (value === "") return ""
+\t\treturn value.split("/").map((part) => this.#encodeSegmentValue(key, part)).join("/")
+\t}
+
+\t#paramValue(params: Record<string, string> | undefined, key: string): string | undefined {
+\t\tif (!params || !Object.hasOwn(params, key)) return undefined
+\t\tconst raw = params[key] as unknown
+\t\tif (raw === undefined || raw === null) return undefined
+\t\treturn typeof raw === "string" ? raw : String(raw)
+\t}
+
+\t#interpolatePath(path: string, params: Record<string, string> | undefined, partial = false): string {
+\t\tconst segments = path.split("/")
+\t\tconst out: string[] = []
+\t\tfor (let i = 0; i < segments.length; i++) {
+\t\t\tconst seg = segments[i] ?? ""
+\t\t\tif (seg.length > 1 && seg.charCodeAt(0) === 58) {
+\t\t\t\tconst optional = seg.endsWith("?")
+\t\t\t\tconst name = optional ? seg.slice(1, -1) : seg.slice(1)
+\t\t\t\tconst value = this.#paramValue(params, name)
+\t\t\t\tif (value === undefined) {
+\t\t\t\t\tif (partial) { out.push(seg); continue }
+\t\t\t\t\tif (optional) continue
+\t\t\t\t\tthrow new _PathParamError(\`Missing path param: \${name}\`)
+\t\t\t\t}
+\t\t\t\tout.push(this.#encodeSegmentValue(name, value))
+\t\t\t\tcontinue
+\t\t\t}
+\t\t\tif (seg.charCodeAt(0) === 42 && i === segments.length - 1) {
+\t\t\t\tconst name = seg.length > 1 ? seg.slice(1) : "*"
+\t\t\t\tconst value = this.#paramValue(params, name)
+\t\t\t\tif (value === undefined) {
+\t\t\t\t\tif (partial) { out.push(seg); continue }
+\t\t\t\t\tif (seg.length === 1) { out.push(""); continue }
+\t\t\t\t\tthrow new _PathParamError(\`Missing path param: \${name}\`)
+\t\t\t\t}
+\t\t\t\tout.push(this.#encodeWildcardValue(name, value))
+\t\t\t\tcontinue
+\t\t\t}
+\t\t\tout.push(
+\t\t\t\tseg.replace(/\\{([^{}/]+)\\}/g, (match: string, name: string) => {
+\t\t\t\t\tconst value = this.#paramValue(params, name)
+\t\t\t\t\tif (value === undefined) {
+\t\t\t\t\t\tif (partial) return match
+\t\t\t\t\t\tthrow new _PathParamError(\`Missing path param: \${name}\`)
+\t\t\t\t\t}
+\t\t\t\t\treturn this.#encodeSegmentValue(name, value)
+\t\t\t\t}),
+\t\t\t)
+\t\t}
+\t\treturn out.join("/")
+\t}
+
+\t#hasPlaceholder(path: string): boolean {
+\t\tfor (const seg of path.split("/")) {
+\t\t\tif (seg.length > 1 && seg.charCodeAt(0) === 58) return true
+\t\t\tif (seg.charCodeAt(0) === 42) return true
+\t\t\tif (/\\{[^{}/]+\\}/.test(seg)) return true
+\t\t}
+\t\treturn false
+\t}
+`;
+}
+function sdkClientToColonParams() {
+    return `
+\t/* OpenAPI template → route pattern: a whole-segment {name} is :name, the wildcard *name; {name} inside a segment stays */
+\t#toColonParams(path: string, wildcard?: string): string {
+\t\treturn path
+\t\t\t.split("/")
+\t\t\t.map((seg) => {
+\t\t\t\tconst m = /^\\{([^{}/]+)\\}$/.exec(seg)
+\t\t\t\tif (!m) return seg
+\t\t\t\treturn m[1] === wildcard ? \`*\${m[1]}\` : \`:\${m[1]}\`
+\t\t\t})
+\t\t\t.join("/")
+\t}
+`;
+}
+function sdkClientResolveInvalidationTargets() {
+    return `
+\t/* params that are present are substituted; a target left partly unresolved stays a narrower pattern */
+\t#resolveInvalidationTargets(
+\t\ttargets: readonly string[],
+\t\tparams: Record<string, string> | undefined,
+\t): string[] {
+\t\tconst resolved: string[] = []
+\t\tfor (const target of targets) {
+\t\t\tconst spaceIdx = target.indexOf(" ")
+\t\t\tif (spaceIdx <= 0) continue
+\t\t\tconst targetMethod = target.slice(0, spaceIdx)
+\t\t\tconst targetPath = target.slice(spaceIdx + 1)
+\t\t\ttry {
+\t\t\t\tresolved.push(\`\${targetMethod} \${this.#interpolatePath(targetPath, params, true)}\`)
+\t\t\t} catch {
+\t\t\t\t/* a param value that is not a path segment marks nothing */
+\t\t\t}
+\t\t}
+\t\treturn resolved
+\t}
+`;
+}
+function sdkClientPathMatchesPattern() {
+    return `
+\t#pathMatchesPattern(concretePath: string, pattern: string): boolean {
+\t\tlet re = this.#patternRegexCache.get(pattern)
+\t\tif (!re) {
+\t\t\tconst esc = (text: string) => text.replace(/[.*+?^\${}()|[\\]\\\\]/g, "\\\\$&")
+\t\t\tconst segments = pattern.split("/")
+\t\t\tlet source = ""
+\t\t\tfor (let i = 0; i < segments.length; i++) {
+\t\t\t\tconst seg = segments[i] ?? ""
+\t\t\t\tconst sep = i === 0 ? "" : "/"
+\t\t\t\tif (seg.length > 1 && seg.charCodeAt(0) === 58) {
+\t\t\t\t\tsource += seg.endsWith("?") ? \`(?:\${sep}[^/]+)?\` : \`\${sep}[^/]+\`
+\t\t\t\t\tcontinue
+\t\t\t\t}
+\t\t\t\tif (seg.charCodeAt(0) === 42 && i === segments.length - 1) {
+\t\t\t\t\tsource += \`(?:\${sep}.*)?\`
+\t\t\t\t\tcontinue
+\t\t\t\t}
+\t\t\t\tsource += sep + seg.split(/\\{[^{}/]+\\}/).map(esc).join("[^/]+")
+\t\t\t}
+\t\t\tre = new RegExp(\`^\${source}$\`)
+\t\t\tif (this.#patternRegexCache.size >= 1024) {
+\t\t\t\tconst oldest = this.#patternRegexCache.keys().next().value
+\t\t\t\tif (oldest !== undefined) this.#patternRegexCache.delete(oldest)
+\t\t\t}
+\t\t\tthis.#patternRegexCache.set(pattern, re)
+\t\t}
+\t\treturn re.test(concretePath)
+\t}
+`;
+}
+function sdkClientLookupStale() {
+    return `
+\t/* Keep in sync with client/sdk.ts StaleIndex — exact keys and pattern keys are kept apart, so a
+\t   concrete path containing ":" is never read as a pattern, and a lookup scans only its method. */
+\t#lookupStale(
+\t\tconcreteSelector: string,
+\t\tconcretePath: string,
+\t\tmethod: string,
+\t\tnow: number,
+\t): { by: string[]; isStale: boolean } {
+\t\tconst by = new Set<string>()
+\t\tconst exact = this.#staleUntil?.get(concreteSelector)
+\t\tif (exact) {
+\t\t\tif (exact.until > now) for (const m of exact.by) by.add(m)
+\t\t\telse this.#staleUntil?.delete(concreteSelector)
+\t\t}
+\t\tconst table = this.#stalePatterns.get(method)
+\t\tif (table) {
+\t\t\tfor (const [key, entry] of table) {
+\t\t\t\tif (entry.until <= now) { table.delete(key); continue }
+\t\t\t\tif (entry.refreshed?.has(concretePath)) continue
+\t\t\t\tif (this.#pathMatchesPattern(concretePath, key.slice(key.indexOf(" ") + 1))) {
+\t\t\t\t\tfor (const m of entry.by) by.add(m)
+\t\t\t\t}
+\t\t\t}
+\t\t}
+\t\treturn { by: [...by], isStale: by.size > 0 }
+\t}
+`;
+}
+function sdkClientCreateTypedWebSocket() {
+    return `
+\t#createTypedWebSocket(url: string, protocols?: string | string[]): _TypedWebSocket {
+\t\tconst ws = protocols ? new WebSocket(url, protocols) : new WebSocket(url)
+\t\t/* keyed by event and handler: one function may listen to several events */
+\t\tconst listenerMap = new Map<string, WeakMap<(...args: never[]) => void, EventListener>>()
+\t\tconst sendBuffer: Array<ArrayBuffer | ArrayBufferView | string> = []
+\t\tlet buffering = true
+
+\t\tws.addEventListener("open", () => {
+\t\t\tbuffering = false
+\t\t\tfor (const msg of sendBuffer) ws.send(msg as Parameters<WebSocket["send"]>[0])
+\t\t\tsendBuffer.length = 0
+\t\t})
+\t\t/* a socket that never opens must not hold messages forever */
+\t\tconst drop = () => {
+\t\t\tbuffering = false
+\t\t\tsendBuffer.length = 0
+\t\t}
+\t\tws.addEventListener("close", drop)
+\t\tws.addEventListener("error", drop)
+
+\t\tfunction close(code?: number, reason?: string) {
+\t\t\tdrop()
+\t\t\tws.close(code, reason)
+\t\t}
+
+\t\tfunction on(event: string, handler: (...args: never[]) => void): void {
+\t\t\tlet wrapped: EventListener
+\t\t\tswitch (event) {
+\t\t\t\tcase "message":
+\t\t\t\t\twrapped = (e: Event) => (handler as (data: unknown) => void)((e as MessageEvent).data)
+\t\t\t\t\tbreak
+\t\t\t\tcase "open":
+\t\t\t\t\twrapped = () => (handler as () => void)()
+\t\t\t\t\tbreak
+\t\t\t\tcase "close":
+\t\t\t\t\twrapped = (e: Event) => (handler as (code: number, reason: string) => void)((e as CloseEvent).code, (e as CloseEvent).reason)
+\t\t\t\t\tbreak
+\t\t\t\tcase "error":
+\t\t\t\t\twrapped = (e: Event) => (handler as (error: unknown) => void)(e)
+\t\t\t\t\tbreak
+\t\t\t\tdefault:
+\t\t\t\t\treturn
+\t\t\t}
+\t\t\tlet byHandler = listenerMap.get(event)
+\t\t\tif (!byHandler) {
+\t\t\t\tbyHandler = new WeakMap()
+\t\t\t\tlistenerMap.set(event, byHandler)
+\t\t\t}
+\t\t\tbyHandler.set(handler, wrapped)
+\t\t\tws.addEventListener(event, wrapped)
+\t\t}
+
+\t\tfunction off(event: string, handler: (...args: never[]) => void): void {
+\t\t\tconst byHandler = listenerMap.get(event)
+\t\t\tconst wrapped = byHandler?.get(handler)
+\t\t\tif (wrapped) {
+\t\t\t\tws.removeEventListener(event, wrapped)
+\t\t\t\tbyHandler?.delete(handler)
+\t\t\t}
+\t\t}
+
+\t\tfunction send(data: ArrayBuffer | ArrayBufferView | object | string) {
+\t\t\tlet payload: ArrayBuffer | ArrayBufferView | string | Blob
+\t\t\tif (typeof data === "string") {
+\t\t\t\tpayload = data
+\t\t\t} else if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+\t\t\t\tpayload = data
+\t\t\t} else if (typeof Blob !== "undefined" && data instanceof Blob) {
+\t\t\t\tpayload = data
+\t\t\t} else {
+\t\t\t\tpayload = JSON.stringify(data)
+\t\t\t}
+\t\t\tif (buffering) { sendBuffer.push(payload as ArrayBuffer | ArrayBufferView | string) } else if (ws.readyState === 1) { ws.send(payload as Parameters<WebSocket["send"]>[0]) }
+\t\t}
+
+\t\tconst typed: _TypedWebSocket = { close, off, on, get readyState() { return ws.readyState }, send }
+\t\tObject.defineProperty(typed, "_ws", { enumerable: false, value: ws })
+\t\treturn typed
+\t}
+`;
+}
+function sdkClientSerializeSearch() {
+    return `
+\t#serializeSearch(query: Record<string, unknown>): URLSearchParams {
+\t\tconst params = new URLSearchParams()
+\t\tconst coerce = (v: unknown): string | null => {
+\t\t\tif (v === undefined || v === null) return null
+\t\t\tif (v instanceof Date) return v.toISOString()
+\t\t\tif (typeof v === "symbol") return null
+\t\t\treturn String(v)
+\t\t}
+\t\tfor (const [k, v] of Object.entries(query)) {
+\t\t\tif (Array.isArray(v)) {
+\t\t\t\tfor (const item of v) { const s = coerce(item); if (s !== null) params.append(k, s) }
+\t\t\t} else {
+\t\t\t\tconst s = coerce(v); if (s !== null) params.set(k, s)
+\t\t\t}
+\t\t}
+\t\treturn params
+\t}
+`;
+}
+/* Keep in sync with client/defaults.ts — generated SDKs have zero runtime imports. */
+function sdkClientResolveBaseURL() {
+    return `
+	#resolveBaseURL(baseURL: string): URL {
+		if (/^(?:https?|wss?):\\/\\//i.test(baseURL)) return new URL(baseURL)
+		let origin: unknown
+		try {
+			origin = globalThis.location?.origin
+		} catch {
+			origin = undefined
+		}
+		if (typeof origin === "string" && origin !== "" && origin !== "null" && /^(?:https?|wss?):\\/\\//i.test(origin)) {
+			try {
+				return new URL(baseURL, origin)
+			} catch {
+				throw new Error(\`Invalid baseURL \${JSON.stringify(baseURL)}: expected an absolute http(s): or ws(s): URL. Path-only values such as "/api" resolve against location.origin in browsers.\`)
+			}
+		}
+		throw new Error(\`Invalid baseURL \${JSON.stringify(baseURL)}: expected an absolute http(s): or ws(s): URL. Path-only values such as "/api" resolve against location.origin in browsers.\`)
+	}
+`;
+}
+function sdkClientBuildURL() {
+    return `
+\t#buildURL(path: string, opts: _RequestOptions): string {
+\t\tconst resolvedPath = this.#interpolatePath(path, opts.params)
+\t\tconst baseUrl = this.#resolveBaseURL(this.#config.baseURL)
+\t\tconst basePath = baseUrl.pathname.endsWith("/") ? baseUrl.pathname : \`\${baseUrl.pathname}/\`
+\t\tconst relative = resolvedPath.startsWith("/") ? resolvedPath.slice(1) : resolvedPath
+\t\tconst url = new URL(\`\${basePath}\${relative}\`, baseUrl)
+\t\t/* a request (and its credentials) never leaves the configured origin */
+\t\tif (url.origin !== baseUrl.origin) {
+\t\t\tthrow new _PathParamError(\`Invalid path param: \${JSON.stringify(path)} resolves outside \${baseUrl.origin}\`)
+\t\t}
+\t\tfor (const [k, v] of baseUrl.searchParams.entries()) url.searchParams.append(k, v)
+\t\tif (opts.search) {
+\t\t\tconst sp = this.#searchSerializer(opts.search)
+\t\t\tif (this.#config.sortSearchParams) sp.sort()
+\t\t\tfor (const [k, v] of sp.entries()) url.searchParams.append(k, v)
+\t\t}
+\t\treturn url.toString()
+\t}
+`;
+}
+function sdkClientNewRequestId() {
+    return `
+\t#newRequestId(): string {
+\t\tconst c = globalThis.crypto as Crypto | undefined
+\t\tif (c && typeof c.randomUUID === "function") return c.randomUUID()
+\t\tif (c && typeof c.getRandomValues === "function") {
+\t\t\tconst bytes = new Uint8Array(16)
+\t\t\tc.getRandomValues(bytes)
+\t\t\tbytes[6] = (bytes[6]! & 0x0f) | 0x40
+\t\t\tbytes[8] = (bytes[8]! & 0x3f) | 0x80
+\t\t\tlet out = ""
+\t\t\tfor (let i = 0; i < 16; i++) {
+\t\t\t\tif (i === 4 || i === 6 || i === 8 || i === 10) out += "-"
+\t\t\t\tout += bytes[i]!.toString(16).padStart(2, "0")
+\t\t\t}
+\t\t\treturn out
+\t\t}
+\t\tthrow new Error("honey: no crypto.randomUUID or crypto.getRandomValues in this runtime")
+\t}
+`;
+}
+function sdkClientBuildHeaders() {
+    return `
+\tasync #buildHeaders(
+\t\topts: _RequestOptions,
+\t\tctx: { method: string; path: string },
+\t): Promise<Headers> {
+\t\tconst headers = new Headers()
+
+\t\tif (this.#config.headers) {
+\t\t\tconst resolved =
+\t\t\t\ttypeof this.#config.headers === "function"
+\t\t\t\t\t? await this.#config.headers(ctx)
+\t\t\t\t\t: this.#config.headers
+\t\t\tfor (const [k, v] of Object.entries(resolved)) {
+\t\t\t\tif (v !== undefined) headers.set(k, v)
+\t\t\t}
+\t\t}
+
+\t\t/* a token from onAuthExpired replaces the configured one until the next refresh */
+\t\tif (this.#token !== null) {
+\t\t\theaders.set(this.#config.authHeaderName ?? "Authorization", \`\${this.#config.authHeaderPrefix ?? "Bearer "}\${this.#token}\`)
+\t\t}
+
+\t\tif (opts.headers) {
+\t\t\tfor (const [k, v] of Object.entries(opts.headers)) {
+\t\t\t\tif (v !== undefined) headers.set(k, v)
+\t\t\t}
+\t\t}
+
+\t\tif (opts.cookies) {
+\t\t\tconst existing = headers.get("cookie")
+\t\t\tconst pairs = Object.entries(opts.cookies)
+\t\t\t\t.map(([k, v]) => \`\${encodeURIComponent(k)}=\${encodeURIComponent(v)}\`)
+\t\t\t\t.join("; ")
+\t\t\tif (pairs) {
+\t\t\t\theaders.set("cookie", existing ? \`\${existing}; \${pairs}\` : pairs)
+\t\t\t}
+\t\t}
+
+\t\tif (!headers.has("x-request-id")) {
+\t\t\theaders.set("x-request-id", this.#newRequestId())
+\t\t}
+
+\t\treturn headers
+\t}
+`;
+}
+function sdkClientDoRequest() {
+    return `
+\t/* the body of a request, and the content-type it needs — shared by plain requests and SSE */
+\t#buildBody(opts: _RequestOptions, headers: Headers): BodyInit | undefined {
+\t\tif (opts.body !== undefined) {
+\t\t\tif (!headers.has("content-type")) headers.set("content-type", "application/octet-stream")
+\t\t\treturn opts.body as BodyInit
+\t\t}
+\t\tif (opts.json !== undefined) {
+\t\t\theaders.set("content-type", "application/json")
+\t\t\ttry {
+\t\t\t\treturn JSON.stringify(opts.json)
+\t\t\t} catch (e) {
+\t\t\t\tthrow new _ClientError({
+\t\t\t\t\tbody: opts.json,
+\t\t\t\t\tdata: null,
+\t\t\t\t\tmessage: \`JSON serialization failed: \${e instanceof Error ? e.message : String(e)}\`,
+\t\t\t\t\tresponse: new Response(null, { status: 0 }),
+\t\t\t\t\tstatus: 0,
+\t\t\t\t})
+\t\t\t}
+\t\t}
+\t\tif (opts.form === undefined) return undefined
+\t\tconst isFile = (v: unknown) =>
+\t\t\t(typeof File !== "undefined" && v instanceof File) || (typeof Blob !== "undefined" && v instanceof Blob)
+\t\tconst hasFiles = Object.values(opts.form).some(
+\t\t\t(v) =>
+\t\t\t\tisFile(v) ||
+\t\t\t\t(typeof FileList !== "undefined" && v instanceof FileList) ||
+\t\t\t\t(Array.isArray(v) && v.some(isFile)),
+\t\t)
+\t\tconst text = (v: unknown): string | null => {
+\t\t\tif (v === undefined || v === null || typeof v === "symbol") return null
+\t\t\tif (v instanceof Date) return v.toISOString()
+\t\t\tif (typeof v === "object") throw new TypeError("form: nested objects cannot be form-encoded; send json instead")
+\t\t\treturn String(v)
+\t\t}
+\t\tif (hasFiles) {
+\t\t\tconst fd = new FormData()
+\t\t\tfor (const [k, v] of Object.entries(opts.form)) {
+\t\t\t\tif (typeof FileList !== "undefined" && v instanceof FileList) {
+\t\t\t\t\tfor (let i = 0; i < v.length; i++) { const f = v[i]; if (f) fd.append(k, f) }
+\t\t\t\t\tcontinue
+\t\t\t\t}
+\t\t\t\tfor (const item of Array.isArray(v) ? v : [v]) {
+\t\t\t\t\tif (isFile(item)) fd.append(k, item as Blob)
+\t\t\t\t\telse {
+\t\t\t\t\t\tconst s = text(item)
+\t\t\t\t\t\tif (s !== null) fd.append(k, s)
+\t\t\t\t\t}
+\t\t\t\t}
+\t\t\t}
+\t\t\treturn fd
+\t\t}
+\t\theaders.set("content-type", "application/x-www-form-urlencoded")
+\t\tconst sp = new URLSearchParams()
+\t\t/* arrays repeat the key, as they do in multipart and in the query */
+\t\tfor (const [k, v] of Object.entries(opts.form)) {
+\t\t\tfor (const item of Array.isArray(v) ? v : [v]) {
+\t\t\t\tconst s = text(item)
+\t\t\t\tif (s !== null) sp.append(k, s)
+\t\t\t}
+\t\t}
+\t\treturn sp.toString()
+\t}
+
+\t/* a stream body is sent once and needs duplex: "half" (Node's fetch throws without it) */
+\t#requestInit(init: RequestInit): RequestInit {
+\t\tif (typeof ReadableStream !== "undefined" && init.body instanceof ReadableStream) {
+\t\t\t;(init as RequestInit & { duplex?: string }).duplex = "half"
+\t\t}
+\t\treturn init
+\t}
+
+\t/* the Request a response hook sees; a stream body was consumed by the send, so it is left off */
+\t#hookRequest(url: string, init: RequestInit): Request {
+\t\tconst consumed = typeof ReadableStream !== "undefined" && init.body instanceof ReadableStream
+\t\treturn new Request(url, consumed ? { ...init, body: null } : init)
+\t}
+
+\tasync #doRequest(
+\t\tmethod: string,
+\t\tpath: string,
+\t\topts: _RequestOptions,
+\t\tisRetry: boolean,
+\t\trequestMeta?: _RequestMeta,
+\t): Promise<{ done: () => void; response: Response }> {
+\t\tconst url = this.#buildURL(path, opts)
+\t\tconst headers = await this.#buildHeaders(opts, { method, path })
+\t\tlet body = this.#buildBody(opts, headers)
+
+\t\tif (this.#config.onRequest) {
+\t\t\tconst reqCtx: { body?: BodyInit; headers: Headers; invalidatedBy?: string[]; isStale?: boolean; method: string; path: string; selector?: string; state: Record<string, unknown>; url: string } = { body, headers, method, path, state: this.#config.state ?? {}, url }
+\t\t\tif (requestMeta) {
+\t\t\t\treqCtx.invalidatedBy = requestMeta.invalidatedBy
+\t\t\t\treqCtx.isStale = requestMeta.isStale
+\t\t\t\treqCtx.selector = requestMeta.selector
+\t\t\t}
+\t\t\tfor (const hook of this.#config.onRequest) {
+\t\t\t\tawait hook(reqCtx)
+\t\t\t}
+\t\t\tif (reqCtx.body !== body) body = reqCtx.body
+\t\t}
+
+\t\tconst { signal, cleanup } = this.#buildSignal(opts)
+\t\tconst init = this.#requestInit({ body, headers, method, signal })
+\t\tif (this.#config.credentials) init.credentials = this.#config.credentials
+\t\tif (this.#config.mode) init.mode = this.#config.mode
+
+\t\tconst _logOp = \`\${method.toUpperCase()} \${path}\`
+\t\tconst _logStart = Date.now()
+\t\tthis.#config.onLog?.({ duration_ms: 0, event: "request_start", level: "debug", operation: _logOp })
+
+\t\ttry {
+\t\t\tsignal?.throwIfAborted()
+\t\t\tlet response = await this.#send(url, init)
+
+\t\t\t/* FormData, Blob, and strings can be sent again; a stream was consumed by the first attempt */
+\t\t\tif (response.status === 401 && this.#config.onAuthExpired && !isRetry && !(body instanceof ReadableStream)) {
+\t\t\t\tconst authName = this.#config.authHeaderName ?? "Authorization"
+\t\t\t\tconst authPrefix = this.#config.authHeaderPrefix ?? "Bearer "
+\t\t\t\tconst sent = new Headers(headers).get(authName)
+\t\t\t\tconst rejectedToken = sent?.startsWith(authPrefix) ? sent.slice(authPrefix.length) : (sent ?? null)
+\t\t\t\tconst newToken = await this.#refreshToken(rejectedToken)
+\t\t\t\tif (newToken !== null) {
+\t\t\t\t\tconst retryHeaders = new Headers(headers)
+\t\t\t\t\tretryHeaders.set(authName, \`\${authPrefix}\${newToken}\`)
+\t\t\t\t\tawait response.body?.cancel().catch(() => {})
+\t\t\t\t\tresponse = await this.#send(url, { ...init, headers: retryHeaders })
+\t\t\t\t}
+\t\t\t}
+
+\t\t\tthis.#config.onLog?.({
+\t\t\t\tduration_ms: Date.now() - _logStart,
+\t\t\t\tevent: "response_received",
+\t\t\t\tlevel: response.status >= 400 ? "warn" : "info",
+\t\t\t\toperation: _logOp,
+\t\t\t\tstatus: response.status,
+\t\t\t})
+
+\t\t\tif (this.#config.onResponse) {
+\t\t\t\tconst resCtx: { invalidatedBy?: string[]; isRetry: boolean; isStale?: boolean; method: string; path: string; request: Request; response: Response; retry: () => Promise<Response>; selector?: string; state: Record<string, unknown>; url: string } = {
+\t\t\t\t\tisRetry,
+\t\t\t\t\tmethod,
+\t\t\t\t\tpath,
+\t\t\t\t\trequest: this.#hookRequest(url, init),
+\t\t\t\t\tresponse,
+\t\t\t\t\tretry: () => {
+\t\t\t\t\t\tif (isRetry) throw new Error("Max 1 retry per request")
+\t\t\t\t\t\tif (body instanceof ReadableStream) throw new Error("A streamed request body cannot be sent again")
+\t\t\t\t\t\treturn this.#doRequest(method, path, opts, true, requestMeta)
+\t\t\t\t\t\t\t.then(async (r) => {
+\t\t\t\t\t\t\t\tr.done()
+\t\t\t\t\t\t\t\tif (!r.response.ok) throw await this.#parseAsClientError(r.response)
+\t\t\t\t\t\t\t\treturn r.response
+\t\t\t\t\t\t\t})
+\t\t\t\t\t},
+\t\t\t\t\tstate: this.#config.state ?? {},
+\t\t\t\t\turl,
+\t\t\t\t}
+\t\t\t\tif (requestMeta) {
+\t\t\t\t\tresCtx.invalidatedBy = requestMeta.invalidatedBy
+\t\t\t\t\tresCtx.isStale = requestMeta.isStale
+\t\t\t\t\tresCtx.selector = requestMeta.selector
+\t\t\t\t}
+\t\t\t\tfor (const hook of this.#config.onResponse) {
+\t\t\t\t\tconst result = await hook(resCtx)
+\t\t\t\t\tif (result instanceof Response) {
+\t\t\t\t\t\tresponse = result
+\t\t\t\t\t\tresCtx.response = result
+\t\t\t\t\t}
+\t\t\t\t}
+\t\t\t}
+
+\t\t\t/* the caller releases the timer after reading the body: the timeout covers the whole exchange */
+\t\t\treturn { done: cleanup, response }
+\t\t} catch (err) {
+\t\t\tcleanup()
+\t\t\tconst _errStatus = typeof (err as { status?: unknown })?.status === "number" ? (err as { status: number }).status : undefined
+\t\t\tthis.#config.onLog?.({
+\t\t\t\tduration_ms: Date.now() - _logStart,
+\t\t\t\terror: err,
+\t\t\t\tevent: "error",
+\t\t\t\tlevel: "error",
+\t\t\t\toperation: _logOp,
+\t\t\t\t...(_errStatus !== undefined ? { status: _errStatus } : {}),
+\t\t\t})
+\t\t\tthrow err
+\t\t}
+\t}
+
+\t/* one refresh for every 401 in flight; the new token is kept for later requests */
+\t#refreshToken(rejectedToken: string | null): Promise<string | null> {
+\t\tconst hook = this.#config.onAuthExpired
+\t\tif (!hook) return Promise.resolve(null)
+\t\tif (rejectedToken !== null && this.#token !== null && rejectedToken !== this.#token) {
+\t\t\t/* another request already refreshed past the rejected token */
+\t\t\treturn Promise.resolve(this.#token)
+\t\t}
+\t\tthis.#refreshing ??= Promise.resolve()
+\t\t\t.then(() => hook({ rejectedToken }))
+\t\t\t.then((token) => {
+\t\t\t\tthis.#token = typeof token === "string" && token.length > 0 ? token : null
+\t\t\t\treturn this.#token
+\t\t\t})
+\t\t\t.finally(() => {
+\t\t\t\tthis.#refreshing = null
+\t\t\t})
+\t\treturn this.#refreshing
+\t}
+
+\t/* Same rules as client/http.ts; the cross-origin header allowlist comes from
+\t   client/redirect-policy.ts. "same-origin" (default) follows a redirect only while it stays on
+\t   the base URL's origin; "follow" also follows cross-origin ones, carrying only allowlisted
+\t   headers and never a replayed body.
+\t   Browsers hide redirect targets from script, so there the platform follows. */
+\tasync #send(url: string, init: RequestInit): Promise<Response> {
+\t\tconst policy = this.#config.redirect ?? "same-origin"
+\t\tconst g = globalThis as { document?: unknown; WorkerGlobalScope?: unknown }
+\t\tconst platformFollows = typeof g.document !== "undefined" || typeof g.WorkerGlobalScope !== "undefined"
+\t\tif (policy === "manual" || policy === "error" || platformFollows) {
+\t\t\treturn this.#fetchFn(url, policy === "same-origin" ? init : { ...init, redirect: policy })
+\t\t}
+\t\tconst origin = new URL(url).origin
+\t\tlet current = new URL(url)
+\t\tlet currentInit: RequestInit = { ...init, redirect: "manual" }
+\t\tconst replayable = (b: unknown) =>
+\t\t\tb == null || typeof b === "string" || (typeof Blob !== "undefined" && b instanceof Blob) || (typeof FormData !== "undefined" && b instanceof FormData) || b instanceof URLSearchParams || b instanceof ArrayBuffer || ArrayBuffer.isView(b)
+\t\tfor (let hop = 0; ; hop++) {
+\t\t\tconst response = await this.#fetchFn(current.toString(), currentInit)
+\t\t\tconst location = response.headers.get("location")
+\t\t\tif (![301, 302, 303, 307, 308].includes(response.status) || location === null || hop >= 20) return response
+\t\t\tlet target: URL
+\t\t\ttry {
+\t\t\t\ttarget = new URL(location, current)
+\t\t\t} catch {
+\t\t\t\treturn response
+\t\t\t}
+\t\t\tif (target.protocol !== "http:" && target.protocol !== "https:") return response
+\t\t\tconst crossOrigin = target.origin !== origin
+\t\t\tif (crossOrigin && policy !== "follow") return response
+\t\t\tconst nextInit: RequestInit = { ...currentInit, headers: new Headers(currentInit.headers) }
+\t\t\tif (response.status === 307 || response.status === 308) {
+\t\t\t\tif (currentInit.body != null && (crossOrigin || !replayable(currentInit.body))) return response
+\t\t\t} else {
+\t\t\t\tconst method = (currentInit.method ?? "GET").toUpperCase()
+\t\t\t\tif (response.status === 303 ? method !== "HEAD" : method === "POST") {
+\t\t\t\t\tnextInit.method = "GET"
+\t\t\t\t\tnextInit.body = undefined
+\t\t\t\t\t;(nextInit.headers as Headers).delete("content-type")
+\t\t\t\t}
+\t\t\t}
+\t\t\tif (crossOrigin) {
+\t\t\t\t/* only allowlisted headers cross: no credential, configured, per-call or hook header */
+\t\t\t\tconst safe = new Headers()
+\t\t\t\tfor (const name of [${CROSS_ORIGIN_SAFE_HEADERS.map((h) => JSON.stringify(h)).join(", ")}]) {
+\t\t\t\t\tconst value = (nextInit.headers as Headers).get(name)
+\t\t\t\t\tif (value !== null) safe.set(name, value)
+\t\t\t\t}
+\t\t\t\tnextInit.headers = safe
+\t\t\t}
+\t\t\tawait response.body?.cancel().catch(() => {})
+\t\t\tcurrent = target
+\t\t\tcurrentInit = nextInit
+\t\t}
+\t}
+`;
+}
+function sdkClientParseBody() {
+    return `
+\t#parseBody(response: Response): Promise<unknown> {
+\t\tif (response.status === 204) return Promise.resolve(null)
+
+\t\tconst rawCt = response.headers.get("content-type") ?? ""
+\t\tconst ct = rawCt.split(";")[0]?.trim().toLowerCase() ?? ""
+\t\tif (ct === "application/json" || ct.endsWith("+json")) {
+\t\t\treturn response.json()
+\t\t}
+\t\tif (ct === "application/octet-stream" || ct === "application/pdf") {
+\t\t\treturn response.arrayBuffer()
+\t\t}
+\t\t/* the classes the generated types use: text/*, XML, otherwise bytes */
+\t\tif (ct.startsWith("text/") || ct === "application/xml" || ct.endsWith("+xml")) return response.text()
+\t\t/* unknown content type \u2014 binary-safe fallback */
+\t\treturn response.arrayBuffer()
+\t}
+`;
+}
+function sdkClientParseErrorBody() {
+    return `
+\tasync #parseErrorBody(response: Response): Promise<unknown> {
+\t\ttry {
+\t\t\treturn await response.json()
+\t\t} catch {
+\t\t\treturn undefined
+\t\t}
+\t}
+`;
+}
+function sdkClientParseAsClientError() {
+    return `
+\tasync #parseAsClientError(response: Response): Promise<_ClientError> {
+\t\tconst preserved = response.clone()
+\t\tconst body = await this.#parseErrorBody(response)
+\t\tconst msgVal = typeof body === "object" && body !== null && "message" in body
+\t\t\t? (body as Record<string, unknown>)["message"]
+\t\t\t: undefined
+\t\tconst rawMsg = typeof msgVal === "string" ? msgVal : null
+\t\tconst safeMsg = rawMsg !== null
+\t\t\t? rawMsg.replace(/[\\x00-\\x1f]/g, "").slice(0, this.#maxErrorMessageChars)
+\t\t\t: \`HTTP \${response.status}\`
+\t\tconst Cls = _STATUS_ERROR_MAP[response.status] ?? _ClientError
+\t\treturn new Cls({ body, data: body, message: safeMsg, response: preserved, status: response.status })
+\t}
+`;
+}
+function sdkClientBuildSignal() {
+    return `
+\t#buildSignal(opts: _RequestOptions, isStream?: boolean): { cleanup: () => void; signal: AbortSignal } {
+\t\tconst userSignal = opts.signal
+\t\tconst timeout = isStream ? undefined : (opts.timeout ?? this.#config.timeout)
+\t\tif (!timeout && !userSignal) return { cleanup: () => {}, signal: this.#disposeCtrl.signal }
+\t\tconst ctrl = new AbortController()
+\t\tlet timer: ReturnType<typeof setTimeout> | undefined
+\t\tif (timeout) {
+\t\t\ttimer = setTimeout(() => ctrl.abort(new Error("timeout")), timeout)
+\t\t\tif (typeof (timer as unknown as { unref?: () => void }).unref === "function") {
+\t\t\t\t(timer as unknown as { unref: () => void }).unref()
+\t\t\t}
+\t\t}
+\t\tconst abort = (reason?: unknown) => { if (!ctrl.signal.aborted) ctrl.abort(reason) }
+\t\tconst onDispose = () => abort(this.#disposeCtrl.signal.reason)
+\t\tconst onUserAbort = () => abort(userSignal?.reason)
+\t\tif (this.#disposeCtrl.signal.aborted) {
+\t\t\tabort(this.#disposeCtrl.signal.reason)
+\t\t} else {
+\t\t\tthis.#disposeCtrl.signal.addEventListener("abort", onDispose, { once: true })
+\t\t}
+\t\tif (userSignal?.aborted) {
+\t\t\tabort(userSignal.reason)
+\t\t} else if (userSignal) {
+\t\t\tuserSignal.addEventListener("abort", onUserAbort, { once: true })
+\t\t}
+\t\treturn {
+\t\t\tcleanup: () => {
+\t\t\t\tif (timer !== undefined) clearTimeout(timer)
+\t\t\t\tthis.#disposeCtrl.signal.removeEventListener("abort", onDispose)
+\t\t\t\tuserSignal?.removeEventListener("abort", onUserAbort)
+\t\t\t},
+\t\t\tsignal: ctrl.signal,
+\t\t}
+\t}
+`;
+}
+function sdkClientRequestThrow() {
+    return `
+\tasync #requestThrow(
+\t\tmethod: string,
+\t\tpath: string,
+\t\topts: _RequestOptions,
+\t\trequestMeta?: _RequestMeta,
+\t): Promise<unknown> {
+\t\tconst { done, response } = await this.#doRequest(method, path, opts, false, requestMeta)
+\t\ttry {
+\t\t\tif (!response.ok) throw await this.#parseAsClientError(response)
+\t\t\treturn await this.#parseBody(response)
+\t\t} finally {
+\t\t\tdone()
+\t\t}
+\t}
+`;
+}
+function sdkClientRequestSafe() {
+    return `
+\tasync #requestSafe(
+\t\tmethod: string,
+\t\tpath: string,
+\t\topts: _RequestOptions,
+\t\trequestMeta?: _RequestMeta,
+\t): Promise<{
+\t\tdata: unknown
+\t\terror: unknown
+\t\tresponse: Response
+\t\tstatus: number
+\t}> {
+\t\tlet doResponse: { done: () => void; response: Response }
+\t\ttry {
+\t\t\tdoResponse = await this.#doRequest(method, path, opts, false, requestMeta)
+\t\t} catch (e) {
+\t\t\tif (e instanceof _ClientError) return { data: null, error: e, response: e.response, status: e.status }
+\t\t\tthrow e
+\t\t}
+\t\tconst { done, response } = doResponse
+\t\ttry {
+\t\t\tif (!response.ok) {
+\t\t\t\tconst preserved = response.clone()
+\t\t\t\tconst parsed = await this.#parseErrorBody(response)
+\t\t\t\t/* a failed request always has a truthy error: the JSON body, or a ClientError for any other body */
+\t\t\t\tconst error = parsed !== undefined && parsed !== null && parsed !== false && parsed !== "" && parsed !== 0
+\t\t\t\t\t? parsed
+\t\t\t\t\t: await this.#parseAsClientError(preserved.clone())
+\t\t\t\treturn { data: null, error, response: preserved, status: response.status }
+\t\t\t}
+\t\t\tlet data: unknown
+\t\t\ttry {
+\t\t\t\tdata = await this.#parseBody(response)
+\t\t\t} catch (e) {
+\t\t\t\treturn { data: null, error: e, response, status: response.status }
+\t\t\t}
+\t\t\treturn { data, error: null, response, status: response.status }
+\t\t} finally {
+\t\t\tdone()
+\t\t}
+\t}
+`;
+}
+function sdkClientRequest() {
+    return `
+\tasync #request(entry: _ServiceEntry, input: Record<string, unknown>): Promise<unknown> {
+\t\tconst path = this.#toColonParams(entry.path, entry.wildcard)
+\t\tconst method = entry.method
+\t\t/* a copy: the caller's input object is never written to, so reusing it never reuses a key */
+\t\tconst opts = { ...input } as _RequestOptions
+\t\tif (entry.idempotent) {
+\t\t\tconst existing = opts.headers?.["Idempotency-Key"] ?? opts.headers?.["idempotency-key"]
+\t\t\tif (existing === undefined) {
+\t\t\t\tconst key = opts.idempotencyKey ?? this.#newRequestId()
+\t\t\t\topts.headers = { ...(opts.headers ?? {}), "Idempotency-Key": key }
+\t\t\t}
+\t\t}
+\t\tconst params = opts.params
+\t\tlet cp: string
+\t\ttry {
+\t\t\tcp = this.#interpolatePath(path, params)
+\t\t} catch (e) {
+\t\t\tif (!(e instanceof _PathParamError)) throw e
+\t\t\tconst err = new _ClientError({
+\t\t\t\tbody: null,
+\t\t\t\tdata: null,
+\t\t\t\tmessage: \`\${e.message} for \${method} \${entry.path}\`,
+\t\t\t\tresponse: Response.error(),
+\t\t\t\tstatus: 0,
+\t\t\t})
+\t\t\tif (!this.#config.throwOnError) return { data: null, error: err, response: err.response, status: 0 }
+\t\t\tthrow err
+\t\t}
+\t\tconst cs = \`\${method} \${cp}\`
+\t\tconst requestMeta = this.#buildRequestMeta(cs, cp, method)
+\t\tif (!this.#config.throwOnError) {
+\t\t\tconst r = await this.#requestSafe(method, path, opts, requestMeta)
+\t\t\tif (r.status >= 200 && r.status < 300) {
+\t\t\t\tthis.#markStale(entry.invalidate??[], params, cs)
+\t\t\t\tif (requestMeta?.isStale) this.#clearStale(cs, cp, method, requestMeta.seqSnapshot)
+\t\t\t}
+\t\t\treturn r
+\t\t}
+\t\tconst data = await this.#requestThrow(method, path, opts, requestMeta)
+\t\tthis.#markStale(entry.invalidate??[], params, cs)
+\t\tif (requestMeta?.isStale) this.#clearStale(cs, cp, method, requestMeta?.seqSnapshot ?? 0)
+\t\treturn data
+\t}
+`;
+}
+function sdkClientRequestSSE() {
+    return `
+\t#requestSSE(entry: _ServiceEntry, path: string, opts: _RequestOptions): AsyncIterable<_SSEEvent> {
+\t\treturn { [Symbol.asyncIterator]: () => this.#doSSE(entry, path, opts) }
+\t}
+`;
+}
+function sdkClientConnectWS() {
+    return `
+\t#connectWS(entry: _ServiceEntry, path: string, opts: _RequestOptions): _TypedWebSocket {
+\t\tconst built = new URL(this.#buildURL(path, opts))
+\t\t/* only the scheme changes: an https URL elsewhere in the query is left alone */
+\t\tif (built.protocol === "https:") built.protocol = "wss:"
+\t\telse if (built.protocol === "http:") built.protocol = "ws:"
+\t\tif (opts.reconnectToken) built.searchParams.append("reconnect_token", opts.reconnectToken)
+\t\tconst ws = this.#createTypedWebSocket(built.toString(), opts.protocols)
+\t\tif (entry.invalidate && entry.invalidate.length > 0) {
+\t\t\tconst invalidate = entry.invalidate
+\t\t\tconst params = opts.params
+\t\t\tconst cs = \`WS \${this.#interpolatePath(path, params)}\`
+\t\t\tws.on("open", () => this.#markStale(invalidate, params, cs))
+\t\t}
+\t\treturn ws
+\t}
+`;
+}
+function sdkClientBuildRequestMeta() {
+    return `
+\t#buildRequestMeta(concreteSelector: string, concretePath: string, method: string): _RequestMeta | undefined {
+\t\tif (!this.#staleUntil) return undefined
+\t\tconst now = Date.now()
+\t\tconst { by, isStale } = this.#lookupStale(concreteSelector, concretePath, method, now)
+\t\treturn { invalidatedBy: by, isStale, selector: concreteSelector, seqSnapshot: this.#invalidationSeq }
+\t}
+`;
+}
+function sdkClientMarkStale() {
+    return `
+\t#markStale(invalidate: readonly string[], params: Record<string, string> | undefined, mutationSelector: string): void {
+\t\tconst exactTable = this.#staleUntil
+\t\tif (!exactTable || invalidate.length === 0) return
+\t\tconst seq = ++this.#invalidationSeq
+\t\tconst until = Date.now() + this.#staleTime
+\t\tfor (const target of this.#resolveInvalidationTargets(invalidate, params)) {
+\t\t\tconst spaceIdx = target.indexOf(" ")
+\t\t\tconst method = target.slice(0, spaceIdx)
+\t\t\tconst isPattern = this.#hasPlaceholder(target.slice(spaceIdx + 1))
+\t\t\tlet table: Map<string, _StaleEntry>
+\t\t\tif (isPattern) {
+\t\t\t\ttable = this.#stalePatterns.get(method) ?? new Map<string, _StaleEntry>()
+\t\t\t\tthis.#stalePatterns.set(method, table)
+\t\t\t} else {
+\t\t\t\ttable = exactTable
+\t\t\t}
+\t\t\tconst existing = table.get(target)
+\t\t\tif (existing) {
+\t\t\t\tif (!existing.by.includes(mutationSelector)) {
+\t\t\t\t\texisting.by.push(mutationSelector)
+\t\t\t\t\tif (existing.by.length > this.#maxSourcesPerTarget) existing.by.shift()
+\t\t\t\t}
+\t\t\t\texisting.until = until
+\t\t\t\texisting.seq = seq
+\t\t\t\t/* a new mutation re-marks every instance */
+\t\t\t\texisting.refreshed?.clear()
+\t\t\t} else {
+\t\t\t\ttable.set(target, { by: [mutationSelector], refreshed: isPattern ? new Set<string>() : undefined, seq, until })
+\t\t\t}
+\t\t}
+\t\tif (exactTable.size > this.#staleMaxEntries) {
+\t\t\tconst now = Date.now()
+\t\t\tfor (const [k, entry] of exactTable) if (entry.until <= now) exactTable.delete(k)
+\t\t\t/* still over: drop the oldest marks */
+\t\t\tfor (const k of exactTable.keys()) {
+\t\t\t\tif (exactTable.size <= this.#staleMaxEntries) break
+\t\t\t\texactTable.delete(k)
+\t\t\t}
+\t\t}
+\t}
+`;
+}
+function sdkClientClearStale() {
+    return `
+\t/* a successful stale read clears that resource only: its exact mark, and this path's share of a pattern mark */
+\t#clearStale(concreteSelector: string, concretePath: string, method: string, seqSnapshot: number): void {
+\t\tif (!this.#staleUntil) return
+\t\tconst exact = this.#staleUntil.get(concreteSelector)
+\t\tif (exact && exact.seq <= seqSnapshot) this.#staleUntil.delete(concreteSelector)
+\t\tconst table = this.#stalePatterns.get(method)
+\t\tif (!table) return
+\t\tfor (const [key, entry] of table) {
+\t\t\tif (entry.seq > seqSnapshot || !entry.refreshed) continue
+\t\t\tif (!this.#pathMatchesPattern(concretePath, key.slice(key.indexOf(" ") + 1))) continue
+\t\t\tif (entry.refreshed.size >= 1024) {
+\t\t\t\tconst oldest = entry.refreshed.values().next().value
+\t\t\t\tif (oldest !== undefined) entry.refreshed.delete(oldest)
+\t\t\t}
+\t\t\tentry.refreshed.add(concretePath)
+\t\t}
+\t}
+`;
+}
+function sdkClientDispose() {
+    return `
+\tdispose(): void {
+\t\tif (this.#disposed) return
+\t\tthis.#disposed = true
+\t\tthis.#disposeCtrl.abort()
+\t\tthis.#staleUntil?.clear()
+\t\tthis.#stalePatterns.clear()
+\t\tthis.#resourceCache.clear()
+\t\tthis.#patternRegexCache.clear()
+\t}
+`;
+}
+function sdkClientDoSSE() {
+    return `
+\tasync *#doSSE(entry: _ServiceEntry, path: string, opts: _RequestOptions): AsyncGenerator<_SSEEvent> {
+\t\tconst method = entry.method
+\t\tconst url = this.#buildURL(path, opts)
+\t\tconst headers = await this.#buildHeaders(opts, { method, path })
+\t\theaders.set("accept", "text/event-stream")
+\t\tif (opts.lastEventId) {
+\t\t\theaders.set("last-event-id", opts.lastEventId)
+\t\t}
+\t\t/* a streamed operation carries its body like any other request */
+\t\tlet body = this.#buildBody(opts, headers)
+\t\tconst { signal, cleanup } = this.#buildSignal(opts, true)
+\t\ttry {
+\t\t\tif (this.#config.onRequest) {
+\t\t\t\tconst reqCtx: { body?: BodyInit; headers: Headers; invalidatedBy?: string[]; isStale?: boolean; method: string; path: string; selector?: string; state: Record<string, unknown>; url: string } = { body, headers, method, path, state: this.#config.state ?? {}, url }
+\t\t\t\tfor (const hook of this.#config.onRequest) {
+\t\t\t\t\tawait hook(reqCtx)
+\t\t\t\t}
+\t\t\t\tif (reqCtx.body !== body) body = reqCtx.body
+\t\t\t}
+\t\t\tconst sseInit = this.#requestInit({ body, headers, method, signal })
+\t\t\tif (this.#config.credentials) sseInit.credentials = this.#config.credentials
+\t\t\tif (this.#config.mode) sseInit.mode = this.#config.mode
+\t\t\tsignal?.throwIfAborted()
+\t\t\tlet response = await this.#fetchFn(url, sseInit)
+\t\t\tif (this.#config.onResponse) {
+\t\t\t\tconst resCtx: { invalidatedBy?: string[]; isRetry: boolean; isStale?: boolean; method: string; path: string; request: Request; response: Response; retry: () => Promise<Response>; selector?: string; state: Record<string, unknown>; url: string } = {
+\t\t\t\t\tisRetry: false, method, path, request: this.#hookRequest(url, sseInit), response,
+\t\t\t\t\tretry: () => { throw new Error("SSE streams do not support retry") },
+\t\t\t\t\tstate: this.#config.state ?? {}, url,
+\t\t\t\t}
+\t\t\t\tfor (const hook of this.#config.onResponse) {
+\t\t\t\t\tconst result = await hook(resCtx)
+\t\t\t\t\tif (result instanceof Response) { response = result; resCtx.response = result }
+\t\t\t\t}
+\t\t\t}
+\t\t\tif (!response.ok) {
+\t\t\t\tthrow await this.#parseAsClientError(response)
+\t\t\t}
+\t\t\tif (entry.invalidate && entry.invalidate.length > 0) {
+\t\t\t\tconst cs = \`\${method} \${this.#interpolatePath(path, opts.params)}\`
+\t\t\t\tthis.#markStale(entry.invalidate, opts.params, cs)
+\t\t\t}
+\t\t\tif (!response.body) return
+\t\t\tyield* this.#parseSSE(response.body)
+\t\t} finally {
+\t\t\tcleanup()
+\t\t}
+\t}
+`;
+}
+function sdkClientParseSSEBlock() {
+    return `
+\t/* Keep in sync with client/sse.ts — the WHATWG event-stream rules: lines end at CRLF, LF or CR;
+\t   a leading BOM is skipped; id is sticky and ignored if it holds NUL; retry is digits only; an
+\t   event still open when the stream ends is discarded, never dispatched. */
+\tasync *#parseSSE(stream: ReadableStream<Uint8Array>): AsyncGenerator<_SSEEvent> {
+\t\tconst decoder = new TextDecoder()
+\t\tconst reader = stream.getReader()
+\t\tconst maxBuffer = this.#sseMaxBufferChars
+\t\tlet pending = ""
+\t\tlet first = true
+\t\tlet data: string[] = []
+\t\tlet dataSize = 0
+\t\tlet hasData = false
+\t\tlet event: string | undefined
+\t\tlet lastId = ""
+\t\tlet retry: number | undefined
+\t\tconst dispatch = (): _SSEEvent | undefined => {
+\t\t\tconst out: _SSEEvent | undefined = hasData ? { data: data.join("\\n") } : undefined
+\t\t\tif (out) {
+\t\t\t\tif (event !== undefined && event !== "") out.event = event
+\t\t\t\tif (lastId !== "") out.id = lastId
+\t\t\t\tif (retry !== undefined) out.retry = retry
+\t\t\t\tretry = undefined
+\t\t\t}
+\t\t\tdata = []
+\t\t\tdataSize = 0
+\t\t\thasData = false
+\t\t\tevent = undefined
+\t\t\treturn out
+\t\t}
+\t\tconst processLine = (line: string): void => {
+\t\t\tif (line.charCodeAt(0) === 58) return
+\t\t\tconst colon = line.indexOf(":")
+\t\t\tconst field = colon === -1 ? line : line.slice(0, colon)
+\t\t\tlet value = colon === -1 ? "" : line.slice(colon + 1)
+\t\t\tif (value.charCodeAt(0) === 32) value = value.slice(1)
+\t\t\tswitch (field) {
+\t\t\t\tcase "data":
+\t\t\t\t\tdataSize += value.length + 1
+\t\t\t\t\tif (dataSize > maxBuffer) throw new Error(\`SSE event exceeded \${maxBuffer} characters\`)
+\t\t\t\t\tdata.push(value)
+\t\t\t\t\thasData = true
+\t\t\t\t\tbreak
+\t\t\t\tcase "event":
+\t\t\t\t\tevent = value
+\t\t\t\t\tbreak
+\t\t\t\tcase "id":
+\t\t\t\t\tif (!value.includes("\\0")) lastId = value
+\t\t\t\t\tbreak
+\t\t\t\tcase "retry":
+\t\t\t\t\tif (/^\\d+$/.test(value)) retry = Number(value)
+\t\t\t\t\tbreak
+\t\t\t}
+\t\t}
+\t\ttry {
+\t\t\twhile (true) {
+\t\t\t\tconst { done, value } = await reader.read()
+\t\t\t\tif (done) break
+\t\t\t\tpending += decoder.decode(value, { stream: true })
+\t\t\t\tif (first && pending.length > 0) {
+\t\t\t\t\tif (pending.charCodeAt(0) === 0xfeff) pending = pending.slice(1)
+\t\t\t\t\tfirst = false
+\t\t\t\t}
+\t\t\t\tlet start = 0
+\t\t\t\twhile (start < pending.length) {
+\t\t\t\t\tlet end = start
+\t\t\t\t\twhile (end < pending.length) {
+\t\t\t\t\t\tconst c = pending.charCodeAt(end)
+\t\t\t\t\t\tif (c === 10 || c === 13) break
+\t\t\t\t\t\tend++
+\t\t\t\t\t}
+\t\t\t\t\tif (end === pending.length) break
+\t\t\t\t\t/* a CR as the last character may be the first half of CRLF */
+\t\t\t\t\tif (pending.charCodeAt(end) === 13 && end === pending.length - 1) break
+\t\t\t\t\tconst line = pending.slice(start, end)
+\t\t\t\t\tstart = end + (pending.charCodeAt(end) === 13 && pending.charCodeAt(end + 1) === 10 ? 2 : 1)
+\t\t\t\t\tif (line === "") {
+\t\t\t\t\t\tconst out = dispatch()
+\t\t\t\t\t\tif (out) yield out
+\t\t\t\t\t} else {
+\t\t\t\t\t\tprocessLine(line)
+\t\t\t\t\t}
+\t\t\t\t}
+\t\t\t\tpending = pending.slice(start)
+\t\t\t\tif (pending.length > maxBuffer) throw new Error(\`SSE buffer exceeded \${maxBuffer} characters\`)
+\t\t\t}
+\t\t\t/* a lone CR held back at the end of the stream still terminates its line */
+\t\t\tif (pending === "\\r") {
+\t\t\t\tconst out = dispatch()
+\t\t\t\tif (out) yield out
+\t\t\t}
+\t\t\t/* anything else still open is an incomplete event: discard it */
+\t\t} finally {
+\t\t\tawait reader.cancel().catch(() => {})
+\t\t\treader.releaseLock()
+\t\t}
+\t}
+`;
+}
+function sdkClientFooter() {
+    const reexports = ["\t_ClientError as ClientError,"]
+        .concat(STATUS_ERROR_CLASSES.map(({ name }) => `\t_${name} as ${name},`))
+        .join("\n");
+    return `}
+
+export {
+${reexports}
+}
+
+export function isClientError(e: unknown): e is _ClientError {
+\treturn e instanceof _ClientError
+}
+`;
+}
+/** The IR every TypeScript SDK emitter reads: refs inlined, derived ids, duplicate ids refused. */
+export function sdkIR(spec) {
+    return toIR(resolveRefs(spec), { deriveOperationIds: true, duplicateOperationIds: "throw" });
+}
+/** Flat `resource → action → entry` map of every operation, for SDK result objects. */
+export function serviceMapOf(ir) {
+    /* null-prototype: an operationId of "__proto__.x" must not reach Object.prototype */
+    const serviceMap = Object.create(null);
+    for (const op of ir.operations) {
+        const segments = op.id.split(".");
+        const resource = segments.length === 1 ? op.id : (segments[0] ?? op.id);
+        const action = segments.length === 1 ? "_call" : segments.slice(1).join(".");
+        if (!Object.hasOwn(serviceMap, resource))
+            serviceMap[resource] = Object.create(null);
+        serviceMap[resource][action] = buildServiceEntryForOp(op);
+    }
+    return serviceMap;
+}
+export function collectSDKMethods(spec, 
+/* toIR validates namespace collisions; an operation without an operationId gets a derived
+   one instead of silently vanishing from the SDK */
+ir = sdkIR(spec)) {
+    const resolve = irResolver(ir.schemas);
+    const methods = [];
+    for (const op of ir.operations) {
+        const operationId = op.id;
+        const segments = operationId.split(".");
+        const isTopLevel = segments.length === 1;
+        const resource = isTopLevel ? operationId : (segments[0] ?? operationId);
+        const action = isTopLevel ? "_call" : segments.slice(1).join(".");
+        const inputResult = emitSDKInputType(op);
+        methods.push({
+            action,
+            errorsByStatusType: emitSDKErrorsByStatusType(op, resolve),
+            id: operationId,
+            inputHasMandatory: inputResult.hasMandatory,
+            inputType: inputResult.type,
+            realtime: op.extensions.realtime === true,
+            resource,
+            responseType: emitSDKResponseType(op),
+            sse: op.extensions.sse === true,
+            ws: op.extensions.websocket === true,
+        });
+    }
+    const nestedMap = buildNestedServiceMap(safeMemberTree(ir.tree, true));
+    return { methods, nestedMap, serviceMap: serviceMapOf(ir) };
+}
+function buildServiceEntryForOp(op) {
+    const params = openApiPathParams(op.path);
+    const entry = { method: op.method, path: op.path };
+    if (params.length > 0)
+        entry.params = params;
+    const wildcard = op.params.path.find((p) => p.wildcard === true);
+    if (wildcard)
+        entry.wildcard = wildcard.name;
+    if (op.extensions.sse)
+        entry.sse = true;
+    if (op.extensions.websocket)
+        entry.ws = true;
+    if (op.extensions.realtime)
+        entry.realtime = true;
+    if (op.extensions.idempotencyKey)
+        entry.idempotent = true;
+    const inv = op.extensions.invalidates;
+    if (inv && inv.length > 0)
+        entry.invalidate = inv;
+    return entry;
+}
+/** Members a generated client already has; a resource of the same name would hide them. */
+const SDK_ROOT_MEMBERS = new Set(["dispose", "state"]);
+/**
+ * Names JavaScript machinery reads off any object: a `then` member makes the client a
+ * thenable, `toString` breaks `String(sdk)`, `__proto__` sets the prototype.
+ */
+const SDK_OBJECT_MEMBERS = new Set([
+    "__defineGetter__",
+    "__defineSetter__",
+    "__lookupGetter__",
+    "__lookupSetter__",
+    "__proto__",
+    "constructor",
+    "hasOwnProperty",
+    "isPrototypeOf",
+    "propertyIsEnumerable",
+    "then",
+    "toJSON",
+    "toLocaleString",
+    "toString",
+    "valueOf",
+]);
+/**
+ * The resource tree with every member name a client can expose. A name that would shadow a
+ * client member or an `Object.prototype` name gets a trailing `_` (`state` → `state_`), the
+ * same rename in the interface and the service map, so types and runtime agree.
+ */
+function safeMemberTree(ns, root) {
+    const entries = new Map();
+    const sorted = [...ns.entries.entries()].sort(([a], [b]) => compareCodeUnits(a, b));
+    for (const [key, entry] of sorted) {
+        let name = key;
+        if ((root && SDK_ROOT_MEMBERS.has(key)) || SDK_OBJECT_MEMBERS.has(key)) {
+            name = `${key}_`;
+            while (ns.entries.has(name) || entries.has(name))
+                name += "_";
+        }
+        entries.set(name, entry.kind === "namespace" ? { kind: "namespace", ns: safeMemberTree(entry.ns, false) } : entry);
+    }
+    return { entries };
+}
+/**
+ * The member path of every operation on a generated TypeScript client, after the renames
+ * `safeMemberTree` applies: `["state_", "get"]` for an operation `state.get`. A namespace whose
+ * only method is `_call` is callable itself, so its path ends at the namespace.
+ */
+export function sdkMemberPaths(ir) {
+    const out = new Map();
+    const walk = (ns, prefix) => {
+        const methods = methodsOf(ns);
+        for (const [key, entry] of ns.entries) {
+            if (entry.kind === "namespace") {
+                walk(entry.ns, [...prefix, key]);
+            }
+            else if (key !== "_call") {
+                out.set(entry.op.id, [...prefix, key]);
+            }
+            else if (methods.length === 1) {
+                /* the interface promotes a lone `_call` to the namespace itself and drops any other */
+                out.set(entry.op.id, prefix);
+            }
+        }
+    };
+    walk(safeMemberTree(ir.tree, true), []);
+    return out;
+}
+function buildNestedServiceMap(ns) {
+    function walkNs(namespace) {
+        const map = new Map();
+        for (const [key, entry] of [...namespace.entries.entries()].sort(([a], [b]) => compareCodeUnits(a, b))) {
+            if (entry.kind === "method")
+                map.set(key, { entry: buildServiceEntryForOp(entry.op), kind: "leaf" });
+            else
+                map.set(key, { children: walkNs(entry.ns), kind: "ns" });
+        }
+        return map;
+    }
+    return walkNs(ns);
+}
+const TS_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+/** The SDK class name lands in source, the stem in import specifiers and file names. */
+function validateSdkNames(name, stem) {
+    if (!TS_IDENTIFIER.test(name) || SDK_TS_RESERVED.has(name)) {
+        throw new Error(`generateSDK: name ${JSON.stringify(name)} is not a TypeScript identifier`);
+    }
+    if (!/^[A-Za-z0-9_-][A-Za-z0-9._-]*$/.test(stem)) {
+        throw new Error(`generateSDK: stem ${JSON.stringify(stem)} must be a plain file name (letters, digits, ".", "_", "-")`);
+    }
+}
+export function generateSDK(spec, options) {
+    const sdkName = options?.name ?? "SDK";
+    const stem = options?.stem ?? "sdk";
+    validateSdkNames(sdkName, stem);
+    const ir = sdkIR(spec);
+    const { methods: sdkMethods, nestedMap, serviceMap } = collectSDKMethods(spec, ir);
+    const hasRealtime = sdkMethods.some((m) => m.realtime);
+    const fullMethodLookup = new Map();
+    for (const m of sdkMethods)
+        fullMethodLookup.set(m.id, m);
+    return {
+        files: {
+            client: buildSDKClient(sdkName, stem),
+            index: buildSDKIndex(sdkName, stem),
+            map: buildSDKMap(nestedMap),
+            runtime: hasRealtime ? buildSDKRuntime() : null,
+            types: buildSDKTypes(sdkName, sdkMethods, safeMemberTree(ir.tree, true), fullMethodLookup),
+        },
+        serviceMap,
+    };
+}
+//# sourceMappingURL=codegen.js.map