@json-schema-engine/core 0.0.1

package/dist/keywords/unevaluated.js

@@ -0,0 +1,296 @@
+// Unevaluated vocabulary: the channel-consumer keyword class. Phase 1: runs
+// after every other keyword in the same schema object has merged.
+import { isObject } from "../json.js";
+import { lowerIR } from "../lowering.js";
+import { childCursor } from "../cursor.js";
+import { SELF } from "./core.js";
+import { properties, patternProperties, additionalProperties, prefixItems, items, contains, } from "./applicator.js";
+/** 2020-12 unevaluated vocabulary URI. */
+export const VOCAB_UNEVALUATED = "https://json-schema.org/draft/2020-12/vocab/unevaluated";
+/**
+ * EXEMPLAR (consumer class): reads visible dependency records (engine.ts
+ * visibility rule), applies the subschema to properties nobody evaluated,
+ * and produces like any other applicator.
+ */
+export const unevaluatedProperties = {
+    id: `${VOCAB_UNEVALUATED}#unevaluatedProperties`,
+    phase: 1,
+    analyze: () => ({
+        subschemas: SELF.subschemas,
+        consumes: [
+            properties.id,
+            patternProperties.id,
+            additionalProperties.id,
+            `${VOCAB_UNEVALUATED}#unevaluatedProperties`,
+        ],
+        produces: [`${VOCAB_UNEVALUATED}#unevaluatedProperties`],
+        evaluatesNames: { kind: "all" },
+        applications: [
+            { path: [], mode: "childSweep", conditional: false, asserts: true },
+        ],
+    }),
+    // Static-coverage path only (D9a): the planner classifies this schema
+    // object as interpreted when any coverage contributor is dynamic, so
+    // lower() is never called with a null coverage.
+    lower: (_value, lctx) => {
+        // Runtime-coverage path (phase B activates it): fold the unit's runtime
+        // channel into an evaluated-name set and sweep the names it does not
+        // cover, mirroring evaluate()'s seen-set skip. The object-gated
+        // collectedNames produce is the same one the static path emits — its
+        // attempted-apply accumulator is exactly the interpreter's `matched`.
+        if (lctx.runtimeCoverage()) {
+            const f = lctx.binding();
+            const b = lctx.binding();
+            lctx.emit(lowerIR.when(lowerIR.typeIs(lctx.instance, "object"), [
+                { kind: "coverageFold", half: "names", binding: f },
+                {
+                    kind: "forEachKey",
+                    target: lctx.instance,
+                    binding: b,
+                    body: [
+                        lowerIR.when(lowerIR.not({
+                            kind: "coverageCovers",
+                            fold: f,
+                            target: { kind: "binding", id: b },
+                        }), [
+                            {
+                                kind: "apply",
+                                apply: {
+                                    path: [],
+                                    cursor: {
+                                        kind: "child",
+                                        of: { kind: "here" },
+                                        segment: { kind: "binding", id: b },
+                                    },
+                                    fold: "allMustPass",
+                                },
+                            },
+                        ]),
+                    ],
+                },
+                { kind: "produce", value: { kind: "collectedNames" } },
+            ]));
+            return;
+        }
+        const coverage = lctx.staticCoverage();
+        if (coverage === null) {
+            throw new Error("unevaluatedProperties lowering requires static coverage (planner bug)");
+        }
+        // The sweep is statically vacuous when sibling coverage is total, but the
+        // produce is not: evaluate() emits an (empty) names annotation for every
+        // object regardless. So the object-type guard always wraps a produce; the
+        // sweep is added only when some name can still be unevaluated.
+        const body = [];
+        if (!coverage.coversAllNames) {
+            const b = lctx.binding();
+            const covered = [
+                ...coverage.names.map((n) => lowerIR.cmp("===", { kind: "binding", id: b }, lowerIR.constant(n))),
+                ...coverage.patterns.map((p) => lowerIR.regexTest(p, { kind: "binding", id: b })),
+            ];
+            body.push({
+                kind: "forEachKey",
+                target: lctx.instance,
+                binding: b,
+                body: [
+                    lowerIR.when(covered.length === 0
+                        ? lowerIR.constant(true)
+                        : lowerIR.not(lowerIR.or(...covered)), [
+                        {
+                            kind: "apply",
+                            apply: {
+                                path: [],
+                                cursor: {
+                                    kind: "child",
+                                    of: { kind: "here" },
+                                    segment: { kind: "binding", id: b },
+                                },
+                                fold: "allMustPass",
+                            },
+                        },
+                    ]),
+                ],
+            });
+        }
+        body.push({ kind: "produce", value: { kind: "collectedNames" } });
+        // Produce iff the instance is an object (nothing otherwise), matching
+        // evaluate()'s object-type guard before ctx.produce.
+        lctx.emit(lowerIR.when(lowerIR.typeIs(lctx.instance, "object"), body));
+    },
+    evaluate: (_value, cursor, ctx) => {
+        if (!isObject(cursor.value))
+            return true;
+        const seen = new Set();
+        for (const p of ctx.visible([
+            properties.id,
+            patternProperties.id,
+            additionalProperties.id,
+            unevaluatedProperties.id,
+        ])) {
+            for (const name of p.data)
+                seen.add(name);
+        }
+        let ok = true;
+        const matched = [];
+        for (const name of Object.keys(cursor.value)) {
+            if (seen.has(name))
+                continue;
+            matched.push(name);
+            if (!ctx.apply(["unevaluatedProperties"], childCursor(cursor, name, cursor.value[name])))
+                ok = false;
+        }
+        // Dependency data only from an accepting keyword (Appendix D; see
+        // applicator.ts properties).
+        if (ok)
+            ctx.produce(matched);
+        return ok;
+    },
+};
+/** Same consumer shape as {@link unevaluatedProperties}, over array indexes not covered by `prefixItems`/`items`/`contains`. */
+export const unevaluatedItems = {
+    id: `${VOCAB_UNEVALUATED}#unevaluatedItems`,
+    phase: 1,
+    analyze: () => ({
+        subschemas: SELF.subschemas,
+        consumes: [
+            prefixItems.id,
+            items.id,
+            contains.id,
+            `${VOCAB_UNEVALUATED}#unevaluatedItems`,
+        ],
+        produces: [`${VOCAB_UNEVALUATED}#unevaluatedItems`],
+        evaluatesIndexes: { kind: "all" },
+        applications: [
+            { path: [], mode: "childSweep", conditional: false, asserts: true },
+        ],
+    }),
+    // Static-coverage path only (D9a), same discipline as
+    // unevaluatedProperties: the planner classifies this schema object as
+    // interpreted whenever any index-coverage contributor is dynamic (e.g. a
+    // sibling `contains`, whose coverage is instance-dependent), so lower() is
+    // never called with a null/incomplete coverage.
+    lower: (_value, lctx) => {
+        // Runtime-coverage path (phase B activates it): fold the unit's runtime
+        // channel into a coveredPrefix/coveredIdx summary over this array's
+        // length and sweep the indexes it does not cover, mirroring evaluate()'s
+        // skip loop. The appliedTrue produce is the same one the static path
+        // emits (any attempted apply -> true, the interpreter's `applied` flag).
+        if (lctx.runtimeCoverage()) {
+            const f = lctx.binding();
+            const b = lctx.binding();
+            lctx.emit(lowerIR.when(lowerIR.typeIs(lctx.instance, "array"), [
+                { kind: "coverageFold", half: "indexes", binding: f },
+                {
+                    kind: "forEachIndex",
+                    target: lctx.instance,
+                    binding: b,
+                    start: 0,
+                    body: [
+                        lowerIR.when(lowerIR.not({
+                            kind: "coverageCovers",
+                            fold: f,
+                            target: { kind: "binding", id: b },
+                        }), [
+                            {
+                                kind: "apply",
+                                apply: {
+                                    path: [],
+                                    cursor: {
+                                        kind: "child",
+                                        of: { kind: "here" },
+                                        segment: { kind: "binding", id: b },
+                                    },
+                                    fold: "allMustPass",
+                                },
+                            },
+                        ]),
+                    ],
+                },
+                {
+                    kind: "produce",
+                    value: { kind: "collectedIndexes", render: "appliedTrue" },
+                },
+            ]));
+            return;
+        }
+        const coverage = lctx.staticCoverage();
+        if (coverage === null) {
+            throw new Error("unevaluatedItems lowering requires static coverage (planner bug)");
+        }
+        if (coverage.coversAllIndexes)
+            return; // statically vacuous
+        const b = lctx.binding();
+        lctx.emit(lowerIR.when(lowerIR.typeIs(lctx.instance, "array"), [
+            {
+                kind: "forEachIndex",
+                target: lctx.instance,
+                binding: b,
+                start: coverage.prefixCount,
+                body: [
+                    {
+                        kind: "apply",
+                        apply: {
+                            path: [],
+                            cursor: {
+                                kind: "child",
+                                of: { kind: "here" },
+                                segment: { kind: "binding", id: b },
+                            },
+                            fold: "allMustPass",
+                        },
+                    },
+                ],
+            },
+        ]));
+        // Annotation: true iff it applied to any unevaluated index.
+        lctx.emit({
+            kind: "produce",
+            value: { kind: "collectedIndexes", render: "appliedTrue" },
+        });
+    },
+    evaluate: (_value, cursor, ctx) => {
+        if (!Array.isArray(cursor.value))
+            return true;
+        const length = cursor.value.length;
+        let coveredPrefix = 0;
+        const coveredIdx = new Set();
+        for (const p of ctx.visible([
+            prefixItems.id,
+            items.id,
+            contains.id,
+            unevaluatedItems.id,
+        ])) {
+            if (p.behaviorId === contains.id) {
+                if (p.data === true)
+                    coveredPrefix = length;
+                else
+                    for (const i of p.data)
+                        coveredIdx.add(i);
+            }
+            else if (p.data === true) {
+                coveredPrefix = length;
+            }
+            else if (p.behaviorId === prefixItems.id) {
+                coveredPrefix = Math.max(coveredPrefix, p.data + 1);
+            }
+        }
+        let ok = true;
+        let applied = false;
+        for (let i = coveredPrefix; i < length; i++) {
+            if (coveredIdx.has(i))
+                continue;
+            applied = true;
+            if (!ctx.apply(["unevaluatedItems"], childCursor(cursor, i, cursor.value[i]))) {
+                ok = false;
+            }
+        }
+        if (applied && ok)
+            ctx.produce(true);
+        return ok;
+    },
+};
+/** The 2020-12 unevaluated vocabulary's keyword behaviors, by name. */
+export const unevaluatedVocabulary = {
+    unevaluatedProperties,
+    unevaluatedItems,
+};
+//# sourceMappingURL=unevaluated.js.map

