@astrale-os/kernel-dsl 0.2.0-beta.33 → 0.2.0-beta.35

package/dist/v1/language/value/regexp/matcher.d.ts

@@ -3,5 +3,8 @@ export interface IRegexpMatcher {
     test(value: string): boolean;
     matches(value: string): boolean;
 }
-/** Load portable NFA data without a regex engine or dynamic compilation. */
+/**
+ * Load the portable Thompson NFA executor shared by search and whole-string matching.
+ * Scratch belongs to one invocation: no match-result cache, shared mutable cursor or DFA expansion.
+ */
 export declare function loadPattern(pattern: Pattern): IRegexpMatcher;

package/dist/v1/language/value/regexp/matcher.js

@@ -1,50 +1,135 @@
-/** Load portable NFA data without a regex engine or dynamic compilation. */
+/**
+ * Load the portable Thompson NFA executor shared by search and whole-string matching.
+ * Scratch belongs to one invocation: no match-result cache, shared mutable cursor or DFA expansion.
+ */
 export function loadPattern(pattern) {
-    const start = closure(pattern.states, new Set([pattern.start]));
+    const states = pattern.states;
+    const start = initialFrontier(pattern);
     const run = (input, search) => {
-        let active = new Set(start);
-        if ((search || input.length === 0) && accepts(pattern.states, active))
+        if (input.length === 0)
+            return start.accepting;
+        if (search && start.accepting)
             return true;
+        const resolve = executionStates(states);
+        // Initial frontier entries consume characters, so none can be a dead conduit cycle.
+        const initial = start.frontier.map((index) => resolve(index));
+        let active = [...initial];
+        let next = [];
+        const pending = [];
+        let activeCount = start.frontier.length;
+        let nextCount = 0;
+        let epoch = 0;
+        let accepting = false;
+        function add(destination) {
+            const seed = resolve(destination);
+            if (seed === null || seed.epoch === epoch)
+                return;
+            let count = 1;
+            pending[0] = seed;
+            seed.epoch = epoch;
+            while (count > 0) {
+                const entry = pending[--count];
+                const state = entry.state;
+                if (state.accepting === true)
+                    accepting = true;
+                if (state.transitions.length > 0)
+                    next[nextCount++] = entry;
+                for (const destination of state.epsilon) {
+                    const target = resolve(destination);
+                    if (target === null || target.epoch === epoch)
+                        continue;
+                    target.epoch = epoch;
+                    pending[count++] = target;
+                }
+            }
+        }
         for (const character of input) {
+            if (!search && activeCount === 0)
+                return false;
+            epoch++;
+            nextCount = 0;
+            accepting = false;
             const scalar = character.codePointAt(0);
-            const next = new Set();
-            for (const index of active) {
-                for (const transition of pattern.states[index].transitions) {
-                    if (transition.ranges.some(([minimum, maximum]) => scalar >= minimum && scalar <= maximum)) {
-                        next.add(transition.to);
+            for (let index = 0; index < activeCount; index++) {
+                for (const transition of active[index].state.transitions) {
+                    for (const [minimum, maximum] of transition.ranges) {
+                        if (scalar < minimum || scalar > maximum)
+                            continue;
+                        add(transition.to);
+                        break;
                     }
                 }
             }
-            active = closure(pattern.states, next);
-            if (search)
-                for (const index of start)
-                    active.add(index);
-            if (search && accepts(pattern.states, active))
-                return true;
+            if (search) {
+                if (accepting)
+                    return true;
+                // The complete initial epsilon closure is already known; do not traverse it again.
+                for (const entry of initial) {
+                    if (entry.epoch === epoch)
+                        continue;
+                    entry.epoch = epoch;
+                    next[nextCount++] = entry;
+                }
+            }
+            const previous = active;
+            active = next;
+            next = previous;
+            activeCount = nextCount;
         }
-        return accepts(pattern.states, active);
+        return accepting;
     };
     return Object.freeze({
         test: (input) => run(input, true),
         matches: (input) => run(input, false),
     });
 }
-function closure(states, seed) {
-    const output = new Set(seed);
-    const pending = [...seed];
+function initialFrontier(pattern) {
+    const start = pattern.start;
+    const seen = new Set([start]);
+    const pending = [start];
+    const frontier = [];
+    let accepting = false;
     while (pending.length > 0) {
-        for (const next of states[pending.pop()].epsilon) {
-            if (output.has(next))
+        const index = pending.pop();
+        const state = pattern.states[index];
+        if (state.accepting === true)
+            accepting = true;
+        if (state.transitions.length > 0)
+            frontier.push(index);
+        for (const target of state.epsilon) {
+            if (seen.has(target))
                 continue;
-            output.add(next);
-            pending.push(next);
+            seen.add(target);
+            pending.push(target);
         }
     }
-    return output;
+    return { frontier: Object.freeze(frontier), accepting };
 }
-function accepts(states, active) {
-    for (const index of active)
-        if (states[index]?.accepting === true)
-            return true;
-    return false;
+/** Resolve only visited conduits, once within this invocation; never retain cross-call state. */
+function executionStates(states) {
+    const destinations = new Map();
+    return (index) => {
+        const known = destinations.get(index);
+        if (known !== undefined)
+            return known;
+        const path = [];
+        let current = index;
+        let destination = destinations.get(current);
+        while (destination === undefined) {
+            const state = states[current];
+            if (state.accepting === true || state.transitions.length > 0 || state.epsilon.length !== 1) {
+                destination = { state, epoch: 0 };
+                destinations.set(current, destination);
+                break;
+            }
+            // A revisit before resolving the path is a dead, epsilon-only cycle.
+            destinations.set(current, null);
+            path.push(current);
+            current = state.epsilon[0];
+            destination = destinations.get(current);
+        }
+        for (const member of path)
+            destinations.set(member, destination);
+        return destination;
+    };
 }

package/dist/v1/schema/compatibility/meaning.d.ts

@@ -1,17 +1,33 @@
 import type { Key as SemanticKey } from '../../addressing/index.js';
 import type { Revision } from '../../addressing/index.js';
+import type { ResolvedFunction, ResolvedMethod } from '../../language/callable/resolved.js';
 import type { DomainSchema } from '../model/schema.js';
 import { Key } from '../../addressing/index.js';
-export type DependencyMeaningChangeKind = 'missing' | 'changed';
+/**
+ * How strongly a dependent relies on a dependency Class. `inherit` covers `extends` and Core
+ * instantiation, which take on the Class creation contract; `reference` covers every other site,
+ * which only names the Class and reads its surface.
+ */
+export type DependencyMeaningLevel = 'reference' | 'inherit';
+export type DependencyMeaningChangeKind = 'missing' | 'changed' | 'added';
 export type MeaningFingerprint = `sha256:${string}`;
-export interface DependencyMeaningChange {
+export type DependencyMeaningChange = {
     readonly key: SemanticKey;
-    readonly kind: DependencyMeaningChangeKind;
+    readonly kind: 'missing';
     readonly sourceFingerprint: MeaningFingerprint;
-    readonly targetFingerprint?: MeaningFingerprint;
-}
+} | {
+    readonly key: SemanticKey;
+    readonly kind: 'changed';
+    readonly sourceFingerprint: MeaningFingerprint;
+    readonly targetFingerprint: MeaningFingerprint;
+} | {
+    /** A required, non-automatic Property the target adds to an inherited Class. */
+    readonly key: SemanticKey;
+    readonly kind: 'added';
+    readonly targetFingerprint: MeaningFingerprint;
+};
 export interface DependencyMeaningComparison {
-    readonly version: 1;
+    readonly version: 2;
     readonly dependency: Key.Origin;
     readonly source: Revision;
     readonly target: Revision;
@@ -27,3 +43,11 @@ export interface DependencyMeaningComparison {
 export declare function compareDependencyMeaning(dependent: DomainSchema, target: DomainSchema): DependencyMeaningComparison;
 /** Compare one explicit non-empty source member surface and its reachable V1 meaning. */
 export declare function compareMemberMeaning(source: DomainSchema, target: DomainSchema, roots: readonly [SemanticKey, ...SemanticKey[]]): DependencyMeaningComparison;
+/**
+ * Fingerprint the contract a caller compiles against, independently of its Domain revision: the
+ * exact key, the owner, dispatch and abstractness of a Method, and the semantic input and output
+ * contracts; authorization is excluded (DM-CALLABLE-FINGERPRINT). A static consumer pins this
+ * instead of a Domain revision, so a dependency release that leaves the callable contract untouched
+ * keeps every bound invocation valid.
+ */
+export declare function callableFingerprint(callable: ResolvedFunction | ResolvedMethod): MeaningFingerprint;

package/dist/v1/schema/compatibility/meaning.js

@@ -1,6 +1,6 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { Key, MethodKey, PropertyKey } from '../../addressing/index.js';
-import { compareDefinitionRefs, compareUnicode, definitionRefIndex, } from '../../addressing/ordering.js';
+import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
 import { isValueObject as isJsonObject } from '../../language/value/model/object.js';
 import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../../language/value/syntax/keywords.js';
 import { digestDomainSchemaBytes } from '../canonical/domain.digest.js';
@@ -8,7 +8,7 @@ import { revisionOfDomainSchema } from '../canonical/revision.js';
 import { SchemaError, diagnostic } from '../diagnostic.js';
 import { knownDomainClosure, lookupForDomainClosure } from '../resolution/closure.js';
 import { resolve } from '../resolution/domain.js';
-import { collectCallableRefs, collectClassRefs, collectPolicyDefinitionRefs, collectValueDefinitionRefs, } from '../resolution/origins.js';
+import { collectCallableContractRefs, collectCallableRefs, collectClassPolicyRefs, collectClassRefs, collectCoreRefs, collectEndpointRefs, collectPolicyDefinitionRefs, collectValueDefinitionRefs, } from '../resolution/origins.js';
 import { validateDomainSchemaSemantics } from '../validation/domain.js';
 const VALUE_SCHEMA_ANNOTATIONS = new Set([
     '$comment',
@@ -31,19 +31,15 @@ const VALUE_SCHEMA_ANNOTATIONS = new Set([
  */
 export function compareDependencyMeaning(dependent, target) {
     resolve(dependent);
-    const closure = knownDomainClosure(dependent) ?? [];
-    const source = closure.find((candidate) => candidate.schema.origin === target.origin)?.schema;
+    const context = contextOf(dependent);
+    const source = (knownDomainClosure(dependent) ?? []).find((candidate) => candidate.schema.origin === target.origin)?.schema;
     if (source === undefined) {
         throw new SchemaError([
             diagnostic('DM_DEPENDENCY_NOT_RETAINED', '/target/origin', `Domain ${dependent.origin} was not admitted with a dependency at ${target.origin}.`),
         ]);
     }
-    const schemas = new Map([
-        [dependent.origin, dependent],
-        ...closure.map(({ schema: candidate }) => [candidate.origin, candidate]),
-    ]);
-    const sourceMeanings = collectDependencyMeanings(dependent, source.origin, schemas);
-    return compareSourceMeanings(source, target, sourceMeanings);
+    const meanings = collectReachableMeanings(collectSchemaRoots(dependent), source.origin, context);
+    return compareSourceMeanings(source, target, meanings);
 }
 /** Compare one explicit non-empty source member surface and its reachable V1 meaning. */
 export function compareMemberMeaning(source, target, roots) {
@@ -58,24 +54,55 @@ export function compareMemberMeaning(source, target, roots) {
         ]);
     }
     resolve(source);
-    const closure = knownDomainClosure(source) ?? [];
+    const context = contextOf(source);
+    const coordinates = roots.map((key, index) => coordinateForKey(context, source, key, index));
+    const meanings = collectReachableMeanings(coordinates, source.origin, context);
+    return compareSourceMeanings(source, target, meanings);
+}
+/**
+ * Fingerprint the contract a caller compiles against, independently of its Domain revision: the
+ * exact key, the owner, dispatch and abstractness of a Method, and the semantic input and output
+ * contracts; authorization is excluded (DM-CALLABLE-FINGERPRINT). A static consumer pins this
+ * instead of a Domain revision, so a dependency release that leaves the callable contract untouched
+ * keeps every bound invocation valid.
+ */
+export function callableFingerprint(callable) {
+    return fingerprintMeaning('owner' in callable
+        ? {
+            kind: 'method',
+            key: callable.key,
+            owner: callable.owner.key,
+            ...semanticMethod(callable),
+        }
+        : { kind: 'function', key: callable.key, ...semanticFunction(callable) });
+}
+function contextOf(root) {
     const schemas = new Map([
-        [source.origin, source],
-        ...closure.map(({ schema: candidate }) => [candidate.origin, candidate]),
+        [root.origin, root],
+        ...(knownDomainClosure(root) ?? []).map(({ schema }) => [schema.origin, schema]),
     ]);
-    const coordinates = roots.map((key, index) => coordinateForKey(source, key, index));
-    const sourceMeanings = collectReachableMeanings(coordinates, source.origin, schemas);
-    return compareSourceMeanings(source, target, sourceMeanings);
+    const analyses = new Map();
+    return {
+        schemas,
+        analysis(owner) {
+            if (!analyses.has(owner)) {
+                const validation = validateDomainSchemaSemantics(owner, lookupForDomainClosure(owner));
+                analyses.set(owner, validation.diagnostics.length > 0 ? undefined : validation.analysis.definitions);
+            }
+            return analyses.get(owner);
+        },
+    };
 }
 function compareSourceMeanings(source, target, sourceMeanings) {
     // Prove the candidate still has an exact accepted semantic context before comparing it.
     resolve(target);
+    const context = contextOf(target);
     const footprint = Object.freeze([...sourceMeanings.keys()].sort(compareUnicode));
     const changes = [];
     const comparisonCoordinates = [];
     for (const key of footprint) {
         const sourceMeaning = sourceMeanings.get(key);
-        const targetMeaning = meaningForCoordinate(target, sourceMeaning.coordinate);
+        const targetMeaning = meaningForCoordinate(context, sourceMeaning.coordinate, sourceMeaning.requirement);
         const targetFingerprint = targetMeaning === undefined ? undefined : fingerprintMeaning(targetMeaning);
         comparisonCoordinates.push([
             key,
@@ -83,11 +110,7 @@ function compareSourceMeanings(source, target, sourceMeanings) {
             targetFingerprint ?? null,
         ]);
         if (targetFingerprint === undefined) {
-            changes.push(Object.freeze({
-                key,
-                kind: 'missing',
-                sourceFingerprint: sourceMeaning.fingerprint,
-            }));
+            changes.push(Object.freeze({ key, kind: 'missing', sourceFingerprint: sourceMeaning.fingerprint }));
         }
         else if (targetFingerprint !== sourceMeaning.fingerprint) {
             changes.push(Object.freeze({
@@ -98,177 +121,214 @@ function compareSourceMeanings(source, target, sourceMeanings) {
             }));
         }
     }
+    const additions = addedObligations(context, sourceMeanings);
     const sourceRevision = revisionOfDomainSchema(source);
     const targetRevision = revisionOfDomainSchema(target);
-    const immutableChanges = Object.freeze(changes);
     const fingerprint = fingerprintMeaning({
-        version: 1,
+        version: 2,
         dependency: source.origin,
         source: sourceRevision,
         target: targetRevision,
         coordinates: comparisonCoordinates,
+        additions: additions.map(({ key, targetFingerprint }) => [key, targetFingerprint]),
     });
     return Object.freeze({
-        version: 1,
+        version: 2,
         dependency: source.origin,
         source: sourceRevision,
         target: targetRevision,
         footprint,
-        changes: immutableChanges,
+        changes: Object.freeze([...changes, ...additions]),
         fingerprint,
     });
 }
-function collectDependencyMeanings(dependent, dependencyOrigin, schemas) {
-    return collectReachableMeanings(collectSchemaSemanticRefs(dependent).map(memberCoordinate), dependencyOrigin, schemas);
+/** A target may extend an inherited Class only with optional or automatic Properties. */
+function addedObligations(context, sourceMeanings) {
+    const additions = new Map();
+    for (const { coordinate, requirement } of sourceMeanings.values()) {
+        if (coordinate.kind !== 'class' || coordinate.level !== 'inherit' || requirement === undefined)
+            continue;
+        const owner = context.schemas.get(coordinate.ref.origin);
+        const analysis = owner === undefined ? undefined : effectiveDefinition(context, owner, coordinate.ref);
+        if (analysis === undefined)
+            continue;
+        for (const field of analysis.properties.values()) {
+            if (requirement.properties.has(field.identity) || !field.required || field.auto !== undefined)
+                continue;
+            additions.set(field.identity, Object.freeze({
+                key: field.identity,
+                kind: 'added',
+                targetFingerprint: fingerprintMeaning(propertyMeaning(field)),
+            }));
+        }
+    }
+    return [...additions.values()].sort((left, right) => compareUnicode(left.key, right.key));
+}
+function collectSchemaRoots(owner) {
+    const classes = new Map();
+    const members = new Map();
+    const add = (ref, site) => {
+        if (ref.kind === 'class') {
+            const index = definitionRefIndex(ref);
+            const level = levelOf(site);
+            const previous = classes.get(index);
+            if (previous === undefined || (previous.level === 'reference' && level === 'inherit')) {
+                classes.set(index, classCoordinate(ref, level));
+            }
+            return;
+        }
+        members.set(definitionRefIndex(ref), memberCoordinate(ref));
+    };
+    for (const declaration of Object.values(owner.classes))
+        collectClassRefs(declaration, add);
+    for (const declaration of Object.values(owner.functions))
+        collectCallableRefs(declaration, add);
+    for (const declaration of Object.values(owner.policies)) {
+        collectPolicyDefinitionRefs(declaration, add);
+    }
+    for (const declaration of Object.values(owner.views)) {
+        if (declaration.target.kind === 'definition') {
+            declaration.target.definitions.forEach((ref) => add(ref, 'view'));
+        }
+    }
+    collectCoreRefs(owner, add);
+    return [...classes.values(), ...members.values()].sort((left, right) => compareUnicode(left.key, right.key));
 }
-function collectReachableMeanings(roots, selectedOrigin, schemas) {
+function collectReachableMeanings(roots, selectedOrigin, context) {
     const meanings = new Map();
-    const pending = [];
-    const visited = new Set();
+    const classLevels = new Map();
+    const visitedMembers = new Set();
+    const pendingClasses = [];
+    const pendingMembers = [];
+    const push = (ref, site) => {
+        if (ref.kind === 'class')
+            pendingClasses.push(classCoordinate(ref, levelOf(site)));
+        else
+            pendingMembers.push(memberCoordinate(ref));
+    };
     for (const coordinate of roots) {
+        if (coordinate.kind === 'class') {
+            pendingClasses.push(coordinate);
+            continue;
+        }
         if (coordinate.kind === 'member') {
-            pending.push(coordinate.ref);
+            pendingMembers.push(coordinate);
             continue;
         }
-        const owner = schemas.get(Key.origin(coordinate.key));
-        const meaning = owner === undefined ? undefined : meaningForCoordinate(owner, coordinate);
-        if (owner === undefined || meaning === undefined) {
+        const meaning = meaningForCoordinate(context, coordinate);
+        if (meaning === undefined) {
             throw new SchemaError([
                 diagnostic('DM_MEMBER_ROOT_INVALID', '/roots', `Member comparison root ${coordinate.key} does not exist in its source context.`, coordinate.key),
             ]);
         }
         retainMeaning(meanings, selectedOrigin, coordinate, meaning);
-        collectCoordinateSemanticRefs(owner, coordinate, (candidate) => pending.push(requireMemberRef(candidate)));
+        collectCoordinateSemanticRefs(context, coordinate, push);
     }
-    for (let index = 0; index < pending.length; index += 1) {
-        const ref = pending[index];
-        const refIndex = definitionRefIndex(ref);
-        if (visited.has(refIndex))
-            continue;
-        visited.add(refIndex);
-        const owner = schemas.get(ref.origin);
-        if (owner === undefined) {
-            throw new SchemaError([
-                diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', `Retained acceptance context cannot resolve ${keyForDefinitionRef(ref)}.`, keyForDefinitionRef(ref)),
-            ]);
+    const visitClass = (coordinate) => {
+        const index = definitionRefIndex(coordinate.ref);
+        const previous = classLevels.get(index);
+        if (previous === 'inherit' || previous === coordinate.level)
+            return;
+        classLevels.set(index, coordinate.level);
+        const owner = requireOwner(context, coordinate.ref, coordinate.key);
+        const declaration = owner.classes[coordinate.ref.name];
+        const analysis = effectiveDefinition(context, owner, coordinate.ref);
+        const resolved = classMeaning(context, coordinate);
+        if (declaration === undefined || analysis === undefined || resolved === undefined) {
+            throw contextInvalid(`Retained acceptance context has no meaning for ${coordinate.key}.`, coordinate.key);
         }
-        const primary = memberCoordinate(ref);
-        const primaryMeaning = meaningForCoordinate(owner, primary);
-        if (primaryMeaning === undefined) {
-            throw new SchemaError([
-                diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', `Retained acceptance context has no meaning for ${primary.key}.`, primary.key),
-            ]);
+        retainMeaning(meanings, selectedOrigin, coordinate, resolved.meaning, resolved.requirement);
+        if (previous === undefined) {
+            // The surface is level-independent: every effective Property and Method the dependent may
+            // read or call, with the Definitions their contracts and policies name.
+            for (const field of analysis.properties.values()) {
+                retainMeaning(meanings, selectedOrigin, propertyCoordinate(field.owner, field.name), propertyMeaning(field));
+                collectValueDefinitionRefs(field.schema, push);
+            }
+            for (const method of analysis.methods.values()) {
+                retainMeaning(meanings, selectedOrigin, methodCoordinate(method.owner, method.name), methodMeaning(method));
+                collectCallableContractRefs(method.declaration, push);
+            }
+            collectClassPolicyRefs(declaration, push);
         }
-        retainMeaning(meanings, selectedOrigin, primary, primaryMeaning);
-        collectMemberSemanticRefs(owner, ref, (candidate) => pending.push(requireMemberRef(candidate)));
-        if (!isDefinitionRef(ref))
-            continue;
-        const analysis = effectiveDefinition(owner, ref);
-        if (analysis === undefined)
-            continue;
-        collectEffectiveMeanings(analysis, selectedOrigin, meanings, (candidate) => pending.push(requireMemberRef(candidate)));
+        if (coordinate.level === 'inherit') {
+            // Only inheritance takes on the ancestry and, for an Edge, the endpoint contract.
+            declaration.extends.forEach((parent) => push(parent, 'extends'));
+            if (declaration.kind === 'edge')
+                collectEndpointRefs(declaration, push);
+        }
+    };
+    const visitMember = (coordinate) => {
+        const index = definitionRefIndex(coordinate.ref);
+        if (visitedMembers.has(index))
+            return;
+        visitedMembers.add(index);
+        const owner = requireOwner(context, coordinate.ref, coordinate.key);
+        const meaning = memberMeaning(owner, coordinate.ref);
+        if (meaning === undefined) {
+            throw contextInvalid(`Retained acceptance context has no meaning for ${coordinate.key}.`, coordinate.key);
+        }
+        retainMeaning(meanings, selectedOrigin, coordinate, meaning);
+        collectMemberSemanticRefs(owner, coordinate.ref, push);
+    };
+    let classIndex = 0;
+    let memberIndex = 0;
+    while (classIndex < pendingClasses.length || memberIndex < pendingMembers.length) {
+        if (classIndex < pendingClasses.length)
+            visitClass(pendingClasses[classIndex++]);
+        else
+            visitMember(pendingMembers[memberIndex++]);
     }
     return meanings;
 }
-function collectCoordinateSemanticRefs(owner, coordinate, add) {
-    const analysis = effectiveDefinition(owner, coordinate.owner);
+function requireOwner(context, ref, key) {
+    const owner = context.schemas.get(ref.origin);
+    if (owner === undefined) {
+        throw contextInvalid(`Retained acceptance context cannot resolve ${key}.`, key);
+    }
+    return owner;
+}
+function contextInvalid(message, key) {
+    return new SchemaError([diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', message, key)]);
+}
+function collectCoordinateSemanticRefs(context, coordinate, add) {
+    const owner = context.schemas.get(coordinate.owner.origin);
+    const analysis = owner === undefined ? undefined : effectiveDefinition(context, owner, coordinate.owner);
     if (analysis === undefined)
         return;
     if (coordinate.kind === 'property') {
         const field = analysis.properties.get(coordinate.key);
         if (field !== undefined)
-            collectValueDefinitionRefs(semanticValueSchema(field.schema), add);
+            collectValueDefinitionRefs(field.schema, add);
         return;
     }
     const method = [...analysis.methods.values()].find((candidate) => MethodKey.of(candidate.owner, candidate.name) === coordinate.key);
     if (method !== undefined)
-        collectCallableRefs(semanticMethod(method.declaration), add);
-}
-function collectEffectiveMeanings(analysis, dependencyOrigin, meanings, add) {
-    for (const field of analysis.properties.values()) {
-        const coordinate = propertyCoordinate(field.owner, field.name);
-        retainMeaning(meanings, dependencyOrigin, coordinate, propertyMeaning(field));
-        add(field.owner);
-        collectValueDefinitionRefs(semanticValueSchema(field.schema), add);
-    }
-    for (const method of analysis.methods.values()) {
-        const coordinate = methodCoordinate(method.owner, method.name);
-        retainMeaning(meanings, dependencyOrigin, coordinate, methodMeaning(method));
-        add(method.owner);
-        collectCallableRefs(semanticMethod(method.declaration), add);
-    }
-}
-function retainMeaning(meanings, dependencyOrigin, coordinate, meaning) {
-    if (Key.origin(coordinate.key) !== dependencyOrigin)
-        return;
-    const fingerprint = fingerprintMeaning(meaning);
-    const previous = meanings.get(coordinate.key);
-    if (previous !== undefined && previous.fingerprint !== fingerprint) {
-        throw new SchemaError([
-            diagnostic('DM_MEANING_INCONSISTENT', '', `Semantic coordinate ${coordinate.key} produced inconsistent effective meaning.`, coordinate.key),
-        ]);
-    }
-    meanings.set(coordinate.key, Object.freeze({ coordinate, fingerprint }));
-}
-function collectSchemaSemanticRefs(owner) {
-    const refs = new Map();
-    const add = (ref) => {
-        const member = requireMemberRef(ref);
-        refs.set(definitionRefIndex(member), member);
-    };
-    for (const declaration of Object.values(owner.classes)) {
-        collectClassRefs(semanticDefinition(declaration), add);
-    }
-    for (const declaration of Object.values(owner.functions)) {
-        collectCallableRefs(semanticFunction(declaration), add);
-    }
-    for (const declaration of Object.values(owner.policies)) {
-        collectPolicyDefinitionRefs(semanticPolicy(declaration), add);
-    }
-    for (const declaration of Object.values(owner.views)) {
-        if (declaration.target.kind === 'definition')
-            declaration.target.definitions.forEach(add);
-    }
-    for (const node of Object.values(owner.core.nodes))
-        add(node.class);
-    for (const edge of owner.core.edges) {
-        add(edge.class);
-        if (edge.source.kind !== 'domain')
-            add(edge.source);
-        if (edge.target.kind !== 'domain')
-            add(edge.target);
-    }
-    return [...refs.values()].sort(compareDefinitionRefs);
+        collectCallableContractRefs(method.declaration, add);
 }
 function collectMemberSemanticRefs(owner, ref, add) {
     switch (ref.kind) {
-        case 'class': {
-            const declaration = owner.classes[ref.name];
-            if (declaration !== undefined) {
-                collectClassRefs(semanticDefinition(declaration), add);
-            }
-            return;
-        }
         case 'function': {
             const declaration = owner.functions[ref.name];
             if (declaration !== undefined)
-                collectCallableRefs(semanticFunction(declaration), add);
+                collectCallableRefs(declaration, add);
             return;
         }
         case 'policy': {
             const declaration = owner.policies[ref.name];
-            if (declaration !== undefined) {
-                collectPolicyDefinitionRefs(semanticPolicy(declaration), add);
-            }
+            if (declaration !== undefined)
+                collectPolicyDefinitionRefs(declaration, add);
             return;
         }
         case 'view': {
             const declaration = owner.views[ref.name];
-            if (declaration?.target.kind === 'definition')
-                declaration.target.definitions.forEach(add);
+            if (declaration?.target.kind === 'definition') {
+                declaration.target.definitions.forEach((definition) => add(definition, 'view'));
+            }
             return;
         }
         case 'core': {
+            // The dependency instantiates its own Core; the dependent only refers to it.
             const node = owner.core.nodes[ref.name];
             if (node === undefined)
                 return;
@@ -283,12 +343,41 @@ function collectMemberSemanticRefs(owner, ref, add) {
         }
     }
 }
-function meaningForCoordinate(owner, coordinate) {
-    if (Key.origin(coordinate.key) !== owner.origin)
+function retainMeaning(meanings, selectedOrigin, coordinate, meaning, requirement) {
+    if (Key.origin(coordinate.key) !== selectedOrigin)
+        return;
+    const fingerprint = fingerprintMeaning(meaning);
+    const previous = meanings.get(coordinate.key);
+    if (previous !== undefined) {
+        const upgraded = previous.coordinate.kind === 'class' &&
+            coordinate.kind === 'class' &&
+            previous.coordinate.level !== coordinate.level;
+        if (upgraded) {
+            // A stronger requirement replaces the weaker one for the same Class.
+            if (coordinate.level === 'reference')
+                return;
+        }
+        else if (previous.fingerprint !== fingerprint) {
+            throw new SchemaError([
+                diagnostic('DM_MEANING_INCONSISTENT', '', `Semantic coordinate ${coordinate.key} produced inconsistent effective meaning.`, coordinate.key),
+            ]);
+        }
+    }
+    meanings.set(coordinate.key, Object.freeze({
+        coordinate,
+        fingerprint,
+        ...(requirement === undefined ? {} : { requirement }),
+    }));
+}
+function meaningForCoordinate(context, coordinate, requirement) {
+    const owner = context.schemas.get(Key.origin(coordinate.key));
+    if (owner === undefined)
         return undefined;
+    if (coordinate.kind === 'class')
+        return classMeaning(context, coordinate, requirement)?.meaning;
     if (coordinate.kind === 'member')
         return memberMeaning(owner, coordinate.ref);
-    const analysis = effectiveDefinition(owner, coordinate.owner);
+    const analysis = effectiveDefinition(context, owner, coordinate.owner);
     if (analysis === undefined)
         return undefined;
     if (coordinate.kind === 'property') {
@@ -298,12 +387,69 @@ function meaningForCoordinate(owner, coordinate) {
     const method = [...analysis.methods.values()].find((candidate) => MethodKey.of(candidate.owner, candidate.name) === coordinate.key);
     return method === undefined ? undefined : methodMeaning(method);
 }
+/**
+ * The requirement one usage level places on a Class. A reference needs the Class to exist with
+ * its kind; inheritance additionally needs the source ancestors, class policies, data contract
+ * and, for an Edge, the endpoint contract. A target projected onto a source requirement keeps only
+ * the ancestors the source named, so a superset satisfies it while a removal changes it.
+ */
+function classMeaning(context, coordinate, onto) {
+    const owner = context.schemas.get(coordinate.ref.origin);
+    const declaration = owner?.classes[coordinate.ref.name];
+    const analysis = owner === undefined ? undefined : effectiveDefinition(context, owner, coordinate.ref);
+    if (owner === undefined || declaration === undefined || analysis === undefined)
+        return undefined;
+    const ancestors = ancestorKeys(context, coordinate.ref);
+    const requirement = Object.freeze({
+        ancestors,
+        properties: new Set(analysis.properties.keys()),
+    });
+    const meaning = {
+        kind: 'class',
+        level: coordinate.level,
+        classKind: declaration.kind,
+        ...(declaration.kind === 'edge' ? { orientation: declaration.orientation } : {}),
+        ...(coordinate.level === 'inherit'
+            ? {
+                ancestors: onto === undefined
+                    ? ancestors
+                    : onto.ancestors.filter((ancestor) => ancestors.includes(ancestor)),
+                policies: Object.fromEntries(Object.entries(declaration.policies)
+                    .filter(([, ref]) => ref !== undefined)
+                    .map(([role, ref]) => [role, keyForDefinitionRef(ref)])),
+                data: analysis.data === undefined
+                    ? null
+                    : {
+                        owner: keyForDefinitionRef(analysis.data.owner),
+                        declaration: analysis.data.declaration,
+                    },
+                ...(declaration.kind === 'edge' ? { endpoints: declaration.endpoints } : {}),
+            }
+            : {}),
+    };
+    return { meaning, requirement };
+}
+function ancestorKeys(context, ref) {
+    const seen = new Set();
+    const visit = (current) => {
+        const declaration = context.schemas.get(current.origin)?.classes[current.name];
+        if (declaration === undefined)
+            return;
+        for (const parent of declaration.extends) {
+            const key = keyForDefinitionRef(parent);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            visit(parent);
+        }
+    };
+    visit(ref);
+    return [...seen].sort(compareUnicode);
+}
 function memberMeaning(owner, ref) {
     if (ref.origin !== owner.origin)
         return undefined;
     switch (ref.kind) {
-        case 'class':
-            return definitionMeaning(owner, ref);
         case 'function': {
             const declaration = owner.functions[ref.name];
             return declaration === undefined
@@ -334,35 +480,8 @@ function memberMeaning(owner, ref) {
         }
     }
 }
-function definitionMeaning(owner, ref) {
-    const declaration = owner.classes[ref.name];
-    const effective = effectiveDefinition(owner, ref);
-    if (declaration === undefined || effective === undefined || ref.origin !== owner.origin)
-        return undefined;
-    return {
-        kind: ref.kind,
-        declaration: semanticDefinition(declaration),
-        effective: {
-            properties: [...effective.properties.keys()].sort(compareUnicode),
-            methods: [...effective.methods.values()]
-                .map((method) => MethodKey.of(method.owner, method.name))
-                .sort(compareUnicode),
-            ...(effective.data === undefined
-                ? {}
-                : {
-                    data: {
-                        owner: keyForDefinitionRef(effective.data.owner),
-                        declaration: effective.data.declaration,
-                    },
-                }),
-        },
-    };
-}
-function effectiveDefinition(owner, ref) {
-    const validation = validateDomainSchemaSemantics(owner, lookupForDomainClosure(owner));
-    if (validation.diagnostics.length > 0)
-        return undefined;
-    return validation.analysis.definitions.get(definitionRefIndex(ref));
+function effectiveDefinition(context, owner, ref) {
+    return context.analysis(owner)?.get(definitionRefIndex(ref));
 }
 function propertyMeaning(field) {
     return {
@@ -382,37 +501,17 @@ function methodMeaning(method) {
         declaration: semanticMethod(method.declaration),
     };
 }
-function semanticDefinition(declaration) {
-    const { description: _description, ...rest } = declaration;
-    const semantic = {
-        ...rest,
-        properties: Object.fromEntries(Object.entries(declaration.properties).map(([name, property]) => [
-            name,
-            {
-                ...property,
-                schema: semanticValueSchema(property.schema),
-            },
-        ])),
-    };
-    if ('methods' in declaration) {
-        semantic.methods = Object.fromEntries(Object.entries(declaration.methods).map(([name, method]) => [name, semanticMethod(method)]));
-    }
-    return semantic;
-}
 function semanticFunction(declaration) {
-    const { description: _description, ...rest } = declaration;
     return {
-        ...rest,
         input: semanticValueSchema(declaration.input),
         output: semanticOutput(declaration.output),
     };
 }
 function semanticMethod(declaration) {
-    const { description: _description, ...rest } = declaration;
     return {
-        ...rest,
-        input: semanticValueSchema(declaration.input),
-        output: semanticOutput(declaration.output),
+        static: declaration.static,
+        abstract: declaration.abstract,
+        ...semanticFunction(declaration),
     };
 }
 function semanticOutput(output) {
@@ -458,7 +557,7 @@ function semanticValueSchema(value) {
     }
     return semantic;
 }
-function coordinateForKey(source, input, index) {
+function coordinateForKey(context, source, input, index) {
     let key;
     try {
         key = Key(input);
@@ -474,72 +573,45 @@ function coordinateForKey(source, input, index) {
     if ((reference.member === 'property' || reference.member === 'method') &&
         reference.ownerKind === 'class' &&
         reference.ownerName !== undefined) {
-        const owner = definitionRefFor(source, reference.ownerKind, reference.ownerName);
-        if (owner === undefined) {
+        if (source.classes[reference.ownerName] === undefined) {
             return invalidMemberRoot(key, index, 'has no exact owning Definition');
         }
+        const owner = { origin: source.origin, kind: 'class', name: reference.ownerName };
         coordinate =
             reference.member === 'property'
                 ? propertyCoordinate(owner, reference.name)
                 : methodCoordinate(owner, reference.name);
     }
-    else if (reference.kind !== 'core') {
-        const member = memberRefFor(source, {
-            origin: source.origin,
-            kind: reference.kind,
-            name: reference.name,
-        });
-        if (member === undefined)
+    else if (reference.kind === 'class') {
+        if (source.classes[reference.name] === undefined) {
             return invalidMemberRoot(key, index, 'does not exist in the source');
-        coordinate = memberCoordinate(member);
+        }
+        // An explicit Class root compares its surface; it never infers an inheritance contract.
+        coordinate = classCoordinate({ origin: source.origin, kind: 'class', name: reference.name }, 'reference');
     }
     else {
         coordinate = memberCoordinate({
             origin: source.origin,
-            kind: 'core',
+            kind: reference.kind,
             name: reference.name,
         });
     }
-    if (meaningForCoordinate(source, coordinate) === undefined) {
+    if (meaningForCoordinate(context, coordinate) === undefined) {
         return invalidMemberRoot(key, index, 'does not exist in the source');
     }
     return coordinate;
 }
-function memberRefFor(source, ref) {
-    const name = ref.name;
-    const owner = definitionRefFor(source, ref.kind, name);
-    if (owner !== undefined)
-        return owner;
-    switch (ref.kind) {
-        case 'function':
-            return source.functions[name] === undefined
-                ? undefined
-                : { origin: source.origin, kind: 'function', name };
-        case 'policy':
-            return source.policies[name] === undefined
-                ? undefined
-                : { origin: source.origin, kind: 'policy', name };
-        case 'view':
-            return source.views[name] === undefined
-                ? undefined
-                : { origin: source.origin, kind: 'view', name };
-        default:
-            return undefined;
-    }
-}
-function definitionRefFor(source, namespace, name) {
-    if (namespace === 'class') {
-        return source.classes[name] === undefined
-            ? undefined
-            : { origin: source.origin, kind: 'class', name };
-    }
-    return undefined;
-}
 function invalidMemberRoot(key, index, reason) {
     throw new SchemaError([
         diagnostic('DM_MEMBER_ROOT_INVALID', `/roots/${index}`, `Member comparison root ${JSON.stringify(key)} ${reason}.`, typeof key === 'string' ? key : undefined),
     ]);
 }
+function levelOf(site) {
+    return site === 'extends' || site === 'core' ? 'inherit' : 'reference';
+}
+function classCoordinate(ref, level) {
+    return Object.freeze({ kind: 'class', key: keyForDefinitionRef(ref), ref, level });
+}
 function memberCoordinate(ref) {
     return Object.freeze({ kind: 'member', key: keyForDefinitionRef(ref), ref });
 }
@@ -585,21 +657,6 @@ function incidentCoreEdges(owner, name) {
 function fingerprintMeaning(value) {
     return digestDomainSchemaBytes(json.encode(value));
 }
-function isDefinitionRef(ref) {
-    return ref.kind === 'class';
-}
-function requireMemberRef(ref) {
-    switch (ref.kind) {
-        case 'class':
-        case 'function':
-        case 'policy':
-        case 'view':
-            return ref;
-        case 'core':
-            return ref;
-    }
-    return ref;
-}
 function isJsonSchema(value) {
     return typeof value === 'boolean' || isJsonObject(value);
 }

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

@@ -11,8 +11,8 @@ export type { SchemaDiagnosticCode as DiagnosticCode } from './diagnostic.js';
 export { acceptDomainSchema as accept } from './admission/accept.js';
 export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
-export { compareDependencyMeaning, compareMemberMeaning } from './compatibility/meaning.js';
-export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, MeaningFingerprint, } from './compatibility/meaning.js';
+export { callableFingerprint, compareDependencyMeaning, compareMemberMeaning, } from './compatibility/meaning.js';
+export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, DependencyMeaningLevel, MeaningFingerprint, } from './compatibility/meaning.js';
 export { header } from './codec/header.js';
 export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
 export { compile, load } from '../compiled/index.js';

package/dist/v1/schema/index.js

@@ -4,7 +4,7 @@ export const resolve = resolveDomainSchema;
 export { acceptDomainSchema as accept } from './admission/accept.js';
 export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
-export { compareDependencyMeaning, compareMemberMeaning } from './compatibility/meaning.js';
+export { callableFingerprint, compareDependencyMeaning, compareMemberMeaning, } from './compatibility/meaning.js';
 export { header } from './codec/header.js';
 export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
 export { compile, load } from '../compiled/index.js';

package/dist/v1/schema/resolution/origins.d.ts

@@ -4,11 +4,24 @@ import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { PolicyDefinition } from '../../language/policy/model/policy.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { DomainSchemaIR } from '../model/schema.js';
+/**
+ * Where one schema references a Definition. `extends` and `core` mean the schema inherits from or
+ * instantiates the Definition; every other site only refers to it.
+ */
+export type ReferenceSite = 'extends' | 'endpoint' | 'value' | 'policy' | 'view' | 'core';
+export type ReferenceCollector = (ref: DefinitionRef, site: ReferenceSite) => void;
 /** Collect only semantic refs, never strings or objects embedded as JSON data. */
 export declare function collectUsedForeignOrigins(schema: DomainSchemaIR): ReadonlySet<string>;
 /** Complete structured references in one schema, in canonical order. */
 export declare function collectDomainDefinitionRefs(schema: DomainSchemaIR): readonly DefinitionRef[];
-export declare function collectClassRefs(declaration: ClassDefinition, add: (ref: DefinitionRef) => void): void;
-export declare function collectCallableRefs(declaration: FunctionDefinition | MethodDefinition, add: (ref: DefinitionRef) => void): void;
-export declare function collectPolicyDefinitionRefs(declaration: PolicyDefinition, add: (ref: DefinitionRef) => void): void;
-export declare function collectValueDefinitionRefs(schema: JsonSchema, add: (ref: DefinitionRef) => void): void;
+export declare function collectCoreRefs(schema: DomainSchemaIR, add: ReferenceCollector): void;
+export declare function collectClassRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
+export declare function collectClassPolicyRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
+export declare function collectEndpointRefs(declaration: Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>, add: ReferenceCollector): void;
+export declare function collectCallableRefs(declaration: FunctionDefinition | MethodDefinition, add: ReferenceCollector): void;
+/** References inside the contract a caller compiles against: the input and output value schemas. */
+export declare function collectCallableContractRefs(declaration: Pick<FunctionDefinition | MethodDefinition, 'input' | 'output'>, add: ReferenceCollector): void;
+export declare function collectPolicyDefinitionRefs(declaration: PolicyDefinition, add: ReferenceCollector): void;
+export declare function collectValueDefinitionRefs(schema: JsonSchema, add: ReferenceCollector): void;

package/dist/v1/schema/resolution/origins.js

@@ -24,48 +24,59 @@ export function collectDomainDefinitionRefs(schema) {
         collectPolicyDefinitionRefs(declaration, add);
     }
     for (const declaration of Object.values(schema.views)) {
-        if (declaration.target.kind === 'definition')
-            declaration.target.definitions.forEach(add);
+        if (declaration.target.kind === 'definition') {
+            declaration.target.definitions.forEach((ref) => add(ref, 'view'));
+        }
     }
+    collectCoreRefs(schema, add);
+    return Object.freeze([...result.values()].sort(compareDefinitionRefs));
+}
+export function collectCoreRefs(schema, add) {
     for (const node of Object.values(schema.core.nodes))
-        add(node.class);
+        add(node.class, 'core');
     for (const edge of schema.core.edges) {
-        add(edge.class);
+        add(edge.class, 'core');
         if (edge.source.kind !== 'domain')
-            add(edge.source);
+            add(edge.source, 'core');
         if (edge.target.kind !== 'domain')
-            add(edge.target);
+            add(edge.target, 'core');
     }
-    return Object.freeze([...result.values()].sort(compareDefinitionRefs));
 }
 export function collectClassRefs(declaration, add) {
-    declaration.extends.forEach(add);
+    declaration.extends.forEach((ref) => add(ref, 'extends'));
     Object.values(declaration.properties).forEach((property) => collectValueDefinitionRefs(property.schema, add));
-    if (declaration.policies.read !== undefined)
-        add(declaration.policies.read);
-    if (declaration.policies.traverse !== undefined)
-        add(declaration.policies.traverse);
+    collectClassPolicyRefs(declaration, add);
     if (declaration.kind === 'edge') {
         collectEndpointRefs(declaration, add);
         return;
     }
     Object.values(declaration.methods).forEach((method) => collectCallableRefs(method, add));
 }
-function collectEndpointRefs(declaration, add) {
+export function collectClassPolicyRefs(declaration, add) {
+    if (declaration.policies.read !== undefined)
+        add(declaration.policies.read, 'policy');
+    if (declaration.policies.traverse !== undefined)
+        add(declaration.policies.traverse, 'policy');
+}
+export function collectEndpointRefs(declaration, add) {
     const endpoints = declaration.orientation === 'directed'
         ? [declaration.endpoints.source, declaration.endpoints.target]
         : declaration.endpoints;
-    endpoints[0].accepts.forEach(add);
-    endpoints[1].accepts.forEach(add);
+    endpoints[0].accepts.forEach((ref) => add(ref, 'endpoint'));
+    endpoints[1].accepts.forEach((ref) => add(ref, 'endpoint'));
 }
 export function collectCallableRefs(declaration, add) {
+    collectCallableContractRefs(declaration, add);
+    if (declaration.policy !== undefined)
+        collectPolicyCheckRefs(declaration.policy, add);
+}
+/** References inside the contract a caller compiles against: the input and output value schemas. */
+export function collectCallableContractRefs(declaration, add) {
     collectValueDefinitionRefs(declaration.input, add);
     if (declaration.output.mode === 'value')
         collectValueDefinitionRefs(declaration.output.schema, add);
     if (declaration.output.mode === 'stream')
         collectValueDefinitionRefs(declaration.output.item, add);
-    if (declaration.policy !== undefined)
-        collectPolicyCheckRefs(declaration.policy, add);
 }
 export function collectPolicyDefinitionRefs(declaration, add) {
     collectPolicyExpressionRefs(declaration.expression, add);
@@ -76,27 +87,27 @@ function collectPolicyExpressionRefs(expression, add) {
         return;
     }
     const refs = 'allOf' in expression ? expression.allOf : expression.anyOf;
-    refs.forEach(add);
+    refs.forEach((ref) => add(ref, 'policy'));
 }
 function collectPolicyPatternRefs(expression, add) {
     if ('sameNode' in expression) {
         for (const term of [expression.sameNode.left, expression.sameNode.right])
             if (term.kind === 'ref')
-                add(term.ref.kind === 'method' ? term.ref.owner : term.ref);
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
         return;
     }
     if ('source' in expression) {
         for (const term of [expression.source, expression.target])
             if (term.kind === 'ref')
-                add(term.ref.kind === 'method' ? term.ref.owner : term.ref);
-        add(expression.class);
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
+        add(expression.class, 'policy');
         return;
     }
     if ('exists' in expression) {
         expression.exists.nodes.forEach((node) => {
             const ref = policyVariableClass(node);
             if (ref !== undefined)
-                add(ref);
+                add(ref, 'policy');
         });
         collectPolicyPatternRefs(expression.exists.where, add);
         return;
@@ -108,15 +119,15 @@ function collectPolicyCheckRefs(expression, add) {
     if ('sameNode' in expression) {
         for (const term of [expression.sameNode.left, expression.sameNode.right])
             if (term.kind === 'ref')
-                add(term.ref.kind === 'method' ? term.ref.owner : term.ref);
+                add(term.ref.kind === 'method' ? term.ref.owner : term.ref, 'policy');
         return;
     }
     if ('check' in expression) {
-        add(expression.check);
+        add(expression.check, 'policy');
         if (expression.object.kind === 'ref')
             add(expression.object.ref.kind === 'method'
                 ? expression.object.ref.owner
-                : expression.object.ref);
+                : expression.object.ref, 'policy');
         return;
     }
     const children = 'allOf' in expression ? expression.allOf : expression.anyOf;
@@ -134,7 +145,7 @@ export function collectValueDefinitionRefs(schema, add) {
                 typeof candidate.origin === 'string' &&
                 typeof candidate.kind === 'string' &&
                 typeof candidate.name === 'string') {
-                add(candidate);
+                add(candidate, 'value');
             }
         }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.33",
+  "version": "0.2.0-beta.35",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {
@@ -105,7 +105,7 @@
     "generate:value-schema-validator": "node scripts/generate-value-schema-meta-validator.mjs",
     "layout:check": "node scripts/check-layout.mjs",
     "spec:typecheck": "tsgo --noEmit -p tsconfig.spec.json",
-    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.types.json",
+    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.types.json && tsgo -p tsconfig.workers.json",
     "test": "pnpm run conformance && pnpm run layout:check && vitest run",
     "test:file": "vitest run",
     "test:semantic-lock": "pnpm run conformance && pnpm run layout:check && vitest run",