@lostgradient/weft 0.3.0 → 0.5.0

package/dist/core/engine/lifecycle/transition.js

@@ -1,11 +1,14 @@
 import { KEYS } from "../../../storage/interface.js";
 import { deserializeCheckpoint, serializeCheckpoint } from "../../checkpoint.js";
+import { RegExpExtensionDecodeError } from "../../codec/extension-codec.js";
 import { Context, setContextWorkflowInterceptor } from "../../context.js";
 import { EMPTY_EVENT_HEAD } from "../../event-log.js";
 import { WorkflowRecoverySkippedEvent, WorkflowStartedEvent } from "../../events.js";
 import { createCancelHandlerRegistration, resetCancelHandlers } from "../cancel-handlers.js";
 import { forgetCommittedCheckpointBytes } from "../checkpoint-commit-snapshots.js";
+import { hydrateCheckpointReplayState } from "../checkpoint-replay.js";
 import { WorkflowTypeNotRegisteredForRecoveryError } from "../errors.js";
+import { commitFencedEngineWrite } from "../fenced-write.js";
 import { getWorkflowExecutionStartedAt } from "../handles.js";
 import { normalizeForkStep, selectPersistedWorkflowStartHeaders } from "../state-utilities.js";
 import { loadWorkflowState } from "../storage-io.js";
@@ -73,7 +76,15 @@ export async function recoverAll(internals, callbacks, options) {
       callbacks.dispatchEvent(new WorkflowRecoverySkippedEvent(entry.workflow.workflowId, entry.workflow.type, "type-not-registered"));
       continue;
     }
-    handles.push(await resume(internals, entry.workflowId, callbacks));
+    try {
+      handles.push(await resume(internals, entry.workflowId, callbacks));
+    } catch (error) {
+      if (error instanceof RegExpExtensionDecodeError) {
+        await callbacks.failWorkflowForCheckpointDecodeError(entry.workflowId, error);
+        continue;
+      }
+      throw error;
+    }
   }
   return handles;
 }
@@ -100,8 +111,8 @@ export async function fork(internals, sourceWorkflowId, options, callbacks) {
       throw Error(`Checkpoint not found at step ${String(fromStep)} for workflow "${sourceWorkflowId}"`);
     throw Error(`Checkpoint not found for workflow "${sourceWorkflowId}"`);
   }