package/dist/keywords/unevaluated.js.map

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

package/dist/keywords/validation.d.ts

@@ -0,0 +1,21 @@
+import { KeywordBehavior } from "../dialect.js";
+/** 2020-12 validation vocabulary URI. */
+export declare const VOCAB_VALIDATION = "https://json-schema.org/draft/2020-12/vocab/validation";
+/**
+ * EXEMPLAR (assertion class): inspect the instance, report one error on
+ * failure, return the verdict. `pattern` compiles its regex through the
+ * context so a caller-supplied engine and the per-engine cache apply
+ * (see regex.ts), and declares the pattern via analyze() so
+ * `rejectUnsafeRegex` can screen it at registration.
+ */
+export declare const pattern: KeywordBehavior;
+/**
+ * `instance` is an exact multiple of `divisor` (`multipleOf`'s predicate,
+ * shared by both tiers). Scales both operands to integers by the same power
+ * of ten before the modulus so binary-float rounding doesn't misfire (e.g.
+ * 0.0075 % 0.0001 in raw floats).
+ */
+export declare function isMultipleOf(instance: number, divisor: number): boolean;
+/** The 2020-12 validation vocabulary's keyword behaviors, by name. */
+export declare const validationVocabulary: Record<string, KeywordBehavior>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/keywords/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/keywords/validation.ts"],"names":[],"mappings":"AAYA,OAAO,EAAe,eAAe,EAAkB,MAAM,eAAe,CAAC;AAS7E,yCAAyC;AACzC,eAAO,MAAM,gBAAgB,2DAC6B,CAAC;AA8D3D;;;;;;GAMG;AACH,eAAO,MAAM,OAAO,EAAE,eA4BrB,CAAC;AAsBF;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAYvE;AAED,sEAAsE;AACtE,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CA+chE,CAAC"}

