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

package/dist/v1/language/value/evaluate/validity.optimization.js

@@ -0,0 +1,342 @@
+import { isCanonicalBlobRef } from '../model/blob.js';
+import { isInstantValue } from '../model/instant.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { codePointLength, isMultipleOf, jsonEqual, matchesType, unique } from './assertions.js';
+/**
+ * Whether a value satisfies its prepared schema, as the evaluator decides it, without building a
+ * failure, an instance pointer or an annotation: the evaluator's verdict, or undefined when this
+ * check cannot give it. Only the evaluator reports why a value fails, so a caller keeps it for
+ * every value this check does not find valid.
+ *
+ * Each schema location is compiled once into a closure over its keywords, retained with the
+ * prepared schema. A schema whose closure holds an annotation-dependent keyword
+ * (`unevaluatedItems`, `unevaluatedProperties`) is left to the evaluator, as is a value nested
+ * deeper than this check follows, and any value whose check throws.
+ */
+export function satisfies(compiled, value) {
+    let checks = compilations.get(compiled);
+    if (checks === undefined) {
+        checks = annotationFree(compiled) ? new Map() : null;
+        compilations.set(compiled, checks);
+    }
+    if (checks === null)
+        return undefined;
+    const outer = verdicts;
+    verdicts = new Map();
+    try {
+        return checkOf(compiled, checks, compiled.root)(value, 0);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        verdicts = outer;
+    }
+}
+/** Per prepared schema: its checks by location, or null when its closure needs annotations. */
+const compilations = new WeakMap();
+/** Locations one evaluation follows before leaving the value to the evaluator. */
+const MAXIMUM_DEPTH = 1_024;
+const UNDECIDED = new Error('The value is left to the evaluator.');
+/**
+ * The verdicts of the current evaluation by referenced location and value. Only a reference reaches
+ * one location from several places, so each referenced location is checked once per value, as the
+ * evaluator memoizes it, and a schema that references a location twice per level stays linear. A
+ * location entered again on the same value is a cycle, left to the evaluator.
+ */
+let verdicts = new Map();
+function annotationFree(compiled) {
+    for (const { schema } of compiled.locations.values()) {
+        if (isJsonObject(schema) &&
+            (Object.hasOwn(schema, 'unevaluatedItems') || Object.hasOwn(schema, 'unevaluatedProperties'))) {
+            return false;
+        }
+    }
+    return true;
+}
+/** The check of one location, compiled on its first use so that references may recur. */
+function checkOf(compiled, checks, location) {
+    let check = checks.get(location);
+    if (check === undefined) {
+        let body;
+        check = (value, depth) => {
+            if (depth > MAXIMUM_DEPTH)
+                throw UNDECIDED;
+            body ??= compileLocation(compiled, checks, location);
+            return body(value, depth);
+        };
+        checks.set(location, check);
+    }
+    return check;
+}
+/**
+ * The conjunction of the location's keywords, each as the evaluator applies it: an applicator
+ * checks the same value at its child location, a keyword of one type passes every other type.
+ */
+function compileLocation(compiled, checks, location) {
+    const schema = location.schema;
+    if (schema === true)
+        return () => true;
+    if (schema === false)
+        return () => false;
+    const child = (keyword, member) => checkOf(compiled, checks, compiled.child(location, keyword, member));
+    const parts = [];
+    if (Object.hasOwn(schema, '$ref')) {
+        const target = compiled.reference(location);
+        if (target === undefined)
+            throw UNDECIDED;
+        const check = checkOf(compiled, checks, target);
+        parts.push((value, depth) => {
+            let byValue = verdicts.get(target);
+            if (byValue === undefined)
+                verdicts.set(target, (byValue = new Map()));
+            const known = byValue.get(value);
+            if (known === null)
+                throw UNDECIDED;
+            if (known !== undefined)
+                return known;
+            byValue.set(value, null);
+            const verdict = check(value, depth + 1);
+            byValue.set(value, verdict);
+            return verdict;
+        });
+    }
+    compileCompositions(schema, child, parts);
+    compileCommon(schema, parts);
+    compileNumber(schema, parts);
+    compileString(compiled, schema, parts);
+    compileArray(schema, child, parts);
+    compileObject(compiled, schema, child, parts);
+    if (parts.length === 0)
+        return () => true;
+    if (parts.length === 1)
+        return parts[0];
+    return (value, depth) => {
+        for (const part of parts)
+            if (!part(value, depth))
+                return false;
+        return true;
+    };
+}
+function compileCompositions(schema, child, parts) {
+    const allOf = schemaList(schema.allOf)?.map((_, index) => child('allOf', index));
+    if (allOf !== undefined) {
+        parts.push((value, depth) => allOf.every((check) => check(value, depth + 1)));
+    }
+    const anyOf = schemaList(schema.anyOf)?.map((_, index) => child('anyOf', index));
+    if (anyOf !== undefined) {
+        parts.push((value, depth) => anyOf.some((check) => check(value, depth + 1)));
+    }
+    const oneOf = schemaList(schema.oneOf)?.map((_, index) => child('oneOf', index));
+    if (oneOf !== undefined) {
+        parts.push((value, depth) => {
+            let admitted = 0;
+            for (const check of oneOf)
+                if (check(value, depth + 1) && ++admitted > 1)
+                    return false;
+            return admitted === 1;
+        });
+    }
+    if (isSchema(schema.not)) {
+        const not = child('not');
+        parts.push((value, depth) => !not(value, depth + 1));
+    }
+    if (isSchema(schema.if)) {
+        const condition = child('if');
+        const then = isSchema(schema.then) ? child('then') : undefined;
+        const otherwise = isSchema(schema.else) ? child('else') : undefined;
+        parts.push((value, depth) => {
+            const branch = condition(value, depth + 1) ? then : otherwise;
+            return branch === undefined || branch(value, depth + 1);
+        });
+    }
+}
+function compileCommon(schema, parts) {
+    const kind = schema['x-astrale-value-kind'];
+    if (kind === 'instant')
+        parts.push((value) => isInstantValue(value));
+    if (kind === 'blob')
+        parts.push((value) => isCanonicalBlobRef(value));
+    const type = schema.type;
+    if (typeof type === 'string')
+        parts.push((value) => matchesType(type, value));
+    else if (Array.isArray(type)) {
+        const types = type.filter((candidate) => typeof candidate === 'string');
+        parts.push((value) => types.some((candidate) => matchesType(candidate, value)));
+    }
+    if (Object.hasOwn(schema, 'const')) {
+        const expected = schema.const;
+        parts.push((value) => jsonEqual(value, expected));
+    }
+    const choices = schema.enum;
+    if (Array.isArray(choices)) {
+        parts.push((value) => choices.some((candidate) => jsonEqual(value, candidate)));
+    }
+}
+function compileNumber(schema, parts) {
+    const { multipleOf, maximum, exclusiveMaximum, minimum, exclusiveMinimum } = schema;
+    const bounded = typeof multipleOf === 'number' ||
+        typeof maximum === 'number' ||
+        typeof exclusiveMaximum === 'number' ||
+        typeof minimum === 'number' ||
+        typeof exclusiveMinimum === 'number';
+    if (!bounded)
+        return;
+    parts.push((value) => typeof value !== 'number' ||
+        ((typeof multipleOf !== 'number' || isMultipleOf(value, multipleOf)) &&
+            (typeof maximum !== 'number' || value <= maximum) &&
+            (typeof exclusiveMaximum !== 'number' || value < exclusiveMaximum) &&
+            (typeof minimum !== 'number' || value >= minimum) &&
+            (typeof exclusiveMinimum !== 'number' || value > exclusiveMinimum)));
+}
+function compileString(compiled, schema, parts) {
+    const { maxLength, minLength, pattern, fullMatch } = schema;
+    if (typeof maxLength === 'number' || typeof minLength === 'number') {
+        // For n UTF-16 units, ceil(n / 2) <= code points <= n: count only when the bounds cannot
+        // decide, as the evaluator does.
+        parts.push((value) => {
+            if (typeof value !== 'string')
+                return true;
+            if ((typeof maxLength !== 'number' || value.length <= maxLength) &&
+                (typeof minLength !== 'number' || Math.ceil(value.length / 2) >= minLength)) {
+                return true;
+            }
+            const length = codePointLength(value);
+            return ((typeof maxLength !== 'number' || length <= maxLength) &&
+                (typeof minLength !== 'number' || length >= minLength));
+        });
+    }
+    if (typeof pattern === 'string') {
+        const matcher = compiled.matcher(pattern);
+        parts.push((value) => typeof value !== 'string' || matcher.test(value));
+    }
+    if (typeof fullMatch === 'string') {
+        const matcher = compiled.matcher(fullMatch);
+        parts.push((value) => typeof value !== 'string' || matcher.matches(value));
+    }
+}
+function compileArray(schema, child, parts) {
+    const { maxItems, minItems } = schema;
+    if (typeof maxItems === 'number' || typeof minItems === 'number' || schema.uniqueItems === true) {
+        const distinct = schema.uniqueItems === true;
+        parts.push((value) => !Array.isArray(value) ||
+            ((typeof maxItems !== 'number' || value.length <= maxItems) &&
+                (typeof minItems !== 'number' || value.length >= minItems) &&
+                (!distinct || unique(value))));
+    }
+    const prefix = schemaList(schema.prefixItems)?.map((_, index) => child('prefixItems', index));
+    const items = isSchema(schema.items) ? child('items') : undefined;
+    if (prefix !== undefined || items !== undefined) {
+        const leading = prefix ?? [];
+        parts.push((value, depth) => {
+            if (!Array.isArray(value))
+                return true;
+            for (let index = 0; index < value.length; index++) {
+                const check = index < leading.length ? leading[index] : items;
+                if (check !== undefined && !check(value[index], depth + 1))
+                    return false;
+            }
+            return true;
+        });
+    }
+    if (isSchema(schema.contains)) {
+        const contains = child('contains');
+        const least = typeof schema.minContains === 'number' ? schema.minContains : 1;
+        const most = typeof schema.maxContains === 'number' ? schema.maxContains : Number.POSITIVE_INFINITY;
+        parts.push((value, depth) => {
+            if (!Array.isArray(value))
+                return true;
+            let matches = 0;
+            for (const item of value)
+                if (contains(item, depth + 1))
+                    matches++;
+            return matches >= least && matches <= most;
+        });
+    }
+}
+function compileObject(compiled, schema, child, parts) {
+    const { maxProperties, minProperties } = schema;
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((name) => typeof name === 'string')
+        : [];
+    const dependentRequired = isJsonObject(schema.dependentRequired)
+        ? Object.entries(schema.dependentRequired).flatMap(([name, names]) => Array.isArray(names)
+            ? [[name, names.filter((other) => typeof other === 'string')]]
+            : [])
+        : [];
+    if (typeof maxProperties === 'number' ||
+        typeof minProperties === 'number' ||
+        required.length > 0 ||
+        dependentRequired.length > 0) {
+        parts.push((value) => {
+            if (!isJsonObject(value))
+                return true;
+            if (typeof maxProperties === 'number' || typeof minProperties === 'number') {
+                const count = Object.keys(value).length;
+                if (typeof maxProperties === 'number' && count > maxProperties)
+                    return false;
+                if (typeof minProperties === 'number' && count < minProperties)
+                    return false;
+            }
+            for (const name of required)
+                if (!Object.hasOwn(value, name))
+                    return false;
+            for (const [name, names] of dependentRequired) {
+                if (Object.hasOwn(value, name) && !names.every((other) => Object.hasOwn(value, other))) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    // Each member is checked by every pattern it matches, by its declared schema, and by the
+    // additional schema when neither declares it.
+    const declared = isJsonObject(schema.properties) ? schema.properties : {};
+    const properties = new Map(Object.keys(declared).map((name) => [name, child('properties', name)]));
+    const patterns = isJsonObject(schema.patternProperties)
+        ? Object.keys(schema.patternProperties).map((source) => [compiled.matcher(source), child('patternProperties', source)])
+        : [];
+    const additional = isSchema(schema.additionalProperties)
+        ? child('additionalProperties')
+        : undefined;
+    const names = isSchema(schema.propertyNames) ? child('propertyNames') : undefined;
+    if (properties.size > 0 || patterns.length > 0 || additional !== undefined || names) {
+        parts.push((value, depth) => {
+            if (!isJsonObject(value))
+                return true;
+            for (const name of Object.keys(value)) {
+                const member = value[name];
+                let matched = false;
+                for (const [matcher, check] of patterns) {
+                    if (!matcher.test(name))
+                        continue;
+                    matched = true;
+                    if (!check(member, depth + 1))
+                        return false;
+                }
+                const check = Object.hasOwn(declared, name) ? properties.get(name) : undefined;
+                if (check !== undefined) {
+                    if (!check(member, depth + 1))
+                        return false;
+                }
+                else if (!matched && additional !== undefined && !additional(member, depth + 1)) {
+                    return false;
+                }
+                if (names !== undefined && !names(name, depth + 1))
+                    return false;
+            }
+            return true;
+        });
+    }
+    if (isJsonObject(schema.dependentSchemas)) {
+        const dependent = Object.keys(schema.dependentSchemas).map((name) => [name, child('dependentSchemas', name)]);
+        parts.push((value, depth) => !isJsonObject(value) ||
+            dependent.every(([name, check]) => !Object.hasOwn(value, name) || check(value, depth + 1)));
+    }
+}
+function schemaList(input) {
+    return Array.isArray(input) ? input : undefined;
+}
+function isSchema(input) {
+    return typeof input === 'boolean' || isJsonObject(input);
+}

package/dist/v1/language/value/inclusion/arrays.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from './assertions.js';
+/** Rules for the array size, uniqueness, item and `contains` keywords. */
+export declare const arrayRules: ReadonlyMap<string, Rule>;

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

@@ -0,0 +1,85 @@
+import { has } from './evidence.js';
+import { isTop } from './keywords.js';
+import { ARRAY } from './kinds.js';
+import { childOf, childrenOf, schemaOf } from './location.js';
+/** Rules for the array size, uniqueness, item and `contains` keywords. */
+export const arrayRules = new Map([
+    [
+        'maxItems',
+        ({ value, evidence }) => typeof value !== 'number' ||
+            !has(evidence, ARRAY) ||
+            (evidence.maxItems !== undefined && evidence.maxItems <= value),
+    ],
+    [
+        'minItems',
+        ({ value, evidence }) => typeof value !== 'number' ||
+            !has(evidence, ARRAY) ||
+            value <= 0 ||
+            evidence.minItems >= value,
+    ],
+    [
+        'uniqueItems',
+        ({ value, evidence }) => value !== true ||
+            !has(evidence, ARRAY) ||
+            evidence.uniqueItems ||
+            (evidence.maxItems !== undefined && evidence.maxItems <= 1),
+    ],
+    ['prefixItems', itemsHold],
+    ['items', itemsHold],
+    ['contains', containsHolds],
+    ['minContains', containsHolds],
+    ['maxContains', containsHolds],
+]);
+function itemsHold({ inclusion, 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) => inclusion.includes(required, constraint)))
+            return false;
+    }
+    return true;
+}
+function containsHolds({ inclusion, outer, schema, evidence }) {
+    const contains = childOf(outer, 'contains');
+    if (contains === undefined || !has(evidence, ARRAY))
+        return true;
+    const { minimum, maximum } = containsCounts(schema);
+    const ownContains = evidence.conjuncts.flatMap((conjunct) => {
+        const own = childOf(conjunct, 'contains');
+        if (own === undefined)
+            return [];
+        const conjunctSchema = schemaOf(conjunct);
+        return [{ at: own, ...containsCounts(conjunctSchema) }];
+    });
+    // Every inner match is an outer match, so outer counts at least as many.
+    const atLeast = minimum <= 0 ||
+        ownContains.some((own) => own.minimum >= minimum && inclusion.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 && inclusion.includes(own.at, contains));
+    return atLeast && atMost;
+}
+/** The match counts `contains` requires, with the evaluator's defaults. */
+function containsCounts(schema) {
+    return {
+        minimum: typeof schema.minContains === 'number' ? schema.minContains : 1,
+        maximum: typeof schema.maxContains === 'number' ? schema.maxContains : Number.POSITIVE_INFINITY,
+    };
+}

package/dist/v1/language/value/inclusion/assertions.d.ts

@@ -0,0 +1,18 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { Evidence } from './evidence.js';
+import type { Inclusion } from './includes.js';
+import type { At } from './location.js';
+/** One keyword of `outer`, to be proved from the evidence of `inner`. */
+export interface Assertion {
+    readonly inclusion: Inclusion;
+    readonly keyword: string;
+    readonly value: JsonValue | undefined;
+    readonly outer: At;
+    readonly schema: Readonly<Record<string, JsonValue>>;
+    readonly inner: At;
+    readonly evidence: Evidence;
+}
+/** Whether one outer keyword holds for every value the inner evidence admits. */
+export type Rule = (assertion: Assertion) => boolean;
+/** Whether every keyword of the outer `schema` holds for the values `inner` admits. */
+export declare function assertionsHold(inclusion: Inclusion, outer: At, schema: Readonly<Record<string, JsonValue>>, inner: At, evidence: Evidence): boolean;

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

@@ -0,0 +1,29 @@
+import { arrayRules } from './arrays.js';
+import { combinatorRules } from './combinators.js';
+import { INERT } from './keywords.js';
+import { numberRules } from './numbers.js';
+import { objectRules } from './objects.js';
+import { stringRules } from './strings.js';
+import { typeRules } from './types.js';
+const RULES = new Map([
+    ...combinatorRules,
+    ...typeRules,
+    ...numberRules,
+    ...stringRules,
+    ...arrayRules,
+    ...objectRules,
+]);
+/** Whether every keyword of the outer `schema` holds for the values `inner` admits. */
+export function assertionsHold(inclusion, 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) => {
+        const rule = RULES.get(keyword);
+        if (rule === undefined)
+            return INERT.has(keyword);
+        return rule({ inclusion, keyword, value: schema[keyword], outer, schema, inner, evidence });
+    });
+}

