@lostgradient/weft 0.2.0

package/dist/core/engine/callback-creators-core.js

@@ -0,0 +1,136 @@
+import { HISTORY_CIRCUIT_BREAKER_REASON } from "../types.js";
+import {
+  broadcast as broadcastFromInternals,
+  forwardEventToHandle as forwardEventToHandleFromBroadcast
+} from "./broadcast.js";
+import { createWorkflowHandleWithResultPromise } from "./handle-result.js";
+import {
+  hasLocalCheckpointOwnership,
+  isInlineWorkflowLocallyOwned,
+  queueInlineWorkflowExecutionStart
+} from "./inline-launch-queue.js";
+import { getInternals } from "./internals.js";
+import { processPendingUpdatesAfterReplay } from "./lifecycle.js";
+import {
+  processPendingUpdatesAfterInlineAdvance,
+  processPendingUpdatesForHandlers
+} from "./pending-updates.js";
+import { resolveWorkflowTypeTarget } from "./registration.js";
+import { cleanupReviews } from "./reviews.js";
+import {
+  commitWorkflowStateOperations,
+  loadWorkflowState,
+  runSerializedWorkflowStateWrite
+} from "./storage-io.js";
+import {
+  feedOperationResult,
+  getComposedWorkflowInterceptor,
+  swallowPromiseRejection
+} from "./strategy-helpers.js";
+import {
+  failWorkflow,
+  handleCleanupError,
+  terminateWorkflow
+} from "./termination.js";
+export function createPendingUpdateCallbacks(engine) {
+  return {
+    dispatchEvent: (event) => engine.dispatchEvent(event),
+    broadcast: (message) => broadcastFromInternals(getInternals(engine), message, createBroadcastCallbacks(engine))
+  };
+}
+export function createInlineLaunchQueueCallbacks(engine) {
+  return {
+    processPendingUpdatesAfterInlineAdvance: (workflowId) => processPendingUpdatesAfterInlineAdvanceForEngine(engine, workflowId),
+    swallowPromiseRejection: (promise) => swallowPromiseRejection(promise)
+  };
+}
+export async function processPendingUpdatesAfterInlineAdvanceForEngine(engine, workflowId) {
+  try {
+    await processPendingUpdatesAfterInlineAdvance(getInternals(engine), workflowId, createPendingUpdateCallbacks(engine));
+  } catch (error) {
+    createTerminationCallbacks(engine).handleCleanupError("processPendingUpdates", error, workflowId);
+  }
+}
+export function createLifecycleCallbacks(engine) {
+  return {
+    dispatchEvent: (event) => {
+      engine.dispatchEvent(event);
+    },
+    getHandle: (workflowId) => engine.getHandle(workflowId),
+    createWorkflowHandleWithResultPromise: (workflowId) => createWorkflowHandleWithResultPromise(getInternals(engine), workflowId),
+    runSerializedWorkflowStateWrite: (workflowId, writeOperation) => runSerializedWorkflowStateWrite(getInternals(engine), workflowId, writeOperation),
+    getComposedWorkflowInterceptor: () => getComposedWorkflowInterceptor(getInternals(engine)),
+    resolveWorkflowTypeTarget: (target) => resolveWorkflowTypeTarget(getInternals(engine), target, createRegistrationCallbacks(engine)),
+    processPendingUpdatesAfterReplay: (workflowId) => {
+      processPendingUpdatesAfterReplay(getInternals(engine), workflowId, {
+        processPendingUpdatesForHandlers: (id) => processPendingUpdatesForHandlers(getInternals(engine), id, createPendingUpdateCallbacks(engine)),
+        handleCleanupError: (source, error, id) => createTerminationCallbacks(engine).handleCleanupError(source, error, id)
+      });
+    },
+    processPendingUpdatesAfterInlineAdvance: (workflowId) => processPendingUpdatesAfterInlineAdvanceForEngine(engine, workflowId),
+    processPendingUpdatesForHandlers: (workflowId) => processPendingUpdatesForHandlers(getInternals(engine), workflowId, createPendingUpdateCallbacks(engine)),
+    queueInlineWorkflowExecutionStart: (start) => queueInlineWorkflowExecutionStart(getInternals(engine), start, createInlineLaunchQueueCallbacks(engine)),
+    isInlineWorkflowLocallyOwned: (workflowId, workflowStatus) => isInlineWorkflowLocallyOwned(getInternals(engine), workflowId, workflowStatus),
+    hasLocalCheckpointOwnership: (workflowId, workflowStatus) => hasLocalCheckpointOwnership(getInternals(engine), workflowId, workflowStatus),
+    handleCleanupError: (source, error, workflowId) => createTerminationCallbacks(engine).handleCleanupError(source, error, workflowId),
+    swallowPromiseRejection: (promise) => swallowPromiseRejection(promise),
+    enforceHistoryCircuitBreaker: (workflowId) => terminateWorkflow(getInternals(engine), workflowId, "timed-out", createTerminationCallbacks(engine), HISTORY_CIRCUIT_BREAKER_REASON)
+  };
+}
+export function createTerminationCallbacksWith(engine, handleScheduledWorkflowTerminal) {
+  const dispatchEvent = (event) => {
+    engine.dispatchEvent(event);
+  };
+  return {
+    dispatchEvent,
+    forwardEventToHandle: (workflowId, event) => forwardEventToHandleFromBroadcast(getInternals(engine), workflowId, event, createBroadcastCallbacks(engine)),
+    broadcast: (message) => broadcastFromInternals(getInternals(engine), message, createBroadcastCallbacks(engine)),
+    swallowPromiseRejection: (promise) => swallowPromiseRejection(promise),
+    handleCleanupError: (source, error, workflowId) => handleCleanupError(getInternals(engine), source, error, workflowId, { dispatchEvent }),
+    handleScheduledWorkflowTerminal,
+    loadWorkflowState: (workflowId) => loadWorkflowState(getInternals(engine), workflowId),
+    runSerializedWorkflowStateWrite: (workflowId, writeOperation) => runSerializedWorkflowStateWrite(getInternals(engine), workflowId, writeOperation),
+    commitWorkflowStateOperations: (state, operations) => commitWorkflowStateOperations(getInternals(engine), state, operations),
+    cleanupReviews: (workflowId) => cleanupReviews(getInternals(engine), workflowId)
+  };
+}
+let scheduledWorkflowTerminalHandler = async () => {
+  return;
+};
+export function registerScheduledWorkflowTerminalHandler(handler) {
+  scheduledWorkflowTerminalHandler = handler;
+}
+export function createTerminationCallbacks(engine) {
+  return createTerminationCallbacksWith(engine, (workflowId) => scheduledWorkflowTerminalHandler(engine, workflowId));
+}
+export function createRegistrationCallbacks(engine) {
+  return {
+    ensureRetentionSweepInterval: () => ensureRetentionSweepIntervalCallable(engine)
+  };
+}
+let retentionSweepIntervalCallable = () => {
+  return;
+};
+export function registerEnsureRetentionSweepInterval(fn) {
+  retentionSweepIntervalCallable = fn;
+}
+function ensureRetentionSweepIntervalCallable(engine) {
+  retentionSweepIntervalCallable(engine);
+}
+export function createBroadcastCallbacks(engine) {
+  return { dispatchEvent: (event) => engine.dispatchEvent(event) };
+}
+export function createGuardCallbacks(engine) {
+  return {
+    deleteRequestIfUnconsumed: (workflowId, updateId) => getInternals(engine).updateCoordinator.deleteRequestIfUnconsumed(workflowId, updateId),
+    getUpdateResponse: (updateId) => getInternals(engine).updateCoordinator.getResponse(updateId)
+  };
+}
+export function createConstraintCallbacks(engine) {
+  return {
+    cancelWorkflowInStrategy: (workflowId) => getInternals(engine).strategy.cancelWorkflow(workflowId),
+    dispatchEvent: (event) => engine.dispatchEvent(event),
+    failWorkflow: (workflowId, error) => failWorkflow(getInternals(engine), workflowId, error, createTerminationCallbacks(engine)),
+    feedOperationResult: (workflowId, outcome, originalError) => feedOperationResult(getInternals(engine), workflowId, outcome, originalError)
+  };
+}

