@zocomputer/system-api 0.0.0-stage → 0.1.1

package/dist/validation/schema.js

@@ -0,0 +1,1300 @@
+/**
+ * Bounded JSON Schema 2020-12 compiler and validator for the System API SDK — a
+ * faithful port of `hostagent.system_api.schema`, so the client accepts and
+ * rejects exactly the schemas and instances the server does, and returns the
+ * same canonical value.
+ *
+ * `compileSchema` admits one schema document (everything outside the supported
+ * dialect throws {@link SchemaDefinitionError}), normalizes it into one
+ * canonical form, and returns an immutable {@link CompiledSchema} whose
+ * `validate` returns a detached canonical value or throws
+ * {@link SchemaValidationError}.
+ *
+ * Structural traversal is delegated to Ajv 2020 (branch/sibling/oneOf/anyOf,
+ * `$ref`, `required`, `additionalProperties`, `items`, item/property/count
+ * limits, and `type`). Custom keywords override only where Ajv cannot meet the
+ * exact contract: every numeric comparison (`minimum`, `maximum`,
+ * `exclusiveMinimum`, `exclusiveMaximum`, `multipleOf`) and `enum`/`const`
+ * equality read the instance's exact decimal lexeme (a JS `number` loses
+ * precision), `pattern` runs the portable linear-time engine, `minLength` /
+ * `maxLength` count code points, integers are range-checked against
+ * ±(2**53 - 1), and `x-zo-json-value` admits any bounded JSON. Ajv still owns
+ * `oneOf`, so a discriminated union accepts/rejects by exact branch match.
+ */
+import { Decimal } from "decimal.js";
+import Ajv2020, {} from "ajv/dist/2020.js";
+import { JsonError, JsonNumber, canonicalNumberFromToken, canonicalizeJson, checkJsonValue, formatPointer, loadsJson, measureJson, } from "./json.js";
+import { PatternError, compilePattern, } from "./pattern.js";
+/** Exact decimal arithmetic for numeric keywords; matches the Python precision. */
+const Dec = Decimal.clone({ precision: 500 });
+export const SUPPORTED_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+export const MAX_SCHEMA_NODES = 10_000;
+export const MAX_SCHEMA_DEPTH = 32;
+/** Longest permitted chain of definitions reachable through `$ref` hops. */
+export const MAX_REF_CHAIN_DEPTH = MAX_SCHEMA_DEPTH;
+export const MAX_VALIDATION_ERRORS = 20;
+export const MAX_SAFE_INTEGER_EXACT = 2 ** 53 - 1;
+export const MAX_ENUM_VALUES = 256;
+export const MAX_UNION_BRANCHES = 64;
+export const MAX_TEXT_LENGTH = 4096;
+export const MAX_PROPERTY_NAME_LENGTH = 256;
+const MAX_SAFE_D = new Dec(MAX_SAFE_INTEGER_EXACT.toString());
+const REF_PREFIX = "#/$defs/";
+const DEF_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const ANNOTATIONS = new Set(["title", "description", "examples", "deprecated"]);
+const WRAPPER_KEYS = new Set([...ANNOTATIONS, "default"]);
+const NUMERIC_KEYWORDS = new Set([
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+]);
+const TYPE_KEYWORDS = {
+    string: new Set(["minLength", "maxLength", "pattern"]),
+    number: new Set([...NUMERIC_KEYWORDS]),
+    integer: new Set([...NUMERIC_KEYWORDS]),
+    boolean: new Set(),
+    null: new Set(),
+    array: new Set(["items", "minItems", "maxItems"]),
+    object: new Set([
+        "properties",
+        "required",
+        "additionalProperties",
+        "minProperties",
+        "maxProperties",
+    ]),
+};
+const TYPED_COMMON = new Set([...WRAPPER_KEYS, "type", "enum", "const"]);
+// --- errors ------------------------------------------------------------------
+/** Base for schema definition and validation failures. */
+export class SchemaError extends Error {
+    code;
+    path;
+    schemaPath;
+    keyword;
+    constructor(code, message, options = {}) {
+        const path = options.path ?? [];
+        const schemaPath = options.schemaPath ?? [];
+        let suffix = "";
+        if (path.length)
+            suffix += ` at ${formatPointer(path)}`;
+        if (schemaPath.length)
+            suffix += ` (schema ${formatPointer(schemaPath)})`;
+        super(message + suffix);
+        this.name = "SchemaError";
+        this.code = code;
+        this.path = path;
+        this.schemaPath = schemaPath;
+        this.keyword = options.keyword;
+    }
+}
+/** The schema document is outside the supported dialect or inconsistent. */
+export class SchemaDefinitionError extends SchemaError {
+    constructor(code, message, options = {}) {
+        super(code, message, options);
+        this.name = "SchemaDefinitionError";
+    }
+}
+/** A value does not conform to the compiled schema. */
+export class SchemaValidationError extends SchemaError {
+    constructor(code, message, options = {}) {
+        super(code, message, options);
+        this.name = "SchemaValidationError";
+    }
+}
+function pathKey(path) {
+    return JSON.stringify(path);
+}
+// --- type matching -----------------------------------------------------------
+function isPlainObject(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        !(value instanceof JsonNumber));
+}
+function matchesType(value, typeName) {
+    if (typeName === "null")
+        return value === null;
+    if (typeName === "boolean")
+        return typeof value === "boolean";
+    if (typeof value === "boolean")
+        return false;
+    if (typeName === "integer")
+        return value instanceof JsonNumber && value.isInteger;
+    if (typeName === "number")
+        return value instanceof JsonNumber;
+    if (typeName === "string")
+        return typeof value === "string";
+    if (typeName === "array")
+        return Array.isArray(value);
+    return isPlainObject(value);
+}
+function isNullNode(node) {
+    return (isPlainObject(node) &&
+        Object.keys(node).length === 1 &&
+        node["type"] === "null");
+}
+// --- exact value equality ----------------------------------------------------
+/** Deep equality that compares numbers by exact decimal value, not JS float. */
+function zoEqual(a, b) {
+    if (a instanceof JsonNumber || b instanceof JsonNumber) {
+        return (a instanceof JsonNumber &&
+            b instanceof JsonNumber &&
+            new Dec(a.text).eq(new Dec(b.text)));
+    }
+    if (a === null || b === null)
+        return a === b;
+    const ta = typeof a;
+    if (ta !== typeof b)
+        return false;
+    if (ta === "boolean" || ta === "string")
+        return a === b;
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b) || a.length !== b.length)
+            return false;
+        return a.every((item, index) => zoEqual(item, b[index]));
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+        const keys = Object.keys(a);
+        if (keys.length !== Object.keys(b).length)
+            return false;
+        return keys.every((key) => Object.hasOwn(b, key) && zoEqual(a[key], b[key]));
+    }
+    return false;
+}
+// --- pattern cache -----------------------------------------------------------
+const patternCache = new Map();
+function getPattern(pattern) {
+    let compiled = patternCache.get(pattern);
+    if (compiled === undefined) {
+        try {
+            compiled = compilePattern(pattern);
+        }
+        catch (error) {
+            if (error instanceof PatternError)
+                throw new SchemaDefinitionError("invalid_pattern", error.message, {
+                    keyword: "pattern",
+                });
+            throw error;
+        }
+        patternCache.set(pattern, compiled);
+    }
+    return compiled;
+}
+// --- schema preparation ------------------------------------------------------
+/**
+ * Convert a raw schema input into a {@link JsonValue} tree: finite JS numbers
+ * become exact {@link JsonNumber}s (through their shortest round-trip text, as
+ * pydantic-emitted floats are normalized server-side); existing `JsonNumber`s
+ * are kept. Mirrors the Python `_prepare` float normalization.
+ */
+function prepareSchema(value, path, depth) {
+    if (depth > MAX_SCHEMA_DEPTH + 1)
+        throw new SchemaDefinitionError("too_deep", "schema nesting exceeds the supported depth", { schemaPath: path });
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return value;
+    if (value instanceof JsonNumber)
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new SchemaDefinitionError("nonfinite_number", "schema numbers must be finite", { schemaPath: path });
+        try {
+            return canonicalNumberFromToken(JSON.stringify(value), path);
+        }
+        catch (error) {
+            if (error instanceof JsonError)
+                throw new SchemaDefinitionError(error.code, error.message, {
+                    schemaPath: path,
+                });
+            throw error;
+        }
+    }
+    if (typeof value === "bigint")
+        return canonicalNumberFromToken(value.toString(), path);
+    if (Array.isArray(value))
+        return value.map((item, index) => prepareSchema(item, [...path, index], depth + 1));
+    if (typeof value === "object") {
+        // Null-prototype so a schema key literally named `__proto__` (a data field
+        // named `__proto__` in `properties`, or a `$def` so named) is assigned as an
+        // own data property rather than invoking the inherited `__proto__` setter,
+        // which would drop the key (losing its rule) and mutate the prototype. This
+        // runs before canonicalizeJson, so the key must survive here to survive at
+        // all. Matches the null-proto materialization used throughout the validator.
+        const out = Object.create(null);
+        for (const [key, item] of Object.entries(value))
+            out[key] = prepareSchema(item, [...path, key], depth + 1);
+        return out;
+    }
+    throw new SchemaDefinitionError("unsupported_schema", "schema contains an unsupported value", { schemaPath: path });
+}
+// --- the compiler ------------------------------------------------------------
+class Compiler {
+    schema;
+    defs = new Map();
+    refEdges = new Map();
+    unions = new Map();
+    defaults = new Map();
+    constructor(schema) {
+        this.schema = schema;
+        this.refEdges.set(null, new Set());
+    }
+    fail(code, message, schemaPath, keyword) {
+        throw new SchemaDefinitionError(code, message, { schemaPath, keyword });
+    }
+    expectDict(node, schemaPath) {
+        if (!isPlainObject(node))
+            this.fail("unsupported_schema", "schema node must be an object", schemaPath);
+        return node;
+    }
+    checkAnnotations(node, schemaPath, allowDefault) {
+        for (const key of ["title", "description"]) {
+            if (key in node) {
+                const text = node[key];
+                if (!(typeof text === "string" &&
+                    Array.from(text).length <= MAX_TEXT_LENGTH))
+                    this.fail("invalid_annotation", `'${key}' must be a bounded string`, schemaPath, key);
+            }
+        }
+        if ("examples" in node && !Array.isArray(node["examples"]))
+            this.fail("invalid_annotation", "'examples' must be an array", schemaPath, "examples");
+        if ("deprecated" in node && typeof node["deprecated"] !== "boolean")
+            this.fail("invalid_annotation", "'deprecated' must be a boolean", schemaPath, "deprecated");
+        if ("default" in node) {
+            if (!allowDefault)
+                this.fail("default_not_allowed", "'default' is only supported on object properties", schemaPath, "default");
+            this.defaults.set(pathKey(schemaPath), {
+                path: schemaPath,
+                value: node["default"],
+            });
+        }
+    }
+    rejectUnknown(node, allowed, schemaPath) {
+        for (const key of Object.keys(node))
+            if (!allowed.has(key))
+                this.fail("unsupported_keyword", `keyword '${key}' is not supported here`, schemaPath, key);
+    }
+    compile() {
+        const root = this.expectDict(this.schema, []);
+        if ("$schema" in root) {
+            const dialect = root["$schema"];
+            delete root["$schema"];
+            if (dialect !== null && dialect !== SUPPORTED_DIALECT)
+                this.fail("unsupported_dialect", "only the JSON Schema 2020-12 dialect is supported", ["$schema"], "$schema");
+        }
+        if ("$defs" in root) {
+            const rawDefs = this.expectDict(root["$defs"], ["$defs"]);
+            delete root["$defs"];
+            for (const name of Object.keys(rawDefs))
+                if (!DEF_NAME.test(name))
+                    this.fail("invalid_ref", "definition names must be identifiers", ["$defs"], "$defs");
+            for (const [name, definition] of Object.entries(rawDefs))
+                this.defs.set(name, this.expectDict(definition, ["$defs", name]));
+            for (const [name, definition] of this.defs) {
+                this.refEdges.set(name, new Set());
+                this.normalize(definition, ["$defs", name], name, false);
+            }
+        }
+        this.normalize(root, [], null, false, true);
+        if (this.defs.size) {
+            // Null-prototype so a `$def` literally named `__proto__` survives as an own
+            // key (Ajv resolves a `$ref` to it correctly) instead of hitting the
+            // inherited setter and being dropped before the Ajv schema is built.
+            const defsObject = Object.create(null);
+            for (const [name, definition] of this.defs)
+                defsObject[name] = definition;
+            root["$defs"] = defsObject;
+        }
+        this.checkAcyclic();
+    }
+    normalize(raw, schemaPath, context, allowDefault, isRoot = false) {
+        const node = this.expectDict(raw, schemaPath);
+        if (isRoot)
+            for (const key of [
+                "$id",
+                "$anchor",
+                "$comment",
+                "$vocabulary",
+                "$dynamicAnchor",
+            ])
+                if (key in node)
+                    this.fail("unsupported_keyword", `keyword '${key}' is not supported`, schemaPath, key);
+        if ("$ref" in node) {
+            this.rejectUnknown(node, new Set([...WRAPPER_KEYS, "$ref"]), schemaPath);
+            const ref = node["$ref"];
+            if (typeof ref !== "string" || !ref.startsWith(REF_PREFIX))
+                this.fail("invalid_ref", "only local '#/$defs/<name>' references are supported", schemaPath, "$ref");
+            const name = ref.slice(REF_PREFIX.length);
+            if (!this.defs.has(name))
+                this.fail("invalid_ref", "reference names an undefined definition", schemaPath, "$ref");
+            this.refEdges.get(context).add(name);
+            this.checkAnnotations(node, schemaPath, allowDefault);
+            return;
+        }
+        if ("x-zo-json-value" in node) {
+            this.rejectUnknown(node, new Set([...WRAPPER_KEYS, "x-zo-json-value"]), schemaPath);
+            if (node["x-zo-json-value"] !== true)
+                this.fail("unsupported_keyword", "'x-zo-json-value' must be true", schemaPath, "x-zo-json-value");
+            this.checkAnnotations(node, schemaPath, allowDefault);
+            return;
+        }
+        if ("anyOf" in node) {
+            this.normalizeNullable(node, schemaPath, context, allowDefault);
+            return;
+        }
+        if ("oneOf" in node) {
+            this.normalizeUnion(node, schemaPath, context, allowDefault);
+            return;
+        }
+        if (!("type" in node))
+            this.fail("unsupported_schema", "schema node needs 'type', '$ref', 'anyOf', 'oneOf' or 'x-zo-json-value'", schemaPath);
+        if (Array.isArray(node["type"])) {
+            this.rewriteTypeList(node, schemaPath);
+            this.normalize(node, schemaPath, context, allowDefault, isRoot);
+            return;
+        }
+        this.normalizeTyped(node, schemaPath, context, allowDefault);
+    }
+    rewriteTypeList(node, schemaPath) {
+        const types = node["type"];
+        if (types.length !== 2 || !types.includes("null") || types[0] === types[1])
+            this.fail("unsupported_type", "a type list must be exactly [<type>, 'null']", schemaPath, "type");
+        const innerType = types[1] === "null" ? types[0] : types[1];
+        const inner = { type: innerType };
+        const wrapper = {};
+        for (const [key, value] of Object.entries(node)) {
+            if (key === "type")
+                continue;
+            if (WRAPPER_KEYS.has(key))
+                wrapper[key] = value;
+            else
+                inner[key] = value;
+        }
+        const enumValues = inner["enum"];
+        const enumPresent = Array.isArray(enumValues);
+        let nullAllowed = enumPresent
+            ? enumValues.some((item) => item === null)
+            : true;
+        const nonNull = enumPresent
+            ? enumValues.filter((item) => item !== null)
+            : null;
+        let nullOnly = enumPresent && nullAllowed && nonNull.length === 0;
+        if ("const" in inner) {
+            if (inner["const"] === null) {
+                if (!nullAllowed)
+                    this.fail("invalid_const", "'const' null contradicts an 'enum' without null", schemaPath, "const");
+                nullOnly = true;
+            }
+            else {
+                if (nullOnly)
+                    this.fail("invalid_const", "'const' contradicts a null-only 'enum'", schemaPath, "const");
+                nullAllowed = false;
+            }
+        }
+        for (const key of Object.keys(node))
+            delete node[key];
+        if (nullOnly) {
+            node["type"] = "null";
+            const innerKeywords = typeof innerType === "string"
+                ? (TYPE_KEYWORDS[innerType] ?? new Set())
+                : new Set();
+            for (const [key, value] of Object.entries(inner))
+                if (key !== "type" &&
+                    key !== "enum" &&
+                    key !== "const" &&
+                    !innerKeywords.has(key))
+                    node[key] = value;
+            if (enumPresent)
+                node["enum"] = [null];
+            if ("const" in inner)
+                node["const"] = null;
+        }
+        else {
+            if (nonNull !== null)
+                inner["enum"] = nonNull;
+            if (nullAllowed)
+                node["anyOf"] = [inner, { type: "null" }];
+            else
+                Object.assign(node, inner);
+        }
+        Object.assign(node, wrapper);
+    }
+    normalizeNullable(node, schemaPath, context, allowDefault) {
+        this.rejectUnknown(node, new Set([...WRAPPER_KEYS, "anyOf"]), schemaPath);
+        const branches = node["anyOf"];
+        if (!(Array.isArray(branches) &&
+            branches.length === 2 &&
+            branches.filter((branch) => isNullNode(branch)).length === 1))
+            this.fail("unsupported_keyword", "'anyOf' is supported only as the nullable form [X, {'type': 'null'}]", schemaPath, "anyOf");
+        const list = branches;
+        const innerRaw = isNullNode(list[1]) ? list[0] : list[1];
+        const inner = this.expectDict(innerRaw, [...schemaPath, "anyOf", 0]);
+        if (inner["type"] === "null" || "anyOf" in inner)
+            this.fail("unsupported_type", "a nullable node must wrap a non-null type", schemaPath, "anyOf");
+        node["anyOf"] = [inner, { type: "null" }];
+        this.normalize(inner, [...schemaPath, "anyOf", 0], context, false);
+        this.checkAnnotations(node, schemaPath, allowDefault);
+    }
+    normalizeUnion(node, schemaPath, context, allowDefault) {
+        this.rejectUnknown(node, new Set([...WRAPPER_KEYS, "oneOf", "discriminator"]), schemaPath);
+        const branches = node["oneOf"];
+        if (!Array.isArray(branches) ||
+            branches.length < 2 ||
+            branches.length > MAX_UNION_BRANCHES)
+            this.fail("unsupported_keyword", "'oneOf' needs between 2 and 64 branches", schemaPath, "oneOf");
+        branches.forEach((branch, index) => {
+            this.normalize(branch, [...schemaPath, "oneOf", index], context, false);
+        });
+        if ("discriminator" in node) {
+            const discriminator = this.expectDict(node["discriminator"], [
+                ...schemaPath,
+                "discriminator",
+            ]);
+            this.rejectUnknown(discriminator, new Set(["propertyName", "mapping"]), [
+                ...schemaPath,
+                "discriminator",
+            ]);
+            if (typeof discriminator["propertyName"] !== "string")
+                this.fail("invalid_discriminator", "'discriminator.propertyName' must be a string", schemaPath, "discriminator");
+            if ("mapping" in discriminator &&
+                !isPlainObject(discriminator["mapping"]))
+                this.fail("invalid_discriminator", "'discriminator.mapping' must be an object", schemaPath, "discriminator");
+        }
+        this.checkAnnotations(node, schemaPath, allowDefault);
+        this.unions.set(pathKey(schemaPath), { node, path: schemaPath });
+    }
+    normalizeTyped(node, schemaPath, context, allowDefault) {
+        const typeName = node["type"];
+        if (typeof typeName !== "string" || !(typeName in TYPE_KEYWORDS))
+            this.fail("unsupported_type", "unsupported 'type'", schemaPath, "type");
+        const allowed = new Set([
+            ...TYPED_COMMON,
+            ...TYPE_KEYWORDS[typeName],
+        ]);
+        this.rejectUnknown(node, allowed, schemaPath);
+        this.checkAnnotations(node, schemaPath, allowDefault);
+        if ("enum" in node) {
+            const values = node["enum"];
+            if (!Array.isArray(values) ||
+                values.length < 1 ||
+                values.length > MAX_ENUM_VALUES)
+                this.fail("invalid_enum", "'enum' must be a non-empty bounded array", schemaPath, "enum");
+            for (const value of values)
+                if (!matchesType(value, typeName))
+                    this.fail("invalid_enum", "'enum' values must match the declared type", schemaPath, "enum");
+        }
+        if ("const" in node && !matchesType(node["const"], typeName))
+            this.fail("invalid_const", "'const' must match the declared type", schemaPath, "const");
+        if (typeName === "string") {
+            this.checkLengthPair(node, "minLength", "maxLength", schemaPath);
+            if ("pattern" in node) {
+                if (typeof node["pattern"] !== "string")
+                    this.fail("invalid_pattern", "'pattern' must be a string", schemaPath, "pattern");
+                getPattern(node["pattern"]);
+            }
+        }
+        else if (typeName === "number" || typeName === "integer") {
+            this.checkNumericKeywords(node, schemaPath);
+        }
+        else if (typeName === "array") {
+            if (!("items" in node))
+                this.fail("unsupported_schema", "array schemas must declare 'items'", schemaPath, "items");
+            this.checkLengthPair(node, "minItems", "maxItems", schemaPath);
+            this.normalize(node["items"], [...schemaPath, "items"], context, false);
+        }
+        else if (typeName === "object") {
+            this.normalizeObject(node, schemaPath, context);
+        }
+    }
+    normalizeObject(node, schemaPath, context) {
+        if (!("additionalProperties" in node))
+            this.fail("open_object", "object schemas must declare 'additionalProperties' (false, or a schema for a map)", schemaPath, "additionalProperties");
+        this.checkLengthPair(node, "minProperties", "maxProperties", schemaPath);
+        const extra = node["additionalProperties"];
+        if (extra === false) {
+            const properties = node["properties"] ?? {};
+            if (!isPlainObject(properties))
+                this.fail("unsupported_schema", "'properties' must be an object", schemaPath, "properties");
+            node["properties"] = properties;
+            for (const [name, sub] of Object.entries(properties)) {
+                const nameLength = Array.from(name).length;
+                if (nameLength < 1 || nameLength > MAX_PROPERTY_NAME_LENGTH)
+                    this.fail("invalid_property_name", "property names must be 1-256 characters", schemaPath, "properties");
+                this.normalize(sub, [...schemaPath, "properties", name], context, true);
+            }
+            const required = node["required"] ?? [];
+            if (!(Array.isArray(required) &&
+                required.every((name) => typeof name === "string")))
+                this.fail("unsupported_schema", "'required' must be an array of property names", schemaPath, "required");
+            const names = required;
+            if (new Set(names).size !== names.length ||
+                names.some((name) => !(name in properties)))
+                this.fail("unsupported_schema", "'required' must list distinct declared properties", schemaPath, "required");
+            node["required"] = required;
+        }
+        else if (extra === true) {
+            this.fail("open_object", "'additionalProperties: true' is not supported", schemaPath, "additionalProperties");
+        }
+        else {
+            if ("properties" in node || "required" in node)
+                this.fail("unsupported_schema", "a map schema (additionalProperties: <schema>) cannot also declare 'properties' or 'required'", schemaPath, "additionalProperties");
+            this.normalize(extra, [...schemaPath, "additionalProperties"], context, false);
+        }
+    }
+    checkLengthPair(node, lowKey, highKey, schemaPath) {
+        for (const key of [lowKey, highKey]) {
+            if (!(key in node))
+                continue;
+            const value = node[key];
+            if (!(value instanceof JsonNumber &&
+                value.isInteger &&
+                !new Dec(value.text).isNegative()))
+                this.fail("invalid_limit", `'${key}' must be a non-negative integer`, schemaPath, key);
+        }
+        const low = node[lowKey];
+        const high = node[highKey];
+        if (low instanceof JsonNumber &&
+            high instanceof JsonNumber &&
+            new Dec(low.text).gt(new Dec(high.text)))
+            this.fail("invalid_limit", `'${lowKey}' exceeds '${highKey}'`, schemaPath, lowKey);
+    }
+    checkNumericKeywords(node, schemaPath) {
+        for (const key of NUMERIC_KEYWORDS) {
+            if (!(key in node))
+                continue;
+            if (!(node[key] instanceof JsonNumber))
+                this.fail("invalid_limit", `'${key}' must be a number`, schemaPath, key);
+        }
+        const step = node["multipleOf"];
+        if (step instanceof JsonNumber && !new Dec(step.text).gt(0))
+            this.fail("invalid_limit", "'multipleOf' must be positive", schemaPath, "multipleOf");
+        const lows = ["minimum", "exclusiveMinimum"]
+            .filter((key) => node[key] instanceof JsonNumber)
+            .map((key) => new Dec(node[key].text));
+        const highs = ["maximum", "exclusiveMaximum"]
+            .filter((key) => node[key] instanceof JsonNumber)
+            .map((key) => new Dec(node[key].text));
+        if (lows.length && highs.length) {
+            const maxLow = lows.reduce((a, b) => (a.gt(b) ? a : b));
+            const minHigh = highs.reduce((a, b) => (a.lt(b) ? a : b));
+            if (maxLow.gt(minHigh))
+                this.fail("invalid_limit", "numeric lower bound exceeds upper bound", schemaPath, "minimum");
+        }
+    }
+    checkAcyclic() {
+        const indegree = new Map();
+        for (const name of this.defs.keys())
+            indegree.set(name, 0);
+        for (const [source, targets] of this.refEdges) {
+            if (source === null)
+                continue;
+            for (const target of targets)
+                indegree.set(target, (indegree.get(target) ?? 0) + 1);
+        }
+        const ready = [...indegree]
+            .filter(([, count]) => count === 0)
+            .map(([name]) => name)
+            .sort();
+        const order = [];
+        while (ready.length) {
+            const name = ready.pop();
+            order.push(name);
+            for (const target of [...(this.refEdges.get(name) ?? [])].sort()) {
+                indegree.set(target, indegree.get(target) - 1);
+                if (indegree.get(target) === 0)
+                    ready.push(target);
+            }
+        }
+        if (order.length !== this.defs.size) {
+            const stuck = [...indegree]
+                .filter(([, count]) => count > 0)
+                .map(([name]) => name)
+                .sort()[0];
+            this.fail("recursive_ref", "recursive definitions are not supported", ["$defs", stuck], "$ref");
+        }
+        const height = new Map();
+        for (const name of [...order].reverse()) {
+            let best = 0;
+            for (const target of this.refEdges.get(name) ?? [])
+                best = Math.max(best, height.get(target) ?? 0);
+            height.set(name, 1 + best);
+            if (height.get(name) > MAX_REF_CHAIN_DEPTH)
+                this.fail("ref_chain_too_deep", `definitions chain through more than ${MAX_REF_CHAIN_DEPTH} '$ref' hops`, ["$defs", name], "$ref");
+        }
+    }
+}
+/** Analyze a normalized `oneOf` node into its discriminator + branch mapping. */
+function computeUnion(defs, unionNode, unionPath) {
+    const resolve = (node) => {
+        let current = node;
+        while ("$ref" in current) {
+            const ref = current["$ref"];
+            current = defs.get(ref.slice(REF_PREFIX.length));
+        }
+        return current;
+    };
+    const fail = (message, path, keyword) => {
+        throw new SchemaDefinitionError("ambiguous_union", message, {
+            schemaPath: path,
+            keyword,
+        });
+    };
+    const branches = unionNode["oneOf"];
+    const resolved = [];
+    branches.forEach((branch, index) => {
+        const node = resolve(branch);
+        if (node["type"] !== "object" || !isPlainObject(node["properties"]))
+            fail("every 'oneOf' branch must be a closed object", [...unionPath, "oneOf", index], "oneOf");
+        resolved.push(node);
+    });
+    const constOf = (node, name) => {
+        const properties = node["properties"];
+        const required = (node["required"] ?? []);
+        if (!(name in properties) || !required.includes(name))
+            return null;
+        const prop = resolve(properties[name]);
+        const constant = prop["const"];
+        return prop["type"] === "string" && typeof constant === "string"
+            ? constant
+            : null;
+    };
+    const firstProps = resolved[0]["properties"];
+    let candidates = [];
+    for (const name of Object.keys(firstProps)) {
+        const consts = resolved.map((node) => constOf(node, name));
+        if (consts.every((constant) => typeof constant === "string") &&
+            new Set(consts).size === consts.length)
+            candidates.push(name);
+    }
+    const discriminator = unionNode["discriminator"];
+    if (isPlainObject(discriminator)) {
+        const declared = discriminator["propertyName"];
+        if (!candidates.includes(declared))
+            throw new SchemaDefinitionError("invalid_discriminator", "'discriminator.propertyName' is not a required string constant distinct in every branch", { schemaPath: unionPath, keyword: "discriminator" });
+        candidates = [declared];
+    }
+    if (candidates.length !== 1)
+        fail("'oneOf' branches need exactly one shared required string 'const' property (or a 'discriminator')", unionPath, "oneOf");
+    const name = candidates[0];
+    const mapping = new Map();
+    resolved.forEach((node, index) => {
+        mapping.set(constOf(node, name), index);
+    });
+    if (isPlainObject(discriminator) &&
+        isPlainObject(discriminator["mapping"])) {
+        const declaredMapping = discriminator["mapping"];
+        const declaredKeys = new Set(Object.keys(declaredMapping));
+        if (declaredKeys.size !== mapping.size ||
+            [...mapping.keys()].some((tag) => !declaredKeys.has(tag)))
+            throw new SchemaDefinitionError("invalid_discriminator", "'discriminator.mapping' keys must equal the branch constants", { schemaPath: unionPath, keyword: "discriminator" });
+        for (const [tag, target] of Object.entries(declaredMapping)) {
+            const branch = branches[mapping.get(tag)];
+            if (branch["$ref"] !== target)
+                throw new SchemaDefinitionError("invalid_discriminator", "'discriminator.mapping' must reference the branch carrying each constant", { schemaPath: unionPath, keyword: "discriminator" });
+        }
+    }
+    return { property: name, branches: mapping };
+}
+function unescapePointerToken(token) {
+    return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+/** Resolve an Ajv `instancePath` (a JSON pointer) into the canonical tree. */
+function resolveInstance(root, instancePath) {
+    if (instancePath === "")
+        return root;
+    let current = root;
+    for (const raw of instancePath.split("/").slice(1)) {
+        const token = unescapePointerToken(raw);
+        if (Array.isArray(current))
+            current = current[Number(token)];
+        else if (isPlainObject(current))
+            current = current[token];
+        else
+            return undefined;
+    }
+    return current;
+}
+/**
+ * Build the plain schema handed to Ajv from the normalized canonical schema.
+ * Exact-decimal keywords carry their canonical text as a string so a custom
+ * keyword can recover the exact value; `enum` / `const` carry the exact
+ * members serialized as JSON text; integer nodes gain a range check.
+ */
+function buildAjvSchema(node) {
+    if (!isPlainObject(node))
+        return node;
+    const out = {};
+    for (const [key, value] of Object.entries(node)) {
+        if (key === "$ref") {
+            out["$ref"] = value;
+        }
+        else if (key === "$defs") {
+            // Null-prototype: a `$def` name is user-controlled, so a `__proto__` def
+            // name must land as an own key rather than the inherited setter.
+            const defs = Object.create(null);
+            for (const [name, definition] of Object.entries(value))
+                defs[name] = buildAjvSchema(definition);
+            out["$defs"] = defs;
+        }
+        else if (key === "type") {
+            out["type"] = value;
+            if (value === "integer")
+                out["zoIntegerRange"] = true;
+        }
+        else if (key === "anyOf" || key === "oneOf") {
+            out[key] = value.map(buildAjvSchema);
+        }
+        else if (key === "properties") {
+            // Ajv's `properties` keyword intentionally ignores a member literally
+            // named `__proto__` (its own prototype-pollution guard), so a declared
+            // `__proto__` property would go unenforced — with `additionalProperties:
+            // false` it wrongly rejects the valid field, otherwise the field goes
+            // unchecked. Emit that one member as an anchored `patternProperties` entry
+            // instead: Ajv honors `__proto__` there and in `required`, so the field's
+            // rule and its `additionalProperties` exemption are preserved with
+            // equivalent semantics. Every other name (constructor/toString included)
+            // validates correctly under `properties`. The map is null-prototype for
+            // the same reason the rest of the validator is.
+            const properties = Object.create(null);
+            let protoAjvSchema;
+            for (const [name, sub] of Object.entries(value)) {
+                if (name === "__proto__")
+                    protoAjvSchema = buildAjvSchema(sub);
+                else
+                    properties[name] = buildAjvSchema(sub);
+            }
+            out["properties"] = properties;
+            if (protoAjvSchema !== undefined)
+                out["patternProperties"] = { "^__proto__$": protoAjvSchema };
+        }
+        else if (key === "items" || key === "additionalProperties") {
+            out[key] = typeof value === "boolean" ? value : buildAjvSchema(value);
+        }
+        else if (key === "required") {
+            out["required"] = value;
+        }
+        else if (NUMERIC_KEYWORDS.has(key)) {
+            out[key] = value.text;
+        }
+        else if (key === "minLength" || key === "maxLength") {
+            out[key] = Number(value.text);
+        }
+        else if (key === "minItems" ||
+            key === "maxItems" ||
+            key === "minProperties" ||
+            key === "maxProperties") {
+            out[key] = Number(value.text);
+        }
+        else if (key === "enum") {
+            out["enum"] = serializeMembers(value);
+        }
+        else if (key === "const") {
+            out["const"] = serializeMembers([value]);
+        }
+        else if (key === "pattern") {
+            out["pattern"] = value;
+        }
+        else if (key === "x-zo-json-value") {
+            out["x-zo-json-value"] = true;
+        }
+        // annotations (title/description/examples/deprecated), `default` and
+        // `discriminator` are dropped: they never affect accept/reject, and Ajv
+        // owns `oneOf` branch selection directly.
+    }
+    return out;
+}
+/** Serialize exact members to a JSON string the keyword recovers losslessly. */
+function serializeMembers(members) {
+    const parts = [];
+    const write = (value) => {
+        if (value === null)
+            parts.push("null");
+        else if (value === true)
+            parts.push("true");
+        else if (value === false)
+            parts.push("false");
+        else if (typeof value === "string")
+            parts.push(JSON.stringify(value));
+        else if (value instanceof JsonNumber)
+            parts.push(value.text);
+        else if (Array.isArray(value)) {
+            parts.push("[");
+            value.forEach((item, index) => {
+                if (index)
+                    parts.push(",");
+                write(item);
+            });
+            parts.push("]");
+        }
+        else {
+            const keys = Object.keys(value);
+            parts.push("{");
+            keys.forEach((key, index) => {
+                if (index)
+                    parts.push(",");
+                parts.push(JSON.stringify(key), ":");
+                write(value[key]);
+            });
+            parts.push("}");
+        }
+    };
+    parts.push("[");
+    members.forEach((member, index) => {
+        if (index)
+            parts.push(",");
+        write(member);
+    });
+    parts.push("]");
+    return parts.join("");
+}
+function buildValidator(ajvSchema) {
+    // `passContext` forwards the `this` given to `validator.call(ctx, data)` into
+    // every custom keyword, so the exact-value keywords read a fresh per-call
+    // `{ root }` instead of instance-shared mutable state. The keyword callbacks
+    // are therefore plain functions (not arrows) so `this` binds to that context.
+    const ajv = new Ajv2020({
+        strict: false,
+        allErrors: false,
+        validateSchema: false,
+        useDefaults: false,
+        passContext: true,
+    });
+    for (const keyword of NUMERIC_KEYWORDS)
+        ajv.removeKeyword(keyword);
+    ajv.removeKeyword("enum");
+    ajv.removeKeyword("const");
+    ajv.removeKeyword("minLength");
+    ajv.removeKeyword("maxLength");
+    ajv.removeKeyword("pattern");
+    const numericCompare = (keyword, test) => {
+        ajv.addKeyword({
+            keyword,
+            schemaType: "string",
+            errors: false,
+            compile(schemaText) {
+                const limit = new Dec(schemaText);
+                return function (_data, dataCxt) {
+                    const instance = resolveInstance(this.root, dataCxt?.instancePath ?? "");
+                    if (!(instance instanceof JsonNumber))
+                        return true;
+                    return test(new Dec(instance.text), limit);
+                };
+            },
+        });
+    };
+    numericCompare("minimum", (value, limit) => value.gte(limit));
+    numericCompare("maximum", (value, limit) => value.lte(limit));
+    numericCompare("exclusiveMinimum", (value, limit) => value.gt(limit));
+    numericCompare("exclusiveMaximum", (value, limit) => value.lt(limit));
+    ajv.addKeyword({
+        keyword: "multipleOf",
+        schemaType: "string",
+        errors: false,
+        compile(schemaText) {
+            const step = new Dec(schemaText);
+            return function (_data, dataCxt) {
+                const instance = resolveInstance(this.root, dataCxt?.instancePath ?? "");
+                if (!(instance instanceof JsonNumber))
+                    return true;
+                try {
+                    return new Dec(instance.text).mod(step).isZero();
+                }
+                catch {
+                    return false;
+                }
+            };
+        },
+    });
+    ajv.addKeyword({
+        keyword: "zoIntegerRange",
+        schemaType: "boolean",
+        errors: false,
+        validate(_flag, _data, _schema, dataCxt) {
+            const instance = resolveInstance(this.root, dataCxt?.instancePath ?? "");
+            // A non-number instance is the `type` keyword's concern, not ours.
+            if (!(instance instanceof JsonNumber))
+                return true;
+            // Judge integerness on the lossless lexeme, not Ajv's rounded native: a
+            // decimal such as 1.0000000000000001 rounds to an integer float and slips
+            // past Ajv's `type: "integer"`, so reject a non-integer node here where the
+            // exact token is visible.
+            if (!instance.isInteger)
+                return false;
+            return !new Dec(instance.text).abs().gt(MAX_SAFE_D);
+        },
+    });
+    ajv.addKeyword({
+        keyword: "enum",
+        schemaType: "string",
+        errors: false,
+        compile(schemaText) {
+            const members = loadsJson(schemaText, { maxNodes: null });
+            return function (_data, dataCxt) {
+                const instance = resolveInstance(this.root, dataCxt?.instancePath ?? "");
+                return members.some((member) => zoEqual(instance, member));
+            };
+        },
+    });
+    ajv.addKeyword({
+        keyword: "const",
+        schemaType: "string",
+        errors: false,
+        compile(schemaText) {
+            const member = loadsJson(schemaText, { maxNodes: null })[0];
+            return function (_data, dataCxt) {
+                const instance = resolveInstance(this.root, dataCxt?.instancePath ?? "");
+                return zoEqual(instance, member);
+            };
+        },
+    });
+    const lengthKeyword = (keyword, ok) => {
+        ajv.addKeyword({
+            keyword,
+            schemaType: "number",
+            errors: false,
+            compile(limit) {
+                return (data) => {
+                    if (typeof data !== "string")
+                        return true;
+                    return ok(Array.from(data).length, limit);
+                };
+            },
+        });
+    };
+    lengthKeyword("minLength", (count, limit) => count >= limit);
+    lengthKeyword("maxLength", (count, limit) => count <= limit);
+    ajv.addKeyword({
+        keyword: "pattern",
+        schemaType: "string",
+        errors: false,
+        compile(pattern) {
+            const compiled = getPattern(pattern);
+            return (data) => typeof data !== "string" || compiled.search(data);
+        },
+    });
+    ajv.addKeyword({
+        keyword: "x-zo-json-value",
+        schemaType: "boolean",
+        errors: false,
+        validate(_flag, _data, _schema, dataCxt) {
+            const instance = resolveInstance(this.root, dataCxt?.instancePath ?? "");
+            try {
+                checkJsonValue(instance);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    });
+    return ajv.compile(ajvSchema);
+}
+// --- compiled schema ---------------------------------------------------------
+/** An immutable compiled schema. Construct through {@link compileSchema}. */
+export class CompiledSchema {
+    schema;
+    defs;
+    unions;
+    defaults;
+    hasDefaults;
+    validator;
+    constructor(schema, defs, unions, defaults, hasDefaults) {
+        this.schema = schema;
+        this.defs = defs;
+        this.unions = unions;
+        this.defaults = defaults;
+        this.hasDefaults = hasDefaults;
+        this.validator = buildValidator(buildAjvSchema(schema));
+    }
+    static build(compiler, schema) {
+        const unions = new Map();
+        for (const [key, { node, path }] of compiler.unions)
+            unions.set(key, computeUnion(compiler.defs, node, path));
+        const compiled = new CompiledSchema(schema, compiler.defs, unions, compiler.defaults, compiler.defaults.size > 0);
+        compiled.validateDefaults();
+        return compiled;
+    }
+    /** A fresh detached copy of the canonical schema. */
+    get canonicalSchema() {
+        return canonicalizeJson(this.schema, { maxNodes: null });
+    }
+    get isObject() {
+        // Mirror Python `_node_types(root) == {"object"}` on the resolved node:
+        // `anyOf` always admits `null`, `x-zo-json-value` is the `json` type, but a
+        // discriminated `oneOf` in this subset is always over object branches, so a
+        // direct or `$ref`-referenced object-only union is an object.
+        const [root] = this.resolve(this.schema);
+        if ("anyOf" in root)
+            return false;
+        if ("oneOf" in root)
+            return true;
+        if ("x-zo-json-value" in root)
+            return false;
+        return root["type"] === "object";
+    }
+    resolve(node) {
+        let current = node;
+        let schemaPath = [];
+        while ("$ref" in current) {
+            const ref = current["$ref"];
+            const name = ref.slice(REF_PREFIX.length);
+            current = this.defs.get(name);
+            schemaPath = ["$defs", name];
+        }
+        return [current, schemaPath];
+    }
+    /**
+     * Return a detached canonical copy of `value` if it conforms. With
+     * `applyDefaults` the copy first receives defaults for absent object
+     * properties (choosing a union branch only by its discriminator).
+     */
+    validate(value, options = {}) {
+        let canonical;
+        try {
+            // Always enforce the selected-tree node/depth budget on the value itself
+            // (matching Python `canonicalize_json(value)`), independent of the
+            // envelope wrapper the caller parsed with the node bound disabled.
+            canonical = canonicalizeJson(value);
+            if (options.applyDefaults && this.hasDefaults) {
+                const [nodes] = measureJson(canonical);
+                const budget = new Budget(nodes);
+                this.fill(canonical, this.schema, [], budget, 1, []);
+                // Re-charge the filled tree against the same bound.
+                checkJsonValue(canonical);
+            }
+        }
+        catch (error) {
+            if (error instanceof JsonError)
+                throw new SchemaValidationError(error.code, stripLocation(error), {});
+            throw error;
+        }
+        // A fresh context per call (via Ajv `passContext`) — no instance-shared
+        // mutable state, so concurrent or reentrant validations never collide.
+        const context = { root: canonical };
+        if (!this.validator.call(context, buildNative(canonical))) {
+            const first = this.validator.errors?.[0];
+            throw new SchemaValidationError("schema_violation", first?.message ?? "value does not conform to the schema", { path: first ? splitInstancePath(first.instancePath) : [] });
+        }
+        return canonical;
+    }
+    fill(value, rawNode, rawSchemaPath, budget, depth, path) {
+        const [node, schemaPath] = this.resolveFrom(rawNode, rawSchemaPath);
+        if ("x-zo-json-value" in node)
+            return;
+        if ("anyOf" in node) {
+            if (value !== null)
+                this.fill(value, branch(node, "anyOf", 0), [...schemaPath, "anyOf", 0], budget, depth, path);
+            return;
+        }
+        if ("oneOf" in node) {
+            const info = this.unions.get(pathKey(schemaPath));
+            if (info && isPlainObject(value)) {
+                const tag = value[info.property];
+                if (typeof tag === "string" && info.branches.has(tag)) {
+                    const index = info.branches.get(tag);
+                    this.fill(value, branch(node, "oneOf", index), [...schemaPath, "oneOf", index], budget, depth, path);
+                }
+            }
+            return;
+        }
+        const typeName = node["type"];
+        if (typeName === "object" && isPlainObject(value)) {
+            const properties = node["properties"];
+            if (isPlainObject(properties)) {
+                for (const [name, sub] of Object.entries(properties)) {
+                    const subPath = [...schemaPath, "properties", name];
+                    const childPath = [...path, name];
+                    if (Object.hasOwn(value, name)) {
+                        this.fill(value[name], sub, subPath, budget, depth + 1, childPath);
+                    }
+                    else {
+                        const def = this.defaults.get(pathKey(subPath));
+                        if (def) {
+                            const measured = this.measuredDefault(def.value);
+                            budget.charge(measured, depth + 1, childPath);
+                            const inserted = deepCopy(def.value);
+                            value[name] = inserted;
+                            this.fill(inserted, sub, subPath, budget, depth + 1, childPath);
+                        }
+                    }
+                }
+            }
+            else {
+                const extra = node["additionalProperties"];
+                const extraPath = [...schemaPath, "additionalProperties"];
+                for (const [name, item] of Object.entries(value))
+                    this.fill(item, extra, extraPath, budget, depth + 1, [...path, name]);
+            }
+        }
+        else if (typeName === "array" && Array.isArray(value)) {
+            const items = node["items"];
+            const itemsPath = [...schemaPath, "items"];
+            value.forEach((item, index) => {
+                this.fill(item, items, itemsPath, budget, depth + 1, [...path, index]);
+            });
+        }
+    }
+    resolveFrom(node, schemaPath) {
+        let current = node;
+        let currentPath = schemaPath;
+        while ("$ref" in current) {
+            const ref = current["$ref"];
+            const name = ref.slice(REF_PREFIX.length);
+            current = this.defs.get(name);
+            currentPath = ["$defs", name];
+        }
+        return [current, currentPath];
+    }
+    measuredCache = new Map();
+    measuredDefault(value) {
+        let measured = this.measuredCache.get(value);
+        if (!measured) {
+            const [nodes, depth] = measureJson(value);
+            measured = { nodes, depth };
+            this.measuredCache.set(value, measured);
+        }
+        return measured;
+    }
+    /** Publication check: every default conforms to its property schema. */
+    validateDefaults() {
+        for (const { path, value } of this.defaults.values()) {
+            const [node] = this.locate(path);
+            const filled = deepCopy(value);
+            const [nodes] = measureJson(value);
+            const budget = new Budget(nodes);
+            try {
+                this.fill(filled, node, path, budget, 1, []);
+            }
+            catch (error) {
+                if (error instanceof JsonError)
+                    throw new SchemaDefinitionError("invalid_default", `'default' expansion exceeds the supported bounds (${error.code})`, { schemaPath: path, keyword: "default" });
+                throw error;
+            }
+            const subValidator = buildValidator(buildAjvSchema(this.subSchema(node)));
+            if (!subValidator.call({ root: filled }, buildNative(filled)))
+                throw new SchemaDefinitionError("invalid_default", "'default' does not conform to its property schema", { schemaPath: path, keyword: "default" });
+        }
+    }
+    /** A node reparented under the root's `$defs` so its `$ref`s still resolve. */
+    subSchema(node) {
+        if (this.defs.size === 0)
+            return node;
+        // Null-prototype so a `$def` literally named `__proto__` is copied as an own
+        // key here too — this map feeds buildAjvSchema on the default-publication
+        // path (validateDefaults), so an ordinary `{}` would drop such a def via the
+        // inherited setter and a property default referencing `#/$defs/__proto__`
+        // could not be validated even though root validation resolves it.
+        const defs = Object.create(null);
+        for (const [name, definition] of this.defs)
+            defs[name] = definition;
+        return { ...node, $defs: defs };
+    }
+    /** Follow a normalized schema path from the root, resolving `$ref` hops. */
+    locate(schemaPath) {
+        let node = this.schema;
+        let canonical = [];
+        let inMap = false;
+        for (const part of schemaPath) {
+            if (Array.isArray(node)) {
+                node = node[part];
+                inMap = false;
+            }
+            else {
+                const object = node;
+                if (!inMap && part !== "$defs")
+                    [node, canonical] = this.resolve(object);
+                node = node[part];
+                inMap = !inMap && (part === "properties" || part === "$defs");
+            }
+            canonical = [...canonical, part];
+        }
+        return this.resolve(node);
+    }
+}
+// --- helpers -----------------------------------------------------------------
+class Budget {
+    nodes;
+    constructor(nodes) {
+        this.nodes = nodes;
+    }
+    charge(def, depth, path) {
+        if (depth + def.depth - 1 > MAX_SCHEMA_DEPTH)
+            throw new JsonError("too_deep", "default insertion exceeds the supported depth", path);
+        if (this.nodes + def.nodes > MAX_SCHEMA_NODES)
+            throw new JsonError("too_many_nodes", "default insertion exceeds the supported node count", path);
+        this.nodes += def.nodes;
+    }
+}
+function branch(node, key, index) {
+    return node[key][index];
+}
+function deepCopy(value) {
+    if (value === null ||
+        typeof value !== "object" ||
+        value instanceof JsonNumber)
+        return value;
+    if (Array.isArray(value))
+        return value.map(deepCopy);
+    // Null-prototype record so a copied `__proto__` key stays an own data
+    // property instead of mutating the prototype chain.
+    const out = Object.create(null);
+    for (const [key, item] of Object.entries(value))
+        out[key] = deepCopy(item);
+    return out;
+}
+/** Map the canonical tree to plain JS numbers so Ajv can traverse it. */
+function buildNative(value) {
+    if (value instanceof JsonNumber)
+        return Number(value.text);
+    if (Array.isArray(value))
+        return value.map(buildNative);
+    if (isPlainObject(value)) {
+        // Null-prototype record so a `__proto__` key is materialized as an own data
+        // property Ajv traverses, rather than reassigning the object's prototype.
+        const out = Object.create(null);
+        for (const [key, item] of Object.entries(value))
+            out[key] = buildNative(item);
+        return out;
+    }
+    return value;
+}
+function splitInstancePath(instancePath) {
+    if (instancePath === "")
+        return [];
+    return instancePath
+        .split("/")
+        .slice(1)
+        .map((token) => {
+        const unescaped = unescapePointerToken(token);
+        return /^\d+$/.test(unescaped) ? Number(unescaped) : unescaped;
+    });
+}
+function stripLocation(error) {
+    const message = error.message;
+    const marker = " at /";
+    return message.includes(marker) ? message.split(marker, 1)[0] : message;
+}
+// --- public entry ------------------------------------------------------------
+/** Compile a schema document into an immutable {@link CompiledSchema}. */
+export function compileSchema(schema) {
+    const prepared = prepareSchema(schema, [], 1);
+    let canonical;
+    try {
+        canonical = canonicalizeJson(prepared, {
+            maxNodes: MAX_SCHEMA_NODES,
+            maxDepth: MAX_SCHEMA_DEPTH,
+        });
+    }
+    catch (error) {
+        if (error instanceof JsonError)
+            throw new SchemaDefinitionError(error.code, stripLocation(error), {
+                schemaPath: error.path,
+            });
+        throw error;
+    }
+    if (!isPlainObject(canonical))
+        throw new SchemaDefinitionError("unsupported_schema", "schema must be an object");
+    const compiler = new Compiler(canonical);
+    compiler.compile();
+    return CompiledSchema.build(compiler, canonical);
+}