@lostgradient/weft 0.2.0

package/dist/core/engine/state-utilities.d.ts

@@ -0,0 +1,62 @@
+import type { ContextOperationRequest } from '../context.ts';
+import type { ListFilter, PaginatedResult, ScheduleFilter, ScheduleState, ScheduleSummary, WorkflowState, WorkflowSummary } from '../types.ts';
+type PaginationFilter = {
+    limit?: number;
+    offset?: number;
+};
+/**
+ * Build the unified `#workflowFeedListeners` map key. Uses `\0` as
+ * the separator: workflow ID validation (`assertValidWorkflowId`)
+ * rejects control characters, so no legal workflow ID can contain
+ * NUL, and the selector is a fixed two-member union, so no legal
+ * input can collide.
+ */
+export declare function workflowFeedListenerKey(workflowId: string, selector: 'events' | 'tokens'): string;
+/**
+ * Safely cast a `Function` stored on a ContextOperationRequest
+ * to a callable signature.  We trust the Context layer to populate
+ * `fn` with the correct reference—the Engine merely invokes it.
+ */
+export declare function callActivityFunction(fn: Function, input: unknown, context?: unknown): unknown;
+export declare function callMemoFunction(fn: Function): unknown;
+export declare function summarizeTimelineValue(value: unknown): string;
+export declare function getTimelineOperationLabel(operation: ContextOperationRequest): string;
+export declare function getTimelineReviewArtifactType(artifact: unknown): unknown;
+export declare function getTimelineBasicInputSummary(operation: ContextOperationRequest): string;
+export declare function getTimelineInputSummary(operation: ContextOperationRequest): string;
+export declare function sanitizeCheckpointLocals(locals: unknown): Record<string, unknown>;
+export declare function sanitizeCheckpointSearchAttributes(searchAttributes: unknown): Record<string, import('../types.ts').SearchAttributeValue>;
+export declare function sanitizeCheckpointState(checkpoint: import('../types.ts').CheckpointState): import('../types.ts').CheckpointState;
+export declare function sanitizeWorkflowEventPayload(payload: unknown): Record<string, unknown>;
+export declare function sanitizeTimelineSummary(summary: string | undefined): string | undefined;
+export declare function normalizeForkStep(fromStep: number): number;
+export declare function encodeWorkflowStartHeaders(headers: Map<string, string>): Uint8Array;
+export declare function decodeWorkflowStartHeaders(bytes: Uint8Array): Map<string, string>;
+export declare function selectPersistedWorkflowStartHeaders(headers: Map<string, string> | undefined): Map<string, string> | undefined;
+export declare function intersectIdentifierSets(idSets: Set<string>[]): Set<string> | null;
+export declare function matchesListFilter(state: WorkflowState, filter: ListFilter | undefined, constrainedIds: Set<string> | null, normalizedTagFilters: readonly string[] | undefined): boolean;
+/**
+ * Slice an in-memory list of {@link WorkflowSummary} into a {@link PaginatedResult}.
+ *
+ * Important note on `total` semantics: the returned `total` reflects the number
+ * of workflows that matched the supplied {@link ListFilter} (status, type, and
+ * search attribute filters). It is **not** the absolute count of workflows in
+ * storage. A UI computing "page 1 of N" from `total` will see the page count
+ * for the active filter; the unfiltered population is intentionally not
+ * surfaced through this response, since recovering it would require a separate
+ * full scan that defeats the purpose of the filter fast path.
+ */
+export declare function paginateWorkflowSummaries(items: WorkflowSummary[], filter?: ListFilter): PaginatedResult<WorkflowSummary>;
+export declare function paginateItems<T>(items: T[], filter: PaginationFilter | undefined): PaginatedResult<T>;
+export declare function normalizeValueForEncodedComparison(value: unknown): unknown;
+export declare function encodedValuesEqual(left: unknown, right: unknown): boolean;
+export declare function matchesScheduleFilter(state: ScheduleState, filter: ScheduleFilter | undefined): boolean;
+export declare function paginateScheduleSummaries(items: ScheduleSummary[], filter?: ScheduleFilter): PaginatedResult<ScheduleSummary>;
+export declare function createScheduleTimerId(scheduleId: string): string;
+export declare function createTerminalCleanupTimerId(includeOutputArtifacts: boolean, terminalCleanupToken: string): string;
+export declare function parseTerminalCleanupTimerId(timerId: string): {
+    includeOutputArtifacts: boolean;
+    terminalCleanupToken: string;
+} | null;
+export declare function clearScheduleCurrentWorkflow(state: ScheduleState): ScheduleState;
+export {};

