@lostgradient/weft 0.7.0 → 0.9.0

package/dist/core/engine/memo-durable-activity.js

@@ -0,0 +1,282 @@
+import { hashString } from "../../runtime/portable.js";
+import {
+  DurableActivityScopeError,
+  DurableActivityUnsupportedError,
+  runWithDurableActivityScope
+} from "../context/durable-activity.js";
+import {
+  readOrInitActivityRetrySleepFireAt,
+  runActivityWithRetryAtStep
+} from "../context/run-operation.js";
+import { AsyncActivityDeferral } from "./async-activity-completion.js";
+import {
+  executeActivityOperationResult
+} from "./operations-activity.js";
+import { registerSleepResolver } from "./operations-time.js";
+import { callMemoFunction } from "./state-utilities.js";
+export async function callMemoFunctionWithDurableActivityScope(internals, workflowId, operation, callbacks) {
+  const context = internals.inlineStrategy?.getContext(workflowId);
+  if (context === void 0 || typeof operation.step !== "number" || !Number.isSafeInteger(operation.step) || operation.step < 0 || callbacks.getActivityOperationCallbacks === void 0)
+    return callMemoFunction(operation.fn);
+  const memoOperation = { ...operation, step: operation.step };
+  return new MemoDurableActivityScope(internals, workflowId, memoOperation, context, callbacks.getActivityOperationCallbacks(), callbacks.persistCheckpoint).run(() => callMemoFunction(operation.fn));
+}
+
+class MemoDurableActivityScope {
+  #internals;
+  #workflowId;
+  #operation;
+  #context;
+  #activityCallbacks;
+  #persistCheckpoint;
+  #scopeAbortController = new AbortController;
+  #pendingPromises = new Set;
+  #identityPrefix;
+  #activePromise;
+  #activeNonCancellableWriteCount = 0;
+  #closed = !1;
+  #closeReason;
+  #nextOrdinal = 0;
+  constructor(internals, workflowId, operation, context, activityCallbacks, persistCheckpoint) {
+    this.#internals = internals;
+    this.#workflowId = workflowId;
+    this.#operation = operation;
+    this.#context = context;
+    this.#activityCallbacks = activityCallbacks;
+    this.#persistCheckpoint = persistCheckpoint;
+    this.#identityPrefix = `memo:${operation.step}:${hashString(operation.key)}`;
+    this.#internals.workflowTypeByWorkflowId.set(workflowId, context.workflowType);
+  }
+  async run(execute) {
+    const cleanupAbortForwarding = this.#forwardAbortSignals();
+    try {
+      const result = await runWithDurableActivityScope(this, execute);
+      if (this.#pendingPromises.size > 0) {
+        const error = new DurableActivityScopeError("durableActivity() calls started inside ctx.memo() must be awaited before the memo callback returns.");
+        await this.#closeAndDrain(error);
+        throw error;
+      }
+      this.#close();
+      return result;
+    } catch (error) {
+      await this.#closeAndDrain(error);
+      throw error;
+    } finally {
+      cleanupAbortForwarding();
+    }
+  }
+  dispatch(invocation) {
+    try {
+      this.#throwIfClosed();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    if (this.#activePromise !== void 0)
+      return Promise.reject(new DurableActivityScopeError("durableActivity() calls inside one ctx.memo() scope must be awaited sequentially. Start the next durableActivity() call after the previous promise settles."));
+    const ordinal = this.#nextOrdinal;
+    this.#nextOrdinal += 1;
+    const execution = this.#executeInvocation(invocation, ordinal);
+    this.#activePromise = execution;
+    this.#pendingPromises.add(execution);
+    execution.finally(() => {
+      if (this.#activePromise === execution)
+        this.#activePromise = void 0;
+      this.#pendingPromises.delete(execution);
+    }).catch(() => {});
+    execution.catch(() => {});
+    return execution;
+  }
+  async#executeInvocation(invocation, ordinal) {
+    const activityStateKey = this.#activityStateKey(ordinal), generator = runActivityWithRetryAtStep(this.#context, invocation.activity, invocation.arguments, this.#operation.step, {
+      activityStateKey,
+      cacheResultStep: !1,
+      retryStateKey: activityStateKey,
+      retrySleep: (duration, nextAttempt) => this.#retrySleepOperation(duration, ordinal, nextAttempt)
+    });
+    let next = generator.next();
+    while (!next.done)
+      try {
+        const result = await this.#executeYieldedOperation(next.value, invocation, ordinal);
+        next = generator.next(result);
+      } catch (error) {
+        if (error instanceof AsyncActivityDeferral)
+          throw new DurableActivityUnsupportedError("ActivityContext.completeAsync() is not supported from durableActivity(). Use yield* ctx.run() for async-completion activities.");
+        next = generator.throw(error);
+      }
+    return next.value;
+  }
+  async#executeYieldedOperation(operation, invocation, ordinal) {
+    this.#throwIfClosed();
+    if (operation.type === "activity")
+      return this.#executeActivityOperation(operation, invocation.callerStack, ordinal);
+    if (operation.type === "sleep") {
+      await this.#raceWithScopeAbort(this.#executeDurableRetrySleepOperation(operation));
+      this.#throwIfClosed();
+      return;
+    }
+    throw new DurableActivityScopeError(`durableActivity() retry driver yielded unsupported operation "${operation.type}".`);
+  }
+  #executeActivityOperation(request, callerStack, ordinal) {
+    const attempt = typeof request.attempt === "number" ? request.attempt : 1, operation = {
+      ...request,
+      operationId: this.#activityOperationId(ordinal, attempt),
+      callerStack
+    };
+    return this.#raceWithScopeAbort(executeActivityOperationResult(this.#internals, this.#workflowId, operation, this.#activityCallbacks, this.#scopeAbortController.signal, void 0, {
+      reconciliationCompletion: "immediate-fenced",
+      beforeImmediateReconciliationCommit: () => this.#beginNonCancellableWrite()
+    }));
+  }
+  async#executeDurableRetrySleepOperation(operation) {
+    const finishCheckpointWrite = this.#beginNonCancellableWrite();
+    try {
+      await this.#persistCheckpoint(this.#workflowId, operation);
+    } finally {
+      finishCheckpointWrite();
+    }
+    this.#throwIfClosed();
+    if (operation.scheduledFireAt <= this.#internals.options.getNow())
+      return;
+    const { promise, resolve } = Promise.withResolvers(), finishTimerWrite = this.#beginNonCancellableWrite();
+    try {
+      await this.#internals.scheduler.schedule({
+        id: `sleep:${operation.operationId}`,
+        workflowId: this.#workflowId,
+        fireAt: operation.scheduledFireAt,
+        kind: "sleep"
+      });
+    } finally {
+      finishTimerWrite();
+    }
+    this.#throwIfClosed();
+    registerSleepResolver(this.#internals, this.#workflowId, operation.operationId, resolve, operation.scheduledFireAt);
+    await promise;
+  }
+  #activityOperationId(ordinal, attempt) {
+    return `${this.#activityStateKey(ordinal)}:activity:${attempt}`;
+  }
+  #retrySleepOperationId(ordinal, nextAttempt) {
+    return `${this.#activityStateKey(ordinal)}:retry-sleep:${nextAttempt}`;
+  }
+  *#retrySleepOperation(duration, ordinal, nextAttempt) {
+    const operationId = this.#retrySleepOperationId(ordinal, nextAttempt);
+    yield {
+      type: "sleep",
+      operationId,
+      duration,
+      scheduledFireAt: this.#readOrInitRetrySleepFireAt(operationId, duration)
+    };
+  }
+  #readOrInitRetrySleepFireAt(operationId, duration) {
+    return readOrInitActivityRetrySleepFireAt(this.#context, operationId, duration);
+  }
+  #activityStateKey(ordinal) {
+    if (!Number.isSafeInteger(ordinal) || ordinal < 0)
+      throw new DurableActivityScopeError(`Invalid durableActivity() call ordinal ${String(ordinal)} for ctx.memo() step ${String(this.#operation.step)}.`);
+    return `${this.#identityPrefix}:call:${String(ordinal)}`;
+  }
+  #raceWithScopeAbort(operation) {
+    operation.catch(() => {});
+    this.#throwIfClosed();
+    return new Promise((resolve, reject) => {
+      let settled = !1;
+      const signal = this.#scopeAbortController.signal, cleanup = () => {
+        signal.removeEventListener("abort", onAbort);
+      }, settle = (callback) => {
+        if (settled)
+          return;
+        settled = !0;
+        cleanup();
+        callback();
+      }, onAbort = () => {
+        if (this.#activeNonCancellableWriteCount > 0)
+          return;
+        settle(() => reject(this.#abortError()));
+      };
+      signal.addEventListener("abort", onAbort, { once: !0 });
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      operation.then((value) => {
+        settle(() => {
+          if (this.#closed || signal.aborted) {
+            reject(this.#abortError());
+            return;
+          }
+          resolve(value);
+        });
+      }).catch((error) => {
+        settle(() => reject(error));
+      });
+    });
+  }
+  #beginNonCancellableWrite() {
+    this.#throwIfClosed();
+    this.#activeNonCancellableWriteCount += 1;
+    let finished = !1;
+    return () => {
+      if (finished)
+        return;
+      finished = !0;
+      this.#activeNonCancellableWriteCount -= 1;
+      if (this.#closed && this.#activeNonCancellableWriteCount === 0 && !this.#scopeAbortController.signal.aborted)
+        this.#scopeAbortController.abort(this.#abortError());
+    };
+  }
+  #forwardAbortSignals() {
+    const signals = [this.#context.signal, this.#internals.abortController.signal], listeningSignals = [], onAbort = () => {
+      this.#close(new DurableActivityScopeError("durableActivity() scope closed before completion."));
+    }, cleanup = () => {
+      for (const signal of listeningSignals)
+        signal.removeEventListener("abort", onAbort);
+    };
+    for (const signal of signals) {
+      if (signal.aborted) {
+        onAbort();
+        return cleanup;
+      }
+      signal.addEventListener("abort", onAbort, { once: !0 });
+      listeningSignals.push(signal);
+    }
+    return cleanup;
+  }
+  #close(reason) {
+    if (this.#closed)
+      return;
+    this.#closed = !0;
+    this.#closeReason = toScopeError(reason);
+    if (this.#activeNonCancellableWriteCount === 0 && !this.#scopeAbortController.signal.aborted)
+      this.#scopeAbortController.abort(this.#closeReason);
+  }
+  async#closeAndDrain(reason) {
+    this.#close(reason);
+    if (this.#pendingPromises.size === 0)
+      return;
+    await Promise.allSettled(this.#pendingPromises);
+  }
+  #throwIfClosed() {
+    if (this.#closed || this.#scopeAbortController.signal.aborted)
+      throw this.#abortError();
+  }
+  #abortError() {
+    if (this.#closeReason !== void 0)
+      return this.#closeReason;
+    const reason = this.#scopeAbortController.signal.reason;
+    return reason instanceof Error ? reason : new DurableActivityScopeError("durableActivity() scope closed before completion.");
+  }
+}
+function toScopeError(reason) {
+  if (reason instanceof Error)
+    return reason;
+  if (reason === void 0)
+    return new DurableActivityScopeError("durableActivity() scope closed before completion.");
+  return new DurableActivityScopeError(formatCloseReason(reason));
+}
+function formatCloseReason(reason) {
+  if (typeof reason === "string")
+    return reason;
+  if (typeof reason === "number" || typeof reason === "boolean" || typeof reason === "bigint")
+    return reason.toString();
+  return "durableActivity() scope closed before completion.";
+}

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

@@ -12,6 +12,10 @@ export type ActivityFunctionWithMetadata = ((...arguments_: unknown[]) => unknow
 type ActivityOperation = Extract<ContextOperationRequest, {
     type: 'activity';
 }>;
+export interface ActivityExecutionOptions {
+    reconciliationCompletion?: 'stage-with-workflow-commit' | 'immediate-fenced';
+    beforeImmediateReconciliationCommit?: () => void | (() => void);
+}
 export type ActivityOperationCallbacks = {
     runOperationWithResult: (workflowId: string, operation: ActivityOperation, execute: () => Promise<unknown>) => Promise<void>;
     finalizePendingTimelineEntry: (workflowId: string, status: 'completed' | 'failed', value: unknown) => void;
@@ -21,13 +25,13 @@ 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
  * `activityExecution` is configured, or running inline on the main thread.
  */
 export declare function executeActivity(internals: EngineInternals, workflowId: string, operation: ActivityOperation, callbacks: ActivityOperationCallbacks, attempt?: number, coordinatorSignal?: AbortSignal): Promise<unknown>;
-export declare function executeActivityOperationResult(internals: EngineInternals, workflowId: string, operation: ActivityOperation, callbacks: ActivityOperationCallbacks, coordinatorSignal?: AbortSignal, speculativeState?: SpeculativeExecutionState): Promise<unknown>;
+export declare function executeActivityOperationResult(internals: EngineInternals, workflowId: string, operation: ActivityOperation, callbacks: ActivityOperationCallbacks, coordinatorSignal?: AbortSignal, speculativeState?: SpeculativeExecutionState, executionOptions?: ActivityExecutionOptions): Promise<unknown>;
 export declare function processActivityOperation(internals: EngineInternals, workflowId: string, operation: ActivityOperation, callbacks: ActivityOperationCallbacks): Promise<void>;
 export {};

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

@@ -8,6 +8,7 @@ import { resolvePerAttemptTimeout, withPerAttemptTimeout } from "./activity-per-
 import {
   buildActivityReconciliationReference,
   buildActivityVerificationContext,
+  commitActivityReconciliationTransitionWithFencedWrite,
   createCompletedActivityReconciliationRecord,
   resolveActivityIdempotencyKey,
   resolveStartedActivityReconciliationRecord,
@@ -39,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}"`);
@@ -47,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);
@@ -69,12 +72,15 @@ function getActivityAttempt(operation) {
   const attempt = operation.attempt;
   return typeof attempt === "number" && Number.isInteger(attempt) && attempt > 0 ? attempt : 1;
 }
+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, step = operation.step ?? 0;
-  warnIfRetryMissingHeartbeat(internals, workflowId, step, attempt);
-  const asyncToken = deriveAsyncActivityToken(workflowId, step, attempt), { perAttemptTimeoutMs, attemptAbortController, activitySignal } = resolvePerAttemptTimeout(internals, workflowId, operation, coordinatorSignal), activityContext = buildActivityContext(internals, workflowId, step, activitySignal, () => {
+  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, 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 = {
@@ -107,7 +113,7 @@ export async function executeActivity(internals, workflowId, operation, callback
   copyActivityHeadersToOperation(operation, headers);
   return result;
 }
-export async function executeActivityOperationResult(internals, workflowId, operation, callbacks, coordinatorSignal, speculativeState) {
+export async function executeActivityOperationResult(internals, workflowId, operation, callbacks, coordinatorSignal, speculativeState, executionOptions = {}) {
   const activity = getActivityFunctionWithMetadata(internals, workflowId, operation), idempotencyKey = resolveActivityIdempotencyKey(activity, operation), operationAttempt = getActivityAttempt(operation);
   if (idempotencyKey !== void 0) {
     const reference = await buildActivityReconciliationReference(workflowId, operation.activityName, idempotencyKey), started = await resolveStartedActivityReconciliationRecord(internals, workflowId, operation, reference, activity, idempotencyKey, operationAttempt);
@@ -119,16 +125,24 @@ export async function executeActivityOperationResult(internals, workflowId, oper
     validateActivityResultForReconciliation(result, internals.options.payloadSizePolicy.maxBytes);
     await finalizeActivityResult(internals, workflowId, operation, result, activity, idempotencyKey, started.attempt, speculativeState, !0);
     const completedRecord = createCompletedActivityReconciliationRecord(started, result, internals.options.getNow());
-    stageActivityReconciliationTransitionWithAtomicWorkflowCommit(internals, workflowId, reference, started, completedRecord);
+    if (executionOptions.reconciliationCompletion === "immediate-fenced") {
+      const finishImmediateReconciliationCommit = executionOptions.beforeImmediateReconciliationCommit?.();
+      try {
+        await commitActivityReconciliationTransitionWithFencedWrite(internals, reference, started, completedRecord);
+      } finally {
+        finishImmediateReconciliationCommit?.();
+      }
+    } else
+      stageActivityReconciliationTransitionWithAtomicWorkflowCommit(internals, workflowId, reference, started, completedRecord);
     if (!speculativeState)
-      clearLastHeartbeatForStep(internals, workflowId, operation.step ?? 0);
+      clearLastHeartbeatForStep(internals, workflowId, getActivityStateKey(operation));
     return result;
   }
   const result = await executeActivity(internals, workflowId, operation, callbacks, operationAttempt, coordinatorSignal);
   assertPayloadWithinLimit(result, internals.options.payloadSizePolicy.maxBytes, "activity result");
   await finalizeActivityResult(internals, workflowId, operation, result, activity, idempotencyKey, operationAttempt, speculativeState);
   if (!speculativeState)
-    clearLastHeartbeatForStep(internals, workflowId, operation.step ?? 0);
+    clearLastHeartbeatForStep(internals, workflowId, getActivityStateKey(operation));
   return result;
 }
 async function finalizeActivityResult(internals, workflowId, operation, result, activity, idempotencyKey, attempt, speculativeState, awaitSpeculativeVerification = !1) {

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

@@ -1,5 +1,6 @@
 import type { ContextOperationRequest } from '../context.ts';
 import type { EngineInternals } from './internals.ts';
+import type { ActivityOperationCallbacks } from './operations-activity.ts';
 import type { OperationWithCallerStack } from './operations-router.ts';
 type MemoOperation = Extract<ContextOperationRequest, {
     type: 'memo';
@@ -15,8 +16,10 @@ type ArchiveOperation = Extract<ContextOperationRequest, {
 }>;
 export type DataOperationCallbacks = {
     runOperationWithResult: (workflowId: string, operation: OperationWithCallerStack, execute: () => Promise<unknown>) => Promise<void>;
+    persistCheckpoint: (workflowId: string, operation: ContextOperationRequest) => Promise<void>;
+    getActivityOperationCallbacks?: () => ActivityOperationCallbacks;
 };
-export declare function processMemoOperation(_internals: EngineInternals, workflowId: string, operation: MemoOperation, callbacks: DataOperationCallbacks): Promise<void>;
+export declare function processMemoOperation(internals: EngineInternals, workflowId: string, operation: MemoOperation, callbacks: DataOperationCallbacks): Promise<void>;
 export declare function processOffloadOperation(internals: EngineInternals, workflowId: string, operation: OffloadOperation, callbacks: DataOperationCallbacks): Promise<void>;
 export declare function processLoadOperation(internals: EngineInternals, workflowId: string, operation: LoadOperation, callbacks: DataOperationCallbacks): Promise<void>;
 /**

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

@@ -1,8 +1,8 @@
 import { KEYS } from "../../storage/interface.js";
 import { decode, encode } from "../codec.js";
-import { callMemoFunction } from "./state-utilities.js";
-export async function processMemoOperation(_internals, workflowId, operation, callbacks) {
-  return callbacks.runOperationWithResult(workflowId, operation, async () => callMemoFunction(operation.fn));
+import { callMemoFunctionWithDurableActivityScope } from "./memo-durable-activity.js";
+export async function processMemoOperation(internals, workflowId, operation, callbacks) {
+  return callbacks.runOperationWithResult(workflowId, operation, async () => callMemoFunctionWithDurableActivityScope(internals, workflowId, operation, callbacks));
 }
 export async function processOffloadOperation(internals, workflowId, operation, callbacks) {
   return callbacks.runOperationWithResult(workflowId, operation, async () => {

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

@@ -3,6 +3,7 @@ import { ReviewCompletedEvent, ReviewRequestedEvent } from "../review/events.js"
 import {
   ReviewTimeoutError
 } from "../review/index.js";
+import { stageAtomicWorkflowCommitSideEffects } from "./checkpoint-side-effects.js";
 import {
   deleteCompletedReviewsForWorkflow,
   listCompletedReviewsFromStorage,
@@ -26,7 +27,7 @@ async function listPendingReviews(internals, filter) {
   return reviews;
 }
 async function dispatchCompletedReview(internals, reviewKey, reviewData, decisionResult, dispatchEvent) {
-  await persistCompletedReviewRecord(internals.storage, reviewKey, reviewData, decisionResult);
+  await persistCompletedReviewRecord(internals, reviewKey, reviewData, decisionResult);
   dispatchEvent(new ReviewCompletedEvent(reviewData.workflowId, reviewData.reviewId, decisionResult.decision, decisionResult.reviewer, decisionResult.timestamp - reviewData.createdAt));
 }
 export async function listReviews(internals, filter = {}) {
@@ -96,9 +97,11 @@ export async function handleReviewEscalationTimer(internals, workflowId, reviewI
   if (entry.id === `review-timeout:${reviewId}`) {
     internals.reviewWaiters.delete(waiterKey);
     untrackWaiterKey(internals.reviewWaitersByWorkflow, workflowId, waiterKey);
-    const elapsed = internals.options.getNow() - reviewRequest.createdAt;
-    await internals.storage.delete(KEYS.review(workflowId, reviewId));
-    const timeoutError = new ReviewTimeoutError(reviewId, elapsed);
+    const elapsed = internals.options.getNow() - reviewRequest.createdAt, timeoutError = new ReviewTimeoutError(reviewId, elapsed);
+    stageAtomicWorkflowCommitSideEffects(internals, workflowId, {
+      operations: [{ type: "delete", key: KEYS.review(workflowId, reviewId) }],
+      conditions: []
+    });
     await callbacks.failWorkflow(workflowId, timeoutError);
     resolve({ ok: !1, error: timeoutError });
     return !0;

package/dist/core/engine/schedule-timer.js

@@ -12,6 +12,8 @@ class ScheduleStatePersistenceError extends Error {
   }
 }
 export async function handleScheduleTimer(internals, entry, callbacks) {
+  if (internals.deposed)
+    return;
   const state = await loadScheduleState(internals, entry.workflowId);
   if (!isCurrentActiveScheduleTimer(state, entry))
     return;

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,

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

@@ -93,7 +93,7 @@ export async function writeScheduleState(internals, state, options) {
       kind: "schedule"
     }));
   }
-  await internals.storage.batch(operations);
+  await commitFencedEngineWrite(internals, operations, [], () => Error(`Schedule state commit for schedule "${state.id}" lost its precondition.`));
 }
 export async function loadWorkflowStartHeaders(internals, workflowId) {
   const bytes = await internals.storage.get(KEYS.workflowHeaders(workflowId));

package/dist/core/engine/termination/cleanup.js

@@ -43,23 +43,25 @@ function cleanupTrackedWaiter(internals, workflowId, kind) {
 }
 function cleanupSleepResolvers(internals, workflowId) {
   const sleepOps = internals.sleepResolversByWorkflow.get(workflowId);
-  if (!sleepOps)
-    return;
-  for (const operationId of sleepOps) {
-    const key = `${workflowId}:${operationId}`, resolver = internals.sleepResolvers.get(key);
-    if (resolver)
-      resolver();
-    internals.sleepResolvers.delete(key);
+  if (sleepOps) {
+    for (const operationId of sleepOps) {
+      const key = `${workflowId}:${operationId}`, resolver = internals.sleepResolvers.get(key);
+      if (resolver)
+        resolver.resolve();
+      internals.sleepResolvers.delete(key);
+    }
+    internals.sleepResolversByWorkflow.delete(workflowId);
   }
-  internals.sleepResolversByWorkflow.delete(workflowId);
+  internals.sleepTimersFiredWithoutResolver.delete(workflowId);
 }
 function evictSleepResolversWithoutResolving(internals, workflowId) {
   const sleepOps = internals.sleepResolversByWorkflow.get(workflowId);
-  if (!sleepOps)
-    return;
-  for (const operationId of sleepOps)
-    internals.sleepResolvers.delete(`${workflowId}:${operationId}`);
-  internals.sleepResolversByWorkflow.delete(workflowId);
+  if (sleepOps) {
+    for (const operationId of sleepOps)
+      internals.sleepResolvers.delete(`${workflowId}:${operationId}`);
+    internals.sleepResolversByWorkflow.delete(workflowId);
+  }
+  internals.sleepTimersFiredWithoutResolver.delete(workflowId);
 }
 function cleanupConditionWaiters(internals, workflowId) {
   const resolver = internals.conditionWaiters.get(workflowId);

package/dist/core/engine/termination/finalizer-activity.d.ts

@@ -50,4 +50,4 @@ export type FinalizerAttemptResult = {
  * @param attempt - 1-based attempt number, for the per-attempt timeout error message
  * @param shutdownSignal - the engine's dispose/shutdown abort signal; aborting it stops a cooperating finalizer
  */
-export declare function runFinalizerActivity(finalizer: RunnableFinalizer, input: unknown, attempt: number, shutdownSignal: AbortSignal): Promise<FinalizerAttemptResult>;
+export declare function runFinalizerActivity(finalizer: RunnableFinalizer, input: unknown, attempt: number, shutdownSignal: AbortSignal, workflowExecutionToken?: string): Promise<FinalizerAttemptResult>;