@databehave/server 0.1.0

package/dist/openapi/register.js

@@ -0,0 +1,166 @@
+import { generateFromOasSchema } from './generate.js';
+const SUPPORTED_METHODS = new Set([
+    'get',
+    'post',
+    'put',
+    'delete',
+    'patch',
+]);
+/**
+ * Convert OAS path syntax (`/users/{id}`) into @databehave/server pattern syntax
+ * (`/users/:id`). Other `{x}` placeholders not isolated to a single
+ * segment are left as-is — the matcher will then reject them at
+ * registration time.
+ */
+const oasPathToInternal = (oasPath) => oasPath
+    .split('/')
+    .map((seg) => (seg.startsWith('{') && seg.endsWith('}') ? `:${seg.slice(1, -1)}` : seg))
+    .join('/');
+const stubBody = (method) => Object.freeze(method === 'get' ? {} : { success: true, message: null });
+const buildHandler = (body) => {
+    // The OAS-only generator is structurally deterministic — same
+    // schema → same value — so the body is materialised once at boot
+    // and re-served per request.
+    return () => ({ json: body });
+};
+const buildStubHandler = (_routePath, method) => {
+    const body = stubBody(method);
+    return () => ({ json: body });
+};
+/**
+ * `true` when an OAS schema node is empty / permissive (`{}`) —
+ * i.e. carries no shape information (no `$ref`, `type`, `enum`,
+ * `const`, `properties`, `items`, `allOf`, `oneOf`, `anyOf`).
+ * Per JSON Schema this matches any JSON value.
+ */
+const isEmptyOasSchema = (node) => !node.$ref &&
+    !node.type &&
+    !node.enum &&
+    node.const === undefined &&
+    !node.properties &&
+    !node.items &&
+    !node.allOf &&
+    !node.oneOf &&
+    !node.anyOf;
+/**
+ * Build a per-route per-status JSON body generator map from the OAS
+ * `responses` table. Used by mock-mode to synthesize an error body
+ * from the schema declared for that status code.
+ *
+ * Each generator is deterministic: same `(routeKey, status)` always
+ * yields the same body. Routes with `:param` segments are matched
+ * by exact path key only — runtime path-param substitution is the
+ * caller's responsibility.
+ *
+ * `onWalkError` mirrors `buildOpenApiRoutes` so spec gaps in error
+ * responses surface the same way as gaps in success responses.
+ */
+export const buildOpenApiResponseGenerators = (doc, options = {}) => {
+    const out = new Map();
+    const paths = doc.paths;
+    if (!paths)
+        return out;
+    for (const [oasPath, methods] of Object.entries(paths)) {
+        if (oasPath === '/')
+            continue;
+        const kitPath = oasPathToInternal(oasPath);
+        for (const [methodName, op] of Object.entries(methods)) {
+            const method = methodName.toLowerCase();
+            if (!SUPPORTED_METHODS.has(method))
+                continue;
+            const key = `${method.toUpperCase()} ${kitPath}`;
+            const responses = op.responses;
+            if (!responses)
+                continue;
+            const perStatus = new Map();
+            for (const [statusStr, resp] of Object.entries(responses)) {
+                const status = Number.parseInt(statusStr, 10);
+                if (!Number.isFinite(status))
+                    continue;
+                const schemaNode = resp?.content?.['application/json']?.schema;
+                if (!schemaNode || typeof schemaNode !== 'object')
+                    continue;
+                if (isEmptyOasSchema(schemaNode)) {
+                    // Permissive — let mock-mode fall back to its envelope.
+                    continue;
+                }
+                try {
+                    // Pre-generate at boot — the OAS-only generator is
+                    // structurally deterministic so the body is constant per
+                    // (route, status).
+                    const body = generateFromOasSchema(schemaNode, doc);
+                    perStatus.set(status, () => body);
+                }
+                catch (err) {
+                    // Caller's mock-mode fallback envelope will be used; surface
+                    // the spec gap so it can be fixed.
+                    options.onWalkError?.(method, kitPath, err);
+                }
+            }
+            if (perStatus.size > 0)
+                out.set(key, perStatus);
+        }
+    }
+    return out;
+};
+/**
+ * Produce a `Map<RouteKey, Handler>` covering every OAS
+ * `paths.<p>.<m>` not in `skip`. Failing schemas fall back to the
+ * stub body and report via `onWalkError` (default: ignore).
+ */
+export const buildOpenApiRoutes = (doc, options = {}) => {
+    const out = new Map();
+    const skip = options.skip ?? new Set();
+    const paths = doc.paths;
+    if (!paths)
+        return out;
+    for (const [oasPath, methods] of Object.entries(paths)) {
+        if (oasPath === '/')
+            continue;
+        const kitPath = oasPathToInternal(oasPath);
+        for (const [methodName, op] of Object.entries(methods)) {
+            const method = methodName.toLowerCase();
+            if (!SUPPORTED_METHODS.has(method))
+                continue;
+            const key = `${method.toUpperCase()} ${kitPath}`;
+            if (skip.has(key))
+                continue;
+            // Prefer 200, then the smallest declared 2xx response \u2014 OAS
+            // documents for mutating endpoints often only declare 201 / 202
+            // / 204, so falling back to those keeps the synthesised handler
+            // honest. 204 explicitly means \"no body\" and is handled below.
+            const responses = op.responses ?? {};
+            const twoXx = Object.keys(responses)
+                .map((s) => Number.parseInt(s, 10))
+                .filter((n) => Number.isFinite(n) && n >= 200 && n < 300)
+                .sort((a, b) => (a === 200 ? -1 : b === 200 ? 1 : a - b));
+            const pickedStatus = twoXx[0];
+            const pickedKey = pickedStatus !== undefined ? String(pickedStatus) : '200';
+            const responseSchema = responses[pickedKey]?.content?.['application/json']?.schema;
+            try {
+                if (pickedStatus === 204) {
+                    out.set(key, buildStubHandler(kitPath, method));
+                }
+                else if (responseSchema && typeof responseSchema === 'object') {
+                    if (isEmptyOasSchema(responseSchema)) {
+                        options.onEmptySchema?.(method, kitPath, pickedStatus ?? 200);
+                        out.set(key, buildStubHandler(kitPath, method));
+                    }
+                    else {
+                        const body = generateFromOasSchema(responseSchema, doc);
+                        out.set(key, buildHandler(body));
+                    }
+                }
+                else {
+                    out.set(key, buildStubHandler(kitPath, method));
+                }
+            }
+            catch (err) {
+                options.onWalkError?.(method, kitPath, err);
+                out.set(key, buildStubHandler(kitPath, method));
+            }
+        }
+    }
+    return out;
+};
+//# sourceMappingURL=register.js.map

