@smithers-orchestrator/engine 0.20.1 → 0.20.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/engine",
-  "version": "0.20.1",
+  "version": "0.20.4",
   "description": "Concrete Smithers workflow execution engine",
   "type": "module",
   "sideEffects": false,
@@ -33,20 +33,19 @@
     "react": "^19.2.5",
     "react-dom": "^19.2.5",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/components": "0.20.1",
-    "@smithers-orchestrator/db": "0.20.1",
-    "@smithers-orchestrator/driver": "0.20.1",
-    "@smithers-orchestrator/errors": "0.20.1",
-    "@smithers-orchestrator/agents": "0.20.1",
-    "@smithers-orchestrator/react-reconciler": "0.20.1",
-    "@smithers-orchestrator/memory": "0.20.1",
-    "@smithers-orchestrator/observability": "0.20.1",
-    "@smithers-orchestrator/graph": "0.20.1",
-    "@smithers-orchestrator/sandbox": "0.20.1",
-    "@smithers-orchestrator/scheduler": "0.20.1",
-    "@smithers-orchestrator/scorers": "0.20.1",
-    "@smithers-orchestrator/time-travel": "0.20.1",
-    "@smithers-orchestrator/vcs": "0.20.1"
+    "@smithers-orchestrator/components": "0.20.4",
+    "@smithers-orchestrator/agents": "0.20.4",
+    "@smithers-orchestrator/driver": "0.20.4",
+    "@smithers-orchestrator/errors": "0.20.4",
+    "@smithers-orchestrator/graph": "0.20.4",
+    "@smithers-orchestrator/observability": "0.20.4",
+    "@smithers-orchestrator/sandbox": "0.20.4",
+    "@smithers-orchestrator/react-reconciler": "0.20.4",
+    "@smithers-orchestrator/scheduler": "0.20.4",
+    "@smithers-orchestrator/db": "0.20.4",
+    "@smithers-orchestrator/scorers": "0.20.4",
+    "@smithers-orchestrator/time-travel": "0.20.4",
+    "@smithers-orchestrator/vcs": "0.20.4"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/approvals.js

@@ -217,3 +217,9 @@ export function denyNode(adapter, runId, nodeId, iteration, note, decidedBy, dec
         approvalDecidedBy: decidedBy ?? null,
     }), Effect.withLogSpan("approval:deny"));
 }
+export const __approvalInternals = {
+    isAsyncApprovalRequest,
+    nextRunStatusForApproval,
+    serializeDecision,
+    validateNodeWaitingForApproval,
+};

package/src/child-workflow.js

@@ -161,3 +161,10 @@ export async function executeChildWorkflow(parentWorkflow, options) {
         output: normalizeChildOutput(result),
     };
 }
+export const __childWorkflowInternals = {
+    buildChildWorkflowRunId,
+    normalizeChildInput,
+    normalizeChildOutput,
+    resolveChildWorkflow,
+    stripSystemColumns,
+};

package/src/effect/builder.js

@@ -289,21 +289,16 @@ function deriveRetryCount(retry) {
             return Math.max(0, Math.floor(maxAttempts - 1));
         }
     }
