@astrale-os/kernel-dsl 0.2.0-beta.2 → 0.2.0-beta.21

package/dist/v1/schema/canonical/freeze.js

@@ -7,4 +7,3 @@ export function deepFreeze(value) {
     }
     return Object.freeze(value);
 }
-//# sourceMappingURL=freeze.js.map

package/dist/v1/schema/{domain.revision.d.ts → canonical/revision.d.ts}

@@ -1,5 +1,5 @@
-import type { Revision } from './reference.js';
-import { type DomainSchema, type DomainSchemaIR } from './domain.ir.js';
+import type { Revision } from '../../addressing/index.js';
+import { type DomainSchema, type DomainSchemaIR } from '../model/schema.js';
 export interface CanonicalDomainSchema {
     readonly schema: DomainSchema;
     readonly bytes: Uint8Array;
@@ -9,4 +9,3 @@ export declare function canonicalDomainSchema(value: DomainSchema): CanonicalDom
 /** Internal acceptance seam. The caller must establish whole-Domain validity first. */
 export declare function canonicalDomainSchemaAfterValidation(value: DomainSchemaIR): CanonicalDomainSchema;
 export declare function revisionOfDomainSchema(schema: DomainSchema): Revision;
-//# sourceMappingURL=domain.revision.d.ts.map

package/dist/v1/schema/{domain.revision.js → canonical/revision.js}

@@ -1,7 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { digestDomainSchemaBytes } from './canonical/domain.digest.js';
-import { canonicalizeDomainSchema } from './canonical/domain.js';
-import { asDomainSchema } from './domain.ir.js';
+import { asDomainSchema } from '../model/schema.js';
+import { digestDomainSchemaBytes } from './domain.digest.js';
+import { canonicalizeDomainSchema } from './domain.js';
 export function canonicalDomainSchema(value) {
     return canonicalDomainSchemaAfterValidation(value);
 }
@@ -15,4 +15,3 @@ export function canonicalDomainSchemaAfterValidation(value) {
 export function revisionOfDomainSchema(schema) {
     return canonicalDomainSchema(schema).revision;
 }
-//# sourceMappingURL=domain.revision.js.map

package/dist/v1/schema/codec/header.d.ts

@@ -0,0 +1,17 @@
+import type { Key } from '../../addressing/index.js';
+import type { DomainDependencyMap } from '../../addressing/index.js';
+/**
+ * Structurally trusted routing information used to discover an exact
+ * dependency closure before whole-Domain semantic acceptance is possible.
+ *
+ * This is deliberately not a DomainSchema: callers must still load the
+ * declared revisions and pass the original document to acceptDomainSchema.
+ */
+export interface DomainSchemaHeader {
+    readonly format: 'astrale.dsl';
+    readonly version: 'v1';
+    readonly origin: Key.Origin;
+    readonly dependencies: DomainDependencyMap;
+}
+/** Decode detached Schema bytes or text and retain only validated closure-routing identity. */
+export declare function header(input: string | Uint8Array): DomainSchemaHeader;

package/dist/v1/schema/codec/header.js

@@ -0,0 +1,26 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { routeDomainSchema } from '../validation/domain.route.js';
+/** Decode detached Schema bytes or text and retain only validated closure-routing identity. */
+export function header(input) {
+    let decoded;
+    try {
+        decoded = json.decode(input);
+    }
+    catch (error) {
+        if (error instanceof json.DecodeError) {
+            throw new SchemaError([diagnostic('DV_JSON_VALUE', '', error.message)]);
+        }
+        throw error;
+    }
+    const structured = routeDomainSchema(decoded);
+    return Object.freeze({
+        format: structured.format,
+        version: structured.version,
+        dependencies: Object.freeze(Object.fromEntries(Object.entries(structured.dependencies).map(([alias, dependency]) => [
+            alias,
+            Object.freeze({ ...dependency }),
+        ]))),
+        origin: structured.origin,
+    });
+}

package/dist/v1/schema/{domain.codec.d.ts → codec/schema.d.ts}

@@ -1,6 +1,5 @@
-import type { DomainSchema } from './domain.ir.js';
-import type { DomainSchemaLookup } from './domain.lookup.js';
+import type { DomainSchemaLookup } from '../dependency/lookup.js';
+import type { DomainSchema } from '../model/schema.js';
 export declare function decodeDomainSchema(input: string | Uint8Array, lookup?: DomainSchemaLookup): DomainSchema;
 export declare function serializeDomainSchema(schema: DomainSchema): string;
 export declare function encodeDomainSchema(schema: DomainSchema): Uint8Array;
-//# sourceMappingURL=domain.codec.d.ts.map

package/dist/v1/schema/{domain.codec.js → codec/schema.js}

@@ -1,14 +1,14 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { DomainSchemaError, diagnostic } from './diagnostic.js';
-import { acceptDomainSchema } from './domain.accept.js';
-import { emptyDomainSchemaLookup } from './domain.lookup.js';
+import { acceptDomainSchema } from '../admission/accept.js';
+import { emptyDomainSchemaLookup } from '../dependency/lookup.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
 export function decodeDomainSchema(input, lookup = emptyDomainSchemaLookup()) {
     try {
         return acceptDomainSchema(json.decode(input), lookup);
     }
     catch (error) {
         if (error instanceof json.DecodeError) {
-            throw new DomainSchemaError([diagnostic('DV_JSON_VALUE', '', error.message)]);
+            throw new SchemaError([diagnostic('DV_JSON_VALUE', '', error.message)]);
         }
         throw error;
     }
@@ -19,4 +19,3 @@ export function serializeDomainSchema(schema) {
 export function encodeDomainSchema(schema) {
     return json.encode(schema);
 }
-//# sourceMappingURL=domain.codec.js.map

package/dist/v1/schema/{dependency.meaning.d.ts → compatibility/meaning.d.ts}

@@ -1,7 +1,7 @@
-import type { Key as SemanticKey } from '../addressing/index.js';
-import type { DomainSchema } from './domain.ir.js';
-import type { Revision } from './reference.js';
-import { Key } from '../addressing/index.js';
+import type { Key as SemanticKey } from '../../addressing/index.js';
+import type { Revision } from '../../addressing/index.js';
+import type { DomainSchema } from '../model/schema.js';
+import { Key } from '../../addressing/index.js';
 export type DependencyMeaningChangeKind = 'missing' | 'changed';
 export type MeaningFingerprint = `sha256:${string}`;
 export interface DependencyMeaningChange {
@@ -27,4 +27,3 @@ export interface DependencyMeaningComparison {
 export declare function compareDependencyMeaning(dependent: DomainSchema, target: DomainSchema): DependencyMeaningComparison;
 /** Compare one explicit non-empty source member surface and its reachable V1 meaning. */
 export declare function compareMemberMeaning(source: DomainSchema, target: DomainSchema, roots: readonly [SemanticKey, ...SemanticKey[]]): DependencyMeaningComparison;
-//# sourceMappingURL=dependency.meaning.d.ts.map

package/dist/v1/schema/{dependency.meaning.js → compatibility/meaning.js}

@@ -1,13 +1,15 @@
 import { json } from '@astrale-os/kernel-dsl/value';
-import { Key, PropertyKey, Ref } from '../addressing/index.js';
-import { digestDomainSchemaBytes } from './canonical/domain.digest.js';
-import { DomainSchemaError, diagnostic } from './diagnostic.js';
-import { resolveDomainSchema } from './domain.resolve.js';
-import { revisionOfDomainSchema } from './domain.revision.js';
-import { compareSchemaRefs, compareUnicode, schemaRefIndex } from './reference.js';
-import { collectCallableRefs, collectClassRefs, collectInterfaceRefs, collectPolicyDeclarationRefs, collectValueSchemaRefs, } from './resolution/origins.js';
-import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from './value/location/keywords.js';
-import { isValueObject as isJsonObject } from './value/object.js';
+import { Key, MethodKey, PropertyKey } from '../../addressing/index.js';
+import { compareDefinitionRefs, 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';
+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 { validateDomainSchemaSemantics } from '../validation/domain.js';
 const VALUE_SCHEMA_ANNOTATIONS = new Set([
     '$comment',
     'contentEncoding',
@@ -28,16 +30,17 @@ const VALUE_SCHEMA_ANNOTATIONS = new Set([
  * lifecycle-compatibility decision.
  */
 export function compareDependencyMeaning(dependent, target) {
-    const resolution = resolveDomainSchema(dependent);
-    const source = resolution.$.closure.find((candidate) => candidate.origin === target.origin);
+    resolve(dependent);
+    const closure = knownDomainClosure(dependent) ?? [];
+    const source = closure.find((candidate) => candidate.schema.origin === target.origin)?.schema;
     if (source === undefined) {
-        throw new DomainSchemaError([
+        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],
-        ...resolution.$.closure.map((candidate) => [candidate.origin, candidate]),
+        ...closure.map(({ schema: candidate }) => [candidate.origin, candidate]),
     ]);
     const sourceMeanings = collectDependencyMeanings(dependent, source.origin, schemas);
     return compareSourceMeanings(source, target, sourceMeanings);
@@ -45,19 +48,20 @@ export function compareDependencyMeaning(dependent, target) {
 /** Compare one explicit non-empty source member surface and its reachable V1 meaning. */
 export function compareMemberMeaning(source, target, roots) {
     if (source.origin !== target.origin) {
-        throw new DomainSchemaError([
+        throw new SchemaError([
             diagnostic('DM_MEMBER_ORIGIN_MISMATCH', '/target/origin', `Member comparison target ${target.origin} does not match source ${source.origin}.`),
         ]);
     }
     if (!Array.isArray(roots) || roots.length === 0 || new Set(roots).size !== roots.length) {
-        throw new DomainSchemaError([
+        throw new SchemaError([
             diagnostic('DM_MEMBER_ROOT_INVALID', '/roots', 'Member comparison roots must be one non-empty duplicate-free Key set.'),
         ]);
     }
-    const resolution = resolveDomainSchema(source);
+    resolve(source);
+    const closure = knownDomainClosure(source) ?? [];
     const schemas = new Map([
         [source.origin, source],
-        ...resolution.$.closure.map((candidate) => [candidate.origin, candidate]),
+        ...closure.map(({ schema: candidate }) => [candidate.origin, candidate]),
     ]);
     const coordinates = roots.map((key, index) => coordinateForKey(source, key, index));
     const sourceMeanings = collectReachableMeanings(coordinates, source.origin, schemas);
@@ -65,7 +69,7 @@ export function compareMemberMeaning(source, target, roots) {
 }
 function compareSourceMeanings(source, target, sourceMeanings) {
     // Prove the candidate still has an exact accepted semantic context before comparing it.
-    resolveDomainSchema(target);
+    resolve(target);
     const footprint = Object.freeze([...sourceMeanings.keys()].sort(compareUnicode));
     const changes = [];
     const comparisonCoordinates = [];
@@ -129,7 +133,7 @@ function collectReachableMeanings(roots, selectedOrigin, schemas) {
         const owner = schemas.get(Key.origin(coordinate.key));
         const meaning = owner === undefined ? undefined : meaningForCoordinate(owner, coordinate);
         if (owner === undefined || meaning === undefined) {
-            throw new DomainSchemaError([
+            throw new SchemaError([
                 diagnostic('DM_MEMBER_ROOT_INVALID', '/roots', `Member comparison root ${coordinate.key} does not exist in its source context.`, coordinate.key),
             ]);
         }
@@ -138,20 +142,20 @@ function collectReachableMeanings(roots, selectedOrigin, schemas) {
     }
     for (let index = 0; index < pending.length; index += 1) {
         const ref = pending[index];
-        const refIndex = schemaRefIndex(ref);
+        const refIndex = definitionRefIndex(ref);
         if (visited.has(refIndex))
             continue;
         visited.add(refIndex);
         const owner = schemas.get(ref.origin);
         if (owner === undefined) {
-            throw new DomainSchemaError([
-                diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', `Retained acceptance context cannot resolve ${Key.fromSchema(ref)}.`, String(Key.fromSchema(ref))),
+            throw new SchemaError([
+                diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', `Retained acceptance context cannot resolve ${keyForDefinitionRef(ref)}.`, keyForDefinitionRef(ref)),
             ]);
         }
         const primary = memberCoordinate(ref);
         const primaryMeaning = meaningForCoordinate(owner, primary);
         if (primaryMeaning === undefined) {
-            throw new DomainSchemaError([
+            throw new SchemaError([
                 diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', `Retained acceptance context has no meaning for ${primary.key}.`, primary.key),
             ]);
         }
@@ -159,7 +163,7 @@ function collectReachableMeanings(roots, selectedOrigin, schemas) {
         collectMemberSemanticRefs(owner, ref, (candidate) => pending.push(requireMemberRef(candidate)));
         if (!isDefinitionRef(ref))
             continue;
-        const analysis = resolveDomainSchema(owner).$.refs.effective(ref);
+        const analysis = effectiveDefinition(owner, ref);
         if (analysis === undefined)
             continue;
         collectEffectiveMeanings(analysis, selectedOrigin, meanings, (candidate) => pending.push(requireMemberRef(candidate)));
@@ -167,16 +171,16 @@ function collectReachableMeanings(roots, selectedOrigin, schemas) {
     return meanings;
 }
 function collectCoordinateSemanticRefs(owner, coordinate, add) {
-    const analysis = resolveDomainSchema(owner).$.refs.effective(coordinate.owner);
+    const analysis = effectiveDefinition(owner, coordinate.owner);
     if (analysis === undefined)
         return;
     if (coordinate.kind === 'property') {
         const field = analysis.properties.get(coordinate.key);
         if (field !== undefined)
-            collectValueSchemaRefs(semanticValueSchema(field.schema), add);
+            collectValueDefinitionRefs(semanticValueSchema(field.schema), add);
         return;
     }
-    const method = [...analysis.methods.values()].find((candidate) => methodKey(candidate.owner, candidate.name) === coordinate.key);
+    const method = [...analysis.methods.values()].find((candidate) => MethodKey.of(candidate.owner, candidate.name) === coordinate.key);
     if (method !== undefined)
         collectCallableRefs(semanticMethod(method.declaration), add);
 }
@@ -185,7 +189,7 @@ function collectEffectiveMeanings(analysis, dependencyOrigin, meanings, add) {
         const coordinate = propertyCoordinate(field.owner, field.name);
         retainMeaning(meanings, dependencyOrigin, coordinate, propertyMeaning(field));
         add(field.owner);
-        collectValueSchemaRefs(semanticValueSchema(field.schema), add);
+        collectValueDefinitionRefs(semanticValueSchema(field.schema), add);
     }
     for (const method of analysis.methods.values()) {
         const coordinate = methodCoordinate(method.owner, method.name);
@@ -200,7 +204,7 @@ function retainMeaning(meanings, dependencyOrigin, coordinate, meaning) {
     const fingerprint = fingerprintMeaning(meaning);
     const previous = meanings.get(coordinate.key);
     if (previous !== undefined && previous.fingerprint !== fingerprint) {
-        throw new DomainSchemaError([
+        throw new SchemaError([
             diagnostic('DM_MEANING_INCONSISTENT', '', `Semantic coordinate ${coordinate.key} produced inconsistent effective meaning.`, coordinate.key),
         ]);
     }
@@ -210,14 +214,8 @@ function collectSchemaSemanticRefs(owner) {
     const refs = new Map();
     const add = (ref) => {
         const member = requireMemberRef(ref);
-        refs.set(schemaRefIndex(member), member);
+        refs.set(definitionRefIndex(member), member);
     };
-    for (const value of Object.values(owner.types)) {
-        collectValueSchemaRefs(semanticValueSchema(value), add);
-    }
-    for (const declaration of Object.values(owner.interfaces)) {
-        collectInterfaceRefs(semanticDefinition(declaration), add);
-    }
     for (const declaration of Object.values(owner.classes)) {
         collectClassRefs(semanticDefinition(declaration), add);
     }
@@ -225,7 +223,7 @@ function collectSchemaSemanticRefs(owner) {
         collectCallableRefs(semanticFunction(declaration), add);
     }
     for (const declaration of Object.values(owner.policies)) {
-        collectPolicyDeclarationRefs(semanticPolicy(declaration), add);
+        collectPolicyDefinitionRefs(semanticPolicy(declaration), add);
     }
     for (const declaration of Object.values(owner.views)) {
         if (declaration.target.kind === 'definition')
@@ -240,23 +238,10 @@ function collectSchemaSemanticRefs(owner) {
         if (edge.target.kind !== 'domain')
             add(edge.target);
     }
-    return [...refs.values()].sort(compareSchemaRefs);
+    return [...refs.values()].sort(compareDefinitionRefs);
 }
 function collectMemberSemanticRefs(owner, ref, add) {
     switch (ref.kind) {
-        case 'type': {
-            const declaration = owner.types[ref.name];
-            if (declaration !== undefined)
-                collectValueSchemaRefs(semanticValueSchema(declaration), add);
-            return;
-        }
-        case 'interface': {
-            const declaration = owner.interfaces[ref.name];
-            if (declaration !== undefined) {
-                collectInterfaceRefs(semanticDefinition(declaration), add);
-            }
-            return;
-        }
         case 'class': {
             const declaration = owner.classes[ref.name];
             if (declaration !== undefined) {
@@ -273,7 +258,7 @@ function collectMemberSemanticRefs(owner, ref, add) {
         case 'policy': {
             const declaration = owner.policies[ref.name];
             if (declaration !== undefined) {
-                collectPolicyDeclarationRefs(semanticPolicy(declaration), add);
+                collectPolicyDefinitionRefs(semanticPolicy(declaration), add);
             }
             return;
         }
@@ -303,27 +288,20 @@ function meaningForCoordinate(owner, coordinate) {
         return undefined;
     if (coordinate.kind === 'member')
         return memberMeaning(owner, coordinate.ref);
-    const analysis = resolveDomainSchema(owner).$.refs.effective(coordinate.owner);
+    const analysis = effectiveDefinition(owner, coordinate.owner);
     if (analysis === undefined)
         return undefined;
     if (coordinate.kind === 'property') {
         const field = analysis.properties.get(coordinate.key);
         return field === undefined ? undefined : propertyMeaning(field);
     }
-    const method = [...analysis.methods.values()].find((candidate) => methodKey(candidate.owner, candidate.name) === coordinate.key);
+    const method = [...analysis.methods.values()].find((candidate) => MethodKey.of(candidate.owner, candidate.name) === coordinate.key);
     return method === undefined ? undefined : methodMeaning(method);
 }
 function memberMeaning(owner, ref) {
     if (ref.origin !== owner.origin)
         return undefined;
     switch (ref.kind) {
-        case 'type': {
-            const declaration = owner.types[ref.name];
-            return declaration === undefined
-                ? undefined
-                : { kind: ref.kind, schema: semanticValueSchema(declaration) };
-        }
-        case 'interface':
         case 'class':
             return definitionMeaning(owner, ref);
         case 'function': {
@@ -357,44 +335,49 @@ function memberMeaning(owner, ref) {
     }
 }
 function definitionMeaning(owner, ref) {
-    const resolution = resolveDomainSchema(owner);
-    const resolved = resolution.$.refs.definition(ref);
-    const effective = resolution.$.refs.effective(ref);
-    if (resolved === undefined || effective === undefined || resolved.owner !== owner)
+    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(resolved.declaration),
+        declaration: semanticDefinition(declaration),
         effective: {
             properties: [...effective.properties.keys()].sort(compareUnicode),
             methods: [...effective.methods.values()]
-                .map((method) => methodKey(method.owner, method.name))
+                .map((method) => MethodKey.of(method.owner, method.name))
                 .sort(compareUnicode),
             ...(effective.data === undefined
                 ? {}
                 : {
                     data: {
-                        owner: Key.fromSchema(effective.data.owner),
+                        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 propertyMeaning(field) {
     return {
         kind: 'property',
-        owner: Key.fromSchema(field.owner),
+        owner: keyForDefinitionRef(field.owner),
         name: field.name,
         schema: semanticValueSchema(field.schema),
         required: field.required,
-        visibility: field.visibility,
+        ...(field.state === undefined ? {} : { state: field.state }),
     };
 }
 function methodMeaning(method) {
     return {
         kind: 'method',
-        owner: Key.fromSchema(method.owner),
+        owner: keyForDefinitionRef(method.owner),
         name: method.name,
         declaration: semanticMethod(method.declaration),
     };
@@ -403,7 +386,13 @@ function semanticDefinition(declaration) {
     const { description: _description, ...rest } = declaration;
     const semantic = {
         ...rest,
-        properties: semanticValueSchema(declaration.properties),
+        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)]));
@@ -419,11 +408,11 @@ function semanticFunction(declaration) {
     };
 }
 function semanticMethod(declaration) {
-    const semantic = semanticFunction(declaration);
+    const { description: _description, ...rest } = declaration;
     return {
-        ...semantic,
-        static: declaration.static,
-        inheritance: declaration.inheritance,
+        ...rest,
+        input: semanticValueSchema(declaration.input),
+        output: semanticOutput(declaration.output),
     };
 }
 function semanticOutput(output) {
@@ -480,50 +469,48 @@ function coordinateForKey(source, input, index) {
     if (Key.origin(key) !== source.origin) {
         return invalidMemberRoot(key, index, `belongs to ${Key.origin(key)}, not source ${source.origin}`);
     }
-    const ref = Key.ref(key);
+    const reference = keyReference(key);
     let coordinate;
-    if (Ref.isProperty(ref) || Ref.isMethod(ref)) {
-        const owner = definitionRefFor(source, Ref.namespace(ref), Ref.member(ref));
-        const name = Ref.child(ref);
-        if (owner === undefined || name === undefined) {
+    if ((reference.member === 'property' || reference.member === 'method') &&
+        reference.ownerKind === 'class' &&
+        reference.ownerName !== undefined) {
+        const owner = definitionRefFor(source, reference.ownerKind, reference.ownerName);
+        if (owner === undefined) {
             return invalidMemberRoot(key, index, 'has no exact owning Definition');
         }
-        coordinate = Ref.isProperty(ref)
-            ? propertyCoordinate(owner, name)
-            : methodCoordinate(owner, name);
+        coordinate =
+            reference.member === 'property'
+                ? propertyCoordinate(owner, reference.name)
+                : methodCoordinate(owner, reference.name);
     }
-    else if (Ref.isDefinition(ref)) {
-        const member = memberRefFor(source, ref);
+    else if (reference.kind !== 'core') {
+        const member = memberRefFor(source, {
+            origin: source.origin,
+            kind: reference.kind,
+            name: reference.name,
+        });
         if (member === undefined)
             return invalidMemberRoot(key, index, 'does not exist in the source');
         coordinate = memberCoordinate(member);
     }
-    else if (ref.startsWith('core.')) {
+    else {
         coordinate = memberCoordinate({
             origin: source.origin,
             kind: 'core',
-            name: Ref.member(ref),
+            name: reference.name,
         });
     }
-    else {
-        return invalidMemberRoot(key, index, 'is not an independently comparable V1 member');
-    }
     if (meaningForCoordinate(source, coordinate) === undefined) {
         return invalidMemberRoot(key, index, 'does not exist in the source');
     }
     return coordinate;
 }
 function memberRefFor(source, ref) {
-    const namespace = Ref.namespace(ref);
-    const name = Ref.member(ref);
-    const owner = definitionRefFor(source, namespace, name);
+    const name = ref.name;
+    const owner = definitionRefFor(source, ref.kind, name);
     if (owner !== undefined)
         return owner;
-    switch (namespace) {
-        case 'type':
-            return source.types[name] === undefined
-                ? undefined
-                : { origin: source.origin, kind: 'type', name };
+    switch (ref.kind) {
         case 'function':
             return source.functions[name] === undefined
                 ? undefined
@@ -546,29 +533,50 @@ function definitionRefFor(source, namespace, name) {
             ? undefined
             : { origin: source.origin, kind: 'class', name };
     }
-    if (namespace === 'interface') {
-        return source.interfaces[name] === undefined
-            ? undefined
-            : { origin: source.origin, kind: 'interface', name };
-    }
     return undefined;
 }
 function invalidMemberRoot(key, index, reason) {
-    throw new DomainSchemaError([
+    throw new SchemaError([
         diagnostic('DM_MEMBER_ROOT_INVALID', `/roots/${index}`, `Member comparison root ${JSON.stringify(key)} ${reason}.`, typeof key === 'string' ? key : undefined),
     ]);
 }
 function memberCoordinate(ref) {
-    return Object.freeze({ kind: 'member', key: Key.fromSchema(ref), ref });
+    return Object.freeze({ kind: 'member', key: keyForDefinitionRef(ref), ref });
 }
 function propertyCoordinate(owner, name) {
     return Object.freeze({ kind: 'property', key: PropertyKey.of(owner, name), owner, name });
 }
 function methodCoordinate(owner, name) {
-    return Object.freeze({ kind: 'method', key: methodKey(owner, name), owner, name });
-}
-function methodKey(owner, name) {
-    return Key.of(owner.origin, Ref.method(Ref.fromSchema(owner), name));
+    return Object.freeze({ kind: 'method', key: MethodKey.of(owner, name), owner, name });
+}
+function keyForDefinitionRef(ref) {
+    return ref.kind === 'core'
+        ? Key.of(ref)
+        : Key.of(ref);
+}
+function keyReference(key) {
+    const semantic = key.slice(key.indexOf(':') + 1);
+    const parts = semantic.split('.');
+    if (parts[0] === 'core' && parts.length === 2) {
+        return { kind: 'core', name: parts[1] };
+    }
+    if (parts.length === 2) {
+        return { kind: parts[0], name: parts[1] };
+    }
+    if (parts.length === 4 &&
+        parts[0] === 'class' &&
+        (parts[2] === 'property' || parts[2] === 'method')) {
+        return {
+            kind: 'class',
+            name: parts[3],
+            member: parts[2],
+            ownerKind: 'class',
+            ownerName: parts[1],
+        };
+    }
+    throw new SchemaError([
+        diagnostic('DM_MEMBER_ROOT_INVALID', '/roots', `Key ${key} has no supported V1 shape.`, key),
+    ]);
 }
 function incidentCoreEdges(owner, name) {
     return owner.core.edges.filter((edge) => (edge.source.kind === 'core' && edge.source.name === name) ||
@@ -578,31 +586,20 @@ function fingerprintMeaning(value) {
     return digestDomainSchemaBytes(json.encode(value));
 }
 function isDefinitionRef(ref) {
-    switch (ref.kind) {
-        case 'interface':
-        case 'class':
-            return true;
-        default:
-            return false;
-    }
+    return ref.kind === 'class';
 }
 function requireMemberRef(ref) {
     switch (ref.kind) {
-        case 'type':
-        case 'interface':
         case 'class':
         case 'function':
         case 'policy':
         case 'view':
+            return ref;
         case 'core':
             return ref;
-        default:
-            throw new DomainSchemaError([
-                diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', `Semantic reference kind ${JSON.stringify(ref.kind)} is outside V1.`),
-            ]);
     }
+    return ref;
 }
 function isJsonSchema(value) {
     return typeof value === 'boolean' || isJsonObject(value);
 }
-//# sourceMappingURL=dependency.meaning.js.map

package/dist/v1/schema/{domain.lookup.d.ts → dependency/lookup.d.ts}

@@ -1,6 +1,6 @@
-import type { Key } from '../addressing/index.js';
-import type { DomainSchema } from './domain.ir.js';
-import type { Revision } from './reference.js';
+import type { Key } from '../../addressing/index.js';
+import type { Revision } from '../../addressing/index.js';
+import type { DomainSchema } from '../model/schema.js';
 /** Exact revision-addressed lookup used while accepting a dependency closure. */
 export interface DomainSchemaLookup {
     get(origin: Key.Origin, revision: Revision): DomainSchema | undefined;
@@ -16,4 +16,3 @@ export declare class MemoryDomainSchemaLookup implements DomainSchemaLookup {
     set(entry: DomainSchemaEntry): this;
 }
 export declare function emptyDomainSchemaLookup(): DomainSchemaLookup;
-//# sourceMappingURL=domain.lookup.d.ts.map