@astrale-os/kernel-dsl 0.2.0-beta.3 → 0.2.0-beta.30

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,19 @@
-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 { policyVariableClass } from '../../language/policy/model/policy.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 +21,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 +29,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,29 +59,45 @@ 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) {
+    if ('sameNode' in expression) {
+        for (const term of [expression.sameNode.left, expression.sameNode.right])
+            if (term.kind === 'ref')
+                add(term.ref);
+        return;
+    }
     if ('source' in expression) {
+        for (const term of [expression.source, expression.target])
+            if (term.kind === 'ref')
+                add(term.ref);
         add(expression.class);
         return;
     }
     if ('exists' in expression) {
-        expression.exists.nodes.forEach((node) => add(node.class));
+        expression.exists.nodes.forEach((node) => {
+            const ref = policyVariableClass(node);
+            if (ref !== undefined)
+                add(ref);
+        });
         collectPolicyPatternRefs(expression.exists.where, add);
         return;
     }
@@ -96,6 +105,12 @@ function collectPolicyPatternRefs(expression, add) {
     children.forEach((child) => collectPolicyPatternRefs(child, add));
 }
 function collectPolicyCheckRefs(expression, add) {
+    if ('sameNode' in expression) {
+        for (const term of [expression.sameNode.left, expression.sameNode.right])
+            if (term.kind === 'ref')
+                add(term.ref);
+        return;
+    }
     if ('check' in expression) {
         add(expression.check);
         if (expression.object.kind === 'ref')
@@ -105,17 +120,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 +137,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[];