package/dist/core/engine/state-utilities.js

@@ -0,0 +1,306 @@
+import { decode, encode } from "../codec.js";
+import { isRecord, safeDebugStringify, sanitizeDebugValueForDisplay } from "../debug-output.js";
+import { matchesWorkflowTagFilter } from "../workflow-tags.js";
+import { isPlainObjectRecord, isSanitizedSearchAttributeValue } from "./validation.js";
+const PERSISTED_WORKFLOW_START_HEADER_NAMES = new Set(["traceparent", "tracestate"]), PRESERVE_OUTPUT_TERMINAL_CLEANUP_TIMER_PREFIX = "terminal-cleanup:preserve-output:", FULL_TERMINAL_CLEANUP_TIMER_PREFIX = "terminal-cleanup:full:";
+export function workflowFeedListenerKey(workflowId, selector) {
+  return `${workflowId}\x00${selector}`;
+}
+export function callActivityFunction(fn, input, context) {
+  return fn(input, context);
+}
+export function callMemoFunction(fn) {
+  return fn();
+}
+export function summarizeTimelineValue(value) {
+  return safeDebugStringify(value);
+}
+const KEY_LABELED_OPERATIONS = new Set([
+  "memo",
+  "offload",
+  "archive",
+  "stream",
+  "state-read",
+  "state-commit"
+]);
+export function getTimelineOperationLabel(operation) {
+  if (KEY_LABELED_OPERATIONS.has(operation.type))
+    return operation.key;
+  switch (operation.type) {
+    case "activity":
+      return operation.activityName;
+    case "wait-signal":
+      return operation.signalName;
+    case "wait-update":
+      return operation.updateName;
+    case "child-workflow":
+      return operation.workflowType;
+    case "load":
+      return operation.reference.key;
+    default:
+      return operation.type;
+  }
+}
+export function getTimelineReviewArtifactType(artifact) {
+  if (typeof artifact !== "object" || artifact === null || !("type" in artifact))
+    return;
+  return artifact.type;
+}
+const KEY_ONLY_INPUT_OPERATIONS = new Set([
+  "memo",
+  "offload",
+  "stream"
+]);
+function summarizeStorageOperationInput(operation) {
+  if (KEY_ONLY_INPUT_OPERATIONS.has(operation.type))
+    return summarizeTimelineValue({
+      key: operation.key
+    });
+  switch (operation.type) {
+    case "load":
+      return summarizeTimelineValue({ key: operation.reference.key });
+    case "archive":
+      return summarizeTimelineValue({ key: operation.key, data: operation.data });
+    case "state-read":
+      return summarizeTimelineValue({ key: operation.key, scope: operation.scope });
+    case "state-commit":
+      return summarizeTimelineValue({
+        key: operation.key,
+        mode: operation.mode,
+        scope: operation.scope
+      });
+    default:
+      return;
+  }
+}
+export function getTimelineBasicInputSummary(operation) {
+  const storageSummary = summarizeStorageOperationInput(operation);
+  if (storageSummary !== void 0)
+    return storageSummary;
+  switch (operation.type) {
+    case "sleep":
+      return summarizeTimelineValue({ duration: operation.duration });
+    case "wait-signal":
+      return summarizeTimelineValue({ signalName: operation.signalName });
+    case "wait-update":
+      return summarizeTimelineValue({ updateName: operation.updateName });
+    case "parallel":
+    case "race":
+      return summarizeTimelineValue({ operationCount: operation.operations.length });
+    case "speculate":
+      return summarizeTimelineValue({ branch: "speculative" });
+    default:
+      return summarizeTimelineValue(void 0);
+  }
+}
+export function getTimelineInputSummary(operation) {
+  switch (operation.type) {
+    case "activity":
+      return summarizeTimelineValue(operation.input);
+    case "child-workflow":
+      return summarizeTimelineValue({
+        workflowType: operation.workflowType,
+        input: operation.input
+      });
+    case "run-all":
+      return summarizeTimelineValue({ branches: Object.keys(operation.branches) });
+    case "wait-review":
+      return summarizeTimelineValue({
+        reviewers: operation.reviewOptions.reviewers,
+        artifactType: getTimelineReviewArtifactType(operation.reviewOptions.artifact)
+      });
+    default:
+      return getTimelineBasicInputSummary(operation);
+  }
+}
+export function sanitizeCheckpointLocals(locals) {
+  const sanitized = sanitizeDebugValueForDisplay(locals);
+  return isRecord(sanitized) ? sanitized : {};
+}
+export function sanitizeCheckpointSearchAttributes(searchAttributes) {
+  const sanitized = sanitizeDebugValueForDisplay(searchAttributes);
+  if (!isRecord(sanitized))
+    return {};
+  const result = {};
+  for (const [key, value] of Object.entries(sanitized))
+    if (isSanitizedSearchAttributeValue(value))
+      result[key] = value;
+  return result;
+}
+export function sanitizeCheckpointState(checkpoint) {
+  return {
+    step: checkpoint.step,
+    locals: sanitizeCheckpointLocals(checkpoint.locals),
+    searchAttributes: sanitizeCheckpointSearchAttributes(checkpoint.searchAttributes),
+    version: checkpoint.version,
+    createdAt: checkpoint.createdAt
+  };
+}
+export function sanitizeWorkflowEventPayload(payload) {
+  const sanitized = sanitizeDebugValueForDisplay(payload);
+  return isRecord(sanitized) ? sanitized : { value: sanitized };
+}
+export function sanitizeTimelineSummary(summary) {
+  if (summary === void 0)
+    return;
+  try {
+    return summarizeTimelineValue(JSON.parse(summary));
+  } catch {
+    return summary;
+  }
+}
+export function normalizeForkStep(fromStep) {
+  if (!Number.isSafeInteger(fromStep) || fromStep < 0)
+    throw Error("options.fromStep must be a non-negative safe integer");
+  return fromStep;
+}
+export function encodeWorkflowStartHeaders(headers) {
+  return encode([...headers.entries()]);
+}
+export function decodeWorkflowStartHeaders(bytes) {
+  const entries = decode(bytes);
+  return new Map(entries);
+}
+export function selectPersistedWorkflowStartHeaders(headers) {
+  if (!headers || headers.size === 0)
+    return;
+  const persistedHeaders = new Map;
+  for (const [name, value] of headers) {
+    const normalizedName = name.toLowerCase();
+    if (!PERSISTED_WORKFLOW_START_HEADER_NAMES.has(normalizedName))
+      continue;
+    persistedHeaders.set(normalizedName, value);
+  }
+  return persistedHeaders.size > 0 ? persistedHeaders : void 0;
+}
+export function intersectIdentifierSets(idSets) {
+  const [firstSet, ...remainingSets] = idSets;
+  if (!firstSet)
+    return null;
+  const intersected = new Set(firstSet);
+  for (const nextSet of remainingSets)
+    for (const id of intersected)
+      if (!nextSet.has(id))
+        intersected.delete(id);
+  return intersected;
+}
+function matchesListFilterStatus(state, filter) {
+  if (filter.status === void 0)
+    return !0;
+  return (Array.isArray(filter.status) ? filter.status : [filter.status]).includes(state.status);
+}
+function matchesListFilterIdentity(state, filter) {
+  return matchesListFilterStatus(state, filter) && (filter.type === void 0 || state.type === filter.type) && (filter.idPrefix === void 0 || state.id.startsWith(filter.idPrefix));
+}
+function matchesListFilterTimeRanges(state, filter) {
+  if (filter.createdAt !== void 0 && !timestampInRange(state.createdAt, filter.createdAt))
+    return !1;
+  if (filter.updatedAt !== void 0 && !timestampInRange(state.updatedAt, filter.updatedAt))
+    return !1;
+  if (filter.executionDeadline === void 0)
+    return !0;
+  return state.executionDeadline !== void 0 && timestampInRange(state.executionDeadline, filter.executionDeadline);
+}
+function matchesListFilterFailureCategory(state, filter) {
+  if (filter.failureCategory === void 0)
+    return !0;
+  const categories = Array.isArray(filter.failureCategory) ? filter.failureCategory : [filter.failureCategory];
+  return state.failureCategory !== void 0 && state.failureCategory !== null && categories.includes(state.failureCategory);
+}
+export function matchesListFilter(state, filter, constrainedIds, normalizedTagFilters) {
+  if (constrainedIds !== null && !constrainedIds.has(state.id))
+    return !1;
+  if (!matchesWorkflowTagFilter(state.tags, normalizedTagFilters))
+    return !1;
+  if (filter === void 0)
+    return !0;
+  if (!matchesListFilterIdentity(state, filter))
+    return !1;
+  if (!matchesListFilterTimeRanges(state, filter))
+    return !1;
+  if (!matchesListFilterFailureCategory(state, filter))
+    return !1;
+  return !0;
+}
+function timestampInRange(value, range) {
+  if (range.gte !== void 0 && value < range.gte)
+    return !1;
+  if (range.gt !== void 0 && value <= range.gt)
+    return !1;
+  if (range.lte !== void 0 && value > range.lte)
+    return !1;
+  if (range.lt !== void 0 && value >= range.lt)
+    return !1;
+  return !0;
+}
+export function paginateWorkflowSummaries(items, filter) {
+  return paginateItems(items, filter);
+}
+export function paginateItems(items, filter) {
+  const offset = filter?.offset ?? 0, limit = filter?.limit ?? items.length;
+  return {
+    items: items.slice(offset, offset + limit),
+    total: items.length,
+    offset,
+    limit
+  };
+}
+export function normalizeValueForEncodedComparison(value) {
+  if (Array.isArray(value))
+    return value.map((entry) => normalizeValueForEncodedComparison(entry));
+  if (!isPlainObjectRecord(value))
+    return value;
+  const normalizedRecord = {};
+  for (const key of Object.keys(value).toSorted())
+    normalizedRecord[key] = normalizeValueForEncodedComparison(value[key]);
+  return normalizedRecord;
+}
+export function encodedValuesEqual(left, right) {
+  const leftEncoded = encode(normalizeValueForEncodedComparison(left)), rightEncoded = encode(normalizeValueForEncodedComparison(right));
+  if (leftEncoded.byteLength !== rightEncoded.byteLength)
+    return !1;
+  for (let index = 0;index < leftEncoded.byteLength; index++)
+    if (leftEncoded[index] !== rightEncoded[index])
+      return !1;
+  return !0;
+}
+export function matchesScheduleFilter(state, filter) {
+  if (filter?.status !== void 0) {
+    if (!(Array.isArray(filter.status) ? filter.status : [filter.status]).includes(state.status))
+      return !1;
+  }
+  return filter?.workflowType === void 0 || state.workflowType === filter.workflowType;
+}
+export function paginateScheduleSummaries(items, filter) {
+  const sortedItems = items.toSorted((left, right) => {
+    if (left.createdAt !== right.createdAt)
+      return left.createdAt - right.createdAt;
+    return left.id.localeCompare(right.id);
+  });
+  return paginateItems(sortedItems, filter);
+}
+export function createScheduleTimerId(scheduleId) {
+  return `schedule:${scheduleId}`;
+}
+export function createTerminalCleanupTimerId(includeOutputArtifacts, terminalCleanupToken) {
+  return includeOutputArtifacts ? `${FULL_TERMINAL_CLEANUP_TIMER_PREFIX}${terminalCleanupToken}` : `${PRESERVE_OUTPUT_TERMINAL_CLEANUP_TIMER_PREFIX}${terminalCleanupToken}`;
+}
+export function parseTerminalCleanupTimerId(timerId) {
+  const parseTerminalCleanupToken = (prefix) => {
+    const token = timerId.slice(prefix.length);
+    return token.length === 0 ? null : token;
+  };
+  if (timerId.startsWith(FULL_TERMINAL_CLEANUP_TIMER_PREFIX)) {
+    const terminalCleanupToken = parseTerminalCleanupToken(FULL_TERMINAL_CLEANUP_TIMER_PREFIX);
+    return terminalCleanupToken === null ? null : { includeOutputArtifacts: !0, terminalCleanupToken };
+  }
+  if (timerId.startsWith(PRESERVE_OUTPUT_TERMINAL_CLEANUP_TIMER_PREFIX)) {
+    const terminalCleanupToken = parseTerminalCleanupToken(PRESERVE_OUTPUT_TERMINAL_CLEANUP_TIMER_PREFIX);
+    return terminalCleanupToken === null ? null : { includeOutputArtifacts: !1, terminalCleanupToken };
+  }
+  return null;
+}
+export function clearScheduleCurrentWorkflow(state) {
+  const { currentWorkflowId: _currentWorkflowId, ...rest } = state;
+  return rest;
+}

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