package/dist/keywords/validation.js

@@ -0,0 +1,332 @@
+// Validation vocabulary: pure assertions. Assertions never produce and
+// never descend.
+import { isObject, jsonTypeOf, jsonEqual, codePointLength, firstDuplicatePair, } from "../json.js";
+import { lowerIR, } from "../lowering.js";
+/** 2020-12 validation vocabulary URI. */
+export const VOCAB_VALIDATION = "https://json-schema.org/draft/2020-12/vocab/validation";
+const id = (name) => `${VOCAB_VALIDATION}#${name}`;
+const assertion = (name, test, message, params) => ({
+    id: id(name),
+    evaluate: (value, cursor, ctx) => {
+        if (test(value, cursor.value))
+            return true;
+        ctx.error(message(value), params?.(value));
+        return false;
+    },
+});
+/**
+ * Shared shape for the numeric/string/array/object "guard, then compare"
+ * assertions (minLength/maxLength/minimum/maximum/exclusiveMinimum/
+ * exclusiveMaximum/minItems/maxItems/minProperties/maxProperties): the
+ * keyword is vacuously true unless the instance has the guarded type, in
+ * which case a comparison against the (hoisted) keyword value must hold.
+ * Mirrors each assertion's `test` above exactly — same guard, same
+ * direction of comparison — via `when(and(guard, not(cmp)), [fail])`.
+ */
+const guardedCompare = (guardType, measure, op, message) => (value, lctx) => {
+    lctx.emit(lowerIR.when(lowerIR.and(lowerIR.typeIs(lctx.instance, guardType), lowerIR.not(lowerIR.cmp(op, measure(lctx), lowerIR.constant(value)))), [lowerIR.failWith({ limit: lowerIR.constant(value) }, message(value))]));
+};
+/**
+ * The `limit` params shape shared by every guard-then-compare bounds
+ * keyword: minLength/maxLength, minItems/maxItems, minProperties/
+ * maxProperties, and minimum/maximum/exclusiveMinimum/exclusiveMaximum.
+ */
+const limitParams = (value) => ({ limit: value });
+const arrayLengthMeasure = (lctx) => lowerIR.helper("lengthOf", lctx.instance);
+const propertyCountMeasure = (lctx) => lowerIR.helper("lengthOf", lowerIR.helper("keysOf", lctx.instance));
+const numberMeasure = (lctx) => lctx.instance;
+const typeMatches = (t, v) => t === "integer"
+    ? typeof v === "number" && Number.isInteger(v)
+    : jsonTypeOf(v) === t;
+/**
+ * EXEMPLAR (assertion class): inspect the instance, report one error on
+ * failure, return the verdict. `pattern` compiles its regex through the
+ * context so a caller-supplied engine and the per-engine cache apply
+ * (see regex.ts), and declares the pattern via analyze() so
+ * `rejectUnsafeRegex` can screen it at registration.
+ */
+export const pattern = {
+    id: id("pattern"),
+    analyze: (value) => ({
+        regexes: typeof value === "string" ? [value] : [],
+    }),
+    evaluate: (value, cursor, ctx) => {
+        const instance = cursor.value;
+        if (typeof instance !== "string")
+            return true;
+        if (ctx.compileRegex(value).test(instance))
+            return true;
+        ctx.error("does not match required pattern", { pattern: value });
+        return false;
+    },
+    lower: (value, lctx) => {
+        lctx.emit(lowerIR.when(lowerIR.and(lowerIR.typeIs(lctx.instance, "string"), lowerIR.not(lowerIR.regexTest(value, lctx.instance))), [
+            lowerIR.failWith({ pattern: lowerIR.constant(value) }, "does not match required pattern"),
+        ]));
+    },
+};
+// Number of digits after the decimal point in `n`'s shortest representation,
+// including exponential notation (1e-8 has 8). `%` on the raw floats fails
+// suite cases like 0.0075 % 0.0001 (binary rounding); scaling both operands
+// to integers by the same power of ten sidesteps that at the cost of this
+// string inspection.
+function decimalDigits(n) {
+    if (!Number.isFinite(n))
+        return 0;
+    const s = Math.abs(n).toString();
+    const eIndex = s.indexOf("e");
+    if (eIndex !== -1) {
+        const mantissa = s.slice(0, eIndex);
+        const exponent = Number(s.slice(eIndex + 1));
+        const dot = mantissa.indexOf(".");
+        const mantissaDigits = dot === -1 ? 0 : mantissa.length - dot - 1;
+        return Math.max(0, mantissaDigits - exponent);
+    }
+    const dot = s.indexOf(".");
+    return dot === -1 ? 0 : s.length - dot - 1;
+}
+/**
+ * `instance` is an exact multiple of `divisor` (`multipleOf`'s predicate,
+ * shared by both tiers). Scales both operands to integers by the same power
+ * of ten before the modulus so binary-float rounding doesn't misfire (e.g.
+ * 0.0075 % 0.0001 in raw floats).
+ */
+export function isMultipleOf(instance, divisor) {
+    const scale = 10 ** Math.max(decimalDigits(instance), decimalDigits(divisor));
+    const scaledInstance = instance * scale;
+    const scaledDivisor = divisor * scale;
+    // Suite case: the scaling itself can overflow to Infinity for huge
+    // instances against a small divisor; that must read as non-multiple, not
+    // throw or silently misvalidate.
+    if (Number.isFinite(scaledInstance) && Number.isFinite(scaledDivisor)) {
+        return Math.round(scaledInstance) % Math.round(scaledDivisor) === 0;
+    }
+    const quotient = instance / divisor;
+    return Number.isFinite(quotient) && Number.isInteger(quotient);
+}
+/** The 2020-12 validation vocabulary's keyword behaviors, by name. */
+export const validationVocabulary = {
+    type: {
+        id: id("type"),
+        evaluate: (value, cursor, ctx) => {
+            const ok = Array.isArray(value)
+                ? value.some((t) => typeMatches(t, cursor.value))
+                : typeMatches(value, cursor.value);
+            if (!ok)
+                ctx.error(`expected type ${JSON.stringify(value)}`, {
+                    expected: value,
+                });
+            return ok;
+        },
+        lower: (value, lctx) => {
+            const types = (Array.isArray(value) ? value : [value]);
+            lctx.emit(lowerIR.when(lowerIR.not(lowerIR.typeIs(lctx.instance, ...types)), [
+                lowerIR.failWith({ expected: lowerIR.constant(value) }, `expected type ${JSON.stringify(value)}`),
+            ]));
+        },
+    },
+    enum: {
+        ...assertion("enum", (value, instance) => value.some((x) => jsonEqual(x, instance)), () => "not one of the allowed values", (value) => ({ allowedValues: value })),
+        lower: (value, lctx) => {
+            const alternatives = value;
+            const params = { allowedValues: lowerIR.constant(value) };
+            // An empty enum can never match (some() over zero alternatives is
+            // false); guard explicitly since lowerIR.or() with zero parts has no
+            // meaningful "no alternatives matched" expression to negate.
+            lctx.emit(alternatives.length === 0
+                ? lowerIR.failWith(params, "not one of the allowed values")
+                : lowerIR.when(lowerIR.not(lowerIR.or(...alternatives.map((x) => lowerIR.helper("jsonEqual", lowerIR.constant(x), lctx.instance)))), [lowerIR.failWith(params, "not one of the allowed values")]));
+        },
+    },
+    const: {
+        ...assertion("const", (value, instance) => jsonEqual(value, instance), () => "does not equal the required constant", (value) => ({ allowedValue: value })),
+        lower: (value, lctx) => {
+            lctx.emit(lowerIR.when(lowerIR.not(lowerIR.helper("jsonEqual", lowerIR.constant(value), lctx.instance)), [
+                lowerIR.failWith({ allowedValue: lowerIR.constant(value) }, "does not equal the required constant"),
+            ]));
+        },
+    },
+    pattern,
+    minLength: {
+        ...assertion("minLength", (value, instance) => typeof instance !== "string" ||
+            codePointLength(instance) >= value, (value) => `must be at least ${value} characters`, limitParams),
+        // Violation = code points < n. UTF-16 units bound points from above
+        // (points <= units) and below (points >= units/2), so units alone decide
+        // outside [n, 2n) — codePointLength runs only in that window (D9).
+        lower: (value, lctx) => {
+            const n = value;
+            const len = lowerIR.helper("lengthOf", lctx.instance);
+            const cpl = lowerIR.helper("codePointLength", lctx.instance);
+            lctx.emit(lowerIR.when(lowerIR.and(lowerIR.typeIs(lctx.instance, "string"), lowerIR.or(lowerIR.cmp("<", len, lowerIR.constant(n)), lowerIR.and(lowerIR.cmp("<", len, lowerIR.constant(2 * n)), lowerIR.cmp("<", cpl, lowerIR.constant(n))))), [
+                lowerIR.failWith({ limit: lowerIR.constant(n) }, `must be at least ${n} characters`),
+            ]));
+        },
+    },
+    maxLength: {
+        ...assertion("maxLength", (value, instance) => typeof instance !== "string" ||
+            codePointLength(instance) <= value, (value) => `must be at most ${value} characters`, limitParams),
+        // Violation = code points > n; units <= n implies points <= n, so the
+        // expensive count runs only when units exceed the bound (D9).
+        lower: (value, lctx) => {
+            const n = value;
+            lctx.emit(lowerIR.when(lowerIR.and(lowerIR.typeIs(lctx.instance, "string"), lowerIR.cmp(">", lowerIR.helper("lengthOf", lctx.instance), lowerIR.constant(n)), lowerIR.cmp(">", lowerIR.helper("codePointLength", lctx.instance), lowerIR.constant(n))), [
+                lowerIR.failWith({ limit: lowerIR.constant(n) }, `must be at most ${n} characters`),
+            ]));
+        },
+    },
+    minimum: {
+        ...assertion("minimum", (value, instance) => typeof instance !== "number" || instance >= value, (value) => `must be >= ${value}`, limitParams),
+        lower: guardedCompare("number", numberMeasure, ">=", (value) => `must be >= ${value}`),
+    },
+    maximum: {
+        ...assertion("maximum", (value, instance) => typeof instance !== "number" || instance <= value, (value) => `must be <= ${value}`, limitParams),
+        lower: guardedCompare("number", numberMeasure, "<=", (value) => `must be <= ${value}`),
+    },
+    exclusiveMinimum: {
+        ...assertion("exclusiveMinimum", (value, instance) => typeof instance !== "number" || instance > value, (value) => `must be > ${value}`, limitParams),
+        lower: guardedCompare("number", numberMeasure, ">", (value) => `must be > ${value}`),
+    },
+    exclusiveMaximum: {
+        ...assertion("exclusiveMaximum", (value, instance) => typeof instance !== "number" || instance < value, (value) => `must be < ${value}`, limitParams),
+        lower: guardedCompare("number", numberMeasure, "<", (value) => `must be < ${value}`),
+    },
+    minItems: {
+        ...assertion("minItems", (value, instance) => !Array.isArray(instance) || instance.length >= value, (value) => `must have at least ${value} items`, limitParams),
+        lower: guardedCompare("array", arrayLengthMeasure, ">=", (value) => `must have at least ${value} items`),
+    },
+    maxItems: {
+        ...assertion("maxItems", (value, instance) => !Array.isArray(instance) || instance.length <= value, (value) => `must have at most ${value} items`, limitParams),
+        lower: guardedCompare("array", arrayLengthMeasure, "<=", (value) => `must have at most ${value} items`),
+    },
+    minProperties: {
+        ...assertion("minProperties", (value, instance) => !isObject(instance) ||
+            Object.keys(instance).length >= value, (value) => `must have at least ${value} properties`, limitParams),
+        lower: guardedCompare("object", propertyCountMeasure, ">=", (value) => `must have at least ${value} properties`),
+    },
+    maxProperties: {
+        ...assertion("maxProperties", (value, instance) => !isObject(instance) ||
+            Object.keys(instance).length <= value, (value) => `must have at most ${value} properties`, limitParams),
+        lower: guardedCompare("object", propertyCountMeasure, "<=", (value) => `must have at most ${value} properties`),
+    },
+    required: {
+        id: id("required"),
+        evaluate: (value, cursor, ctx) => {
+            if (!isObject(cursor.value))
+                return true;
+            let ok = true;
+            for (const name of value) {
+                if (!Object.hasOwn(cursor.value, name)) {
+                    ctx.error(`missing required property '${name}'`, {
+                        missingProperty: name,
+                    });
+                    ok = false;
+                }
+            }
+            return ok;
+        },
+        lower: (value, lctx) => {
+            lctx.emit(lowerIR.when(lowerIR.typeIs(lctx.instance, "object"), [
+                ...value.map((name) => lowerIR.when(lowerIR.not({
+                    kind: "hasOwn",
+                    target: lctx.instance,
+                    key: name,
+                }), [
+                    lowerIR.failWith({ missingProperty: lowerIR.constant(name) }, `missing required property '${name}'`),
+                ])),
+            ]));
+        },
+    },
+    multipleOf: {
+        ...assertion("multipleOf", (value, instance) => typeof instance !== "number" || isMultipleOf(instance, value), (value) => `must be a multiple of ${value}`, (value) => ({ multipleOf: value })),
+        lower: (value, lctx) => {
+            lctx.emit(lowerIR.when(lowerIR.and(lowerIR.typeIs(lctx.instance, "number"), lowerIR.not(lowerIR.helper("isMultipleOf", lctx.instance, lowerIR.constant(value)))), [
+                lowerIR.failWith({ multipleOf: lowerIR.constant(value) }, `must be a multiple of ${value}`),
+            ]));
+        },
+    },
+    uniqueItems: {
+        id: id("uniqueItems"),
+        evaluate: (value, cursor, ctx) => {
+            if (value !== true || !Array.isArray(cursor.value))
+                return true;
+            const pair = firstDuplicatePair(cursor.value);
+            if (pair === null)
+                return true;
+            const [j, i] = pair;
+            ctx.error(`items at ${j} and ${i} are not unique`, {
+                duplicates: [j, i],
+            });
+            return false;
+        },
+        // evaluate() returns true (vacuously) whenever `value !== true` — mirror
+        // that by emitting nothing at all when the keyword value isn't literally
+        // `true` (the message text can't cite specific indexes at compile time,
+        // but the assertion itself does not depend on them: any duplicate fails).
+        lower: (value, lctx) => {
+            if (value !== true)
+                return;
+            // The pair lookup in the message runs only on the failure path
+            // (D9e), so the duplicate scan's cost is not doubled for valid data.
+            const pair = lowerIR.helper("firstDuplicatePair", lctx.instance);
+            lctx.emit(lowerIR.when(lowerIR.and(lowerIR.typeIs(lctx.instance, "array"), lowerIR.helper("hasDuplicateItems", lctx.instance)), [
+                lowerIR.failWith({ duplicates: pair }, "items at ", { kind: "item", target: pair, index: lowerIR.constant(0) }, " and ", { kind: "item", target: pair, index: lowerIR.constant(1) }, " are not unique"),
+            ]));
+        },
+    },
+    dependentRequired: {
+        id: id("dependentRequired"),
+        evaluate: (value, cursor, ctx) => {
+            if (!isObject(cursor.value))
+                return true;
+            const instance = cursor.value;
+            let ok = true;
+            for (const [name, deps] of Object.entries(value)) {
+                if (!Object.hasOwn(instance, name))
+                    continue;
+                for (const dep of deps) {
+                    if (!Object.hasOwn(instance, dep)) {
+                        ctx.error(`'${name}' requires '${dep}' to be present`, {
+                            property: name,
+                            missingProperty: dep,
+                        });
+                        ok = false;
+                    }
+                }
+            }
+            return ok;
+        },
+        lower: (value, lctx) => {
+            lctx.emit(lowerIR.when(lowerIR.typeIs(lctx.instance, "object"), [
+                ...Object.entries(value).map(([name, deps]) => lowerIR.when({ kind: "hasOwn", target: lctx.instance, key: name }, deps.map((dep) => lowerIR.when(lowerIR.not({
+                    kind: "hasOwn",
+                    target: lctx.instance,
+                    key: dep,
+                }), [
+                    lowerIR.failWith({
+                        property: lowerIR.constant(name),
+                        missingProperty: lowerIR.constant(dep),
+                    }, `'${name}' requires '${dep}' to be present`),
+                ])))),
+            ]));
+        },
+    },
+    // minContains/maxContains have no assertion of their own; `contains` reads
+    // them as inert siblings (applicator.ts), the same way `if` drives `then`/
+    // `else`. They must still be registered so unknown-keyword handling and the
+    // registration walk don't treat them as annotation-only or absent.
+    minContains: {
+        id: id("minContains"),
+        evaluate: () => true,
+        lower: () => {
+            /* contains reads this sibling directly (lctx.schema.minContains) */
+        },
+    },
+    maxContains: {
+        id: id("maxContains"),
+        evaluate: () => true,
+        lower: () => {
+            /* contains reads this sibling directly (lctx.schema.maxContains) */
+        },
+    },
+};
+//# sourceMappingURL=validation.js.map