@astrale-os/kernel-dsl 0.2.0-beta.38 → 0.2.0-beta.39

package/dist/v1/schema/compatibility/structure/requirements.d.ts

@@ -0,0 +1,7 @@
+import type { Report } from '../report.js';
+import type { ComparisonContext } from '../scope.js';
+/** Structure follows data and abstract obligations; concrete IO never expands its requirements. */
+export declare function compareRequirements({ context, report, }: {
+    readonly context: ComparisonContext;
+    readonly report: Report;
+}): void;

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

@@ -0,0 +1,70 @@
+import { Key } from '../../../addressing/index.js';
+import { compareAddedProperties } from '../comparators/classes.js';
+import { compareFacet } from '../comparators/index.js';
+import { contextInvalid } from '../context.js';
+import { methodCoordinate } from '../coordinate.js';
+import { callableReferences, classReferences, inherits, memberReferences, usageOf, valueReferences, } from '../references.js';
+/** Structure follows data and abstract obligations; concrete IO never expands its requirements. */
+export function compareRequirements({ context, report, }) {
+    const queue = [...context.roots];
+    const visited = new Set();
+    for (const reference of queue) {
+        report.note(reference);
+        const { coordinate, usage } = reference;
+        const visit = `${coordinate.key}:${usage.relation}`;
+        if (visited.has(visit))
+            continue;
+        visited.add(visit);
+        const pair = context.pair(coordinate);
+        const subject = pair.source;
+        if (subject === undefined)
+            throw contextInvalid(`Retained acceptance context has no meaning for ${coordinate.key}.`, coordinate.key);
+        let facet;
+        switch (subject.kind) {
+            case 'class': {
+                facet = inherits(usage) ? 'class.inherit' : 'class.reference';
+                queue.push(...classReferences(subject, false));
+                if (inherits(usage)) {
+                    queue.push(...classReferences(subject, true));
+                    for (const method of subject.analysis.requirements.values())
+                        queue.push({
+                            coordinate: methodCoordinate(method.owner, method.name),
+                            usage: usageOf(subject.schema, 'abstract', coordinate.key),
+                        });
+                }
+                break;
+            }
+            case 'property':
+                facet = 'property';
+                queue.push(...valueReferences(subject));
+                break;
+            case 'method': {
+                facet = usage.relation === 'abstract' ? 'method.inheritance' : 'method.existence';
+                if (facet === 'method.inheritance')
+                    queue.push(...callableReferences(subject));
+                break;
+            }
+            case 'member': {
+                facet =
+                    subject.coordinate.ref.kind === 'function'
+                        ? 'function.existence'
+                        : subject.coordinate.ref.kind;
+                if (facet !== 'function.existence')
+                    queue.push(...memberReferences(subject));
+            }
+        }
+        if (Key.origin(coordinate.key) !== context.source.origin)
+            continue;
+        // Class membership does not establish an invocation dependency. Explicit member selection
+        // and inherited abstract obligations do establish requirements; call tracking can add others.
+        const required = facet !== 'method.existence' || usage.relation === 'selection';
+        report.record({
+            pair,
+            facet,
+            ...compareFacet({ context, pair, facet }),
+            ...(required ? { requirement: { kind: facet } } : {}),
+        });
+        if (facet === 'class.inherit')
+            compareAddedProperties({ context, pair, report });
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { Key as SemanticKey } from '../../addressing/index.js';
+import type { DefinitionAnalysis, EffectiveField, EffectiveMethod } from '../analysis/class.js';
+import type { DomainSchema } from '../model/schema.js';
+import type { Context } from './context.js';
+import type { ClassCoordinate, Coordinate, MemberCoordinate, MethodCoordinate, PropertyCoordinate } from './coordinate.js';
+import type { Subject } from './model.js';
+export type ResolvedSubject = {
+    readonly kind: 'class';
+    readonly coordinate: ClassCoordinate;
+    readonly schema: DomainSchema;
+    readonly analysis: DefinitionAnalysis;
+} | {
+    readonly kind: 'property';
+    readonly coordinate: PropertyCoordinate;
+    readonly schema: DomainSchema;
+    readonly field: EffectiveField;
+} | {
+    readonly kind: 'method';
+    readonly coordinate: MethodCoordinate;
+    readonly schema: DomainSchema;
+    readonly method: EffectiveMethod;
+} | {
+    readonly kind: 'member';
+    readonly coordinate: MemberCoordinate;
+    readonly schema: DomainSchema;
+};
+/** Resolve a trusted coordinate within one exact accepted closure. */
+export declare function resolveSubject({ context, coordinate, }: {
+    readonly context: Context;
+    readonly coordinate: Coordinate;
+}): ResolvedSubject | undefined;
+export declare function identityOf(coordinate: Coordinate): Subject;
+/** Resolve one caller-supplied Key of the source into an exact coordinate that exists there. */
+export declare function coordinateForKey(context: Context, source: DomainSchema, input: SemanticKey, index: number): Coordinate;

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

@@ -0,0 +1,86 @@
+import { Key } from '../../addressing/index.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { effectiveDefinition, effectiveMethod } from './context.js';
+import { classCoordinate, keyReference, memberCoordinate, methodCoordinate, propertyCoordinate, } from './coordinate.js';
+/** Resolve a trusted coordinate within one exact accepted closure. */
+export function resolveSubject({ context, coordinate, }) {
+    const schema = context.schemas.get(Key.origin(coordinate.key));
+    if (schema === undefined)
+        return undefined;
+    if (coordinate.kind === 'member') {
+        const { ref } = coordinate;
+        const declaration = ref.kind === 'function'
+            ? schema.functions[ref.name]
+            : ref.kind === 'policy'
+                ? schema.policies[ref.name]
+                : ref.kind === 'view'
+                    ? schema.views[ref.name]
+                    : schema.core.nodes[ref.name];
+        return declaration === undefined ? undefined : { kind: 'member', coordinate, schema };
+    }
+    const analysis = effectiveDefinition(context, schema, coordinate.kind === 'class' ? coordinate.ref : coordinate.owner);
+    if (analysis === undefined)
+        return undefined;
+    if (coordinate.kind === 'class')
+        return { kind: 'class', coordinate, schema, analysis };
+    if (coordinate.kind === 'property') {
+        const field = analysis.properties.get(coordinate.key);
+        return field === undefined ? undefined : { kind: 'property', coordinate, schema, field };
+    }
+    const method = effectiveMethod(analysis, coordinate.key);
+    return method === undefined ? undefined : { kind: 'method', coordinate, schema, method };
+}
+export function identityOf(coordinate) {
+    return Object.freeze({
+        key: coordinate.key,
+        kind: coordinate.kind === 'member' ? coordinate.ref.kind : coordinate.kind,
+    });
+}
+/** Resolve one caller-supplied Key of the source into an exact coordinate that exists there. */
+export function coordinateForKey(context, source, input, index) {
+    let key;
+    try {
+        key = Key(input);
+    }
+    catch {
+        return invalidMemberRoot(input, index, 'is not a canonical semantic Key');
+    }
+    if (Key.origin(key) !== source.origin) {
+        return invalidMemberRoot(key, index, `belongs to ${Key.origin(key)}, not source ${source.origin}`);
+    }
+    const reference = keyReference(key);
+    let coordinate;
+    if (reference.member !== undefined && reference.ownerName !== 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 === 'class') {
+        if (source.classes[reference.name] === undefined) {
+            return invalidMemberRoot(key, index, 'does not exist in the source');
+        }
+        // Explicit Class selection compares its surface without inferring inheritance.
+        coordinate = classCoordinate({ origin: source.origin, kind: 'class', name: reference.name });
+    }
+    else {
+        coordinate = memberCoordinate({
+            origin: source.origin,
+            kind: reference.kind,
+            name: reference.name,
+        });
+    }
+    if (resolveSubject({ context, coordinate }) === undefined) {
+        return invalidMemberRoot(key, index, 'does not exist in the source');
+    }
+    return coordinate;
+}
+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),
+    ]);
+}

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

