@lostgradient/weft 0.3.0 → 0.5.0

package/dist/core/engine/async-activity-completion.d.ts

@@ -22,7 +22,10 @@
  * across replay. After an engine restart, `recoverAll()` replays the workflow
  * from its checkpoint; the deferred activity re-runs, re-defers, and produces
  * the *same* token. A callback that arrives after the crash therefore still
- * resolves the correct activity.
+ * resolves the correct activity. If that callback races `recoverAll()` and
+ * arrives after token recovery but before replay has adopted the workflow
+ * generator, the engine buffers the completion or failure outcome and drains it
+ * when replay reaches the same deterministic token.
  *
  * Internal-only. Imported from `src/core/engine/**` and the `ActivityContext`
  * construction path.
@@ -30,6 +33,12 @@
 import type { OperationOutcome } from '../types.ts';
 import { WeftError } from '../weft-error.ts';
 import type { EngineInternals } from './internals.ts';
+type AsyncActivityResolutionCallbacks = {
+    feedOperationResult: (workflowId: string, outcome: OperationOutcome, originalReason?: {
+        value: unknown;
+    }) => void;
+    finalizeTimeline: (workflowId: string, status: 'completed' | 'failed', output: unknown) => void;
+};
 /**
  * Per-workflow prefix for all async-activity storage keys. Used by cleanup and
  * purge paths that need to sweep every async-activity record for a workflow
@@ -80,6 +89,15 @@ export type PendingAsyncActivity = {
     readonly attempt: number;
     readonly createdAt: number;
 };
+export type PendingAsyncActivityResolution = {
+    readonly token: string;
+    readonly outcome: OperationOutcome;
+    readonly originalReason?: {
+        value: unknown;
+    };
+    readonly timelineStatus: 'completed' | 'failed';
+    readonly timelineOutput: unknown;
+};
 /**
  * Derive the durable, deterministic task token for an async activity.
  *
@@ -106,7 +124,7 @@ export declare function registerPendingAsyncActivity(internals: EngineInternals,
  * out-of-band completion resumes it. Keeps the operation-pipeline catch site a
  * one-liner.
  */
-export declare function parkDeferredAsyncActivity(internals: EngineInternals, deferral: AsyncActivityDeferral, details: Omit<PendingAsyncActivity, 'token' | 'createdAt'>): Promise<never>;
+export declare function parkDeferredAsyncActivity(internals: EngineInternals, deferral: AsyncActivityDeferral, details: Omit<PendingAsyncActivity, 'token' | 'createdAt'>, callbacks: AsyncActivityResolutionCallbacks): Promise<never>;
 /**
  * Reload pending async-activity records from storage into memory. Called by
  * `recoverAll()` so a token minted before a crash is resolvable again — even
@@ -117,7 +135,7 @@ export declare function recoverPendingAsyncActivities(internals: EngineInternals
  * Complete a deferred activity out-of-band with `result`, resuming the parked
  * workflow as though the activity had returned `result` inline.
  */
-export declare function completeAsyncActivity(internals: EngineInternals, token: string, result: unknown, feedOperationResult: (workflowId: string, outcome: OperationOutcome) => void, finalizeTimeline: (workflowId: string, status: 'completed' | 'failed', output: unknown) => void): Promise<void>;
+export declare function completeAsyncActivity(internals: EngineInternals, token: string, result: unknown, callbacks: AsyncActivityResolutionCallbacks): Promise<void>;
 /**
  * Drive a generator that may yield promises — the workflow interceptor's
  * `activity` hook returns such a generator. Forwards rejections into the
@@ -136,6 +154,5 @@ export declare function driveWorkflowInterceptorGenerator(generator: Generator<u
  * that threw — so the workflow's own try/catch and any configured retry policy
  * apply unchanged.
  */
-export declare function failAsyncActivity(internals: EngineInternals, token: string, error: unknown, feedOperationResult: (workflowId: string, outcome: OperationOutcome, originalReason?: {
-    value: unknown;
-}) => void, finalizeTimeline: (workflowId: string, status: 'completed' | 'failed', output: unknown) => void): Promise<void>;
+export declare function failAsyncActivity(internals: EngineInternals, token: string, error: unknown, callbacks: AsyncActivityResolutionCallbacks): Promise<void>;
+export {};

package/dist/core/engine/async-activity-completion.js

