@astrale-os/kernel-dsl 0.2.0-beta.45 → 0.2.0-beta.46

package/dist/v1/addressing/class-key.js

@@ -20,10 +20,11 @@ export function ClassKey(input) {
     function is(input) {
         if (typeof input !== 'string' || !Key.is(input))
             return false;
-        const separator = input.indexOf(':');
-        return (input.slice(separator + 1).startsWith('class.') &&
-            !input.includes('.property.') &&
-            !input.includes('.method.'));
+        // Only the coordinate is tested: an origin label may itself be `property` or `method`.
+        const coordinate = input.slice(input.indexOf(':') + 1);
+        return (coordinate.startsWith('class.') &&
+            !coordinate.includes('.property.') &&
+            !coordinate.includes('.method.'));
     }
     ClassKey.is = is;
     function ref(input) {

package/dist/v1/addressing/method-key.js

@@ -21,8 +21,9 @@ export function MethodKey(input) {
     function is(input) {
         if (typeof input !== 'string' || !Key.is(input))
             return false;
-        const coordinate = input.slice(input.indexOf(':') + 1);
-        return coordinate.startsWith('class.') && coordinate.includes('.method.');
+        // The member kind is the third segment: the owner Class may itself be named `method`.
+        const [kind, , member] = input.slice(input.indexOf(':') + 1).split('.');
+        return kind === 'class' && member === 'method';
     }
     MethodKey.is = is;
     function address(input) {

package/dist/v1/builder/lowering/value/zod.js

@@ -161,7 +161,10 @@ function inspectCheck(def, pointer, diagnostics) {
         return;
     }
     if (def.check === 'string_format' && def.format === 'regex' && def.pattern instanceof RegExp) {
-        if (!isLosslessRegexp(def.pattern)) {
+        if (def.pattern.flags === '') {
+            diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', pointer, 'Zod RegExp without the u flag reads \\p{...} as literal text, and classes and quantifiers by UTF-16 code unit, unlike the V1 I-Regexp it would lower to; add the u flag.'));
+        }
+        else if (!isLosslessRegexp(def.pattern)) {
             diagnostics.push(diagnostic('ZOD_SCHEMA_NOT_LOSSLESS', pointer, 'Zod RegExp flags, anchors, dot semantics, or syntax cannot be preserved as a V1 I-Regexp substring pattern.'));
         }
     }
@@ -292,8 +295,14 @@ function escapePointerToken(value) {
 function isPlainRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
+/**
+ * Whether a Zod RegExp search means its source read as an I-Regexp. Only the u flag qualifies:
+ * without it, `\p{L}` matches the text `p{L}`, and classes and quantifiers apply to UTF-16 code
+ * units rather than scalars; `v` reads class syntax differently, and every other flag changes the
+ * match itself.
+ */
 function isLosslessRegexp(pattern) {
-    if (pattern.flags !== '' && pattern.flags !== 'u')
+    if (pattern.flags !== 'u')
         return false;
     if (!isIRegexp(pattern.source))
         return false;

package/dist/v1/builder/value/full-match.js

@@ -1,11 +1,14 @@
-import { isIRegexp } from '../../language/value/regexp/syntax.js';
+import { refuseIRegexp, stateBudgetMessage } from '../../language/value/regexp/syntax.js';
 import { fullMatch as languageFullMatch, } from '../../language/value/syntax/full-match.js';
 import { fail } from '../schema/diagnostic.js';
 export { fullMatchSource } from '../../language/value/syntax/full-match.js';
 /** Authoring facade preserving the Builder-owned diagnostic for invalid source syntax. */
 export function fullMatch(source) {
-    if (!isIRegexp(source)) {
-        fail('BUILDER_FULL_MATCH_INVALID', '/fullMatch', 'fullMatch(...) requires a complete RFC 9485 I-Regexp source.');
+    const refusal = refuseIRegexp(source);
+    if (refusal !== undefined) {
+        fail('BUILDER_FULL_MATCH_INVALID', '/fullMatch', refusal === 'syntax'
+            ? 'fullMatch(...) requires a complete RFC 9485 I-Regexp source.'
+            : stateBudgetMessage('fullMatch(...)'));
     }
     return languageFullMatch(source);
 }

package/dist/v1/compiled/admission/accept.js

@@ -8,6 +8,8 @@ import { admitStateTopology } from '../../language/state/topology.js';
 import { bindValueProgram } from '../../language/value/compile/load.js';
 import { isValueObject } from '../../language/value/model/object.js';
 import { classifyValueProgramOrdering } from '../../language/value/ordering.js';
+import { compilePattern } from '../../language/value/regexp/compile.js';
+import { isIRegexp } from '../../language/value/regexp/syntax.js';
 import { invalidCompiled } from '../diagnostic.js';
 import { revisionOfCompiledEntry } from './revision.js';
 import { validateCompiledSemantics } from './semantics.js';
@@ -24,7 +26,8 @@ export function acceptCompiledSchema(input) {
     if (root.version !== 2)
         invalid('version', undefined, '/version');
     const rootPin = dependency(root.root, 'root', '/root');
-    const closure = array(root.closure, 'closure', '/closure').map((value, index) => entry(value, index, `/closure/${index}`));
+    const machines = new Map();
+    const closure = array(root.closure, 'closure', '/closure').map((value, index) => entry(value, index, `/closure/${index}`, machines));
     if (closure.length > dependencyLimits.closure) {
         invalid('dependency closure limit', 'COMPILED_DEPENDENCY_LIMITS', '/closure');
     }
@@ -74,7 +77,7 @@ export function acceptCompiledSchema(input) {
     validateCompiledSemantics(candidate);
     return deepFreeze(candidate);
 }
-function entry(input, entryIndex, path) {
+function entry(input, entryIndex, path, machines) {
     const value = object(input, `closure[${entryIndex}]`, path);
     exact(value, ['origin', 'revision', 'dependencies', 'definitions', 'facts', 'values', 'patterns'], 'entry', path);
     const origin = originValue(value.origin, 'entry origin', `${path}/origin`);
@@ -89,7 +92,7 @@ function entry(input, entryIndex, path) {
     }
     const valuesPath = `${path}/values`;
     const patternsPath = `${path}/patterns`;
-    const patterns = array(value.patterns, 'entry patterns', patternsPath).map((item, index) => pattern(item, index, `${patternsPath}/${index}`));
+    const patterns = array(value.patterns, 'entry patterns', patternsPath).map((item, index) => pattern(item, index, `${patternsPath}/${index}`, machines));
     const values = array(value.values, 'values', valuesPath).map((item, index) => program(item, index, `${valuesPath}/${index}`, patterns));
     const bound = values.map((value) => bindValueProgram(value, patterns));
     const definitionsPath = `${path}/definitions`;
@@ -838,10 +841,28 @@ function valueNode(input, nodeIndex, path) {
             : { reference: integer(value.reference, 'reference', `${path}/reference`) }),
     };
 }
-function pattern(input, patternIndex, path) {
+/**
+ * Admit one received pattern as data and return the machine compiled from its source. A received
+ * machine never decides membership: it may come from another compiler, from a host with other
+ * Unicode data, or from a forger, and the artifact carries no compiler version that could tell a
+ * current machine from those, so it is ignored rather than compared. Its source decides, through
+ * the same bounded `isIRegexp` and `compilePattern` that source resolution uses.
+ */
+function pattern(input, patternIndex, path, machines) {
     const value = object(input, `patterns[${patternIndex}]`, path);
-    if (Object.hasOwn(value, 'runs'))
-        return runPattern(value, path);
+    const { source } = Object.hasOwn(value, 'runs')
+        ? runPattern(value, path)
+        : nfaPattern(value, path);
+    let machine = machines.get(source);
+    if (machine === undefined) {
+        if (!isIRegexp(source))
+            invalid('Pattern source', 'COMPILED_SOURCE_INVALID', `${path}/source`);
+        machine = compilePattern(source);
+        machines.set(source, machine);
+    }
+    return machine;
+}
+function nfaPattern(value, path) {
     exact(value, ['source', 'start', 'states'], 'Pattern', path);
     if (typeof value.source !== 'string')
         invalid('Pattern source', undefined, `${path}/source`);

package/dist/v1/compiled/admission/semantics.js

@@ -21,10 +21,11 @@ export function validateCompiledSemantics(candidate) {
     const partial = index(candidate);
     const analyses = analyzeClasses(partial.classes);
     const context = { ...partial, analyses };
+    const admitted = admittedOrigins(candidate);
     validateClassFacets(context);
-    validateEdges(context);
+    validateEdges(context, admitted);
     validateViews(candidate, context);
-    validatePolicies(candidate, context);
+    validatePolicies(candidate, context, admitted);
     validateCore(candidate, context);
 }
 function index(candidate) {
@@ -171,7 +172,30 @@ function validateClassFacets(context) {
         }
     }
 }
-function validateEdges(context) {
+/**
+ * The origins each closure entry was admitted against: itself and its transitive dependencies.
+ * Source admission decides undirected overlap and types Policies within that closure alone, so a
+ * dependent's Class extending a dependency's Classes never reaches the dependency's own decisions.
+ */
+function admittedOrigins(candidate) {
+    const entries = new Map(candidate.closure.map((entry) => [entry.origin, entry]));
+    const scopes = new Map();
+    const scope = (origin) => {
+        const known = scopes.get(origin);
+        if (known !== undefined)
+            return known;
+        const origins = new Set([origin]);
+        for (const dependency of Object.values(entries.get(origin)?.dependencies ?? {}))
+            for (const reached of scope(dependency.origin))
+                origins.add(reached);
+        scopes.set(origin, origins);
+        return origins;
+    };
+    for (const entry of candidate.closure)
+        scope(entry.origin);
+    return scopes;
+}
+function validateEdges(context, admitted) {
     for (const located of context.classes.values()) {
         if (!isCompiledEdge(located.value))
             continue;
@@ -194,7 +218,7 @@ function validateEdges(context) {
         }
         if (edge.orientation === 'undirected' &&
             !sameIncidentEndpoint(edge.endpoints[0], edge.endpoints[1]) &&
-            undirectedOverlap(context, edge.endpoints)) {
+            undirectedOverlap(context, edge.endpoints, admitted.get(located.entry.origin))) {
             fail(`${located.pointer}/endpoints`, 'Unequal undirected endpoint contracts overlap.');
         }
         for (const [parentIndex, parentRef] of edge.extends.entries()) {
@@ -242,8 +266,9 @@ function sameIncidentEndpoint(left, right) {
         a.length === b.length &&
         a.every((value, index) => value === b[index]));
 }
-function undirectedOverlap(context, endpoints) {
-    return [...context.classes.values()].some(({ value }) => value.kind === 'node' &&
+function undirectedOverlap(context, endpoints, origins) {
+    return [...context.classes.values()].some(({ value }) => origins.has(value.ref.origin) &&
+        value.kind === 'node' &&
         !value.abstract &&
         classSatisfiesAny(context, value.ref, endpoints[0].accepts) &&
         classSatisfiesAny(context, value.ref, endpoints[1].accepts));
@@ -274,14 +299,14 @@ function validateViews(candidate, context) {
         }
     }
 }
-function validatePolicies(candidate, context) {
+function validatePolicies(candidate, context, admitted) {
     for (const [entryIndex, entry] of candidate.closure.entries()) {
         const localPolicies = new Map(entry.definitions.policies.map((value) => [value.ref.name, value]));
         for (const [policyIndex, policy] of entry.definitions.policies.entries()) {
             validatePolicyExpression(context, entry, policy.expression, `/closure/${entryIndex}/definitions/policies/${policyIndex}/expression`, localPolicies);
         }
         validatePolicyCycles(entry, localPolicies, entryIndex);
-        validatePolicyParity(context, entry, entryIndex, localPolicies);
+        validatePolicyParity(context, entry, entryIndex, localPolicies, admitted.get(entry.origin));
         for (const [functionIndex, callable] of entry.definitions.functions.entries()) {
             if (callable.policy !== undefined)
                 validateCallablePolicy(context, entry, callable.policy, typeof callable.input === 'number' ? callable.input : callable.input.metadata, callable.fields, false, `/closure/${entryIndex}/definitions/functions/${functionIndex}/policy`);
@@ -455,9 +480,9 @@ function isNodeClassRef(context, value) {
     }
     return context.classes.get(Key.of(ref))?.value.kind === 'node';
 }
-function validatePolicyParity(context, entry, entryIndex, policies) {
+function validatePolicyParity(context, entry, entryIndex, policies, origins) {
     const normalized = new Map([...policies].map(([name, policy]) => [name, normalizePolicyExpression(policy.expression)]));
-    const typing = new CompiledPolicyTyping(context, entry, normalized);
+    const typing = new CompiledPolicyTyping(context, entry, normalized, origins);
     for (const [name, declaration] of policies) {
         const path = `/closure/${entryIndex}/definitions/policies/${declarationIndex(entry, 'policies', name)}`;
         if ('match' in declaration.expression) {
@@ -602,21 +627,21 @@ function nodePathAccepts(entry, input, field) {
         ? annotation.accepts
         : [];
 }
+/** Types one entry's Policies against the Node Classes of its own closure, as source admission. */
 class CompiledPolicyTyping {
     context;
     entry;
     normalized;
     allNodeClasses;
     concreteNodeClasses;
-    constructor(context, entry, normalized) {
+    constructor(context, entry, normalized, origins) {
         this.context = context;
         this.entry = entry;
         this.normalized = normalized;
-        this.allNodeClasses = [...context.classes.values()]
-            .filter(({ value }) => value.kind === 'node')
-            .map(({ value }) => value.ref);
-        this.concreteNodeClasses = [...context.classes.values()]
-            .filter(({ value }) => value.kind === 'node' && !value.abstract)
+        const nodeClasses = [...context.classes.values()].filter(({ value }) => value.kind === 'node' && origins.has(value.ref.origin));
+        this.allNodeClasses = nodeClasses.map(({ value }) => value.ref);
+        this.concreteNodeClasses = nodeClasses
+            .filter(({ value }) => !value.abstract)
             .map(({ value }) => value.ref);
     }
     expandedBranches(name, visiting, namespace) {

package/dist/v1/compiled/loader/load.js

@@ -125,6 +125,7 @@ function programValidation(programs, properties, propertyOrdering, callables) {
         propertyValidation.set(key, Object.freeze({
             ordering: propertyOrdering.get(key),
             validate: (value) => validateValueProgram(program, value),
+            program: () => program,
         }));
     }
     const callableValidation = new Map();

package/dist/v1/domain/model/input.d.ts

@@ -3,6 +3,7 @@ import type { DomainDependency, DomainDependencyMap } from '../../addressing/ind
 import type { CoreEdge } from '../../language/core/model/core.js';
 import type { Definition } from '../../language/definition.js';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { ValueProgram } from '../../language/value/compile/model.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
 /** One admitted Schema entry in a dependency-closed Domain universe. */
 export interface DomainEntryInput {
@@ -22,6 +23,8 @@ export interface DomainInput {
 export interface DomainValidation {
     propertyExists(key: PropertyKey): boolean;
     property(key: PropertyKey, input: unknown): readonly Diagnostic[];
+    /** The admitted program `property` evaluates. */
+    propertyProgram(key: PropertyKey): ValueProgram;
     propertyOrdering(key: PropertyKey): OrderingKind | undefined;
     callableExists(key: AddressKey.Callable): boolean;
     callableInput(key: AddressKey.Callable, input: unknown): readonly Diagnostic[];

package/dist/v1/domain/projection/classes.js

@@ -45,6 +45,7 @@ export function createClasses(definitions, validation) {
                 definition: propertyDefinition,
                 ...(ordering === undefined ? {} : { ordering }),
                 validate: (input) => validation.property(propertyKey, input),
+                program: () => validation.propertyProgram(propertyKey),
             });
             ownProperties.push(property);
             effectiveProperties.set(property.key, property);

package/dist/v1/domain/validation/create.d.ts

@@ -1,10 +1,12 @@
 import type { Key, PropertyKey } from '../../addressing/index.js';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
+import type { ValueProgram } from '../../language/value/compile/model.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
 import type { DomainValidation } from '../model/input.js';
 export interface PropertyValidation {
     readonly ordering?: OrderingKind;
     validate(input: unknown): readonly Diagnostic[];
+    program(): ValueProgram;
 }
 export interface CallableValidation {
     readonly fields?: readonly string[];

package/dist/v1/domain/validation/create.js

@@ -6,6 +6,12 @@ export function createDomainValidation(properties, callables) {
             const target = properties.get(key);
             return target === undefined ? unknownTarget('Property', key) : target.validate(input);
         },
+        propertyProgram(key) {
+            const target = properties.get(key);
+            if (target === undefined)
+                throw new TypeError(`Property ${key} is absent.`);
+            return target.program();
+        },
         propertyOrdering: (key) => properties.get(key)?.ordering,
         callableExists: (key) => callables.has(key),
         callableInput(key, input) {
@@ -33,6 +39,12 @@ export function combineDomainValidation(values) {
             const owner = values.find((value) => value.propertyExists(key));
             return owner === undefined ? unknownTarget('Property', key) : owner.property(key, input);
         },
+        propertyProgram(key) {
+            const owner = values.find((value) => value.propertyExists(key));
+            if (owner === undefined)
+                throw new TypeError(`Property ${key} is absent.`);
+            return owner.propertyProgram(key);
+        },
         propertyOrdering: (key) => values.find((value) => value.propertyExists(key))?.propertyOrdering(key),
         callableExists: (key) => values.some((value) => value.callableExists(key)),
         callableInput(key, input) {

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

@@ -3,6 +3,7 @@ import type { ClassRef, DefinitionKey, Key, PropertyKey } from '../../addressing
 import type { ResolvedMethodCollection } from '../callable/resolved.js';
 import type { StateTopology } from '../state/index.js';
 import type { Diagnostic } from '../validation/diagnostic.js';
+import type { ValueProgram } from '../value/compile/model.js';
 import type { OrderingKind } from '../value/ordering.js';
 import type { ClassDefinition, ClassKind } from './model/class.js';
 import type { DataDefinition } from './model/data.js';
@@ -19,6 +20,8 @@ export interface ResolvedProperty<out Value = PortableValue, out Required extend
     /** The one portable scalar ordering domain, when the Property is orderable. */
     readonly ordering?: OrderingKind;
     validate(input: unknown): readonly Diagnostic[];
+    /** The admitted program `validate` evaluates. */
+    program(): ValueProgram;
     readonly __value?: Value;
     readonly __input?: Input;
 }

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

@@ -4,6 +4,8 @@ export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, F
 export type { Value as PropertyValue } from '@astrale-os/kernel-dsl/value';
 export type { JsonSchema as ValueSchema, JsonSchemaObject as ValueSchemaObject, } from './value/model/schema.js';
 export type { OrderingKind } from './value/ordering.js';
+export type { ValueProgram } from './value/compile/model.js';
+export { valueProgramIncludes } from './value/inclusion/includes.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

@@ -1,5 +1,6 @@
 export { isMethodExecutable } from './callable/executable.js';
 export { isBinaryInput } from './callable/model/callable.js';
+export { valueProgramIncludes } from './value/inclusion/includes.js';
 export { stateMachine } from './state/index.js';
 export { PropertyValues } from './class/property-values.js';
 export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';

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

@@ -1,4 +1,8 @@
 import type { PolicyCheckExpression, PolicyExpression, PolicyPatternExpression } from '../model/policy.js';
 export declare function normalizePolicyExpression(value: PolicyExpression): PolicyExpression;
+/**
+ * The fixed point of the single pass: a Pattern the single pass reproduces is returned unchanged,
+ * so the canonical form of every Pattern that was already stable keeps its bytes.
+ */
 export declare function normalizePolicyPattern(value: PolicyPatternExpression): PolicyPatternExpression;
 export declare function normalizePolicyChecks(value: PolicyCheckExpression): PolicyCheckExpression;

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

@@ -10,7 +10,32 @@ export function normalizePolicyExpression(value) {
     }
     return { anyOf: uniqueRefs(value.anyOf) };
 }
+/**
+ * Passes after the first, while one still changes the Pattern. A pass numbers variables by the
+ * operands as written, then merges duplicate operands and flattens nested ones, so its result can
+ * number differently when normalized again; the next pass numbers that result by itself. One
+ * further pass reached the fixed point on every Pattern tested, the other is margin, and a
+ * Pattern still changing keeps its last pass rather than failing.
+ */
+const SETTLING_PASSES = 2;
+/**
+ * The fixed point of the single pass: a Pattern the single pass reproduces is returned unchanged,
+ * so the canonical form of every Pattern that was already stable keeps its bytes.
+ */
 export function normalizePolicyPattern(value) {
+    let current = normalizePatternOnce(value);
+    let encoding = json.serialize(current);
+    for (let pass = 0; pass < SETTLING_PASSES; pass++) {
+        const next = normalizePatternOnce(current);
+        const nextEncoding = json.serialize(next);
+        if (nextEncoding === encoding)
+            return current;
+        current = next;
+        encoding = nextEncoding;
+    }
+    return current;
+}
+function normalizePatternOnce(value) {
     const rewritten = rewriteVariables(value, canonicalVariableIds(value));
     return normalizePatternNode(rewritten);
 }
@@ -71,7 +96,8 @@ function normalizePatternNode(value) {
 }
 function canonicalVariableIds(value) {
     const declarations = new Map();
-    collectDeclarations(value, declarations);
+    const depths = new Map();
+    collectDeclarations(value, declarations, depths);
     const uses = new Map([...declarations.keys()].map((id) => [id, []]));
     collectUses(value, uses);
     let colors = declarations;
@@ -89,8 +115,15 @@ function canonicalVariableIds(value) {
             break;
         colors = next;
     }
+    // Colors ignore where a variable is declared, so two variables can tie on color although
+    // different `exists` declare them, and which of them is numbered first decides which `exists`
+    // declares the smaller id. Their declaration depth tells them apart where it differs: operands of
+    // equal signature are ordered by their signature over depth-scoped colors before authored order,
+    // and the final order compares depth before the authored id (decision
+    // `policy-pattern-canonical-ties`). Both keys only order what color and first use leave tied.
+    const scoped = new Map([...colors].map(([id, color]) => [id, `${color}@${depths.get(id) ?? 0}`]));
     const firstUse = new Map();
-    collectFirstUseKeys(value, colors, firstUse);
+    collectFirstUseKeys(value, colors, scoped, firstUse);
     const ordered = [...declarations.keys()].sort((left, right) => {
         const byColor = compareUtf8Bytes(colors.get(left) ?? '', colors.get(right) ?? '');
         if (byColor !== 0)
@@ -98,26 +131,31 @@ function canonicalVariableIds(value) {
         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.
+        const byDepth = (depths.get(left) ?? 0) - (depths.get(right) ?? 0);
+        if (byDepth !== 0)
+            return byDepth;
+        // A remaining tie keeps the authored order of the ids: such variables were interchangeable in
+        // every admissible Pattern checked (`__tests__/canonical.test.ts`).
         return left - right;
     });
     return new Map(ordered.map((id, index) => [id, index]));
 }
-function collectDeclarations(value, result) {
+/** Each declared variable's selector signature and the number of `exists` around its declaration. */
+function collectDeclarations(value, result, depths, depth = 0) {
     if ('exists' in value) {
         for (const node of value.exists.nodes) {
             result.set(node.variable.id, selectorSignature(node));
+            depths.set(node.variable.id, depth + 1);
         }
-        collectDeclarations(value.exists.where, result);
+        collectDeclarations(value.exists.where, result, depths, depth + 1);
         return;
     }
     if ('allOf' in value)
         for (const child of value.allOf)
-            collectDeclarations(child, result);
+            collectDeclarations(child, result, depths, depth);
     if ('anyOf' in value)
         for (const child of value.anyOf)
-            collectDeclarations(child, result);
+            collectDeclarations(child, result, depths, depth);
 }
 function collectUses(value, result) {
     if ('sameNode' in value) {
@@ -155,7 +193,7 @@ function termColor(term, colors) {
         return `ref:${term.ref.kind === 'method' ? policyObjectKey(term.ref) : definitionRefIndex(term.ref)}`;
     return term.kind;
 }
-function collectFirstUseKeys(value, colors, result, prefix = '$') {
+function collectFirstUseKeys(value, colors, scoped, result, prefix = '$') {
     if ('sameNode' in value) {
         for (const term of [value.sameNode.left, value.sameNode.right]) {
             if (term.kind !== 'variable')
@@ -182,15 +220,15 @@ function collectFirstUseKeys(value, colors, result, prefix = '$') {
         return;
     }
     if ('exists' in value) {
-        collectFirstUseKeys(value.exists.where, colors, result, `${prefix}:exists`);
+        collectFirstUseKeys(value.exists.where, colors, scoped, result, `${prefix}:exists`);
         return;
     }
     const key = 'allOf' in value ? 'allOf' : 'anyOf';
     const operands = 'allOf' in value ? value.allOf : value.anyOf;
     const children = operands
-        .map((child) => [patternSignature(child, colors), child])
-        .sort(([left], [right]) => compareUtf8Bytes(left, right));
-    children.forEach(([, child], index) => collectFirstUseKeys(child, colors, result, `${prefix}:${key}:${index}`));
+        .map((child) => [patternSignature(child, colors), patternSignature(child, scoped), child])
+        .sort(([left, leftScoped], [right, rightScoped]) => compareUtf8Bytes(left, right) || compareUtf8Bytes(leftScoped, rightScoped));
+    children.forEach(([, , child], index) => collectFirstUseKeys(child, colors, scoped, result, `${prefix}:${key}:${index}`));
 }
 function patternSignature(value, colors) {
     if ('sameNode' in value)

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

@@ -0,0 +1,9 @@
+import type { ValueProgram } from '../compile/model.js';
+/**
+ * Whether `outer` admits every value `inner` admits, under the one V1 evaluator.
+ *
+ * `true` is a proof. `false` only means that no rule proved inclusion: a caller must then decide
+ * the values themselves. Each rule relates one assertion of `outer` to evidence carried by
+ * `inner`; a finite `inner` is decided exactly by evaluating its candidates.
+ */
+export declare function valueProgramIncludes(outer: ValueProgram, inner: ValueProgram): boolean;