@@ -1,2 +1,2 @@
-export { callableFingerprint } from './compatibility/meaning.js';
-export type { MeaningFingerprint } from './compatibility/meaning.js';
+export { callableFingerprint } from './compatibility/comparators/callables.js';
+export type { Fingerprint as MeaningFingerprint } from './compatibility/model.js';

package/dist/v1/schema/fingerprint.js

@@ -1 +1 @@
-export { callableFingerprint } from './compatibility/meaning.js';
+export { callableFingerprint } from './compatibility/comparators/callables.js';

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

@@ -13,6 +13,7 @@ export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDo
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
 export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint, compareDependencyMeaning, compareMemberMeaning, describeMeaningChange, footprintOf, meaningOf, } from './compatibility/index.js';
 export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, DependencyMeaningLevel, FieldRole, FootprintEntry, MeaningDifference, MeaningFingerprint, } from './compatibility/index.js';
+export * as compatibility from './compatibility/api.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';
@@ -24,3 +25,5 @@ export type { DomainSchemaHeader as Header } from './codec/header.js';
 export type { DomainDependency } from '../addressing/index.js';
 /** The versioned value-schema grammar embedded in declarations. */
 export * as values from './validation/value-api.js';
+export { compareDependencyStructure } from './compatibility/index.js';
+export type { DependencyStructureComparison } from './compatibility/index.js';