package/dist/core/engine/callback-creators-router-registry.d.ts

@@ -0,0 +1,4 @@
+import type { Engine } from './index.ts';
+import type { OperationRouterCallbacks } from './operations-router.ts';
+export declare function registerOperationRouterCallbacksFactory(fn: <TW extends object, TA extends object>(engine: Engine<TW, TA>) => OperationRouterCallbacks): void;
+export declare function callRouterCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): OperationRouterCallbacks;

package/dist/core/engine/callback-creators-router-registry.js

@@ -0,0 +1,9 @@
+let factory;
+export function registerOperationRouterCallbacksFactory(fn) {
+  factory = fn;
+}
+export function callRouterCallbacks(engine) {
+  if (factory === void 0)
+    throw Error("Operation-router callback factory was not registered before being requested. Ensure the engine has been initialized (which loads the router module).");
+  return factory(engine);
+}

package/dist/core/engine/callback-creators-router.d.ts

@@ -0,0 +1,3 @@
+import type { Engine } from './index.ts';
+import { type OperationRouterCallbacks } from './operations-router.ts';
+export declare function createOperationRouterCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): OperationRouterCallbacks;

package/dist/core/engine/callback-creators-router.js

@@ -0,0 +1,68 @@
+import {
+  createActivityOperationCallbacks,
+  createChildWorkflowOperationCallbacks,
+  createCoordinationOperationCallbacks,
+  createDataOperationCallbacks,
+  createStateOperationCallbacks,
+  createStreamOperationCallbacks,
+  createTimeOperationCallbacks,
+  createUpdateCallbacks,
+  executeSubOperationForEngine,
+  processReviewOperationForEngine,
+  runOperationWithResultForEngine,
+  runOperationWithoutResultForEngine
+} from "./callback-creators-bundles.js";
+import { registerOperationRouterCallbacksFactory } from "./callback-creators-router-registry.js";
+import { processChildWorkflowOperation } from "./child-workflow.js";
+import { getInternals } from "./internals.js";
+import { processActivityOperation } from "./operations-activity.js";
+import {
+  processParallelOperation,
+  processRaceOperation,
+  processRunAllOperation,
+  processWaitSignalOperation
+} from "./operations-coordination.js";
+import {
+  processArchiveOperation,
+  processLoadOperation,
+  processMemoOperation,
+  processOffloadOperation
+} from "./operations-data.js";
+import { processSpeculateOperation } from "./operations-speculate.js";
+import { processStateCommitOperation, processStateReadOperation } from "./operations-state.js";
+import { processStreamOperation } from "./operations-stream.js";
+import { processSleepOperation } from "./operations-time.js";
+import { feedOperationResult } from "./strategy-helpers.js";
+import { processWaitReviewOperation } from "./sub-operation.js";
+import { finalizePendingTimelineEntry } from "./termination.js";
+import { processWaitUpdateOperation } from "./updates.js";
+export function createOperationRouterCallbacks(engine) {
+  return {
+    processActivityOperation: (workflowId, operation) => processActivityOperation(getInternals(engine), workflowId, operation, createActivityOperationCallbacks(engine)),
+    processSleepOperation: (workflowId, operation) => processSleepOperation(getInternals(engine), workflowId, operation, createTimeOperationCallbacks(engine)),
+    processWaitSignalOperation: (workflowId, operation) => processWaitSignalOperation(getInternals(engine), workflowId, operation, createCoordinationOperationCallbacks(engine)),
+    processWaitUpdateOperation: (workflowId, operation) => processWaitUpdateOperation(getInternals(engine), workflowId, operation, createUpdateCallbacks(engine)),
+    processParallelOperation: (workflowId, operation) => processParallelOperation(getInternals(engine), workflowId, operation, createCoordinationOperationCallbacks(engine)),
+    processRaceOperation: (workflowId, operation) => processRaceOperation(getInternals(engine), workflowId, operation, createCoordinationOperationCallbacks(engine)),
+    processMemoOperation: (workflowId, operation) => processMemoOperation(getInternals(engine), workflowId, operation, createDataOperationCallbacks(engine)),
+    processChildWorkflowOperation: (workflowId, operation) => processChildWorkflowOperation(getInternals(engine), workflowId, operation, createChildWorkflowOperationCallbacks(engine)),
+    processOffloadOperation: (workflowId, operation) => processOffloadOperation(getInternals(engine), workflowId, operation, createDataOperationCallbacks(engine)),
+    processLoadOperation: (workflowId, operation) => processLoadOperation(getInternals(engine), workflowId, operation, createDataOperationCallbacks(engine)),
+    processArchiveOperation: (workflowId, operation) => processArchiveOperation(getInternals(engine), workflowId, operation, createDataOperationCallbacks(engine)),
+    processStateReadOperation: (workflowId, operation) => processStateReadOperation(getInternals(engine), workflowId, operation, createStateOperationCallbacks(engine)),
+    processStateCommitOperation: (workflowId, operation) => processStateCommitOperation(getInternals(engine), workflowId, operation, createStateOperationCallbacks(engine)),
+    processRunAllOperation: (workflowId, operation) => processRunAllOperation(getInternals(engine), workflowId, operation, createCoordinationOperationCallbacks(engine)),
+    processSpeculateOperation: (workflowId, operation) => processSpeculateOperation(getInternals(engine), workflowId, operation, {
+      runOperationWithResult: (id, subOperation, execute) => runOperationWithResultForEngine(engine, id, subOperation, execute),
+      executeSubOperation: (id, subOperation, signal, speculativeState) => executeSubOperationForEngine(engine, id, subOperation, signal, speculativeState)
+    }),
+    processStreamOperation: (workflowId, operation) => processStreamOperation(getInternals(engine), workflowId, operation, createStreamOperationCallbacks(engine)),
+    processWaitReviewOperation: (workflowId, operation) => processWaitReviewOperation(getInternals(engine), workflowId, operation, {
+      runOperationWithoutResult: (id, subOperation, execute) => runOperationWithoutResultForEngine(engine, id, subOperation, execute),
+      processReviewOperation: (id, options) => processReviewOperationForEngine(engine, id, options)
+    }),
+    finalizePendingTimelineEntry: (workflowId, status, value) => finalizePendingTimelineEntry(getInternals(engine), workflowId, status, value),
+    feedOperationResult: (workflowId, result, error) => feedOperationResult(getInternals(engine), workflowId, result, error)
+  };
+}
+registerOperationRouterCallbacksFactory((engine) => createOperationRouterCallbacks(engine));

