@lostgradient/weft 0.23.1 → 0.24.1

package/dist/core/contract/types.d.ts

@@ -0,0 +1,274 @@
+/**
+ * Canonical, normalized workflow contract vocabulary.
+ *
+ * A `WorkflowContract` is the single normalized representation that feeds
+ * both TypeScript code generation (`weft codegen`) and `contractHash()` — the
+ * same data, described once, rather than two independent derivations that
+ * could silently drift apart. `WorkflowRevisionManifest` pairs that contract
+ * with the two identity questions a consumer asks about a workflow revision:
+ *
+ * | Field          | Question answered                                    | Stability                    |
+ * | -------------- | ----------------------------------------------------- | ----------------------------- |
+ * | `contractHash` | Which public payload contract does this revision use? | Deterministic, payload-only   |
+ * | `revision`     | Which contract-metadata identity (name, version, docs) is this? | Deterministic or author-set   |
+ *
+ * `contractHash` deliberately excludes `name`, `workflowVersion`,
+ * `description`, and `tags` — those identify *which* workflow and *how it is
+ * documented*, not *what callers may send and expect back*. `revision` is the
+ * broader identity: it changes on a documentation edit even when the payload
+ * contract does not, which is what lets a caller detect "the same contract,
+ * redeployed" versus "a genuinely different definition was loaded."
+ *
+ * @module core/contract/types
+ */
+import type { DefinitionSchema } from '../types/definition-schema.ts';
+/**
+ * Domain separator folded into every `contractHash()`/`deriveWorkflowRevision()`
+ * digest. Bumping this constant is how a future normalization change is
+ * guaranteed to produce a different hash rather than silently colliding with
+ * one computed under the old rules.
+ *
+ * @example
+ * ```ts
+ * import { WORKFLOW_CONTRACT_VERSION } from '@lostgradient/weft';
+ *
+ * console.log(WORKFLOW_CONTRACT_VERSION); // 1
+ * ```
+ */
+export declare const WORKFLOW_CONTRACT_VERSION = 1;
+/**
+ * Normalized JSON Schema pair carried by one workflow signal, update, or
+ * query.
+ *
+ * @example
+ * ```ts
+ * import type { WorkflowMessageContract } from '@lostgradient/weft';
+ *
+ * const approval: WorkflowMessageContract = {
+ *   inputSchema: { type: 'object', properties: { approved: { type: 'boolean' } } },
+ * };
+ * console.log(approval.inputSchema?.['type']);
+ * ```
+ */
+export type WorkflowMessageContract = Readonly<{
+    /** Normalized JSON Schema describing accepted input, when the message accepts one. */
+    inputSchema?: Record<string, unknown>;
+    /** Normalized JSON Schema describing the returned value, when the message returns one. */
+    outputSchema?: Record<string, unknown>;
+}>;
+/**
+ * Normalized JSON Schema pair carried by one activity a workflow contract
+ * exposes.
+ *
+ * @example
+ * ```ts
+ * import type { WorkflowActivityContract } from '@lostgradient/weft';
+ *
+ * const charge: WorkflowActivityContract = {
+ *   inputSchema: { type: 'object', properties: { amount: { type: 'number' } } },
+ *   outputSchema: { type: 'object', properties: { id: { type: 'string' } } },
+ * };
+ * console.log(charge.inputSchema?.['type']);
+ * ```
+ */
+export type WorkflowActivityContract = Readonly<{
+    /** Normalized JSON Schema describing accepted input, when the activity accepts one. */
+    inputSchema?: Record<string, unknown>;
+    /** Normalized JSON Schema describing the returned value, when the activity returns one. */
+    outputSchema?: Record<string, unknown>;
+}>;
+/**
+ * Canonical, normalized representation of one workflow's public contract —
+ * everything callers may send it and expect back, plus enough identity
+ * metadata (`name`, `workflowVersion`, `description`, `tags`) to describe
+ * which workflow this is. This is the single input to both TypeScript
+ * emission and `contractHash()`.
+ *
+ * Every open-ended record (`signals`, `updates`, `queries`, `activities`) is
+ * omitted entirely rather than present-but-empty, matching the registry
+ * snapshot's "absent fields omitted, never `null` or `{}`" convention — see
+ * {@link normalizeWorkflowContract}.
+ *
+ * @example
+ * ```ts
+ * import type { WorkflowContract } from '@lostgradient/weft';
+ *
+ * const checkout: WorkflowContract = {
+ *   name: 'checkout',
+ *   workflowVersion: '2.1.0',
+ *   inputSchema: { type: 'object', properties: { cartId: { type: 'string' } } },
+ *   activities: {
+ *     charge: { inputSchema: { type: 'object', properties: { amount: { type: 'number' } } } },
+ *   },
+ * };
+ * console.log(checkout.name);
+ * ```
+ */
+export type WorkflowContract = Readonly<{
+    /** Wire-safe workflow name. */
+    name: string;
+    /** Semantic replay-compatibility boundary declared by the workflow author. */
+    workflowVersion: string;
+    /** User-facing description. Excluded from `contractHash()`; included in `revision`. */
+    description?: string;
+    /** User-facing grouping tags. Excluded from `contractHash()`; included in `revision`. */
+    tags?: ReadonlyArray<string>;
+    /** Normalized JSON Schema describing accepted workflow input, when declared. */
+    inputSchema?: Record<string, unknown>;
+    /** Normalized JSON Schema describing the workflow result, when declared. */
+    outputSchema?: Record<string, unknown>;
+    /** Signal contracts keyed by canonical signal name. */
+    signals?: Readonly<Record<string, WorkflowMessageContract>>;
+    /** Update contracts keyed by canonical update name. */
+    updates?: Readonly<Record<string, WorkflowMessageContract>>;
+    /** Query contracts keyed by canonical query name. */
+    queries?: Readonly<Record<string, WorkflowMessageContract>>;
+    /** Activity contracts keyed by canonical activity name. */
+    activities?: Readonly<Record<string, WorkflowActivityContract>>;
+    /** Contract of the workflow's definition-level finalizer activity, when declared. */
+    finalizer?: WorkflowActivityContract;
+}>;
+/**
+ * Structural shape one signal, update, or query source must satisfy for
+ * {@link buildWorkflowContract} to convert it. Deliberately narrower than
+ * `SignalDefinition`/`UpdateDefinition`/`QueryDefinition` — only the schema
+ * metadata those conversions need — so any of the three handle types (and
+ * any structurally equivalent value) satisfies it without a cast.
+ *
+ * @example
+ * ```ts
+ * import { signal } from '@lostgradient/weft';
+ * import type { WorkflowContractMessageSource } from '@lostgradient/weft';
+ *
+ * const approval = signal('approval');
+ * const source: WorkflowContractMessageSource = approval;
+ * console.log(source.inputSchema === undefined);
+ * ```
+ */
+export interface WorkflowContractMessageSource {
+    /**
+     * The message's own wire name, as recorded by `signal()`/`update()`/`query()`
+     * and used by `normalizeMessageDefinitions()` (`core/engine/registration.ts`)
+     * to key the registered message — not necessarily the JS object key the
+     * caller used in `.signals({...})`/`.updates({...})`/`.queries({...})`,
+     * which may alias a different local name. {@link buildWorkflowContract}
+     * keys `WorkflowContract.signals`/`updates`/`queries` by this field so the
+     * built contract matches what the registry and codegen actually expose.
+     */
+    readonly name: string;
+    readonly inputSchema?: DefinitionSchema;
+    readonly outputSchema?: DefinitionSchema;
+}
+/**
+ * Structural shape one activity or finalizer source must satisfy for
+ * {@link buildWorkflowContract} to convert it. Requires `name` — shared with
+ * every real activity source type — specifically so a `WorkflowDefinition`'s
+ * `finalizer` field (declared as the narrower `AnyActivityDefinition`, which
+ * does not itself declare `inputSchema`/`outputSchema`) remains structurally
+ * assignable here: TypeScript's weak-type check requires at least one
+ * property in common between source and target when every target property is
+ * optional, and `name` is that shared property.
+ *
+ * @example
+ * ```ts
+ * import { activity } from '@lostgradient/weft';
+ * import type { WorkflowContractActivitySource } from '@lostgradient/weft';
+ *
+ * const charge = activity({ name: 'charge', execute: async (input: number) => input });
+ * const source: WorkflowContractActivitySource = charge;
+ * console.log(source.name);
+ * ```
+ */
+export interface WorkflowContractActivitySource {
+    readonly name: string;
+    readonly inputSchema?: DefinitionSchema;
+    readonly outputSchema?: DefinitionSchema;
+}
+/**
+ * Authoring-time input accepted by {@link buildWorkflowContract} — the
+ * narrowest structural shape that both `WorkflowDefinition` and
+ * `BuiltWorkflowDefinition` already satisfy, so neither type is imported here
+ * and no coupling is introduced between this module and the workflow builder.
+ *
+ * @example
+ * ```ts
+ * import { workflow } from '@lostgradient/weft';
+ * import type { WorkflowContractSource } from '@lostgradient/weft';
+ *
+ * const greet = workflow({ name: 'greet', version: '1.0.0' }).execute(
+ *   async function* (_ctx, input: string) {
+ *     return `hello ${input}`;
+ *   },
+ * );
+ * const source: WorkflowContractSource = greet;
+ * console.log(source.name);
+ * ```
+ */
+export interface WorkflowContractSource {
+    readonly name: string;
+    readonly version?: string;
+    readonly description?: string;
+    readonly tags?: ReadonlyArray<string>;
+    readonly inputSchema?: DefinitionSchema;
+    readonly outputSchema?: DefinitionSchema;
+    readonly signals?: Readonly<Record<string, WorkflowContractMessageSource>>;
+    readonly updates?: Readonly<Record<string, WorkflowContractMessageSource>>;
+    readonly queries?: Readonly<Record<string, WorkflowContractMessageSource>>;
+    readonly activities?: Readonly<Record<string, WorkflowContractActivitySource>>;
+    readonly finalizer?: WorkflowContractActivitySource;
+}
+/**
+ * Current workflow revision manifest schema version. An unknown value is
+ * rejected by {@link parseWorkflowRevisionManifest} before any other field is
+ * read, the same "reject rather than best-effort parse" contract
+ * `WORKER_MANIFEST_VERSION` uses.
+ *
+ * @example
+ * ```ts
+ * import { WORKFLOW_REVISION_MANIFEST_VERSION } from '@lostgradient/weft';
+ *
+ * console.log(WORKFLOW_REVISION_MANIFEST_VERSION); // 1
+ * ```
+ */
+export declare const WORKFLOW_REVISION_MANIFEST_VERSION = 1;
+/**
+ * A workflow contract paired with its two identity answers: the
+ * payload-only `contractHash` and the broader `revision`.
+ *
+ * `revision` is an opaque label: content-derived by {@link deriveWorkflowRevision}
+ * by default, or explicitly supplied. {@link parseWorkflowRevisionManifest}
+ * recomputes and checks `contractHash` on every parse, but never recomputes
+ * `revision` — an explicitly supplied revision is a caller assertion, not a
+ * value this module can verify.
+ *
+ * @example
+ * ```ts
+ * import { WORKFLOW_REVISION_MANIFEST_VERSION, buildWorkflowContract } from '@lostgradient/weft';
+ * import type { WorkflowRevisionManifest } from '@lostgradient/weft';
+ *
+ * const contract = buildWorkflowContract({ name: 'checkout', version: '2.1.0' });
+ * const manifest: WorkflowRevisionManifest = {
+ *   manifestVersion: WORKFLOW_REVISION_MANIFEST_VERSION,
+ *   name: contract.name,
+ *   workflowVersion: contract.workflowVersion,
+ *   revision: 'sha256:placeholder',
+ *   contractHash: 'sha256:placeholder',
+ *   contract,
+ * };
+ * console.log(manifest.name);
+ * ```
+ */
+export type WorkflowRevisionManifest = Readonly<{
+    /** Manifest schema version; unknown values are rejected, not tolerated. */
+    manifestVersion: typeof WORKFLOW_REVISION_MANIFEST_VERSION;
+    /** Wire-safe workflow name; must equal `contract.name`. */
+    name: string;
+    /** Semantic replay-compatibility boundary; must equal `contract.workflowVersion`. */
+    workflowVersion: string;
+    /** Content-derived or explicitly supplied opaque revision identity. */
+    revision: string;
+    /** Deterministic payload-only contract identity, verified on every parse. */
+    contractHash: string;
+    /** The normalized workflow contract this manifest describes. */
+    contract: WorkflowContract;
+}>;

