@lostgradient/weft 0.16.0 → 0.17.0

package/README.md

@@ -1,6 +1,6 @@
 # Weft
 
-A Bun-native durable execution engine. Current release: `0.16.0`.
+A Bun-native durable execution engine. Current release: `0.17.0`.
 
 Install the library from npm as `@lostgradient/weft`:
 

package/dist/alerting/alert-manager.d.ts

@@ -5,7 +5,7 @@
  *
  * @module alerting/alert-manager
  */
-import type { AlertState, AlertingOptions } from './types';
+import type { AlertStateSnapshot, AlertingOptions } from './types';
 /**
  * Event-driven alert manager that evaluates metric-based rules against sliding
  * time windows and fires `alert:fired` / `alert:resolved` lifecycle events.
@@ -38,9 +38,9 @@ export declare class AlertManager implements Disposable {
     constructor(target: EventTarget, options: AlertingOptions, getNow?: () => number, startBackgroundTick?: boolean);
     /** Re-evaluate every rule once, for hosts that drive maintenance explicitly. */
     tick(): void;
-    /** Get current state of all alert rules (for debugging/testing). */
-    get states(): readonly AlertState[];
-    /** Get the alert rules that are currently firing. */
-    get activeStates(): readonly AlertState[];
+    /** Get a detached snapshot of all alert rules (for debugging/testing). */
+    get states(): readonly AlertStateSnapshot[];
+    /** Get detached snapshots of the alert rules that are currently firing. */
+    get activeStates(): readonly AlertStateSnapshot[];
     [Symbol.dispose](): void;
 }

package/dist/alerting/alert-manager.js

