@astrale-os/kernel-dsl 0.2.0-beta.32 → 0.2.0-beta.34

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

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