package/dist/v1/language/value/inclusion/combinators.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from './assertions.js';
+/** Rules for `$ref`, the boolean combinators and the conditional keywords. */
+export declare const combinatorRules: ReadonlyMap<string, Rule>;

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

@@ -0,0 +1,67 @@
+import { equivalent } from './equivalence.js';
+import { childOf, childrenOf, referenceOf } from './location.js';
+/** Rules for `$ref`, the boolean combinators and the conditional keywords. */
+export const combinatorRules = new Map([
+    [
+        '$ref',
+        ({ inclusion, outer, inner }) => {
+            const target = referenceOf(outer);
+            return target !== undefined && inclusion.includes(target, inner);
+        },
+    ],
+    [
+        'allOf',
+        ({ inclusion, outer, inner }) => childrenOf(outer, 'allOf').every((branch) => inclusion.includes(branch, inner)),
+    ],
+    [
+        'anyOf',
+        ({ inclusion, outer, inner }) => childrenOf(outer, 'anyOf').some((branch) => inclusion.includes(branch, inner)),
+    ],
+    ['oneOf', () => false],
+    [
+        'not',
+        ({ inclusion, outer, evidence }) => {
+            const negated = childOf(outer, 'not');
+            return negated !== undefined && excludes(inclusion, negated, evidence);
+        },
+    ],
+    ['if', conditionalHolds],
+    ['then', conditionalHolds],
+    ['else', conditionalHolds],
+]);
+/** Whether no value admitted by `evidence` satisfies `negated`. */
+function excludes(inclusion, negated, evidence) {
+    if ((inclusion.evidence(negated).kinds & evidence.kinds) === 0)
+        return true;
+    return evidence.conjuncts.some((conjunct) => {
+        const own = childOf(conjunct, 'not');
+        return own !== undefined && inclusion.includes(own, negated);
+    });
+}
+function conditionalHolds({ inclusion, 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 ||
+        inclusion.includes(then, inner) ||
+        (fallback !== undefined && inclusion.includes(then, fallback));
+    const elseHolds = (fallback) => otherwise === undefined ||
+        inclusion.includes(otherwise, inner) ||
+        (fallback !== undefined && inclusion.includes(otherwise, fallback));
+    if (thenHolds() && elseHolds())
+        return true;
+    for (const conjunct of evidence.conjuncts) {
+        const own = childOf(conjunct, 'if');
+        if (own === undefined || !equivalent(inclusion, own, condition))
+            continue;
+        if (thenHolds(childOf(conjunct, 'then')) && elseHolds(childOf(conjunct, 'else')))
+            return true;
+    }
+    if (inclusion.includes(condition, inner))
+        return thenHolds();
+    if (excludes(inclusion, condition, evidence))
+        return elseHolds();
+    return false;
+}

package/dist/v1/language/value/inclusion/equivalence.d.ts

@@ -0,0 +1,4 @@
+import type { Inclusion } from './includes.js';
+import type { At } from './location.js';
+/** Whether the two locations are bisimilar: equal assertions over paired subschemas. */
+export declare function equivalent(inclusion: Inclusion, left: At, right: At): boolean;

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

@@ -0,0 +1,74 @@
+import { jsonEqual } from '../evaluate/assertions.js';
+import { INERT } from './keywords.js';
+import { at, referenceOf, schemaOf } from './location.js';
+/** 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',
+]);
+/** Whether the two locations are bisimilar: equal assertions over paired subschemas. */
+export function equivalent(inclusion, left, right) {
+    const pending = [[left, right]];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const [first, second] = pending.pop();
+        const key = inclusion.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;
+}
+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', '~'))));
+}

