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

package/dist/v1/schema/admission/accept.d.ts

@@ -1,4 +1,3 @@
 import type { DomainSchemaLookup } from '../dependency/lookup.js';
 import type { DomainSchema } from '../model/schema.js';
 export declare function acceptDomainSchema(input: unknown, lookup?: DomainSchemaLookup): DomainSchema;
-//# sourceMappingURL=accept.d.ts.map

package/dist/v1/schema/admission/accept.js

@@ -24,4 +24,3 @@ export function acceptDomainSchema(input, lookup = emptyDomainSchemaLookup()) {
     rememberDomainClosure(accepted, validation.context.dependencies.values());
     return accepted;
 }
-//# sourceMappingURL=accept.js.map

package/dist/v1/schema/analysis/class.d.ts

@@ -39,4 +39,3 @@ export interface DefinitionAnalysisResult {
     readonly diagnostics: readonly SchemaDiagnostic[];
 }
 export declare function analyzeDefinitions(environment: DomainResolutionContext): DefinitionAnalysisResult;
-//# sourceMappingURL=class.d.ts.map

package/dist/v1/schema/analysis/class.js

@@ -179,4 +179,3 @@ function canonicalMethodOutput(value) {
 function canonicalPolicy(value) {
     return json.serialize(value === undefined ? null : normalizePolicyChecks(value));
 }
-//# sourceMappingURL=class.js.map

package/dist/v1/schema/canonical/domain.d.ts

@@ -1,4 +1,3 @@
 import type { DomainSchemaIR } from '../model/schema.js';
 /** Produce the deterministic semantic document consumed by canonical JSON serialization. */
 export declare function canonicalizeDomainSchema(schema: DomainSchemaIR): DomainSchemaIR;
-//# sourceMappingURL=domain.d.ts.map

package/dist/v1/schema/canonical/domain.digest.d.ts

@@ -1,4 +1,3 @@
 import type { Revision } from '../../addressing/index.js';
 /** Content-address canonical DomainSchema bytes with the V1 revision algorithm. */
 export declare function digestDomainSchemaBytes(bytes: Uint8Array): Revision;
-//# sourceMappingURL=domain.digest.d.ts.map

package/dist/v1/schema/canonical/domain.digest.js

@@ -3,4 +3,3 @@ import { digestRevisionBytes } from '../../addressing/revision.js';
 export function digestDomainSchemaBytes(bytes) {
     return digestRevisionBytes(bytes);
 }
-//# sourceMappingURL=domain.digest.js.map

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

@@ -3,4 +3,3 @@ import { normalizeDomainSchema } from '../normalization/domain.js';
 export function canonicalizeDomainSchema(schema) {
     return normalizeDomainSchema(schema);
 }
-//# sourceMappingURL=domain.js.map

package/dist/v1/schema/canonical/freeze.d.ts

@@ -1,2 +1 @@
 export declare function deepFreeze<T>(value: T): Readonly<T>;
-//# sourceMappingURL=freeze.d.ts.map

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/canonical/revision.d.ts

@@ -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=revision.d.ts.map

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

@@ -15,4 +15,3 @@ export function canonicalDomainSchemaAfterValidation(value) {
 export function revisionOfDomainSchema(schema) {
     return canonicalDomainSchema(schema).revision;
 }
-//# sourceMappingURL=revision.js.map

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,8 +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;
-//# sourceMappingURL=header.d.ts.map

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

@@ -17,8 +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,
     });
 }
-//# sourceMappingURL=header.js.map

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

@@ -3,4 +3,3 @@ 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=schema.d.ts.map

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