package/dist/core/engine/callback-creators-schedule.d.ts

@@ -0,0 +1,13 @@
+import type { ScheduleState, TimerEntry } from '../types.ts';
+import type { Engine } from './index.ts';
+import type { ReviewOperationCallbacks, SubmitReviewCallbacks } from './reviews.ts';
+import { type RefreshedScheduleState, type ScheduleCallbacks } from './schedules.ts';
+export declare function createScheduleCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): ScheduleCallbacks;
+export declare function createReviewOperationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): ReviewOperationCallbacks;
+export declare function createSubmitReviewCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): SubmitReviewCallbacks;
+export declare function refreshScheduledWorkflowStateForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState): Promise<RefreshedScheduleState>;
+export declare function startScheduledRunForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState): Promise<string>;
+export declare function applyScheduleOccurrenceForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState): Promise<ScheduleState>;
+export declare function settleBackfillScheduleStateForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState): Promise<ScheduleState>;
+export declare function handleScheduleTimerForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, entry: TimerEntry): Promise<void>;
+export declare function handleScheduledWorkflowTerminalForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, workflowId: string): Promise<void>;

package/dist/core/engine/callback-creators-schedule.js

@@ -0,0 +1,65 @@
+import {
+  createInlineLaunchQueueCallbacks,
+  createLifecycleCallbacks,
+  createTerminationCallbacks,
+  registerScheduledWorkflowTerminalHandler
+} from "./callback-creators-core.js";
+import { flushQueuedInlineWorkflowStartsDirectly } from "./inline-launch-queue.js";
+import { getInternals } from "./internals.js";
+import { startWorkflow } from "./lifecycle.js";
+import {
+  applyScheduleOccurrence,
+  handleScheduleTimer,
+  handleScheduledWorkflowTerminal,
+  refreshScheduledWorkflowState,
+  settleBackfillScheduleState,
+  startScheduledRun
+} from "./schedules.js";
+import { loadWorkflowState } from "./storage-io.js";
+import { feedOperationResult } from "./strategy-helpers.js";
+import { ensureTerminalCleanupTracked, failWorkflow } from "./termination.js";
+export function createScheduleCallbacks(engine) {
+  return {
+    startWorkflow: async (type, input, options, additionalStartOperations) => {
+      await startWorkflow(getInternals(engine), type, input, options, additionalStartOperations, createLifecycleCallbacks(engine));
+    },
+    loadWorkflowState: (workflowId) => loadWorkflowState(getInternals(engine), workflowId),
+    cancelWorkflow: (workflowId) => engine.cancel(workflowId),
+    getWorkflowResult: (workflowId) => engine.getHandle(workflowId).result(),
+    refreshScheduledWorkflowState: (state) => refreshScheduledWorkflowStateForEngine(engine, state),
+    startScheduledRun: (state) => startScheduledRunForEngine(engine, state),
+    applyScheduleOccurrence: (state) => applyScheduleOccurrenceForEngine(engine, state),
+    settleBackfillScheduleState: (state) => settleBackfillScheduleStateForEngine(engine, state),
+    flushQueuedInlineWorkflowStartsDirectly: () => flushQueuedInlineWorkflowStartsDirectly(getInternals(engine), createInlineLaunchQueueCallbacks(engine))
+  };
+}
+export function createReviewOperationCallbacks(engine) {
+  return {
+    dispatchEvent: engine.dispatchEvent.bind(engine),
+    failWorkflow: (workflowId, error) => failWorkflow(getInternals(engine), workflowId, error, createTerminationCallbacks(engine)),
+    feedOperationResult: (workflowId, result) => feedOperationResult(getInternals(engine), workflowId, result),
+    ensureTerminalCleanupTracked: (workflowId) => ensureTerminalCleanupTracked(getInternals(engine), workflowId)
+  };
+}
+export function createSubmitReviewCallbacks(engine) {
+  return { dispatchEvent: engine.dispatchEvent.bind(engine) };
+}
+export async function refreshScheduledWorkflowStateForEngine(engine, state) {
+  return refreshScheduledWorkflowState(getInternals(engine), state, createScheduleCallbacks(engine));
+}
+export async function startScheduledRunForEngine(engine, state) {
+  return startScheduledRun(getInternals(engine), state, createScheduleCallbacks(engine));
+}
+export async function applyScheduleOccurrenceForEngine(engine, state) {
+  return applyScheduleOccurrence(getInternals(engine), state, createScheduleCallbacks(engine));
+}
+export async function settleBackfillScheduleStateForEngine(engine, state) {
+  return settleBackfillScheduleState(getInternals(engine), state, createScheduleCallbacks(engine));
+}
+export async function handleScheduleTimerForEngine(engine, entry) {
+  return handleScheduleTimer(getInternals(engine), entry, createScheduleCallbacks(engine));
+}
+export async function handleScheduledWorkflowTerminalForEngine(engine, workflowId) {
+  return handleScheduledWorkflowTerminal(getInternals(engine), workflowId, createScheduleCallbacks(engine));
+}
+registerScheduledWorkflowTerminalHandler((engine, workflowId) => handleScheduledWorkflowTerminalForEngine(engine, workflowId));

