@astrale-os/kernel-dsl 0.2.0-beta.45 → 0.2.0-beta.46

package/dist/v1/language/value/inclusion/includes.js

@@ -0,0 +1,777 @@
+import { loadValueProgram } from '../compile/load.js';
+import { isMultipleOf, jsonEqual } from '../evaluate/assertions.js';
+import { evaluateInstance } from '../evaluate/evaluator.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { appendPointer } from '../syntax/pointer.js';
+/**
+ * Whether `outer` admits every value `inner` admits, under the one V1 evaluator.
+ *
+ * `true` is a proof. `false` only means that no rule proved inclusion: a caller must then decide
+ * the values themselves. Each rule relates one assertion of `outer` to evidence carried by
+ * `inner`; a finite `inner` is decided exactly by evaluating its candidates.
+ */
+export function valueProgramIncludes(outer, inner) {
+    return new Inclusion().includes(at(outer, outer.root), at(inner, inner.root));
+}
+const NULL = 1;
+const BOOLEAN = 2;
+const OBJECT = 4;
+const ARRAY = 8;
+const STRING = 16;
+const INTEGER = 32;
+const FRACTION = 64;
+const NUMBER = INTEGER | FRACTION;
+const ANY = NULL | BOOLEAN | OBJECT | ARRAY | STRING | NUMBER;
+/** Keywords the evaluator never asserts. */
+const INERT = new Set([
+    '$anchor',
+    '$comment',
+    '$defs',
+    '$id',
+    '$schema',
+    'contentEncoding',
+    'contentMediaType',
+    'contentSchema',
+    'default',
+    'deprecated',
+    'description',
+    'examples',
+    'format',
+    'readOnly',
+    'title',
+    'writeOnly',
+    'x-astrale-path',
+]);
+/** Keywords whose subschemas the equivalence check compares positionally. */
+const SUBSCHEMA_KEYWORDS = new Set([
+    'additionalProperties',
+    'allOf',
+    'anyOf',
+    'contains',
+    'dependentSchemas',
+    'else',
+    'if',
+    'items',
+    'not',
+    'oneOf',
+    'patternProperties',
+    'prefixItems',
+    'properties',
+    'propertyNames',
+    'then',
+    'unevaluatedItems',
+    'unevaluatedProperties',
+]);
+class Inclusion {
+    programs = new Map();
+    decided = new Map();
+    pending = new Set();
+    evidenceByAt = new Map();
+    includes(outer, inner) {
+        const key = this.pair(outer, inner);
+        const known = this.decided.get(key);
+        if (known !== undefined)
+            return known;
+        // Assuming a pending pair would make a later result depend on an unproven premise.
+        if (this.pending.has(key))
+            return false;
+        this.pending.add(key);
+        try {
+            const result = this.decide(outer, inner);
+            this.decided.set(key, result);
+            return result;
+        }
+        finally {
+            this.pending.delete(key);
+        }
+    }
+    decide(outer, inner) {
+        const schema = schemaOf(outer);
+        if (isTop(schema))
+            return true;
+        const evidence = this.evidence(inner);
+        if (evidence.values !== undefined) {
+            return evidence.values.every((value) => !this.accepts(inner, value) || this.accepts(outer, value));
+        }
+        if (schema === false)
+            return false;
+        if (this.equivalent(outer, inner))
+            return true;
+        if (schema !== true && this.assertionsHold(outer, schema, inner, evidence))
+            return true;
+        // A disjunction admits each value through one branch, and each branch alone is weaker.
+        return evidence.conjuncts.some((conjunct) => ['anyOf', 'oneOf'].some((keyword) => {
+            const branches = childrenOf(conjunct, keyword);
+            return branches.length > 0 && branches.every((branch) => this.includes(outer, branch));
+        }));
+    }
+    assertionsHold(outer, schema, inner, evidence) {
+        // Annotation-dependent keywords are decided only by equivalence.
+        if (Object.hasOwn(schema, 'unevaluatedProperties'))
+            return false;
+        if (Object.hasOwn(schema, 'unevaluatedItems'))
+            return false;
+        return Object.keys(schema).every((keyword) => this.assertionHolds(keyword, outer, schema, inner, evidence));
+    }
+    assertionHolds(keyword, outer, schema, inner, evidence) {
+        const value = schema[keyword];
+        switch (keyword) {
+            case '$ref': {
+                const target = referenceOf(outer);
+                return target !== undefined && this.includes(target, inner);
+            }
+            case 'allOf':
+                return childrenOf(outer, keyword).every((branch) => this.includes(branch, inner));
+            case 'anyOf':
+                return childrenOf(outer, keyword).some((branch) => this.includes(branch, inner));
+            case 'oneOf':
+                return false;
+            case 'not': {
+                const negated = childOf(outer, keyword);
+                return negated !== undefined && this.excludes(negated, evidence);
+            }
+            case 'if':
+            case 'then':
+            case 'else':
+                return this.conditionalHolds(outer, inner, evidence);
+            case 'type':
+                return (evidence.kinds & ~typeMask(value)) === 0;
+            case 'const':
+            case 'enum':
+                return false;
+            case 'x-astrale-value-kind':
+                return typeof value === 'string' && evidence.valueKinds.has(value);
+            case 'maximum':
+                return (typeof value !== 'number' ||
+                    !has(evidence, NUMBER) ||
+                    (evidence.upper !== undefined && evidence.upper.value <= value));
+            case 'exclusiveMaximum':
+                return (typeof value !== 'number' ||
+                    !has(evidence, NUMBER) ||
+                    (evidence.upper !== undefined &&
+                        (evidence.upper.value < value ||
+                            (evidence.upper.exclusive && evidence.upper.value <= value))));
+            case 'minimum':
+                return (typeof value !== 'number' ||
+                    !has(evidence, NUMBER) ||
+                    (evidence.lower !== undefined && evidence.lower.value >= value));
+            case 'exclusiveMinimum':
+                return (typeof value !== 'number' ||
+                    !has(evidence, NUMBER) ||
+                    (evidence.lower !== undefined &&
+                        (evidence.lower.value > value ||
+                            (evidence.lower.exclusive && evidence.lower.value >= value))));
+            case 'multipleOf':
+                return (typeof value !== 'number' ||
+                    !has(evidence, NUMBER) ||
+                    evidence.multipleOf.some((divisor) => isMultipleOf(divisor, value)) ||
+                    (!has(evidence, FRACTION) && isMultipleOf(1, value)));
+            case 'maxLength':
+                return (typeof value !== 'number' ||
+                    !has(evidence, STRING) ||
+                    (evidence.maxLength !== undefined && evidence.maxLength <= value));
+            case 'minLength':
+                return (typeof value !== 'number' ||
+                    !has(evidence, STRING) ||
+                    value <= 0 ||
+                    evidence.minLength >= value);
+            case 'pattern':
+                return (typeof value !== 'string' ||
+                    !has(evidence, STRING) ||
+                    evidence.patterns.has(value) ||
+                    evidence.fullMatches.has(value));
+            case 'fullMatch':
+                return (typeof value !== 'string' || !has(evidence, STRING) || evidence.fullMatches.has(value));
+            case 'maxItems':
+                return (typeof value !== 'number' ||
+                    !has(evidence, ARRAY) ||
+                    (evidence.maxItems !== undefined && evidence.maxItems <= value));
+            case 'minItems':
+                return (typeof value !== 'number' ||
+                    !has(evidence, ARRAY) ||
+                    value <= 0 ||
+                    evidence.minItems >= value);
+            case 'uniqueItems':
+                return (value !== true ||
+                    !has(evidence, ARRAY) ||
+                    evidence.uniqueItems ||
+                    (evidence.maxItems !== undefined && evidence.maxItems <= 1));
+            case 'prefixItems':
+            case 'items':
+                return this.itemsHold(outer, schema, evidence);
+            case 'contains':
+            case 'minContains':
+            case 'maxContains':
+                return this.containsHolds(outer, schema, evidence);
+            case 'maxProperties':
+                return (typeof value !== 'number' ||
+                    !has(evidence, OBJECT) ||
+                    (evidence.maxProperties !== undefined && evidence.maxProperties <= value) ||
+                    evidence.conjuncts.some((conjunct) => {
+                        const names = this.closedNames(conjunct);
+                        return names !== undefined && names.length <= value;
+                    }));
+            case 'minProperties':
+                return (typeof value !== 'number' ||
+                    !has(evidence, OBJECT) ||
+                    value <= 0 ||
+                    evidence.minProperties >= value ||
+                    evidence.required.size >= value);
+            case 'required':
+                return (!Array.isArray(value) ||
+                    !has(evidence, OBJECT) ||
+                    value.every((name) => typeof name !== 'string' || evidence.required.has(name)));
+            case 'dependentRequired':
+                return (!isJsonObject(value) ||
+                    !has(evidence, OBJECT) ||
+                    Object.entries(value).every(([name, dependencies]) => !Array.isArray(dependencies) ||
+                        this.forbids(evidence, name) ||
+                        dependencies.every((dependency) => typeof dependency !== 'string' ||
+                            evidence.required.has(dependency) ||
+                            evidence.dependentRequired.get(name)?.has(dependency) === true)));
+            case 'properties':
+                return (!isJsonObject(value) ||
+                    !has(evidence, OBJECT) ||
+                    Object.keys(value).every((name) => {
+                        const member = childOf(outer, keyword, name);
+                        return (member === undefined ||
+                            isTop(schemaOf(member)) ||
+                            this.memberConstraints(evidence, name).some((constraint) => this.includes(member, constraint)));
+                    }));
+            case 'patternProperties':
+                return (!isJsonObject(value) ||
+                    !has(evidence, OBJECT) ||
+                    Object.keys(value).every((pattern) => {
+                        const member = childOf(outer, keyword, pattern);
+                        if (member === undefined || isTop(schemaOf(member)))
+                            return true;
+                        return evidence.conjuncts.some((conjunct) => {
+                            const same = childOf(conjunct, keyword, pattern);
+                            if (same !== undefined && this.includes(member, same))
+                                return true;
+                            return this.coversNames(conjunct, member, (name) => matches(outer, pattern, name));
+                        });
+                    }));
+            case 'additionalProperties':
+                return this.additionalHolds(outer, schema, evidence);
+            case 'propertyNames': {
+                const names = childOf(outer, keyword);
+                if (names === undefined || isTop(schemaOf(names)) || !has(evidence, OBJECT))
+                    return true;
+                return evidence.conjuncts.some((conjunct) => {
+                    const own = childOf(conjunct, keyword);
+                    if (own !== undefined && this.includes(names, own))
+                        return true;
+                    const closed = this.closedNames(conjunct);
+                    return closed !== undefined && closed.every((name) => this.accepts(names, name));
+                });
+            }
+            case 'dependentSchemas':
+                return (!isJsonObject(value) ||
+                    !has(evidence, OBJECT) ||
+                    Object.keys(value).every((name) => {
+                        const dependent = childOf(outer, keyword, name);
+                        if (dependent === undefined || isTop(schemaOf(dependent)))
+                            return true;
+                        if (this.forbids(evidence, name))
+                            return true;
+                        if (evidence.conjuncts.some((conjunct) => this.includes(dependent, conjunct))) {
+                            return true;
+                        }
+                        return evidence.conjuncts.some((conjunct) => {
+                            const own = childOf(conjunct, keyword, name);
+                            return own !== undefined && this.includes(dependent, own);
+                        });
+                    }));
+            default:
+                return INERT.has(keyword);
+        }
+    }
+    /** Whether no value admitted by `evidence` satisfies `negated`. */
+    excludes(negated, evidence) {
+        if ((this.evidence(negated).kinds & evidence.kinds) === 0)
+            return true;
+        return evidence.conjuncts.some((conjunct) => {
+            const own = childOf(conjunct, 'not');
+            return own !== undefined && this.includes(own, negated);
+        });
+    }
+    conditionalHolds(outer, inner, evidence) {
+        const condition = childOf(outer, 'if');
+        if (condition === undefined)
+            return true;
+        const then = childOf(outer, 'then');
+        const otherwise = childOf(outer, 'else');
+        const thenHolds = (fallback) => then === undefined ||
+            this.includes(then, inner) ||
+            (fallback !== undefined && this.includes(then, fallback));
+        const elseHolds = (fallback) => otherwise === undefined ||
+            this.includes(otherwise, inner) ||
+            (fallback !== undefined && this.includes(otherwise, fallback));
+        if (thenHolds() && elseHolds())
+            return true;
+        for (const conjunct of evidence.conjuncts) {
+            const own = childOf(conjunct, 'if');
+            if (own === undefined || !this.equivalent(own, condition))
+                continue;
+            if (thenHolds(childOf(conjunct, 'then')) && elseHolds(childOf(conjunct, 'else')))
+                return true;
+        }
+        if (this.includes(condition, inner))
+            return thenHolds();
+        if (this.excludes(condition, evidence))
+            return elseHolds();
+        return false;
+    }
+    itemsHold(outer, schema, evidence) {
+        if (!has(evidence, ARRAY))
+            return true;
+        const prefix = childrenOf(outer, 'prefixItems');
+        const rest = Object.hasOwn(schema, 'items') ? childOf(outer, 'items') : undefined;
+        const width = Math.max(prefix.length, ...evidence.conjuncts.map((conjunct) => childrenOf(conjunct, 'prefixItems').length));
+        // Every index at or beyond `width` meets `items` on both sides.
+        for (let index = 0; index <= width; index++) {
+            const required = index < prefix.length ? prefix[index] : rest;
+            if (required === undefined || isTop(schemaOf(required)))
+                continue;
+            if (evidence.maxItems !== undefined && evidence.maxItems <= index)
+                continue;
+            const admitted = evidence.conjuncts.flatMap((conjunct) => {
+                const own = childrenOf(conjunct, 'prefixItems');
+                if (index < own.length)
+                    return [own[index]];
+                const items = childOf(conjunct, 'items');
+                return items === undefined ? [] : [items];
+            });
+            if (!admitted.some((constraint) => this.includes(required, constraint)))
+                return false;
+        }
+        return true;
+    }
+    containsHolds(outer, schema, evidence) {
+        const contains = childOf(outer, 'contains');
+        if (contains === undefined || !has(evidence, ARRAY))
+            return true;
+        const minimum = typeof schema.minContains === 'number' ? schema.minContains : 1;
+        const maximum = typeof schema.maxContains === 'number' ? schema.maxContains : Number.POSITIVE_INFINITY;
+        const ownContains = evidence.conjuncts.flatMap((conjunct) => {
+            const own = childOf(conjunct, 'contains');
+            if (own === undefined)
+                return [];
+            const conjunctSchema = schemaOf(conjunct);
+            return [
+                {
+                    at: own,
+                    minimum: typeof conjunctSchema.minContains === 'number' ? conjunctSchema.minContains : 1,
+                    maximum: typeof conjunctSchema.maxContains === 'number'
+                        ? conjunctSchema.maxContains
+                        : Number.POSITIVE_INFINITY,
+                },
+            ];
+        });
+        // Every inner match is an outer match, so outer counts at least as many.
+        const atLeast = minimum <= 0 ||
+            ownContains.some((own) => own.minimum >= minimum && this.includes(contains, own.at));
+        // Every outer match is an inner match, so outer counts at most as many.
+        const atMost = maximum === Number.POSITIVE_INFINITY ||
+            (evidence.maxItems !== undefined && evidence.maxItems <= maximum) ||
+            ownContains.some((own) => own.maximum <= maximum && this.includes(own.at, contains));
+        return atLeast && atMost;
+    }
+    additionalHolds(outer, schema, evidence) {
+        const additional = childOf(outer, 'additionalProperties');
+        if (additional === undefined || isTop(schemaOf(additional)) || !has(evidence, OBJECT)) {
+            return true;
+        }
+        const declared = isJsonObject(schema.properties) ? schema.properties : {};
+        const patterns = isJsonObject(schema.patternProperties)
+            ? Object.keys(schema.patternProperties)
+            : [];
+        const isAdditional = (name) => !Object.hasOwn(declared, name) && !patterns.some((pattern) => matches(outer, pattern, name));
+        return evidence.conjuncts.some((conjunct) => this.coversNames(conjunct, additional, isAdditional, patterns));
+    }
+    /**
+     * Whether every property of a `conjunct`-admitted object whose name is `relevant` satisfies
+     * `required`. Names matching a pattern in `settled` are never relevant.
+     */
+    coversNames(conjunct, required, relevant, settled = []) {
+        const schema = schemaOf(conjunct);
+        if (!isJsonObject(schema))
+            return false;
+        const rest = childOf(conjunct, 'additionalProperties');
+        if (rest === undefined || !this.includes(required, rest))
+            return false;
+        const declared = isJsonObject(schema.properties) ? Object.keys(schema.properties) : [];
+        const patterns = isJsonObject(schema.patternProperties)
+            ? Object.keys(schema.patternProperties)
+            : [];
+        return (declared.every((name) => {
+            if (!relevant(name))
+                return true;
+            const member = childOf(conjunct, 'properties', name);
+            return member !== undefined && this.includes(required, member);
+        }) &&
+            patterns.every((pattern) => {
+                if (settled.includes(pattern))
+                    return true;
+                const member = childOf(conjunct, 'patternProperties', pattern);
+                return member !== undefined && this.includes(required, member);
+            }));
+    }
+    /** Locations one conjunct applies to the value of property `name`. */
+    memberConstraints(evidence, name) {
+        return evidence.conjuncts.flatMap((conjunct) => {
+            const schema = schemaOf(conjunct);
+            if (!isJsonObject(schema))
+                return [];
+            const constraints = [];
+            const declared = isJsonObject(schema.properties) && Object.hasOwn(schema.properties, name);
+            if (declared) {
+                const member = childOf(conjunct, 'properties', name);
+                if (member !== undefined)
+                    constraints.push(member);
+            }
+            let matched = false;
+            if (isJsonObject(schema.patternProperties)) {
+                for (const pattern of Object.keys(schema.patternProperties)) {
+                    if (!matches(conjunct, pattern, name))
+                        continue;
+                    matched = true;
+                    const member = childOf(conjunct, 'patternProperties', pattern);
+                    if (member !== undefined)
+                        constraints.push(member);
+                }
+            }
+            if (!declared && !matched) {
+                const rest = childOf(conjunct, 'additionalProperties');
+                if (rest !== undefined)
+                    constraints.push(rest);
+            }
+            return constraints;
+        });
+    }
+    /** Whether an admitted object never has property `name`. */
+    forbids(evidence, name) {
+        return this.memberConstraints(evidence, name).some((constraint) => this.evidence(constraint).kinds === 0);
+    }
+    /** The complete property-name set of a closed object conjunct, when it is one. */
+    closedNames(conjunct) {
+        const schema = schemaOf(conjunct);
+        if (!isJsonObject(schema))
+            return undefined;
+        if (isJsonObject(schema.patternProperties) && Object.keys(schema.patternProperties).length > 0)
+            return undefined;
+        const rest = childOf(conjunct, 'additionalProperties');
+        if (rest === undefined || this.evidence(rest).kinds !== 0)
+            return undefined;
+        return isJsonObject(schema.properties) ? Object.keys(schema.properties) : [];
+    }
+    /** Whether the two locations are bisimilar: equal assertions over paired subschemas. */
+    equivalent(left, right) {
+        const pending = [[left, right]];
+        const seen = new Set();
+        while (pending.length > 0) {
+            const [first, second] = pending.pop();
+            const key = this.pair(first, second);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const a = schemaOf(first);
+            const b = schemaOf(second);
+            if (typeof a === 'boolean' || typeof b === 'boolean') {
+                if (a !== b)
+                    return false;
+                continue;
+            }
+            const assertions = assertionKeys(a);
+            if (assertions.length !== assertionKeys(b).length)
+                return false;
+            for (const keyword of assertions) {
+                if (!Object.hasOwn(b, keyword) || !jsonEqual(a[keyword], b[keyword]))
+                    return false;
+            }
+            const firstChildren = subschemaChildren(first);
+            const secondChildren = subschemaChildren(second);
+            if (firstChildren.size !== secondChildren.size)
+                return false;
+            for (const [path, index] of firstChildren) {
+                const other = secondChildren.get(path);
+                if (other === undefined)
+                    return false;
+                pending.push([at(first.program, index), at(second.program, other)]);
+            }
+            const firstReference = referenceOf(first);
+            const secondReference = referenceOf(second);
+            if ((firstReference === undefined) !== (secondReference === undefined))
+                return false;
+            if (firstReference !== undefined)
+                pending.push([firstReference, secondReference]);
+        }
+        return true;
+    }
+    evidence(location) {
+        const key = this.location(location);
+        const cached = this.evidenceByAt.get(key);
+        if (cached !== undefined)
+            return cached;
+        const conjuncts = conjunctsOf(location);
+        let kinds = ANY;
+        let values;
+        let upper;
+        let lower;
+        const multipleOf = [];
+        let maxLength;
+        let minLength = 0;
+        const patterns = new Set();
+        const fullMatches = new Set();
+        let maxItems;
+        let minItems = 0;
+        let uniqueItems = false;
+        let maxProperties;
+        let minProperties = 0;
+        const required = new Set();
+        const dependentRequired = new Map();
+        const valueKinds = new Set();
+        const narrow = (candidates) => {
+            values =
+                values === undefined
+                    ? [...candidates]
+                    : values.filter((value) => candidates.some((candidate) => jsonEqual(value, candidate)));
+        };
+        for (const conjunct of conjuncts) {
+            const schema = schemaOf(conjunct);
+            if (schema === false)
+                kinds = 0;
+            if (!isJsonObject(schema))
+                continue;
+            kinds &= typeMask(schema.type);
+            if (Object.hasOwn(schema, 'const')) {
+                narrow([schema.const]);
+                kinds &= kindOf(schema.const);
+            }
+            if (Array.isArray(schema.enum)) {
+                narrow(schema.enum);
+                kinds &= schema.enum.reduce((mask, value) => mask | kindOf(value), 0);
+            }
+            const valueKind = schema['x-astrale-value-kind'];
+            if (typeof valueKind === 'string') {
+                valueKinds.add(valueKind);
+                if (valueKind === 'instant')
+                    kinds &= STRING;
+                if (valueKind === 'blob')
+                    kinds &= OBJECT;
+            }
+            upper = tighter(upper, schema.maximum, false, (a, b) => a < b);
+            upper = tighter(upper, schema.exclusiveMaximum, true, (a, b) => a < b);
+            lower = tighter(lower, schema.minimum, false, (a, b) => a > b);
+            lower = tighter(lower, schema.exclusiveMinimum, true, (a, b) => a > b);
+            if (typeof schema.multipleOf === 'number')
+                multipleOf.push(schema.multipleOf);
+            if (typeof schema.maxLength === 'number')
+                maxLength = min(maxLength, schema.maxLength);
+            if (typeof schema.minLength === 'number')
+                minLength = Math.max(minLength, schema.minLength);
+            if (typeof schema.pattern === 'string')
+                patterns.add(schema.pattern);
+            if (typeof schema.fullMatch === 'string')
+                fullMatches.add(schema.fullMatch);
+            if (typeof schema.maxItems === 'number')
+                maxItems = min(maxItems, schema.maxItems);
+            if (typeof schema.minItems === 'number')
+                minItems = Math.max(minItems, schema.minItems);
+            if (schema.uniqueItems === true)
+                uniqueItems = true;
+            if (typeof schema.maxProperties === 'number') {
+                maxProperties = min(maxProperties, schema.maxProperties);
+            }
+            if (typeof schema.minProperties === 'number') {
+                minProperties = Math.max(minProperties, schema.minProperties);
+            }
+            if (Array.isArray(schema.required)) {
+                for (const name of schema.required)
+                    if (typeof name === 'string')
+                        required.add(name);
+            }
+            if (isJsonObject(schema.dependentRequired)) {
+                for (const [name, dependencies] of Object.entries(schema.dependentRequired)) {
+                    if (!Array.isArray(dependencies))
+                        continue;
+                    const known = dependentRequired.get(name) ?? new Set();
+                    for (const dependency of dependencies) {
+                        if (typeof dependency === 'string')
+                            known.add(dependency);
+                    }
+                    dependentRequired.set(name, known);
+                }
+            }
+        }
+        const finite = values === undefined
+            ? finiteKinds(kinds)
+            : values.filter((value) => (kindOf(value) & kinds) !== 0);
+        const result = Object.freeze({
+            conjuncts,
+            kinds,
+            ...(finite === undefined ? {} : { values: finite }),
+            ...(upper === undefined ? {} : { upper }),
+            ...(lower === undefined ? {} : { lower }),
+            multipleOf,
+            ...(maxLength === undefined ? {} : { maxLength }),
+            minLength,
+            patterns,
+            fullMatches,
+            ...(maxItems === undefined ? {} : { maxItems }),
+            minItems,
+            uniqueItems,
+            ...(maxProperties === undefined ? {} : { maxProperties }),
+            minProperties,
+            required,
+            dependentRequired,
+            valueKinds,
+        });
+        this.evidenceByAt.set(key, result);
+        return result;
+    }
+    accepts(location, value) {
+        return evaluateInstance(loadValueProgram(location.program, location.index), value).valid;
+    }
+    location(value) {
+        let id = this.programs.get(value.program);
+        if (id === undefined) {
+            id = this.programs.size;
+            this.programs.set(value.program, id);
+        }
+        return `${id}:${value.index}`;
+    }
+    pair(outer, inner) {
+        return `${this.location(outer)}|${this.location(inner)}`;
+    }
+}
+function at(program, index) {
+    return { program, index };
+}
+function schemaOf(location) {
+    const node = location.program.nodes[location.index];
+    if (node === undefined)
+        throw new TypeError('Value program location is absent.');
+    return node.schema;
+}
+function childOf(location, keyword, member) {
+    const base = appendPointer('', keyword);
+    const key = (member === undefined ? base : appendPointer(base, member)).slice(1);
+    const index = location.program.nodes[location.index]?.children[key];
+    return index === undefined ? undefined : at(location.program, index);
+}
+function childrenOf(location, keyword) {
+    const schema = schemaOf(location);
+    if (!isJsonObject(schema) || !Array.isArray(schema[keyword]))
+        return [];
+    return schema[keyword].flatMap((_, index) => {
+        const child = childOf(location, keyword, index);
+        return child === undefined ? [] : [child];
+    });
+}
+function referenceOf(location) {
+    const index = location.program.nodes[location.index]?.reference;
+    return index === undefined ? undefined : at(location.program, index);
+}
+/** The location with its `$ref` targets and `allOf` branches; admission makes this acyclic. */
+function conjunctsOf(location) {
+    const seen = new Set();
+    const conjuncts = [];
+    const visit = (current) => {
+        if (seen.has(current.index))
+            return;
+        seen.add(current.index);
+        conjuncts.push(current);
+        const reference = referenceOf(current);
+        if (reference !== undefined)
+            visit(reference);
+        for (const branch of childrenOf(current, 'allOf'))
+            visit(branch);
+    };
+    visit(location);
+    return conjuncts;
+}
+function matches(location, pattern, name) {
+    return loadValueProgram(location.program).matcher(pattern).test(name);
+}
+/** Whether a schema asserts nothing. */
+function isTop(schema) {
+    if (schema === true)
+        return true;
+    if (schema === false)
+        return false;
+    return Object.keys(schema).every((keyword) => INERT.has(keyword) ||
+        ((keyword === 'then' || keyword === 'else') && !Object.hasOwn(schema, 'if')) ||
+        ((keyword === 'minContains' || keyword === 'maxContains') &&
+            !Object.hasOwn(schema, 'contains')));
+}
+function assertionKeys(schema) {
+    return Object.keys(schema).filter((keyword) => !INERT.has(keyword) && !SUBSCHEMA_KEYWORDS.has(keyword) && keyword !== '$ref');
+}
+/** Subschema children keyed by their keyword path, without `$defs` or inert annotations. */
+function subschemaChildren(location) {
+    const children = location.program.nodes[location.index]?.children ?? {};
+    return new Map(Object.entries(children).filter(([path]) => SUBSCHEMA_KEYWORDS.has(path.split('/', 1)[0].replaceAll('~1', '/').replaceAll('~0', '~'))));
+}
+function has(evidence, kinds) {
+    return (evidence.kinds & kinds) !== 0;
+}
+function typeMask(type) {
+    if (type === undefined)
+        return ANY;
+    const names = typeof type === 'string' ? [type] : Array.isArray(type) ? type : [];
+    return names.reduce((mask, name) => {
+        switch (name) {
+            case 'null':
+                return mask | NULL;
+            case 'boolean':
+                return mask | BOOLEAN;
+            case 'object':
+                return mask | OBJECT;
+            case 'array':
+                return mask | ARRAY;
+            case 'string':
+                return mask | STRING;
+            case 'integer':
+                return mask | INTEGER;
+            case 'number':
+                return mask | NUMBER;
+            default:
+                return mask;
+        }
+    }, 0);
+}
+function kindOf(value) {
+    if (value === null)
+        return NULL;
+    if (typeof value === 'boolean')
+        return BOOLEAN;
+    if (typeof value === 'string')
+        return STRING;
+    if (typeof value === 'number')
+        return Number.isInteger(value) ? INTEGER : FRACTION;
+    return Array.isArray(value) ? ARRAY : OBJECT;
+}
+/** The finite value set of a kind mask made only of null and booleans. */
+function finiteKinds(kinds) {
+    if ((kinds & ~(NULL | BOOLEAN)) !== 0)
+        return undefined;
+    return [
+        ...((kinds & NULL) !== 0 ? [null] : []),
+        ...((kinds & BOOLEAN) !== 0 ? [true, false] : []),
+    ];
+}
+function tighter(current, value, exclusive, stricter) {
+    if (typeof value !== 'number')
+        return current;
+    if (current === undefined ||
+        stricter(value, current.value) ||
+        (value === current.value && exclusive)) {
+        return { value, exclusive };
+    }
+    return current;
+}
+function min(current, value) {
+    return current === undefined ? value : Math.min(current, value);
+}