@@ -0,0 +1,21 @@
+import { type BatchOperation } from '../../storage/interface.ts';
+import type { ScheduleState, WorkflowState } from '../types.ts';
+import type { EngineInternals } from './internals.ts';
+/** Run a workflow-state write after any earlier write for that workflow has settled. */
+export declare function runSerializedWorkflowStateWrite<TResult>(internals: EngineInternals, workflowId: string, writeOperation: () => Promise<TResult>): Promise<TResult>;
+/** Load and decode persisted workflow state by workflow ID. */
+export declare function loadWorkflowState(internals: EngineInternals, workflowId: string): Promise<WorkflowState | null>;
+/** Load a terminal workflow result or throw the persisted terminal error. */
+export declare function loadWorkflowResult(internals: EngineInternals, workflowId: string): Promise<unknown>;
+/** Commit workflow state operations. */
+export declare function commitWorkflowStateOperations(internals: EngineInternals, _state: WorkflowState, operations: BatchOperation[]): Promise<void>;
+/** Load and decode persisted schedule state by schedule ID. */
+export declare function loadScheduleState(internals: EngineInternals, scheduleId: string): Promise<ScheduleState | null>;
+/** Load a schedule state. */
+export declare function requireScheduleState(internals: EngineInternals, scheduleId: string): Promise<ScheduleState>;
+/** Persist schedule state and optionally write the next schedule timer. */
+export declare function writeScheduleState(internals: EngineInternals, state: ScheduleState, options?: {
+    includeTimer?: boolean;
+}): Promise<void>;
+/** Load persisted workflow start headers by workflow ID. */
+export declare function loadWorkflowStartHeaders(internals: EngineInternals, workflowId: string): Promise<Map<string, string> | undefined>;

