@cynodia/axiom-runtime 0.8.2-alpha.1 → 0.9.0-alpha.2

package/dist/dom.d.ts

@@ -86,5 +86,15 @@ export interface HostEnvironment {
     queryIntegration?(operationId: string, args: Record<string, unknown>, options: {
         timeoutMs?: number;
     }): Promise<IntegrationQueryOutcome>;
+    /**
+     * Reads a stored object's metadata by key and returns it as a `BlobRef` record.
+     *
+     * The same shape as `queryIntegration`, and for the same reason: a `blob-metadata`
+     * operation is a finite question resolved before the transaction opens. It returns the
+     * reference, never the bytes — nothing in the runtime ever holds an object's contents.
+     * Only the authoritative runtime calls this; object stores, like integrations, are
+     * server-only.
+     */
+    readBlobMetadata?(storageId: string, key: string): Promise<IntegrationQueryOutcome>;
 }
 //# sourceMappingURL=dom.d.ts.map

package/dist/runtime.d.ts

@@ -44,6 +44,10 @@ export declare const RUNTIME_DIAGNOSTIC_CODES: {
     readonly INTEGRATION_RESULT_INVALID: "INTEGRATION_RESULT_INVALID";
     /** An integration query failed. Never carries a provider secret. */
     readonly INTEGRATION_QUERY_FAILED: "INTEGRATION_QUERY_FAILED";
+    /** No host capable of reaching an object store is configured. */
+    readonly BLOB_STORAGE_UNAVAILABLE: "BLOB_STORAGE_UNAVAILABLE";
+    /** A `blob-metadata` lookup failed: no such key, a staged object, or the store refused. */
+    readonly BLOB_METADATA_FAILED: "BLOB_METADATA_FAILED";
 };
 export type RuntimeDiagnosticCode = (typeof RUNTIME_DIAGNOSTIC_CODES)[keyof typeof RUNTIME_DIAGNOSTIC_CODES];
 /**
@@ -81,6 +85,19 @@ export interface EffectIntentRecord {
     succeededEventId?: NodeId;
     failedEventId?: NodeId;
     outcome?: 'committed' | 'rolled-back';
+    /**
+     * Set instead of an integration operation when the intent is a storage effect — a
+     * `blob-commit` or a `blob-delete`. It rides the same outbox for the same reason: an
+     * object store cannot join an Axiom transaction, so the intent commits with the state
+     * that references the object and dispatches only afterwards. `operationId` then carries
+     * the store's id, so one log and one dispatcher serve both kinds of effect rather than
+     * a second, parallel durability system (spec 0.9 §57).
+     */
+    storage?: {
+        storageId: NodeId;
+        operation: 'commit' | 'delete';
+        key: string;
+    };
 }
 export interface ActionResult {
     ok: boolean;

package/dist/runtime.js

@@ -48,6 +48,10 @@ export const RUNTIME_DIAGNOSTIC_CODES = {
     INTEGRATION_RESULT_INVALID: 'INTEGRATION_RESULT_INVALID',
     /** An integration query failed. Never carries a provider secret. */
     INTEGRATION_QUERY_FAILED: 'INTEGRATION_QUERY_FAILED',
+    /** No host capable of reaching an object store is configured. */
+    BLOB_STORAGE_UNAVAILABLE: 'BLOB_STORAGE_UNAVAILABLE',
+    /** A `blob-metadata` lookup failed: no such key, a staged object, or the store refused. */
+    BLOB_METADATA_FAILED: 'BLOB_METADATA_FAILED',
 };
 const MISSING = Symbol('missing');
 function unwrapType(type) {
@@ -1083,6 +1087,7 @@ export function createAxiomRuntime(options) {
                 return;
             }
             case 'integration-query':
+            case 'blob-metadata':
                 // The result was already resolved and bound into the action's scope before this
                 // transaction opened — see `runActionAsync`. Nothing to do here; this case exists
                 // only so the kind is recognized rather than falling to `default`.
@@ -1109,6 +1114,27 @@ export function createAxiomRuntime(options) {
                 });
                 return;
             }
