@lostgradient/weft 0.2.1 → 0.4.0

package/dist/core/engine/termination/finalizer.js

@@ -0,0 +1,159 @@
+import { KEYS } from "../../../storage/interface.js";
+import { decode } from "../../codec.js";
+import { WorkflowTeardownEvent } from "../../events.js";
+import { isTeardownClaim, parseTeardownTimerId } from "../state-utilities.js";
+import { runFinalizerActivity } from "./finalizer-activity.js";
+import {
+  claimTeardownMarker,
+  clearTeardownMarker,
+  deadLetterTeardown,
+  encodeOwedClaim,
+  MAX_TEARDOWN_ATTEMPTS,
+  rearmTeardownTimer,
+  runningClaimIsStale,
+  settleOnRunningClaim,
+  TEARDOWN_SELF_HEAL_DELAY_MS,
+  teardownBackoffMs,
+  teardownStaleThresholdMs,
+  teardownTimerOperations
+} from "./finalizer-claim.js";
+export { teardownStaleThresholdMs } from "./finalizer-claim.js";
+const TERMINAL_STATUSES_OWED_TEARDOWN = new Set([
+  "cancelled",
+  "timed-out"
+]);
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function rearmOnLostSettle(internals, workflowId, token) {
+  await rearmTeardownTimer(internals, workflowId, token, TEARDOWN_SELF_HEAL_DELAY_MS);
+}
+async function clearOrRearm(internals, workflowId, token, markerBytes) {
+  return await clearTeardownMarker(internals, workflowId, markerBytes) ? { kind: "cleared" } : { kind: "rearm", token };
+}
+async function readDriveableClaim(internals, workflowId, token, markerBytes) {
+  let decoded;
+  try {
+    decoded = decode(markerBytes);
+  } catch {
+    return clearOrRearm(internals, workflowId, token, markerBytes);
+  }
+  if (!isTeardownClaim(decoded))
+    return clearOrRearm(internals, workflowId, token, markerBytes);
+  return { kind: "claim", claim: decoded };
+}
+async function resolveTeardownDrive(internals, workflowId, token, callbacks) {
+  const markerBytes = await internals.storage.get(KEYS.teardownOwed(workflowId));
+  if (markerBytes === null)
+    return { kind: "cleared" };
+  const resolution = await readDriveableClaim(internals, workflowId, token, markerBytes);
+  if (resolution.kind !== "claim")
+    return resolution;
+  const claim = resolution.claim;
+  if (claim.token !== token)
+    return { kind: "cleared" };
+  const state = await callbacks.loadWorkflowState(workflowId);
+  if (state === null || !TERMINAL_STATUSES_OWED_TEARDOWN.has(state.status))
+    return clearOrRearm(internals, workflowId, token, markerBytes);
+  const registeredFinalizer = internals.registrations.get(state.type)?.finalizer;
+  if (registeredFinalizer === void 0)
+    return { kind: "rearm", token };
+  const finalizer = registeredFinalizer;
+  if (!runningClaimIsStale(internals, claim, finalizer))
+    return { kind: "rearm", token };
+  const finalizerStateBytes = await internals.storage.get(KEYS.finalizerState(workflowId));
+  if (finalizerStateBytes === null) {
+    await deadLetterMissingState(internals, workflowId, state.type, claim.attempts, markerBytes, callbacks);
+    return { kind: "cleared" };
+  }
+  return {
+    kind: "run",
+    drive: { state, claim, markerBytes, finalizer, finalizerInput: decode(finalizerStateBytes) }
+  };
+}
+async function deadLetterMissingState(internals, workflowId, workflowType, attempts, expectedBytes, callbacks) {
+  const lastError = "finalizer state missing \u2014 recorded resource cannot be torn down";
+  if (await deadLetterTeardown(internals, workflowId, workflowType, attempts, expectedBytes, {
+    lastError,
+    finalizerInput: void 0
+  }))
+    callbacks.dispatchEvent(new WorkflowTeardownEvent(workflowId, workflowType, "dead-lettered", attempts, lastError));
+}
+export async function runWorkflowFinalizer(internals, workflowId, timerId, callbacks) {
+  const token = parseTeardownTimerId(timerId);
+  if (token === null)
+    return;
+  try {
+    const resolution = await resolveTeardownDrive(internals, workflowId, token, callbacks);
+    if (resolution.kind === "cleared")
+      return;
+    if (resolution.kind === "rearm") {
+      await rearmTeardownTimer(internals, workflowId, resolution.token, TEARDOWN_SELF_HEAL_DELAY_MS);
+      return;
+    }
+    await driveResolvedTeardown(internals, workflowId, token, resolution.drive, callbacks);
+  } catch (error) {
+    await rearmTeardownTimer(internals, workflowId, token, TEARDOWN_SELF_HEAL_DELAY_MS);
+    callbacks.handleCleanupError("runWorkflowFinalizer", error, workflowId);
+  }
+}
+async function driveResolvedTeardown(internals, workflowId, token, drive, callbacks) {
+  const { state, claim, markerBytes, finalizer, finalizerInput } = drive, attempt = claim.attempts + 1, runningBytes = await claimTeardownMarker(internals, workflowId, markerBytes, claim.attempts, token);
+  if (runningBytes === null) {
+    await rearmTeardownTimer(internals, workflowId, token, TEARDOWN_SELF_HEAL_DELAY_MS);
+    return;
+  }
+  const result = await runFinalizerActivity(finalizer, finalizerInput, attempt, internals.abortController.signal);
+  if (result.ok) {
+    await settleTeardownSuccess(internals, workflowId, state.type, token, attempt, runningBytes, callbacks);
+    return;
+  }
+  if (result.abortedByShutdown) {
+    const fireAt = internals.options.getNow() + TEARDOWN_SELF_HEAL_DELAY_MS;
+    if (!await settleOnRunningClaim(internals, workflowId, runningBytes, [
+      {
+        type: "put",
+        key: KEYS.teardownOwed(workflowId),
+        value: encodeOwedClaim(claim.attempts, token)
+      },
+      ...teardownTimerOperations(token, workflowId, fireAt)
+    ]))
+      await rearmOnLostSettle(internals, workflowId, token);
+    return;
+  }
+  await settleTeardownFailure(internals, workflowId, state, attempt, token, runningBytes, result.error, callbacks);
+}
+async function settleTeardownSuccess(internals, workflowId, workflowType, token, attempt, runningBytes, callbacks) {
+  if (!await settleOnRunningClaim(internals, workflowId, runningBytes, [
+    { type: "delete", key: KEYS.teardownOwed(workflowId) },
+    { type: "delete", key: KEYS.finalizerState(workflowId) }
+  ])) {
+    await rearmOnLostSettle(internals, workflowId, token);
+    return;
+  }
+  callbacks.dispatchEvent(new WorkflowTeardownEvent(workflowId, workflowType, "completed", attempt));
+}
+async function settleTeardownFailure(internals, workflowId, state, attempt, token, runningBytes, error, callbacks) {
+  const message = errorMessage(error);
+  if (attempt >= MAX_TEARDOWN_ATTEMPTS) {
+    const finalizerStateBytes = await internals.storage.get(KEYS.finalizerState(workflowId));
+    if (!await deadLetterTeardown(internals, workflowId, state.type, attempt, runningBytes, {
+      lastError: message,
+      finalizerInput: finalizerStateBytes === null ? void 0 : decode(finalizerStateBytes)
+    })) {
+      await rearmOnLostSettle(internals, workflowId, token);
+      return;
+    }
+    callbacks.dispatchEvent(new WorkflowTeardownEvent(workflowId, state.type, "dead-lettered", attempt, message));
+    return;
+  }
+  const fireAt = internals.options.getNow() + teardownBackoffMs(attempt);
+  if (!await settleOnRunningClaim(internals, workflowId, runningBytes, [
+    { type: "put", key: KEYS.teardownOwed(workflowId), value: encodeOwedClaim(attempt, token) },
+    ...teardownTimerOperations(token, workflowId, fireAt)
+  ])) {
+    await rearmOnLostSettle(internals, workflowId, token);
+    return;
+  }
+  callbacks.dispatchEvent(new WorkflowTeardownEvent(workflowId, state.type, "failed", attempt, message));
+}