package/dist/core/engine/storage-io.js

@@ -0,0 +1,82 @@
+import { KEYS } from "../../storage/interface.js";
+import { encode } from "../codec.js";
+import { buildTimerBatchOperations } from "../scheduler.js";
+import { WorkflowTimeoutError } from "../timeouts.js";
+import { getWorkflowExecutionStartedAt } from "./handles.js";
+import { createScheduleTimerId, decodeWorkflowStartHeaders } from "./state-utilities.js";
+import { decodeWorkflowState } from "./validation.js";
+import { decodeScheduleState } from "./validation/schedule.js";
+export async function runSerializedWorkflowStateWrite(internals, workflowId, writeOperation) {
+  const execution = (internals.workflowStateWriteChains.get(workflowId) ?? Promise.resolve()).catch(() => {
+    return;
+  }).then(writeOperation), settledExecution = execution.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  internals.workflowStateWriteChains.set(workflowId, settledExecution);
+  try {
+    return await execution;
+  } finally {
+    if (internals.workflowStateWriteChains.get(workflowId) === settledExecution)
+      internals.workflowStateWriteChains.delete(workflowId);
+  }
+}
+export async function loadWorkflowState(internals, workflowId) {
+  const bytes = await internals.storage.get(KEYS.workflow(workflowId));
+  if (!bytes)
+    return null;
+  return decodeWorkflowState(bytes);
+}
+export async function loadWorkflowResult(internals, workflowId) {
+  const state = await loadWorkflowState(internals, workflowId);
+  if (!state)
+    throw Error(`Workflow "${workflowId}" not found`);
+  if (state.status === "completed")
+    return state.result;
+  if (state.status === "failed") {
+    const restoredError = Error(state.error ?? "Workflow failed");
+    if (state.errorStack)
+      restoredError.stack = state.errorStack;
+    throw restoredError;
+  }
+  if (state.status === "cancelled")
+    throw Error("Workflow cancelled");
+  if (state.status === "timed-out") {
+    const elapsed = state.executionDeadline ? state.executionDeadline - getWorkflowExecutionStartedAt(state) : 0;
+    throw new WorkflowTimeoutError(workflowId, "execution", elapsed);
+  }
+  throw Error(`Workflow "${workflowId}" is still ${state.status}`);
+}
+export async function commitWorkflowStateOperations(internals, _state, operations) {
+  await internals.storage.batch(operations);
+}
+export async function loadScheduleState(internals, scheduleId) {
+  const bytes = await internals.storage.get(KEYS.schedule(scheduleId));
+  return bytes ? decodeScheduleState(bytes) : null;
+}
+export async function requireScheduleState(internals, scheduleId) {
+  const state = await loadScheduleState(internals, scheduleId);
+  if (!state)
+    throw Error(`Schedule "${scheduleId}" not found`);
+  return state;
+}
+export async function writeScheduleState(internals, state, options) {
+  const operations = [
+    { type: "put", key: KEYS.schedule(state.id), value: encode(state) }
+  ];
+  if ((options?.includeTimer ?? state.status === "active") && state.status === "active" && state.nextFireAt !== null)
+    operations.push(...buildTimerBatchOperations({
+      id: createScheduleTimerId(state.id),
+      workflowId: state.id,
+      fireAt: state.nextFireAt,
+      kind: "schedule"
+    }));
+  await internals.storage.batch(operations);
+}
+export async function loadWorkflowStartHeaders(internals, workflowId) {
+  const bytes = await internals.storage.get(KEYS.workflowHeaders(workflowId));
+  if (!bytes)
+    return;
+  return decodeWorkflowStartHeaders(bytes);
+}

