@astrale-os/kernel-dsl 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/v1/language/policy/analysis/typing.js

@@ -0,0 +1,338 @@
+import { Key } from '../../../addressing/index.js';
+import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { branchesOf, branchProduct, capBranches, targetMode, termKey, UnionFind, } from './branches.js';
+import { MAX_REPEAT } from './budgets.js';
+import { admittedCheckClasses } from './checks.js';
+export class PolicyTyping {
+    scope;
+    // Expanded branches of each named Policy, cached by node identity. A Policy's expansion is reused
+    // across every composition path that reaches it (and across every use site and object contract,
+    // none of which the expansion depends on), so a shared-child composition DAG is expanded in work
+    // linear in the number of Policies instead of enumerating every path. The expansion result is
+    // independent of the reaching path up to the opaque term-namespace labels, which only ever
+    // disambiguate variables within one branch and leave targetMode and branch typing unchanged.
+    // Two occurrences of one Policy in a branch share labels only when a Policy reaches it by two
+    // paths; for that to merge distinct variables, the Policy expands deeper than MAX_PATTERN_DEPTH.
+    #expansions = new Map();
+    constructor(scope) {
+        this.scope = scope;
+    }
+    /** The normalized branches of a named Policy, `undefined` when it does not expand. */
+    expandedBranches(name, namespace) {
+        return this.#expandedBranches(name, new Set(), namespace);
+    }
+    policyAccepts(name, object) {
+        return this.#policyBranchTyping(name, object)?.every(Boolean) ?? false;
+    }
+    /** Whether the Policy accepts every concrete source and target pair the Edge Class accepts. */
+    policyAcceptsEdgeClass(name, declaration) {
+        const endpoints = declaration.orientation === 'directed'
+            ? [declaration.endpoints.source, declaration.endpoints.target]
+            : declaration.endpoints;
+        const sources = this.#concreteEndpointClasses(endpoints[0].accepts);
+        const targets = this.#concreteEndpointClasses(endpoints[1].accepts);
+        return sources.every((source) => targets.every((target) => this.#policyAcceptsEdge(name, { kind: 'exact', ref: source }, { kind: 'exact', ref: target })));
+    }
+    /**
+     * How a check of the Policy types against each contract of its object, `undefined` when the
+     * Policy does not expand or one of its branches is typed for no contract.
+     */
+    checkLeafClasses(name, contracts) {
+        const typings = new Map(contracts.map((contract) => [
+            contract.kind === 'exact' ? Key.of(contract.ref) : 'default',
+            this.#policyBranchTyping(name, contract),
+        ]));
+        const admitted = admittedCheckClasses(typings);
+        return admitted === undefined ? undefined : { accepted: [...typings.keys()], admitted };
+    }
+    endpointsOverlap(left, right) {
+        const seed = [{ kind: 'open', requirements: [] }];
+        const afterLeft = this.#applyEndpoint(seed, left);
+        return this.#applyEndpoint(afterLeft, right).length > 0;
+    }
+    branchIsTyped(branch, use) {
+        if (targetMode(branch) !== use.kind)
+            return false;
+        const alternatives = edgeAlternatives(branch.edges, this);
+        return alternatives.some((variants) => this.#constraintsAreSatisfiable(branch, variants, use));
+    }
+    /** Whether each normalized branch of the Policy is typed for an object of this contract. */
+    #policyBranchTyping(name, object) {
+        const branches = this.#expandedBranches(name, new Set(), `$use:${name}`);
+        const use = { kind: 'object', object };
+        return branches?.map((branch) => this.branchIsTyped(branch, use));
+    }
+    #policyAcceptsEdge(name, source, target) {
+        const branches = this.#expandedBranches(name, new Set(), `$edge-use:${name}`);
+        const use = { kind: 'edge', source, target };
+        return branches !== undefined && branches.every((branch) => this.branchIsTyped(branch, use));
+    }
+    #concreteEndpointClasses(accepts) {
+        return this.scope.concreteNodeClasses.filter((candidate) => this.#classSatisfiesEndpoint(candidate, accepts));
+    }
+    #expandedBranches(name, visiting, namespace) {
+        if (visiting.has(name))
+            return undefined;
+        const cached = this.#expansions.get(name);
+        if (cached !== undefined || this.#expansions.has(name))
+            return cached;
+        const expanded = this.#expandDeclaration(name, visiting, namespace);
+        this.#expansions.set(name, expanded);
+        return expanded;
+    }
+    #expandDeclaration(name, visiting, namespace) {
+        const declaration = this.scope.normalized.get(name);
+        if (declaration === undefined)
+            return undefined;
+        if ('match' in declaration)
+            return branchesOf(declaration.match, namespace);
+        const nested = new Set(visiting);
+        nested.add(name);
+        const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
+        const children = [];
+        for (const [index, ref] of refs.entries()) {
+            if (!this.scope.isLocalPolicy(ref))
+                return undefined;
+            const expanded = this.#expandedBranches(ref.name, nested, `${namespace}/${index}:${ref.name}`);
+            if (expanded === undefined)
+                return undefined;
+            children.push(expanded);
+        }
+        return 'allOf' in declaration ? branchProduct(children) : capBranches(children.flat());
+    }
+    #constraintsAreSatisfiable(branch, variants, use) {
+        const terms = new Set(use.kind === 'object' ? ['subject', 'object'] : ['subject', 'source', 'target']);
+        for (const key of branch.variables.keys())
+            terms.add(key);
+        for (const key of branch.terms.keys())
+            terms.add(key);
+        for (const edge of branch.edges) {
+            terms.add(termKey(edge.pattern.source, edge.namespace));
+            terms.add(termKey(edge.pattern.target, edge.namespace));
+        }
+        const union = new UnionFind(terms);
+        for (const [left, right] of branch.equalities)
+            union.join(left, right);
+        for (const variant of variants) {
+            for (const [left, right] of variant.equalities)
+                union.join(left, right);
+        }
+        const constraints = new Map();
+        for (const variant of variants) {
+            for (const [term, accepts] of variant.constraints) {
+                const root = union.find(term);
+                const values = constraints.get(root) ?? [];
+                values.push(accepts);
+                constraints.set(root, values);
+            }
+        }
+        const groups = new Map();
+        for (const term of terms) {
+            const root = union.find(term);
+            const members = groups.get(root) ?? [];
+            members.push(term);
+            groups.set(root, members);
+        }
+        for (const [root, members] of groups) {
+            const endpointConstraints = constraints.get(root) ?? [];
+            let candidates = [{ kind: 'open', requirements: [] }];
+            for (const member of members) {
+                candidates = this.#applyInitial(candidates, member, branch, use);
+                if (candidates.length === 0)
+                    return false;
+            }
+            for (const endpoint of endpointConstraints) {
+                candidates = this.#applyEndpoint(candidates, endpoint);
+                if (candidates.length === 0)
+                    return false;
+            }
+        }
+        return true;
+    }
+    #applyInitial(candidates, term, branch, use) {
+        if (term === 'subject')
+            return this.#applyAnyNodeClass(candidates);
+        const contract = targetContract(term, use);
+        if (contract !== undefined) {
+            if (contract.kind === 'exact')
+                return this.#applyExact(candidates, contract.ref);
+            if (contract.kind === 'default') {
+                return uniqueCandidates(this.scope.allNodeClasses.flatMap((ref) => this.#applyExact(candidates, ref)));
+            }
+            return candidates;
+        }
+        const referenced = branch.terms.get(term);
+        if (referenced?.kind === 'ref') {
+            const contract = this.scope.referenceContract(referenced.ref);
+            return contract?.kind === 'exact' ? this.#applyExact(candidates, contract.ref) : [];
+        }
+        const selector = branch.variables.get(term);
+        if (selector === undefined)
+            return [];
+        if (selector.kind === 'exact')
+            return this.#applyExact(candidates, selector.class);
+        if (selector.kind === 'any')
+            return candidates;
+        return this.#applyRequirement(candidates, selector.class);
+    }
+    #applyExact(candidates, exact) {
+        const result = [];
+        for (const candidate of candidates) {
+            if (candidate.kind === 'exact') {
+                if (definitionRefIndex(candidate.ref) === definitionRefIndex(exact))
+                    result.push(candidate);
+            }
+            else if (candidate.requirements.every((required) => this.scope.classExtends(exact, required))) {
+                result.push({ kind: 'exact', ref: exact });
+            }
+        }
+        return uniqueCandidates(result);
+    }
+    #applyAnyNodeClass(candidates) {
+        return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
+            ? [candidate]
+            : this.scope.allNodeClasses
+                .filter((ref) => candidate.requirements.every((required) => this.scope.classExtends(ref, required)))
+                .map((ref) => ({ kind: 'exact', ref }))));
+    }
+    #applyRequirement(candidates, required) {
+        const result = [];
+        for (const candidate of candidates) {
+            if (candidate.kind === 'exact') {
+                if (this.scope.classExtends(candidate.ref, required))
+                    result.push(candidate);
+            }
+            else {
+                result.push({
+                    kind: 'open',
+                    requirements: uniqueClasses([...candidate.requirements, required]),
+                });
+            }
+        }
+        return uniqueCandidates(result);
+    }
+    #applyEndpoint(candidates, accepts) {
+        const result = [];
+        for (const candidate of candidates) {
+            if (candidate.kind === 'exact') {
+                if (this.#classSatisfiesEndpoint(candidate.ref, accepts))
+                    result.push(candidate);
+                continue;
+            }
+            for (const accept of accepts) {
+                result.push({
+                    kind: 'open',
+                    requirements: uniqueClasses([...candidate.requirements, accept]),
+                });
+            }
+        }
+        return uniqueCandidates(result);
+    }
+    #classSatisfiesEndpoint(candidate, accepts) {
+        return accepts.some((accept) => this.scope.classExtends(candidate, accept));
+    }
+}
+function targetContract(term, use) {
+    if (use.kind === 'object')
+        return term === 'object' ? use.object : undefined;
+    if (term === 'source')
+        return use.source;
+    if (term === 'target')
+        return use.target;
+    return undefined;
+}
+function edgeAlternatives(edges, typing) {
+    let result = [[]];
+    for (const edge of edges) {
+        const variants = variantsForEdge(edge, typing);
+        if (variants.length === 0)
+            return [];
+        const next = [];
+        for (const prefix of result) {
+            for (const variant of variants)
+                next.push([...prefix, variant]);
+        }
+        result = next;
+    }
+    return result;
+}
+function variantsForEdge(use, typing) {
+    const edge = use.pattern;
+    const declaration = typing.scope.edgeDeclaration(edge.class);
+    if (declaration === undefined)
+        return [];
+    const endpoints = declaration.orientation === 'directed'
+        ? [declaration.endpoints.source, declaration.endpoints.target]
+        : declaration.endpoints;
+    const bounds = edge.repeat ?? { min: 1, max: 1 };
+    if (!Number.isInteger(bounds.min) ||
+        !Number.isInteger(bounds.max) ||
+        bounds.min < 0 ||
+        bounds.max < bounds.min ||
+        bounds.max > MAX_REPEAT) {
+        return [];
+    }
+    const sourceKey = termKey(edge.source, use.namespace);
+    const targetKey = termKey(edge.target, use.namespace);
+    const variants = [];
+    for (let length = bounds.min; length <= bounds.max; length++) {
+        if (length === 0) {
+            variants.push({ constraints: [], equalities: [[sourceKey, targetKey]] });
+            continue;
+        }
+        const orientationCount = declaration.orientation === 'undirected' ? 2 ** length : 1;
+        for (let mask = 0; mask < orientationCount; mask++) {
+            const orientations = Array.from({ length }, (_, index) => declaration.orientation === 'undirected' && (mask & (1 << index)) !== 0);
+            let transitionsValid = true;
+            for (let index = 0; index + 1 < length; index++) {
+                const incoming = endEndpoint(endpoints, orientations[index] ?? false);
+                const outgoing = startEndpoint(endpoints, orientations[index + 1] ?? false);
+                if (!typing.endpointsOverlap(incoming.accepts, outgoing.accepts)) {
+                    transitionsValid = false;
+                    break;
+                }
+            }
+            if (!transitionsValid)
+                continue;
+            const first = startEndpoint(endpoints, orientations[0] ?? false);
+            const last = endEndpoint(endpoints, orientations[length - 1] ?? false);
+            variants.push({
+                constraints: [
+                    [sourceKey, first.accepts],
+                    [targetKey, last.accepts],
+                ],
+                equalities: [],
+            });
+        }
+    }
+    return uniqueEdgeVariants(variants);
+}
+function startEndpoint(endpoints, reversed) {
+    return reversed ? endpoints[1] : endpoints[0];
+}
+function endEndpoint(endpoints, reversed) {
+    return reversed ? endpoints[0] : endpoints[1];
+}
+function uniqueEdgeVariants(values) {
+    const result = new Map();
+    for (const value of values) {
+        const key = `${value.constraints
+            .map(([term, accepts]) => `${term}:${accepts.map(definitionRefIndex).sort().join(',')}`)
+            .join('|')}=${value.equalities.map(([left, right]) => `${left}:${right}`).join('|')}`;
+        result.set(key, value);
+    }
+    return [...result.values()];
+}
+function uniqueCandidates(values) {
+    const result = new Map();
+    for (const value of values) {
+        const key = value.kind === 'exact'
+            ? `exact:${definitionRefIndex(value.ref)}`
+            : `open:${value.requirements.map(definitionRefIndex).sort().join('|')}`;
+        result.set(key, value);
+    }
+    return [...result.values()];
+}
+function uniqueClasses(values) {
+    return [...new Map(values.map((value) => [definitionRefIndex(value), value])).values()];
+}

