@astrale-os/kernel-dsl 0.2.0-beta.1 → 0.2.0-beta.10

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

@@ -1,36 +1,26 @@
 /** Admit, encode, inspect, and semantically resolve canonical V1 DomainSchemas. */
-export type { DomainSchema, DomainSchemaIR, DomainSchemaInputOf as InputOf } from './domain.ir.js';
-export { acceptDomainSchema as accept } from './domain.accept.js';
-export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './domain.codec.js';
-export { revisionOfDomainSchema as revision } from './domain.revision.js';
-export { resolveDomainSchema as resolve } from './domain.resolve.js';
-export { compareDependencyMeaning, compareMemberMeaning } from './dependency.meaning.js';
-export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, } from './dependency.meaning.js';
-export { readDomainSchemaHeader as readHeader } from './domain.header.js';
-export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './reference.js';
-export { namedTypeUri as typeUri } from './reference.js';
-export { patterns } from '../addressing/index.js';
-export { DomainSchemaError as Error } from './diagnostic.js';
-export type { DomainDiagnostic as Diagnostic } from './diagnostic.js';
-export type { DomainSchemaLookup as Lookup } from './domain.lookup.js';
-export type { DomainSchemaHeader as Header } from './domain.header.js';
-/** Exact structured identities retained only by schema lifecycle and resolution. */
-export type { CoreEndpointRef, CoreRef, ClassFamily, ClassRef, DefinitionKind, DefinitionRef, DomainDependency, DomainMemberKind, DomainRef, Revision, Family, FunctionRef, MemberKind, InterfaceFamily, InterfaceRef, PolicyRef, SchemaRef, ValueTypeRef, ViewRef, } from './reference.js';
-export type { ClassDeclaration, NodeClassDeclaration, EdgeClassDeclaration, EdgeClassPolicies, NodeClassPolicies, } from './definition/class.js';
-export type { InterfaceDeclaration, NodeInterfaceDeclaration, EdgeInterfaceDeclaration, } from './definition/interface.js';
-export type { DefinitionAnalysis } from './definition/analysis.js';
-export type { PropertyFacet, PropertyMetadata, PropertyMetadataRecord, PropertyVisibility, } from './definition/property.js';
-export type { PropertyObjectSchema } from './value/schema.js';
-export type { Cardinality, EdgeConstraints, EdgeContract, EdgeEndpoint, EdgeEndpoints, EdgeOrientation, } from './definition/edge.js';
-export type { CallableContract, CallableOutput, AuthenticationMode, FunctionDeclaration, MethodDeclaration, MethodInheritance, MethodRecord, OutputMode, } from './callable.js';
-export type { DataDeclaration, DataFacet, MediaType } from './definition/data.js';
-export type { ViewDeclaration, ViewTarget } from './view/declaration.js';
-export type { PolicyCheckExpression, PolicyCheckObject, PolicyObjectRef, PolicyDeclaration, PolicyEdgePattern, PolicyVariable, PolicyPatternExpression, PolicyPatternTerm, PolicyRepeat, } from './policy/ast.js';
-export type { CoreDeclaration, CoreEdgeDeclaration, CoreNodeDeclaration, } from './core/declaration.js';
-export type { ResolvedDomainSchema as Resolution, ResolvedDomainSchemaReferences as ResolutionReferences, } from './domain.resolve.js';
-export type { ResolvedDefinition } from './resolution/definition.index.js';
+import type { SourceDomain } from '../domain/index.js';
+import type { DomainSchema } from './model/schema.js';
+export type { DomainSchema, DomainSchemaIR, DomainOfSchema as DomainOf } from './model/schema.js';
+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 { compareDependencyMeaning, compareMemberMeaning } from './compatibility/meaning.js';
+export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, MeaningFingerprint, } from './compatibility/meaning.js';
+export { header } from './codec/header.js';
+export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
+export { compile, load } from '../compiled/index.js';
+export type { CompiledSchema, DomainOfCompiled } from '../compiled/index.js';
+export { SchemaError as Error } from './diagnostic.js';
+export type { SchemaDiagnostic as Diagnostic } from './diagnostic.js';
+export type { DomainSchemaLookup as Lookup } from './dependency/lookup.js';
+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 './value/index.js';
-/** Shared exact value bounds for declaration metadata. */
-export * as metadata from './metadata.js';
-//# sourceMappingURL=index.d.ts.map
+export * as values from './validation/value-api.js';

