@lostgradient/weft 0.8.0 → 0.9.0

package/dist/core/context/durable-operations.js

@@ -11,7 +11,7 @@ export function prepareSleepOperation(internals, duration) {
     console.log(`  \u2192 Creating checkpoint at step ${step}`);
     console.log(`  \u2192 Scheduling timer for ${milliseconds}ms`);
   }
-  const operationId = crypto.randomUUID(), callerStack = captureCallerStack(), referenceTime = internals.sleepReferenceTime ?? internals.getNow();
+  const operationId = `${internals.context.workflowId}:${step}`, callerStack = captureCallerStack(), referenceTime = internals.sleepReferenceTime ?? internals.getNow();
   internals.sleepReferenceTime = void 0;
   return {
     cached: !1,

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

@@ -23,6 +23,7 @@ export declare function setContextWorkflowInterceptor(context: Context, workflow
 export declare class Context implements WorkflowContext {
     #private;
     readonly workflowId: string;
+    readonly workflowExecutionToken: string | undefined;
     readonly workflowType: string;
     readonly startedAt: number;
     readonly signal: AbortSignal;

package/dist/core/context/index.js

@@ -21,12 +21,14 @@ export function setContextWorkflowInterceptor(context, workflowInterceptor) {
 
 export class Context {
   workflowId;
+  workflowExecutionToken;
   workflowType;
   startedAt;
   signal;
   #log;
   constructor(options) {
     this.workflowId = options.workflowId;
+    this.workflowExecutionToken = options.workflowExecutionToken;
     this.workflowType = options.workflowType;
     this.startedAt = options.startedAt;
     this.signal = options.abortController.signal;

package/dist/core/context/operation-request.d.ts

@@ -30,6 +30,8 @@ export type ContextOperationRequest = {
     activityName: string;
     fn?: (input: unknown, context?: unknown) => unknown;
     input: unknown;
+    /** Immutable owner token for this workflow run, used to fence external side effects. */
+    workflowExecutionToken?: string;
     callerStack?: string;
     options?: Record<string, unknown>;
     /** Dispatch attempt used for worker payloads, interceptors, and reconciliation verifiers. */

package/dist/core/context/run-operation.js

@@ -74,7 +74,7 @@ function getActivityName(activity, explicitName) {
 function getActivityFunction(activity) {
   return typeof activity === "function" ? activity : void 0;
 }
-function createFreshRunActivityRequest(internals, step, activityName, activityFunction, input, options, activityStateKey) {
+function createFreshRunActivityRequest(internals, step, activityName, activityFunction, input, options, activityStateKey, workflowExecutionToken) {
   const queue = options?.queue ?? "default";
   if (internals.explainMode) {
     console.log(`[weft] ctx.run(${activityName}, ${JSON.stringify(input)})`);
@@ -87,6 +87,7 @@ function createFreshRunActivityRequest(internals, step, activityName, activityFu
     activityName,
     step,
     ...activityStateKey === void 0 ? {} : { activityStateKey },
+    ...workflowExecutionToken === void 0 ? {} : { workflowExecutionToken },
     ...activityFunction !== void 0 ? { fn: activityFunction } : {},
     input,
     callerStack: captureCallerStack(),
@@ -141,7 +142,7 @@ export function createRunActivityRequestAtStep(context, activity, rest, step, co
     return cachedRequest;
   const retryPolicy = resolveActivityRetryPolicy(activity, options), scheduleToCloseTimeout = resolveActivityScheduleToCloseTimeout(activity, options);
   return {
-    request: createFreshRunActivityRequest(internals, step, activityName, activityFunction, input, resolveDispatchedActivityOptions(activity, options), configuration.activityStateKey),
+    request: createFreshRunActivityRequest(internals, step, activityName, activityFunction, input, resolveDispatchedActivityOptions(activity, options), configuration.activityStateKey, context.workflowExecutionToken),
     step,
     retryStateKey,
     ...cacheResultStep === void 0 ? {} : { cacheResultStep },

package/dist/core/context/speculative-child.js

@@ -24,6 +24,7 @@ function assignOptionalContextOptions(options, internals) {
 function createSpeculativeChildOptions(parent, internals) {
   const options = {
     workflowId: parent.workflowId,
+    ...parent.workflowExecutionToken === void 0 ? {} : { workflowExecutionToken: parent.workflowExecutionToken },
     workflowType: parent.workflowType,
     startedAt: parent.startedAt,
     abortController: internals.abortController,

package/dist/core/context/types.d.ts

@@ -150,6 +150,7 @@ export interface StreamSink {
  */
 export interface ContextOptions {
     workflowId: string;
+    workflowExecutionToken?: string;
     workflowType: string;
     startedAt: number;
     abortController: AbortController;

package/dist/core/engine/activity-heartbeat-tracking.d.ts

@@ -52,4 +52,4 @@ export declare function warnIfRetryMissingHeartbeat(internals: EngineInternals,
  * tracking above; `completeAsync` is supplied by the caller (it owns the
  * async-completion token machinery).
  */
-export declare function buildActivityContext(internals: EngineInternals, workflowId: string, step: ActivityHeartbeatKey, signal: AbortSignal, completeAsync: () => never): ActivityContext;
+export declare function buildActivityContext(internals: EngineInternals, workflowId: string, workflowExecutionToken: string | undefined, step: ActivityHeartbeatKey, attempt: number, signal: AbortSignal, completeAsync: () => never): ActivityContext;

package/dist/core/engine/activity-heartbeat-tracking.js

@@ -35,9 +35,13 @@ export function warnIfRetryMissingHeartbeat(internals, workflowId, step, attempt
     return;
   internals.engine.dispatchEvent(new DevelopmentWarningEvent(workflowId, `Activity retry (attempt ${attempt}) at ${activityHeartbeatKeyLabel(step)} has no lastHeartbeatDetails. Either the previous attempt never recorded heartbeat details (it never called heartbeat(), or called it with no details), or the engine process restarted and discarded the in-memory heartbeat (it is not durable). The resumable-batch pattern only resumes across in-process retries; design the activity to restart cleanly when lastHeartbeatDetails is undefined.`, [activityHeartbeatFieldPath(step)]));
 }
-export function buildActivityContext(internals, workflowId, step, signal, completeAsync) {
+export function buildActivityContext(internals, workflowId, workflowExecutionToken, step, attempt, signal, completeAsync) {
   return {
     signal,
+    ...workflowExecutionToken !== void 0 && {
+      workflowExecutionToken,
+      activityAttemptToken: `${workflowExecutionToken}:activity:${String(step)}:${String(attempt)}`
+    },
     lastHeartbeatDetails: readLastHeartbeatForStep(internals, workflowId, step),
     heartbeat: (details) => {
       internals.heartbeatDetails.set(workflowId, details);

package/dist/core/engine/anonymous-signal-sequence.js

@@ -94,8 +94,6 @@ function extractAnonymousSignalSequence(key) {
   return Number.isSafeInteger(sequence) && sequence >= 0 ? sequence : null;
 }
 function decodeSignalSequence(bytes) {
-  if (bytes === null)
-    return 0;
   const value = decode(bytes);
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
     throw Error("Stored anonymous signal sequence must be a non-negative safe integer");

package/dist/core/engine/bulk-operations.js

@@ -62,20 +62,13 @@ async function runBulkCancellation(internals, filter, options = {}) {
   const workflowIdsToCancel = preparation.workflowIds, bulkConcurrency = resolveBulkOperationConcurrency(options);
   let cancelled = 0;
   const errors = [], cancellationResults = await runBulkWorkflowPool(workflowIdsToCancel, bulkConcurrency, async (workflowId) => {
-    try {
-      await internals.engine.cancel(workflowId);
-      if ((await loadWorkflowState(internals, workflowId))?.status === "cancelled")
-        return { status: "cancelled" };
-      return {
-        status: "failed",
-        error: { id: workflowId, error: "Workflow no longer cancellable" }
-      };
-    } catch (error) {
-      return {
-        status: "failed",
-        error: toBulkOperationError(internals, workflowId, error)
-      };
-    }
+    await internals.engine.cancel(workflowId);
+    if ((await loadWorkflowState(internals, workflowId))?.status === "cancelled")
+      return { status: "cancelled" };
+    return {
+      status: "failed",
+      error: { id: workflowId, error: "Workflow no longer cancellable" }
+    };
   });
   for (const cancellationResult of cancellationResults) {
     if (cancellationResult.status === "rejected") {
@@ -107,27 +100,15 @@ async function runBulkFailedWorkflowRetry(internals, filter, options = {}) {
   const bulkConcurrency = resolveBulkOperationConcurrency(options);
   let retried = 0;
   const errors = [], retryResults = await runBulkWorkflowPool(preparation.workflowIds, bulkConcurrency, async (workflowId) => {
-    try {
-      await retryFailedWorkflow(internals, workflowId);
-      return { status: "retried" };
-    } catch (error) {
-      return {
-        status: "failed",
-        error: toBulkOperationError(internals, workflowId, error)
-      };
-    }
+    await retryFailedWorkflow(internals, workflowId);
+    return { status: "retried" };
   });
   for (const retryResult of retryResults) {
     if (retryResult.status === "rejected") {
       errors.push(toBulkOperationError(internals, retryResult.item, retryResult.reason));
       continue;
     }
-    const { value } = retryResult;
-    if (value.status === "retried") {
-      retried += 1;
-      continue;
-    }
-    errors.push(value.error);
+    retried += 1;
   }
   const result = { retried, failed: errors.length, errors };
   if (!shouldPersistBulkAudit(options))

package/dist/core/engine/callback-creators-bundles.js

@@ -122,7 +122,7 @@ export function createTimeOperationCallbacks(engine) {
     loadWorkflowState: (workflowId) => loadWorkflowState(getInternals(engine), workflowId),
     failWorkflow: (workflowId, error) => failWorkflow(getInternals(engine), workflowId, error, createTerminationCallbacks(engine)),
     runSerializedWorkflowStateWrite: (workflowId, writeOperation) => runSerializedWorkflowStateWrite(getInternals(engine), workflowId, writeOperation),
-    beginWorkflowExecution: (workflowId, workflowType, input, checkpoint, executionDeadline, executionStateOwnerId, registration) => beginWorkflowExecution(getInternals(engine), workflowId, workflowType, input, checkpoint, executionDeadline, executionStateOwnerId, registration, createLifecycleCallbacks(engine)),
+    beginWorkflowExecution: (workflowId, workflowExecutionToken, workflowType, input, checkpoint, executionDeadline, executionStateOwnerId, registration) => beginWorkflowExecution(getInternals(engine), workflowId, workflowExecutionToken, workflowType, input, checkpoint, executionDeadline, executionStateOwnerId, registration, createLifecycleCallbacks(engine)),
     workflowVersionTupleFromState: (state) => workflowVersionTupleFromState(getInternals(engine), state, createLifecycleCallbacks(engine)),
     setWorkflowStartHeaders: (workflowId, headers) => setWorkflowStartHeaders(getInternals(engine), workflowId, headers, createLifecycleCallbacks(engine)),
     loadWorkflowStartHeaders: (workflowId) => loadWorkflowStartHeaders(getInternals(engine), workflowId, createLifecycleCallbacks(engine)),

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.js

@@ -209,6 +209,16 @@ 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"), 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);

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

@@ -90,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;

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.js

@@ -149,7 +149,7 @@ class MemoDurableActivityScope {
       finishTimerWrite();
     }
     this.#throwIfClosed();
-    registerSleepResolver(this.#internals, this.#workflowId, operation.operationId, resolve);
+    registerSleepResolver(this.#internals, this.#workflowId, operation.operationId, resolve, operation.scheduledFireAt);
     await promise;
   }
   #activityOperationId(ordinal, attempt) {

package/dist/core/engine/operations-activity.d.ts

@@ -25,7 +25,7 @@ export type ActivityOperationCallbacks = {
 };
 export declare function buildActivityVerification(_internals: EngineInternals, activityName: string, verify: ActivityFunctionWithMetadata['verify'], context: ReturnType<typeof buildActivityVerificationContext>, result: unknown): Promise<void>;
 export declare function buildActivityCompensation(internals: EngineInternals, workflowId: string, operation: ActivityOperation, result: unknown): (() => Promise<void>) | undefined;
-export declare function invokeWorkerActivity(internals: EngineInternals, operationId: string, activityName: string, input: unknown, attempt: number): Promise<unknown>;
+export declare function invokeWorkerActivity(internals: EngineInternals, operationId: string, activityName: string, input: unknown, attempt: number, workflowExecutionToken: string | undefined, activityAttemptToken: string | undefined): Promise<unknown>;
 export declare function invokeInlineActivity(internals: EngineInternals, workflowId: string, operation: ActivityOperation, activityContext: ActivityContext, _activityName: string, input: unknown): unknown;
 /**
  * Execute an activity function, dispatching to a Web Worker pool when

package/dist/core/engine/operations-activity.js

@@ -40,7 +40,7 @@ export function buildActivityCompensation(internals, workflowId, operation, resu
     await activity.compensate?.(operation.input, result);
   };
 }
-export async function invokeWorkerActivity(internals, operationId, activityName, input, attempt) {
+export async function invokeWorkerActivity(internals, operationId, activityName, input, attempt, workflowExecutionToken, activityAttemptToken) {
   const dispatcher = internals.activityWorkerDispatcher;
   if (!dispatcher)
     throw Error(`No activity worker dispatcher available for "${activityName}"`);
@@ -48,7 +48,9 @@ export async function invokeWorkerActivity(internals, operationId, activityName,
     operationId,
     activityName,
     input,
-    attempt
+    attempt,
+    ...workflowExecutionToken !== void 0 && { workflowExecutionToken },
+    ...activityAttemptToken !== void 0 && { activityAttemptToken }
   });
   if (result.status === "failed") {
     const error = Error(result.error);
@@ -74,11 +76,11 @@ function getActivityStateKey(operation) {
   return operation.activityStateKey ?? operation.step ?? 0;
 }
 export async function executeActivity(internals, workflowId, operation, callbacks, attempt = getActivityAttempt(operation), coordinatorSignal) {
-  const activityInput = operation.input, activityStateKey = getActivityStateKey(operation);
+  const activityInput = operation.input, activityStateKey = getActivityStateKey(operation), workflowExecutionToken = operation.workflowExecutionToken;
   warnIfRetryMissingHeartbeat(internals, workflowId, activityStateKey, attempt);
-  const asyncToken = deriveAsyncActivityToken(workflowId, activityStateKey, attempt), { perAttemptTimeoutMs, attemptAbortController, activitySignal } = resolvePerAttemptTimeout(internals, workflowId, operation, coordinatorSignal), activityContext = buildActivityContext(internals, workflowId, activityStateKey, activitySignal, () => {
+  const asyncToken = deriveAsyncActivityToken(workflowId, activityStateKey, attempt), { perAttemptTimeoutMs, attemptAbortController, activitySignal } = resolvePerAttemptTimeout(internals, workflowId, operation, coordinatorSignal), activityContext = buildActivityContext(internals, workflowId, workflowExecutionToken, activityStateKey, attempt, activitySignal, () => {
     throw new AsyncActivityDeferral(asyncToken);
-  }), invokeActivity = internals.activityWorkerDispatcher ? (activityName, input) => invokeWorkerActivity(internals, operation.operationId, activityName, input, attempt) : (activityName, input) => withPerAttemptTimeout(invokeInlineActivity(internals, workflowId, operation, activityContext, activityName, input), perAttemptTimeoutMs, activityName, attempt, attemptAbortController), composedActivity = callbacks.getComposedActivityInterceptor(), executeWithActivityInterceptors = async (activityName, input, headers) => {
+  }), activityAttemptToken = activityContext.activityAttemptToken, invokeActivity = internals.activityWorkerDispatcher ? (activityName, input) => invokeWorkerActivity(internals, operation.operationId, activityName, input, attempt, workflowExecutionToken, activityAttemptToken) : (activityName, input) => withPerAttemptTimeout(invokeInlineActivity(internals, workflowId, operation, activityContext, activityName, input), perAttemptTimeoutMs, activityName, attempt, attemptAbortController), composedActivity = callbacks.getComposedActivityInterceptor(), executeWithActivityInterceptors = async (activityName, input, headers) => {
     if (!composedActivity)
       return invokeActivity(activityName, input);
     const activityInterception = {

package/dist/core/engine/operations-time.d.ts

@@ -12,7 +12,7 @@ export type TimeOperationCallbacks = {
     loadWorkflowState: (workflowId: string) => Promise<WorkflowState | null>;
     failWorkflow: (workflowId: string, error: Error) => Promise<void>;
     runSerializedWorkflowStateWrite: <Result>(workflowId: string, writeOperation: () => Promise<Result>) => Promise<Result>;
-    beginWorkflowExecution: (workflowId: string, workflowType: string, input: unknown, checkpoint: Checkpoint, executionDeadline: number | undefined, executionStateOwnerId: string, registration: RegistrationEntry) => void;
+    beginWorkflowExecution: (workflowId: string, workflowExecutionToken: string | undefined, workflowType: string, input: unknown, checkpoint: Checkpoint, executionDeadline: number | undefined, executionStateOwnerId: string, registration: RegistrationEntry) => void;
     workflowVersionTupleFromState: (state: WorkflowState) => WorkflowVersionTuple;
     setWorkflowStartHeaders: (workflowId: string, headers: Map<string, string> | undefined) => void;
     loadWorkflowStartHeaders: (workflowId: string) => Promise<Map<string, string> | undefined>;
@@ -25,7 +25,7 @@ export type TimeOperationCallbacks = {
 };
 export declare function createDelayedStartTimerEntry(_internals: EngineInternals, workflowId: string, scheduledStartAt: number, options: StartOptions | undefined, callbacks: Pick<TimeOperationCallbacks, 'parseStartOptionDuration'>): TimerEntry;
 export declare function processSleepOperation(internals: EngineInternals, workflowId: string, operation: SleepOperation, callbacks: Pick<TimeOperationCallbacks, 'completeOperation' | 'loadWorkflowState'>): Promise<void>;
-export declare function registerSleepResolver(internals: EngineInternals, workflowId: string, operationId: string, resolve: () => void): void;
+export declare function registerSleepResolver(internals: EngineInternals, workflowId: string, operationId: string, resolve: () => void, scheduledFireAt: number): void;
 export declare function startDelayedWorkflow(internals: EngineInternals, entry: TimerEntry, callbacks: Pick<TimeOperationCallbacks, 'beginWorkflowExecution' | 'dispatchEvent' | 'failWorkflow' | 'handleCleanupError' | 'loadWorkflowStartHeaders' | 'loadWorkflowState' | 'runSerializedWorkflowStateWrite' | 'setWorkflowStartHeaders' | 'workflowVersionTupleFromState'>): Promise<void>;
 export declare function handleTimerFired(internals: EngineInternals, entry: TimerEntry, callbacks: Pick<TimeOperationCallbacks, 'failWorkflow' | 'handleCleanupError' | 'loadWorkflowStartHeaders' | 'loadWorkflowState' | 'runDeferredTerminalCleanup' | 'runWorkflowFinalizer' | 'runSerializedWorkflowStateWrite' | 'handleScheduleTimer' | 'setWorkflowStartHeaders' | 'timeout' | 'beginWorkflowExecution' | 'dispatchEvent' | 'workflowVersionTupleFromState'>): Promise<void>;
 export {};

package/dist/core/engine/operations-time.js

@@ -16,6 +16,18 @@ export function createDelayedStartTimerEntry(_internals, workflowId, scheduledSt
     }
   };
 }
+function sleepTimerFiredEarly(internals, workflowId, operation) {
+  const workflowMarkers = internals.sleepTimersFiredWithoutResolver.get(workflowId);
+  if (!workflowMarkers)
+    return !1;
+  const markedFireAt = workflowMarkers.get(operation.operationId);
+  if (markedFireAt === void 0)
+    return !1;
+  workflowMarkers.delete(operation.operationId);
+  if (workflowMarkers.size === 0)
+    internals.sleepTimersFiredWithoutResolver.delete(workflowId);
+  return markedFireAt >= operation.scheduledFireAt;
+}
 export async function processSleepOperation(internals, workflowId, operation, callbacks) {
   if (operation.scheduledFireAt <= internals.options.getNow()) {
     callbacks.completeOperation(workflowId, void 0);
@@ -28,13 +40,24 @@ export async function processSleepOperation(internals, workflowId, operation, ca
     fireAt: operation.scheduledFireAt,
     kind: "sleep"
   });
-  registerSleepResolver(internals, workflowId, operation.operationId, resolve);
+  registerSleepResolver(internals, workflowId, operation.operationId, resolve, operation.scheduledFireAt);
+  const resolverKey = `${workflowId}:${operation.operationId}`;
+  if (sleepTimerFiredEarly(internals, workflowId, operation) && internals.sleepResolvers.has(resolverKey))
+    resolveSleepTimer(internals, {
+      id: `sleep:${operation.operationId}`,
+      workflowId,
+      fireAt: operation.scheduledFireAt,
+      kind: "sleep"
+    });
   await promise;
   if ((await callbacks.loadWorkflowState(workflowId))?.status === "running")
     callbacks.completeOperation(workflowId, void 0);
 }
-export function registerSleepResolver(internals, workflowId, operationId, resolve) {
-  internals.sleepResolvers.set(`${workflowId}:${operationId}`, resolve);
+export function registerSleepResolver(internals, workflowId, operationId, resolve, scheduledFireAt) {
+  internals.sleepResolvers.set(`${workflowId}:${operationId}`, {
+    resolve,
+    fireAt: scheduledFireAt
+  });
   let workflowOperations = internals.sleepResolversByWorkflow.get(workflowId);
   if (!workflowOperations) {
     workflowOperations = new Set;
@@ -94,7 +117,7 @@ export async function startDelayedWorkflow(internals, entry, callbacks) {
   internals.checkpoints.set(entry.workflowId, checkpoint);
   internals.workflowVersionTuples.set(entry.workflowId, callbacks.workflowVersionTupleFromState(runningState));
   callbacks.setWorkflowStartHeaders(entry.workflowId, await callbacks.loadWorkflowStartHeaders(entry.workflowId));
-  callbacks.beginWorkflowExecution(entry.workflowId, runningState.type, runningState.input, checkpoint, executionDeadline, runningState.executionStateOwnerId ?? entry.workflowId, registration);
+  callbacks.beginWorkflowExecution(entry.workflowId, runningState.workflowExecutionToken, runningState.type, runningState.input, checkpoint, executionDeadline, runningState.executionStateOwnerId ?? entry.workflowId, registration);
 }
 async function loadDelayedWorkflowCheckpoint(internals, entry, callbacks) {
   const checkpointBytes = await internals.storage.get(KEYS.checkpoint(entry.workflowId));
@@ -168,11 +191,22 @@ async function handleReviewTimer(internals, entry, callbacks) {
 }
 function resolveSleepTimer(internals, entry) {
   const operationId = entry.id.replace("sleep:", ""), resolverKey = `${entry.workflowId}:${operationId}`, resolver = internals.sleepResolvers.get(resolverKey);
-  if (!resolver)
+  if (!resolver) {
+    let workflowMarkers = internals.sleepTimersFiredWithoutResolver.get(entry.workflowId);
+    if (!workflowMarkers) {
+      workflowMarkers = new Map;
+      internals.sleepTimersFiredWithoutResolver.set(entry.workflowId, workflowMarkers);
+    }
+    const existing = workflowMarkers.get(operationId);
+    if (existing === void 0 || entry.fireAt > existing)
+      workflowMarkers.set(operationId, entry.fireAt);
+    return;
+  }
+  if (entry.fireAt < resolver.fireAt)
     return;
   internals.sleepResolvers.delete(resolverKey);
   untrackSleepResolver(internals, entry.workflowId, operationId);
-  resolver();
+  resolver.resolve();
 }
 function untrackSleepResolver(internals, workflowId, operationId) {
   const workflowOperations = internals.sleepResolversByWorkflow.get(workflowId);

package/dist/core/engine/schedules.js

@@ -35,6 +35,9 @@ export async function schedule(internals, type, input, spec, options) {
       id: scheduleId,
       workflowType: type,
       input,
+      ...normalizedOptions.description !== void 0 && {
+        description: normalizedOptions.description
+      },
       ...cadenceFields,
       status: "active",
       overlap: normalizedOptions.overlap,