@lostgradient/weft 0.15.0 → 0.17.0

package/dist/cli-main.js

@@ -21,6 +21,7 @@ import {
   executeWorkflow,
   findCliSubcommandName,
   HELP_TEXT,
+  loadConsoleMount,
   parseCliArguments,
   removeRunLockfile,
   SCHEDULE_HELP_TEXT,
@@ -53,7 +54,7 @@ if (parsedArguments.command === "version") {
     console.log(HELP_TEXT);
     process.exit(0);
   }
-  const storage = await createStorage(parsedArguments.storage, parsedArguments.database), engine = new Engine({ storage });
+  const consoleMount = parsedArguments.console ? await loadConsoleMount() : void 0, storage = await createStorage(parsedArguments.storage, parsedArguments.database), engine = new Engine({ storage });
   if (parsedArguments.workflows) {
     const { loadRegistrationsFromModule } = await import("./diagnostics/validate.js"), { registerModuleExports } = await import("./cli/serve-registrations.js"), loaded = await loadRegistrationsFromModule(parsedArguments.workflows);
     registerModuleExports(engine, loaded.registrations, loaded.activities);
@@ -61,7 +62,8 @@ if (parsedArguments.command === "version") {
     console.log("No --workflows module provided; starting in inspect-only mode.");
   const server = serve({
     engine,
-    port: Number(parsedArguments.port)
+    port: Number(parsedArguments.port),
+    ...consoleMount
   });
   await writeRunLockfile(server.url);
   console.log(`Weft API running at ${new URL("/api/v1", server.url).href}`);

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,3 +1,4 @@
+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';
@@ -24,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';
@@ -38,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
@@ -145,6 +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 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
@@ -311,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>;
@@ -477,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
@@ -490,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);
@@ -522,6 +532,9 @@ export class Engine extends EventTarget {
       workflow: (workflowType, key, options) => new AtomicState(storage, KEYS.stateWorkflow(workflowType, key), options)
     };
   }
+  getActiveAlerts() {
+    return getInternals(this).alertManager?.activeStates ?? [];
+  }
   async#handleStrategyMessage(message) {
     return handleStrategyMessageFromInternals(getInternals(this), message, this.#createInlineParkingCallbacks());
   }
@@ -696,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),
@@ -868,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;
     /**