package/dist/core/engine/termination/suspend.d.ts

@@ -0,0 +1,70 @@
+import type { EngineInternals } from '../internals.ts';
+import { type TerminationCallbacks } from './cleanup.ts';
+/**
+ * Suspend a running workflow without terminating it: a non-terminal cousin of
+ * {@link terminateWorkflow}. The workflow's status transitions `running →
+ * suspended`, its durable checkpoint is preserved, and it becomes resumable via
+ * `engine.resume(id)` / `handle.resume()`. Suspension is client-driven
+ * preemption, so — unlike a fault — a suspended workflow is NOT auto-recovered
+ * by `engine.recoverAll()`.
+ *
+ * Contrast with cancel/timeout, which this deliberately does NOT do:
+ * - does NOT abort the workflow's `AbortController` — suspend is a pause, not a
+ *   cancellation, so user code observing `ctx.signal.aborted` or registered
+ *   abort listeners must not fire. The live inline run is *parked*
+ *   (`parkWorkflow`: evict execution state without aborting), the same primitive
+ *   the engine uses for signal-parking — but with the default eviction, not the
+ *   `retainContext` form signal-parking uses, so suspend leaves no queryable
+ *   Context behind,
+ * - does NOT run cancel handlers,
+ * - does NOT settle the result promise (`handle.result()` stays pending until a
+ *   later `resume()` drives the run to completion, or a `cancel()` terminates it),
+ * - does NOT clean up durable output artifacts or in-memory services (the
+ *   `services` value is preserved so an in-process `resume()` can reuse it),
+ * - does NOT schedule terminal cleanup.
+ *
+ * The CAS status flip and the in-memory teardown both run inside one serialized
+ * per-workflow write section with `allowedStatuses: ['running']`. If the
+ * workflow already left `running` (it completed, failed, or a concurrent cancel
+ * won the race), the flip is skipped and suspend is a no-op — and because the
+ * teardown is gated on the flip succeeding, a workflow that lost the race keeps
+ * its execution state intact.
+ *
+ * The teardown evicts every piece of in-memory execution state that could let a
+ * post-suspend operation drive the parked run: the inline context/generator (via
+ * `parkWorkflow`), the in-memory checkpoint, the parked-inline marker, and the
+ * in-flight operation waiters (signal/update/sleep/review — deleted, NOT
+ * resolved, so a signal arriving after suspend buffers durably and is replayed
+ * on resume instead of waking a dormant operation loop against the gone
+ * generator). The durable checkpoint, durable buffered signals, durable sleep
+ * timers, and `workflowServices` are all left intact for resume.
+ *
+ * A signal that races the in-lock teardown is benign: `continueWorkflow` no-ops
+ * for an evicted generator, and `persistCheckpoint` no-ops when the context and
+ * in-memory checkpoint are gone — so no step can commit past the suspend point.
+ *
+ * `'suspended'` is neither `'running'` nor `'pending'`, and both local-ownership
+ * predicates (`isInlineWorkflowLocallyOwned`, `hasLocalCheckpointOwnership`) are
+ * gated on those two statuses. So once the status flips, the workflow stops
+ * registering as locally owned — which is exactly what makes `recoverAll()` skip
+ * it AND what lets `engine.resume()` re-drive it from storage instead of taking
+ * its local-ownership early return.
+ *
+ * The execution deadline is absolute wall-clock time: suspension does NOT extend
+ * it. The pending `deadline:` timer is deleted durably IN THE SAME COMMIT BATCH
+ * as the status flip, and re-armed at the same absolute fire time on resume (or
+ * fires immediately if already past). It is a durable delete rather than a
+ * `scheduler.cancel()` call because the scheduler is durable-scan-based and
+ * resume's re-arm is likewise durable-only (`buildTimerBatchOperations`); folding
+ * the delete into the commit makes it atomic with the flip and ordered before any
+ * concurrent resume, so an immediate resume cannot have its freshly re-armed
+ * deadline deleted by a late fire-and-forget cancel.
+ *
+ * Worker execution mode is not supported: a worker run cannot be parked without
+ * sending it a cancellation. To keep the contract state-dependent (suspend on a
+ * non-running workflow is always a no-op), the mode check runs only AFTER the
+ * status load confirms the workflow is `running`; a `running` worker workflow
+ * throws {@link WorkflowSuspendNotSupportedError}, while a completed or unknown
+ * one is a no-op regardless of execution mode.
+ */
+export declare function suspendWorkflow(internals: EngineInternals, workflowId: string, callbacks: TerminationCallbacks): Promise<void>;

