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

package/dist/v1/compiled/admission/revision.d.ts

@@ -0,0 +1,4 @@
+import type { Revision } from '../../addressing/index.js';
+import type { CompiledSchemaEntry } from '../model/schema.js';
+/** Derive the exact canonical source-revision preimage without constructing an authored Schema. */
+export declare function revisionOfCompiledEntry(entry: CompiledSchemaEntry): Revision;

package/dist/v1/compiled/admission/revision.js

@@ -0,0 +1,79 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+import { digestRevisionBytes } from '../../addressing/revision.js';
+/** Derive the exact canonical source-revision preimage without constructing an authored Schema. */
+export function revisionOfCompiledEntry(entry) {
+    return digestRevisionBytes(json.encode(revisionPreimage(entry)));
+}
+function revisionPreimage(entry) {
+    return {
+        format: 'astrale.dsl',
+        version: 'v1',
+        origin: entry.origin,
+        dependencies: entry.dependencies,
+        classes: Object.fromEntries(entry.definitions.classes.map((definition) => [
+            definition.ref.name,
+            sourceClass(entry, definition),
+        ])),
+        functions: Object.fromEntries(entry.definitions.functions.map((definition) => [
+            definition.ref.name,
+            sourceFunction(entry, definition),
+        ])),
+        policies: Object.fromEntries(entry.definitions.policies.map((definition) => [definition.ref.name, definition])),
+        views: Object.fromEntries(entry.definitions.views.map((definition) => [definition.ref.name, definition])),
+        core: {
+            nodes: Object.fromEntries(entry.definitions.core.map((definition) => [definition.ref.name, definition])),
+            edges: entry.facts.core,
+        },
+    };
+}
+function sourceClass(entry, definition) {
+    const properties = Object.fromEntries(definition.properties.map(({ name, value, ordering: _, ...property }) => [
+        name,
+        { ...property, schema: schemaOf(entry, value) },
+    ]));
+    if (definition.kind === 'edge') {
+        const { properties: _, ...rest } = definition;
+        return { ...rest, properties };
+    }
+    const { properties: _, methods, ...rest } = definition;
+    return {
+        ...rest,
+        properties,
+        methods: Object.fromEntries(methods.map((method) => [method.name, sourceMethod(entry, method)])),
+    };
+}
+function sourceMethod(entry, method) {
+    const { name: _, input, fields: __, output, ...rest } = method;
+    return {
+        ...rest,
+        input: schemaOf(entry, input),
+        output: sourceOutput(entry, output),
+    };
+}
+function sourceFunction(entry, definition) {
+    const { input, fields: _, output, ...rest } = definition;
+    return {
+        ...rest,
+        input: typeof input === 'number'
+            ? schemaOf(entry, input)
+            : {
+                mode: 'binary',
+                metadata: schemaOf(entry, input.metadata),
+                maximumBytes: input.maximumBytes,
+            },
+        output: sourceOutput(entry, output),
+    };
+}
+function sourceOutput(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;
+}

package/dist/v1/compiled/admission/semantics.d.ts

@@ -0,0 +1,7 @@
+import type { CompiledSchema } from '../model/schema.js';
+/**
+ * Re-admit contextual Language laws after the portable compiled grammar and
+ * exact closure have been established. This module deliberately depends only
+ * on compiled and Language runtime machinery; it is safe in the load graph.
+ */
+export declare function validateCompiledSemantics(candidate: CompiledSchema): void;