-    try {
-        const driver = Effect.runSync(Schedule.driver(retry));
-        let count = 0;
-        while (count < 100) {
-            const exit = Effect.runSyncExit(driver.next(undefined));
-            if (Exit.isFailure(exit)) {
-                return count;
-            }
-            count += 1;
+    const driver = Effect.runSync(Schedule.driver(retry));
+    let count = 0;
+    while (count < 100) {
+        const exit = Effect.runSyncExit(driver.next(undefined));
+        if (Exit.isFailure(exit)) {
+            return count;
         }
-        return count;
-    }
-    catch {
-        return 0;
+        count += 1;
     }
+    return count;
 }
 /**
  * @template T
@@ -1101,3 +1096,43 @@ export const Smithers = {
     workflow,
     fragment,
 };
+
+export const __builderInternals = {
+    ApprovalDecision,
+    SmithersSqlite,
+    annotateLoops,
+    applyPrefixId,
+    assertUniqueHandleIds,
+    buildNeedsContext,
+    buildUserContext,
+    collectHandles,
+    compileGraph,
+    compileNeeds,
+    createBuilder,
+    createBuilderDb,
+    createInputTable,
+    createPayloadTable,
+    decodeSchema,
+    deriveRetryCount,
+    deriveRetryPolicy,
+    durationToMs,
+    encodeSchema,
+    evaluateSkip,
+    executeStepHandle,
+    extractResult,
+    isBuilderNode,
+    isWorkflowGraph,
+    makeFactory,
+    makeGraph,
+    makeTableName,
+    normalizeExecutionError,
+    readHandle,
+    readHandleMaybe,
+    readLatestHandleResult,
+    renderNode,
+    resolveEffectResult,
+    resolveHandleIteration,
+    sanitizeIdentifier,
+    sqlite,
+    stripPersistedKeys,
+};

package/src/effect/compute-task-bridge.js

@@ -38,13 +38,13 @@ function isAbortError(err) {
     }
     if (fromTaggedError(err)?.code === "TASK_ABORTED")
         return true;
-    if (err.name === "AbortError")
-        return true;
     if (typeof DOMException !== "undefined" &&
         err instanceof DOMException &&
         err.name === "AbortError") {
         return true;
     }
+    if (err.name === "AbortError")
+        return true;
     if (err instanceof Error) {
         return /aborted|abort/i.test(err.message);
     }
@@ -90,9 +90,6 @@ function validateHeartbeatValue(value, path, seen) {
         typeof value === "symbol") {
         throw new SmithersError("HEARTBEAT_PAYLOAD_NOT_JSON_SERIALIZABLE", `Heartbeat payload contains a non-JSON value (invalid at ${path}).`, { path, valueType: typeof value });
     }
-    if (typeof value !== "object") {
-        throw new SmithersError("HEARTBEAT_PAYLOAD_NOT_JSON_SERIALIZABLE", `Heartbeat payload contains an unsupported value at ${path}.`, { path });
-    }
     if (seen.has(value)) {
         throw new SmithersError("HEARTBEAT_PAYLOAD_NOT_JSON_SERIALIZABLE", "Heartbeat payload cannot contain circular references.", { path });
     }
@@ -171,6 +168,25 @@ function isHeartbeatPayloadValidationError(err) {
     return (code === "HEARTBEAT_PAYLOAD_NOT_JSON_SERIALIZABLE" ||
         code === "HEARTBEAT_PAYLOAD_TOO_LARGE");
 }
+/**
+ * @param {AbortController} controller
+ * @param {AbortSignal} signal
+ * @returns {() => void}
+ */
+function linkEffectAbortSignal(controller, signal) {
+    const forwardAbort = () => {
+        controller.abort(signal.reason ?? makeAbortError());
+    };
+    if (signal.aborted) {
+        forwardAbort();
+    }
+    else {
+        signal.addEventListener("abort", forwardAbort, { once: true });
+    }
+    return () => {
+        signal.removeEventListener("abort", forwardAbort);
+    };
+}
 /**
  * @param {_TaskDescriptor} desc
  * @param {boolean} cacheEnabled
@@ -288,46 +304,26 @@ export const executeComputeTaskBridge = async (adapter, db, runId, desc, eventBu
         finally {
             heartbeatWriteInFlight = false;
             if (heartbeatHasPendingWrite && !heartbeatClosed) {
-                if (heartbeatWriteTimer) {
-                    clearTimeout(heartbeatWriteTimer);
-                    heartbeatWriteTimer = undefined;
-                }
                 void flushHeartbeat();
             }
         }
     };
     /**
    * @param {unknown} data
-   * @param {{ internal?: boolean }} [opts]
    */
-    const queueHeartbeat = (data, opts) => {
+    const queueHeartbeat = (data) => {
         if (taskCompleted ||
             heartbeatClosed ||
-            (!opts?.internal && taskExecutionReturned)) {
+            taskExecutionReturned) {
             return;
         }
         const heartbeatAtMs = nowMs();
         let nextHeartbeatDataJson = null;
         let dataSizeBytes = 0;
-        try {
-            if (data !== undefined) {
-                const serialized = serializeHeartbeatPayload(data);
-                nextHeartbeatDataJson = serialized.heartbeatDataJson;
-                dataSizeBytes = serialized.dataSizeBytes;
-            }
-        }
-        catch (error) {
-            if (!opts?.internal) {
-                throw error;
-            }
-            logWarning("internal heartbeat payload rejected", {
-                runId,
-                nodeId: desc.nodeId,
-                iteration: desc.iteration,
-                attempt: attemptNo,
-                error: error instanceof Error ? error.message : String(error),
-            }, "heartbeat:record");
-            return;
+        if (data !== undefined) {
+            const serialized = serializeHeartbeatPayload(data);
+            nextHeartbeatDataJson = serialized.heartbeatDataJson;
+            dataSizeBytes = serialized.dataSizeBytes;
         }
         heartbeatPendingAtMs = heartbeatAtMs;
         heartbeatPendingDataJson = nextHeartbeatDataJson;
@@ -358,10 +354,6 @@ export const executeComputeTaskBridge = async (adapter, db, runId, desc, eventBu
             if (Exit.isSuccess(exit)) {
                 return exit.value;
             }
-            const failure = Cause.failureOption(exit.cause);
-            if (failure._tag === "Some") {
-                throw failure.value;
-            }
             throw Cause.squash(exit.cause);
         };
         const heartbeatTimeoutMs = desc.heartbeatTimeoutMs;
@@ -484,17 +476,7 @@ export const executeComputeTaskBridge = async (adapter, db, runId, desc, eventBu
             try: (effectSignal) => {
                 const computeAbortController = new AbortController();
                 const removeTaskAbortForwarder = wireAbortSignal(computeAbortController, taskSignal);
-                const forwardEffectAbort = () => {
-                    computeAbortController.abort(effectSignal.reason ?? makeAbortError());
-                };
-                if (effectSignal.aborted) {
-                    forwardEffectAbort();
-                }
-                else {
-                    effectSignal.addEventListener("abort", forwardEffectAbort, {
-                        once: true,
-                    });
-                }
+                const removeEffectAbortForwarder = linkEffectAbortSignal(computeAbortController, effectSignal);
                 return Promise.resolve()
                     .then(() => withTaskRuntime({
                     runId,
@@ -510,7 +492,7 @@ export const executeComputeTaskBridge = async (adapter, db, runId, desc, eventBu
                 }, () => desc.computeFn()))
                     .finally(() => {
                     removeTaskAbortForwarder();
-                    effectSignal.removeEventListener("abort", forwardEffectAbort);
+                    removeEffectAbortForwarder();
                 });
             },
             catch: (error) => error,
@@ -738,3 +720,16 @@ export const executeComputeTaskBridge = async (adapter, db, runId, desc, eventBu
         removeAbortForwarder();
     }
 };
+
+export const __computeTaskBridgeInternals = {
+    TASK_HEARTBEAT_MAX_PAYLOAD_BYTES,
+    TASK_HEARTBEAT_THROTTLE_MS,
+    TASK_HEARTBEAT_TIMEOUT_CHECK_MS,
+    heartbeatTimeoutReasonFromAbort,
+    isAbortError,
+    isHeartbeatPayloadValidationError,
+    linkEffectAbortSignal,
+    parseAttemptHeartbeatData,
+    serializeHeartbeatPayload,
+    validateHeartbeatValue,
+};

package/src/effect/deferred-state-bridge.js

@@ -1340,3 +1340,40 @@ export async function cancelPendingTimersBridge(adapter, runId, eventBus, reason
         }));
     }
 }
+
+export const __deferredStateBridgeInternals = {
+    buildApprovalRequestJson,
+    buildHumanRequestSchemaJson,
+    buildTimerAttemptMeta,
+    buildTimerSnapshot,
+    buildWaitForEventAttemptMeta,
+    buildWaitForEventSnapshot,
+    cancelPendingTimersBridge,
+    defaultAutoApprovalDecision,
+    ensurePendingHumanRequest,
+    failWaitForEventTaskBridge,
+    finishWaitForEventTaskBridge,
+    getHumanTaskPrompt,
+    parseAttemptErrorCode,
+    parseOptionalFiniteNumber,
+    parseTimerDurationMs,
+    parseTimerSnapshot,
+    parseTimerType,
+    parseTimerUntilMs,
+    parseWaitForEventCorrelationId,
+    parseWaitForEventOnTimeout,
+    parseWaitForEventSignalName,
+    parseWaitForEventSnapshot,
+    reconcileHumanRequestValidationFailure,
+    renderHumanPromptToText,
+    resolveApprovalTaskStateBridge,
+    resolveTimerTaskStateBridge,
+    resolveWaitForEventTaskStateBridge,
+    resolveWaitForEventTimeoutBridge,
+    shouldAutoApprove,
+    shouldClearAsyncWaitMetric,
+    syncApprovalDurableDeferredFromDb,
+    syncWaitForEventDurableDeferredFromDb,
+    updateAsyncExternalWaitPendingSafe,
+    validateDeferredOutputPayload,
+};

package/src/effect/diff-bundle.js

@@ -171,6 +171,24 @@ async function computeUntrackedDiffs(currentDir) {
     }
     return diffs;
 }