package/dist/v1/schema/index.js

@@ -5,9 +5,11 @@ 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 { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint, compareDependencyMeaning, compareMemberMeaning, describeMeaningChange, footprintOf, meaningOf, } from './compatibility/index.js';
+export * as compatibility from './compatibility/api.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';
 export { SchemaError as Error } from './diagnostic.js';
 /** The versioned value-schema grammar embedded in declarations. */
 export * as values from './validation/value-api.js';
+export { compareDependencyStructure } from './compatibility/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.38",
+  "version": "0.2.0-beta.39",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {
@@ -99,7 +99,7 @@
     "ajv": "^8.20.0",
     "re2js": "2.8.6",
     "typescript": "~6.0.3",
-    "vitest": "^4.1.10",
+    "vitest": "^5.0.1",
     "yaml": "2.9.0"
   },
   "scripts": {

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

@@ -1,25 +0,0 @@
-import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { Key as SemanticKey } from '../../addressing/index.js';
-import type { DomainSchema } from '../model/schema.js';
-import type { Context } from './context.js';
-import type { Coordinate } from './coordinate.js';
-import type { DependencyMeaningLevel } from './fields.js';
-import type { ClassRequirement, MeaningFingerprint } from './meaning.js';
-/** One footprint coordinate with the meaning the dependent was authored against. */
-export interface SourceMeaning {
-    readonly coordinate: Coordinate;
-    readonly meaning: JsonValue;
-    readonly fingerprint: MeaningFingerprint;
-    readonly requirement?: ClassRequirement;
-}
-/** Every dependency Definition the dependent's own declarations name, at its strongest usage. */
-export declare function collectSchemaRoots(owner: DomainSchema): readonly Coordinate[];
-/**
- * The transitive footprint: from the roots, every Class, Property, Method, Function, Policy, View
- * and Core coordinate of the selected origin that the dependent's meaning reaches. A Class carries
- * its strongest usage level; only inheritance traverses ancestors and Edge endpoint contracts, and
- * a reached callable contributes its contract references but never its Policy check.
- */
-export declare function collectReachableMeanings(roots: readonly Coordinate[], selectedOrigin: string, context: Context): ReadonlyMap<SemanticKey, SourceMeaning>;
-/** Resolve one caller-supplied Key of the source into an exact coordinate that exists there. */
-export declare function coordinateForKey(context: Context, source: DomainSchema, input: SemanticKey, index: number, level?: DependencyMeaningLevel): Coordinate;

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

@@ -1,264 +0,0 @@
-import { Key } from '../../addressing/index.js';
-import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
-import { SchemaError, diagnostic } from '../diagnostic.js';
-import { collectCallableContractRefs, collectCallableRefs, collectClassPolicyRefs, collectClassRefs, collectCoreRefs, collectEndpointRefs, collectPolicyDefinitionRefs, collectValueDefinitionRefs, coreEndpointDefinitionRef, } from '../resolution/origins.js';
-import { contextInvalid, effectiveDefinition, effectiveMethod, requireOwner } from './context.js';
-import { classCoordinate, keyReference, levelOf, memberCoordinate, methodCoordinate, propertyCoordinate, } from './coordinate.js';
-import { classMeaning, fingerprintMeaning, meaningForCoordinate, memberMeaning, methodMeaning, propertyMeaning, } from './meaning.js';
-/** Every dependency Definition the dependent's own declarations name, at its strongest usage. */
-export 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));
-}
-/**
- * The transitive footprint: from the roots, every Class, Property, Method, Function, Policy, View
- * and Core coordinate of the selected origin that the dependent's meaning reaches. A Class carries
- * its strongest usage level; only inheritance traverses ancestors and Edge endpoint contracts, and
- * a reached callable contributes its contract references but never its Policy check.
- */
-export function collectReachableMeanings(roots, selectedOrigin, context) {
-    const meanings = new Map();
-    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') {
-            pendingMembers.push(coordinate);
-            continue;
-        }
-        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(context, coordinate, push);
-    }
-    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);
-        }
-        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);
-        }
-        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;
-}
-/** Resolve one caller-supplied Key of the source into an exact coordinate that exists there. */
-export function coordinateForKey(context, source, input, index, level = 'reference') {
-    let key;
-    try {
-        key = Key(input);
-    }
-    catch {
-        return invalidMemberRoot(input, index, 'is not a canonical semantic Key');
-    }
-    if (Key.origin(key) !== source.origin) {
-        return invalidMemberRoot(key, index, `belongs to ${Key.origin(key)}, not source ${source.origin}`);
-    }
-    const reference = keyReference(key);
-    let coordinate;
-    if (reference.member !== undefined && reference.ownerName !== 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 === 'class') {
-        if (source.classes[reference.name] === undefined) {
-            return invalidMemberRoot(key, index, 'does not exist in the source');
-        }
-        // A Class root takes the caller's level; compareMemberMeaning passes none and compares the
-        // surface at reference level without inferring an inheritance contract.
-        coordinate = classCoordinate({ origin: source.origin, kind: 'class', name: reference.name }, level);
-    }
-    else {
-        coordinate = memberCoordinate({
-            origin: source.origin,
-            kind: reference.kind,
-            name: reference.name,
-        });
-    }
-    if (meaningForCoordinate(context, coordinate) === undefined) {
-        return invalidMemberRoot(key, index, 'does not exist in the source');
-    }
-    return coordinate;
-}
-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(field.schema, add);
-        return;
-    }
-    const method = effectiveMethod(analysis, coordinate.key);
-    if (method !== undefined)
-        collectCallableContractRefs(method.declaration, add);
-}
-function collectMemberSemanticRefs(owner, ref, add) {
-    switch (ref.kind) {
-        case 'function': {
-            const declaration = owner.functions[ref.name];
-            if (declaration !== undefined)
-                collectCallableRefs(declaration, add);
-            return;
-        }
-        case 'policy': {
-            const declaration = owner.policies[ref.name];
-            if (declaration !== undefined)
-                collectPolicyDefinitionRefs(declaration, add);
-            return;
-        }
-        case 'view': {
-            const declaration = owner.views[ref.name];
-            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;
-            add(node.class);
-            for (const edge of owner.core.edges) {
-                const incident = (edge.source.kind === 'core' && edge.source.name === ref.name) ||
-                    (edge.target.kind === 'core' && edge.target.name === ref.name);
-                if (!incident)
-                    continue;
-                add(edge.class);
-                for (const endpoint of [edge.source, edge.target]) {
-                    const endpointRef = coreEndpointDefinitionRef(endpoint);
-                    if (endpointRef !== undefined)
-                        add(endpointRef);
-                }
-            }
-        }
-    }
-}
-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,
-        meaning,
-        fingerprint,
-        ...(requirement === undefined ? {} : { requirement }),
-    }));
-}
-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),
-    ]);
-}

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

