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

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;

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

@@ -0,0 +1,138 @@
+import { jsonEqual } from '../evaluate/assertions.js';
+import { isValueObject as isJsonObject } from '../model/object.js';
+import { ANY, OBJECT, STRING, finiteKinds, kindOf, typeMask } from './kinds.js';
+import { conjunctsOf, schemaOf } from './location.js';
+/** Whether `evidence` may admit a value of one of `kinds`. */
+export function has(evidence, kinds) {
+    return (evidence.kinds & kinds) !== 0;
+}
+/** The evidence the conjuncts of `location` carry together. */
+export function evidenceOf(location) {
+    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);
+    return 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,
+    });
+}
+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);
+}

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

@@ -1,4 +1,6 @@
 import type { ValueProgram } from '../compile/model.js';
+import type { Evidence } from './evidence.js';
+import type { At } from './location.js';
 /**
  * Whether `outer` admits every value `inner` admits, under the one V1 evaluator.
  *
@@ -7,3 +9,18 @@ import type { ValueProgram } from '../compile/model.js';
  * `inner`; a finite `inner` is decided exactly by evaluating its candidates.
  */
 export declare function valueProgramIncludes(outer: ValueProgram, inner: ValueProgram): boolean;
+/** One inclusion question: the decided pairs, the pairs being decided and the evidence cache. */
+export declare class Inclusion {
+    private readonly programs;
+    private readonly decided;
+    private readonly pending;
+    private readonly evidenceByAt;
+    /** Whether `outer` admits every value `inner` admits; a cyclic premise proves nothing. */
+    includes(outer: At, inner: At): boolean;
+    /** The evidence of one location, computed once per question. */
+    evidence(location: At): Evidence;
+    /** A key identifying an ordered pair of locations within this question. */
+    pair(outer: At, inner: At): string;
+    private decide;
+    private location;
+}