@@ -7,6 +7,15 @@ import {
 import { parseDuration } from "../core/scheduler.js";
 import { CounterWindow, HistogramWindow } from "./sliding-window.js";
 const TICK_INTERVAL_MS = 1e4;
+function snapshotAlertState(state) {
+  return {
+    rule: { ...state.rule },
+    status: state.status,
+    currentValue: state.currentValue,
+    ...state.lastFiredAt === void 0 ? {} : { lastFiredAt: state.lastFiredAt },
+    ...state.lastResolvedAt === void 0 ? {} : { lastResolvedAt: state.lastResolvedAt }
+  };
+}
 
 export class AlertManager {
   #target;
@@ -20,21 +29,30 @@ export class AlertManager {
   #tickInterval;
   constructor(target, options, getNow = Date.now, startBackgroundTick = !0) {
     this.#target = target;
-    this.#options = options;
+    this.#options = {
+      ...options,
+      rules: options.rules.map((rule) => ({ ...rule })),
+      ...options.webhooks === void 0 ? {} : {
+        webhooks: options.webhooks.map((webhook) => ({
+          ...webhook,
+          events: [...webhook.events]
+        }))
+      }
+    };
     this.#getNow = getNow;
     this.#latestStorageSize = 0;
     this.#pendingWebhooks = new Set;
     this.#listeners = [];
     this.#states = [];
-    for (const rule of options.rules)
+    for (const rule of this.#options.rules)
       this.#states.push({
         rule,
         status: "idle",
         currentValue: 0
       });
     this.#windows = new Map;
-    for (let i = 0;i < options.rules.length; i++) {
-      const rule = options.rules[i], windowMs = rule.window ? parseDuration(rule.window) : 60000;
+    for (let i = 0;i < this.#options.rules.length; i++) {
+      const rule = this.#options.rules[i], windowMs = rule.window ? parseDuration(rule.window) : 60000;
       if (rule.metric === "workflow.failure_rate")
         this.#windows.set(i, new CounterWindow(windowMs));
       else if (rule.metric === "activity.p99_duration")
@@ -153,10 +171,10 @@ export class AlertManager {
     }
   }
   get states() {
-    return this.#states;
+    return this.#states.map(snapshotAlertState);
   }
   get activeStates() {
-    return this.#states.filter((state) => state.status === "firing");
+    return this.#states.filter((state) => state.status === "firing").map(snapshotAlertState);
   }
   [Symbol.dispose]() {
     if (this.#tickInterval !== null) {

package/dist/alerting/index.d.ts

@@ -1,2 +1,2 @@
 export { AlertManager } from './alert-manager';
-export type { AlertAction, AlertMetric, AlertRule, AlertState, AlertStatus, AlertingOptions, WebhookTarget, } from './types';
+export type { AlertAction, AlertMetric, AlertRule, AlertStateSnapshot, AlertStatus, AlertingOptions, WebhookTarget, } from './types';

package/dist/alerting/types.d.ts

@@ -6,6 +6,8 @@
  * {@link WebhookTarget} URLs.
  */
 export type AlertAction = 'log' | 'webhook';
+/** Runtime vocabulary shared by alerting types and operation schemas. */
+export declare const ALERT_METRICS: readonly ["workflow.failure_rate", "activity.p99_duration", "storage.size"];
 /**
  * Which built-in metric an {@link AlertRule} monitors.
  *
@@ -30,7 +32,7 @@ export type AlertAction = 'log' | 'webhook';
  * void rule;
  * ```
  */
-export type AlertMetric = 'workflow.failure_rate' | 'activity.p99_duration' | 'storage.size';
+export type AlertMetric = (typeof ALERT_METRICS)[number];
 /**
  * Defines a single alerting threshold applied to a named metric.
  *
@@ -124,7 +126,8 @@ export type AlertingOptions = {
  *
  * Transitions from `'idle'` to `'firing'` when the metric exceeds the
  * threshold and back to `'idle'` once the metric drops below it again.
- * Read this off an {@link AlertState} object to see the current state of a rule.
+ * Read this off an {@link AlertStateSnapshot} object to see the current state
+ * of a rule.
  *
  * @example
  * ```ts
@@ -141,17 +144,18 @@ export type AlertingOptions = {
  */
 export type AlertStatus = 'idle' | 'firing';
 /**
- * Runtime tracking state for a single {@link AlertRule} managed by
- * {@link AlertManager}.
+ * Detached, deeply read-only observation of a single alert rule's runtime
+ * state. The manager returns a fresh snapshot for every getter call, so
+ * changing it cannot affect alert evaluation.
  *
- * Users observe this shape via `AlertManager.states` to see the current
- * metric value, firing status, and timestamps of the last transition.  It is
- * created and owned by the manager — callers do not construct it directly.
+ * Users observe this shape via `AlertManager.states` or
+ * `Engine.getActiveAlerts()` to see the current metric value, firing status,
+ * and timestamps of the last transition.
  */
-export type AlertState = {
-    rule: AlertRule;
-    status: AlertStatus;
-    currentValue: number;
-    lastFiredAt?: number;
-    lastResolvedAt?: number;
+export type AlertStateSnapshot = {
+    readonly rule: Readonly<AlertRule>;
+    readonly status: AlertStatus;
+    readonly currentValue: number;
+    readonly lastFiredAt?: number;
+    readonly lastResolvedAt?: number;
 };

package/dist/alerting/types.js

@@ -0,0 +1,5 @@
+export const ALERT_METRICS = [
+  "workflow.failure_rate",
+  "activity.p99_duration",
+  "storage.size"
+];

package/dist/core/engine/disposal.js

@@ -2,6 +2,12 @@ import { disposeEngineCleanupInterval } from "./engine-runtime-helpers.js";
 import { EngineDisposedError } from "./errors.js";
 import { disposeQueuedInlineWorkflowStarts } from "./inline-launch-queue.js";
 import { rejectAllSleepTimerAcknowledgements } from "./sleep-timer-acknowledgements.js";
+function settleSleepResolverReadyWaitersForTesting(internals) {
+  for (const waiters of internals.sleepResolverReadyWaitersForTesting?.values() ?? [])
+    for (const notifyReady of waiters)
+      notifyReady();
+  internals.sleepResolverReadyWaitersForTesting?.clear();
+}
 export function disposeEngine(internals) {
   internals.disposed = !0;
   internals.alertManager?.[Symbol.dispose]();
@@ -48,6 +54,7 @@ export function disposeEngine(internals) {
   internals.pendingWebhooks.clear();
   internals.sleepResolvers.clear();
   internals.sleepResolversByWorkflow.clear();
+  settleSleepResolverReadyWaitersForTesting(internals);
   internals.sleepTimerAcknowledgementWaiters.clear();
   internals.durableInlineOperations.clear();
   internals.sleepTimersFiredWithoutResolver.clear();

package/dist/core/engine/engine-runtime-helpers.d.ts

@@ -19,7 +19,9 @@ export declare function createQueuedInlineWorkflowStartHandler<TWorkflows extend
  * `[Symbol.asyncDispose]` ahead of synchronous disposal (which aborts the signal
  * and would otherwise discard the queue).
  */
-export declare function drainQueuedInlineWorkflowStartsForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): Promise<void>;
+export declare function drainQueuedInlineWorkflowStartsForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, options?: {
+    abortStartedWorkflows?: boolean;
+}): Promise<void>;
 export declare function createCleanupIntervalTick<TWorkflows extends object, TActivities extends object>(weakEngine: WeakRef<Engine<TWorkflows, TActivities>>, tracker: EngineCleanupIntervalDisposalTracker): () => void;
 /**
  * Build the resolver the second-instance detection interval uses to find its live

package/dist/core/engine/engine-runtime-helpers.js

@@ -40,8 +40,8 @@ export function createQueuedInlineWorkflowStartHandler(weakEngine, channel) {
     swallowPromiseRejection(flushQueuedInlineWorkflowStarts(getInternals(engine), inlineLaunchQueueCallbacksForEngine(engine)));
   };
 }
-export async function drainQueuedInlineWorkflowStartsForEngine(engine) {
-  await drainQueuedInlineWorkflowStarts(getInternals(engine), inlineLaunchQueueCallbacksForEngine(engine));
+export async function drainQueuedInlineWorkflowStartsForEngine(engine, options) {
+  await drainQueuedInlineWorkflowStarts(getInternals(engine), inlineLaunchQueueCallbacksForEngine(engine), options);
 }
 export function createCleanupIntervalTick(weakEngine, tracker) {
   return function cleanupExpiredResponsesForLiveEngine() {

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

@@ -163,6 +163,26 @@ export declare class EngineCreateNameMismatchError extends WeftError<'EngineCrea
 export declare class EngineDisposedError extends WeftError<'EngineDisposedError'> {
     constructor();
 }
+/**
+ * Thrown when queued inline workflow draining fails during asynchronous engine
+ * disposal. The engine is still fully torn down, and `leaseReleased` reports
+ * whether the final fenced lease delete committed. The original drain failure
+ * is available as `cause`.
+ *
+ * @example
+ * ```ts
+ * import { EngineDisposalError } from '@lostgradient/weft';
+ *
+ * function releaseSucceeded(error: unknown): boolean {
+ *   return error instanceof EngineDisposalError && error.leaseReleased;
+ * }
+ * void releaseSucceeded;
+ * ```
+ */
+export declare class EngineDisposalError extends WeftError<'EngineDisposalError'> {
+    readonly leaseReleased: boolean;
+    constructor(cause: unknown, leaseReleased: boolean);
+}
 /**
  * Thrown by engine APIs that need a workflow to be present in storage but
  * cannot find one with the given ID. Inspect `workflowId` to identify the

package/dist/core/engine/errors.js

@@ -70,6 +70,14 @@ export class EngineDisposedError extends WeftError {
   }
 }
 
+export class EngineDisposalError extends WeftError {
+  leaseReleased;
+  constructor(cause, leaseReleased) {
+    super("EngineDisposalError", "Engine disposal failed while draining queued work", { cause });
+    this.leaseReleased = leaseReleased;
+  }
+}
+
 export class WorkflowNotFoundError extends WeftError {
   workflowId;
   constructor(workflowId) {

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

@@ -1,4 +1,4 @@
-import type { AlertState } from '../../alerting/types.ts';
+import type { AlertStateSnapshot } from '../../alerting/types.ts';
 import { type Storage as WeftStorage } from '../../storage/interface.ts';
 import { type ActivityMetadata, type ActivityRegistrationOptions, type RegisteredActivityFunction } from '../activity-registry.ts';
 import type { StoredStreamChunk } from '../context.ts';
@@ -25,7 +25,7 @@ export { ActivityReconciliationCapabilityError, ActivityReconciliationConflictEr
 export { AsyncActivityTokenNotFoundError } from './async-activity-completion.ts';
 export type { PendingAsyncActivity } from './async-activity-records.ts';
 export type { PendingTimelineEntry, RegistrationEntry, ResolvedOptions, TrackedWaiterKeys, WorkflowResultWaiter, } from './engine-internal-types.ts';
-export { ActivityResolutionError, BulkDeleteRequiresTerminalWorkflowsError, BulkOperationConfirmationError, EngineCreateNameMismatchError, EngineDisposedError, IdempotencyKeyPurgedError, PersistedDataIncompatibleError, StartOrSignalConflictError, WorkflowAlreadyExistsError, WorkflowConcurrencyLimitExceededError, WorkflowNotFoundError, WorkflowNotRegisteredError, WorkflowSuspendNotSupportedError, WorkflowTeardownPendingError, WorkflowTypeNotRegisteredForRecoveryError, } from './errors.ts';
+export { ActivityResolutionError, BulkDeleteRequiresTerminalWorkflowsError, BulkOperationConfirmationError, EngineCreateNameMismatchError, EngineDisposalError, EngineDisposedError, IdempotencyKeyPurgedError, PersistedDataIncompatibleError, StartOrSignalConflictError, WorkflowAlreadyExistsError, WorkflowConcurrencyLimitExceededError, WorkflowNotFoundError, WorkflowNotRegisteredError, WorkflowSuspendNotSupportedError, WorkflowTeardownPendingError, WorkflowTypeNotRegisteredForRecoveryError, } from './errors.ts';
 export { HANDLE_RESULT_PROMISE, WorkflowHandle } from './handles.ts';
 export { EngineLeaseAcquisitionTimeoutError, EngineLeaseCorruptedError, EngineLeaseNotHeldError, } from './lease-errors.ts';
 export type { EngineLeaseHealth, LeaseLostReason } from './lease-health.ts';
@@ -39,6 +39,30 @@ 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;
+export declare const ENGINE_WAIT_FOR_SLEEP_RESOLVER_FOR_TESTING: unique symbol;
+export declare const ENGINE_SET_WORKER_TURN_TIMEOUT_RESOLVER_FOR_TESTING: unique symbol;
+/**
+ * Bound for `ENGINE_WAIT_FOR_SLEEP_RESOLVER_FOR_TESTING`.
+ *
+ * The only production-adjacent consumer awaits that hook inside the
+ * `weft:test:periodic-sync` Service Worker message handler in
+ * service-worker-browser.test.ts, and that file bounds each message round trip
+ * at 5s (`sendWorkerMessage`), each phase at 15s or whatever remains of the
+ * test budget, and each test at 30s. This bound has to be strictly tighter than
+ * the innermost of those — at 5s it would tie with the message bound and the
+ * generic "Service Worker message timed out" could win the race, hiding the
+ * diagnostic this bound exists to produce. 3s expires first, and the handler
+ * posts the rejection back over the port so the workflow-naming error is what
+ * reaches CI.
+ *
+ * The ordering holds whenever the phase bound is the 15s ceiling. It cannot
+ * hold once a test has burned all but a few seconds of its 30s budget, because
+ * no inner window survives an outer bound shorter than itself. That case is
+ * reported rather than papered over: the phase error says the bound was
+ * shortened by the remaining budget and that a nested timeout may have been
+ * preempted, which points at the earlier phases that actually consumed it.
+ */
+export declare const SLEEP_RESOLVER_READY_WAIT_TIMEOUT_MS_FOR_TESTING = 3000;
 /**
  * The `name` of the `process` warning emitted when a lease-owning engine is
  * disposed through the synchronous `[Symbol.dispose]()` path. Sync disposal can
@@ -146,8 +170,8 @@ export declare class Engine<TWorkflows extends object = DefaultWorkflowRegistry,
     removeEventListener<K extends Extract<keyof WeftEventMap, string>>(type: K, listener: (event: WeftEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
     removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
     get state(): EngineStateNamespace;
-    /** Return the alert rules that are currently firing. */
-    getActiveAlerts(): readonly AlertState[];
+    /** Return detached snapshots of the alert rules that are currently firing. */
+    getActiveAlerts(): readonly AlertStateSnapshot[];
     /**
      * Register a workflow by name or definition, or register an activity
      * definition. Definition overloads return this same engine with the
@@ -314,6 +338,11 @@ export declare class Engine<TWorkflows extends object = DefaultWorkflowRegistry,
     [ENGINE_PARKED_WORKFLOW_COUNT_FOR_TESTING](): number;
     [ENGINE_SIGNAL_WAITER_COUNT_FOR_TESTING](): number;
     [ENGINE_SLEEP_RESOLVER_COUNT_FOR_TESTING](): number;
+    [ENGINE_WAIT_FOR_SLEEP_RESOLVER_FOR_TESTING](workflowId: string): Promise<void>;
+    [ENGINE_SET_WORKER_TURN_TIMEOUT_RESOLVER_FOR_TESTING](resolver: (turn: {
+        workflowId: string;
+        kind: 'run' | 'resume';
+    }) => number): void;
     signal(workflowId: string, name: SignalDefinition): Promise<void>;
     signal<TInput>(workflowId: string, name: SignalDefinition<TInput>, payload: TInput, options?: SignalDeliveryOptions): Promise<void>;
     signal(workflowId: string, name: string, payload?: unknown, options?: SignalDeliveryOptions): Promise<void>;
@@ -480,11 +509,13 @@ export declare class Engine<TWorkflows extends object = DefaultWorkflowRegistry,
      *
      * 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.
+     * lease release before resolving. The returned boolean is `true` when no lease
+     * needed release or the holder delete committed, and `false` when the delete
+     * did not commit. 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>;
+    shutdown(): Promise<boolean>;
     /**
      * Synchronous teardown (`using engine = ...`). Pending inline launches that
      * have not yet run are **discarded**, not executed. When you need queued
@@ -493,15 +524,6 @@ export declare class Engine<TWorkflows extends object = DefaultWorkflowRegistry,
      * via `await using`.
      */
     [Symbol.dispose](): void;
-    /**
-     * Async teardown (`await using engine = ...`). Drains pending inline launches
-     * so each queued workflow completes its first turn before disposal, leaving no
-     * deferred-launch macrotask to fire against torn-down state. The drain is
-     * bounded (a pass cap and the abort signal); in the pathological case where it
-     * cannot converge, anything still queued is discarded by the synchronous
-     * teardown that always follows. Prefer this over the synchronous
-     * {@link Engine[Symbol.dispose]} in async contexts and tests.
-     */
     [Symbol.asyncDispose](): Promise<void>;
     get storage(): WeftStorage;
     get scheduler(): Scheduler;

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