package/dist/core/engine/termination/suspend.js

@@ -0,0 +1,41 @@
+import { KEYS } from "../../../storage/interface.js";
+import { encode } from "../../codec.js";
+import { WorkflowSuspendedEvent } from "../../events.js";
+import { WorkflowSuspendNotSupportedError } from "../errors.js";
+import { dropQueuedInlineWorkflowStart } from "../inline-launch-queue.js";
+import { buildWorkflowVisibilityIndexTransition } from "../workflow-indexes.js";
+import { evictSuspendedWorkflowWaiters } from "./cleanup.js";
+export async function suspendWorkflow(internals, workflowId, callbacks) {
+  if (!await callbacks.runSerializedWorkflowStateWrite(workflowId, async () => {
+    const state = await callbacks.loadWorkflowState(workflowId);
+    if (!state || state.status !== "running")
+      return !1;
+    if (internals.inlineStrategy === null)
+      throw new WorkflowSuspendNotSupportedError("suspend is only supported in inline execution mode; a worker run cannot be paused without cancelling it.");
+    internals.inlineStrategy.parkWorkflow(workflowId);
+    dropQueuedInlineWorkflowStart(internals, workflowId);
+    internals.checkpoints.delete(workflowId);
+    internals.parkedInlineWorkflows.delete(workflowId);
+    evictSuspendedWorkflowWaiters(internals, workflowId, callbacks);
+    const updatedAt = internals.options.getNow(), updatedState = { ...state, status: "suspended", updatedAt };
+    await callbacks.commitWorkflowStateOperations(state, [
+      { type: "put", key: KEYS.workflow(workflowId), value: encode(updatedState) },
+      ...buildWorkflowVisibilityIndexTransition(workflowId, state, updatedState).batchOps,
+      ...buildDeadlineTimerDeleteOperations(workflowId, state.executionDeadline)
+    ]);
+    return !0;
+  }))
+    return;
+  const event = new WorkflowSuspendedEvent(workflowId);
+  callbacks.dispatchEvent(event);
+  callbacks.forwardEventToHandle(workflowId, event);
+}
+function buildDeadlineTimerDeleteOperations(workflowId, executionDeadline) {
+  if (executionDeadline === void 0)
+    return [];
+  const timerId = `deadline:${workflowId}`;
+  return [
+    { type: "delete", key: KEYS.deadline(executionDeadline, timerId) },
+    { type: "delete", key: `timer-idx:${timerId}` }
+  ];
+}

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

