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

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/context.d.ts

@@ -2,11 +2,15 @@ import type { ClassRef, DefinitionRef, Key as SemanticKey } from '../../addressi
 import type { DefinitionAnalysis, EffectiveMethod } from '../analysis/class.js';
 import type { DomainSchema } from '../model/schema.js';
 import { SchemaError } from '../diagnostic.js';
-/** One accepted root with its exact closure and a memoized semantic analysis per owner. */
+/** One accepted root with its exact closure and a memoized Definition analysis per owner. */
 export interface Context {
     readonly schemas: ReadonlyMap<string, DomainSchema>;
-    analysis(owner: DomainSchema): ReadonlyMap<string, DefinitionAnalysis> | undefined;
+    analysis(owner: DomainSchema): ReadonlyMap<string, DefinitionAnalysis>;
 }
+/**
+ * Every owner passed acceptance against the closure it retains, which is the only way a schema
+ * gets one, so its analysis is derived without validating it again.
+ */
 export declare function contextOf(root: DomainSchema): Context;
 export declare function effectiveDefinition(context: Context, owner: DomainSchema, ref: ClassRef): DefinitionAnalysis | undefined;
 /** Effective Methods are keyed by name; a coordinate names one by its exact Method Key. */

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

@@ -1,8 +1,13 @@
 import { MethodKey } from '../../addressing/index.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
+import { analyzeDefinitions } from '../analysis/class.js';
 import { SchemaError, diagnostic } from '../diagnostic.js';
 import { knownDomainClosure, lookupForDomainClosure } from '../resolution/closure.js';
-import { validateDomainSchemaSemantics } from '../validation/domain.js';
+import { buildDomainResolutionContext } from '../resolution/context.js';
+/**
+ * Every owner passed acceptance against the closure it retains, which is the only way a schema
+ * gets one, so its analysis is derived without validating it again.
+ */
 export function contextOf(root) {
     const schemas = new Map([
         [root.origin, root],
@@ -12,16 +17,17 @@ export function contextOf(root) {
     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);
+            let definitions = analyses.get(owner);
+            if (definitions === undefined) {
+                definitions = analyzeDefinitions(buildDomainResolutionContext(owner, lookupForDomainClosure(owner))).definitions;
+                analyses.set(owner, definitions);
             }
-            return analyses.get(owner);
+            return definitions;
         },
     };
 }
 export function effectiveDefinition(context, owner, ref) {
-    return context.analysis(owner)?.get(definitionRefIndex(ref));
+    return context.analysis(owner).get(definitionRefIndex(ref));
 }
 /** Effective Methods are keyed by name; a coordinate names one by its exact Method Key. */
 export function effectiveMethod(analysis, key) {

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/fields.d.ts

@@ -43,6 +43,7 @@ export declare const PROPERTY_FIELDS: Readonly<{
     schema: "always";
     required: "always";
     auto: "always";
+    immutable: "always";
     state: "always";
     description: Readonly<{
         excluded: 'annotation';
@@ -132,6 +133,7 @@ export declare const FIELD_ROLES: Readonly<{
         schema: "always";
         required: "always";
         auto: "always";
+        immutable: "always";
         state: "always";
         description: Readonly<{
             excluded: 'annotation';

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

@@ -22,6 +22,7 @@ export const PROPERTY_FIELDS = Object.freeze({
     schema: 'always',
     required: 'always',
     auto: 'always',
+    immutable: 'always',
     state: 'always',
     description: ANNOTATION,
 });

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/diagnostic.d.ts

@@ -1,4 +1,4 @@
-export type SchemaDiagnosticCode = 'DM_CAPABILITY_INVALID' | 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'DV_VIEW_TARGET' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
+export type SchemaDiagnosticCode = 'DM_CAPABILITY_INVALID' | 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_IMMUTABLE' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'DV_VIEW_TARGET' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
 export interface SchemaDiagnostic<out Code extends SchemaDiagnosticCode = SchemaDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;

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

@@ -142,6 +142,7 @@ function canonicalizeProperty(value) {
                     set: value.auto.set,
                 },
             }),
+        ...(value.immutable === undefined ? {} : { immutable: value.immutable }),
         ...(value.description === undefined ? {} : { description: value.description }),
         ...(value.state === undefined
             ? {}

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

@@ -1,4 +1,7 @@
 import type { SourceDomain } from '../../domain/model/domain.js';
 import type { DomainSchema } from '../model/schema.js';
-/** Resolve one accepted Schema through its exact retained source closure. */
+/**
+ * Resolve one accepted Schema through its exact retained source closure. Acceptance validated it
+ * against that closure, which is the only way a Schema retains one, so it is not validated again.
+ */
 export declare function resolve<const S extends DomainSchema>(schema: S): SourceDomain<S>;

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

@@ -9,12 +9,14 @@ import { validateValueProgram } from '../../language/value/evaluate/program.js';
 import { validateJsonInstance, validatePreparedInstance, } from '../../language/value/evaluate/validate.js';
 import { classifyPreparedOrdering } from '../../language/value/ordering.js';
 import { revisionOfDomainSchema } from '../canonical/revision.js';
-import { SchemaError } from '../diagnostic.js';
-import { validateDomainSchemaSemantics } from '../validation/domain.js';
 import { lookupForDomainClosure } from './closure.js';
+import { buildDomainResolutionContext } from './context.js';
 import { createDomainValueSchemaRegistry } from './value.registry.js';
 const resolvedSchemas = new WeakMap();
-/** Resolve one accepted Schema through its exact retained source closure. */
+/**
+ * Resolve one accepted Schema through its exact retained source closure. Acceptance validated it
+ * against that closure, which is the only way a Schema retains one, so it is not validated again.
+ */
 export function resolve(schema) {
     const cached = resolvedSchemas.get(schema);
     if (cached !== undefined)
@@ -24,10 +26,7 @@ export function resolve(schema) {
     return resolved;
 }
 function resolveWithLookup(schema, lookup) {
-    const validation = validateDomainSchemaSemantics(schema, lookup);
-    if (validation.diagnostics.length > 0)
-        throw new SchemaError(validation.diagnostics);
-    const closure = [schema, ...validation.context.dependencies.values()];
+    const closure = [schema, ...buildDomainResolutionContext(schema, lookup).dependencies.values()];
     const registries = new Map(closure.map((owner) => [owner.origin, createDomainValueSchemaRegistry(owner, lookup)]));
     const input = {
         root: Object.freeze({
@@ -66,6 +65,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')