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

package/dist/v1/schema/compatibility/comparators/classes.js

@@ -49,6 +49,30 @@ export function classMeaning(context, coordinate, level, onto) {
     };
     return { meaning: deepFreeze(meaning), requirement };
 }
+/**
+ * What a Policy pattern reads of an Edge it matches: its orientation and the Classes each endpoint
+ * accepts, without cardinalities or roles. Undirected endpoints form an unordered pair.
+ */
+export function edgeEndpoints(context, coordinate) {
+    const declaration = context.schemas.get(coordinate.ref.origin)?.classes[coordinate.ref.name];
+    if (declaration?.kind !== 'edge')
+        return undefined;
+    const accepts = ({ accepts: refs }) => refs.map(keyForDefinitionRef).sort(compareUnicode);
+    return deepFreeze(declaration.orientation === 'directed'
+        ? {
+            coordinate: 'class',
+            orientation: 'directed',
+            source: accepts(declaration.endpoints.source),
+            target: accepts(declaration.endpoints.target),
+        }
+        : {
+            coordinate: 'class',
+            orientation: 'undirected',
+            endpoints: declaration.endpoints
+                .map(accepts)
+                .sort((left, right) => compareUnicode(left.join('\n'), right.join('\n'))),
+        });
+}
 export function propertyMeaning(field) {
     return deepFreeze({
         coordinate: 'property',
@@ -75,6 +99,36 @@ function ancestorKeys(context, ref) {
     visit(ref);
     return [...seen].sort(compareUnicode);
 }
+/**
+ * A Class a dependent references or inherits keeps every effective Property it had, whichever
+ * ancestor declares it. Each Property is compared on its owner, which still declares it when the
+ * Class stops extending that owner, and is not compared at all when another origin owns it: only the
+ * Class's own identity set shows those losses. Every loss is recorded, a Property its owner removed
+ * included, and only a loss is: a comparison that keeps every identity keeps its facts and evidence
+ * bytes, and an added ancestor or Property obliges nothing. The target is projected onto the source
+ * identities, as inherited ancestry is, so the differences name the lost Properties.
+ */
+export function compareLostProperties({ pair, report, }) {
+    if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')
+        return;
+    const kept = pair.target.analysis.properties;
+    const identities = [...pair.source.analysis.properties.keys()].sort(compareUnicode);
+    if (identities.every((identity) => kept.has(identity)))
+        return;
+    report.record({
+        pair,
+        facet: 'class.properties',
+        before: propertyIdentities(identities),
+        after: propertyIdentities(identities.filter((identity) => kept.has(identity))),
+        requirement: { kind: 'class.properties' },
+    });
+}
+function propertyIdentities(identities) {
+    return deepFreeze({
+        coordinate: 'class',
+        properties: Object.fromEntries(identities.map((identity) => [identity, true])),
+    });
+}
 /** Newly required data is an obligation even though it was absent from the source footprint. */
 export function compareAddedProperties({ context, pair, report, }) {
     if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')

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

@@ -5,7 +5,7 @@ import type { ComparisonContext, SubjectPair } from '../scope.js';
 export declare function compareFacet({ context, pair, facet, }: {
     readonly context: ComparisonContext;
     readonly pair: SubjectPair;
-    readonly facet: Exclude<Facet, 'class.composition' | 'property.required'>;
+    readonly facet: Exclude<Facet, 'class.composition' | 'class.properties' | 'property.required'>;
 }): {
     readonly before?: Value;
     readonly after?: Value;

package/dist/v1/schema/compatibility/comparators/index.js

@@ -1,5 +1,5 @@
-import { methodInheritance, functionSignature, functionExistence, methodSignature, methodExistence, } from './callables.js';
-import { classMeaning, propertyMeaning } from './classes.js';
+import { methodInheritance, functionSignature, functionExistence, methodObject, methodSignature, methodExistence, } from './callables.js';
+import { classMeaning, edgeEndpoints, propertyMeaning } from './classes.js';
 import { memberMeaning } from './members.js';
 /** Shared facet comparisons know declarations, never installation or an analysis mode. */
 export function compareFacet({ context, pair, facet, }) {
@@ -11,6 +11,14 @@ export function compareFacet({ context, pair, facet, }) {
         const after = classMeaning(context.after, pair.coordinate, level, before?.requirement);
         return { before: before?.meaning, after: after?.meaning };
     }
+    if (facet === 'class.endpoints') {
+        if (pair.coordinate.kind !== 'class')
+            throw new TypeError('Class facet requires a Class coordinate.');
+        return {
+            before: edgeEndpoints(context.before, pair.coordinate),
+            after: edgeEndpoints(context.after, pair.coordinate),
+        };
+    }
     const value = (subject) => {
         if (subject === undefined)
             return undefined;
@@ -19,6 +27,10 @@ export function compareFacet({ context, pair, facet, }) {
                 return subject.kind === 'property' ? propertyMeaning(subject.field) : undefined;
             case 'method.existence':
                 return subject.kind === 'method' ? methodExistence(subject.method) : undefined;
+            case 'method.object':
+                return subject.kind === 'method'
+                    ? methodObject(subject.method, subject.schema.classes[subject.method.owner.name])
+                    : undefined;
             case 'method.signature':
                 return subject.kind === 'method' ? methodSignature(subject.method) : undefined;
             case 'method.inheritance':

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

@@ -1,9 +1,16 @@
 import type { Analysis, ComparisonEvidence } from './model.js';
 /**
  * Only semantic facts and decisions are durable; provenance and diagnostic prose are not. Each
- * analysis names the version of the requirement policy its facts were assessed under.
+ * analysis names the oldest requirement policy that yields its facts: a version applies exactly when
+ * a fact it introduced is recorded, so a comparison without one keeps the earlier version's bytes.
  */
 export declare function evidenceOf({ kind, version, scope, entries, assessments, }: Omit<Analysis, 'evidence'> & {
     readonly kind: ComparisonEvidence['kind'];
     readonly version: ComparisonEvidence['version'];
 }): ComparisonEvidence;
+/**
+ * Whether a referenced or inherited Class lost an effective Property. The fact is recorded only on a
+ * loss, so the evidence version that introduced it applies exactly when it is present
+ * (DM-CLASS-PROPERTIES).
+ */
+export declare function losesProperties({ entries }: Pick<Analysis, 'entries'>): boolean;

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

@@ -2,7 +2,8 @@ import { compareUnicode } from '../../addressing/ordering.js';
 import { fingerprintMeaning } from './comparators/values.js';
 /**
  * Only semantic facts and decisions are durable; provenance and diagnostic prose are not. Each
- * analysis names the version of the requirement policy its facts were assessed under.
+ * analysis names the oldest requirement policy that yields its facts: a version applies exactly when
+ * a fact it introduced is recorded, so a comparison without one keeps the earlier version's bytes.
  */
 export function evidenceOf({ kind, version, scope, entries, assessments, }) {
     return Object.freeze({
@@ -38,6 +39,14 @@ export function evidenceOf({ kind, version, scope, entries, assessments, }) {
         }),
     });
 }
+/**
+ * Whether a referenced or inherited Class lost an effective Property. The fact is recorded only on a
+ * loss, so the evidence version that introduced it applies exactly when it is present
+ * (DM-CLASS-PROPERTIES).
+ */
+export function losesProperties({ entries }) {
+    return entries.some(({ observations }) => observations.some(({ facet }) => facet === 'class.properties'));
+}
 /** Version-1 evidence keeps its original tags independently of public facet names. */
 function evidenceFacet(facet) {
     switch (facet) {

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

@@ -1,5 +1,5 @@
 import { Key } from '../../../addressing/index.js';
-import { compareAddedProperties } from '../comparators/classes.js';
+import { compareAddedProperties, compareLostProperties } from '../comparators/classes.js';
 import { compareFacet } from '../comparators/index.js';
 import { contextInvalid } from '../context.js';
 import { callableReferences, classReferences, inherits, memberReferences, valueReferences, } from '../references.js';
@@ -53,5 +53,7 @@ export function compareFootprint({ context, report, }) {
         });
         if (facet === 'class.inherit')
             compareAddedProperties({ context, pair, report });
+        if (subject.kind === 'class')
+            compareLostProperties({ pair, report });
     }
 }

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

@@ -1,4 +1,4 @@
-import { evidenceOf } from '../evidence.js';
+import { evidenceOf, losesProperties } from '../evidence.js';
 import { createReport } from '../report.js';
 import { compareFootprint } from './footprint.js';
 export function analyzeMeaning(context) {
@@ -9,6 +9,8 @@ export function analyzeMeaning(context) {
         kind: 'meaning',
         ...result,
         equivalent: result.assessments.every(({ satisfied }) => satisfied),
-        evidence: evidenceOf({ kind: 'meaning', version: 1, ...result }),
+        // Version 2 adds a referenced or inherited Class that lost an effective Property; without it,
+        // version 1.
+        evidence: evidenceOf({ kind: 'meaning', version: losesProperties(result) ? 2 : 1, ...result }),
     });
 }

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

@@ -46,7 +46,7 @@ export interface Usage {
     readonly key?: Key;
     readonly relation: ReferenceSite | 'member' | 'abstract' | 'selection' | 'capability';
 }
-export type Facet = 'class.reference' | 'class.inherit' | 'class.composition' | 'property' | 'property.required' | 'method.existence' | 'method.inheritance' | 'method.signature' | 'function.existence' | 'function.signature' | 'policy' | 'view' | 'core';
+export type Facet = 'class.reference' | 'class.inherit' | 'class.composition' | 'class.properties' | 'class.endpoints' | 'property' | 'property.required' | 'method.existence' | 'method.object' | 'method.inheritance' | 'method.signature' | 'function.existence' | 'function.signature' | 'policy' | 'view' | 'core';
 /** A fact about a compared facet, including unchanged facets. No admission decision is implied. */
 export interface Observation {
     readonly id: string;
@@ -74,14 +74,19 @@ export interface Assessment {
 }
 /**
  * Evidence is a semantic projection; presentation/provenance never enters its digest. Versions are
- * per kind. Meaning is version 1. Structure is version 2, or version 3 when declared capabilities
- * are among its roots, so a comparison without them keeps the version-2 bytes. Capability Keys join
- * the root Key set of both digests: one that is not already a root changes the meaning fingerprint,
- * never its version, and meaning evidence never records whether capabilities were declared.
+ * per kind, and a comparison names the oldest policy that yields its facts. Meaning is version 1.
+ * Structure is version 2, or version 3 when declared capabilities are among its roots, so a
+ * comparison without them keeps the version-2 bytes. Capability Keys join the root Key set of both
+ * digests: one that is not already a root changes the meaning fingerprint, never its version, and
+ * meaning evidence never records whether capabilities were declared. A referenced or inherited Class
+ * that loses an effective Property (`class.properties`) raises structure to version 4 and meaning to
+ * version 2, and structure is version 4 too when it records that a dependent Policy lost what it
+ * relies on (`method.object`, `class.endpoints`). Those facts are recorded only on such a loss, so
+ * every other comparison, every compatible one included, keeps its bytes.
  */
 export interface ComparisonEvidence {
     readonly kind: 'structure' | 'meaning';
-    readonly version: 1 | 2 | 3;
+    readonly version: 1 | 2 | 3 | 4;
     readonly fingerprint: Fingerprint;
 }
 export interface Analysis {

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

@@ -1,8 +1,8 @@
-import type { Key } from '../../addressing/index.js';
 import type { DomainSchema } from '../model/schema.js';
 import type { Coordinate } from './coordinate.js';
 import type { Usage } from './model.js';
 import type { ResolvedSubject } from './subjects.js';
+import { Key } from '../../addressing/index.js';
 export interface Reference {
     readonly coordinate: Coordinate;
     readonly usage: Usage;
@@ -14,6 +14,13 @@ export declare function schemaIdentity(schema: DomainSchema): Readonly<{
 export declare function usageOf(schema: DomainSchema, relation: Usage['relation'], key?: Key): Usage;
 /** References keep their declaring member and relation; no strongest-usage collapse happens here. */
 export declare function rootReferences(schema: DomainSchema): readonly Reference[];
+/**
+ * What the dependent's own Policies rely on in one origin beyond naming a Definition: each Method a
+ * Policy object term names, which the Policy resolves as its owner's own executable declaration, and
+ * each Edge Class a Policy pattern matches, whose orientation and accepted endpoint Classes Policy
+ * typing reads. Policies the dependent reaches in a dependency are that dependency's own.
+ */
+export declare function policyReliance(schema: DomainSchema, origin: Key.Origin): readonly Reference[];
 /** Existing DSL collectors own reference syntax. These functions attach comparison provenance. */
 export declare function valueReferences(subject: Extract<ResolvedSubject, {
     kind: 'property';

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

@@ -1,3 +1,4 @@
+import { Key } from '../../addressing/index.js';
 import { revisionOfDomainSchema } from '../canonical/revision.js';
 import { collectCallableContractRefs, collectCallableRefs, collectClassPolicyRefs, collectCoreRefs, collectEndpointRefs, collectPolicyDefinitionRefs, collectValueDefinitionRefs, coreEndpointDefinitionRef, } from '../resolution/origins.js';
 import { classCoordinate, keyForDefinitionRef, memberCoordinate, methodCoordinate, propertyCoordinate, } from './coordinate.js';
@@ -11,13 +12,17 @@ export function usageOf(schema, relation, key) {
         ...(key === undefined ? {} : { key }),
     });
 }
+/** A Method a Policy names stays a reference to its owner Class; `policyReliance` keeps the Method. */
 function collector(schema, result, key) {
-    return (ref, relation) => result.push({
-        coordinate: ref.kind === 'class'
-            ? classCoordinate(ref)
-            : memberCoordinate(ref),
-        usage: usageOf(schema, relation, key),
-    });
+    return (ref, relation) => {
+        const definition = ref.kind === 'method' ? ref.owner : ref;
+        result.push({
+            coordinate: definition.kind === 'class'
+                ? classCoordinate(definition)
+                : memberCoordinate(definition),
+            usage: usageOf(schema, relation, key),
+        });
+    };
 }
 /** References keep their declaring member and relation; no strongest-usage collapse happens here. */
 export function rootReferences(schema) {
@@ -49,6 +54,34 @@ export function rootReferences(schema) {
     collectCoreRefs(schema, collector(schema, result));
     return result;
 }
+/**
+ * What the dependent's own Policies rely on in one origin beyond naming a Definition: each Method a
+ * Policy object term names, which the Policy resolves as its owner's own executable declaration, and
+ * each Edge Class a Policy pattern matches, whose orientation and accepted endpoint Classes Policy
+ * typing reads. Policies the dependent reaches in a dependency are that dependency's own.
+ */
+export function policyReliance(schema, origin) {
+    const result = new Map();
+    const collect = (key) => (ref, site) => {
+        const coordinate = ref.kind === 'method'
+            ? methodCoordinate(ref.owner, ref.name)
+            : site === 'pattern'
+                ? classCoordinate(ref)
+                : undefined;
+        if (coordinate === undefined || Key.origin(coordinate.key) !== origin)
+            return;
+        result.set(`${coordinate.key}:${site}`, { coordinate, usage: usageOf(schema, site, key) });
+    };
+    for (const declaration of Object.values(schema.classes))
+        if (declaration.kind === 'node')
+            for (const [name, method] of Object.entries(declaration.methods))
+                collectCallableRefs(method, collect(methodCoordinate(declaration.ref, name).key));
+    for (const declaration of Object.values(schema.functions))
+        collectCallableRefs(declaration, collect(keyForDefinitionRef(declaration.ref)));
+    for (const declaration of Object.values(schema.policies))
+        collectPolicyDefinitionRefs(declaration, collect(keyForDefinitionRef(declaration.ref)));
+    return [...result.values()];
+}
 /** Existing DSL collectors own reference syntax. These functions attach comparison provenance. */
 export function valueReferences(subject) {
     const result = [];

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

@@ -20,6 +20,11 @@ export interface ComparisonContext {
     readonly roots: readonly Reference[];
     /** Roots the dependent declares as capabilities on the compared origin; also in `roots`. */
     readonly capabilities: readonly Reference[];
+    /**
+     * What the dependent's own Policies rely on in the compared origin (`policyReliance`). Not roots:
+     * structure records them only when they fail, so a compatible comparison keeps its bytes.
+     */
+    readonly reliance: readonly Reference[];
     pair(coordinate: Coordinate): SubjectPair;
 }
 export declare function prepare(request: ComparisonRequest): ComparisonContext;

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

@@ -3,7 +3,7 @@ import { SchemaError, diagnostic } from '../diagnostic.js';
 import { knownDomainClosure } from '../resolution/closure.js';
 import { resolve } from '../resolution/domain.js';
 import { contextOf } from './context.js';
-import { rootReferences, schemaIdentity, usageOf } from './references.js';
+import { policyReliance, rootReferences, schemaIdentity, usageOf } from './references.js';
 import { capabilityCoordinates, coordinateForKey, resolveSubject } from './subjects.js';
 export function prepare(request) {
     const { scope, target } = request;
@@ -41,6 +41,7 @@ export function prepare(request) {
         before,
         roots: [...rootReferences(dependent), ...capabilities],
         capabilities,
+        reliance: policyReliance(dependent, source.origin),
     });
 }
 /**
@@ -61,9 +62,10 @@ export function selectMembers(source, target, keys) {
             usage: usageOf(source, 'selection', key),
         })),
         capabilities: [],
+        reliance: [],
     });
 }
-function comparisonContext({ kind, source, target, dependent, before, roots, capabilities, }) {
+function comparisonContext({ kind, source, target, dependent, before, roots, capabilities, reliance, }) {
     resolve(target);
     const after = contextOf(target);
     const pairs = new Map();
@@ -75,6 +77,7 @@ function comparisonContext({ kind, source, target, dependent, before, roots, cap
         after,
         roots,
         capabilities,
+        reliance,
         scope: Object.freeze({
             kind,
             source: schemaIdentity(source),

package/dist/v1/schema/compatibility/structure/index.js

@@ -11,11 +11,30 @@ export function analyzeStructure(context) {
         kind: 'structure',
         ...result,
         compatible: result.assessments.every(({ satisfied }) => satisfied),
-        // Version 3 adds declared capability roots; without one, evidence keeps its version-2 bytes.
+        // Each version adds one requirement policy and applies only when its fact is present: 3 a
+        // declared capability root, 4 a lost effective Property of a reached Class or a failed Policy
+        // reliance, facts recorded only when they fail. Without one, evidence keeps its version-2 bytes.
         evidence: evidenceOf({
             kind: 'structure',
-            version: context.capabilities.length > 0 ? 3 : 2,
+            version: recordsFailureOnlyFact(result.assessments)
+                ? 4
+                : context.capabilities.length > 0
+                    ? 3
+                    : 2,
             ...result,
         }),
     });
 }
+/**
+ * The facts structure records only when they fail: a referenced or inherited Class that lost an
+ * effective Property, and what a dependent Policy relies on (a Method object, a matched Edge's
+ * endpoints).
+ */
+const FAILURE_ONLY_FACETS = new Set([
+    'class.properties',
+    'method.object',
+    'class.endpoints',
+]);
+function recordsFailureOnlyFact(assessments) {
+    return assessments.some(({ requirement }) => FAILURE_ONLY_FACETS.has(requirement.kind));
+}

package/dist/v1/schema/compatibility/structure/requirements.js

@@ -1,6 +1,7 @@
 import { Key } from '../../../addressing/index.js';
-import { compareAddedProperties } from '../comparators/classes.js';
+import { compareAddedProperties, compareLostProperties } from '../comparators/classes.js';
 import { compareFacet } from '../comparators/index.js';
+import { fingerprintMeaning } from '../comparators/values.js';
 import { contextInvalid } from '../context.js';
 import { methodCoordinate } from '../coordinate.js';
 import { callableReferences, classReferences, inherits, memberReferences, usageOf, valueReferences, } from '../references.js';
@@ -68,5 +69,29 @@ export function compareRequirements({ context, report, }) {
         });
         if (facet === 'class.inherit')
             compareAddedProperties({ context, pair, report });
+        if (subject.kind === 'class')
+            compareLostProperties({ pair, report });
+    }
+    compareReliance({ context, report });
+}
+/**
+ * What a dependent Policy relies on is recorded only when it fails: a Method it names that is gone
+ * or no longer executable by its owner, or an Edge it matches whose orientation or accepted endpoint
+ * Classes changed. A held reliance adds no fact, so a compatible comparison keeps its evidence bytes
+ * and no coordinate minted from it moves; a failed one is a refusal, from which none is minted.
+ */
+function compareReliance({ context, report, }) {
+    for (const reference of context.reliance) {
+        const pair = context.pair(reference.coordinate);
+        if (pair.source === undefined)
+            throw contextInvalid(`Retained acceptance context has no meaning for ${reference.coordinate.key}.`, reference.coordinate.key);
+        const facet = reference.coordinate.kind === 'method' ? 'method.object' : 'class.endpoints';
+        const { before, after } = compareFacet({ context, pair, facet });
+        if (before !== undefined &&
+            after !== undefined &&
+            fingerprintMeaning(before) === fingerprintMeaning(after))
+            continue;
+        report.note(reference);
+        report.record({ pair, facet, before, after, requirement: { kind: facet } });
     }
 }

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

@@ -115,11 +115,29 @@ function capabilityCoordinate(source, key) {
 }
 function invalidCapability(key, index, reason) {
     throw new SchemaError([
-        diagnostic('DM_CAPABILITY_INVALID', `/capabilities/${index}`, `Capability ${JSON.stringify(key)} ${reason}.`, typeof key === 'string' ? key : undefined),
+        diagnostic('DM_CAPABILITY_INVALID', `/capabilities/${index}`, `Capability ${shown(key)} ${reason}.`, typeof key === 'string' ? key : undefined),
     ]);
 }
 function invalidMemberRoot(key, index, reason) {
     throw new SchemaError([
-        diagnostic('DM_MEMBER_ROOT_INVALID', `/roots/${index}`, `Key ${JSON.stringify(key)} ${reason}.`, typeof key === 'string' ? key : undefined),
+        diagnostic('DM_MEMBER_ROOT_INVALID', `/roots/${index}`, `Key ${shown(key)} ${reason}.`, typeof key === 'string' ? key : undefined),
     ]);
 }
+/**
+ * A caller-supplied item as diagnostic text. Formatting never throws, so the caller always gets the
+ * diagnostic: a bigint is shown as its literal, and another item JSON cannot encode, such as a cyclic
+ * object, is named by its type.
+ */
+function shown(item) {
+    if (typeof item === 'bigint')
+        return `${item}n`;
+    try {
+        const text = JSON.stringify(item);
+        if (text !== undefined)
+            return text;
+    }
+    catch {
+        // Not encodable as JSON: named by its type below.
+    }
+    return `<${typeof item}>`;
+}

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

@@ -66,6 +66,7 @@ function sourceValidation(closure, registries) {
                 properties.set(PropertyKey.of(definition.ref, name), Object.freeze({
                     ordering: classifyPreparedOrdering(prepared.value),
                     validate: (input) => validatePreparedInstance(prepared.value, input),
+                    program: () => prepared.value.program(),
                 }));
             }
             if (definition.kind !== 'node')

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

@@ -1,4 +1,4 @@
-import type { DefinitionRef } from '../../addressing/index.js';
+import type { DefinitionRef, MethodAddress } from '../../addressing/index.js';
 import type { FunctionDefinition, MethodDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { CoreEndpointRef } from '../../language/core/model/core.js';
@@ -7,10 +7,17 @@ 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.
+ * instantiates the Definition; every other site only refers to it. `pattern` is the Edge Class a
+ * Policy pattern matches, whose orientation and accepted endpoint Classes Policy typing reads.
  */
-export type ReferenceSite = 'extends' | 'endpoint' | 'value' | 'policy' | 'view' | 'core';
-export type ReferenceCollector = (ref: DefinitionRef, site: ReferenceSite) => void;
+export type ReferenceSite = 'extends' | 'endpoint' | 'value' | 'policy' | 'pattern' | 'view' | 'core';
+/**
+ * What a site names: a Definition, or the Class-owned Method a Policy object term names. A Policy
+ * keeps the Method itself, since it resolves that Method's own executable declaration; a collector
+ * that needs Definitions only takes its owner Class.
+ */
+export type ReferencedDefinition = DefinitionRef | MethodAddress;
+export type ReferenceCollector = (ref: ReferencedDefinition, 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. */

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

@@ -13,7 +13,8 @@ export function collectUsedForeignOrigins(schema) {
 export function collectDomainDefinitionRefs(schema) {
     const result = new Map();
     const add = (ref) => {
-        result.set(definitionRefIndex(ref), ref);
+        const definition = ref.kind === 'method' ? ref.owner : ref;
+        result.set(definitionRefIndex(definition), definition);
     };
     for (const declaration of Object.values(schema.classes)) {
         collectClassRefs(declaration, add);
@@ -102,14 +103,14 @@ 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, 'policy');
+                add(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, 'policy');
-        add(expression.class, 'policy');
+                add(term.ref, 'policy');
+        add(expression.class, 'pattern');
         return;
     }
     if ('exists' in expression) {
@@ -128,15 +129,13 @@ 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, 'policy');
+                add(term.ref, 'policy');
         return;
     }
     if ('check' in expression) {
         add(expression.check, 'policy');
         if (expression.object.kind === 'ref')
-            add(expression.object.ref.kind === 'method'
-                ? expression.object.ref.owner
-                : expression.object.ref, 'policy');
+            add(expression.object.ref, 'policy');
         return;
     }
     const children = 'allOf' in expression ? expression.allOf : expression.anyOf;

package/dist/v1/schema/validation/class.d.ts

@@ -1,5 +1,15 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { DefinitionAnalysisResult } from '../analysis/class.js';
 import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
 /** Validate the semantic contracts owned by Class declarations. */
 export declare function validateDefinitions(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult): readonly SchemaDiagnostic[];
+/** Whether `child` safely refines its parent Edge contract `parent`. */
+export declare function edgeContractRefines(environment: DomainResolutionContext, child: Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>, parent: Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>): boolean;
+/** Whether `candidate` is, or is a Node Class extending, one of `accepts`. */
+export declare function classSatisfies(environment: DomainResolutionContext, candidate: ClassRef, accepts: readonly ClassRef[]): boolean;

package/dist/v1/schema/validation/class.js

@@ -149,7 +149,8 @@ function validateEdgeClassComposition(environment, diagnostics) {
         }
     }
 }
-function edgeContractRefines(environment, child, parent) {
+/** Whether `child` safely refines its parent Edge contract `parent`. */
+export function edgeContractRefines(environment, child, parent) {
     if (child.orientation !== parent.orientation)
         return false;
     if (parent.constraints.noSelf === true && child.constraints.noSelf !== true)
@@ -207,7 +208,8 @@ function undirectedEndpointsOverlap(environment, endpoints) {
     }
     return false;
 }
-function classSatisfies(environment, candidate, accepts) {
+/** Whether `candidate` is, or is a Node Class extending, one of `accepts`. */
+export function classSatisfies(environment, candidate, accepts) {
     if (accepts.some((ref) => definitionRefIndex(ref) === definitionRefIndex(candidate)))
         return true;
     const resolved = environment.resolveAny(candidate);

package/dist/v1/schema/validation/policy/budgets.js

@@ -3,8 +3,14 @@ import { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_D
 import { escapePointer } from './context.js';
 export { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, };
 export function validatePolicyBudgets(context) {
+    // Measure every distinct composition node once. A node's expanded measure is independent of the
+    // path that reaches it (the only path-sensitive outcome, the back-edge `undefined`, already holds
+    // for every node on or reaching a composition cycle, regardless of entry), so caching the
+    // completed result by node identity turns path enumeration over the composition DAG into work
+    // linear in the number of nodes while preserving the exact measure and PL_BUDGET decision.
+    const measures = new Map();
     for (const name of Object.keys(context.environment.candidate.policies)) {
-        const measure = measurePolicy(context, name, new Set());
+        const measure = measurePolicy(context, name, new Set(), measures);
         if (measure === undefined)
             continue;
         const pointer = `/policies/${escapePointer(name)}`;
@@ -23,14 +29,21 @@ export function validatePolicyBudgets(context) {
         }
     }
 }
-function measurePolicy(context, name, visiting) {
+function measurePolicy(context, name, visiting, measures) {
     if (visiting.has(name))
         return undefined;
+    if (measures.has(name))
+        return measures.get(name);
     const declaration = context.normalized.get(name);
     if (declaration === undefined)
         return undefined;
     const nested = new Set(visiting);
     nested.add(name);
+    const measure = measureDeclaration(context, declaration, nested, measures);
+    measures.set(name, measure);
+    return measure;
+}
+function measureDeclaration(context, declaration, nested, measures) {
     if ('match' in declaration) {
         return measurePattern(declaration.match, context.environment.candidate.origin);
     }
@@ -38,7 +51,7 @@ function measurePolicy(context, name, visiting) {
     const children = refs.flatMap((ref) => {
         if (!context.isLocalPolicy(ref))
             return [];
-        const value = measurePolicy(context, ref.name, nested);
+        const value = measurePolicy(context, ref.name, nested, measures);
         return value === undefined ? [] : [value];
     });
     if (children.length !== refs.length || children.length === 0)