package/dist/core/contract/types.js

@@ -0,0 +1 @@
+export const WORKFLOW_CONTRACT_VERSION = 1, WORKFLOW_REVISION_MANIFEST_VERSION = 1;

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

@@ -1,22 +1,22 @@
 import { ActivityResolutionError } from "./errors.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;
+function resolveViaKnownIdentity(internals, identity, activityName) {
+  const eagerFn = internals.activityRegistriesByWorkflow.get(identity.type)?.resolve(activityName);
+  if (eagerFn)
+    return { fn: eagerFn, workflowType: identity.type };
+  if (identity.revision !== void 0) {
+    const revisionFn = internals.sources.resolved.get(identity.type)?.get(identity.revision)?.activityRegistry.resolve(activityName);
+    if (revisionFn)
+      return { fn: revisionFn, workflowType: identity.type };
   }
   const globalFn = internals.activityRegistry.resolve(activityName);
-  if (globalFn)
-    return { fn: globalFn, workflowType: "<unknown>" };
-  return;
+  return globalFn ? { fn: globalFn, workflowType: identity.type } : void 0;
+}
+function resolveActivityViaRegistries(internals, workflowId, activityName) {
+  const identity = internals.workflowTypeByWorkflowId.get(workflowId);
+  if (identity !== void 0)
+    return resolveViaKnownIdentity(internals, identity, activityName);
+  const globalFn = internals.activityRegistry.resolve(activityName);
+  return globalFn ? { fn: globalFn, workflowType: "<unknown>" } : void 0;
 }
 export function getActivityFunctionWithMetadata(internals, workflowId, operation) {
   const resolved = resolveActivityViaRegistries(internals, workflowId, operation.activityName);
@@ -32,6 +32,6 @@ export function resolveActivityFunction(internals, workflowId, operation) {
     return resolved.fn;
   if (operation.fn)
     return operation.fn;
-  const workflowType = internals.workflowTypeByWorkflowId.get(workflowId) ?? "<unknown>";
+  const workflowType = internals.workflowTypeByWorkflowId.get(workflowId)?.type ?? "<unknown>";
   throw new ActivityResolutionError(workflowType, operation.activityName);
 }

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

@@ -12,15 +12,16 @@ import { asyncActivityWorkflowPrefix } from "./async-activity-records.js";
 import { forgetCommittedCheckpointBytes } from "./checkpoint-commit-snapshots.js";
 import { commitFencedEngineWrite } from "./fenced-write.js";
 import { streamWorkflowStates } from "./listing.js";
+import {
+  forEachResolvedDynamicRetentionPolicy,
+  hasUnresolvedDynamicSourceCandidate
+} from "./registration.js";
 import { decodeScheduleRunMetadata } from "./schedule-run-metadata.js";
 import { createTerminalCleanupTimerId } from "./state-utilities.js";
 import { buildExternalTerminalRotationFragment } from "./storage-io.js";
-import {
-  decodeWorkflowState,
-  isTerminalWorkflowStatus,
-  resolveRetentionForStatus
-} from "./validation.js";
+import { decodeWorkflowState, isTerminalWorkflowStatus } from "./validation.js";
 import { buildWorkflowVisibilityIndexTransition } from "./workflow-indexes.js";
+import { getWorkflowRetentionDeadline } from "./workflow-retention-deadline.js";
 export const TERMINAL_CLEANUP_DELAY_MS = 60000;
 export async function purgeInternal(internals, filter, parameters, cleanupWaiters) {
   const { effectiveLimit, manualOffset } = resolvePurgeWindow(internals, filter, parameters.limit);
@@ -59,16 +60,17 @@ function getMinimumRetentionMs(internals) {
   considerRetentionPolicy(internals.options.retention);
   for (const registration of internals.registrations.values())
     considerRetentionPolicy(registration.retention);
+  forEachResolvedDynamicRetentionPolicy(internals, considerRetentionPolicy);
   return minimumRetentionMs;
 }
 async function* streamExpiredRetentionWorkflowStates(internals, now) {
-  const minimumRetentionMs = getMinimumRetentionMs(internals);
-  if (minimumRetentionMs === null)
+  const untrustworthyBound = hasUnresolvedDynamicSourceCandidate(internals), minimumRetentionMs = untrustworthyBound ? null : getMinimumRetentionMs(internals);
+  if (!untrustworthyBound && minimumRetentionMs === null)
     return;
-  const terminalWorkflowPrefix = KEYS.terminalWorkflowPrefix(), newestPossibleExpiredUpdatedAt = now - minimumRetentionMs, upperBound = `${terminalWorkflowPrefix}${String(newestPossibleExpiredUpdatedAt).padStart(16, "0")}:\xFF`;
-  for await (const [key] of internals.storage.scan(terminalWorkflowPrefix, {
-    lte: upperBound
-  })) {
+  const terminalWorkflowPrefix = KEYS.terminalWorkflowPrefix(), scanOptions = minimumRetentionMs === null ? {} : {
+    lte: `${terminalWorkflowPrefix}${String(now - minimumRetentionMs).padStart(16, "0")}:\xFF`
+  };
+  for await (const [key] of internals.storage.scan(terminalWorkflowPrefix, scanOptions)) {
     const encodedWorkflowId = key.slice(key.lastIndexOf(":") + 1), workflowId = tryDecodeStorageKeyComponent(encodedWorkflowId);
     if (workflowId === null)
       continue;
@@ -121,17 +123,9 @@ async function shouldPurgeWorkflowState(internals, state, expiredOnly, now) {
     return !1;
   if (!expiredOnly)
     return !0;
-  const deadline = getWorkflowRetentionDeadline(internals, state);
+  const deadline = await getWorkflowRetentionDeadline(internals, state);
   return deadline !== null && deadline <= now;
 }
-function getWorkflowRetentionDeadline(internals, state) {
-  if (!isTerminalWorkflowStatus(state.status))
-    return null;
-  const policy = internals.registrations.get(state.type)?.retention ?? internals.options.retention, retentionMs = resolveRetentionForStatus(policy, state.status);
-  if (retentionMs === void 0)
-    return null;
-  return state.updatedAt + retentionMs;
-}
 export async function purgeWorkflow(internals, state, cleanupWaiters) {
   const deleteOperations = await collectWorkflowPurgeDeleteOperations(internals, state), rotation = await buildExternalTerminalRotationFragment(internals, state.id), operations = [...deleteOperations, ...rotation.operations];
   await commitFencedEngineWrite(internals, null, operations, rotation.conditions, () => {

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

@@ -0,0 +1,9 @@
+import type { BulkOperationDryRunResult, BulkOperationOptions, BulkRetryFailedResult, ListFilter } from '../types.ts';
+import type { EngineInternals } from './internals.ts';
+/**
+ * `bulkOperations.ts`'s `retryFailedAll()` implementation, split into its
+ * own module (with the rest of the retry-failed cluster below) to keep
+ * `bulk-operations.ts` under the 800-line implementation-file ceiling —
+ * the same reason `bulk-operations-purge.ts` was split out earlier.
+ */
+export declare function runBulkFailedWorkflowRetry(internals: EngineInternals, filter: ListFilter, options?: BulkOperationOptions): Promise<BulkRetryFailedResult | BulkOperationDryRunResult>;

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

@@ -0,0 +1,177 @@
+import {
+  KEYS,
+  requireStorageCapability
+} from "../../storage/interface.js";
+import { assertScopedBulkWorkflowFilter } from "../bulk-workflow-filter.js";
+import { deserializeCheckpoint } from "../checkpoint.js";
+import { decode, encode } from "../codec.js";
+import { buildTimerBatchOperations } from "../scheduler.js";
+import { buildIndexOperations } from "../search-attributes.js";
+import { buildTerminalWorkflowIndexOperations } from "./attributes-tags.js";
+import {
+  buildActionableBulkWorkflowFilter,
+  normalizeBulkOperationOptions,
+  prepareBulkOperation,
+  resolveBulkOperationConcurrency,
+  runBulkWorkflowPool,
+  shouldPersistBulkAudit,
+  toBulkOperationError,
+  validateBulkConfirmation,
+  withBulkAuditEvent
+} from "./bulk-operations-shared.js";
+import { resolveExecutableRegistrationForRetry } from "./dynamic-source-execution.js";
+import { commitFencedEngineWriteAllowingPreconditionFailure } from "./fenced-write.js";
+import { buildCatalogEntryRevisionCondition } from "./lifecycle/start-commit.js";
+import { createTerminalCleanupTimerId } from "./state-utilities.js";
+import { loadWorkflowState, runSerializedWorkflowStateWrite } from "./storage-io.js";
+import { decodeWorkflowState } from "./validation.js";
+import {
+  commitWithWorkflowClaimFold,
+  prepareWorkflowClaimFold,
+  throwWorkflowClaimUnavailable
+} from "./workflow-claim-fold.js";
+import { buildWorkflowConcurrencyStartOperations } from "./workflow-concurrency.js";
+import { buildWorkflowVisibilityIndexTransition } from "./workflow-indexes.js";
+const FAILED_WORKFLOW_STATUSES = ["failed"], CHECKPOINT_RETRY_CONCURRENCY_ADMISSION_MAX_ATTEMPTS = 5;
+export async function runBulkFailedWorkflowRetry(internals, filter, options = {}) {
+  options = normalizeBulkOperationOptions(options);
+  assertScopedBulkWorkflowFilter(filter);
+  const actionableFilter = buildActionableBulkWorkflowFilter(internals, filter, FAILED_WORKFLOW_STATUSES), preparation = await prepareBulkOperation(internals, "retry-failed", actionableFilter, filter, {}, options);
+  if (options.dryRun === !0)
+    return preparation.preview;
+  validateBulkConfirmation(options, preparation);
+  const bulkConcurrency = resolveBulkOperationConcurrency(options);
+  let retried = 0;
+  const errors = [], retryResults = await runBulkWorkflowPool(preparation.workflowIds, bulkConcurrency, async (workflowId) => {
+    await retryFailedWorkflow(internals, workflowId);
+    return { status: "retried" };
+  });
+  for (const retryResult of retryResults) {
+    if (retryResult.status === "rejected") {
+      errors.push(toBulkOperationError(internals, retryResult.item, retryResult.reason));
+      continue;
+    }
+    retried += 1;
+  }
+  const result = { retried, failed: errors.length, errors };
+  if (!shouldPersistBulkAudit(options))
+    return result;
+  return withBulkAuditEvent(internals, preparation, options, result, retried);
+}
+async function retryFailedWorkflow(internals, workflowId) {
+  const state = await loadWorkflowState(internals, workflowId);
+  if (state === null)
+    throw Error("Workflow no longer exists");
+  if (state.status !== "failed")
+    throw Error(`Workflow is ${state.status}, not failed`);
+  if (await internals.storage.get(KEYS.checkpoint(workflowId)) !== null) {
+    await reactivateFailedWorkflowFromCheckpoint(internals, state);
+    await internals.engine.resume(workflowId);
+    return;
+  }
+  await internals.engine.start(state.type, state.input, {
+    id: workflowId,
+    onTerminalConflict: "start-new",
+    ...state.tags !== void 0 ? { tags: state.tags } : {}
+  });
+}
+async function reactivateFailedWorkflowFromCheckpoint(internals, state) {
+  const reactivated = await runSerializedWorkflowStateWrite(internals, state.id, async () => reactivateFailedWorkflowFromCheckpointSerialized(internals, state.id));
+  if (reactivated.terminalCleanupTimerId !== void 0)
+    await internals.scheduler.cancel(reactivated.terminalCleanupTimerId, state.id);
+}
+async function reactivateFailedWorkflowFromCheckpointSerialized(internals, workflowId) {
+  let lastConcurrencyStateKey;
+  for (let attempt = 0;attempt < CHECKPOINT_RETRY_CONCURRENCY_ADMISSION_MAX_ATTEMPTS; attempt += 1) {
+    const { currentState, checkpoint } = await loadFailedWorkflowForReactivation(internals, workflowId), commit = await buildReactivationCommit(internals, workflowId, currentState, checkpoint);
+    lastConcurrencyStateKey = commit.concurrencyStateKey ?? lastConcurrencyStateKey;
+    if (await commitFailedWorkflowReactivation(internals, workflowId, commit.operations, commit.conditions))
+      return {
+        terminalCleanupTimerId: currentState.terminalCleanupToken === void 0 ? void 0 : createTerminalCleanupTimerId(!1, currentState.terminalCleanupToken)
+      };
+  }
+  throw Error(`Workflow concurrency admission for "${lastConcurrencyStateKey ?? workflowId}" changed too many times while retrying failed workflow "${workflowId}"`);
+}
+async function loadFailedWorkflowForReactivation(internals, workflowId) {
+  const currentStateBytes = await internals.storage.get(KEYS.workflow(workflowId));
+  if (currentStateBytes === null)
+    throw Error("Workflow no longer exists");
+  const currentState = decodeWorkflowState(currentStateBytes);
+  if (currentState.status !== "failed")
+    throw Error(`Workflow is ${currentState.status}, not failed`);
+  const currentCheckpointBytes = await internals.storage.get(KEYS.checkpoint(workflowId));
+  if (currentCheckpointBytes === null)
+    throw Error("Checkpoint no longer exists");
+  return { currentState, checkpoint: deserializeCheckpoint(currentCheckpointBytes) };
+}
+async function buildReactivationCommit(internals, workflowId, currentState, checkpoint) {
+  const { entry: registration } = await resolveExecutableRegistrationForRetry(internals, currentState.type, currentState.revision, workflowId), catalogEntryCondition = currentState.revision === void 0 ? void 0 : await buildCatalogEntryRevisionCondition(internals, currentState.type, currentState.revision), concurrencyStartOperations = registration.concurrency === void 0 ? void 0 : await buildWorkflowConcurrencyStartOperations(internals, currentState.type, workflowId, currentState.input, registration.concurrency), reactivatedState = buildReactivatedWorkflowState(internals, currentState), currentAttributes = await loadSearchAttributes(internals, workflowId);
+  return {
+    operations: buildReactivationBatchOperations(workflowId, currentState, reactivatedState, checkpoint, currentAttributes, concurrencyStartOperations?.operations),
+    conditions: [
+      ...concurrencyStartOperations?.conditions ?? [],
+      ...catalogEntryCondition === void 0 ? [] : [catalogEntryCondition]
+    ],
+    concurrencyStateKey: concurrencyStartOperations?.stateKey
+  };
+}
+function buildReactivationBatchOperations(workflowId, currentState, reactivatedState, checkpoint, currentAttributes, concurrencyOperations) {
+  const deadlineOperations = reactivatedState.executionDeadline === void 0 ? [] : buildTimerBatchOperations({
+    id: `deadline:${workflowId}`,
+    workflowId,
+    fireAt: reactivatedState.executionDeadline,
+    kind: "execution-deadline"
+  });
+  return [
+    ...buildTerminalWorkflowIndexOperations(currentState, reactivatedState),
+    { type: "put", key: KEYS.workflow(workflowId), value: encode(reactivatedState) },
+    ...buildWorkflowVisibilityIndexTransition(workflowId, currentState, reactivatedState).batchOps,
+    ...buildRetrySearchAttributeOperations(workflowId, currentAttributes, checkpoint.searchAttributes),
+    ...deadlineOperations,
+    ...concurrencyOperations ?? []
+  ];
+}
+async function commitFailedWorkflowReactivation(internals, workflowId, operations, conditions) {
+  const claimFold = await prepareWorkflowClaimFold(internals, workflowId);
+  if (claimFold === void 0) {
+    if (conditions.length > 0)
+      requireStorageCapability(internals.storage, "conditionalBatch", "retry failed workflow");
+    return commitFencedEngineWriteAllowingPreconditionFailure(internals, workflowId, operations, conditions);
+  }
+  const result = await commitWithWorkflowClaimFold(internals, claimFold, operations, conditions, "retry failed workflow claim acquisition");
+  if (result.status === "committed")
+    return !0;
+  return result.claimConflict ? throwWorkflowClaimUnavailable(internals, workflowId) : !1;
+}
+function buildReactivatedWorkflowState(internals, state) {
+  const reactivatedState = {
+    ...state,
+    status: "running",
+    updatedAt: internals.options.getNow()
+  };
+  delete reactivatedState.error;
+  delete reactivatedState.errorStack;
+  delete reactivatedState.failureCategory;
+  delete reactivatedState.result;
+  delete reactivatedState.terminationReason;
+  delete reactivatedState.terminalCleanupToken;
+  return reactivatedState;
+}
+async function loadSearchAttributes(internals, workflowId) {
+  const attributeBytes = await internals.storage.get(KEYS.attribute(workflowId));
+  if (attributeBytes === null)
+    return {};
+  return decode(attributeBytes);
+}
+function buildRetrySearchAttributeOperations(workflowId, currentAttributes, checkpointAttributes) {
+  const operations = buildIndexOperations(workflowId, currentAttributes, checkpointAttributes);
+  if (Object.keys(checkpointAttributes).length === 0)
+    operations.push({ type: "delete", key: KEYS.attribute(workflowId) });
+  else
+    operations.push({
+      type: "put",
+      key: KEYS.attribute(workflowId),
+      value: encode(checkpointAttributes)
+    });
+  return operations;
+}

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

@@ -2,6 +2,24 @@ import type { BulkOperationAction, BulkOperationAuditEvent, BulkOperationCommitO
 import type { EngineInternals } from './internals.ts';
 export declare const BULK_OPERATION_SAMPLE_LIMIT = 20;
 export declare const DEFAULT_BULK_OPERATION_CONCURRENCY = 1;
+export type BulkWorkflowPoolResult<TItem, TResult> = {
+    item: TItem;
+    status: 'fulfilled';
+    value: TResult;
+} | {
+    item: TItem;
+    status: 'rejected';
+    reason: unknown;
+};
+/**
+ * Shared bounded-concurrency runner every bulk operation (cancel, retry,
+ * signal, delete) uses to drive its per-workflow work: runs `items` in
+ * fixed-size batches of `concurrencyLimit`, capturing each item's outcome
+ * rather than letting one rejection abort the batch (mirrors
+ * `Promise.allSettled`, but keyed back to the originating `item` so a
+ * caller can map a failure to the workflow it belongs to).
+ */
+export declare function runBulkWorkflowPool<TItem, TResult>(items: readonly TItem[], concurrencyLimit: number, operation: (item: TItem) => Promise<TResult>): Promise<BulkWorkflowPoolResult<TItem, TResult>[]>;
 export type BulkWorkflowSnapshot = {
     id: string;
     type: string;

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

@@ -15,6 +15,20 @@ import { streamWorkflowStateBatches } from "./listing.js";
 import { isTerminalWorkflowStatus } from "./validation.js";
 export const BULK_OPERATION_SAMPLE_LIMIT = 20, DEFAULT_BULK_OPERATION_CONCURRENCY = 1;
 const DEFAULT_BULK_OPERATION_PRINCIPAL = { method: "in-process" };
+export async function runBulkWorkflowPool(items, concurrencyLimit, operation) {
+  const results = [];
+  for (let batchStart = 0;batchStart < items.length; batchStart += concurrencyLimit) {
+    const batchItems = items.slice(batchStart, batchStart + concurrencyLimit);
+    results.push(...await Promise.all(batchItems.map(async (item) => {
+      try {
+        return { item, status: "fulfilled", value: await operation(item) };
+      } catch (reason) {
+        return { item, status: "rejected", reason };
+      }
+    })));
+  }
+  return results;
+}
 export function buildActionableBulkWorkflowFilter(_internals, filter, actionableStatuses) {
   const effectiveStatuses = (filter.status === void 0 ? actionableStatuses : Array.isArray(filter.status) ? filter.status : [filter.status]).filter((status) => actionableStatuses.includes(status));
   if (effectiveStatuses.length === 0)