package/dist/core/engine/strategy-helpers.d.ts

@@ -0,0 +1,27 @@
+import type { ComposedActivityInterceptor, ComposedWorkflowInterceptor } from '../interceptor.ts';
+import type { OperationOutcome } from '../types.ts';
+import type { EngineInternals } from './internals.ts';
+/**
+ * Wrapper that carries a captured rejection reason alongside a presence
+ * flag, so callers can distinguish "no reason captured" from "reason
+ * captured and happens to be `undefined`" (a workflow that threw
+ * `undefined` explicitly). Using a wrapper instead of `arguments.length`
+ * avoids tripping the lint rule against `arguments`.
+ */
+export type CapturedRejectionReason = {
+    value: unknown;
+};
+/**
+ * Feed an operation outcome back to the strategy. For failures, callers
+ * pass the original thrown reason via a `CapturedRejectionReason`
+ * wrapper so the workflow throw boundary can rethrow it as-is —
+ * matching `Promise.all`'s rethrow semantics for non-`Error` values
+ * like strings or `undefined`. The string-form `outcome.error` is used
+ * only for storage/timeline metadata. When the reason wasn't captured
+ * (worker-strategy resume path), we fall back to constructing an Error
+ * from the outcome message.
+ */
+export declare function feedOperationResult(internals: EngineInternals, workflowId: string, outcome: OperationOutcome, originalReason?: CapturedRejectionReason): void;
+export declare function swallowPromiseRejection(promise: Promise<unknown> | undefined): Promise<void>;
+export declare function getComposedWorkflowInterceptor(internals: EngineInternals): ComposedWorkflowInterceptor | null;
+export declare function getComposedActivityInterceptor(internals: EngineInternals): ComposedActivityInterceptor | null;

