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

package/dist/v1/addressing/domain-dependency.d.ts

@@ -6,3 +6,13 @@ export type DomainDependency = JsonObject & {
     readonly origin: Key.Origin;
     readonly revision: Revision;
 };
+/** Canonical authored name of one exact direct dependency. */
+export type DependencyAlias = string;
+/** Exact direct dependency pins keyed by their authored aliases. */
+export type DomainDependencyMap = Readonly<Record<DependencyAlias, DomainDependency>>;
+/** Representation-neutral admission budgets shared by source and compiled closures. */
+export declare const dependencyLimits: Readonly<{
+    direct: 32;
+    closure: 256;
+    depth: 32;
+}>;

package/dist/v1/addressing/domain-dependency.js

@@ -1 +1,6 @@
-export {};
+/** Representation-neutral admission budgets shared by source and compiled closures. */
+export const dependencyLimits = Object.freeze({
+    direct: 32,
+    closure: 256,
+    depth: 32,
+});

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

@@ -9,4 +9,4 @@ export { Key } from './key.js';
 export { compareUnicode } from './ordering.js';
 export { PropertyKey } from './property-key.js';
 export type { Revision } from './revision.js';
-export type { DomainDependency } from './domain-dependency.js';
+export type { DependencyAlias, DomainDependency, DomainDependencyMap } from './domain-dependency.js';

package/dist/v1/addressing/patterns.d.ts

@@ -2,15 +2,19 @@
 export type DomainOrigin = string;
 export declare const DOMAIN_ORIGIN_PATTERN: RegExp;
 export declare const MEMBER_NAME_PATTERN: RegExp;
+export declare const DEPENDENCY_ALIAS_PATTERN: RegExp;
 export declare const CORE_SLUG_PATTERN: RegExp;
 export declare const DOMAIN_REVISION_PATTERN: RegExp;
 export declare const DOMAIN_REVISION_FULL_MATCH = "sha256:[0-9a-f]{64}";
 export declare const DOMAIN_ORIGIN_FULL_MATCH = "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?";
 export declare const MEMBER_NAME_FULL_MATCH = "[A-Za-z][A-Za-z0-9_]*";
+export declare const DEPENDENCY_ALIAS_FULL_MATCH = "[a-z][A-Za-z0-9]*";
 export declare const PROPERTY_KEY_FULL_MATCH = "([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*";
 export declare const PROPERTY_KEY_PATTERN: RegExp;
 export declare const patterns: Readonly<{
     coreSlug: RegExp;
+    dependencyAlias: RegExp;
+    dependencyAliasFullMatch: "[a-z][A-Za-z0-9]*";
     memberName: RegExp;
     memberNameFullMatch: "[A-Za-z][A-Za-z0-9_]*";
     origin: RegExp;

package/dist/v1/addressing/patterns.js

@@ -1,14 +1,18 @@
 export const DOMAIN_ORIGIN_PATTERN = /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u;
 export const MEMBER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]*$/u;
+export const DEPENDENCY_ALIAS_PATTERN = /^[a-z][A-Za-z0-9]*$/u;
 export const CORE_SLUG_PATTERN = /^[a-z][a-z0-9-]{0,99}$/u;
 export const DOMAIN_REVISION_PATTERN = /^sha256:[0-9a-f]{64}$/u;
 export const DOMAIN_REVISION_FULL_MATCH = 'sha256:[0-9a-f]{64}';
 export const DOMAIN_ORIGIN_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?';
 export const MEMBER_NAME_FULL_MATCH = '[A-Za-z][A-Za-z0-9_]*';