@@ -1,7 +1,10 @@
 /**
  * Thin barrel over the split termination modules. Keeps existing import paths
  * (`./termination.ts`) working while the implementation lives in
- * `./termination/cleanup.ts` and `./termination/complete.ts`.
+ * `./termination/cleanup.ts`, `./termination/complete.ts`, and
+ * `./termination/suspend.ts`.
  */
-export { TERMINAL_WORKFLOW_STATUSES, cleanupTerminalWorkflowDurableState, cleanupTerminalWorkflowImmediately, cleanupTerminalWorkflowMemory, cleanupTerminalWorkflowSynchronously, cleanupWaiters, cleanupWorkflowStorage, finalizeScheduledWorkflowTerminal, handleCleanupError, runDeferredTerminalCleanup, type TerminationCallbacks, } from './termination/cleanup.ts';
+export { TERMINAL_WORKFLOW_STATUSES, cleanupTerminalWorkflowDurableState, cleanupTerminalWorkflowImmediately, cleanupTerminalWorkflowMemory, cleanupTerminalWorkflowSynchronously, cleanupWaiters, cleanupWorkflowStorage, evictSuspendedWorkflowWaiters, finalizeScheduledWorkflowTerminal, handleCleanupError, runDeferredTerminalCleanup, type TerminationCallbacks, } from './termination/cleanup.ts';
 export { buildPendingTimelineOperation, buildTerminalCleanupTimerOperations, cancelWorkflow, completeWorkflow, ensureTerminalCleanupTracked, failWorkflow, finalizePendingTimelineEntry, terminateWorkflow, timeoutWorkflow, } from './termination/complete.ts';
