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

package/dist/v1/compiled/codec/json.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledSchema } from '../model/schema.js';
+export declare function encode(schema: CompiledSchema): Uint8Array;
+export declare function decode(input: string | Uint8Array): CompiledSchema;

package/dist/v1/compiled/codec/json.js

@@ -0,0 +1,9 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { acceptCompiledSchema } from '../admission/accept.js';
+export function encode(schema) {
+    return new TextEncoder().encode(json.serialize(schema));
+}
+export function decode(input) {
+    const text = typeof input === 'string' ? input : new TextDecoder().decode(input);
+    return acceptCompiledSchema(json.decode(text));
+}

package/dist/v1/compiled/compiler/compile.d.ts

@@ -0,0 +1,4 @@
+import type { DomainOfSchema, DomainSchema } from '../../schema/model/schema.js';
+import type { CompiledSchema } from '../model/schema.js';
+/** Compile one admitted source closure into deterministic, dependency-closed Domain data. */
+export declare function compile<const Schema extends DomainSchema>(schema: Schema): CompiledSchema<DomainOfSchema<Schema>>;

package/dist/v1/compiled/compiler/compile.js

@@ -0,0 +1,113 @@
+import { inputFieldNodes } from '../../language/value/compile/fields.js';
+import { prepareValueSchema } from '../../language/value/evaluate/preparation.js';
+import { classifyOrdering } from '../../language/value/ordering.js';
+import { revisionOfDomainSchema } from '../../schema/canonical/revision.js';
+import { lookupForDomainClosure, requireDomainClosure } from '../../schema/resolution/closure.js';
+import { createDomainValueSchemaRegistry } from '../../schema/resolution/value.registry.js';
+/** Compile one admitted source closure into deterministic, dependency-closed Domain data. */
+export function compile(schema) {
+    const lookup = lookupForDomainClosure(schema);
+    const sources = [
+        schema,
+        ...requireDomainClosure(schema).map(({ schema: dependency }) => dependency),
+    ]
+        .filter((value, index, all) => all.findIndex(({ origin }) => origin === value.origin) === index)
+        .sort((left, right) => compare(left.origin, right.origin));
+    const closure = Object.freeze(sources.map((source) => compileEntry(source, lookup)));
+    return Object.freeze({
+        format: 'astrale.dsl.compiled-schema',
+        version: 1,
+        root: Object.freeze({ origin: schema.origin, revision: revisionOfDomainSchema(schema) }),
+        closure,
+    });
+}
+function compileEntry(schema, lookup) {
+    const registry = createDomainValueSchemaRegistry(schema, lookup);
+    const values = [];
+    const add = (contract, pointer) => {
+        const result = prepareValueSchema(contract, registry, pointer);
+        if (!result.compiled)
+            throw new TypeError(`Cannot compile ValueSchema: ${result.message}`);
+        return values.push(result.value.program()) - 1;
+    };
+    const properties = (definition, pointer) => Object.entries(definition.properties)
+        .sort(([left], [right]) => compare(left, right))
+        .map(([name, property]) => {
+        const ordering = classifyOrdering(property.schema, registry);
+        return {
+            name,
+            required: property.required,
+            visibility: property.visibility,
+            ...(property.auto === undefined ? {} : { auto: property.auto }),
+            ...(property.description === undefined ? {} : { description: property.description }),
+            ...(ordering === undefined ? {} : { ordering }),
+            value: add(property.schema, `${pointer}/properties/${name}/schema`),
+        };
+    });
+    const output = (value, pointer) => value.mode === 'binary'
+        ? { mode: 'binary' }
+        : {
+            mode: value.mode,
+            value: add(value.mode === 'value' ? value.schema : value.item, pointer),
+        };
+    const classes = Object.values(schema.classes)
+        .sort((left, right) => compare(left.ref.name, right.ref.name))
+        .map((definition) => {
+        const pointer = `/classes/${definition.ref.name}`;
+        if (definition.kind === 'edge') {
+            const { properties: _, ...rest } = definition;
+            return { ...rest, properties: properties(definition, pointer) };
+        }
+        const { properties: _, methods: __, ...rest } = definition;
+        const methods = Object.entries(definition.methods)
+            .sort(([left], [right]) => compare(left, right))
+            .map(([name, method]) => {
+            const input = add(method.input, `${pointer}/methods/${name}/input`);
+            const fields = inputFieldNodes(values[input]);
+            return {
+                name,
+                auth: method.auth,
+                ...(method.policy === undefined ? {} : { policy: method.policy }),
+                ...(method.description === undefined ? {} : { description: method.description }),
+                static: method.static,
+                inheritance: method.inheritance,
+                input,
+                ...(fields === undefined ? {} : { fields }),
+                output: output(method.output, `${pointer}/methods/${name}/output`),
+            };
+        });
+        return { ...rest, properties: properties(definition, pointer), methods };
+    });
+    const functions = Object.values(schema.functions)
+        .sort((left, right) => compare(left.ref.name, right.ref.name))
+        .map((definition) => {
+        const input = add(definition.input, `/functions/${definition.ref.name}/input`);
+        const fields = inputFieldNodes(values[input]);
+        return {
+            ref: definition.ref,
+            auth: definition.auth,
+            ...(definition.policy === undefined ? {} : { policy: definition.policy }),
+            ...(definition.description === undefined ? {} : { description: definition.description }),
+            input,
+            ...(fields === undefined ? {} : { fields }),
+            output: output(definition.output, `/functions/${definition.ref.name}/output`),
+        };
+    });
+    return Object.freeze({
+        origin: schema.origin,
+        revision: revisionOfDomainSchema(schema),
+        dependencies: schema.dependencies,
+        definitions: Object.freeze({
+            classes: Object.freeze(classes),
+            functions: Object.freeze(functions),
+            policies: Object.freeze(Object.values(schema.policies)),
+            views: Object.freeze(Object.values(schema.views)),
+            core: Object.freeze(Object.values(schema.core.nodes)),
+        }),
+        facts: Object.freeze({ core: schema.core.edges }),
+        values: Object.freeze(values),
+    });
+}
+function compare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

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