@@ -19,4 +19,3 @@ export function serializeDomainSchema(schema) {
 export function encodeDomainSchema(schema) {
     return json.encode(schema);
 }
-//# sourceMappingURL=schema.js.map

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

@@ -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=meaning.d.ts.map

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

@@ -603,4 +603,3 @@ function requireMemberRef(ref) {
 function isJsonSchema(value) {
     return typeof value === 'boolean' || isJsonObject(value);
 }
-//# sourceMappingURL=meaning.js.map

package/dist/v1/schema/dependency/lookup.d.ts

@@ -16,4 +16,3 @@ export declare class MemoryDomainSchemaLookup implements DomainSchemaLookup {
     set(entry: DomainSchemaEntry): this;
 }
 export declare function emptyDomainSchemaLookup(): DomainSchemaLookup;
-//# sourceMappingURL=lookup.d.ts.map

package/dist/v1/schema/dependency/lookup.js

@@ -29,4 +29,3 @@ export function emptyDomainSchemaLookup() {
 function lookupKey(origin, revision) {
     return `${origin}\u0000${revision}`;
 }
-//# sourceMappingURL=lookup.js.map

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;
@@ -10,4 +10,3 @@ export declare class SchemaError extends Error {
     readonly diagnostics: readonly SchemaDiagnostic[];
     constructor(diagnostics: readonly SchemaDiagnostic[]);
 }
-//# sourceMappingURL=diagnostic.d.ts.map

package/dist/v1/schema/diagnostic.js

@@ -19,4 +19,3 @@ function compareDiagnostic(left, right) {
 function formatDiagnostic(value) {
     return `${value.pointer || '/'} [${value.code}] ${value.message}`;
 }
-//# sourceMappingURL=diagnostic.js.map

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

@@ -1,16 +1,16 @@
 /** Admit, encode, inspect, and semantically resolve canonical V1 DomainSchemas. */
 import type { SourceDomain } from '../domain/index.js';
-import type { DomainOfSchema, DomainSchema } from './model/schema.js';
+import type { DomainSchema } from './model/schema.js';
 export type { DomainSchema, DomainSchemaIR, DomainOfSchema as DomainOf, DomainSchemaInputOf as InputOf, } from './model/schema.js';
-export type ResolvedDomainOf<Schema extends DomainSchema> = SourceDomain<Schema, DomainOfSchema<Schema>>;
+export type ResolvedDomainOf<Schema extends DomainSchema> = SourceDomain<Schema>;
 export interface Resolve {
     <const Schema extends DomainSchema>(schema: Schema): ResolvedDomainOf<Schema>;
 }
+export declare const resolve: Resolve;
 export type { SchemaDiagnosticCode as DiagnosticCode } from './diagnostic.js';
 export { acceptDomainSchema as accept } from './admission/accept.js';
 export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
-export { resolve } from './resolution/domain.js';
 export { compareDependencyMeaning, compareMemberMeaning } from './compatibility/meaning.js';
 export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, MeaningFingerprint, } from './compatibility/meaning.js';
 export { header } from './codec/header.js';
@@ -24,4 +24,3 @@ export type { DomainSchemaHeader as Header } from './codec/header.js';
 export type { DomainDependency } from '../addressing/index.js';
 /** The versioned value-schema grammar embedded in declarations. */
 export * as values from './validation/value-api.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/schema/index.js

@@ -1,8 +1,9 @@
 /** Admit, encode, inspect, and semantically resolve canonical V1 DomainSchemas. */
+import { resolve as resolveDomainSchema } from './resolution/domain.js';
+export const resolve = resolveDomainSchema;
 export { acceptDomainSchema as accept } from './admission/accept.js';
 export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
-export { resolve } from './resolution/domain.js';
 export { compareDependencyMeaning, compareMemberMeaning } from './compatibility/meaning.js';
 export { header } from './codec/header.js';
 export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
@@ -10,4 +11,3 @@ export { compile, load } from '../compiled/index.js';
 export { SchemaError as Error } from './diagnostic.js';
 /** The versioned value-schema grammar embedded in declarations. */
 export * as values from './validation/value-api.js';
-//# sourceMappingURL=index.js.map

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

@@ -1,3 +1,2 @@
 export declare const DOMAIN_FORMAT: 'astrale.dsl';
 export declare const DOMAIN_VERSION: 'v1';
-//# sourceMappingURL=format.d.ts.map

package/dist/v1/schema/model/format.js

@@ -1,3 +1,2 @@
 export const DOMAIN_FORMAT = 'astrale.dsl';
 export const DOMAIN_VERSION = 'v1';
-//# sourceMappingURL=format.js.map

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

@@ -1,6 +1,6 @@
 import type { Key } from '../../addressing/index.js';
-import type { DomainDependency } from '../../addressing/index.js';
-import type { Domain } from '../../domain/model/domain.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';
 import type { CoreContent } from '../../language/core/model/core.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>>;
@@ -19,22 +19,19 @@ export interface DomainSchemaIR {
 }
 declare const DOMAIN_SCHEMA_BRAND: unique symbol;
 declare const DOMAIN_SCHEMA_INPUT: unique symbol;
-declare const DOMAIN_SCHEMA_DOMAIN: unique symbol;
 /**
  * Accepted canonical schema retaining its exact builder input at the type level.
  *
  * The input marker never exists as a JavaScript property and therefore cannot
  * affect canonical JSON, bytes, or revision identity.
  */
-export type DomainSchema<Origin extends string = string, Input = unknown, Resolved extends Domain = Domain> = DomainSchemaIR & {
+export type DomainSchema<Origin extends string = string, Input = unknown, Resolved extends Domain = Domain> = DomainSchemaIR & DomainSource<Resolved> & {
     readonly origin: Origin;
     readonly [DOMAIN_SCHEMA_BRAND]: true;
     readonly [DOMAIN_SCHEMA_INPUT]: Input;
-    readonly [DOMAIN_SCHEMA_DOMAIN]: Resolved;
 };
 /** Recover the exact builder input retained by a locally defined schema. */
 export type DomainSchemaInputOf<Schema extends DomainSchema> = Schema[typeof DOMAIN_SCHEMA_INPUT];
-export type DomainOfSchema<Schema extends DomainSchema> = Schema[typeof DOMAIN_SCHEMA_DOMAIN];
+export type DomainOfSchema<Schema extends DomainSchema> = DomainOfSource<Schema>;
 export declare function asDomainSchema<Origin extends string = string, Input = unknown, Resolved extends Domain = Domain>(value: DomainSchemaIR): DomainSchema<Origin, Input, Resolved>;
 export {};
-//# sourceMappingURL=schema.d.ts.map

package/dist/v1/schema/model/schema.js

@@ -2,4 +2,3 @@ import { deepFreeze } from '../canonical/freeze.js';
 export function asDomainSchema(value) {
     return deepFreeze(value);
 }
-//# sourceMappingURL=schema.js.map

package/dist/v1/schema/normalization/domain.d.ts

@@ -1,3 +1,2 @@
 import type { DomainSchemaIR } from '../model/schema.js';
 export declare function normalizeDomainSchema(schema: DomainSchemaIR): DomainSchemaIR;
-//# sourceMappingURL=domain.d.ts.map

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),
@@ -205,4 +205,3 @@ function copyJsonValue(value) {
         return value.map((entry) => copyJsonValue(entry));
     return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, copyJsonValue(entry)]));
 }