package/dist/v1/schema/index.js

@@ -1,16 +1,13 @@
 /** Admit, encode, inspect, and semantically resolve canonical V1 DomainSchemas. */
-export { acceptDomainSchema as accept } from './domain.accept.js';
-export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './domain.codec.js';
-export { revisionOfDomainSchema as revision } from './domain.revision.js';
-export { resolveDomainSchema as resolve } from './domain.resolve.js';
-export { compareDependencyMeaning, compareMemberMeaning } from './dependency.meaning.js';
-export { readDomainSchemaHeader as readHeader } from './domain.header.js';
-export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './reference.js';
-export { namedTypeUri as typeUri } from './reference.js';
-export { patterns } from '../addressing/index.js';
-export { DomainSchemaError as Error } from './diagnostic.js';
+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 { 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';
+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 './value/index.js';
-/** Shared exact value bounds for declaration metadata. */
-export * as metadata from './metadata.js';
-//# sourceMappingURL=index.js.map
+export * as values from './validation/value-api.js';

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

@@ -0,0 +1,2 @@
+export declare const DOMAIN_FORMAT: 'astrale.dsl';
+export declare const DOMAIN_VERSION: 'v1';

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

@@ -0,0 +1,2 @@
+export const DOMAIN_FORMAT = 'astrale.dsl';
+export const DOMAIN_VERSION = 'v1';

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

@@ -0,0 +1,30 @@
+import type { Key } 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';
+import type { CoreContent } from '../../language/core/model/core.js';
+import type { PolicyDefinition } from '../../language/policy/model/policy.js';
+import type { ViewDefinition } from '../../language/view/model/view.js';
+export interface DomainSchemaIR {
+    readonly format: 'astrale.dsl';
+    readonly version: 'v1';
+    readonly origin: Key.Origin;
+    readonly dependencies: DomainDependencyMap;
+    readonly classes: Readonly<Record<string, ClassDefinition>>;
+    readonly functions: Readonly<Record<string, FunctionDefinition>>;
+    readonly policies: Readonly<Record<string, PolicyDefinition>>;
+    readonly views: Readonly<Record<string, ViewDefinition>>;
+    readonly core: CoreContent;
+}
+declare const DOMAIN_SCHEMA_BRAND: unique symbol;
+/**
+ * Accepted canonical schema carrying its exact resolved Domain projection.
+ */
+export type DomainSchema<Origin extends string = string, Resolved extends Domain = Domain> = DomainSchemaIR & DomainSource<Resolved> & {
+    readonly origin: Origin;
+    readonly [DOMAIN_SCHEMA_BRAND]: true;
+};
+export type DomainOfSchema<Schema extends DomainSchema> = DomainOfSource<Schema>;
+export declare function asDomainSchema<Origin extends string = string, Resolved extends Domain = Domain>(value: DomainSchemaIR): DomainSchema<Origin, Resolved>;
+export {};

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

@@ -0,0 +1,4 @@
+import { deepFreeze } from '../canonical/freeze.js';
+export function asDomainSchema(value) {
+    return deepFreeze(value);
+}

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

@@ -0,0 +1,2 @@
+import type { DomainSchemaIR } from '../model/schema.js';
+export declare function normalizeDomainSchema(schema: DomainSchemaIR): DomainSchemaIR;

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

@@ -0,0 +1,207 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { compareDefinitionRefs, compareUnicode } from '../../addressing/ordering.js';
+import { normalizePolicyChecks, normalizePolicyExpression, } from '../../language/policy/normalization/normalize.js';
+import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
+export function normalizeDomainSchema(schema) {
+    const classes = mapRecord(schema.classes, canonicalizeClass);
+    const orientationByClass = new Map(Object.entries(classes)
+        .filter((entry) => entry[1].kind === 'edge')
+        .map(([name, declaration]) => [name, declaration.orientation]));
+    const normalized = {
+        format: 'astrale.dsl',
+        version: 'v1',
+        origin: schema.origin,
+        dependencies: mapRecord(schema.dependencies, (dependency) => ({ ...dependency })),
+        classes,
+        functions: mapRecord(schema.functions, canonicalizeFunction),
+        policies: mapRecord(schema.policies, canonicalizePolicy),
+        views: mapRecord(schema.views, canonicalizeView),
+        core: {
+            nodes: mapRecord(schema.core.nodes, (node) => ({
+                ref: node.ref,
+                class: node.class,
+                properties: copyJsonValue(node.properties),
+            })),
+            edges: schema.core.edges
+                .map((edge) => canonicalizeCoreEdge(edge, schema.origin, orientationByClass))
+                .sort(compareCoreEdges),
+        },
+    };
+    return copyJsonValue(normalized);
+}
+function canonicalizePolicy(value) {
+    return {
+        ref: value.ref,
+        ...withDescription(value),
+        expression: normalizePolicyExpression(value.expression),
+    };
+}
+function canonicalizeView(value) {
+    return {
+        ref: value.ref,
+        ...withDescription(value),
+        target: value.target.kind === 'domain'
+            ? { kind: 'domain' }
+            : {
+                kind: 'definition',
+                definitions: [...value.target.definitions].sort(compareDefinitionRefs),
+            },
+    };
+}
+function canonicalizeClass(value) {
+    const base = {
+        ...withDescription(value),
+        ref: value.ref,
+        kind: value.kind,
+        abstract: value.abstract,
+        extends: [...value.extends].sort(compareDefinitionRefs),
+        properties: mapRecord(value.properties, canonicalizeProperty),
+    };
+    if (value.kind === 'node') {
+        return {
+            ...base,
+            methods: mapRecord(value.methods, canonicalizeMethod),
+            ...(value.data === undefined ? {} : { data: { mediaType: value.data.mediaType } }),
+            ...(value.icon === undefined ? {} : { icon: value.icon }),
+            policies: value.policies,
+        };
+    }
+    return value.orientation === 'directed'
+        ? {
+            ...base,
+            orientation: 'directed',
+            endpoints: canonicalizeDirectedEndpoints(value.endpoints),
+            policies: value.policies,
+            constraints: value.constraints,
+        }
+        : {
+            ...base,
+            orientation: 'undirected',
+            endpoints: canonicalizeIncidentEndpoints(value.endpoints),
+            policies: value.policies,
+            constraints: value.constraints,
+        };
+}
+function canonicalizeFunction(value) {
+    return {
+        ref: value.ref,
+        ...canonicalizeCallable(value),
+    };
+}
+function canonicalizeCallable(value) {
+    const base = {
+        ...withDescription(value),
+        input: canonicalizeValueSchema(value.input, 'callable-input'),
+        output: canonicalizeCallableOutput(value.output),
+    };
+    return value.auth === 'authorized'
+        ? {
+            ...base,
+            auth: value.auth,
+            ...(value.policy === undefined ? {} : { policy: normalizePolicyChecks(value.policy) }),
+        }
+        : { ...base, auth: value.auth };
+}
+function canonicalizeMethod(value) {
+    return {
+        ...canonicalizeCallable(value),
+        static: value.static,
+        inheritance: value.inheritance,
+    };
+}
+function canonicalizeCallableOutput(value) {
+    switch (value.mode) {
+        case 'value':
+            return { mode: 'value', schema: canonicalizeValueSchema(value.schema, 'callable-output') };
+        case 'stream':
+            return { mode: 'stream', item: canonicalizeValueSchema(value.item, 'callable-output') };
+        case 'binary':
+            return { mode: 'binary' };
+    }
+}
+function canonicalizeProperty(value) {
+    return {
+        schema: canonicalizeValueSchema(value.schema, 'property-facet'),
+        required: value.required,
+        visibility: value.visibility,
+        ...(value.auto === undefined
+            ? {}
+            : {
+                auto: {
+                    on: [...new Set(value.auto.on)].sort(compareUnicode),
+                    set: value.auto.set,
+                },
+            }),
+        ...(value.description === undefined ? {} : { description: value.description }),
+    };
+}
+function canonicalizeDirectedEndpoints(value) {
+    return {
+        ...value,
+        source: { ...value.source, accepts: [...value.source.accepts].sort(compareDefinitionRefs) },
+        target: { ...value.target, accepts: [...value.target.accepts].sort(compareDefinitionRefs) },
+    };
+}
+function canonicalizeIncidentEndpoints(value) {
+    return [
+        { ...value[0], accepts: [...value[0].accepts].sort(compareDefinitionRefs) },
+        { ...value[1], accepts: [...value[1].accepts].sort(compareDefinitionRefs) },
+    ];
+}
+function canonicalizeCoreEdge(edge, origin, orientationByClass) {
+    const isLocal = edge.class.origin === origin;
+    const isUndirected = isLocal && orientationByClass.get(edge.class.name) === 'undirected';
+    const [source, target] = isUndirected && compareCoreEndpoints(edge.source, edge.target) > 0
+        ? [edge.target, edge.source]
+        : [edge.source, edge.target];
+    return {
+        class: edge.class,
+        source,
+        target,
+        properties: copyJsonValue(edge.properties),
+    };
+}
+function compareCoreEdges(left, right) {
+    return (compareDefinitionRefs(left.class, right.class) ||
+        compareCoreEndpoints(left.source, right.source) ||
+        compareCoreEndpoints(left.target, right.target) ||
+        compareBytes(json.serialize(left.properties), json.serialize(right.properties)));
+}
+function compareCoreEndpoints(left, right) {
+    if (left.kind === 'domain')
+        return right.kind === 'domain' ? 0 : -1;
+    if (right.kind === 'domain')
+        return 1;
+    return compareDefinitionRefs(left, right);
+}
+function compareBytes(left, right) {
+    const encoder = new TextEncoder();
+    const a = encoder.encode(left);
+    const b = encoder.encode(right);
+    const length = Math.min(a.length, b.length);
+    for (let index = 0; index < length; index++) {
+        if (a[index] !== b[index])
+            return (a[index] ?? 0) - (b[index] ?? 0);
+    }
+    return a.length - b.length;
+}
+function mapRecord(value, map) {
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => compareUnicode(left, right))
+        .map(([name, entry]) => [name, map(entry, name)]));
+}
+function withDescription(value) {
+    return value.description === undefined ? {} : { description: value.description };
+}
+function copyJsonValue(value) {
+    if (typeof value === 'number') {
+        if (Object.is(value, -0))
+            throw new TypeError('Cannot canonicalize negative zero.');
+        return value;
+    }
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map((entry) => copyJsonValue(entry));
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, copyJsonValue(entry)]));
+}

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

