@lostgradient/weft 0.7.0 → 0.9.0

package/dist/core/engine/checkpoint-io.d.ts

@@ -6,6 +6,9 @@ type PendingTimelineEntryValue = {
     startedAt: number;
     entry: WorkflowTimelineEntry;
 };
+export type PersistCheckpointOptions = {
+    timeline?: 'record-operation' | 'preserve-pending';
+};
 type PersistCheckpointCallbacks = {
     appendTimelineBatchOperations: (workflowId: string, operation: ContextOperationRequest, step: number, timestamp: number, operations: BatchOperation[]) => PendingTimelineEntryValue;
     swallowPromiseRejection: (promise: Promise<void>) => void;
@@ -26,7 +29,7 @@ type DevelopmentCheckpointCallbacks = {
 };
 export declare function appendTimelineBatchOperations(internals: EngineInternals, workflowId: string, operation: ContextOperationRequest, step: number, timestamp: number, operations: BatchOperation[]): PendingTimelineEntryValue;
 /** Persist a workflow checkpoint, history entry, timeline record, and event log record. */
-export declare function persistCheckpoint(internals: EngineInternals, workflowId: string, operation: ContextOperationRequest, workerCheckpointBytes: ArrayBuffer | undefined, callbacks: PersistCheckpointCallbacks): Promise<void>;
+export declare function persistCheckpoint(internals: EngineInternals, workflowId: string, operation: ContextOperationRequest, workerCheckpointBytes: ArrayBuffer | undefined, callbacks: PersistCheckpointCallbacks, options?: PersistCheckpointOptions): Promise<void>;
 /** Delete the single checkpoint history entry that overflows the retention limit. */
 export declare function pruneCheckpointHistory(internals: EngineInternals, workflowId: string, currentStep: number): Promise<void>;
 /** Validate checkpoint serialization in development mode and dispatch warnings. */

package/dist/core/engine/checkpoint-io.js

@@ -60,13 +60,13 @@ export function appendTimelineBatchOperations(internals, workflowId, operation,
     entry
   };
 }
