@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/dist/codegen-ir.js

@@ -1,661 +0,0 @@
-import { cmpCodeUnit, pascalWords } from "./codegen-lang.js";
-export function methodsOf(ns) {
-    return [...ns.entries.entries()]
-        .filter((e) => e[1].kind === "method")
-        .map(([k, v]) => [k, v.op])
-        .sort(([a], [b]) => cmpCodeUnit(a, b));
-}
-export function namespacesOf(ns) {
-    return [...ns.entries.entries()]
-        .filter((e) => e[1].kind === "namespace")
-        .map(([k, v]) => [k, v.ns])
-        .sort(([a], [b]) => cmpCodeUnit(a, b));
-}
-function firstDescendantId(ns) {
-    for (const [, entry] of ns.entries) {
-        if (entry.kind === "method")
-            return entry.op.id;
-        const sub = firstDescendantId(entry.ns);
-        if (sub)
-            return sub;
-    }
-    return "";
-}
-export function buildResourceTree(operations) {
-    const root = { entries: new Map() };
-    for (const op of operations) {
-        const segments = op.id.split(".");
-        let cur = root;
-        for (let i = 0; i < segments.length - 1; i++) {
-            const seg = segments[i] ?? "";
-            const existing = cur.entries.get(seg);
-            if (existing) {
-                if (existing.kind === "method") {
-                    throw new Error(`operationId conflict: "${existing.op.id}" is callable but also a namespace prefix of "${op.id}".\n` +
-                        `Rename one. Suggested: "${existing.op.id}" → "${existing.op.id}One" or drop "${op.id}".`);
-                }
-                cur = existing.ns;
-            }
-            else {
-                const ns = { entries: new Map() };
-                cur.entries.set(seg, { kind: "namespace", ns });
-                cur = ns;
-            }
-        }
-        const leafName = segments[segments.length - 1] ?? "";
-        const existing = cur.entries.get(leafName);
-        if (existing && existing.kind === "namespace") {
-            const otherId = firstDescendantId(existing.ns);
-            throw new Error(`operationId conflict: "${op.id}" is callable but also a namespace prefix of "${otherId}".\n` +
-                `Rename one. Suggested: "${op.id}" → "${op.id}One" or drop "${otherId}".`);
-        }
-        cur.entries.set(leafName, { kind: "method", op });
-    }
-    return root;
-}
-function isNullableSchema(schema) {
-    if (schema.nullable === true)
-        return true;
-    const t = schema.type;
-    if (Array.isArray(t) && t.includes("null"))
-        return true;
-    const variants = (schema.anyOf ?? schema.oneOf);
-    if (variants && variants.some((v) => v.type === "null"))
-        return true;
-    return false;
-}
-function isStringEnum(schema) {
-    const e = schema.enum;
-    if (!e || e.length === 0)
-        return false;
-    const t = schema.type;
-    if (t === "string")
-        return true;
-    if (!t && e.every((v) => typeof v === "string"))
-        return true;
-    return false;
-}
-function isIntEnum(schema) {
-    const e = schema.enum;
-    if (!e || e.length === 0)
-        return false;
-    const t = schema.type;
-    if (t === "integer")
-        return true;
-    if (!t && e.every((v) => typeof v === "number" && Number.isInteger(v)))
-        return true;
-    return false;
-}
-/** Strip null variant from anyOf/oneOf; returns remaining schemas. */
-function stripNullVariants(schema) {
-    const variants = (schema.anyOf ?? schema.oneOf);
-    if (!variants)
-        return null;
-    return variants.filter((v) => v.type !== "null");
-}
-/** Strip "null" from a type array, returning the first non-null type string. */
-function stripNullFromTypeArray(schema) {
-    const t = schema.type;
-    const nonNull = t.filter((v) => v !== "null");
-    return { ...schema, type: nonNull.length === 1 ? nonNull[0] : nonNull };
-}
-export function schemaToIR(schema) {
-    if (!schema)
-        return { kind: "unknown" };
-    if (typeof schema.$ref === "string") {
-        const parts = schema.$ref.split("/");
-        const name = parts[parts.length - 1] ?? schema.$ref;
-        return { kind: "ref", name };
-    }
-    if (Array.isArray(schema.allOf)) {
-        const parts = schema.allOf.map(schemaToIR);
-        return { kind: "allOf", parts };
-    }
-    /* const precedes type inference */
-    if (schema.const !== undefined) {
-        const v = schema.const;
-        if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
-            const out = { kind: "const", value: v };
-            const t = schema.type;
-            if (t === "string" || t === "integer" || t === "number" || t === "boolean")
-                out.type = t;
-            return out;
-        }
-    }
-    if (isNullableSchema(schema)) {
-        let inner;
-        if (Array.isArray(schema.type) && schema.type.includes("null")) {
-            inner = schemaToIR(stripNullFromTypeArray(schema));
-        }
-        else if (schema.anyOf || schema.oneOf) {
-            const remaining = stripNullVariants(schema) ?? [];
-            if (remaining.length === 0) {
-                inner = { kind: "unknown" };
-            }
-            else if (remaining.length === 1) {
-                inner = schemaToIR(remaining[0]);
-            }
-            else {
-                inner = { kind: "union", variants: remaining.map(schemaToIR) };
-            }
-        }
-        else {
-            /* nullable: true on a plain schema — strip the flag and recurse */
-            const { nullable: _n, ...rest } = schema;
-            inner = schemaToIR(rest);
-        }
-        /* idempotent: never double-wrap */
-        if (inner.kind === "nullable")
-            return inner;
-        return { inner, kind: "nullable" };
-    }
-    /* multi-type array without null — nullable path already handled null-containing arrays above */
-    if (Array.isArray(schema.type) && schema.type.length > 1) {
-        const types = schema.type;
-        const variants = types.map((t) => schemaToIR({ ...schema, type: t }));
-        if (variants.length === 1)
-            return variants[0];
-        return { kind: "union", variants };
-    }
-    if (Array.isArray(schema.oneOf) || Array.isArray(schema.anyOf)) {
-        const variants = (schema.oneOf ?? schema.anyOf).map(schemaToIR);
-        const rawDisc = schema.discriminator;
-        if (rawDisc) {
-            const propertyName = rawDisc.propertyName;
-            const rawMapping = rawDisc.mapping;
-            let mapping;
-            if (rawMapping) {
-                mapping = {};
-                for (const [k, v] of Object.entries(rawMapping)) {
-                    const parts = v.split("/");
-                    mapping[k] = parts[parts.length - 1];
-                }
-            }
-            const discriminator = { propertyName };
-            if (mapping)
-                discriminator.mapping = mapping;
-            return { discriminator, kind: "union", variants };
-        }
-        return { kind: "union", variants };
-    }
-    /* enum detection precedes type branching — {enum:[...]} can lack type */
-    if (Array.isArray(schema.enum)) {
-        const enumVals = schema.enum;
-        if (isStringEnum(schema))
-            return { enum: enumVals, kind: "scalar", type: "string" };
-        if (isIntEnum(schema))
-            return { enum: enumVals, kind: "scalar", type: "integer" };
-        /* mixed enum (string + number values) — emit as union of const literals */
-        if (enumVals.length > 0 &&
-            enumVals.every((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")) {
-            return { kind: "union", variants: enumVals.map((v) => ({ kind: "const", value: v })) };
-        }
-    }
-    if (schema.format === "binary" && (schema.type === "string" || schema.type === undefined)) {
-        return { kind: "binary" };
-    }
-    if (schema.type === "array" || Array.isArray(schema.items)) {
-        if (Array.isArray(schema.items)) {
-            const items = schema.items.map(schemaToIR);
-            return { items, kind: "tuple" };
-        }
-        const items = schema.items ? schemaToIR(schema.items) : { kind: "unknown" };
-        return { items, kind: "array" };
-    }
-    if (schema.type === "object" || schema.properties !== undefined || schema.additionalProperties !== undefined) {
-        const props = (schema.properties ?? {});
-        const requiredKeys = new Set(schema.required ?? []);
-        const fields = Object.entries(props).map(([name, propSchema]) => {
-            const field = {
-                name,
-                required: requiredKeys.has(name),
-                schema: schemaToIR(propSchema),
-            };
-            if (typeof propSchema.description === "string")
-                field.description = propSchema.description;
-            return field;
-        });
-        let additional;
-        const ap = schema.additionalProperties;
-        if (ap === false) {
-            additional = false;
-        }
-        else if (ap === true) {
-            additional = { kind: "unknown" };
-        }
-        else if (ap !== undefined) {
-            additional = schemaToIR(ap);
-        }
-        const result = {
-            fields,
-            kind: "object",
-        };
-        if (additional !== undefined)
-            result.additional = additional;
-        return result;
-    }
-    const t = schema.type;
-    if (t === "string" || t === "integer" || t === "number" || t === "boolean" || t === "null") {
-        const scalar = { kind: "scalar", type: t };
-        if (typeof schema.format === "string")
-            scalar.format = schema.format;
-        if (Array.isArray(schema.enum))
-            scalar.enum = schema.enum;
-        return scalar;
-    }
-    return { kind: "unknown" };
-}
-const HTTP_METHODS = ["get", "post", "put", "patch", "delete", "head", "options"];
-/** Splits an OpenAPI path template into literal and `{param}` pieces. Any text between braces is a name. */
-export function parseOpenApiPath(path) {
-    const out = [];
-    const re = /\{([^{}]+)\}/g;
-    let last = 0;
-    let match = re.exec(path);
-    while (match !== null) {
-        if (match.index > last)
-            out.push({ kind: "literal", text: path.slice(last, match.index) });
-        out.push({ kind: "param", name: match[1] });
-        last = match.index + match[0].length;
-        match = re.exec(path);
-    }
-    if (last < path.length)
-        out.push({ kind: "literal", text: path.slice(last) });
-    return out;
-}
-export function openApiPathParams(path) {
-    const names = [];
-    for (const seg of parseOpenApiPath(path)) {
-        if (seg.kind === "param" && !names.includes(seg.name))
-            names.push(seg.name);
-    }
-    return names;
-}
-/** Follows a component `$ref` on a parameter, request body or response object (not on schemas). */
-function deref(value, components, depth = 0) {
-    if (!value || typeof value !== "object")
-        return undefined;
-    const obj = value;
-    if (typeof obj.$ref !== "string" || depth > 16)
-        return obj;
-    const parts = obj.$ref.replace(/^#\//, "").split("/");
-    if (parts[0] !== "components" || parts.length !== 3)
-        return undefined;
-    const target = Object.hasOwn(components, parts[1]) ? components[parts[1]] : undefined;
-    const next = target && Object.hasOwn(target, parts[2]) ? target[parts[2]] : undefined;
-    return deref(next, components, depth + 1);
-}
-/** Resolves a top-level schema `$ref` against `components.schemas`, for shape checks only. */
-function resolveSchemaShallow(schema, components, depth = 0) {
-    if (!schema || typeof schema.$ref !== "string" || depth > 16)
-        return schema;
-    const name = schema.$ref.split("/").pop() ?? "";
-    const schemas = components.schemas ?? {};
-    const next = Object.hasOwn(schemas, name) ? schemas[name] : undefined;
-    return resolveSchemaShallow(next, components, depth + 1);
-}
-/** Detect whether a multipart/form-data schema has at least one binary (file) property. */
-function hasBinaryMultipartPart(schema, components) {
-    const props = schema?.properties;
-    if (!props)
-        return false;
-    for (const raw of Object.values(props)) {
-        const prop = resolveSchemaShallow(raw, components);
-        if (prop?.format === "binary")
-            return true;
-        if (prop?.type === "array") {
-            const items = resolveSchemaShallow(prop.items, components);
-            if (items?.format === "binary")
-                return true;
-        }
-    }
-    return false;
-}
-/** Normalise a multipart/form-data object schema into typed parts. */
-function extractMultipartParts(schema, components) {
-    const props = schema?.properties;
-    if (!props)
-        return [];
-    const parts = [];
-    for (const [name, propSchema] of Object.entries(props)) {
-        const resolved = resolveSchemaShallow(propSchema, components);
-        const resolvedItems = resolved?.type === "array"
-            ? resolveSchemaShallow(resolved.items, components)
-            : undefined;
-        const isBinary = resolved?.format === "binary" || resolvedItems?.format === "binary";
-        parts.push({ name, schema: schemaToIR(propSchema), type: isBinary ? "file" : "text" });
-    }
-    return parts;
-}
-/* JSON first, then the structured kinds, then whatever the spec lists first. */
-const BODY_PREFERENCE = [
-    "application/json",
-    "application/x-www-form-urlencoded",
-    "multipart/form-data",
-    "application/octet-stream",
-];
-function isJsonMediaType(ct) {
-    const essence = ct.split(";")[0]?.trim().toLowerCase() ?? "";
-    return essence === "application/json" || essence.endsWith("+json");
-}
-function contentTypeRank(ct) {
-    const essence = ct.split(";")[0]?.trim().toLowerCase() ?? "";
-    const i = BODY_PREFERENCE.indexOf(essence);
-    if (i >= 0)
-        return i;
-    return isJsonMediaType(ct) ? BODY_PREFERENCE.length : BODY_PREFERENCE.length + 1;
-}
-/** Content types in preference order; ties keep the order the spec lists them in. */
-function orderedContentTypes(content) {
-    return Object.keys(content)
-        .map((ct, i) => ({ ct, i, rank: contentTypeRank(ct) }))
-        .sort((a, b) => a.rank - b.rank || a.i - b.i)
-        .map((x) => x.ct);
-}
-function preferredContentType(content) {
-    return orderedContentTypes(content)[0];
-}
-function bodyFor(ct, mediaType, required, components) {
-    const rawSchema = mediaType?.schema;
-    const essence = ct.split(";")[0]?.trim().toLowerCase();
-    if (essence === "application/octet-stream") {
-        return { contentType: "application/octet-stream", kind: "stream", required };
-    }
-    if (essence === "multipart/form-data" &&
-        hasBinaryMultipartPart(resolveSchemaShallow(rawSchema, components), components)) {
-        const body = {
-            contentType: "multipart/form-data",
-            kind: "multipart",
-            parts: extractMultipartParts(resolveSchemaShallow(rawSchema, components), components),
-            required,
-        };
-        if (rawSchema)
-            body.schema = schemaToIR(rawSchema);
-        return body;
-    }
-    const bodySchema = rawSchema ? schemaToIR(rawSchema) : { kind: "unknown" };
-    return { contentType: ct, kind: "raw", required, schema: bodySchema };
-}
-function buildOperation(id, method, path, op, pathItem, components) {
-    const upperMethod = method.toUpperCase();
-    /* path-item parameters apply to every operation unless the operation overrides (same name + in) */
-    const opParams = (op.parameters ?? []).map((p) => deref(p, components));
-    const itemParams = (pathItem.parameters ?? []).map((p) => deref(p, components));
-    const declaredParams = [];
-    for (const p of opParams)
-        if (p)
-            declaredParams.push(p);
-    for (const p of itemParams) {
-        if (!p)
-            continue;
-        if (!declaredParams.some((d) => d.name === p.name && d.in === p.in))
-            declaredParams.push(p);
-    }
-    const pathParams = [];
-    const queryParams = [];
-    const headerParams = [];
-    const cookieParams = [];
-    const templateNames = openApiPathParams(path);
-    for (const p of declaredParams) {
-        const pIn = p.in;
-        const pName = String(p.name);
-        const pSchema = p.schema
-            ? schemaToIR(p.schema)
-            : { kind: "scalar", type: "string" };
-        const param = { name: pName, required: pIn === "path" || p.required === true, schema: pSchema };
-        if (typeof p.description === "string")
-            param.description = p.description;
-        if (p["x-honey-wildcard"] === true)
-            param.wildcard = true;
-        const pDefault = p.schema?.default;
-        if (pDefault !== undefined)
-            param.default = pDefault;
-        if (pIn === "path") {
-            /* a declared path param missing from the template cannot be sent */
-            if (templateNames.includes(pName))
-                pathParams.push(param);
-        }
-        else if (pIn === "query") {
-            queryParams.push(param);
-        }
-        else if (pIn === "header") {
-            headerParams.push(param);
-        }
-        else if (pIn === "cookie") {
-            cookieParams.push(param);
-        }
-    }
-    /* path params in template order; back-fill the ones absent from parameters[] */
-    const orderedPath = [];
-    for (const name of templateNames) {
-        orderedPath.push(pathParams.find((p) => p.name === name) ?? { name, required: true, schema: { kind: "scalar", type: "string" } });
-    }
-    let body;
-    const bodies = [];
-    const requestBody = deref(op.requestBody, components);
-    if (requestBody) {
-        const content = requestBody.content;
-        const required = requestBody.required === true;
-        for (const ct of content ? orderedContentTypes(content) : []) {
-            bodies.push(bodyFor(ct, content?.[ct], required, components));
-        }
-        body = bodies[0];
-    }
-    const responses = {};
-    const extensions = {};
-    const rawResponses = op.responses;
-    if (rawResponses) {
-        for (const [status, rawResponse] of Object.entries(rawResponses)) {
-            const response = deref(rawResponse, components) ?? {};
-            const content = response.content;
-            if (!content || Object.keys(content).length === 0) {
-                responses[status] = { status };
-                continue;
-            }
-            /* SSE detected by response content-type, not a request extension */
-            if (Object.keys(content).some((k) => k.split(";")[0]?.trim().toLowerCase() === "text/event-stream")) {
-                extensions.sse = true;
-            }
-            const ct = preferredContentType(content) ?? Object.keys(content)[0];
-            const mediaType = content[ct];
-            const respSchema = mediaType?.schema ? schemaToIR(mediaType.schema) : undefined;
-            const resp = { contentType: ct, status };
-            if (respSchema !== undefined)
-                resp.schema = respSchema;
-            responses[status] = resp;
-        }
-    }
-    if (op["x-websocket"] === true)
-        extensions.websocket = true;
-    if (op["x-realtime"] === true)
-        extensions.realtime = true;
-    if (op["x-deprecated"] === true || op.deprecated === true)
-        extensions.deprecated = true;
-    if (op["x-idempotency-key"] === true)
-        extensions.idempotencyKey = true;
-    if (op["x-mcp"] === true)
-        extensions.mcp = true;
-    if (Array.isArray(op["x-invalidate"])) {
-        extensions.invalidates = op["x-invalidate"].filter((x) => typeof x === "string");
-    }
-    const operation = {
-        extensions,
-        id,
-        method: upperMethod,
-        params: { header: headerParams, path: orderedPath, query: queryParams },
-        path,
-        responses,
-    };
-    if (cookieParams.length > 0)
-        operation.params.cookie = cookieParams;
-    if (body)
-        operation.body = body;
-    if (bodies.length > 1)
-        operation.bodies = bodies;
-    if (typeof op.description === "string")
-        operation.description = op.description;
-    if (typeof op.summary === "string")
-        operation.summary = op.summary;
-    return operation;
-}
-/** Deterministic id for an operation without an `operationId`: `GET /users/{id}` → `getUsersById`. */
-export function deriveOperationId(method, path) {
-    const literal = [];
-    const params = [];
-    for (const seg of parseOpenApiPath(path)) {
-        if (seg.kind === "param")
-            params.push(pascalWords(seg.name));
-        else
-            literal.push(pascalWords(seg.text));
-    }
-    const base = `${method.toLowerCase()}${literal.join("")}${params.length > 0 ? `By${params.join("And")}` : ""}`;
-    return base === method.toLowerCase() ? `${base}Root` : base;
-}
-export function toIR(spec, options = {}) {
-    const schemas = {};
-    for (const [name, schema] of Object.entries(spec.components?.schemas ?? {})) {
-        schemas[name] = schemaToIR(schema);
-    }
-    const components = (spec.components ?? {});
-    const operations = [];
-    const seen = new Set();
-    const pending = [];
-    for (const [path, pathItem] of Object.entries(spec.paths ?? {})) {
-        for (const method of HTTP_METHODS) {
-            const op = pathItem[method];
-            if (!op)
-                continue;
-            const id = op.operationId;
-            if (!id) {
-                if (options.deriveOperationIds)
-                    pending.push({ method, op, path, pathItem: pathItem });
-                continue;
-            }
-            let finalId = id;
-            if (seen.has(id)) {
-                const onDuplicate = options.duplicateOperationIds ?? (options.deriveOperationIds ? "suffix" : "throw");
-                if (onDuplicate === "throw")
-                    throw new Error(`Duplicate operationId: "${id}"`);
-                finalId = `${id}${pascalWords(method)}`;
-                for (let i = 2; seen.has(finalId); i++)
-                    finalId = `${id}${pascalWords(method)}${i}`;
-            }
-            seen.add(finalId);
-            operations.push(buildOperation(finalId, method, path, op, pathItem, components));
-        }
-    }
-    /* derived ids after explicit ones, so an explicit id always keeps its name */
-    const namespaceRoots = new Set(operations.map((o) => o.id.split(".")[0] ?? o.id));
-    for (const { method, op, path, pathItem } of pending) {
-        const base = deriveOperationId(method, path);
-        let id = base;
-        for (let i = 2; seen.has(id) || namespaceRoots.has(id); i++)
-            id = `${base}${i}`;
-        seen.add(id);
-        operations.push(buildOperation(id, method, path, op, pathItem, components));
-    }
-    const tree = buildResourceTree(operations);
-    const schemaDescriptions = {};
-    for (const [name, schema] of Object.entries(spec.components?.schemas ?? {})) {
-        if (typeof schema.description === "string")
-            schemaDescriptions[name] = schema.description;
-    }
-    return { auth: specAuth(spec), info: infoOf(spec), operations, schemaDescriptions, schemas, tree };
-}
-/**
- * The first security scheme (code-unit order) decides the header: http basic → `Basic `, other
- * http → `Bearer `, a header apiKey → its name, with a prefix when its description says
- * `Format: <prefix> {token}`. Anything else, or no scheme, is `Authorization: Bearer`.
- */
-export function specAuth(spec) {
-    const components = (spec.components ?? {});
-    const schemes = (components.securitySchemes ?? {});
-    const keys = Object.keys(schemes).sort(cmpCodeUnit);
-    const fallback = { headerName: "Authorization", prefix: "Bearer " };
-    const scheme = keys.length > 0 ? schemes[keys[0]] : undefined;
-    if (!scheme)
-        return fallback;
-    const type = String(scheme.type ?? "");
-    if (type === "http") {
-        const httpScheme = String(scheme.scheme ?? "").toLowerCase();
-        return { headerName: "Authorization", prefix: httpScheme === "basic" ? "Basic " : "Bearer " };
-    }
-    if (type === "apiKey" && scheme.in === "header") {
-        const headerName = String(scheme.name ?? "Authorization");
-        const match = /Format:\s*(\S+)\s+\{/i.exec(String(scheme.description ?? ""));
-        return { headerName, prefix: match ? `${match[1]} ` : "" };
-    }
-    return fallback;
-}
-function infoOf(spec) {
-    const info = (spec.info ?? {});
-    const out = {};
-    for (const key of ["title", "description", "version"]) {
-        if (typeof info[key] === "string")
-            out[key] = info[key];
-    }
-    return out;
-}
-/** Every request body an operation declares, preferred first. */
-export function bodiesOf(op) {
-    return op.bodies ?? (op.body ? [op.body] : []);
-}
-/** Follows `ref` nodes to their component schema; an unknown ref resolves to `unknown`. */
-export function irResolver(schemas) {
-    return (schema) => {
-        let cur = schema;
-        for (let i = 0; i < 32 && cur.kind === "ref"; i++) {
-            const next = Object.hasOwn(schemas, cur.name) ? schemas[cur.name] : undefined;
-            if (!next)
-                return { kind: "unknown" };
-            cur = next;
-        }
-        return cur;
-    };
-}
-function isStringSchema(s) {
-    return s?.kind === "scalar" && s.type === "string";
-}
-/**
- * Honey's standard error envelope (`success: false`, `error_key` enum, one `status`), read from the IR.
- * Returns its error keys and status, or null for any other shape.
- */
-export function irErrorEnvelope(schema, resolve) {
-    const obj = resolve(schema);
-    if (obj.kind !== "object")
-        return null;
-    const field = (o, name) => {
-        const f = o.fields.find((x) => x.name === name);
-        return f ? resolve(f.schema) : undefined;
-    };
-    const success = field(obj, "success");
-    if (success?.kind !== "const" || success.value !== false)
-        return null;
-    if (!isStringSchema(field(obj, "message")) || !isStringSchema(field(obj, "status_key")))
-        return null;
-    const fields = field(obj, "fields");
-    if (fields?.kind !== "object" || !fields.additional)
-        return null;
-    const list = resolve(fields.additional);
-    if (list.kind !== "array")
-        return null;
-    const item = resolve(list.items);
-    if (item.kind !== "object")
-        return null;
-    for (const k of ["error_key", "message", "path"])
-        if (!isStringSchema(field(item, k)))
-            return null;
-    const status = field(obj, "status");
-    if (status?.kind !== "scalar" || !status.enum || status.enum.length !== 1)
-        return null;
-    const statusVal = status.enum[0];
-    if (typeof statusVal !== "number")
-        return null;
-    const key = field(obj, "error_key");
-    if (key?.kind !== "scalar" || !key.enum || key.enum.length === 0)
-        return null;
-    if (!key.enum.every((k) => typeof k === "string"))
-        return null;
-    return { keys: key.enum, status: statusVal };
-}
-//# sourceMappingURL=codegen-ir.js.map