@@ -0,0 +1,11 @@
+export type CompiledDiagnosticCode = 'COMPILED_CANONICAL_MISMATCH' | 'COMPILED_DEPENDENCY_CYCLE' | 'COMPILED_DEPENDENCY_LIMITS' | 'COMPILED_SOURCE_INVALID' | 'COMPILED_STRUCTURE_INVALID';
+export interface CompiledDiagnostic<out Code extends CompiledDiagnosticCode = CompiledDiagnosticCode> {
+    readonly code: Code;
+    readonly pointer: string;
+    readonly message: string;
+}
+export declare class CompiledSchemaError extends Error {
+    readonly diagnostics: readonly CompiledDiagnostic[];
+    constructor(diagnostics: readonly CompiledDiagnostic[], options?: ErrorOptions);
+}
+export declare function invalidCompiled(code: CompiledDiagnosticCode, message: string, pointer: string, options?: ErrorOptions): never;

package/dist/v1/compiled/diagnostic.js

@@ -0,0 +1,13 @@
+export class CompiledSchemaError extends Error {
+    diagnostics;
+    constructor(diagnostics, options) {
+        super(diagnostics
+            .map(({ code, pointer, message }) => `${pointer || '/'} [${code}] ${message}`)
+            .join('\n'), options);
+        this.name = 'CompiledSchemaError';
+        this.diagnostics = Object.freeze([...diagnostics]);
+    }
+}
+export function invalidCompiled(code, message, pointer, options) {
+    throw new CompiledSchemaError([Object.freeze({ code, pointer, message })], options);
+}

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

@@ -0,0 +1,7 @@
+export { acceptCompiledSchema as accept } from './admission/accept.js';
+export { compile } from './compiler/compile.js';
+export { decode, encode } from './codec/json.js';
+export { load } from './loader/load.js';
+export { CompiledSchemaError as Error } from './diagnostic.js';
+export type { CompiledDiagnostic as Diagnostic, CompiledDiagnosticCode as DiagnosticCode, } from './diagnostic.js';
+export type * from './model/schema.js';

package/dist/v1/compiled/index.js

@@ -0,0 +1,5 @@
+export { acceptCompiledSchema as accept } from './admission/accept.js';
+export { compile } from './compiler/compile.js';
+export { decode, encode } from './codec/json.js';
+export { load } from './loader/load.js';
+export { CompiledSchemaError as Error } from './diagnostic.js';

package/dist/v1/compiled/loader/index.d.ts

@@ -0,0 +1 @@
+export { load } from './load.js';

package/dist/v1/compiled/loader/index.js

@@ -0,0 +1 @@
+export { load } from './load.js';

package/dist/v1/compiled/loader/load.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledSchema, DomainOfCompiled } from '../model/schema.js';
+/** Load admitted compiled data through the one resolved Domain constructor. */
+export declare function load<const Input extends CompiledSchema>(input: Input): DomainOfCompiled<Input>;
+export declare function load(input: unknown): import('../../domain/model/domain.js').Domain;

package/dist/v1/compiled/loader/load.js

