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

package/dist/v1/builder/lowering/schema/context.d.ts

@@ -6,7 +6,8 @@ import type { PolicyObjectRef } from '../../../language/index.js';
 import type { ValueSchemaRegistry } from '../../../language/value/reference/registry.js';
 import type { DomainSchema, DomainSchemaIR } from '../../../schema/model/schema.js';
 import type { Function, PolicyObjectInput } from '../../callable/authoring.js';
-import type { Class, ClassReferenceInput } from '../../class/authoring.js';
+import type { Class } from '../../class/handle.js';
+import type { ClassReferenceInput } from '../../class/input.js';
 import type { CoreEndpoint, CoreNode } from '../../core/authoring.js';
 import type { Policy } from '../../policy/authoring.js';
 import type { View } from '../../view/authoring.js';

package/dist/v1/builder/lowering/value/path.d.ts

@@ -1,3 +1,3 @@
-import type { NodeClassReferenceInput } from '../../class/authoring.js';
+import type { NodeClassReferenceInput } from '../../class/input.js';
 import type { ZodValueSchemaOverrideContext } from './zod.js';
 export declare function lowerPathSchema(context: ZodValueSchemaOverrideContext, resolveAccepts: (inputs: readonly NodeClassReferenceInput[], pointer: string) => readonly unknown[], pointer: string): void;

package/dist/v1/builder/policy/authoring.d.ts

@@ -1,7 +1,7 @@
 import type { ClassRef } from '../../addressing/index.js';
 import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm, PolicyObjectRef } from '../../language/policy/model/policy.js';
 import type { PolicyObjectInput } from '../callable/authoring.js';
-import type { EdgeClassReferenceInput, NodeClassReferenceInput } from '../class/authoring.js';
+import type { EdgeClassReferenceInput, NodeClassReferenceInput } from '../class/input.js';
 import type { AuthoringValue } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
 export interface PolicyEdgeInput {

package/dist/v1/builder/schema/input.d.ts

@@ -1,6 +1,6 @@
 import type { DomainSchema } from '../../schema/model/schema.js';
 import type { Function } from '../callable/authoring.js';
-import type { Class } from '../class/authoring.js';
+import type { Class } from '../class/handle.js';
 import type { CoreInput } from '../core/authoring.js';
 import type { Policy } from '../policy/authoring.js';
 import type { View } from '../view/authoring.js';

package/dist/v1/builder/schema/projection/class.d.ts

@@ -1,5 +1,6 @@
 import type * as language from '../../../language/index.js';
-import type { NodeClass, DirectedEdgeClass, UndirectedEdgeClass, ClassReferenceProjection, Class, ProjectionOfClass } from '../../class/authoring.js';
+import type { NodeClass, DirectedEdgeClass, UndirectedEdgeClass, Class, ProjectionOfClass } from '../../class/handle.js';
+import type { ClassReferenceProjection } from '../../class/projection.js';
 import type { DomainSchemaInput } from '../input.js';
 import type { OwnInstanceMethodProjectionsOf, OwnStaticMethodProjectionsOf } from './callable.js';
 import type { AbstractOf, ConstraintsOf, ResolveLazy, LocalNameOfReference, ClassesInputOf, LocalNameOf } from './identity.js';

package/dist/v1/builder/schema/projection/core-input.d.ts

@@ -1,6 +1,7 @@
 import type * as language from '../../../language/index.js';
 import type { BlobReceipt } from '../../../language/value/model/blob.js';
-import type { Class, AuthoredPropertyProjection } from '../../class/authoring.js';
+import type { Class } from '../../class/handle.js';
+import type { AuthoredPropertyProjection } from '../../class/projection.js';
 import type { ResolveLazy, IsMultiple } from './identity.js';
 import type { EffectivePropertyEntriesOfClass } from './property.js';
 /** Derive required, optional and forbidden Core Property inputs by name. */

package/dist/v1/builder/schema/projection/identity.d.ts

@@ -1,4 +1,5 @@
-import type { NodeClass, DirectedEdgeClass, UndirectedEdgeClass, ClassReferenceProjection, ClassReferenceProjectionOf, Class, ClassIdentityProjectionOf, ClassOwnerProjectionOf, ClassOwnerProjection, ClassIdentityProjection } from '../../class/authoring.js';
+import type { NodeClass, DirectedEdgeClass, UndirectedEdgeClass, Class } from '../../class/handle.js';
+import type { ClassReferenceProjection, ClassReferenceProjectionOf, ClassIdentityProjectionOf, ClassOwnerProjectionOf, ClassOwnerProjection, ClassIdentityProjection } from '../../class/projection.js';
 import type { DomainSchemaInput } from '../input.js';
 /** Extract an authored abstract modifier with its default. */
 export type AbstractOf<Config> = Config extends {

package/dist/v1/builder/schema/projection/property.d.ts

@@ -1,5 +1,5 @@
 import type * as language from '../../../language/index.js';
-import type { AuthoredPropertyProjection } from '../../class/authoring.js';
+import type { AuthoredPropertyProjection } from '../../class/projection.js';
 import type { DomainSchemaInput } from '../input.js';
 import type { RecordField, ClassInputOf, OwnerNameOf } from './identity.js';
 import type { PropertyProjection } from './model.js';

package/dist/v1/builder/value/path-metadata.d.ts

@@ -1,4 +1,4 @@
 import type { z } from 'zod';
-import type { NodeClassReferenceInput } from '../class/authoring.js';
+import type { NodeClassReferenceInput } from '../class/input.js';
 export declare function rememberPath(schema: z.ZodType, accepts: readonly NodeClassReferenceInput[]): void;
 export declare function pathAccepts(schema: z.ZodType): readonly NodeClassReferenceInput[] | undefined;

package/dist/v1/builder/value/path.d.ts

@@ -1,5 +1,5 @@
 import { type ZodString } from 'zod';
-import type { NodeClassReferenceInput } from '../class/authoring.js';
+import type { NodeClassReferenceInput } from '../class/input.js';
 declare const PATH_ACCEPTS: unique symbol;
 export type PathAuthoring<Accepts extends readonly NodeClassReferenceInput[] = readonly NodeClassReferenceInput[]> = ZodString & {
     readonly [PATH_ACCEPTS]: Accepts;

package/dist/v1/language/index.d.ts

@@ -7,6 +7,7 @@ export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject,
 export type { OrderingKind } from './value/ordering.js';
 export type { ValueProgram } from './value/compile/model.js';
 export { valueProgramIncludes } from './value/inclusion/includes.js';
+export { isInstantValue } from './value/model/instant.js';
 export { stateMachine } from './state/index.js';
 export type { EventOf, StateMachine, StateOf, StateTopology } from './state/index.js';
 export type * from './callable/model/callable.js';

package/dist/v1/language/index.js

@@ -2,6 +2,7 @@ export { admissionInputFields, isAdmissionMaxAge, MAXIMUM_ADMISSION_AGE_SECONDS,
 export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
 export { valueProgramIncludes } from './value/inclusion/includes.js';
+export { isInstantValue } from './value/model/instant.js';
 export { stateMachine } from './state/index.js';
 export { admitsForeignSubclass, inheritanceOf } from './class/inheritance.js';
 export { edgeLifetimes, lifetimeScope } from './class/lifetime.js';

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;

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;

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