package/dist/v1/language/validation/diagnostic.d.ts

@@ -1,4 +1,4 @@
-export type DiagnosticCode = 'CALLABLE_INPUT_FIELD_UNKNOWN' | 'DOMAIN_CLASS_ABSTRACT' | 'DOMAIN_PROPERTY_INPUT_INVALID' | 'DOMAIN_PROPERTY_REQUIRED' | 'DOMAIN_PROPERTY_UNKNOWN' | 'DOMAIN_VALIDATION_TARGET_UNKNOWN' | 'VALUE_SCHEMA_INSTANCE_INVALID' | 'VS_DIALECT' | 'VS_DYNAMIC_FORBIDDEN' | 'VS_KEYWORD_CLOSED' | 'VS_META_SCHEMA' | 'VS_NUMBER_DOMAIN' | 'VS_PATH_EXTENSION' | 'VS_RECURSION_PRODUCTIVE' | 'VS_REFERENCE_FORM' | 'VS_REFERENCE_RESOLUTION' | 'VS_REGEX_PORTABLE' | 'VS_RESOURCE_ID' | 'VS_VALUE_KIND';
+export type DiagnosticCode = 'CALLABLE_INPUT_FIELD_UNKNOWN' | 'DOMAIN_CLASS_ABSTRACT' | 'DOMAIN_PROPERTY_INPUT_INVALID' | 'DOMAIN_PROPERTY_REQUIRED' | 'DOMAIN_PROPERTY_UNKNOWN' | 'DOMAIN_VALIDATION_TARGET_UNKNOWN' | 'VALUE_SCHEMA_INSTANCE_INVALID' | 'VS_DIALECT' | 'VS_DYNAMIC_FORBIDDEN' | 'VS_KEYWORD_CLOSED' | 'VS_META_SCHEMA' | 'VS_NUMBER_DOMAIN' | 'VS_PATH_EXTENSION' | 'VS_RECURSION_PRODUCTIVE' | 'VS_REFERENCE_FORM' | 'VS_REFERENCE_RESOLUTION' | 'VS_REGEX_PORTABLE' | 'VS_RESOURCE_ID' | 'VS_VALUE_KIND' | 'VS_VALUE_KIND_JSON';
 export interface Diagnostic<out Code extends DiagnosticCode = DiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;
