@lostgradient/weft 0.5.0 → 0.7.0

package/dist/core/engine/lifecycle/start-or-signal-resolution.js

@@ -23,12 +23,30 @@ async function awaitReservationCleared(internals, workflowId) {
     await sleep(RESERVATION_CLEAR_RETRY_DELAY_MS);
   }
 }
-export async function resolveCallerIdWinnerOrRetry(internals, winnerId, signalSpec, signalId, callbacks) {
-  const resolved = await signalOrConflictExistingWorkflow(internals, winnerId, signalSpec, signalId, callbacks);
-  if (resolved !== void 0)
-    return resolved;
+export async function resolveCallerIdWinnerOrRetry(internals, winnerId, signalSpec, signalId, callbacks, allowTerminalRestart = !1) {
+  const state = await loadWorkflowState(internals, winnerId);
+  if (state !== null) {
+    if (!isTerminalWorkflowStatus(state.status)) {
+      await callbacks.signalExistingWorkflow(winnerId, signalSpec.name, signalSpec.payload, signalId);
+      return callbacks.getHandle(winnerId);
+    }
+    if (!allowTerminalRestart)
+      throw new StartOrSignalConflictError(winnerId, state.status);
+  }
   await awaitReservationCleared(internals, winnerId);
-  return signalOrConflictExistingWorkflow(internals, winnerId, signalSpec, signalId, callbacks);
+  const stateAfterReservation = await loadWorkflowState(internals, winnerId);
+  if (stateAfterReservation === null)
+    return;
+  if (isTerminalWorkflowStatus(stateAfterReservation.status)) {
+    if (state !== null && isSameTerminalRun(state, stateAfterReservation))
+      return;
+    throw new StartOrSignalConflictError(winnerId, stateAfterReservation.status);
+  }
+  await callbacks.signalExistingWorkflow(winnerId, signalSpec.name, signalSpec.payload, signalId);
+  return callbacks.getHandle(winnerId);
+}
+function isSameTerminalRun(before, after) {
+  return before.id === after.id && before.type === after.type && before.status === after.status && before.createdAt === after.createdAt && before.updatedAt === after.updatedAt && before.terminalCleanupToken === after.terminalCleanupToken;
 }
 export async function signalOrConflictExistingWorkflow(internals, workflowId, signalSpec, signalId, callbacks) {
   const state = await loadWorkflowState(internals, workflowId);

package/dist/core/engine/lifecycle/start-or-signal.d.ts

@@ -1,4 +1,4 @@
-import type { StartOptions, StartOrSignalSignal } from '../../types.ts';
+import type { StartOptions, StartOrSignalOptions, StartOrSignalSignal } from '../../types.ts';
 import { type WorkflowHandle } from '../handles.ts';
 import type { EngineInternals } from '../internals.ts';
 import { type LifecycleCallbacks } from './shared.ts';
@@ -28,8 +28,10 @@ export declare function startWithIdempotency(internals: EngineInternals, type: s
  * - **Non-terminal** (running, pending, suspended) → deliver the signal through
  *   the standard engine signal path with the same `signalId`, so it dedups
  *   against a create-batch signal a concurrent winner may have written.
- * - **Terminal** → throw {@link StartOrSignalConflictError}: a finished run
- *   cannot be signalled and is not silently replaced.
+ * - **Terminal** → throw {@link StartOrSignalConflictError} by default. With
+ *   `options.onTerminalConflict: 'start-new'`, purge the prior terminal run
+ *   through the shared terminal-replacement path, start a fresh run, and deliver
+ *   the initial signal in the create batch.
  *
  * Convergence requires a SHARED workflow identity. Concurrent callers converge on
  * one workflow and one signal only when they share an `options.idempotencyKey`
@@ -43,4 +45,4 @@ export declare function startWithIdempotency(internals: EngineInternals, type: s
  * convergence primitive. Use `idempotencyKey` (id-free convergence) or
  * `id` + `signalId` when concurrent callers must converge.
  */
-export declare function startOrSignal(internals: EngineInternals, type: string, input: unknown, signalSpec: StartOrSignalSignal, options: StartOptions | undefined, callbacks: StartOrSignalCallbacks): Promise<StartOrSignalResult>;
+export declare function startOrSignal(internals: EngineInternals, type: string, input: unknown, signalSpec: StartOrSignalSignal, options: StartOrSignalOptions | undefined, callbacks: StartOrSignalCallbacks): Promise<StartOrSignalResult>;

package/dist/core/engine/lifecycle/start-or-signal.js

@@ -1,12 +1,11 @@
 import { KEYS, requireStorageCapability } from "../../../storage/interface.js";
 import {
   assertIdAndIdempotencyKeyExclusive,
-  assertOnTerminalConflictUnsupported,
   assertValidIdempotencyKey,
   assertValidOnTerminalConflict,
   StartWorkflowValidationError
 } from "../../start-workflow-validation.js";
-import { IdempotencyKeyPurgedError } from "../errors.js";
+import { IdempotencyKeyPurgedError, StartOrSignalConflictError } from "../errors.js";
 import { StartIdempotencyRaceLostError } from "./start-commit.js";
 import {
   createWithSignalOrFallback,
@@ -54,14 +53,20 @@ function validateStartOrSignalConvergence(signalSpec, options) {
   if (signalSpec.signalId !== void 0)
     throw new StartWorkflowValidationError("startOrSignal does not accept both signal.signalId and options.idempotencyKey: the signal id derives from the idempotency key for convergence. Provide exactly one.");
 }
+function validateStartOrSignalRestartPolicy(signalSpec, options) {
+  if (options?.onTerminalConflict !== "start-new" || signalSpec.signalId !== void 0)
+    return;
+  throw new StartWorkflowValidationError("startOrSignal options.onTerminalConflict: 'start-new' requires signal.signalId so concurrent restart-capable callers converge on one deterministic initial signal.");
+}
 export async function startOrSignal(internals, type, input, signalSpec, options, callbacks) {
   requireStorageCapability(internals.storage, "conditionalBatch", "startOrSignal");
-  assertOnTerminalConflictUnsupported(options, "startOrSignal");
+  assertValidOnTerminalConflict(options);
+  validateStartOrSignalRestartPolicy(signalSpec, options);
   const idempotencyKey = options?.idempotencyKey;
   validateStartOrSignalConvergence(signalSpec, options);
   const signalId = resolveSignalId(signalSpec, idempotencyKey), mappedId = idempotencyKey !== void 0 ? await resolveIdempotencyKeyWorkflowId(internals, idempotencyKey) : void 0, existingId = mappedId ?? options?.id;
   if (existingId !== void 0) {
-    const resolved = await signalOrConflictExistingWorkflow(internals, existingId, signalSpec, signalId, callbacks);
+    const resolved = await resolveExistingStartOrSignalTarget(internals, existingId, mappedId, signalSpec, signalId, options, callbacks);
     if (resolved !== void 0)
       return { handle: resolved, outcome: "signalled" };
     if (mappedId !== void 0)
@@ -69,3 +74,15 @@ export async function startOrSignal(internals, type, input, signalSpec, options,
   }
   return createWithSignalOrFallback(internals, type, input, signalSpec, signalId, options, callbacks);
 }
+async function resolveExistingStartOrSignalTarget(internals, existingId, mappedId, signalSpec, signalId, options, callbacks) {
+  try {
+    return await signalOrConflictExistingWorkflow(internals, existingId, signalSpec, signalId, callbacks);
+  } catch (error) {
+    if (canRestartTerminalCallerIdTarget(error, options, mappedId))
+      return;
+    throw error;
+  }
+}
+function canRestartTerminalCallerIdTarget(error, options, mappedId) {
+  return error instanceof StartOrSignalConflictError && options?.onTerminalConflict === "start-new" && mappedId === void 0;
+}

package/dist/core/engine/schedule-run.js

@@ -4,7 +4,7 @@ import { ScheduleFiredEvent } from "../events.js";
 import { unavailableServicesError } from "./lifecycle/recovered-services.js";
 import { EMPTY_STORAGE_VALUE } from "./lifecycle/shared.js";
 export async function startScheduledRun(internals, state, callbacks, occurrence) {
-  const workflowId = crypto.randomUUID(), scheduleRunOperations = state.overlap === "allow" ? [] : [{ type: "put", key: KEYS.scheduleRun(workflowId), value: encode(state.id) }], resolution = await resolveScheduledRunServices(internals, workflowId, state);
+  const workflowId = crypto.randomUUID(), scheduleRunOperations = state.overlap === "allow" ? [] : [{ type: "put", key: KEYS.scheduleRun(workflowId), value: encode(state.id) }], resolution = await resolveScheduledRunServices(internals, workflowId, state, occurrence);
   if (resolution !== null) {
     scheduleRunOperations.push({ type: "put", key: KEYS.workflowHasServices(workflowId), value: EMPTY_STORAGE_VALUE }, { type: "put", key: KEYS.terminalCleanupNeeded(workflowId), value: EMPTY_STORAGE_VALUE });
     internals.workflowsNeedingTerminalCleanup.add(workflowId);
@@ -23,12 +23,21 @@ export async function startScheduledRun(internals, state, callbacks, occurrence)
   }
   return workflowId;
 }
-async function resolveScheduledRunServices(internals, workflowId, state) {
+async function resolveScheduledRunServices(internals, workflowId, state, occurrence) {
   const resolver = internals.options.resolveWorkflowServices;
   if (internals.inlineStrategy === null || !resolver)
     return null;
   try {
-    return await resolver({ workflowId, workflowType: state.workflowType, input: state.input });
+    return await resolver({
+      workflowId,
+      workflowType: state.workflowType,
+      input: state.input,
+      launchOptions: { id: workflowId },
+      schedule: {
+        id: state.id,
+        ...occurrence !== void 0 ? { occurrence } : {}
+      }
+    });
   } catch (error) {
     return {
       status: "unavailable",

package/dist/core/engine/storage-io.js

@@ -52,7 +52,7 @@ export async function loadWorkflowResult(internals, workflowId) {
     throw Error("Workflow cancelled");
   if (state.status === "timed-out") {
     const elapsed = state.executionDeadline ? state.executionDeadline - getWorkflowExecutionStartedAt(state) : 0;
-    throw new WorkflowTimeoutError(workflowId, "execution", elapsed);
+    throw new WorkflowTimeoutError(workflowId, "execution", elapsed, state.terminationReason);
   }
   throw Error(`Workflow "${workflowId}" is still ${state.status}`);
 }

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

@@ -86,7 +86,7 @@ export async function terminateWorkflow(internals, workflowId, status, callbacks
     callbacks.swallowPromiseRejection(internals.scheduler.cancel(`deadline:${workflowId}`, workflowId));
     if (previousState.status === "pending")
       callbacks.swallowPromiseRejection(internals.scheduler.cancel(`delayed-start:${workflowId}`, workflowId));
-    const resolver = internals.resultResolvers.get(workflowId), terminalError = buildTerminalError(workflowId, status, elapsed);
+    const resolver = internals.resultResolvers.get(workflowId), terminalError = buildTerminalError(workflowId, status, elapsed, reason);
     try {
       await cleanupTerminalWorkflowSynchronously(internals, workflowId, !0, callbacks);
       const event = buildTerminalEvent(workflowId, status, elapsed, reason);
@@ -106,8 +106,8 @@ export async function terminateWorkflow(internals, workflowId, status, callbacks
     internals.terminalizingWorkflows.delete(workflowId);
   }
 }
-function buildTerminalError(workflowId, status, elapsed) {
-  return status === "timed-out" ? new WorkflowTimeoutError(workflowId, "execution", elapsed) : Error("Workflow cancelled");
+function buildTerminalError(workflowId, status, elapsed, reason) {
+  return status === "timed-out" ? new WorkflowTimeoutError(workflowId, "execution", elapsed, reason) : Error("Workflow cancelled");
 }
 function buildTerminalEvent(workflowId, status, elapsed, reason) {
   return status === "timed-out" ? new WorkflowTimedOutEvent(workflowId, "execution", elapsed, reason) : new WorkflowCancelledEvent(workflowId);

package/dist/core/scheduler/scheduler-class.js

@@ -1,5 +1,6 @@
 import { KEYS, resolvePrefixRangeEnd } from "../../storage/interface.js";
 import { decode } from "../codec.js";
+import { DEFAULT_POLL_INTERVAL_MS } from "../types/constants.js";
 import { buildTimerBatchOperations } from "./timer-batch.js";
 import {
   advanceTimerSource,
@@ -22,7 +23,7 @@ export class Scheduler {
   constructor(options) {
     this.#storage = options.storage;
     this.#onTimerFired = options.onTimerFired;
-    this.#pollIntervalMs = options.pollIntervalMs ?? 1000;
+    this.#pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     this.#getNow = options.getNow ?? Date.now;
     this.#commitTimerCleanup = options.commitTimerCleanup ?? ((operations) => this.#storage.batch(operations));
   }

package/dist/core/start-workflow-validation.d.ts

@@ -56,11 +56,10 @@ export declare function assertIdAndIdempotencyKeyExclusive(options: {
 }): void;
 /**
  * Reject `onTerminalConflict` on a start surface that does not support it
- * (`engine.startOrSignal`). The option is type-absent from those surfaces, but a
+ * (`ctx.startChild`). The option is type-absent from those surfaces, but a
  * transport or untyped JS caller could still smuggle the field into the options
- * object — this is the runtime backstop. `engine.startOrSignal`'s identity is the
- * permanent at-most-once idempotency mapping, which `'start-new'` would violate,
- * so the policy is `engine.start`-only (see follow-up issue #489).
+ * object — this is the runtime backstop. Child starts reattach by id during
+ * parent replay, so purging a terminal child mid-replay would break determinism.
  */
 export declare function assertOnTerminalConflictUnsupported(options: object | undefined, surface: string): void;
 export declare function coerceStartWorkflowTimestamp(value: unknown, fieldName: string): number;

package/dist/core/start-workflow-validation.js

@@ -50,7 +50,7 @@ export function assertIdAndIdempotencyKeyExclusive(options) {
 }
 export function assertOnTerminalConflictUnsupported(options, surface) {
   if (options !== void 0 && "onTerminalConflict" in options && options.onTerminalConflict !== void 0)
-    throw new StartWorkflowValidationError(`${surface} does not support options.onTerminalConflict; it is available on engine.start only`);
+    throw new StartWorkflowValidationError(`${surface} does not support options.onTerminalConflict`);
 }
 export function coerceStartWorkflowTimestamp(value, fieldName) {
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)

package/dist/core/timeouts.d.ts

@@ -8,6 +8,7 @@
  */
 import type { BatchOperation, Storage } from '../storage/interface';
 import type { Duration, WorkflowId } from './types';
+import type { TerminationReason } from './types/history-policy';
 import { WeftError } from './weft-error';
 export interface ExpiredDeadline {
     workflowId: string;
@@ -68,6 +69,12 @@ export declare function timeRemaining(deadline: number | undefined, now: number)
  * The `timeoutType` distinguishes `'execution'` (wall-clock cap set via
  * {@link StartOptions.executionTimeout}) from `'run'` (per-step run timeout).
  *
+ * When the run was force-terminated by the history circuit breaker
+ * (`history.maxEvents`) rather than a genuine deadline, `terminationReason` is
+ * set to {@link HISTORY_CIRCUIT_BREAKER_REASON}; for ordinary deadline timeouts
+ * it is `undefined`. This mirrors {@link WorkflowTimedOutEvent.reason} so callers
+ * can classify the two without a second `engine.get(runId)` read.
+ *
  * @example
  * ```ts
  * import { workflow, Engine, WorkflowTimeoutError } from '@lostgradient/weft';
@@ -94,5 +101,10 @@ export declare class WorkflowTimeoutError extends WeftError<'WorkflowTimeoutErro
     readonly workflowId: string;
     readonly timeoutType: 'execution' | 'run';
     readonly elapsed: number;
-    constructor(workflowId: string, timeoutType: 'execution' | 'run', elapsed: number);
+    /**
+     * Set to {@link HISTORY_CIRCUIT_BREAKER_REASON} when the run was force-terminated
+     * by the history circuit breaker; `undefined` for an ordinary deadline timeout.
+     */
+    readonly terminationReason?: TerminationReason;
+    constructor(workflowId: string, timeoutType: 'execution' | 'run', elapsed: number, terminationReason?: TerminationReason);
 }

package/dist/core/timeouts.js

@@ -29,10 +29,13 @@ export class WorkflowTimeoutError extends WeftError {
   workflowId;
   timeoutType;
   elapsed;
-  constructor(workflowId, timeoutType, elapsed) {
+  terminationReason;
+  constructor(workflowId, timeoutType, elapsed, terminationReason) {
     super("WorkflowTimeoutError", `Workflow "${workflowId}" exceeded ${timeoutType} timeout after ${elapsed}ms`);
     this.workflowId = workflowId;
     this.timeoutType = timeoutType;
     this.elapsed = elapsed;
+    if (terminationReason !== void 0)
+      this.terminationReason = terminationReason;
   }
 }

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

@@ -28,6 +28,22 @@ export declare const DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD = 65536;
  * ```
  */
 export declare const DEFAULT_MAX_NESTING_DEPTH = 10;
+/**
+ * Default durable-timer scheduler poll interval in milliseconds. The scheduler
+ * scans for expired deadlines, delayed starts, and scheduled occurrences once
+ * per interval. Override via {@link EngineOptions.schedulerPollIntervalMs} —
+ * primarily useful for tests that need a fast (real-time, not deterministic)
+ * poll cycle.
+ *
+ * @example
+ * ```ts
+ * import { Engine, DEFAULT_POLL_INTERVAL_MS } from '@lostgradient/weft';
+ *
+ * // A test can shorten the poll cycle far below the 1000ms default.
+ * const engine = new Engine({ schedulerPollIntervalMs: DEFAULT_POLL_INTERVAL_MS / 100 });
+ * void engine;
+ * ```
+ */
 export declare const DEFAULT_POLL_INTERVAL_MS = 1000;
 /**
  * Default activity visibility timeout in milliseconds (30 seconds). The engine

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

@@ -21,12 +21,9 @@ import type { WorkflowLogRecord } from './workflow-log.ts';
  * via filters. `id` and `idempotencyKey` are mutually exclusive — idempotency
  * assigns its own generated id and dedups through the key.
  *
- * This is the shared base accepted by every start-like surface
- * (`engine.start`, `engine.startOrSignal`, and the clients). `engine.start`
- * specifically accepts the wider {@link StartWorkflowOptions}, which adds
- * `onTerminalConflict`; that policy is intentionally absent here so it cannot be
- * passed to `startOrSignal` (whose at-most-once identity is the permanent
- * idempotency mapping).
+ * This is the shared base accepted by every start-like surface. `engine.start`
+ * specifically accepts the wider {@link StartWorkflowOptions}, while
+ * `engine.startOrSignal` accepts {@link StartOrSignalOptions}.
  *
  * The `idempotencyKey` mapping is durable and permanent: it survives the run
  * reaching a terminal state, so repeat calls keep returning the same handle. When
@@ -98,12 +95,12 @@ export interface StartOptions<TServices = unknown> {
  * Options accepted by `engine.start(type, input, options?)` — the shared
  * {@link StartOptions} plus the start-only `onTerminalConflict` policy.
  *
- * `onTerminalConflict` lives here, not on {@link StartOptions}, so it is
- * structurally rejected on every other start-like surface: `engine.startOrSignal`
- * (whose identity is the permanent at-most-once idempotency mapping),
- * `ctx.startChild` (which re-attaches to an existing run by id on replay), and the
- * REST/JSON-RPC transport (which keeps `weft.workflows.start` honestly
- * `destructive: false`). It is therefore an in-process `engine.start`-only policy.
+ * `onTerminalConflict` lives here, not on {@link StartOptions}, so
+ * `weft.workflows.start` stays non-restart-capable over REST/JSON-RPC and keeps
+ * its `destructive: false` operation contract. `ctx.startChild` also rejects the
+ * policy because it re-attaches to an existing run by id on replay. The
+ * signal-with-start surface accepts its own narrower
+ * {@link StartOrSignalOptions.onTerminalConflict} policy.
  */
 export interface StartWorkflowOptions<TServices = unknown> extends StartOptions<TServices> {
     /**
@@ -135,6 +132,46 @@ export interface StartWorkflowOptions<TServices = unknown> extends StartOptions<
      */
     onTerminalConflict?: 'error' | 'start-new';
 }
+/**
+ * Options accepted by `engine.startOrSignal(type, input, signal, options?)` —
+ * the shared {@link StartOptions} plus the restart-capable
+ * `onTerminalConflict` policy for terminal stable ids.
+ *
+ * `onTerminalConflict: 'start-new'` is intentionally narrower here than on
+ * `engine.start`: it requires an explicit `id`, requires `signal.signalId`, and
+ * remains mutually exclusive with `idempotencyKey`. That preserves permanent
+ * start-idempotency mappings while giving callers with a deterministic stable id
+ * and deterministic signal id a single signal-with-start API for re-sync style
+ * workflows.
+ *
+ * @example
+ * ```ts
+ * import type { StartOrSignalOptions } from '@lostgradient/weft';
+ *
+ * const options: StartOrSignalOptions = {
+ *   id: 'github:installations:42:sync',
+ *   onTerminalConflict: 'start-new',
+ * };
+ * void options;
+ * ```
+ */
+export interface StartOrSignalOptions<TServices = unknown> extends StartOptions<TServices> {
+    /**
+     * What `engine.startOrSignal()` does when the supplied `id` already belongs to
+     * a terminal run.
+     *
+     * - `'error'` (default): preserve the existing contract — a terminal target
+     *   throws {@link StartOrSignalConflictError}.
+     * - `'start-new'`: if the prior run is terminal, purge it through the same
+     *   terminal-replacement path as `engine.start(..., { onTerminalConflict:
+     *   'start-new' })`, then start a fresh run and deliver the initial signal in
+     *   the create batch. Non-terminal targets are still signalled, not replaced.
+     *
+     * Requires `options.id` and `signal.signalId`. Mutually exclusive with
+     * `options.idempotencyKey`.
+     */
+    onTerminalConflict?: 'error' | 'start-new';
+}
 /**
  * Options for {@link Engine.fork}. Controls which checkpoint step to fork
  * from; defaults to the latest persisted checkpoint when omitted.
@@ -284,6 +321,17 @@ export interface EngineOptions<TServices = unknown> {
     checkpointHistory?: number;
     checkpointSizeWarningThreshold?: number;
     maxNestingDepth?: number;
+    /**
+     * Poll interval in milliseconds for the durable-timer scheduler, which scans
+     * for expired deadlines, delayed starts, and scheduled occurrences once per
+     * interval. Defaults to {@link DEFAULT_POLL_INTERVAL_MS} (1000ms). Must be a
+     * positive safe integer when provided; it drives a live `setInterval`, so an
+     * invalid value is rejected at construction rather than coerced. Primarily
+     * useful for tests that need a fast (real-time, not deterministic) poll cycle —
+     * for example to assert {@link EngineCreateOptions.startScheduler} arms the
+     * poller without waiting a full real poll cycle.
+     */
+    schedulerPollIntervalMs?: number;
     /** Enable BroadcastChannel for cross-worker event coordination. Default: false. */
     broadcastEvents?: boolean;
     /**

package/dist/core/types/services-resolution.d.ts

@@ -25,11 +25,55 @@ export type WorkflowServicesResolution<TServices = unknown> = {
     status: 'unavailable';
     reason: string;
 };
+/**
+ * Durable launch context passed to {@link EngineOptions.resolveWorkflowServices}
+ * when it is available before the workflow body advances.
+ *
+ * `tags` reflects the workflow's current durable tag set, not necessarily the
+ * exact tag list supplied at launch, because callers can mutate tags after
+ * start.
+ *
+ * @example
+ * ```ts
+ * import { type WorkflowServicesResolverLaunchOptions } from '@lostgradient/weft';
+ *
+ * const launchOptions: WorkflowServicesResolverLaunchOptions = {
+ *   id: 'checkout-123',
+ *   tags: ['tenant:acme'],
+ * };
+ * void launchOptions;
+ * ```
+ */
+export interface WorkflowServicesResolverLaunchOptions {
+    id: string;
+    tags?: string[];
+}
+/**
+ * Schedule context passed to {@link EngineOptions.resolveWorkflowServices} for
+ * scheduled occurrences.
+ *
+ * @example
+ * ```ts
+ * import { type WorkflowServicesResolverScheduleInfo } from '@lostgradient/weft';
+ *
+ * const schedule: WorkflowServicesResolverScheduleInfo = {
+ *   id: 'nightly-reconciliation',
+ *   occurrence: Date.parse('2026-01-01T00:00:00.000Z'),
+ * };
+ * void schedule;
+ * ```
+ */
+export interface WorkflowServicesResolverScheduleInfo {
+    id: string;
+    occurrence?: number;
+}
 /**
  * Information passed to {@link EngineOptions.resolveWorkflowServices} for each
- * recovered workflow. `input` is the original durable launch input, available
- * at resume time — typically enough to rebuild the run's dependencies (tenant,
- * model, tool registry) without a side table.
+ * recovered workflow or scheduled occurrence. `input` is the original durable
+ * launch input, available at resume time — typically enough to rebuild the run's
+ * dependencies (tenant, model, tool registry) without a side table. When tags or
+ * schedule identity are part of the durable launch context, they are exposed so
+ * resolvers do not need parallel side channels for the same classification.
  *
  * @example
  * ```ts
@@ -44,4 +88,6 @@ export interface WorkflowServicesResolverInfo {
     workflowId: string;
     workflowType: string;
     input: unknown;
+    launchOptions?: WorkflowServicesResolverLaunchOptions;
+    schedule?: WorkflowServicesResolverScheduleInfo;
 }

package/dist/core/weft-error.d.ts

@@ -25,7 +25,7 @@
  * }
  * ```
  */
-export type WeftErrorCode = 'WorkflowAlreadyExistsError' | 'BulkDeleteRequiresTerminalWorkflowsError' | 'BulkOperationConfirmationError' | 'WorkflowTypeNotRegisteredForRecoveryError' | 'EngineCreateNameMismatchError' | 'EngineDisposedError' | 'WorkflowNotFoundError' | 'WorkflowNotRegisteredError' | 'WorkflowConcurrencyLimitExceededError' | 'WorkflowSuspendNotSupportedError' | 'ActivityResolutionError' | 'BranchTopologyChangedError' | 'PersistedDataIncompatibleError' | 'WorkflowTimeoutError' | 'HttpClientError' | 'WorkerProtocolIncompatibleError' | 'UpdateTimeoutError' | 'UpdateValidationError' | 'WorkflowTerminalError' | 'WorkflowBuilderError' | 'VersionMismatchError' | 'EffectReplayConflictError' | 'ReviewTimeoutError' | 'AtomicStateConflictError' | 'StandardSchemaValidationError' | 'ActivityReconciliationCapabilityError' | 'ActivityReconciliationConflictError' | 'ActivityReconciliationIndeterminateError' | 'AsyncActivityTokenNotFoundError' | 'ActivityScheduleToCloseTimeoutError' | 'ActivityPerAttemptTimeoutError' | 'PayloadSizeExceededError' | 'StartOrSignalConflictError' | 'IdempotencyKeyPurgedError';
+export type WeftErrorCode = 'WorkflowAlreadyExistsError' | 'BulkDeleteRequiresTerminalWorkflowsError' | 'BulkOperationConfirmationError' | 'WorkflowTypeNotRegisteredForRecoveryError' | 'EngineCreateNameMismatchError' | 'EngineDisposedError' | 'WorkflowNotFoundError' | 'WorkflowNotRegisteredError' | 'WorkflowConcurrencyLimitExceededError' | 'WorkflowSuspendNotSupportedError' | 'ActivityResolutionError' | 'BranchTopologyChangedError' | 'PersistedDataIncompatibleError' | 'WorkflowTimeoutError' | 'HttpClientError' | 'WorkerProtocolIncompatibleError' | 'UpdateTimeoutError' | 'UpdateValidationError' | 'WorkflowTerminalError' | 'WorkflowBuilderError' | 'VersionMismatchError' | 'EffectReplayConflictError' | 'ReviewTimeoutError' | 'AtomicStateConflictError' | 'StandardSchemaValidationError' | 'ActivityReconciliationCapabilityError' | 'ActivityReconciliationConflictError' | 'ActivityReconciliationIndeterminateError' | 'AsyncActivityTokenNotFoundError' | 'ActivityScheduleToCloseTimeoutError' | 'ActivityPerAttemptTimeoutError' | 'PayloadSizeExceededError' | 'StartOrSignalConflictError' | 'WorkflowTeardownPendingError' | 'IdempotencyKeyPurgedError';
 /**
  * Generic abstract base for all Weft library errors. The `TCode` parameter
  * makes each subclass's `code` its own literal type; the exported base surface

package/dist/core/weft-error.js

@@ -40,6 +40,7 @@ const publicWeftErrorCodeMap = {
   ActivityPerAttemptTimeoutError: !0,
   PayloadSizeExceededError: !0,
   StartOrSignalConflictError: !0,
+  WorkflowTeardownPendingError: !0,
   IdempotencyKeyPurgedError: !0
 }, PUBLIC_WEFT_ERROR_CODES = new Set(Object.keys(publicWeftErrorCodeMap));
 export function isWeftError(value) {

package/dist/index.d.ts

@@ -22,8 +22,8 @@ export { FAULT_CODE_TO_FAILURE_CATEGORY, failureCategoryForFaultCode, isFaultCod
 export type { FaultCode } from './core/fault-code.ts';
 export { ActivityReconciliationCapabilityError, ActivityReconciliationConflictError, ActivityReconciliationIndeterminateError, ActivityResolutionError, AsyncActivityTokenNotFoundError, BulkDeleteRequiresTerminalWorkflowsError, BulkOperationConfirmationError, ENGINE_LEASE_LOST_WARNING_NAME, Engine, EngineCreateNameMismatchError, EngineDisposedError, EngineLeaseAcquisitionTimeoutError, EngineLeaseCorruptedError, EngineLeaseNotHeldError, IdempotencyKeyPurgedError, PersistedDataIncompatibleError, ScheduleHandle, StartOrSignalConflictError, WorkflowAlreadyExistsError, WorkflowConcurrencyLimitExceededError, WorkflowHandle, WorkflowNotFoundError, WorkflowNotRegisteredError, WorkflowSuspendNotSupportedError, WorkflowTeardownPendingError, WorkflowTypeNotRegisteredForRecoveryError, } from './core/engine';
 export type { EngineCreateOptions, EngineStateNamespace, RecoverAllOptions } from './core/engine';
-export { DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD, DEFAULT_MAX_NESTING_DEPTH, DEFAULT_RETRY_POLICY, DEFAULT_VISIBILITY_TIMEOUT_MS, HISTORY_CIRCUIT_BREAKER_REASON, WorkflowBuilderError, query, schedule, signal, update, workflow, } from './core/types';
-export type { ActivityArgsFor, ActivityCallOptions, ActivityCallable, ActivityContext, ActivityDefinition, ActivityEntryInput, ActivityFunction, ActivityMap, ActivityMapInput, ActivityObjectInput, ActivityResultFor, ActivityVerificationContext, ActivityVerificationPhase, ActivityVerificationResult, AnyActivityDefinition, AnyWorkflowDefinition, ArchiveAdapter, BuilderState, BuiltWorkflowDefinition, BulkCancelResult, BulkDeleteResult, BulkOperationAction, BulkOperationAuditEvent, BulkOperationCommitOptions, BulkOperationDryRunOptions, BulkOperationDryRunResult, BulkOperationError, BulkOperationFilterSummary, BulkOperationOptions, BulkOperationPrincipal, BulkOperationScopeSummary, BulkRetryFailedResult, BulkSignalAllCommitOptions, BulkSignalAllDryRunOptions, BulkSignalAllOptions, BulkSignalResult, BulkTagResult, Checkpoint, CheckpointState, CheckpointSummary, CompletedReviewEntry, CoordinatedUpdateResult, DefinitionSchema, Duration, EngineOptions, FailureCategory, ForkLineage, ForkOptions, HistoryPolicy, InferActivityEntries, InferActivityEntry, InferWorkflowEntries, InferWorkflowEntry, InitialBuilderState, LaunchMetadata, ListFilter, ListOptions, MarkBuilderState, NormalizeActivities, NormalizedActivityEntry, NormalizedRetentionPolicy, PaginatedResult, PayloadSizePolicy, PendingReviewEntry, PurgeResult, QueryDefinition, QueryMap, QueryShape, RegisteredWorkflowDefinition, RetentionOverview, RetentionPolicy, RetryPolicy, ReviewListEntry, ReviewListFilter, ReviewStatus, ScheduleDefinition, ScheduleFilter, ScheduleOptions, ScheduleOverlapPolicy, ScheduleSpec, ScheduleState, ScheduleStatus, ScheduleSummary, SearchAttributeDefinition, SearchAttributeHandle, SearchAttributeSchema, SearchAttributeValue, Serializer, SignalDefinition, SignalDeliveryOptions, SignalMap, SignalPayload, StartOptions, StartOrSignalSignal, SubmitReviewOptions, TerminationReason, UpdateDefinition, UpdateMap, UpdatePayload, WorkerReplayOperationFailure, WorkerReplayOperationSignature, WorkflowAlreadyRegistered, WorkflowAtomicState, WorkflowAtomicStateOptions, WorkflowBuilder, WorkflowBuilderOptions, WorkflowConcurrencyOptions, WorkflowContext, WorkflowDefinition, WorkflowEvent, WorkflowFunction, WorkflowGenerator, WorkflowId, WorkflowLogLevel, WorkflowLogRecord, WorkflowLogger, WorkflowRegistry, WorkflowReplay, WorkflowServicesResolution, WorkflowServicesResolverInfo, WorkflowSessionState, WorkflowSnapshot, WorkflowState, WorkflowStateNamespace, WorkflowStatus, WorkflowSummary, WorkflowTimelineEntry, WorkflowTimelineStatus, WorkflowTypeRetentionPolicy, } from './core/types';
+export { DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD, DEFAULT_MAX_NESTING_DEPTH, DEFAULT_POLL_INTERVAL_MS, DEFAULT_RETRY_POLICY, DEFAULT_VISIBILITY_TIMEOUT_MS, HISTORY_CIRCUIT_BREAKER_REASON, WorkflowBuilderError, query, schedule, signal, update, workflow, } from './core/types';
+export type { ActivityArgsFor, ActivityCallOptions, ActivityCallable, ActivityContext, ActivityDefinition, ActivityEntryInput, ActivityFunction, ActivityMap, ActivityMapInput, ActivityObjectInput, ActivityResultFor, ActivityVerificationContext, ActivityVerificationPhase, ActivityVerificationResult, AnyActivityDefinition, AnyWorkflowDefinition, ArchiveAdapter, BuilderState, BuiltWorkflowDefinition, BulkCancelResult, BulkDeleteResult, BulkOperationAction, BulkOperationAuditEvent, BulkOperationCommitOptions, BulkOperationDryRunOptions, BulkOperationDryRunResult, BulkOperationError, BulkOperationFilterSummary, BulkOperationOptions, BulkOperationPrincipal, BulkOperationScopeSummary, BulkRetryFailedResult, BulkSignalAllCommitOptions, BulkSignalAllDryRunOptions, BulkSignalAllOptions, BulkSignalResult, BulkTagResult, Checkpoint, CheckpointState, CheckpointSummary, CompletedReviewEntry, CoordinatedUpdateResult, DefinitionSchema, Duration, EngineOptions, FailureCategory, ForkLineage, ForkOptions, HistoryPolicy, InferActivityEntries, InferActivityEntry, InferWorkflowEntries, InferWorkflowEntry, InitialBuilderState, LaunchMetadata, ListFilter, ListOptions, MarkBuilderState, NormalizeActivities, NormalizedActivityEntry, NormalizedRetentionPolicy, PaginatedResult, PayloadSizePolicy, PendingReviewEntry, PurgeResult, QueryDefinition, QueryMap, QueryShape, RegisteredWorkflowDefinition, RetentionOverview, RetentionPolicy, RetryPolicy, ReviewListEntry, ReviewListFilter, ReviewStatus, ScheduleDefinition, ScheduleFilter, ScheduleOptions, ScheduleOverlapPolicy, ScheduleSpec, ScheduleState, ScheduleStatus, ScheduleSummary, SearchAttributeDefinition, SearchAttributeHandle, SearchAttributeSchema, SearchAttributeValue, Serializer, SignalDefinition, SignalDeliveryOptions, SignalMap, SignalPayload, StartOptions, StartOrSignalOptions, StartOrSignalSignal, SubmitReviewOptions, TerminationReason, UpdateDefinition, UpdateMap, UpdatePayload, WorkerReplayOperationFailure, WorkerReplayOperationSignature, WorkflowAlreadyRegistered, WorkflowAtomicState, WorkflowAtomicStateOptions, WorkflowBuilder, WorkflowBuilderOptions, WorkflowConcurrencyOptions, WorkflowContext, WorkflowDefinition, WorkflowEvent, WorkflowFunction, WorkflowGenerator, WorkflowId, WorkflowLogLevel, WorkflowLogRecord, WorkflowLogger, WorkflowRegistry, WorkflowReplay, WorkflowServicesResolution, WorkflowServicesResolverInfo, WorkflowServicesResolverLaunchOptions, WorkflowServicesResolverScheduleInfo, WorkflowSessionState, WorkflowSnapshot, WorkflowState, WorkflowStateNamespace, WorkflowStatus, WorkflowSummary, WorkflowTimelineEntry, WorkflowTimelineStatus, WorkflowTypeRetentionPolicy, } from './core/types';
 export { AlertManager } from './alerting/index';
 export type { AlertAction, AlertMetric, AlertRule, AlertState, AlertStatus, AlertingOptions, WebhookTarget, } from './alerting/types';
 export { ActivityAsyncPendingEvent, ActivityCompletedEvent, ActivityFailedEvent, ActivityStartedEvent, AlertFiredEvent, AlertResolvedEvent, AttributesChangedEvent, CheckpointSizeWarningEvent, ConstraintViolatedEvent, DevelopmentWarningEvent, ScheduleFiredEvent, ScheduleMissedFireEvent, SignalDeliveredEvent, SignalReceivedEvent, StorageSizeReportedEvent, TaskResultDeadLetteredEvent, UpdateCompletedEvent, UpdateReceivedEvent, WorkflowCancelledEvent, WorkflowCompletedEvent, WorkflowDefinitionRegisteredEvent, WorkflowFailedEvent, WorkflowRecoverySkippedEvent, WorkflowResumedEvent, WorkflowStartedEvent, WorkflowSuspendedEvent, WorkflowTeardownEvent, WorkflowTimedOutEvent, } from './core/events';
@@ -107,7 +107,7 @@ export { buildQualifiedActivityTable } from './worker/workflow-activity-binding'
 export type { RemoteWorkerActivityFunction, RemoteWorkerActivityImplementation, RemoteWorkerWorkflowDefinition, } from './worker/workflow-activity-binding';
 export type { WorkflowEventTail } from './client/event-tail';
 export { HttpClient, HttpClientError } from './client/index';
-export type { HttpClientOptions } from './client/index';
+export type { HttpClientOptions, WorkflowEventStreamOptions, WorkflowEventTransport, } from './client/index';
 export type { ClientHandle, ClientStartOptions, StartOrSignalOutcome, UpdateResult, WeftClient, WeftClientActivity, } from './client/interface';
 export { LocalClient } from './client/local';
 export type { KnownWorkflowName, UnknownNameWhenRegistryEmpty, } from './client/workflow-name-typing';

package/dist/index.js

@@ -42,6 +42,7 @@ export {
 export {
   DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD,
   DEFAULT_MAX_NESTING_DEPTH,
+  DEFAULT_POLL_INTERVAL_MS,
   DEFAULT_RETRY_POLICY,
   DEFAULT_VISIBILITY_TIMEOUT_MS,
   HISTORY_CIRCUIT_BREAKER_REASON,

package/dist/json-schema.js

@@ -1,4 +1,4 @@
 // @bun
-var b=Object.defineProperty;var w=(j)=>j;function F(j,q){this[j]=w.bind(null,q)}var I=(j,q)=>{for(var z in q)b(j,z,{get:q[z],enumerable:!0,configurable:!0,set:F.bind(q,z)})};var Z=(j,q)=>()=>(j&&(q=j(j=0)),q);var N=(j,q,z)=>{if(q!=null){if(typeof q!=="object"&&typeof q!=="function")throw TypeError('Object expected to be assigned to "using" declaration');let A;if(z)A=q[Symbol.asyncDispose];if(A===void 0)A=q[Symbol.dispose];if(typeof A!=="function")throw TypeError("Object not disposable");j.push([z,A,q])}else if(z)j.push([z]);return q},V=(j,q,z)=>{let A=(G)=>q=z?new SuppressedError(G,q,"An error was suppressed during disposal"):(z=!0,G),H=(G)=>{while(G=j.pop())try{var U=G[1]&&G[1].call(G[2]);if(G[0])return Promise.resolve(U).then(H,(Q)=>(A(Q),H()))}catch(Q){A(Q)}if(z)throw q};return H()};function P(j){return typeof j==="string"&&M.has(j)}var X,J,M;var $=Z(()=>{X=class X extends Error{code;constructor(j,q,z){super(q,z);this.code=j,this.name=j}};J={WorkflowAlreadyExistsError:!0,BulkDeleteRequiresTerminalWorkflowsError:!0,BulkOperationConfirmationError:!0,WorkflowTypeNotRegisteredForRecoveryError:!0,EngineCreateNameMismatchError:!0,EngineDisposedError:!0,WorkflowNotFoundError:!0,WorkflowNotRegisteredError:!0,WorkflowConcurrencyLimitExceededError:!0,WorkflowSuspendNotSupportedError:!0,ActivityResolutionError:!0,BranchTopologyChangedError:!0,PersistedDataIncompatibleError:!0,WorkflowTimeoutError:!0,HttpClientError:!0,WorkerProtocolIncompatibleError:!0,UpdateTimeoutError:!0,UpdateValidationError:!0,WorkflowTerminalError:!0,WorkflowBuilderError:!0,VersionMismatchError:!0,EffectReplayConflictError:!0,ReviewTimeoutError:!0,AtomicStateConflictError:!0,StandardSchemaValidationError:!0,ActivityReconciliationCapabilityError:!0,ActivityReconciliationConflictError:!0,ActivityReconciliationIndeterminateError:!0,AsyncActivityTokenNotFoundError:!0,ActivityScheduleToCloseTimeoutError:!0,ActivityPerAttemptTimeoutError:!0,PayloadSizeExceededError:!0,StartOrSignalConflictError:!0,IdempotencyKeyPurgedError:!0},M=new Set(Object.keys(J))});async function B(j,q,z){let A=j["~standard"];if(!O(A))throw TypeError(`Schema for ${z.fieldName} does not provide runtime validation. Attach a Standard Schema validator (Zod, Valibot, or another vendor) or supply a runtime-validating schema at this boundary.`);let H=await A.validate(q);if(H.issues===void 0)return H.value;throw new K({fieldName:z.fieldName,operation:z.operation,issues:H.issues.map(T)})}function Y(j){return j.map((q)=>q.path===""?q.message:`${q.path}: ${q.message}`).join(`
+var b=Object.defineProperty;var w=(j)=>j;function F(j,q){this[j]=w.bind(null,q)}var I=(j,q)=>{for(var z in q)b(j,z,{get:q[z],enumerable:!0,configurable:!0,set:F.bind(q,z)})};var Z=(j,q)=>()=>(j&&(q=j(j=0)),q);var N=(j,q,z)=>{if(q!=null){if(typeof q!=="object"&&typeof q!=="function")throw TypeError('Object expected to be assigned to "using" declaration');let A;if(z)A=q[Symbol.asyncDispose];if(A===void 0)A=q[Symbol.dispose];if(typeof A!=="function")throw TypeError("Object not disposable");j.push([z,A,q])}else if(z)j.push([z]);return q},V=(j,q,z)=>{let A=(G)=>q=z?new SuppressedError(G,q,"An error was suppressed during disposal"):(z=!0,G),H=(G)=>{while(G=j.pop())try{var U=G[1]&&G[1].call(G[2]);if(G[0])return Promise.resolve(U).then(H,(Q)=>(A(Q),H()))}catch(Q){A(Q)}if(z)throw q};return H()};function P(j){return typeof j==="string"&&M.has(j)}var X,J,M;var $=Z(()=>{X=class X extends Error{code;constructor(j,q,z){super(q,z);this.code=j,this.name=j}};J={WorkflowAlreadyExistsError:!0,BulkDeleteRequiresTerminalWorkflowsError:!0,BulkOperationConfirmationError:!0,WorkflowTypeNotRegisteredForRecoveryError:!0,EngineCreateNameMismatchError:!0,EngineDisposedError:!0,WorkflowNotFoundError:!0,WorkflowNotRegisteredError:!0,WorkflowConcurrencyLimitExceededError:!0,WorkflowSuspendNotSupportedError:!0,ActivityResolutionError:!0,BranchTopologyChangedError:!0,PersistedDataIncompatibleError:!0,WorkflowTimeoutError:!0,HttpClientError:!0,WorkerProtocolIncompatibleError:!0,UpdateTimeoutError:!0,UpdateValidationError:!0,WorkflowTerminalError:!0,WorkflowBuilderError:!0,VersionMismatchError:!0,EffectReplayConflictError:!0,ReviewTimeoutError:!0,AtomicStateConflictError:!0,StandardSchemaValidationError:!0,ActivityReconciliationCapabilityError:!0,ActivityReconciliationConflictError:!0,ActivityReconciliationIndeterminateError:!0,AsyncActivityTokenNotFoundError:!0,ActivityScheduleToCloseTimeoutError:!0,ActivityPerAttemptTimeoutError:!0,PayloadSizeExceededError:!0,StartOrSignalConflictError:!0,WorkflowTeardownPendingError:!0,IdempotencyKeyPurgedError:!0},M=new Set(Object.keys(J))});async function B(j,q,z){let A=j["~standard"];if(!O(A))throw TypeError(`Schema for ${z.fieldName} does not provide runtime validation. Attach a Standard Schema validator (Zod, Valibot, or another vendor) or supply a runtime-validating schema at this boundary.`);let H=await A.validate(q);if(H.issues===void 0)return H.value;throw new K({fieldName:z.fieldName,operation:z.operation,issues:H.issues.map(T)})}function Y(j){return j.map((q)=>q.path===""?q.message:`${q.path}: ${q.message}`).join(`
 `)}function O(j){return typeof j.validate==="function"}function T(j){return{message:j.message,path:y(j.path)}}function y(j){if(j===void 0||j.length===0)return"";let q="";for(let z of j)q+="/",q+=L(z);return q}function L(j){let q=R(j)?j.key:j;return _(String(q))}function R(j){return j!==null&&typeof j==="object"&&"key"in j}function _(j){return j.replace(/~/g,"~0").replace(/\//g,"~1")}function C(j,q,z){return`Validation failed for ${q===void 0?j:`${q} ${j}`}:
 ${Y(z)}`}var K;var D=Z(()=>{$();K=class K extends X{fieldName;operation;issues;constructor(j){super("StandardSchemaValidationError",C(j.fieldName,j.operation,j.issues));this.fieldName=j.fieldName,this.operation=j.operation,this.issues=j.issues}}});D();var g=Y,S=K,h=B;export{h as validateStandardSchema,g as formatStandardSchemaIssues,S as StandardSchemaValidationError};