@@ -53,7 +53,12 @@ export async function registerPendingAsyncActivity(internals, pending) {
   if (!alreadyRegistered)
     internals.engine.dispatchEvent(new ActivityAsyncPendingEvent(pending.token, pending.operationId, pending.workflowId, pending.activityName, pending.attempt));
 }
-export async function parkDeferredAsyncActivity(internals, deferral, details) {
+export async function parkDeferredAsyncActivity(internals, deferral, details, callbacks) {
+  const queuedResolution = takePendingAsyncActivityResolution(internals, details.workflowId, deferral.token);
+  if (queuedResolution !== void 0) {
+    deliverPendingAsyncActivityResolution(details.workflowId, queuedResolution, callbacks);
+    return new Promise(() => {});
+  }
   await registerPendingAsyncActivity(internals, {
     token: deferral.token,
     createdAt: internals.options.getNow(),
@@ -90,14 +95,52 @@ async function consumePendingAsyncActivity(internals, token) {
   }
   return pending;
 }
-async function resolvePendingAsyncActivity(internals, token, outcome, feedOperationResult, finalizeTimeline) {
-  const pending = await consumePendingAsyncActivity(internals, token), timelineOutput = outcome.status === "completed" ? outcome.value : outcome.error;
-  finalizeTimeline(pending.workflowId, outcome.status, timelineOutput);
-  feedOperationResult(pending.workflowId, outcome);
+function shouldBufferPendingAsyncActivityResolution(internals, workflowId) {
+  return internals.inlineStrategy !== null && !internals.inlineStrategy.hasGenerator(workflowId);
+}
+function queuePendingAsyncActivityResolution(internals, workflowId, resolution) {
+  internals.pendingAsyncActivityResolutions ??= new Map;
+  const queued = internals.pendingAsyncActivityResolutions.get(workflowId) ?? [];
+  queued.push(resolution);
+  internals.pendingAsyncActivityResolutions.set(workflowId, queued);
+}
+function takePendingAsyncActivityResolution(internals, workflowId, token) {
+  internals.pendingAsyncActivityResolutions ??= new Map;
+  const queued = internals.pendingAsyncActivityResolutions.get(workflowId);
+  if (queued === void 0)
+    return;
+  const index = queued.findIndex((resolution) => resolution.token === token);
+  if (index === -1)
+    return;
+  const resolution = queued[index];
+  if (resolution === void 0)
+    return;
+  queued.splice(index, 1);
+  if (queued.length === 0)
+    internals.pendingAsyncActivityResolutions.delete(workflowId);
+  return resolution;
+}
+function deliverPendingAsyncActivityResolution(workflowId, resolution, callbacks) {
+  callbacks.finalizeTimeline(workflowId, resolution.timelineStatus, resolution.timelineOutput);
+  callbacks.feedOperationResult(workflowId, resolution.outcome, resolution.originalReason);
+}
+async function resolvePendingAsyncActivity(internals, token, outcome, callbacks, originalReason) {
+  const pending = await consumePendingAsyncActivity(internals, token), timelineOutput = outcome.status === "completed" ? outcome.value : outcome.error, resolution = {
+    token,
+    outcome,
+    timelineStatus: outcome.status,
+    timelineOutput,
+    ...originalReason !== void 0 ? { originalReason } : {}
+  };
+  if (shouldBufferPendingAsyncActivityResolution(internals, pending.workflowId)) {
+    queuePendingAsyncActivityResolution(internals, pending.workflowId, resolution);
+    return;
+  }
+  deliverPendingAsyncActivityResolution(pending.workflowId, resolution, callbacks);
 }
-export async function completeAsyncActivity(internals, token, result, feedOperationResult, finalizeTimeline) {
+export async function completeAsyncActivity(internals, token, result, callbacks) {
   assertPayloadWithinLimit(result, internals.options.payloadSizePolicy.maxBytes, "activity result");
-  await resolvePendingAsyncActivity(internals, token, { status: "completed", value: result }, feedOperationResult, finalizeTimeline);
+  await resolvePendingAsyncActivity(internals, token, { status: "completed", value: result }, callbacks);
 }
 export async function driveWorkflowInterceptorGenerator(generator) {
   let current = generator.next();
@@ -117,15 +160,13 @@ export async function driveWorkflowInterceptorGenerator(generator) {
   }
   return current.value;
 }
-export async function failAsyncActivity(internals, token, error, feedOperationResult, finalizeTimeline) {
+export async function failAsyncActivity(internals, token, error, callbacks) {
   const message = error instanceof Error ? error.message : String(error), errorName = error instanceof Error ? error.name : void 0;
   assertPayloadWithinLimit({ message, name: errorName }, internals.options.payloadSizePolicy.maxBytes, "activity result");
-  const pending = await consumePendingAsyncActivity(internals, token);
-  finalizeTimeline(pending.workflowId, "failed", message);
-  feedOperationResult(pending.workflowId, {
+  await resolvePendingAsyncActivity(internals, token, {
     status: "failed",
     error: message,
     ...error instanceof Error ? { errorName: error.name } : {},
     failureCategory: "application"
-  }, { value: error });
+  }, callbacks, { value: error });
 }

package/dist/core/engine/attributes-tags.js

@@ -9,7 +9,10 @@ import {
 import { assertWorkflowTagCount, coerceStartWorkflowTags } from "../start-workflow-validation.js";
 import { buildWorkflowTagIndexOperations, normalizeWorkflowTags } from "../workflow-tags.js";
 import { WorkflowNotFoundError } from "./errors.js";
-import { commitWorkflowStateOperations, runSerializedWorkflowStateWrite } from "./storage-io.js";
+import {
+  commitFencedWorkflowStateOperations,
+  runSerializedWorkflowStateWrite
+} from "./storage-io.js";
 import {
   decodeWorkflowState,
   isTerminalWorkflowStatus,
@@ -73,12 +76,14 @@ export async function updateWorkflowState(internals, workflowId, updates, option
       ...updates,
       updatedAt
     }, additionalOperations = options.buildAdditionalOperations?.(state, updatedAt) ?? [];
-    await commitWorkflowStateOperations(internals, state, [
+    await commitFencedWorkflowStateOperations(internals, state, [
       ...buildTerminalWorkflowIndexOperations(state, updated),
       { type: "put", key: KEYS.workflow(workflowId), value: encode(updated) },
       ...buildWorkflowVisibilityIndexTransition(workflowId, state, updated).batchOps,
       ...additionalOperations
-    ]);
+    ], {
+      includePendingAtomicSideEffects: isTerminalWorkflowStatus(updated.status)
+    });
     return {
       previousState: state,
       updatedAt
@@ -172,7 +177,7 @@ async function snapshotMatchingWorkflowIds(internals, filter) {
     if (remainingLimit !== void 0)
       remainingLimit -= 1;
     if (remainingLimit === 0)
-      break;
+      return workflowIds;
   }
   return workflowIds;
 }

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

@@ -1,3 +1,4 @@
+import type { BatchOperation } from '../../storage/interface.ts';
 import type { ListFilter, PurgeResult, WorkflowState } from '../types.ts';
 import type { EngineInternals } from './internals.ts';
 export declare const TERMINAL_CLEANUP_DELAY_MS = 60000;
@@ -9,3 +10,28 @@ export type PurgeParameters = {
 export type CleanupWaiters = (workflowId: string) => void;
 export declare function purgeInternal(internals: EngineInternals, filter: ListFilter | undefined, parameters: PurgeParameters, cleanupWaiters: CleanupWaiters): Promise<PurgeResult>;
 export declare function purgeWorkflow(internals: EngineInternals, state: WorkflowState, cleanupWaiters: CleanupWaiters): Promise<void>;
+/**
+ * Collect every storage delete operation that removing a workflow id entails —
+ * index deletes (search attributes + tags), the explicit key set (state,
+ * checkpoint, headers, services marker, update requests/responses, and the
+ * `wf:`/`ev:`/`sig:`/... prefix sweeps), and the visibility-index transition to
+ * `null`. Pure: it reads storage to discover keys but writes nothing, so a caller
+ * can fold the returned ops into a larger atomic batch instead of committing them
+ * standalone. {@link purgeWorkflow} commits them on their own; the
+ * `onTerminalConflict: 'start-new'` restart path prepends them to the create batch
+ * so purge-and-recreate land as one atomic unit (no window where the prior run is
+ * gone but the new one has not committed). Keep this the single source of truth
+ * for "what a purge deletes" — do not fork the delete-set.
+ */
+export declare function collectWorkflowPurgeDeleteOperations(internals: EngineInternals, state: WorkflowState): Promise<BatchOperation[]>;
+/**
+ * Drop every in-memory cache entry a purged workflow id owns (checkpoints,
+ * heartbeat details, event-log heads, version tuples, handle cache, result
+ * resolvers, headers, nesting depths, type map, pending async activities) and run
+ * `cleanupWaiters` to settle any pending signal/update/sleep waiters. Split from
+ * the storage batch in {@link collectWorkflowPurgeDeleteOperations} so the restart
+ * path can clear the OLD run's in-memory state up front — before the new run's
+ * caches are written under the reused id — while the durable delete still commits
+ * atomically with the create.
+ */
+export declare function clearPurgedWorkflowInMemoryState(internals: EngineInternals, workflowId: string, cleanupWaiters: CleanupWaiters): void;

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

@@ -1,6 +1,7 @@
 import {
   KEYS,
   encodeStorageKeyComponent,
+  storageHas,
   storageKeys,
   tryDecodeStorageKeyComponent
 } from "../../storage/interface.js";
@@ -25,7 +26,7 @@ export async function purgeInternal(internals, filter, parameters, cleanupWaiter
   let remainingOffset = manualOffset, deleted = 0;
   const workflowStateStream = parameters.expiredOnly && filter === void 0 ? streamExpiredRetentionWorkflowStates(internals, parameters.now) : streamWorkflowStates(internals, filter);
   for await (const state of workflowStateStream) {
-    if (!shouldPurgeWorkflowState(internals, state, parameters.expiredOnly, parameters.now))
+    if (!await shouldPurgeWorkflowState(internals, state, parameters.expiredOnly, parameters.now))
       continue;
     if (remainingOffset > 0) {
       remainingOffset -= 1;
@@ -110,9 +111,11 @@ function resolvePurgeLimit(manualLimit, fallbackLimit) {
     return manualLimit;
   return Math.min(manualLimit, fallbackLimit);
 }
-function shouldPurgeWorkflowState(internals, state, expiredOnly, now) {
+async function shouldPurgeWorkflowState(internals, state, expiredOnly, now) {
   if (!isTerminalWorkflowStatus(state.status))
     return !1;
+  if (await storageHas(internals.storage, KEYS.teardownOwed(state.id)))
+    return !1;
   if (!expiredOnly)
     return !0;
   const deadline = getWorkflowRetentionDeadline(internals, state);
@@ -127,16 +130,25 @@ function getWorkflowRetentionDeadline(internals, state) {
   return state.updatedAt + retentionMs;
 }
 export async function purgeWorkflow(internals, state, cleanupWaiters) {
+  const deleteOperations = await collectWorkflowPurgeDeleteOperations(internals, state);
+  await internals.storage.batch(deleteOperations);
+  clearPurgedWorkflowInMemoryState(internals, state.id, cleanupWaiters);
+}
+export async function collectWorkflowPurgeDeleteOperations(internals, state) {
   const workflowId = state.id, attributeBytes = await internals.storage.get(KEYS.attribute(workflowId)), deleteOperations = buildWorkflowIndexDeleteOperations(state, attributeBytes), deleteKeys = await collectWorkflowPurgeDeleteKeys(internals, state);
   appendKeyDeleteOperations(deleteOperations, deleteKeys);
   deleteOperations.push(...buildWorkflowVisibilityIndexTransition(workflowId, state, null).batchOps);
-  await internals.storage.batch(deleteOperations);
+  return deleteOperations;
+}
+export function clearPurgedWorkflowInMemoryState(internals, workflowId, cleanupWaiters) {
   forgetCommittedCheckpointBytes(internals, workflowId);
   internals.checkpoints.delete(workflowId);
   internals.heartbeatDetails.delete(workflowId);
+  internals.lastHeartbeatDetailsByStep.delete(workflowId);
   for (const [token, pending] of internals.pendingAsyncActivities)
     if (pending.workflowId === workflowId)
       internals.pendingAsyncActivities.delete(token);
+  internals.pendingAsyncActivityResolutions.delete(workflowId);
   internals.eventLogHeads.delete(workflowId);
   internals.workflowVersionTuples.delete(workflowId);
   internals.handleCache.delete(workflowId);
@@ -178,7 +190,10 @@ function buildBaseWorkflowDeleteKeys(state) {
     KEYS.checkpoint(state.id),
     KEYS.workflowHeaders(state.id),
     KEYS.terminalCleanupNeeded(state.id),
+    KEYS.workflowConcurrencyHolder(state.id),
     KEYS.workflowHasServices(state.id),
+    KEYS.finalizerState(state.id),
+    KEYS.teardownOwed(state.id),
     KEYS.attribute(state.id),
     KEYS.terminalWorkflow(state.updatedAt, state.id)
   ]);
@@ -216,11 +231,31 @@ async function addWorkflowPrefixDeleteKeys(storage, deleteKeys, workflowId) {
     for (const key of keys)
       deleteKeys.add(key);
   }
+  await addWorkflowLinkedFleetEventDeleteKeys(storage, deleteKeys, workflowId);
+}
+async function addWorkflowLinkedFleetEventDeleteKeys(storage, deleteKeys, workflowId) {
+  const prefix = KEYS.fleetEventByWorkflowPrefix(workflowId);
+  for await (const [key] of storage.scan(prefix)) {
+    deleteKeys.add(key);
+    const sequence = parseFleetEventSequenceFromWorkflowIndexKey(prefix, key);
+    if (sequence !== null)
+      deleteKeys.add(KEYS.fleetEvent(sequence));
+  }
+}
+function parseFleetEventSequenceFromWorkflowIndexKey(prefix, key) {
+  if (!key.startsWith(prefix))
+    return null;
+  const rawSequence = key.slice(prefix.length);
+  if (!/^\d+$/.test(rawSequence))
+    return null;
+  const sequence = Number(rawSequence);
+  return Number.isSafeInteger(sequence) ? sequence : null;
 }
 function workflowPurgePrefixes(workflowId) {
   const encodedWorkflowId = encodeStorageKeyComponent(workflowId);
   return [
     `wf:${encodedWorkflowId}:ckpt:`,
+    `wf:${encodedWorkflowId}:timeline:`,
     `ev:${encodedWorkflowId}:`,
     `sig:${encodedWorkflowId}:`,
     `review:${encodedWorkflowId}:`,

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

@@ -1,6 +1,7 @@
 import type { BulkOperationAction, BulkOperationAuditEvent, BulkOperationCommitOptions, BulkOperationDryRunResult, BulkOperationError, BulkOperationOptions, BulkOperationScopeSummary, ListFilter, WorkflowState, WorkflowStatus } from '../types.ts';
 import type { EngineInternals } from './internals.ts';
 export declare const BULK_OPERATION_SAMPLE_LIMIT = 20;
+export declare const DEFAULT_BULK_OPERATION_CONCURRENCY = 1;
 export type BulkWorkflowSnapshot = {
     id: string;
     type: string;
@@ -22,6 +23,7 @@ export declare function withBulkAuditEvent<TResult extends object>(internals: En
     auditEvent: BulkOperationAuditEvent;
 }>;
 export declare function normalizeBulkOperationOptions<TOptions extends BulkOperationOptions>(options: TOptions): TOptions;
+export declare function resolveBulkOperationConcurrency(options: BulkOperationOptions): number;
 export declare function toBulkOperationError(_internals: EngineInternals, workflowId: string, error: unknown): BulkOperationError;
 export declare function snapshotMatchingWorkflowSnapshots(internals: EngineInternals, filter?: ListFilter): Promise<BulkWorkflowSnapshot[]>;
 export declare function workflowStateToBulkSnapshot(state: WorkflowState): BulkWorkflowSnapshot;

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

@@ -13,7 +13,7 @@ import {
 } from "./errors.js";
 import { streamWorkflowStateBatches } from "./listing.js";
 import { isTerminalWorkflowStatus } from "./validation.js";
-export const BULK_OPERATION_SAMPLE_LIMIT = 20;
+export const BULK_OPERATION_SAMPLE_LIMIT = 20, DEFAULT_BULK_OPERATION_CONCURRENCY = 1;
 const DEFAULT_BULK_OPERATION_PRINCIPAL = { method: "in-process" };
 export function buildActionableBulkWorkflowFilter(_internals, filter, actionableStatuses) {
   const effectiveStatuses = (filter.status === void 0 ? actionableStatuses : Array.isArray(filter.status) ? filter.status : [filter.status]).filter((status) => actionableStatuses.includes(status));
@@ -69,7 +69,7 @@ function summarizeBulkFilter(filter) {
   if (filter.attributes !== void 0)
     summary.attributes = filter.attributes.map((attribute) => ({
       key: searchAttributeName(attribute.key),
-      ...attribute.value === void 0 ? {} : { value: attribute.value },
+      ...attribute.value === void 0 ? {} : { value: Array.isArray(attribute.value) ? [...attribute.value] : attribute.value },
       ...attribute.gt === void 0 ? {} : { gt: attribute.gt },
       ...attribute.lt === void 0 ? {} : { lt: attribute.lt },
       ...attribute.gte === void 0 ? {} : { gte: attribute.gte },
@@ -136,6 +136,9 @@ async function persistBulkOperationAuditEvent(internals, preparation, options, a
   return auditEvent;
 }
 export function normalizeBulkOperationOptions(options) {
+  const bulkConcurrency = options.bulkConcurrency;
+  if (bulkConcurrency !== void 0 && (!Number.isSafeInteger(bulkConcurrency) || bulkConcurrency < 1))
+    throw Error('Field "bulkConcurrency" must be a positive integer');
   const confirmationToken = "confirmationToken" in options ? options.confirmationToken : void 0;
   if (confirmationToken !== void 0 && confirmationToken.length > MAX_BULK_CONFIRMATION_TOKEN_LENGTH)
     throw Error(`Field "confirmationToken" must be at most ${String(MAX_BULK_CONFIRMATION_TOKEN_LENGTH)} characters`);
@@ -143,6 +146,9 @@ export function normalizeBulkOperationOptions(options) {
     throw Error(`Field "requestId" must be at most ${String(MAX_BULK_OPERATION_REQUEST_ID_LENGTH)} characters`);
   return options;
 }
+export function resolveBulkOperationConcurrency(options) {
+  return options.bulkConcurrency ?? DEFAULT_BULK_OPERATION_CONCURRENCY;
+}
 export function toBulkOperationError(_internals, workflowId, error) {
   return {
     id: workflowId,

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

@@ -1,4 +1,4 @@
-import type { BulkCancelResult, BulkDeleteResult, BulkOperationCommitOptions, BulkOperationDryRunOptions, BulkOperationDryRunResult, BulkOperationOptions, BulkSignalAllCommitOptions, BulkSignalAllDryRunOptions, BulkSignalResult, BulkTagResult, ListFilter, PurgeResult } from '../types.ts';
+import type { BulkCancelResult, BulkDeleteResult, BulkOperationCommitOptions, BulkOperationDryRunOptions, BulkOperationDryRunResult, BulkOperationOptions, BulkRetryFailedResult, BulkSignalAllCommitOptions, BulkSignalAllDryRunOptions, BulkSignalResult, BulkTagResult, ListFilter, PurgeResult } from '../types.ts';
 import { type CleanupWaiters } from './bulk-operations-purge.ts';
 import type { EngineInternals } from './internals.ts';
 export { purgeInternal, TERMINAL_CLEANUP_DELAY_MS } from './bulk-operations-purge.ts';
@@ -6,6 +6,9 @@ export declare function purge(internals: EngineInternals, filter: ListFilter | u
 export declare function cancelAll(internals: EngineInternals, filter: ListFilter, options: BulkOperationDryRunOptions): Promise<BulkOperationDryRunResult>;
 export declare function cancelAll(internals: EngineInternals, filter: ListFilter, options?: BulkOperationCommitOptions): Promise<BulkCancelResult>;
 export declare function cancelAll(internals: EngineInternals, filter: ListFilter, options?: BulkOperationDryRunOptions | BulkOperationCommitOptions): Promise<BulkCancelResult | BulkOperationDryRunResult>;
+export declare function retryFailedAll(internals: EngineInternals, filter: ListFilter, options: BulkOperationDryRunOptions): Promise<BulkOperationDryRunResult>;
+export declare function retryFailedAll(internals: EngineInternals, filter: ListFilter, options?: BulkOperationCommitOptions): Promise<BulkRetryFailedResult>;
+export declare function retryFailedAll(internals: EngineInternals, filter: ListFilter, options?: BulkOperationDryRunOptions | BulkOperationCommitOptions): Promise<BulkRetryFailedResult | BulkOperationDryRunResult>;
 export declare function signalAll(internals: EngineInternals, filter: ListFilter, name: string, payload: unknown, options: BulkSignalAllDryRunOptions): Promise<BulkOperationDryRunResult>;
 export declare function signalAll(internals: EngineInternals, filter: ListFilter, name: string, payload: unknown, options: BulkSignalAllCommitOptions): Promise<BulkSignalResult>;
 export declare function signalAll(internals: EngineInternals, filter: ListFilter, name: string, payload?: unknown, options?: BulkOperationCommitOptions): Promise<BulkSignalResult>;