@lostgradient/weft 0.6.0 → 0.8.0

package/dist/core/engine/lifecycle/start-or-signal-resolution.js

@@ -23,12 +23,30 @@ async function awaitReservationCleared(internals, workflowId) {
     await sleep(RESERVATION_CLEAR_RETRY_DELAY_MS);
   }
 }
-export async function resolveCallerIdWinnerOrRetry(internals, winnerId, signalSpec, signalId, callbacks) {
-  const resolved = await signalOrConflictExistingWorkflow(internals, winnerId, signalSpec, signalId, callbacks);
-  if (resolved !== void 0)
-    return resolved;
+export async function resolveCallerIdWinnerOrRetry(internals, winnerId, signalSpec, signalId, callbacks, allowTerminalRestart = !1) {
+  const state = await loadWorkflowState(internals, winnerId);
+  if (state !== null) {
+    if (!isTerminalWorkflowStatus(state.status)) {
+      await callbacks.signalExistingWorkflow(winnerId, signalSpec.name, signalSpec.payload, signalId);
+      return callbacks.getHandle(winnerId);
+    }
+    if (!allowTerminalRestart)
+      throw new StartOrSignalConflictError(winnerId, state.status);
+  }
   await awaitReservationCleared(internals, winnerId);
-  return signalOrConflictExistingWorkflow(internals, winnerId, signalSpec, signalId, callbacks);
+  const stateAfterReservation = await loadWorkflowState(internals, winnerId);
+  if (stateAfterReservation === null)
+    return;
+  if (isTerminalWorkflowStatus(stateAfterReservation.status)) {
+    if (state !== null && isSameTerminalRun(state, stateAfterReservation))
+      return;
+    throw new StartOrSignalConflictError(winnerId, stateAfterReservation.status);
+  }
+  await callbacks.signalExistingWorkflow(winnerId, signalSpec.name, signalSpec.payload, signalId);
+  return callbacks.getHandle(winnerId);
+}
+function isSameTerminalRun(before, after) {
+  return before.id === after.id && before.type === after.type && before.status === after.status && before.createdAt === after.createdAt && before.updatedAt === after.updatedAt && before.terminalCleanupToken === after.terminalCleanupToken;
 }
 export async function signalOrConflictExistingWorkflow(internals, workflowId, signalSpec, signalId, callbacks) {
   const state = await loadWorkflowState(internals, workflowId);

package/dist/core/engine/lifecycle/start-or-signal.d.ts

@@ -1,4 +1,4 @@
-import type { StartOptions, StartOrSignalSignal } from '../../types.ts';
+import type { StartOptions, StartOrSignalOptions, StartOrSignalSignal } from '../../types.ts';
 import { type WorkflowHandle } from '../handles.ts';
 import type { EngineInternals } from '../internals.ts';
 import { type LifecycleCallbacks } from './shared.ts';
@@ -28,8 +28,10 @@ export declare function startWithIdempotency(internals: EngineInternals, type: s
  * - **Non-terminal** (running, pending, suspended) → deliver the signal through
  *   the standard engine signal path with the same `signalId`, so it dedups
  *   against a create-batch signal a concurrent winner may have written.
- * - **Terminal** → throw {@link StartOrSignalConflictError}: a finished run
- *   cannot be signalled and is not silently replaced.
+ * - **Terminal** → throw {@link StartOrSignalConflictError} by default. With
+ *   `options.onTerminalConflict: 'start-new'`, purge the prior terminal run
+ *   through the shared terminal-replacement path, start a fresh run, and deliver
+ *   the initial signal in the create batch.
  *
  * Convergence requires a SHARED workflow identity. Concurrent callers converge on
  * one workflow and one signal only when they share an `options.idempotencyKey`
@@ -43,4 +45,4 @@ export declare function startWithIdempotency(internals: EngineInternals, type: s
  * convergence primitive. Use `idempotencyKey` (id-free convergence) or
  * `id` + `signalId` when concurrent callers must converge.
  */
-export declare function startOrSignal(internals: EngineInternals, type: string, input: unknown, signalSpec: StartOrSignalSignal, options: StartOptions | undefined, callbacks: StartOrSignalCallbacks): Promise<StartOrSignalResult>;
+export declare function startOrSignal(internals: EngineInternals, type: string, input: unknown, signalSpec: StartOrSignalSignal, options: StartOrSignalOptions | undefined, callbacks: StartOrSignalCallbacks): Promise<StartOrSignalResult>;

package/dist/core/engine/lifecycle/start-or-signal.js

@@ -1,12 +1,11 @@
 import { KEYS, requireStorageCapability } from "../../../storage/interface.js";
 import {
   assertIdAndIdempotencyKeyExclusive,
-  assertOnTerminalConflictUnsupported,
   assertValidIdempotencyKey,
   assertValidOnTerminalConflict,
   StartWorkflowValidationError
 } from "../../start-workflow-validation.js";
-import { IdempotencyKeyPurgedError } from "../errors.js";
+import { IdempotencyKeyPurgedError, StartOrSignalConflictError } from "../errors.js";
 import { StartIdempotencyRaceLostError } from "./start-commit.js";
 import {
   createWithSignalOrFallback,
@@ -54,14 +53,20 @@ function validateStartOrSignalConvergence(signalSpec, options) {
   if (signalSpec.signalId !== void 0)
     throw new StartWorkflowValidationError("startOrSignal does not accept both signal.signalId and options.idempotencyKey: the signal id derives from the idempotency key for convergence. Provide exactly one.");
 }
+function validateStartOrSignalRestartPolicy(signalSpec, options) {
+  if (options?.onTerminalConflict !== "start-new" || signalSpec.signalId !== void 0)
+    return;
+  throw new StartWorkflowValidationError("startOrSignal options.onTerminalConflict: 'start-new' requires signal.signalId so concurrent restart-capable callers converge on one deterministic initial signal.");
+}
 export async function startOrSignal(internals, type, input, signalSpec, options, callbacks) {
   requireStorageCapability(internals.storage, "conditionalBatch", "startOrSignal");
-  assertOnTerminalConflictUnsupported(options, "startOrSignal");
+  assertValidOnTerminalConflict(options);
+  validateStartOrSignalRestartPolicy(signalSpec, options);
   const idempotencyKey = options?.idempotencyKey;
   validateStartOrSignalConvergence(signalSpec, options);
   const signalId = resolveSignalId(signalSpec, idempotencyKey), mappedId = idempotencyKey !== void 0 ? await resolveIdempotencyKeyWorkflowId(internals, idempotencyKey) : void 0, existingId = mappedId ?? options?.id;
   if (existingId !== void 0) {
-    const resolved = await signalOrConflictExistingWorkflow(internals, existingId, signalSpec, signalId, callbacks);
+    const resolved = await resolveExistingStartOrSignalTarget(internals, existingId, mappedId, signalSpec, signalId, options, callbacks);
     if (resolved !== void 0)
       return { handle: resolved, outcome: "signalled" };
     if (mappedId !== void 0)
@@ -69,3 +74,15 @@ export async function startOrSignal(internals, type, input, signalSpec, options,
   }
   return createWithSignalOrFallback(internals, type, input, signalSpec, signalId, options, callbacks);
 }
+async function resolveExistingStartOrSignalTarget(internals, existingId, mappedId, signalSpec, signalId, options, callbacks) {
+  try {
+    return await signalOrConflictExistingWorkflow(internals, existingId, signalSpec, signalId, callbacks);
+  } catch (error) {
+    if (canRestartTerminalCallerIdTarget(error, options, mappedId))
+      return;
+    throw error;
+  }
+}
+function canRestartTerminalCallerIdTarget(error, options, mappedId) {
+  return error instanceof StartOrSignalConflictError && options?.onTerminalConflict === "start-new" && mappedId === void 0;
+}

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 {};

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);
+    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;
@@ -28,6 +32,6 @@ export declare function invokeInlineActivity(internals: EngineInternals, workflo
  * `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,
@@ -69,10 +70,13 @@ 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);
+  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, () => {
     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) => {
     if (!composedActivity)
@@ -107,7 +111,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 +123,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/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-run.js

@@ -4,7 +4,7 @@ import { ScheduleFiredEvent } from "../events.js";
 import { unavailableServicesError } from "./lifecycle/recovered-services.js";
 import { EMPTY_STORAGE_VALUE } from "./lifecycle/shared.js";
 export async function startScheduledRun(internals, state, callbacks, occurrence) {
-  const workflowId = crypto.randomUUID(), scheduleRunOperations = state.overlap === "allow" ? [] : [{ type: "put", key: KEYS.scheduleRun(workflowId), value: encode(state.id) }], resolution = await resolveScheduledRunServices(internals, workflowId, state);
+  const workflowId = crypto.randomUUID(), scheduleRunOperations = state.overlap === "allow" ? [] : [{ type: "put", key: KEYS.scheduleRun(workflowId), value: encode(state.id) }], resolution = await resolveScheduledRunServices(internals, workflowId, state, occurrence);
   if (resolution !== null) {
     scheduleRunOperations.push({ type: "put", key: KEYS.workflowHasServices(workflowId), value: EMPTY_STORAGE_VALUE }, { type: "put", key: KEYS.terminalCleanupNeeded(workflowId), value: EMPTY_STORAGE_VALUE });
     internals.workflowsNeedingTerminalCleanup.add(workflowId);
@@ -23,12 +23,21 @@ export async function startScheduledRun(internals, state, callbacks, occurrence)
   }
   return workflowId;
 }
-async function resolveScheduledRunServices(internals, workflowId, state) {
+async function resolveScheduledRunServices(internals, workflowId, state, occurrence) {
   const resolver = internals.options.resolveWorkflowServices;
   if (internals.inlineStrategy === null || !resolver)
     return null;
   try {
-    return await resolver({ workflowId, workflowType: state.workflowType, input: state.input });
+    return await resolver({
+      workflowId,
+      workflowType: state.workflowType,
+      input: state.input,
+      launchOptions: { id: workflowId },
+      schedule: {
+        id: state.id,
+        ...occurrence !== void 0 ? { occurrence } : {}
+      }
+    });
   } catch (error) {
     return {
       status: "unavailable",

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/storage-io.js

@@ -52,7 +52,7 @@ export async function loadWorkflowResult(internals, workflowId) {
     throw Error("Workflow cancelled");
   if (state.status === "timed-out") {
     const elapsed = state.executionDeadline ? state.executionDeadline - getWorkflowExecutionStartedAt(state) : 0;
-    throw new WorkflowTimeoutError(workflowId, "execution", elapsed);
+    throw new WorkflowTimeoutError(workflowId, "execution", elapsed, state.terminationReason);
   }
   throw Error(`Workflow "${workflowId}" is still ${state.status}`);
 }
@@ -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/complete.js

@@ -86,7 +86,7 @@ export async function terminateWorkflow(internals, workflowId, status, callbacks
     callbacks.swallowPromiseRejection(internals.scheduler.cancel(`deadline:${workflowId}`, workflowId));
     if (previousState.status === "pending")
       callbacks.swallowPromiseRejection(internals.scheduler.cancel(`delayed-start:${workflowId}`, workflowId));
-    const resolver = internals.resultResolvers.get(workflowId), terminalError = buildTerminalError(workflowId, status, elapsed);
+    const resolver = internals.resultResolvers.get(workflowId), terminalError = buildTerminalError(workflowId, status, elapsed, reason);
     try {
       await cleanupTerminalWorkflowSynchronously(internals, workflowId, !0, callbacks);
       const event = buildTerminalEvent(workflowId, status, elapsed, reason);
@@ -106,8 +106,8 @@ export async function terminateWorkflow(internals, workflowId, status, callbacks
     internals.terminalizingWorkflows.delete(workflowId);
   }
 }
-function buildTerminalError(workflowId, status, elapsed) {
-  return status === "timed-out" ? new WorkflowTimeoutError(workflowId, "execution", elapsed) : Error("Workflow cancelled");
+function buildTerminalError(workflowId, status, elapsed, reason) {
+  return status === "timed-out" ? new WorkflowTimeoutError(workflowId, "execution", elapsed, reason) : Error("Workflow cancelled");
 }
 function buildTerminalEvent(workflowId, status, elapsed, reason) {
   return status === "timed-out" ? new WorkflowTimedOutEvent(workflowId, "execution", elapsed, reason) : new WorkflowCancelledEvent(workflowId);

package/dist/core/json.js

@@ -33,7 +33,7 @@ function isJSONPrimitive(value) {
   if (value === null)
     return !0;
   if (typeof value === "number")
-    return Number.isFinite(value);
+    return Number.isFinite(value) && !Object.is(value, -0);
   return typeof value === "string" || typeof value === "boolean";
 }
 function isUnsupportedJSONType(value) {