@astrale-os/kernel-dsl 0.2.0-beta.2 → 0.2.0-beta.20

package/dist/v1/schema/{domain.lookup.js → dependency/lookup.js}

@@ -1,4 +1,4 @@
-import { revisionOfDomainSchema } from './domain.revision.js';
+import { revisionOfDomainSchema } from '../canonical/revision.js';
 export class MemoryDomainSchemaLookup {
     #entries = new Map();
     constructor(entries = []) {
@@ -29,4 +29,3 @@ export function emptyDomainSchemaLookup() {
 function lookupKey(origin, revision) {
     return `${origin}\u0000${revision}`;
 }
-//# sourceMappingURL=domain.lookup.js.map

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

@@ -1,12 +1,12 @@
-export interface DomainDiagnostic {
-    readonly code: string;
+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_PROPERTY_STATE' | '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 class DomainSchemaError extends Error {
-    readonly diagnostics: readonly DomainDiagnostic[];
-    constructor(diagnostics: readonly DomainDiagnostic[]);
+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[]);
 }
-export declare function diagnostic(code: string, pointer: string, message: string, ref?: string): DomainDiagnostic;
-//# sourceMappingURL=diagnostic.d.ts.map

package/dist/v1/schema/diagnostic.js

@@ -1,21 +1,21 @@
-export class DomainSchemaError extends Error {
+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 = 'DomainSchemaError';
+        this.name = 'SchemaError';
         this.diagnostics = Object.freeze(ordered);
     }
 }
-export function diagnostic(code, pointer, message, ref) {
-    return Object.freeze({ code, pointer, message, ...(ref === undefined ? {} : { ref }) });
-}
 function compareDiagnostic(left, right) {
-    return (left.pointer.localeCompare(right.pointer) ||
-        left.code.localeCompare(right.code) ||
-        left.message.localeCompare(right.message));
+    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}`;
 }
-//# sourceMappingURL=diagnostic.js.map

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

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

package/dist/v1/schema/index.js

@@ -1,16 +1,13 @@
 /** Admit, encode, inspect, and semantically resolve canonical V1 DomainSchemas. */
-export { acceptDomainSchema as accept } from './domain.accept.js';
-export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './domain.codec.js';
-export { revisionOfDomainSchema as revision } from './domain.revision.js';
-export { resolveDomainSchema as resolve } from './domain.resolve.js';
-export { compareDependencyMeaning, compareMemberMeaning } from './dependency.meaning.js';
-export { readDomainSchemaHeader as readHeader } from './domain.header.js';
-export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './reference.js';
-export { namedTypeUri as typeUri } from './reference.js';
-export { patterns } from '../addressing/index.js';
-export { DomainSchemaError as Error } from './diagnostic.js';
+import { resolve as resolveDomainSchema } from './resolution/domain.js';
+export const resolve = resolveDomainSchema;
+export { acceptDomainSchema as accept } from './admission/accept.js';
+export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
+export { revisionOfDomainSchema as revision } from './canonical/revision.js';
+export { compareDependencyMeaning, compareMemberMeaning } from './compatibility/meaning.js';
+export { header } from './codec/header.js';
+export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
+export { compile, load } from '../compiled/index.js';
+export { SchemaError as Error } from './diagnostic.js';
 /** The versioned value-schema grammar embedded in declarations. */
-export * as values from './value/index.js';
-/** Shared exact value bounds for declaration metadata. */
-export * as metadata from './metadata.js';
-//# sourceMappingURL=index.js.map
+export * as values from './validation/value-api.js';

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,210 @@
+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 { admitStateTopology } from '../../language/state/topology.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,
+        ...(value.auto === undefined
+            ? {}
+            : {
+                auto: {
+                    on: [...new Set(value.auto.on)].sort(compareUnicode),
+                    set: value.auto.set,
+                },
+            }),
+        ...(value.description === undefined ? {} : { description: value.description }),
+        ...(value.state === undefined
+            ? {}
+            : { state: admitStateTopology(value.state) }),
+    };
+}
+function canonicalizeDirectedEndpoints(value) {
+    return {
+        ...value,
+        source: { ...value.source, accepts: [...value.source.accepts].sort(compareDefinitionRefs) },
+        target: { ...value.target, accepts: [...value.target.accepts].sort(compareDefinitionRefs) },
+    };
+}
+function canonicalizeIncidentEndpoints(value) {
+    return [
+        { ...value[0], accepts: [...value[0].accepts].sort(compareDefinitionRefs) },
+        { ...value[1], accepts: [...value[1].accepts].sort(compareDefinitionRefs) },
+    ];
+}
+function canonicalizeCoreEdge(edge, origin, orientationByClass) {
+    const isLocal = edge.class.origin === origin;
+    const isUndirected = isLocal && orientationByClass.get(edge.class.name) === 'undirected';
+    const [source, target] = isUndirected && compareCoreEndpoints(edge.source, edge.target) > 0
+        ? [edge.target, edge.source]
+        : [edge.source, edge.target];
+    return {
+        class: edge.class,
+        source,
+        target,
+        properties: copyJsonValue(edge.properties),
+    };
+}
+function compareCoreEdges(left, right) {
+    return (compareDefinitionRefs(left.class, right.class) ||
+        compareCoreEndpoints(left.source, right.source) ||
+        compareCoreEndpoints(left.target, right.target) ||
+        compareBytes(json.serialize(left.properties), json.serialize(right.properties)));
+}
+function compareCoreEndpoints(left, right) {
+    if (left.kind === 'domain')
+        return right.kind === 'domain' ? 0 : -1;
+    if (right.kind === 'domain')
+        return 1;
+    return compareDefinitionRefs(left, right);
+}
+function compareBytes(left, right) {
+    const encoder = new TextEncoder();
+    const a = encoder.encode(left);
+    const b = encoder.encode(right);
+    const length = Math.min(a.length, b.length);
+    for (let index = 0; index < length; index++) {
+        if (a[index] !== b[index])
+            return (a[index] ?? 0) - (b[index] ?? 0);
+    }
+    return a.length - b.length;
+}
+function mapRecord(value, map) {
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => compareUnicode(left, right))
+        .map(([name, entry]) => [name, map(entry, name)]));
+}
+function withDescription(value) {
+    return value.description === undefined ? {} : { description: value.description };
+}
+function copyJsonValue(value) {
+    if (typeof value === 'number') {
+        if (Object.is(value, -0))
+            throw new TypeError('Cannot canonicalize negative zero.');
+        return value;
+    }
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Array.isArray(value))
+        return value.map((entry) => copyJsonValue(entry));
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, copyJsonValue(entry)]));
+}

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

@@ -1,10 +1,9 @@
-import type { DomainSchema } from '../domain.ir.js';
-import type { DomainSchemaEntry, DomainSchemaLookup } from '../domain.lookup.js';
+import type { DomainSchemaEntry, DomainSchemaLookup } from '../dependency/lookup.js';
+import type { DomainSchema } from '../model/schema.js';
 /** Retain the exact schema objects used by one successful semantic acceptance. */
 export declare function rememberDomainClosure(schema: DomainSchema, dependencies: Iterable<DomainSchema>): void;
 /** Undefined means the value did not pass through this process's acceptance boundary. */
 export declare function knownDomainClosure(schema: DomainSchema): readonly DomainSchemaEntry[] | undefined;
 export declare function requireDomainClosure(schema: DomainSchema): readonly DomainSchemaEntry[];
 export declare function lookupForDomainClosure(schema: DomainSchema): DomainSchemaLookup;
-export declare function lookupEntriesForDependencies(dependencies: readonly DomainSchema[]): readonly DomainSchemaEntry[];
-//# sourceMappingURL=closure.d.ts.map
+export declare function lookupEntriesForDependencies(dependencies: Readonly<Record<string, DomainSchema>>): readonly DomainSchemaEntry[];

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

@@ -1,7 +1,7 @@
-import { DomainSchemaError, diagnostic } from '../diagnostic.js';
-import { MemoryDomainSchemaLookup } from '../domain.lookup.js';
-import { revisionOfDomainSchema } from '../domain.revision.js';
-import { compareUnicode } from '../reference.js';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { revisionOfDomainSchema } from '../canonical/revision.js';
+import { MemoryDomainSchemaLookup } from '../dependency/lookup.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
 const knownClosure = new WeakMap();
 /** Retain the exact schema objects used by one successful semantic acceptance. */
 export function rememberDomainClosure(schema, dependencies) {
@@ -20,7 +20,7 @@ export function requireDomainClosure(schema) {
     const closure = knownDomainClosure(schema);
     if (closure !== undefined)
         return closure;
-    throw new DomainSchemaError([
+    throw new SchemaError([
         diagnostic('DV_ACCEPTANCE_CONTEXT', '', `DomainSchema ${schema.origin} has no retained acceptance context; accept it again against its exact lookup.`),
     ]);
 }
@@ -29,7 +29,7 @@ export function lookupForDomainClosure(schema) {
 }
 export function lookupEntriesForDependencies(dependencies) {
     const entries = new Map();
-    for (const schema of dependencies) {
+    for (const schema of Object.values(dependencies)) {
         const revision = revisionOfDomainSchema(schema);
         entries.set(closureKey(schema.origin, revision), { schema, revision });
         for (const entry of requireDomainClosure(schema)) {
@@ -47,4 +47,3 @@ function freezeEntries(entries) {
 function closureKey(origin, revision) {
     return `${origin}\u0000${revision}`;
 }
-//# sourceMappingURL=closure.js.map

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

@@ -1,18 +1,17 @@
-import type { DomainDiagnostic } from '../diagnostic.js';
-import type { DomainSchema, DomainSchemaIR } from '../domain.ir.js';
-import type { DomainSchemaLookup } from '../domain.lookup.js';
-import type { PolicyDeclaration } from '../policy/ast.js';
-import type { SchemaRef, PolicyRef } from '../reference.js';
-import type { ResolvedDefinition } from './definition.index.js';
+import type { DefinitionRef, PolicyRef } from '../../addressing/index.js';
+import type { PolicyDefinition } from '../../language/policy/model/policy.js';
+import type { DomainSchemaLookup } from '../dependency/lookup.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainSchema, DomainSchemaIR } from '../model/schema.js';
+import type { IndexedClassDefinition } from './definition.index.js';
 /** Transient symbol and dependency scope for one DomainSchema analysis pass. */
 export interface DomainResolutionContext {
     readonly candidate: DomainSchemaIR;
     readonly dependencies: ReadonlyMap<string, DomainSchema>;
-    readonly definitions: ReadonlyMap<string, ResolvedDefinition>;
-    readonly diagnostics: readonly DomainDiagnostic[];
-    resolve(ref: SchemaRef): ResolvedDefinition | undefined;
-    resolveAny(ref: SchemaRef): ResolvedDefinition | undefined;
-    resolvePolicy(ref: PolicyRef): PolicyDeclaration | undefined;
+    readonly definitions: ReadonlyMap<string, IndexedClassDefinition>;
+    readonly diagnostics: readonly SchemaDiagnostic[];
+    resolve(ref: DefinitionRef): IndexedClassDefinition | undefined;
+    resolveAny(ref: DefinitionRef): IndexedClassDefinition | undefined;
+    resolvePolicy(ref: PolicyRef): PolicyDefinition | undefined;
 }
 export declare function buildDomainResolutionContext(candidate: DomainSchemaIR, lookup: DomainSchemaLookup): DomainResolutionContext;
-//# sourceMappingURL=context.d.ts.map