package/dist/openapi/register.js.map

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

package/dist/openapi/seed.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pure helper for building deterministic databehave seed strings.
+ *
+ * Seed format: `<endpoint>|<sortedKey>=<val>|...|date=<YYYY-MM-DD>|day=<n>`.
+ * Same input → same string → databehave yields byte-identical JSON. Re-exported
+ * from `@databehave/server` so consumers can derive their own seeds without
+ * reimplementing the format.
+ */
+export type SeedInput = {
+    endpoint: string;
+    from?: string;
+    dayOffset?: number;
+    extra?: Record<string, unknown>;
+};
+export declare const seedFor: (i: SeedInput) => string;
+//# sourceMappingURL=seed.d.ts.map

package/dist/openapi/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../../src/openapi/seed.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAChC,CAAA;AAmCD,eAAO,MAAM,OAAO,GAAI,GAAG,SAAS,KAAG,MAWtC,CAAA"}

package/dist/openapi/seed.js

@@ -0,0 +1,58 @@
+/**
+ * Pure helper for building deterministic databehave seed strings.
+ *
+ * Seed format: `<endpoint>|<sortedKey>=<val>|...|date=<YYYY-MM-DD>|day=<n>`.
+ * Same input → same string → databehave yields byte-identical JSON. Re-exported
+ * from `@databehave/server` so consumers can derive their own seeds without
+ * reimplementing the format.
+ */
+/**
+ * Recursively rebuild `v` with object keys sorted so two structurally
+ * identical objects with different insertion orders serialise to the
+ * same string. Arrays preserve order (semantic), plain objects are
+ * key-sorted, primitives are returned as-is.
+ */
+const sortKeys = (v) => {
+    if (v === null || typeof v !== 'object')
+        return v;
+    if (Array.isArray(v))
+        return v.map(sortKeys);
+    const out = {};
+    for (const k of Object.keys(v).sort()) {
+        out[k] = sortKeys(v[k]);
+    }
+    return out;
+};
+const stringifyExtra = (v) => {
+    if (v === null || v === undefined)
+        return String(v);
+    const t = typeof v;
+    if (t === 'string' || t === 'number' || t === 'boolean' || t === 'bigint') {
+        return String(v);
+    }
+    // Objects / arrays — use JSON so distinct shapes produce distinct
+    // seeds. Keys are sorted recursively so insertion-order doesn't
+    // perturb the seed. Falls back to `String()` if stringify fails
+    // (cycles).
+    try {
+        return JSON.stringify(sortKeys(v));
+    }
+    catch {
+        return String(v);
+    }
+};
+export const seedFor = (i) => {
+    const parts = [i.endpoint];
+    if (i.extra) {
+        const keys = Object.keys(i.extra).sort();
+        if (keys.length > 0) {
+            parts.push(keys.map((k) => `${k}=${stringifyExtra(i.extra[k])}`).join('|'));
+        }
+    }
+    if (i.from !== undefined)
+        parts.push(`date=${i.from}`);
+    if (i.dayOffset !== undefined)
+        parts.push(`day=${i.dayOffset}`);
+    return parts.join('|');
+};
+//# sourceMappingURL=seed.js.map

