@lostgradient/weft 0.2.0

package/dist/core/engine/bulk-operations-shared.js

@@ -0,0 +1,198 @@
+import { KEYS } from "../../storage/interface.js";
+import { encode } from "../codec.js";
+import { computeSemanticHash } from "../effect-log/index.js";
+import { searchAttributeName } from "../search-attributes.js";
+import {
+  MAX_BULK_CONFIRMATION_TOKEN_LENGTH,
+  MAX_BULK_OPERATION_REQUEST_ID_LENGTH
+} from "../types/bulk.js";
+import { normalizeWorkflowTags } from "../workflow-tags.js";
+import {
+  BulkDeleteRequiresTerminalWorkflowsError,
+  BulkOperationConfirmationError
+} from "./errors.js";
+import { streamWorkflowStateBatches } from "./listing.js";
+import { isTerminalWorkflowStatus } from "./validation.js";
+export const BULK_OPERATION_SAMPLE_LIMIT = 20;
+const DEFAULT_BULK_OPERATION_PRINCIPAL = { method: "in-process" };
+export function buildActionableBulkWorkflowFilter(_internals, filter, actionableStatuses) {
+  const effectiveStatuses = (filter.status === void 0 ? actionableStatuses : Array.isArray(filter.status) ? filter.status : [filter.status]).filter((status) => actionableStatuses.includes(status));
+  if (effectiveStatuses.length === 0)
+    return { ...filter, status: [] };
+  if (effectiveStatuses.length !== 1)
+    return { ...filter, status: effectiveStatuses };
+  const [effectiveStatus] = effectiveStatuses;
+  return { ...filter, status: effectiveStatus ?? [] };
+}
+export async function prepareBulkOperation(internals, action, scanFilter, tokenFilter, actionParameters, options) {
+  const snapshots = await snapshotMatchingWorkflowSnapshots(internals, scanFilter);
+  return buildBulkOperationPreparation(action, tokenFilter, actionParameters, snapshots, options);
+}
+export function buildBulkOperationPreparation(action, filter, actionParameters, snapshots, options) {
+  const filterSummary = summarizeBulkFilter(filter), scope = summarizeBulkOperationScope(filterSummary, snapshots), requestId = resolveBulkOperationRequestId(action, filterSummary, actionParameters, scope, options), confirmationToken = deriveBulkConfirmationToken(action, filterSummary, actionParameters, snapshots), sampleWorkflowIds = scope.sampleWorkflowIds;
+  return {
+    workflowIds: snapshots.map((snapshot) => snapshot.id),
+    confirmationToken,
+    scope,
+    preview: {
+      dryRun: !0,
+      action,
+      matched: snapshots.length,
+      requestId,
+      scope,
+      sampleWorkflowIds,
+      confirmationToken,
+      confirmationTokenVersion: 1
+    }
+  };
+}
+function summarizeBulkOperationScope(filter, snapshots) {
+  const sampleWorkflowIds = snapshots.slice(0, BULK_OPERATION_SAMPLE_LIMIT).map((snapshot) => snapshot.id);
+  return {
+    matched: snapshots.length,
+    filter,
+    statuses: uniqueSorted(snapshots.map((snapshot) => snapshot.status)),
+    workflowTypes: uniqueSorted(snapshots.map((snapshot) => snapshot.type)),
+    sampleWorkflowIds,
+    sampleLimit: BULK_OPERATION_SAMPLE_LIMIT
+  };
+}
+function summarizeBulkFilter(filter) {
+  const summary = {};
+  if (filter.status !== void 0)
+    summary.status = Array.isArray(filter.status) ? uniqueSorted(filter.status) : filter.status;
+  if (filter.type !== void 0)
+    summary.type = filter.type;
+  const normalizedTags = normalizeWorkflowTags(filter.tags);
+  if (normalizedTags !== void 0)
+    summary.tags = normalizedTags;
+  if (filter.attributes !== void 0)
+    summary.attributes = filter.attributes.map((attribute) => ({
+      key: searchAttributeName(attribute.key),
+      ...attribute.value === void 0 ? {} : { value: attribute.value },
+      ...attribute.gt === void 0 ? {} : { gt: attribute.gt },
+      ...attribute.lt === void 0 ? {} : { lt: attribute.lt },
+      ...attribute.gte === void 0 ? {} : { gte: attribute.gte },
+      ...attribute.lte === void 0 ? {} : { lte: attribute.lte }
+    })).toSorted((left, right) => computeSemanticHash(left).localeCompare(computeSemanticHash(right)));
+  if (filter.limit !== void 0)
+    summary.limit = filter.limit;
+  if (filter.offset !== void 0)
+    summary.offset = filter.offset;
+  return summary;
+}
+function resolveBulkOperationRequestId(action, filterSummary, actionParameters, scope, options) {
+  const explicitRequestId = options.requestId?.trim();
+  if (explicitRequestId !== void 0 && explicitRequestId.length > 0)
+    return explicitRequestId;
+  return `bulk:${computeSemanticHash({
+    action,
+    actionParameters: sanitizeBulkTokenValue(actionParameters),
+    filterSummary,
+    matched: scope.matched,
+    sampleWorkflowIds: scope.sampleWorkflowIds
+  })}`;
+}
+function deriveBulkConfirmationToken(action, filterSummary, actionParameters, snapshots) {
+  return `bulk:${computeSemanticHash({
+    version: 1,
+    action,
+    actionParameters: sanitizeBulkTokenValue(actionParameters),
+    filterSummary,
+    workflows: snapshots.map((snapshot) => ({
+      id: snapshot.id,
+      status: snapshot.status
+    }))
+  })}`;
+}
+export function validateBulkConfirmation(options, preparation) {
+  if (options.confirmationToken === void 0)
+    return;
+  if (options.confirmationToken === preparation.confirmationToken)
+    return;
+  throw new BulkOperationConfirmationError;
+}
+export function shouldPersistBulkAudit(options) {
+  return options.confirmationToken !== void 0 || options.requestId !== void 0 || options.principal !== void 0;
+}
+export async function withBulkAuditEvent(internals, preparation, options, result, affectedCount) {
+  const auditEvent = await persistBulkOperationAuditEvent(internals, preparation, options, affectedCount);
+  return { ...result, auditEvent };
+}
+async function persistBulkOperationAuditEvent(internals, preparation, options, affectedCount) {
+  const timestamp = internals.options.getNow(), explicitRequestId = options.requestId?.trim(), requestId = explicitRequestId !== void 0 && explicitRequestId.length > 0 ? explicitRequestId : preparation.preview.requestId, auditEvent = {
+    type: "bulk-operation:audit",
+    action: preparation.preview.action,
+    requestId,
+    timestamp,
+    principal: options.principal ?? DEFAULT_BULK_OPERATION_PRINCIPAL,
+    filterSummary: preparation.scope.filter,
+    scope: preparation.scope,
+    affectedCount,
+    sampleWorkflowIds: preparation.scope.sampleWorkflowIds,
+    confirmationToken: preparation.confirmationToken
+  };
+  await internals.storage.put(KEYS.bulkOperationAudit(timestamp, requestId, preparation.confirmationToken), encode(auditEvent));
+  return auditEvent;
+}
+export function normalizeBulkOperationOptions(options) {
+  const confirmationToken = "confirmationToken" in options ? options.confirmationToken : void 0;
+  if (confirmationToken !== void 0 && confirmationToken.length > MAX_BULK_CONFIRMATION_TOKEN_LENGTH)
+    throw Error(`Field "confirmationToken" must be at most ${String(MAX_BULK_CONFIRMATION_TOKEN_LENGTH)} characters`);
+  if (options.requestId !== void 0 && options.requestId.length > MAX_BULK_OPERATION_REQUEST_ID_LENGTH)
+    throw Error(`Field "requestId" must be at most ${String(MAX_BULK_OPERATION_REQUEST_ID_LENGTH)} characters`);
+  return options;
+}
+export function toBulkOperationError(_internals, workflowId, error) {
+  return {
+    id: workflowId,
+    error: error instanceof Error ? error.message : String(error)
+  };
+}
+export async function snapshotMatchingWorkflowSnapshots(internals, filter) {
+  const snapshots = [];
+  for await (const batch of streamWorkflowStateBatches(internals, filter))
+    for (const state of batch)
+      snapshots.push(workflowStateToBulkSnapshot(state));
+  return snapshots;
+}
+export function workflowStateToBulkSnapshot(state) {
+  return {
+    id: state.id,
+    type: state.type,
+    status: state.status,
+    updatedAt: state.updatedAt
+  };
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].toSorted((left, right) => left.localeCompare(right));
+}
+function sanitizeBulkTokenValue(value) {
+  if (isBulkTokenPrimitive(value))
+    return value;
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value === "symbol")
+    return String(value);
+  if (typeof value === "function")
+    return "[function]";
+  if (Array.isArray(value))
+    return value.map(sanitizeBulkTokenValue);
+  const record = value, result = {};
+  for (const key of Object.keys(record).toSorted())
+    result[key] = sanitizeBulkTokenValue(record[key]);
+  return result;
+}
+function isBulkTokenPrimitive(value) {
+  return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+export async function collectTerminalWorkflowSnapshots(internals, filter) {
+  const snapshots = [];
+  for await (const batch of streamWorkflowStateBatches(internals, filter))
+    for (const state of batch) {
+      if (!isTerminalWorkflowStatus(state.status))
+        throw new BulkDeleteRequiresTerminalWorkflowsError;
+      snapshots.push(workflowStateToBulkSnapshot(state));
+    }
+  return snapshots;
+}

package/dist/core/engine/bulk-operations.d.ts

@@ -0,0 +1,21 @@
+import type { BulkCancelResult, BulkDeleteResult, BulkOperationCommitOptions, BulkOperationDryRunOptions, BulkOperationDryRunResult, BulkOperationOptions, BulkSignalAllCommitOptions, BulkSignalAllDryRunOptions, BulkSignalResult, BulkTagResult, ListFilter, PurgeResult } from '../types.ts';
+import { type CleanupWaiters } from './bulk-operations-purge.ts';
+import type { EngineInternals } from './internals.ts';
+export { purgeInternal, TERMINAL_CLEANUP_DELAY_MS } from './bulk-operations-purge.ts';
+export declare function purge(internals: EngineInternals, filter: ListFilter | undefined, cleanupWaiters: CleanupWaiters): Promise<PurgeResult>;
+export declare function cancelAll(internals: EngineInternals, filter: ListFilter, options: BulkOperationDryRunOptions): Promise<BulkOperationDryRunResult>;
+export declare function cancelAll(internals: EngineInternals, filter: ListFilter, options?: BulkOperationCommitOptions): Promise<BulkCancelResult>;
+export declare function cancelAll(internals: EngineInternals, filter: ListFilter, options?: BulkOperationDryRunOptions | BulkOperationCommitOptions): Promise<BulkCancelResult | BulkOperationDryRunResult>;
+export declare function signalAll(internals: EngineInternals, filter: ListFilter, name: string, payload: unknown, options: BulkSignalAllDryRunOptions): Promise<BulkOperationDryRunResult>;
+export declare function signalAll(internals: EngineInternals, filter: ListFilter, name: string, payload: unknown, options: BulkSignalAllCommitOptions): Promise<BulkSignalResult>;
+export declare function signalAll(internals: EngineInternals, filter: ListFilter, name: string, payload?: unknown, options?: BulkOperationCommitOptions): Promise<BulkSignalResult>;
+export declare function signalAll(internals: EngineInternals, filter: ListFilter, name: string, payload: unknown, options: BulkOperationOptions): Promise<BulkSignalResult | BulkOperationDryRunResult>;
+export declare function deleteAll(internals: EngineInternals, filter: ListFilter, cleanupWaiters: CleanupWaiters, options: BulkOperationDryRunOptions): Promise<BulkOperationDryRunResult>;
+export declare function deleteAll(internals: EngineInternals, filter: ListFilter, cleanupWaiters: CleanupWaiters, options?: BulkOperationCommitOptions): Promise<BulkDeleteResult>;
+export declare function deleteAll(internals: EngineInternals, filter: ListFilter, cleanupWaiters: CleanupWaiters, options?: BulkOperationDryRunOptions | BulkOperationCommitOptions): Promise<BulkDeleteResult | BulkOperationDryRunResult>;
+export declare function tagAll(internals: EngineInternals, filter: ListFilter, tags: string[], options: BulkOperationDryRunOptions): Promise<BulkOperationDryRunResult>;
+export declare function tagAll(internals: EngineInternals, filter: ListFilter, tags: string[], options?: BulkOperationCommitOptions): Promise<BulkTagResult>;
+export declare function tagAll(internals: EngineInternals, filter: ListFilter, tags: string[], options?: BulkOperationDryRunOptions | BulkOperationCommitOptions): Promise<BulkTagResult | BulkOperationDryRunResult>;
+export declare function untagAll(internals: EngineInternals, filter: ListFilter, tags: string[], options: BulkOperationDryRunOptions): Promise<BulkOperationDryRunResult>;
+export declare function untagAll(internals: EngineInternals, filter: ListFilter, tags: string[], options?: BulkOperationCommitOptions): Promise<BulkTagResult>;
+export declare function untagAll(internals: EngineInternals, filter: ListFilter, tags: string[], options?: BulkOperationDryRunOptions | BulkOperationCommitOptions): Promise<BulkTagResult | BulkOperationDryRunResult>;

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

@@ -0,0 +1,128 @@
+import { assertScopedBulkWorkflowFilter } from "../bulk-workflow-filter.js";
+import { bulkMutateWorkflowTags } from "./attributes-tags.js";
+import { purgeInternal, purgeWorkflow } from "./bulk-operations-purge.js";
+import {
+  buildActionableBulkWorkflowFilter,
+  buildBulkOperationPreparation,
+  collectTerminalWorkflowSnapshots,
+  normalizeBulkOperationOptions,
+  prepareBulkOperation,
+  shouldPersistBulkAudit,
+  toBulkOperationError,
+  validateBulkConfirmation,
+  withBulkAuditEvent
+} from "./bulk-operations-shared.js";
+import { BulkDeleteRequiresTerminalWorkflowsError } from "./errors.js";
+import { BULK_OPERATION_BATCH_SIZE } from "./listing.js";
+import { loadWorkflowState } from "./storage-io.js";
+import { isTerminalWorkflowStatus } from "./validation.js";
+export { purgeInternal, TERMINAL_CLEANUP_DELAY_MS } from "./bulk-operations-purge.js";
+const ACTIVE_WORKFLOW_STATUSES = ["pending", "running"];
+export async function purge(internals, filter, cleanupWaiters) {
+  return purgeInternal(internals, filter, { expiredOnly: !1, now: internals.options.getNow() }, cleanupWaiters);
+}
+async function runBulkCancellation(internals, filter, options = {}) {
+  options = normalizeBulkOperationOptions(options);
+  assertScopedBulkWorkflowFilter(filter);
+  const actionableFilter = buildActionableBulkWorkflowFilter(internals, filter, ACTIVE_WORKFLOW_STATUSES), preparation = await prepareBulkOperation(internals, "cancel", actionableFilter, filter, {}, options);
+  if (options.dryRun === !0)
+    return preparation.preview;
+  validateBulkConfirmation(options, preparation);
+  const workflowIdsToCancel = preparation.workflowIds;
+  let cancelled = 0;
+  const errors = [];
+  for (const workflowId of workflowIdsToCancel)
+    try {
+      await internals.engine.cancel(workflowId);
+      if ((await loadWorkflowState(internals, workflowId))?.status === "cancelled") {
+        cancelled += 1;
+        continue;
+      }
+      errors.push({ id: workflowId, error: "Workflow no longer cancellable" });
+    } catch (error) {
+      errors.push(toBulkOperationError(internals, workflowId, error));
+    }
+  const result = { cancelled, failed: errors.length, errors };
+  if (!shouldPersistBulkAudit(options))
+    return result;
+  return withBulkAuditEvent(internals, preparation, options, result, cancelled);
+}
+export async function cancelAll(internals, filter, options = {}) {
+  return runBulkCancellation(internals, filter, options);
+}
+export async function signalAll(internals, filter, name, payload, maybeOptions) {
+  const options = normalizeBulkOperationOptions(maybeOptions ?? {});
+  assertScopedBulkWorkflowFilter(filter);
+  if (name.length === 0)
+    throw Error('Field "name" must be a non-empty string');
+  const actionableFilter = buildActionableBulkWorkflowFilter(internals, filter, ACTIVE_WORKFLOW_STATUSES), preparation = await prepareBulkOperation(internals, "signal", actionableFilter, filter, { name, payload }, options);
+  if (options.dryRun === !0)
+    return preparation.preview;
+  validateBulkConfirmation(options, preparation);
+  const workflowIdsToSignal = preparation.workflowIds;
+  let signalled = 0, failed = 0;
+  for (const workflowId of workflowIdsToSignal)
+    try {
+      await internals.engine.signal(workflowId, name, payload);
+      signalled += 1;
+    } catch {
+      failed += 1;
+    }
+  const result = { signalled, failed };
+  if (!shouldPersistBulkAudit(options))
+    return result;
+  return withBulkAuditEvent(internals, preparation, options, result, signalled);
+}
+async function runBulkDeletion(internals, filter, cleanupWaiters, options = {}) {
+  options = normalizeBulkOperationOptions(options);
+  assertScopedBulkWorkflowFilter(filter);
+  const candidateWorkflowSnapshots = await collectTerminalWorkflowSnapshots(internals, filter), preparation = buildBulkOperationPreparation("delete", filter, {}, candidateWorkflowSnapshots, options);
+  if (options.dryRun === !0)
+    return preparation.preview;
+  validateBulkConfirmation(options, preparation);
+  let deleted = 0;
+  for (let batchStart = 0;batchStart < preparation.workflowIds.length; batchStart += BULK_OPERATION_BATCH_SIZE) {
+    const batchWorkflowIds = preparation.workflowIds.slice(batchStart, batchStart + BULK_OPERATION_BATCH_SIZE), workflowStatesToDelete = await loadTerminalWorkflowStatesForBatch(internals, batchWorkflowIds);
+    for (const workflowState of workflowStatesToDelete) {
+      await purgeWorkflow(internals, workflowState, cleanupWaiters);
+      deleted += 1;
+    }
+  }
+  const result = { deleted };
+  if (!shouldPersistBulkAudit(options))
+    return result;
+  return withBulkAuditEvent(internals, preparation, options, result, deleted);
+}
+export async function deleteAll(internals, filter, cleanupWaiters, options = {}) {
+  return runBulkDeletion(internals, filter, cleanupWaiters, options);
+}
+async function loadTerminalWorkflowStatesForBatch(internals, workflowIds) {
+  const workflowStates = [];
+  for (const workflowId of workflowIds) {
+    const refreshedState = await loadWorkflowState(internals, workflowId);
+    if (refreshedState === null)
+      continue;
+    if (!isTerminalWorkflowStatus(refreshedState.status))
+      throw new BulkDeleteRequiresTerminalWorkflowsError;
+    workflowStates.push(refreshedState);
+  }
+  return workflowStates;
+}
+export async function tagAll(internals, filter, tags, options = {}) {
+  return mutateTagsWithBulkControls(internals, filter, tags, "add", options);
+}
+export async function untagAll(internals, filter, tags, options = {}) {
+  return mutateTagsWithBulkControls(internals, filter, tags, "remove", options);
+}
+async function mutateTagsWithBulkControls(internals, filter, tags, mode, options) {
+  options = normalizeBulkOperationOptions(options);
+  assertScopedBulkWorkflowFilter(filter);
+  const preparation = await prepareBulkOperation(internals, mode === "add" ? "tag:add" : "tag:remove", filter, filter, { tags }, options);
+  if (options.dryRun === !0)
+    return preparation.preview;
+  validateBulkConfirmation(options, preparation);
+  const result = await bulkMutateWorkflowTags(internals, filter, tags, mode, preparation.workflowIds);
+  if (!shouldPersistBulkAudit(options))
+    return result;
+  return withBulkAuditEvent(internals, preparation, options, result, result.modified);
+}

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

@@ -0,0 +1,25 @@
+import type { ContextOperationRequest } from '../context.ts';
+import type { HumanReviewOptions } from '../review/index.ts';
+import type { ChildWorkflowOperationCallbacks } from './child-workflow.ts';
+import type { Engine } from './index.ts';
+import type { ActivityOperationCallbacks } from './operations-activity.ts';
+import type { CoordinationOperationCallbacks } from './operations-coordination.ts';
+import type { DataOperationCallbacks } from './operations-data.ts';
+import { type OperationWithCallerStack } from './operations-router.ts';
+import type { StateOperationCallbacks } from './operations-state.ts';
+import type { StreamOperationCallbacks } from './operations-stream.ts';
+import type { TimeOperationCallbacks } from './operations-time.ts';
+import { type UpdateCallbacks } from './updates.ts';
+export declare function createChildWorkflowOperationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): ChildWorkflowOperationCallbacks;
+export declare function createActivityOperationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): ActivityOperationCallbacks;
+export declare function createCoordinationOperationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): CoordinationOperationCallbacks;
+export declare function createDataOperationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): DataOperationCallbacks;
+export declare function createStateOperationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): StateOperationCallbacks;
+export declare function createStreamOperationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): StreamOperationCallbacks;
+export declare function createTimeOperationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): TimeOperationCallbacks;
+export declare function createUpdateCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): UpdateCallbacks;
+export declare function completeOperationForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, workflowId: string, value: unknown): void;
+export declare function runOperationWithResultForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, workflowId: string, operation: OperationWithCallerStack, execute: () => Promise<unknown>): Promise<void>;
+export declare function runOperationWithoutResultForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, workflowId: string, operation: OperationWithCallerStack, execute: () => Promise<void>): Promise<void>;
+export declare function executeSubOperationForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, workflowId: string, operation: ContextOperationRequest, signal?: AbortSignal, speculativeState?: import('./speculative-execution-state.ts').SpeculativeExecutionState): Promise<unknown>;
+export declare function processReviewOperationForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, workflowId: string, options: HumanReviewOptions): Promise<void>;

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

