@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.41

package/dist/v1/language/policy/model/policy.js

@@ -0,0 +1,35 @@
+/** Resolve the semantic selector while preserving the legacy exact wire representation. */
+export function policyVariableSelector(variable) {
+    return 'class' in variable ? { kind: 'exact', class: variable.class } : variable.selector;
+}
+/** Return the selector's referenced Class, when it has one. */
+export function policyVariableClass(variable) {
+    const selector = policyVariableSelector(variable);
+    return selector.kind === 'any' ? undefined : selector.class;
+}
+/** Exact projected identity, including Class-owned Method declarations. */
+export function policyObjectKey(ref) {
+    return ref.kind === 'method'
+        ? `${ref.owner.origin}:class.${ref.owner.name}.method.${ref.name}`
+        : `${ref.origin}:${ref.kind}.${ref.name}`;
+}
+export function policyObjectOrigin(ref) {
+    return ref.kind === 'method' ? ref.owner.origin : ref.origin;
+}
+/**
+ * The Kernel declaration Class each projected member materializes as. A Core Node is absent: it
+ * keeps the concrete Class its own Domain authored, which only that Domain's schema can resolve.
+ */
+const PROJECTED_MEMBER_CLASSES = Object.freeze({
+    class: kernelClassRef('Class'),
+    function: kernelClassRef('Function'),
+    method: kernelClassRef('Function'),
+    policy: kernelClassRef('Policy'),
+    view: kernelClassRef('View'),
+});
+export function projectedMemberClass(ref) {
+    return PROJECTED_MEMBER_CLASSES[ref.kind];
+}
+function kernelClassRef(name) {
+    return Object.freeze({ origin: 'kernel.astrale.ai', kind: 'class', name });
+}

package/dist/v1/language/policy/normalization/normalize.d.ts

@@ -0,0 +1,4 @@
+import type { PolicyCheckExpression, PolicyExpression, PolicyPatternExpression } from '../model/policy.js';
+export declare function normalizePolicyExpression(value: PolicyExpression): PolicyExpression;
+export declare function normalizePolicyPattern(value: PolicyPatternExpression): PolicyPatternExpression;
+export declare function normalizePolicyChecks(value: PolicyCheckExpression): PolicyCheckExpression;

package/dist/v1/language/policy/normalization/normalize.js

