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

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

@@ -0,0 +1,129 @@
+import type { ResolvedMethod } from '../../language/callable/resolved.js';
+import type { ResolvedProperty } from '../../language/class/resolved.js';
+import type { StateTopology } from '../../language/state/topology.js';
+import type { Method } from '../callable/authoring.js';
+import type { DirectedEdgeClass, NodeClass, UndirectedEdgeClass } from './handle.js';
+/** Compact type of one authored Property: values, requiredness, name, owner and state. */
+export interface AuthoredPropertyProjection<out Input = unknown, out Output = unknown, out Required extends boolean = boolean, out Name extends string = string, out Owner = 'self', out State extends StateTopology | undefined = StateTopology | undefined> {
+    readonly input: Input;
+    readonly output: Output;
+    readonly required: Required;
+    readonly name: Name;
+    readonly owner: Owner;
+    readonly state?: State;
+}
+/** Compact type of one authored Method with its name and owner. */
+export interface AuthoredMethodProjection<out Value extends Method = Method, out Name extends string = string, out Owner = 'self'> {
+    readonly value: Value;
+    readonly name: Name;
+    readonly owner: Owner;
+}
+/** Give `Owner` to every Property projection still owned by `self`. */
+export type BindPropertyOwners<Entries, Owner> = Entries extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, infer Name, infer ExistingOwner, infer State> ? AuthoredPropertyProjection<Input, Output, Required, Name, ExistingOwner extends 'self' ? Owner : ExistingOwner, State> : Entries;
+/** Give `Owner` to every Method projection still owned by `self`. */
+export type BindMethodOwners<Entries, Owner> = Entries extends AuthoredMethodProjection<infer Value, infer Name, infer ExistingOwner> ? AuthoredMethodProjection<Value, Name, ExistingOwner extends 'self' ? Owner : ExistingOwner> : Entries;
+/** Kind and structural identity of an authored Class. */
+export interface ClassIdentityProjection<out Kind extends 'node' | 'edge' = 'node' | 'edge', out Identity = unknown> {
+    readonly kind: Kind;
+    readonly identity: Identity;
+}
+/** An authored Class as the owner its Properties and Methods name. */
+export interface ClassOwnerProjection<out Kind extends 'node' | 'edge' = 'node' | 'edge', out Identity = unknown, out Properties = unknown, out InstanceMethods = unknown, out StaticMethods = unknown> extends ClassIdentityProjection<Kind, Identity> {
+    readonly properties: Properties;
+    readonly instanceMethods: InstanceMethods;
+    readonly staticMethods: StaticMethods;
+}
+/** An authored Class as a reference, with its effective Properties and Methods. */
+export interface ClassReferenceProjection<out Kind extends 'node' | 'edge' = 'node' | 'edge', out Identity = unknown, out EffectiveProperties = AuthoredPropertyProjection, out EffectiveInstanceMethods = unknown, out EffectiveStaticMethods = unknown> extends ClassIdentityProjection<Kind, Identity> {
+    readonly effectiveProperties: EffectiveProperties;
+    readonly effectiveInstanceMethods: EffectiveInstanceMethods;
+    readonly effectiveStaticMethods: EffectiveStaticMethods;
+}
+type NodeClassIdentity<Config> = Config extends {
+    readonly abstract: infer Abstract;
+    readonly depth: infer Depth;
+    readonly properties: infer Properties;
+    readonly methods: infer Methods;
+} ? {
+    readonly abstract: Abstract;
+    readonly depth: Depth;
+    readonly properties: Properties;
+    readonly methods: Methods;
+} : never;
+type DirectedEdgeClassIdentity<Config> = Config extends {
+    readonly abstract: infer Abstract;
+    readonly depth: infer Depth;
+    readonly properties: infer Properties;
+    readonly source: infer Source;
+    readonly target: infer Target;
+    readonly constraints: infer Constraints;
+} ? {
+    readonly abstract: Abstract;
+    readonly depth: Depth;
+    readonly properties: Properties;
+    readonly source: Source;
+    readonly target: Target;
+    readonly constraints: Constraints;
+} : never;
+type UndirectedEdgeClassIdentity<Config> = Config extends {
+    readonly abstract: infer Abstract;
+    readonly depth: infer Depth;
+    readonly properties: infer Properties;
+    readonly endpoints: infer Endpoints;
+    readonly constraints: infer Constraints;
+} ? {
+    readonly abstract: Abstract;
+    readonly depth: Depth;
+    readonly properties: Properties;
+    readonly endpoints: Endpoints;
+    readonly constraints: Constraints;
+} : never;
+type OwnerErasedPropertyProjection<Entry> = Entry extends AuthoredPropertyProjection<infer Input, infer Output, infer Required, infer Name, unknown, infer State> ? AuthoredPropertyProjection<Input, Output, Required, Name, unknown, State> : Entry extends ResolvedProperty<infer Value, infer Required, infer State, infer Input> & {
+    readonly name: infer Name;
+    readonly key: infer Key;
+} ? {
+    readonly value: Value;
+    readonly input: Input;
+    readonly required: Required;
+    readonly name: Name;
+    readonly key: Key;
+    readonly state?: State;
+} : never;
+type OwnerErasedMethodProjection<Entry> = Entry extends AuthoredMethodProjection<infer Value, infer Name, unknown> ? AuthoredMethodProjection<Value, Name, unknown> : Entry extends ResolvedMethod<infer Input, infer Output, infer Static, infer Abstract, infer Auth, infer _Policy, infer Key> & {
+    readonly name: infer Name;
+} ? {
+    readonly input: Input;
+    readonly output: Output;
+    readonly static: Static;
+    readonly abstract: Abstract;
+    readonly auth: Auth;
+    readonly name: Name;
+    readonly key: Key;
+} : never;
+/** Identity projection of a Class handle. */
+export type ClassIdentityProjectionOf<Value> = Value extends NodeClass<infer Config> ? ClassIdentityProjection<'node', NodeClassIdentity<Config>> : Value extends DirectedEdgeClass<infer Config> ? ClassIdentityProjection<'edge', DirectedEdgeClassIdentity<Config>> : Value extends UndirectedEdgeClass<infer Config> ? ClassIdentityProjection<'edge', UndirectedEdgeClassIdentity<Config>> : never;
+/** Owner projection of a Class handle. */
+export type ClassOwnerProjectionOf<Value> = Value extends NodeClass<infer Config> ? ClassOwnerProjection<'node', NodeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? OwnerErasedPropertyProjection<Properties> : never, Config extends {
+    readonly effectiveInstanceMethods: infer Methods;
+} ? OwnerErasedMethodProjection<Methods> : never, Config extends {
+    readonly effectiveStaticMethods: infer Methods;
+} ? OwnerErasedMethodProjection<Methods> : never> : Value extends DirectedEdgeClass<infer Config> ? ClassOwnerProjection<'edge', DirectedEdgeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? OwnerErasedPropertyProjection<Properties> : never, never, never> : Value extends UndirectedEdgeClass<infer Config> ? ClassOwnerProjection<'edge', UndirectedEdgeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? OwnerErasedPropertyProjection<Properties> : never, never, never> : never;
+/** Reference projection of a Class handle. */
+export type ClassReferenceProjectionOf<Value> = Value extends NodeClass<infer Config> ? ClassReferenceProjection<'node', NodeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? BindPropertyOwners<Properties, ClassOwnerProjectionOf<NodeClass<Config>>> : never, Config extends {
+    readonly effectiveInstanceMethods: infer Methods;
+} ? BindMethodOwners<Methods, ClassOwnerProjectionOf<NodeClass<Config>>> : never, Config extends {
+    readonly effectiveStaticMethods: infer Methods;
+} ? BindMethodOwners<Methods, ClassOwnerProjectionOf<NodeClass<Config>>> : never> : Value extends DirectedEdgeClass<infer Config> ? ClassReferenceProjection<'edge', DirectedEdgeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? BindPropertyOwners<Properties, ClassOwnerProjectionOf<DirectedEdgeClass<Config>>> : never, never, never> : Value extends UndirectedEdgeClass<infer Config> ? ClassReferenceProjection<'edge', UndirectedEdgeClassIdentity<Config>, Config extends {
+    readonly effectiveProperties: infer Properties;
+} ? BindPropertyOwners<Properties, ClassOwnerProjectionOf<UndirectedEdgeClass<Config>>> : never, never, never> : never;
+export {};