package/dist/core/engine/strategy-helpers.js

@@ -0,0 +1,47 @@
+import { serializeCheckpoint } from "../checkpoint.js";
+import { errorFromFailedOperationOutcome } from "../failure-categories.js";
+import {
+  composeActivityInterceptors,
+  composeWorkflowInterceptors,
+  splitInterceptors
+} from "../interceptor.js";
+export function feedOperationResult(internals, workflowId, outcome, originalReason) {
+  if (internals.inlineStrategy) {
+    if (outcome.status === "completed")
+      internals.inlineStrategy.continueWorkflow(workflowId, outcome.value);
+    else
+      internals.inlineStrategy.throwIntoWorkflow(workflowId, originalReason !== void 0 ? originalReason.value : errorFromFailedOperationOutcome(outcome), outcome.failureCategory);
+    return;
+  }
+  const checkpoint = internals.checkpoints.get(workflowId), serialized = checkpoint ? serializeCheckpoint(checkpoint) : new ArrayBuffer(0);
+  internals.strategy.resumeWorkflow({
+    workflowId,
+    checkpoint: serialized,
+    operationResult: outcome
+  });
+}
+export async function swallowPromiseRejection(promise) {
+  if (!promise)
+    return;
+  try {
+    await promise;
+  } catch {}
+}
+export function getComposedWorkflowInterceptor(internals) {
+  if (internals.interceptors.length === 0)
+    return null;
+  if (internals.composedWorkflowInterceptor !== void 0)
+    return internals.composedWorkflowInterceptor;
+  const workflowSlice = splitInterceptors(internals.interceptors).workflow;
+  internals.composedWorkflowInterceptor = workflowSlice.length === 0 ? null : composeWorkflowInterceptors(workflowSlice);
+  return internals.composedWorkflowInterceptor;
+}
+export function getComposedActivityInterceptor(internals) {
+  if (internals.interceptors.length === 0)
+    return null;
+  if (internals.composedActivityInterceptor !== void 0)
+    return internals.composedActivityInterceptor;
+  const activitySlice = splitInterceptors(internals.interceptors).activity;
+  internals.composedActivityInterceptor = activitySlice.length === 0 ? null : composeActivityInterceptors(activitySlice);
+  return internals.composedActivityInterceptor;
+}

