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

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

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

package/dist/v1/schema/diagnostic.js

@@ -0,0 +1,21 @@
+import { compareUnicode } from '../addressing/ordering.js';
+export function diagnostic(code, pointer, message, ref) {
+    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
+}
+export class SchemaError extends Error {
+    diagnostics;
+    constructor(diagnostics) {
+        const ordered = [...diagnostics].sort(compareDiagnostic);
+        super(ordered.map(formatDiagnostic).join('\n'));
+        this.name = 'SchemaError';
+        this.diagnostics = Object.freeze(ordered);
+    }
+}
+function compareDiagnostic(left, right) {
+    return (compareUnicode(left.pointer, right.pointer) ||
+        compareUnicode(left.code, right.code) ||
+        compareUnicode(left.message, right.message));
+}
+function formatDiagnostic(value) {
+    return `${value.pointer || '/'} [${value.code}] ${value.message}`;
+}

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

@@ -0,0 +1,26 @@
+/** Admit, encode, inspect, and semantically resolve canonical V1 DomainSchemas. */
+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 './validation/value-api.js';

package/dist/v1/schema/index.js

@@ -0,0 +1,13 @@
+/** Admit, encode, inspect, and semantically resolve canonical V1 DomainSchemas. */
+import { resolve as resolveDomainSchema } from './resolution/domain.js';
+export const resolve = resolveDomainSchema;
+export { acceptDomainSchema as accept } from './admission/accept.js';
+export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
+export { revisionOfDomainSchema as revision } from './canonical/revision.js';
+export { 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 './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

@@ -0,0 +1,9 @@
+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<Record<string, DomainSchema>>): readonly DomainSchemaEntry[];

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

@@ -0,0 +1,49 @@
+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) {
+    const entries = new Map();
+    for (const dependency of dependencies) {
+        const revision = revisionOfDomainSchema(dependency);
+        entries.set(closureKey(dependency.origin, revision), { revision, schema: dependency });
+    }
+    knownClosure.set(schema, freezeEntries(entries.values()));
+}
+/** Undefined means the value did not pass through this process's acceptance boundary. */
+export function knownDomainClosure(schema) {
+    return knownClosure.get(schema);
+}
+export function requireDomainClosure(schema) {
+    const closure = knownDomainClosure(schema);
+    if (closure !== undefined)
+        return closure;
+    throw new SchemaError([
+        diagnostic('DV_ACCEPTANCE_CONTEXT', '', `DomainSchema ${schema.origin} has no retained acceptance context; accept it again against its exact lookup.`),
+    ]);
+}
+export function lookupForDomainClosure(schema) {
+    return new MemoryDomainSchemaLookup(requireDomainClosure(schema));
+}
+export function lookupEntriesForDependencies(dependencies) {
+    const entries = new Map();
+    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)) {
+            entries.set(closureKey(entry.schema.origin, entry.revision), entry);
+        }
+    }
+    return freezeEntries(entries.values());
+}
+function freezeEntries(entries) {
+    return Object.freeze([...entries]
+        .map(({ revision, schema }) => Object.freeze({ revision, schema }))
+        .sort((left, right) => compareUnicode(left.schema.origin, right.schema.origin) ||
+        compareUnicode(left.revision, right.revision)));
+}
+function closureKey(origin, revision) {
+    return `${origin}\u0000${revision}`;
+}

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

@@ -0,0 +1,17 @@
+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, 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;

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

