@lostgradient/weft 0.2.1 → 0.4.0

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

@@ -1,11 +1,10 @@
-import { KEYS } from "../../../storage/interface.js";
 import { createCheckpoint } from "../../checkpoint.js";
-import { WorkflowStartedEvent } from "../../events.js";
 import { assertPayloadWithinLimit } from "../../payload-size.js";
 import { normalizeStorageTimestamp } from "../../scheduler.js";
 import {
   StartWorkflowValidationError,
   assertExclusiveStartWorkflowOptions,
+  assertValidOnTerminalConflict,
   coerceStartWorkflowId,
   coerceStartWorkflowTimestamp,
   parseStartWorkflowDuration
@@ -14,21 +13,30 @@ import { forgetCommittedCheckpointBytes } from "../checkpoint-commit-snapshots.j
 import { WorkflowAlreadyExistsError, WorkflowNotRegisteredError } from "../errors.js";
 import { createDelayedStartTimerEntry } from "../operations-time.js";
 import { selectPersistedWorkflowStartHeaders } from "../state-utilities.js";
+import { buildWorkflowConcurrencyStartOperations } from "../workflow-concurrency.js";
 import { createWorkflowVersionTuple } from "./persist.js";
 import {
   createWorkflowHandle,
   normalizeStartWorkflowTags,
   setWorkflowStartHeaders
 } from "./shared.js";
-import { buildStartBatchOperations } from "./start-batch.js";
-import { runWorkflowStartInterceptor, startWorkflowExecution } from "./start-exec.js";
+import { buildAndCommitStartBatch } from "./start-commit.js";
+import {
+  assertDeferSupported,
+  beginExecutionAwaitingLiveness,
+  runWorkflowStartInterceptor
+} from "./start-exec.js";
+import {
+  prepareTerminalRunPurge,
+  resolveTerminalConflictForRestart
+} from "./start-terminal-conflict-purge.js";
 export async function start(internals, type, input, options, callbacks) {
   return startWorkflow(internals, type, input, options, void 0, callbacks);
 }
 function prepareStartWorkflow(internals, options, callbacks) {
   const callerProvidedId = options?.id !== void 0, workflowId = options?.id !== void 0 ? coerceStartWorkflowId(options.id, "options.id") : crypto.randomUUID(), parentHeaders = internals.pendingParentHeaders;
   internals.pendingParentHeaders = void 0;
-  const executionStateOwnerId = internals.pendingExecutionStateOwnerId ?? workflowId;
+  const pendingExecutionStateOwnerId = internals.pendingExecutionStateOwnerId, executionStateOwnerId = pendingExecutionStateOwnerId === null ? void 0 : pendingExecutionStateOwnerId ?? workflowId;
   internals.pendingExecutionStateOwnerId = void 0;
   const submissionTime = internals.options.getNow(), scheduledStartAt = resolveScheduledStartAt(internals, options, submissionTime, callbacks), normalizedTags = normalizeStartWorkflowTags(internals, options?.tags, void 0, callbacks), delayedStartTimer = scheduledStartAt !== void 0 && scheduledStartAt > submissionTime ? createDelayedStartTimerEntry(internals, workflowId, scheduledStartAt, options, {
     parseStartOptionDuration: (value, fieldName) => parseStartOptionDuration(internals, value, fieldName, callbacks)
@@ -43,9 +51,6 @@ function prepareStartWorkflow(internals, options, callbacks) {
     normalizedTags
   };
 }
-async function persistStartBatch(internals, startOperations) {
-  await internals.storage.batch(startOperations);
-}
 function rollbackTransientStartState(internals, workflowId) {
   forgetCommittedCheckpointBytes(internals, workflowId);
   internals.checkpoints.delete(workflowId);
@@ -58,35 +63,56 @@ function assertServicesSupportedForMode(internals, options) {
   if (options?.services !== void 0 && internals.inlineStrategy === null)
     throw Error('options.services is only supported in inline execution mode; it cannot be serialized to a Worker. Remove services or use workflowExecutionMode: "inline".');
 }
-export async function startWorkflow(internals, type, input, options, additionalStartOperations, callbacks) {
+export async function startWorkflow(internals, type, input, options, additionalStartOperations, callbacks, buildIdempotentStartOperations) {
   const registration = internals.registrations.get(type);
   if (!registration)
     throw new WorkflowNotRegisteredError(type);
+  const workflowConcurrency = registration.concurrency;
   assertServicesSupportedForMode(internals, options);
+  assertValidOnTerminalConflict(options);
   const preparation = prepareStartWorkflow(internals, options, callbacks), { workflowId, callerProvidedId, parentHeaders, executionStateOwnerId, delayedStartTimer } = preparation;
+  assertDeferSupported(internals, options, Boolean(delayedStartTimer));
   if (internals.pendingStarts.has(workflowId))
     throw new WorkflowAlreadyExistsError(workflowId);
   internals.pendingStarts.add(workflowId);
   let startSucceeded = !1;
   try {
-    if (callerProvidedId) {
-      if (await internals.storage.get(KEYS.workflow(workflowId)) !== null)
-        throw new WorkflowAlreadyExistsError(workflowId);
-    }
+    const terminalRunToPurge = callerProvidedId ? await resolveTerminalConflictForRestart(internals, workflowId, options) : null;
     assertPayloadWithinLimit(input, internals.options.payloadSizePolicy.maxBytes, "workflow input");
-    const versionTuple = createWorkflowVersionTuple(internals, registration, callbacks), state = createInitialWorkflowState(internals, workflowId, type, input, versionTuple, options, preparation.normalizedTags, executionStateOwnerId, delayedStartTimer, callbacks), checkpoint = createInitialCheckpoint(internals, workflowId, versionTuple.workflowVersion, options, callbacks), workflowStartHeaders = runWorkflowStartInterceptor(internals, workflowId, type, input, parentHeaders, callbacks), persistedWorkflowStartHeaders = selectPersistedWorkflowStartHeaders(workflowStartHeaders);
+    const versionTuple = createWorkflowVersionTuple(internals, registration, callbacks), state = createInitialWorkflowState(internals, workflowId, type, input, versionTuple, options, preparation.normalizedTags, executionStateOwnerId, delayedStartTimer, callbacks), checkpoint = createInitialCheckpoint(internals, workflowId, versionTuple.workflowVersion, options, callbacks), workflowStartHeaders = runWorkflowStartInterceptor(internals, workflowId, type, input, parentHeaders, callbacks), persistedWorkflowStartHeaders = selectPersistedWorkflowStartHeaders(workflowStartHeaders), purgeDeleteOperations = terminalRunToPurge !== null ? await prepareTerminalRunPurge(internals, terminalRunToPurge, callbacks) : void 0;
     internals.checkpoints.set(workflowId, checkpoint);
     setWorkflowStartHeaders(internals, workflowId, workflowStartHeaders, callbacks);
     internals.workflowVersionTuples.set(workflowId, versionTuple);
-    const startOperations = buildStartBatchOperations(internals, workflowId, state, checkpoint, registration, options, state.executionDeadline, delayedStartTimer, persistedWorkflowStartHeaders, additionalStartOperations, callbacks);
-    await persistStartBatch(internals, startOperations);
+    await buildAndCommitStartBatch({
+      internals,
+      workflowId,
+      state,
+      checkpoint,
+      registration,
+      options,
+      delayedStartTimer,
+      persistedWorkflowStartHeaders,
+      additionalStartOperations,
+      buildWorkflowConcurrencyStartOperations: workflowConcurrency === void 0 ? void 0 : () => buildWorkflowConcurrencyStartOperations(internals, type, workflowId, input, workflowConcurrency),
+      callbacks,
+      purgeDeleteOperations
+    }, buildIdempotentStartOperations);
     if (options?.services !== void 0) {
       internals.workflowServices.set(workflowId, options.services);
       internals.workflowsNeedingTerminalCleanup.add(workflowId);
     }
+    if (workflowConcurrency !== void 0)
+      internals.workflowsNeedingTerminalCleanup.add(workflowId);
     const handle = createWorkflowHandle(internals, workflowId, callbacks);
-    if (!delayedStartTimer)
-      beginWorkflowExecution(internals, workflowId, type, input, checkpoint, state.executionDeadline, state.executionStateOwnerId ?? workflowId, registration, callbacks);
+    await beginExecutionAwaitingLiveness(internals, {
+      type,
+      input,
+      checkpoint,
+      state,
+      registration,
+      options,
+      isDelayed: Boolean(delayedStartTimer)
+    }, workflowId, callbacks);
     startSucceeded = !0;
     return handle;
   } finally {
@@ -112,42 +138,18 @@ export function resolveScheduledStartAt(internals, options, submissionTime, call
 export function parseStartOptionDuration(_internals, duration, fieldName, _callbacks) {
   return parseStartWorkflowDuration(duration, fieldName);
 }
-export function beginWorkflowExecution(internals, workflowId, workflowType, input, checkpoint, executionDeadline, executionStateOwnerId, _registration, callbacks) {
-  const nestingDepth = internals.pendingNestingDepth ?? 0;
-  internals.pendingNestingDepth = void 0;
-  if (internals.inlineStrategy !== null) {
-    callbacks.queueInlineWorkflowExecutionStart({
-      workflowId,
-      workflowType,
-      input,
-      checkpoint,
-      nestingDepth,
-      executionDeadline,
-      executionStateOwnerId
-    });
-    return;
-  }
-  callbacks.dispatchEvent(new WorkflowStartedEvent(workflowId, workflowType, input));
-  startWorkflowExecution(internals, workflowId, workflowType, input, checkpoint, nestingDepth, executionDeadline, executionStateOwnerId, callbacks);
-}
 function buildInitialIdentitySlice(workflowId, type, input, versionTuple, executionStateOwnerId, delayedStartTimer, now, tags) {
   return {
     id: workflowId,
     type,
     status: delayedStartTimer ? "pending" : "running",
     input,
-    version: versionTuple.workflowVersion,
-    executionStateOwnerId,
+    versionTuple,
+    ...executionStateOwnerId !== void 0 && { executionStateOwnerId },
     createdAt: now,
     ...!delayedStartTimer && { startedAt: now },
     updatedAt: now,
-    ...tags !== void 0 && { tags },
-    ...versionTuple.agentVersion !== void 0 && {
-      agentVersion: versionTuple.agentVersion
-    },
-    ...versionTuple.toolVersions !== void 0 && {
-      toolVersions: versionTuple.toolVersions
-    }
+    ...tags !== void 0 && { tags }
   };
 }
 function resolveInitialExecutionDeadline(internals, options, delayedStartTimer, now, callbacks) {

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,8 +1,9 @@
 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 { beginWorkflowExecution, createInitialCheckpoint, createInitialWorkflowState, parseStartOptionDuration, resolveScheduledStartAt, start, startWorkflow, } from './lifecycle/start.ts';
+export { createInitialCheckpoint, createInitialWorkflowState, parseStartOptionDuration, resolveScheduledStartAt, start, startWorkflow, } from './lifecycle/start.ts';
+export { startOrSignal, startWithIdempotency, type StartOrSignalCallbacks, type StartOrSignalResult, } from './lifecycle/start-or-signal.ts';
 export { buildInitialSearchAttributeOperations, buildStartBatchOperations, validateSearchAttributes, } from './lifecycle/start-batch.ts';
-export { runWorkflowStartInterceptor, startWorkflowExecution } from './lifecycle/start-exec.ts';
+export { beginWorkflowExecution, runWorkflowStartInterceptor, startWorkflowExecution, } from './lifecycle/start-exec.ts';
 export { buildForkBatchOperations, buildForkSearchAttributes, createForkLineage, createForkedWorkflowState, } from './lifecycle/fork-helpers.ts';
 export { fork, launchWorkflowFromCheckpoint, recoverAll, resume } from './lifecycle/transition.ts';
 export { resumeWorkflowFromStorage } from './lifecycle/resume.ts';

package/dist/core/engine/lifecycle.js

@@ -16,7 +16,6 @@ export {
   workflowVersionTupleFromState
 } from "./lifecycle/persist.js";
 export {
-  beginWorkflowExecution,
   createInitialCheckpoint,
   createInitialWorkflowState,
   parseStartOptionDuration,
@@ -24,12 +23,20 @@ export {
   start,
   startWorkflow
 } from "./lifecycle/start.js";
+export {
+  startOrSignal,
+  startWithIdempotency
+} from "./lifecycle/start-or-signal.js";
 export {
   buildInitialSearchAttributeOperations,
   buildStartBatchOperations,
   validateSearchAttributes
 } from "./lifecycle/start-batch.js";
-export { runWorkflowStartInterceptor, startWorkflowExecution } from "./lifecycle/start-exec.js";
+export {
+  beginWorkflowExecution,
+  runWorkflowStartInterceptor,
+  startWorkflowExecution
+} from "./lifecycle/start-exec.js";
 export {
   buildForkBatchOperations,
   buildForkSearchAttributes,

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)));
@@ -88,7 +92,7 @@ function summaryFromState(state, attributeFailureCategory) {
     type: state.type,
     status: state.status,
     ...state.tags !== void 0 && { tags: state.tags },
-    version: state.version,
+    version: state.versionTuple.workflowVersion,
     createdAt: state.createdAt,
     updatedAt: state.updatedAt,
     ...state.executionDeadline !== void 0 && { executionDeadline: state.executionDeadline },

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>;

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);
@@ -100,15 +70,11 @@ function getActivityAttempt(operation) {
   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) => {
+  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), 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 = {
@@ -153,12 +119,16 @@ export async function executeActivityOperationResult(internals, workflowId, oper
     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);
   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) {

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>;