+/**
+ * @param {string} currentDir
+ * @param {string} targetRef
+ * @param {string} path
+ * @returns {Promise<string | undefined>}
+ */
+async function readBinaryContentAtRef(currentDir, targetRef, path) {
+    try {
+        const { stdout } = await runGit(currentDir, [
+            "show",
+            `${targetRef}:${path}`,
+        ]);
+        return Buffer.from(stdout, "binary").toString("base64");
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Compute a diff bundle strictly between two immutable refs.
  *
@@ -225,18 +243,7 @@ export async function computeDiffBundleBetweenRefs(baseRef, targetRef, currentDi
         const binary = isBinaryPatch(chunk) || binaryPaths.has(path);
         let binaryContent;
         if (binary && operation !== "delete") {
-            try {
-                const { stdout } = await runGit(currentDir, [
-                    "show",
-                    `${targetRef}:${path}`,
-                ]);
-                binaryContent = Buffer.from(stdout, "binary").toString("base64");
-            }
-            catch {
-                // File may not be readable as a blob at targetRef; fall through
-                // without binaryContent. Caller receives operation + diff only.
-                binaryContent = undefined;
-            }
+            binaryContent = await readBinaryContentAtRef(currentDir, targetRef, path);
         }
         patches.push({
             path,
@@ -350,3 +357,8 @@ export async function applyDiffBundle(bundle, targetDir) {
         }
     }
 }
+export const __diffBundleInternals = {
+    extractPatchPath,
+    readBinaryContentAtRef,
+    splitGitDiff,
+};

package/src/effect/durable-deferred-bridge.js

@@ -135,6 +135,12 @@ function buildResolvedWaitForEventMetaJson(snapshot, signal) {
         },
     });
 }