@@ -0,0 +1,141 @@
+import { Key, MethodKey, PropertyKey as PropertyKeyValue } from '../../addressing/index.js';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { createDomain } from '../../domain/create.js';
+import { combineDomainValidation, createDomainValidation, unknownInputField, } from '../../domain/validation/create.js';
+import { validateValueProgram } from '../../language/value/evaluate/program.js';
+import { acceptCompiledSchema } from '../admission/accept.js';
+export function load(input) {
+    const compiled = acceptCompiledSchema(input);
+    const entries = new Map(compiled.closure.map((entry) => [entry.origin, loadEntry(entry)]));
+    const root = entries.get(compiled.root.origin);
+    if (root === undefined || root.entry.revision !== compiled.root.revision) {
+        throw new TypeError('Compiled root is absent or has the wrong revision.');
+    }
+    return createDomain({
+        root: compiled.root,
+        entries: Object.freeze([...entries.values()]
+            .map(({ entry, definitions }) => Object.freeze({
+            origin: entry.origin,
+            revision: entry.revision,
+            dependencies: entry.dependencies,
+            definitions,
+            coreEdges: entry.facts.core,
+        }))
+            .sort((left, right) => compareUnicode(left.origin, right.origin))),
+        validation: combineDomainValidation([...entries.values()].map(({ validation }) => validation)),
+    });
+}
+function loadEntry(entry) {
+    const propertyPrograms = new Map();
+    const propertyOrdering = new Map();
+    const callablePrograms = new Map();
+    const classes = entry.definitions.classes.map((compiled) => {
+        const properties = Object.fromEntries(compiled.properties.map(({ name, value, ordering, ...definition }) => {
+            const key = PropertyKeyValue.of(compiled.ref, name);
+            propertyPrograms.set(key, value);
+            if (ordering !== undefined)
+                propertyOrdering.set(key, ordering);
+            return [name, { ...definition, schema: schemaOf(entry, value) }];
+        }));
+        if (compiled.kind === 'edge') {
+            const { properties: _, ...definition } = compiled;
+            return Object.freeze({ ...definition, properties });
+        }
+        const { properties: _, methods: __, ...definition } = compiled;
+        const methods = Object.fromEntries(compiled.methods.map((method) => {
+            const key = MethodKey.of(compiled.ref, method.name);
+            callablePrograms.set(key, callableProgram(method));
+            return [method.name, loadMethod(entry, method)];
+        }));
+        return Object.freeze({ ...definition, properties, methods });
+    });
+    const functions = entry.definitions.functions.map((compiled) => {
+        callablePrograms.set(Key.of(compiled.ref), callableProgram(compiled));
+        return loadFunction(entry, compiled);
+    });
+    return {
+        entry,
+        definitions: Object.freeze([
+            ...classes,
+            ...functions,
+            ...entry.definitions.policies,
+            ...entry.definitions.views,
+            ...entry.definitions.core,
+        ]),
+        validation: programValidation(entry.values, propertyPrograms, propertyOrdering, callablePrograms),
+    };
+}
+function loadMethod(entry, value) {
+    const { name: _, input, fields: __, output, ...definition } = value;
+    return Object.freeze({
+        ...definition,
+        input: schemaOf(entry, input),
+        output: loadOutput(entry, output),
+    });
+}
+function loadFunction(entry, value) {
+    const { input, fields: _, output, ...definition } = value;
+    return Object.freeze({
+        ...definition,
+        input: schemaOf(entry, input),
+        output: loadOutput(entry, output),
+    });
+}
+function loadOutput(entry, output) {
+    if (output.mode === 'binary')
+        return output;
+    const schema = schemaOf(entry, output.value);
+    return output.mode === 'value'
+        ? { mode: 'value', schema }
+        : { mode: 'stream', item: schema };
+}
+function schemaOf(entry, index) {
+    const program = entry.values[index];
+    const root = program?.nodes[program.root];
+    if (root === undefined)
+        throw new TypeError(`Compiled Value program ${index} is absent.`);
+    return root.schema;
+}
+function callableProgram(value) {
+    return {
+        input: value.input,
+        ...(value.fields === undefined ? {} : { fields: value.fields }),
+        ...(value.output.mode === 'binary' ? {} : { output: value.output.value }),
+    };
+}
+function programValidation(programs, properties, propertyOrdering, callables) {
+    const propertyValidation = new Map();
+    for (const [key, index] of properties) {
+        const program = programs[index];
+        if (program === undefined)
+            throw new TypeError(`Compiled Property program ${index} is absent.`);
+        propertyValidation.set(key, Object.freeze({
+            ordering: propertyOrdering.get(key),
+            validate: (value) => validateValueProgram(program, value),
+        }));
+    }
+    const callableValidation = new Map();
+    for (const [key, callable] of callables) {
+        const input = programs[callable.input];
+        if (input === undefined)
+            throw new TypeError(`Compiled Callable input ${callable.input} is absent.`);
+        const output = callable.output === undefined ? undefined : programs[callable.output];
+        if (callable.output !== undefined && output === undefined) {
+            throw new TypeError(`Compiled Callable output ${callable.output} is absent.`);
+        }
+        callableValidation.set(key, Object.freeze({
+            ...(callable.fields === undefined
+                ? {}
+                : { fields: Object.freeze(Object.keys(callable.fields)) }),
+            validateInput: (value) => validateValueProgram(input, value),
+            validateInputField(field, value) {
+                const nodes = callable.fields?.[field];
+                return nodes === undefined
+                    ? unknownInputField(field)
+                    : validateValueProgram(input, value, nodes);
+            },
+            validateOutput: (value) => output === undefined ? [] : validateValueProgram(output, value),
+        }));
+    }
+    return createDomainValidation(propertyValidation, callableValidation);
+}

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