@@ -0,0 +1,275 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { definitionRefIndex, compareDefinitionRefs } from '../../../addressing/ordering.js';
+import { policyObjectKey, policyVariableSelector } from '../model/policy.js';
+const textEncoder = new TextEncoder();
+export function normalizePolicyExpression(value) {
+    if ('match' in value) {
+        return { match: normalizePolicyPattern(value.match) };
+    }
+    if ('allOf' in value) {
+        return { allOf: uniqueRefs(value.allOf) };
+    }
+    return { anyOf: uniqueRefs(value.anyOf) };
+}
+export function normalizePolicyPattern(value) {
+    const rewritten = rewriteVariables(value, canonicalVariableIds(value));
+    return normalizePatternNode(rewritten);
+}
+export function normalizePolicyChecks(value) {
+    if ('check' in value)
+        return value;
+    if ('sameNode' in value)
+        return { sameNode: normalizeEquality(value.sameNode) };
+    if ('allOf' in value) {
+        const children = value.allOf.flatMap((child) => {
+            const normalized = normalizePolicyChecks(child);
+            return 'allOf' in normalized ? normalized.allOf : [normalized];
+        });
+        return { allOf: policyCheckComposition(uniqueJson(children)) };
+    }
+    const children = value.anyOf.flatMap((child) => {
+        const normalized = normalizePolicyChecks(child);
+        return 'anyOf' in normalized ? normalized.anyOf : [normalized];
+    });
+    return { anyOf: policyCheckComposition(uniqueJson(children)) };
+}
+function policyCheckComposition(values) {
+    // Structural routing may carry an invalid empty array into semantic validation;
+    // validateChecks reports it before the DomainSchema can be accepted.
+    return values;
+}
+function normalizePatternNode(value) {
+    if ('sameNode' in value)
+        return { sameNode: normalizeEquality(value.sameNode) };
+    if (isEdge(value)) {
+        const repeat = value.repeat;
+        if (repeat?.min === 1 && repeat.max === 1) {
+            const { repeat: _omitted, ...edge } = value;
+            return edge;
+        }
+        return value;
+    }
+    if ('exists' in value) {
+        return {
+            exists: {
+                nodes: [...value.exists.nodes].sort((left, right) => left.variable.id - right.variable.id),
+                where: normalizePatternNode(value.exists.where),
+            },
+        };
+    }
+    if ('allOf' in value) {
+        const children = value.allOf.flatMap((child) => {
+            const normalized = normalizePatternNode(child);
+            return 'allOf' in normalized ? normalized.allOf : [normalized];
+        });
+        return { allOf: uniqueJson(children) };
+    }
+    const children = value.anyOf.flatMap((child) => {
+        const normalized = normalizePatternNode(child);
+        return 'anyOf' in normalized ? normalized.anyOf : [normalized];
+    });
+    return { anyOf: uniqueJson(children) };
+}
+function canonicalVariableIds(value) {
+    const declarations = new Map();
+    collectDeclarations(value, declarations);
+    const colors = new Map(declarations);
+    for (let iteration = 0; iteration < declarations.size + 1; iteration++) {
+        const next = new Map();
+        for (const id of declarations.keys()) {
+            const uses = [];
+            collectUses(value, id, colors, uses);
+            uses.sort(compareUtf8Bytes);
+            next.set(id, `${declarations.get(id) ?? ''}|${uses.join('|')}`);
+        }
+        if ([...next].every(([id, color]) => colors.get(id) === color))
+            break;
+        colors.clear();
+        for (const [id, color] of next)
+            colors.set(id, color);
+    }
+    const firstUse = new Map();
+    collectFirstUseKeys(value, colors, firstUse);
+    const ordered = [...declarations.keys()].sort((left, right) => {
+        const byColor = compareUtf8Bytes(colors.get(left) ?? '', colors.get(right) ?? '');
+        if (byColor !== 0)
+            return byColor;
+        const byUse = compareUtf8Bytes(firstUse.get(left) ?? '', firstUse.get(right) ?? '');
+        if (byUse !== 0)
+            return byUse;
+        // A remaining tie is an automorphic binder class: assigning either first
+        // yields the same recursively sorted canonical Pattern.
+        return left - right;
+    });
+    return new Map(ordered.map((id, index) => [id, index]));
+}
+function collectDeclarations(value, result) {
+    if ('exists' in value) {
+        for (const node of value.exists.nodes) {
+            result.set(node.variable.id, selectorSignature(node));
+        }
+        collectDeclarations(value.exists.where, result);
+        return;
+    }
+    if ('allOf' in value)
+        for (const child of value.allOf)
+            collectDeclarations(child, result);
+    if ('anyOf' in value)
+        for (const child of value.anyOf)
+            collectDeclarations(child, result);
+}
+function collectUses(value, target, colors, result) {
+    if ('sameNode' in value) {
+        const { left, right } = value.sameNode;
+        if (left.kind === 'variable' && left.id === target)
+            result.push(`same:${termColor(right, colors)}`);
+        if (right.kind === 'variable' && right.id === target)
+            result.push(`same:${termColor(left, colors)}`);
+        return;
+    }
+    if (isEdge(value)) {
+        if (value.source.kind === 'variable' && value.source.id === target) {
+            result.push(`s:${definitionRefIndex(value.class)}:${termColor(value.target, colors)}`);
+        }
+        if (value.target.kind === 'variable' && value.target.id === target) {
+            result.push(`t:${definitionRefIndex(value.class)}:${termColor(value.source, colors)}`);
+        }
+        return;
+    }
+    if ('exists' in value)
+        return collectUses(value.exists.where, target, colors, result);
+    const children = 'allOf' in value ? value.allOf : value.anyOf;
+    for (const child of children)
+        collectUses(child, target, colors, result);
+}
+function termColor(term, colors) {
+    if (term.kind === 'variable')
+        return `variable:${colors.get(term.id) ?? '?'}`;
+    if (term.kind === 'ref')
+        return `ref:${term.ref.kind === 'method' ? policyObjectKey(term.ref) : definitionRefIndex(term.ref)}`;
+    return term.kind;
+}
+function collectFirstUseKeys(value, colors, result, prefix = '$') {
+    if ('sameNode' in value) {
+        for (const term of [value.sameNode.left, value.sameNode.right]) {
+            if (term.kind !== 'variable')
+                continue;
+            const key = `${prefix}:same`;
+            const current = result.get(term.id);
+            if (current === undefined || key < current)
+                result.set(term.id, key);
+        }
+        return;
+    }
+    if (isEdge(value)) {
+        for (const [position, term] of [
+            ['source', value.source],
+            ['target', value.target],
+        ]) {
+            if (term.kind === 'variable') {
+                const key = `${prefix}:${definitionRefIndex(value.class)}:${position}`;
+                const current = result.get(term.id);
+                if (current === undefined || key < current)
+                    result.set(term.id, key);
+            }
+        }
+        return;
+    }
+    if ('exists' in value) {
+        collectFirstUseKeys(value.exists.where, colors, result, `${prefix}:exists`);
+        return;
+    }
+    const key = 'allOf' in value ? 'allOf' : 'anyOf';
+    const operands = 'allOf' in value ? value.allOf : value.anyOf;
+    const children = [...operands].sort((left, right) => compareUtf8Bytes(patternSignature(left, colors), patternSignature(right, colors)));
+    children.forEach((child, index) => collectFirstUseKeys(child, colors, result, `${prefix}:${key}:${index}`));
+}
+function patternSignature(value, colors) {
+    if ('sameNode' in value)
+        return `same:${[termColor(value.sameNode.left, colors), termColor(value.sameNode.right, colors)].sort(compareUtf8Bytes).join(':')}`;
+    if (isEdge(value)) {
+        return `edge:${definitionRefIndex(value.class)}:${termColor(value.source, colors)}:${termColor(value.target, colors)}:${value.repeat?.min ?? 1}:${value.repeat?.max ?? 1}`;
+    }
+    if ('exists' in value) {
+        return `exists:${value.exists.nodes
+            .map((node) => colors.get(node.variable.id) ?? '')
+            .sort(compareUtf8Bytes)
+            .join(',')}:${patternSignature(value.exists.where, colors)}`;
+    }
+    const key = 'allOf' in value ? 'allOf' : 'anyOf';
+    const operands = 'allOf' in value ? value.allOf : value.anyOf;
+    return `${key}:${operands
+        .map((child) => patternSignature(child, colors))
+        .sort(compareUtf8Bytes)
+        .join('|')}`;
+}
+function rewriteVariables(value, ids) {
+    if ('sameNode' in value)
+        return {
+            sameNode: {
+                left: rewriteTerm(value.sameNode.left, ids),
+                right: rewriteTerm(value.sameNode.right, ids),
+            },
+        };
+    if (isEdge(value)) {
+        return {
+            ...value,
+            source: rewriteTerm(value.source, ids),
+            target: rewriteTerm(value.target, ids),
+        };
+    }
+    if ('exists' in value) {
+        return {
+            exists: {
+                nodes: value.exists.nodes.map((node) => {
+                    const variable = {
+                        kind: 'variable',
+                        id: ids.get(node.variable.id) ?? node.variable.id,
+                    };
+                    return 'class' in node
+                        ? { variable, class: node.class }
+                        : { variable, selector: node.selector };
+                }),
+                where: rewriteVariables(value.exists.where, ids),
+            },
+        };
+    }
+    if ('allOf' in value)
+        return { allOf: value.allOf.map((child) => rewriteVariables(child, ids)) };
+    return { anyOf: value.anyOf.map((child) => rewriteVariables(child, ids)) };
+}
+function selectorSignature(node) {
+    const selector = policyVariableSelector(node);
+    return selector.kind === 'any' ? 'any' : `${selector.kind}:${definitionRefIndex(selector.class)}`;
+}
+function rewriteTerm(value, ids) {
+    return value.kind === 'variable' ? { kind: 'variable', id: ids.get(value.id) ?? value.id } : value;
+}
+function uniqueRefs(values) {
+    const byKey = new Map(values.map((value) => [definitionRefIndex(value), value]));
+    return [...byKey.values()].sort(compareDefinitionRefs);
+}
+function uniqueJson(values) {
+    const byEncoding = new Map(values.map((value) => [json.serialize(value), value]));
+    return [...byEncoding.entries()]
+        .sort(([left], [right]) => compareUtf8Bytes(left, right))
+        .map(([, value]) => value);
+}
+function compareUtf8Bytes(left, right) {
+    const a = textEncoder.encode(left);
+    const b = textEncoder.encode(right);
+    const length = Math.min(a.length, b.length);
+    for (let index = 0; index < length; index++) {
+        if (a[index] !== b[index])
+            return (a[index] ?? 0) - (b[index] ?? 0);
+    }
+    return a.length - b.length;
+}
+function isEdge(value) {
+    return 'source' in value;
+}
+function normalizeEquality(value) {
+    return compareUtf8Bytes(json.serialize(value.left), json.serialize(value.right)) <= 0
+        ? value
+        : { left: value.right, right: value.left };
+}