@@ -0,0 +1,154 @@
+import { UpdateCompletedEvent } from "../events.js";
+import {
+  broadcast as broadcastFromInternals,
+  dispatchPendingUpdateReceived as dispatchPendingUpdateReceivedFromBroadcast
+} from "./broadcast.js";
+import {
+  createBroadcastCallbacks,
+  createGuardCallbacks,
+  createLifecycleCallbacks,
+  createPendingUpdateCallbacks,
+  createTerminationCallbacks
+} from "./callback-creators-core.js";
+import { callRouterCallbacks } from "./callback-creators-router-registry.js";
+import {
+  createReviewOperationCallbacks,
+  handleScheduleTimerForEngine
+} from "./callback-creators-schedule.js";
+import { guardTerminalWorkflow, guardTerminalWorkflowAfterCoordinatedRequest } from "./guards.js";
+import { getInternals } from "./internals.js";
+import {
+  beginWorkflowExecution,
+  loadWorkflowStartHeaders,
+  parseStartOptionDuration,
+  setWorkflowStartHeaders,
+  startWorkflow,
+  workflowVersionTupleFromState
+} from "./lifecycle.js";
+import {
+  completeOperation,
+  runOperationWithResult,
+  runOperationWithoutResult
+} from "./operations-router.js";
+import { schedulePendingInlineUpdateDrain } from "./pending-updates.js";
+import { processReviewOperation } from "./reviews.js";
+import { loadWorkflowState, runSerializedWorkflowStateWrite } from "./storage-io.js";
+import {
+  getComposedActivityInterceptor,
+  getComposedWorkflowInterceptor
+} from "./strategy-helpers.js";
+import { executeSubOperation } from "./sub-operation.js";
+import {
+  ensureTerminalCleanupTracked,
+  failWorkflow,
+  runDeferredTerminalCleanup
+} from "./termination.js";
+import {
+  createCoordinatedUpdateResponder,
+  deliverCoordinatedUpdateToWaiterIfAvailable,
+  findPendingUpdateByName
+} from "./updates.js";
+export function createChildWorkflowOperationCallbacks(engine) {
+  return {
+    runOperationWithResult: (workflowId, operation, execute) => runOperationWithResultForEngine(engine, workflowId, operation, execute),
+    start: (type, input, options) => startWorkflow(getInternals(engine), type, input, options, void 0, createLifecycleCallbacks(engine)),
+    loadWorkflowState: (workflowId) => loadWorkflowState(getInternals(engine), workflowId),
+    getHandle: (workflowId) => engine.getHandle(workflowId),
+    getComposedWorkflowInterceptor: () => getComposedWorkflowInterceptor(getInternals(engine))
+  };
+}
+export function createActivityOperationCallbacks(engine) {
+  return {
+    runOperationWithResult: (workflowId, operation, execute) => runOperationWithResultForEngine(engine, workflowId, operation, execute),
+    getComposedActivityInterceptor: () => getComposedActivityInterceptor(getInternals(engine)),
+    getComposedWorkflowInterceptor: () => getComposedWorkflowInterceptor(getInternals(engine))
+  };
+}
+export function createCoordinationOperationCallbacks(engine) {
+  return {
+    completeOperation: (workflowId, value) => completeOperationForEngine(engine, workflowId, value),
+    runOperationWithResult: (workflowId, operation, execute) => runOperationWithResultForEngine(engine, workflowId, operation, execute),
+    executeSubOperation: (workflowId, operation, signal, speculativeState) => executeSubOperationForEngine(engine, workflowId, operation, signal, speculativeState),
+    getActivityOperationCallbacks: () => createActivityOperationCallbacks(engine)
+  };
+}
+export function createDataOperationCallbacks(engine) {
+  return {
+    runOperationWithResult: (workflowId, operation, execute) => runOperationWithResultForEngine(engine, workflowId, operation, execute)
+  };
+}
+export function createStateOperationCallbacks(engine) {
+  return {
+    runOperationWithResult: (workflowId, operation, execute) => runOperationWithResultForEngine(engine, workflowId, operation, execute),
+    ensureTerminalCleanupTracked: (workflowId) => ensureTerminalCleanupTracked(getInternals(engine), workflowId)
+  };
+}
+export function createStreamOperationCallbacks(engine) {
+  return {
+    runOperationWithResult: (workflowId, operation, execute) => runOperationWithResultForEngine(engine, workflowId, operation, execute),
+    handleCleanupError: (source, error, workflowId) => createTerminationCallbacks(engine).handleCleanupError(source, error, workflowId)
+  };
+}
+export function createTimeOperationCallbacks(engine) {
+  return {
+    completeOperation: (workflowId, value) => completeOperationForEngine(engine, workflowId, value),
+    loadWorkflowState: (workflowId) => loadWorkflowState(getInternals(engine), workflowId),
+    failWorkflow: (workflowId, error) => failWorkflow(getInternals(engine), workflowId, error, createTerminationCallbacks(engine)),
+    runSerializedWorkflowStateWrite: (workflowId, writeOperation) => runSerializedWorkflowStateWrite(getInternals(engine), workflowId, writeOperation),
+    beginWorkflowExecution: (workflowId, workflowType, input, checkpoint, executionDeadline, executionStateOwnerId, registration) => beginWorkflowExecution(getInternals(engine), workflowId, workflowType, input, checkpoint, executionDeadline, executionStateOwnerId, registration, createLifecycleCallbacks(engine)),
+    workflowVersionTupleFromState: (state) => workflowVersionTupleFromState(getInternals(engine), state, createLifecycleCallbacks(engine)),
+    setWorkflowStartHeaders: (workflowId, headers) => setWorkflowStartHeaders(getInternals(engine), workflowId, headers, createLifecycleCallbacks(engine)),
+    loadWorkflowStartHeaders: (workflowId) => loadWorkflowStartHeaders(getInternals(engine), workflowId, createLifecycleCallbacks(engine)),
+    parseStartOptionDuration: (value, fieldName) => parseStartOptionDuration(getInternals(engine), value, fieldName, createLifecycleCallbacks(engine)),
+    runDeferredTerminalCleanup: (workflowId, timerId) => runDeferredTerminalCleanup(getInternals(engine), workflowId, timerId, createTerminationCallbacks(engine)),
+    handleScheduleTimer: (entry) => handleScheduleTimerForEngine(engine, entry),
+    timeout: (workflowId) => engine.timeout(workflowId)
+  };
+}
+export function createUpdateCallbacks(engine) {
+  return {
+    dispatchEvent: (event) => engine.dispatchEvent(event),
+    broadcast: (message) => broadcastFromInternals(getInternals(engine), message, createBroadcastCallbacks(engine)),
+    completeOperation: (id, value) => completeOperationForEngine(engine, id, value),
+    guardTerminalWorkflow: (id) => guardTerminalWorkflow(getInternals(engine), id, createGuardCallbacks(engine)),
+    guardTerminalWorkflowAfterCoordinatedRequest: (id, updateId) => guardTerminalWorkflowAfterCoordinatedRequest(getInternals(engine), id, updateId, createGuardCallbacks(engine)),
+    persistCoordinatedUpdateResponse: (id, updateName, updateId, idempotencyKey, value) => persistCoordinatedUpdateResponse(engine, id, updateName, updateId, idempotencyKey, value),
+    deliverCoordinatedUpdateToWaiterIfAvailable: (id, updateRequest, dispatchReceivedEvent) => deliverCoordinatedUpdateToWaiterIfAvailable(getInternals(engine), id, updateRequest, dispatchReceivedEvent, createUpdateCallbacks(engine)),
+    dispatchPendingUpdateReceived: (id, updateName, updateRequest) => dispatchPendingUpdateReceivedFromBroadcast(getInternals(engine), id, updateName, updateRequest, createBroadcastCallbacks(engine)),
+    createCoordinatedUpdateResponder: (id, updateName, updateRequest) => createCoordinatedUpdateResponder(getInternals(engine), id, updateName, updateRequest, {
+      persistCoordinatedUpdateResponse: (workflowId, name, updateId, idempotencyKey, value) => persistCoordinatedUpdateResponse(engine, workflowId, name, updateId, idempotencyKey, value)
+    }),
+    findPendingUpdateByName: (id, name) => findPendingUpdateByName(getInternals(engine), id, name),
+    schedulePendingInlineUpdateDrain: (workflowId) => schedulePendingInlineUpdateDrain(getInternals(engine), workflowId, createPendingUpdateCallbacks(engine))
+  };
+}
+async function persistCoordinatedUpdateResponse(engine, workflowId, updateName, updateId, idempotencyKey, value) {
+  const internals = getInternals(engine), responseOperations = internals.updateCoordinator.buildResponseOperations(updateId, workflowId, value, void 0, idempotencyKey);
+  try {
+    await internals.storage.batch(responseOperations);
+    engine.dispatchEvent(new UpdateCompletedEvent(updateId, workflowId, updateName, value));
+    broadcastFromInternals(internals, { type: "update:completed", workflowId, updateId }, createBroadcastCallbacks(engine));
+  } catch (error) {
+    createTerminationCallbacks(engine).handleCleanupError("writeCoordinatedUpdateResponse", error, workflowId);
+  }
+}
+export function completeOperationForEngine(engine, workflowId, value) {
+  return completeOperation(getInternals(engine), workflowId, value, callRouterCallbacks(engine));
+}
+export async function runOperationWithResultForEngine(engine, workflowId, operation, execute) {
+  return runOperationWithResult(getInternals(engine), workflowId, operation, execute, callRouterCallbacks(engine));
+}
+export async function runOperationWithoutResultForEngine(engine, workflowId, operation, execute) {
+  return runOperationWithoutResult(getInternals(engine), workflowId, operation, execute, callRouterCallbacks(engine));
+}
+export async function executeSubOperationForEngine(engine, workflowId, operation, signal, speculativeState) {
+  return executeSubOperation(getInternals(engine), workflowId, operation, {
+    createActivityOperationCallbacks: () => createActivityOperationCallbacks(engine),
+    createChildWorkflowOperationCallbacks: () => createChildWorkflowOperationCallbacks(engine),
+    createCoordinationOperationCallbacks: () => createCoordinationOperationCallbacks(engine),
+    createStateOperationCallbacks: () => createStateOperationCallbacks(engine)
+  }, signal, speculativeState);
+}
+export async function processReviewOperationForEngine(engine, workflowId, options) {
+  return processReviewOperation(getInternals(engine), workflowId, options, createReviewOperationCallbacks(engine));
+}

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

