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

package/dist/v1/builder/value/full-match.d.ts

@@ -2,4 +2,3 @@ import { type FullMatch } from '../../language/value/syntax/full-match.js';
 export { fullMatchSource, type FullMatch } from '../../language/value/syntax/full-match.js';
 /** Authoring facade preserving the Builder-owned diagnostic for invalid source syntax. */
 export declare function fullMatch(source: string): FullMatch;
-//# sourceMappingURL=full-match.d.ts.map

package/dist/v1/builder/value/full-match.js

@@ -9,4 +9,3 @@ export function fullMatch(source) {
     }
     return languageFullMatch(source);
 }
-//# sourceMappingURL=full-match.js.map

package/dist/v1/builder/value/path-metadata.d.ts

@@ -2,4 +2,3 @@ import type { z } from 'zod';
 import type { NodeClassReferenceInput } from '../class/authoring.js';
 export declare function rememberPath(schema: z.ZodType, accepts: readonly NodeClassReferenceInput[]): void;
 export declare function pathAccepts(schema: z.ZodType): readonly NodeClassReferenceInput[] | undefined;
-//# sourceMappingURL=path-metadata.d.ts.map

package/dist/v1/builder/value/path-metadata.js

@@ -5,4 +5,3 @@ export function rememberPath(schema, accepts) {
 export function pathAccepts(schema) {
     return pathInputs.get(schema);
 }
-//# sourceMappingURL=path-metadata.js.map

package/dist/v1/builder/value/path.d.ts

@@ -6,4 +6,3 @@ export type PathAuthoring<Accepts extends readonly NodeClassReferenceInput[] = r
 };
 export declare function path<const Accepts extends readonly NodeClassReferenceInput[]>(...accepts: Accepts): PathAuthoring<Accepts>;
 export {};
-//# sourceMappingURL=path.d.ts.map

package/dist/v1/builder/value/path.js

@@ -9,4 +9,3 @@ export function path(...accepts) {
     rememberPath(schema, accepts);
     return schema;
 }
-//# sourceMappingURL=path.js.map

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

@@ -14,4 +14,3 @@ export interface TypedValueSchema<out Value = unknown> extends JsonSchemaObject
  */
 export declare function valueSchema<Value>(): <const Schema extends ValueSchemaInput>(schema: Schema) => Schema & TypedValueSchema<Value>;
 export {};
-//# sourceMappingURL=schema.d.ts.map

package/dist/v1/builder/value/schema.js

@@ -8,4 +8,3 @@
 export function valueSchema() {
     return (schema) => schema;
 }
-//# sourceMappingURL=schema.js.map

package/dist/v1/builder/view/authoring.d.ts

@@ -10,13 +10,12 @@ export interface ViewInput {
     readonly description?: string;
     readonly target?: ViewTargetInput;
 }
-export interface ViewAuthoring<out Config extends ViewInput = ViewInput> {
+export interface View<out Config extends ViewInput = ViewInput> {
     readonly [AUTHORING]: 'view';
     readonly [VIEW_INPUT]: Config;
 }
-export type ViewAuthoringInput<Value extends ViewAuthoring> = Value extends ViewAuthoring<infer Config> ? Config : never;
+export type ViewAuthoringInput<Value extends View> = Value extends View<infer Config> ? Config : never;
 /** Internal lowering access; View authoring handles expose no public configuration object. */
-export declare function viewAuthoringInput<const Value extends ViewAuthoring>(value: Value): ViewAuthoringInput<Value>;
-export declare function view<const Config extends ViewInput>(config: Config & Record<Exclude<keyof Config, keyof ViewInput>, never>): ViewAuthoring<Config>;
+export declare function viewAuthoringInput<const Value extends View>(value: Value): ViewAuthoringInput<Value>;
+export declare function view<const Config extends ViewInput>(config: Config & Record<Exclude<keyof Config, keyof ViewInput>, never>): View<Config>;
 export {};
-//# sourceMappingURL=authoring.d.ts.map

package/dist/v1/builder/view/authoring.js

@@ -9,4 +9,3 @@ export function view(config) {
     assertKnownKeys(config, ['description', 'target']);
     return authoringValue('view', { [VIEW_INPUT]: { ...config } });
 }
-//# sourceMappingURL=authoring.js.map

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

@@ -3,4 +3,3 @@ export declare function acceptDomainSchemaBundle(input: unknown): DomainSchemaBu
 export declare function decodeDomainSchemaBundle(input: string | Uint8Array): DomainSchemaBundle;
 export declare function serializeDomainSchemaBundle(bundle: DomainSchemaBundleValue): string;
 export declare function encodeDomainSchemaBundle(bundle: DomainSchemaBundleValue): Uint8Array;
-//# sourceMappingURL=codec.d.ts.map

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);
 }