@@ -0,0 +1,73 @@
+import type { Key } from '../../addressing/index.js';
+import type { DomainDependency, DomainDependencyMap, Revision } from '../../addressing/index.js';
+import type { Domain } from '../../domain/model/domain.js';
+import type { MethodDefinition } from '../../language/callable/model/callable.js';
+import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { PropertyDefinition } from '../../language/class/model/property.js';
+import type { CoreDefinition, CoreEdge } from '../../language/core/model/core.js';
+import type { PolicyDefinition } from '../../language/policy/model/policy.js';
+import type { ValueProgram } from '../../language/value/compile/model.js';
+import type { OrderingKind } from '../../language/value/ordering.js';
+import type { ViewDefinition } from '../../language/view/model/view.js';
+export type { Pattern, PatternState, PatternTransition, ScalarRange, ValueNode, ValueProgram, } from '../../language/value/compile/model.js';
+export interface CompiledProperty extends Omit<PropertyDefinition, 'schema'> {
+    readonly name: string;
+    readonly value: number;
+    readonly ordering?: OrderingKind;
+}
+export interface CompiledMethod extends Omit<MethodDefinition, 'input' | 'output'> {
+    readonly name: string;
+    readonly input: number;
+    readonly fields?: Readonly<Record<string, readonly number[]>>;
+    readonly output: CompiledOutput;
+}
+export type CompiledOutput = {
+    readonly mode: 'value' | 'stream';
+    readonly value: number;
+} | {
+    readonly mode: 'binary';
+};
+export type CompiledClass = (Omit<Extract<ClassDefinition, {
+    readonly kind: 'node';
+}>, 'properties' | 'methods'> & {
+    readonly properties: readonly CompiledProperty[];
+    readonly methods: readonly CompiledMethod[];
+}) | (Omit<Extract<ClassDefinition, {
+    readonly kind: 'edge';
+}>, 'properties'> & {
+    readonly properties: readonly CompiledProperty[];
+});
+export interface CompiledFunction extends Omit<import('../../language/callable/model/callable.js').FunctionDefinition, 'input' | 'output'> {
+    readonly input: number;
+    readonly fields?: Readonly<Record<string, readonly number[]>>;
+    readonly output: CompiledOutput;
+}
+export type CompiledPolicy = PolicyDefinition;
+export type CompiledView = ViewDefinition;
+export type CompiledCoreDefinition = CoreDefinition;
+export type CompiledCoreEdge = CoreEdge;
+export interface CompiledSchemaEntry {
+    readonly origin: Key.Origin;
+    readonly revision: Revision;
+    readonly dependencies: DomainDependencyMap;
+    readonly definitions: {
+        readonly classes: readonly CompiledClass[];
+        readonly functions: readonly CompiledFunction[];
+        readonly policies: readonly PolicyDefinition[];
+        readonly views: readonly ViewDefinition[];
+        readonly core: readonly CoreDefinition[];
+    };
+    readonly facts: {
+        readonly core: readonly CoreEdge[];
+    };
+    readonly values: readonly ValueProgram[];
+}
+declare const COMPILED_DOMAIN: unique symbol;
+export interface CompiledSchema<Resolved = Domain> {
+    readonly format: 'astrale.dsl.compiled-schema';
+    readonly version: 1;
+    readonly root: DomainDependency;
+    readonly closure: readonly CompiledSchemaEntry[];
+    readonly [COMPILED_DOMAIN]?: Resolved;
+}
+export type DomainOfCompiled<Value extends CompiledSchema> = Value extends CompiledSchema<infer Resolved> ? Resolved : Domain;

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

@@ -0,0 +1 @@
+export {};

package/dist/v1/domain/create.d.ts

@@ -0,0 +1,8 @@
+import type { Domain, SourceDomain } from './model/domain.js';
+import type { DomainInput } from './model/input.js';
+/** True only for an immutable Domain created by DSL resolution or compiled loading. */
+export declare function isDomain(input: unknown): input is Domain;
+/** Retain source provenance without losing the admitted root Domain identity. */
+export declare function createSourceDomain<Source, Resolved extends Domain>(domain: Resolved, source: Source): SourceDomain<Source, Resolved>;
+/** Construct one resolved Definition universe and one memoized facade per closure Domain. */
+export declare function createDomain(input: DomainInput): Domain;