@lostgradient/weft 0.2.1 → 0.4.0

package/dist/core/engine/checkpoint-side-effects.js

@@ -0,0 +1,35 @@
+export function stageAtomicWorkflowCommitSideEffects(internals, workflowId, sideEffects) {
+  if (sideEffects.conditions.length === 0 && sideEffects.operations.length === 0)
+    return;
+  const pending = internals.pendingAtomicWorkflowCommitSideEffects.get(workflowId);
+  if (pending === void 0) {
+    internals.pendingAtomicWorkflowCommitSideEffects.set(workflowId, {
+      conditions: [...sideEffects.conditions],
+      operations: [...sideEffects.operations]
+    });
+    return;
+  }
+  pending.conditions.push(...sideEffects.conditions);
+  pending.operations.push(...sideEffects.operations);
+}
+export function takePendingAtomicWorkflowCommitSideEffects(internals, workflowId) {
+  const pending = internals.pendingAtomicWorkflowCommitSideEffects.get(workflowId);
+  if (pending === void 0)
+    return;
+  internals.pendingAtomicWorkflowCommitSideEffects.delete(workflowId);
+  if (pending.conditions.length === 0 && pending.operations.length === 0)
+    return;
+  return {
+    conditions: [...pending.conditions],
+    operations: [...pending.operations]
+  };
+}
+export function clearPendingAtomicWorkflowCommitSideEffects(internals, workflowId) {
+  internals.pendingAtomicWorkflowCommitSideEffects.delete(workflowId);
+}
+export function pendingAtomicWorkflowCommitSideEffectsStagePut(internals, workflowId, key) {
+  const pending = internals.pendingAtomicWorkflowCommitSideEffects.get(workflowId);
+  if (pending === void 0)
+    return !1;
+  return pending.operations.some((operation) => operation.type === "put" && operation.key === key);
+}

package/dist/core/engine/child-workflow-cancellation.d.ts

@@ -0,0 +1,10 @@
+import { type BatchOperation } from '../../storage/interface.ts';
+import type { WorkflowHandle } from './handles.ts';
+import type { EngineInternals } from './internals.ts';
+type ChildCancellationCallbacks = {
+    getHandle: (workflowId: string) => WorkflowHandle;
+};
+export declare function buildChildCancellationOperations(internals: EngineInternals, workflowId: string, childWorkflowId: string): BatchOperation[];
+export declare function registerChildCancellationHandler(internals: EngineInternals, workflowId: string, childWorkflowId: string, callbacks: ChildCancellationCallbacks): void;
+export declare function rehydrateChildCancellationHandlers(internals: EngineInternals, workflowId: string, callbacks: ChildCancellationCallbacks): Promise<void>;
+export {};

package/dist/core/engine/child-workflow-cancellation.js

@@ -0,0 +1,40 @@
+import { KEYS, decodeStorageKeyComponent } from "../../storage/interface.js";
+import { registerCancelHandler } from "./cancel-handlers.js";
+import { EMPTY_STORAGE_VALUE } from "./lifecycle/shared.js";
+export function buildChildCancellationOperations(internals, workflowId, childWorkflowId) {
+  const operations = [
+    {
+      type: "put",
+      key: KEYS.childCancellation(workflowId, childWorkflowId),
+      value: EMPTY_STORAGE_VALUE
+    }
+  ], needsCleanupMarker = !internals.workflowsNeedingTerminalCleanup.has(workflowId);
+  internals.workflowsNeedingTerminalCleanup.add(workflowId);
+  if (needsCleanupMarker)
+    operations.push({
+      type: "put",
+      key: KEYS.terminalCleanupNeeded(workflowId),
+      value: EMPTY_STORAGE_VALUE
+    });
+  return operations;
+}
+export function registerChildCancellationHandler(internals, workflowId, childWorkflowId, callbacks) {
+  registerCancelHandler(internals, workflowId, () => callbacks.getHandle(childWorkflowId).cancel());
+}
+export async function rehydrateChildCancellationHandlers(internals, workflowId, callbacks) {
+  for await (const [key] of internals.storage.scan(KEYS.childCancellationPrefix(workflowId))) {
+    const childWorkflowId = decodeChildCancellationKey(workflowId, key);
+    if (childWorkflowId === null)
+      continue;
+    registerChildCancellationHandler(internals, workflowId, childWorkflowId, callbacks);
+  }
+}
+function decodeChildCancellationKey(workflowId, key) {
+  const prefix = KEYS.childCancellationPrefix(workflowId);
+  if (!key.startsWith(prefix))
+    return null;
+  const encodedChildWorkflowId = key.slice(prefix.length);
+  if (encodedChildWorkflowId.length === 0 || encodedChildWorkflowId.includes(":"))
+    return null;
+  return decodeStorageKeyComponent(encodedChildWorkflowId);
+}