@@ -1,10 +1,9 @@
-import type { DomainSchema } from '../domain.ir.js';
-import type { DomainSchemaEntry, DomainSchemaLookup } from '../domain.lookup.js';
+import type { DomainSchemaEntry, DomainSchemaLookup } from '../dependency/lookup.js';
+import type { DomainSchema } from '../model/schema.js';
 /** Retain the exact schema objects used by one successful semantic acceptance. */
 export declare function rememberDomainClosure(schema: DomainSchema, dependencies: Iterable<DomainSchema>): void;
 /** Undefined means the value did not pass through this process's acceptance boundary. */
 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

@@ -1,7 +1,7 @@
-import { DomainSchemaError, diagnostic } from '../diagnostic.js';
-import { MemoryDomainSchemaLookup } from '../domain.lookup.js';
-import { revisionOfDomainSchema } from '../domain.revision.js';
-import { compareUnicode } from '../reference.js';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { revisionOfDomainSchema } from '../canonical/revision.js';
+import { MemoryDomainSchemaLookup } from '../dependency/lookup.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
 const knownClosure = new WeakMap();
 /** Retain the exact schema objects used by one successful semantic acceptance. */
 export function rememberDomainClosure(schema, dependencies) {
@@ -20,7 +20,7 @@ export function requireDomainClosure(schema) {
     const closure = knownDomainClosure(schema);
     if (closure !== undefined)
         return closure;
-    throw new DomainSchemaError([
+    throw new SchemaError([
         diagnostic('DV_ACCEPTANCE_CONTEXT', '', `DomainSchema ${schema.origin} has no retained acceptance context; accept it again against its exact lookup.`),
     ]);
 }
@@ -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

@@ -1,18 +1,17 @@
-import type { DomainDiagnostic } from '../diagnostic.js';
-import type { DomainSchema, DomainSchemaIR } from '../domain.ir.js';
-import type { DomainSchemaLookup } from '../domain.lookup.js';
-import type { PolicyDeclaration } from '../policy/ast.js';
-import type { SchemaRef, PolicyRef } from '../reference.js';
-import type { ResolvedDefinition } from './definition.index.js';
+import type { DefinitionRef, PolicyRef } from '../../addressing/index.js';
+import type { PolicyDefinition } from '../../language/policy/model/policy.js';
+import type { DomainSchemaLookup } from '../dependency/lookup.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainSchema, DomainSchemaIR } from '../model/schema.js';
+import type { IndexedClassDefinition } from './definition.index.js';
 /** Transient symbol and dependency scope for one DomainSchema analysis pass. */
 export interface DomainResolutionContext {
     readonly candidate: DomainSchemaIR;
     readonly dependencies: ReadonlyMap<string, DomainSchema>;
-    readonly definitions: ReadonlyMap<string, ResolvedDefinition>;
-    readonly diagnostics: readonly DomainDiagnostic[];
-    resolve(ref: SchemaRef): ResolvedDefinition | undefined;
-    resolveAny(ref: SchemaRef): ResolvedDefinition | undefined;
-    resolvePolicy(ref: PolicyRef): PolicyDeclaration | undefined;
+    readonly definitions: ReadonlyMap<string, IndexedClassDefinition>;
+    readonly diagnostics: readonly SchemaDiagnostic[];
+    resolve(ref: DefinitionRef): IndexedClassDefinition | undefined;
+    resolveAny(ref: DefinitionRef): IndexedClassDefinition | undefined;
+    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,6 +1,8 @@
+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';
 import { diagnostic } from '../diagnostic.js';
-import { revisionOfDomainSchema } from '../domain.revision.js';
-import { DOMAIN_REVISION_PATTERN, schemaRefIndex } from '../reference.js';
 import { indexSchemaDefinitions } from './definition.index.js';
 import { collectUsedForeignOrigins } from './origins.js';
 export function buildDomainResolutionContext(candidate, lookup) {
@@ -8,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) {
@@ -53,10 +58,10 @@ export function buildDomainResolutionContext(candidate, lookup) {
         resolve(ref) {
             if (ref.origin !== candidate.origin && !directOrigins.has(ref.origin))
                 return undefined;
-            return definitions.get(schemaRefIndex(ref));
+            return definitions.get(definitionRefIndex(ref));
         },
         resolveAny(ref) {
-            return definitions.get(schemaRefIndex(ref));
+            return definitions.get(definitionRefIndex(ref));
         },
         resolvePolicy(ref) {
             if (ref.origin !== candidate.origin)
@@ -67,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);
@@ -117,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');
+}