package/dist/core/engine/callback-creators.d.ts

@@ -0,0 +1,9 @@
+import type { ContextOperationRequest } from '../context.ts';
+import type { Engine } from './index.ts';
+import { type InlineParkingCallbacks } from './inline-parking.ts';
+import { type TerminationCallbacks } from './termination.ts';
+export { createUpdateCallbacks } from './callback-creators-bundles.ts';
+export { createBroadcastCallbacks, createGuardCallbacks, createInlineLaunchQueueCallbacks, createLifecycleCallbacks, createRegistrationCallbacks, createTerminationCallbacks, } from './callback-creators-core.ts';
+export type { TerminationCallbacks };
+export declare function createInlineParkingCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): InlineParkingCallbacks;
+export declare function persistCheckpointForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, workflowId: string, operation: ContextOperationRequest, workerCheckpointBytes?: ArrayBuffer): Promise<void>;

package/dist/core/engine/callback-creators.js

@@ -0,0 +1,87 @@
+import { KEYS } from "../../storage/interface.js";
+import { HISTORY_CIRCUIT_BREAKER_REASON } from "../types.js";
+import { validateAttributeValueSizes } from "./attributes-tags.js";
+import {
+  createConstraintCallbacks,
+  createLifecycleCallbacks,
+  createTerminationCallbacks,
+  registerEnsureRetentionSweepInterval
+} from "./callback-creators-core.js";
+import { createOperationRouterCallbacks } from "./callback-creators-router.js";
+import {
+  appendTimelineBatchOperations,
+  persistCheckpoint,
+  pruneCheckpointHistory,
+  validateDevelopmentCheckpoint
+} from "./checkpoint-io.js";
+import { evaluateConstraints } from "./constraints.js";
+import {
+  getParkedWorkflowResumeDisposition,
+  parkInlineWorkflowAfterCheckpoint,
+  resumeParkedInlineWorkflow
+} from "./inline-parking.js";
+import { getInternals } from "./internals.js";
+import { processOperation, translateOperationRequest } from "./operations-router.js";
+import {
+  ensureRetentionSweepInterval,
+  hasConfiguredRetention,
+  runRetentionSweep,
+  setNextRetentionSweepAt
+} from "./retention.js";
+import { hasBufferedSignal } from "./signals.js";
+import { loadWorkflowState, runSerializedWorkflowStateWrite } from "./storage-io.js";
+import { swallowPromiseRejection } from "./strategy-helpers.js";
+import { cleanupWaiters, terminateWorkflow } from "./termination.js";
+export { createUpdateCallbacks } from "./callback-creators-bundles.js";
+export {
+  createBroadcastCallbacks,
+  createGuardCallbacks,
+  createInlineLaunchQueueCallbacks,
+  createLifecycleCallbacks,
+  createRegistrationCallbacks,
+  createTerminationCallbacks
+} from "./callback-creators-core.js";
+export function createInlineParkingCallbacks(engine) {
+  return {
+    createLifecycleCallbacks: () => createLifecycleCallbacks(engine),
+    createTerminationCallbacks: () => createTerminationCallbacks(engine),
+    evaluateConstraints: (workflowId) => evaluateConstraints(getInternals(engine), workflowId, createConstraintCallbacks(engine)),
+    getParkedWorkflowResumeDisposition: (workflowId) => getParkedWorkflowResumeDisposition(getInternals(engine), workflowId, createInlineParkingCallbacks(engine)),
+    hasBufferedSignal: (workflowId, signalName) => hasBufferedSignal(getInternals(engine), workflowId, signalName),
+    loadWorkflowState: (workflowId) => loadWorkflowState(getInternals(engine), workflowId),
+    parkInlineWorkflowAfterCheckpoint: (workflowId, operation) => parkInlineWorkflowAfterCheckpoint(getInternals(engine), workflowId, operation, createInlineParkingCallbacks(engine)),
+    persistCheckpoint: (workflowId, operation, workerCheckpointBytes) => persistCheckpointForEngine(engine, workflowId, operation, workerCheckpointBytes),
+    processOperation: (workflowId, operation) => processOperation(getInternals(engine), workflowId, operation, createOperationRouterCallbacks(engine)),
+    readCheckpointBytes: (workflowId) => getInternals(engine).storage.get(KEYS.checkpoint(workflowId)),
+    resumeParkedInlineWorkflow: (workflowId) => resumeParkedInlineWorkflow(getInternals(engine), workflowId, createInlineParkingCallbacks(engine)),
+    runSerializedWorkflowStateWrite: (workflowId, writeOperation) => runSerializedWorkflowStateWrite(getInternals(engine), workflowId, writeOperation),
+    translateOperationRequest: (operationRequest) => translateOperationRequest(getInternals(engine), operationRequest),
+    validateDevelopmentCheckpoint: (workflowId) => validateDevelopmentCheckpoint(getInternals(engine), workflowId, {
+      dispatchEvent: (event) => {
+        engine.dispatchEvent(event);
+      }
+    })
+  };
+}
+export function persistCheckpointForEngine(engine, workflowId, operation, workerCheckpointBytes) {
+  return persistCheckpoint(getInternals(engine), workflowId, operation, workerCheckpointBytes, {
+    appendTimelineBatchOperations: (id, checkpointOperation, step, timestamp, operations) => appendTimelineBatchOperations(getInternals(engine), id, checkpointOperation, step, timestamp, operations),
+    swallowPromiseRejection: (promise) => {
+      swallowPromiseRejection(promise);
+    },
+    validateAttributeValueSizes,
+    pruneCheckpointHistory: (id, step) => pruneCheckpointHistory(getInternals(engine), id, step),
+    dispatchEvent: (event) => {
+      engine.dispatchEvent(event);
+    },
+    enforceHistoryCircuitBreaker: (id) => terminateWorkflow(getInternals(engine), id, "timed-out", createTerminationCallbacks(engine), HISTORY_CIRCUIT_BREAKER_REASON)
+  });
+}
+function ensureRetentionSweepIntervalForEngine(engine) {
+  ensureRetentionSweepInterval(getInternals(engine), {
+    hasConfiguredRetention: () => hasConfiguredRetention(getInternals(engine)),
+    runRetentionSweep: () => runRetentionSweep(getInternals(engine), (source, error) => createTerminationCallbacks(engine).handleCleanupError(source, error), (workflowId) => cleanupWaiters(getInternals(engine), workflowId, createTerminationCallbacks(engine))),
+    setNextRetentionSweepAt: () => setNextRetentionSweepAt(getInternals(engine))
+  });
+}
+registerEnsureRetentionSweepInterval((engine) => ensureRetentionSweepIntervalForEngine(engine));

