@lostgradient/weft 0.12.0 → 0.13.0

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)

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

@@ -175,9 +175,12 @@ export interface EngineInternals {
     pendingNestingDepth: number | undefined;
     pendingParentHeaders: Map<string, string> | undefined;
     pendingExecutionStateOwnerId: string | null | undefined;
+    pendingParentWorkflowId: string | undefined;
+    pendingParentWorkflowExecutionToken: string | undefined;
     workflowNestingDepths: Map<string, number>;
     workflowHeaders: Map<string, Map<string, string>>;
     workflowStateWriteChains: Map<string, Promise<void>>;
+    scheduleStateOperationChains: Map<string, Promise<void>>;
     heartbeatDetails: Map<string, unknown>;
     /**
      * Last heartbeat payload PER ACTIVITY STEP, so a retry of a step can read the

package/dist/core/engine/lease-health.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Why a holder lost its lease while running. `deposed` is confirmed ownership
+ * loss; `renewal-unconfirmable` means storage failures outlasted the last
+ * confirmed lease expiry.
+ *
+ * @example
+ * ```ts
+ * import type { LeaseLostReason } from '@lostgradient/weft';
+ *
+ * function requiresImmediateHandoff(reason: LeaseLostReason): boolean {
+ *   return reason === 'deposed';
+ * }
+ * void requiresImmediateHandoff;
+ * ```
+ */
+export type LeaseLostReason = 'deposed' | 'renewal-unconfirmable';
+/** Process-local, last-known ownership state exposed through the operator API. */
+export type LeaseManagerHealth = {
+    status: 'no-lease';
+    holdsLease: false;
+} | {
+    status: 'healthy';
+    holdsLease: true;
+    holderId: string;
+    heldSince: number;
+    expiresAt: number;
+    lastRenewedAt: number;
+    fencingEpoch: number;
+} | {
+    status: 'contested';
+    holdsLease: false;
+    lossReason?: LeaseLostReason;
+    holderId: string;
+    heldSince: number;
+    expiresAt: number;
+    lastRenewedAt: number;
+    fencingEpoch: number;
+};
+/**
+ * Public engine ownership-health snapshot returned by
+ * {@link Engine.getLeaseHealth} and `weft.system.lease`.
+ *
+ * @example
+ * ```ts
+ * import type { EngineLeaseHealth } from '@lostgradient/weft';
+ *
+ * function needsOperatorAttention(health: EngineLeaseHealth): boolean {
+ *   return health.status === 'contested';
+ * }
+ * void needsOperatorAttention;
+ * ```
+ */
+export type EngineLeaseHealth = {
+    mode: 'none';
+    status: 'disabled';
+    holdsLease: false;
+} | ({
+    mode: 'lease';
+} & LeaseManagerHealth) | {
+    mode: 'lease';
+    status: 'contested';
+    holdsLease: false;
+    lossReason: 'deposed';
+};

package/dist/core/engine/lease-manager.d.ts

@@ -44,8 +44,8 @@
  * @module core/engine/lease-manager
  */
 import { type Storage } from '../../storage/interface.ts';
-/** Why a holder lost its lease — surfaced to {@link LeaseManagerOptions.onLeaseLost}. */
-export type LeaseLostReason = 'deposed' | 'renewal-unconfirmable';
+import type { LeaseLostReason, LeaseManagerHealth } from './lease-health.ts';
+export type { LeaseLostReason } from './lease-health.ts';
 /** Options for {@link createLeaseManager}. */
 export type LeaseManagerOptions = {
     storage: Storage;
@@ -102,6 +102,8 @@ export type LeaseManager = {
     startRenewal(): void;
     renewOnce(): Promise<void>;
     currentEpochBytes(): Uint8Array | null;
+    /** Return a defensive, synchronous view of this process's last-known lease state. */
+    health(): LeaseManagerHealth;
     release(): Promise<void>;
     stop(): void;
 };

package/dist/core/engine/lease-manager.js

@@ -9,12 +9,13 @@ import { EngineLeaseAcquisitionTimeoutError, EngineLeaseCorruptedError } from ".
 const DEFAULT_ACQUIRE_POLL_INTERVAL_MS = 1000;
 export function createLeaseManager(options) {
   const { storage, holderId, getNow, ttlMs, renewIntervalMs, waitTimeoutMs } = options, acquirePollIntervalMs = options.acquirePollIntervalMs ?? DEFAULT_ACQUIRE_POLL_INTERVAL_MS;
-  let stopped = !1, heldEpoch = null, heldEpochBytes = null, lastHolderBytes = null, renewalInterval = null, leaseLost = !1, inFlightRenewal = null;
+  let stopped = !1, heldEpoch = null, heldEpochBytes = null, lastHolderBytes = null, renewalInterval = null, leaseLost = !1, leaseLostReason = null, heldSince = null, lastRenewedAt = null, inFlightRenewal = null;
   const delay = options.delay ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
   function reportLeaseLost(reason) {
     if (leaseLost)
       return;
     leaseLost = !0;
+    leaseLostReason = reason;
     options.onLeaseLost?.(reason);
   }
   async function readState() {
@@ -27,7 +28,7 @@ export function createLeaseManager(options) {
     };
   }
   async function takeOwnership(expectedEpochBytes, expectedHolderBytes, nextEpoch) {
-    const expiresAt = getNow() + ttlMs, holderBytes = encodeHolder({ holderId, expiresAt, epoch: nextEpoch }), committed = await storageConditionalBatch(storage, [
+    const acquiredAt = getNow(), expiresAt = acquiredAt + ttlMs, holderBytes = encodeHolder({ holderId, expiresAt, epoch: nextEpoch }), committed = await storageConditionalBatch(storage, [
       { key: KEYS.leaseEpoch(), expectedValue: expectedEpochBytes },
       { key: KEYS.leaseHolder(), expectedValue: expectedHolderBytes }
     ], [
@@ -38,6 +39,8 @@ export function createLeaseManager(options) {
       heldEpoch = nextEpoch;
       heldEpochBytes = encodeEpoch(nextEpoch);
       lastHolderBytes = holderBytes;
+      heldSince = acquiredAt;
+      lastRenewedAt = acquiredAt;
     }
     return committed;
   }
@@ -75,7 +78,7 @@ export function createLeaseManager(options) {
   async function renewOnce() {
     if (stopped || leaseLost || heldEpoch === null || lastHolderBytes === null)
       return;
-    const expiresAt = getNow() + ttlMs, holderBytes = encodeHolder({ holderId, expiresAt, epoch: heldEpoch });
+    const renewedAt = getNow(), expiresAt = renewedAt + ttlMs, holderBytes = encodeHolder({ holderId, expiresAt, epoch: heldEpoch });
     let committed;
     try {
       committed = await storageConditionalBatch(storage, [{ key: KEYS.leaseHolder(), expectedValue: lastHolderBytes }], [{ type: "put", key: KEYS.leaseHolder(), value: holderBytes }]);
@@ -87,6 +90,7 @@ export function createLeaseManager(options) {
     }
     if (committed) {
       lastHolderBytes = holderBytes;
+      lastRenewedAt = renewedAt;
       return;
     }
     reportLeaseLost("deposed");
@@ -109,6 +113,30 @@ export function createLeaseManager(options) {
   function currentEpochBytes() {
     return heldEpochBytes === null ? null : heldEpochBytes.slice();
   }
+  function health() {
+    if (stopped)
+      return { status: "no-lease", holdsLease: !1 };
+    const holder = lastHolderBytes === null ? null : decodeHolder(lastHolderBytes);
+    if (holder === null || heldEpoch === null || heldSince === null || lastRenewedAt === null)
+      return { status: "no-lease", holdsLease: !1 };
+    const lastKnownLease = {
+      holderId: holder.holderId,
+      heldSince,
+      expiresAt: holder.expiresAt,
+      lastRenewedAt,
+      fencingEpoch: heldEpoch
+    };
+    if (leaseLostReason !== null)
+      return {
+        status: "contested",
+        holdsLease: !1,
+        lossReason: leaseLostReason,
+        ...lastKnownLease
+      };
+    if (getNow() >= holder.expiresAt)
+      return { status: "contested", holdsLease: !1, ...lastKnownLease };
+    return { status: "healthy", holdsLease: !0, ...lastKnownLease };
+  }
   function clearRenewal() {
     if (renewalInterval !== null) {
       clearInterval(renewalInterval);
@@ -131,5 +159,5 @@ export function createLeaseManager(options) {
     stopped = !0;
     clearRenewal();
   }
-  return { acquire, startRenewal, renewOnce, currentEpochBytes, release, stop };
+  return { acquire, startRenewal, renewOnce, currentEpochBytes, health, release, stop };
 }

package/dist/core/engine/lifecycle/recovered-services.js

@@ -80,7 +80,5 @@ async function scheduleFromWorkflowState(internals, state) {
     return metadata;
   if (metadata.occurrence !== void 0 && scheduleState.nextFireAt === metadata.occurrence)
     return metadata;
-  if (metadata.occurrence === void 0 && scheduleState.overlap === "queue" && scheduleState.queuedRuns > 0)
-    return metadata;
   return null;
 }

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

@@ -58,19 +58,22 @@ export type RecoverAllOptions = {
      */
     onRecoveredWorkflow?: (info: RecoveredWorkflowInfo) => void | Promise<void>;
     /**
-     * Policy for a recovered workflow whose stored {@link WorkflowVersionTuple}
-     * (or legacy checkpoint `version`) no longer matches the registered
-     * {@link WorkflowDefinition.version}. The mismatch is detected before
-     * `resolveWorkflowServices` and `onRecoveredWorkflow` run for that workflow,
-     * so a mismatched run never re-provides services or invokes the hook.
+     * Policy for a recovered workflow whose persisted
+     * {@link WorkflowVersionTuple} or checkpoint `version` no longer matches the
+     * registered {@link WorkflowDefinition.version}. Recovery checks both
+     * persisted records against the registered version so current workflow-state
+     * metadata cannot mask a stale checkpoint version. The mismatch is detected
+     * before `resolveWorkflowServices` and `onRecoveredWorkflow` run for that
+     * workflow, so a mismatched run never re-provides services or invokes the
+     * hook.
      *
      * - `'fail-run'` (default): fail only the mismatched run to a terminal
      *   `failed` state with a `system` failure category carrying the
      *   {@link VersionMismatchError} message, then continue recovering its
      *   siblings. The run never advances user workflow code.
-     * - `'throw'`: preserve the pre-#702 behavior — rethrow the
-     *   {@link VersionMismatchError} out of `recoverAll()` immediately, aborting
-     *   recovery for every workflow not yet processed in this batch.
+     * - `'throw'`: use fail-fast recovery — rethrow the
+     *   {@link VersionMismatchError} out of `recoverAll()` immediately, leaving
+     *   every workflow not yet processed in this batch unresumed.
      */
     versionMismatchPolicy?: 'fail-run' | 'throw';
 };

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

@@ -19,6 +19,7 @@ export function buildStartBatchOperations(_internals, workflowId, state, checkpo
     },
     ...visibilityIndexOperations,
     ...buildWorkflowTagIndexOperations(workflowId, void 0, state.tags),
+    ...buildChildWorkflowIndexOperations(state),
     ...buildInitialSearchAttributeOperations(_internals, workflowId, registration, options?.searchAttributes, callbacks),
     ...buildPerRunScratchOperations(workflowId, options, workflowStartHeaders),
     ...additionalOperations ?? []
@@ -34,6 +35,17 @@ export function buildStartBatchOperations(_internals, workflowId, state, checkpo
     operations.push(...buildTimerBatchOperations(delayedStartTimer));
   return operations;
 }
+function buildChildWorkflowIndexOperations(state) {
+  if (state.parentWorkflowId === void 0)
+    return [];
+  return [
+    {
+      type: "put",
+      key: KEYS.childWorkflowByParent(state.parentWorkflowId, state.parentWorkflowExecutionToken, state.id),
+      value: EMPTY_STORAGE_VALUE
+    }
+  ];
+}
 function buildPerRunScratchOperations(workflowId, options, workflowStartHeaders) {
   const hasHeaders = workflowStartHeaders !== void 0 && workflowStartHeaders.size > 0, hasServices = options?.services !== void 0, operations = [];
   if (hasHeaders)

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

@@ -9,5 +9,5 @@ export declare function start(internals: EngineInternals, type: string, input: u
 export declare function startWorkflow(internals: EngineInternals, type: string, input: unknown, options: StartWorkflowOptions | undefined, additionalStartOperations: BatchOperation[] | undefined, callbacks: LifecycleCallbacks, buildIdempotentStartOperations?: BuildIdempotentStartOperations): Promise<WorkflowHandle>;
 export declare function resolveScheduledStartAt(internals: EngineInternals, options: StartOptions | undefined, submissionTime: number, callbacks: LifecycleCallbacks): number | undefined;
 export declare function parseStartOptionDuration(_internals: EngineInternals, duration: Duration, fieldName: 'options.executionTimeout' | 'options.startAfter', _callbacks: LifecycleCallbacks): number;
-export declare function createInitialWorkflowState(internals: EngineInternals, workflowId: string, type: string, input: unknown, versionTuple: WorkflowVersionTuple, options: StartOptions | undefined, tags: string[] | undefined, executionStateOwnerId: string | undefined, delayedStartTimer: TimerEntry | undefined, callbacks: LifecycleCallbacks): WorkflowState;
+export declare function createInitialWorkflowState(internals: EngineInternals, workflowId: string, type: string, input: unknown, versionTuple: WorkflowVersionTuple, options: StartOptions | undefined, tags: string[] | undefined, executionStateOwnerId: string | undefined, parentWorkflowId: string | undefined, parentWorkflowExecutionToken: string | undefined, delayedStartTimer: TimerEntry | undefined, callbacks: LifecycleCallbacks): WorkflowState;
 export declare function createInitialCheckpoint(internals: EngineInternals, workflowId: string, workflowVersion: string, options: StartOptions | undefined, _callbacks: LifecycleCallbacks): Checkpoint;