package/dist/v1/language/policy/resolved.d.ts

@@ -0,0 +1,9 @@
+import type { DefinitionKey, PolicyRef } from '../../addressing/index.js';
+import type { PolicyDefinition } from './model/policy.js';
+export interface ResolvedPolicy {
+    readonly ref: PolicyRef;
+    readonly key: DefinitionKey<string, 'policy'>;
+    readonly expression: PolicyDefinition['expression'];
+    readonly description?: PolicyDefinition['description'];
+    readonly definition: PolicyDefinition;
+}

package/dist/v1/language/policy/resolved.js

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

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

@@ -0,0 +1,10 @@
+import type { DefinitionRef } from '../addressing/index.js';
+import type { ResolvedFunction } from './callable/resolved.js';
+import type { AnyResolvedClass } from './class/resolved.js';
+import type { ResolvedCoreDefinition } from './core/resolved.js';
+import type { ResolvedPolicy } from './policy/resolved.js';
+import type { ResolvedView } from './view/resolved.js';
+export type ResolvedDefinition = AnyResolvedClass | ResolvedFunction | ResolvedPolicy | ResolvedView | ResolvedCoreDefinition;
+export type ResolvedDefinitionOf<Kind extends DefinitionRef['kind']> = Extract<ResolvedDefinition, {
+    readonly ref: DefinitionRef<Kind>;
+}>;