package/dist/core/engine/child-workflow.js

@@ -1,3 +1,9 @@
+import { assertOnTerminalConflictUnsupported } from "../start-workflow-validation.js";
+import { stageAtomicWorkflowCommitSideEffects } from "./checkpoint-side-effects.js";
+import {
+  buildChildCancellationOperations,
+  registerChildCancellationHandler
+} from "./child-workflow-cancellation.js";
 import { WorkflowAlreadyExistsError } from "./errors.js";
 import { encodedValuesEqual } from "./state-utilities.js";
 export async function processChildWorkflowOperation(internals, workflowId, operation, callbacks) {
@@ -37,6 +43,7 @@ async function resolveCollisionChildHandle(childWorkflowId, operation, execution
   return callbacks.getHandle(childWorkflowId);
 }
 async function dispatchChildWorkflowStart(internals, childWorkflowId, operation, context, callbacks) {
+  assertOnTerminalConflictUnsupported(operation.options, "ctx.startChild");
   applyPendingChildExecutionContext(internals, context);
   try {
     return await callbacks.start(operation.workflowType, operation.input, {
@@ -45,19 +52,29 @@ async function dispatchChildWorkflowStart(internals, childWorkflowId, operation,
   } catch (error) {
     if (!(error instanceof WorkflowAlreadyExistsError))
       throw error;
-    return resolveCollisionChildHandle(childWorkflowId, operation, context.pendingExecutionStateOwnerId, error, callbacks);
+    return resolveCollisionChildHandle(childWorkflowId, operation, context.pendingExecutionStateOwnerId ?? void 0, error, callbacks);
   } finally {
     clearPendingChildExecutionContext(internals, context);
   }
 }
 export async function executeChildWorkflow(internals, workflowId, operation, currentDepth, callbacks) {
-  const rawId = operation.options?.id, childWorkflowId = typeof rawId === "string" ? rawId : crypto.randomUUID(), parentHeaders = internals.workflowHeaders.get(workflowId) ?? new Map, executionStateOwnerId = (await callbacks.loadWorkflowState(workflowId))?.executionStateOwnerId ?? workflowId, executeChild = async () => {
+  const rawId = operation.options?.id, childWorkflowId = typeof rawId === "string" ? rawId : crypto.randomUUID(), parentHeaders = internals.workflowHeaders.get(workflowId) ?? new Map, parentState = await callbacks.loadWorkflowState(workflowId), parentClosePolicy = resolveChildWorkflowParentClosePolicy(operation), executionStateOwnerId = parentClosePolicy === "abandon" ? null : parentState?.executionStateOwnerId ?? workflowId, executeChild = async () => {
     const context = {
       pendingNestingDepth: currentDepth + 1,
       pendingParentHeaders: internals.workflowHeaders.get(workflowId),
       pendingExecutionStateOwnerId: executionStateOwnerId
-    };
-    return (await dispatchChildWorkflowStart(internals, childWorkflowId, operation, context, callbacks)).result();
+    }, childHandle = await dispatchChildWorkflowStart(internals, childWorkflowId, operation, context, callbacks);
+    if (parentClosePolicy === "abandon")
+      return createChildWorkflowHandleReference(childHandle.id);
+    if (parentClosePolicy === "request-cancel") {
+      stageAtomicWorkflowCommitSideEffects(internals, workflowId, {
+        conditions: [],
+        operations: buildChildCancellationOperations(internals, workflowId, childHandle.id)
+      });
+      registerChildCancellationHandler(internals, workflowId, childHandle.id, callbacks);
+      return createChildWorkflowHandleReference(childHandle.id);
+    }
+    return childHandle.result();
   }, composedInterceptor = callbacks.getComposedWorkflowInterceptor();
   if (!composedInterceptor)
     return executeChild();
@@ -70,3 +87,9 @@ export async function executeChildWorkflow(internals, workflowId, operation, cur
     parentHeaders
   }, executeChild);
 }
+function resolveChildWorkflowParentClosePolicy(operation) {
+  return operation.options?.parentClosePolicy ?? "await";
+}
+function createChildWorkflowHandleReference(workflowId) {
+  return { id: workflowId };
+}

package/dist/core/engine/condition-waiters.d.ts

@@ -0,0 +1,14 @@
+import type { EngineInternals } from './internals.ts';
+/**
+ * Re-drive every in-process `ctx.waitUntil` waiter registered for a workflow.
+ * Called after an inline `onUpdate` handler runs (`tryInlineUpdateHandler`),
+ * since the handler may have mutated the workflow-local state a predicate reads.
+ * Each call wakes the parked `processWaitConditionOperation`, which re-evaluates
+ * its predicate against the (possibly mutated) state.
+ *
+ * Weft signals are pull-only (`ctx.waitForSignal`) and run no state-mutating
+ * handler, so signal delivery is intentionally NOT a re-drive trigger — `onUpdate`
+ * is the push path. Lives in its own module so `updates.ts` can call it without
+ * an import cycle through `operations-coordination.ts`.
+ */
+export declare function notifyConditionWaiters(internals: EngineInternals, workflowId: string): void;

package/dist/core/engine/condition-waiters.js

@@ -0,0 +1,5 @@
+export function notifyConditionWaiters(internals, workflowId) {
+  const resolve = internals.conditionWaiters.get(workflowId);
+  if (resolve)
+    resolve();
+}

package/dist/core/engine/construction.d.ts

@@ -3,6 +3,7 @@ import type { Storage as WeftStorage } from '../../storage/interface.ts';
 import { ActivityWorkerDispatcher } from '../../workers/activity-worker-dispatcher.ts';
 import type { ComposedWorkflowInterceptor, Interceptor } from '../interceptor.ts';
 import { type AnyActivityDefinition, type AnyWorkflowDefinition, type EngineOptions, type RegisteredWorkflowDefinition } from '../types.ts';
+import type { WorkflowLogRecord } from '../types/workflow-log.ts';
 import type { EngineConstructorOptions, ExecutionStrategyBundle, RegistrationEntry, ResolvedOptions } from './engine-internal-types.ts';
 export type KnownWorkflowNames<TWorkflows extends object> = Extract<keyof TWorkflows, string>;
 declare const emptyWorkflowDefinitions: unique symbol;
@@ -18,7 +19,6 @@ export type EngineCreateRuntimeOptions = EngineConstructorOptions & {
     workflows?: Record<string, AnyWorkflowDefinition> | undefined;
     recover?: boolean | undefined;
     acknowledgeUnknownWorkflowTypes?: boolean | undefined;
-    allowLegacyData?: boolean | undefined;
 };
 export type NormalizedWorkerExecutionConfiguration = {
     mode: 'inline';
@@ -54,7 +54,9 @@ export declare function createExecutionStrategyBundle(parameters: {
     getComposedWorkflowInterceptor?: () => ComposedWorkflowInterceptor | null;
     resolveWorkflowType: (target: string | Function) => string;
     registerCancelHandler?: (workflowId: string, handler: () => Promise<void> | void) => () => void;
+    recordFinalizerState?: (workflowId: string, value: unknown) => void;
     getWorkflowServices?: (workflowId: string) => unknown;
+    getLogSink?: () => ((record: WorkflowLogRecord) => void) | undefined;
 }): ExecutionStrategyBundle;
 export declare function createActivityWorkerDispatcher(activityExecution: EngineConstructorOptions['activityExecution']): ActivityWorkerDispatcher | null;
 export declare function createAlertManagerForEngine(engine: EventTarget, alerts: EngineOptions['alerts'] | undefined, getNow: () => number): AlertManager | null;

package/dist/core/engine/construction.js

@@ -3,6 +3,7 @@ import { CompressedStorage } from "../../storage/compressed-storage.js";
 import { MemoryStorage } from "../../storage/memory.js";
 import { ActivityWorkerDispatcher } from "../../workers/activity-worker-dispatcher.js";
 import { WorkerPool } from "../../workers/pool.js";
+import { optionalInlineDependencies } from "../inline-execution-strategy.context-options.js";
 import { InlineExecutionStrategy } from "../inline-execution-strategy.js";
 import {
   DEFAULT_RETENTION_SWEEP_BATCH_SIZE,
@@ -14,6 +15,7 @@ import {
   DEFAULT_WORKER_TURN_TIMEOUT_MS,
   MIN_WORKER_PROTOCOL_MESSAGE_BYTES
 } from "../worker-protocol.js";
+import { resolveOwnershipFields } from "./ownership-options.js";
 import {
   normalizeHistoryPolicy,
   normalizePayloadSizePolicy,
@@ -70,7 +72,8 @@ export function copyWorkflowDefinition(type, registration) {
     ...registration.description === void 0 ? {} : { description: registration.description },
     ...registration.inputSchema === void 0 ? {} : { inputSchema: registration.inputSchema },
     ...registration.outputSchema === void 0 ? {} : { outputSchema: registration.outputSchema },
-    ...registration.searchAttributes === void 0 ? {} : { searchAttributes: registration.searchAttributes }
+    ...registration.searchAttributes === void 0 ? {} : { searchAttributes: registration.searchAttributes },
+    ...registration.concurrency === void 0 ? {} : { concurrency: registration.concurrency }
   };
 }
 function resolveRetentionFields(options) {
@@ -103,15 +106,26 @@ function resolveHistoryFields(options) {
     payloadSizePolicy: normalizePayloadSizePolicy(options?.payloadSize, "options.payloadSize")
   };
 }
+const DEFAULT_SECOND_INSTANCE_HEARTBEAT_INTERVAL_MS = 15000;
+function resolveSecondInstanceFields(options) {
+  const enabled = defaultTo(options?.detectSecondInstance, !1), intervalMs = enabled ? normalizeRetentionDuration(options?.secondInstanceHeartbeatInterval, "options.secondInstanceHeartbeatInterval") ?? DEFAULT_SECOND_INSTANCE_HEARTBEAT_INTERVAL_MS : DEFAULT_SECOND_INSTANCE_HEARTBEAT_INTERVAL_MS;
+  return {
+    secondInstanceDetectionEnabled: enabled,
+    secondInstanceHeartbeatIntervalMs: intervalMs
+  };
+}
 export function resolveEngineOptions(storage, options, getNow) {
   return {
     storage,
     getNow,
     resolveWorkflowServices: options?.resolveWorkflowServices ?? null,
+    onLog: options?.onLog ?? null,
     ...resolveBooleanDefaults(options),
     ...resolveNumericDefaults(options),
     ...resolveRetentionFields(options),
-    ...resolveHistoryFields(options)
+    ...resolveHistoryFields(options),
+    ...resolveSecondInstanceFields(options),
+    ...resolveOwnershipFields(options)
   };
 }
 export function normalizeWorkerExecutionConfiguration(options) {
@@ -171,19 +185,23 @@ export function createExecutionStrategyBundle(parameters) {
     getComposedWorkflowInterceptor,
     resolveWorkflowType,
     registerCancelHandler,
-    getWorkflowServices
+    recordFinalizerState,
+    getWorkflowServices,
+    getLogSink
   } = parameters, workerExecutionConfiguration = normalizeWorkerExecutionConfiguration(options);
   if (workerExecutionConfiguration.mode === "worker") {
     const pool = new WorkerPool({
       workerUrl: workerExecutionConfiguration.workerExecution.workerUrl,
       concurrency: workerExecutionConfiguration.workerExecution.poolSize ?? 4,
       smol: workerExecutionConfiguration.workerExecution.smol ?? !1
-    }), strategyOptions = {
+    }), logSink = getLogSink?.(), strategyOptions = {
       broadcastEvents,
       requireProtocolVersion: workerExecutionConfiguration.requireProtocolVersion,
       discardOnCancel: workerExecutionConfiguration.discardOnCancel,
       workflowTurnTimeoutMs: workerExecutionConfiguration.workflowTurnTimeoutMs,
-      maxProtocolMessageBytes: workerExecutionConfiguration.maxProtocolMessageBytes
+      maxProtocolMessageBytes: workerExecutionConfiguration.maxProtocolMessageBytes,
+      getNow,
+      ...logSink !== void 0 && { onLog: logSink }
     };
     return {
       strategy: new WorkerExecutionStrategy(pool, strategyOptions),
@@ -192,13 +210,17 @@ export function createExecutionStrategyBundle(parameters) {
   }
   const inlineStrategy = new InlineExecutionStrategy({
     getRegistration,
-    ...getComposedWorkflowInterceptor !== void 0 && { getComposedWorkflowInterceptor },
     getNow,
     maxNestingDepth,
     development,
     resolveWorkflowType,
-    ...registerCancelHandler !== void 0 && { registerCancelHandler },
-    ...getWorkflowServices !== void 0 && { getWorkflowServices }
+    ...optionalInlineDependencies({
+      getComposedWorkflowInterceptor,
+      registerCancelHandler,
+      recordFinalizerState,
+      getWorkflowServices,
+      getLogSink
+    })
   });
   return { strategy: inlineStrategy, inlineStrategy };
 }

package/dist/core/engine/coordination-branch-executors.d.ts

@@ -0,0 +1,70 @@
+import type { ContextOperationRequest } from '../context.ts';
+import type { EngineInternals } from './internals.ts';
+/**
+ * The largest delay a host `setTimeout` can hold without overflow. Node and Bun
+ * store the delay in a 32-bit signed integer, so a value above this wraps and
+ * the timer fires almost immediately. A multi-day race-branch sleep must be
+ * chunked under this ceiling and re-armed, or it would win its race instantly.
+ */
+export declare const MAX_TIMER_DELAY_MS = 2147483647;
+/**
+ * Compute the next host-timer delay for a race-branch sleep: the milliseconds
+ * remaining until the deterministic `scheduledFireAt` deadline, clamped to
+ * `[0, MAX_TIMER_DELAY_MS]`. Clamping to the ceiling is what prevents a multi-day
+ * sleep from overflowing `setTimeout` and firing instantly — the caller re-arms
+ * against the same deadline until the remaining delay reaches `0`.
+ */
+export declare function nextSleepTimerDelayMs(scheduledFireAt: number, now: number): number;
+/**
+ * Abortable in-process `sleep` branch for `ctx.race` / `ctx.all`.
+ *
+ * Unlike a top-level `ctx.sleep` (which arms a durable timer and parks the whole
+ * generator), a sleep branch inside a coordination operation is a TRANSIENT
+ * in-process wait: the coordination operation as a whole is the durable unit, and
+ * on replay the cached winner short-circuits before any branch re-runs. So this
+ * must NOT touch `internals.scheduler` (a durable timer write would corrupt the
+ * timer index) — it waits with a plain timer that the race's AbortController can
+ * cancel when another branch wins.
+ *
+ * The deadline is the operation's deterministic `scheduledFireAt`, compared
+ * against the engine clock (`internals.options.getNow()`), not wall-clock
+ * `Date.now()`, so a clock-overriding deployment stays consistent. The remaining
+ * delay is recomputed against that absolute deadline on every chunk, which both
+ * chunks delays beyond {@link MAX_TIMER_DELAY_MS} (so a multi-day sleep does not
+ * overflow `setTimeout` and fire instantly) and self-corrects for timer drift.
+ *
+ * Note: because the timer is a real event-loop timer, a long sleep that WINS its
+ * race is not driven by a virtual-clock `advanceTime`; tests should use short
+ * real durations for sleep-wins paths (sleep-loses paths need no timing — the
+ * abort fires).
+ *
+ * The timer also observes the engine abort signal so a long sleep branch does
+ * not outlive engine disposal. `ctx.all` does not abort siblings (it has no
+ * loser), so without watching `internals.abortController.signal` a multi-day
+ * `ctx.all([ctx.sleep('30d')])` branch would keep a host timer alive after the
+ * engine is gone.
+ */
+export declare function executeSleepSubOperation(internals: EngineInternals, operation: Extract<ContextOperationRequest, {
+    type: 'sleep';
+}>, signal?: AbortSignal): Promise<void>;
+/**
+ * Abortable in-process `wait-signal` branch for `ctx.race` / `ctx.all`.
+ *
+ * A wait-signal branch must never consume its durable signal record itself —
+ * when it is woken it does not yet know whether it WON its race. So on delivery
+ * it resolves with a {@link createDeferredConsumeEnvelope | deferred-consume
+ * envelope}: the single atomic {@link consumeSignalWithAtomicWorkflowCommit} is wrapped in
+ * `finalize` and performed ONLY by the coordinator, on the winner, strictly
+ * after `Promise.race` / `Promise.all` settles. A losing branch (race settled by
+ * a sibling → `signal` aborts) drops its envelope unfinalized and releases its
+ * waiter via {@link releaseSignalWaiter} WITHOUT consuming, so the signal
+ * survives for a later `waitForSignal` or a replay.
+ *
+ * Reads are non-destructive {@link peekSignal}s until the coordinator finalizes;
+ * the identity-guarded release (`expectedResolve === deliver`) ensures a loser
+ * never clobbers another waiter (e.g. a later top-level `waitForSignal`) that
+ * reused the shared `${workflowId}:${signalName}` key.
+ */
+export declare function executeWaitSignalSubOperation(internals: EngineInternals, workflowId: string, operation: Extract<ContextOperationRequest, {
+    type: 'wait-signal';
+}>, signal?: AbortSignal): Promise<unknown>;

package/dist/core/engine/coordination-branch-executors.js

@@ -0,0 +1,107 @@
+import { createDeferredConsumeEnvelope } from "./deferred-consume-envelope.js";
+import {
+  consumeSignalWithAtomicWorkflowCommit,
+  peekSignal,
+  releaseSignalWaiter,
+  trackWaiterKey
+} from "./signals.js";
+export const MAX_TIMER_DELAY_MS = 2147483647;
+export function nextSleepTimerDelayMs(scheduledFireAt, now) {
+  return Math.min(Math.max(0, scheduledFireAt - now), MAX_TIMER_DELAY_MS);
+}
+export function executeSleepSubOperation(internals, operation, signal) {
+  signal?.throwIfAborted();
+  const engineAbort = internals.abortController.signal;
+  if (engineAbort.aborted)
+    return Promise.reject(engineAbort.reason ?? Error("aborted"));
+  if (nextSleepTimerDelayMs(operation.scheduledFireAt, internals.options.getNow()) === 0)
+    return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    let timer;
+    const cleanup = () => {
+      signal?.removeEventListener("abort", onAbort);
+      engineAbort.removeEventListener("abort", onAbort);
+    }, onAbort = () => {
+      clearTimeout(timer);
+      cleanup();
+      reject(signal?.reason ?? engineAbort.reason ?? Error("aborted"));
+    }, arm = () => {
+      const remainingMs = nextSleepTimerDelayMs(operation.scheduledFireAt, internals.options.getNow());
+      if (remainingMs === 0) {
+        cleanup();
+        resolve();
+        return;
+      }
+      timer = setTimeout(arm, remainingMs);
+    };
+    signal?.addEventListener("abort", onAbort, { once: !0 });
+    engineAbort.addEventListener("abort", onAbort, { once: !0 });
+    arm();
+  });
+}
+export function executeWaitSignalSubOperation(internals, workflowId, operation, signal) {
+  signal?.throwIfAborted();
+  const { signalName } = operation, waiterKey = `${workflowId}:${signalName}`, engineAbort = internals.abortController.signal;
+  return new Promise((resolve, reject) => {
+    let settled = !1, registered = !1;
+    const { promise: delivered, resolve: deliver } = Promise.withResolvers(), cleanup = () => {
+      signal?.removeEventListener("abort", onAbort);
+      engineAbort.removeEventListener("abort", onAbort);
+    }, finalize = async () => {
+      const consumed = await consumeSignalWithAtomicWorkflowCommit(internals, workflowId, signalName);
+      return consumed.found ? consumed.payload : void 0;
+    }, onAbort = () => {
+      if (settled)
+        return;
+      settled = !0;
+      cleanup();
+      if (registered)
+        releaseSignalWaiter(internals, workflowId, waiterKey, deliver);
+      reject(signal?.reason ?? engineAbort.reason ?? Error("aborted"));
+    }, win = () => {
+      if (settled)
+        return;
+      settled = !0;
+      cleanup();
+      resolve(createDeferredConsumeEnvelope(finalize));
+    }, fail = (error) => {
+      if (settled)
+        return;
+      settled = !0;
+      cleanup();
+      if (registered)
+        releaseSignalWaiter(internals, workflowId, waiterKey, deliver);
+      reject(error);
+    };
+    signal?.addEventListener("abort", onAbort, { once: !0 });
+    engineAbort.addEventListener("abort", onAbort, { once: !0 });
+    if (engineAbort.aborted) {
+      onAbort();
+      return;
+    }
+    (async () => {
+      const existing = await peekSignal(internals, workflowId, signalName);
+      if (settled)
+        return;
+      if (existing.found) {
+        win();
+        return;
+      }
+      internals.signalWaiters.set(waiterKey, deliver);
+      trackWaiterKey(internals.signalWaitersByWorkflow, workflowId, waiterKey);
+      registered = !0;
+      const buffered = await peekSignal(internals, workflowId, signalName);
+      if (settled)
+        return;
+      if (buffered.found) {
+        releaseSignalWaiter(internals, workflowId, waiterKey, deliver);
+        win();
+        return;
+      }
+      await delivered;
+      if (settled)
+        return;
+      win();
+    })().catch(fail);
+  });
+}

package/dist/core/engine/deferred-consume-envelope.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Deferred-consume envelopes for `wait-signal` branches inside `ctx.race` /
+ * `ctx.all`.
+ *
+ * A `wait-signal` branch must NOT destructively consume its durable signal
+ * record when it is woken — at that moment it does not yet know whether it WON
+ * its race. If a losing branch consumed, it would delete a signal that a later
+ * `waitForSignal` (or a replay) still needs. So a woken wait-signal branch
+ * resolves with one of these envelopes instead of a value: the branch defers the
+ * single destructive {@link import('./signals.ts').consumeSignal} into
+ * `finalize`, and ONLY the coordinator — which authoritatively knows the race
+ * winner once `Promise.race` settles — calls `finalize()`, on the winner alone.
+ * Losing branches drop their envelope unfinalized and release their waiter
+ * without consuming, so the signal survives.
+ *
+ * The envelope is branded with a unique {@link DEFERRED_CONSUME_BRAND} symbol and
+ * detected ONLY by that symbol, never structurally — a user's signal payload can
+ * legitimately be an object shaped like `{ finalize }`, and a structural check
+ * would misfire on it.
+ *
+ * Envelopes must never reach the durable operation cache (a function cannot
+ * round-trip `encode`/`decode`), so the coordinator finalize-and-unwraps every
+ * winning branch's envelope before the operation result is written — including
+ * envelopes nested at arbitrary positions inside a `ctx.all` array result that a
+ * nested coordinator surfaces up to its parent.
+ */
+declare const DEFERRED_CONSUME_BRAND: unique symbol;
+/**
+ * A branch result whose real value is produced by a single deferred consume that
+ * only the winning coordinator performs.
+ */
+export type DeferredConsumeEnvelope = {
+    readonly [DEFERRED_CONSUME_BRAND]: true;
+    /** Perform the single destructive consume and return the consumed payload. */
+    readonly finalize: () => Promise<unknown>;
+};
+/** Wrap a deferred consume into a branded envelope. */
+export declare function createDeferredConsumeEnvelope(finalize: () => Promise<unknown>): DeferredConsumeEnvelope;
+/** Detect an envelope by its brand symbol only (never structurally). */
+export declare function isDeferredConsumeEnvelope(value: unknown): value is DeferredConsumeEnvelope;
+/**
+ * Finalize-and-unwrap a coordination result before it is written to the durable
+ * cache. A winning `wait-signal` branch surfaces a {@link DeferredConsumeEnvelope}
+ * whose `finalize()` performs the single consume; a nested `ctx.all` branch
+ * surfaces an ARRAY that may hold envelopes at arbitrary positions, so arrays are
+ * walked and each element finalized. Any other value passes through untouched.
+ *
+ * This runs only on the WINNING path (race winner, or every branch of a settled
+ * `ctx.all`), so finalizing here is exactly the linearization point of "this
+ * branch won" — the consume happens strictly after the coordinator settled, and a
+ * losing branch's envelope is never reached, so its signal is never consumed.
+ *
+ * The array walk reconstructs arrays via `Promise.all(map(...))`. This is safe
+ * because coordination results are cache-safe encoded data: they round-trip
+ * `encode`/`decode` for the durable cache, so sparse holes, custom array
+ * properties, subclasses, and array identity are not preserved semantics here.
+ */
+export declare function finalizeAndUnwrap(value: unknown): Promise<unknown>;
+export {};

package/dist/core/engine/deferred-consume-envelope.js

@@ -0,0 +1,14 @@
+const DEFERRED_CONSUME_BRAND = Symbol("weft.deferredConsume");
+export function createDeferredConsumeEnvelope(finalize) {
+  return { [DEFERRED_CONSUME_BRAND]: !0, finalize };
+}
+export function isDeferredConsumeEnvelope(value) {
+  return typeof value === "object" && value !== null && value[DEFERRED_CONSUME_BRAND] === !0;
+}
+export async function finalizeAndUnwrap(value) {
+  if (isDeferredConsumeEnvelope(value))
+    return value.finalize();
+  if (Array.isArray(value))
+    return Promise.all(value.map((element) => finalizeAndUnwrap(element)));
+  return value;
+}

package/dist/core/engine/disposal.js

@@ -10,6 +10,9 @@ export function disposeEngine(internals) {
     resolveSignalWaiter();
   internals.signalWaiters.clear();
   internals.signalWaitersByWorkflow.clear();
+  for (const resolveConditionWaiter of internals.conditionWaiters.values())
+    resolveConditionWaiter();
+  internals.conditionWaiters.clear();
   disposeQueuedInlineWorkflowStarts(internals);
   internals.scheduler[Symbol.dispose]();
   internals.strategy[Symbol.dispose]();
@@ -22,6 +25,8 @@ export function disposeEngine(internals) {
     internals.retentionSweepInterval = null;
   }
   internals.nextRetentionSweepAt = null;
+  disposeSecondInstanceDetection(internals);
+  disposeLeaseManager(internals);
   internals.handleCache.clear();
   for (const waiter of internals.resultResolvers.values())
     waiter.reject(new EngineDisposedError);
@@ -34,6 +39,7 @@ export function disposeEngine(internals) {
   internals.workflowReviewIds.clear();
   internals.parkedInlineWorkflows.clear();
   internals.terminalizingWorkflows.clear();
+  internals.deliveredPendingUpdateIds.clear();
   internals.reviewTimerIds.clear();
   for (const controller of internals.pendingWebhooks)
     controller.abort();
@@ -43,11 +49,14 @@ export function disposeEngine(internals) {
   internals.checkpoints.clear();
   internals.pendingExecutionStateOwnerId = void 0;
   internals.workflowNestingDepths.clear();
+  internals.workflowServices.clear();
   internals.workflowHeaders.clear();
   internals.pendingStarts.clear();
   internals.pendingScheduleCreations.clear();
   internals.eventLogHeads.clear();
   internals.pendingTimelineEntries.clear();
+  internals.pendingAtomicWorkflowCommitSideEffects.clear();
+  internals.pendingAsyncActivityResolutions.clear();
   internals.workflowVersionTuples.clear();
   internals.workflowFeedListeners.clear();
   internals.activityRegistriesByWorkflow.clear();
@@ -56,3 +65,19 @@ export function disposeEngine(internals) {
   internals.broadcastChannel?.close();
   internals.broadcastChannel = null;
 }
+function disposeSecondInstanceDetection(internals) {
+  if (internals.secondInstanceDetectionInterval !== null) {
+    clearInterval(internals.secondInstanceDetectionInterval ?? void 0);
+    internals.secondInstanceDetectionInterval = null;
+  }
+  if (internals.secondInstanceDetector !== null) {
+    internals.secondInstanceDetector.stop();
+    internals.secondInstanceDetector = null;
+  }
+}
+function disposeLeaseManager(internals) {
+  if (internals.leaseManager !== null) {
+    internals.leaseManager.stop();
+    internals.leaseManager = null;
+  }
+}