package/dist/openapi/seed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.js","sourceRoot":"","sources":["../../src/openapi/seed.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH;;;;;GAKG;AACH,MAAM,QAAQ,GAAG,CAAC,CAAU,EAAW,EAAE;IACvC,IAAI,CAAC,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,OAAO,CAAC,CAAA;IACjD,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;IAC5C,MAAM,GAAG,GAA4B,EAAE,CAAA;IACvC,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,CAA4B,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QACjE,GAAG,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAE,CAA6B,CAAC,CAAC,CAAC,CAAC,CAAA;IACtD,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC,CAAA;AAED,MAAM,cAAc,GAAG,CAAC,CAAU,EAAU,EAAE;IAC5C,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC,CAAC,CAAC,CAAA;IACnD,MAAM,CAAC,GAAG,OAAO,CAAC,CAAA;IAClB,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,QAAQ,EAAE,CAAC;QAC1E,OAAO,MAAM,CAAC,CAAC,CAAC,CAAA;IAClB,CAAC;IACD,kEAAkE;IAClE,gEAAgE;IAChE,gEAAgE;IAChE,YAAY;IACZ,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;IACpC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,MAAM,CAAC,CAAC,CAAC,CAAA;IAClB,CAAC;AACH,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,CAAY,EAAU,EAAE;IAC9C,MAAM,KAAK,GAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAA;IACpC,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC;QACZ,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAA;QACxC,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,cAAc,CAAC,CAAC,CAAC,KAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAA;QAC9E,CAAC;IACH,CAAC;IACD,IAAI,CAAC,CAAC,IAAI,KAAK,SAAS;QAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC,CAAA;IACtD,IAAI,CAAC,CAAC,SAAS,KAAK,SAAS;QAAE,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAA;IAC/D,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACxB,CAAC,CAAA"}

package/dist/openapi/translate.d.ts

