@astrale-os/kernel-dsl 0.2.0-beta.4 → 0.2.0-beta.40

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

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,120 @@
+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 { isBinaryInput } from '../../language/callable/model/callable.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, validatePreparedInstance, } from '../../language/value/evaluate/validate.js';
+import { classifyPreparedOrdering } 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();
+    const patterns = 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)) {
+                const prepared = prepareValueSchema(property.schema, registry, '', patterns);
+                if (!prepared.compiled) {
+                    throw new TypeError(`Accepted Property cannot be prepared: ${prepared.message}`);
+                }
+                properties.set(PropertyKey.of(definition.ref, name), Object.freeze({
+                    ordering: classifyPreparedOrdering(prepared.value),
+                    validate: (input) => validatePreparedInstance(prepared.value, input),
+                }));
+            }
+            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, patterns));
+            }
+        }
+        for (const definition of Object.values(owner.functions)) {
+            callables.set(Key.of(definition.ref), callableValidation(isBinaryInput(definition.input) ? definition.input.metadata : definition.input, definition.output.mode === 'binary'
+                ? undefined
+                : definition.output.mode === 'value'
+                    ? definition.output.schema
+                    : definition.output.item, registry, patterns));
+        }
+    }
+    return createDomainValidation(properties, callables);
+}
+function callableValidation(input, output, registry, patterns) {
+    const prepared = prepareValueSchema(input, registry, '', patterns);
+    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) => validatePreparedInstance(prepared.value, value),
+        validateInputField(field, value) {
+            const nodes = fields?.[field];
+            return nodes === undefined
+                ? unknownInputField(field)
+                : validateValueProgram(inputProgram, value, nodes);
+        },
+        validateOutput: (value) => output === undefined
+            ? []
+            : validateJsonInstance(output, value, registry, '', patterns),
+    });
+}
+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,30 @@
-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 { CoreEndpointRef } from '../../language/core/model/core.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';
+/**
+ * Where one schema references a Definition. `extends` and `core` mean the schema inherits from or
+ * instantiates the Definition; every other site only refers to it.
+ */
+export type ReferenceSite = 'extends' | 'endpoint' | 'value' | 'policy' | 'view' | 'core';
+export type ReferenceCollector = (ref: DefinitionRef, site: ReferenceSite) => void;
 /** 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 collectCoreRefs(schema: DomainSchemaIR, add: ReferenceCollector): void;
+/** The owning Domain addresses no Definition, and a Method is addressed through its owner Class. */
+export declare function coreEndpointDefinitionRef(endpoint: CoreEndpointRef): DefinitionRef | undefined;
+export declare function collectClassRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
+export declare function collectClassPolicyRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
+export declare function collectEndpointRefs(declaration: Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>, add: ReferenceCollector): void;
+export declare function collectCallableRefs(declaration: FunctionDefinition | MethodDefinition, add: ReferenceCollector): void;
+/** References inside the contract a caller compiles against: the input and output value schemas. */
+export declare function collectCallableContractRefs(declaration: Pick<FunctionDefinition | MethodDefinition, 'input' | 'output'>, add: ReferenceCollector): void;
+export declare function collectPolicyDefinitionRefs(declaration: PolicyDefinition, add: ReferenceCollector): void;
+export declare function collectValueDefinitionRefs(schema: JsonSchema, add: ReferenceCollector): void;