@lostgradient/weft 0.2.1 → 0.4.0

package/dist/core/engine/index.js

@@ -1,8 +1,12 @@
-import { KEYS } from "../../storage/interface.js";
+import {
+  KEYS,
+  requireStorageCapability
+} from "../../storage/interface.js";
 import {
   ActivityRegistry
 } from "../activity-registry.js";
 import { AtomicState } from "../atomic-state.js";
+import { deserializeCheckpoint } from "../checkpoint.js";
 import { createHandleCacheFinalizer } from "../engine-helpers.js";
 import { ReviewCoordinator } from "../review/index.js";
 import { Scheduler } from "../scheduler.js";
@@ -23,6 +27,7 @@ import {
   cancelAll as cancelAllWorkflows,
   deleteAll as deleteAllWorkflows,
   purge as purgeWorkflows,
+  retryFailedAll as retryFailedAllWorkflows,
   signalAll as signalAllWorkflows,
   tagAll as tagAllWorkflows,
   untagAll as untagAllWorkflows
@@ -63,24 +68,32 @@ import {
 import {
   createCleanupIntervalTick,
   createQueuedInlineWorkflowStartHandler,
+  createSecondInstanceDetectorResolver,
+  drainQueuedInlineWorkflowStartsForEngine,
   isActivityDefinition
 } from "./engine-runtime-helpers.js";
-import { EngineCreateNameMismatchError } from "./errors.js";
+import { EngineCreateNameMismatchError, EngineDisposedError } from "./errors.js";
+import { assertLeaseHeldForEngineWork, commitFencedEngineWrite } from "./fenced-write.js";
+import { recordFinalizerState } from "./finalizer-state.js";
 import {
   createWorkflowHandleWithResultPromise as createWorkflowHandleWithResultPromiseFromInternals,
   getWorkflowResultPromise as getWorkflowResultPromiseFromInternals
 } from "./handle-result.js";
-import { HANDLE_RESULT_PROMISE, ScheduleHandle, WorkflowHandle } from "./handles.js";
+import { HANDLE_RESULT_PROMISE, WorkflowHandle } from "./handles.js";
 import { hasQueuedInlineWorkflowStart } from "./inline-launch-queue.js";
 import {
   handleStrategyMessage as handleStrategyMessageFromInternals,
   resumeParkedInlineWorkflow as resumeParkedInlineWorkflowFromInternals
 } from "./inline-parking.js";
 import { getInternals, initializeInternals } from "./internals.js";
+import { ENGINE_LEASE_LOST_WARNING_NAME, handleDeposition } from "./lease-deposition.js";
+import { createLeaseManager } from "./lease-manager.js";
 import {
   fork as forkFromLifecycle,
   recoverAll as recoverAllFromLifecycle,
   resume as resumeFromLifecycle,
+  startOrSignal as startOrSignalFromLifecycle,
+  startWithIdempotency as startWithIdempotencyFromLifecycle,
   startWorkflow as startWorkflowFromLifecycle
 } from "./lifecycle.js";
 import {
@@ -114,15 +127,21 @@ import {
   listReviews as listReviewsFromInternals,
   submitReview as submitReviewFromInternals
 } from "./reviews.js";
+import { ScheduleHandle } from "./schedule-handle.js";
 import {
   cancelSchedule as cancelScheduleFromInternals,
   listSchedules as listSchedulesFromInternals,
   pauseSchedule as pauseScheduleFromInternals,
+  recoverOrphanedScheduleTimers,
   resumeSchedule as resumeScheduleFromInternals,
   schedule as scheduleFromInternals,
   toScheduleSummary,
   updateSchedule as updateScheduleFromInternals
 } from "./schedules.js";
+import {
+  createSecondInstanceDetectionTick,
+  createSecondInstanceDetector
+} from "./second-instance-detector.js";
 import { signal as signalWorkflow } from "./signals.js";
 import { loadScheduleState, loadWorkflowState } from "./storage-io.js";
 import {
@@ -134,6 +153,7 @@ import {
   cancelWorkflow as cancelWorkflowFromTermination,
   cleanupWaiters as cleanupWaitersFromTermination,
   finalizePendingTimelineEntry,
+  suspendWorkflow as suspendWorkflowFromTermination,
   timeoutWorkflow as timeoutWorkflowFromTermination
 } from "./termination.js";
 import {
@@ -159,13 +179,24 @@ export {
   BulkOperationConfirmationError,
   EngineCreateNameMismatchError,
   EngineDisposedError,
+  IdempotencyKeyPurgedError,
   PersistedDataIncompatibleError,
+  StartOrSignalConflictError,
   WorkflowAlreadyExistsError,
+  WorkflowConcurrencyLimitExceededError,
   WorkflowNotFoundError,
   WorkflowNotRegisteredError,
+  WorkflowSuspendNotSupportedError,
+  WorkflowTeardownPendingError,
   WorkflowTypeNotRegisteredForRecoveryError
 } from "./errors.js";
-export { HANDLE_RESULT_PROMISE, ScheduleHandle, WorkflowHandle } from "./handles.js";
+export { HANDLE_RESULT_PROMISE, WorkflowHandle } from "./handles.js";
+export {
+  EngineLeaseAcquisitionTimeoutError,
+  EngineLeaseCorruptedError,
+  EngineLeaseNotHeldError
+} from "./lease-errors.js";
+export { ScheduleHandle } from "./schedule-handle.js";
 export {
   clearEngineLeakWarningTokenForTesting,
   getEngineLeakCollectionCountForTesting,
@@ -175,13 +206,15 @@ 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");
+export const ENGINE_PARKED_WORKFLOW_COUNT_FOR_TESTING = Symbol("engineParkedWorkflowCountForTesting"), ENGINE_SIGNAL_WAITER_COUNT_FOR_TESTING = Symbol("engineSignalWaiterCountForTesting"), ENGINE_SLEEP_RESOLVER_COUNT_FOR_TESTING = Symbol("engineSleepResolverCountForTesting");
+
+export { ENGINE_LEASE_LOST_WARNING_NAME };
 
 export class Engine extends EventTarget {
   static async create(options) {
     const engine = new Engine(options);
     try {
-      await assertCompatiblePersistedDataVersion(getInternals(engine).storage, options.allowLegacyData === void 0 ? {} : { allowLegacyData: options.allowLegacyData });
+      await assertCompatiblePersistedDataVersion(getInternals(engine).storage);
       for (const [name, definition] of definitionEntries(options.activities)) {
         if (name !== definition.name)
           throw new EngineCreateNameMismatchError("activity", name, definition.name);
@@ -192,6 +225,7 @@ export class Engine extends EventTarget {
           throw new EngineCreateNameMismatchError("workflow", name, definition.name);
         engine.register(definition);
       }
+      await engine.#acquireLeaseIfConfigured();
       if (options.recover !== !1)
         await engine.recoverAll(options.acknowledgeUnknownWorkflowTypes !== void 0 ? { acknowledgeUnknownWorkflowTypes: options.acknowledgeUnknownWorkflowTypes } : {});
     } catch (error) {
@@ -215,7 +249,9 @@ export class Engine extends EventTarget {
       getComposedWorkflowInterceptor: () => getComposedWorkflowInterceptor(getInternals(this)),
       resolveWorkflowType: this.#resolveWorkflowTypeTarget.bind(this),
       registerCancelHandler: (workflowId, handler) => registerCancelHandler(getInternals(this), workflowId, handler),
-      getWorkflowServices: (workflowId) => getInternals(this).workflowServices.get(workflowId)
+      recordFinalizerState: (workflowId, value) => recordFinalizerState(getInternals(this), workflowId, value),
+      getWorkflowServices: (workflowId) => getInternals(this).workflowServices.get(workflowId),
+      getLogSink: () => resolvedOptions.onLog ?? void 0
     });
     getInternals(this).storage = storage;
     getInternals(this).abortController = new AbortController;
@@ -224,6 +260,7 @@ export class Engine extends EventTarget {
     getInternals(this).resultResolvers = new Map;
     getInternals(this).signalWaiters = new Map;
     getInternals(this).signalWaitersByWorkflow = new Map;
+    getInternals(this).conditionWaiters = new Map;
     getInternals(this).updateWaiters = new Map;
     getInternals(this).updateWaitersByWorkflow = new Map;
     getInternals(this).sleepResolvers = new Map;
@@ -250,7 +287,8 @@ export class Engine extends EventTarget {
     getInternals(this).scheduler = new Scheduler({
       storage,
       onTimerFired: (entry) => handleTimerFiredFromInternals(getInternals(this), entry, this.#createTimeOperationCallbacks()),
-      getNow
+      getNow,
+      commitTimerCleanup: (operations) => commitFencedEngineWrite(getInternals(this), operations, [], () => Error("Timer cleanup lost its fenced CAS race"))
     });
     getInternals(this).strategy = strategyBundle.strategy;
     getInternals(this).inlineStrategy = strategyBundle.inlineStrategy;
@@ -263,8 +301,10 @@ export class Engine extends EventTarget {
     if (queuedInlineWorkflowStartChannel !== null)
       queuedInlineWorkflowStartChannel.port1.onmessage = createQueuedInlineWorkflowStartHandler(weakEngine, queuedInlineWorkflowStartChannel);
     getInternals(this).heartbeatDetails = new Map;
+    getInternals(this).lastHeartbeatDetailsByStep = new Map;
     getInternals(this).workflowServices = new Map;
     getInternals(this).pendingAsyncActivities = new Map;
+    getInternals(this).pendingAsyncActivityResolutions = new Map;
     getInternals(this).pendingStarts = new Set;
     getInternals(this).pendingScheduleCreations = new Set;
     getInternals(this).workflowsNeedingTerminalCleanup = new Set;
@@ -275,14 +315,17 @@ export class Engine extends EventTarget {
     getInternals(this).workflowReviewIds = new Map;
     getInternals(this).parkedInlineWorkflows = new Set;
     getInternals(this).terminalizingWorkflows = new Set;
+    getInternals(this).deliveredPendingUpdateIds = new Map;
     getInternals(this).cancelHandlersByWorkflow = new Map;
     getInternals(this).reviewTimerIds = new Map;
     getInternals(this).pendingWebhooks = new Set;
     getInternals(this).pendingTimelineEntries = new Map;
+    getInternals(this).pendingAtomicWorkflowCommitSideEffects = new Map;
     getInternals(this).cleanupIntervalDisposalTracker = null;
     const cleanupIntervalDisposalTracker = {
       disposed: !1,
       cleanupInterval: null,
+      secondInstanceDetectionInterval: null,
       testToken: consumeNextEngineLeakWarningTokenForTesting()
     }, cleanupInterval = setInterval(createCleanupIntervalTick(weakEngine, cleanupIntervalDisposalTracker), 60000);
     cleanupIntervalDisposalTracker.cleanupInterval = cleanupInterval;
@@ -292,13 +335,109 @@ export class Engine extends EventTarget {
     getInternals(this).retentionSweepInterval = null;
     getInternals(this).retentionSweepInFlight = null;
     getInternals(this).nextRetentionSweepAt = null;
+    getInternals(this).secondInstanceDetectionInterval = null;
+    getInternals(this).secondInstanceDetector = null;
+    getInternals(this).leaseManager = null;
+    getInternals(this).inFlightLeaseAcquire = null;
+    getInternals(this).deposed = !1;
+    getInternals(this).tearDownAfterDeposition = () => {
+      this.#disposeAfterDeposition();
+    };
     getInternals(this).eventLogHeads = new Map;
     getInternals(this).workflowFeedListeners = new Map;
     getInternals(this).workflowVersionTuples = new Map;
+    getInternals(this).workflowVisibilityWatermark = void 0;
+    getInternals(this).workflowVisibilityWatermarkExpiresAt = void 0;
     getInternals(this).activityWorkerDispatcher = createActivityWorkerDispatcher(options?.activityExecution);
     getInternals(this).strategy.onMessage(this.#handleStrategyMessage.bind(this));
     getInternals(this).alertManager = createAlertManagerForEngine(this, options?.alerts, getNow);
     this.#ensureRetentionSweepInterval();
+    this.#startSecondInstanceDetection();
+  }
+  addEventListener(type, listener, options) {
+    super.addEventListener(type, listener, options);
+  }
+  removeEventListener(type, listener, options) {
+    super.removeEventListener(type, listener, options);
+  }
+  async#acquireLeaseIfConfigured() {
+    const internals = getInternals(this);
+    if (internals.options.ownershipMode !== "lease")
+      return;
+    if (internals.disposed)
+      throw new EngineDisposedError;
+    if (internals.inFlightLeaseAcquire !== null) {
+      await internals.inFlightLeaseAcquire;
+      return;
+    }
+    if (internals.leaseManager !== null)
+      return;
+    requireStorageCapability(internals.storage, "conditionalBatch", "ownership: 'lease'");
+    const manager = createLeaseManager({
+      storage: internals.storage,
+      holderId: crypto.randomUUID(),
+      getNow: internals.options.getNow,
+      ttlMs: internals.options.leaseTtlMs,
+      renewIntervalMs: internals.options.leaseRenewIntervalMs,
+      waitTimeoutMs: internals.options.leaseWaitTimeoutMs,
+      onLeaseLost: (reason) => {
+        if (reason === "deposed") {
+          handleDeposition(internals);
+          return;
+        }
+        process.emitWarning("engine ownership lease renewal could not be confirmed (transient storage error); another instance may take over if this persists. Weft supports one engine process " + "per store \u2014 keep infrastructure-level single-instance enforcement in place.", ENGINE_LEASE_LOST_WARNING_NAME);
+      }
+    });
+    internals.leaseManager = manager;
+    const acquisition = (async () => {
+      try {
+        await manager.acquire();
+      } catch (error) {
+        if (internals.leaseManager === manager)
+          internals.leaseManager = null;
+        throw error;
+      }
+      if (internals.disposed) {
+        await manager.release();
+        if (internals.leaseManager === manager)
+          internals.leaseManager = null;
+        throw new EngineDisposedError;
+      }
+      manager.startRenewal();
+    })();
+    internals.inFlightLeaseAcquire = acquisition;
+    try {
+      await acquisition;
+    } finally {
+      if (internals.inFlightLeaseAcquire === acquisition)
+        internals.inFlightLeaseAcquire = null;
+    }
+  }
+  #disposeAfterDeposition() {
+    const internals = getInternals(this);
+    if (internals.disposed)
+      return;
+    const leaseManager = internals.leaseManager;
+    disposeEngine(internals);
+    leaseManager?.release().catch(() => {});
+  }
+  #startSecondInstanceDetection() {
+    const internals = getInternals(this);
+    if (!internals.options.secondInstanceDetectionEnabled)
+      return;
+    const detector = createSecondInstanceDetector({
+      storage: internals.storage,
+      instanceId: crypto.randomUUID(),
+      getNow: internals.options.getNow,
+      intervalMs: internals.options.secondInstanceHeartbeatIntervalMs
+    });
+    internals.secondInstanceDetector = detector;
+    const tracker = internals.cleanupIntervalDisposalTracker;
+    if (tracker === null)
+      return;
+    const weakEngine = new WeakRef(this), detectionInterval = setInterval(createSecondInstanceDetectionTick(createSecondInstanceDetectorResolver(weakEngine), tracker), internals.options.secondInstanceHeartbeatIntervalMs);
+    internals.secondInstanceDetectionInterval = detectionInterval;
+    tracker.secondInstanceDetectionInterval = detectionInterval;
   }
   #hasConfiguredRetention() {
     return hasConfiguredRetention(getInternals(this));
@@ -400,8 +539,21 @@ export class Engine extends EventTarget {
     return getInternals(this).activityRegistry.listDefinitions();
   }
   async start(type, input, options) {
+    assertLeaseHeldForEngineWork(getInternals(this));
+    if (options?.idempotencyKey !== void 0)
+      return startWithIdempotencyFromLifecycle(getInternals(this), type, input, options, this.#createLifecycleCallbacks());
     return startWorkflowFromLifecycle(getInternals(this), type, input, options, void 0, this.#createLifecycleCallbacks());
   }
+  async startOrSignal(type, input, signal, options) {
+    assertLeaseHeldForEngineWork(getInternals(this));
+    return startOrSignalFromLifecycle(getInternals(this), type, input, signal, options, this.#createStartOrSignalCallbacks());
+  }
+  #createStartOrSignalCallbacks() {
+    return {
+      ...this.#createLifecycleCallbacks(),
+      signalExistingWorkflow: (workflowId, signalName, payload, signalId) => this.signal(workflowId, signalName, payload, { signalId })
+    };
+  }
   getHandle(workflowId) {
     const entry = getInternals(this).handleCache.get(workflowId);
     if (entry) {
@@ -426,6 +578,9 @@ export class Engine extends EventTarget {
   async cancelAll(filter, options) {
     return cancelAllWorkflows(getInternals(this), filter, options);
   }
+  async retryFailedAll(filter, options) {
+    return retryFailedAllWorkflows(getInternals(this), filter, options);
+  }
   async signalAll(filter, name, payloadOrOptions, options) {
     if (options === void 0)
       return signalAllWorkflows(getInternals(this), filter, name, payloadOrOptions);
@@ -446,7 +601,8 @@ export class Engine extends EventTarget {
       return scheduleFromInternals(getInternals(this), workflowType, definition.input, definitionSpec, {
         ...definition.id !== void 0 && { id: definition.id },
         ...definition.overlapPolicy !== void 0 && { overlap: definition.overlapPolicy },
-        ...definition.backfill !== void 0 && { backfill: definition.backfill }
+        ...definition.backfill !== void 0 && { backfill: definition.backfill },
+        ...definition.jitter !== void 0 && { jitter: definition.jitter }
       });
     }
     if (spec === void 0)
@@ -481,6 +637,9 @@ export class Engine extends EventTarget {
   [ENGINE_SIGNAL_WAITER_COUNT_FOR_TESTING]() {
     return getInternals(this).signalWaiters.size;
   }
+  [ENGINE_SLEEP_RESOLVER_COUNT_FOR_TESTING]() {
+    return getInternals(this).sleepResolvers.size;
+  }
   async signal(workflowId, nameOrDefinition, payload, options) {
     return signalWorkflow(getInternals(this), workflowId, messageName(nameOrDefinition), payload, {
       loadWorkflowState: (id) => loadWorkflowState(getInternals(this), id),
@@ -503,24 +662,39 @@ export class Engine extends EventTarget {
     return getOffloadFromInternals(getInternals(this), workflowId, key);
   }
   async fork(sourceWorkflowId, options) {
+    assertLeaseHeldForEngineWork(getInternals(this));
     return forkFromLifecycle(getInternals(this), sourceWorkflowId, options, this.#createLifecycleCallbacks());
   }
   async resume(workflowId) {
+    assertLeaseHeldForEngineWork(getInternals(this));
     return resumeFromLifecycle(getInternals(this), workflowId, this.#createLifecycleCallbacks());
   }
   async recoverAll(options) {
+    await this.#acquireLeaseIfConfigured();
+    if (getInternals(this).disposed)
+      throw new EngineDisposedError;
     await recoverPendingAsyncActivities(getInternals(this));
+    await recoverOrphanedScheduleTimers(getInternals(this));
     return recoverAllFromLifecycle(getInternals(this), this.#createLifecycleCallbacks(), options);
   }
   async completeAsyncActivity(token, result) {
-    await completeAsyncActivityFromInternals(getInternals(this), token, result, (workflowId, outcome) => feedOperationResult(getInternals(this), workflowId, outcome), (workflowId, status, output) => finalizePendingTimelineEntry(getInternals(this), workflowId, status, output));
+    await completeAsyncActivityFromInternals(getInternals(this), token, result, {
+      feedOperationResult: (workflowId, outcome) => feedOperationResult(getInternals(this), workflowId, outcome),
+      finalizeTimeline: (workflowId, status, output) => finalizePendingTimelineEntry(getInternals(this), workflowId, status, output)
+    });
   }
   async failAsyncActivity(token, error) {
-    await failAsyncActivityFromInternals(getInternals(this), token, error, (workflowId, outcome, originalReason) => feedOperationResult(getInternals(this), workflowId, outcome, originalReason), (workflowId, status, output) => finalizePendingTimelineEntry(getInternals(this), workflowId, status, output));
+    await failAsyncActivityFromInternals(getInternals(this), token, error, {
+      feedOperationResult: (workflowId, outcome, originalReason) => feedOperationResult(getInternals(this), workflowId, outcome, originalReason),
+      finalizeTimeline: (workflowId, status, output) => finalizePendingTimelineEntry(getInternals(this), workflowId, status, output)
+    });
   }
   async cancel(workflowId) {
     await cancelWorkflowFromTermination(getInternals(this), workflowId, this.#createTerminationCallbacks());
   }
+  async suspend(workflowId) {
+    await suspendWorkflowFromTermination(getInternals(this), workflowId, this.#createTerminationCallbacks());
+  }
   async timeout(workflowId) {
     await timeoutWorkflowFromTermination(getInternals(this), workflowId, this.#createTerminationCallbacks());
   }
@@ -530,6 +704,15 @@ export class Engine extends EventTarget {
       return { ...state, status: "pending" };
     return state;
   }
+  async getCurrentCheckpointStep(workflowId) {
+    const inMemory = getInternals(this).checkpoints.get(workflowId);
+    if (inMemory !== void 0)
+      return inMemory.step;
+    const bytes = await getInternals(this).storage.get(KEYS.checkpoint(workflowId));
+    if (bytes === null)
+      return null;
+    return deserializeCheckpoint(bytes).step;
+  }
   async getAttributes(workflowId) {
     return getWorkflowAttributes(getInternals(this), workflowId);
   }
@@ -584,9 +767,22 @@ export class Engine extends EventTarget {
     return submitCoordinatedUpdateFromInternals(getInternals(this), workflowId, name, payload, options, this.#createUpdateCallbacks());
   }
   [Symbol.dispose]() {
+    const leaseManager = getInternals(this).leaseManager;
     disposeEngine(getInternals(this));
+    leaseManager?.release();
   }
   async[Symbol.asyncDispose]() {
+    if (!getInternals(this).disposed) {
+      const leaseManager = getInternals(this).leaseManager;
+      try {
+        await drainQueuedInlineWorkflowStartsForEngine(this);
+      } finally {
+        disposeEngine(getInternals(this));
+        await getInternals(this).inFlightLeaseAcquire?.catch(() => {});
+        await leaseManager?.release();
+      }
+      return;
+    }
     this[Symbol.dispose]();
   }
   get storage() {

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

@@ -9,6 +9,20 @@ export declare function queueInlineWorkflowExecutionStart(internals: EngineInter
 export declare function flushQueuedInlineWorkflowStarts(internals: EngineInternals, callbacks: InlineLaunchQueueCallbacks): Promise<void>;
 /** Used by scheduler-driven direct backfill flushes. Clears the scheduled flag first. */
 export declare function flushQueuedInlineWorkflowStartsDirectly(internals: EngineInternals, callbacks: InlineLaunchQueueCallbacks): Promise<void>;
+/**
+ * Drain every pending inline launch before engine teardown. Called from
+ * `[Symbol.asyncDispose]` *before* `disposeEngine` aborts the signal, so the
+ * flush actually executes the queued starts (the abort check in
+ * {@link flushQueuedInlineWorkflowStarts} would otherwise discard them). This
+ * turns a deferred-launch macrotask into work that completes before
+ * `asyncDispose` returns, so a disposed engine leaves no dangling pending
+ * launch — the fix for the test-runner macrotask-starvation footgun.
+ *
+ * A queued start that was already aborted (signal set before this is reached)
+ * 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 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

@@ -17,9 +17,18 @@ export function queueInlineWorkflowExecutionStart(internals, start, callbacks) {
     callbacks.swallowPromiseRejection(flushQueuedInlineWorkflowStarts(internals, callbacks));
   }, 0);
 }
+function settleDiscardedInlineStarts(internals, discarded) {
+  for (const start of discarded) {
+    internals.queuedInlineWorkflowStartIds.delete(start.workflowId);
+    internals.queuedOrLaunchingInlineWorkflowStartIds.delete(start.workflowId);
+    start.onStarted?.();
+  }
+}
 export async function flushQueuedInlineWorkflowStarts(internals, callbacks) {
   if (internals.abortController.signal.aborted) {
+    const discarded = internals.queuedInlineWorkflowStarts;
     internals.queuedInlineWorkflowStarts = [];
+    settleDiscardedInlineStarts(internals, discarded);
     return;
   }
   if (internals.queuedInlineWorkflowStarts.length === 0)
@@ -27,12 +36,21 @@ export async function flushQueuedInlineWorkflowStarts(internals, callbacks) {
   const pendingStarts = internals.queuedInlineWorkflowStarts;
   internals.queuedInlineWorkflowStarts = [];
   for (const start of pendingStarts)
-    await startQueuedInlineWorkflowExecution(internals, start, callbacks);
+    await callbacks.swallowPromiseRejection(startQueuedInlineWorkflowExecution(internals, start, callbacks));
 }
 export async function flushQueuedInlineWorkflowStartsDirectly(internals, callbacks) {
   internals.queuedInlineWorkflowStartFlushScheduled = !1;
   await flushQueuedInlineWorkflowStarts(internals, callbacks);
 }
+export async function drainQueuedInlineWorkflowStarts(internals, callbacks) {
+  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));
+  }
+}
 async function startQueuedInlineWorkflowExecution(internals, start, callbacks) {
   try {
     const state = await loadWorkflowState(internals, start.workflowId);
@@ -45,22 +63,29 @@ async function startQueuedInlineWorkflowExecution(internals, start, callbacks) {
   } finally {
     internals.queuedInlineWorkflowStartIds.delete(start.workflowId);
     internals.queuedOrLaunchingInlineWorkflowStartIds.delete(start.workflowId);
+    start.onStarted?.();
   }
 }
 export function dropQueuedInlineWorkflowStart(internals, workflowId) {
   if (internals.queuedInlineWorkflowStarts.length === 0)
     return !1;
-  const initialLength = internals.queuedInlineWorkflowStarts.length;
-  internals.queuedInlineWorkflowStarts = internals.queuedInlineWorkflowStarts.filter((start) => start.workflowId !== workflowId);
-  if (internals.queuedInlineWorkflowStarts.length !== initialLength) {
-    internals.queuedInlineWorkflowStartIds.delete(workflowId);
-    internals.queuedOrLaunchingInlineWorkflowStartIds.delete(workflowId);
-  }
+  const initialLength = internals.queuedInlineWorkflowStarts.length, dropped = [];
+  internals.queuedInlineWorkflowStarts = internals.queuedInlineWorkflowStarts.filter((start) => {
+    if (start.workflowId === workflowId) {
+      dropped.push(start);
+      return !1;
+    }
+    return !0;
+  });
+  if (internals.queuedInlineWorkflowStarts.length !== initialLength)
+    settleDiscardedInlineStarts(internals, dropped);
   return internals.queuedInlineWorkflowStarts.length !== initialLength;
 }
 export function disposeQueuedInlineWorkflowStarts(internals) {
   internals.queuedInlineWorkflowStartFlushScheduled = !1;
+  const discarded = internals.queuedInlineWorkflowStarts;
   internals.queuedInlineWorkflowStarts = [];
+  settleDiscardedInlineStarts(internals, discarded);
   internals.queuedInlineWorkflowStartIds.clear();
   internals.queuedOrLaunchingInlineWorkflowStartIds.clear();
   const channel = internals.queuedInlineWorkflowStartChannel;

package/dist/core/engine/inline-parking.js

@@ -1,3 +1,4 @@
+import { hasExposedAccessors, hasUpdateHandlers } from "../context/context-presence.js";
 import {
   resumeWorkflowFromStorage as resumeWorkflowFromStorageFromLifecycle
 } from "./lifecycle.js";
@@ -9,7 +10,7 @@ export async function parkInlineWorkflowAfterCheckpoint(internals, workflowId, o
   if (operation.type !== "wait-signal" || internals.inlineStrategy === null)
     return !1;
   const inlineStrategy = internals.inlineStrategy, context = inlineStrategy.getContext(workflowId);
-  if (context?.hasUpdateHandlers || context?.hasExposedAccessors)
+  if (context && (hasUpdateHandlers(context) || hasExposedAccessors(context)))
     return !1;
   if (await callbacks.hasBufferedSignal(workflowId, operation.signalName))
     return !1;
@@ -17,7 +18,7 @@ export async function parkInlineWorkflowAfterCheckpoint(internals, workflowId, o
     const latestState = await callbacks.loadWorkflowState(workflowId);
     if (internals.terminalizingWorkflows.has(workflowId) || !latestState || latestState.status !== "running")
       return !1;
-    inlineStrategy.parkWorkflow(workflowId);
+    inlineStrategy.parkWorkflow(workflowId, { retainContext: !0 });
     internals.parkedInlineWorkflows.add(workflowId);
     return !0;
   }))