package/dist/core/engine/stream-chunk-loading.d.ts

@@ -0,0 +1,5 @@
+import { type Storage } from '../../storage/interface.ts';
+import type { StoredStreamChunk } from '../context.ts';
+export declare function loadStoredStreamChunks(storage: Storage, workflowId: string, key: string, options?: {
+    after?: number;
+}): Promise<StoredStreamChunk[]>;

package/dist/core/engine/stream-chunk-loading.js

@@ -0,0 +1,22 @@
+import { KEYS } from "../../storage/interface.js";
+import { decode } from "../codec.js";
+const STREAM_CHUNK_SEQUENCE_PATTERN = /^\d+$/;
+function parseStreamChunkSequence(sequenceText) {
+  if (!STREAM_CHUNK_SEQUENCE_PATTERN.test(sequenceText))
+    return;
+  const sequence = Number.parseInt(sequenceText, 10);
+  return Number.isSafeInteger(sequence) ? sequence : void 0;
+}
+export async function loadStoredStreamChunks(storage, workflowId, key, options) {
+  const after = options?.after, prefix = KEYS.streamChunkPrefix(workflowId, key), chunks = [], scanOptions = after !== void 0 && after >= 0 ? { gt: KEYS.streamChunk(workflowId, key, after) } : void 0;
+  for await (const [storageKey, chunkBytes] of storage.scan(prefix, scanOptions)) {
+    const sequenceText = storageKey.slice(prefix.length), sequence = parseStreamChunkSequence(sequenceText);
+    if (sequence === void 0)
+      continue;
+    chunks.push({
+      sequence,
+      value: decode(chunkBytes)
+    });
+  }
+  return chunks;
+}

package/dist/core/engine/sub-operation.d.ts

@@ -0,0 +1,24 @@
+import type { ContextOperationRequest } from '../context.ts';
+import type { HumanReviewOptions } from '../review/index.ts';
+import { type ChildWorkflowOperationCallbacks } from './child-workflow.ts';
+import type { EngineInternals } from './internals.ts';
+import { type ActivityOperationCallbacks } from './operations-activity.ts';
+import { type CoordinationOperationCallbacks } from './operations-coordination.ts';
+import type { OperationWithCallerStack } from './operations-router.ts';
+import type { StateOperationCallbacks } from './operations-state.ts';
+import type { SpeculativeExecutionState } from './speculative-execution-state.ts';
+type SubOperationCallbacks = {
+    createActivityOperationCallbacks: () => ActivityOperationCallbacks;
+    createChildWorkflowOperationCallbacks: () => ChildWorkflowOperationCallbacks;
+    createCoordinationOperationCallbacks: () => CoordinationOperationCallbacks;
+    createStateOperationCallbacks: () => StateOperationCallbacks;
+};
+type WaitReviewOperationCallbacks = {
+    runOperationWithoutResult: (workflowId: string, operation: OperationWithCallerStack, execute: () => Promise<void>) => Promise<void>;
+    processReviewOperation: (workflowId: string, options: HumanReviewOptions) => Promise<void>;
+};
+export declare function processWaitReviewOperation(_internals: EngineInternals, workflowId: string, operation: Extract<ContextOperationRequest, {
+    type: 'wait-review';
+}>, callbacks: WaitReviewOperationCallbacks): Promise<void>;
+export declare function executeSubOperation(internals: EngineInternals, workflowId: string, operation: ContextOperationRequest, callbacks: SubOperationCallbacks, signal?: AbortSignal, speculativeState?: SpeculativeExecutionState): Promise<unknown>;
+export {};