+export const DEPENDENCY_ALIAS_FULL_MATCH = '[a-z][A-Za-z0-9]*';
 export const PROPERTY_KEY_FULL_MATCH = '([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?:class\\.[A-Za-z][A-Za-z0-9_]*\\.property\\.[A-Za-z][A-Za-z0-9_]*';
 export const PROPERTY_KEY_PATTERN = new RegExp(`^(?:${PROPERTY_KEY_FULL_MATCH})$`, 'u');
 export const patterns = Object.freeze({
     coreSlug: CORE_SLUG_PATTERN,
+    dependencyAlias: DEPENDENCY_ALIAS_PATTERN,
+    dependencyAliasFullMatch: DEPENDENCY_ALIAS_FULL_MATCH,
     memberName: MEMBER_NAME_PATTERN,
     memberNameFullMatch: MEMBER_NAME_FULL_MATCH,
     origin: DOMAIN_ORIGIN_PATTERN,

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

@@ -7,7 +7,7 @@ export { policy } from './policy/authoring.js';
 export { auto, property } from './class/property.js';
 export { defineSchema } from './schema/define.js';
 export type { DefinedSchema } from './schema/define.js';
-export type { DomainOfInput } from './schema/projection.js';
+export type { DirectDependenciesOf, DomainOfInput } from './schema/projection.js';
 export { valueSchema } from './value/schema.js';
 export { view } from './view/authoring.js';
 export { BuilderError as Error } from './schema/diagnostic.js';

package/dist/v1/builder/lowering/schema/capture.js

@@ -11,7 +11,7 @@ export function captureSchema(input, context) {
     captureCore(input.core, context);
 }
 export function commitSchemaOwnership(input, origin) {
-    const context = new BuilderContext(origin, input.dependencies ?? []);
+    const context = new BuilderContext(origin, input.dependencies ?? {});
     captureSchema(input, context);
     context.ownership.commit();
 }

package/dist/v1/builder/lowering/schema/compile.js

@@ -21,7 +21,7 @@ import { BuilderContext } from './context.js';
  * This is the private implementation behind defineSchema.
  */
 export function compileSchema(origin, input) {
-    const lookup = new MemoryDomainSchemaLookup(lookupEntriesForDependencies(input.dependencies ?? []));
+    const lookup = new MemoryDomainSchemaLookup(lookupEntriesForDependencies(input.dependencies ?? {}));
     const candidate = assembleDomainSchema(origin, input, lookup);
     const accepted = acceptDomainSchema(candidate, lookup);
     commitSchemaOwnership(input, origin);
@@ -32,7 +32,7 @@ function assembleDomainSchema(origin, input, lookup) {
     assertKnownKeys(input, ['dependencies', 'classes', 'functions', 'policies', 'views', 'core']);
     if (input.core !== undefined)
         assertKnownKeys(input.core, ['nodes', 'edges'], '/core');
-    const context = new BuilderContext(origin, input.dependencies ?? []);
+    const context = new BuilderContext(origin, input.dependencies ?? {});
     captureSchema(input, context);
     const values = new BuilderValueSchemas(context);
     const policyCompiler = new V1PolicyCompiler(context);

package/dist/v1/builder/lowering/schema/context.d.ts

@@ -25,7 +25,7 @@ export declare class BuilderContext {
     readonly policyObjects: Map<object, PolicyObjectRef>;
     readonly policyObjectRefs: Set<string>;
     readonly usedForeignOrigins: Set<string>;
-    constructor(origin: string, dependencies: readonly DomainSchema[]);
+    constructor(origin: string, dependencies: Readonly<Record<string, DomainSchema>>);
     captureDefinition(value: Class, ref: ClassRef, pointer: string): void;
     capturePolicy(value: Policy, ref: PolicyRef, pointer: string): void;
     captureCoreNode(value: CoreNode, slug: string, pointer: string): void;
@@ -37,7 +37,7 @@ export declare class BuilderContext {
     resolvePolicy(input: Lazy<unknown>, pointer: string): PolicyRef;
     resolvePolicyObject(input: PolicyObjectInput | PolicyObjectRef, pointer: string): PolicyObjectRef;
     resolveCoreEndpoint(value: CoreNode | CoreEndpointRef, pointer: string): CoreEndpointRef;
-    dependencies(): readonly DomainDependency[];
+    dependencies(): Readonly<Record<string, DomainDependency>>;
     valueRegistry(): ValueSchemaRegistry;
     noteDomainEndpointReferences(schema: DomainSchemaIR): void;
     private assertVisible;

package/dist/v1/builder/lowering/schema/context.js

@@ -1,4 +1,5 @@
 import { compareDefinitionRefs, compareUnicode, definitionRefIndex, } from '../../../addressing/ordering.js';
+import { DEPENDENCY_ALIAS_PATTERN } from '../../../addressing/patterns.js';
 import { graphNodePathSchema } from '../../../language/value/syntax/node-path/schema.js';
 import { revisionOfDomainSchema } from '../../../schema/canonical/revision.js';
 import { requireDomainClosure } from '../../../schema/resolution/closure.js';
@@ -19,16 +20,23 @@ export class BuilderContext {
     #dependencies = new Map();
     constructor(origin, dependencies) {
         this.origin = origin;
-        for (const schema of dependencies) {
+        for (const [alias, schema] of Object.entries(dependencies)) {
+            const pointer = `/dependencies/${escapePointer(alias)}`;
+            if (!DEPENDENCY_ALIAS_PATTERN.test(alias)) {
+                fail('BUILDER_DEPENDENCY_ALIAS', pointer, `Dependency alias ${JSON.stringify(alias)} must be an ASCII lower-camel identifier.`);
+            }
+            if (alias === '__proto__' || alias === 'prototype' || alias === 'constructor') {
+                fail('BUILDER_DEPENDENCY_ALIAS', pointer, `Dependency alias ${JSON.stringify(alias)} is reserved.`);
+            }
             const dependency = {
                 origin: schema.origin,
                 revision: revisionOfDomainSchema(schema),
             };
             const previous = this.#dependencies.get(schema.origin);
-            if (previous !== undefined && previous.dependency.revision !== dependency.revision) {
-                fail('BUILDER_DEPENDENCY_CONFLICT', '/dependencies', `Dependency ${schema.origin} was supplied at two different revisions.`);
+            if (previous !== undefined) {
+                fail('BUILDER_DEPENDENCY_CONFLICT', pointer, `Dependency origin ${schema.origin} is already declared as alias ${previous.alias}.`);
             }
-            this.#dependencies.set(schema.origin, { schema, dependency });
+            this.#dependencies.set(schema.origin, { alias, schema, dependency });
         }
     }
     captureDefinition(value, ref, pointer) {
@@ -75,11 +83,11 @@ export class BuilderContext {
         if (ref.kind !== 'class') {
             fail('BUILDER_REFERENCE_KIND', pointer, `Expected class, received ${ref.kind}.`);
         }
+        this.assertVisible(ref, pointer);
         const resolvedKind = this.classKind(ref);
         if (resolvedKind !== kind) {
             fail('BUILDER_REFERENCE_KIND', pointer, `Expected ${kind} Class, received ${resolvedKind ?? 'an unresolved Class'}.`);
         }
-        this.assertVisible(ref, pointer);
         return { ...ref };
     }
     resolveNodeClass(input, pointer) {
@@ -123,15 +131,9 @@ export class BuilderContext {
         return { ...ref };
     }
     dependencies() {
-        return [...this.usedForeignOrigins]
-            .map((origin) => {
-            const source = this.#dependencies.get(origin);
-            if (source === undefined) {
-                fail('BUILDER_DEPENDENCY_DIRECT', '/dependencies', `Foreign origin ${origin} is not supplied as an exact direct dependency.`);
-            }
-            return source.dependency;
-        })
-            .sort((left, right) => compareUnicode(left.origin, right.origin));
+        return Object.fromEntries([...this.#dependencies.values()]
+            .sort((left, right) => compareUnicode(left.alias, right.alias))
+            .map(({ alias, dependency }) => [alias, dependency]));
     }
     valueRegistry() {
         const directOrigins = new Set(this.#dependencies.keys());
@@ -145,7 +147,7 @@ export class BuilderContext {
         const registryDomain = (schema, revision) => ({
             origin: schema.origin,
             ...(revision === undefined ? {} : { revision }),
-            dependencies: schema.dependencies,
+            dependencies: Object.values(schema.dependencies),
             nodeDefinitions: definitionRefsOf(schema),
         });
         return {
@@ -192,6 +194,9 @@ export class BuilderContext {
         this.policyObjectRefs.add(definitionRefIndex(ref));
     }
 }
+function escapePointer(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
 function isResolvedClass(value) {
     if (typeof value !== 'object' || value === null)
         return false;

package/dist/v1/builder/schema/define.d.ts

@@ -7,4 +7,4 @@ export interface DefinedSchema<Origin extends string, Input extends DomainSchema
 }
 /** Build and semantically accept one immutable V1 DomainSchema. */
 export declare function defineSchema<const Origin extends string, const Input extends DomainSchemaInput>(origin: Origin, input: Input): DefinedSchema<Origin, Input>;
-export type { DomainOfInput } from './projection.js';
+export type { DirectDependenciesOf, DomainOfInput } from './projection.js';

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

@@ -1,5 +1,5 @@
 import type { DiagnosticCode as LanguageDiagnosticCode } from '../../language/validation/diagnostic.js';
-export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
+export type BuilderDiagnosticCode = LanguageDiagnosticCode | 'BUILDER_ABSTRACT_POLICY' | 'BUILDER_AMBIGUOUS_OWNERSHIP' | 'BUILDER_AUTO_EVENT_INVALID' | 'BUILDER_AUTO_NESTED' | 'BUILDER_AUTO_SET_INVALID' | 'BUILDER_CALLABLE_AUTH' | 'BUILDER_CALLABLE_PLACEMENT' | 'BUILDER_CALLABLE_POLICY_AUTH' | 'BUILDER_CORE_CLASS' | 'BUILDER_CORE_EDGE' | 'BUILDER_CORE_NODE' | 'BUILDER_CORE_PROPERTY' | 'BUILDER_CORE_REF' | 'BUILDER_DEFINITION' | 'BUILDER_DEPENDENCY_CONFLICT' | 'BUILDER_DEPENDENCY_ALIAS' | 'BUILDER_DEPENDENCY_DIRECT' | 'BUILDER_DUPLICATE_MEMBER' | 'BUILDER_FOREIGN_POLICY' | 'BUILDER_FULL_MATCH_INVALID' | 'BUILDER_FUNCTION' | 'BUILDER_METHOD' | 'BUILDER_PATH_DUPLICATE' | 'BUILDER_PATH_EMPTY' | 'BUILDER_POLICY' | 'BUILDER_POLICY_COMPOSITION' | 'BUILDER_POLICY_CYCLE' | 'BUILDER_POLICY_EMPTY_COMPOSITION' | 'BUILDER_POLICY_EMPTY_EXISTS' | 'BUILDER_POLICY_INPUT' | 'BUILDER_POLICY_REF' | 'BUILDER_POLICY_SELF' | 'BUILDER_REFERENCE_CYCLE' | 'BUILDER_REFERENCE_KIND' | 'BUILDER_REFERENCE_MISSING' | 'BUILDER_UNKNOWN_FIELD' | 'BUILDER_UNOWNED_REFERENCE' | 'BUILDER_VIEW' | 'ZOD_SCHEMA_NOT_LOSSLESS';
 export interface BuilderDiagnostic<out Code extends BuilderDiagnosticCode = BuilderDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;

package/dist/v1/builder/schema/input.d.ts

@@ -6,7 +6,7 @@ import type { Policy } from '../policy/authoring.js';
 import type { View } from '../view/authoring.js';
 /** Complete authoring input accepted by defineSchema. */
 export interface DomainSchemaInput {
-    readonly dependencies?: readonly DomainSchema<string, unknown>[];
+    readonly dependencies?: Readonly<Record<string, DomainSchema<string, unknown>>>;
     readonly classes?: Readonly<Record<string, Class>>;
     readonly functions?: Readonly<Record<string, Function>>;
     readonly policies?: Readonly<Record<string, Policy>>;

package/dist/v1/builder/schema/projection.d.ts

@@ -3,12 +3,13 @@ import type { z } from 'zod';
 import type { Revision } from '../../addressing/index.js';
 import type * as domain from '../../domain/model/domain.js';
 import type * as language from '../../language/index.js';
+import type { DomainOfSchema, DomainSchema } from '../../schema/model/schema.js';
 import type { Function, Method, StreamOutput, BinaryOutput } from '../callable/authoring.js';
 import type { Class, DirectedEdgeClass, NodeClass, UndirectedEdgeClass } from '../class/authoring.js';
 import type { AutoProperty, Property, PropertyOptions, ValueSchemaInput } from '../class/property.js';
 import type { TypedValueSchema } from '../value/schema.js';
 import type { DomainSchemaInput } from './input.js';
-export type DomainOfInput<Origin extends string, Input extends DomainSchemaInput> = domain.Domain<{
+export type DomainOfInput<Origin extends string, Input extends DomainSchemaInput> = Omit<domain.Domain<{
     readonly [Name in keyof ClassesInputOf<Input>]: ResolvedClassOfAuthoring<Origin, Extract<Name, string>, ClassesInputOf<Input>[Name], Input>;
 }, {
     readonly [Name in keyof FunctionsInputOf<Input>]: ResolvedFunctionOfAuthoring<Origin, Extract<Name, string>, FunctionsInputOf<Input>[Name]>;
@@ -33,7 +34,17 @@ export type DomainOfInput<Origin extends string, Input extends DomainSchemaInput
         };
         readonly key: language.DefinitionKey<Origin, 'core', Extract<Name, string>>;
     };
-}, Revision>;
+}, Revision>, 'dependencies'> & {
+    readonly dependencies: domain.DependencyDomainNamespace<DirectDependenciesOf<Input>>;
+};
+type DependenciesInputOf<Input extends DomainSchemaInput> = RecordField<Input, 'dependencies'>;
+/**
+ * Project exact direct witnesses already carried by dependency Schemas.
+ * This intentionally never reopens their authored inputs or computes a typed closure.
+ */
+export type DirectDependenciesOf<Input extends DomainSchemaInput> = {
+    readonly [Alias in keyof DependenciesInputOf<Input>]: DependenciesInputOf<Input>[Alias] extends infer Dependency extends DomainSchema ? DomainOfSchema<Dependency> : never;
+};
 export type ResolvedClassOfAuthoring<Origin extends string, Name extends string, Value, Root extends DomainSchemaInput, Seen = Value> = Value extends NodeClass ? language.ResolvedClass<'node', PropertyCollectionOf<Origin, EffectivePropertyEntries<Value>, Root>, MethodCollectionOf<Origin, EffectiveMethodEntries<Value, false>, Root>, MethodCollectionOf<Origin, EffectiveMethodEntries<Value, true>, Root>, PropertyCollectionOf<Origin, OwnPropertyEntries<Value>, Root>, MethodCollectionOf<Origin, OwnMethodEntries<Value, false>, Root>, MethodCollectionOf<Origin, OwnMethodEntries<Value, true>, Root>, Extract<ProjectedClassDefinition<Origin, Name, Value>, language.NodeClassDefinition>, ResolvedParentsOf<Origin, Value, Root, Seen>> & {
     readonly ref: language.ClassRef<Name> & {
         readonly origin: Origin;

package/dist/v1/bundle/codec.js

@@ -1,4 +1,5 @@
 import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, json, } from '@astrale-os/kernel-dsl/value';
+import { dependencyLimits } from '../addressing/domain-dependency.js';
 import { compareUnicode } from '../addressing/ordering.js';
 import { acceptDomainSchema } from '../schema/admission/accept.js';
 import { canonicalDomainSchemaAfterValidation } from '../schema/canonical/revision.js';
@@ -8,6 +9,9 @@ import { SchemaError } from '../schema/diagnostic.js';
 import { BundleError, diagnostic } from './diagnostic.js';
 import { asDomainSchemaBundle, } from './model.js';
 import { parseDomainSchemaBundleStructure } from './structure.js';
+function escapeToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
 export function acceptDomainSchemaBundle(input) {
     let admitted;
     try {
@@ -44,6 +48,14 @@ function acceptBundleValue(input) {
     const closure = structure.closure.map((schema, index) => candidate(schema, `/closure/${index}`));
     const diagnostics = [];
     const candidates = new Map();
+    if (closure.length + 1 > dependencyLimits.closure) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/closure', `A dependency closure may contain at most ${dependencyLimits.closure} Domains.`));
+    }
+    for (const entry of [root, ...closure]) {
+        if (Object.keys(entry.schema.dependencies).length > dependencyLimits.direct) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', `${entry.pointer}/dependencies`, `A Domain may declare at most ${dependencyLimits.direct} direct dependency aliases.`));
+        }
+    }
     for (const entry of closure) {
         if (entry.key === root.key) {
             diagnostics.push(diagnostic('BUNDLE_ROOT_DUPLICATED', entry.pointer, 'The root schema must not also appear in the bundle closure.'));
@@ -57,7 +69,7 @@ function acceptBundleValue(input) {
         candidates.set(entry.key, entry);
     }
     const reachable = new Set();
-    collectReachable(root, root, candidates, reachable, new Set(), new Map(), diagnostics);
+    collectReachable(root, root, candidates, reachable, new Set(), new Map(), diagnostics, 0);
     for (const entry of candidates.values()) {
         if (!reachable.has(entry.key)) {
             diagnostics.push(diagnostic('BUNDLE_CLOSURE_EXTRA', entry.pointer, `Schema ${entry.schema.origin}@${entry.revision} is not reachable from the root.`));
@@ -70,7 +82,7 @@ function acceptBundleValue(input) {
         const existing = accepted.get(entry.key);
         if (existing !== undefined)
             return existing.schema;
-        for (const dependency of entry.schema.dependencies) {
+        for (const dependency of Object.values(entry.schema.dependencies)) {
             const nested = candidates.get(keyOf(dependency.origin, dependency.revision));
             if (nested !== undefined)
                 acceptCandidate(nested);
@@ -112,14 +124,19 @@ function candidate(schema, pointer) {
         pointer,
     };
 }
-function collectReachable(current, root, candidates, reachable, active, revisions, diagnostics) {
+function collectReachable(current, root, candidates, reachable, active, revisions, diagnostics, depth) {
     if (active.has(current.key)) {
         diagnostics.push(diagnostic('BUNDLE_CLOSURE_CYCLE', current.pointer, `Bundle dependency cycle reaches ${current.schema.origin}@${current.revision}.`));
         return;
     }
     active.add(current.key);
-    for (const [index, dependency] of current.schema.dependencies.entries()) {
-        const pointer = `${current.pointer}/dependencies/${index}`;
+    if (depth > dependencyLimits.depth) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', current.pointer, `Dependency depth ${depth} exceeds the maximum ${dependencyLimits.depth}.`));
+        active.delete(current.key);
+        return;
+    }
+    for (const [alias, dependency] of Object.entries(current.schema.dependencies)) {
+        const pointer = `${current.pointer}/dependencies/${escapeToken(alias)}`;
         const dependencyKey = keyOf(dependency.origin, dependency.revision);
         if (dependencyKey === root.key) {
             diagnostics.push(diagnostic('BUNDLE_CLOSURE_CYCLE', pointer, 'Bundle dependency closure returns to its root.'));
@@ -138,7 +155,7 @@ function collectReachable(current, root, candidates, reachable, active, revision
             continue;
         }
         reachable.add(nested.key);
-        collectReachable(nested, root, candidates, reachable, active, revisions, diagnostics);
+        collectReachable(nested, root, candidates, reachable, active, revisions, diagnostics, depth + 1);
     }
     active.delete(current.key);
 }

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

@@ -1,6 +1,7 @@
 import { accept as acceptPortable } from '@astrale-os/kernel-dsl/value';
+import { dependencyLimits } from '../../addressing/domain-dependency.js';
 import { isDefinitionRef, Key } from '../../addressing/index.js';
-import { DOMAIN_ORIGIN_PATTERN, DOMAIN_REVISION_PATTERN, MEMBER_NAME_PATTERN, } from '../../addressing/patterns.js';
+import { DEPENDENCY_ALIAS_PATTERN, DOMAIN_ORIGIN_PATTERN, DOMAIN_REVISION_PATTERN, MEMBER_NAME_PATTERN, } from '../../addressing/patterns.js';
 import { MEDIA_TYPE_PATTERN } from '../../language/class/model/data.js';
 import { PropertyValues } from '../../language/class/property-values.js';
 import { classifyValueProgramOrdering } from '../../language/value/ordering.js';
@@ -21,6 +22,9 @@ export function acceptCompiledSchema(input) {
         invalid('version', undefined, '/version');
     const rootPin = dependency(root.root, 'root', '/root');
     const closure = array(root.closure, 'closure', '/closure').map((value, index) => entry(value, index, `/closure/${index}`));
+    if (closure.length > dependencyLimits.closure) {
+        invalid('dependency closure limit', 'COMPILED_DEPENDENCY_LIMITS', '/closure');
+    }
     const closureOrigins = new Set();
     for (const [index, value] of closure.entries()) {
         if (closureOrigins.has(value.origin))
@@ -32,9 +36,12 @@ export function acceptCompiledSchema(input) {
     if (rootEntry?.revision !== rootPin.revision)
         invalid('root pin', undefined, '/root');
     for (const [entryIndex, owner] of closure.entries()) {
-        for (const [dependencyIndex, pin] of owner.dependencies.entries()) {
+        if (Object.keys(owner.dependencies).length > dependencyLimits.direct) {
+            invalid('direct dependency limit', 'COMPILED_DEPENDENCY_LIMITS', `/closure/${entryIndex}/dependencies`);
+        }
+        for (const [alias, pin] of Object.entries(owner.dependencies)) {
             if (byOrigin.get(pin.origin)?.revision !== pin.revision)
-                invalid('dependency closure', undefined, `/closure/${entryIndex}/dependencies/${dependencyIndex}`);
+                invalid('dependency closure', undefined, pointer(`/closure/${entryIndex}/dependencies`, alias));
         }
     }
     const reachable = new Set();
@@ -42,9 +49,12 @@ export function acceptCompiledSchema(input) {
         if (reachable.has(origin))
             return;
         reachable.add(origin);
-        byOrigin
-            .get(origin)
-            ?.dependencies.forEach(({ origin: dependencyOrigin }) => visit(dependencyOrigin));
+        const owner = byOrigin.get(origin);
+        if (owner !== undefined) {
+            for (const { origin: dependencyOrigin } of Object.values(owner.dependencies)) {
+                visit(dependencyOrigin);
+            }
+        }
     };
     visit(rootPin.origin);
     if (reachable.size !== closure.length) {
@@ -67,11 +77,11 @@ function entry(input, entryIndex, path) {
     const origin = originValue(value.origin, 'entry origin', `${path}/origin`);
     const revision = revisionValue(value.revision, 'entry revision', `${path}/revision`);
     const dependenciesPath = `${path}/dependencies`;
-    const dependencies = array(value.dependencies, 'dependencies', dependenciesPath).map((item, index) => dependency(item, `dependencies[${index}]`, `${dependenciesPath}/${index}`));
+    const dependencies = dependencyMap(value.dependencies, dependenciesPath);
     const dependencyOrigins = new Set();
-    for (const [index, dependency] of dependencies.entries()) {
+    for (const [alias, dependency] of Object.entries(dependencies)) {
         if (dependencyOrigins.has(dependency.origin))
-            invalid('duplicate dependency', undefined, `${dependenciesPath}/${index}/origin`);
+            invalid('duplicate dependency', undefined, `${pointer(dependenciesPath, alias)}/origin`);
         dependencyOrigins.add(dependency.origin);
     }
     const valuesPath = `${path}/values`;
@@ -530,7 +540,7 @@ function validateClosure(candidate) {
     for (const [entryIndex, entry] of candidate.closure.entries()) {
         const visibleOrigins = new Set([
             entry.origin,
-            ...entry.dependencies.map(({ origin }) => origin),
+            ...Object.values(entry.dependencies).map(({ origin }) => origin),
         ]);
         const collections = [
             ['definitions/classes', entry.definitions.classes],
@@ -619,21 +629,37 @@ function validateClosure(candidate) {
 }
 function validateDependencyCycles(candidate) {
     const byOrigin = new Map(candidate.closure.map((entry, index) => [entry.origin, { entry, index }]));
-    const visiting = new Set();
+    const active = new Set();
     const visited = new Set();
-    const visit = (origin) => {
-        if (visited.has(origin))
-            return;
-        if (visiting.has(origin))
-            invalid('dependency cycle', 'COMPILED_DEPENDENCY_CYCLE', `/closure/${byOrigin.get(origin)?.index ?? 0}/dependencies`);
-        visiting.add(origin);
-        for (const dependency of byOrigin.get(origin)?.entry.dependencies ?? [])
-            visit(dependency.origin);
-        visiting.delete(origin);
-        visited.add(origin);
+    const frames = [];
+    const push = (origin, depth) => {
+        if (depth > dependencyLimits.depth) {
+            invalid('dependency depth limit', 'COMPILED_DEPENDENCY_LIMITS', `/closure/${byOrigin.get(origin)?.index ?? 0}/dependencies`);
+        }
+        active.add(origin);
+        frames.push({
+            origin,
+            depth,
+            dependencies: Object.values(byOrigin.get(origin)?.entry.dependencies ?? {}),
+            index: 0,
+        });
     };
-    for (const origin of byOrigin.keys())
-        visit(origin);
+    push(candidate.root.origin, 0);
+    while (frames.length > 0) {
+        const frame = frames.at(-1);
+        const dependency = frame.dependencies[frame.index++];
+        if (dependency === undefined) {
+            frames.pop();
+            active.delete(frame.origin);
+            visited.add(frame.origin);
+            continue;
+        }
+        if (active.has(dependency.origin)) {
+            invalid('dependency cycle', 'COMPILED_DEPENDENCY_CYCLE', `/closure/${byOrigin.get(dependency.origin)?.index ?? 0}/dependencies`);
+        }
+        if (!visited.has(dependency.origin))
+            push(dependency.origin, frame.depth + 1);
+    }
 }
 function walk(input, path, visit) {
     if (isDefinitionRef(input)) {
@@ -737,6 +763,21 @@ function dependency(input, label, path) {
         revision: revisionValue(value.revision, label, `${path}/revision`),
     };
 }
+function dependencyMap(input, path) {
+    const value = object(input, 'dependencies', path);
+    const accepted = Object.create(null);
+    for (const [alias, inputDependency] of Object.entries(value).sort(([left], [right]) => compare(left, right))) {
+        const aliasPath = pointer(path, alias);
+        if (!DEPENDENCY_ALIAS_PATTERN.test(alias) ||
+            alias === '__proto__' ||
+            alias === 'prototype' ||
+            alias === 'constructor') {
+            invalid('dependency alias', undefined, aliasPath);
+        }
+        accepted[alias] = dependency(inputDependency, `dependency ${alias}`, aliasPath);
+    }
+    return accepted;
+}
 function originValue(input, label, path) {
     if (typeof input !== 'string' || !DOMAIN_ORIGIN_PATTERN.test(input))
         invalid(label, undefined, path);

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

@@ -1,4 +1,4 @@
-export type CompiledDiagnosticCode = 'COMPILED_CANONICAL_MISMATCH' | 'COMPILED_DEPENDENCY_CYCLE' | 'COMPILED_SOURCE_INVALID' | 'COMPILED_STRUCTURE_INVALID';
+export type CompiledDiagnosticCode = 'COMPILED_CANONICAL_MISMATCH' | 'COMPILED_DEPENDENCY_CYCLE' | 'COMPILED_DEPENDENCY_LIMITS' | 'COMPILED_SOURCE_INVALID' | 'COMPILED_STRUCTURE_INVALID';
 export interface CompiledDiagnostic<out Code extends CompiledDiagnosticCode = CompiledDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;

package/dist/v1/compiled/loader/load.js

@@ -12,14 +12,16 @@ export function load(input) {
         throw new TypeError('Compiled root is absent or has the wrong revision.');
     }
     return createDomain({
-        origin: root.entry.origin,
-        revision: root.entry.revision,
-        closure: Object.freeze(compiled.closure
-            .map(({ origin, revision }) => Object.freeze({ origin, revision }))
+        root: compiled.root,
+        entries: Object.freeze([...entries.values()]
+            .map(({ entry, definitions }) => Object.freeze({
+            origin: entry.origin,
+            revision: entry.revision,
+            dependencies: entry.dependencies,
+            definitions,
+            coreEdges: entry.facts.core,
+        }))
             .sort((left, right) => compareUnicode(left.origin, right.origin))),
-        dependencies: root.entry.dependencies,
-        definitions: Object.freeze([...entries.values()].flatMap(({ definitions }) => definitions)),
-        coreEdges: root.entry.facts.core,
         validation: combineDomainValidation([...entries.values()].map(({ validation }) => validation)),
     });
 }

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

@@ -1,5 +1,5 @@
 import type { Key } from '../../addressing/index.js';
-import type { DomainDependency, Revision } from '../../addressing/index.js';
+import type { DomainDependency, DomainDependencyMap, Revision } from '../../addressing/index.js';
 import type { Domain } from '../../domain/model/domain.js';
 import type { MethodDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
@@ -49,7 +49,7 @@ export type CompiledCoreEdge = CoreEdge;
 export interface CompiledSchemaEntry {
     readonly origin: Key.Origin;
     readonly revision: Revision;
-    readonly dependencies: readonly DomainDependency[];
+    readonly dependencies: DomainDependencyMap;
     readonly definitions: {
         readonly classes: readonly CompiledClass[];
         readonly functions: readonly CompiledFunction[];

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

@@ -1,8 +1,8 @@
-import type { Domain } from './model/domain.js';
-import type { SourceDomain } from './model/domain.js';
+import type { Domain, SourceDomain } from './model/domain.js';
 import type { DomainInput } from './model/input.js';
 /** True only for an immutable Domain created by DSL resolution or compiled loading. */
 export declare function isDomain(input: unknown): input is Domain;
-/** Retain source provenance without losing the admitted Domain identity. */
+/** Retain source provenance without losing the admitted root Domain identity. */
 export declare function createSourceDomain<Source, Resolved extends Domain>(domain: Resolved, source: Source): SourceDomain<Source, Resolved>;
+/** Construct one resolved Definition universe and one memoized facade per closure Domain. */
 export declare function createDomain(input: DomainInput): Domain;