package/dist/v1/language/resolved.js

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

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

@@ -0,0 +1,3 @@
+export { stateMachine } from './machine.js';
+export type { EventOf, StateMachine, StateOf } from './machine.js';
+export type { StateTopology } from './topology.js';

package/dist/v1/language/state/index.js

@@ -0,0 +1 @@
+export { stateMachine } from './machine.js';

package/dist/v1/language/state/machine.d.ts

@@ -0,0 +1,28 @@
+import { type ZodType } from 'zod';
+import type { EventName, StateName, StateTopology, TransitionRelation, ValidTransitionRelation } from './topology.js';
+export interface StateMachine<Transitions extends TransitionRelation = any, Initial extends StateName<Transitions> = StateName<Transitions>> extends StateTopology<Transitions, Initial> {
+    readonly stateSchema: ZodType<StateName<Transitions>, StateName<Transitions>>;
+    readonly eventSchema: ZodType<EventName<Transitions>, EventName<Transitions>>;
+    eventsFrom<State extends StateName<Transitions>>(state: State): readonly EventName<Transitions, State>[];
+    decide<State extends StateName<Transitions>, Event extends EventName<Transitions>>(state: State, event: Event): TransitionDecision<Transitions, State, Event>;
+}
+export type StateOf<Machine extends StateMachine> = StateName<Machine['transitions']>;
+export type EventOf<Machine extends StateMachine, State extends StateOf<Machine> = StateOf<Machine>> = EventName<Machine['transitions'], State>;
+type TransitionDecision<Transitions extends TransitionRelation, State extends StateName<Transitions>, Event extends EventName<Transitions>> = State extends StateName<Transitions> ? Event extends EventName<Transitions> ? Event extends keyof Transitions[State] ? Readonly<{
+    kind: 'allowed';
+    transition: Readonly<{
+        from: State;
+        event: Event;
+        to: Transitions[State][Event];
+    }>;
+}> : Readonly<{
+    kind: 'rejected';
+    code: 'STATE_TRANSITION_ILLEGAL';
+    from: State;
+    event: Event;
+}> : never : never;
+export declare function stateMachine<const Transitions extends TransitionRelation, const Initial extends StateName<Transitions>>(input: Readonly<{
+    initial: Initial;
+    transitions: Transitions & ValidTransitionRelation<Transitions>;
+}>): StateMachine<Transitions, Initial>;
+export {};

