@lostgradient/weft 0.7.0 → 0.9.0

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

@@ -1,6 +1,6 @@
 import { parseDuration } from "../../scheduler.js";
 import { withPerAttemptTimeout } from "../activity-per-attempt-timeout.js";
-export async function runFinalizerActivity(finalizer, input, attempt, shutdownSignal) {
+export async function runFinalizerActivity(finalizer, input, attempt, shutdownSignal, workflowExecutionToken) {
   const perAttemptTimeoutMs = finalizer.timeout === void 0 ? void 0 : parseDuration(finalizer.timeout), attemptController = new AbortController, relayShutdownAbort = () => attemptController.abort(shutdownSignal.reason);
   if (shutdownSignal.aborted)
     attemptController.abort(shutdownSignal.reason);
@@ -8,6 +8,10 @@ export async function runFinalizerActivity(finalizer, input, attempt, shutdownSi
     shutdownSignal.addEventListener("abort", relayShutdownAbort, { once: !0 });
   const activityContext = {
     signal: attemptController.signal,
+    ...workflowExecutionToken !== void 0 && {
+      workflowExecutionToken,
+      activityAttemptToken: `${workflowExecutionToken}:finalizer:${String(attempt)}`
+    },
     heartbeat: () => {},
     completeAsync: () => {
       throw Error(`Finalizer "${finalizer.name}" called ctx.completeAsync(), which is not supported in a workflow finalizer: the finalizer runs after the workflow is already terminal, so there is no durable step to complete out of band. Run the teardown synchronously instead.`);

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

@@ -103,7 +103,7 @@ async function driveResolvedTeardown(internals, workflowId, token, drive, callba
     await rearmTeardownTimer(internals, workflowId, token, TEARDOWN_SELF_HEAL_DELAY_MS);
     return;
   }
-  const result = await runFinalizerActivity(finalizer, finalizerInput, attempt, internals.abortController.signal);
+  const result = await runFinalizerActivity(finalizer, finalizerInput, attempt, internals.abortController.signal, state.workflowExecutionToken);
   if (result.ok) {
     await settleTeardownSuccess(internals, workflowId, state.type, token, attempt, runningBytes, callbacks);
     return;

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

@@ -0,0 +1,9 @@
+import type { ScheduleOptions, ScheduleOverlapPolicy } from '../../types.ts';
+export declare const SCHEDULE_OVERLAP_POLICIES: Set<ScheduleOverlapPolicy>;
+type NormalizedScheduleOptions = Required<Pick<ScheduleOptions, 'overlap' | 'backfill'>> & {
+    id?: string;
+    description?: string;
+    jitterMs?: number;
+};
+export declare function normalizeScheduleOptions(options: ScheduleOptions | undefined): NormalizedScheduleOptions;
+export {};

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

@@ -0,0 +1,59 @@
+import { parseDuration } from "../../scheduler.js";
+import { coerceStartWorkflowId } from "../../start-workflow-validation.js";
+export const SCHEDULE_OVERLAP_POLICIES = new Set([
+  "skip",
+  "queue",
+  "cancel-running",
+  "allow"
+]);
+export function normalizeScheduleOptions(options) {
+  if (options === void 0)
+    return { overlap: "skip", backfill: !1 };
+  if (typeof options !== "object" || options === null)
+    throw Error("options must be an object when provided");
+  return {
+    overlap: normalizeScheduleOverlap(options.overlap),
+    backfill: normalizeScheduleBackfill(options.backfill),
+    ...options.id !== void 0 && { id: coerceStartWorkflowId(options.id, "options.id") },
+    ...options.description !== void 0 && {
+      description: normalizeScheduleDescription(options.description)
+    },
+    ...options.jitter !== void 0 && {
+      jitterMs: normalizeScheduleJitter(options.jitter, "options.jitter")
+    }
+  };
+}
+function normalizeScheduleDescription(description) {
+  if (typeof description !== "string")
+    throw Error("options.description must be a string when provided");
+  return description;
+}
+function normalizeScheduleOverlap(overlap) {
+  if (overlap === void 0)
+    return "skip";
+  if (!SCHEDULE_OVERLAP_POLICIES.has(overlap))
+    throw Error(`options.overlap must be one of ${[...SCHEDULE_OVERLAP_POLICIES].join(", ")}`);
+  return overlap;
+}
+function normalizeScheduleBackfill(backfill) {
+  if (backfill === void 0)
+    return !1;
+  if (typeof backfill !== "boolean")
+    throw Error("options.backfill must be a boolean when provided");
+  return backfill;
+}
+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;
+}

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

@@ -1,15 +1,11 @@
-import type { ScheduleFilter, ScheduleOptions, ScheduleOverlapPolicy, ScheduleSpec, ScheduleState, ScheduleStatus } from '../../types.ts';
+import type { ScheduleFilter, ScheduleOverlapPolicy, ScheduleSpec, ScheduleState, ScheduleStatus } from '../../types.ts';
+export { normalizeScheduleOptions, SCHEDULE_OVERLAP_POLICIES } from './schedule-options.ts';
 export declare const SCHEDULE_STATUSES: Set<ScheduleStatus>;
-export declare const SCHEDULE_OVERLAP_POLICIES: Set<ScheduleOverlapPolicy>;
 export declare function isValidScheduleTimestamp(value: unknown): value is number;
 export declare function isValidScheduleStatus(value: unknown): value is ScheduleStatus;
 export declare function isValidScheduleOverlapPolicy(value: unknown): value is ScheduleOverlapPolicy;
 export declare function isValidScheduleIdentifier(value: unknown): value is string;
 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
  * engine persists. Interval periods are resolved to whole milliseconds.
@@ -33,7 +29,6 @@ export declare function decodeScheduleIdentityFields(decoded: Record<string, unk
     cronExpression?: string;
     intervalMs?: number;
 }) | null;
-type ScheduleRuntimeFields = Pick<ScheduleState, 'backfill' | 'jitterMs' | 'createdAt' | 'updatedAt' | 'lastFireAt' | 'lastMissedFireAt' | 'nextFireAt' | 'currentWorkflowId' | 'missedFireCount' | 'queuedRuns'>;
+type ScheduleRuntimeFields = Pick<ScheduleState, 'description' | '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

@@ -3,12 +3,9 @@ import { isRecord } from "../../debug-output.js";
 import { parseCronExpression } from "../../schedule.js";
 import { parseDuration } from "../../scheduler.js";
 import { coerceStartWorkflowId } from "../../start-workflow-validation.js";
-export const SCHEDULE_STATUSES = new Set(["active", "paused", "cancelled"]), SCHEDULE_OVERLAP_POLICIES = new Set([
-  "skip",
-  "queue",
-  "cancel-running",
-  "allow"
-]);
+import { SCHEDULE_OVERLAP_POLICIES } from "./schedule-options.js";
+export { normalizeScheduleOptions, SCHEDULE_OVERLAP_POLICIES } from "./schedule-options.js";
+export const SCHEDULE_STATUSES = new Set(["active", "paused", "cancelled"]);
 export function isValidScheduleTimestamp(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
@@ -31,46 +28,6 @@ export function isValidScheduleIdentifier(value) {
 export function coerceScheduleId(scheduleId, fieldName) {
   return coerceStartWorkflowId(scheduleId, fieldName);
 }
-export function normalizeScheduleOptions(options) {
-  if (options === void 0)
-    return { overlap: "skip", backfill: !1 };
-  if (typeof options !== "object" || options === null)
-    throw Error("options must be an object when provided");
-  const { id, overlap, backfill, jitter } = options, normalizedOptions = {
-    overlap: "skip",
-    backfill: !1
-  };
-  if (id !== void 0)
-    normalizedOptions.id = coerceScheduleId(id, "options.id");
-  if (overlap !== void 0) {
-    if (!SCHEDULE_OVERLAP_POLICIES.has(overlap))
-      throw Error(`options.overlap must be one of ${[...SCHEDULE_OVERLAP_POLICIES].join(", ")}`);
-    normalizedOptions.overlap = overlap;
-  }
-  if (backfill !== void 0) {
-    if (typeof backfill !== "boolean")
-      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');
@@ -188,6 +145,16 @@ function decodeScheduleBackfill(decoded, scheduleId) {
   }
   return backfill;
 }
+function decodeScheduleDescription(decoded, scheduleId) {
+  const description = decoded.description;
+  if (description === void 0)
+    return;
+  if (typeof description !== "string") {
+    rejectInvalidScheduleRecord(scheduleId, "with invalid description");
+    return null;
+  }
+  return description;
+}
 function decodeScheduleJitterMs(decoded, scheduleId) {
   const jitterMs = decoded.jitterMs;
   if (jitterMs === void 0)
@@ -255,13 +222,35 @@ function decodeScheduleMissedFireCount(decoded, scheduleId) {
   }
   return missedFireCount;
 }
-export function decodeScheduleRuntimeFields(decoded, scheduleId) {
+function decodeScheduleQueueFields(decoded, scheduleId) {
+  const queuedRuns = decodeScheduleQueuedRuns(decoded, scheduleId);
+  if (queuedRuns === null)
+    return null;
+  const missedFireCount = decodeScheduleMissedFireCount(decoded, scheduleId);
+  if (missedFireCount === null)
+    return null;
+  return { missedFireCount, queuedRuns };
+}
+function decodeScheduleOptionFields(decoded, scheduleId) {
+  const description = decodeScheduleDescription(decoded, scheduleId);
+  if (description === null)
+    return null;
   const backfill = decodeScheduleBackfill(decoded, scheduleId);
   if (backfill === null)
     return null;
   const jitterMs = decodeScheduleJitterMs(decoded, scheduleId);
   if (jitterMs === null)
     return null;
+  return {
+    ...description !== void 0 && { description },
+    backfill,
+    ...jitterMs !== void 0 && { jitterMs }
+  };
+}
+export function decodeScheduleRuntimeFields(decoded, scheduleId) {
+  const optionFields = decodeScheduleOptionFields(decoded, scheduleId);
+  if (optionFields === null)
+    return null;
   const timestamps = decodeScheduleTimestamps(decoded, scheduleId);
   if (timestamps === null)
     return null;
@@ -271,20 +260,15 @@ export function decodeScheduleRuntimeFields(decoded, scheduleId) {
   const currentWorkflow = decodeScheduleCurrentWorkflowId(decoded, scheduleId);
   if (!currentWorkflow.ok)
     return null;
-  const queuedRuns = decodeScheduleQueuedRuns(decoded, scheduleId);
-  if (queuedRuns === null)
-    return null;
-  const missedFireCount = decodeScheduleMissedFireCount(decoded, scheduleId);
-  if (missedFireCount === null)
+  const queueFields = decodeScheduleQueueFields(decoded, scheduleId);
+  if (queueFields === null)
     return null;
   return {
-    backfill,
-    ...jitterMs !== void 0 && { jitterMs },
+    ...optionFields,
     ...timestamps,
     nextFireAt: nextFireAt.value,
     ...currentWorkflow.value !== void 0 && { currentWorkflowId: currentWorkflow.value },
-    missedFireCount,
-    queuedRuns
+    ...queueFields
   };
 }
 export function decodeScheduleState(bytes) {

package/dist/core/engine/validation.js

@@ -26,6 +26,7 @@ const WORKFLOW_STATE_FIELD_NAMES = new Set(defineCompleteWorkflowStateFieldNames
   "failureCategory",
   "terminationReason",
   "versionTuple",
+  "workflowExecutionToken",
   "executionStateOwnerId",
   "createdAt",
   "startedAt",

package/dist/core/execution-strategy.d.ts

@@ -76,6 +76,7 @@ export interface ExecutionStrategy extends Disposable, AsyncDisposable {
      */
     startWorkflow(parameters: {
         workflowId: string;
+        workflowExecutionToken?: string;
         workflowType: string;
         input: unknown;
         checkpoint: ArrayBuffer | Uint8Array;

package/dist/core/inline-execution-strategy.context-options.d.ts

@@ -45,6 +45,7 @@ export type InlineWorkflowRegistration = NonNullable<ReturnType<InlineExecutionD
 /** Parameters for starting a workflow run on the inline strategy. */
 export type InlineStartWorkflowParameters = {
     workflowId: string;
+    workflowExecutionToken?: string;
     workflowType: string;
     input: unknown;
     checkpoint: ArrayBuffer | Uint8Array;

package/dist/core/inline-execution-strategy.context-options.js

@@ -1,6 +1,9 @@
 export function createInlineContextOptions(dependencies, registration, parameters, workflowAbort) {
   return {
     workflowId: parameters.workflowId,
+    ...parameters.workflowExecutionToken !== void 0 && {
+      workflowExecutionToken: parameters.workflowExecutionToken
+    },
     workflowType: parameters.workflowType,
     startedAt: parameters.startedAt ?? dependencies.getNow(),
     abortController: workflowAbort,

package/dist/core/json.js

@@ -33,7 +33,7 @@ function isJSONPrimitive(value) {
   if (value === null)
     return !0;
   if (typeof value === "number")
-    return Number.isFinite(value);
+    return Number.isFinite(value) && !Object.is(value, -0);
   return typeof value === "string" || typeof value === "boolean";
 }
 function isUnsupportedJSONType(value) {

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

@@ -47,6 +47,17 @@ export type ActivityFunction<TInput = unknown, TOutput = unknown> = (input: TInp
  */
 export interface ActivityContext {
     signal: AbortSignal;
+    /**
+     * Durable token for the workflow run that launched this activity. It changes
+     * when a stable workflow id is replaced with `onTerminalConflict: 'start-new'`
+     * and stays stable for recovery of the same run.
+     */
+    workflowExecutionToken?: string;
+    /**
+     * Token for this specific activity dispatch attempt. It changes on retry and
+     * can be copied into external writes to reject stale late completions.
+     */
+    activityAttemptToken?: string;
     heartbeat(details?: unknown): void;
     /**
      * The heartbeat payload recorded by the PREVIOUS attempt of this activity, or

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

@@ -198,6 +198,7 @@ export type WorkerInboundMessage = {
     turnId?: number;
     maxProtocolMessageBytes?: number;
     workflowId: WorkflowId;
+    workflowExecutionToken?: string;
     workflowType: string;
     checkpoint: ArrayBuffer;
     input: unknown;

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

@@ -53,6 +53,7 @@ export type ScheduleSpec = {
  * schedule identifier; `overlap` controls what happens when a tick fires while a
  * previous run is still active; `backfill` controls missed ticks after downtime;
  * `jitter` deterministically spreads each occurrence's effective dispatch time.
+ * `description` stores a human-readable operator label with the schedule.
  *
  * @example
  * ```ts
@@ -65,6 +66,7 @@ export type ScheduleSpec = {
  *   overlap: 'skip',
  *   backfill: false,
  *   jitter: '30s',
+ *   description: 'Generate the daily report',
  * };
  * const handle = await engine.schedule('report', null, '0 9 * * *', options);
  * void handle;
@@ -72,6 +74,8 @@ export type ScheduleSpec = {
  */
 export interface ScheduleOptions {
     id?: string;
+    /** Human-readable operator description stored with this schedule. */
+    description?: string;
     overlap?: ScheduleOverlapPolicy;
     /**
      * When `false` (the default), a tick that is more than one second late is
@@ -118,6 +122,8 @@ export type ScheduleDefinition<TInput = unknown> = ScheduleSpec & {
     workflow: string | WorkflowDefinition<TInput>;
     input: TInput;
     id?: string;
+    /** Human-readable operator description stored with this schedule. */
+    description?: string;
     overlapPolicy?: ScheduleOverlapPolicy;
     backfill?: boolean;
     jitter?: Duration;
@@ -142,6 +148,8 @@ export interface ScheduleState {
     id: string;
     workflowType: string;
     input: unknown;
+    /** Human-readable operator description stored with this schedule. */
+    description?: string;
     /**
      * Cron expression driving the cadence for cron-based schedules. Present when
      * `intervalMs` is absent; the two are mutually exclusive.
@@ -179,6 +187,8 @@ export interface ScheduleState {
 export interface ScheduleSummary {
     id: string;
     workflowType: string;
+    /** Human-readable operator description stored with this schedule. */
+    description?: string;
     /** Cron expression for cron-based schedules; absent for interval schedules. */
     cronExpression?: string;
     /** Interval period in milliseconds for interval-based schedules; absent for cron schedules. */

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

@@ -53,6 +53,12 @@ export interface WorkflowState {
      * detect version drift.
      */
     versionTuple: WorkflowVersionTuple;
+    /**
+     * Durable token identifying this concrete workflow run. It changes when a
+     * stable workflow id is reused with `onTerminalConflict: 'start-new'`, and
+     * stays stable for the same run across recovery.
+     */
+    workflowExecutionToken?: string;
     /**
      * Owner identifier for execution-scoped durable state. Top-level workflows
      * own their own execution state; durable child workflows inherit the

package/dist/core/types/workflow-context.d.ts

@@ -54,6 +54,13 @@ export type RunAllResult<TBranches extends Record<string, WorkflowRunAllBranch>>
  */
 export interface WorkflowContext<TActivities extends ActivityMap = {}, TSignals extends SignalMap = {}, TUpdates extends UpdateMap = {}, TQueries extends QueryMap = {}, TSearchAttributes extends SearchAttributeSchema = {}, TServices = unknown> {
     readonly workflowId: WorkflowId;
+    /**
+     * Durable token for this concrete run. A stable workflow id reused with
+     * `onTerminalConflict: 'start-new'` receives a new token, while recovery of the
+     * same run keeps the token. Store this with external side effects so late
+     * activity writes or finalizer cleanup can prove they still belong to this run.
+     */
+    readonly workflowExecutionToken: string | undefined;
     /**
      * The registered workflow type name for this run (the `name` field from
      * `workflow({ name: '...' })`). Useful for logging and self-inspection
@@ -233,6 +240,12 @@ export interface WorkflowContext<TActivities extends ActivityMap = {}, TSignals
      * Handlers run in registration order; async handlers are awaited; failures
      * are swallowed — the workflow still finalizes as cancelled.
      *
+     * For inline workflows, `engine.cancel(id)` aborts {@link WorkflowContext.signal}
+     * promptly before in-memory execution state is evicted. A handler registered
+     * on the live context then runs after the cancelled state commits and before
+     * `cancel()` settles. Work that ignores the abort signal is still cooperative
+     * JavaScript and cannot be force-interrupted.
+     *
      * **Best-effort only**: handlers run outside the durable effect log and are
      * not retried. Side effects in handlers are not replay-safe, and registered
      * handlers are not restored after an engine restart. A hard cancel or an

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' | 'WorkflowTeardownPendingError' | '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' | 'DurableActivityScopeError' | 'DurableActivityUnsupportedError' | '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

@@ -35,6 +35,8 @@ const publicWeftErrorCodeMap = {
   ActivityReconciliationCapabilityError: !0,
   ActivityReconciliationConflictError: !0,
   ActivityReconciliationIndeterminateError: !0,
+  DurableActivityScopeError: !0,
+  DurableActivityUnsupportedError: !0,
   AsyncActivityTokenNotFoundError: !0,
   ActivityScheduleToCloseTimeoutError: !0,
   ActivityPerAttemptTimeoutError: !0,

package/dist/core/worker-execution-strategy.d.ts

@@ -8,6 +8,7 @@ export declare class WorkerExecutionStrategy implements ExecutionStrategy {
     onMessage(handler: (message: WorkerOutboundMessage) => void | Promise<void>): void;
     startWorkflow(parameters: {
         workflowId: string;
+        workflowExecutionToken?: string;
         workflowType: string;
         input: unknown;
         checkpoint: ArrayBuffer;

package/dist/core/worker-inbound-message.d.ts

@@ -19,6 +19,7 @@ export interface WorkerInboundMessageContext {
 /** Build a `run` inbound message from start parameters and the turn context. */
 export declare function buildRunMessage(parameters: {
     workflowId: string;
+    workflowExecutionToken?: string;
     workflowType: string;
     input: unknown;
     checkpoint: ArrayBuffer;

package/dist/core/worker-inbound-message.js

@@ -5,6 +5,9 @@ export function buildRunMessage(parameters, context) {
     protocolVersion: WORKER_PROTOCOL_VERSION,
     turnId: context.turnId,
     workflowId: parameters.workflowId,
+    ...parameters.workflowExecutionToken !== void 0 && {
+      workflowExecutionToken: parameters.workflowExecutionToken
+    },
     workflowType: parameters.workflowType,
     checkpoint: parameters.checkpoint,
     input: parameters.input,

package/dist/index.d.ts

@@ -20,7 +20,8 @@ export { WeftError, isWeftError, isWeftErrorCode, isWeftErrorLike, isWeftFault,
 export type { WeftErrorCode } from './core/weft-error.ts';
 export { FAULT_CODE_TO_FAILURE_CATEGORY, failureCategoryForFaultCode, isFaultCode, } from './core/fault-code.ts';
 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 { DurableActivityScopeError, DurableActivityUnsupportedError, durableActivity, } from './core/context/durable-activity.ts';
+export { ActivityReconciliationCapabilityError, ActivityReconciliationConflictError, ActivityReconciliationIndeterminateError, ActivityResolutionError, AsyncActivityTokenNotFoundError, BulkDeleteRequiresTerminalWorkflowsError, BulkOperationConfirmationError, ENGINE_LEASE_LOST_WARNING_NAME, ENGINE_LEASE_SYNCHRONOUS_DISPOSE_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_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';

package/dist/index.js

@@ -11,6 +11,11 @@ export {
   failureCategoryForFaultCode,
   isFaultCode
 } from "./core/fault-code.js";
+export {
+  DurableActivityScopeError,
+  DurableActivityUnsupportedError,
+  durableActivity
+} from "./core/context/durable-activity.js";
 export {
   ActivityReconciliationCapabilityError,
   ActivityReconciliationConflictError,
@@ -20,6 +25,7 @@ export {
   BulkDeleteRequiresTerminalWorkflowsError,
   BulkOperationConfirmationError,
   ENGINE_LEASE_LOST_WARNING_NAME,
+  ENGINE_LEASE_SYNCHRONOUS_DISPOSE_WARNING_NAME,
   Engine,
   EngineCreateNameMismatchError,
   EngineDisposedError,

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,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(`
+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=import.meta.require,V=(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},k=(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 x(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,DurableActivityScopeError:!0,DurableActivityUnsupportedError:!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};
+${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 S=Y,h=K,v=B;export{v as validateStandardSchema,S as formatStandardSchemaIssues,h as StandardSchemaValidationError};