package/dist/core/engine/cancel-handlers.d.ts

@@ -0,0 +1,6 @@
+import type { EngineInternals } from './internals.ts';
+export type CancelHandler = () => Promise<void> | void;
+export declare function registerCancelHandler(internals: EngineInternals, workflowId: string, handler: CancelHandler): () => void;
+export declare function createCancelHandlerRegistration(internals: EngineInternals, workflowId: string): (handler: CancelHandler) => () => void;
+export declare function resetCancelHandlers(internals: EngineInternals, workflowId: string): void;
+export declare function takeCancelHandlers(internals: EngineInternals, workflowId: string): CancelHandler[];

package/dist/core/engine/cancel-handlers.js

@@ -0,0 +1,32 @@
+export function registerCancelHandler(internals, workflowId, handler) {
+  internals.cancelHandlersByWorkflow ??= new Map;
+  let handlers = internals.cancelHandlersByWorkflow.get(workflowId);
+  if (handlers === void 0) {
+    handlers = [];
+    internals.cancelHandlersByWorkflow.set(workflowId, handlers);
+  }
+  handlers.push(handler);
+  return () => {
+    const currentHandlers = internals.cancelHandlersByWorkflow.get(workflowId);
+    if (currentHandlers === void 0)
+      return;
+    const handlerIndex = currentHandlers.indexOf(handler);
+    if (handlerIndex !== -1)
+      currentHandlers.splice(handlerIndex, 1);
+    if (currentHandlers.length === 0)
+      internals.cancelHandlersByWorkflow.delete(workflowId);
+  };
+}
+export function createCancelHandlerRegistration(internals, workflowId) {
+  return (handler) => registerCancelHandler(internals, workflowId, handler);
+}
+export function resetCancelHandlers(internals, workflowId) {
+  internals.cancelHandlersByWorkflow ??= new Map;
+  internals.cancelHandlersByWorkflow.delete(workflowId);
+}
+export function takeCancelHandlers(internals, workflowId) {
+  internals.cancelHandlersByWorkflow ??= new Map;
+  const handlers = internals.cancelHandlersByWorkflow.get(workflowId) ?? [];
+  internals.cancelHandlersByWorkflow.delete(workflowId);
+  return handlers;
+}