package/dist/v1/language/state/machine.js

@@ -0,0 +1,40 @@
+import { enum as enumeration } from 'zod';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { admitStateTopology } from './topology.js';
+export function stateMachine(input) {
+    const topology = admitStateTopology(input);
+    const states = Object.keys(topology.transitions);
+    const events = [
+        ...new Set(states.flatMap((state) => Object.keys(topology.transitions[state]))),
+    ].sort(compareUnicode);
+    const stateSet = new Set(states);
+    const eventSet = new Set(events);
+    return Object.freeze({
+        ...topology,
+        stateSchema: enumeration(states),
+        eventSchema: enumeration(events),
+        eventsFrom(state) {
+            admitState(state, stateSet);
+            return Object.freeze(Object.keys(topology.transitions[state]));
+        },
+        decide(state, event) {
+            admitState(state, stateSet);
+            admitEvent(event, eventSet);
+            const target = topology.transitions[state][event];
+            return target === undefined
+                ? Object.freeze({ kind: 'rejected', code: 'STATE_TRANSITION_ILLEGAL', from: state, event })
+                : Object.freeze({
+                    kind: 'allowed',
+                    transition: Object.freeze({ from: state, event, to: target }),
+                });
+        },
+    });
+}
+function admitState(state, states) {
+    if (!states.has(state))
+        throw new TypeError(`State machine does not declare state "${state}".`);
+}
+function admitEvent(event, events) {
+    if (!events.has(event))
+        throw new TypeError(`State machine does not declare event "${event}".`);
+}

package/dist/v1/language/state/topology.d.ts

@@ -0,0 +1,14 @@
+export type TransitionRelation = Readonly<Record<string, Readonly<Record<string, string>>>>;
+export type StateName<Transitions extends TransitionRelation> = Extract<keyof Transitions, string>;
+export type EventName<Transitions extends TransitionRelation, State extends StateName<Transitions> = StateName<Transitions>> = State extends StateName<Transitions> ? Extract<keyof Transitions[State], string> : never;
+export type ValidTransitionRelation<Transitions extends TransitionRelation> = Readonly<{
+    [State in StateName<Transitions>]: Readonly<{
+        [Event in keyof Transitions[State]]: string extends StateName<Transitions> ? string : Exclude<StateName<Transitions>, State>;
+    }>;
+}>;
+export interface StateTopology<Transitions extends TransitionRelation = TransitionRelation, Initial extends StateName<Transitions> = StateName<Transitions>> {
+    readonly initial: Initial;
+    readonly transitions: Transitions;
+}
+export type StateTopologyOf<Value> = Value extends StateTopology<infer Transitions, infer Initial> ? StateTopology<Transitions, Initial> : undefined;
+export declare function admitStateTopology(input: unknown): StateTopology;

package/dist/v1/language/state/topology.js