@@ -149,4 +166,3 @@ function compareSchemas(left, right) {
 function keyOf(origin, revision) {
     return `${origin}\u0000${revision}`;
 }
-//# sourceMappingURL=codec.js.map

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

@@ -1,4 +1,3 @@
 import type { DomainSchema } from '../schema/model/schema.js';
 import type { DomainSchemaBundle } from './model.js';
 export declare function createDomainSchemaBundle<const Root extends DomainSchema>(root: Root): DomainSchemaBundle<Root>;
-//# sourceMappingURL=create.d.ts.map

package/dist/v1/bundle/create.js

@@ -3,4 +3,3 @@ import { asDomainSchemaBundle } from './model.js';
 export function createDomainSchemaBundle(root) {
     return asDomainSchemaBundle(root, requireDomainClosure(root).map(({ schema }) => schema));
 }
-//# sourceMappingURL=create.js.map

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

@@ -8,4 +8,3 @@ export declare class BundleError extends Error {
     readonly diagnostics: readonly BundleDiagnostic[];
     constructor(diagnostics: readonly BundleDiagnostic[]);
 }
-//# sourceMappingURL=diagnostic.d.ts.map

package/dist/v1/bundle/diagnostic.js

@@ -15,4 +15,3 @@ export class BundleError extends Error {
         this.diagnostics = Object.freeze(ordered);
     }
 }
-//# sourceMappingURL=diagnostic.js.map

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

@@ -16,4 +16,3 @@ export declare function serialize(bundle: Bundle): string;
 export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
 export { BundleError as Error } from './diagnostic.js';
 export type { BundleDiagnostic as Diagnostic, BundleDiagnosticCode as DiagnosticCode, } from './diagnostic.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/bundle/index.js

@@ -18,4 +18,3 @@ export function serialize(bundle) {
 }
 export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
 export { BundleError as Error } from './diagnostic.js';
-//# sourceMappingURL=index.js.map

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

@@ -14,4 +14,3 @@ export type DomainSchemaBundle<Root extends DomainSchema = DomainSchema> = Domai
 };
 export declare function asDomainSchemaBundle<Root extends DomainSchema>(root: Root, closure: readonly DomainSchema[]): DomainSchemaBundle<Root>;
 export {};
-//# sourceMappingURL=model.d.ts.map

package/dist/v1/bundle/model.js

@@ -9,4 +9,3 @@ export function asDomainSchemaBundle(root, closure) {
         closure: [...closure],
     });
 }
-//# sourceMappingURL=model.js.map

package/dist/v1/bundle/structure.d.ts

@@ -5,4 +5,3 @@ export interface DomainSchemaBundleStructure {
     readonly closure: readonly DomainSchemaIR[];
 }
 export declare function parseDomainSchemaBundleStructure(input: JsonValue): DomainSchemaBundleStructure;
-//# sourceMappingURL=structure.d.ts.map

package/dist/v1/bundle/structure.js

@@ -69,4 +69,3 @@ function describe(value) {
 function escapeToken(value) {
     return value.replaceAll('~', '~0').replaceAll('/', '~1');
 }
-//# sourceMappingURL=structure.js.map

package/dist/v1/bundle/transport.d.ts

@@ -6,4 +6,3 @@ export declare const encode: (bundle: Bundle) => Uint8Array;
 export declare const serialize: (bundle: Bundle) => string;
 export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
 export { BundleError as Error } from './diagnostic.js';
-//# sourceMappingURL=transport.d.ts.map

package/dist/v1/bundle/transport.js

@@ -5,4 +5,3 @@ export const encode = (bundle) => encodeDomainSchemaBundle(bundle);
 export const serialize = (bundle) => serializeDomainSchemaBundle(bundle);
 export { DOMAIN_BUNDLE_FORMAT as FORMAT, DOMAIN_BUNDLE_VERSION as VERSION } from './model.js';
 export { BundleError as Error } from './diagnostic.js';
-//# sourceMappingURL=transport.js.map

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

@@ -1,4 +1,3 @@
 import type { CompiledSchema } from '../model/schema.js';
 /** Admit one detached compiled closure before indices and declarations become executable. */
 export declare function acceptCompiledSchema(input: unknown): CompiledSchema;
-//# sourceMappingURL=accept.d.ts.map

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);
@@ -838,4 +879,3 @@ function deepFreeze(input) {
         deepFreeze(value);
     return Object.freeze(input);
 }
-//# sourceMappingURL=accept.js.map

package/dist/v1/compiled/admission/revision.d.ts

@@ -2,4 +2,3 @@ import type { Revision } from '../../addressing/index.js';
 import type { CompiledSchemaEntry } from '../model/schema.js';
 /** Derive the exact canonical source-revision preimage without constructing an authored Schema. */
 export declare function revisionOfCompiledEntry(entry: CompiledSchemaEntry): Revision;
-//# sourceMappingURL=revision.d.ts.map

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

@@ -71,4 +71,3 @@ function schemaOf(entry, index) {
         throw new TypeError(`Compiled Value program ${index} is absent.`);
     return root.schema;
 }
