@cynodia/axiom-runtime 0.3.1-alpha.1

package/dist/mutation/transaction.js

@@ -0,0 +1,45 @@
+export function createTransactionManager(store, nextId) {
+    const open = [];
+    return {
+        currentId: () => open[0]?.id,
+        begin() {
+            const isRoot = open.length === 0;
+            const id = isRoot ? nextId() : open[0].id;
+            const entry = { id, snapshot: isRoot ? store.capture() : undefined };
+            open.push(entry);
+            let settled = false;
+            const close = () => {
+                settled = true;
+                const index = open.indexOf(entry);
+                if (index >= 0) {
+                    open.splice(index, 1);
+                }
+            };
+            return {
+                id,
+                isRoot,
+                commit() {
+                    if (settled) {
+                        return;
+                    }
+                    close();
+                },
+                rollback() {
+                    if (settled) {
+                        return;
+                    }
+                    // A nested failure unwinds to the outermost snapshot, so a whole action is
+                    // rolled back atomically rather than half applied.
+                    const root = open[0];
+                    close();
+                    if (isRoot) {
+                        store.restore(entry.snapshot);
+                    }
+                    else if (root) {
+                        store.restore(root.snapshot);
+                    }
+                },
+            };
+        },
+    };
+}

package/dist/mutation/values.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Value helpers shared by the runtime and the mutation subsystem.
+ *
+ * Stored state is deeply frozen. Any accidental write to a value read out of the store
+ * throws in strict mode, which is what keeps "no implicit object mutation" an enforced
+ * invariant rather than a convention.
+ */
+export declare function cloneValue<T>(value: T): T;
+export declare function deepFreeze<T>(value: T): T;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** Presence semantics used by `required` — distinct from boolean coercion. */
+export declare function isPresent(value: unknown): boolean;
+export declare function toBoolean(value: unknown): boolean;
+export declare function toText(value: unknown): string;
+export declare function compareValues(left: unknown, right: unknown): number;
+export declare function valuesEqual(left: unknown, right: unknown): boolean;
+//# sourceMappingURL=values.d.ts.map

package/dist/mutation/values.js

@@ -0,0 +1,73 @@
+/**
+ * Value helpers shared by the runtime and the mutation subsystem.
+ *
+ * Stored state is deeply frozen. Any accidental write to a value read out of the store
+ * throws in strict mode, which is what keeps "no implicit object mutation" an enforced
+ * invariant rather than a convention.
+ */
+export function cloneValue(value) {
+    return value === undefined ? value : JSON.parse(JSON.stringify(value));
+}
+export function deepFreeze(value) {
+    if (value === null || typeof value !== 'object' || Object.isFrozen(value)) {
+        return value;
+    }
+    for (const entry of Object.values(value)) {
+        deepFreeze(entry);
+    }
+    return Object.freeze(value);
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Presence semantics used by `required` — distinct from boolean coercion. */
+export function isPresent(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if (typeof value === 'string') {
+        return value.trim().length > 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return true;
+}
+export function toBoolean(value) {
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return Boolean(value);
+}
+export function toText(value) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return JSON.stringify(value);
+}
+export function compareValues(left, right) {
+    if (typeof left === 'number' && typeof right === 'number') {
+        return left === right ? 0 : left < right ? -1 : 1;
+    }
+    const leftText = toText(left);
+    const rightText = toText(right);
+    return leftText === rightText ? 0 : leftText < rightText ? -1 : 1;
+}
+export function valuesEqual(left, right) {
+    if (left === right) {
+        return true;
+    }
+    if (left === null || left === undefined || right === null || right === undefined) {
+        return (left ?? null) === (right ?? null);
+    }
+    if (typeof left === 'object' || typeof right === 'object') {
+        return JSON.stringify(left) === JSON.stringify(right);
+    }
+    return false;
+}

package/dist/runtime.d.ts

@@ -0,0 +1,48 @@
+import type { ApplicationIR, CompiledRoute, FieldId, NodeId } from '@cynodia/axiom-core';
+import type { DomElement, HostEnvironment } from './dom.js';
+import type { MutationLogEntry } from './mutation/mutation-engine.js';
+export interface RuntimeDiagnostic {
+    code: string;
+    message: string;
+    severity: 'error' | 'warning';
+    nodeId?: NodeId;
+    fieldId?: FieldId;
+}
+export interface ActionResult {
+    ok: boolean;
+    diagnostics: RuntimeDiagnostic[];
+}
+export interface RouteMatch {
+    route: CompiledRoute;
+    /** Parameter values keyed by route parameter id. */
+    parameters: Record<string, string>;
+}
+export type NativeImplementation = (inputs: Record<string, unknown>) => unknown;
+/** When constraints are evaluated after an input writes to its location. */
+export type InputValidationMode = 'immediate' | 'deferred';
+export interface AxiomRuntimeOptions {
+    ir: ApplicationIR;
+    rootElement: DomElement;
+    host: HostEnvironment;
+    nativeOperations?: Record<string, NativeImplementation>;
+    inputValidation?: InputValidationMode;
+    /** Records previous and next values in the mutation log. */
+    recordMutationValues?: boolean;
+}
+export interface AxiomRuntime {
+    start(): void;
+    render(): void;
+    getState(id: NodeId): unknown;
+    setState(id: NodeId, value: unknown): void;
+    invokeAction(id: NodeId, args?: Record<string, unknown>): ActionResult;
+    navigate(path: string): void;
+    currentRoute(): RouteMatch | null;
+    diagnostics(): RuntimeDiagnostic[];
+    /** Every mutation this runtime has applied, in order, with its semantic location. */
+    getMutationLog(): MutationLogEntry[];
+    registerNativeOperation(implementationId: string, implementation: NativeImplementation): void;
+}
+export declare function createAxiomRuntime(options: AxiomRuntimeOptions): AxiomRuntime;
+/** Builds a host bound to the browser globals. Used by generated pages. */
+export declare function createBrowserHost(): HostEnvironment;
+//# sourceMappingURL=runtime.d.ts.map