@@ -0,0 +1,69 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+export function admitStateTopology(input) {
+    if (!isRecord(input) || !exactKeys(input, ['initial', 'transitions']))
+        invalidInput();
+    const initial = input.initial;
+    const authored = input.transitions;
+    if (typeof initial !== 'string' || initial.length === 0 || !isRecord(authored))
+        invalidInput();
+    const states = Object.keys(authored);
+    if (states.length === 0)
+        throw new TypeError('State topology requires at least one state.');
+    if (states.includes(''))
+        throw new TypeError('State topology has an empty state name.');
+    if (!states.includes(initial)) {
+        throw new TypeError(`State topology initial state "${initial}" is not declared.`);
+    }
+    const declared = new Set(states);
+    const transitions = Object.create(null);
+    let transitionCount = 0;
+    for (const state of states.sort(compareUnicode)) {
+        const outgoing = authored[state];
+        if (!isRecord(outgoing))
+            throw new TypeError(`State "${state}" transitions must be an object.`);
+        const accepted = Object.create(null);
+        for (const event of Object.keys(outgoing).sort(compareUnicode)) {
+            const target = outgoing[event];
+            if (event.length === 0)
+                throw new TypeError(`State "${state}" has an empty event name.`);
+            if (typeof target !== 'string' || !declared.has(target)) {
+                throw new TypeError(`State "${state}" event "${event}" targets undeclared state "${String(target)}".`);
+            }
+            if (target === state) {
+                throw new TypeError(`State "${state}" event "${event}" is a self-transition.`);
+            }
+            accepted[event] = target;
+            transitionCount += 1;
+        }
+        transitions[state] = Object.freeze(accepted);
+    }
+    if (transitionCount === 0)
+        throw new TypeError('State topology requires at least one transition.');
+    const reachable = new Set([initial]);
+    const pending = [initial];
+    while (pending.length > 0) {
+        const state = pending.shift();
+        for (const target of Object.values(transitions[state])) {
+            if (reachable.has(target))
+                continue;
+            reachable.add(target);
+            pending.push(target);
+        }
+    }
+    for (const state of states) {
+        if (!reachable.has(state)) {
+            throw new TypeError(`State "${state}" is unreachable from initial "${initial}".`);
+        }
+    }
+    return Object.freeze({ initial, transitions: Object.freeze(transitions) });
+}
+function invalidInput() {
+    throw new TypeError('State topology must contain exactly initial and transitions.');
+}
+function isRecord(input) {
+    return input !== null && typeof input === 'object' && !Array.isArray(input);
+}
+function exactKeys(input, expected) {
+    const keys = Reflect.ownKeys(input);
+    return keys.length === expected.length && keys.every((key) => expected.includes(String(key)));
+}

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

@@ -0,0 +1,8 @@
+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 interface Diagnostic<out Code extends DiagnosticCode = DiagnosticCode> {
+    readonly code: Code;
+    readonly pointer: string;
+    readonly message: string;
+    readonly ref?: string;
+}
+export declare function diagnostic<const Code extends DiagnosticCode>(code: Code, pointer: string, message: string, ref?: string): Diagnostic<Code>;

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

@@ -0,0 +1,3 @@
+export function diagnostic(code, pointer, message, ref) {
+    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
+}

package/dist/v1/language/value/compile/fields.d.ts

@@ -0,0 +1,3 @@
+import type { ValueProgram } from './model.js';
+/** Exact field constraints available for independent scalar route validation. */
+export declare function inputFieldNodes(program: Pick<ValueProgram, 'root' | 'nodes'>): Readonly<Record<string, readonly number[]>> | undefined;

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

