@lostgradient/weft 0.10.0 → 0.11.0

package/dist/core/checkpoint/serialization.js

@@ -29,7 +29,7 @@ export function validateCheckpointShape(value) {
   validateAccumulatedResultReplayWatermark(record);
   validateWorkerReplaySignatures(record);
   validateWorkerReplayFailures(record);
-  dropLegacyPendingSignals(record);
+  dropRetiredPendingSignals(record);
   assertRecordField(record, "searchAttributes");
   assertStringField(record, "version");
   assertNumberField(record, "createdAt");
@@ -148,7 +148,7 @@ function validateAccumulatedResultReplayWatermark(record) {
   if (typeof watermark !== "number" || !Number.isSafeInteger(watermark) || watermark < 0)
     throw Error('Invalid checkpoint: invalid "accumulatedResultReplayWatermark" (expected non-negative safe integer)');
 }
-function dropLegacyPendingSignals(record) {
+function dropRetiredPendingSignals(record) {
   delete record.pendingSignals;
 }
 function assertCurrentSchemaVersion(record) {

package/dist/core/engine/disposal.js

@@ -1,6 +1,7 @@
 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";
 export function disposeEngine(internals) {
   internals.disposed = !0;
   internals.alertManager?.[Symbol.dispose]();
@@ -30,6 +31,7 @@ export function disposeEngine(internals) {
   internals.handleCache.clear();
   for (const waiter of internals.resultResolvers.values())
     waiter.reject(new EngineDisposedError);
+  rejectAllSleepTimerAcknowledgements(internals, new EngineDisposedError);
   internals.resultResolvers.clear();
   internals.updateWaiters.clear();
   internals.updateWaitersByWorkflow.clear();
@@ -46,6 +48,8 @@ export function disposeEngine(internals) {
   internals.pendingWebhooks.clear();
   internals.sleepResolvers.clear();
   internals.sleepResolversByWorkflow.clear();
+  internals.sleepTimerAcknowledgementWaiters.clear();
+  internals.durableInlineOperations.clear();
   internals.sleepTimersFiredWithoutResolver.clear();
   internals.checkpoints.clear();
   internals.pendingExecutionStateOwnerId = void 0;

package/dist/core/engine/engine-leak-warnings.d.ts

@@ -15,6 +15,8 @@ export type EngineCleanupIntervalDisposalTracker = {
     testToken: symbol | undefined;
 };
 export declare const engineCleanupIntervalFinalizer: FinalizationRegistry<EngineCleanupIntervalDisposalTracker>;
+/** Test-only hook for the finalizer callback's synchronous warning gate. */
+export declare function finalizeEngineCleanupIntervalTrackerForTesting(tracker: EngineCleanupIntervalDisposalTracker): void;
 export declare function shouldEmitEngineLeakWarning(): boolean;
 /** Test-only override for the engine leak-warning environment gate. */
 export declare function setEngineLeakWarningOverrideForTesting(value: boolean | undefined): void;

package/dist/core/engine/engine-leak-warnings.js

@@ -1,6 +1,6 @@
 let engineLeakWarningOverrideForTesting, engineLeakCollectionCountForTesting = 0, nextEngineLeakWarningTokenForTesting;
 const engineLeakWarningTokensForTesting = new Set;
-export const engineCleanupIntervalFinalizer = new FinalizationRegistry((tracker) => {
+function finalizeEngineCleanupIntervalTracker(tracker) {
   engineLeakCollectionCountForTesting++;
   if (tracker.cleanupInterval !== null) {
     clearInterval(tracker.cleanupInterval);
@@ -15,7 +15,13 @@ export const engineCleanupIntervalFinalizer = new FinalizationRegistry((tracker)
       engineLeakWarningTokensForTesting.add(tracker.testToken);
     process.emitWarning("WeftEngineLeakWarning: A Weft Engine was garbage-collected without calling [Symbol.dispose](). Use `using`, `await using`, or call engine[Symbol.dispose]() to clear background timers and release runtime resources.");
   }
+}
+export const engineCleanupIntervalFinalizer = new FinalizationRegistry((tracker) => {
+  finalizeEngineCleanupIntervalTracker(tracker);
 });
+export function finalizeEngineCleanupIntervalTrackerForTesting(tracker) {
+  finalizeEngineCleanupIntervalTracker(tracker);
+}
 export function shouldEmitEngineLeakWarning() {
   if (engineLeakWarningOverrideForTesting !== void 0)
     return engineLeakWarningOverrideForTesting;

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

@@ -220,9 +220,12 @@ export declare class Engine<TWorkflows extends object = DefaultWorkflowRegistry,
      * (signal-with-start). With an absent target, the workflow record and the
      * first signal commit in one batch and the freshly-launched run consumes the
      * signal on its first drive. A non-terminal target (running, pending, or
-     * suspended) is signalled through the normal signal path; a terminal target
-     * throws {@link StartOrSignalConflictError} unless
-     * `options.onTerminalConflict: 'start-new'` is supplied with an explicit
+     * suspended) is signalled through a workflow-serialized signal path. If
+     * terminal completion wins that handoff, the target is treated as terminal:
+     * the default path throws {@link StartOrSignalConflictError}, while
+     * `options.onTerminalConflict: 'start-new'` transfers the signal to the
+     * replacement run. A terminal target throws {@link StartOrSignalConflictError}
+     * unless `options.onTerminalConflict: 'start-new'` is supplied with an explicit
      * workflow id and deterministic `signal.signalId`.
      *
      * Concurrent callers converge on one workflow and one delivered signal. Pass

package/dist/core/engine/index.js

@@ -74,7 +74,11 @@ import {
   shouldStartEngineScheduler,
   validateEngineCreateBackgroundTaskOptions
 } from "./engine-runtime-helpers.js";
-import { EngineCreateNameMismatchError, EngineDisposedError } from "./errors.js";
+import {
+  EngineCreateNameMismatchError,
+  EngineDisposedError,
+  StartOrSignalConflictError
+} from "./errors.js";
 import { assertLeaseHeldForEngineWork, commitFencedEngineWrite } from "./fenced-write.js";
 import { recordFinalizerState } from "./finalizer-state.js";
 import {
@@ -145,7 +149,11 @@ import {
   createSecondInstanceDetector
 } from "./second-instance-detector.js";
 import { signal as signalWorkflow } from "./signals.js";
-import { loadScheduleState, loadWorkflowState } from "./storage-io.js";
+import {
+  loadScheduleState,
+  loadWorkflowState,
+  runSerializedWorkflowStateWrite
+} from "./storage-io.js";
 import {
   feedOperationResult,
   getComposedWorkflowInterceptor,
@@ -163,6 +171,7 @@ import {
   submitCoordinatedUpdate as submitCoordinatedUpdateFromInternals,
   update as updateFromInternals
 } from "./updates.js";
+import { isTerminalWorkflowStatus } from "./validation.js";
 import { coerceScheduleId } from "./validation/schedule.js";
 import {
   replayWorkflowFeed,
@@ -280,6 +289,8 @@ export class Engine extends EventTarget {
     getInternals(this).updateWaitersByWorkflow = new Map;
     getInternals(this).sleepResolvers = new Map;
     getInternals(this).sleepResolversByWorkflow = new Map;
+    getInternals(this).sleepTimerAcknowledgementWaiters = new Map;
+    getInternals(this).durableInlineOperations = new Map;
     getInternals(this).sleepTimersFiredWithoutResolver = new Map;
     getInternals(this).interceptors = resolveEngineInterceptors(options);
     getInternals(this).composedWorkflowInterceptor = void 0;
@@ -568,7 +579,12 @@ export class Engine extends EventTarget {
   #createStartOrSignalCallbacks() {
     return {
       ...this.#createLifecycleCallbacks(),
-      signalExistingWorkflow: (workflowId, signalName, payload, signalId) => this.signal(workflowId, signalName, payload, { signalId })
+      signalExistingWorkflow: (workflowId, signalName, payload, signalId) => runSerializedWorkflowStateWrite(getInternals(this), workflowId, async () => {
+        const state = await loadWorkflowState(getInternals(this), workflowId);
+        if (state && isTerminalWorkflowStatus(state.status))
+          throw new StartOrSignalConflictError(workflowId, state.status);
+        await this.signal(workflowId, signalName, payload, { signalId });
+      })
     };
   }
   getHandle(workflowId) {

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

@@ -2,6 +2,10 @@ import { hasExposedAccessors, hasUpdateHandlers } from "../context/context-prese
 import {
   resumeWorkflowFromStorage as resumeWorkflowFromStorageFromLifecycle
 } from "./lifecycle.js";
+import {
+  recordDurableInlineOperation,
+  rejectSleepTimerAcknowledgements
+} from "./sleep-timer-acknowledgements.js";
 import {
   completeWorkflow as completeWorkflowFromTermination,
   failWorkflow as failWorkflowFromTermination
@@ -53,7 +57,7 @@ export async function getParkedWorkflowResumeDisposition(internals, workflowId,
     return "corrupt";
   return "resumable";
 }
-export async function handleStrategyMessage(internals, message, callbacks) {
+async function dispatchStrategyMessage(internals, message, callbacks) {
   switch (message.type) {
     case "completed":
       await completeWorkflowFromTermination(internals, message.workflowId, message.result, callbacks.createTerminationCallbacks());
@@ -68,6 +72,7 @@ export async function handleStrategyMessage(internals, message, callbacks) {
     case "checkpoint": {
       const operation = callbacks.translateOperationRequest(message.operationRequest);
       await callbacks.persistCheckpoint(message.workflowId, operation, message.checkpoint);
+      recordDurableInlineOperation(internals, message.workflowId, operation);
       callbacks.validateDevelopmentCheckpoint(message.workflowId);
       if (await callbacks.evaluateConstraints(message.workflowId))
         break;
@@ -85,3 +90,11 @@ export async function handleStrategyMessage(internals, message, callbacks) {
     }
   }
 }
+export async function handleStrategyMessage(internals, message, callbacks) {
+  try {
+    await dispatchStrategyMessage(internals, message, callbacks);
+  } catch (error) {
+    rejectSleepTimerAcknowledgements(internals, message.workflowId, error);
+    throw error;
+  }
+}

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

@@ -22,6 +22,7 @@ import type { AlertManager } from '../../alerting/alert-manager.ts';
 import type { Storage as WeftStorage } from '../../storage/interface.ts';
 import type { ActivityWorkerDispatcher } from '../../workers/activity-worker-dispatcher.ts';
 import type { ActivityRegistry } from '../activity-registry.ts';
+import type { ContextOperationRequest } from '../context.ts';
 import type { EventHeadRecord } from '../event-log.ts';
 import type { ExecutionStrategy } from '../execution-strategy.ts';
 import type { InlineExecutionStrategy } from '../inline-execution-strategy.ts';
@@ -39,6 +40,17 @@ import type { WorkflowFeedListener } from './index.ts';
 import type { LeaseManager } from './lease-manager.ts';
 import type { ScheduleHandleEngine } from './schedule-handle.ts';
 import type { SecondInstanceDetector } from './second-instance-detector.ts';
+export type SleepTimerAcknowledgementWaiter = {
+    fireAt: number;
+    operationId: string;
+    reject: (error: Error) => void;
+    resolve: () => void;
+};
+export type DurableInlineOperation = {
+    operationId: string;
+    scheduledFireAt?: number;
+    type: ContextOperationRequest['type'];
+};
 type EngineRuntime = WorkflowHandleEngine & ScheduleHandleEngine & {
     start(type: string, input: unknown, options?: StartWorkflowOptions): Promise<WorkflowHandle>;
 };
@@ -102,6 +114,15 @@ export interface EngineInternals {
         fireAt: number;
     }>;
     sleepResolversByWorkflow: Map<string, Set<string>>;
+    /**
+     * Fired sleep timers awaiting proof that the awakened inline workflow reached
+     * its next durable checkpoint or terminal state. External schedulers must not
+     * delete a timer before these waiters settle, or a Service Worker eviction can
+     * lose the only durable wake-up between resolver settlement and checkpointing.
+     */
+    sleepTimerAcknowledgementWaiters: Map<string, Set<SleepTimerAcknowledgementWaiter>>;
+    /** Most recently persisted inline operation, used to reject stale sleep-timer callbacks. */
+    durableInlineOperations: Map<string, DurableInlineOperation>;
     /**
      * Per-workflow maps of `operationId` → fired timer `fireAt` for sleep timers
      * the scheduler tick fired before the resolver was registered. Keyed by

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

@@ -4,6 +4,11 @@ import { encode } from "../codec.js";
 import { buildTimerBatchOperations, normalizeStorageTimestamp } from "../scheduler.js";
 import { commitFencedEngineWrite } from "./fenced-write.js";
 import { reprovideRecoveredServices } from "./lifecycle/recovered-services.js";
+import {
+  acknowledgeSupersededSleepTimers,
+  handleSleepTimerWithAcknowledgement,
+  resolveSleepTimer
+} from "./sleep-timer-acknowledgements.js";
 import { buildWorkflowVisibilityIndexTransition } from "./workflow-indexes.js";
 export function createDelayedStartTimerEntry(_internals, workflowId, scheduledStartAt, options, callbacks) {
   return {
@@ -26,6 +31,8 @@ function sleepTimerFiredEarly(internals, workflowId, operation) {
   workflowMarkers.delete(operation.operationId);
   if (workflowMarkers.size === 0)
     internals.sleepTimersFiredWithoutResolver.delete(workflowId);
+  if (markedFireAt < operation.scheduledFireAt)
+    acknowledgeSupersededSleepTimers(internals, workflowId, operation.scheduledFireAt);
   return markedFireAt >= operation.scheduledFireAt;
 }
 export async function processSleepOperation(internals, workflowId, operation, callbacks) {
@@ -166,7 +173,7 @@ export async function handleTimerFired(internals, entry, callbacks) {
     return;
   }
   if (entry.kind === "sleep")
-    resolveSleepTimer(internals, entry);
+    await handleSleepTimerWithAcknowledgement(internals, entry, callbacks.loadWorkflowState);
   else if (entry.kind === "wait-condition")
     resolveConditionTimer(internals, entry);
   else if (entry.kind === "execution-deadline")
@@ -189,30 +196,3 @@ async function handleReviewTimer(internals, entry, callbacks) {
     return;
   await handler(entry);
 }
-function resolveSleepTimer(internals, entry) {
-  const operationId = entry.id.replace("sleep:", ""), resolverKey = `${entry.workflowId}:${operationId}`, resolver = internals.sleepResolvers.get(resolverKey);
-  if (!resolver) {
-    let workflowMarkers = internals.sleepTimersFiredWithoutResolver.get(entry.workflowId);
-    if (!workflowMarkers) {
-      workflowMarkers = new Map;
-      internals.sleepTimersFiredWithoutResolver.set(entry.workflowId, workflowMarkers);
-    }
-    const existing = workflowMarkers.get(operationId);
-    if (existing === void 0 || entry.fireAt > existing)
-      workflowMarkers.set(operationId, entry.fireAt);
-    return;
-  }
-  if (entry.fireAt < resolver.fireAt)
-    return;
-  internals.sleepResolvers.delete(resolverKey);
-  untrackSleepResolver(internals, entry.workflowId, operationId);
-  resolver.resolve();
-}
-function untrackSleepResolver(internals, workflowId, operationId) {
-  const workflowOperations = internals.sleepResolversByWorkflow.get(workflowId);
-  if (!workflowOperations)
-    return;
-  workflowOperations.delete(operationId);
-  if (workflowOperations.size === 0)
-    internals.sleepResolversByWorkflow.delete(workflowId);
-}

package/dist/core/engine/sleep-timer-acknowledgements.d.ts

@@ -0,0 +1,15 @@
+import type { ContextOperationRequest } from '../context.ts';
+import type { TimerEntry, WorkflowState } from '../types.ts';
+import type { EngineInternals } from './internals.ts';
+export type SleepTimerAcknowledgement = {
+    cancel: () => void;
+    promise: Promise<void>;
+};
+export declare function handleSleepTimerWithAcknowledgement(internals: EngineInternals, entry: TimerEntry, loadWorkflowState: (workflowId: string) => Promise<WorkflowState | null>): Promise<void>;
+export declare function createSleepTimerAcknowledgement(internals: EngineInternals, workflowId: string, operationId: string, fireAt: number): SleepTimerAcknowledgement;
+export declare function recordDurableInlineOperation(internals: EngineInternals, workflowId: string, operation: ContextOperationRequest): void;
+export declare function settleSleepTimerAcknowledgements(internals: EngineInternals, workflowId: string, disposition: 'suspended' | 'terminal'): void;
+export declare function acknowledgeSupersededSleepTimers(internals: EngineInternals, workflowId: string, currentDeadline: number): void;
+export declare function rejectSleepTimerAcknowledgements(internals: EngineInternals, workflowId: string, error: unknown): void;
+export declare function rejectAllSleepTimerAcknowledgements(internals: EngineInternals, error: Error): void;
+export declare function resolveSleepTimer(internals: EngineInternals, entry: TimerEntry): boolean;

package/dist/core/engine/sleep-timer-acknowledgements.js

@@ -0,0 +1,144 @@
+export async function handleSleepTimerWithAcknowledgement(internals, entry, loadWorkflowState) {
+  const operationId = entry.id.replace("sleep:", "");
+  if (await shouldIgnoreUnclaimedSleepTimer(internals, entry, operationId, loadWorkflowState))
+    return;
+  const acknowledgement = internals.inlineStrategy === null ? null : createSleepTimerAcknowledgement(internals, entry.workflowId, operationId, entry.fireAt);
+  if (!resolveSleepTimer(internals, entry)) {
+    acknowledgement?.cancel();
+    return;
+  }
+  await acknowledgement?.promise;
+}
+async function shouldIgnoreUnclaimedSleepTimer(internals, entry, operationId, loadWorkflowState) {
+  const resolverKey = `${entry.workflowId}:${operationId}`;
+  if (internals.sleepResolvers.has(resolverKey) || internals.inlineStrategy === null)
+    return !1;
+  const durableOperation = internals.durableInlineOperations.get(entry.workflowId);
+  if (durableOperationBelongsToAnotherOperation(durableOperation, operationId))
+    return !0;
+  if (workflowReplayIsAdvancing(internals, entry.workflowId))
+    return !1;
+  if ((await loadWorkflowState(entry.workflowId))?.status !== "running")
+    return !0;
+  throw Error(`Sleep timer "${entry.id}" fired before workflow "${entry.workflowId}" was ready to consume it.`);
+}
+function durableOperationBelongsToAnotherOperation(durableOperation, operationId) {
+  if (durableOperation === void 0)
+    return !1;
+  if (durableOperation.type !== "sleep")
+    return !0;
+  return durableOperation.operationId !== operationId;
+}
+function workflowReplayIsAdvancing(internals, workflowId) {
+  const inlineStrategy = internals.inlineStrategy;
+  if (inlineStrategy === null)
+    return !1;
+  return inlineStrategy.waitForWorkflowAdvance(workflowId) !== void 0 || inlineStrategy.waitForWorkflowTurn(workflowId) !== void 0;
+}
+function removeWaiter(internals, workflowId, waiter) {
+  const workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters)
+    return;
+  workflowWaiters.delete(waiter);
+  if (workflowWaiters.size === 0)
+    internals.sleepTimerAcknowledgementWaiters.delete(workflowId);
+}
+export function createSleepTimerAcknowledgement(internals, workflowId, operationId, fireAt) {
+  const { promise, reject, resolve } = Promise.withResolvers(), waiter = { fireAt, operationId, reject, resolve };
+  let workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters) {
+    workflowWaiters = new Set;
+    internals.sleepTimerAcknowledgementWaiters.set(workflowId, workflowWaiters);
+  }
+  workflowWaiters.add(waiter);
+  return {
+    promise,
+    cancel: () => {
+      removeWaiter(internals, workflowId, waiter);
+      resolve();
+    }
+  };
+}
+export function recordDurableInlineOperation(internals, workflowId, operation) {
+  const durableOperation = {
+    operationId: operation.operationId,
+    type: operation.type,
+    ...operation.type === "sleep" && { scheduledFireAt: operation.scheduledFireAt }
+  };
+  internals.durableInlineOperations.set(workflowId, durableOperation);
+  const workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters)
+    return;
+  for (const waiter of workflowWaiters) {
+    const stillWaitingOnThisSleep = durableOperation.type === "sleep" && durableOperation.operationId === waiter.operationId, supersededByLaterDeadline = stillWaitingOnThisSleep && durableOperation.scheduledFireAt !== void 0 && waiter.fireAt < durableOperation.scheduledFireAt;
+    if (stillWaitingOnThisSleep && !supersededByLaterDeadline)
+      continue;
+    removeWaiter(internals, workflowId, waiter);
+    waiter.resolve();
+  }
+}
+export function settleSleepTimerAcknowledgements(internals, workflowId, disposition) {
+  internals.durableInlineOperations.delete(workflowId);
+  if (disposition === "suspended") {
+    rejectSleepTimerAcknowledgements(internals, workflowId, Error(`Workflow "${workflowId}" was suspended before its sleep timer was acknowledged.`));
+    return;
+  }
+  const workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters)
+    return;
+  internals.sleepTimerAcknowledgementWaiters.delete(workflowId);
+  for (const waiter of workflowWaiters)
+    waiter.resolve();
+}
+export function acknowledgeSupersededSleepTimers(internals, workflowId, currentDeadline) {
+  const workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters)
+    return;
+  for (const waiter of workflowWaiters) {
+    if (waiter.fireAt >= currentDeadline)
+      continue;
+    removeWaiter(internals, workflowId, waiter);
+    waiter.resolve();
+  }
+}
+export function rejectSleepTimerAcknowledgements(internals, workflowId, error) {
+  const workflowWaiters = internals.sleepTimerAcknowledgementWaiters.get(workflowId);
+  if (!workflowWaiters)
+    return;
+  internals.sleepTimerAcknowledgementWaiters.delete(workflowId);
+  const rejection = error instanceof Error ? error : Error(String(error));
+  for (const waiter of workflowWaiters)
+    waiter.reject(rejection);
+}
+export function rejectAllSleepTimerAcknowledgements(internals, error) {
+  for (const workflowId of internals.sleepTimerAcknowledgementWaiters.keys())
+    rejectSleepTimerAcknowledgements(internals, workflowId, error);
+}
+export function resolveSleepTimer(internals, entry) {
+  const operationId = entry.id.replace("sleep:", ""), resolverKey = `${entry.workflowId}:${operationId}`, resolver = internals.sleepResolvers.get(resolverKey);
+  if (!resolver) {
+    let workflowMarkers = internals.sleepTimersFiredWithoutResolver.get(entry.workflowId);
+    if (!workflowMarkers) {
+      workflowMarkers = new Map;
+      internals.sleepTimersFiredWithoutResolver.set(entry.workflowId, workflowMarkers);
+    }
+    const existing = workflowMarkers.get(operationId);
+    if (existing === void 0 || entry.fireAt > existing)
+      workflowMarkers.set(operationId, entry.fireAt);
+    return !0;
+  }
+  if (entry.fireAt < resolver.fireAt)
+    return !1;
+  internals.sleepResolvers.delete(resolverKey);
+  untrackSleepResolver(internals, entry.workflowId, operationId);
+  resolver.resolve();
+  return !0;
+}
+function untrackSleepResolver(internals, workflowId, operationId) {
+  const workflowOperations = internals.sleepResolversByWorkflow.get(workflowId);
+  if (!workflowOperations)
+    return;
+  workflowOperations.delete(operationId);
+  if (workflowOperations.size === 0)
+    internals.sleepResolversByWorkflow.delete(workflowId);
+}

package/dist/core/engine/termination/cleanup.js

@@ -2,6 +2,7 @@ import { KEYS, encodeStorageKeyComponent, storageHas } from "../../../storage/in
 import { CleanupWarningEvent } from "../../events.js";
 import { asyncActivityWorkflowPrefix } from "../async-activity-records.js";
 import { forgetCommittedCheckpointBytes } from "../checkpoint-commit-snapshots.js";
+import { settleSleepTimerAcknowledgements } from "../sleep-timer-acknowledgements.js";
 import { parseTerminalCleanupTimerId, workflowFeedListenerKey } from "../state-utilities.js";
 import { releaseWorkflowConcurrencySlot } from "../workflow-concurrency.js";
 export const TERMINAL_WORKFLOW_STATUSES = new Set([
@@ -102,6 +103,7 @@ export function cleanupWaiters(internals, workflowId, callbacks) {
   internals.workflowTypeByWorkflowId.delete(workflowId);
 }
 export function evictSuspendedWorkflowWaiters(internals, workflowId, callbacks) {
+  settleSleepTimerAcknowledgements(internals, workflowId, "suspended");
   for (const kind of TRACKED_WAITER_KINDS)
     cleanupTrackedWaiter(internals, workflowId, kind);
   evictSleepResolversWithoutResolving(internals, workflowId);
@@ -148,6 +150,7 @@ export async function cleanupWorkflowStorage(internals, workflowId, includeOutpu
   await flush();
 }
 export function cleanupTerminalWorkflowMemory(internals, workflowId, callbacks) {
+  settleSleepTimerAcknowledgements(internals, workflowId, "terminal");
   internals.workflowsNeedingTerminalCleanup.delete(workflowId);
   forgetCommittedCheckpointBytes(internals, workflowId);
   internals.checkpoints.delete(workflowId);