package/dist/core/engine/checkpoint-commit-snapshots.d.ts

@@ -0,0 +1,4 @@
+import type { EngineInternals } from './internals.ts';
+export declare function rememberCommittedCheckpointBytes(internals: EngineInternals, workflowId: string, serialized: Uint8Array): void;
+export declare function getCommittedCheckpointBytes(internals: EngineInternals, workflowId: string): Uint8Array | undefined;
+export declare function forgetCommittedCheckpointBytes(internals: EngineInternals, workflowId: string): void;

package/dist/core/engine/checkpoint-commit-snapshots.js

@@ -0,0 +1,16 @@
+const committedCheckpointBytes = new WeakMap;
+export function rememberCommittedCheckpointBytes(internals, workflowId, serialized) {
+  let bytesByWorkflowId = committedCheckpointBytes.get(internals);
+  if (!bytesByWorkflowId) {
+    bytesByWorkflowId = new Map;
+    committedCheckpointBytes.set(internals, bytesByWorkflowId);
+  }
+  bytesByWorkflowId.set(workflowId, new Uint8Array(serialized));
+}
+export function getCommittedCheckpointBytes(internals, workflowId) {
+  const committedBytes = committedCheckpointBytes.get(internals)?.get(workflowId);
+  return committedBytes ? new Uint8Array(committedBytes) : void 0;
+}
+export function forgetCommittedCheckpointBytes(internals, workflowId) {
+  committedCheckpointBytes.get(internals)?.delete(workflowId);
+}