-export async function persistCheckpoint(internals, workflowId, operation, workerCheckpointBytes, callbacks) {
+export async function persistCheckpoint(internals, workflowId, operation, workerCheckpointBytes, callbacks, options = {}) {
   if (internals.inlineStrategy?.getContext(workflowId))
-    await persistInlineCheckpoint(internals, workflowId, operation, callbacks);
+    await persistInlineCheckpoint(internals, workflowId, operation, callbacks, options);
   else if (workerCheckpointBytes && workerCheckpointBytes.byteLength > 0)
-    await persistWorkerCheckpoint(internals, workflowId, operation, workerCheckpointBytes, callbacks);
+    await persistWorkerCheckpoint(internals, workflowId, operation, workerCheckpointBytes, callbacks, options);
 }
-async function persistInlineCheckpoint(internals, workflowId, operation, callbacks) {
+async function persistInlineCheckpoint(internals, workflowId, operation, callbacks, options) {
   const current = internals.checkpoints.get(workflowId), context = internals.inlineStrategy?.getContext(workflowId);
   if (!current || !context)
     return;
@@ -76,13 +76,13 @@ async function persistInlineCheckpoint(internals, workflowId, operation, callbac
     ...pendingAttributeChanges !== void 0 ? { searchAttributes: pendingAttributeChanges } : {}
   }), pruned = pruneCheckpointReplayState(advanced, resolvePendingOperationStep(operation, context.stepIndex)), commit = createCheckpointCommit(internals, workflowId, pruned.checkpoint, serializeCheckpoint(attachTransientCheckpointReplayPayload(pruned.checkpoint, pruned.replayPayload)), pruned.replayPayload);
   appendAttributeOperations(workflowId, commit, previousAttributes, pendingAttributeChanges, hasPendingAttributeChangesValue, callbacks);
-  await commitCheckpoint(internals, workflowId, operation, commit, callbacks);
+  await commitCheckpoint(internals, workflowId, operation, commit, callbacks, options);
   if (hasPendingAttributeChangesValue)
     callbacks.dispatchEvent(new AttributesChangedEvent(workflowId, { ...pendingAttributeChanges }));
 }
-async function persistWorkerCheckpoint(internals, workflowId, operation, workerCheckpointBytes, callbacks) {
+async function persistWorkerCheckpoint(internals, workflowId, operation, workerCheckpointBytes, callbacks, options) {
   const serialized = new Uint8Array(workerCheckpointBytes), checkpoint = deserializeCheckpoint(serialized), workerReplayPayload = readCheckpointReplayPayload(checkpoint), pruned = pruneCheckpointReplayState(checkpoint, resolvePendingOperationStep(operation, checkpoint.step)), replayPayload = mergeCheckpointReplayPayloads(workerReplayPayload, pruned.replayPayload), prunedSerialized = serializeCheckpoint(attachTransientCheckpointReplayPayload(pruned.checkpoint, replayPayload));
-  await commitCheckpoint(internals, workflowId, operation, createCheckpointCommit(internals, workflowId, pruned.checkpoint, prunedSerialized, replayPayload), callbacks);
+  await commitCheckpoint(internals, workflowId, operation, createCheckpointCommit(internals, workflowId, pruned.checkpoint, prunedSerialized, replayPayload), callbacks, options);
 }
 function createCheckpointCommit(internals, workflowId, checkpoint, serialized, replayPayload) {
   const operations = [
@@ -116,9 +116,9 @@ function appendAttributeOperations(workflowId, commit, previousAttributes, pendi
   });
   commit.operations.push(...buildIndexOperations(workflowId, previousAttributes, commit.checkpoint.searchAttributes));
 }
-async function commitCheckpoint(internals, workflowId, operation, commit, callbacks) {
+async function commitCheckpoint(internals, workflowId, operation, commit, callbacks, options) {
   dispatchCheckpointSizeWarning(internals, workflowId, commit, callbacks);
-  const nextPendingTimelineEntry = callbacks.appendTimelineBatchOperations(workflowId, operation, commit.step, commit.timestamp, commit.operations), { newHead, timestamp } = appendCheckpointEventLog(internals, workflowId, commit), retentionWindow = internals.options.historyPolicy.retentionWindow, compaction = retentionWindow === null ? null : await appendCompactionOperations(internals.storage, workflowId, newHead.sequence, retentionWindow, commit.operations), pendingSideEffects = takePendingAtomicWorkflowCommitSideEffects(internals, workflowId);
+  const nextPendingTimelineEntry = options.timeline === "preserve-pending" ? preservePendingTimelineEntry(internals, workflowId, commit.operations) : callbacks.appendTimelineBatchOperations(workflowId, operation, commit.step, commit.timestamp, commit.operations), { newHead, timestamp } = appendCheckpointEventLog(internals, workflowId, commit), retentionWindow = internals.options.historyPolicy.retentionWindow, compaction = retentionWindow === null ? null : await appendCompactionOperations(internals.storage, workflowId, newHead.sequence, retentionWindow, commit.operations), pendingSideEffects = takePendingAtomicWorkflowCommitSideEffects(internals, workflowId);
   if (pendingSideEffects !== void 0)
     commit.operations.push(...pendingSideEffects.operations);
   const storageSupportsConditionalBatch = internals.storage.capabilities().conditionalBatch, sideEffectConditions = checkpointSideEffectConditions(pendingSideEffects, storageSupportsConditionalBatch), conditions = buildCheckpointCommitConditions(workflowId, commit, storageSupportsConditionalBatch, sideEffectConditions);
@@ -129,7 +129,10 @@ async function commitCheckpoint(internals, workflowId, operation, commit, callba
     clearPendingAtomicWorkflowCommitSideEffects(internals, workflowId);
   if (commit.expectedSerialized !== void 0)
     rememberCommittedCheckpointBytes(internals, workflowId, commit.serialized);
-  internals.pendingTimelineEntries.set(workflowId, nextPendingTimelineEntry);
+  if (nextPendingTimelineEntry === void 0)
+    internals.pendingTimelineEntries.delete(workflowId);
+  else
+    internals.pendingTimelineEntries.set(workflowId, nextPendingTimelineEntry);
   internals.checkpoints.set(workflowId, commit.checkpoint);
   internals.eventLogHeads.set(workflowId, newHead);
   if (compaction !== null)
@@ -146,6 +149,12 @@ async function commitCheckpoint(internals, workflowId, operation, commit, callba
   if (historyEventLimitBreached(internals, newHead.sequence))
     await callbacks.enforceHistoryCircuitBreaker(workflowId);
 }
+function preservePendingTimelineEntry(internals, workflowId, operations) {
+  const pendingTimelineOperation = buildPendingTimelineOperation(internals, workflowId);
+  if (pendingTimelineOperation)
+    operations.push(pendingTimelineOperation);
+  return internals.pendingTimelineEntries.get(workflowId);
+}
 function checkpointSideEffectConditions(pendingSideEffects, storageSupportsConditionalBatch) {
   if (!storageSupportsConditionalBatch)
     return [];

package/dist/core/engine/completed-review-storage.d.ts

@@ -1,6 +1,7 @@
 import type { Storage } from '../../storage/interface.ts';
 import type { HumanReviewResult, ReviewRequest } from '../review/index.ts';
 import type { CompletedReviewEntry, ReviewListFilter } from '../types.ts';
+import type { EngineInternals } from './internals.ts';
 type ReviewListFilterableEntry = {
     workflowId?: string;
     reviewType?: string;
@@ -9,6 +10,6 @@ export declare function matchesReviewListFilter(review: ReviewListFilterableEntr
 export declare function completedReviewStoragePrefix(workflowId?: string): string;
 export declare function completedReviewStorageKey(workflowId: string, reviewId: string): string;
 export declare function listCompletedReviewsFromStorage(storage: Storage, filter: ReviewListFilter): Promise<CompletedReviewEntry[]>;
-export declare function persistCompletedReviewRecord(storage: Storage, reviewKey: string, reviewData: ReviewRequest, decisionResult: HumanReviewResult): Promise<void>;
+export declare function persistCompletedReviewRecord(internals: EngineInternals, reviewKey: string, reviewData: ReviewRequest, decisionResult: HumanReviewResult): Promise<void>;
 export declare function deleteCompletedReviewsForWorkflow(storage: Storage, workflowId: string): Promise<void>;
 export {};

package/dist/core/engine/completed-review-storage.js

@@ -1,5 +1,6 @@
 import { encodeStorageKeyComponent } from "../../storage/interface.js";
 import { encode } from "../codec.js";
+import { commitFencedEngineWrite } from "./fenced-write.js";
 import { parseCompletedReviewEntry, toCompletedReviewEntry } from "./review-list-entries.js";
 export function matchesReviewListFilter(review, filter) {
   if (filter.workflowId !== void 0 && review.workflowId !== filter.workflowId)
@@ -32,16 +33,16 @@ export async function listCompletedReviewsFromStorage(storage, filter) {
   await appendCompletedReviews(reviews, storage.scan("review-decision:"), filter, (key) => scopedPrefix === null || !key.startsWith(scopedPrefix));
   return reviews;
 }
-export async function persistCompletedReviewRecord(storage, reviewKey, reviewData, decisionResult) {
+export async function persistCompletedReviewRecord(internals, reviewKey, reviewData, decisionResult) {
   const completedReview = toCompletedReviewEntry(reviewData, decisionResult);
-  await storage.batch([
+  await commitFencedEngineWrite(internals, [
     {
       type: "put",
       key: completedReviewStorageKey(reviewData.workflowId, reviewData.reviewId),
       value: encode(completedReview)
     },
     { type: "delete", key: reviewKey }
-  ]);
+  ], [], () => Error(`Completed review commit for review "${reviewData.reviewId}" lost its precondition.`));
 }
 export async function deleteCompletedReviewsForWorkflow(storage, workflowId) {
   const completedPrefix = completedReviewStoragePrefix(workflowId), deleteOperations = [];

package/dist/core/engine/disposal.js

@@ -46,6 +46,7 @@ export function disposeEngine(internals) {
   internals.pendingWebhooks.clear();
   internals.sleepResolvers.clear();
   internals.sleepResolversByWorkflow.clear();
+  internals.sleepTimersFiredWithoutResolver.clear();
   internals.checkpoints.clear();
   internals.pendingExecutionStateOwnerId = void 0;
   internals.workflowNestingDepths.clear();

package/dist/core/engine/engine-internal-types.d.ts

@@ -84,6 +84,7 @@ export type PendingTimelineEntry = {
 };
 export type QueuedInlineWorkflowExecutionStart = {
     workflowId: string;
+    workflowExecutionToken?: string;
     workflowType: string;
     input: unknown;
     checkpoint: Checkpoint;

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

@@ -36,6 +36,25 @@ export { assertCompatiblePersistedDataVersion };
 export declare const ENGINE_PARKED_WORKFLOW_COUNT_FOR_TESTING: unique symbol;
 export declare const ENGINE_SIGNAL_WAITER_COUNT_FOR_TESTING: unique symbol;
 export declare const ENGINE_SLEEP_RESOLVER_COUNT_FOR_TESTING: unique symbol;
+/**
+ * The `name` of the `process` warning emitted when a lease-owning engine is
+ * disposed through the synchronous `[Symbol.dispose]()` path. Sync disposal can
+ * only fire the lease release in the background; use `await engine.shutdown()`,
+ * `await using`, or `await engine[Symbol.asyncDispose]()` when prompt rolling
+ * deploy handoff matters.
+ *
+ * @example
+ * ```ts
+ * import { ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME } from '@lostgradient/weft';
+ *
+ * process.on('warning', (warning) => {
+ *   if (warning.name === ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME) {
+ *     // Alert on shutdown paths that can make lease handoff wait for leaseTtl.
+ *   }
+ * });
+ * ```
+ */
+export declare const ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME = "WeftEngineLeaseSynchronousDisposeWarning";
 export { ENGINE_LEASE_LOST_WARNING_NAME };
 /**
  * Durable execution engine.
@@ -408,6 +427,18 @@ export declare class Engine<TWorkflows extends object = DefaultWorkflowRegistry,
         timeout?: number;
         idempotencyKey?: string;
     }): Promise<CoordinatedUpdateResult>;
+    /**
+     * Awaited engine shutdown. Equivalent to
+     * `await engine[Symbol.asyncDispose]()` and useful in explicit signal handlers
+     * where `await using` syntax cannot own the process lifetime directly.
+     *
+     * Under `ownership: 'lease'`, this is the explicit prompt-handoff primitive:
+     * it drains queued inline starts, tears down in-memory write paths, and awaits
+     * lease release before resolving. Synchronous disposal remains immediate and
+     * can make the next engine wait for `leaseTtl` if the process exits before its
+     * background release completes.
+     */
+    shutdown(): Promise<void>;
     /**
      * Synchronous teardown (`using engine = ...`). Pending inline launches that
      * have not yet run are **discarded**, not executed. When you need queued

package/dist/core/engine/index.js

@@ -206,9 +206,19 @@ export {
   shouldEmitEngineLeakWarningForTesting
 } from "./engine-leak-warnings.js";
 export { assertCompatiblePersistedDataVersion };
-export const ENGINE_PARKED_WORKFLOW_COUNT_FOR_TESTING = Symbol("engineParkedWorkflowCountForTesting"), ENGINE_SIGNAL_WAITER_COUNT_FOR_TESTING = Symbol("engineSignalWaiterCountForTesting"), ENGINE_SLEEP_RESOLVER_COUNT_FOR_TESTING = Symbol("engineSleepResolverCountForTesting");
+export const ENGINE_PARKED_WORKFLOW_COUNT_FOR_TESTING = Symbol("engineParkedWorkflowCountForTesting"), ENGINE_SIGNAL_WAITER_COUNT_FOR_TESTING = Symbol("engineSignalWaiterCountForTesting"), ENGINE_SLEEP_RESOLVER_COUNT_FOR_TESTING = Symbol("engineSleepResolverCountForTesting"), ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME = "WeftEngineLeaseSynchronousDisposeWarning";
 
 export { ENGINE_LEASE_LOST_WARNING_NAME };
+function scheduleDefinitionFromInternals(internals, definition) {
+  const workflowType = typeof definition.workflow === "string" ? definition.workflow : definition.workflow.name, definitionSpec = definition.every !== void 0 ? { every: definition.every } : { cron: definition.cron ?? "" };
+  return scheduleFromInternals(internals, workflowType, definition.input, definitionSpec, {
+    ...definition.id !== void 0 && { id: definition.id },
+    ...definition.description !== void 0 && { description: definition.description },
+    ...definition.overlapPolicy !== void 0 && { overlap: definition.overlapPolicy },
+    ...definition.backfill !== void 0 && { backfill: definition.backfill },
+    ...definition.jitter !== void 0 && { jitter: definition.jitter }
+  });
+}
 
 export class Engine extends EventTarget {
   static async create(options) {
@@ -267,6 +277,7 @@ export class Engine extends EventTarget {
     getInternals(this).updateWaitersByWorkflow = new Map;
     getInternals(this).sleepResolvers = new Map;
     getInternals(this).sleepResolversByWorkflow = new Map;
+    getInternals(this).sleepTimersFiredWithoutResolver = new Map;
     getInternals(this).interceptors = resolveEngineInterceptors(options);
     getInternals(this).composedWorkflowInterceptor = void 0;
     getInternals(this).composedActivityInterceptor = void 0;
@@ -599,15 +610,8 @@ export class Engine extends EventTarget {
     return untagAllWorkflows(getInternals(this), filter, tags, options);
   }
   async schedule(typeOrDefinition, input, spec, options) {
-    if (typeof typeOrDefinition === "object") {
-      const definition = typeOrDefinition, workflowType = typeof definition.workflow === "string" ? definition.workflow : definition.workflow.name, definitionSpec = definition.every !== void 0 ? { every: definition.every } : { cron: definition.cron ?? "" };
-      return scheduleFromInternals(getInternals(this), workflowType, definition.input, definitionSpec, {
-        ...definition.id !== void 0 && { id: definition.id },
-        ...definition.overlapPolicy !== void 0 && { overlap: definition.overlapPolicy },
-        ...definition.backfill !== void 0 && { backfill: definition.backfill },
-        ...definition.jitter !== void 0 && { jitter: definition.jitter }
-      });
-    }
+    if (typeof typeOrDefinition === "object")
+      return scheduleDefinitionFromInternals(getInternals(this), typeOrDefinition);
     if (spec === void 0)
       throw Error("A cron string or schedule spec must be provided when scheduling by workflow type.");
     return scheduleFromInternals(getInternals(this), typeOrDefinition, input, spec, options);
@@ -769,8 +773,13 @@ export class Engine extends EventTarget {
   async submitCoordinatedUpdate(workflowId, name, payload, options) {
     return submitCoordinatedUpdateFromInternals(getInternals(this), workflowId, name, payload, options, this.#createUpdateCallbacks());
   }
+  async shutdown() {
+    return this[Symbol.asyncDispose]();
+  }
   [Symbol.dispose]() {
     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);
     disposeEngine(getInternals(this));
     leaseManager?.release();
   }

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

@@ -58,7 +58,7 @@ async function startQueuedInlineWorkflowExecution(internals, start, callbacks) {
       return;
     internals.queuedInlineWorkflowStartIds.delete(start.workflowId);
     internals.engine.dispatchEvent(new WorkflowStartedEvent(start.workflowId, start.workflowType, start.input));
-    startWorkflowExecution(internals, start.workflowId, start.workflowType, start.input, start.checkpoint, start.nestingDepth, start.executionDeadline, start.executionStateOwnerId);
+    startWorkflowExecution(internals, start.workflowId, state.workflowExecutionToken, start.workflowType, start.input, start.checkpoint, start.nestingDepth, start.executionDeadline, start.executionStateOwnerId);
     await callbacks.processPendingUpdatesAfterInlineAdvance(start.workflowId);
   } finally {
     internals.queuedInlineWorkflowStartIds.delete(start.workflowId);

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

@@ -31,6 +31,7 @@ import type { Scheduler } from '../scheduler.ts';
 import type { Checkpoint, StartWorkflowOptions } from '../types.ts';
 import type { UpdateCoordinator } from '../updates.ts';
 import type { WorkflowVersionTuple } from '../workflow-version-tuple.ts';
+import type { ActivityHeartbeatKey } from './activity-heartbeat-tracking.ts';
 import type { PendingTimelineEntry, QueuedInlineWorkflowExecutionStart, RegistrationEntry, ResolvedOptions, TrackedWaiterKeys, WorkflowResultWaiter } from './engine-internal-types.ts';
 import type { EngineCleanupIntervalDisposalTracker } from './engine-leak-warnings.ts';
 import type { WorkflowHandle, WorkflowHandleEngine } from './handles.ts';
@@ -89,8 +90,30 @@ export interface EngineInternals {
     conditionWaiters: Map<string, () => void>;
     updateWaiters: Map<string, (payload: unknown) => void>;
     updateWaitersByWorkflow: Map<string, TrackedWaiterKeys>;
-    sleepResolvers: Map<string, () => void>;
+    /**
+     * In-process sleep resolvers keyed by `${workflowId}:${operationId}`. Each
+     * carries the run's expected `fireAt` so a fired timer only settles the sleep
+     * whose deadline it represents — a stale timer from a terminated run that
+     * reused the same deterministic operationId (its durable timer outlives
+     * terminal cleanup) is ignored rather than resolving a replacement run early.
+     */
+    sleepResolvers: Map<string, {
+        resolve: () => void;
+        fireAt: number;
+    }>;
     sleepResolversByWorkflow: Map<string, Set<string>>;
+    /**
+     * Per-workflow maps of `operationId` → fired timer `fireAt` for sleep timers
+     * the scheduler tick fired before the resolver was registered. Keyed by
+     * `workflowId` so per-workflow cleanup (`cleanupSleepResolvers`,
+     * `evictSleepResolversWithoutResolving`) can call `.delete(workflowId)` and
+     * sweep all markers in O(1) — including orphaned ones where the timer fired
+     * while the workflow was suspended (no `sleepResolversByWorkflow` entry) or
+     * during recovery of an already-elapsed sleep that takes the early-return
+     * path. The `fireAt` lets `processSleepOperation` ignore a marker left by a
+     * stale earlier-run timer. Cleared entirely at engine disposal.
+     */
+    sleepTimersFiredWithoutResolver: Map<string, Map<string, number>>;
     interceptors: Interceptor[];
     composedWorkflowInterceptor: ComposedWorkflowInterceptor | null | undefined;
     composedActivityInterceptor: ComposedActivityInterceptor | null | undefined;
@@ -148,7 +171,7 @@ export interface EngineInternals {
      * {@link heartbeatDetails}. Inline-execution only; worker-executed activities run
      * their function out of process and never observe this.
      */
-    lastHeartbeatDetailsByStep: Map<string, Map<number, unknown>>;
+    lastHeartbeatDetailsByStep: Map<string, Map<ActivityHeartbeatKey, unknown>>;
     /**
      * Per-run, non-serialized `services` value exposed to the workflow body as
      * `ctx.services`. Set at `engine.start({ services })` and re-provided on

package/dist/core/engine/lease-manager.js

@@ -8,7 +8,7 @@ import {
 import { EngineLeaseAcquisitionTimeoutError, EngineLeaseCorruptedError } from "./lease-errors.js";
 const DEFAULT_ACQUIRE_POLL_INTERVAL_MS = 1000;
 export function createLeaseManager(options) {
-  const { storage, holderId, getNow, ttlMs, renewIntervalMs, waitTimeoutMs } = options, acquirePollIntervalMs = options.acquirePollIntervalMs ?? DEFAULT_ACQUIRE_POLL_INTERVAL_MS, unconfirmableMarginMs = renewIntervalMs;
+  const { storage, holderId, getNow, ttlMs, renewIntervalMs, waitTimeoutMs } = options, acquirePollIntervalMs = options.acquirePollIntervalMs ?? DEFAULT_ACQUIRE_POLL_INTERVAL_MS;
   let stopped = !1, heldEpoch = null, heldEpochBytes = null, lastHolderBytes = null, renewalInterval = null, leaseLost = !1, inFlightRenewal = null;
   const delay = options.delay ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   function reportLeaseLost(reason) {
@@ -81,7 +81,7 @@ export function createLeaseManager(options) {
       committed = await storageConditionalBatch(storage, [{ key: KEYS.leaseHolder(), expectedValue: lastHolderBytes }], [{ type: "put", key: KEYS.leaseHolder(), value: holderBytes }]);
     } catch {
       const priorExpiry = decodeHolder(lastHolderBytes)?.expiresAt ?? 0;
-      if (getNow() >= priorExpiry - unconfirmableMarginMs)
+      if (getNow() >= priorExpiry)
         reportLeaseLost("renewal-unconfirmable");
       return;
     }

package/dist/core/engine/lifecycle/fork-helpers.js

@@ -22,6 +22,7 @@ export function createForkedWorkflowState(_internals, workflowId, sourceState, v
     type: sourceState.type,
     status: "running",
     input: sourceState.input,
+    workflowExecutionToken: crypto.randomUUID(),
     versionTuple,
     executionStateOwnerId: workflowId,
     createdAt: forkedAt,

package/dist/core/engine/lifecycle/resume.js

@@ -51,6 +51,9 @@ async function relaunchInlineWorkflowAfterResume(internals, latestState, args) {
   await rehydrateChildCancellationHandlers(internals, workflowId, callbacks);
   const context = new Context({
     workflowId,
+    ...latestState.workflowExecutionToken !== void 0 && {
+      workflowExecutionToken: latestState.workflowExecutionToken
+    },
     workflowType: latestState.type,
     startedAt: getWorkflowExecutionStartedAt(latestState),
     abortController: workflowAbort,
@@ -85,6 +88,9 @@ async function relaunchWorkerWorkflowAfterResume(internals, latestState, args) {
   const serialized = serializeCheckpoint(resumeCheckpoint);
   internals.strategy.startWorkflow({
     workflowId,
+    ...latestState.workflowExecutionToken !== void 0 && {
+      workflowExecutionToken: latestState.workflowExecutionToken
+    },
     workflowType: latestState.type,
     input: latestState.input,
     checkpoint: serialized,

package/dist/core/engine/lifecycle/start-exec.d.ts

@@ -2,8 +2,8 @@ import type { Checkpoint, StartOptions, WorkflowState } from '../../types.ts';
 import type { EngineInternals } from '../internals.ts';
 import { type LifecycleCallbacks, type RegistrationEntry } from './shared.ts';
 export declare function runWorkflowStartInterceptor(_internals: EngineInternals, workflowId: string, workflowType: string, input: unknown, parentHeaders: Map<string, string> | undefined, callbacks: LifecycleCallbacks): Map<string, string> | undefined;
-export declare function startWorkflowExecution(internals: EngineInternals, workflowId: string, workflowType: string, input: unknown, checkpoint: Checkpoint, nestingDepth: number, executionDeadline: number | undefined, executionStateOwnerId: string, _callbacks?: LifecycleCallbacks): void;
-export declare function beginWorkflowExecution(internals: EngineInternals, workflowId: string, workflowType: string, input: unknown, checkpoint: Checkpoint, executionDeadline: number | undefined, executionStateOwnerId: string, _registration: RegistrationEntry, callbacks: LifecycleCallbacks, onStarted?: () => void): void;
+export declare function startWorkflowExecution(internals: EngineInternals, workflowId: string, workflowExecutionToken: string | undefined, workflowType: string, input: unknown, checkpoint: Checkpoint, nestingDepth: number, executionDeadline: number | undefined, executionStateOwnerId: string, _callbacks?: LifecycleCallbacks): void;
+export declare function beginWorkflowExecution(internals: EngineInternals, workflowId: string, workflowExecutionToken: string | undefined, workflowType: string, input: unknown, checkpoint: Checkpoint, executionDeadline: number | undefined, executionStateOwnerId: string, _registration: RegistrationEntry, callbacks: LifecycleCallbacks, onStarted?: () => void): void;
 /**
  * `defer: false` is an inline-only liveness gate: it awaits the moment the
  * generator is first driven. A worker-mode start queues to the Worker transport

package/dist/core/engine/lifecycle/start-exec.js

@@ -20,12 +20,13 @@ export function runWorkflowStartInterceptor(_internals, workflowId, workflowType
   });
   return capturedHeaders;
 }
-export function startWorkflowExecution(internals, workflowId, workflowType, input, checkpoint, nestingDepth, executionDeadline, executionStateOwnerId, _callbacks) {
+export function startWorkflowExecution(internals, workflowId, workflowExecutionToken, workflowType, input, checkpoint, nestingDepth, executionDeadline, executionStateOwnerId, _callbacks) {
   if (nestingDepth !== 0)
     internals.workflowNestingDepths.set(workflowId, nestingDepth);
   internals.workflowTypeByWorkflowId.set(workflowId, workflowType);
   internals.strategy.startWorkflow({
     workflowId,
+    ...workflowExecutionToken !== void 0 && { workflowExecutionToken },
     workflowType,
     input,
     checkpoint: serializeCheckpoint(checkpoint),
@@ -39,12 +40,13 @@ export function startWorkflowExecution(internals, workflowId, workflowType, inpu
     }
   });
 }
-export function beginWorkflowExecution(internals, workflowId, workflowType, input, checkpoint, executionDeadline, executionStateOwnerId, _registration, callbacks, onStarted) {
+export function beginWorkflowExecution(internals, workflowId, workflowExecutionToken, workflowType, input, checkpoint, executionDeadline, executionStateOwnerId, _registration, callbacks, onStarted) {
   const nestingDepth = internals.pendingNestingDepth ?? 0;
   internals.pendingNestingDepth = void 0;
   if (internals.inlineStrategy !== null) {
     callbacks.queueInlineWorkflowExecutionStart({
       workflowId,
+      ...workflowExecutionToken !== void 0 && { workflowExecutionToken },
       workflowType,
       input,
       checkpoint,
@@ -56,7 +58,7 @@ export function beginWorkflowExecution(internals, workflowId, workflowType, inpu
     return;
   }
   callbacks.dispatchEvent(new WorkflowStartedEvent(workflowId, workflowType, input));
-  startWorkflowExecution(internals, workflowId, workflowType, input, checkpoint, nestingDepth, executionDeadline, executionStateOwnerId, callbacks);
+  startWorkflowExecution(internals, workflowId, workflowExecutionToken, workflowType, input, checkpoint, nestingDepth, executionDeadline, executionStateOwnerId, callbacks);
   onStarted?.();
 }
 export function assertDeferSupported(internals, options, isDelayedStart) {
@@ -71,7 +73,7 @@ export async function beginExecutionAwaitingLiveness(internals, params, workflow
   if (params.isDelayed)
     return;
   const liveness = params.options?.defer === !1 ? Promise.withResolvers() : void 0;
-  beginWorkflowExecution(internals, workflowId, params.type, params.input, params.checkpoint, params.state.executionDeadline, params.state.executionStateOwnerId ?? workflowId, params.registration, callbacks, liveness ? () => liveness.resolve() : void 0);
+  beginWorkflowExecution(internals, workflowId, params.state.workflowExecutionToken, params.type, params.input, params.checkpoint, params.state.executionDeadline, params.state.executionStateOwnerId ?? workflowId, params.registration, callbacks, liveness ? () => liveness.resolve() : void 0);
   if (liveness)
     await liveness.promise;
 }

package/dist/core/engine/lifecycle/start.js

@@ -145,6 +145,7 @@ function buildInitialIdentitySlice(workflowId, type, input, versionTuple, execut
     status: delayedStartTimer ? "pending" : "running",
     input,
     versionTuple,
+    workflowExecutionToken: crypto.randomUUID(),
     ...executionStateOwnerId !== void 0 && { executionStateOwnerId },
     createdAt: now,
     ...!delayedStartTimer && { startedAt: now },

package/dist/core/engine/lifecycle/transition.js

@@ -144,6 +144,9 @@ function launchInlineWorkflowFromCheckpoint(internals, workflowId, state, checkp
   resetCancelHandlers(internals, workflowId);
   const context = new Context({
     workflowId,
+    ...state.workflowExecutionToken !== void 0 && {
+      workflowExecutionToken: state.workflowExecutionToken
+    },
     workflowType: state.type,
     startedAt: getWorkflowExecutionStartedAt(state),
     abortController: workflowAbort,
@@ -172,6 +175,9 @@ function launchWorkerWorkflowFromCheckpoint(internals, workflowId, state, checkp
   const serialized = serializeCheckpoint(checkpoint);
   internals.strategy.startWorkflow({
     workflowId,
+    ...state.workflowExecutionToken !== void 0 && {
+      workflowExecutionToken: state.workflowExecutionToken
+    },
     workflowType: state.type,
     input: state.input,
     checkpoint: serialized,

package/dist/core/engine/memo-durable-activity.d.ts

@@ -0,0 +1,11 @@
+import type { ContextOperationRequest } from '../context.ts';
+import type { EngineInternals } from './internals.ts';
+import { type ActivityOperationCallbacks } from './operations-activity.ts';
+type MemoOperation = Extract<ContextOperationRequest, {
+    type: 'memo';
+}>;
+export declare function callMemoFunctionWithDurableActivityScope(internals: EngineInternals, workflowId: string, operation: MemoOperation, callbacks: {
+    getActivityOperationCallbacks?: () => ActivityOperationCallbacks;
+    persistCheckpoint: (workflowId: string, operation: ContextOperationRequest) => Promise<void>;
+}): Promise<unknown>;
+export {};