@lostgradient/weft 0.20.0 → 0.21.0

package/dist/core/engine/fenced-write.js

@@ -1,6 +1,6 @@
 import { KEYS, storageConditionalBatch } from "../../storage/interface.js";
 import { decodeEpoch } from "./lease-codec.js";
-import { handleDeposition } from "./lease-deposition.js";
+import { emitWorkflowClaimLostWarning, handleDeposition } from "./lease-deposition.js";
 import { EngineDeposedError, EngineLeaseNotHeldError } from "./lease-errors.js";
 export function assertLeaseHeldForEngineWork(internals) {
   if (internals.options.ownershipMode !== "lease")
@@ -8,7 +8,9 @@ export function assertLeaseHeldForEngineWork(internals) {
   if (!(!internals.deposed && internals.leaseManager !== null && internals.leaseManager.currentEpochBytes() !== null))
     throw new EngineLeaseNotHeldError;
 }
-async function fencedCommit(internals, operations, baseConditions) {
+async function fencedCommit(internals, workflowId, operations, baseConditions) {
+  if (internals.options.ownershipMode === "workflow-lease" && workflowId !== null)
+    return fencedCommitForWorkflow(internals, workflowId, operations, baseConditions);
   const epochBytes = resolveFenceEpochOrHalt(internals);
   if (epochBytes === null) {
     if (baseConditions.length === 0) {
@@ -41,12 +43,30 @@ function resolveFenceEpochOrHalt(internals) {
   }
   return epochBytes;
 }
-export async function commitFencedEngineWrite(internals, operations, baseConditions, onLostRace) {
-  if (await fencedCommit(internals, operations, baseConditions) === "lost-race")
+async function fencedCommitForWorkflow(internals, workflowId, operations, baseConditions) {
+  const epochBytes = internals.workflowClaimRegistry?.currentEpochBytes(workflowId) ?? null;
+  if (epochBytes === null)
+    haltWorkflowClaim(workflowId);
+  const conditions = [
+    ...baseConditions,
+    { key: KEYS.workflowOwnerEpoch(workflowId), expectedValue: epochBytes }
+  ];
+  if (await storageConditionalBatch(internals.storage, conditions, operations))
+    return "committed";
+  if (await isWorkflowDeposed(internals, workflowId, epochBytes))
+    haltWorkflowClaim(workflowId);
+  return "lost-race";
+}
+function haltWorkflowClaim(workflowId) {
+  emitWorkflowClaimLostWarning(workflowId);
+  throw new EngineDeposedError(workflowId);
+}
+export async function commitFencedEngineWrite(internals, workflowId, operations, baseConditions, onLostRace) {
+  if (await fencedCommit(internals, workflowId, operations, baseConditions) === "lost-race")
     throw onLostRace();
 }
-export async function commitFencedEngineWriteAllowingPreconditionFailure(internals, operations, baseConditions) {
-  return await fencedCommit(internals, operations, baseConditions) === "committed";
+export async function commitFencedEngineWriteAllowingPreconditionFailure(internals, workflowId, operations, baseConditions) {
+  return await fencedCommit(internals, workflowId, operations, baseConditions) === "committed";
 }
 function epochBytesEqual(a, b) {
   if (b === null || a.byteLength !== b.byteLength)
@@ -69,3 +89,16 @@ async function isDeposed(internals, heldEpochBytes) {
     return !0;
   return !epochBytesEqual(heldEpochBytes, currentEpochRaw);
 }
+async function isWorkflowDeposed(internals, workflowId, heldEpochBytes) {
+  let currentEpochRaw;
+  try {
+    currentEpochRaw = await internals.storage.get(KEYS.workflowOwnerEpoch(workflowId));
+  } catch {
+    return !0;
+  }
+  if (currentEpochRaw === null)
+    return !0;
+  if (decodeEpoch(currentEpochRaw) === null)
+    return !0;
+  return !epochBytesEqual(heldEpochBytes, currentEpochRaw);
+}

package/dist/core/engine/finalizer-state.d.ts

@@ -16,7 +16,9 @@ import type { EngineInternals } from './internals.ts';
  * the next checkpoint still flushes the staged op in the terminal batch, so the
  * finalizer always sees the resource id. The staged op inherits the lease-epoch
  * fence (#470) for free, since checkpoint and terminal commits route through
- * `commitFencedWorkflowStateOperations`.
+ * `commitSelfWorkflowStateOperations` (completion) or
+ * `commitExternalTerminalWorkflowStateOperations` (cancel/timeout/suspend —
+ * ADR 0002), both in `storage-io.ts`.
  *
  * Oversized payloads are rejected before staging (the same hostile-input guard
  * activity results use). A call made once the workflow is already terminalizing

package/dist/core/engine/handle-result.d.ts

@@ -4,5 +4,53 @@ import type { EngineInternals } from './internals.ts';
 export declare function createWorkflowHandleWithResultPromise(internals: EngineInternals, workflowId: string): WorkflowHandle;
 export declare function createWorkflowResultWaiter(internals: EngineInternals, workflowId: string): WorkflowResultWaiter;
 export declare function getWorkflowResultPromise(internals: EngineInternals, workflowId: string): Promise<unknown>;
-export declare function bootstrapWorkflowResultResolver(internals: EngineInternals, workflowId: string, waiter: WorkflowResultWaiter): Promise<void>;
+/**
+ * Result promise for a parent generator parked on `ctx.startChild()`'s
+ * default `parentClosePolicy: 'await'` — the ONLY intended caller (see
+ * `child-workflow.ts`'s `executeChildWorkflow`, which must call this instead
+ * of the plain `childHandle.result()` / `handle.result()` path). Identical to
+ * {@link getWorkflowResultPromise} except the waiter this settles is marked
+ * generator-owned for `parentWorkflowId`: under `ownership: 'workflow-lease'`
+ * a settle attempt first confirms `parentWorkflowId` still holds the claim
+ * generation it parked under (`confirmWakeOwnership`, `'child-completion'`),
+ * fencing duplicate generator advancement (WFT-79 F1) — see
+ * {@link bootstrapWorkflowResultResolver}. Top-level, non-generator callers
+ * must keep using {@link getWorkflowResultPromise}, which stays unfenced by
+ * design: cross-engine `handle.result()` polling has no generator to
+ * duplicate and must remain settleable from durable state alone.
+ *
+ * If `internals.resultResolvers` already holds a waiter for `workflowId` —
+ * e.g. an observational `handle.result()` caller got there first — that
+ * SHARED waiter is untouched: {@link fenceResultOnParentGeneration} wraps
+ * only THIS caller's derived promise, so the observational caller's own
+ * promise settles normally from the shared waiter regardless of the parent's
+ * claim generation. See that function's doc for why fencing lives on the
+ * parent's view instead of the shared waiter itself.
+ */
+export declare function getGeneratorOwnedWorkflowResultPromise(internals: EngineInternals, workflowId: string, parentWorkflowId: string): Promise<unknown>;
+/**
+ * Settle result waiters for workflows this engine does not own, whose terminal
+ * transition lands on another engine and so never touches this engine's
+ * in-memory resolver map.
+ *
+ * Exported for `backgroundTasks: 'manual'`, where no timer runs and the host
+ * drives every background step through an awaited `runMaintenance()`.
+ */
+export declare function pollPendingCrossEngineResultWaiters(internals: EngineInternals): Promise<void>;
+/**
+ * Outcome of one {@link bootstrapWorkflowResultResolver} attempt, used by
+ * this file's callers to decide whether to keep polling:
+ *
+ * - `'settled'`: the waiter was resolved or rejected.
+ * - `'pending'`: no terminal result yet (still running, or a transient read
+ *   failure under a guaranteed-retry ownership mode). Keep polling.
+ *
+ * A generator-owned caller's discarded parent generation needs no outcome
+ * here at all: `fenceResultOnParentGeneration` withholds settlement on that
+ * caller's own derived promise, independent of whether the SHARED waiter
+ * this function settles ever resolves.
+ */
+type ResultResolutionOutcome = 'settled' | 'pending';
+export declare function bootstrapWorkflowResultResolver(internals: EngineInternals, workflowId: string, waiter: WorkflowResultWaiter): Promise<ResultResolutionOutcome>;
 export declare function cacheHandle(internals: EngineInternals, workflowId: string, handle: WorkflowHandle): void;
+export {};

package/dist/core/engine/handle-result.js

@@ -1,6 +1,7 @@
 import { EngineDisposedError } from "./errors.js";
 import { WorkflowHandle } from "./handles.js";
-import { loadWorkflowResult, loadWorkflowState } from "./storage-io.js";
+import { deriveWorkflowResultFromState, loadWorkflowState } from "./storage-io.js";
+import { confirmWakeOwnership } from "./wake-ownership-guard.js";
 export function createWorkflowHandleWithResultPromise(internals, workflowId) {
   const handle = new WorkflowHandle(workflowId, internals.engine);
   cacheHandle(internals, workflowId, handle);
@@ -22,32 +23,106 @@ export function getWorkflowResultPromise(internals, workflowId) {
     return rejected;
   }
   const waiter = createWorkflowResultWaiter(internals, workflowId);
-  bootstrapWorkflowResultResolver(internals, workflowId, waiter);
+  bootstrapWorkflowResultResolver(internals, workflowId, waiter).then(() => scheduleCrossEngineResultPollIfPending(internals, workflowId, waiter));
   return waiter.promise;
 }
-export async function bootstrapWorkflowResultResolver(internals, workflowId, waiter) {
+export function getGeneratorOwnedWorkflowResultPromise(internals, workflowId, parentWorkflowId) {
+  return fenceResultOnParentGeneration(internals, parentWorkflowId, getWorkflowResultPromise(internals, workflowId));
+}
+function fenceResultOnParentGeneration(internals, parentWorkflowId, promise) {
+  const gate = Promise.withResolvers();
+  promise.then(async (value) => {
+    if (await parentStillOwnsGeneration(internals, parentWorkflowId))
+      gate.resolve(value);
+  }, async (error) => {
+    if (await parentStillOwnsGeneration(internals, parentWorkflowId))
+      gate.reject(error);
+  });
+  return gate.promise;
+}
+async function parentStillOwnsGeneration(internals, parentWorkflowId) {
   try {
-    const state = await loadWorkflowState(internals, workflowId);
-    if (linkToReplacementWaiter(internals, workflowId, waiter))
-      return;
-    if (!state) {
-      internals.resultResolvers.delete(workflowId);
-      waiter.reject(Error(`Workflow "${workflowId}" not found in storage`));
-      return;
-    }
-    if (state.status === "running" || state.status === "pending" || state.status === "suspended")
-      return;
+    return await confirmWakeOwnership(internals, parentWorkflowId, "child-completion") === "proceed";
+  } catch {
+    return !0;
+  }
+}
+function scheduleCrossEngineResultPollIfPending(internals, workflowId, waiter) {
+  if (internals.workflowClaimRegistry === null)
+    return;
+  if (internals.resultResolvers.get(workflowId) !== waiter)
+    return;
+  if (internals.options.backgroundTaskMode !== "automatic")
+    return;
+  const handle = setTimeout(() => {
+    internals.pendingResultPollTimers.delete(handle);
+    bootstrapWorkflowResultResolver(internals, workflowId, waiter).then(() => scheduleCrossEngineResultPollIfPending(internals, workflowId, waiter));
+  }, internals.options.workflowClaimRenewIntervalMs);
+  internals.pendingResultPollTimers.add(handle);
+  handle.unref?.();
+}
+export async function pollPendingCrossEngineResultWaiters(internals) {
+  if (internals.workflowClaimRegistry === null)
+    return;
+  const pending = Array.from(internals.resultResolvers.entries());
+  for (const [workflowId, waiter] of pending) {
+    if (await deferToLocalTerminalDeliveryIfPending(internals, workflowId, waiter))
+      continue;
     try {
-      const result = await loadWorkflowResult(internals, workflowId);
-      clearResultWaiter(internals, workflowId, waiter);
-      waiter.resolve(result);
-    } catch (error) {
-      clearResultWaiter(internals, workflowId, waiter);
-      waiter.reject(error);
-    }
+      await bootstrapWorkflowResultResolver(internals, workflowId, waiter);
+    } catch {}
+  }
+}
+function settleOrRetryOnTransientReadFailure(internals, workflowId, waiter, error) {
+  if (internals.workflowClaimRegistry === null) {
+    clearResultWaiter(internals, workflowId, waiter);
+    waiter.reject(error);
+    return "settled";
+  }
+  return "pending";
+}
+async function deferToLocalTerminalDeliveryIfPending(internals, workflowId, waiter) {
+  if (internals.workflowClaimRegistry?.currentEpoch(workflowId) == null)
+    return !1;
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  return internals.resultResolvers.get(workflowId) !== waiter;
+}
+async function prepareToSettleTerminalWaiter(internals, workflowId, waiter) {
+  if (await deferToLocalTerminalDeliveryIfPending(internals, workflowId, waiter))
+    return "settled";
+  return "proceed";
+}
+export async function bootstrapWorkflowResultResolver(internals, workflowId, waiter) {
+  let state;
+  try {
+    state = await loadWorkflowState(internals, workflowId);
+  } catch (error) {
+    return settleOrRetryOnTransientReadFailure(internals, workflowId, waiter, error);
+  }
+  if (linkToReplacementWaiter(internals, workflowId, waiter))
+    return "settled";
+  if (!state) {
+    const outcome = await prepareToSettleTerminalWaiter(internals, workflowId, waiter);
+    if (outcome !== "proceed")
+      return outcome;
+    internals.resultResolvers.delete(workflowId);
+    waiter.reject(Error(`Workflow "${workflowId}" not found in storage`));
+    return "settled";
+  }
+  if (state.status === "running" || state.status === "pending" || state.status === "suspended")
+    return "pending";
+  const outcome = await prepareToSettleTerminalWaiter(internals, workflowId, waiter);
+  if (outcome !== "proceed")
+    return outcome;
+  try {
+    const result = deriveWorkflowResultFromState(state);
+    clearResultWaiter(internals, workflowId, waiter);
+    waiter.resolve(result);
+    return "settled";
   } catch (error) {
     clearResultWaiter(internals, workflowId, waiter);
     waiter.reject(error);
+    return "settled";
   }
 }
 function linkToReplacementWaiter(internals, workflowId, waiter) {

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

@@ -27,7 +27,9 @@ export type { PendingAsyncActivity } from './async-activity-records.ts';
 export type { PendingTimelineEntry, RegistrationEntry, ResolvedOptions, TrackedWaiterKeys, WorkflowResultWaiter, } from './engine-internal-types.ts';
 export { ActivityResolutionError, BulkDeleteRequiresTerminalWorkflowsError, BulkOperationConfirmationError, EngineCreateNameMismatchError, EngineDisposalError, EngineDisposedError, IdempotencyKeyPurgedError, PersistedDataIncompatibleError, StartOrSignalConflictError, WorkflowAlreadyExistsError, WorkflowConcurrencyLimitExceededError, WorkflowNotFoundError, WorkflowNotRegisteredError, WorkflowSuspendNotSupportedError, WorkflowTeardownPendingError, WorkflowTypeNotRegisteredForRecoveryError, } from './errors.ts';
 export { HANDLE_RESULT_PROMISE, WorkflowHandle } from './handles.ts';
-export { EngineLeaseAcquisitionTimeoutError, EngineLeaseCorruptedError, EngineLeaseNotHeldError, } from './lease-errors.ts';
+export { WeftWorkflowClaimLostWarning, WeftWorkflowWakeDiscardedWarning, WORKFLOW_CLAIM_LOST_WARNING_NAME, WORKFLOW_WAKE_DISCARDED_WARNING_NAME, } from './lease-deposition.ts';
+export type { WorkflowWakeKind } from './lease-deposition.ts';
+export { EngineLeaseAcquisitionTimeoutError, EngineLeaseCorruptedError, EngineLeaseNotHeldError, OwnershipModeMismatchError, WorkflowClaimUnavailableError, } from './lease-errors.ts';
 export type { EngineLeaseHealth, LeaseLostReason } from './lease-health.ts';
 export type { RecoverAllOptions, RecoveredWorkflowInfo } from './lifecycle.ts';
 export { ScheduleHandle } from './schedule-handle.ts';
@@ -272,13 +274,19 @@ export declare class Engine<TWorkflows extends object = DefaultWorkflowRegistry,
     aggregate(filter: ListFilter | undefined, options: AggregateOptions): Promise<AggregateResult>;
     getRetentionOverview(): RetentionOverview;
     /**
-     * Run one host-driven maintenance cycle. This fires due durable timers,
-     * deletes expired update responses, applies configured retention, and
-     * re-evaluates alert rules without relying on process-local intervals.
+     * Run one host-driven maintenance cycle. This runs the `ownership:
+     * 'workflow-lease'` construction gates (idempotent — a no-op once already
+     * bootstrapped) and one per-workflow claim-renewal pass, fires due durable
+     * timers, deletes expired update responses, applies configured retention,
+     * and re-evaluates alert rules without relying on process-local intervals.
      *
      * Use with `backgroundTasks: 'manual'` from a serverless alarm, Cron trigger,
      * or another externally scheduled wake-up. Concurrent calls are safe, but a
-     * host should await each cycle before scheduling another.
+     * host should await each cycle before scheduling another. Under `ownership:
+     * 'workflow-lease'`, this is also the ONLY thing that renews this engine's
+     * per-workflow claims in manual mode — no interval is ever started for
+     * `backgroundTasks: 'manual'`, so a host that calls this less often than
+     * `workflowClaimRenewInterval` will see its own live claims lapse.
      */
     runMaintenance(now?: number): Promise<void>;
     purge(filter?: ListFilter): Promise<PurgeResult>;

package/dist/core/engine/index.js

@@ -37,6 +37,7 @@ import {
   untagAll as untagAllWorkflows
 } from "./bulk-operations.js";
 import { createTimeOperationCallbacks as createTimeOperationCallbacksForEngine } from "./callback-creators-bundles.js";
+import { createPendingUpdateCallbacks as createPendingUpdateCallbacksForEngine } from "./callback-creators-core.js";
 import {
   createBroadcastCallbacks as createBroadcastCallbacksForEngine,
   createInlineParkingCallbacks as createInlineParkingCallbacksForEngine,
@@ -88,7 +89,8 @@ import { recordFinalizerState } from "./finalizer-state.js";
 import { getFinalizerStatus as getFinalizerStatusFromInternals } from "./finalizer-status.js";
 import {
   createWorkflowHandleWithResultPromise as createWorkflowHandleWithResultPromiseFromInternals,
-  getWorkflowResultPromise as getWorkflowResultPromiseFromInternals
+  getWorkflowResultPromise as getWorkflowResultPromiseFromInternals,
+  pollPendingCrossEngineResultWaiters
 } from "./handle-result.js";
 import { HANDLE_RESULT_PROMISE, WorkflowHandle } from "./handles.js";
 import { hasQueuedInlineWorkflowStart } from "./inline-launch-queue.js";
@@ -119,6 +121,12 @@ import { getStreamChunksFromInternals } from "./operations-stream.js";
 import {
   handleTimerFired as handleTimerFiredFromInternals
 } from "./operations-time.js";
+import {
+  bootstrapWorkflowLeaseOwnership,
+  buildOwnerSideSignalPollTarget
+} from "./ownership-bootstrap.js";
+import { bootstrapOwnershipGates } from "./ownership-mode-marker.js";
+import { processPendingUpdatesForHandlers as processPendingUpdatesForHandlersFromInternals } from "./pending-updates.js";
 import { assertCompatiblePersistedDataVersion } from "./persisted-data-version.js";
 import { query as queryWorkflow } from "./queries.js";
 import {
@@ -154,7 +162,11 @@ import {
   createSecondInstanceDetectionTick,
   createSecondInstanceDetector
 } from "./second-instance-detector.js";
-import { signal as signalWorkflow } from "./signals.js";
+import {
+  hasBufferedSignal as hasBufferedSignalFromInternals,
+  releaseSignalWaiter,
+  signal as signalWorkflow
+} from "./signals.js";
 import {
   loadScheduleState,
   loadWorkflowState,
@@ -173,12 +185,14 @@ import {
   timeoutWorkflow as timeoutWorkflowFromTermination
 } from "./termination.js";
 import {
+  deliverCoordinatedUpdateToWaiterIfAvailable as deliverCoordinatedUpdateToWaiterIfAvailableFromInternals,
   getUpdateResult as getUpdateResultFromInternals,
   submitCoordinatedUpdate as submitCoordinatedUpdateFromInternals,
   update as updateFromInternals
 } from "./updates.js";
 import { isTerminalWorkflowStatus } from "./validation.js";
 import { coerceScheduleId } from "./validation/schedule.js";
+import { confirmWakeOwnership } from "./wake-ownership-guard.js";
 import {
   replayWorkflowFeed,
   snapshotWorkflowFeedTail,
@@ -209,10 +223,18 @@ export {
   WorkflowTypeNotRegisteredForRecoveryError
 } from "./errors.js";
 export { HANDLE_RESULT_PROMISE, WorkflowHandle } from "./handles.js";
+export {
+  WeftWorkflowClaimLostWarning,
+  WeftWorkflowWakeDiscardedWarning,
+  WORKFLOW_CLAIM_LOST_WARNING_NAME,
+  WORKFLOW_WAKE_DISCARDED_WARNING_NAME
+} from "./lease-deposition.js";
 export {
   EngineLeaseAcquisitionTimeoutError,
   EngineLeaseCorruptedError,
-  EngineLeaseNotHeldError
+  EngineLeaseNotHeldError,
+  OwnershipModeMismatchError,
+  WorkflowClaimUnavailableError
 } from "./lease-errors.js";
 export { ScheduleHandle } from "./schedule-handle.js";
 export {
@@ -257,6 +279,7 @@ export class Engine extends EventTarget {
           throw new EngineCreateNameMismatchError("workflow", name, definition.name);
         engine.register(definition);
       }
+      await engine.#bootstrapOwnershipIfConfigured();
       await engine.#acquireLeaseIfConfigured();
       if (options.recover !== !1)
         await engine.recoverAll(options.acknowledgeUnknownWorkflowTypes !== void 0 ? { acknowledgeUnknownWorkflowTypes: options.acknowledgeUnknownWorkflowTypes } : {});
@@ -331,7 +354,7 @@ export class Engine extends EventTarget {
       onTimerFired: (entry) => handleTimerFiredFromInternals(getInternals(this), entry, this.#createTimeOperationCallbacks()),
       pollIntervalMs: resolvedOptions.schedulerPollIntervalMs,
       getNow,
-      commitTimerCleanup: (operations) => commitFencedEngineWrite(getInternals(this), operations, [], () => Error("Timer cleanup lost its fenced CAS race"))
+      commitTimerCleanup: (operations) => commitFencedEngineWrite(getInternals(this), null, operations, [], () => Error("Timer cleanup lost its fenced CAS race"))
     });
     getInternals(this).strategy = strategyBundle.strategy;
     getInternals(this).inlineStrategy = strategyBundle.inlineStrategy;
@@ -359,9 +382,11 @@ export class Engine extends EventTarget {
     getInternals(this).parkedInlineWorkflows = new Set;
     getInternals(this).terminalizingWorkflows = new Set;
     getInternals(this).deliveredPendingUpdateIds = new Map;
+    getInternals(this).onRecoveredWorkflowHook = void 0;
     getInternals(this).cancelHandlersByWorkflow = new Map;
     getInternals(this).reviewTimerIds = new Map;
     getInternals(this).pendingWebhooks = new Set;
+    getInternals(this).pendingResultPollTimers = new Set;
     getInternals(this).pendingTimelineEntries = new Map;
     getInternals(this).pendingAtomicWorkflowCommitSideEffects = new Map;
     getInternals(this).cleanupIntervalDisposalTracker = null;
@@ -381,7 +406,11 @@ export class Engine extends EventTarget {
     getInternals(this).secondInstanceDetectionInterval = null;
     getInternals(this).secondInstanceDetector = null;
     getInternals(this).leaseManager = null;
+    getInternals(this).workflowClaimRegistry = null;
+    getInternals(this).workflowClaimRenewalTask = null;
+    getInternals(this).workflowClaimMetrics = null;
     getInternals(this).inFlightLeaseAcquire = null;
+    getInternals(this).inFlightOwnershipBootstrap = null;
     getInternals(this).deposed = !1;
     getInternals(this).tearDownAfterDeposition = () => {
       this.#disposeAfterDeposition();
@@ -458,15 +487,81 @@ export class Engine extends EventTarget {
         internals.inFlightLeaseAcquire = null;
     }
   }
+  async#bootstrapOwnershipIfConfigured() {
+    const internals = getInternals(this), ownershipMode = internals.options.ownershipMode;
+    if (ownershipMode === "none")
+      return;
+    if (internals.disposed)
+      throw new EngineDisposedError;
+    if (ownershipMode === "lease") {
+      await bootstrapOwnershipGates({
+        storage: internals.storage,
+        ownershipMode,
+        getNow: internals.options.getNow
+      });
+      return;
+    }
+    if (internals.inFlightOwnershipBootstrap !== null) {
+      await internals.inFlightOwnershipBootstrap;
+      return;
+    }
+    if (internals.workflowClaimRegistry !== null)
+      return;
+    const bootstrap = (async () => {
+      const result = await bootstrapWorkflowLeaseOwnership({
+        storage: internals.storage,
+        getNow: internals.options.getNow,
+        claimTtlMs: internals.options.workflowClaimTtlMs,
+        claimRenewIntervalMs: internals.options.workflowClaimRenewIntervalMs,
+        isWorkflowTypeRegistered: (workflowType) => internals.workflowDefinitionsByName.has(workflowType),
+        onWorkflowClaimReclaimed: async (workflowId) => {
+          internals.inlineStrategy?.evictContextForReclaim(workflowId);
+          internals.deliveredPendingUpdateIds.delete(workflowId);
+          await recoverPendingAsyncActivities(internals, workflowId);
+          if (internals.disposed)
+            return;
+          await resumeFromLifecycle(internals, workflowId, this.#createLifecycleCallbacks(), internals.onRecoveredWorkflowHook, { forceReplayFromStorage: !0 });
+        },
+        signalPollTarget: this.#buildOwnerSideSignalPollTarget(),
+        updatePollTarget: this.#buildOwnerSideUpdatePollTarget()
+      });
+      if (internals.disposed)
+        throw new EngineDisposedError;
+      internals.workflowClaimRegistry = result.registry;
+      internals.workflowClaimRenewalTask = result.renewalTask;
+      internals.workflowClaimMetrics = result.metrics;
+      if (internals.options.backgroundTaskMode === "automatic")
+        result.renewalTask.start();
+    })();
+    internals.inFlightOwnershipBootstrap = bootstrap;
+    try {
+      await bootstrap;
+    } finally {
+      if (internals.inFlightOwnershipBootstrap === bootstrap)
+        internals.inFlightOwnershipBootstrap = null;
+    }
+  }
+  #detachWorkflowClaimOwnership() {
+    const internals = getInternals(this), registry = internals.workflowClaimRegistry;
+    internals.workflowClaimRenewalTask?.stop();
+    internals.workflowClaimRenewalTask = null;
+    internals.workflowClaimRegistry = null;
+    internals.workflowClaimMetrics = null;
+    return { registry };
+  }
+  async#releaseWorkflowClaimsBestEffort(registry) {
+    await registry?.releaseAll().catch(() => {});
+  }
   #disposeAfterDeposition() {
     const internals = getInternals(this);
     if (internals.disposed)
       return;
-    const leaseManager = internals.leaseManager;
+    const leaseManager = internals.leaseManager, { registry: workflowClaimRegistry } = this.#detachWorkflowClaimOwnership();
     disposeEngine(internals);
     if (this.#synchronousDisposeResult === null)
       this.#synchronousDisposeResult = (leaseManager?.release() ?? Promise.resolve(!0)).catch(() => !1);
     this.#synchronousDisposeResult;
+    this.#releaseWorkflowClaimsBestEffort(workflowClaimRegistry);
   }
   #startSecondInstanceDetection() {
     const internals = getInternals(this);
@@ -517,9 +612,55 @@ export class Engine extends EventTarget {
   #createInlineParkingCallbacks() {
     return createInlineParkingCallbacksForEngine(this);
   }
+  #buildOwnerSideSignalPollTarget() {
+    const internals = getInternals(this);
+    return buildOwnerSideSignalPollTarget({
+      listParkedInlineWorkflowIds: () => internals.parkedInlineWorkflows,
+      isParkedInlineWorkflow: (workflowId) => internals.parkedInlineWorkflows.has(workflowId),
+      parkedSignalName: (workflowId) => {
+        const pending = internals.pendingTimelineEntries.get(workflowId);
+        return pending?.entry.operationType === "wait-signal" ? pending.entry.operationLabel : void 0;
+      },
+      listSignalWaiterEntries: function* signalWaiterEntries() {
+        for (const [workflowId, waiterKeys] of internals.signalWaitersByWorkflow) {
+          if (typeof waiterKeys === "string") {
+            yield [workflowId, waiterKeys];
+            continue;
+          }
+          for (const waiterKey of waiterKeys)
+            yield [workflowId, waiterKey];
+        }
+      },
+      hasBufferedSignal: (workflowId, signalName) => hasBufferedSignalFromInternals(internals, workflowId, signalName),
+      resumeParkedInlineWorkflow: (workflowId) => resumeParkedInlineWorkflowFromInternals(internals, workflowId, this.#createInlineParkingCallbacks()),
+      confirmSignalWakeOwnership: (workflowId) => confirmWakeOwnership(internals, workflowId, "signal"),
+      wakeSignalWaiter: (workflowId, waiterKey) => {
+        const waiter = internals.signalWaiters.get(waiterKey);
+        if (waiter === void 0)
+          return;
+        if (releaseSignalWaiter(internals, workflowId, waiterKey, waiter))
+          waiter();
+      }
+    });
+  }
   #createUpdateCallbacks() {
     return createUpdateCallbacksForEngine(this);
   }
+  #buildOwnerSideUpdatePollTarget() {
+    const internals = getInternals(this);
+    return {
+      listHeldWorkflowIds: () => internals.workflowClaimRegistry?.listHeldWorkflowIds() ?? [],
+      hasPendingUpdates: async (workflowId) => {
+        return (await internals.updateCoordinator.getPendingUpdates(workflowId)).length > 0;
+      },
+      drainPendingUpdates: async (workflowId) => {
+        await processPendingUpdatesForHandlersFromInternals(internals, workflowId, createPendingUpdateCallbacksForEngine(this));
+        const stillPending = await internals.updateCoordinator.getPendingUpdates(workflowId), updateCallbacks = this.#createUpdateCallbacks();
+        for (const updateRequest of stillPending)
+          await deliverCoordinatedUpdateToWaiterIfAvailableFromInternals(internals, workflowId, updateRequest, !1, updateCallbacks);
+      }
+    };
+  }
   #createTimeOperationCallbacks() {
     return createTimeOperationCallbacksForEngine(this);
   }
@@ -629,6 +770,9 @@ export class Engine extends EventTarget {
   }
   async runMaintenance(now = getInternals(this).options.getNow()) {
     const internals = getInternals(this);
+    await this.#bootstrapOwnershipIfConfigured();
+    await internals.workflowClaimRenewalTask?.runOnce();
+    await pollPendingCrossEngineResultWaiters(internals);
     await internals.scheduler.tick(now);
     try {
       await internals.updateCoordinator.cleanupExpiredResponses();
@@ -768,11 +912,13 @@ export class Engine extends EventTarget {
     return resumeFromLifecycle(getInternals(this), workflowId, this.#createLifecycleCallbacks());
   }
   async recoverAll(options) {
+    await this.#bootstrapOwnershipIfConfigured();
     await this.#acquireLeaseIfConfigured();
     if (getInternals(this).disposed)
       throw new EngineDisposedError;
     await recoverPendingAsyncActivities(getInternals(this));
     await recoverOrphanedScheduleTimers(getInternals(this));
+    getInternals(this).onRecoveredWorkflowHook = options?.onRecoveredWorkflow;
     return recoverAllFromLifecycle(getInternals(this), this.#createLifecycleCallbacks(), options);
   }
   async completeAsyncActivity(token, result) {
@@ -934,10 +1080,12 @@ export class Engine extends EventTarget {
     const leaseManager = getInternals(this).leaseManager;
     if (leaseManager !== null && leaseManager.currentEpochBytes() !== null)
       process.emitWarning("engine ownership lease disposed synchronously; lease release is fire-and-forget, so exiting before the release completes can make the next instance wait for leaseTtl. Use await engine.shutdown(), await using, or await engine[Symbol.asyncDispose]() for prompt rolling-deploy handoff.", ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME);
+    const { registry: workflowClaimRegistry } = this.#detachWorkflowClaimOwnership();
     disposeEngine(getInternals(this));
     if (this.#synchronousDisposeResult === null)
       this.#synchronousDisposeResult = leaseManager?.release() ?? Promise.resolve(!0);
     this.#synchronousDisposeResult;
+    this.#releaseWorkflowClaimsBestEffort(workflowClaimRegistry);
   }
   async#disposeAsyncWithLeaseResult() {
     if (!getInternals(this).disposed) {
@@ -950,9 +1098,11 @@ export class Engine extends EventTarget {
       } catch (error) {
         drainFailure = { error };
       } finally {
+        const { registry: workflowClaimRegistry } = this.#detachWorkflowClaimOwnership();
         disposeEngine(getInternals(this));
         await getInternals(this).inFlightLeaseAcquire?.catch(() => {});
         leaseReleased = await (this.#synchronousDisposeResult ?? leaseManager?.release() ?? Promise.resolve(!0));
+        await this.#releaseWorkflowClaimsBestEffort(workflowClaimRegistry);
       }
       if (drainFailure !== null)
         throw new EngineDisposalError(drainFailure.error, leaseReleased);

package/dist/core/engine/inline-launch-queue.js

@@ -1,6 +1,7 @@
 import { WorkflowStartedEvent } from "../events.js";
 import { startWorkflowExecution } from "./lifecycle.js";
 import { loadWorkflowState } from "./storage-io.js";
+import { confirmWakeOwnership } from "./wake-ownership-guard.js";
 async function yieldQueuedShutdownAdvanceOpportunity() {
   await new Promise((resolve) => {
     setTimeout(resolve, 0);
@@ -83,11 +84,19 @@ export async function drainQueuedInlineWorkflowStarts(internals, callbacks, opti
     }
   }
 }
+async function isQueuedStartStillTheLiveRun(internals, start) {
+  const currentState = await loadWorkflowState(internals, start.workflowId);
+  return currentState !== null && currentState.status === "running" && (start.workflowExecutionToken === void 0 || currentState.workflowExecutionToken === start.workflowExecutionToken);
+}
 async function startQueuedInlineWorkflowExecution(internals, start, callbacks, options) {
   try {
     const state = await loadWorkflowState(internals, start.workflowId);
     if (!state || state.status !== "running")
       return;
+    if (await confirmWakeOwnership(internals, start.workflowId, "inline-macrotask-drive") === "discard")
+      return;
+    if (!await isQueuedStartStillTheLiveRun(internals, start))
+      return;
     internals.queuedInlineWorkflowStartIds.delete(start.workflowId);
     internals.engine.dispatchEvent(new WorkflowStartedEvent(start.workflowId, start.workflowType, start.input));
     startWorkflowExecution(internals, start.workflowId, state.workflowExecutionToken, start.workflowType, start.input, start.checkpoint, start.nestingDepth, start.executionDeadline, start.executionStateOwnerId);