@@ -0,0 +1,158 @@
+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 { indexSchemaDefinitions } from './definition.index.js';
+import { collectUsedForeignOrigins } from './origins.js';
+export function buildDomainResolutionContext(candidate, lookup) {
+    const diagnostics = [];
+    const dependencies = new Map();
+    const definitions = new Map();
+    const directOrigins = new Set();
+    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) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_UNIQUE', `${pointer}/origin`, 'A Domain cannot depend on itself.'));
+            continue;
+        }
+        if (directOrigins.has(dependency.origin)) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_UNIQUE', `${pointer}/origin`, `Dependency origin ${dependency.origin} is declared more than once.`));
+            continue;
+        }
+        directOrigins.add(dependency.origin);
+        const resolved = lookup.get(dependency.origin, dependency.revision);
+        if (resolved === undefined) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', pointer, `Schema lookup has no exact ${dependency.origin}@${dependency.revision}.`));
+            continue;
+        }
+        if (resolved.origin !== dependency.origin) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', pointer, `Schema lookup value origin ${resolved.origin} disagrees with ${dependency.origin}.`));
+            continue;
+        }
+        const actualRevision = revisionOfDomainSchema(resolved);
+        if (actualRevision !== dependency.revision) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', pointer, `Schema lookup content revision is ${actualRevision}, not ${dependency.revision}.`));
+            continue;
+        }
+        dependencies.set(resolved.origin, resolved);
+    }
+    loadDependencyClosure(candidate, dependencies, lookup, diagnostics);
+    for (const [key, resolved] of indexSchemaDefinitions(candidate))
+        definitions.set(key, resolved);
+    for (const schema of dependencies.values()) {
+        for (const [key, resolved] of indexSchemaDefinitions(schema))
+            definitions.set(key, resolved);
+    }
+    validateDependencyUse(candidate, directOrigins, diagnostics);
+    return Object.freeze({
+        candidate,
+        dependencies,
+        definitions,
+        diagnostics: Object.freeze(diagnostics),
+        resolve(ref) {
+            if (ref.origin !== candidate.origin && !directOrigins.has(ref.origin))
+                return undefined;
+            return definitions.get(definitionRefIndex(ref));
+        },
+        resolveAny(ref) {
+            return definitions.get(definitionRefIndex(ref));
+        },
+        resolvePolicy(ref) {
+            if (ref.origin !== candidate.origin)
+                return undefined;
+            return candidate.policies[ref.name];
+        },
+    });
+}
+function loadDependencyClosure(candidate, dependencies, lookup, diagnostics) {
+    const revisionByOrigin = new Map();
+    const visited = new Set();
+    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;
+        }
+        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;
+            }
+            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;
+        }
+        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);
+    for (const origin of used) {
+        if (!directOrigins.has(origin)) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_DIRECT', '', `Foreign origin ${origin} is referenced without an exact direct dependency.`));
+        }
+    }
+}
+function escapeToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

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

@@ -0,0 +1,21 @@
+import type { ClassRef, DefinitionRef } from '../../addressing/index.js';
+import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { DomainSchemaIR } from '../model/schema.js';
+/** One exact Class declaration resolved within the retained Domain closure. */
+export type IndexedClassDefinition = {
+    readonly ref: ClassRef;
+    readonly kind: 'node';
+    readonly owner: DomainSchemaIR;
+    readonly declaration: Extract<ClassDefinition, {
+        readonly kind: 'node';
+    }>;
+} | {
+    readonly ref: ClassRef;
+    readonly kind: 'edge';
+    readonly owner: DomainSchemaIR;
+    readonly declaration: Extract<ClassDefinition, {
+        readonly kind: 'edge';
+    }>;
+};
+export declare function indexSchemaDefinitions(schema: DomainSchemaIR): ReadonlyMap<string, IndexedClassDefinition>;
+export declare function resolveIndexedReference(indexes: ReadonlyMap<string, IndexedClassDefinition>, ref: DefinitionRef): IndexedClassDefinition | undefined;

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

@@ -0,0 +1,17 @@
+import { definitionRefIndex } from '../../addressing/ordering.js';
+export function indexSchemaDefinitions(schema) {
+    const result = new Map();
+    for (const [name, declaration] of Object.entries(schema.classes)) {
+        const ref = { origin: schema.origin, kind: 'class', name };
+        if (declaration.kind === 'node') {
+            result.set(definitionRefIndex(ref), { ref, kind: 'node', owner: schema, declaration });
+        }
+        else {
+            result.set(definitionRefIndex(ref), { ref, kind: 'edge', owner: schema, declaration });
+        }
+    }
+    return result;
+}
+export function resolveIndexedReference(indexes, ref) {
+    return ref.kind === 'class' ? indexes.get(definitionRefIndex(ref)) : undefined;
+}

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

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