package/dist/v1/builder/class/projection.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,7 +1,7 @@
 import type { Object as JsonObject } from '@astrale-os/kernel-dsl/value';
 import type { DomainEndpointRef } from '../../language/core/model/core.js';
 import type { PolicyObjectInput } from '../callable/authoring.js';
-import type { EdgeClass, NodeClass } from '../class/authoring.js';
+import type { EdgeClass, NodeClass } from '../class/handle.js';
 import type { AUTHORING } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
 import type { CoreNamedPropertyInput } from '../schema/projection.js';

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

@@ -14,7 +14,9 @@ export { BuilderError as Error } from './schema/diagnostic.js';
 export type { BuilderDiagnostic as Diagnostic, BuilderDiagnosticCode as DiagnosticCode, } from './schema/diagnostic.js';
 export type { CallableInputBase, CallableInput, BinaryInputAuthoring, CallableOutputInput, CallableProjection, CallablePolicyBuilder, CallablePolicyContext, PolicyCheckContext, BinaryOutput, Function, FunctionInput, Method, MethodInput, PolicyObjectInput, StreamOutput, } from './callable/authoring.js';
 export type { CoreEdge, CoreEndpoint, CoreInput, CoreNode } from './core/authoring.js';
-export type { AuthoredPropertyProjection, AuthoredMethodProjection, Class, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedEdgeClass, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClass, EdgeClassReferenceInput as EdgeClassReference, EdgeUniqueFieldInput, EdgeUniqueTupleInput, IncidentEndpointInput, NodeClass, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, NodeUniqueTupleInput, UndirectedEdgeInput, UndirectedEdgeClass, } from './class/authoring.js';
+export type { Class, DirectedEdgeClass, EdgeClass, NodeClass, UndirectedEdgeClass, } from './class/handle.js';
+export type { ClassReferenceInput as ClassReference, ClassRuleBuilder, ClassRuleContext, DirectedEdgeInput, DirectedSourceInput, DirectedTargetInput, EdgeClassCommon, EdgeClassInput, EdgeClassReferenceInput as EdgeClassReference, EdgeUniqueFieldInput, EdgeUniqueTupleInput, IncidentEndpointInput, NodeClassInput, NodeClassPoliciesInput, NodeClassPolicyInput, NodeClassReferenceInput as NodeClassReference, NodeUniqueTupleInput, UndirectedEdgeInput, } from './class/input.js';
+export type { AuthoredPropertyProjection, AuthoredMethodProjection, ClassIdentityProjection, ClassOwnerProjection, ClassReferenceProjection, } from './class/projection.js';
 export type { PathAuthoring } from './value/path.js';
 export type { Lazy } from './schema/lazy.js';
 export type { MatchPolicyInput, Policy, PolicyBuilder as PolicyFactory, PolicyEdgeInput, PolicyExistsContext, PolicyInput, PolicyNodeBinder, PolicyPatternContext, } from './policy/authoring.js';

package/dist/v1/builder/lowering/class.d.ts

@@ -1,5 +1,5 @@
 import type { ClassDefinition } from '../../language/class/model/class.js';
-import type { Class } from '../class/authoring.js';
+import type { Class } from '../class/handle.js';
 import type { CallableCompiler } from './callable.js';
 import type { PolicyCompiler } from './policy.js';
 import type { BuilderContext } from './schema/context.js';

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;