@astrale-os/kernel-dsl 0.2.0-beta.7 → 0.2.0-beta.8

package/dist/v1/domain/create.js

@@ -6,7 +6,7 @@ const admittedDomains = new WeakSet();
 export function isDomain(input) {
     return input !== null && typeof input === 'object' && admittedDomains.has(input);
 }
-/** Retain source provenance without losing the admitted Domain identity. */
+/** Retain source provenance without losing the admitted root Domain identity. */
 export function createSourceDomain(domain, source) {
     if (!isDomain(domain))
         throw new TypeError('Source provenance requires an admitted Domain.');
@@ -14,12 +14,129 @@ export function createSourceDomain(domain, source) {
     admittedDomains.add(resolved);
     return resolved;
 }
+/** Construct one resolved Definition universe and one memoized facade per closure Domain. */
 export function createDomain(input) {
-    const classesByKey = createClasses(input.definitions, input.validation);
+    const entries = new Map();
+    for (const entry of input.entries) {
+        if (entries.has(entry.origin))
+            throw new TypeError(`Domain entry ${entry.origin} is duplicated.`);
+        entries.set(entry.origin, entry);
+    }
+    const root = entries.get(input.root.origin);
+    if (root === undefined || root.revision !== input.root.revision) {
+        throw new TypeError('Domain root is absent or has the wrong revision.');
+    }
+    const declarations = Object.freeze(input.entries.flatMap(({ definitions }) => definitions));
+    const classesByKey = createClasses(declarations, input.validation);
+    const definitionsByKey = createDefinitions(declarations, classesByKey, input);
+    const callables = createCallables(definitionsByKey, classesByKey);
+    const facades = new Map();
+    const projecting = new Set();
+    const project = (entry) => {
+        const cached = facades.get(entry.origin);
+        if (cached !== undefined)
+            return cached;
+        if (projecting.has(entry.origin))
+            throw new TypeError(`Dependency cycle reaches ${entry.origin}.`);
+        projecting.add(entry.origin);
+        const visibleEntries = reachableEntries(entry, entries);
+        const visibleOrigins = new Set(visibleEntries.map(({ origin }) => origin));
+        const local = [...definitionsByKey.values()]
+            .filter(({ ref }) => ref.origin === entry.origin)
+            .sort((left, right) => compare(left.key, right.key));
+        const classes = namespace(local, 'class');
+        const functions = namespace(local, 'function');
+        const policies = namespace(local, 'policy');
+        const views = namespace(local, 'view');
+        const coreNodes = namespace(local, 'core');
+        const domainEndpoint = Object.freeze({
+            kind: 'domain',
+            origin: entry.origin,
+        });
+        const coreEdges = Object.freeze(entry.coreEdges.map((edge) => {
+            const classValue = classesByKey.get(Key.of(edge.class));
+            if (classValue?.kind !== 'edge') {
+                throw new TypeError(`Core Edge has no Edge Class ${Key.of(edge.class)}.`);
+            }
+            return Object.freeze({
+                class: classValue,
+                source: edge.source.kind === 'domain'
+                    ? domainEndpoint
+                    : requiredCore(definitionsByKey, edge.source),
+                target: edge.target.kind === 'domain'
+                    ? domainEndpoint
+                    : requiredCore(definitionsByKey, edge.target),
+                properties: edge.properties,
+            });
+        }));
+        const dependencies = frozenRecord(Object.entries(entry.dependencies).map(([alias, pin]) => {
+            const dependency = entries.get(pin.origin);
+            if (dependency === undefined || dependency.revision !== pin.revision) {
+                throw new TypeError(`Dependency alias ${alias} has no exact ${pin.origin}@${pin.revision} entry.`);
+            }
+            return [alias, project(dependency)];
+        }));
+        const definitionLookup = ((value) => {
+            const resolved = definitionsByKey.get(typeof value === 'string' ? value : Key.of(value));
+            return resolved !== undefined && visibleOrigins.has(resolved.ref.origin)
+                ? resolved
+                : undefined;
+        });
+        const domain = {
+            origin: entry.origin,
+            revision: entry.revision,
+            closure: Object.freeze(visibleEntries
+                .map(({ origin, revision }) => Object.freeze({ origin, revision }))
+                .sort((left, right) => compare(left.origin, right.origin))),
+            dependencies,
+            classes,
+            functions,
+            policies,
+            views,
+            core: Object.freeze({ nodes: coreNodes, edges: coreEdges }),
+            definition: definitionLookup,
+            callable(key) {
+                const callable = callables.get(key);
+                if (callable === undefined)
+                    return undefined;
+                const origin = 'ref' in callable ? callable.ref.origin : callable.owner.ref.origin;
+                return visibleOrigins.has(origin) ? callable : undefined;
+            },
+            definitions(kind) {
+                return kind === undefined ? local : local.filter(({ ref }) => ref.kind === kind);
+            },
+            viewsFor(target) {
+                return Object.freeze(Object.values(views).filter((view) => {
+                    if (view.target.kind === 'domain')
+                        return target === 'domain';
+                    if (target === 'domain')
+                        return false;
+                    return view.target.definitions.some((ref) => {
+                        const selected = classesByKey.get(Key.of(ref));
+                        if (target.kind === 'node' && selected?.kind === 'node') {
+                            return target.satisfies(selected);
+                        }
+                        if (target.kind === 'edge' && selected?.kind === 'edge') {
+                            return target.satisfies(selected);
+                        }
+                        return false;
+                    });
+                }));
+            },
+        };
+        const admitted = Object.freeze(domain);
+        facades.set(entry.origin, admitted);
+        admittedDomains.add(admitted);
+        projecting.delete(entry.origin);
+        return admitted;
+    };
+    return project(root);
+}
+function createDefinitions(declarations, classesByKey, input) {
     const definitionsByKey = new Map();
     for (const value of classesByKey.values())
         definitionsByKey.set(value.key, value);
-    for (const definition of input.definitions) {
+    for (const definition of declarations) {
         if (definition.ref.kind === 'class')
             continue;
         if (isFunctionDefinition(definition)) {
@@ -44,35 +161,33 @@ export function createDomain(input) {
         }
         if (isPolicyDefinition(definition)) {
             const key = Key.of(definition.ref);
-            const resolved = Object.freeze({
+            definitionsByKey.set(key, Object.freeze({
                 ref: definition.ref,
                 key,
                 expression: definition.expression,
                 description: definition.description,
                 definition,
-            });
-            definitionsByKey.set(key, resolved);
+            }));
             continue;
         }
         if (isViewDefinition(definition)) {
             const key = Key.of(definition.ref);
-            const resolved = Object.freeze({
+            definitionsByKey.set(key, Object.freeze({
                 ref: definition.ref,
                 key,
                 target: definition.target,
                 description: definition.description,
                 definition,
-            });
-            definitionsByKey.set(key, resolved);
-            continue;
+            }));
         }
     }
-    for (const definition of input.definitions) {
+    for (const definition of declarations) {
         if (!isCoreDefinition(definition))
             continue;
         const classValue = classesByKey.get(Key.of(definition.class));
-        if (classValue?.kind !== 'node')
+        if (classValue?.kind !== 'node') {
             throw new TypeError(`Core ${Key.of(definition.ref)} has no Node Class.`);
+        }
         if (classValue.abstract) {
             throw new TypeError(`Core ${Key.of(definition.ref)} cannot use abstract Class ${classValue.key}.`);
         }
@@ -85,84 +200,41 @@ export function createDomain(input) {
         });
         definitionsByKey.set(resolved.key, resolved);
     }
-    const local = [...definitionsByKey.values()]
-        .filter(({ ref }) => ref.origin === input.origin)
-        .sort((left, right) => compare(left.key, right.key));
-    const classes = namespace(local, 'class');
-    const functions = namespace(local, 'function');
-    const policies = namespace(local, 'policy');
-    const views = namespace(local, 'view');
-    const coreNodes = namespace(local, 'core');
-    const domainEndpoint = Object.freeze({
-        kind: 'domain',
-        origin: input.origin,
-    });
-    const coreEdges = Object.freeze(input.coreEdges.map((edge) => {
-        const classValue = classesByKey.get(Key.of(edge.class));
-        if (classValue?.kind !== 'edge')
-            throw new TypeError(`Core Edge has no Edge Class ${Key.of(edge.class)}.`);
-        return Object.freeze({
-            class: classValue,
-            source: edge.source.kind === 'domain'
-                ? domainEndpoint
-                : requiredCore(definitionsByKey, edge.source),
-            target: edge.target.kind === 'domain'
-                ? domainEndpoint
-                : requiredCore(definitionsByKey, edge.target),
-            properties: edge.properties,
-        });
-    }));
+    return definitionsByKey;
+}
+function createCallables(definitions, classes) {
     const callables = new Map();
-    for (const definition of definitionsByKey.values()) {
-        if (definition.ref.kind === 'function')
+    for (const definition of definitions.values()) {
+        if (definition.ref.kind === 'function') {
             callables.set(definition.key, definition);
+        }
     }
-    for (const definition of classesByKey.values()) {
+    for (const definition of classes.values()) {
         if (definition.kind !== 'node')
             continue;
-        for (const method of [...definition.methods, ...definition.static.methods])
+        for (const method of [...definition.methods, ...definition.static.methods]) {
             callables.set(method.key, method);
+        }
     }
-    const definitionLookup = ((value) => definitionsByKey.get(typeof value === 'string' ? value : Key.of(value)));
-    const domain = {
-        origin: input.origin,
-        revision: input.revision,
-        closure: Object.freeze(input.closure.map(({ origin, revision }) => Object.freeze({ origin, revision }))),
-        dependencies: Object.freeze(input.dependencies.map(({ origin, revision }) => Object.freeze({ origin, revision }))),
-        classes,
-        functions,
-        policies,
-        views,
-        core: Object.freeze({ nodes: coreNodes, edges: coreEdges }),
-        definition: definitionLookup,
-        callable(key) {
-            return callables.get(key);
-        },
-        definitions(kind) {
-            return kind === undefined ? local : local.filter(({ ref }) => ref.kind === kind);
-        },
-        viewsFor(target) {
-            return Object.freeze(Object.values(views).filter((view) => {
-                if (view.target.kind === 'domain')
-                    return target === 'domain';
-                if (target === 'domain')
-                    return false;
-                return view.target.definitions.some((ref) => {
-                    const selected = classesByKey.get(Key.of(ref));
-                    if (target.kind === 'node' && selected?.kind === 'node') {
-                        return target.satisfies(selected);
-                    }
-                    if (target.kind === 'edge' && selected?.kind === 'edge') {
-                        return target.satisfies(selected);
-                    }
-                    return false;
-                });
-            }));
-        },
-    };
-    const admitted = Object.freeze(domain);
-    admittedDomains.add(admitted);
-    return admitted;
+    return callables;
+}
+function reachableEntries(root, entries) {
+    const reachable = new Map();
+    const pending = [root];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (reachable.has(current.origin))
+            continue;
+        reachable.set(current.origin, current);
+        for (const dependency of Object.values(current.dependencies)) {
+            const nested = entries.get(dependency.origin);
+            if (nested === undefined || nested.revision !== dependency.revision) {
+                throw new TypeError(`Domain universe has no exact ${dependency.origin}@${dependency.revision}.`);
+            }
+            pending.push(nested);
+        }
+    }
+    return [...reachable.values()];
 }
 function namespace(definitions, kind) {
     return frozenRecord(definitions

package/dist/v1/domain/model/domain.d.ts

@@ -14,12 +14,18 @@ export interface CoreNamespace<Nodes extends Readonly<Record<string, unknown>> =
     readonly nodes: Readonly<Nodes>;
     readonly edges: readonly ResolvedCoreEdge[];
 }
+/** Erased recursive dependency projection used when no authored Schema witness is available. */
+export interface DependencyDomains {
+    readonly [alias: string]: Domain<Readonly<Record<string, AnyResolvedClass>>, Readonly<Record<string, ResolvedFunction>>, Readonly<Record<string, ResolvedPolicy>>, Readonly<Record<string, ResolvedView>>, Readonly<Record<string, ResolvedCoreDefinition>>, Revision>;
+}
+export type DependencyDomainNamespace<Dependencies extends Readonly<Record<string, unknown>> = DependencyDomains> = Readonly<Dependencies>;
 export interface Domain<Classes extends Readonly<Record<string, unknown>> = Readonly<Record<string, AnyResolvedClass>>, Functions extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedFunction>>, Policies extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedPolicy>>, Views extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedView>>, CoreNodes extends Readonly<Record<string, unknown>> = Readonly<Record<string, ResolvedCoreDefinition>>, RevisionValue extends Revision = Revision> {
     readonly origin: Key.Origin;
     readonly revision: RevisionValue;
     /** Exact admitted root and transitive dependency revisions, ordered by origin. */
     readonly closure: readonly DomainDependency[];
-    readonly dependencies: readonly DomainDependency[];
+    /** Exact immutable direct dependency Domains keyed by authored Schema aliases. */
+    readonly dependencies: DependencyDomainNamespace;
     readonly classes: ClassNamespace<Classes>;
     readonly functions: FunctionNamespace<Functions>;
     readonly policies: PolicyNamespace<Policies>;

package/dist/v1/domain/model/input.d.ts

@@ -1,17 +1,21 @@
 import type { Key as AddressKey, PropertyKey, Revision } from '../../addressing/index.js';
-import type { DomainDependency } from '../../addressing/index.js';
+import type { DomainDependency, DomainDependencyMap } from '../../addressing/index.js';
 import type { CoreEdge } from '../../language/core/model/core.js';
 import type { Definition } from '../../language/definition.js';
 import type { Diagnostic } from '../../language/validation/diagnostic.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
-/** Dependency-closed, representation-neutral input to the one Domain constructor. */
-export interface DomainInput {
+/** One admitted Schema entry in a dependency-closed Domain universe. */
+export interface DomainEntryInput {
     readonly origin: AddressKey.Origin;
     readonly revision: Revision;
-    readonly closure: readonly DomainDependency[];
-    readonly dependencies: readonly DomainDependency[];
+    readonly dependencies: DomainDependencyMap;
     readonly definitions: readonly Definition[];
     readonly coreEdges: readonly CoreEdge[];
+}
+/** Dependency-closed, representation-neutral input to the one Domain universe constructor. */
+export interface DomainInput {
+    readonly root: DomainDependency;
+    readonly entries: readonly DomainEntryInput[];
     readonly validation: DomainValidation;
 }
 /** Already-bound validation semantics supplied by source compilation or compiled loading. */

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

@@ -1,5 +1,5 @@
 import type { Key } from '../../addressing/index.js';
-import type { DomainDependency } 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.
@@ -11,7 +11,7 @@ export interface DomainSchemaHeader {
     readonly format: 'astrale.dsl';
     readonly version: 'v1';
     readonly origin: Key.Origin;
-    readonly dependencies: readonly DomainDependency[];
+    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

@@ -17,7 +17,10 @@ export function header(input) {
     return Object.freeze({
         format: structured.format,
         version: structured.version,
-        dependencies: Object.freeze([...structured.dependencies]),
+        dependencies: Object.freeze(Object.fromEntries(Object.entries(structured.dependencies).map(([alias, dependency]) => [
+            alias,
+            Object.freeze({ ...dependency }),
+        ]))),
         origin: structured.origin,
     });
 }

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

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

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

@@ -1,5 +1,5 @@
 import type { Key } from '../../addressing/index.js';
-import type { DomainDependency } from '../../addressing/index.js';
+import type { DomainDependencyMap } from '../../addressing/index.js';
 import type { Domain, DomainOfSource, DomainSource } from '../../domain/model/domain.js';
 import type { FunctionDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
@@ -10,7 +10,7 @@ export interface DomainSchemaIR {
     readonly format: 'astrale.dsl';
     readonly version: 'v1';
     readonly origin: Key.Origin;
-    readonly dependencies: readonly DomainDependency[];
+    readonly dependencies: DomainDependencyMap;
     readonly classes: Readonly<Record<string, ClassDefinition>>;
     readonly functions: Readonly<Record<string, FunctionDefinition>>;
     readonly policies: Readonly<Record<string, PolicyDefinition>>;

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

@@ -11,7 +11,7 @@ export function normalizeDomainSchema(schema) {
         format: 'astrale.dsl',
         version: 'v1',
         origin: schema.origin,
-        dependencies: [...schema.dependencies].sort((left, right) => compareUnicode(left.origin, right.origin)),
+        dependencies: mapRecord(schema.dependencies, (dependency) => ({ ...dependency })),
         classes,
         functions: mapRecord(schema.functions, canonicalizeFunction),
         policies: mapRecord(schema.policies, canonicalizePolicy),

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

@@ -6,4 +6,4 @@ export declare function rememberDomainClosure(schema: DomainSchema, dependencies
 export declare function knownDomainClosure(schema: DomainSchema): readonly DomainSchemaEntry[] | undefined;
 export declare function requireDomainClosure(schema: DomainSchema): readonly DomainSchemaEntry[];
 export declare function lookupForDomainClosure(schema: DomainSchema): DomainSchemaLookup;
-export declare function lookupEntriesForDependencies(dependencies: readonly DomainSchema[]): readonly DomainSchemaEntry[];
+export declare function lookupEntriesForDependencies(dependencies: Readonly<Record<string, DomainSchema>>): readonly DomainSchemaEntry[];

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

@@ -29,7 +29,7 @@ export function lookupForDomainClosure(schema) {
 }
 export function lookupEntriesForDependencies(dependencies) {
     const entries = new Map();
-    for (const schema of dependencies) {
+    for (const schema of Object.values(dependencies)) {
         const revision = revisionOfDomainSchema(schema);
         entries.set(closureKey(schema.origin, revision), { schema, revision });
         for (const entry of requireDomainClosure(schema)) {

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

@@ -1,3 +1,4 @@
+import { dependencyLimits } from '../../addressing/domain-dependency.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { DOMAIN_REVISION_PATTERN } from '../../addressing/patterns.js';
 import { revisionOfDomainSchema } from '../canonical/revision.js';
@@ -9,8 +10,11 @@ export function buildDomainResolutionContext(candidate, lookup) {
     const dependencies = new Map();
     const definitions = new Map();
     const directOrigins = new Set();
-    for (const [index, dependency] of candidate.dependencies.entries()) {
-        const pointer = `/dependencies/${index}`;
+    if (Object.keys(candidate.dependencies).length > dependencyLimits.direct) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/dependencies', `A Domain may declare at most ${dependencyLimits.direct} direct dependency aliases.`));
+    }
+    for (const [alias, dependency] of Object.entries(candidate.dependencies)) {
+        const pointer = `/dependencies/${escapeToken(alias)}`;
         if (!DOMAIN_REVISION_PATTERN.test(dependency.revision))
             continue;
         if (dependency.origin === candidate.origin) {
@@ -68,48 +72,78 @@ export function buildDomainResolutionContext(candidate, lookup) {
 }
 function loadDependencyClosure(candidate, dependencies, lookup, diagnostics) {
     const revisionByOrigin = new Map();
-    const visiting = new Set();
     const visited = new Set();
-    const visit = (schema, key) => {
-        if (visiting.has(key)) {
-            diagnostics.push(diagnostic('DV_DEPENDENCY_ACYCLIC', '/dependencies', `Dependency cycle reaches ${schema.origin}.`));
-            return;
+    const activeOrigins = new Set([candidate.origin]);
+    const frames = [
+        {
+            schema: candidate,
+            key: `${candidate.origin}\u0000candidate`,
+            depth: 0,
+            edges: Object.entries(candidate.dependencies),
+            index: 0,
+        },
+    ];
+    let closureLimitReported = false;
+    while (frames.length > 0) {
+        const frame = frames.at(-1);
+        const edge = frame.edges[frame.index++];
+        if (edge === undefined) {
+            frames.pop();
+            activeOrigins.delete(frame.schema.origin);
+            visited.add(frame.key);
+            continue;
         }
-        if (visited.has(key))
-            return;
-        visiting.add(key);
-        for (const dependency of schema.dependencies) {
-            if (dependency.origin === candidate.origin) {
-                diagnostics.push(diagnostic('DV_DEPENDENCY_ACYCLIC', '/dependencies', `Dependency cycle returns to ${candidate.origin}.`));
-                continue;
-            }
-            const previous = revisionByOrigin.get(dependency.origin);
-            if (previous !== undefined && previous !== dependency.revision) {
-                diagnostics.push(diagnostic('DV_DEPENDENCY_REVISION_COHERENCE', '/dependencies', `Closure contains ${dependency.origin} at both ${previous} and ${dependency.revision}.`));
-            }
-            else {
-                revisionByOrigin.set(dependency.origin, dependency.revision);
-            }
-            const nested = dependencies.get(dependency.origin) ?? lookup.get(dependency.origin, dependency.revision);
-            if (nested === undefined) {
-                diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', '/dependencies', `Dependency closure is missing ${dependency.origin}@${dependency.revision}.`));
-                continue;
-            }
-            if (nested.origin !== dependency.origin) {
-                diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', '/dependencies', `Schema lookup value origin ${nested.origin} disagrees with ${dependency.origin}.`));
-                continue;
-            }
-            if (revisionOfDomainSchema(nested) !== dependency.revision) {
-                diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', '/dependencies', `Schema lookup content for ${dependency.origin} disagrees with ${dependency.revision}.`));
-                continue;
+        const [alias, dependency] = edge;
+        const pointer = frames.length === 1 ? `/dependencies/${escapeToken(alias)}` : '/dependencies';
+        if (activeOrigins.has(dependency.origin)) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_ACYCLIC', pointer, `Dependency cycle reaches ${dependency.origin}.`));
+            continue;
+        }
+        const previous = revisionByOrigin.get(dependency.origin);
+        if (previous !== undefined && previous !== dependency.revision) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_REVISION_COHERENCE', pointer, `Closure contains ${dependency.origin} at both ${previous} and ${dependency.revision}.`));
+        }
+        else {
+            revisionByOrigin.set(dependency.origin, dependency.revision);
+        }
+        const nested = dependencies.get(dependency.origin) ?? lookup.get(dependency.origin, dependency.revision);
+        if (nested === undefined) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', pointer, `Dependency closure is missing ${dependency.origin}@${dependency.revision}.`));
+            continue;
+        }
+        if (nested.origin !== dependency.origin) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', pointer, `Schema lookup value origin ${nested.origin} disagrees with ${dependency.origin}.`));
+            continue;
+        }
+        if (revisionOfDomainSchema(nested) !== dependency.revision) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', pointer, `Schema lookup content for ${dependency.origin} disagrees with ${dependency.revision}.`));
+            continue;
+        }
+        dependencies.set(nested.origin, nested);
+        if (dependencies.size + 1 > dependencyLimits.closure) {
+            if (!closureLimitReported) {
+                diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/dependencies', `A dependency closure may contain at most ${dependencyLimits.closure} Domains.`));
+                closureLimitReported = true;
             }
-            dependencies.set(nested.origin, nested);
-            visit(nested, `${dependency.origin}\u0000${dependency.revision}`);
+            continue;
+        }
+        const depth = frame.depth + 1;
+        if (depth > dependencyLimits.depth) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', pointer, `Dependency depth ${depth} exceeds the maximum ${dependencyLimits.depth}.`));
+            continue;
         }
-        visiting.delete(key);
-        visited.add(key);
-    };
-    visit(candidate, `${candidate.origin}\u0000candidate`);
+        const key = `${dependency.origin}\u0000${dependency.revision}`;
+        if (visited.has(key))
+            continue;
+        activeOrigins.add(nested.origin);
+        frames.push({
+            schema: nested,
+            key,
+            depth,
+            edges: Object.entries(nested.dependencies),
+            index: 0,
+        });
+    }
 }
 function validateDependencyUse(candidate, directOrigins, diagnostics) {
     const used = collectUsedForeignOrigins(candidate);
@@ -118,9 +152,7 @@ function validateDependencyUse(candidate, directOrigins, diagnostics) {
             diagnostics.push(diagnostic('DV_DEPENDENCY_DIRECT', '', `Foreign origin ${origin} is referenced without an exact direct dependency.`));
         }
     }
-    for (const origin of directOrigins) {
-        if (!used.has(origin)) {
-            diagnostics.push(diagnostic('DV_DEPENDENCY_USED', '/dependencies', `Dependency ${origin} is not referenced by the Domain.`));
-        }
-    }
+}
+function escapeToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }

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

@@ -29,17 +29,20 @@ function resolveWithLookup(schema, lookup) {
     const closure = [schema, ...validation.context.dependencies.values()];
     const registries = new Map(closure.map((owner) => [owner.origin, createDomainValueSchemaRegistry(owner, lookup)]));
     const input = {
-        origin: schema.origin,
-        revision: revisionOfDomainSchema(schema),
-        closure: Object.freeze(closure
+        root: Object.freeze({
+            origin: schema.origin,
+            revision: revisionOfDomainSchema(schema),
+        }),
+        entries: Object.freeze(closure
+            .filter((owner, index, values) => values.findIndex(({ origin }) => origin === owner.origin) === index)
             .map((owner) => Object.freeze({
             origin: owner.origin,
             revision: revisionOfDomainSchema(owner),
+            dependencies: owner.dependencies,
+            definitions: Object.freeze(definitionsOf(owner)),
+            coreEdges: owner.core.edges,
         }))
             .sort((left, right) => compareUnicode(left.origin, right.origin))),
-        dependencies: schema.dependencies,
-        definitions: Object.freeze(closure.flatMap(definitionsOf)),
-        coreEdges: schema.core.edges,
         validation: sourceValidation(closure, registries),
     };
     const domain = createDomain(input);

package/dist/v1/schema/resolution/value.registry.js

@@ -9,7 +9,7 @@ export function createDomainValueSchemaRegistry(schema, lookup = lookupForDomain
 export function createValueSchemaRegistry(context) {
     const directDependencies = [];
     const transitiveDependencies = [];
-    const directOrigins = new Set(context.candidate.dependencies.map(({ origin }) => origin));
+    const directOrigins = new Set(Object.values(context.candidate.dependencies).map(({ origin }) => origin));
     for (const schema of context.dependencies.values()) {
         const entry = {
             ...domainValueRegistry(schema),
@@ -33,7 +33,7 @@ function domainValueRegistry(schema) {
         .map(([name]) => ({ origin: schema.origin, kind: 'class', name }));
     return Object.freeze({
         origin: schema.origin,
-        dependencies: schema.dependencies,
+        dependencies: Object.values(schema.dependencies),
         nodeDefinitions: Object.freeze(nodeDefinitions),
     });
 }