@@ -0,0 +1,55 @@
+/**
+ * OpenAPI-node → @databehave/schema IR translator.
+ *
+ * Phase 2C step 2C.a: pure translator + unit tests. NOT yet wired into
+ * the OAS dispatch — `register.ts` and `generate.ts` still drive the
+ * default OAS-only mock path; this module is staged for the upcoming
+ * auto-schema mode where, when the consumer opts in via the JSONC
+ * `schema:` field, the server translates each response schema to the
+ * databehave IR and hands it to `mock()` for richer fixtures.
+ *
+ * Genuine-separation invariant: this file MUST NOT statically value-
+ * import `@databehave/schema`. The runtime DSL constructors are only
+ * loaded via `await import('@databehave/schema')` inside the function
+ * body, so OAS-only consumers who never opt in do not pay for the
+ * schema package at all. Type-only imports (`import type`) are erased
+ * at compile time and are fine.
+ *
+ * Supported OAS keywords (mirror `validation/validate.ts`):
+ *   type / enum / required / properties / items / nullable + ["X","null"] /
+ *   minLength / maxLength / pattern / minimum / maximum /
+ *   exclusiveMinimum / exclusiveMaximum / minItems / maxItems /
+ *   format (date | date-time | email | uuid | uri) /
+ *   $ref (intra-document only) / oneOf / anyOf / allOf (shallow merge) /
+ *   discriminator (propertyName + mapping) / example / examples / const /
+ *   additionalProperties (no-op for generation; nested schema is
+ *     recursively validated so unsupported inner keywords still FAIL LOUD).
+ *
+ * UNSUPPORTED keywords (FAIL LOUD at translate time, mirroring the
+ * validator): if / then / else / dependentSchemas / dependentRequired /
+ * unevaluatedProperties / unevaluatedItems / propertyNames /
+ * patternProperties / contentEncoding / contentMediaType /
+ * remote `http(s)://` $ref.
+ *
+ * Security guarantees mirror the validator:
+ *   - Pattern length capped at 1024 chars (ReDoS guard).
+ *   - `pattern` requires an own-node `maxLength` (ReDoS footgun).
+ *   - Recursion depth capped at 64 levels.
+ *   - $ref cycle detection via a build-time visited-pointer set.
+ *
+ * Precedence (mirrors `generate.ts` ordering, expressed via IR):
+ *   example > examples[0] > enum[0]/enum > const > $ref >
+ *   allOf (shallow merge of object branches) > oneOf[0]/union >
+ *   anyOf[0]/union > type-fallback.
+ */
+import type { Schema } from '@databehave/schema';
+import type { OasDoc as OasDocument, OasNode as OasSchemaNode } from './walker.js';
+/**
+ * Translate an OpenAPI schema node into a `@databehave/schema` IR
+ * Schema instance. Throws at translate time on unsupported keywords,
+ * malformed `$ref`s, `$ref` cycles, ReDoS-vulnerable patterns, and
+ * schemas that exceed the depth cap. See the file header for the
+ * full keyword matrix and security guarantees.
+ */
+export declare function translateOasToIR(node: OasSchemaNode, doc: OasDocument): Promise<Schema<unknown>>;
+//# sourceMappingURL=translate.d.ts.map

package/dist/openapi/translate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translate.d.ts","sourceRoot":"","sources":["../../src/openapi/translate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,EAAE,MAAM,IAAI,WAAW,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,aAAa,CAAA;AAgVlF;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,aAAa,EACnB,GAAG,EAAE,WAAW,GACf,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAO1B"}

package/dist/openapi/translate.js