@@ -1,44 +0,0 @@
-import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { Key as SemanticKey, PropertyKey as SemanticPropertyKey } from '../../addressing/index.js';
-import type { ResolvedFunction, ResolvedMethod } from '../../language/callable/resolved.js';
-import type { JsonSchema } from '../../language/value/model/schema.js';
-import type { EffectiveField, EffectiveMethod } from '../analysis/class.js';
-import type { DomainSchema } from '../model/schema.js';
-import type { Context } from './context.js';
-import type { ClassCoordinate, Coordinate, MemberRef } from './coordinate.js';
-export type MeaningFingerprint = `sha256:${string}`;
-/** What the source Class projects onto the target before comparing an inherited Class. */
-export interface ClassRequirement {
-    readonly ancestors: readonly SemanticKey[];
-    readonly properties: ReadonlySet<SemanticPropertyKey>;
-}
-/**
- * The meaning of one coordinate is a portable value built from the fields `fields.ts` classifies
- * as counting at the coordinate's usage level; `__tests__/fields.test.ts` proves the two agree.
- * Comparison works on these values, so every difference can name its exact path.
- */
-export declare function meaningForCoordinate(context: Context, coordinate: Coordinate, requirement?: ClassRequirement): JsonValue | undefined;
-/**
- * A reference needs the Class to exist with its kind, abstractness and orientation; inheritance
- * additionally takes on the source ancestors, class policies, data contract and, for an Edge, the
- * endpoint and constraint contracts. A target projected onto a source requirement keeps only the
- * ancestors the source named, so a superset satisfies it while a removal changes it.
- */
-export declare function classMeaning(context: Context, coordinate: ClassCoordinate, onto?: ClassRequirement): {
-    readonly meaning: JsonValue;
-    readonly requirement: ClassRequirement;
-} | undefined;
-export declare function memberMeaning(owner: DomainSchema, ref: MemberRef): JsonValue | undefined;
-export declare function propertyMeaning(field: EffectiveField): JsonValue;
-export declare function methodMeaning(method: EffectiveMethod): JsonValue;
-/**
- * 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;
-/** Drop annotation keywords wherever a schema keyword nests a schema; never inside data. */
-export declare function semanticValueSchema(value: JsonSchema): JsonSchema;
-export declare function fingerprintMeaning(value: unknown): MeaningFingerprint;