package/dist/core/engine/checkpoint-io.d.ts

@@ -0,0 +1,34 @@
+import type { BatchOperation } from '../../storage/interface.ts';
+import type { ContextOperationRequest } from '../context.ts';
+import type { SearchAttributeValue, WorkflowTimelineEntry } from '../types.ts';
+import type { EngineInternals } from './internals.ts';
+type PendingTimelineEntryValue = {
+    startedAt: number;
+    entry: WorkflowTimelineEntry;
+};
+type PersistCheckpointCallbacks = {
+    appendTimelineBatchOperations: (workflowId: string, operation: ContextOperationRequest, step: number, timestamp: number, operations: BatchOperation[]) => PendingTimelineEntryValue;
+    swallowPromiseRejection: (promise: Promise<void>) => void;
+    validateAttributeValueSizes: (attributes: Record<string, SearchAttributeValue>) => void;
+    pruneCheckpointHistory: (workflowId: string, step: number) => Promise<void>;
+    dispatchEvent: (event: Event) => void;
+    /**
+     * Force the workflow to a terminal `timed-out` state because its event-log
+     * record count breached the configured history circuit-breaker threshold.
+     * Awaited synchronously on the commit path so no further checkpoint can be
+     * written after the breaching one; a rejection propagates out of
+     * {@link commitCheckpoint} (the checkpoint has already committed durably).
+     */
+    enforceHistoryCircuitBreaker: (workflowId: string) => Promise<void>;
+};
+type DevelopmentCheckpointCallbacks = {
+    dispatchEvent: (event: Event) => void;
+};
+export declare function appendTimelineBatchOperations(internals: EngineInternals, workflowId: string, operation: ContextOperationRequest, step: number, timestamp: number, operations: BatchOperation[]): PendingTimelineEntryValue;
+/** Persist a workflow checkpoint, history entry, timeline record, and event log record. */
+export declare function persistCheckpoint(internals: EngineInternals, workflowId: string, operation: ContextOperationRequest, workerCheckpointBytes: ArrayBuffer | undefined, callbacks: PersistCheckpointCallbacks): Promise<void>;
+/** Delete the single checkpoint history entry that overflows the retention limit. */
+export declare function pruneCheckpointHistory(internals: EngineInternals, workflowId: string, currentStep: number): Promise<void>;
+/** Validate checkpoint serialization in development mode and dispatch warnings. */
+export declare function validateDevelopmentCheckpoint(internals: EngineInternals, workflowId: string, callbacks: DevelopmentCheckpointCallbacks): void;
+export {};