@@ -0,0 +1,319 @@
+const DEPTH_CAP = 64;
+const PATTERN_MAX_LENGTH = 1024;
+const UNSUPPORTED_KEYWORDS = new Set([
+    'if', 'then', 'else',
+    'dependentSchemas', 'dependentRequired',
+    'unevaluatedProperties', 'unevaluatedItems',
+    'contentEncoding', 'contentMediaType',
+    'propertyNames', 'patternProperties',
+]);
+const FORMAT_MAP = {
+    date: 'date',
+    'date-time': 'datetime',
+    email: 'email',
+    uuid: 'uuid',
+    uri: 'url',
+};
+const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+const buildErr = (pointer, message) => new Error(`@databehave/server/openapi: ${message} (at ${pointer})`);
+const resolveRef = (ref, doc, pointer) => {
+    if (ref.includes('://'))
+        throw buildErr(pointer, `unsupported $ref: ${ref}`);
+    const m = /^#\/components\/schemas\/(.+)$/.exec(ref);
+    if (!m)
+        throw buildErr(pointer, `unsupported $ref: ${ref}`);
+    const name = decodeURIComponent(m[1]);
+    const target = doc.components?.schemas?.[name];
+    if (!target)
+        throw buildErr(pointer, `$ref not found: ${ref}`);
+    return target;
+};
+/**
+ * Build a databehave Schema from an arbitrary JSON value, used when
+ * an OAS node carries a literal `example` / `examples[0]` / `const`
+ * payload. Recursively maps objects → `obj({...})` and arrays →
+ * `tuple(...)` so the entire value is preserved in the IR.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const literalize = (value, m, pointer, depth) => {
+    if (depth > DEPTH_CAP) {
+        throw buildErr(pointer, `schema nesting exceeds depth cap of ${DEPTH_CAP}`);
+    }
+    if (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return m.literal(value);
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return m.tuple();
+        return m.tuple(...value.map((v) => literalize(v, m, pointer, depth + 1)));
+    }
+    if (isObj(value)) {
+        const fields = {};
+        for (const [k, v] of Object.entries(value)) {
+            fields[k] = literalize(v, m, pointer, depth + 1);
+        }
+        return m.obj(fields);
+    }
+    throw buildErr(pointer, `cannot literalize value of type ${typeof value}`);
+};
+const enterPtr = (ctx, segment) => ({
+    ...ctx,
+    pointer: `${ctx.pointer}/${segment}`,
+    depth: ctx.depth + 1,
+});
+const pickType = (node) => {
+    if (Array.isArray(node.type))
+        return node.type.find((t) => t !== 'null');
+    return node.type;
+};
+const isNullable = (node) => node.nullable === true || (Array.isArray(node.type) && node.type.includes('null'));
+const buildString = (node, ctx) => {
+    if (typeof node.pattern === 'string') {
+        if (node.pattern.length > PATTERN_MAX_LENGTH) {
+            throw buildErr(ctx.pointer, `pattern length ${node.pattern.length} exceeds cap of ${PATTERN_MAX_LENGTH} (ReDoS guard)`);
+        }
+        if (typeof node.maxLength !== 'number') {
+            throw buildErr(ctx.pointer, 'pattern requires maxLength on the same schema (footgun: ReDoS)');
+        }
+        try {
+            new RegExp(node.pattern);
+        }
+        catch (err) {
+            throw buildErr(ctx.pointer, `invalid pattern: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const fmt = typeof node.format === 'string' ? FORMAT_MAP[node.format] : undefined;
+    const stringNode = { kind: 'string', format: fmt ?? 'plain' };
+    if (typeof node.minLength === 'number')
+        stringNode.min = node.minLength;
+    if (typeof node.maxLength === 'number')
+        stringNode.max = node.maxLength;
+    if (typeof node.pattern === 'string')
+        stringNode.pattern = node.pattern;
+    return new ctx.m.StringSchema(stringNode);
+};
+const buildNumber = (node, ctx, isInt) => {
+    // schema's IR has only min/max (inclusive). exclusiveMinimum/Maximum are
+    // approximated as inclusive for IR mock-generation purposes — the
+    // generated value drift is at most one ulp / one int and acceptable for
+    // placeholder fixtures. The validator (validate.ts) still enforces the
+    // exact exclusive semantics on real inbound requests.
+    const numNode = { kind: 'number', int: isInt };
+    if (typeof node.minimum === 'number')
+        numNode.min = node.minimum;
+    else if (typeof node.exclusiveMinimum === 'number') {
+        numNode.min = node.exclusiveMinimum;
+    }
+    if (typeof node.maximum === 'number')
+        numNode.max = node.maximum;
+    else if (typeof node.exclusiveMaximum === 'number') {
+        numNode.max = node.exclusiveMaximum;
+    }
+    return new ctx.m.NumberSchema(numNode);
+};
+const buildArray = (node, ctx) => {
+    const itemNode = node.items ?? {};
+    const itemSchema = translate(itemNode, enterPtr(ctx, 'items'));
+    let arr = ctx.m.arr(itemSchema);
+    if (typeof node.minItems === 'number')
+        arr = arr.min(node.minItems);
+    if (typeof node.maxItems === 'number')
+        arr = arr.max(node.maxItems);
+    return arr;
+};
+const buildObject = (node, ctx) => {
+    const required = new Set(Array.isArray(node.required) ? node.required : []);
+    const fields = {};
+    for (const [k, child] of Object.entries(node.properties ?? {})) {
+        const childSchema = translate(child, enterPtr(ctx, `properties/${k}`));
+        fields[k] = required.has(k) ? childSchema : childSchema.optional();
+    }
+    // `additionalProperties` is a no-op for *generation* — we only ever
+    // emit the declared `properties` above, so we never invent extra
+    // keys regardless of the keyword's value. We still acknowledge it
+    // explicitly so the translator's keyword surface mirrors
+    // `validation/validate.ts` (which DOES enforce it on inbound bodies).
+    const ap = node.additionalProperties;
+    if (ap === false) {
+        // Strict-extra-keys: aligned with validator behaviour. No-op here.
+    }
+    else if (ap === true || ap === undefined) {
+        // Open object: no-op — generator never invents undeclared keys.
+    }
+    else if (isObj(ap)) {
+        // Schema form: translate-and-discard. We don't use the result for
+        // generation (we never emit extra keys), but recursing now means
+        // an unsupported nested keyword (e.g. `if`) FAILS LOUD at build
+        // time instead of being silently accepted.
+        translate(ap, enterPtr(ctx, 'additionalProperties'));
+    }
+    return ctx.m.obj(fields);
+};
+const buildDiscriminated = (node, ctx, disc) => {
+    const branches = {};
+    for (const [tag, ref] of Object.entries(disc.mapping)) {
+        const childCtx = enterPtr(ctx, `discriminator/mapping/${tag}`);
+        if (childCtx.refStack.includes(ref)) {
+            throw buildErr(childCtx.pointer, `$ref cycle detected: ${ref}`);
+        }
+        const target = resolveRef(ref, ctx.doc, childCtx.pointer);
+        const branchSchema = translate(target, {
+            ...childCtx,
+            refStack: [...childCtx.refStack, ref],
+            pointer: ref,
+        });
+        if (!(branchSchema instanceof ctx.m.ObjectSchema)) {
+            throw buildErr(childCtx.pointer, `discriminator branch ${JSON.stringify(tag)} must be an object schema`);
+        }
+        // Force the discriminator field to literal(tag) so `discriminated()`
+        // accepts the branch — OAS schemas typically declare it as
+        // `type: 'string'` rather than constraining to the tag value.
+        const objBranch = branchSchema;
+        const newFields = {
+            ...objBranch._fields,
+            [disc.propertyName]: ctx.m.literal(tag),
+        };
+        branches[tag] = ctx.m.obj(newFields);
+    }
+    return ctx.m.discriminated(disc.propertyName, branches);
+};
+const buildAllOfMerge = (node, ctx) => {
+    // Mirror generate.ts: shallow-merge object-typed branches into a
+    // single obj schema. If any branch isn't object-typed once translated
+    // we bail and let the caller fall through to other precedence rules.
+    const merged = {};
+    let allObjects = true;
+    for (let i = 0; i < node.allOf.length; i++) {
+        const branch = translate(node.allOf[i], enterPtr(ctx, `allOf/${i}`));
+        if (!(branch instanceof ctx.m.ObjectSchema)) {
+            allObjects = false;
+            break;
+        }
+        const fields = branch._fields;
+        for (const [k, v] of Object.entries(fields))
+            merged[k] = v;
+    }
+    if (!allObjects)
+        return null;
+    return ctx.m.obj(merged);
+};
+const translate = (node, ctx) => {
+    if (ctx.depth > DEPTH_CAP) {
+        throw buildErr(ctx.pointer, `schema nesting exceeds depth cap of ${DEPTH_CAP}`);
+    }
+    if (!isObj(node))
+        throw buildErr(ctx.pointer, 'schema node must be an object');
+    for (const key of Object.keys(node)) {
+        if (UNSUPPORTED_KEYWORDS.has(key)) {
+            throw buildErr(ctx.pointer, `unsupported JSON Schema keyword: ${key}`);
+        }
+    }
+    // Precedence (mirrors generate.ts):
+    //   example > examples[0] > enum > const > $ref > allOf > oneOf > anyOf > type
+    if (node.example !== undefined) {
+        return literalize(node.example, ctx.m, ctx.pointer, ctx.depth);
+    }
+    if (Array.isArray(node.examples) && node.examples.length > 0) {
+        return literalize(node.examples[0], ctx.m, ctx.pointer, ctx.depth);
+    }
+    if (Array.isArray(node.enum) && node.enum.length > 0) {
+        const allStrNum = node.enum.every((v) => typeof v === 'string' || typeof v === 'number');
+        return allStrNum
+            ? ctx.m.enum_(node.enum)
+            : ctx.m.union(...node.enum.map((v) => literalize(v, ctx.m, ctx.pointer, ctx.depth)));
+    }
+    if (node.const !== undefined) {
+        return literalize(node.const, ctx.m, ctx.pointer, ctx.depth);
+    }
+    if (typeof node.$ref === 'string') {
+        if (ctx.refStack.includes(node.$ref)) {
+            throw buildErr(ctx.pointer, `$ref cycle detected: ${[...ctx.refStack, node.$ref].join(' -> ')}`);
+        }
+        const target = resolveRef(node.$ref, ctx.doc, ctx.pointer);
+        const out = translate(target, {
+            ...ctx,
+            refStack: [...ctx.refStack, node.$ref],
+            depth: ctx.depth + 1,
+            pointer: node.$ref,
+        });
+        return isNullable(node) ? out.nullable() : out;
+    }
+    if (Array.isArray(node.allOf) && node.allOf.length > 0) {
+        const merged = buildAllOfMerge(node, ctx);
+        if (merged !== null)
+            return isNullable(node) ? merged.nullable() : merged;
+    }
+    const disc = node.discriminator;
+    if (Array.isArray(node.oneOf) && node.oneOf.length > 0) {
+        if (disc && disc.mapping) {
+            const out = buildDiscriminated(node, ctx, { propertyName: disc.propertyName, mapping: disc.mapping });
+            return isNullable(node) ? out.nullable() : out;
+        }
+        const branches = node.oneOf.map((b, i) => translate(b, enterPtr(ctx, `oneOf/${i}`)));
+        const out = ctx.m.union(...branches);
+        return isNullable(node) ? out.nullable() : out;
+    }
+    if (Array.isArray(node.anyOf) && node.anyOf.length > 0) {
+        const branches = node.anyOf.map((b, i) => translate(b, enterPtr(ctx, `anyOf/${i}`)));
+        const out = ctx.m.union(...branches);
+        return isNullable(node) ? out.nullable() : out;
+    }
+    // type-fallback
+    let t = pickType(node);
+    if (!t && node.properties)
+        t = 'object';
+    if (!t && node.items !== undefined)
+        t = 'array';
+    if (!t) {
+        // Unknown / open node: best-effort — empty object schema, with
+        // nullable applied if requested.
+        const empty = ctx.m.obj({});
+        return isNullable(node) ? empty.nullable() : empty;
+    }
+    let built;
+    switch (t) {
+        case 'string':
+            built = buildString(node, ctx);
+            break;
+        case 'integer':
+            built = buildNumber(node, ctx, true);
+            break;
+        case 'number':
+            built = buildNumber(node, ctx, false);
+            break;
+        case 'boolean':
+            built = ctx.m.bool();
+            break;
+        case 'null':
+            built = ctx.m.null_();
+            break;
+        case 'array':
+            built = buildArray(node, ctx);
+            break;
+        case 'object':
+            built = buildObject(node, ctx);
+            break;
+        default:
+            throw buildErr(ctx.pointer, `unsupported OpenAPI type: ${t}`);
+    }
+    return isNullable(node) ? built.nullable() : built;
+};
+/**
+ * Translate an OpenAPI schema node into a `@databehave/schema` IR
+ * Schema instance. Throws at translate time on unsupported keywords,
+ * malformed `$ref`s, `$ref` cycles, ReDoS-vulnerable patterns, and
+ * schemas that exceed the depth cap. See the file header for the
+ * full keyword matrix and security guarantees.
+ */
+export async function translateOasToIR(node, doc) {
+    // Genuine-separation invariant: dynamic import only. Do NOT replace
+    // with a static `import { ... } from '@databehave/schema'` — that
+    // would re-introduce a runtime dependency on the schema package and
+    // break the OAS-only consumer's zero-dep posture.
+    const m = await import('@databehave/schema');
+    return translate(node, { doc, refStack: [], depth: 0, pointer: '#', m });
+}
+//# sourceMappingURL=translate.js.map