@bastani/atomic 0.9.18-alpha.7 → 0.9.19-alpha.1

package/dist/builtin/workflows/src/index.js

@@ -5387,8 +5387,8 @@ function pendingStageIdForReplay(backend, workflowId, replayKey, stageName) {
   return candidates.size === 1 ? candidates.values().next().value : undefined;
 }
 function createDurableStagePrimitive(input) {
-  return (name, options) => {
-    const replayKey = input.nextReplayKey(name);
+  return (name, options, reservedReplayKey) => {
+    const replayKey = reservedReplayKey ?? input.nextReplayKey(name);
     const cached = stageCheckpointWithOutput(input.backend, input.workflowId, replayKey);
     if (cached !== undefined) {
       input.recordCachedStage?.(name, replayKey, cached);
@@ -6467,6 +6467,11 @@ function classifyWorkflowFailure(error) {
   }
   return failureForDecision(unknownDecision(), message, error);
 }
+// dist/builtin/workflows/src/durable/workflow-status-transition.ts
+async function transitionDurableWorkflowStatus(backend, workflowId, expectedStatuses, status, pendingPrompts, resumable) {
+  return await backend.transitionWorkflowStatus(workflowId, expectedStatuses, status, pendingPrompts, resumable);
+}
+
 // dist/builtin/workflows/src/durable/dbos-process-owner.ts
 var DBOS_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/dbos-process-owner@1");
 function emptyOwner2() {
@@ -9748,6 +9753,7 @@ function isTerminalStage(stage) {
 function createStageScheduler(input) {
   const releaseBarriers = new Map;
   const cascadePauseOwners = new Map;
+  let runBarrier;
   const makeReleaseBarrier = () => {
     const resolver = Promise.withResolvers();
     resolver.promise.catch(() => {});
@@ -9869,6 +9875,8 @@ function createStageScheduler(input) {
     }
   };
   const rejectReleaseBarriers = (reason) => {
+    runBarrier?.reject(reason);
+    runBarrier = undefined;
     cascadePauseOwners.clear();
     for (const [stageId, barrier] of releaseBarriers) {
       releaseBarriers.delete(stageId);
@@ -9891,6 +9899,19 @@ function createStageScheduler(input) {
   };
   return {
     tracker: input.tracker,
+    isRunPaused: () => runBarrier !== undefined,
+    pauseRun: () => {
+      runBarrier ??= makeReleaseBarrier();
+    },
+    releaseRun: () => {
+      const barrier = runBarrier;
+      runBarrier = undefined;
+      barrier?.resolve();
+    },
+    waitForRunRelease: async () => {
+      while (runBarrier !== undefined)
+        await runBarrier.promise;
+    },
     stageById,
     setStageParentIds,
     descendantsOf,
@@ -10190,6 +10211,24 @@ function createRunLimiter(defaultConcurrency) {
   return new ConcurrencyLimiter(defaultConcurrency ?? 4);
 }
 
+// dist/builtin/workflows/src/shared/abort.ts
+function raceAbort2(operation, signal) {
+  if (signal === undefined)
+    return operation;
+  if (signal.aborted) {
+    operation.catch(() => {});
+    return Promise.reject(signal.reason ?? new DOMException("Workflow request aborted", "AbortError"));
+  }
+  const abort = Promise.withResolvers();
+  const onAbort = () => {
+    abort.reject(signal.reason ?? new DOMException("Workflow request aborted", "AbortError"));
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  return Promise.race([operation, abort.promise]).finally(() => {
+    signal.removeEventListener("abort", onAbort);
+  });
+}
+
 // dist/builtin/workflows/src/engine/primitives/chain.ts
 function createChainPrimitive(input) {
   return async (steps, options = {}) => {
@@ -10896,6 +10935,8 @@ function wrapUiWithDurable(base, deps) {
   return {
     async input(promptText) {
       const callerStack = new Error().stack;
+      for (let wait = deps.beforeCall?.();wait !== undefined; wait = deps.beforeCall?.())
+        await wait;
       const identity = nextIdentity("input", promptText, callerStack);
       const hit = cached(identity);
       if (typeof hit === "string") {
@@ -10915,6 +10956,8 @@ function wrapUiWithDurable(base, deps) {
     },
     async confirm(message) {
       const callerStack = new Error().stack;
+      for (let wait = deps.beforeCall?.();wait !== undefined; wait = deps.beforeCall?.())
+        await wait;
       const identity = nextIdentity("confirm", message, callerStack);
       const hit = cached(identity);
       if (typeof hit === "boolean") {
@@ -10934,6 +10977,8 @@ function wrapUiWithDurable(base, deps) {
     },
     async select(message, options) {
       const callerStack = new Error().stack;
+      for (let wait = deps.beforeCall?.();wait !== undefined; wait = deps.beforeCall?.())
+        await wait;
       const identity = nextIdentity("select", message, callerStack, [...options]);
       const hit = cached(identity);
       if (typeof hit === "string") {
@@ -10953,6 +10998,8 @@ function wrapUiWithDurable(base, deps) {
     },
     async editor(initial) {
       const callerStack = new Error().stack;
+      for (let wait = deps.beforeCall?.();wait !== undefined; wait = deps.beforeCall?.())
+        await wait;
       const identity = nextIdentity("editor", initial ?? "", callerStack, initial ?? null);
       const hit = cached(identity);
       if (typeof hit === "string") {
@@ -10972,6 +11019,8 @@ function wrapUiWithDurable(base, deps) {
     },
     async custom(factory, options) {
       const callerStack = new Error().stack;
+      for (let wait = deps.beforeCall?.();wait !== undefined; wait = deps.beforeCall?.())
+        await wait;
       const replayIdentity = options?.replayIdentity ?? factory?.name ?? "custom";
       const identity = nextIdentity("custom", replayIdentity, callerStack, { replayIdentity });
       const hit = cachedCustom(identity);
@@ -11004,26 +11053,32 @@ function buildExitGatedUiContext(input) {
   const base = input.opts.usePromptNodesForUi === true ? input.baseFromPromptNodes() : input.opts.executionMode === "non_interactive" && input.opts.ui === undefined ? makeHeadlessUnavailableUIContext() : normalizeUIContext(input.opts.ui);
   const promptNodeReplay = input.opts.usePromptNodesForUi === true && input.opts.continuation !== undefined;
   const durableBase = input.durableUi !== undefined && !promptNodeReplay ? wrapUiWithDurable(base, input.durableUi) : base;
+  const invoke = (call) => {
+    input.throwIfWorkflowExitSelected();
+    if (!promptNodeReplay || input.durableUi?.beforeCall === undefined)
+      return call();
+    return withPromptCallerStack(new Error().stack, async () => {
+      for (let wait = input.durableUi?.beforeCall?.();wait !== undefined; wait = input.durableUi?.beforeCall?.())
+        await wait;
+      input.throwIfWorkflowExitSelected();
+      return call();
+    });
+  };
   return {
     async input(promptText) {
-      input.throwIfWorkflowExitSelected();
-      return await durableBase.input(promptText);
+      return await invoke(() => durableBase.input(promptText));
     },
     async confirm(message) {
-      input.throwIfWorkflowExitSelected();
-      return await durableBase.confirm(message);
+      return await invoke(() => durableBase.confirm(message));
     },
     async select(message, options) {
-      input.throwIfWorkflowExitSelected();
-      return await durableBase.select(message, options);
+      return await invoke(() => durableBase.select(message, options));
     },
     async editor(initial) {
-      input.throwIfWorkflowExitSelected();
-      return await durableBase.editor(initial);
+      return await invoke(() => durableBase.editor(initial));
     },
     async custom(factory, options) {
-      input.throwIfWorkflowExitSelected();
-      return await durableBase.custom(factory, options);
+      return await invoke(() => durableBase.custom(factory, options));
     }
   };
 }
@@ -12304,6 +12359,61 @@ function workflowChildRunId(checkpoint) {
   return (parseWorkflowChildResult(checkpoint.output) ?? (hasCurrentIdentity ? undefined : parseLegacyWorkflowChildResult(checkpoint.output)))?.runId;
 }
 
+// dist/builtin/workflows/src/engine/run-paused-stage.ts
+function deferStageUntilRunRelease(input) {
+  let stage;
+  const current = () => {
+    input.signal.throwIfAborted();
+    if (input.isPaused())
+      throw new Error(`Workflow is paused; resume before synchronous access to stage ${input.name}`);
+    stage ??= input.create();
+    return stage;
+  };
+  const invoke = async (call) => {
+    while (input.isPaused())
+      await input.waitForRelease();
+    return call(current());
+  };
+  return {
+    name: input.name,
+    prompt: (...args) => invoke((stage2) => stage2.prompt(...args)),
+    complete: (...args) => invoke((stage2) => stage2.complete(...args)),
+    sendUserMessage: (...args) => invoke((stage2) => stage2.sendUserMessage(...args)),
+    steer: (...args) => invoke((stage2) => stage2.steer(...args)),
+    followUp: (...args) => invoke((stage2) => stage2.followUp(...args)),
+    subscribe: (...args) => current().subscribe(...args),
+    get sessionFile() {
+      return current().sessionFile;
+    },
+    get sessionId() {
+      return current().sessionId;
+    },
+    setModel: (...args) => invoke((stage2) => stage2.setModel(...args)),
+    setThinkingLevel: (...args) => current().setThinkingLevel(...args),
+    cycleModel: () => invoke((stage2) => stage2.cycleModel()),
+    cycleThinkingLevel: () => current().cycleThinkingLevel(),
+    get agent() {
+      return current().agent;
+    },
+    get model() {
+      return current().model;
+    },
+    get thinkingLevel() {
+      return current().thinkingLevel;
+    },
+    get messages() {
+      return current().messages;
+    },
+    get isStreaming() {
+      return current().isStreaming;
+    },
+    navigateTree: (...args) => invoke((stage2) => stage2.navigateTree(...args)),
+    compact: () => invoke((stage2) => stage2.compact()),
+    abortCompaction: () => current().abortCompaction(),
+    abort: () => invoke((stage2) => stage2.abort())
+  };
+}
+
 // dist/builtin/workflows/src/engine/run-returned-status.ts
 function classifyReturnedRunStatus(result, runSnapshot) {
   const structuredFailure = runSnapshot !== undefined ? structuredRecoverableWorkflowFailure(runSnapshot) : undefined;
@@ -12459,6 +12569,7 @@ function createToolAdmissionBoundary() {
 function createToolControlRegistry() {
   const byRun = new Map;
   const admissionByRun = new Map;
+  const runControls = new Map;
   const makeHandle = (registration) => ({
     runId: registration.runId,
     nodeId: registration.nodeId,
@@ -12517,9 +12628,18 @@ function createToolControlRegistry() {
     admissionBoundary(runId) {
       return admissionByRun.get(runId);
     },
+    registerRun(runId, handle) {
+      runControls.set(runId, handle);
+      return () => {
+        if (runControls.get(runId) === handle)
+          runControls.delete(runId);
+      };
+    },
+    runControl: (runId) => runControls.get(runId),
     clear() {
       byRun.clear();
       admissionByRun.clear();
+      runControls.clear();
     }
   };
 }
@@ -12576,7 +12696,7 @@ function createAdmittedToolExecutionTracker(options = {}) {
   };
   return {
     track(execution) {
-      if (state === "CLOSED") {
+      if (state === "CLOSED" || options.signal?.aborted) {
         const error = new Error("atomic-workflows: ctx.tool admission is closed for this run");
         execution.catch(() => {
           return;
@@ -12718,6 +12838,7 @@ function compatibleReplayedToolParents(tracker, translated, inferredParents, isR
 function createTrackedToolPrimitive(input) {
   let observedQuit;
   const admittedTools = createAdmittedToolExecutionTracker({
+    signal: input.controller.signal,
     onFailureObserved: ({ error, nodeId }) => {
       input.terminalEvents.selectFailure(error, nodeId);
     },
@@ -17629,14 +17750,7 @@ async function run(def, inputs, opts = {}) {
     terminalEvents.selectCancellation(ownController.signal.reason);
   }, { once: true });
   const callerSignal = opts.signal;
-  if (callerSignal) {
-    if (callerSignal.aborted)
-      ownController.abort(callerSignal.reason);
-    else
-      callerSignal.addEventListener("abort", () => {
-        ownController.abort(callerSignal.reason);
-      }, { once: true });
-  }
+  const onCallerAbort = () => ownController.abort(callerSignal?.reason);
   const exit = createWorkflowExitManager({ runId, exitScope, controller: ownController });
   const backendView = opts.durableBackend ?? getDurableBackend();
   const rootBackend = opts.durableRootBackend ?? backendView;
@@ -17730,28 +17844,7 @@ async function run(def, inputs, opts = {}) {
     classifiedFailures.set(error, classified);
     return classified;
   };
-  activeStore.recordRunStart(runSnapshot);
   const ownsCancellationRegistration = opts.signal === undefined && opts.cancellation !== undefined;
-  if (ownsCancellationRegistration)
-    opts.cancellation?.register(runId, ownController);
-  opts.onRunStart?.(runSnapshot);
-  if (opts.persistence) {
-    appendRunStart(opts.persistence, {
-      runId,
-      name: def.name,
-      inputs: resolvedInputs,
-      ...runSnapshot.parentRunId !== undefined ? { parentRunId: runSnapshot.parentRunId } : {},
-      ...runSnapshot.parentStageId !== undefined ? { parentStageId: runSnapshot.parentStageId } : {},
-      ...runSnapshot.rootRunId !== undefined ? { rootRunId: runSnapshot.rootRunId } : {},
-      ...runSnapshot.resumedFromRunId !== undefined ? { resumedFromRunId: runSnapshot.resumedFromRunId } : {},
-      ...runSnapshot.origin !== undefined ? { origin: runSnapshot.origin } : {},
-      ...runSnapshot.resumeFromStageId !== undefined ? { resumeFromStageId: runSnapshot.resumeFromStageId } : {},
-      ...runSnapshot.accumulatedDurationMs !== undefined ? { accumulatedDurationMs: runSnapshot.accumulatedDurationMs } : {},
-      ...runSnapshot.budget !== undefined ? { budget: runSnapshot.budget } : {},
-      ...runSnapshot.budgetState !== undefined ? { budgetState: runSnapshot.budgetState } : {},
-      ts: runSnapshot.startedAt
-    });
-  }
   const tracker = new GraphFrontierTracker;
   const inputConcurrency = resolveInputConcurrency(def.inputs, resolvedInputs);
   const inputRuntimeDefaults = resolveInputRuntimeDefaults(def, resolvedInputs), gitWorktreeSetupCacheOwner = createGitWorktreeSetupCacheOwner(opts.gitWorktreeSetupCache);
@@ -17773,6 +17866,17 @@ async function run(def, inputs, opts = {}) {
     tracker,
     stageRegistry: () => stageRegistry
   });
+  const waitForRunRelease = async () => {
+    await scheduler.waitForRunRelease();
+    ownController.signal.throwIfAborted();
+  };
+  const whenRunning = (call) => {
+    if (scheduler.isRunPaused())
+      return waitForRunRelease().then(() => whenRunning(call));
+    if (ownController.signal.aborted)
+      return Promise.reject(ownController.signal.reason);
+    return call();
+  };
   ownController.signal.addEventListener("abort", () => scheduler.rejectReleaseBarriers(ownController.signal.reason ?? new Error("atomic-workflows: run aborted")), { once: true });
   const finalizers = createRunFinalizers({
     def,
@@ -17974,6 +18078,10 @@ async function run(def, inputs, opts = {}) {
     workflowId: runId,
     backend: durableBackend,
     nextCheckpointId: checkpointIdGenerator,
+    beforeCall: () => {
+      ownController.signal.throwIfAborted();
+      return scheduler.isRunPaused() ? waitForRunRelease() : undefined;
+    },
     ...opts.usePromptNodesForUi === true ? {
       onReplay: async (request) => getPromptNodeUi().replayDurable(request)
     } : {}
@@ -17987,6 +18095,10 @@ async function run(def, inputs, opts = {}) {
     completedStageReplayKeys,
     sourceToReplayedNodeIds: sourceToContinuationNodeIds
   });
+  const recordCachedStage = (...args) => {
+    ownController.signal.throwIfAborted();
+    cachedStage.record(...args);
+  };
   const durableIntercomGroup = (replayKey, stageId) => {
     const stages = activeStore.runs().find((candidate) => candidate.id === runId)?.stages ?? [];
     return stages.find((stage) => stageId !== undefined && stage.id === stageId || stage.replayKey === replayKey)?.intercomGroup;
@@ -17998,7 +18110,7 @@ async function run(def, inputs, opts = {}) {
     nextReplayKey: (stageName) => stageReplayKeyGenerator(stageName),
     durableIntercomGroup,
     task: taskRunners.task,
-    recordCachedTask: cachedStage.record,
+    recordCachedTask: recordCachedStage,
     signal: ownController.signal,
     registerTailControl: (registration) => {
       registration.controller.signal.addEventListener("abort", () => {
@@ -18024,60 +18136,152 @@ async function run(def, inputs, opts = {}) {
     setChildDurableInvocation: (invocation) => {
       pendingChildDurableInvocation = invocation;
     },
-    recordCachedStage: cachedStage.record,
+    recordCachedStage,
     runTopology: durableRunTopology(runSnapshot),
     workflow: workflow2
   });
+  const pendingChildWorkflows = new Set;
+  const durableStage = createDurableStagePrimitive({
+    workflowId: runId,
+    backend: durableBackend,
+    nextReplayKey: (stageName) => stageReplayKeyGenerator(stageName),
+    durableIntercomGroup,
+    recordCachedStage,
+    stage: (name, options, replayKey) => {
+      const stage = runtime.stage(name, options);
+      const stageId = activeStore.runs().find((r) => r.id === runId)?.stages.at(-1)?.id;
+      if (stageId !== undefined)
+        completedStageReplayKeys.set(stageId, replayKey);
+      return stage;
+    }
+  });
+  const gatedTask = (...args) => whenRunning(() => durableTask(...args));
+  const chain = createChainPrimitive({ runtime, task: gatedTask });
+  const parallel = createParallelPrimitive({ runtime, task: gatedTask });
+  const ui = buildExitGatedUiContext({
+    opts,
+    throwIfWorkflowExitSelected: exit.throwIfWorkflowExitSelected,
+    durableUi: durableUiDeps,
+    baseFromPromptNodes: getPromptNodeUi
+  });
+  let pausedExit;
   const ctx = {
     inputs: resolvedInputs,
     runId,
     get cwd() {
       return resolveWorkflowCwd();
     },
-    exit: exit.exit,
-    ui: buildExitGatedUiContext({
-      opts,
-      throwIfWorkflowExitSelected: exit.throwIfWorkflowExitSelected,
-      durableUi: durableUiDeps,
-      baseFromPromptNodes: getPromptNodeUi
-    }),
-    stage: createDurableStagePrimitive({
-      workflowId: runId,
-      backend: durableBackend,
-      nextReplayKey: (stageName) => stageReplayKeyGenerator(stageName),
-      durableIntercomGroup,
-      recordCachedStage: cachedStage.record,
-      stage: (name, options, replayKey) => {
-        const stage = runtime.stage(name, options);
-        const stageId = activeStore.runs().find((r) => r.id === runId)?.stages.at(-1)?.id;
-        if (stageId !== undefined)
-          completedStageReplayKeys.set(stageId, replayKey);
-        return stage;
+    exit: (options) => {
+      if (scheduler.isRunPaused()) {
+        pausedExit ??= whenRunning(async () => exit.exit(options));
+        pausedExit.catch(() => {});
+        throw new Error("Workflow exit is waiting for explicit resume");
       }
+      return exit.exit(options);
+    },
+    ui,
+    stage: (name, options) => {
+      ownController.signal.throwIfAborted();
+      if (!scheduler.isRunPaused())
+        return durableStage(name, options);
+      const replayKey = stageReplayKeyGenerator(name);
+      return deferStageUntilRunRelease({
+        name,
+        create: () => durableStage(name, options, replayKey),
+        isPaused: scheduler.isRunPaused,
+        waitForRelease: waitForRunRelease,
+        signal: ownController.signal
+      });
+    },
+    task: gatedTask,
+    chain: (...args) => whenRunning(() => chain(...args)),
+    parallel: (...args) => whenRunning(() => parallel(...args)),
+    workflow: (...args) => whenRunning(() => {
+      const pending = durableWorkflow(...args);
+      pendingChildWorkflows.add(pending);
+      const settled = () => {
+        pendingChildWorkflows.delete(pending);
+      };
+      pending.then(settled, settled);
+      return pending;
     }),
-    task: durableTask,
-    chain: createChainPrimitive({ runtime, task: durableTask }),
-    parallel: createParallelPrimitive({ runtime, task: durableTask }),
-    workflow: durableWorkflow,
-    tool,
+    tool: (...args) => {
+      if (!scheduler.isRunPaused())
+        return tool(...args);
+      const pending = whenRunning(() => tool(...args));
+      pending.catch(() => {});
+      return pending;
+    },
     ...opts.models !== undefined ? { models: opts.models } : {}
   };
+  const runtimeSettled = Promise.withResolvers();
+  let pausePersistence;
+  const persistRunControl = async (status) => {
+    ownController.signal.throwIfAborted();
+    if (opts.parentRun !== undefined || durableBackend.getWorkflow(runId) === undefined)
+      return;
+    if (!await transitionDurableWorkflowStatus(durableBackend, runId, ["running", "paused"], status, undefined, true)) {
+      throw new Error(`Workflow ${runId} refused the durable ${status} transition`);
+    }
+    recordRunTimingCheckpoint(durableBackend, runSnapshot);
+    await durableBackend.flush(runId);
+  };
+  const unregisterRunControl = toolControls.registerRun(runId, {
+    get paused() {
+      return scheduler.isRunPaused();
+    },
+    pause: () => {
+      ownController.signal.throwIfAborted();
+      scheduler.pauseRun();
+      activeStore.recordRunPaused(runId, undefined, { resumable: true });
+      pausePersistence = persistRunControl("paused");
+      return pausePersistence;
+    },
+    resume: async () => {
+      await pausePersistence;
+      await persistRunControl("running");
+      ownController.signal.throwIfAborted();
+      activeStore.recordRunResumed(runId, undefined, { source: "run_control" });
+      scheduler.releaseRun();
+    },
+    quit: () => {
+      ownController.abort(new WorkflowGracefulQuitError(runId, "workflow runtime"));
+      return runtimeSettled.promise;
+    }
+  });
   terminalEvents.register();
   try {
-    if (opts.deferWorkflowStart === true) {
-      await nextEventLoopTurn();
-      if (ownController.signal.aborted) {
-        await admittedTools.closeAndDrain();
-        const selectedExit = findWorkflowExitSignal(ownController.signal.reason, exitScope);
-        if (selectedExit !== undefined)
-          return await finalizers.finalizeWorkflowExit(selectedExit);
-        const parentExit = parentWorkflowExitAbortReason(ownController.signal.reason);
-        if (parentExit !== undefined)
-          return await finalizers.finalizeParentWorkflowExitCancellation(parentExit);
-        return finalizeKilled(runId, runSnapshot, activeStore, opts.persistence, opts.onRunEnd);
-      }
+    if (callerSignal?.aborted)
+      onCallerAbort();
+    else
+      callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
+    activeStore.recordRunStart(runSnapshot);
+    if (ownsCancellationRegistration)
+      opts.cancellation?.register(runId, ownController);
+    opts.onRunStart?.(runSnapshot);
+    if (opts.persistence) {
+      appendRunStart(opts.persistence, {
+        runId,
+        name: def.name,
+        inputs: resolvedInputs,
+        ...runSnapshot.parentRunId !== undefined ? { parentRunId: runSnapshot.parentRunId } : {},
+        ...runSnapshot.parentStageId !== undefined ? { parentStageId: runSnapshot.parentStageId } : {},
+        ...runSnapshot.rootRunId !== undefined ? { rootRunId: runSnapshot.rootRunId } : {},
+        ...runSnapshot.resumedFromRunId !== undefined ? { resumedFromRunId: runSnapshot.resumedFromRunId } : {},
+        ...runSnapshot.origin !== undefined ? { origin: runSnapshot.origin } : {},
+        ...runSnapshot.resumeFromStageId !== undefined ? { resumeFromStageId: runSnapshot.resumeFromStageId } : {},
+        ...runSnapshot.accumulatedDurationMs !== undefined ? { accumulatedDurationMs: runSnapshot.accumulatedDurationMs } : {},
+        ...runSnapshot.budget !== undefined ? { budget: runSnapshot.budget } : {},
+        ...runSnapshot.budgetState !== undefined ? { budgetState: runSnapshot.budgetState } : {},
+        ts: runSnapshot.startedAt
+      });
     }
-    await admitDurableRootRun({
+    if (opts.deferWorkflowStart === true)
+      await raceAbort2(nextEventLoopTurn(), ownController.signal);
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
+    ownController.signal.throwIfAborted();
+    await raceAbort2(admitDurableRootRun({
       backend: durableBackend,
       runId,
       isChildRun: opts.parentRun !== undefined,
@@ -18085,7 +18289,10 @@ async function run(def, inputs, opts = {}) {
         ...durableRootRegistration,
         ...workflowInvocationMetadata(inputRuntimeDefaults, workflowInvocationCwd, gitWorktreeSetupCache, runSnapshot.origin)
       }
-    });
+    }), ownController.signal);
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
+    ownController.signal.throwIfAborted();
     if (opts.deferWorkflowStart === true)
       opts.onWorkflowStartReady?.();
     const sourceFrontierStage = opts.continuation?.source;
@@ -18093,8 +18300,17 @@ async function run(def, inputs, opts = {}) {
     const startupFrontierStage = sourceFrontierStage?.stages.find((stage) => stage.id === sourceFrontierId)?.name ?? "workflow frontier";
     if (budget.enabled)
       await budget.stopAtBoundaryAsync(startupFrontierStage);
-    const rawResult = await runWorkflowDefinitionCallback(def.name, runId, () => def.run(ctx));
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
+    ownController.signal.throwIfAborted();
+    const rawResult = await raceAbort2(runWorkflowDefinitionCallback(def.name, runId, () => def.run(ctx)), ownController.signal);
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
     await admittedTools.closeAndDrain();
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
+    if (pausedExit !== undefined)
+      await pausedExit;
     budget.rethrowIfSystemOwnedStop(runSnapshot.stages.at(-1)?.name ?? startupFrontierStage);
     const normalTerminalEvent = terminalEvents.winner();
     if (normalTerminalEvent?.kind === "cancellation") {
@@ -18115,7 +18331,10 @@ async function run(def, inputs, opts = {}) {
     const result = normalizeWorkflowRunOutput(def.name, rawResult);
     assertWorkflowRunOutputs(def.name, result, def.outputs);
     assertWorkflowCreatedExecution(runSnapshot);
-    await durableBackend.flush(runId);
+    await raceAbort2(durableBackend.flush(runId), ownController.signal);
+    while (scheduler.isRunPaused())
+      await waitForRunRelease();
+    ownController.signal.throwIfAborted();
     const returned = classifyReturnedRunStatus(result, runSnapshot);
     if (returned.status === "completed")
       assertFrontierConsumed();
@@ -18135,12 +18354,26 @@ async function run(def, inputs, opts = {}) {
     durableBackend.setWorkflowStatus(runId, returned.status, undefined, returned.metadata?.resumable);
     await durableBackend.flush(runId);
     return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: returned.status, result, error: returned.error }, opts.onRunEnd);
-  } catch (err) {
-    terminalEvents.selectFailure(err);
+  } catch (error) {
+    let err = error;
+    try {
+      while (scheduler.isRunPaused())
+        await waitForRunRelease();
+      if (pausedExit !== undefined)
+        await pausedExit;
+    } catch (stop) {
+      err = stop;
+    }
+    const selectedTerminalEvent = terminalEvents.selectFailure(err);
+    if (selectedTerminalEvent.kind === "failure" && ownController.signal.aborted && Object.is(err, ownController.signal.reason)) {
+      err = selectedTerminalEvent.error;
+    }
     const gracefulQuit = observedQuitCancellation() ?? observedTaskTailQuit ?? findWorkflowGracefulQuit(err) ?? findWorkflowGracefulQuit(ownController.signal.reason);
     if (gracefulQuit !== undefined)
       return suspendForGracefulQuit(gracefulQuit);
     await admittedTools.closeAndDrain();
+    if (ownController.signal.aborted)
+      await Promise.allSettled([...pendingChildWorkflows]);
     if (err instanceof WorkflowBudgetExceededError) {
       const pendingBudgetError = await budget.awaitPendingWrapUp();
       const selectedBudgetError = pendingBudgetError ?? err;
@@ -18209,6 +18442,9 @@ async function run(def, inputs, opts = {}) {
       onRunEnd: opts.onRunEnd
     });
   } finally {
+    callerSignal?.removeEventListener("abort", onCallerAbort);
+    runtimeSettled.resolve();
+    unregisterRunControl();
     try {
       await finalizeDurableTerminalStatus({
         runId,

package/docs/quickstart.md

@@ -32,7 +32,7 @@ bun add -g @bastani/atomic
 
 Atomic does not require package install scripts. Add `--ignore-scripts` if you want to disable dependency lifecycle scripts during a package install.
 
-Embedded PostgreSQL is also available without install scripts or a first-run download. npm-compatible package managers select a target-specific `@bastani/atomic-natives` package containing the runtime on Linux musl x64/ARM64 and Windows ARM64; standalone archives contain only their matching runtime. Both forms are offline at runtime. Windows ARM64 support is Windows x64 PostgreSQL under Windows 11's x64 emulation, not native PostgreSQL ARM64, and requires the Microsoft Visual C++ x64 v14 Redistributable. Windows 10 on ARM cannot run this x64 runtime.
+Embedded PostgreSQL is available without install scripts or a first-run download on Linux x64/ARM64 (glibc and musl), macOS x64/ARM64, and Windows x64/ARM64. npm-compatible package managers select the matching `@bastani/atomic-natives` leaf containing the runtime; standalone archives carry a target-selected runtime and resolve its binaries directly from the extracted installation. Keep the complete archive directory, including `node_modules`, libraries and licenses. Older upstream optional packages may also remain in npm installations for compatibility, but the native leaf takes precedence. Windows ARM64 uses Windows x64 PostgreSQL under Windows 11's x64 emulation, not native PostgreSQL ARM64, and requires the Microsoft Visual C++ x64 v14 Redistributable. Windows 10 on ARM cannot run this x64 runtime; Windows ARM64 execution still needs hardware validation.
 
 ### Release archive