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

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

@@ -1,6 +1,8 @@
+import { dependencyLimits } from '../../addressing/domain-dependency.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { DOMAIN_REVISION_PATTERN } from '../../addressing/patterns.js';
+import { revisionOfDomainSchema } from '../canonical/revision.js';
 import { diagnostic } from '../diagnostic.js';
-import { revisionOfDomainSchema } from '../domain.revision.js';
-import { DOMAIN_REVISION_PATTERN, schemaRefIndex } from '../reference.js';
 import { indexSchemaDefinitions } from './definition.index.js';
 import { collectUsedForeignOrigins } from './origins.js';
 export function buildDomainResolutionContext(candidate, lookup) {
@@ -8,8 +10,11 @@ export function buildDomainResolutionContext(candidate, lookup) {
     const dependencies = new Map();
     const definitions = new Map();
     const directOrigins = new Set();
-    for (const [index, dependency] of candidate.dependencies.entries()) {
-        const pointer = `/dependencies/${index}`;
+    if (Object.keys(candidate.dependencies).length > dependencyLimits.direct) {
+        diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/dependencies', `A Domain may declare at most ${dependencyLimits.direct} direct dependency aliases.`));
+    }
+    for (const [alias, dependency] of Object.entries(candidate.dependencies)) {
+        const pointer = `/dependencies/${escapeToken(alias)}`;
         if (!DOMAIN_REVISION_PATTERN.test(dependency.revision))
             continue;
         if (dependency.origin === candidate.origin) {
@@ -53,10 +58,10 @@ export function buildDomainResolutionContext(candidate, lookup) {
         resolve(ref) {
             if (ref.origin !== candidate.origin && !directOrigins.has(ref.origin))
                 return undefined;
-            return definitions.get(schemaRefIndex(ref));
+            return definitions.get(definitionRefIndex(ref));
         },
         resolveAny(ref) {
-            return definitions.get(schemaRefIndex(ref));
+            return definitions.get(definitionRefIndex(ref));
         },
         resolvePolicy(ref) {
             if (ref.origin !== candidate.origin)
@@ -67,48 +72,78 @@ export function buildDomainResolutionContext(candidate, lookup) {
 }
 function loadDependencyClosure(candidate, dependencies, lookup, diagnostics) {
     const revisionByOrigin = new Map();
-    const visiting = new Set();
     const visited = new Set();
-    const visit = (schema, key) => {
-        if (visiting.has(key)) {
-            diagnostics.push(diagnostic('DV_DEPENDENCY_ACYCLIC', '/dependencies', `Dependency cycle reaches ${schema.origin}.`));
-            return;
+    const activeOrigins = new Set([candidate.origin]);
+    const frames = [
+        {
+            schema: candidate,
+            key: `${candidate.origin}\u0000candidate`,
+            depth: 0,
+            edges: Object.entries(candidate.dependencies),
+            index: 0,
+        },
+    ];
+    let closureLimitReported = false;
+    while (frames.length > 0) {
+        const frame = frames.at(-1);
+        const edge = frame.edges[frame.index++];
+        if (edge === undefined) {
+            frames.pop();
+            activeOrigins.delete(frame.schema.origin);
+            visited.add(frame.key);
+            continue;
         }
-        if (visited.has(key))
-            return;
-        visiting.add(key);
-        for (const dependency of schema.dependencies) {
-            if (dependency.origin === candidate.origin) {
-                diagnostics.push(diagnostic('DV_DEPENDENCY_ACYCLIC', '/dependencies', `Dependency cycle returns to ${candidate.origin}.`));
-                continue;
-            }
-            const previous = revisionByOrigin.get(dependency.origin);
-            if (previous !== undefined && previous !== dependency.revision) {
-                diagnostics.push(diagnostic('DV_DEPENDENCY_REVISION_COHERENCE', '/dependencies', `Closure contains ${dependency.origin} at both ${previous} and ${dependency.revision}.`));
-            }
-            else {
-                revisionByOrigin.set(dependency.origin, dependency.revision);
-            }
-            const nested = dependencies.get(dependency.origin) ?? lookup.get(dependency.origin, dependency.revision);
-            if (nested === undefined) {
-                diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', '/dependencies', `Dependency closure is missing ${dependency.origin}@${dependency.revision}.`));
-                continue;
-            }
-            if (nested.origin !== dependency.origin) {
-                diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', '/dependencies', `Schema lookup value origin ${nested.origin} disagrees with ${dependency.origin}.`));
-                continue;
-            }
-            if (revisionOfDomainSchema(nested) !== dependency.revision) {
-                diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', '/dependencies', `Schema lookup content for ${dependency.origin} disagrees with ${dependency.revision}.`));
-                continue;
+        const [alias, dependency] = edge;
+        const pointer = frames.length === 1 ? `/dependencies/${escapeToken(alias)}` : '/dependencies';
+        if (activeOrigins.has(dependency.origin)) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_ACYCLIC', pointer, `Dependency cycle reaches ${dependency.origin}.`));
+            continue;
+        }
+        const previous = revisionByOrigin.get(dependency.origin);
+        if (previous !== undefined && previous !== dependency.revision) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_REVISION_COHERENCE', pointer, `Closure contains ${dependency.origin} at both ${previous} and ${dependency.revision}.`));
+        }
+        else {
+            revisionByOrigin.set(dependency.origin, dependency.revision);
+        }
+        const nested = dependencies.get(dependency.origin) ?? lookup.get(dependency.origin, dependency.revision);
+        if (nested === undefined) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', pointer, `Dependency closure is missing ${dependency.origin}@${dependency.revision}.`));
+            continue;
+        }
+        if (nested.origin !== dependency.origin) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', pointer, `Schema lookup value origin ${nested.origin} disagrees with ${dependency.origin}.`));
+            continue;
+        }
+        if (revisionOfDomainSchema(nested) !== dependency.revision) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_EXACT', pointer, `Schema lookup content for ${dependency.origin} disagrees with ${dependency.revision}.`));
+            continue;
+        }
+        dependencies.set(nested.origin, nested);
+        if (dependencies.size + 1 > dependencyLimits.closure) {
+            if (!closureLimitReported) {
+                diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', '/dependencies', `A dependency closure may contain at most ${dependencyLimits.closure} Domains.`));
+                closureLimitReported = true;
             }
-            dependencies.set(nested.origin, nested);
-            visit(nested, `${dependency.origin}\u0000${dependency.revision}`);
+            continue;
+        }
+        const depth = frame.depth + 1;
+        if (depth > dependencyLimits.depth) {
+            diagnostics.push(diagnostic('DV_DEPENDENCY_LIMITS', pointer, `Dependency depth ${depth} exceeds the maximum ${dependencyLimits.depth}.`));
+            continue;
         }
-        visiting.delete(key);
-        visited.add(key);
-    };
-    visit(candidate, `${candidate.origin}\u0000candidate`);
+        const key = `${dependency.origin}\u0000${dependency.revision}`;
+        if (visited.has(key))
+            continue;
+        activeOrigins.add(nested.origin);
+        frames.push({
+            schema: nested,
+            key,
+            depth,
+            edges: Object.entries(nested.dependencies),
+            index: 0,
+        });
+    }
 }
 function validateDependencyUse(candidate, directOrigins, diagnostics) {
     const used = collectUsedForeignOrigins(candidate);
@@ -117,10 +152,7 @@ function validateDependencyUse(candidate, directOrigins, diagnostics) {
             diagnostics.push(diagnostic('DV_DEPENDENCY_DIRECT', '', `Foreign origin ${origin} is referenced without an exact direct dependency.`));
         }
     }
-    for (const origin of directOrigins) {
-        if (!used.has(origin)) {
-            diagnostics.push(diagnostic('DV_DEPENDENCY_USED', '/dependencies', `Dependency ${origin} is not referenced by the Domain.`));
-        }
-    }
 }
-//# sourceMappingURL=context.js.map
+function escapeToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}

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

@@ -1,43 +1,21 @@
-import type { ClassDeclaration } from '../definition/class.js';
-import type { InterfaceDeclaration } from '../definition/interface.js';
-import type { DomainSchemaIR } from '../domain.ir.js';
-import type { ClassRef, DefinitionRef, InterfaceRef } from '../reference.js';
-export type ResolvedDefinition = {
+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 family: 'node';
+    readonly kind: 'node';
     readonly owner: DomainSchemaIR;
-    readonly declaration: Extract<ClassDeclaration, {
-        readonly family: 'node';
+    readonly declaration: Extract<ClassDefinition, {
+        readonly kind: 'node';
     }>;
 } | {
     readonly ref: ClassRef;
-    readonly family: 'edge';
+    readonly kind: 'edge';
     readonly owner: DomainSchemaIR;
-    readonly declaration: Extract<ClassDeclaration, {
-        readonly family: 'edge';
-    }>;
-} | {
-    readonly ref: InterfaceRef;
-    readonly family: 'both';
-    readonly owner: DomainSchemaIR;
-    readonly declaration: Extract<InterfaceDeclaration, {
-        readonly family: 'both';
-    }>;
-} | {
-    readonly ref: InterfaceRef;
-    readonly family: 'node';
-    readonly owner: DomainSchemaIR;
-    readonly declaration: Extract<InterfaceDeclaration, {
-        readonly family: 'node';
-    }>;
-} | {
-    readonly ref: InterfaceRef;
-    readonly family: 'edge';
-    readonly owner: DomainSchemaIR;
-    readonly declaration: Extract<InterfaceDeclaration, {
-        readonly family: 'edge';
+    readonly declaration: Extract<ClassDefinition, {
+        readonly kind: 'edge';
     }>;
 };
-export declare function indexSchemaDefinitions(schema: DomainSchemaIR): ReadonlyMap<string, ResolvedDefinition>;
-export declare function resolveIndexedReference(indexes: ReadonlyMap<string, ResolvedDefinition>, ref: DefinitionRef): ResolvedDefinition | undefined;
-//# sourceMappingURL=definition.index.d.ts.map
+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

@@ -1,27 +1,17 @@
-import { schemaRefIndex } from '../reference.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
 export function indexSchemaDefinitions(schema) {
     const result = new Map();
-    for (const [name, declaration] of Object.entries(schema.interfaces)) {
-        const ref = { origin: schema.origin, kind: 'interface', name };
-        result.set(schemaRefIndex(ref), {
-            ref,
-            family: declaration.family,
-            owner: schema,
-            declaration,
-        });
-    }
     for (const [name, declaration] of Object.entries(schema.classes)) {
         const ref = { origin: schema.origin, kind: 'class', name };
-        result.set(schemaRefIndex(ref), {
-            ref,
-            family: declaration.family,
-            owner: schema,
-            declaration,
-        });
+        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 indexes.get(schemaRefIndex(ref));
+    return ref.kind === 'class' ? indexes.get(definitionRefIndex(ref)) : undefined;
 }
-//# sourceMappingURL=definition.index.js.map

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>;

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

@@ -0,0 +1,112 @@
+import { Key, MethodKey, PropertyKey } from '../../addressing/index.js';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { createDomain, createSourceDomain } from '../../domain/create.js';
+import { createDomainValidation, unknownInputField } from '../../domain/validation/create.js';
+import { inputFieldNodes } from '../../language/value/compile/fields.js';
+import { prepareValueSchema } from '../../language/value/evaluate/preparation.js';
+import { validateValueProgram } from '../../language/value/evaluate/program.js';
+import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
+import { classifyOrdering } from '../../language/value/ordering.js';
+import { revisionOfDomainSchema } from '../canonical/revision.js';
+import { SchemaError } from '../diagnostic.js';
+import { validateDomainSchemaSemantics } from '../validation/domain.js';
+import { lookupForDomainClosure } from './closure.js';
+import { createDomainValueSchemaRegistry } from './value.registry.js';
+const resolvedSchemas = new WeakMap();
+/** Resolve one accepted Schema through its exact retained source closure. */
+export function resolve(schema) {
+    const cached = resolvedSchemas.get(schema);
+    if (cached !== undefined)
+        return cached;
+    const resolved = resolveWithLookup(schema, lookupForDomainClosure(schema));
+    resolvedSchemas.set(schema, resolved);
+    return resolved;
+}
+function resolveWithLookup(schema, lookup) {
+    const validation = validateDomainSchemaSemantics(schema, lookup);
+    if (validation.diagnostics.length > 0)
+        throw new SchemaError(validation.diagnostics);
+    const closure = [schema, ...validation.context.dependencies.values()];
+    const registries = new Map(closure.map((owner) => [owner.origin, createDomainValueSchemaRegistry(owner, lookup)]));
+    const input = {
+        root: Object.freeze({
+            origin: schema.origin,
+            revision: revisionOfDomainSchema(schema),
+        }),
+        entries: Object.freeze(closure
+            .filter((owner, index, values) => values.findIndex(({ origin }) => origin === owner.origin) === index)
+            .map((owner) => Object.freeze({
+            origin: owner.origin,
+            revision: revisionOfDomainSchema(owner),
+            dependencies: owner.dependencies,
+            definitions: Object.freeze(definitionsOf(owner)),
+            coreEdges: owner.core.edges,
+        }))
+            .sort((left, right) => compareUnicode(left.origin, right.origin))),
+        validation: sourceValidation(closure, registries),
+    };
+    const domain = createDomain(input);
+    return createSourceDomain(domain, schema);
+}
+function sourceValidation(closure, registries) {
+    const properties = new Map();
+    const callables = new Map();
+    for (const owner of closure) {
+        const registry = registries.get(owner.origin);
+        if (registry === undefined)
+            throw new TypeError(`No Value registry exists for ${owner.origin}.`);
+        for (const definition of Object.values(owner.classes)) {
+            for (const [name, property] of Object.entries(definition.properties)) {
+                properties.set(PropertyKey.of(definition.ref, name), Object.freeze({
+                    ordering: classifyOrdering(property.schema, registry),
+                    validate: (input) => validateJsonInstance(property.schema, input, registry),
+                }));
+            }
+            if (definition.kind !== 'node')
+                continue;
+            for (const [name, method] of Object.entries(definition.methods)) {
+                callables.set(MethodKey.of(definition.ref, name), callableValidation(method.input, method.output.mode === 'binary'
+                    ? undefined
+                    : method.output.mode === 'value'
+                        ? method.output.schema
+                        : method.output.item, registry));
+            }
+        }
+        for (const definition of Object.values(owner.functions)) {
+            callables.set(Key.of(definition.ref), callableValidation(definition.input, definition.output.mode === 'binary'
+                ? undefined
+                : definition.output.mode === 'value'
+                    ? definition.output.schema
+                    : definition.output.item, registry));
+        }
+    }
+    return createDomainValidation(properties, callables);
+}
+function callableValidation(input, output, registry) {
+    const prepared = prepareValueSchema(input, registry, '');
+    if (!prepared.compiled) {
+        throw new TypeError(`Accepted callable input cannot be prepared: ${prepared.message}`);
+    }
+    const inputProgram = prepared.value.program();
+    const fields = inputFieldNodes(inputProgram);
+    return Object.freeze({
+        ...(fields === undefined ? {} : { fields: Object.freeze(Object.keys(fields)) }),
+        validateInput: (value) => validateJsonInstance(input, value, registry),
+        validateInputField(field, value) {
+            const nodes = fields?.[field];
+            return nodes === undefined
+                ? unknownInputField(field)
+                : validateValueProgram(inputProgram, value, nodes);
+        },
+        validateOutput: (value) => output === undefined ? [] : validateJsonInstance(output, value, registry),
+    });
+}
+function definitionsOf(schema) {
+    return [
+        ...Object.values(schema.classes),
+        ...Object.values(schema.functions),
+        ...Object.values(schema.policies),
+        ...Object.values(schema.views),
+        ...Object.values(schema.core.nodes),
+    ];
+}

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

@@ -1,17 +1,14 @@
-import type { FunctionDeclaration, MethodDeclaration } from '../callable.js';
-import type { ClassDeclaration } from '../definition/class.js';
-import type { InterfaceDeclaration } from '../definition/interface.js';
-import type { DomainSchemaIR } from '../domain.ir.js';
-import type { PolicyDeclaration } from '../policy/ast.js';
-import type { SchemaRef } from '../reference.js';
-import type { JsonSchema } from '../value/schema.js';
+import type { DefinitionRef } from '../../addressing/index.js';
+import type { FunctionDefinition, MethodDefinition } from '../../language/callable/model/callable.js';
+import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { PolicyDefinition } from '../../language/policy/model/policy.js';
+import type { JsonSchema } from '../../language/value/model/schema.js';
+import type { DomainSchemaIR } from '../model/schema.js';
 /** Collect only semantic refs, never strings or objects embedded as JSON data. */
 export declare function collectUsedForeignOrigins(schema: DomainSchemaIR): ReadonlySet<string>;
 /** Complete structured references in one schema, in canonical order. */
-export declare function collectDomainSchemaRefs(schema: DomainSchemaIR): readonly SchemaRef[];
-export declare function collectInterfaceRefs(declaration: InterfaceDeclaration, add: (ref: SchemaRef) => void): void;
-export declare function collectClassRefs(declaration: ClassDeclaration, add: (ref: SchemaRef) => void): void;
-export declare function collectCallableRefs(declaration: FunctionDeclaration | MethodDeclaration, add: (ref: SchemaRef) => void): void;
-export declare function collectPolicyDeclarationRefs(declaration: PolicyDeclaration, add: (ref: SchemaRef) => void): void;
-export declare function collectValueSchemaRefs(schema: JsonSchema, add: (ref: SchemaRef) => void): void;
-//# sourceMappingURL=origins.d.ts.map
+export declare function collectDomainDefinitionRefs(schema: DomainSchemaIR): readonly DefinitionRef[];
+export declare function collectClassRefs(declaration: ClassDefinition, add: (ref: DefinitionRef) => void): void;
+export declare function collectCallableRefs(declaration: FunctionDefinition | MethodDefinition, add: (ref: DefinitionRef) => void): void;
+export declare function collectPolicyDefinitionRefs(declaration: PolicyDefinition, add: (ref: DefinitionRef) => void): void;
+export declare function collectValueDefinitionRefs(schema: JsonSchema, add: (ref: DefinitionRef) => void): void;

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

@@ -1,24 +1,18 @@
-import { compareSchemaRefs, schemaRefIndex } from '../reference.js';
-import { walkSchema } from '../value/location/walk.js';
-import { isValueObject as isJsonObject } from '../value/object.js';
-import { parseNamedTypeReference } from '../value/resources/references.js';
+import { compareDefinitionRefs, definitionRefIndex } from '../../addressing/ordering.js';
+import { isValueObject as isJsonObject } from '../../language/value/model/object.js';
+import { walkSchema } from '../../language/value/syntax/walk.js';
 /** Collect only semantic refs, never strings or objects embedded as JSON data. */
 export function collectUsedForeignOrigins(schema) {
-    return new Set(collectDomainSchemaRefs(schema)
+    return new Set(collectDomainDefinitionRefs(schema)
         .filter((ref) => ref.origin !== schema.origin)
         .map((ref) => ref.origin));
 }
 /** Complete structured references in one schema, in canonical order. */
-export function collectDomainSchemaRefs(schema) {
+export function collectDomainDefinitionRefs(schema) {
     const result = new Map();
     const add = (ref) => {
-        result.set(schemaRefIndex(ref), ref);
+        result.set(definitionRefIndex(ref), ref);
     };
-    for (const value of Object.values(schema.types))
-        collectValueSchemaRefs(value, add);
-    for (const declaration of Object.values(schema.interfaces)) {
-        collectInterfaceRefs(declaration, add);
-    }
     for (const declaration of Object.values(schema.classes)) {
         collectClassRefs(declaration, add);
     }
@@ -26,7 +20,7 @@ export function collectDomainSchemaRefs(schema) {
         collectCallableRefs(declaration, add);
     }
     for (const declaration of Object.values(schema.policies)) {
-        collectPolicyDeclarationRefs(declaration, add);
+        collectPolicyDefinitionRefs(declaration, add);
     }
     for (const declaration of Object.values(schema.views)) {
         if (declaration.target.kind === 'definition')
@@ -34,29 +28,27 @@ export function collectDomainSchemaRefs(schema) {
     }
     for (const node of Object.values(schema.core.nodes))
         add(node.class);
-    for (const edge of schema.core.edges)
+    for (const edge of schema.core.edges) {
         add(edge.class);
-    return Object.freeze([...result.values()].sort(compareSchemaRefs));
-}
-export function collectInterfaceRefs(declaration, add) {
-    declaration.extends.forEach(add);
-    collectValueSchemaRefs(declaration.properties, add);
-    if ('methods' in declaration) {
-        Object.values(declaration.methods).forEach((method) => collectCallableRefs(method, add));
+        if (edge.source.kind !== 'domain')
+            add(edge.source);
+        if (edge.target.kind !== 'domain')
+            add(edge.target);
     }
-    if (declaration.family === 'edge')
-        collectEndpointRefs(declaration, add);
+    return Object.freeze([...result.values()].sort(compareDefinitionRefs));
 }
 export function collectClassRefs(declaration, add) {
-    declaration.implements.forEach(add);
-    collectValueSchemaRefs(declaration.properties, add);
-    if (declaration.family === 'edge') {
+    declaration.extends.forEach(add);
+    Object.values(declaration.properties).forEach((property) => collectValueDefinitionRefs(property.schema, add));
+    if (declaration.policies.read !== undefined)
+        add(declaration.policies.read);
+    if (declaration.policies.traverse !== undefined)
+        add(declaration.policies.traverse);
+    if (declaration.kind === 'edge') {
         collectEndpointRefs(declaration, add);
         return;
     }
     Object.values(declaration.methods).forEach((method) => collectCallableRefs(method, add));
-    if (declaration.policies.read !== undefined)
-        add(declaration.policies.read);
 }
 function collectEndpointRefs(declaration, add) {
     const endpoints = declaration.orientation === 'directed'
@@ -66,20 +58,23 @@ function collectEndpointRefs(declaration, add) {
     endpoints[1].accepts.forEach(add);
 }
 export function collectCallableRefs(declaration, add) {
-    collectValueSchemaRefs(declaration.input, add);
+    collectValueDefinitionRefs(declaration.input, add);
     if (declaration.output.mode === 'value')
-        collectValueSchemaRefs(declaration.output.schema, add);
+        collectValueDefinitionRefs(declaration.output.schema, add);
     if (declaration.output.mode === 'stream')
-        collectValueSchemaRefs(declaration.output.item, add);
+        collectValueDefinitionRefs(declaration.output.item, add);
     if (declaration.policy !== undefined)
         collectPolicyCheckRefs(declaration.policy, add);
 }
-export function collectPolicyDeclarationRefs(declaration, add) {
-    if ('match' in declaration) {
-        collectPolicyPatternRefs(declaration.match, add);
+export function collectPolicyDefinitionRefs(declaration, add) {
+    collectPolicyExpressionRefs(declaration.expression, add);
+}
+function collectPolicyExpressionRefs(expression, add) {
+    if ('match' in expression) {
+        collectPolicyPatternRefs(expression.match, add);
         return;
     }
-    const refs = 'allOf' in declaration ? declaration.allOf : declaration.anyOf;
+    const refs = 'allOf' in expression ? expression.allOf : expression.anyOf;
     refs.forEach(add);
 }
 function collectPolicyPatternRefs(expression, add) {
@@ -105,17 +100,10 @@ function collectPolicyCheckRefs(expression, add) {
     const children = 'allOf' in expression ? expression.allOf : expression.anyOf;
     children.forEach((child) => collectPolicyCheckRefs(child, add));
 }
-export function collectValueSchemaRefs(schema, add) {
+export function collectValueDefinitionRefs(schema, add) {
     walkSchema(schema, ({ schema: current }) => {
         if (!isJsonObject(current))
             return;
-        if (typeof current.$ref === 'string') {
-            const named = parseNamedTypeReference(current.$ref);
-            if (named !== undefined) {
-                const ref = { origin: named.origin, kind: 'type', name: named.name };
-                add(ref);
-            }
-        }
         const annotation = current['x-astrale-path'];
         if (!isJsonObject(annotation) || !Array.isArray(annotation.accepts))
             return;
@@ -129,4 +117,3 @@ export function collectValueSchemaRefs(schema, add) {
         }
     });
 }
-//# sourceMappingURL=origins.js.map

package/dist/v1/schema/resolution/value.registry.d.ts

@@ -1,8 +1,7 @@
-import type { DomainSchema } from '../domain.ir.js';
-import type { DomainSchemaLookup } from '../domain.lookup.js';
-import type { ValueSchemaRegistry } from '../value/registry.js';
+import type { ValueSchemaRegistry } from '../../language/value/reference/registry.js';
+import type { DomainSchemaLookup } from '../dependency/lookup.js';
+import type { DomainSchema } from '../model/schema.js';
 import type { DomainResolutionContext } from './context.js';
 /** Build the exact value-schema resource closure for one installed Domain. */
 export declare function createDomainValueSchemaRegistry(schema: DomainSchema, lookup?: DomainSchemaLookup): ValueSchemaRegistry;
 export declare function createValueSchemaRegistry(context: DomainResolutionContext): ValueSchemaRegistry;
-//# sourceMappingURL=value.registry.d.ts.map

package/dist/v1/schema/resolution/value.registry.js

@@ -1,5 +1,5 @@
-import { revisionOfDomainSchema } from '../domain.revision.js';
-import { graphNodePathSchema } from '../value/extensions/node-path/schema.js';
+import { graphNodePathSchema } from '../../language/value/syntax/node-path/schema.js';
+import { revisionOfDomainSchema } from '../canonical/revision.js';
 import { lookupForDomainClosure } from './closure.js';
 import { buildDomainResolutionContext } from './context.js';
 /** Build the exact value-schema resource closure for one installed Domain. */
@@ -9,7 +9,7 @@ export function createDomainValueSchemaRegistry(schema, lookup = lookupForDomain
 export function createValueSchemaRegistry(context) {
     const directDependencies = [];
     const transitiveDependencies = [];
-    const directOrigins = new Set(context.candidate.dependencies.map(({ origin }) => origin));
+    const directOrigins = new Set(Object.values(context.candidate.dependencies).map(({ origin }) => origin));
     for (const schema of context.dependencies.values()) {
         const entry = {
             ...domainValueRegistry(schema),
@@ -28,19 +28,12 @@ export function createValueSchemaRegistry(context) {
     });
 }
 function domainValueRegistry(schema) {
-    const nodeDefinitions = [
-        ...Object.entries(schema.interfaces)
-            .filter(([, declaration]) => declaration.family === 'node')
-            .map(([name]) => ({ origin: schema.origin, kind: 'interface', name })),
-        ...Object.entries(schema.classes)
-            .filter(([, declaration]) => declaration.family === 'node')
-            .map(([name]) => ({ origin: schema.origin, kind: 'class', name })),
-    ];
+    const nodeDefinitions = Object.entries(schema.classes)
+        .filter(([, declaration]) => declaration.kind === 'node')
+        .map(([name]) => ({ origin: schema.origin, kind: 'class', name }));
     return Object.freeze({
         origin: schema.origin,
-        dependencies: schema.dependencies,
-        types: schema.types,
+        dependencies: Object.values(schema.dependencies),
         nodeDefinitions: Object.freeze(nodeDefinitions),
     });
 }
-//# sourceMappingURL=value.registry.js.map

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

@@ -0,0 +1 @@
+export { revisionOfDomainSchema as revision } from './canonical/revision.js';

package/dist/v1/schema/revision.js

@@ -0,0 +1 @@
+export { revisionOfDomainSchema as revision } from './canonical/revision.js';

package/dist/v1/schema/validation/class.d.ts

@@ -0,0 +1,5 @@
+import type { DefinitionAnalysisResult } from '../analysis/class.js';
+import type { SchemaDiagnostic } from '../diagnostic.js';
+import type { DomainResolutionContext } from '../resolution/context.js';
+/** Validate the semantic contracts owned by Class declarations. */
+export declare function validateDefinitions(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult): readonly SchemaDiagnostic[];