+async function decrementAsyncEventWaitPending(updatePending = updateAsyncExternalWaitPending) {
+    try {
+        await Effect.runPromise(updatePending("event", -1));
+    }
+    catch { }
+}
 /**
  * @param {_SmithersDb} adapter
  * @param {string} runId
@@ -154,10 +160,7 @@ async function markWaitForEventResolved(adapter, runId, nodeId, iteration, signa
         metaJson: buildResolvedWaitForEventMetaJson(snapshot, signal),
     }));
     if (snapshot.waitAsync) {
-        try {
-            await Effect.runPromise(updateAsyncExternalWaitPending("event", -1));
-        }
-        catch { }
+        await decrementAsyncEventWaitPending();
     }
 }
 const deferredResolutions = new Map();
@@ -280,3 +283,12 @@ export const bridgeSignalResolve = async (adapter, runId, signal) => {
         await bridgeWaitForEventResolve(adapter, runId, node.nodeId, iteration, signal);
     }
 };
+export const __durableDeferredBridgeInternals = {
+    buildResolvedWaitForEventMetaJson,
+    decrementAsyncEventWaitPending,
+    getAdapterNamespace,
+    markWaitForEventResolved,
+    normalizeCorrelationId,
+    parseOptionalFiniteNumber,
+    parseWaitForEventAttemptSnapshot,
+};

package/src/effect/http-runner.js

@@ -1,86 +1,2 @@
-import { HttpRunner } from "@effect/cluster";
-import { mkdir, cp, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { Effect, Layer } from "effect";
-import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
-import { spawnCaptureEffect } from "@smithers-orchestrator/driver/child-process";
-import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
-import { SandboxEntityExecutor } from "@smithers-orchestrator/sandbox/effect/sandbox-entity";
-/**
- * @param {SandboxTransportConfig} config
- * @returns {SandboxHandle}
- */
-function baseHandle(config) {
-    const sandboxRoot = join(config.rootDir, ".smithers", "sandboxes", config.runId, config.sandboxId);
-    return {
-        runtime: config.runtime,
-        runId: config.runId,
-        sandboxId: config.sandboxId,
-        sandboxRoot,
-        requestPath: join(sandboxRoot, "request"),
-        resultPath: join(sandboxRoot, "result"),
-    };
-}
-export const DockerSandboxExecutorLive = Layer.succeed(SandboxEntityExecutor, SandboxEntityExecutor.of({
-    create: (config) => Effect.gen(function* () {
-        const handle = baseHandle(config);
-        yield* spawnCaptureEffect("docker", ["info"], {
-            cwd: config.rootDir,
-            env: process.env,
-            timeoutMs: 10_000,
-            maxOutputBytes: 200_000,
-        }).pipe(Effect.catchAll(() => Effect.fail(new SmithersError("PROCESS_SPAWN_FAILED", "Docker daemon not reachable.", { runtime: "docker" }))));
-        yield* Effect.tryPromise({
-            try: async () => {
-                await mkdir(handle.requestPath, { recursive: true });
-                await mkdir(handle.resultPath, { recursive: true });
-            },
-            catch: (cause) => toSmithersError(cause, "create docker sandbox workspace"),
-        });
-        return handle;
-    }),
-    ship: (bundlePath, handle) => Effect.tryPromise({
-        try: async () => {
-            await rm(handle.requestPath, { recursive: true, force: true });
-            await mkdir(handle.requestPath, { recursive: true });
-            await cp(bundlePath, handle.requestPath, { recursive: true });
-        },
-        catch: (cause) => toSmithersError(cause, "ship docker bundle"),
-    }),
-    execute: (_command, _handle) => Effect.succeed({ exitCode: 0 }),
-    collect: (handle) => Effect.succeed({ bundlePath: handle.resultPath }),
-    cleanup: (_handle) => Effect.void,
-}));
-export const CodeplaneSandboxExecutorLive = Layer.succeed(SandboxEntityExecutor, SandboxEntityExecutor.of({
-    create: (config) => Effect.gen(function* () {
-        const apiUrl = process.env.CODEPLANE_API_URL;
-        const apiKey = process.env.CODEPLANE_API_KEY;
-        if (!apiUrl || !apiKey) {
-            yield* Effect.fail(new SmithersError("INVALID_INPUT", "Codeplane runtime requires CODEPLANE_API_URL and CODEPLANE_API_KEY."));
-        }
-        const handle = baseHandle(config);
-        yield* Effect.tryPromise({
-            try: async () => {
-                await mkdir(handle.requestPath, { recursive: true });
-                await mkdir(handle.resultPath, { recursive: true });
-            },
-            catch: (cause) => toSmithersError(cause, "create codeplane sandbox workspace"),
-        });
-        return {
-            ...handle,
-            workspaceId: `${config.runId}:${config.sandboxId}`,
-        };
-    }),
-    ship: (bundlePath, handle) => Effect.tryPromise({
-        try: async () => {
-            await rm(handle.requestPath, { recursive: true, force: true });
-            await mkdir(handle.requestPath, { recursive: true });
-            await cp(bundlePath, handle.requestPath, { recursive: true });
-        },
-        catch: (cause) => toSmithersError(cause, "ship codeplane bundle"),
-    }),
-    execute: (_command, _handle) => Effect.succeed({ exitCode: 0 }),
-    collect: (handle) => Effect.succeed({ bundlePath: handle.resultPath }),
-    cleanup: (_handle) => Effect.void,
-}));
-export const SandboxHttpRunner = HttpRunner;
+// Preserve the engine subpath while using the canonical sandbox implementation.
+export * from "@smithers-orchestrator/sandbox/effect/http-runner";