@@ -0,0 +1,39 @@
+import { type BroadcastCallbacks } from './broadcast.ts';
+import type { ConstraintCallbacks } from './constraints.ts';
+import type { GuardCallbacks } from './guards.ts';
+import type { Engine } from './index.ts';
+import { type InlineLaunchQueueCallbacks } from './inline-launch-queue.ts';
+import { type LifecycleCallbacks } from './lifecycle.ts';
+import { type RegistrationCallbacks } from './registration.ts';
+import { type TerminationCallbacks } from './termination.ts';
+/**
+ * Public update-broadcast hook shape used by callback-bundle factories that
+ * dispatch `update:completed` events back to engine consumers.
+ */
+export type PendingUpdateBroadcastCallbacks = {
+    dispatchEvent: (event: Event) => boolean;
+    broadcast: (message: {
+        type: 'update:completed';
+        workflowId: string;
+        updateId: string;
+    }) => void;
+};
+export declare function createPendingUpdateCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): PendingUpdateBroadcastCallbacks;
+export declare function createInlineLaunchQueueCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): InlineLaunchQueueCallbacks;
+export declare function processPendingUpdatesAfterInlineAdvanceForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, workflowId: string): Promise<void>;
+export declare function createLifecycleCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): LifecycleCallbacks;
+/**
+ * Build the termination callback bundle.
+ *
+ * The `handleScheduledWorkflowTerminal` callback is parameterized so this
+ * factory does not depend on the schedule sibling module; callers wire in the
+ * schedule terminal hook from `callback-creators-schedule.ts`.
+ */
+export declare function createTerminationCallbacksWith<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, handleScheduledWorkflowTerminal: (workflowId: string) => Promise<void>): TerminationCallbacks;
+export declare function registerScheduledWorkflowTerminalHandler(handler: <TW extends object, TA extends object>(engine: Engine<TW, TA>, workflowId: string) => Promise<void>): void;
+export declare function createTerminationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): TerminationCallbacks;
+export declare function createRegistrationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): RegistrationCallbacks;
+export declare function registerEnsureRetentionSweepInterval(fn: <TW extends object, TA extends object>(engine: Engine<TW, TA>) => void): void;
+export declare function createBroadcastCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): BroadcastCallbacks;
+export declare function createGuardCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): GuardCallbacks;
+export declare function createConstraintCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): ConstraintCallbacks;