@lostgradient/weft 0.12.0 → 0.14.0

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

@@ -12,6 +12,7 @@ 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 { decodeScheduleRunMetadata } from "./schedule-run-metadata.js";
 import { createTerminalCleanupTimerId } from "./state-utilities.js";
 import {
   decodeWorkflowState,
@@ -181,12 +182,22 @@ async function collectWorkflowPurgeDeleteKeys(internals, state) {
   const workflowId = state.id, deleteKeys = buildBaseWorkflowDeleteKeys(state);
   addExecutionDeadlineDeleteKeys(deleteKeys, state);
   addTerminalCleanupDeleteKey(deleteKeys, state);
+  await addScheduleRunHistoryDeleteKeys(internals.storage, deleteKeys, workflowId);
   await addUpdateRequestDeleteKeys(internals.storage, deleteKeys, workflowId);
   await addWorkflowPrefixDeleteKeys(internals.storage, deleteKeys, workflowId);
   return deleteKeys;
 }
+async function addScheduleRunHistoryDeleteKeys(storage, deleteKeys, workflowId) {
+  const linkKey = KEYS.scheduleRunLink(workflowId), linkBytes = await storage.get(linkKey);
+  deleteKeys.add(linkKey);
+  if (linkBytes === null)
+    return;
+  const metadata = decodeScheduleRunMetadata(linkBytes);
+  if (metadata !== null)
+    deleteKeys.add(KEYS.scheduleRunBySchedule(metadata.id, workflowId));
+}
 function buildBaseWorkflowDeleteKeys(state) {
-  return new Set([
+  const keys = new Set([
     KEYS.workflow(state.id),
     KEYS.checkpoint(state.id),
     KEYS.workflowHeaders(state.id),
@@ -196,9 +207,13 @@ function buildBaseWorkflowDeleteKeys(state) {
     KEYS.workflowHasServices(state.id),
     KEYS.finalizerState(state.id),
     KEYS.teardownOwed(state.id),
+    KEYS.teardownSucceeded(state.id),
     KEYS.attribute(state.id),
     KEYS.terminalWorkflow(state.updatedAt, state.id)
   ]);
+  if (state.parentWorkflowId !== void 0)
+    keys.add(KEYS.childWorkflowByParent(state.parentWorkflowId, state.parentWorkflowExecutionToken, state.id));
+  return keys;
 }
 function addExecutionDeadlineDeleteKeys(deleteKeys, state) {
   if (state.executionDeadline === void 0)

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

@@ -63,6 +63,8 @@ function summarizeBulkFilter(filter) {
     summary.status = Array.isArray(filter.status) ? uniqueSorted(filter.status) : filter.status;
   if (filter.type !== void 0)
     summary.type = filter.type;
+  if (filter.scheduleId !== void 0)
+    summary.scheduleId = filter.scheduleId;
   const normalizedTags = normalizeWorkflowTags(filter.tags);
   if (normalizedTags !== void 0)
     summary.tags = normalizedTags;

package/dist/core/engine/callback-checkpoint-persistence.d.ts

@@ -1,3 +1,5 @@
 import type { ContextOperationRequest } from '../context.ts';
+import { type PersistCheckpointCallbacks } from './checkpoint-io.ts';
 import type { Engine } from './index.ts';
+export declare function createCheckpointPersistenceCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): PersistCheckpointCallbacks;
 export declare function persistCheckpointForDataOperation<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, workflowId: string, operation: ContextOperationRequest): Promise<void>;

package/dist/core/engine/callback-checkpoint-persistence.js

@@ -9,8 +9,8 @@ import {
 import { getInternals } from "./internals.js";
 import { swallowPromiseRejection } from "./strategy-helpers.js";
 import { terminateWorkflow } from "./termination.js";
-export function persistCheckpointForDataOperation(engine, workflowId, operation) {
-  return persistCheckpoint(getInternals(engine), workflowId, operation, void 0, {
+export function createCheckpointPersistenceCallbacks(engine) {
+  return {
     appendTimelineBatchOperations: (id, checkpointOperation, step, timestamp, operations) => appendTimelineBatchOperations(getInternals(engine), id, checkpointOperation, step, timestamp, operations),
     swallowPromiseRejection: (promise) => {
       swallowPromiseRejection(promise);
@@ -21,5 +21,8 @@ export function persistCheckpointForDataOperation(engine, workflowId, operation)
       engine.dispatchEvent(event);
     },
     enforceHistoryCircuitBreaker: (id) => terminateWorkflow(getInternals(engine), id, "timed-out", createTerminationCallbacks(engine), HISTORY_CIRCUIT_BREAKER_REASON)
-  }, { timeline: "preserve-pending" });
+  };
+}
+export function persistCheckpointForDataOperation(engine, workflowId, operation) {
+  return persistCheckpoint(getInternals(engine), workflowId, operation, void 0, createCheckpointPersistenceCallbacks(engine), { timeline: "preserve-pending" });
 }

package/dist/core/engine/callback-creators-schedule.d.ts

@@ -1,12 +1,13 @@
 import type { ScheduleState, TimerEntry } from '../types.ts';
 import type { Engine } from './index.ts';
 import type { ReviewOperationCallbacks, SubmitReviewCallbacks } from './reviews.ts';
+import type { ScheduledRunStartOptions } from './schedule-run.ts';
 import { type RefreshedScheduleState, type ScheduleCallbacks } from './schedules.ts';
 export declare function createScheduleCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): ScheduleCallbacks;
 export declare function createReviewOperationCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): ReviewOperationCallbacks;
 export declare function createSubmitReviewCallbacks<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>): SubmitReviewCallbacks;
 export declare function refreshScheduledWorkflowStateForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState): Promise<RefreshedScheduleState>;
-export declare function startScheduledRunForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState, occurrence?: number): Promise<string>;
+export declare function startScheduledRunForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState, options?: ScheduledRunStartOptions): Promise<string>;
 export declare function applyScheduleOccurrenceForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState, occurrence?: number): Promise<ScheduleState>;
 export declare function settleBackfillScheduleStateForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, state: ScheduleState): Promise<ScheduleState>;
 export declare function handleScheduleTimerForEngine<TWorkflows extends object, TActivities extends object>(engine: Engine<TWorkflows, TActivities>, entry: TimerEntry): Promise<void>;