-//# sourceMappingURL=domain.js.map

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

@@ -6,5 +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[];
-//# sourceMappingURL=closure.d.ts.map
+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)) {
@@ -47,4 +47,3 @@ function freezeEntries(entries) {
 function closureKey(origin, revision) {
     return `${origin}\u0000${revision}`;
 }
-//# sourceMappingURL=closure.js.map

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

@@ -15,4 +15,3 @@ export interface DomainResolutionContext {
     resolvePolicy(ref: PolicyRef): PolicyDefinition | undefined;
 }
 export declare function buildDomainResolutionContext(candidate: DomainSchemaIR, lookup: DomainSchemaLookup): DomainResolutionContext;
-//# sourceMappingURL=context.d.ts.map

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,10 +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.`));
-        }
-    }
 }
-//# sourceMappingURL=context.js.map
+function escapeToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

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

@@ -19,4 +19,3 @@ export type IndexedClassDefinition = {
 };
 export declare function indexSchemaDefinitions(schema: DomainSchemaIR): ReadonlyMap<string, IndexedClassDefinition>;
 export declare function resolveIndexedReference(indexes: ReadonlyMap<string, IndexedClassDefinition>, ref: DefinitionRef): IndexedClassDefinition | undefined;
-//# sourceMappingURL=definition.index.d.ts.map

package/dist/v1/schema/resolution/definition.index.js

@@ -15,4 +15,3 @@ export function indexSchemaDefinitions(schema) {
 export function resolveIndexedReference(indexes, ref) {
     return ref.kind === 'class' ? indexes.get(definitionRefIndex(ref)) : undefined;
 }
-//# sourceMappingURL=definition.index.js.map

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

@@ -1,5 +1,4 @@
 import type { SourceDomain } from '../../domain/model/domain.js';
-import type { DomainOfSchema, DomainSchema } from '../model/schema.js';
+import type { DomainSchema } from '../model/schema.js';
 /** Resolve one accepted Schema through its exact retained source closure. */
-export declare function resolve<const S extends DomainSchema>(schema: S): SourceDomain<S, DomainOfSchema<S>>;
-//# sourceMappingURL=domain.d.ts.map
+export declare function resolve<const S extends DomainSchema>(schema: S): SourceDomain<S>;

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);
@@ -107,4 +110,3 @@ function definitionsOf(schema) {
         ...Object.values(schema.core.nodes),
     ];
 }
-//# sourceMappingURL=domain.js.map

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

@@ -12,4 +12,3 @@ export declare function collectClassRefs(declaration: ClassDefinition, add: (ref
 export declare function collectCallableRefs(declaration: FunctionDefinition | MethodDefinition, add: (ref: DefinitionRef) => void): void;
 export declare function collectPolicyDefinitionRefs(declaration: PolicyDefinition, add: (ref: DefinitionRef) => void): void;
 export declare function collectValueDefinitionRefs(schema: JsonSchema, add: (ref: DefinitionRef) => void): void;
-//# sourceMappingURL=origins.d.ts.map

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

@@ -119,4 +119,3 @@ export function collectValueDefinitionRefs(schema, add) {
         }
     });
 }
-//# sourceMappingURL=origins.js.map

package/dist/v1/schema/resolution/value.registry.d.ts

@@ -5,4 +5,3 @@ import type { DomainResolutionContext } from './context.js';
 /** Build the exact value-schema resource closure for one installed Domain. */
 export declare function createDomainValueSchemaRegistry(schema: DomainSchema, lookup?: DomainSchemaLookup): ValueSchemaRegistry;
 export declare function createValueSchemaRegistry(context: DomainResolutionContext): ValueSchemaRegistry;
-//# sourceMappingURL=value.registry.d.ts.map

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,8 +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),
     });
 }
-//# sourceMappingURL=value.registry.js.map

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

@@ -1,2 +1 @@
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
-//# sourceMappingURL=revision.d.ts.map

package/dist/v1/schema/revision.js

@@ -1,2 +1 @@
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
-//# sourceMappingURL=revision.js.map

package/dist/v1/schema/validation/class.d.ts

@@ -3,4 +3,3 @@ import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
 /** Validate the semantic contracts owned by Class declarations. */
 export declare function validateDefinitions(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult): readonly SchemaDiagnostic[];
-//# sourceMappingURL=class.d.ts.map

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

@@ -206,4 +206,3 @@ function sameRef(left, right) {
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=class.js.map

package/dist/v1/schema/validation/core.d.ts

@@ -3,4 +3,3 @@ import type { DefinitionAnalysisResult } from '../analysis/class.js';
 import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
 export declare function validateCore(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult, registry: ValueSchemaRegistry): readonly SchemaDiagnostic[];
-//# sourceMappingURL=core.d.ts.map

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

@@ -262,4 +262,3 @@ function classExtendsAny(environment, parents, accepts, visited) {
 function escapePointer(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=core.js.map

package/dist/v1/schema/validation/domain.d.ts

@@ -9,4 +9,3 @@ export interface DomainSchemaValidation {
     readonly diagnostics: readonly SchemaDiagnostic[];
 }
 export declare function validateDomainSchemaSemantics(schema: DomainSchemaIR, lookup: DomainSchemaLookup): DomainSchemaValidation;
-//# sourceMappingURL=domain.d.ts.map

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

@@ -34,4 +34,3 @@ function orderAndDeduplicate(diagnostics) {
         compareUnicode(left.code, right.code) ||
         compareUnicode(left.message, right.message));
 }
-//# sourceMappingURL=domain.js.map