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

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

@@ -1,6 +1,7 @@
 import type { DefinitionRef } 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';
 import type { PolicyDefinition } from '../../language/policy/model/policy.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { DomainSchemaIR } from '../model/schema.js';
@@ -15,6 +16,8 @@ export declare function collectUsedForeignOrigins(schema: DomainSchemaIR): Reado
 /** Complete structured references in one schema, in canonical order. */
 export declare function collectDomainDefinitionRefs(schema: DomainSchemaIR): readonly DefinitionRef[];
 export declare function collectCoreRefs(schema: DomainSchemaIR, add: ReferenceCollector): void;
+/** The owning Domain addresses no Definition, and a Method is addressed through its owner Class. */
+export declare function coreEndpointDefinitionRef(endpoint: CoreEndpointRef): DefinitionRef | undefined;
 export declare function collectClassRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
 export declare function collectClassPolicyRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
 export declare function collectEndpointRefs(declaration: Extract<ClassDefinition, {

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

@@ -36,12 +36,20 @@ export function collectCoreRefs(schema, add) {
         add(node.class, 'core');
     for (const edge of schema.core.edges) {
         add(edge.class, 'core');
-        if (edge.source.kind !== 'domain')
-            add(edge.source, 'core');
-        if (edge.target.kind !== 'domain')
-            add(edge.target, 'core');
+        for (const endpoint of [edge.source, edge.target]) {
+            const ref = coreEndpointDefinitionRef(endpoint);
+            // An endpoint names the Definition without instantiating it, exactly like an accepts contract.
+            if (ref !== undefined)
+                add(ref, 'endpoint');
+        }
     }
 }
+/** The owning Domain addresses no Definition, and a Method is addressed through its owner Class. */
+export function coreEndpointDefinitionRef(endpoint) {
+    if (endpoint.kind === 'domain')
+        return undefined;
+    return endpoint.kind === 'method' ? endpoint.owner : endpoint;
+}
 export function collectClassRefs(declaration, add) {
     declaration.extends.forEach((ref) => add(ref, 'extends'));
     Object.values(declaration.properties).forEach((property) => collectValueDefinitionRefs(property.schema, add));

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

@@ -1,5 +1,7 @@
 import { Key } from '../../addressing/key.js';
 import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
+import { isMethodExecutable } from '../../language/callable/executable.js';
+import { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../language/policy/model/policy.js';
 import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
 import { diagnostic } from '../diagnostic.js';
 const formatDefinitionRef = Key.of;
@@ -42,8 +44,8 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
     const edges = [];
     for (const [index, edge] of environment.candidate.core.edges.entries()) {
         const pointer = `/core/edges/${index}`;
-        const source = resolveCoreEndpoint(edge.source, `${pointer}/source`, nodesByRef, diagnostics);
-        const target = resolveCoreEndpoint(edge.target, `${pointer}/target`, nodesByRef, diagnostics);
+        const source = resolveCoreEndpoint(environment, edge.source, `${pointer}/source`, nodesByRef, diagnostics);
+        const target = resolveCoreEndpoint(environment, edge.target, `${pointer}/target`, nodesByRef, diagnostics);
         const resolved = environment.resolve(edge.class);
         if (edge.class.origin !== environment.candidate.origin ||
             resolved === undefined ||
@@ -75,14 +77,37 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
     }
     return edges;
 }
-function resolveCoreEndpoint(ref, pointer, nodesByRef, diagnostics) {
+function resolveCoreEndpoint(environment, ref, pointer, nodesByRef, diagnostics) {
     if (ref.kind === 'domain')
         return { kind: 'domain', ref, key: 'domain' };
-    const node = nodesByRef.get(definitionRefIndex(ref));
-    if (node === undefined) {
-        diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${formatDefinitionRef(ref)} does not name a declared local Core Node.`, formatDefinitionRef(ref)));
+    const undeclared = () => {
+        const key = policyObjectKey(ref);
+        diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${key} does not name a declared local Definition.`, key));
+        return undefined;
+    };
+    if (policyObjectOrigin(ref) !== environment.candidate.origin)
+        return undeclared();
+    if (ref.kind === 'core')
+        return nodesByRef.get(definitionRefIndex(ref)) ?? undeclared();
+    if (!declaresProjectedMember(environment, ref))
+        return undeclared();
+    return { kind: 'member', key: policyObjectKey(ref), classRef: projectedMemberClass(ref) };
+}
+/** Only a projected declaration can carry a Core fact; an abstract Method is never projected. */
+function declaresProjectedMember(environment, ref) {
+    const candidate = environment.candidate;
+    if (ref.kind === 'method') {
+        const owner = candidate.classes[ref.owner.name];
+        const method = owner?.kind === 'node' ? owner.methods[ref.name] : undefined;
+        return method !== undefined && isMethodExecutable(owner, method);
     }
-    return node;
+    if (ref.kind === 'class')
+        return Object.hasOwn(candidate.classes, ref.name);
+    if (ref.kind === 'function')
+        return Object.hasOwn(candidate.functions, ref.name);
+    if (ref.kind === 'policy')
+        return Object.hasOwn(candidate.policies, ref.name);
+    return Object.hasOwn(candidate.views, ref.name);
 }
 function endpointSatisfies(environment, endpoint, accepts) {
     // The owning Domain is a graph-projection identity, not a Definition declared by this DSL.
@@ -157,41 +182,68 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
     }
 }
 function validateCardinality(environment, declaration, edges, nodesByRef, diagnostics) {
+    const subjects = cardinalitySubjects(edges, nodesByRef);
     if (declaration.orientation === 'undirected') {
         const [first, second] = declaration.endpoints;
-        for (const node of nodesByRef.values()) {
-            const matchesFirst = classSatisfies(environment, node.classRef, first.accepts);
-            const matchesSecond = classSatisfies(environment, node.classRef, second.accepts);
+        for (const subject of subjects) {
+            const matchesFirst = classSatisfies(environment, subject.classRef, first.accepts);
+            const matchesSecond = classSatisfies(environment, subject.classRef, second.accepts);
             if (!matchesFirst && !matchesSecond)
                 continue;
-            const degree = edges.filter((edge) => edge.source.key === node.key || edge.target.key === node.key).length;
+            const degree = edges.filter((edge) => edge.source.key === subject.key || edge.target.key === subject.key).length;
             if (matchesFirst)
-                checkIncidentBound(first, degree, node, diagnostics);
+                checkBound(first, first.incident, degree, subject, diagnostics);
             if (matchesSecond && !sameIncidentEndpointContract(first, second)) {
-                checkIncidentBound(second, degree, node, diagnostics);
+                checkBound(second, second.incident, degree, subject, diagnostics);
             }
         }
         return;
     }
-    for (const node of nodesByRef.values()) {
-        if (classSatisfies(environment, node.classRef, declaration.endpoints.source.accepts)) {
-            const degree = edges.filter((edge) => edge.source.key === node.key).length;
-            checkBound(declaration.endpoints.source, declaration.endpoints.source.outgoing, degree, node, diagnostics);
+    for (const subject of subjects) {
+        if (classSatisfies(environment, subject.classRef, declaration.endpoints.source.accepts)) {
+            const degree = edges.filter((edge) => edge.source.key === subject.key).length;
+            checkBound(declaration.endpoints.source, declaration.endpoints.source.outgoing, degree, subject, diagnostics);
         }
-        if (classSatisfies(environment, node.classRef, declaration.endpoints.target.accepts)) {
-            const degree = edges.filter((edge) => edge.target.key === node.key).length;
-            checkBound(declaration.endpoints.target, declaration.endpoints.target.incoming, degree, node, diagnostics);
+        if (classSatisfies(environment, subject.classRef, declaration.endpoints.target.accepts)) {
+            const degree = edges.filter((edge) => edge.target.key === subject.key).length;
+            checkBound(declaration.endpoints.target, declaration.endpoints.target.incoming, degree, subject, diagnostics);
+        }
+    }
+}
+/**
+ * Every declared Core Node proves its own complete degree, so both bounds hold. A Definition
+ * endpoint is only named by the Edges that reach it: the Domain may also create ordinary Edges of
+ * the same Class against it, so a minimum is unprovable here and only the maximum is enforced.
+ */
+function cardinalitySubjects(edges, nodesByRef) {
+    const subjects = new Map();
+    for (const node of nodesByRef.values()) {
+        subjects.set(node.key, {
+            key: node.key,
+            classRef: node.classRef,
+            pointer: `/core/nodes/${escapePointer(node.slug)}`,
+            minimum: true,
+        });
+    }
+    for (const edge of edges) {
+        for (const endpoint of [edge.source, edge.target]) {
+            if (endpoint.kind !== 'member' || subjects.has(endpoint.key))
+                continue;
+            subjects.set(endpoint.key, {
+                key: endpoint.key,
+                classRef: endpoint.classRef,
+                pointer: edge.pointer,
+                minimum: false,
+            });
         }
     }
+    return Object.freeze([...subjects.values()]);
 }
-function checkBound(endpoint, count, degree, node, diagnostics) {
+function checkBound(endpoint, count, degree, subject, diagnostics) {
     const [minimum, maximum] = countBounds(count);
-    if (degree >= minimum && degree <= maximum)
+    if (degree <= maximum && (degree >= minimum || !subject.minimum))
         return;
-    diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', `/core/nodes/${escapePointer(node.slug)}`, `Core degree ${degree} violates ${endpoint.role} Edge count ${count}.`));
-}
-function checkIncidentBound(endpoint, degree, node, diagnostics) {
-    checkBound(endpoint, endpoint.incident, degree, node, diagnostics);
+    diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', subject.pointer, `Core degree ${degree} violates ${endpoint.role} Edge count ${count}.`));
 }
 function sameIncidentEndpointContract(left, right) {
     return (left.incident === right.incident &&

package/dist/v1/schema/validation/domain.structure.js

@@ -61,14 +61,19 @@ const coreRefSchema = strictObject({
     name: coreSlugSchema,
 });
 const domainRefSchema = strictObject({ kind: literal('domain') });
-const coreEndpointRefSchema = discriminatedUnion('kind', [coreRefSchema, domainRefSchema]);
-const policyObjectRefSchema = discriminatedUnion('kind', [
+/** Every Definition whose installed projection resolves through one exact member Path. */
+const projectedMemberRefOptions = [
     strictObject({ kind: literal('method'), owner: classRefSchema, name: memberNameSchema }),
     classRefSchema,
     functionRefSchema,
     policyRefSchema,
     viewRefSchema,
     coreRefSchema,
+];
+const policyObjectRefSchema = discriminatedUnion('kind', projectedMemberRefOptions);
+const coreEndpointRefSchema = discriminatedUnion('kind', [
+    ...projectedMemberRefOptions,
+    domainRefSchema,
 ]);
 const edgeEndpointBaseShape = {
     role: memberNameSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.37",
+  "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,263 +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, } 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);
-                if (edge.source.kind !== 'domain')
-                    add(edge.source);
-                if (edge.target.kind !== 'domain')
-                    add(edge.target);
-            }
-        }
-    }
-}
-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;