-//# sourceMappingURL=revision.js.map

package/dist/v1/compiled/admission/semantics.d.ts

@@ -5,4 +5,3 @@ import type { CompiledSchema } from '../model/schema.js';
  * on compiled and Language runtime machinery; it is safe in the load graph.
  */
 export declare function validateCompiledSemantics(candidate: CompiledSchema): void;
-//# sourceMappingURL=semantics.d.ts.map

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

@@ -1089,4 +1089,3 @@ function isCompiledEdge(value) {
 function fail(pointer, message) {
     return invalidCompiled('COMPILED_SOURCE_INVALID', message, pointer);
 }
-//# sourceMappingURL=semantics.js.map

package/dist/v1/compiled/codec/json.d.ts

@@ -1,4 +1,3 @@
 import type { CompiledSchema } from '../model/schema.js';
 export declare function encode(schema: CompiledSchema): Uint8Array;
 export declare function decode(input: string | Uint8Array): CompiledSchema;
-//# sourceMappingURL=json.d.ts.map

package/dist/v1/compiled/codec/json.js

@@ -7,4 +7,3 @@ export function decode(input) {
     const text = typeof input === 'string' ? input : new TextDecoder().decode(input);
     return acceptCompiledSchema(json.decode(text));
 }
-//# sourceMappingURL=json.js.map

package/dist/v1/compiled/compiler/compile.d.ts

@@ -2,4 +2,3 @@ import type { DomainOfSchema, DomainSchema } from '../../schema/model/schema.js'
 import type { CompiledSchema } from '../model/schema.js';
 /** Compile one admitted source closure into deterministic, dependency-closed Domain data. */
 export declare function compile<const Schema extends DomainSchema>(schema: Schema): CompiledSchema<DomainOfSchema<Schema>>;
-//# sourceMappingURL=compile.d.ts.map

package/dist/v1/compiled/compiler/compile.js

@@ -111,4 +111,3 @@ function compileEntry(schema, lookup) {
 function compare(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-//# sourceMappingURL=compile.js.map

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;
@@ -9,4 +9,3 @@ export declare class CompiledSchemaError extends Error {
     constructor(diagnostics: readonly CompiledDiagnostic[], options?: ErrorOptions);
 }
 export declare function invalidCompiled(code: CompiledDiagnosticCode, message: string, pointer: string, options?: ErrorOptions): never;
-//# sourceMappingURL=diagnostic.d.ts.map

package/dist/v1/compiled/diagnostic.js

@@ -11,4 +11,3 @@ export class CompiledSchemaError extends Error {
 export function invalidCompiled(code, message, pointer, options) {
     throw new CompiledSchemaError([Object.freeze({ code, pointer, message })], options);
 }
-//# sourceMappingURL=diagnostic.js.map

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

@@ -5,4 +5,3 @@ export { load } from './loader/load.js';
 export { CompiledSchemaError as Error } from './diagnostic.js';
 export type { CompiledDiagnostic as Diagnostic, CompiledDiagnosticCode as DiagnosticCode, } from './diagnostic.js';
 export type * from './model/schema.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/v1/compiled/index.js

@@ -3,4 +3,3 @@ export { compile } from './compiler/compile.js';
 export { decode, encode } from './codec/json.js';
 export { load } from './loader/load.js';
 export { CompiledSchemaError as Error } from './diagnostic.js';
-//# sourceMappingURL=index.js.map

package/dist/v1/compiled/loader/index.d.ts

@@ -1,2 +1 @@
 export { load } from './load.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,2 +1 @@
 export { load } from './load.js';
-//# sourceMappingURL=index.js.map

package/dist/v1/compiled/loader/load.d.ts

@@ -2,4 +2,3 @@ import type { CompiledSchema, DomainOfCompiled } from '../model/schema.js';
 /** Load admitted compiled data through the one resolved Domain constructor. */
 export declare function load<const Input extends CompiledSchema>(input: Input): DomainOfCompiled<Input>;
 export declare function load(input: unknown): import('../../domain/model/domain.js').Domain;
-//# sourceMappingURL=load.d.ts.map

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)),
     });
 }
@@ -137,4 +139,3 @@ function programValidation(programs, properties, propertyOrdering, callables) {
     }
     return createDomainValidation(propertyValidation, callableValidation);
 }
-//# sourceMappingURL=load.js.map

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[];
@@ -71,4 +71,3 @@ export interface CompiledSchema<Resolved = Domain> {
     readonly [COMPILED_DOMAIN]?: Resolved;
 }
 export type DomainOfCompiled<Value extends CompiledSchema> = Value extends CompiledSchema<infer Resolved> ? Resolved : Domain;
-//# sourceMappingURL=schema.d.ts.map

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

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=schema.js.map

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

@@ -1,9 +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;
-//# sourceMappingURL=create.d.ts.map