-  const sourceCheckpoint = deserializeCheckpoint(checkpointBytes), preparedExecutionState = derivePreparedExecutionState(internals, sourceWorkflowId, sourceState, sourceCheckpoint, registration, callbacks), sourceWorkflowHeaders = internals.workflowHeaders.get(sourceWorkflowId) ?? await loadWorkflowStartHeaders(internals, sourceWorkflowId, callbacks), persistedWorkflowStartHeaders = selectPersistedWorkflowStartHeaders(sourceWorkflowHeaders), workflowId = crypto.randomUUID(), forkedAt = internals.options.getNow(), lineage = createForkLineage(internals, sourceWorkflowId, sourceCheckpoint, callbacks), forkCheckpoint = {
-    ...preparedExecutionState.checkpoint,
+  const storedSourceCheckpoint = deserializeCheckpoint(checkpointBytes), sourceCheckpoint = await hydrateCheckpointReplayState(internals.storage, sourceWorkflowId, storedSourceCheckpoint), preparedExecutionState = derivePreparedExecutionState(internals, sourceWorkflowId, sourceState, sourceCheckpoint, registration, callbacks), sourceWorkflowHeaders = internals.workflowHeaders.get(sourceWorkflowId) ?? await loadWorkflowStartHeaders(internals, sourceWorkflowId, callbacks), persistedWorkflowStartHeaders = selectPersistedWorkflowStartHeaders(sourceWorkflowHeaders), workflowId = crypto.randomUUID(), forkedAt = internals.options.getNow(), lineage = createForkLineage(internals, sourceWorkflowId, sourceCheckpoint, callbacks), { accumulatedResultReplayWatermark: _sourceReplayWatermark, ...sourceCheckpointForFork } = preparedExecutionState.checkpoint, forkCheckpoint = {
+    ...sourceCheckpointForFork,
     createdAt: forkedAt,
     workflowId,
     searchAttributes: buildForkSearchAttributes(internals, preparedExecutionState.checkpoint, lineage, callbacks)
@@ -109,7 +120,7 @@ export async function fork(internals, sourceWorkflowId, options, callbacks) {
   let forkStarted = !1;
   try {
     const forkCheckpointBytes = serializeCheckpoint(forkCheckpoint);
-    await internals.storage.batch(buildForkBatchOperations(internals, workflowId, forkState, forkCheckpoint, forkCheckpointBytes, persistedWorkflowStartHeaders, callbacks));
+    await commitFencedEngineWrite(internals, buildForkBatchOperations(internals, workflowId, forkState, forkCheckpoint, forkCheckpointBytes, persistedWorkflowStartHeaders, callbacks), [], () => Error(`Fork of workflow "${workflowId}" lost its CAS race.`));
     internals.eventLogHeads.set(workflowId, EMPTY_EVENT_HEAD);
     setWorkflowStartHeaders(internals, workflowId, persistedWorkflowStartHeaders, callbacks);
     const handle = launchWorkflowFromCheckpoint(internals, workflowId, forkState, forkCheckpoint, registration, callbacks);
@@ -146,7 +157,8 @@ function launchInlineWorkflowFromCheckpoint(internals, workflowId, state, checkp
       searchAttributeSchema: registration.searchAttributes
     },
     sleepReferenceTime: checkpoint.createdAt,
-    ...state.executionDeadline !== void 0 && { deadline: state.executionDeadline }
+    ...state.executionDeadline !== void 0 && { deadline: state.executionDeadline },
+    ...internals.options.onLog != null && { logSink: internals.options.onLog }
   });
   setContextWorkflowInterceptor(context, getComposedWorkflowInterceptor(internals));
   if (internals.options.development)

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

@@ -1,7 +1,7 @@
 export { EMPTY_STORAGE_VALUE, createWorkflowHandle, loadTerminalCleanupTrackedState, loadWorkflowStartHeaders, normalizeStartWorkflowTags, processPendingUpdatesAfterReplay, setWorkflowStartHeaders, type LifecycleCallbacks, type RecoverAllOptions, } from './lifecycle/shared.ts';
 export { createWorkflowVersionTuple, derivePreparedExecutionState, prepareResumeState, throwVersionMismatch, workflowStateWithVersionTuple, workflowVersionTupleFromState, } from './lifecycle/persist.ts';
 export { createInitialCheckpoint, createInitialWorkflowState, parseStartOptionDuration, resolveScheduledStartAt, start, startWorkflow, } from './lifecycle/start.ts';
-export { startOrSignal, startWithIdempotency, type StartOrSignalCallbacks, } from './lifecycle/start-or-signal.ts';
+export { startOrSignal, startWithIdempotency, type StartOrSignalCallbacks, type StartOrSignalResult, } from './lifecycle/start-or-signal.ts';
 export { buildInitialSearchAttributeOperations, buildStartBatchOperations, validateSearchAttributes, } from './lifecycle/start-batch.ts';
 export { beginWorkflowExecution, runWorkflowStartInterceptor, startWorkflowExecution, } from './lifecycle/start-exec.ts';
 export { buildForkBatchOperations, buildForkSearchAttributes, createForkLineage, createForkedWorkflowState, } from './lifecycle/fork-helpers.ts';

package/dist/core/engine/list-candidate-resolution.js

@@ -1,5 +1,5 @@
 import { intersectIdentifierSets } from "./state-utilities.js";
-import { getWorkflowVisibilityWatermark } from "./workflow-indexes.js";
+import { getCachedWorkflowVisibilityWatermark } from "./workflow-indexes.js";
 import { queryAttributeIndex, resolveConstrainedIds } from "./workflow-state-stream.js";
 import {
   queryWorkflowIdPrefixCandidates,
@@ -50,7 +50,7 @@ export async function resolveListCandidateIds(internals, filter, normalizedTagFi
     resolveConstrainedIds(internals, filter, normalizedTagFilters),
     resolveFailureCategoryCandidateIds(internals, filter?.failureCategory)
   ]);
-  if (await getWorkflowVisibilityWatermark(internals.storage) === "stale") {
+  if (await getCachedWorkflowVisibilityWatermark(internals) === "stale") {
     const queries = filter === void 0 ? [] : collectVisibilityQueries(internals, filter, ["idPrefix"]), visibilitySets = await Promise.all(queries);
     return combineCandidateSets([
       baseConstrainedIds,

package/dist/core/engine/listing.js

@@ -5,7 +5,12 @@ import { isFailureCategory, normalizeListFilter } from "../list-filter-validatio
 import { buildIndexOperations, validateAttributeType } from "../search-attributes.js";
 import { normalizeWorkflowTags } from "../workflow-tags.js";
 import { mutateWorkflowTags, validateAttributeValueSizes } from "./attributes-tags.js";
+import { CONSTRAINED_ID_CHUNK_SIZE } from "./candidate-read-batching.js";
 import { resolveListCandidateIds } from "./list-candidate-resolution.js";
+import {
+  readSearchAttributesForFilter,
+  readSearchAttributesForStates
+} from "./search-attribute-records.js";
 import { matchesListFilter, paginateWorkflowSummaries } from "./state-utilities.js";
 import { decodeWorkflowState, normalizeBulkFilterNumber } from "./validation.js";
 import { MAX_LIST_SCAN_ROWS, WorkflowListScanCapExceededError } from "./workflow-indexes.js";
@@ -18,19 +23,18 @@ export async function list(internals, filter, options) {
   const normalizedFilter = filter === void 0 ? void 0 : normalizeListFilter(filter), normalizedTagFilters = normalizeWorkflowTags(normalizedFilter?.tags), constrainedIds = await resolveListCandidateIds(internals, normalizedFilter, normalizedTagFilters), items = constrainedIds !== null ? await collectSummariesFromConstrainedIds(internals, constrainedIds, normalizedFilter, normalizedTagFilters, options) : await collectSummariesFromFullScan(internals, normalizedFilter, normalizedTagFilters, options);
   return paginateWorkflowSummaries(sortSummariesByCreatedAtDescending(items), normalizedFilter);
 }
-const CONSTRAINED_ID_CHUNK_SIZE = 64;
 async function collectSummariesFromConstrainedIds(internals, constrainedIds, normalizedFilter, normalizedTagFilters, options) {
   const orderedIds = [...constrainedIds];
   if (orderedIds.length > MAX_LIST_SCAN_ROWS)
     throw new WorkflowListScanCapExceededError(MAX_LIST_SCAN_ROWS);
   const items = [];
   for (let start = 0;start < orderedIds.length; start += CONSTRAINED_ID_CHUNK_SIZE) {
-    const chunkIds = orderedIds.slice(start, start + CONSTRAINED_ID_CHUNK_SIZE), chunkBytes = await Promise.all(chunkIds.map((workflowId) => internals.storage.get(KEYS.workflow(workflowId)))), matchingStates = [];
+    const chunkIds = orderedIds.slice(start, start + CONSTRAINED_ID_CHUNK_SIZE), chunkBytes = await Promise.all(chunkIds.map((workflowId) => internals.storage.get(KEYS.workflow(workflowId)))), searchAttributesByWorkflowId = await readSearchAttributesForStates(internals, chunkBytes, normalizedFilter), matchingStates = [];
     for (const stateBytes of chunkBytes) {
       if (!stateBytes)
         continue;
       const state = decodeWorkflowState(stateBytes);
-      if (!matchesListFilter(state, normalizedFilter, constrainedIds, normalizedTagFilters))
+      if (!matchesListFilter(state, normalizedFilter, constrainedIds, normalizedTagFilters, searchAttributesByWorkflowId.get(state.id) ?? null))
         continue;
       matchingStates.push(state);
     }
@@ -47,8 +51,8 @@ async function collectSummariesFromFullScan(internals, normalizedFilter, normali
     scanned += 1;
     if (scanned > MAX_LIST_SCAN_ROWS)
       throw new WorkflowListScanCapExceededError(MAX_LIST_SCAN_ROWS);
-    const state = decodeWorkflowState(value);
-    if (!matchesListFilter(state, normalizedFilter, null, normalizedTagFilters))
+    const state = decodeWorkflowState(value), searchAttributes = await readSearchAttributesForFilter(internals, state.id, normalizedFilter);
+    if (!matchesListFilter(state, normalizedFilter, null, normalizedTagFilters, searchAttributes))
       continue;
     const attributeBytes = shouldReadFailureCategoryAttribute(state, options) ? await internals.storage.get(KEYS.attribute(state.id)) : null;
     items.push(summaryFromState(state, failureCategoryFromAttributeBytes(attributeBytes)));

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

@@ -1,9 +1,10 @@
 import type { ContextOperationRequest } from '../context.ts';
 import type { ComposedActivityInterceptor, ComposedWorkflowInterceptor } from '../interceptor.ts';
-import type { ActivityContext, ActivityVerificationResult } from '../types.ts';
+import type { ActivityContext, ActivityVerificationResult, OperationOutcome } from '../types.ts';
 import { buildActivityVerificationContext, type ActivityReconciliationMetadata } from './activity-reconciliation.ts';
 import type { EngineInternals } from './internals.ts';
 import type { SpeculativeExecutionState } from './speculative-execution-state.ts';
+import type { CapturedRejectionReason } from './strategy-helpers.ts';
 export type ActivityFunctionWithMetadata = ((...arguments_: unknown[]) => unknown) & ActivityReconciliationMetadata & {
     verify?: (result: unknown, context?: ReturnType<typeof buildActivityVerificationContext>) => Promise<ActivityVerificationResult> | ActivityVerificationResult;
     compensate?: (input: unknown, output: unknown) => Promise<void> | void;
@@ -13,19 +14,11 @@ type ActivityOperation = Extract<ContextOperationRequest, {
 }>;
 export type ActivityOperationCallbacks = {
     runOperationWithResult: (workflowId: string, operation: ActivityOperation, execute: () => Promise<unknown>) => Promise<void>;
+    finalizePendingTimelineEntry: (workflowId: string, status: 'completed' | 'failed', value: unknown) => void;
+    feedOperationResult: (workflowId: string, outcome: OperationOutcome, originalReason?: CapturedRejectionReason) => void;
     getComposedActivityInterceptor: () => ComposedActivityInterceptor | null;
     getComposedWorkflowInterceptor: () => ComposedWorkflowInterceptor | null;
 };
-export declare function getActivityFunctionWithMetadata(internals: EngineInternals, workflowId: string, operation: ActivityOperation): ActivityFunctionWithMetadata | undefined;
-/**
- * Resolve the activity function for a given operation. Uses the same
- * per-workflow-first-then-global ordering as `getActivityFunctionWithMetadata`.
- * For inline-mode callers that pass an `operation.fn` directly, the registries
- * are still consulted first so a workflow's locally-scoped activity wins over
- * the bare callable. Throws `ActivityResolutionError` when neither path
- * resolves.
- */
-export declare function resolveActivityFunction(internals: EngineInternals, workflowId: string, operation: ActivityOperation): (...arguments_: unknown[]) => unknown;
 export declare function buildActivityVerification(_internals: EngineInternals, activityName: string, verify: ActivityFunctionWithMetadata['verify'], context: ReturnType<typeof buildActivityVerificationContext>, result: unknown): Promise<void>;
 export declare function buildActivityCompensation(internals: EngineInternals, workflowId: string, operation: ActivityOperation, result: unknown): (() => Promise<void>) | undefined;
 export declare function invokeWorkerActivity(internals: EngineInternals, operationId: string, activityName: string, input: unknown, attempt: number): Promise<unknown>;
@@ -34,7 +27,7 @@ export declare function invokeInlineActivity(internals: EngineInternals, workflo
  * Execute an activity function, dispatching to a Web Worker pool when
  * `activityExecution` is configured, or running inline on the main thread.
  */
-export declare function executeActivity(internals: EngineInternals, workflowId: string, operation: ActivityOperation, callbacks: ActivityOperationCallbacks, attempt?: number): Promise<unknown>;
-export declare function executeActivityOperationResult(internals: EngineInternals, workflowId: string, operation: ActivityOperation, callbacks: ActivityOperationCallbacks, speculativeState?: SpeculativeExecutionState): Promise<unknown>;
+export declare function executeActivity(internals: EngineInternals, workflowId: string, operation: ActivityOperation, callbacks: ActivityOperationCallbacks, attempt?: number, coordinatorSignal?: AbortSignal): Promise<unknown>;
+export declare function executeActivityOperationResult(internals: EngineInternals, workflowId: string, operation: ActivityOperation, callbacks: ActivityOperationCallbacks, coordinatorSignal?: AbortSignal, speculativeState?: SpeculativeExecutionState): Promise<unknown>;
 export declare function processActivityOperation(internals: EngineInternals, workflowId: string, operation: ActivityOperation, callbacks: ActivityOperationCallbacks): Promise<void>;
 export {};

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

@@ -1,57 +1,27 @@
 import { assertPayloadWithinLimit } from "../payload-size.js";
+import {
+  buildActivityContext,
+  clearLastHeartbeatForStep,
+  warnIfRetryMissingHeartbeat
+} from "./activity-heartbeat-tracking.js";
+import { resolvePerAttemptTimeout, withPerAttemptTimeout } from "./activity-per-attempt-timeout.js";
 import {
   buildActivityReconciliationReference,
   buildActivityVerificationContext,
   createCompletedActivityReconciliationRecord,
   resolveActivityIdempotencyKey,
   resolveStartedActivityReconciliationRecord,
-  validateActivityResultForReconciliation,
-  writeActivityReconciliationTransition
+  stageActivityReconciliationTransitionWithAtomicWorkflowCommit,
+  validateActivityResultForReconciliation
 } from "./activity-reconciliation.js";
+import { getActivityFunctionWithMetadata, resolveActivityFunction } from "./activity-resolution.js";
 import {
   AsyncActivityDeferral,
   deriveAsyncActivityToken,
   driveWorkflowInterceptorGenerator,
   parkDeferredAsyncActivity
 } from "./async-activity-completion.js";
-import { ActivityResolutionError } from "./errors.js";
 import { callActivityFunction } from "./state-utilities.js";
-function resolveActivityViaRegistries(internals, workflowId, activityName) {
-  const workflowType = internals.workflowTypeByWorkflowId.get(workflowId);
-  if (workflowType !== void 0) {
-    const perWorkflow = internals.activityRegistriesByWorkflow.get(workflowType);
-    if (perWorkflow !== void 0) {
-      const perWorkflowFn = perWorkflow.resolve(activityName);
-      if (perWorkflowFn)
-        return { fn: perWorkflowFn, workflowType };
-    }
-    const globalFn = internals.activityRegistry.resolve(activityName);
-    if (globalFn)
-      return { fn: globalFn, workflowType };
-    return;
-  }
-  const globalFn = internals.activityRegistry.resolve(activityName);
-  if (globalFn)
-    return { fn: globalFn, workflowType: "<unknown>" };
-  return;
-}
-export function getActivityFunctionWithMetadata(internals, workflowId, operation) {
-  const resolved = resolveActivityViaRegistries(internals, workflowId, operation.activityName);
-  if (resolved)
-    return resolved.fn;
-  if (typeof operation.fn === "function")
-    return operation.fn;
-  return;
-}
-export function resolveActivityFunction(internals, workflowId, operation) {
-  const resolved = resolveActivityViaRegistries(internals, workflowId, operation.activityName);
-  if (resolved)
-    return resolved.fn;
-  if (operation.fn)
-    return operation.fn;
-  const workflowType = internals.workflowTypeByWorkflowId.get(workflowId) ?? "<unknown>";
-  throw new ActivityResolutionError(workflowType, operation.activityName);
-}
 export function buildActivityVerification(_internals, activityName, verify, context, result) {
   return (async () => {
     const verified = await verify?.(result, context);
@@ -99,16 +69,12 @@ function getActivityAttempt(operation) {
   const attempt = operation.attempt;
   return typeof attempt === "number" && Number.isInteger(attempt) && attempt > 0 ? attempt : 1;
 }
-export async function executeActivity(internals, workflowId, operation, callbacks, attempt = getActivityAttempt(operation)) {
-  const activityInput = operation.input, abortController = internals.inlineStrategy?.getAbortController(workflowId), asyncToken = deriveAsyncActivityToken(workflowId, operation.step ?? 0, attempt), activityContext = {
-    signal: abortController?.signal ?? new AbortController().signal,
-    heartbeat: (details) => {
-      internals.heartbeatDetails.set(workflowId, details);
-    },
-    completeAsync: () => {
-      throw new AsyncActivityDeferral(asyncToken);
-    }
-  }, invokeActivity = internals.activityWorkerDispatcher ? (activityName, input) => invokeWorkerActivity(internals, operation.operationId, activityName, input, attempt) : (activityName, input) => invokeInlineActivity(internals, workflowId, operation, activityContext, activityName, input), composedActivity = callbacks.getComposedActivityInterceptor(), executeWithActivityInterceptors = async (activityName, input, headers) => {
+export async function executeActivity(internals, workflowId, operation, callbacks, attempt = getActivityAttempt(operation), coordinatorSignal) {
+  const activityInput = operation.input, step = operation.step ?? 0;
+  warnIfRetryMissingHeartbeat(internals, workflowId, step, attempt);
+  const asyncToken = deriveAsyncActivityToken(workflowId, step, attempt), { perAttemptTimeoutMs, attemptAbortController, activitySignal } = resolvePerAttemptTimeout(internals, workflowId, operation, coordinatorSignal), activityContext = buildActivityContext(internals, workflowId, step, activitySignal, () => {
+    throw new AsyncActivityDeferral(asyncToken);
+  }), invokeActivity = internals.activityWorkerDispatcher ? (activityName, input) => invokeWorkerActivity(internals, operation.operationId, activityName, input, attempt) : (activityName, input) => withPerAttemptTimeout(invokeInlineActivity(internals, workflowId, operation, activityContext, activityName, input), perAttemptTimeoutMs, activityName, attempt, attemptAbortController), composedActivity = callbacks.getComposedActivityInterceptor(), executeWithActivityInterceptors = async (activityName, input, headers) => {
     if (!composedActivity)
       return invokeActivity(activityName, input);
     const activityInterception = {
@@ -141,7 +107,7 @@ export async function executeActivity(internals, workflowId, operation, callback
   copyActivityHeadersToOperation(operation, headers);
   return result;
 }
-export async function executeActivityOperationResult(internals, workflowId, operation, callbacks, speculativeState) {
+export async function executeActivityOperationResult(internals, workflowId, operation, callbacks, coordinatorSignal, speculativeState) {
   const activity = getActivityFunctionWithMetadata(internals, workflowId, operation), idempotencyKey = resolveActivityIdempotencyKey(activity, operation), operationAttempt = getActivityAttempt(operation);
   if (idempotencyKey !== void 0) {
     const reference = await buildActivityReconciliationReference(workflowId, operation.activityName, idempotencyKey), started = await resolveStartedActivityReconciliationRecord(internals, workflowId, operation, reference, activity, idempotencyKey, operationAttempt);
@@ -149,16 +115,20 @@ export async function executeActivityOperationResult(internals, workflowId, oper
       validateActivityResultForReconciliation(started.completedResult, internals.options.payloadSizePolicy.maxBytes);
       return started.completedResult;
     }
-    const result = await executeActivity(internals, workflowId, operation, callbacks, started.attempt);
+    const result = await executeActivity(internals, workflowId, operation, callbacks, started.attempt, coordinatorSignal);
     validateActivityResultForReconciliation(result, internals.options.payloadSizePolicy.maxBytes);
     await finalizeActivityResult(internals, workflowId, operation, result, activity, idempotencyKey, started.attempt, speculativeState, !0);
     const completedRecord = createCompletedActivityReconciliationRecord(started, result, internals.options.getNow());
-    await writeActivityReconciliationTransition(internals.storage, reference, started, completedRecord);
+    stageActivityReconciliationTransitionWithAtomicWorkflowCommit(internals, workflowId, reference, started, completedRecord);
+    if (!speculativeState)
+      clearLastHeartbeatForStep(internals, workflowId, operation.step ?? 0);
     return result;
   }
-  const result = await executeActivity(internals, workflowId, operation, callbacks, operationAttempt);
+  const result = await executeActivity(internals, workflowId, operation, callbacks, operationAttempt, coordinatorSignal);
   assertPayloadWithinLimit(result, internals.options.payloadSizePolicy.maxBytes, "activity result");
   await finalizeActivityResult(internals, workflowId, operation, result, activity, idempotencyKey, operationAttempt, speculativeState);
+  if (!speculativeState)
+    clearLastHeartbeatForStep(internals, workflowId, operation.step ?? 0);
   return result;
 }
 async function finalizeActivityResult(internals, workflowId, operation, result, activity, idempotencyKey, attempt, speculativeState, awaitSpeculativeVerification = !1) {
@@ -187,6 +157,9 @@ export async function processActivityOperation(internals, workflowId, operation,
           operationId: operation.operationId,
           step: operation.step ?? 0,
           attempt: getActivityAttempt(operation)
+        }, {
+          feedOperationResult: callbacks.feedOperationResult,
+          finalizeTimeline: callbacks.finalizePendingTimelineEntry
         });
       throw error;
     }

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

@@ -15,6 +15,16 @@ type RaceOperation = Extract<ContextOperationRequest, {
 type RunAllOperation = Extract<ContextOperationRequest, {
     type: 'run-all';
 }>;
+/**
+ * Reject a `ctx.race` / `ctx.all` whose branches wait on the SAME signal name,
+ * recursively through nested `race` / `parallel` branches. Sibling wait-signal
+ * branches share the `${workflowId}:${signalName}` waiter key, so two anywhere in
+ * the coordination tree would clobber each other at registration, leaving one
+ * branch permanently unreachable (the run would hang). Reject the meaningless
+ * shape deterministically rather than silently dropping a branch. Distinct names
+ * (the event-or-close idiom) are unaffected.
+ */
+export declare function assertSupportedSignalBranches(operations: readonly ContextOperationRequest[]): void;
 export type CoordinationOperationCallbacks = {
     completeOperation: (workflowId: string, value: unknown) => void;
     runOperationWithResult: (workflowId: string, operation: OperationWithCallerStack, execute: () => Promise<unknown>) => Promise<void>;

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

@@ -5,6 +5,7 @@ import {
   executeRunAllBranches,
   executeRunAllBranchesSettled
 } from "../engine-helpers.js";
+import { finalizeAndUnwrap } from "./deferred-consume-envelope.js";
 import {
   executeActivityOperationResult as executeActivityOperationResultFromInternals
 } from "./operations-activity.js";
@@ -13,14 +14,30 @@ import {
   dispatchBranchesAllSettled,
   valuesFromSlots
 } from "./parallel-dispatch.js";
-import { consumeSignal, trackWaiterKey, untrackWaiterKey } from "./signals.js";
+import {
+  consumeSignalWithAtomicWorkflowCommit,
+  trackWaiterKey,
+  untrackWaiterKey
+} from "./signals.js";
 import { callActivityFunction } from "./state-utilities.js";
+export function assertSupportedSignalBranches(operations) {
+  const seen = new Set, walk = (subOperations) => {
+    for (const subOperation of subOperations)
+      if (subOperation.type === "wait-signal") {
+        if (seen.has(subOperation.signalName))
+          throw Error(`ctx.race / ctx.all cannot have two branches waiting on the same signal "${subOperation.signalName}": sibling wait-signal branches share one waiter and would clobber each other. Wait on the signal once, or use distinct signal names.`);
+        seen.add(subOperation.signalName);
+      } else if (subOperation.type === "race" || subOperation.type === "parallel")
+        walk(subOperation.operations);
+  };
+  walk(operations);
+}
 export async function processWaitSignalOperation(internals, workflowId, operation, callbacks) {
   const abortSignal = internals.abortController.signal, waiterKey = `${workflowId}:${operation.signalName}`;
   while (!0) {
     if (abortSignal.aborted)
       return;
-    const existingPayload = await consumeSignal(internals, workflowId, operation.signalName);
+    const existingPayload = await consumeSignalWithAtomicWorkflowCommit(internals, workflowId, operation.signalName);
     if (existingPayload.found) {
       callbacks.completeOperation(workflowId, existingPayload.payload);
       return;
@@ -33,7 +50,7 @@ export async function processWaitSignalOperation(internals, workflowId, operatio
       untrackWaiterKey(internals.signalWaitersByWorkflow, workflowId, waiterKey);
       return;
     }
-    const bufferedPayload = await consumeSignal(internals, workflowId, operation.signalName);
+    const bufferedPayload = await consumeSignalWithAtomicWorkflowCommit(internals, workflowId, operation.signalName);
     if (bufferedPayload.found) {
       if (internals.signalWaiters.get(waiterKey) === resolve) {
         internals.signalWaiters.delete(waiterKey);
@@ -49,19 +66,34 @@ export async function processWaitSignalOperation(internals, workflowId, operatio
 }
 export async function processParallelOperation(internals, workflowId, operation, callbacks) {
   return callbacks.runOperationWithResult(workflowId, operation, async () => {
-    const resumedSlots = extractResumedSlots(operation.resumedCacheEntry), operationIds = operation.operations.map((sub, i) => typeof sub.operationId === "string" ? sub.operationId : `parallel:${operation.step}:${i}`), { slots, hasFirstError, firstError } = await dispatchBranchesAllSettled(operationIds, resumedSlots, (index) => callbacks.executeSubOperation(workflowId, operation.operations[index])), entry = buildEntryFromSlots("all", slots), partialEntryWritten = writePartialEntry(internals, workflowId, operation.step, entry);
-    if (hasFirstError) {
-      assertPartialFailurePersistenceSupported(partialEntryWritten, slots, "ctx.all", "worker execution mode");
+    assertSupportedSignalBranches(operation.operations);
+    const resumedSlots = extractResumedSlots(operation.resumedCacheEntry), operationIds = operation.operations.map((sub, i) => typeof sub.operationId === "string" ? sub.operationId : `parallel:${operation.step}:${i}`), { slots, hasFirstError, firstError } = await dispatchBranchesAllSettled(operationIds, resumedSlots, (index) => callbacks.executeSubOperation(workflowId, operation.operations[index]));
+    if (hasFirstError)
+      assertPartialFailurePersistenceSupported(canPersistPartialEntry(internals, workflowId), slots, "ctx.all", "worker execution mode");
+    await finalizeFulfilledSlots(slots);
+    const entry = buildEntryFromSlots("all", slots);
+    writePartialEntry(internals, workflowId, operation.step, entry);
+    if (hasFirstError)
       throw firstError;
-    }
     return valuesFromSlots(slots);
   });
 }
+async function finalizeFulfilledSlots(slots) {
+  const failure = (await Promise.allSettled(slots.map(async (slot) => {
+    if (slot.status === "fulfilled")
+      slot.value = await finalizeAndUnwrap(slot.value);
+  }))).find((outcome) => outcome.status === "rejected");
+  if (failure)
+    throw failure.reason;
+}
 function extractResumedSlots(resumedCacheEntry) {
   if (!isParallelOperationCacheEntry(resumedCacheEntry))
     return;
   return resumedCacheEntry.branches;
 }
+function canPersistPartialEntry(internals, workflowId) {
+  return internals.inlineStrategy?.getContext(workflowId) !== void 0;
+}
 function writePartialEntry(internals, workflowId, step, entry) {
   const context = internals.inlineStrategy?.getContext(workflowId);
   if (context === void 0)
@@ -76,13 +108,16 @@ function assertPartialFailurePersistenceSupported(partialEntryWritten, slots, op
 }
 export async function processRaceOperation(_internals, workflowId, operation, callbacks) {
   return callbacks.runOperationWithResult(workflowId, operation, async () => {
+    assertSupportedSignalBranches(operation.operations);
     const controller = new AbortController, subOperations = operation.operations.map((subOperation) => callbacks.executeSubOperation(workflowId, subOperation, controller.signal));
     Promise.allSettled(subOperations);
+    let winner;
     try {
-      return await Promise.race(subOperations);
+      winner = await Promise.race(subOperations);
     } finally {
       controller.abort();
     }
+    return finalizeAndUnwrap(winner);
   });
 }
 export async function processRunAllOperation(internals, workflowId, operation, callbacks) {
@@ -157,6 +192,6 @@ export async function executeRunAllOperationResult(internals, workflowId, operat
       activityName: fn.name,
       fn,
       input
-    }, callbacks.getActivityOperationCallbacks(), speculativeState);
+    }, callbacks.getActivityOperationCallbacks(), void 0, speculativeState);
   });
 }

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

@@ -18,6 +18,12 @@ export type OperationRouterCallbacks = {
     processWaitUpdateOperation: (workflowId: string, operation: Extract<ContextOperationRequest, {
         type: 'wait-update';
     }>) => Promise<void>;
+    processWaitConditionOperation: (workflowId: string, operation: Extract<ContextOperationRequest, {
+        type: 'wait-condition';
+    }>) => Promise<void>;
+    processGetVersionOperation: (workflowId: string, operation: Extract<ContextOperationRequest, {
+        type: 'get-version';
+    }>) => Promise<void>;
     processParallelOperation: (workflowId: string, operation: Extract<ContextOperationRequest, {
         type: 'parallel';
     }>) => Promise<void>;

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

@@ -35,6 +35,8 @@ function operationProcessors(callbacks) {
     sleep: callbacks.processSleepOperation,
     "wait-signal": callbacks.processWaitSignalOperation,
     "wait-update": callbacks.processWaitUpdateOperation,
+    "wait-condition": callbacks.processWaitConditionOperation,
+    "get-version": callbacks.processGetVersionOperation,
     parallel: callbacks.processParallelOperation,
     race: callbacks.processRaceOperation,
     memo: callbacks.processMemoOperation,

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

@@ -1,3 +1,5 @@
+import { finalizeAndUnwrap } from "./deferred-consume-envelope.js";
+import { assertSupportedSignalBranches } from "./operations-coordination.js";
 import { SpeculativeExecutionState } from "./speculative-execution-state.js";
 export async function processSpeculateOperation(internals, workflowId, operation, callbacks) {
   return callbacks.runOperationWithResult(workflowId, operation, () => executeSpeculativeBranch(internals, workflowId, operation, callbacks));
@@ -30,8 +32,10 @@ export async function driveSpeculativeGenerator(workflowId, generator, speculati
       return iterationResult.value;
     const nextOperation = iterationResult.value;
     try {
-      const nextResult = await callbacks.executeSubOperation(workflowId, nextOperation, void 0, speculativeState);
-      return advance(nextResult, void 0);
+      if (nextOperation.type === "race" || nextOperation.type === "parallel")
+        assertSupportedSignalBranches(nextOperation.operations);
+      const nextResult = await callbacks.executeSubOperation(workflowId, nextOperation, void 0, speculativeState), finalizedResult = await finalizeAndUnwrap(nextResult);
+      return advance(finalizedResult, void 0);
     } catch (error) {
       return advance(lastResult, error instanceof Error ? error : Error(String(error)));
     }

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

@@ -1,7 +1,7 @@
 import { KEYS } from "../../storage/interface.js";
 import { encode } from "../codec.js";
 import { cleanupPartialStreamChunks, createCleanupErrorReporter } from "../engine-helpers.js";
-import { loadStoredStreamChunks } from "./stream-chunk-loading.js";
+import { encodeStoredStreamTailSequence, loadStoredStreamChunks } from "./stream-chunk-loading.js";
 import { STREAM_CHUNK_KIND, TOKENS_STREAM_KEY, notifyWorkflowFeedCommit } from "./workflow-feed.js";
 export async function getStreamChunksFromInternals(internals, workflowId, key, options) {
   return loadStoredStreamChunks(internals.storage, workflowId, key, options);
@@ -33,7 +33,17 @@ export async function writeStreamChunksFromInternals(internals, workflowId, oper
   let chunkCount = 0, totalSizeBytes = 0;
   for await (const chunk of asyncGenerator) {
     const encoded = encode(chunk), sequence = chunkCount, chunkKey = KEYS.streamChunk(workflowId, operation.key, sequence);
-    await internals.storage.put(chunkKey, encoded);
+    if (operation.key === TOKENS_STREAM_KEY)
+      await internals.storage.batch([
+        { type: "put", key: chunkKey, value: encoded },
+        {
+          type: "put",
+          key: KEYS.streamTail(workflowId, operation.key),
+          value: encodeStoredStreamTailSequence(sequence)
+        }
+      ]);
+    else
+      await internals.storage.put(chunkKey, encoded);
     writtenKeys.push(chunkKey);
     totalSizeBytes += encoded.byteLength;
     chunkCount++;

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

@@ -8,6 +8,7 @@ type SleepOperation = Extract<ContextOperationRequest, {
 }>;
 export type TimeOperationCallbacks = {
     completeOperation: (workflowId: string, value: unknown) => void;
+    dispatchEvent: (event: Event) => void;
     loadWorkflowState: (workflowId: string) => Promise<WorkflowState | null>;
     failWorkflow: (workflowId: string, error: Error) => Promise<void>;
     runSerializedWorkflowStateWrite: <Result>(workflowId: string, writeOperation: () => Promise<Result>) => Promise<Result>;
@@ -17,6 +18,7 @@ export type TimeOperationCallbacks = {
     loadWorkflowStartHeaders: (workflowId: string) => Promise<Map<string, string> | undefined>;
     parseStartOptionDuration: (value: Duration, fieldName: 'options.executionTimeout' | 'options.startAfter') => number;
     runDeferredTerminalCleanup: (workflowId: string, timerId: string) => Promise<void>;
+    runWorkflowFinalizer: (workflowId: string, timerId: string) => Promise<void>;
     handleScheduleTimer: (entry: TimerEntry) => Promise<void>;
     timeout: (workflowId: string) => Promise<void>;
     handleCleanupError: (source: string, error: unknown, workflowId: string) => void;
@@ -24,6 +26,6 @@ export type TimeOperationCallbacks = {
 export declare function createDelayedStartTimerEntry(_internals: EngineInternals, workflowId: string, scheduledStartAt: number, options: StartOptions | undefined, callbacks: Pick<TimeOperationCallbacks, 'parseStartOptionDuration'>): TimerEntry;
 export declare function processSleepOperation(internals: EngineInternals, workflowId: string, operation: SleepOperation, callbacks: Pick<TimeOperationCallbacks, 'completeOperation' | 'loadWorkflowState'>): Promise<void>;
 export declare function registerSleepResolver(internals: EngineInternals, workflowId: string, operationId: string, resolve: () => void): void;
-export declare function startDelayedWorkflow(internals: EngineInternals, entry: TimerEntry, callbacks: Pick<TimeOperationCallbacks, 'beginWorkflowExecution' | 'failWorkflow' | 'handleCleanupError' | 'loadWorkflowStartHeaders' | 'loadWorkflowState' | 'runSerializedWorkflowStateWrite' | 'setWorkflowStartHeaders' | 'workflowVersionTupleFromState'>): Promise<void>;
-export declare function handleTimerFired(internals: EngineInternals, entry: TimerEntry, callbacks: Pick<TimeOperationCallbacks, 'failWorkflow' | 'handleCleanupError' | 'loadWorkflowStartHeaders' | 'loadWorkflowState' | 'runDeferredTerminalCleanup' | 'runSerializedWorkflowStateWrite' | 'handleScheduleTimer' | 'setWorkflowStartHeaders' | 'timeout' | 'beginWorkflowExecution' | 'workflowVersionTupleFromState'>): Promise<void>;
+export declare function startDelayedWorkflow(internals: EngineInternals, entry: TimerEntry, callbacks: Pick<TimeOperationCallbacks, 'beginWorkflowExecution' | 'dispatchEvent' | 'failWorkflow' | 'handleCleanupError' | 'loadWorkflowStartHeaders' | 'loadWorkflowState' | 'runSerializedWorkflowStateWrite' | 'setWorkflowStartHeaders' | 'workflowVersionTupleFromState'>): Promise<void>;
+export declare function handleTimerFired(internals: EngineInternals, entry: TimerEntry, callbacks: Pick<TimeOperationCallbacks, 'failWorkflow' | 'handleCleanupError' | 'loadWorkflowStartHeaders' | 'loadWorkflowState' | 'runDeferredTerminalCleanup' | 'runWorkflowFinalizer' | 'runSerializedWorkflowStateWrite' | 'handleScheduleTimer' | 'setWorkflowStartHeaders' | 'timeout' | 'beginWorkflowExecution' | 'dispatchEvent' | 'workflowVersionTupleFromState'>): Promise<void>;
 export {};

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

@@ -2,6 +2,7 @@ import { KEYS, storageHas } from "../../storage/interface.js";
 import { deserializeCheckpoint } from "../checkpoint.js";
 import { encode } from "../codec.js";
 import { buildTimerBatchOperations, normalizeStorageTimestamp } from "../scheduler.js";
+import { commitFencedEngineWrite } from "./fenced-write.js";
 import { reprovideRecoveredServices } from "./lifecycle/recovered-services.js";
 import { buildWorkflowVisibilityIndexTransition } from "./workflow-indexes.js";
 export function createDelayedStartTimerEntry(_internals, workflowId, scheduledStartAt, options, callbacks) {
@@ -81,12 +82,12 @@ export async function startDelayedWorkflow(internals, entry, callbacks) {
         fireAt: executionDeadline,
         kind: "execution-deadline"
       }));
-    await internals.storage.batch(operations);
+    await commitFencedEngineWrite(internals, operations, [], () => Error(`Delayed-start transition for workflow "${entry.workflowId}" lost its CAS race.`));
     return nextRunningState;
   });
   if (!runningState)
     return;
-  if (await reprovideRecoveredServices(internals, runningState, (workflowId, error) => callbacks.failWorkflow(workflowId, error), callbacks.handleCleanupError))
+  if (await reprovideRecoveredServices(internals, runningState, (workflowId, error) => callbacks.failWorkflow(workflowId, error), callbacks.handleCleanupError, callbacks.dispatchEvent))
     return;
   if (await storageHas(internals.storage, KEYS.terminalCleanupNeeded(entry.workflowId)))
     internals.workflowsNeedingTerminalCleanup.add(entry.workflowId);
@@ -133,15 +134,26 @@ export async function handleTimerFired(internals, entry, callbacks) {
     await callbacks.runDeferredTerminalCleanup(entry.workflowId, entry.id);
     return;
   }
+  if (entry.kind === "teardown") {
+    await callbacks.runWorkflowFinalizer(entry.workflowId, entry.id);
+    return;
+  }
   if (entry.kind === "schedule") {
     await callbacks.handleScheduleTimer(entry);
     return;
   }
   if (entry.kind === "sleep")
     resolveSleepTimer(internals, entry);
+  else if (entry.kind === "wait-condition")
+    resolveConditionTimer(internals, entry);
   else if (entry.kind === "execution-deadline")
     await callbacks.timeout(entry.workflowId);
 }
+function resolveConditionTimer(internals, entry) {
+  const resolver = internals.conditionWaiters.get(entry.workflowId);
+  if (resolver)
+    resolver();
+}
 async function handleReviewTimer(internals, entry, callbacks) {
   const reviewId = entry.id.split(":")[1];
   if (!reviewId)

package/dist/core/engine/operations-wait-condition.d.ts

@@ -0,0 +1,23 @@
+import type { ContextOperationRequest } from '../context.ts';
+import type { EngineInternals } from './internals.ts';
+import type { CoordinationOperationCallbacks } from './operations-coordination.ts';
+type WaitConditionOperation = Extract<ContextOperationRequest, {
+    type: 'wait-condition';
+}>;
+export type ConditionOperationCallbacks = Pick<CoordinationOperationCallbacks, 'completeOperation'> & {
+    /**
+     * Fail the pending operation, feeding the error to the generator so it
+     * re-throws at the `yield* ctx.waitUntil` site. Used when the user predicate
+     * throws — a throwing predicate must surface as a catchable workflow failure,
+     * not park the run forever.
+     */
+    failOperation: (workflowId: string, operation: WaitConditionOperation, error: unknown) => void;
+    /** Whether the workflow is still running — gates completion after a wake. */
+    isWorkflowRunning: (workflowId: string) => Promise<boolean>;
+    /** Schedule the deterministic deadline timer (`cond:${workflowId}:${step}`). */
+    scheduleConditionDeadline: (workflowId: string, step: number, fireAt: number) => Promise<void>;
+    /** Cancel the deadline timer in storage on teardown. */
+    cancelConditionDeadline: (workflowId: string, step: number) => Promise<void>;
+};
+export declare function processWaitConditionOperation(internals: EngineInternals, workflowId: string, operation: WaitConditionOperation, callbacks: ConditionOperationCallbacks): Promise<void>;
+export {};