@cynodia/axiom-runtime 0.6.3-alpha.1 → 0.7.0-alpha.2

package/dist/dom.d.ts

@@ -6,6 +6,16 @@ export interface DomEvent {
     type: string;
     preventDefault?(): void;
     target?: unknown;
+    /**
+     * The key, for a keyboard event.
+     *
+     * Named the way every host already names it, and read for exactly two purposes: dismissing
+     * a dialog on `Escape` and containing focus on `Tab`. It is not a general keyboard channel
+     * — an application cannot bind a key, because a key binding would be behaviour expressed
+     * outside the graph.
+     */
+    key?: string;
+    shiftKey?: boolean;
 }
 export type DomListener = (event: DomEvent) => void;
 export interface DomElement {

package/dist/group-fields.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The two well-known field ids a `group` expression's results carry.
+ *
+ * Declared here rather than imported from `@cynodia/axiom-core` for the same reason `NodeId`
+ * is declared locally in `runtime-types.ts`: a value imported from core would be stripped
+ * out of the browser bundle and become `undefined` in a page. `packages/runtime/test/host.test.ts`
+ * fails if these drift from `GROUP_KEY_FIELD` and `GROUP_ITEMS_FIELD` in core.
+ */
+export declare const GROUP_KEY_FIELD = "field_group_key";
+export declare const GROUP_ITEMS_FIELD = "field_group_items";
+//# sourceMappingURL=group-fields.d.ts.map

package/dist/group-fields.js

@@ -0,0 +1,10 @@
+/**
+ * The two well-known field ids a `group` expression's results carry.
+ *
+ * Declared here rather than imported from `@cynodia/axiom-core` for the same reason `NodeId`
+ * is declared locally in `runtime-types.ts`: a value imported from core would be stripped
+ * out of the browser bundle and become `undefined` in a page. `packages/runtime/test/host.test.ts`
+ * fails if these drift from `GROUP_KEY_FIELD` and `GROUP_ITEMS_FIELD` in core.
+ */
+export const GROUP_KEY_FIELD = 'field_group_key';
+export const GROUP_ITEMS_FIELD = 'field_group_items';

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { BROWSER_RENDERER_CAPABILITIES } from './runtime-types.js';
 export * from './dom.js';
 export * from './mutation/values.js';
 export * from './mutation/store.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+export { BROWSER_RENDERER_CAPABILITIES } from './runtime-types.js';
 export * from './dom.js';
 export * from './mutation/values.js';
 export * from './mutation/store.js';

package/dist/memory-host.js

@@ -35,6 +35,10 @@ export class MemoryElement {
     }
     focus() {
         this.focused = true;
+        // A real host fires a focus event, and the renderer listens for one to track where focus
+        // is. A double that sets a flag without dispatching would let focus-dependent behaviour
+        // pass here and fail in a browser.
+        this.dispatch('focus');
     }
     dispatch(type, event = {}) {
         const payload = { type, target: this, preventDefault: () => undefined, ...event };

package/dist/mutation/values.d.ts

@@ -42,5 +42,12 @@ export declare function toText(value: unknown): string;
  */
 export declare function compareText(left: string, right: string): number;
 export declare function compareValues(left: unknown, right: unknown): number;
+/**
+ * A stable serialization, so record comparison does not depend on key order.
+ *
+ * Also the identity of a group key: two keys are the same key when they serialize the same
+ * way, which is what lets a key be a record and not only a primitive.
+ */
+export declare function canonicalKey(value: unknown): string;
 export declare function valuesEqual(left: unknown, right: unknown): boolean;
 //# sourceMappingURL=values.d.ts.map

package/dist/mutation/values.js

@@ -104,7 +104,15 @@ export function compareValues(left, right) {
     }
     return compareText(toText(left), toText(right));
 }
-/** A stable serialization, so record comparison does not depend on key order. */
+/**
+ * A stable serialization, so record comparison does not depend on key order.
+ *
+ * Also the identity of a group key: two keys are the same key when they serialize the same
+ * way, which is what lets a key be a record and not only a primitive.
+ */
+export function canonicalKey(value) {
+    return canonical(value);
+}
 function canonical(value) {
     if (value === null || typeof value !== 'object') {
         return JSON.stringify(value) ?? 'null';

package/dist/runtime-types.d.ts

@@ -54,4 +54,16 @@ export interface RemoteGateway {
         states: Record<NodeId, unknown>;
     }>;
 }
+/**
+ * The UI node kinds the browser renderer draws.
+ *
+ * It lives beside the renderer rather than in core because the renderer is what has to be
+ * true to it: a kind listed here without a `case` in `renderNode` is a lie that validation
+ * would then repeat. `packages/runtime/test/host.test.ts` renders one of every kind on this
+ * list and fails if any reports `UNSUPPORTED_UI_NODE`.
+ */
+export declare const BROWSER_RENDERER_CAPABILITIES: {
+    readonly target: "browser";
+    readonly supportedUiKinds: readonly ["view", "container", "text", "repeat", "field-display", "form", "input", "button", "conditional", "diagnostic", "dialog"];
+};
 //# sourceMappingURL=runtime-types.d.ts.map

package/dist/runtime-types.js

@@ -1 +1,24 @@
-export {};
+/**
+ * The UI node kinds the browser renderer draws.
+ *
+ * It lives beside the renderer rather than in core because the renderer is what has to be
+ * true to it: a kind listed here without a `case` in `renderNode` is a lie that validation
+ * would then repeat. `packages/runtime/test/host.test.ts` renders one of every kind on this
+ * list and fails if any reports `UNSUPPORTED_UI_NODE`.
+ */
+export const BROWSER_RENDERER_CAPABILITIES = {
+    target: 'browser',
+    supportedUiKinds: [
+        'view',
+        'container',
+        'text',
+        'repeat',
+        'field-display',
+        'form',
+        'input',
+        'button',
+        'conditional',
+        'diagnostic',
+        'dialog',
+    ],
+};

package/dist/runtime.js

@@ -1,10 +1,11 @@
+import { GROUP_ITEMS_FIELD, GROUP_KEY_FIELD } from './group-fields.js';
 import { formatValue } from './format.js';
 import { ariaRoleFor, headingTag, landmarkTag, presentationClasses, } from './presentation-classes.js';
 import { createMutationEngine } from './mutation/mutation-engine.js';
 import { LocationResolutionError, resolveLocation } from './mutation/resolve-location.js';
 import { createStateStore } from './mutation/store.js';
 import { createTransactionManager } from './mutation/transaction.js';
-import { ExpressionEvaluationError, cloneValue, compareValues, deepFreeze, isEmptyValue, isPresent, isRecord, toBoolean, toText, valuesEqual, } from './mutation/values.js';
+import { ExpressionEvaluationError, canonicalKey, cloneValue, compareValues, deepFreeze, isEmptyValue, isPresent, isRecord, toBoolean, toText, valuesEqual, } from './mutation/values.js';
 /**
  * The diagnostics a runtime can report. Agents match on the code rather than parsing the
  * message, so this vocabulary is part of the public contract.
@@ -133,6 +134,52 @@ export function createAxiomRuntime(options) {
      * convention about where inputs are bound.
      */
     let applyingAuthoritative = false;
+    /** Dialogs currently rendered open, so focus moves in once rather than on every render. */
+    const openDialogs = new Set();
+    /** The instance that held focus when each open dialog took it. */
+    const dialogReturnTargets = new Map();
+    /** An explicit override of where focus returns, by semantic node. */
+    const declaredReturnFocus = new Map();
+    /** The instance holding focus as the current render began. */
+    let openedFromInstance = null;
+    /**
+     * Where focus goes after this render, because a dialog just closed.
+     *
+     * A **render instance**, not a node id. `returnFocusId` names a semantic node, and a node
+     * inside a `repeat` is many rendered elements — so returning focus by node id sends a
+     * keyboard user to the last row rendered rather than the row they opened the dialog from.
+     * What is remembered instead is the instance that actually held focus when the dialog
+     * opened, which is both correct for repeats and correct when the trigger was not the
+     * declared `returnFocusId` at all.
+     */
+    let pendingFocusReturn = null;
+    /**
+     * A dialog that opened during this render, and the control focus belongs on.
+     *
+     * Focus cannot be moved while the tree is being built: an element that is not in the
+     * document yet is not focusable, so `focus()` on it does nothing in a browser. The
+     * in-memory host is more forgiving, which is exactly why this was wrong for a release and
+     * only a real browser caught it. Entry focus is therefore deferred to after the render,
+     * beside the focus restoration that already happens there.
+     */
+    let pendingDialogFocus = null;
+    /**
+     * Which render the elements on screen belong to.
+     *
+     * Rendering is a full replace, so removing a focused control makes the browser fire `blur`
+     * and — if its value changed — `change`, **on the element that was just detached**. Handling
+     * that as a new intent re-enters the render from inside itself and applies the same
+     * mutation twice. A control therefore ignores events that arrive after the render which
+     * created it. Nothing in the in-memory host fires those events, which is why only a real
+     * browser found this.
+     */
+    let renderGeneration = 0;
+    /** Every focusable control of the current render, by instance key. */
+    const focusableControls = new Map();
+    /** The instance that last held focus, so a dialog knows where to send it back. */
+    let lastFocusedControl = null;
+    /** Instance keys of the elements rendered for a semantic node, for `returnFocusId`. */
+    const instancesOfNode = new Map();
     let remoteRequests = 0;
     /** Generated once, and only when this runtime can actually talk to an authority. */
     const sessionId = remote ? `s${(runtimeSessions += 1)}-${host.uuid()}` : '';
@@ -210,6 +257,7 @@ export function createAxiomRuntime(options) {
         return safe === '' ? `i${index}` : safe;
     }
     const statesById = new Map(ir.states.map((state) => [state.id, state]));
+    const expressionDefsById = new Map(Object.entries(ir.expressionDefs ?? {}));
     const entitiesById = new Map(ir.entities.map((entity) => [entity.id, entity]));
     const parameterTypes = new Map();
     for (const action of Object.values(ir.actions)) {
@@ -531,6 +579,45 @@ export function createAxiomRuntime(options) {
                 const source = requireCollection(evaluate(expression.source, scope), 'flatten');
                 return source.flatMap((member) => requireCollection(member, 'flatten'));
             }
+            case 'group': {
+                const source = requireCollection(evaluate(expression.source, scope), 'group');
+                // Groups in first-appearance order, members in source order, keys compared
+                // structurally. All three are contract, not implementation detail.
+                const groups = new Map();
+                for (const item of source) {
+                    const key = evaluate(expression.by, childScope(scope, expression.scopeId, item));
+                    const identity = canonicalKey(key);
+                    const existing = groups.get(identity);
+                    if (existing) {
+                        existing.items.push(item);
+                    }
+                    else {
+                        groups.set(identity, { key, items: [item] });
+                    }
+                }
+                return [...groups.values()].map((entry) => ({
+                    [GROUP_KEY_FIELD]: entry.key,
+                    [GROUP_ITEMS_FIELD]: entry.items,
+                }));
+            }
+            case 'expression-ref': {
+                const definition = expressionDefsById.get(expression.expressionId);
+                if (!definition) {
+                    throw new ExpressionEvaluationError(`Expression definition ${expression.expressionId} is not part of this application`, { expressionId: expression.expressionId });
+                }
+                // Arguments are evaluated here; the body is evaluated in a scope of its own, with
+                // no parent. That isolation is the definition's contract: it cannot see the
+                // caller's iteration scopes, so it means the same thing everywhere it is used.
+                const bound = new Map();
+                for (const parameter of definition.parameters ?? []) {
+                    const argument = expression.arguments?.[String(parameter.id)];
+                    if (argument === undefined) {
+                        throw new ExpressionEvaluationError(`Expression ${definition.id} was used without supplying ${parameter.id}`, { expressionId: definition.id, parameterId: parameter.id });
+                    }
+                    bound.set(String(parameter.id), evaluate(argument, scope));
+                }
+                return evaluate(definition.expression, { values: bound });
+            }
             case 'conditional':
                 return toBoolean(evaluate(expression.condition, scope))
                     ? evaluate(expression.whenTrue, scope)
@@ -1309,7 +1396,37 @@ export function createAxiomRuntime(options) {
         }
         return created;
     }
-    /** The semantic classes a node's resolved presentation implies. No styles, no colours. */
+    const dialogFocusStack = [];
+    const openDialogFocus = new Map();
+    /**
+     * Registers a control the keyboard can reach.
+     *
+     * Every focusable control, not only the ones inside a dialog: a dialog has to know where
+     * focus was before it opened, and that is somewhere else in the document by definition.
+     * Every kind that can hold focus registers here — a dialog containing a text field must
+     * trap it, and a trap that only knew about buttons would let focus walk straight out.
+     */
+    function registerFocusable(target, nodeIdentity, instanceKeyValue) {
+        focusableControls.set(instanceKeyValue, target);
+        const forNode = instancesOfNode.get(nodeIdentity) ?? [];
+        forNode.push(instanceKeyValue);
+        instancesOfNode.set(nodeIdentity, forNode);
+        const current = dialogFocusStack[dialogFocusStack.length - 1];
+        const index = current ? current.focusable.length : -1;
+        if (current) {
+            current.focusable.push(target);
+            const dialogNode = ir.uiNodes[current.dialogId];
+            if (dialogNode?.initialFocusId === nodeIdentity) {
+                current.initial = target;
+            }
+        }
+        target.addEventListener('focus', () => {
+            lastFocusedControl = instanceKeyValue;
+            if (current) {
+                current.focusedIndex = index;
+            }
+        });
+    }
     function nodeClasses(node, ...base) {
         return presentationClasses(presentationOf(node.id), ...base);
     }
@@ -1807,14 +1924,29 @@ export function createAxiomRuntime(options) {
                     renderApplication();
                 };
                 // A radio group's listeners live on its radios; everything else is one control.
+                const generation = renderGeneration;
+                const applyIfCurrent = (event) => {
+                    if (generation !== renderGeneration) {
+                        // This element has already been replaced; the event is the browser tidying up
+                        // after it, not a person changing a value.
+                        return;
+                    }
+                    apply(event);
+                };
                 for (const target of grouped ? radios : [control]) {
-                    target.addEventListener('input', apply);
-                    target.addEventListener('change', apply);
+                    target.addEventListener('input', applyIfCurrent);
+                    target.addEventListener('change', applyIfCurrent);
                     target.addEventListener('focus', () => {
                         focusedInstance = instance;
                     });
                 }
                 inputElements.set(instance, control);
+                // A control is focusable whatever kind it is. A dialog containing a text field must
+                // trap it, and a trap that knew only about buttons would let focus walk out of the
+                // first input it met.
+                for (const [offset, focusable] of (grouped ? radios : [control]).entries()) {
+                    registerFocusable(focusable, node.id, grouped ? `${instance}#${offset}` : instance);
+                }
                 wrapper.appendChild(control);
                 if (presentation?.description) {
                     const help = element('span', 'axiom-input-description axiom-text-caption');
@@ -1898,14 +2030,110 @@ export function createAxiomRuntime(options) {
                     // The form invokes exactly this, so the button's arguments are not lost.
                     button.setAttribute('type', 'submit');
                     submitInvokers.set(instanceKey(submits.formId, path), invoke);
+                    registerFocusable(button, node.id, instance);
                     return button;
                 }
                 button.addEventListener('click', (event) => {
                     event.preventDefault?.();
                     invoke();
                 });
+                registerFocusable(button, node.id, instance);
                 return button;
             }
+            case 'dialog': {
+                // Visibility first: a closed dialog is absent, not hidden. Nothing inside it is
+                // rendered, so nothing inside it is reachable by keyboard or by assistive technology.
+                if (!toBoolean(evaluate(node.openWhen, scope))) {
+                    if (openDialogs.delete(node.id)) {
+                        // It was open and is now closed: focus goes back to whatever opened it, rather
+                        // than to the top of the document. A declared override wins, resolved after the
+                        // render, when its instances are known.
+                        const declared = declaredReturnFocus.get(node.id);
+                        pendingFocusReturn = declared
+                            ? `declared:${String(declared)}`
+                            : (dialogReturnTargets.get(node.id) ?? null);
+                        dialogReturnTargets.delete(node.id);
+                    }
+                    openDialogFocus.delete(node.id);
+                    return null;
+                }
+                const dialog = identify(element('div', nodeClasses(node, 'axiom-dialog')));
+                dialog.setAttribute('role', 'dialog');
+                if (node.modal !== false) {
+                    dialog.setAttribute('aria-modal', 'true');
+                }
+                // The accessible name is the title element, related by id — not a copied string, so
+                // the name and the visible heading cannot drift apart.
+                const titleId = `axiom-dialog-title-${instance}`;
+                const title = element('h2', 'axiom-dialog-title axiom-text-heading');
+                title.setAttribute('id', titleId);
+                title.textContent =
+                    typeof node.title === 'string' ? node.title : toText(evaluate(node.title, scope));
+                dialog.setAttribute('aria-labelledby', titleId);
+                dialog.appendChild(title);
+                if (node.description !== undefined) {
+                    const describedId = `axiom-dialog-description-${instance}`;
+                    const description = element('p', 'axiom-dialog-description axiom-text-body');
+                    description.setAttribute('id', describedId);
+                    description.textContent =
+                        typeof node.description === 'string'
+                            ? node.description
+                            : toText(evaluate(node.description, scope));
+                    dialog.setAttribute('aria-describedby', describedId);
+                    dialog.appendChild(description);
+                }
+                const focus = { dialogId: node.id, focusable: [], focusedIndex: -1 };
+                dialogFocusStack.push(focus);
+                renderChildren(node.children, scope, dialog, path);
+                dialogFocusStack.pop();
+                openDialogFocus.set(node.id, focus);
+                // Escape dismisses by invoking the declared close action. What dismissal *means* is
+                // that action's business: the runtime never infers that closing cancels anything.
+                dialog.addEventListener('keydown', (event) => {
+                    if (event.key === 'Escape') {
+                        event.preventDefault?.();
+                        runAction(node.closeActionId, {});
+                        return;
+                    }
+                    if (event.key === 'Tab' && node.modal !== false) {
+                        // Containment: a modal that lets focus walk out of it is not modal. Only the
+                        // wrap is handled here; ordinary Tab movement is the host's.
+                        const { focusable, focusedIndex } = focus;
+                        if (focusable.length === 0) {
+                            return;
+                        }
+                        const atStart = focusedIndex <= 0;
+                        const atEnd = focusedIndex === focusable.length - 1;
+                        if (event.shiftKey ? atStart : atEnd) {
+                            event.preventDefault?.();
+                            const wrapTo = event.shiftKey ? focusable[focusable.length - 1] : focusable[0];
+                            wrapTo.focus?.();
+                            focus.focusedIndex = event.shiftKey ? focusable.length - 1 : 0;
+                        }
+                    }
+                });
+                // Focus moves in when it opens, and back out to whatever opened it when it closes.
+                // Focus moves in the first time it is rendered open, and not on every re-render:
+                // a full re-render must not steal focus back from wherever the person moved it.
+                if (!openDialogs.has(node.id)) {
+                    openDialogs.add(node.id);
+                    // Where focus was, before this dialog took it. Captured by instance, so a trigger
+                    // inside a repeat sends focus back to the row it was actually pressed in.
+                    dialogReturnTargets.set(node.id, openedFromInstance ?? null);
+                    const initial = focus.initial ?? focus.focusable[0];
+                    // Applied once the tree is attached — see `pendingDialogFocus`.
+                    pendingDialogFocus = initial ?? null;
+                    focus.focusedIndex = initial ? focus.focusable.indexOf(initial) : -1;
+                }
+                // A declared `returnFocusId` is an override for the case where focus should not go
+                // back where it came from. It can only name a node, so it resolves to that node's
+                // sole rendered instance; naming one inside a repeat is ambiguous and validation
+                // rejects it.
+                if (node.returnFocusId) {
+                    declaredReturnFocus.set(node.id, node.returnFocusId);
+                }
+                return dialog;
+            }
             case 'diagnostic': {
                 const region = identify(element('div', nodeClasses(node, 'axiom-diagnostic')));
                 region.setAttribute('id', `axiom-diagnostic-${instance}`);
@@ -1949,8 +2177,17 @@ export function createAxiomRuntime(options) {
         }
     }
     function renderApplication() {
+        renderGeneration += 1;
         inputElements.clear();
         submitInvokers.clear();
+        // Which instance held focus as this render began. A dialog opening during it captures
+        // this, so closing returns focus to the control that was actually being used — the right
+        // row of a repeat, not the last one rendered.
+        openedFromInstance = lastFocusedControl;
+        // The elements are about to be replaced; the instance keys they were registered under
+        // are stable, so only the element references are stale.
+        focusableControls.clear();
+        instancesOfNode.clear();
         const scope = rootScope();
         if (!activeRoute) {
             const missing = element('div', 'axiom-no-route');
@@ -1962,7 +2199,47 @@ export function createAxiomRuntime(options) {
         rootElement.replaceChildren(...(view ? [view] : []));
         restoreFocus();
     }
+    /**
+     * Where focus goes when the control that opened a dialog no longer exists.
+     *
+     * A destructive confirmation usually removes the very row its trigger was in, so the exact
+     * render instance is gone by the time the dialog closes. Dropping focus to the top of the
+     * document would lose a keyboard user's place entirely; the nearest equivalent is another
+     * instance of the same node — the next row's control. Absent that, nothing: an invented
+     * target would be worse than none.
+     */
+    function survivingSibling(instanceKeyValue) {
+        const nodeIdentity = instanceKeyValue.split('--')[0];
+        const remaining = instancesOfNode.get(nodeIdentity) ?? [];
+        for (const candidate of remaining) {
+            const element = focusableControls.get(candidate);
+            if (element) {
+                return element;
+            }
+        }
+        return undefined;
+    }
     function restoreFocus() {
+        // A dialog that just opened takes focus, now that its controls are in the document.
+        if (pendingDialogFocus) {
+            const entry = pendingDialogFocus;
+            pendingDialogFocus = null;
+            entry.focus?.();
+            return;
+        }
+        // A dialog that just closed takes precedence: focus belongs on whatever opened it, not on
+        // whatever happened to hold focus before the re-render.
+        if (pendingFocusReturn) {
+            const request = pendingFocusReturn;
+            pendingFocusReturn = null;
+            const target = request.startsWith('declared:')
+                ? focusableControls.get((instancesOfNode.get(request.slice('declared:'.length)) ?? [])[0] ?? '')
+                : (focusableControls.get(request) ?? survivingSibling(request));
+            if (target) {
+                target.focus?.();
+                return;
+            }
+        }
         if (!focusedInstance) {
             return;
         }
@@ -2068,6 +2345,45 @@ export function createAxiomRuntime(options) {
         },
     };
 }
+/**
+ * Local storage, where the browser will actually allow it.
+ *
+ * `localStorage` **exists and still throws**: an opaque origin — a sandboxed iframe, a
+ * `srcdoc` document, a `data:` URL, a private window with storage blocked — denies access on
+ * property read, not on use. Startup must not depend on that succeeding: a page that cannot
+ * persist should render and work, keeping the state in memory instead of failing to boot.
+ * Every call is guarded for the same reason: a write can fail on quota long after startup.
+ */
+function browserStorage(globals) {
+    let store;
+    try {
+        store = globals.localStorage;
+        if (!store) {
+            return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return {
+        read: (key) => {
+            try {
+                return store.getItem(key);
+            }
+            catch {
+                return null;
+            }
+        },
+        write: (key, value) => {
+            try {
+                store.setItem(key, value);
+            }
+            catch {
+                globals.console?.warn?.(`Axiom could not persist ${key}: storage is unavailable`);
+            }
+        },
+    };
+}
 /** Builds a host bound to the browser globals. Used by generated pages. */
 export function createBrowserHost() {
     const globals = globalThis;
@@ -2081,12 +2397,7 @@ export function createBrowserHost() {
         uuid: () => typeof globals.crypto?.randomUUID === 'function'
             ? globals.crypto.randomUUID()
             : `id-${Date.now().toString(16)}-${Math.floor(Math.random() * 1e9).toString(16)}`,
-        storage: globals.localStorage
-            ? {
-                read: (key) => globals.localStorage.getItem(key),
-                write: (key, value) => globals.localStorage.setItem(key, value),
-            }
-            : undefined,
+        storage: browserStorage(globals),
         report: (message) => globals.console?.warn?.(message),
     };
 }

package/dist/source.js

@@ -6,6 +6,7 @@ import { readFileSync } from 'node:fs';
  * bundle without a bundler.
  */
 const RUNTIME_MODULES = [
+    './group-fields.js',
     './mutation/values.js',
     './mutation/store.js',
     './mutation/transaction.js',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cynodia/axiom-runtime",
-  "version": "0.6.3-alpha.1",
+  "version": "0.7.0-alpha.2",
   "description": "Domain-independent runtime that executes an Axiom application graph.",
   "license": "MIT",
   "author": "AskTech AS",
@@ -31,7 +31,7 @@
     }
   },
   "dependencies": {
-    "@cynodia/axiom-core": "0.6.3-alpha.1"
+    "@cynodia/axiom-core": "0.7.0-alpha.2"
   },
   "scripts": {
     "build": "tsc -b tsconfig.json tsconfig.test.json",