@lostgradient/weft 0.16.0 → 0.18.0

package/dist/core/engine/index.js

@@ -79,6 +79,7 @@ import {
 } from "./engine-runtime-helpers.js";
 import {
   EngineCreateNameMismatchError,
+  EngineDisposalError,
   EngineDisposedError,
   StartOrSignalConflictError
 } from "./errors.js";
@@ -194,6 +195,7 @@ export {
   BulkDeleteRequiresTerminalWorkflowsError,
   BulkOperationConfirmationError,
   EngineCreateNameMismatchError,
+  EngineDisposalError,
   EngineDisposedError,
   IdempotencyKeyPurgedError,
   PersistedDataIncompatibleError,
@@ -222,7 +224,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"), ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME = "WeftEngineLeaseSynchronousDisposeWarning";
+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_WAIT_FOR_SLEEP_RESOLVER_FOR_TESTING = Symbol("engineWaitForSleepResolverForTesting"), ENGINE_SET_WORKER_TURN_TIMEOUT_RESOLVER_FOR_TESTING = Symbol("engineSetWorkerTurnTimeoutResolverForTesting"), SLEEP_RESOLVER_READY_WAIT_TIMEOUT_MS_FOR_TESTING = 3000, ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME = "WeftEngineLeaseSynchronousDisposeWarning";
 
 export { ENGINE_LEASE_LOST_WARNING_NAME };
 function scheduleDefinitionFromInternals(internals, definition) {
@@ -237,6 +239,9 @@ function scheduleDefinitionFromInternals(internals, definition) {
 }
 
 export class Engine extends EventTarget {
+  #asyncDisposeResult = null;
+  #shutdownResult = null;
+  #synchronousDisposeResult = null;
   static async create(options) {
     validateEngineCreateBackgroundTaskOptions(options);
     const engine = new Engine(options);
@@ -294,6 +299,7 @@ export class Engine extends EventTarget {
     getInternals(this).updateWaitersByWorkflow = new Map;
     getInternals(this).sleepResolvers = new Map;
     getInternals(this).sleepResolversByWorkflow = new Map;
+    getInternals(this).sleepResolverReadyWaitersForTesting = new Map;
     getInternals(this).sleepTimerAcknowledgementWaiters = new Map;
     getInternals(this).durableInlineOperations = new Map;
     getInternals(this).sleepTimersFiredWithoutResolver = new Map;
@@ -434,7 +440,9 @@ export class Engine extends EventTarget {
         throw error;
       }
       if (internals.disposed) {
-        await manager.release();
+        const releaseResult = manager.release();
+        this.#synchronousDisposeResult = releaseResult;
+        await releaseResult;
         if (internals.leaseManager === manager)
           internals.leaseManager = null;
         throw new EngineDisposedError;
@@ -455,7 +463,9 @@ export class Engine extends EventTarget {
       return;
     const leaseManager = internals.leaseManager;
     disposeEngine(internals);
-    leaseManager?.release().catch(() => {});
+    if (this.#synchronousDisposeResult === null)
+      this.#synchronousDisposeResult = (leaseManager?.release() ?? Promise.resolve(!0)).catch(() => !1);
+    this.#synchronousDisposeResult;
   }
   #startSecondInstanceDetection() {
     const internals = getInternals(this);
@@ -699,6 +709,34 @@ export class Engine extends EventTarget {
   [ENGINE_SLEEP_RESOLVER_COUNT_FOR_TESTING]() {
     return getInternals(this).sleepResolvers.size;
   }
+  async[ENGINE_WAIT_FOR_SLEEP_RESOLVER_FOR_TESTING](workflowId) {
+    const internals = getInternals(this);
+    if (internals.sleepResolversByWorkflow.has(workflowId))
+      return;
+    const { promise, resolve, reject } = Promise.withResolvers();
+    let waiters = internals.sleepResolverReadyWaitersForTesting?.get(workflowId);
+    if (waiters === void 0) {
+      waiters = new Set;
+      internals.sleepResolverReadyWaitersForTesting?.set(workflowId, waiters);
+    }
+    waiters.add(resolve);
+    const expiry = setTimeout(() => {
+      const pendingWaiters = internals.sleepResolverReadyWaitersForTesting?.get(workflowId);
+      if (pendingWaiters !== void 0) {
+        pendingWaiters.delete(resolve);
+        if (pendingWaiters.size === 0)
+          internals.sleepResolverReadyWaitersForTesting?.delete(workflowId);
+      }
+      reject(Error(`Timed out after ${SLEEP_RESOLVER_READY_WAIT_TIMEOUT_MS_FOR_TESTING}ms waiting for workflow "${workflowId}" to register a sleep resolver`));
+    }, SLEEP_RESOLVER_READY_WAIT_TIMEOUT_MS_FOR_TESTING);
+    return await promise.finally(() => clearTimeout(expiry));
+  }
+  [ENGINE_SET_WORKER_TURN_TIMEOUT_RESOLVER_FOR_TESTING](resolver) {
+    const strategy = getInternals(this).strategy;
+    if (strategy.setWorkflowTurnTimeoutResolverForTesting === void 0)
+      throw Error("Worker turn timeout resolver is only available in Worker execution mode");
+    strategy.setWorkflowTurnTimeoutResolverForTesting(resolver);
+  }
   async signal(workflowId, nameOrDefinition, payload, options) {
     return signalWorkflow(getInternals(this), workflowId, messageName(nameOrDefinition), payload, {
       loadWorkflowState: (id) => loadWorkflowState(getInternals(this), id),
@@ -871,28 +909,62 @@ export class Engine extends EventTarget {
     return submitCoordinatedUpdateFromInternals(getInternals(this), workflowId, name, payload, options, this.#createUpdateCallbacks());
   }
   async shutdown() {
-    return this[Symbol.asyncDispose]();
+    if (this.#shutdownResult === null)
+      this.#shutdownResult = (async () => {
+        await this[Symbol.asyncDispose]();
+        const baseResult = this.#asyncDisposeResult;
+        if (baseResult === null) {
+          await getInternals(this).inFlightLeaseAcquire?.catch(() => {});
+          return await this.#synchronousDisposeResult ?? !0;
+        }
+        try {
+          return await baseResult;
+        } catch (error) {
+          return error instanceof EngineDisposalError ? error.leaseReleased : !0;
+        }
+      })();
+    return this.#shutdownResult;
   }
   [Symbol.dispose]() {
+    if (this.#asyncDisposeResult !== null) {
+      this.#asyncDisposeResult;
+      return;
+    }
     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();
+    if (this.#synchronousDisposeResult === null)
+      this.#synchronousDisposeResult = leaseManager?.release() ?? Promise.resolve(!0);
+    this.#synchronousDisposeResult;
   }
-  async[Symbol.asyncDispose]() {
+  async#disposeAsyncWithLeaseResult() {
     if (!getInternals(this).disposed) {
       const leaseManager = getInternals(this).leaseManager;
+      let leaseReleased = !0, drainFailure = null;
       try {
-        await drainQueuedInlineWorkflowStartsForEngine(this);
+        await drainQueuedInlineWorkflowStartsForEngine(this, {
+          abortStartedWorkflows: !0
+        });
+      } catch (error) {
+        drainFailure = { error };
       } finally {
         disposeEngine(getInternals(this));
         await getInternals(this).inFlightLeaseAcquire?.catch(() => {});
-        await leaseManager?.release();
+        leaseReleased = await (this.#synchronousDisposeResult ?? leaseManager?.release() ?? Promise.resolve(!0));
       }
-      return;
+      if (drainFailure !== null)
+        throw new EngineDisposalError(drainFailure.error, leaseReleased);
+      return leaseReleased;
     }
     this[Symbol.dispose]();
+    await getInternals(this).inFlightLeaseAcquire?.catch(() => {});
+    return await this.#synchronousDisposeResult ?? !0;
+  }
+  async[Symbol.asyncDispose]() {
+    if (this.#asyncDisposeResult === null)
+      this.#asyncDisposeResult = this.#disposeAsyncWithLeaseResult();
+    await this.#asyncDisposeResult;
   }
   get storage() {
     return getInternals(this).storage;

package/dist/core/engine/inline-launch-queue.d.ts

@@ -6,7 +6,9 @@ export type InlineLaunchQueueCallbacks = {
 };
 /** Queue a new inline workflow start and schedule a flush if one is not already scheduled. */
 export declare function queueInlineWorkflowExecutionStart(internals: EngineInternals, start: QueuedInlineWorkflowExecutionStart, callbacks: InlineLaunchQueueCallbacks): void;
-export declare function flushQueuedInlineWorkflowStarts(internals: EngineInternals, callbacks: InlineLaunchQueueCallbacks): Promise<void>;
+export declare function flushQueuedInlineWorkflowStarts(internals: EngineInternals, callbacks: InlineLaunchQueueCallbacks, options?: {
+    abortStartedWorkflows?: boolean;
+}): Promise<void>;
 /** Used by scheduler-driven direct backfill flushes. Clears the scheduled flag first. */
 export declare function flushQueuedInlineWorkflowStartsDirectly(internals: EngineInternals, callbacks: InlineLaunchQueueCallbacks): Promise<void>;
 /**
@@ -22,7 +24,9 @@ export declare function flushQueuedInlineWorkflowStartsDirectly(internals: Engin
  * is left for the synchronous `disposeQueuedInlineWorkflowStarts` path, which
  * discards it and settles its `defer: false` awaiter.
  */
-export declare function drainQueuedInlineWorkflowStarts(internals: EngineInternals, callbacks: InlineLaunchQueueCallbacks): Promise<void>;
+export declare function drainQueuedInlineWorkflowStarts(internals: EngineInternals, callbacks: InlineLaunchQueueCallbacks, options?: {
+    abortStartedWorkflows?: boolean;
+}): Promise<void>;
 export declare function dropQueuedInlineWorkflowStart(internals: EngineInternals, workflowId: string): boolean;
 export declare function disposeQueuedInlineWorkflowStarts(internals: EngineInternals): void;
 export declare function hasQueuedInlineWorkflowStart(internals: EngineInternals, workflowId: string): boolean;

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

@@ -1,6 +1,21 @@
 import { WorkflowStartedEvent } from "../events.js";
 import { startWorkflowExecution } from "./lifecycle.js";
 import { loadWorkflowState } from "./storage-io.js";
+async function yieldQueuedShutdownAdvanceOpportunity() {
+  await new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+}
+async function settleQueuedShutdownWork(pendingWork) {
+  if (pendingWork.length === 0)
+    return [];
+  const opportunityElapsed = yieldQueuedShutdownAdvanceOpportunity().then(() => !1);
+  return (await Promise.all(pendingWork.map(async ({ workflowId, promise }) => {
+    if (promise === void 0)
+      return workflowId;
+    return await Promise.race([promise.then(() => !0), opportunityElapsed]) ? workflowId : null;
+  }))).filter((workflowId) => workflowId !== null);
+}
 export function queueInlineWorkflowExecutionStart(internals, start, callbacks) {
   internals.queuedInlineWorkflowStartIds.add(start.workflowId);
   internals.queuedOrLaunchingInlineWorkflowStartIds.add(start.workflowId);
@@ -24,7 +39,7 @@ function settleDiscardedInlineStarts(internals, discarded) {
     start.onStarted?.();
   }
 }
-export async function flushQueuedInlineWorkflowStarts(internals, callbacks) {
+export async function flushQueuedInlineWorkflowStarts(internals, callbacks, options) {
   if (internals.abortController.signal.aborted) {
     const discarded = internals.queuedInlineWorkflowStarts;
     internals.queuedInlineWorkflowStarts = [];
@@ -36,22 +51,39 @@ export async function flushQueuedInlineWorkflowStarts(internals, callbacks) {
   const pendingStarts = internals.queuedInlineWorkflowStarts;
   internals.queuedInlineWorkflowStarts = [];
   for (const start of pendingStarts)
-    await callbacks.swallowPromiseRejection(startQueuedInlineWorkflowExecution(internals, start, callbacks));
+    await callbacks.swallowPromiseRejection(startQueuedInlineWorkflowExecution(internals, start, callbacks, options));
 }
 export async function flushQueuedInlineWorkflowStartsDirectly(internals, callbacks) {
   internals.queuedInlineWorkflowStartFlushScheduled = !1;
   await flushQueuedInlineWorkflowStarts(internals, callbacks);
 }
-export async function drainQueuedInlineWorkflowStarts(internals, callbacks) {
+export async function drainQueuedInlineWorkflowStarts(internals, callbacks, options) {
   internals.queuedInlineWorkflowStartFlushScheduled = !1;
   let passes = 0;
   const maxPasses = 1000;
   while (internals.queuedInlineWorkflowStarts.length > 0 && !internals.abortController.signal.aborted && passes < maxPasses) {
     passes += 1;
-    await callbacks.swallowPromiseRejection(flushQueuedInlineWorkflowStarts(internals, callbacks));
+    const workflowIds = internals.queuedInlineWorkflowStarts.map((start) => start.workflowId);
+    await callbacks.swallowPromiseRejection(flushQueuedInlineWorkflowStarts(internals, callbacks, options));
+    const pendingAdvances = workflowIds.map((workflowId) => {
+      const pendingAdvance = internals.inlineStrategy?.waitForWorkflowAdvance(workflowId);
+      return {
+        workflowId,
+        promise: pendingAdvance === void 0 ? void 0 : callbacks.swallowPromiseRejection(pendingAdvance)
+      };
+    }), settledWorkflowIds = await settleQueuedShutdownWork(pendingAdvances);
+    if (settledWorkflowIds.length > 0) {
+      const terminalTurns = settledWorkflowIds.flatMap((workflowId) => {
+        if (internals.inlineStrategy?.hasGenerator(workflowId))
+          return [];
+        const pendingTurn = internals.inlineStrategy?.waitForWorkflowTurn(workflowId);
+        return pendingTurn === void 0 ? [] : [callbacks.swallowPromiseRejection(pendingTurn)];
+      });
+      await Promise.all(terminalTurns);
+    }
   }
 }
-async function startQueuedInlineWorkflowExecution(internals, start, callbacks) {
+async function startQueuedInlineWorkflowExecution(internals, start, callbacks, options) {
   try {
     const state = await loadWorkflowState(internals, start.workflowId);
     if (!state || state.status !== "running")
@@ -59,7 +91,10 @@ async function startQueuedInlineWorkflowExecution(internals, start, callbacks) {
     internals.queuedInlineWorkflowStartIds.delete(start.workflowId);
     internals.engine.dispatchEvent(new WorkflowStartedEvent(start.workflowId, start.workflowType, start.input));
     startWorkflowExecution(internals, start.workflowId, state.workflowExecutionToken, start.workflowType, start.input, start.checkpoint, start.nestingDepth, start.executionDeadline, start.executionStateOwnerId);
-    await callbacks.processPendingUpdatesAfterInlineAdvance(start.workflowId);
+    if (options?.abortStartedWorkflows === !0)
+      internals.inlineStrategy?.abortWorkflowAdvanceForShutdown(start.workflowId);
+    else
+      await callbacks.processPendingUpdatesAfterInlineAdvance(start.workflowId);
   } finally {
     internals.queuedInlineWorkflowStartIds.delete(start.workflowId);
     internals.queuedOrLaunchingInlineWorkflowStartIds.delete(start.workflowId);

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

@@ -114,6 +114,8 @@ export interface EngineInternals {
         fireAt: number;
     }>;
     sleepResolversByWorkflow: Map<string, Set<string>>;
+    /** Test-only event waiters notified when a workflow registers a sleep resolver. */
+    sleepResolverReadyWaitersForTesting?: Map<string, Set<() => void>>;
     /**
      * Fired sleep timers awaiting proof that the awakened inline workflow reached
      * its next durable checkpoint or terminal state. External schedulers must not

package/dist/core/engine/lease-manager.d.ts

@@ -95,7 +95,8 @@ export type LeaseManagerOptions = {
  * - `currentEpochBytes()` returns the held epoch as bytes for Step-2 fencing
  *   conditions; `null` before a successful acquire. Synchronous and stable across
  *   renewals.
- * - `release()` best-effort relinquishes the lease (holder key only) on dispose.
+ * - `release()` best-effort relinquishes the lease (holder key only) on dispose
+ *   and resolves to whether the holder delete committed.
  */
 export type LeaseManager = {
     acquire(): Promise<void>;
@@ -104,7 +105,7 @@ export type LeaseManager = {
     currentEpochBytes(): Uint8Array | null;
     /** Return a defensive, synchronous view of this process's last-known lease state. */
     health(): LeaseManagerHealth;
-    release(): Promise<void>;
+    release(): Promise<boolean>;
     stop(): void;
 };
 /**

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

@@ -149,11 +149,15 @@ export function createLeaseManager(options) {
     if (inFlightRenewal !== null)
       await inFlightRenewal;
     if (lastHolderBytes === null)
-      return;
+      return !0;
     try {
-      if (await storageConditionalBatch(storage, [{ key: KEYS.leaseHolder(), expectedValue: lastHolderBytes }], [{ type: "delete", key: KEYS.leaseHolder() }]))
+      const deleted = await storageConditionalBatch(storage, [{ key: KEYS.leaseHolder(), expectedValue: lastHolderBytes }], [{ type: "delete", key: KEYS.leaseHolder() }]);
+      if (deleted)
         lastHolderBytes = null;
-    } catch {}
+      return deleted;
+    } catch {
+      return !1;
+    }
   }
   function stop() {
     stopped = !0;

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

@@ -71,6 +71,12 @@ export function registerSleepResolver(internals, workflowId, operationId, resolv
     internals.sleepResolversByWorkflow.set(workflowId, workflowOperations);
   }
   workflowOperations.add(operationId);
+  const readinessWaiters = internals.sleepResolverReadyWaitersForTesting?.get(workflowId);
+  if (readinessWaiters !== void 0) {
+    internals.sleepResolverReadyWaitersForTesting?.delete(workflowId);
+    for (const notifyReady of readinessWaiters)
+      notifyReady();
+  }
 }
 export async function startDelayedWorkflow(internals, entry, callbacks) {
   const state = await callbacks.loadWorkflowState(entry.workflowId);

package/dist/core/execution-strategy.d.ts

@@ -71,6 +71,14 @@
  */
 import type { OperationOutcome, WorkerOutboundMessage } from './types.ts';
 export interface ExecutionStrategy extends Disposable, AsyncDisposable {
+    /**
+     * Internal test seam for selecting a load-tolerant timeout around one
+     * intentionally wedged Worker turn. Production construction never sets it.
+     */
+    setWorkflowTurnTimeoutResolverForTesting?: (resolver: (turn: {
+        workflowId: string;
+        kind: 'run' | 'resume';
+    }) => number) => void;
     /**
      * Start a new workflow execution from the beginning.
      */

package/dist/core/inline-execution-strategy.d.ts

@@ -53,6 +53,7 @@ export declare class InlineExecutionStrategy implements ExecutionStrategy {
     clearParkedContext(workflowId: string): void;
     getAbortController(workflowId: string): AbortController | undefined;
     waitForWorkflowTurn(workflowId: string): Promise<void> | undefined;
+    abortWorkflowAdvanceForShutdown(workflowId: string): void;
     waitForWorkflowAdvance(workflowId: string): Promise<void> | undefined;
     hasGenerator(workflowId: string): boolean;
     /**

package/dist/core/inline-execution-strategy.js

@@ -13,6 +13,7 @@ export class InlineExecutionStrategy {
   #parkedContexts;
   #workflowAdvances;
   #workflowTurns;
+  #shutdownAbortedWorkflowIds;
   #messageHandler;
   constructor(dependencies) {
     this.#dependencies = dependencies;
@@ -22,6 +23,7 @@ export class InlineExecutionStrategy {
     this.#parkedContexts = new Map;
     this.#workflowAdvances = new Map;
     this.#workflowTurns = new Map;
+    this.#shutdownAbortedWorkflowIds = new Set;
     this.#messageHandler = null;
   }
   onMessage(handler) {
@@ -91,6 +93,10 @@ export class InlineExecutionStrategy {
   waitForWorkflowTurn(workflowId) {
     return this.#workflowTurns.get(workflowId);
   }
+  abortWorkflowAdvanceForShutdown(workflowId) {
+    this.#shutdownAbortedWorkflowIds.add(workflowId);
+    this.#abortControllers.get(workflowId)?.abort();
+  }
   waitForWorkflowAdvance(workflowId) {
     return this.#workflowAdvances.get(workflowId);
   }
@@ -122,6 +128,7 @@ export class InlineExecutionStrategy {
     this.#parkedContexts.clear();
     this.#workflowAdvances.clear();
     this.#workflowTurns.clear();
+    this.#shutdownAbortedWorkflowIds.clear();
     this.#messageHandler = null;
   }
   async[Symbol.asyncDispose]() {
@@ -138,26 +145,7 @@ export class InlineExecutionStrategy {
       try {
         if (this.#abortControllers.get(workflowId)?.signal.aborted)
           return;
-        const iterationResult = await advance();
-        if (iterationResult.done) {
-          this.#cleanup(workflowId, {
-            preserveTrackedAdvance: !0,
-            preserveTrackedTurn: !0
-          });
-          this.#emit({
-            type: "completed",
-            workflowId,
-            result: iterationResult.value
-          });
-          return;
-        }
-        const operation = iterationResult.value;
-        this.#emit({
-          type: "checkpoint",
-          workflowId,
-          checkpoint: new ArrayBuffer(0),
-          operationRequest: operation
-        });
+        this.#handleIterationResult(workflowId, await advance());
       } catch (error) {
         this.#cleanup(workflowId, {
           preserveTrackedAdvance: !0,
@@ -177,6 +165,30 @@ export class InlineExecutionStrategy {
       }
     })());
   }
+  #handleIterationResult(workflowId, iterationResult) {
+    const shutdownAborted = this.#shutdownAbortedWorkflowIds.delete(workflowId);
+    if (!iterationResult.done && shutdownAborted)
+      return;
+    if (iterationResult.done) {
+      this.#cleanup(workflowId, {
+        preserveTrackedAdvance: !0,
+        preserveTrackedTurn: !0
+      });
+      this.#emit({
+        type: "completed",
+        workflowId,
+        result: iterationResult.value
+      });
+      return;
+    }
+    const operation = iterationResult.value;
+    this.#emit({
+      type: "checkpoint",
+      workflowId,
+      checkpoint: new ArrayBuffer(0),
+      operationRequest: operation
+    });
+  }
   #trackWorkflowAdvance(workflowId, pendingAdvance) {
     const trackedAdvance = pendingAdvance.finally(() => {
       if (this.#workflowAdvances.get(workflowId) === trackedAdvance)
@@ -212,5 +224,6 @@ export class InlineExecutionStrategy {
       this.#workflowAdvances.delete(workflowId);
     if (!options?.preserveTrackedTurn)
       this.#workflowTurns.delete(workflowId);
+    this.#shutdownAbortedWorkflowIds.delete(workflowId);
   }
 }

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' | 'DurableActivityScopeError' | 'DurableActivityUnsupportedError' | 'AsyncActivityTokenNotFoundError' | 'ActivityScheduleToCloseTimeoutError' | 'ActivityPerAttemptTimeoutError' | 'PayloadSizeExceededError' | 'StartOrSignalConflictError' | 'WorkflowTeardownPendingError' | 'IdempotencyKeyPurgedError';
+export type WeftErrorCode = 'WorkflowAlreadyExistsError' | 'BulkDeleteRequiresTerminalWorkflowsError' | 'BulkOperationConfirmationError' | 'WorkflowTypeNotRegisteredForRecoveryError' | 'EngineCreateNameMismatchError' | 'EngineDisposedError' | 'EngineDisposalError' | '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

@@ -13,6 +13,7 @@ const publicWeftErrorCodeMap = {
   WorkflowTypeNotRegisteredForRecoveryError: !0,
   EngineCreateNameMismatchError: !0,
   EngineDisposedError: !0,
+  EngineDisposalError: !0,
   WorkflowNotFoundError: !0,
   WorkflowNotRegisteredError: !0,
   WorkflowConcurrencyLimitExceededError: !0,

package/dist/core/worker-execution-strategy.d.ts

@@ -2,10 +2,12 @@ import type { WorkerPool } from '../workers/pool.ts';
 import type { ExecutionStrategy } from './execution-strategy.ts';
 import type { OperationOutcome, WorkerOutboundMessage } from './types.ts';
 import type { WorkerExecutionStrategyOptions } from './worker-execution-strategy-options.ts';
+import { type WorkerTurnTimeoutResolverForTesting } from './worker-turn-watchdog.ts';
 export declare class WorkerExecutionStrategy implements ExecutionStrategy {
     #private;
     constructor(pool: WorkerPool, options?: WorkerExecutionStrategyOptions);
     onMessage(handler: (message: WorkerOutboundMessage) => void | Promise<void>): void;
+    setWorkflowTurnTimeoutResolverForTesting(resolver: WorkerTurnTimeoutResolverForTesting): void;
     startWorkflow(parameters: {
         workflowId: string;
         workflowExecutionToken?: string;

package/dist/core/worker-execution-strategy.js

@@ -16,7 +16,9 @@ import {
 import { WorkerProtocolGuard } from "./worker-protocol-guard.js";
 import { isWorkerLogMessage } from "./worker-protocol-log.js";
 import { WORKER_PROTOCOL_VERSION } from "./worker-protocol.js";
-import { WorkerTurnWatchdog } from "./worker-turn-watchdog.js";
+import {
+  WorkerTurnWatchdog
+} from "./worker-turn-watchdog.js";
 
 export class WorkerExecutionStrategy {
   #pool;
@@ -99,6 +101,9 @@ export class WorkerExecutionStrategy {
   onMessage(handler) {
     this.#messageHandler = handler;
   }
+  setWorkflowTurnTimeoutResolverForTesting(resolver) {
+    this.#turnWatchdog.setTimeoutResolverForTesting(resolver);
+  }
   startWorkflow(parameters) {
     this.#ownership.resetWorkflow(parameters.workflowId);
     this.#checkpointResumeState.resetWorkflow(parameters.workflowId);
@@ -315,7 +320,7 @@ export class WorkerExecutionStrategy {
     this.#discardWorkerAndFailWorkflows(turn.worker, {
       targetWorkflowId: turn.workflowId,
       targetCategory: "timeout",
-      targetError: `Worker workflow turn timed out after ${this.#workflowTurnTimeoutMs}ms`,
+      targetError: `Worker workflow turn timed out after ${turn.timeoutMs}ms`,
       otherCategory: "timeout",
       otherError: `Worker discarded after workflow turn timed out: ${turn.workflowId}`
     });

package/dist/core/worker-turn-watchdog.d.ts

@@ -3,11 +3,14 @@ export interface WorkerTurnState {
     workflowId: string;
     turnId: number;
     kind: 'run' | 'resume';
+    timeoutMs: number | undefined;
 }
+export type WorkerTurnTimeoutResolverForTesting = (turn: Pick<WorkerTurnState, 'workflowId' | 'kind'>) => number;
 export declare class WorkerTurnWatchdog {
     #private;
     constructor(timeoutMs: number | undefined, onTimeout: (turn: WorkerTurnState) => void);
-    begin(worker: Worker, workflowId: string, turnId: number, kind: WorkerTurnState['kind']): void;
+    begin(worker: Worker, workflowId: string, turnId: number, kind: WorkerTurnState['kind'], timeoutMs?: number | undefined): void;
+    setTimeoutResolverForTesting(resolver: WorkerTurnTimeoutResolverForTesting): void;
     clear(worker: Worker): void;
     clearAll(): void;
     get(worker: Worker): WorkerTurnState | undefined;

package/dist/core/worker-turn-watchdog.js

@@ -2,26 +2,31 @@ export class WorkerTurnWatchdog {
   #turnsByWorker = new Map;
   #timeoutMs;
   #onTimeout;
+  #timeoutResolverForTesting = null;
   constructor(timeoutMs, onTimeout) {
     this.#timeoutMs = timeoutMs;
     this.#onTimeout = onTimeout;
   }
-  begin(worker, workflowId, turnId, kind) {
+  begin(worker, workflowId, turnId, kind, timeoutMs = this.#timeoutMs) {
     this.clear(worker);
-    const turn = {
+    const resolvedTimeoutMs = this.#timeoutResolverForTesting?.({ workflowId, kind }) ?? timeoutMs, turn = {
       worker,
       workflowId,
       turnId,
       kind,
+      timeoutMs: resolvedTimeoutMs,
       timeout: null
     };
-    if (this.#timeoutMs !== void 0)
+    if (resolvedTimeoutMs !== void 0)
       turn.timeout = setTimeout(() => {
         if (this.#turnsByWorker.get(worker) === turn)
           this.#onTimeout(turn);
-      }, this.#timeoutMs);
+      }, resolvedTimeoutMs);
     this.#turnsByWorker.set(worker, turn);
   }
+  setTimeoutResolverForTesting(resolver) {
+    this.#timeoutResolverForTesting = resolver;
+  }
   clear(worker) {
     const turn = this.#turnsByWorker.get(worker);
     if (!turn)

package/dist/index.d.ts

@@ -21,12 +21,12 @@ export type { WeftErrorCode } from './core/weft-error.ts';
 export { FAULT_CODE_TO_FAILURE_CATEGORY, failureCategoryForFaultCode, isFaultCode, } from './core/fault-code.ts';
 export type { FaultCode } from './core/fault-code.ts';
 export { DurableActivityScopeError, DurableActivityUnsupportedError, durableActivity, } from './core/context/durable-activity.ts';
-export { ActivityReconciliationCapabilityError, ActivityReconciliationConflictError, ActivityReconciliationIndeterminateError, ActivityResolutionError, AsyncActivityTokenNotFoundError, BulkDeleteRequiresTerminalWorkflowsError, BulkOperationConfirmationError, ENGINE_LEASE_LOST_WARNING_NAME, ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME, Engine, EngineCreateNameMismatchError, EngineDisposedError, EngineLeaseAcquisitionTimeoutError, EngineLeaseCorruptedError, EngineLeaseNotHeldError, IdempotencyKeyPurgedError, PersistedDataIncompatibleError, ScheduleHandle, StartOrSignalConflictError, WorkflowAlreadyExistsError, WorkflowConcurrencyLimitExceededError, WorkflowHandle, WorkflowNotFoundError, WorkflowNotRegisteredError, WorkflowSuspendNotSupportedError, WorkflowTeardownPendingError, WorkflowTypeNotRegisteredForRecoveryError, } from './core/engine';
+export { ActivityReconciliationCapabilityError, ActivityReconciliationConflictError, ActivityReconciliationIndeterminateError, ActivityResolutionError, AsyncActivityTokenNotFoundError, BulkDeleteRequiresTerminalWorkflowsError, BulkOperationConfirmationError, ENGINE_LEASE_LOST_WARNING_NAME, ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME, Engine, EngineCreateNameMismatchError, EngineDisposalError, EngineDisposedError, EngineLeaseAcquisitionTimeoutError, EngineLeaseCorruptedError, EngineLeaseNotHeldError, IdempotencyKeyPurgedError, PersistedDataIncompatibleError, ScheduleHandle, StartOrSignalConflictError, WorkflowAlreadyExistsError, WorkflowConcurrencyLimitExceededError, WorkflowHandle, WorkflowNotFoundError, WorkflowNotRegisteredError, WorkflowSuspendNotSupportedError, WorkflowTeardownPendingError, WorkflowTypeNotRegisteredForRecoveryError, } from './core/engine';
 export type { EngineCreateOptions, EngineLeaseHealth, EngineStateNamespace, LeaseLostReason, RecoverAllOptions, RecoveredWorkflowInfo, } from './core/engine';
 export { DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD, DEFAULT_MAX_NESTING_DEPTH, DEFAULT_POLL_INTERVAL_MS, DEFAULT_RETRY_POLICY, DEFAULT_VISIBILITY_TIMEOUT_MS, HISTORY_CIRCUIT_BREAKER_REASON, WorkflowBuilderError, query, schedule, signal, update, workflow, } from './core/types';
 export type { ActivityArgsFor, ActivityCallOptions, ActivityCallable, ActivityContext, ActivityDefinition, ActivityEntryInput, ActivityFunction, ActivityMap, ActivityMapInput, ActivityObjectInput, ActivityResultFor, ActivityVerificationContext, ActivityVerificationPhase, ActivityVerificationResult, AnyActivityDefinition, AnyWorkflowDefinition, ArchiveAdapter, BuilderState, BuiltWorkflowDefinition, BulkCancelResult, BulkDeleteResult, BulkOperationAction, BulkOperationAuditEvent, BulkOperationCommitOptions, BulkOperationDryRunOptions, BulkOperationDryRunResult, BulkOperationError, BulkOperationFilterSummary, BulkOperationOptions, BulkOperationPrincipal, BulkOperationScopeSummary, BulkRetryFailedResult, BulkSignalAllCommitOptions, BulkSignalAllDryRunOptions, BulkSignalAllOptions, BulkSignalResult, BulkTagResult, Checkpoint, CheckpointState, CheckpointSummary, CompletedReviewEntry, CoordinatedUpdateResult, DefinitionSchema, Duration, EngineOptions, FailureCategory, ForkLineage, ForkOptions, HistoryPolicy, InferActivityEntries, InferActivityEntry, InferWorkflowEntries, InferWorkflowEntry, InitialBuilderState, LaunchMetadata, ListFilter, ListOptions, MarkBuilderState, NormalizeActivities, NormalizedActivityEntry, NormalizedRetentionPolicy, PaginatedResult, PayloadSizePolicy, PendingAsyncActivityInfo, PendingAsyncActivityListOptions, PendingAsyncActivityPage, PendingReviewEntry, PurgeResult, QueryDefinition, QueryMap, QueryShape, RegisteredWorkflowDefinition, RestartLineage, RetentionOverview, RetentionPolicy, RetryPolicy, ReviewDecision, ReviewListEntry, ReviewListFilter, ReviewStatus, ScheduleDefinition, ScheduleFilter, ScheduleOptions, ScheduleOverlapPolicy, ScheduleQueuedRun, ScheduleSpec, ScheduleState, ScheduleStatus, ScheduleSummary, ScheduleUpdateOptions, SearchAttributeDefinition, SearchAttributeHandle, SearchAttributeSchema, SearchAttributeValue, Serializer, SignalDefinition, SignalDeliveryOptions, SignalMap, SignalPayload, StartOptions, StartOrSignalOptions, StartOrSignalSignal, SubmitReviewOptions, TerminationReason, UpdateDefinition, UpdateMap, UpdatePayload, WorkerReplayOperationFailure, WorkerReplayOperationSignature, WorkflowAlreadyRegistered, WorkflowAtomicState, WorkflowAtomicStateOptions, WorkflowBuilder, WorkflowBuilderOptions, WorkflowConcurrencyOptions, WorkflowContext, WorkflowDefinition, WorkflowEvent, WorkflowFinalizerStatus, WorkflowFunction, WorkflowGenerator, WorkflowId, WorkflowKeyedRaceResult, WorkflowLogLevel, WorkflowLogRecord, WorkflowLogger, WorkflowRegistry, WorkflowReplay, WorkflowScheduleProvenance, WorkflowServicesResolution, WorkflowServicesResolverInfo, WorkflowServicesResolverLaunchOptions, WorkflowServicesResolverScheduleInfo, WorkflowSessionState, WorkflowSnapshot, WorkflowState, WorkflowStateNamespace, WorkflowStatus, WorkflowSummary, WorkflowTimelineEntry, WorkflowTimelineOperationDetail, WorkflowTimelineStatus, WorkflowTypeRetentionPolicy, } from './core/types';
 export { AlertManager } from './alerting/index';
-export type { AlertAction, AlertMetric, AlertRule, AlertState, AlertStatus, AlertingOptions, WebhookTarget, } from './alerting/types';
+export type { AlertAction, AlertMetric, AlertRule, AlertStateSnapshot, AlertStatus, AlertingOptions, WebhookTarget, } from './alerting/types';
 export { ActivityAsyncPendingEvent, ActivityCompletedEvent, ActivityFailedEvent, ActivityStartedEvent, AlertFiredEvent, AlertResolvedEvent, AttributesChangedEvent, CheckpointSizeWarningEvent, ConstraintViolatedEvent, DevelopmentWarningEvent, ScheduleFiredEvent, ScheduleMissedFireEvent, SignalDeliveredEvent, SignalReceivedEvent, StorageSizeReportedEvent, TaskResultDeadLetteredEvent, UpdateCompletedEvent, UpdateReceivedEvent, WorkflowCancelledEvent, WorkflowCompletedEvent, WorkflowDefinitionRegisteredEvent, WorkflowFailedEvent, WorkflowRecoverySkippedEvent, WorkflowResumedEvent, WorkflowStartedEvent, WorkflowSuspendedEvent, WorkflowTeardownEvent, WorkflowTimedOutEvent, } from './core/events';
 export type { TypedEventTarget, WeftEventMap, WorkflowRecoverySkippedReason, WorkflowTeardownStatus, } from './core/events';
 export { detectRuntime, hashBytes, hashString, sleep } from './runtime/portable';

package/dist/index.js

@@ -28,6 +28,7 @@ export {
   ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME,
   Engine,
   EngineCreateNameMismatchError,
+  EngineDisposalError,
   EngineDisposedError,
   EngineLeaseAcquisitionTimeoutError,
   EngineLeaseCorruptedError,