@lostgradient/weft 0.2.0

package/dist/core/engine/index.js

@@ -0,0 +1,595 @@
+import { KEYS } from "../../storage/interface.js";
+import {
+  ActivityRegistry
+} from "../activity-registry.js";
+import { AtomicState } from "../atomic-state.js";
+import { createHandleCacheFinalizer } from "../engine-helpers.js";
+import { ReviewCoordinator } from "../review/index.js";
+import { Scheduler } from "../scheduler.js";
+import {
+  messageName
+} from "../types.js";
+import { UpdateCoordinator } from "../updates.js";
+import {
+  aggregate as aggregateWorkflows
+} from "./aggregate.js";
+import {
+  completeAsyncActivity as completeAsyncActivityFromInternals,
+  failAsyncActivity as failAsyncActivityFromInternals,
+  recoverPendingAsyncActivities
+} from "./async-activity-completion.js";
+import { broadcast as broadcastFromInternals } from "./broadcast.js";
+import {
+  cancelAll as cancelAllWorkflows,
+  deleteAll as deleteAllWorkflows,
+  purge as purgeWorkflows,
+  signalAll as signalAllWorkflows,
+  tagAll as tagAllWorkflows,
+  untagAll as untagAllWorkflows
+} from "./bulk-operations.js";
+import { createTimeOperationCallbacks as createTimeOperationCallbacksForEngine } from "./callback-creators-bundles.js";
+import {
+  createBroadcastCallbacks as createBroadcastCallbacksForEngine,
+  createInlineParkingCallbacks as createInlineParkingCallbacksForEngine,
+  createLifecycleCallbacks as createLifecycleCallbacksForEngine,
+  createRegistrationCallbacks as createRegistrationCallbacksForEngine,
+  createTerminationCallbacks as createTerminationCallbacksForEngine,
+  createUpdateCallbacks as createUpdateCallbacksForEngine
+} from "./callback-creators.js";
+import { registerCancelHandler } from "./cancel-handlers.js";
+import {
+  getCheckpointAt as getCheckpointStateAt,
+  getEvents as getWorkflowEvents,
+  getTimeline as getWorkflowTimeline,
+  listCheckpoints as listCheckpointHistory,
+  replayTo as replayWorkflowToCheckpoint
+} from "./checkpoint-reads.js";
+import {
+  copyWorkflowDefinition,
+  createActivityWorkerDispatcher,
+  createAlertManagerForEngine,
+  createExecutionStrategyBundle,
+  definitionEntries,
+  resolveEngineInterceptors,
+  resolveEngineOptions,
+  resolveEngineStorage,
+  typedEngineView
+} from "./construction.js";
+import { disposeEngine } from "./disposal.js";
+import {
+  consumeNextEngineLeakWarningTokenForTesting,
+  engineCleanupIntervalFinalizer
+} from "./engine-leak-warnings.js";
+import {
+  createCleanupIntervalTick,
+  createQueuedInlineWorkflowStartHandler,
+  isActivityDefinition
+} from "./engine-runtime-helpers.js";
+import { EngineCreateNameMismatchError } from "./errors.js";
+import {
+  createWorkflowHandleWithResultPromise as createWorkflowHandleWithResultPromiseFromInternals,
+  getWorkflowResultPromise as getWorkflowResultPromiseFromInternals
+} from "./handle-result.js";
+import { HANDLE_RESULT_PROMISE, ScheduleHandle, 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 {
+  fork as forkFromLifecycle,
+  recoverAll as recoverAllFromLifecycle,
+  resume as resumeFromLifecycle,
+  startWorkflow as startWorkflowFromLifecycle
+} from "./lifecycle.js";
+import {
+  addTags as addWorkflowTags,
+  getAttributes as getWorkflowAttributes,
+  list as listWorkflows,
+  removeTags as removeWorkflowTags,
+  setAttributes as setWorkflowAttributes
+} from "./listing.js";
+import { getStreamChunksFromInternals } from "./operations-stream.js";
+import {
+  handleTimerFired as handleTimerFiredFromInternals
+} from "./operations-time.js";
+import { assertCompatiblePersistedDataVersion } from "./persisted-data-version.js";
+import { query as queryWorkflow } from "./queries.js";
+import {
+  register as registerWorkflow,
+  resolveWorkflowTypeTarget as resolveWorkflowTypeTargetFromRegistration
+} from "./registration.js";
+import {
+  ensureRetentionSweepInterval,
+  getRetentionOverview as getRetentionOverviewSnapshot,
+  hasConfiguredRetention,
+  resolveWorkflowTypeRetention,
+  runRetentionSweep,
+  setNextRetentionSweepAt
+} from "./retention.js";
+import {
+  getReview as getReviewFromInternals,
+  listReviews as listReviewsFromInternals,
+  submitReview as submitReviewFromInternals
+} from "./reviews.js";
+import {
+  cancelSchedule as cancelScheduleFromInternals,
+  listSchedules as listSchedulesFromInternals,
+  pauseSchedule as pauseScheduleFromInternals,
+  resumeSchedule as resumeScheduleFromInternals,
+  schedule as scheduleFromInternals,
+  toScheduleSummary,
+  updateSchedule as updateScheduleFromInternals
+} from "./schedules.js";
+import { signal as signalWorkflow } from "./signals.js";
+import { loadScheduleState, loadWorkflowState } from "./storage-io.js";
+import {
+  feedOperationResult,
+  getComposedWorkflowInterceptor,
+  swallowPromiseRejection
+} from "./strategy-helpers.js";
+import {
+  cancelWorkflow as cancelWorkflowFromTermination,
+  cleanupWaiters as cleanupWaitersFromTermination,
+  finalizePendingTimelineEntry,
+  timeoutWorkflow as timeoutWorkflowFromTermination
+} from "./termination.js";
+import {
+  getUpdateResult as getUpdateResultFromInternals,
+  submitCoordinatedUpdate as submitCoordinatedUpdateFromInternals,
+  update as updateFromInternals
+} from "./updates.js";
+import { coerceScheduleId } from "./validation/schedule.js";
+import {
+  replayWorkflowFeed,
+  snapshotWorkflowFeedTail,
+  subscribeWorkflowFeedCommits
+} from "./workflow-feed.js";
+export {
+  ActivityReconciliationCapabilityError,
+  ActivityReconciliationConflictError,
+  ActivityReconciliationIndeterminateError
+} from "./activity-reconciliation.js";
+export { AsyncActivityTokenNotFoundError } from "./async-activity-completion.js";
+export {
+  ActivityResolutionError,
+  BulkDeleteRequiresTerminalWorkflowsError,
+  BulkOperationConfirmationError,
+  EngineCreateNameMismatchError,
+  EngineDisposedError,
+  PersistedDataIncompatibleError,
+  WorkflowAlreadyExistsError,
+  WorkflowNotFoundError,
+  WorkflowNotRegisteredError,
+  WorkflowTypeNotRegisteredForRecoveryError
+} from "./errors.js";
+export { HANDLE_RESULT_PROMISE, ScheduleHandle, WorkflowHandle } from "./handles.js";
+export {
+  clearEngineLeakWarningTokenForTesting,
+  getEngineLeakCollectionCountForTesting,
+  hasEngineLeakWarningTokenForTesting,
+  setEngineLeakWarningOverrideForTesting,
+  setNextEngineLeakWarningTokenForTesting,
+  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 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 });
+      for (const [name, definition] of definitionEntries(options.activities)) {
+        if (name !== definition.name)
+          throw new EngineCreateNameMismatchError("activity", name, definition.name);
+        engine.#registerActivityDefinition(definition);
+      }
+      for (const [name, definition] of definitionEntries(options.workflows)) {
+        if (name !== definition.name)
+          throw new EngineCreateNameMismatchError("workflow", name, definition.name);
+        engine.register(definition);
+      }
+      if (options.recover !== !1)
+        await engine.recoverAll(options.acknowledgeUnknownWorkflowTypes !== void 0 ? { acknowledgeUnknownWorkflowTypes: options.acknowledgeUnknownWorkflowTypes } : {});
+    } catch (error) {
+      await engine[Symbol.asyncDispose]();
+      throw error;
+    }
+    return engine;
+  }
+  constructor(options) {
+    super();
+    initializeInternals(this);
+    getInternals(this).registrations = new Map;
+    getInternals(this).workflowTypesByHandler = new WeakMap;
+    const storage = resolveEngineStorage(options), getNow = options?.getNow ?? Date.now, resolvedOptions = resolveEngineOptions(storage, options, getNow), strategyBundle = createExecutionStrategyBundle({
+      options,
+      getNow,
+      maxNestingDepth: resolvedOptions.maxNestingDepth,
+      development: resolvedOptions.development,
+      broadcastEvents: resolvedOptions.broadcastEvents,
+      getRegistration: getInternals(this).registrations.get.bind(getInternals(this).registrations),
+      getComposedWorkflowInterceptor: () => getComposedWorkflowInterceptor(getInternals(this)),
+      resolveWorkflowType: this.#resolveWorkflowTypeTarget.bind(this),
+      registerCancelHandler: (workflowId, handler) => registerCancelHandler(getInternals(this), workflowId, handler)
+    });
+    getInternals(this).storage = storage;
+    getInternals(this).abortController = new AbortController;
+    getInternals(this).disposed = !1;
+    getInternals(this).handleCache = new Map;
+    getInternals(this).resultResolvers = new Map;
+    getInternals(this).signalWaiters = new Map;
+    getInternals(this).signalWaitersByWorkflow = new Map;
+    getInternals(this).updateWaiters = new Map;
+    getInternals(this).updateWaitersByWorkflow = new Map;
+    getInternals(this).sleepResolvers = new Map;
+    getInternals(this).sleepResolversByWorkflow = new Map;
+    getInternals(this).interceptors = resolveEngineInterceptors(options);
+    getInternals(this).composedWorkflowInterceptor = void 0;
+    getInternals(this).composedActivityInterceptor = void 0;
+    getInternals(this).updateCoordinator = new UpdateCoordinator(storage);
+    getInternals(this).activityRegistry = new ActivityRegistry;
+    getInternals(this).activityRegistriesByWorkflow = new Map;
+    getInternals(this).workflowDefinitionsByName = new Map;
+    getInternals(this).workflowTypeByWorkflowId = new Map;
+    getInternals(this).activityWorkerDispatcher = null;
+    getInternals(this).checkpoints = new Map;
+    getInternals(this).broadcastChannel = null;
+    getInternals(this).pendingNestingDepth = void 0;
+    getInternals(this).pendingParentHeaders = void 0;
+    getInternals(this).pendingExecutionStateOwnerId = void 0;
+    getInternals(this).workflowNestingDepths = new Map;
+    getInternals(this).workflowHeaders = new Map;
+    getInternals(this).workflowStateWriteChains = new Map;
+    getInternals(this).finalizationRegistry = new FinalizationRegistry(createHandleCacheFinalizer(getInternals(this).handleCache));
+    getInternals(this).options = resolvedOptions;
+    getInternals(this).scheduler = new Scheduler({
+      storage,
+      onTimerFired: (entry) => handleTimerFiredFromInternals(getInternals(this), entry, this.#createTimeOperationCallbacks()),
+      getNow
+    });
+    getInternals(this).strategy = strategyBundle.strategy;
+    getInternals(this).inlineStrategy = strategyBundle.inlineStrategy;
+    getInternals(this).queuedInlineWorkflowStarts = [];
+    getInternals(this).queuedInlineWorkflowStartIds = new Set;
+    getInternals(this).queuedOrLaunchingInlineWorkflowStartIds = new Set;
+    getInternals(this).queuedInlineWorkflowStartFlushScheduled = !1;
+    const weakEngine = new WeakRef(this), queuedInlineWorkflowStartChannel = strategyBundle.inlineStrategy !== null ? new MessageChannel : null;
+    getInternals(this).queuedInlineWorkflowStartChannel = queuedInlineWorkflowStartChannel;
+    if (queuedInlineWorkflowStartChannel !== null)
+      queuedInlineWorkflowStartChannel.port1.onmessage = createQueuedInlineWorkflowStartHandler(weakEngine, queuedInlineWorkflowStartChannel);
+    getInternals(this).heartbeatDetails = new Map;
+    getInternals(this).pendingAsyncActivities = new Map;
+    getInternals(this).pendingStarts = new Set;
+    getInternals(this).pendingScheduleCreations = new Set;
+    getInternals(this).workflowsNeedingTerminalCleanup = new Set;
+    getInternals(this).reviewCoordinator = new ReviewCoordinator(storage, getNow);
+    getInternals(this).reviewWaiters = new Map;
+    getInternals(this).reviewWaitersByWorkflow = new Map;
+    getInternals(this).reviewEscalationHandlers = new Map;
+    getInternals(this).workflowReviewIds = new Map;
+    getInternals(this).parkedInlineWorkflows = new Set;
+    getInternals(this).terminalizingWorkflows = new Set;
+    getInternals(this).cancelHandlersByWorkflow = new Map;
+    getInternals(this).reviewTimerIds = new Map;
+    getInternals(this).pendingWebhooks = new Set;
+    getInternals(this).pendingTimelineEntries = new Map;
+    getInternals(this).cleanupIntervalDisposalTracker = null;
+    const cleanupIntervalDisposalTracker = {
+      disposed: !1,
+      cleanupInterval: null,
+      testToken: consumeNextEngineLeakWarningTokenForTesting()
+    }, cleanupInterval = setInterval(createCleanupIntervalTick(weakEngine, cleanupIntervalDisposalTracker), 60000);
+    cleanupIntervalDisposalTracker.cleanupInterval = cleanupInterval;
+    getInternals(this).cleanupInterval = cleanupInterval;
+    getInternals(this).cleanupIntervalDisposalTracker = cleanupIntervalDisposalTracker;
+    engineCleanupIntervalFinalizer.register(this, cleanupIntervalDisposalTracker, cleanupIntervalDisposalTracker);
+    getInternals(this).retentionSweepInterval = null;
+    getInternals(this).retentionSweepInFlight = null;
+    getInternals(this).nextRetentionSweepAt = null;
+    getInternals(this).eventLogHeads = new Map;
+    getInternals(this).workflowFeedListeners = new Map;
+    getInternals(this).workflowVersionTuples = new Map;
+    getInternals(this).activityWorkerDispatcher = createActivityWorkerDispatcher(options?.activityExecution);
+    getInternals(this).strategy.onMessage(this.#handleStrategyMessage.bind(this));
+    getInternals(this).alertManager = createAlertManagerForEngine(this, options?.alerts, getNow);
+    this.#ensureRetentionSweepInterval();
+  }
+  #hasConfiguredRetention() {
+    return hasConfiguredRetention(getInternals(this));
+  }
+  #setNextRetentionSweepAt() {
+    setNextRetentionSweepAt(getInternals(this));
+  }
+  #ensureRetentionSweepInterval() {
+    ensureRetentionSweepInterval(getInternals(this), {
+      hasConfiguredRetention: () => this.#hasConfiguredRetention(),
+      runRetentionSweep: () => this.#runRetentionSweep(),
+      setNextRetentionSweepAt: () => this.#setNextRetentionSweepAt()
+    });
+  }
+  async#runRetentionSweep() {
+    return runRetentionSweep(getInternals(this), (source, error) => this.#createTerminationCallbacks().handleCleanupError(source, error), (workflowId) => cleanupWaitersFromTermination(getInternals(this), workflowId, this.#createTerminationCallbacks()));
+  }
+  #createLifecycleCallbacks() {
+    return createLifecycleCallbacksForEngine(this);
+  }
+  #createTerminationCallbacks() {
+    return createTerminationCallbacksForEngine(this);
+  }
+  #createRegistrationCallbacks() {
+    return createRegistrationCallbacksForEngine(this);
+  }
+  #createBroadcastCallbacks() {
+    return createBroadcastCallbacksForEngine(this);
+  }
+  #createInlineParkingCallbacks() {
+    return createInlineParkingCallbacksForEngine(this);
+  }
+  #createUpdateCallbacks() {
+    return createUpdateCallbacksForEngine(this);
+  }
+  #createTimeOperationCallbacks() {
+    return createTimeOperationCallbacksForEngine(this);
+  }
+  #resolveWorkflowTypeTarget(target) {
+    return resolveWorkflowTypeTargetFromRegistration(getInternals(this), target, this.#createRegistrationCallbacks());
+  }
+  get state() {
+    const storage = getInternals(this).storage;
+    return {
+      execution: (ownerWorkflowId, key, options) => new AtomicState(storage, KEYS.stateExecution(ownerWorkflowId, key), options),
+      workflow: (workflowType, key, options) => new AtomicState(storage, KEYS.stateWorkflow(workflowType, key), options)
+    };
+  }
+  async#handleStrategyMessage(message) {
+    return handleStrategyMessageFromInternals(getInternals(this), message, this.#createInlineParkingCallbacks());
+  }
+  #broadcast(message) {
+    return broadcastFromInternals(getInternals(this), message, this.#createBroadcastCallbacks());
+  }
+  register(definition) {
+    if (isActivityDefinition(definition)) {
+      this.#registerActivityDefinition(definition);
+      return typedEngineView(this);
+    }
+    registerWorkflow(getInternals(this), definition, this.#createRegistrationCallbacks());
+    return typedEngineView(this);
+  }
+  registerWorkflows(workflows) {
+    for (const [name, definition] of Object.entries(workflows)) {
+      if (name !== definition.name)
+        throw new EngineCreateNameMismatchError("workflow", name, definition.name);
+      this.register(definition);
+    }
+    return typedEngineView(this);
+  }
+  addInterceptor(interceptor) {
+    getInternals(this).interceptors.push(interceptor);
+    getInternals(this).composedWorkflowInterceptor = void 0;
+    getInternals(this).composedActivityInterceptor = void 0;
+  }
+  #registerActivityDefinition(definition) {
+    getInternals(this).activityRegistry.register(definition.name, definition);
+  }
+  resolveRegisteredActivity(name) {
+    return getInternals(this).activityRegistry.resolve(name);
+  }
+  registerActivityFunction(name, fn, options) {
+    getInternals(this).activityRegistry.register(name, fn, options);
+  }
+  unregisterRegisteredActivity(name) {
+    getInternals(this).activityRegistry.unregister(name);
+  }
+  getWorkflowDefinition(type) {
+    const registration = getInternals(this).registrations.get(type);
+    return registration === void 0 ? void 0 : copyWorkflowDefinition(type, registration);
+  }
+  listWorkflowDefinitions() {
+    return [...getInternals(this).registrations.entries()].map(([type, registration]) => copyWorkflowDefinition(type, registration));
+  }
+  getActivityDefinition(name) {
+    return getInternals(this).activityRegistry.getDefinition(name);
+  }
+  listActivityDefinitions() {
+    return getInternals(this).activityRegistry.listDefinitions();
+  }
+  async start(type, input, options) {
+    return startWorkflowFromLifecycle(getInternals(this), type, input, options, void 0, this.#createLifecycleCallbacks());
+  }
+  getHandle(workflowId) {
+    const entry = getInternals(this).handleCache.get(workflowId);
+    if (entry) {
+      const existing = entry.ref.deref();
+      if (existing)
+        return existing;
+    }
+    return createWorkflowHandleWithResultPromiseFromInternals(getInternals(this), workflowId);
+  }
+  async list(filter, options) {
+    return listWorkflows(getInternals(this), filter, options);
+  }
+  async aggregate(filter, options) {
+    return aggregateWorkflows(getInternals(this), filter, options);
+  }
+  getRetentionOverview() {
+    return getRetentionOverviewSnapshot(getInternals(this), (type) => resolveWorkflowTypeRetention(getInternals(this), type));
+  }
+  async purge(filter) {
+    return purgeWorkflows(getInternals(this), filter, (workflowId) => cleanupWaitersFromTermination(getInternals(this), workflowId, this.#createTerminationCallbacks()));
+  }
+  async cancelAll(filter, options) {
+    return cancelAllWorkflows(getInternals(this), filter, options);
+  }
+  async signalAll(filter, name, payloadOrOptions, options) {
+    if (options === void 0)
+      return signalAllWorkflows(getInternals(this), filter, name, payloadOrOptions);
+    return signalAllWorkflows(getInternals(this), filter, name, payloadOrOptions, options);
+  }
+  async deleteAll(filter, options) {
+    return deleteAllWorkflows(getInternals(this), filter, (workflowId) => cleanupWaitersFromTermination(getInternals(this), workflowId, this.#createTerminationCallbacks()), options);
+  }
+  async tagAll(filter, tags, options) {
+    return tagAllWorkflows(getInternals(this), filter, tags, options);
+  }
+  async untagAll(filter, tags, options) {
+    return untagAllWorkflows(getInternals(this), filter, tags, options);
+  }
+  async schedule(typeOrDefinition, input, spec, options) {
+    if (typeof typeOrDefinition === "object") {
+      const definition = typeOrDefinition, workflowType = typeof definition.workflow === "string" ? definition.workflow : definition.workflow.name, definitionSpec = definition.every !== void 0 ? { every: definition.every } : { cron: definition.cron ?? "" };
+      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 }
+      });
+    }
+    if (spec === void 0)
+      throw Error("A cron string or schedule spec must be provided when scheduling by workflow type.");
+    return scheduleFromInternals(getInternals(this), typeOrDefinition, input, spec, options);
+  }
+  async getSchedule(scheduleId) {
+    const normalizedScheduleId = coerceScheduleId(scheduleId, "scheduleId"), state = await loadScheduleState(getInternals(this), normalizedScheduleId);
+    return state ? toScheduleSummary(state) : null;
+  }
+  async listSchedules(filter) {
+    return listSchedulesFromInternals(getInternals(this), filter);
+  }
+  async pauseSchedule(scheduleId) {
+    return pauseScheduleFromInternals(getInternals(this), scheduleId);
+  }
+  async resumeSchedule(scheduleId) {
+    return resumeScheduleFromInternals(getInternals(this), scheduleId);
+  }
+  async cancelSchedule(scheduleId) {
+    return cancelScheduleFromInternals(getInternals(this), scheduleId);
+  }
+  async updateSchedule(scheduleId, newSpec) {
+    return updateScheduleFromInternals(getInternals(this), scheduleId, newSpec);
+  }
+  [HANDLE_RESULT_PROMISE](workflowId) {
+    return getWorkflowResultPromiseFromInternals(getInternals(this), workflowId);
+  }
+  [ENGINE_PARKED_WORKFLOW_COUNT_FOR_TESTING]() {
+    return getInternals(this).parkedInlineWorkflows.size;
+  }
+  [ENGINE_SIGNAL_WAITER_COUNT_FOR_TESTING]() {
+    return getInternals(this).signalWaiters.size;
+  }
+  async signal(workflowId, nameOrDefinition, payload, options) {
+    return signalWorkflow(getInternals(this), workflowId, messageName(nameOrDefinition), payload, {
+      loadWorkflowState: (id) => loadWorkflowState(getInternals(this), id),
+      dispatchEvent: (event) => this.dispatchEvent(event),
+      broadcast: (message) => this.#broadcast(message),
+      getComposedInterceptor: () => getComposedWorkflowInterceptor(getInternals(this)),
+      resumeParkedInlineWorkflow: (id) => swallowPromiseRejection(resumeParkedInlineWorkflowFromInternals(getInternals(this), id, this.#createInlineParkingCallbacks()))
+    }, options);
+  }
+  async update(workflowId, name, payload, options) {
+    return updateFromInternals(getInternals(this), workflowId, messageName(name), payload, options, this.#createUpdateCallbacks());
+  }
+  async query(workflowId, nameOrDefinition, input) {
+    return queryWorkflow(getInternals(this), workflowId, messageName(nameOrDefinition), input);
+  }
+  async getStreamChunks(workflowId, key, options) {
+    return getStreamChunksFromInternals(getInternals(this), workflowId, key, options);
+  }
+  async fork(sourceWorkflowId, options) {
+    return forkFromLifecycle(getInternals(this), sourceWorkflowId, options, this.#createLifecycleCallbacks());
+  }
+  async resume(workflowId) {
+    return resumeFromLifecycle(getInternals(this), workflowId, this.#createLifecycleCallbacks());
+  }
+  async recoverAll(options) {
+    await recoverPendingAsyncActivities(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));
+  }
+  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));
+  }
+  async cancel(workflowId) {
+    await cancelWorkflowFromTermination(getInternals(this), workflowId, this.#createTerminationCallbacks());
+  }
+  async timeout(workflowId) {
+    await timeoutWorkflowFromTermination(getInternals(this), workflowId, this.#createTerminationCallbacks());
+  }
+  async get(workflowId) {
+    const state = await loadWorkflowState(getInternals(this), workflowId);
+    if (state?.status === "running" && hasQueuedInlineWorkflowStart(getInternals(this), workflowId))
+      return { ...state, status: "pending" };
+    return state;
+  }
+  async getAttributes(workflowId) {
+    return getWorkflowAttributes(getInternals(this), workflowId);
+  }
+  async setAttributes(workflowId, attributes) {
+    return setWorkflowAttributes(getInternals(this), workflowId, attributes);
+  }
+  async addTags(workflowId, ...tags) {
+    return addWorkflowTags(getInternals(this), workflowId, ...tags);
+  }
+  async removeTags(workflowId, ...tags) {
+    return removeWorkflowTags(getInternals(this), workflowId, ...tags);
+  }
+  async getEvents(workflowId) {
+    return getWorkflowEvents(getInternals(this), workflowId);
+  }
+  async* replayWorkflowFeed(workflowId, selector, afterSequence) {
+    yield* replayWorkflowFeed(getInternals(this), workflowId, selector, afterSequence);
+  }
+  async snapshotWorkflowFeedTail(workflowId, selector) {
+    return snapshotWorkflowFeedTail(getInternals(this), workflowId, selector);
+  }
+  subscribeWorkflowFeedCommits(workflowId, selector, listener) {
+    return subscribeWorkflowFeedCommits(getInternals(this), workflowId, selector, listener);
+  }
+  async listCheckpoints(workflowId) {
+    return listCheckpointHistory(getInternals(this), workflowId);
+  }
+  async getCheckpointAt(workflowId, step) {
+    return getCheckpointStateAt(getInternals(this), workflowId, step);
+  }
+  async getTimeline(workflowId) {
+    return getWorkflowTimeline(getInternals(this), workflowId);
+  }
+  async replayTo(workflowId, step) {
+    return replayWorkflowToCheckpoint(getInternals(this), workflowId, step);
+  }
+  async listReviews(filter) {
+    return listReviewsFromInternals(getInternals(this), filter);
+  }
+  async getReview(workflowId, reviewId) {
+    return getReviewFromInternals(getInternals(this), workflowId, reviewId);
+  }
+  async submitReview(reviewId, options) {
+    return submitReviewFromInternals(getInternals(this), reviewId, options, {
+      dispatchEvent: this.dispatchEvent.bind(this)
+    });
+  }
+  async getUpdateResult(updateId) {
+    return getUpdateResultFromInternals(getInternals(this), updateId);
+  }
+  async submitCoordinatedUpdate(workflowId, name, payload, options) {
+    return submitCoordinatedUpdateFromInternals(getInternals(this), workflowId, name, payload, options, this.#createUpdateCallbacks());
+  }
+  [Symbol.dispose]() {
+    disposeEngine(getInternals(this));
+  }
+  async[Symbol.asyncDispose]() {
+    this[Symbol.dispose]();
+  }
+  get storage() {
+    return getInternals(this).storage;
+  }
+  get scheduler() {
+    return getInternals(this).scheduler;
+  }
+  async fireTimer(entry) {
+    await handleTimerFiredFromInternals(getInternals(this), entry, this.#createTimeOperationCallbacks());
+  }
+}

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

@@ -0,0 +1,17 @@
+import type { QueuedInlineWorkflowExecutionStart } from './engine-internal-types.ts';
+import type { EngineInternals } from './internals.ts';
+export type InlineLaunchQueueCallbacks = {
+    processPendingUpdatesAfterInlineAdvance: (workflowId: string) => Promise<void>;
+    swallowPromiseRejection: (promise: Promise<unknown> | undefined) => Promise<void>;
+};
+/** 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>;
+/** Used by scheduler-driven direct backfill flushes. Clears the scheduled flag first. */
+export declare function flushQueuedInlineWorkflowStartsDirectly(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;
+export declare function hasQueuedOrLaunchingInlineWorkflowStart(internals: EngineInternals, workflowId: string): boolean;
+export declare function isInlineWorkflowLocallyOwned(internals: EngineInternals, workflowId: string, workflowStatus: string): boolean;
+export declare function hasLocalCheckpointOwnership(internals: EngineInternals, workflowId: string, workflowStatus: string): boolean;