package/src/effect/single-runner.js

@@ -142,8 +142,15 @@ async function buildSingleRunnerRuntime() {
  * @returns {Promise<SingleRunnerRuntime>}
  */
 async function getSingleRunnerRuntime() {
+    return getSingleRunnerRuntimeFromBuilder(buildSingleRunnerRuntime);
+}
+/**
+ * @param {() => Promise<SingleRunnerRuntime>} buildRuntime
+ * @returns {Promise<SingleRunnerRuntime>}
+ */
+async function getSingleRunnerRuntimeFromBuilder(buildRuntime) {
     if (!singleRunnerRuntimePromise) {
-        singleRunnerRuntimePromise = buildSingleRunnerRuntime().catch((error) => {
+        singleRunnerRuntimePromise = buildRuntime().catch((error) => {
             singleRunnerRuntimePromise = undefined;
             throw error;
         });
@@ -187,3 +194,21 @@ export function subscribeTaskWorkerDispatches(subscriber) {
         dispatchSubscribers.delete(subscriber);
     };
 }
+
+export const __singleRunnerInternals = {
+    buildMissingExecutionResult,
+    buildSingleRunnerRuntime,
+    consumeWorkerError,
+    dispatchSubscribers,
+    getSingleRunnerRuntimeFromBuilder,
+    getSingleRunnerRuntime,
+    setSingleRunnerRuntimePromiseForTest: (promise) => {
+        singleRunnerRuntimePromise = promise;
+    },
+    notifyDispatchSubscribers,
+    runRegisteredExecution,
+    storeWorkerError,
+    toWorkerTaskError,
+    workerErrors,
+    workerExecutions,
+};