package/dist/v1/language/value/inclusion/evidence.d.ts

@@ -0,0 +1,34 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { At } from './location.js';
+/** One numeric bound, inclusive unless `exclusive`. */
+export interface Bound {
+    readonly value: number;
+    readonly exclusive: boolean;
+}
+/** Over-approximation of the values one location admits, collected from its conjuncts. */
+export interface Evidence {
+    /** The location, its `$ref` targets and its `allOf` branches, transitively. */
+    readonly conjuncts: readonly At[];
+    readonly kinds: number;
+    /** A finite superset of the admitted values, when one is known. */
+    readonly values?: readonly JsonValue[];
+    readonly upper?: Bound;
+    readonly lower?: Bound;
+    readonly multipleOf: readonly number[];
+    readonly maxLength?: number;
+    readonly minLength: number;
+    readonly patterns: ReadonlySet<string>;
+    readonly fullMatches: ReadonlySet<string>;
+    readonly maxItems?: number;
+    readonly minItems: number;
+    readonly uniqueItems: boolean;
+    readonly maxProperties?: number;
+    readonly minProperties: number;
+    readonly required: ReadonlySet<string>;
+    readonly dependentRequired: ReadonlyMap<string, ReadonlySet<string>>;
+    readonly valueKinds: ReadonlySet<string>;
+}
+/** Whether `evidence` may admit a value of one of `kinds`. */
+export declare function has(evidence: Evidence, kinds: number): boolean;
+/** The evidence the conjuncts of `location` carry together. */
+export declare function evidenceOf(location: At): Evidence;