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

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;
+}