@@ -6,3 +6,17 @@ export interface Diagnostic<out Code extends DiagnosticCode = DiagnosticCode> {
     readonly ref?: string;
 }
 export declare function diagnostic<const Code extends DiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): Diagnostic<Code>;
+/** The fields every diagnostic family shares. */
+interface DiagnosticFields {
+    readonly code: string;
+    readonly pointer: string;
+    readonly message: string;
+    readonly ref?: string;
+}
+/** Order diagnostics by pointer, then code, then message. */
+export declare function orderDiagnostics<Value extends DiagnosticFields>(diagnostics: readonly Value[]): Value[];
+/** Keep one of each pointer, code, ref and message, then order them. */
+export declare function orderAndDeduplicate<Value extends DiagnosticFields>(diagnostics: readonly Value[]): Value[];
+/** One line per diagnostic: its pointer (`/` for the root), its code and its message. */
+export declare function formatDiagnostics(diagnostics: readonly DiagnosticFields[]): string;
+export {};

package/dist/v1/language/validation/diagnostic.js

@@ -1,3 +1,24 @@
+import { compareUnicode } from '../../addressing/ordering.js';
 export function diagnostic(code, pointer, message, ref) {
     return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
 }
+/** Order diagnostics by pointer, then code, then message. */
+export function orderDiagnostics(diagnostics) {
+    return [...diagnostics].sort((left, right) => compareUnicode(left.pointer, right.pointer) ||
+        compareUnicode(left.code, right.code) ||
+        compareUnicode(left.message, right.message));
+}
+/** Keep one of each pointer, code, ref and message, then order them. */
+export function orderAndDeduplicate(diagnostics) {
+    const unique = new Map();
+    for (const value of diagnostics) {
+        unique.set(`${value.pointer}\u0000${value.code}\u0000${value.ref ?? ''}\u0000${value.message}`, value);
+    }
+    return orderDiagnostics([...unique.values()]);
+}
+/** One line per diagnostic: its pointer (`/` for the root), its code and its message. */
+export function formatDiagnostics(diagnostics) {
+    return diagnostics
+        .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
+        .join('\n');
+}