+export { runWorkflowFinalizer, teardownStaleThresholdMs, type FinalizerDriveCallbacks, type TeardownDeadLetterRecord, } from './termination/finalizer.ts';
+export { suspendWorkflow } from './termination/suspend.ts';

package/dist/core/engine/termination.js

@@ -6,6 +6,7 @@ export {
   cleanupTerminalWorkflowSynchronously,
   cleanupWaiters,
   cleanupWorkflowStorage,
+  evictSuspendedWorkflowWaiters,
   finalizeScheduledWorkflowTerminal,
   handleCleanupError,
   runDeferredTerminalCleanup
@@ -21,3 +22,8 @@ export {
   terminateWorkflow,
   timeoutWorkflow
 } from "./termination/complete.js";
+export {
+  runWorkflowFinalizer,
+  teardownStaleThresholdMs
+} from "./termination/finalizer.js";
+export { suspendWorkflow } from "./termination/suspend.js";

package/dist/core/engine/updates.js

@@ -1,10 +1,9 @@
 import { UpdateCompletedEvent, UpdateReceivedEvent } from "../events.js";
 import { isGeneratorResult } from "../step-context.js";
-import {
-  UpdateTimeoutError,
-  UpdateValidationError
-} from "../updates.js";
+import { UpdateValidationError } from "../updates.js";
+import { notifyConditionWaiters } from "./condition-waiters.js";
 import { trackWaiterKey, untrackWaiterKey } from "./signals.js";
+import { waitForUpdateResponse } from "./waiting-update-response.js";
 export async function update(internals, workflowId, name, payload, options, callbacks) {
   const timeout = options?.timeout ?? 30000;
   await runUpdateValidator(internals, workflowId, name, payload);
@@ -27,11 +26,13 @@ async function tryInlineUpdateHandler(internals, workflowId, name, payload, call
     const result = await invokeUpdateHandler(internals, name, handler, payload);
     callbacks.dispatchEvent(new UpdateCompletedEvent(updateId, workflowId, name, result));
     callbacks.broadcast({ type: "update:completed", workflowId, updateId });
+    notifyConditionWaiters(internals, workflowId);
     return { handled: !0, value: result };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     callbacks.dispatchEvent(new UpdateCompletedEvent(updateId, workflowId, name, void 0, errorMessage));
     callbacks.broadcast({ type: "update:completed", workflowId, updateId });
+    notifyConditionWaiters(internals, workflowId);
     throw error;
   }
 }
@@ -51,27 +52,6 @@ async function tryWaitingUpdateHandler(internals, workflowId, name, payload, tim
   callbacks.broadcast({ type: "update:completed", workflowId, updateId });
   return { handled: !0, value: result };
 }
-async function waitForUpdateResponse(updateId, payload, timeout, updateWaiter) {
-  const { promise: respondPromise, resolve: resolveRespond } = Promise.withResolvers();
-  let responded = !1;
-  updateWaiter({ payload, respond: (value) => {
-    if (responded)
-      return;
-    responded = !0;
-    resolveRespond(value);
-  } });
-  let timeoutId;
-  try {
-    return await Promise.race([
-      respondPromise,
-      new Promise((_resolve, reject) => {
-        timeoutId = setTimeout(() => reject(new UpdateTimeoutError(updateId, timeout)), timeout);
-      })
-    ]);
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
 async function runCoordinatedUpdate(internals, workflowId, name, payload, timeout, callbacks) {
   const updateId = await internals.updateCoordinator.createRequest(workflowId, name, payload);
   callbacks.schedulePendingInlineUpdateDrain(workflowId);

package/dist/core/engine/validation/schedule.d.ts

@@ -8,6 +8,7 @@ export declare function isValidScheduleIdentifier(value: unknown): value is stri
 export declare function coerceScheduleId(scheduleId: string, fieldName: string): string;
 export declare function normalizeScheduleOptions(options: ScheduleOptions | undefined): Required<Pick<ScheduleOptions, 'overlap' | 'backfill'>> & {
     id?: string;
+    jitterMs?: number;
 };
 /**
  * A recurrence specification normalized into the discriminated cadence the
@@ -32,7 +33,7 @@ export declare function decodeScheduleIdentityFields(decoded: Record<string, unk
     cronExpression?: string;
     intervalMs?: number;
 }) | null;
-type ScheduleRuntimeFields = Pick<ScheduleState, 'backfill' | 'createdAt' | 'updatedAt' | 'lastFireAt' | 'nextFireAt' | 'currentWorkflowId' | 'queuedRuns'>;
+type ScheduleRuntimeFields = Pick<ScheduleState, 'backfill' | 'jitterMs' | 'createdAt' | 'updatedAt' | 'lastFireAt' | 'lastMissedFireAt' | 'nextFireAt' | 'currentWorkflowId' | 'missedFireCount' | 'queuedRuns'>;
 export declare function decodeScheduleRuntimeFields(decoded: Record<string, unknown>, scheduleId: string): ScheduleRuntimeFields | null;
 export declare function decodeScheduleState(bytes: Uint8Array): ScheduleState | null;
 export {};

package/dist/core/engine/validation/schedule.js

@@ -36,7 +36,7 @@ export function normalizeScheduleOptions(options) {
     return { overlap: "skip", backfill: !1 };
   if (typeof options !== "object" || options === null)
     throw Error("options must be an object when provided");
-  const { id, overlap, backfill } = options, normalizedOptions = {
+  const { id, overlap, backfill, jitter } = options, normalizedOptions = {
     overlap: "skip",
     backfill: !1
   };
@@ -52,8 +52,25 @@ export function normalizeScheduleOptions(options) {
       throw Error("options.backfill must be a boolean when provided");
     normalizedOptions.backfill = backfill;
   }
+  if (jitter !== void 0)
+    normalizedOptions.jitterMs = normalizeScheduleJitter(jitter, "options.jitter");
   return normalizedOptions;
 }
+function normalizeScheduleJitter(value, fieldName) {
+  if (typeof value !== "string" && typeof value !== "number")
+    throw Error(`${fieldName} must be a duration string or a number of milliseconds`);
+  let milliseconds;
+  try {
+    milliseconds = parseDuration(value);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw Error(`Invalid ${fieldName}: ${message}`, { cause: error });
+  }
+  const jitterMs = Math.ceil(milliseconds);
+  if (!Number.isSafeInteger(jitterMs) || jitterMs <= 0)
+    throw Error(`${fieldName} must resolve to a positive number of milliseconds`);
+  return jitterMs;
+}
 function normalizeIntervalEvery(every) {
   if (typeof every !== "string" && typeof every !== "number")
     throw Error('Schedule interval "every" must be a duration string or a number of milliseconds');
@@ -171,6 +188,16 @@ function decodeScheduleBackfill(decoded, scheduleId) {
   }
   return backfill;
 }
+function decodeScheduleJitterMs(decoded, scheduleId) {
+  const jitterMs = decoded.jitterMs;
+  if (jitterMs === void 0)
+    return;
+  if (typeof jitterMs !== "number" || !Number.isSafeInteger(jitterMs) || jitterMs <= 0) {
+    rejectInvalidScheduleRecord(scheduleId, "with invalid jitterMs");
+    return null;
+  }
+  return jitterMs;
+}
 function decodeScheduleTimestamps(decoded, scheduleId) {
   const { createdAt, updatedAt } = decoded;
   if (!isValidScheduleTimestamp(createdAt) || !isValidScheduleTimestamp(updatedAt))
@@ -178,10 +205,14 @@ function decodeScheduleTimestamps(decoded, scheduleId) {
   const lastFireAt = decoded.lastFireAt;
   if (lastFireAt !== void 0 && !isValidScheduleTimestamp(lastFireAt))
     return rejectInvalidScheduleRecord(scheduleId, "with invalid lastFireAt");
+  const lastMissedFireAt = decoded.lastMissedFireAt;
+  if (lastMissedFireAt !== void 0 && !isValidScheduleTimestamp(lastMissedFireAt))
+    return rejectInvalidScheduleRecord(scheduleId, "with invalid lastMissedFireAt");
   return {
     createdAt,
     updatedAt,
-    ...lastFireAt !== void 0 && { lastFireAt }
+    ...lastFireAt !== void 0 && { lastFireAt },
+    ...lastMissedFireAt !== void 0 && { lastMissedFireAt }
   };
 }
 function decodeScheduleNextFireAt(decoded, scheduleId) {
@@ -214,10 +245,23 @@ function decodeScheduleQueuedRuns(decoded, scheduleId) {
   }
   return queuedRuns;
 }
+function decodeScheduleMissedFireCount(decoded, scheduleId) {
+  const missedFireCount = decoded.missedFireCount;
+  if (missedFireCount === void 0)
+    return 0;
+  if (typeof missedFireCount !== "number" || !Number.isSafeInteger(missedFireCount) || missedFireCount < 0) {
+    rejectInvalidScheduleRecord(scheduleId, "with invalid missedFireCount");
+    return null;
+  }
+  return missedFireCount;
+}
 export function decodeScheduleRuntimeFields(decoded, scheduleId) {
   const backfill = decodeScheduleBackfill(decoded, scheduleId);
   if (backfill === null)
     return null;
+  const jitterMs = decodeScheduleJitterMs(decoded, scheduleId);
+  if (jitterMs === null)
+    return null;
   const timestamps = decodeScheduleTimestamps(decoded, scheduleId);
   if (timestamps === null)
     return null;
@@ -230,11 +274,16 @@ export function decodeScheduleRuntimeFields(decoded, scheduleId) {
   const queuedRuns = decodeScheduleQueuedRuns(decoded, scheduleId);
   if (queuedRuns === null)
     return null;
+  const missedFireCount = decodeScheduleMissedFireCount(decoded, scheduleId);
+  if (missedFireCount === null)
+    return null;
   return {
     backfill,
+    ...jitterMs !== void 0 && { jitterMs },
     ...timestamps,
     nextFireAt: nextFireAt.value,
     ...currentWorkflow.value !== void 0 && { currentWorkflowId: currentWorkflow.value },
+    missedFireCount,
     queuedRuns
   };
 }

package/dist/core/engine/validation.js

@@ -2,6 +2,7 @@ import { decode } from "../codec.js";
 import { isRecord } from "../debug-output.js";
 import { normalizeFailureCategory } from "../failure-categories.js";
 import { coerceStartWorkflowId, parseStartWorkflowDuration } from "../start-workflow-validation.js";
+import { DEFAULT_WORKFLOW_VERSION } from "../versioning.js";
 import { isWorkflowTagArray } from "../workflow-tags.js";
 const WORKFLOW_TIMELINE_STATUSES = new Set([
   "running",
@@ -10,6 +11,29 @@ const WORKFLOW_TIMELINE_STATUSES = new Set([
   "cancelled",
   "timed-out"
 ]);
+function defineCompleteWorkflowStateFieldNames(fieldNames) {
+  return fieldNames;
+}
+const WORKFLOW_STATE_FIELD_NAMES = new Set(defineCompleteWorkflowStateFieldNames([
+  "id",
+  "type",
+  "status",
+  "tags",
+  "input",
+  "result",
+  "error",
+  "errorStack",
+  "failureCategory",
+  "terminationReason",
+  "versionTuple",
+  "executionStateOwnerId",
+  "createdAt",
+  "startedAt",
+  "updatedAt",
+  "terminalCleanupToken",
+  "executionDeadline",
+  "forkedFrom"
+]));
 export function isSanitizedSearchAttributeValue(value) {
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
     return !0;
@@ -55,9 +79,10 @@ export function isValidDecodedTags(value) {
   return value === void 0 || isWorkflowTagArray(value);
 }
 export function decodeWorkflowState(bytes) {
-  const state = decode(bytes);
-  if ("tenant" in state)
-    delete state.tenant;
+  const decoded = decode(bytes), decodedRecord = isRecord(decoded) ? decoded : void 0;
+  if (decodedRecord !== void 0)
+    liftFlatVersionTuple(decodedRecord);
+  const state = decoded;
   if (!isValidDecodedTags(state.tags)) {
     console.warn(`[weft] Decoded workflow state for "${String(state.id)}" has invalid tags; dropping the malformed tag list from the decoded state.`);
     delete state.tags;
@@ -76,8 +101,34 @@ export function decodeWorkflowState(bytes) {
       console.warn(`[weft] Decoded workflow state for "${String(state.id)}" has an invalid executionStateOwnerId field; falling back to the workflow id as the execution owner. This usually indicates corruption or tampering of the storage record.`);
       delete state.executionStateOwnerId;
     }
+  return decodedRecord === void 0 ? state : stripUnknownWorkflowStateFields(state, decodedRecord);
+}
+function stripUnknownWorkflowStateFields(state, stateFields) {
+  for (const fieldName of Object.keys(stateFields))
+    if (!WORKFLOW_STATE_FIELD_NAMES.has(fieldName))
+      delete stateFields[fieldName];
   return state;
 }
+function liftFlatVersionTuple(record) {
+  const flatVersion = record.version, hasFlatVersion = typeof flatVersion === "string";
+  if (isWorkflowVersionTuple(record.versionTuple)) {
+    delete record.version;
+    delete record.agentVersion;
+    delete record.toolVersions;
+    return;
+  }
+  const { agentVersion: flatAgentVersion, toolVersions: flatToolVersions } = record, versionTuple = {
+    workflowVersion: hasFlatVersion ? flatVersion : DEFAULT_WORKFLOW_VERSION,
+    ...typeof flatAgentVersion === "string" && { agentVersion: flatAgentVersion },
+    ...Array.isArray(flatToolVersions) && flatToolVersions.every((entry) => typeof entry === "string") && {
+      toolVersions: flatToolVersions
+    }
+  };
+  record.versionTuple = versionTuple;
+  delete record.version;
+  delete record.agentVersion;
+  delete record.toolVersions;
+}
 export function normalizeRetentionDuration(value, fieldName) {
   if (value === void 0)
     return;

package/dist/core/engine/waiting-update-response.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Park until a waiting `ctx.waitForUpdate` handler responds (via the resolver it
+ * registered in `updateWaiters`) or the update times out. Resolves with the
+ * handler's response value; rejects with {@link UpdateTimeoutError} when the
+ * timeout elapses first. The `respond` callback is single-shot — a late second
+ * response is ignored.
+ */
+export declare function waitForUpdateResponse(updateId: string, payload: unknown, timeout: number, updateWaiter: (request: unknown) => void): Promise<unknown>;

package/dist/core/engine/waiting-update-response.js

@@ -0,0 +1,22 @@
+import { UpdateTimeoutError } from "../updates.js";
+export async function waitForUpdateResponse(updateId, payload, timeout, updateWaiter) {
+  const { promise: respondPromise, resolve: resolveRespond } = Promise.withResolvers();
+  let responded = !1;
+  updateWaiter({ payload, respond: (value) => {
+    if (responded)
+      return;
+    responded = !0;
+    resolveRespond(value);
+  } });
+  let timeoutId;
+  try {
+    return await Promise.race([
+      respondPromise,
+      new Promise((_resolve, reject) => {
+        timeoutId = setTimeout(() => reject(new UpdateTimeoutError(updateId, timeout)), timeout);
+      })
+    ]);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}

package/dist/core/engine/workflow-concurrency.d.ts

@@ -0,0 +1,10 @@
+import type { BatchOperation, ConditionalBatchCondition } from '../../storage/interface.ts';
+import type { WorkflowConcurrencyOptions } from '../types.ts';
+import type { EngineInternals } from './internals.ts';
+export type WorkflowConcurrencyStartOperations = {
+    stateKey: string;
+    operations: BatchOperation[];
+    conditions: ConditionalBatchCondition[];
+};
+export declare function buildWorkflowConcurrencyStartOperations(internals: EngineInternals, workflowType: string, workflowId: string, input: unknown, concurrency: WorkflowConcurrencyOptions): Promise<WorkflowConcurrencyStartOperations>;
+export declare function releaseWorkflowConcurrencySlot(internals: EngineInternals, workflowId: string): Promise<void>;