@lovrozagar/honey 0.6.5 → 0.7.0

package/dist/codegen-ir.js

@@ -0,0 +1,661 @@
+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