package/dist/core/engine/callback-creators-schedule.js

@@ -27,7 +27,7 @@ export function createScheduleCallbacks(engine) {
     cancelWorkflow: (workflowId) => engine.cancel(workflowId),
     getWorkflowResult: (workflowId) => engine.getHandle(workflowId).result(),
     refreshScheduledWorkflowState: (state) => refreshScheduledWorkflowStateForEngine(engine, state),
-    startScheduledRun: (state, occurrence) => startScheduledRunForEngine(engine, state, occurrence),
+    startScheduledRun: (state, options) => startScheduledRunForEngine(engine, state, options),
     applyScheduleOccurrence: (state, occurrence) => applyScheduleOccurrenceForEngine(engine, state, occurrence),
     settleBackfillScheduleState: (state) => settleBackfillScheduleStateForEngine(engine, state),
     flushQueuedInlineWorkflowStartsDirectly: () => flushQueuedInlineWorkflowStartsDirectly(getInternals(engine), createInlineLaunchQueueCallbacks(engine)),
@@ -51,8 +51,8 @@ export function createSubmitReviewCallbacks(engine) {
 export async function refreshScheduledWorkflowStateForEngine(engine, state) {
   return refreshScheduledWorkflowState(getInternals(engine), state, createScheduleCallbacks(engine));
 }
-export async function startScheduledRunForEngine(engine, state, occurrence) {
-  return startScheduledRun(getInternals(engine), state, createScheduleCallbacks(engine), occurrence);
+export async function startScheduledRunForEngine(engine, state, options) {
+  return startScheduledRun(getInternals(engine), state, createScheduleCallbacks(engine), options);
 }
 export async function applyScheduleOccurrenceForEngine(engine, state, occurrence) {
   return applyScheduleOccurrence(getInternals(engine), state, createScheduleCallbacks(engine), occurrence);

package/dist/core/engine/callback-creators.js

@@ -1,6 +1,5 @@
 import { KEYS } from "../../storage/interface.js";
-import { HISTORY_CIRCUIT_BREAKER_REASON } from "../types.js";
-import { validateAttributeValueSizes } from "./attributes-tags.js";
+import { createCheckpointPersistenceCallbacks } from "./callback-checkpoint-persistence.js";
 import {
   createConstraintCallbacks,
   createLifecycleCallbacks,
@@ -8,12 +7,7 @@ import {
   registerEnsureRetentionSweepInterval
 } from "./callback-creators-core.js";
 import { createOperationRouterCallbacks } from "./callback-creators-router.js";
-import {
-  appendTimelineBatchOperations,
-  persistCheckpoint,
-  pruneCheckpointHistory,
-  validateDevelopmentCheckpoint
-} from "./checkpoint-io.js";
+import { persistCheckpoint, validateDevelopmentCheckpoint } from "./checkpoint-io.js";
 import { evaluateConstraints } from "./constraints.js";
 import {
   getParkedWorkflowResumeDisposition,
@@ -30,8 +24,7 @@ import {
 } from "./retention.js";
 import { hasBufferedSignal } from "./signals.js";
 import { loadWorkflowState, runSerializedWorkflowStateWrite } from "./storage-io.js";
-import { swallowPromiseRejection } from "./strategy-helpers.js";
-import { cleanupWaiters, terminateWorkflow } from "./termination.js";
+import { cleanupWaiters } from "./termination.js";
 export { createUpdateCallbacks } from "./callback-creators-bundles.js";
 export {
   createBroadcastCallbacks,
@@ -64,18 +57,7 @@ export function createInlineParkingCallbacks(engine) {
   };
 }
 export function persistCheckpointForEngine(engine, workflowId, operation, workerCheckpointBytes) {
-  return persistCheckpoint(getInternals(engine), workflowId, operation, workerCheckpointBytes, {
-    appendTimelineBatchOperations: (id, checkpointOperation, step, timestamp, operations) => appendTimelineBatchOperations(getInternals(engine), id, checkpointOperation, step, timestamp, operations),
-    swallowPromiseRejection: (promise) => {
-      swallowPromiseRejection(promise);
-    },
-    validateAttributeValueSizes,
-    pruneCheckpointHistory: (id, step) => pruneCheckpointHistory(getInternals(engine), id, step),
-    dispatchEvent: (event) => {
-      engine.dispatchEvent(event);
-    },
-    enforceHistoryCircuitBreaker: (id) => terminateWorkflow(getInternals(engine), id, "timed-out", createTerminationCallbacks(engine), HISTORY_CIRCUIT_BREAKER_REASON)
-  });
+  return persistCheckpoint(getInternals(engine), workflowId, operation, workerCheckpointBytes, createCheckpointPersistenceCallbacks(engine));
 }
 function ensureRetentionSweepIntervalForEngine(engine) {
   ensureRetentionSweepInterval(getInternals(engine), {

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

@@ -9,7 +9,7 @@ type PendingTimelineEntryValue = {
 export type PersistCheckpointOptions = {
     timeline?: 'record-operation' | 'preserve-pending';
 };
-type PersistCheckpointCallbacks = {
+export type PersistCheckpointCallbacks = {
     appendTimelineBatchOperations: (workflowId: string, operation: ContextOperationRequest, step: number, timestamp: number, operations: BatchOperation[]) => PendingTimelineEntryValue;
     swallowPromiseRejection: (promise: Promise<void>) => void;
     validateAttributeValueSizes: (attributes: Record<string, SearchAttributeValue>) => void;

package/dist/core/engine/checkpoint-reads.js

@@ -66,12 +66,22 @@ export async function getTimeline(internals, workflowId) {
         inputSummary: sanitizeTimelineSummary(decoded.inputSummary) ?? decoded.inputSummary,
         ...decoded.outputSummary !== void 0 ? {
           outputSummary: sanitizeTimelineSummary(decoded.outputSummary) ?? decoded.outputSummary
-        } : {}
+        } : {},
+        ...decoded.branches === void 0 ? {} : { branches: decoded.branches.map(sanitizeTimelineOperationDetail) },
+        ...decoded.children === void 0 ? {} : { children: decoded.children.map(sanitizeTimelineOperationDetail) }
       });
   }
   timeline.sort((left, right) => left.step - right.step);
   return timeline;
 }
+function sanitizeTimelineOperationDetail(detail) {
+  if (detail.errorSummary === void 0)
+    return detail;
+  return {
+    ...detail,
+    errorSummary: sanitizeTimelineSummary(detail.errorSummary) ?? detail.errorSummary
+  };
+}
 export async function replayTo(internals, workflowId, step) {
   const bytes = await internals.storage.get(KEYS.checkpointHistory(workflowId, step));
   if (!bytes)

package/dist/core/engine/child-workflow.js

@@ -22,6 +22,8 @@ function applyPendingChildExecutionContext(internals, context) {
   internals.pendingNestingDepth = context.pendingNestingDepth;
   internals.pendingParentHeaders = context.pendingParentHeaders;
   internals.pendingExecutionStateOwnerId = context.pendingExecutionStateOwnerId;
+  internals.pendingParentWorkflowId = context.pendingParentWorkflowId;
+  internals.pendingParentWorkflowExecutionToken = context.pendingParentWorkflowExecutionToken;
 }
 function clearPendingChildExecutionContext(internals, context) {
   if (internals.pendingNestingDepth === context.pendingNestingDepth)
@@ -30,15 +32,20 @@ function clearPendingChildExecutionContext(internals, context) {
     internals.pendingParentHeaders = void 0;
   if (internals.pendingExecutionStateOwnerId === context.pendingExecutionStateOwnerId)
     internals.pendingExecutionStateOwnerId = void 0;
+  if (internals.pendingParentWorkflowId === context.pendingParentWorkflowId)
+    internals.pendingParentWorkflowId = void 0;
+  if (internals.pendingParentWorkflowExecutionToken === context.pendingParentWorkflowExecutionToken)
+    internals.pendingParentWorkflowExecutionToken = void 0;
 }
-function existingChildMatchesRequest(existingState, operation, executionStateOwnerId) {
-  return existingState.type === operation.workflowType && encodedValuesEqual(existingState.input, operation.input) && existingState.executionStateOwnerId === executionStateOwnerId;
+function existingChildMatchesRequest(existingState, operation, executionStateOwnerId, parentWorkflowId, parentWorkflowExecutionToken) {
+  const lineageMatches = existingState.parentWorkflowId === void 0 && existingState.parentWorkflowExecutionToken === void 0 || existingState.parentWorkflowId === parentWorkflowId && existingState.parentWorkflowExecutionToken === parentWorkflowExecutionToken;
+  return existingState.type === operation.workflowType && encodedValuesEqual(existingState.input, operation.input) && existingState.executionStateOwnerId === executionStateOwnerId && lineageMatches;
 }
-async function resolveCollisionChildHandle(childWorkflowId, operation, executionStateOwnerId, collisionError, callbacks) {
+async function resolveCollisionChildHandle(childWorkflowId, operation, executionStateOwnerId, parentWorkflowId, parentWorkflowExecutionToken, collisionError, callbacks) {
   const existingState = await callbacks.loadWorkflowState(childWorkflowId);
   if (!existingState)
     throw collisionError;
-  if (!existingChildMatchesRequest(existingState, operation, executionStateOwnerId))
+  if (!existingChildMatchesRequest(existingState, operation, executionStateOwnerId, parentWorkflowId, parentWorkflowExecutionToken))
     throw Error(`Child workflow id collision for "${childWorkflowId}" does not match the requested child workflow`, { cause: collisionError });
   return callbacks.getHandle(childWorkflowId);
 }
@@ -52,7 +59,7 @@ async function dispatchChildWorkflowStart(internals, childWorkflowId, operation,
   } catch (error) {
     if (!(error instanceof WorkflowAlreadyExistsError))
       throw error;
-    return resolveCollisionChildHandle(childWorkflowId, operation, context.pendingExecutionStateOwnerId ?? void 0, error, callbacks);
+    return resolveCollisionChildHandle(childWorkflowId, operation, context.pendingExecutionStateOwnerId ?? void 0, context.pendingParentWorkflowId, context.pendingParentWorkflowExecutionToken, error, callbacks);
   } finally {
     clearPendingChildExecutionContext(internals, context);
   }
@@ -62,7 +69,9 @@ export async function executeChildWorkflow(internals, workflowId, operation, cur
     const context = {
       pendingNestingDepth: currentDepth + 1,
       pendingParentHeaders: internals.workflowHeaders.get(workflowId),
-      pendingExecutionStateOwnerId: executionStateOwnerId
+      pendingExecutionStateOwnerId: executionStateOwnerId,
+      pendingParentWorkflowId: workflowId,
+      pendingParentWorkflowExecutionToken: parentState?.workflowExecutionToken
     }, childHandle = await dispatchChildWorkflowStart(internals, childWorkflowId, operation, context, callbacks);
     if (parentClosePolicy === "abandon")
       return createChildWorkflowHandleReference(childHandle.id);

package/dist/core/engine/construction.js

@@ -72,6 +72,9 @@ export function copyWorkflowDefinition(type, registration) {
     ...registration.description === void 0 ? {} : { description: registration.description },
     ...registration.inputSchema === void 0 ? {} : { inputSchema: registration.inputSchema },
     ...registration.outputSchema === void 0 ? {} : { outputSchema: registration.outputSchema },
+    ...registration.signals === void 0 ? {} : { signals: { ...registration.signals } },
+    ...registration.updates === void 0 ? {} : { updates: { ...registration.updates } },
+    ...registration.queries === void 0 ? {} : { queries: { ...registration.queries } },
     ...registration.searchAttributes === void 0 ? {} : { searchAttributes: registration.searchAttributes },
     ...registration.concurrency === void 0 ? {} : { concurrency: registration.concurrency }
   };

package/dist/core/engine/disposal.js

@@ -53,6 +53,8 @@ export function disposeEngine(internals) {
   internals.sleepTimersFiredWithoutResolver.clear();
   internals.checkpoints.clear();
   internals.pendingExecutionStateOwnerId = void 0;
+  internals.pendingParentWorkflowId = void 0;
+  internals.pendingParentWorkflowExecutionToken = void 0;
   internals.workflowNestingDepths.clear();
   internals.workflowServices.clear();
   internals.workflowHeaders.clear();

package/dist/core/engine/engine-internal-types.d.ts

@@ -2,7 +2,7 @@ import type { Storage as WeftStorage } from '../../storage/interface.ts';
 import type { ConstraintDefinition } from '../constraint.ts';
 import type { ExecutionStrategy } from '../execution-strategy.ts';
 import type { InlineExecutionStrategy } from '../inline-execution-strategy.ts';
-import type { AnyActivityDefinition, ArchiveAdapter, Checkpoint, DefinitionSchema, EngineOptions, NormalizedHistoryPolicy, NormalizedPayloadSizePolicy, NormalizedRetentionPolicy, SearchAttributeSchema, WorkflowConcurrencyOptions, WorkflowFunction, WorkflowTimelineEntry } from '../types.ts';
+import type { AnyActivityDefinition, ArchiveAdapter, Checkpoint, DefinitionSchema, EngineOptions, NormalizedHistoryPolicy, NormalizedPayloadSizePolicy, NormalizedRetentionPolicy, QueryDefinition, SearchAttributeSchema, SignalDefinition, UpdateDefinition, WorkflowConcurrencyOptions, WorkflowFunction, WorkflowTimelineEntry } from '../types.ts';
 export interface RegistrationEntry {
     handler: WorkflowFunction;
     version: string;
@@ -10,6 +10,9 @@ export interface RegistrationEntry {
     tags?: ReadonlyArray<string>;
     inputSchema?: DefinitionSchema;
     outputSchema?: DefinitionSchema;
+    signals?: Readonly<Record<string, Readonly<SignalDefinition<unknown>>>>;
+    updates?: Readonly<Record<string, Readonly<UpdateDefinition<unknown>>>>;
+    queries?: Readonly<Record<string, Readonly<QueryDefinition<unknown>>>>;
     searchAttributes?: SearchAttributeSchema;
     retention?: NormalizedRetentionPolicy;
     concurrency?: WorkflowConcurrencyOptions;

package/dist/core/engine/fenced-write.d.ts

@@ -27,9 +27,11 @@ import type { EngineInternals } from './internals.ts';
  * work before `recoverAll()` would otherwise durably write workflow state without
  * single-writer ownership and without having recovered existing runs. Placed at
  * each public awaited entry so the caller gets a clean {@link EngineLeaseNotHeldError}
- * — without this, fork/resume would reach `resolveFenceEpochOrHalt` with no held
- * epoch and be misreported as a deposition (warn + teardown) rather than the true
- * "lease not held yet" condition. A no-op under `ownership: 'none'`.
+ * — without this, fork, resume, and the schedule mutators (`schedule`,
+ * `pauseSchedule`, `resumeSchedule`, `cancelSchedule`, and `updateSchedule`) would
+ * reach `resolveFenceEpochOrHalt` with no held epoch and be misreported as a
+ * deposition (warn + teardown) rather than the true "lease not held yet"
+ * condition. A no-op under `ownership: 'none'`.
  */
 export declare function assertLeaseHeldForEngineWork(internals: EngineInternals): void;
 /**

package/dist/core/engine/finalizer-status.d.ts

@@ -0,0 +1,10 @@
+import { type BatchOperation } from '../../storage/interface.ts';
+import type { WorkflowFinalizerStatus, WorkflowState } from '../types.ts';
+import type { EngineInternals } from './internals.ts';
+export interface TeardownSucceededRecord {
+    attempts: number;
+    completedAt: number;
+    workflowExecutionToken?: string;
+}
+export declare function buildTeardownSuccessOperations(workflowId: string, attempts: number, completedAt: number, workflowExecutionToken: string | undefined): BatchOperation[];
+export declare function getFinalizerStatus(internals: EngineInternals, workflowId: string, state: WorkflowState | null): Promise<WorkflowFinalizerStatus | null>;

package/dist/core/engine/finalizer-status.js

@@ -0,0 +1,82 @@
+import { KEYS } from "../../storage/interface.js";
+import { decode, encode } from "../codec.js";
+import { isRecord } from "../debug-output.js";
+import { isTeardownClaim } from "./state-utilities.js";
+export function buildTeardownSuccessOperations(workflowId, attempts, completedAt, workflowExecutionToken) {
+  const outcome = {
+    attempts,
+    completedAt,
+    ...workflowExecutionToken === void 0 ? {} : { workflowExecutionToken }
+  };
+  return [
+    { type: "delete", key: KEYS.teardownOwed(workflowId) },
+    { type: "delete", key: KEYS.finalizerState(workflowId) },
+    { type: "put", key: KEYS.teardownSucceeded(workflowId), value: encode(outcome) }
+  ];
+}
+function decodeUnknown(bytes) {
+  try {
+    return decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function isNonNegativeSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isNonNegativeFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function recordBelongsToRun(record, state) {
+  const recordToken = record.workflowExecutionToken;
+  if (recordToken !== void 0 && typeof recordToken !== "string")
+    return !1;
+  if (state === null)
+    return !0;
+  return recordToken === state.workflowExecutionToken;
+}
+export async function getFinalizerStatus(internals, workflowId, state) {
+  const claimBytes = await internals.storage.get(KEYS.teardownOwed(workflowId)), claimStatus = decodeClaimStatus(claimBytes);
+  if (claimStatus !== null)
+    return claimStatus;
+  const deadLetterBytes = await internals.storage.get(KEYS.teardownDeadLetter(workflowId)), failedStatus = decodeFailedStatus(deadLetterBytes, state);
+  if (failedStatus !== null)
+    return failedStatus;
+  const succeededBytes = await internals.storage.get(KEYS.teardownSucceeded(workflowId));
+  return decodeSucceededStatus(succeededBytes, state);
+}
+function decodeClaimStatus(bytes) {
+  if (bytes === null)
+    return null;
+  const claim = decodeUnknown(bytes);
+  if (!isTeardownClaim(claim))
+    return null;
+  if (claim.status === "running" && claim.claimedAt !== void 0)
+    return { status: "running", attempts: claim.attempts + 1, startedAt: claim.claimedAt };
+  return { status: "pending", attempts: claim.attempts };
+}
+function decodeFailedStatus(bytes, state) {
+  if (bytes === null)
+    return null;
+  const record = decodeUnknown(bytes);
+  if (!isRecord(record) || !recordBelongsToRun(record, state) || typeof record.lastError !== "string" || !isNonNegativeSafeInteger(record.attempts) || !isNonNegativeFiniteNumber(record.deadLetteredAt))
+    return null;
+  return {
+    status: "failed",
+    attempts: record.attempts,
+    failedAt: record.deadLetteredAt,
+    error: record.lastError
+  };
+}
+function decodeSucceededStatus(bytes, state) {
+  if (bytes === null)
+    return null;
+  const record = decodeUnknown(bytes);
+  if (!isRecord(record) || !recordBelongsToRun(record, state) || !isNonNegativeSafeInteger(record.attempts) || !isNonNegativeFiniteNumber(record.completedAt))
+    return null;
+  return {
+    status: "succeeded",
+    attempts: record.attempts,
+    completedAt: record.completedAt
+  };
+}

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

@@ -5,7 +5,7 @@ import type { TypedEventTarget, WeftEventMap } from '../events.ts';
 import type { Interceptor } from '../interceptor.ts';
 import { type ReviewRequest } from '../review/index.ts';
 import { Scheduler } from '../scheduler.ts';
-import { type AnyActivityDefinition, type AnyWorkflowDefinition, type AttributeFilterKey, type BulkCancelResult, type BulkDeleteResult, type BulkOperationCommitOptions, type BulkOperationDryRunOptions, type BulkOperationDryRunResult, type BulkRetryFailedResult, type BulkSignalAllCommitOptions, type BulkSignalAllDryRunOptions, type BulkSignalResult, type BulkTagResult, type CheckpointState, type CheckpointSummary, type CoordinatedUpdateResult, type DefaultActivityTypes, type DefaultWorkflowRegistry, type ForkOptions, type InferActivityEntries, type InferActivityEntry, type InferWorkflowEntries, type InferWorkflowEntry, type ListFilter, type ListOptions, type PaginatedResult, type PurgeResult, type QueryDefinition, type RegisteredWorkflowDefinition, type RetentionOverview, type ReviewListEntry, type ReviewListFilter, type ScheduleDefinition, type ScheduleFilter, type ScheduleOptions, type ScheduleSpec, type ScheduleSummary, type SearchAttributeValue, type SignalDefinition, type SignalDeliveryOptions, type StartOrSignalOptions, type StartOrSignalSignal, type StartWorkflowOptions, type SubmitReviewOptions, type TypedListFilter, type UpdateDefinition, type WorkflowEvent, type WorkflowInput, type WorkflowOutput, type WorkflowReplay, type WorkflowServices, type WorkflowServicesUnion, type WorkflowState, type WorkflowSummary, type WorkflowTimelineEntry } from '../types.ts';
+import { type AnyActivityDefinition, type AnyWorkflowDefinition, type AttributeFilterKey, type BulkCancelResult, type BulkDeleteResult, type BulkOperationCommitOptions, type BulkOperationDryRunOptions, type BulkOperationDryRunResult, type BulkRetryFailedResult, type BulkSignalAllCommitOptions, type BulkSignalAllDryRunOptions, type BulkSignalResult, type BulkTagResult, type CheckpointState, type CheckpointSummary, type CoordinatedUpdateResult, type DefaultActivityTypes, type DefaultWorkflowRegistry, type ForkOptions, type InferActivityEntries, type InferActivityEntry, type InferWorkflowEntries, type InferWorkflowEntry, type ListFilter, type ListOptions, type PaginatedResult, type PendingAsyncActivityListOptions, type PendingAsyncActivityPage, type PurgeResult, type QueryDefinition, type RegisteredWorkflowDefinition, type RetentionOverview, type ReviewListEntry, type ReviewListFilter, type ScheduleDefinition, type ScheduleFilter, type ScheduleOptions, type ScheduleSpec, type ScheduleSummary, type ScheduleUpdateOptions, type SearchAttributeValue, type SignalDefinition, type SignalDeliveryOptions, type StartOrSignalOptions, type StartOrSignalSignal, type StartWorkflowOptions, type SubmitReviewOptions, type TypedListFilter, type UpdateDefinition, type WorkflowEvent, type WorkflowFinalizerStatus, type WorkflowInput, type WorkflowOutput, type WorkflowReplay, type WorkflowScheduleProvenance, type WorkflowServices, type WorkflowServicesUnion, type WorkflowState, type WorkflowSummary, type WorkflowTimelineEntry } from '../types.ts';
 import type { TimerEntry } from '../types/checkpoint.ts';
 import type { WorkflowAlreadyRegistered } from '../types/workflow-builder.ts';
 import { type AggregateOptions, type AggregateResult } from './aggregate.ts';
@@ -15,6 +15,7 @@ import type { EngineConstructorOptions } from './engine-internal-types.ts';
 import type { EngineStateNamespace } from './engine-state-namespace.ts';
 import { HANDLE_RESULT_PROMISE, WorkflowHandle } from './handles.ts';
 import { ENGINE_LEASE_LOST_WARNING_NAME } from './lease-deposition.ts';
+import type { EngineLeaseHealth } from './lease-health.ts';
 import { type RecoverAllOptions, type StartOrSignalResult } from './lifecycle.ts';
 import { assertCompatiblePersistedDataVersion } from './persisted-data-version.ts';
 import { ScheduleHandle } from './schedule-handle.ts';
@@ -26,6 +27,7 @@ export type { PendingTimelineEntry, RegistrationEntry, ResolvedOptions, TrackedW
 export { ActivityResolutionError, BulkDeleteRequiresTerminalWorkflowsError, BulkOperationConfirmationError, EngineCreateNameMismatchError, EngineDisposedError, IdempotencyKeyPurgedError, PersistedDataIncompatibleError, StartOrSignalConflictError, WorkflowAlreadyExistsError, WorkflowConcurrencyLimitExceededError, WorkflowNotFoundError, WorkflowNotRegisteredError, WorkflowSuspendNotSupportedError, WorkflowTeardownPendingError, WorkflowTypeNotRegisteredForRecoveryError, } from './errors.ts';
 export { HANDLE_RESULT_PROMISE, WorkflowHandle } from './handles.ts';
 export { EngineLeaseAcquisitionTimeoutError, EngineLeaseCorruptedError, EngineLeaseNotHeldError, } from './lease-errors.ts';
+export type { EngineLeaseHealth, LeaseLostReason } from './lease-health.ts';
 export type { RecoverAllOptions, RecoveredWorkflowInfo } from './lifecycle.ts';
 export { ScheduleHandle } from './schedule-handle.ts';
 export type { WorkflowFeedListener, WorkflowFeedRecord, WorkflowFeedSelector, } from './workflow-feed.ts';
@@ -304,7 +306,7 @@ export declare class Engine<TWorkflows extends object = DefaultWorkflowRegistry,
     pauseSchedule(scheduleId: string): Promise<void>;
     resumeSchedule(scheduleId: string): Promise<void>;
     cancelSchedule(scheduleId: string): Promise<void>;
-    updateSchedule(scheduleId: string, newSpec: string | ScheduleSpec): Promise<void>;
+    updateSchedule(scheduleId: string, newSpec: string | ScheduleSpec, options?: ScheduleUpdateOptions): Promise<void>;
     [HANDLE_RESULT_PROMISE](workflowId: string): Promise<unknown>;
     [ENGINE_PARKED_WORKFLOW_COUNT_FOR_TESTING](): number;
     [ENGINE_SIGNAL_WAITER_COUNT_FOR_TESTING](): number;
@@ -394,6 +396,13 @@ export declare class Engine<TWorkflows extends object = DefaultWorkflowRegistry,
      * the token (unknown, or already completed/failed — tokens are single-use).
      */
     completeAsyncActivity(token: string, result: unknown): Promise<void>;
+    /**
+     * List a bounded page of durable async activities awaiting out-of-band
+     * completion for one workflow. This reads storage directly, so callers can
+     * recover tokens after a process restart before `recoverAll()` repopulates
+     * the in-memory completion map.
+     */
+    listPendingAsyncActivities(workflowId: string, options?: PendingAsyncActivityListOptions): Promise<PendingAsyncActivityPage>;
     /**
      * Fail a deferred activity out-of-band with `error`. The error is thrown into
      * the workflow generator at the parked step — identical to an inline activity
@@ -425,6 +434,21 @@ export declare class Engine<TWorkflows extends object = DefaultWorkflowRegistry,
     suspend(workflowId: string): Promise<void>;
     timeout(workflowId: string): Promise<void>;
     get(workflowId: string): Promise<WorkflowState | null>;
+    /** Return the schedule occurrence that launched a workflow, when applicable. */
+    getScheduleProvenance(workflowId: string): Promise<WorkflowScheduleProvenance | null>;
+    /** Return durable post-terminal finalizer progress or outcome, when applicable. */
+    getFinalizerStatus(workflowId: string): Promise<WorkflowFinalizerStatus | null>;
+    /**
+     * Return this process's last-known ownership-lease health.
+     *
+     * This is a synchronous diagnostic snapshot: it never performs a storage read
+     * and therefore remains available to operator transports after a confirmed
+     * deposition has detached the lease manager. Holder identifiers and timestamps
+     * are present only while the manager still has its own last-written holder
+     * record; a detached deposed engine reports the confirmed loss without
+     * inventing successor details.
+     */
+    getLeaseHealth(): EngineLeaseHealth;
     getCurrentCheckpointStep(workflowId: string): Promise<number | null>;
     getAttributes(workflowId: string): Promise<Record<string, SearchAttributeValue> | null>;
     setAttributes(workflowId: string, attributes: Record<string, SearchAttributeValue>): Promise<void>;

package/dist/core/engine/index.js

@@ -22,7 +22,10 @@ import {
   completeAsyncActivity as completeAsyncActivityFromInternals,
   failAsyncActivity as failAsyncActivityFromInternals
 } from "./async-activity-completion.js";
-import { recoverPendingAsyncActivities } from "./async-activity-records.js";
+import {
+  listPendingAsyncActivities as listPendingAsyncActivitiesFromInternals,
+  recoverPendingAsyncActivities
+} from "./async-activity-records.js";
 import { broadcast as broadcastFromInternals } from "./broadcast.js";
 import {
   cancelAll as cancelAllWorkflows,
@@ -81,6 +84,7 @@ import {
 } from "./errors.js";
 import { assertLeaseHeldForEngineWork, commitFencedEngineWrite } from "./fenced-write.js";
 import { recordFinalizerState } from "./finalizer-state.js";
+import { getFinalizerStatus as getFinalizerStatusFromInternals } from "./finalizer-status.js";
 import {
   createWorkflowHandleWithResultPromise as createWorkflowHandleWithResultPromiseFromInternals,
   getWorkflowResultPromise as getWorkflowResultPromiseFromInternals
@@ -134,6 +138,7 @@ import {
   submitReview as submitReviewFromInternals
 } from "./reviews.js";
 import { ScheduleHandle } from "./schedule-handle.js";
+import { decodeScheduleRunMetadata } from "./schedule-run-metadata.js";
 import {
   cancelSchedule as cancelScheduleFromInternals,
   listSchedules as listSchedulesFromInternals,
@@ -306,9 +311,12 @@ export class Engine extends EventTarget {
     getInternals(this).pendingNestingDepth = void 0;
     getInternals(this).pendingParentHeaders = void 0;
     getInternals(this).pendingExecutionStateOwnerId = void 0;
+    getInternals(this).pendingParentWorkflowId = void 0;
+    getInternals(this).pendingParentWorkflowExecutionToken = void 0;
     getInternals(this).workflowNestingDepths = new Map;
     getInternals(this).workflowHeaders = new Map;
     getInternals(this).workflowStateWriteChains = new Map;
+    getInternals(this).scheduleStateOperationChains = new Map;
     getInternals(this).finalizationRegistry = new FinalizationRegistry(createHandleCacheFinalizer(getInternals(this).handleCache));
     getInternals(this).options = resolvedOptions;
     getInternals(this).scheduler = new Scheduler({
@@ -641,11 +649,13 @@ export class Engine extends EventTarget {
     return untagAllWorkflows(getInternals(this), filter, tags, options);
   }
   async schedule(typeOrDefinition, input, spec, options) {
+    const internals = getInternals(this);
+    assertLeaseHeldForEngineWork(internals);
     if (typeof typeOrDefinition === "object")
-      return scheduleDefinitionFromInternals(getInternals(this), typeOrDefinition);
+      return scheduleDefinitionFromInternals(internals, typeOrDefinition);
     if (spec === void 0)
       throw Error("A cron string or schedule spec must be provided when scheduling by workflow type.");
-    return scheduleFromInternals(getInternals(this), typeOrDefinition, input, spec, options);
+    return scheduleFromInternals(internals, typeOrDefinition, input, spec, options);
   }
   async getSchedule(scheduleId) {
     const normalizedScheduleId = coerceScheduleId(scheduleId, "scheduleId"), state = await loadScheduleState(getInternals(this), normalizedScheduleId);
@@ -655,16 +665,24 @@ export class Engine extends EventTarget {
     return listSchedulesFromInternals(getInternals(this), filter);
   }
   async pauseSchedule(scheduleId) {
-    return pauseScheduleFromInternals(getInternals(this), scheduleId);
+    const internals = getInternals(this);
+    assertLeaseHeldForEngineWork(internals);
+    return pauseScheduleFromInternals(internals, scheduleId);
   }
   async resumeSchedule(scheduleId) {
-    return resumeScheduleFromInternals(getInternals(this), scheduleId);
+    const internals = getInternals(this);
+    assertLeaseHeldForEngineWork(internals);
+    return resumeScheduleFromInternals(internals, scheduleId);
   }
   async cancelSchedule(scheduleId) {
-    return cancelScheduleFromInternals(getInternals(this), scheduleId);
+    const internals = getInternals(this);
+    assertLeaseHeldForEngineWork(internals);
+    return cancelScheduleFromInternals(internals, scheduleId);
   }
-  async updateSchedule(scheduleId, newSpec) {
-    return updateScheduleFromInternals(getInternals(this), scheduleId, newSpec);
+  async updateSchedule(scheduleId, newSpec, options) {
+    const internals = getInternals(this);
+    assertLeaseHeldForEngineWork(internals);
+    return updateScheduleFromInternals(internals, scheduleId, newSpec, options);
   }
   [HANDLE_RESULT_PROMISE](workflowId) {
     return getWorkflowResultPromiseFromInternals(getInternals(this), workflowId);
@@ -721,6 +739,9 @@ export class Engine extends EventTarget {
       finalizeTimeline: (workflowId, status, output) => finalizePendingTimelineEntry(getInternals(this), workflowId, status, output)
     });
   }
+  async listPendingAsyncActivities(workflowId, options) {
+    return listPendingAsyncActivitiesFromInternals(getInternals(this), workflowId, options);
+  }
   async failAsyncActivity(token, error) {
     await failAsyncActivityFromInternals(getInternals(this), token, error, {
       feedOperationResult: (workflowId, outcome, originalReason) => feedOperationResult(getInternals(this), workflowId, outcome, originalReason),
@@ -742,6 +763,48 @@ export class Engine extends EventTarget {
       return { ...state, status: "pending" };
     return state;
   }
+  async getScheduleProvenance(workflowId) {
+    const bytes = await getInternals(this).storage.get(KEYS.scheduleRunLink(workflowId));
+    if (bytes === null)
+      return null;
+    const metadata = decodeScheduleRunMetadata(bytes);
+    if (metadata === null)
+      return null;
+    return {
+      scheduleId: metadata.id,
+      ...metadata.occurrence === void 0 ? {} : { occurrence: metadata.occurrence }
+    };
+  }
+  async getFinalizerStatus(workflowId) {
+    const internals = getInternals(this), state = await loadWorkflowState(internals, workflowId);
+    return getFinalizerStatusFromInternals(internals, workflowId, state);
+  }
+  getLeaseHealth() {
+    const internals = getInternals(this);
+    if (internals.options.ownershipMode === "none")
+      return { mode: "none", status: "disabled", holdsLease: !1 };
+    if (internals.deposed) {
+      const lastKnownLease = internals.leaseManager?.health();
+      if (lastKnownLease !== void 0 && lastKnownLease.status !== "no-lease")
+        return {
+          mode: "lease",
+          ...lastKnownLease,
+          status: "contested",
+          holdsLease: !1,
+          lossReason: "deposed"
+        };
+      return {
+        mode: "lease",
+        status: "contested",
+        holdsLease: !1,
+        lossReason: "deposed"
+      };
+    }
+    return {
+      mode: "lease",
+      ...internals.leaseManager?.health() ?? { status: "no-lease", holdsLease: !1 }
+    };
+  }
   async getCurrentCheckpointStep(workflowId) {
     const inMemory = getInternals(this).checkpoints.get(workflowId);
     if (inMemory !== void 0)