@lostgradient/weft 0.7.0 → 0.8.0

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

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

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

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

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

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

package/dist/core/engine/index.js

@@ -206,7 +206,7 @@ export {
   shouldEmitEngineLeakWarningForTesting
 } from "./engine-leak-warnings.js";
 export { assertCompatiblePersistedDataVersion };
-export const ENGINE_PARKED_WORKFLOW_COUNT_FOR_TESTING = Symbol("engineParkedWorkflowCountForTesting"), ENGINE_SIGNAL_WAITER_COUNT_FOR_TESTING = Symbol("engineSignalWaiterCountForTesting"), ENGINE_SLEEP_RESOLVER_COUNT_FOR_TESTING = Symbol("engineSleepResolverCountForTesting");
+export const ENGINE_PARKED_WORKFLOW_COUNT_FOR_TESTING = Symbol("engineParkedWorkflowCountForTesting"), ENGINE_SIGNAL_WAITER_COUNT_FOR_TESTING = Symbol("engineSignalWaiterCountForTesting"), ENGINE_SLEEP_RESOLVER_COUNT_FOR_TESTING = Symbol("engineSleepResolverCountForTesting"), ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME = "WeftEngineLeaseSynchronousDisposeWarning";
 
 export { ENGINE_LEASE_LOST_WARNING_NAME };
 
@@ -769,8 +769,13 @@ export class Engine extends EventTarget {
   async submitCoordinatedUpdate(workflowId, name, payload, options) {
     return submitCoordinatedUpdateFromInternals(getInternals(this), workflowId, name, payload, options, this.#createUpdateCallbacks());
   }
+  async shutdown() {
+    return this[Symbol.asyncDispose]();
+  }
   [Symbol.dispose]() {
     const leaseManager = getInternals(this).leaseManager;
+    if (leaseManager !== null && leaseManager.currentEpochBytes() !== null)
+      process.emitWarning("engine ownership lease disposed synchronously; lease release is fire-and-forget, so exiting before the release completes can make the next instance wait for leaseTtl. Use await engine.shutdown(), await using, or await engine[Symbol.asyncDispose]() for prompt rolling-deploy handoff.", ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME);
     disposeEngine(getInternals(this));
     leaseManager?.release();
   }

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

@@ -31,6 +31,7 @@ import type { Scheduler } from '../scheduler.ts';
 import type { Checkpoint, StartWorkflowOptions } from '../types.ts';
 import type { UpdateCoordinator } from '../updates.ts';
 import type { WorkflowVersionTuple } from '../workflow-version-tuple.ts';
+import type { ActivityHeartbeatKey } from './activity-heartbeat-tracking.ts';
 import type { PendingTimelineEntry, QueuedInlineWorkflowExecutionStart, RegistrationEntry, ResolvedOptions, TrackedWaiterKeys, WorkflowResultWaiter } from './engine-internal-types.ts';
 import type { EngineCleanupIntervalDisposalTracker } from './engine-leak-warnings.ts';
 import type { WorkflowHandle, WorkflowHandleEngine } from './handles.ts';
@@ -148,7 +149,7 @@ export interface EngineInternals {
      * {@link heartbeatDetails}. Inline-execution only; worker-executed activities run
      * their function out of process and never observe this.
      */
-    lastHeartbeatDetailsByStep: Map<string, Map<number, unknown>>;
+    lastHeartbeatDetailsByStep: Map<string, Map<ActivityHeartbeatKey, unknown>>;
     /**
      * Per-run, non-serialized `services` value exposed to the workflow body as
      * `ctx.services`. Set at `engine.start({ services })` and re-provided on

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

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

package/dist/core/engine/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-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

@@ -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/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) {

package/dist/core/weft-error.d.ts

@@ -25,7 +25,7 @@
  * }
  * ```
  */
-export type WeftErrorCode = 'WorkflowAlreadyExistsError' | 'BulkDeleteRequiresTerminalWorkflowsError' | 'BulkOperationConfirmationError' | 'WorkflowTypeNotRegisteredForRecoveryError' | 'EngineCreateNameMismatchError' | 'EngineDisposedError' | 'WorkflowNotFoundError' | 'WorkflowNotRegisteredError' | 'WorkflowConcurrencyLimitExceededError' | 'WorkflowSuspendNotSupportedError' | 'ActivityResolutionError' | 'BranchTopologyChangedError' | 'PersistedDataIncompatibleError' | 'WorkflowTimeoutError' | 'HttpClientError' | 'WorkerProtocolIncompatibleError' | 'UpdateTimeoutError' | 'UpdateValidationError' | 'WorkflowTerminalError' | 'WorkflowBuilderError' | 'VersionMismatchError' | 'EffectReplayConflictError' | 'ReviewTimeoutError' | 'AtomicStateConflictError' | 'StandardSchemaValidationError' | 'ActivityReconciliationCapabilityError' | 'ActivityReconciliationConflictError' | 'ActivityReconciliationIndeterminateError' | 'AsyncActivityTokenNotFoundError' | 'ActivityScheduleToCloseTimeoutError' | 'ActivityPerAttemptTimeoutError' | 'PayloadSizeExceededError' | 'StartOrSignalConflictError' | 'WorkflowTeardownPendingError' | 'IdempotencyKeyPurgedError';
+export type WeftErrorCode = 'WorkflowAlreadyExistsError' | 'BulkDeleteRequiresTerminalWorkflowsError' | 'BulkOperationConfirmationError' | 'WorkflowTypeNotRegisteredForRecoveryError' | 'EngineCreateNameMismatchError' | 'EngineDisposedError' | 'WorkflowNotFoundError' | 'WorkflowNotRegisteredError' | 'WorkflowConcurrencyLimitExceededError' | 'WorkflowSuspendNotSupportedError' | 'ActivityResolutionError' | 'BranchTopologyChangedError' | 'PersistedDataIncompatibleError' | 'WorkflowTimeoutError' | 'HttpClientError' | 'WorkerProtocolIncompatibleError' | 'UpdateTimeoutError' | 'UpdateValidationError' | 'WorkflowTerminalError' | 'WorkflowBuilderError' | 'VersionMismatchError' | 'EffectReplayConflictError' | 'ReviewTimeoutError' | 'AtomicStateConflictError' | 'StandardSchemaValidationError' | 'ActivityReconciliationCapabilityError' | 'ActivityReconciliationConflictError' | 'ActivityReconciliationIndeterminateError' | 'DurableActivityScopeError' | 'DurableActivityUnsupportedError' | 'AsyncActivityTokenNotFoundError' | 'ActivityScheduleToCloseTimeoutError' | 'ActivityPerAttemptTimeoutError' | 'PayloadSizeExceededError' | 'StartOrSignalConflictError' | 'WorkflowTeardownPendingError' | 'IdempotencyKeyPurgedError';
 /**
  * Generic abstract base for all Weft library errors. The `TCode` parameter
  * makes each subclass's `code` its own literal type; the exported base surface

package/dist/core/weft-error.js

@@ -35,6 +35,8 @@ const publicWeftErrorCodeMap = {
   ActivityReconciliationCapabilityError: !0,
   ActivityReconciliationConflictError: !0,
   ActivityReconciliationIndeterminateError: !0,
+  DurableActivityScopeError: !0,
+  DurableActivityUnsupportedError: !0,
   AsyncActivityTokenNotFoundError: !0,
   ActivityScheduleToCloseTimeoutError: !0,
   ActivityPerAttemptTimeoutError: !0,