@astrale-os/kernel-dsl 1.0.0-beta.2 → 1.0.0-beta.20

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

@@ -1,8 +1,8 @@
-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';
+import { assertionsHold } from './assertions.js';
+import { equivalent } from './equivalence.js';
+import { evidenceOf } from './evidence.js';
+import { isTop } from './keywords.js';
+import { accepts, at, childrenOf, schemaOf } from './location.js';
 /**
  * Whether `outer` admits every value `inner` admits, under the one V1 evaluator.
  *
@@ -13,60 +13,13 @@ import { appendPointer } from '../syntax/pointer.js';
 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 {
+/** One inclusion question: the decided pairs, the pairs being decided and the evidence cache. */
+export class Inclusion {
     programs = new Map();
     decided = new Map();
     pending = new Set();
     evidenceByAt = new Map();
+    /** Whether `outer` admits every value `inner` admits; a cyclic premise proves nothing. */
     includes(outer, inner) {
         const key = this.pair(outer, inner);
         const known = this.decided.get(key);
@@ -85,19 +38,33 @@ class Inclusion {
             this.pending.delete(key);
         }
     }
+    /** The evidence of one location, computed once per question. */
+    evidence(location) {
+        const key = this.location(location);
+        const cached = this.evidenceByAt.get(key);
+        if (cached !== undefined)
+            return cached;
+        const result = evidenceOf(location);
+        this.evidenceByAt.set(key, result);
+        return result;
+    }
+    /** A key identifying an ordered pair of locations within this question. */
+    pair(outer, inner) {
+        return `${this.location(outer)}|${this.location(inner)}`;
+    }
     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));
+            return evidence.values.every((value) => !accepts(inner, value) || accepts(outer, value));
         }
         if (schema === false)
             return false;
-        if (this.equivalent(outer, inner))
+        if (equivalent(this, outer, inner))
             return true;
-        if (schema !== true && this.assertionsHold(outer, schema, inner, evidence))
+        if (schema !== true && assertionsHold(this, 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) => {
@@ -105,535 +72,6 @@ class Inclusion {
             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) {
@@ -642,136 +80,4 @@ class Inclusion {
         }
         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);
 }