package/dist/v1/language/value/compile/fields.js

@@ -1,3 +1,5 @@
+import { compareCodeUnits } from '../../../addressing/ordering.js';
+import { escapePointerToken } from '../syntax/pointer.js';
 /** Exact field constraints available for independent scalar route validation. */
 export function inputFieldNodes(program) {
     const fields = new Map();
@@ -34,7 +36,7 @@ export function inputFieldNodes(program) {
             Array.isArray(schema.properties))
             return;
         for (const name of Object.keys(schema.properties)) {
-            const child = node.children[`properties/${escapePointer(name)}`];
+            const child = node.children[`properties/${escapePointerToken(name)}`];
             if (child === undefined)
                 throw new TypeError(`Compiled input field ${name} is absent.`);
             const constraints = fields.get(name) ?? new Set();
@@ -46,15 +48,9 @@ export function inputFieldNodes(program) {
     if (!closed || unsupported)
         return undefined;
     return Object.freeze(Object.fromEntries([...fields]
-        .sort(([left], [right]) => compare(left, right))
+        .sort(([left], [right]) => compareCodeUnits(left, right))
         .map(([name, nodes]) => [
         name,
         Object.freeze([...nodes].sort((left, right) => left - right)),
     ])));
 }
-function escapePointer(value) {
-    return value.replaceAll('~', '~0').replaceAll('/', '~1');
-}
-function compare(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

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;