+            case 'blob-commit':
+            case 'blob-delete': {
+                // Identical discipline to `integration-effect`: no store is called here. Reaching
+                // the operation records intent in the same log, discarded on rollback the same way,
+                // and dispatched only once the surrounding transaction has committed.
+                effectIntentLog.push({
+                    id: host.uuid(),
+                    transactionId: context.transactionId,
+                    ...(context.sourceNodeId ? { actionId: context.sourceNodeId } : {}),
+                    operationId: operation.storageId,
+                    arguments: {},
+                    storage: {
+                        storageId: operation.storageId,
+                        operation: operation.kind === 'blob-commit' ? 'commit' : 'delete',
+                        key: toText(evaluate(operation.blobKey, scope)),
+                    },
+                    ...(operation.succeededEventId ? { succeededEventId: operation.succeededEventId } : {}),
+                    ...(operation.failedEventId ? { failedEventId: operation.failedEventId } : {}),
+                });
+                return;
+            }
             default:
                 result.push({
                     code: RUNTIME_DIAGNOSTIC_CODES.UNSUPPORTED_OPERATION,
@@ -1267,8 +1293,8 @@ export function createAxiomRuntime(options) {
             return result;
         });
     }
-    function actionHasIntegrationQuery(action) {
-        return (action.operations ?? []).some((operation) => operation.kind === 'integration-query');
+    function actionHasAsyncQuery(action) {
+        return (action.operations ?? []).some((operation) => operation.kind === 'integration-query' || operation.kind === 'blob-metadata');
     }
     /**
      * Resolves every top-level `integration-query` operation before the transaction opens,
@@ -1282,7 +1308,7 @@ export function createAxiomRuntime(options) {
      */
     async function runActionAsync(actionId, args = {}) {
         const action = ir.actions[actionId];
-        if (!action || !actionHasIntegrationQuery(action) || remoteActionIds.has(actionId)) {
+        if (!action || !actionHasAsyncQuery(action) || remoteActionIds.has(actionId)) {
             return runAction(actionId, args);
         }
         const scope = rootScope();
@@ -1290,7 +1316,55 @@ export function createAxiomRuntime(options) {
             scope.values.set(parameter.id, args[parameter.id] ?? null);
         }
         const presetBindings = new Map();
+        const failWith = (diagnostic) => {
+            report(diagnostic);
+            recordOutcome(actionId, 'failed', [diagnostic]);
+            renderApplication();
+            return { ok: false, diagnostics: [diagnostic] };
+        };
         for (const operation of action.operations ?? []) {
+            if (operation.kind === 'blob-metadata') {
+                // A metadata lookup is the storage half of the same pre-transaction phase: a finite
+                // question, answered before anything is mutated, whose result later operations read.
+                const key = toText(evaluate(operation.blobKey, scope));
+                let blobOutcome;
+                try {
+                    blobOutcome = await host.readBlobMetadata?.(String(operation.storageId), key);
+                }
+                catch (error) {
+                    blobOutcome = {
+                        ok: false,
+                        code: RUNTIME_DIAGNOSTIC_CODES.BLOB_METADATA_FAILED,
+                        message: error instanceof Error ? error.message : String(error),
+                    };
+                }
+                if (!blobOutcome) {
+                    return failWith({
+                        code: RUNTIME_DIAGNOSTIC_CODES.BLOB_STORAGE_UNAVAILABLE,
+                        message: `${action.name ?? action.id} reads object storage, but this host provides none`,
+                        severity: 'error',
+                        nodeId: action.id,
+                        actionId: action.id,
+                        details: { storageId: String(operation.storageId) },
+                    });
+                }
+                if (!blobOutcome.ok) {
+                    // The store's own code travels in `details.code` rather than replacing the
+                    // diagnostic code: a provider's vocabulary is not Axiom's, and a caller matching
+                    // on `code` must see a code this runtime actually declares.
+                    return failWith({
+                        code: RUNTIME_DIAGNOSTIC_CODES.BLOB_METADATA_FAILED,
+                        message: blobOutcome.message,
+                        severity: 'error',
+                        nodeId: action.id,
+                        actionId: action.id,
+                        details: { storageId: String(operation.storageId), code: blobOutcome.code },
+                    });
+                }
+                scope.values.set(operation.bindAs, blobOutcome.value);
+                presetBindings.set(operation.bindAs, blobOutcome.value);
+                continue;
+            }
             if (operation.kind !== 'integration-query') {
                 continue;
             }
@@ -2455,7 +2529,7 @@ export function createAxiomRuntime(options) {
         },
         async invokeActionAsync(id, args = {}) {
             const action = ir.actions[id];
-            if (action && actionHasIntegrationQuery(action) && !remoteActionIds.has(id)) {
+            if (action && actionHasAsyncQuery(action) && !remoteActionIds.has(id)) {
                 return runActionAsync(id, args);
             }
             const result = runAction(id, args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cynodia/axiom-runtime",
-  "version": "0.8.2-alpha.1",
+  "version": "0.9.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.8.2-alpha.1"
+    "@cynodia/axiom-core": "0.9.0-alpha.2"
   },
   "scripts": {
     "build": "tsc -b tsconfig.json tsconfig.test.json",