@@ -0,0 +1,60 @@
+/** Exact field constraints available for independent scalar route validation. */
+export function inputFieldNodes(program) {
+    const fields = new Map();
+    const visited = new Set();
+    let closed = false;
+    let unsupported = false;
+    const visit = (index) => {
+        if (visited.has(index))
+            return;
+        visited.add(index);
+        const node = program.nodes[index];
+        if (node === undefined ||
+            node.schema === null ||
+            typeof node.schema !== 'object' ||
+            Array.isArray(node.schema))
+            return;
+        const schema = node.schema;
+        if (schema.additionalProperties === false || schema.unevaluatedProperties === false)
+            closed = true;
+        if (schema.anyOf !== undefined || schema.oneOf !== undefined || schema.if !== undefined)
+            unsupported = true;
+        if (node.reference !== undefined)
+            visit(node.reference);
+        if (Array.isArray(schema.allOf)) {
+            schema.allOf.forEach((_, position) => {
+                const child = node.children[`allOf/${position}`];
+                if (child === undefined)
+                    throw new TypeError('Compiled input allOf branch is absent.');
+                visit(child);
+            });
+        }
+        if (schema.properties === null ||
+            typeof schema.properties !== 'object' ||
+            Array.isArray(schema.properties))
+            return;
+        for (const name of Object.keys(schema.properties)) {
+            const child = node.children[`properties/${escapePointer(name)}`];
+            if (child === undefined)
+                throw new TypeError(`Compiled input field ${name} is absent.`);
+            const constraints = fields.get(name) ?? new Set();
+            constraints.add(child);
+            fields.set(name, constraints);
+        }
+    };
+    visit(program.root);
+    if (!closed || unsupported)
+        return undefined;
+    return Object.freeze(Object.fromEntries([...fields]
+        .sort(([left], [right]) => compare(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/compile/load.d.ts

@@ -0,0 +1,6 @@
+import type { CompiledInstanceSchema } from '../evaluate/types.js';
+import type { IndexedValueProgram, ValueProgram } from './model.js';
+/** Bind already-admitted entry-local indices without copying any pattern machine. */
+export declare function bindValueProgram(program: IndexedValueProgram, patterns: ValueProgram['patterns']): ValueProgram;
+/** Bind admitted portable indices to the canonical instance evaluator. */
+export declare function loadValueProgram(program: ValueProgram, rootIndex?: number): CompiledInstanceSchema;

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

@@ -0,0 +1,62 @@
+import { loadPattern } from '../regexp/matcher.js';
+import { appendPointer } from '../syntax/pointer.js';
+const loadedPrograms = new WeakMap();
+/** Bind already-admitted entry-local indices without copying any pattern machine. */
+export function bindValueProgram(program, patterns) {
+    return Object.freeze({
+        ...program,
+        patterns: Object.freeze(program.patterns.map((index) => patterns[index])),
+    });
+}
+/** Bind admitted portable indices to the canonical instance evaluator. */
+export function loadValueProgram(program, rootIndex = program.root) {
+    let compiled = loadedPrograms.get(program);
+    if (compiled === undefined) {
+        compiled = createValueProgram(program);
+        loadedPrograms.set(program, compiled);
+    }
+    if (rootIndex === program.root)
+        return compiled;
+    const root = compiled.locations.get(String(rootIndex));
+    if (root === undefined)
+        throw new TypeError('Compiled value program root is absent.');
+    return { ...compiled, root };
+}
+function createValueProgram(program) {
+    const resource = { key: 'compiled', schema: true, ownerOrigin: 'compiled' };
+    const locations = program.nodes.map((node, index) => ({
+        key: String(index),
+        pointer: '',
+        resource,
+        schema: node.schema,
+    }));
+    const patterns = new Map(program.patterns.map((pattern) => [pattern.source, loadPattern(pattern)]));
+    const root = locations[program.root];
+    if (root === undefined)
+        throw new TypeError('Compiled value program root is absent.');
+    return {
+        root,
+        locations: new Map(locations.map((location) => [location.key, location])),
+        resolutions: new Map(),
+        program: () => program,
+        child(location, keyword, member) {
+            const base = appendPointer('', keyword);
+            const key = (member === undefined ? base : appendPointer(base, member)).slice(1);
+            const index = program.nodes[Number(location.key)]?.children[key];
+            const child = index === undefined ? undefined : locations[index];
+            if (child === undefined)
+                throw new TypeError('Compiled value program child is absent.');
+            return child;
+        },
+        reference(location) {
+            const index = program.nodes[Number(location.key)]?.reference;
+            return index === undefined ? undefined : locations[index];
+        },
+        matcher(source) {
+            const matcher = patterns.get(source);
+            if (matcher === undefined)
+                throw new TypeError('Compiled value program pattern is absent.');
+            return matcher;
+        },
+    };
+}