eve 0.31.0 → 0.31.2

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # eve
 
+## 0.31.2
+
+### Patch Changes
+
+- 69244fe: Update eve's bundled Workflow SDK packages to the latest 5.0.0 beta releases, keeping the core runtime and workflow worlds aligned.
+
+## 0.31.1
+
+### Patch Changes
+
+- 2a141f0: Keep sessions resumable across eve deployment upgrades: sends now cross durable session hooks as the established `deliver` envelope (with a transitional single-payload mirror for sessions pinned to 0.30.3–0.30.8), and consumers keep accepting payloads persisted by those versions.
+- 99982f7: Treat AI SDK `.devtools` like other generated directories: ignore it in `eve dev` watching, agent discovery, and source snapshots so generation writes do not recompile or warn.
+- a497e8d: Preserve each tool executor's concrete return type through `defineTool`, so non-streaming tools no longer appear to return an async iterable. Allow `ctx.to()` to infer closed receive-target interfaces such as Slack's without requiring an index signature.
+- fe9e7ef: Consume interactive authorization callback results once and keep targeted connection searches from replaying callbacks for unrelated connections.
+
 ## 0.31.0
 
 ### Minor Changes

package/dist/src/channel/cross-channel-receive.d.ts

@@ -16,7 +16,7 @@ export interface CrossChannelTargetHandle {
     send(message: string | UserContent, options: CrossChannelSendOptions): Promise<Session>;
 }
 /** Selects another authored channel and one of its proactive targets. */
-export type CrossChannelToFn = <TChannel extends ChannelReference>(channel: TChannel, target: InferReceiveTarget<TChannel>) => CrossChannelTargetHandle;
+export type CrossChannelToFn = <TChannel extends ChannelReference<unknown>>(channel: TChannel, target: InferReceiveTarget<TChannel>) => CrossChannelTargetHandle;
 /**
  * Channel record consumed by the receiver — keeps the public-facing
  * `definition` reference so callers can identify a target by value

package/dist/src/compiled/.vendor-stamp.json

@@ -34,14 +34,14 @@
     "@vercel/oidc": "3.8.0",
     "@vercel/otel": "2.1.3",
     "@vercel/sandbox": "2.8.0",
-    "@workflow/core": "5.0.0-beta.39",
-    "@workflow/errors": "5.0.0-beta.15",
+    "@workflow/core": "5.0.0-beta.40",
+    "@workflow/errors": "5.0.0-beta.16",
     "@workflow/serde": "5.0.0-beta.2",
-    "@workflow/world": "5.0.0-beta.24",
-    "@workflow/world-local": "5.0.0-beta.33",
-    "@workflow/world-vercel": "5.0.0-beta.35",
+    "@workflow/world": "5.0.0-beta.25",
+    "@workflow/world-local": "5.0.0-beta.34",
+    "@workflow/world-vercel": "5.0.0-beta.36",
     "zod": "4.4.3",
     "zod-validation-error": "5.0.0"
   },
-  "scriptHash": "640455d5c2660cbd8a88133eca72ee3218cfd8053d63f21b93f857e4b0d96732"
+  "scriptHash": "e20714a41a19b69ca8599dc01467ae8cce225eaa106301f1ec2e9adc5d2adcca"
 }

package/dist/src/compiled/@workflow/core/_quickjs-wasi.d.ts

@@ -0,0 +1,8 @@
+// Auto-generated stub for `quickjs-wasi` types referenced by a vendored .d.ts.
+// Emitted by createDeclarationCopier > buildOpaqueTypesStub.
+//
+// Names are aliased to `unknown` so consumers don't have to install
+// upstream @types just to typecheck against eve. If real types are
+// needed in user code, install the upstream @types and use them directly.
+
+export type ExtensionDescriptor = unknown;

package/dist/src/compiled/@workflow/core/correlation-id.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Correlation-id generation for the entity families a replay can create.
+ *
+ * Correlation ids are minted by the workflow VM and are the server's identity
+ * gate: a conditional create on the id is what makes a duplicate write from a
+ * second live replay idempotent instead of additive. That only works if two
+ * replays of the same run mint the same id for the same entity.
+ *
+ * Historically every id was the Nth draw of *one* monotonic ULID sequence per
+ * run, shared by steps, waits, hooks, attribute writes, abort controllers and
+ * stream ids alike. Every id was therefore an ordinal over the whole run, and a
+ * single extra draw of any kind renumbered every entity of every kind after it.
+ * Two replays that agreed about every step but disagreed about one `sleep()`
+ * would mint different ids for all subsequent steps, so their writes appended
+ * side by side instead of colliding, and the settled log ended up holding two
+ * names for one logical step. Only one of them can be consumed on the next
+ * replay; the other is fatal (`onUnconsumedEvent`).
+ *
+ * Per-kind sources narrow that coupling to one kind at a time: each family
+ * draws from its own independent incrementing sequence, so a disagreement about
+ * how many hooks or sleeps were created no longer renames steps.
+ *
+ * Ids stay syntactically valid ULIDs (10 Crockford characters of
+ * `fixedTimestamp` plus 16 of body), because correlation ids are validated as
+ * prefixed 26-char ULIDs by the backend, and they stay monotonic *within* a
+ * kind, because `hooks.list` is ordered by hook id.
+ *
+ * Monotonicity is per kind, and two kinds mint `hook_` ids (`hook` and
+ * `abortHook`), so listing order is only creation order *within* each of them.
+ * No world filters system hooks out of a listing, so a run that constructs an
+ * abort controller and also creates its own hooks lists that system hook at a
+ * position decided by its kind's hash rather than at its creation position.
+ * Order among the user's own hooks is unaffected.
+ *
+ * This does not make ids independent of *ordinal position within their own
+ * kind*: two replays that disagree about how many steps ran still mint
+ * different ids for the next step. That is a narrower failure than the shared
+ * sequence's, not an eliminated one.
+ */
+/** Entity families that draw correlation ids, each from its own sequence. */
+export type CorrelationIdKind = 
+/** `step_` ids, one per step invocation. */
+'step'
+/** `wait_` ids, one per `sleep()`. */
+ | 'wait'
+/** `hook_` ids for hooks created by workflow code. */
+ | 'hook'
+/** `attr_` ids, one per attribute write. */
+ | 'attr'
+/**
+ * The abort controller's own id, which becomes its stream name and hook
+ * token. Separate from `hook` so constructing an abort controller does not
+ * renumber later user hooks.
+ */
+ | 'abort'
+/** `hook_` ids for the internal system hook backing an abort controller. */
+ | 'abortHook'
+/**
+ * Ids minted during serialization (`STABLE_ULID`): stream names, and an abort
+ * holder's stream name and `abrt_` hook token when it reaches serialization
+ * without an identity yet (`reduceAbortWithListener`), which is why `abort`
+ * above is not the only mint path for an abort identity. Not correlation ids,
+ * but they drew from the same shared sequence, so a workflow that serialized
+ * a stream renumbered every entity created after it.
+ */
+ | 'stream';
+/** Mints the ULID body of a correlation id for one entity family. */
+export type CorrelationIdGenerator = (kind: CorrelationIdKind) => string;
+/**
+ * Builds a replay's correlation-id generator.
+ *
+ * `perKind: false` returns the run's single shared monotonic sequence and
+ * ignores the kind entirely, so both schemes go through one call path and the
+ * flag is the only difference between them.
+ */
+export declare function createCorrelationIdGenerator(options: {
+    /**
+     * The run's replay-stable seed. Must not vary between replays of one run, and
+     * must differ between runs, or two runs would mint identical ids.
+     */
+    seed: string;
+    fixedTimestamp: number;
+    /** The run's shared monotonic sequence, used as-is when `perKind` is false. */
+    positional: () => string;
+    perKind: boolean;
+}): CorrelationIdGenerator;
+/** Length of a ULID, exported so tests need not restate it. */
+export declare const CORRELATION_ID_LENGTH: number;
+/**
+ * Whether each entity family draws correlation ids from its own sequence rather
+ * than from one sequence shared by the whole run. Off unless opted in, so an SDK
+ * upgrade alone never moves a run between schemes.
+ *
+ * The invariant either way: a run must replay under the scheme that minted its
+ * ids. A replay under the other scheme mints ids its own earlier events do not
+ * carry, so it can consume none of them and fails the run. Two things can break
+ * it, and both are about turning the flag on rather than about upgrading:
+ *
+ * - Enabling it while runs are in flight. On Vercel, skew protection keeps a run
+ *   on the deployment that started it, so a run only ever sees the value baked
+ *   into its own deployment. Elsewhere (world-postgres, world-local, a
+ *   self-hosted process) nothing pins a run to the code that started it, so
+ *   enable it during a quiet window.
+ * - A rolling deploy that leaves both values live, which puts two schemes on one
+ *   run concurrently — the side-by-side append this whole mechanism exists to
+ *   avoid. Roll the value out to the whole fleet at once.
+ */
+export declare function isPerKindCorrelationIdsEnabled(): boolean;
+//# sourceMappingURL=correlation-id.d.ts.map

package/dist/src/compiled/@workflow/core/events-consumer.d.ts

@@ -55,6 +55,7 @@ export declare class EventsConsumer {
     private pendingUnconsumedTimeout;
     private unconsumedCheckVersion;
     constructor(events: Event[], options: EventsConsumerOptions);
+    append(events: Event[]): void;
     /**
      * Registers a callback function to be called after an event has been consumed
      * by a different callback. The callback can return:

package/dist/src/compiled/@workflow/core/index.js

@@ -1,2 +1,2 @@
-import{A as e,Bn as t,Fn as n,Hn as r,In as i,K as a,M as o,Mn as s,Pn as c,S as l,Vn as u,bn as d,kn as f,q as p,zn as m}from"../../_chunks/workflow/wait-until-DoW76jdb.js";import{i as h,u as g}from"../../_chunks/workflow/dist-dNxTT6nO.js";import{a as _,i as v,r as y,t as b}from"../../_chunks/workflow/attribute-changes-DROfGk6l.js";import"../../_chunks/workflow/dist-D5bR13zs.js";import{n as x}from"../../_chunks/workflow/resume-hook-bc-OQVI0.js";import{t as S}from"../../_chunks/workflow/sleep-D5iWly6-.js";function C(e){v(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,C)}function w(e){v(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,w)}function T({schema:e}={}){function t(e){v(`defineHook().create()`,`https://workflow-sdk.dev/docs/api-reference/workflow/define-hook`,t)}return{create:t,async resume(t,n){if(!e?.[`~standard`])return await x(t,n);let r=e[`~standard`].validate(n);if(r instanceof Promise&&(r=await r),r.issues){let e=r.issues.map(e=>{let t=e.path?.map(e=>String(typeof e==`object`&&e?e.key:e)).join(`.`);return t?`  at "${t}": ${e.message}`:`  ${e.message}`});throw Error(`Hook payload did not match the defined schema:\n${e.join(`
-`)}`)}return await x(t,r.value)}}}async function E(e,t={}){let n=p.getStore(),r=n?.workflowMetadata?.workflowRunId;if(!r)throw new h(`setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let i=b(e,t);if(i.length!==0){if(n.runReadyBarrier)try{await n.runReadyBarrier}catch{}await(await s()).events.create(r,{eventType:`attr_set`,specVersion:5,eventData:{changes:i,writer:{type:`step`,stepId:n.stepMetadata.stepId,attempt:n.stepMetadata.attempt},...t.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}}function D(){let e=p.getStore();return e||y(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,D),e.stepMetadata}function O(){let e=p.getStore();return e||_(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,O),e.workflowMetadata}function k(s={}){let h=p.getStore();h||_(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,k);let{namespace:g}=s,v=h.workflowMetadata.workflowRunId,y=a(v,g);h.writables??=new Map;let b=h.writables,x=b.get(y);if(x)return x.writable;let S=o(e(globalThis,h.ops,v,h.encryptionKey,!0,h.runReadyBarrier),h.encryptionKey),C=new l(v,y,h.runReadyBarrier),w=c();return h.ops.push(w.promise),n(S.readable,C,w).catch(()=>{}),i(S.writable,w),Object.defineProperty(S.writable,m,{value:y,writable:!1}),Object.defineProperty(S.writable,r,{value:v,writable:!1}),h.workflowDeploymentId&&Object.defineProperty(S.writable,t,{value:h.workflowDeploymentId,writable:!1}),d(h.encryptionKey)&&Object.defineProperty(S.writable,u,{value:f(h.encryptionKey.keyPair.publicKey),writable:!1}),b.set(y,{writable:S.writable,state:w}),S.writable}export{h as FatalError,g as RetryableError,C as createHook,w as createWebhook,T as defineHook,D as getStepMetadata,O as getWorkflowMetadata,k as getWritable,E as setAttributes,S as sleep};
+import{A as e,Bn as t,En as n,Fn as r,Gn as i,Hn as a,Jn as o,K as s,Kn as c,M as l,Rn as u,S as d,Vn as f,q as p,qn as m}from"../../_chunks/workflow/wait-until-CMX5LUWJ.js";import{i as h,u as g}from"../../_chunks/workflow/dist-CRTn4Sg8.js";import{a as _,i as v,r as y,t as b}from"../../_chunks/workflow/attribute-changes-Du5ztewf.js";import"../../_chunks/workflow/dist-CNXUKQCp.js";import{n as x}from"../../_chunks/workflow/resume-hook-CT0keOww.js";import{t as S}from"../../_chunks/workflow/sleep-BeH4B0Cd.js";function C(e){v(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,C)}function w(e){v(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,w)}function T({schema:e}={}){function t(e){v(`defineHook().create()`,`https://workflow-sdk.dev/docs/api-reference/workflow/define-hook`,t)}return{create:t,async resume(t,n){if(!e?.[`~standard`])return await x(t,n);let r=e[`~standard`].validate(n);if(r instanceof Promise&&(r=await r),r.issues){let e=r.issues.map(e=>{let t=e.path?.map(e=>String(typeof e==`object`&&e?e.key:e)).join(`.`);return t?`  at "${t}": ${e.message}`:`  ${e.message}`});throw Error(`Hook payload did not match the defined schema:\n${e.join(`
+`)}`)}return await x(t,r.value)}}}async function E(e,t={}){let n=p.getStore(),r=n?.workflowMetadata?.workflowRunId;if(!r)throw new h(`setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let i=b(e,t);if(i.length!==0){if(n.runReadyBarrier)try{await n.runReadyBarrier}catch{}await(await u()).events.create(r,{eventType:`attr_set`,specVersion:5,eventData:{changes:i,writer:{type:`step`,stepId:n.stepMetadata.stepId,attempt:n.stepMetadata.attempt},...t.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}}function D(){let e=p.getStore();return e||y(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,D),e.stepMetadata}function O(){let e=p.getStore();return e||_(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,O),e.workflowMetadata}function k(u={}){let h=p.getStore();h||_(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,k);let{namespace:g}=u,v=h.workflowMetadata.workflowRunId,y=s(v,g);h.writables??=new Map;let b=h.writables,x=b.get(y);if(x)return x.writable;let S=l(e(globalThis,h.ops,v,h.encryptionKey,!0,h.runReadyBarrier),h.encryptionKey),C=new d(v,y,h.runReadyBarrier),w=t();return h.ops.push(w.promise),f(S.readable,C,w).catch(()=>{}),a(S.writable,w),Object.defineProperty(S.writable,i,{value:y,writable:!1}),Object.defineProperty(S.writable,o,{value:v,writable:!1}),h.workflowDeploymentId&&Object.defineProperty(S.writable,c,{value:h.workflowDeploymentId,writable:!1}),n(h.encryptionKey)&&Object.defineProperty(S.writable,m,{value:r(h.encryptionKey.keyPair.publicKey),writable:!1}),b.set(y,{writable:S.writable,state:w}),S.writable}export{h as FatalError,g as RetryableError,C as createHook,w as createWebhook,T as defineHook,D as getStepMetadata,O as getWorkflowMetadata,k as getWritable,E as setAttributes,S as sleep};

package/dist/src/compiled/@workflow/core/private.d.ts

@@ -2,6 +2,7 @@
  * Utils used by the bundler when transforming code
  */
 import type { WorldCapabilities } from '#compiled/@workflow/world/index.js';
+import type { CorrelationIdGenerator } from './correlation-id.js';
 import type { EventsConsumer } from './events-consumer.js';
 import type { QueueItem } from './global.js';
 import type { ReplayPayloadCache } from './replay-payload-cache.js';
@@ -30,6 +31,16 @@ export interface WorkflowOrchestratorContext {
     encryptionKey: PayloadKey | undefined;
     worldCapabilities?: WorldCapabilities;
     globalThis: typeof globalThis;
+    /**
+     * Increments when a suspension is accepted and on every retained-session
+     * resume. STEP suspension signals capture it when scheduled and no-op if
+     * it moved (see step.ts) — this drops same-boundary sibling signals and
+     * timers queued at boundary N that would fire after the session resumed
+     * into boundary N+1. Sleep/hook/attribute signals are intentionally
+     * unguarded: their presence makes the boundary unretainable, so a late
+     * signal correctly demotes the session (workflow.ts `onWorkflowError`).
+     */
+    suspensionGeneration: number;
     eventsConsumer: EventsConsumer;
     /**
      * Map of pending invocations keyed by correlationId.
@@ -37,7 +48,12 @@ export interface WorkflowOrchestratorContext {
      */
     invocationsQueue: Map<string, QueueItem>;
     onWorkflowError: (error: Error) => void;
-    generateUlid: () => string;
+    /**
+     * Mints a correlation id body for one entity family. Every entity a replay
+     * creates draws from here, and the family is what keeps a disagreement about
+     * one family's count from renumbering another's.
+     */
+    generateCorrelationId: CorrelationIdGenerator;
     generateNanoid: () => string;
     /**
      * Sequential promise queue that ensures all event-driven promise resolutions

package/dist/src/compiled/@workflow/core/private.js

@@ -1 +1 @@
-import{a as e,i as t,n,r,t as i}from"../../_chunks/workflow/private-BcwCGTV5.js";export{i as awaitEarlierDeliveries,n as getStepFunction,r as registerDeliveryBarrier,t as registerStepFunction,e as scheduleWhenIdle};
+import{a as e,i as t,n,r,t as i}from"../../_chunks/workflow/private-CiWVdS5v.js";export{i as awaitEarlierDeliveries,n as getStepFunction,r as registerDeliveryBarrier,t as registerStepFunction,e as scheduleWhenIdle};

package/dist/src/compiled/@workflow/core/runtime/constants.d.ts

@@ -141,6 +141,18 @@ export declare function isOptimisticInlineStartExplicitlyDisabled(): boolean;
  * explicit `'0'` / `'false'` (case-insensitive).
  */
 export declare function isTurboEnabled(): boolean;
+/**
+ * Whether the inline loop retains a suspended workflow VM across inline steps
+ * within one invocation (default ON). When on, a step-only suspension keeps
+ * the live VM, event consumer, and hydrated state alive, and the next loop
+ * iteration appends only the newly durable events instead of rebuilding the
+ * `vm.Context` and replaying the whole event log. Non-step suspensions and
+ * replay divergence always fall back to the ordinary durable replay path.
+ *
+ * `WORKFLOW_RETAINED_VM=0` (or `false`) is the kill switch: every iteration
+ * replays from scratch in a fresh VM, matching the pre-retention behavior.
+ */
+export declare function isVmRetentionEnabled(): boolean;
 /**
  * Whether inline step ownership is enabled (default ON). When on, the lazy
  * `step_started` that creates an inline step records the owning queue
@@ -219,4 +231,11 @@ export declare const PRECONDITION_REINVOKE_DELAY_SECONDS = 2;
  * `WORKFLOW_PRECONDITION_REINVOKE_DELAY_SECONDS`.
  */
 export declare function getPreconditionReinvokeDelaySeconds(): number;
+export declare const DEPLOYMENT_MISMATCH_MAX_RETRIES = 3;
+/**
+ * Effective deployment-mismatch re-route budget. Override via
+ * `WORKFLOW_DEPLOYMENT_MISMATCH_MAX_RETRIES`; `0` fails the run on the first
+ * misrouted delivery instead of attempting recovery.
+ */
+export declare function getDeploymentMismatchMaxRetries(): number;
 //# sourceMappingURL=constants.d.ts.map

package/dist/src/compiled/@workflow/core/runtime/deployment-guard.d.ts

@@ -0,0 +1,99 @@
+import { type WorkflowRun, type World } from '#compiled/@workflow/world/index.js';
+/**
+ * How the guard resolved a delivery. Both non-`continue` outcomes mean the
+ * caller must ack the message and return without executing anything.
+ */
+export type DeploymentAffinityOutcome = 
+/** The run belongs here (or this world has no deployment affinity). */
+'continue'
+/** Misrouted; re-enqueued at the run's own deployment. */
+ | 'rerouted'
+/** Misrouted and out of budget (or unroutable); `run_failed` recorded. */
+ | 'failed';
+/**
+ * `spanAttributes` is present only on a misrouted delivery — mismatches are
+ * rare, so the presence of `workflow.deployment.pinned_id` on a span *is* the
+ * signal that one happened, and `recovered` separates the ones a re-route fixed
+ * from the ones that kept misrouting.
+ */
+export interface DeploymentAffinityResult {
+    outcome: DeploymentAffinityOutcome;
+    spanAttributes?: Record<string, string | number | boolean>;
+}
+/**
+ * Arguments handed to a call site's re-enqueue closure. The guard owns the
+ * policy — counting, backoff, logging, telemetry, escalation — and the call
+ * site owns only the shape of the message it needs to put back on the queue.
+ */
+export interface ReenqueueArgs {
+    /** The deployment to target: the one the run is pinned to. */
+    deploymentId: string;
+    /**
+     * The run's spec version, so the world picks the right queue transport
+     * (CBOR vs JSON). Undefined on legacy runs that predate the field; worlds
+     * then fall back to their current default.
+     */
+    specVersion: number | undefined;
+    deploymentMismatchRetryCount: number;
+    /** Backoff before the re-routed message becomes visible. */
+    delaySeconds: number;
+}
+/**
+ * Guards deployment affinity: a run may only execute on the deployment it is
+ * pinned to.
+ *
+ * A run's `deploymentId` is fixed when it starts — the deployment that called
+ * `start()`, or whatever `start({ deploymentId })` resolved to (an explicit id
+ * or `'latest'`) — and no replay or step execution may happen anywhere else:
+ * the bundles here may not match the run's persisted history, and any step
+ * dispatched from here derives the per-run encryption key from the wrong
+ * deployment's master key, which surfaces as a `RuntimeDecryptionError` the
+ * queue retry callback swallows into a blank "exceeded max retries".
+ *
+ * A misrouted delivery is not treated as permanent. Rather than failing
+ * immediately, re-enqueue the message *explicitly targeted* at the run's own
+ * deployment; that send is strictly better-addressed than the one that
+ * misrouted, which inherited the producing deployment's ambient id. Fail only
+ * once the budget (`WORKFLOW_DEPLOYMENT_MISMATCH_MAX_RETRIES`, default 3) is
+ * spent, mirroring how a replay divergence gets bounded recovery replays before
+ * being recorded as a corrupted event log.
+ *
+ * Callers must pass a run entity they already have in hand — every call site
+ * loads the run for other reasons — so the guard costs no extra round trip.
+ * (`world.getDeploymentId()` reads the ambient deployment id, e.g.
+ * `VERCEL_DEPLOYMENT_ID`, and does not call the backend either.)
+ *
+ * The failure is recorded **without resolving the run's encryption key**: the
+ * key is fetched from the pinned deployment's API, often unavailable once that
+ * deployment is past its retention window, so depending on it would throw here
+ * instead of recording the failure. The payload is written unencrypted (it
+ * holds only deployment ids, nothing sensitive), and the plaintext `errorCode`
+ * is the signal observability and the UI key off.
+ */
+export declare function guardDeploymentAffinity({ world, run, requestId, retryCount, reenqueue, isDeploymentUnavailableError, beforeStop, }: {
+    world: World;
+    run: Pick<WorkflowRun, 'runId' | 'deploymentId' | 'specVersion'>;
+    requestId?: string;
+    /** `deploymentMismatchRetryCount` from the incoming message, if any. */
+    retryCount?: number;
+    /**
+     * Puts this delivery's message back on the queue, targeted at the run's own
+     * deployment. Omitted by callers that cannot reconstruct their message, which
+     * makes the guard fail-fast.
+     */
+    reenqueue?: (args: ReenqueueArgs) => Promise<void>;
+    /**
+     * Classifies a re-enqueue failure as definitive proof that the pinned
+     * deployment cannot receive the message. Unclassified failures are retried
+     * by rejecting the handler and leaving the current queue message unacked.
+     */
+    isDeploymentUnavailableError?: (error: unknown) => boolean;
+    /**
+     * Ordering barrier awaited once a mismatch is confirmed, before either
+     * stopping action. Under turbo the `run_started` write is backgrounded, and
+     * both outcomes hand the run off (to a `run_failed` here, or to the pinned
+     * deployment's own `run_started`) — so that write must have landed first.
+     */
+    beforeStop?: () => Promise<void>;
+}): Promise<DeploymentAffinityResult>;
+//# sourceMappingURL=deployment-guard.d.ts.map

package/dist/src/compiled/@workflow/core/runtime/quickjs-assets.generated.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Auto-generated by scripts/build-quickjs-assets.js
+ * Do not edit manually.
+ *
+ * Contains base64-encoded quickjs-wasi WASM binary and native C extension
+ * .so files. Decoded at import time so they can be passed directly to
+ * QuickJS.create() and QuickJS.restore() without any filesystem access,
+ * import.meta.url resolution, or require.resolve calls.
+ */
+import type { ExtensionDescriptor } from '../_quickjs-wasi.js';
+declare const quickjsWasm: Uint8Array<ArrayBufferLike>;
+export { quickjsWasm };
+export declare const quickjsExtensions: ExtensionDescriptor[];
+//# sourceMappingURL=quickjs-assets.generated.d.ts.map

package/dist/src/compiled/@workflow/core/runtime/quickjs-entrypoint.d.ts

@@ -0,0 +1,124 @@
+/**
+ * QuickJS VM integration with the Workflow DevKit.
+ *
+ * This module provides the entry point for running workflows in the
+ * QuickJS WASM VM engine instead of the `node:vm` engine. Both engines
+ * implement the same event-replay execution model — every invocation:
+ *
+ * 1. Loads the full event log for the run
+ * 2. Runs the workflow function from the top in a fresh QuickJS VM,
+ *    replaying the event log to resolve awaited primitives
+ * 3. On suspension: creates events + queues steps for new pending ops
+ * 4. On completion: creates run_completed
+ * 5. On failure: creates run_failed
+ */
+import type { Span } from '#compiled/@opentelemetry/api/index.js';
+import { type Event, type RunInput, type WorkflowRun } from '#compiled/@workflow/world/index.js';
+/**
+ * Returns true when the supplied preloaded events indicate this is the
+ * first workflow handler invocation for the run — i.e. the log contains
+ * nothing beyond `run_created` / `run_started`. In that case the
+ * preloaded events ARE the complete event log and the `events.list`
+ * round-trips can be skipped entirely.
+ *
+ * Crucially, if the world backfilled a missing `run_created` via the
+ * resilient start path, `preloadedEvents` contains it even when a fresh
+ * `events.list` might not (eventual consistency), so preferring the
+ * preloaded events on first invocation is also the more correct choice.
+ *
+ * Returns false when `preloadedEvents` is missing/empty so the caller
+ * falls back to the normal fetch path.
+ *
+ * Exported for unit testing.
+ */
+export declare function isFirstInvocation(preloadedEvents: readonly Event[] | undefined): boolean;
+/**
+ * Run a workflow using the QuickJS WASM VM engine.
+ *
+ * This replaces the `node:vm` replay path (runWorkflow + EventsConsumer)
+ * with a QuickJS VM invocation that performs the same full event replay.
+ *
+ * KNOWN GAP — precondition guard: unlike the node:vm path, no event write
+ * in this file participates in the optimistic-concurrency precondition
+ * guard (`withPreconditionRetry` + `stateUpdatedAtForCreate`), which
+ * protects a writer holding a stale event-log snapshot from clobbering a
+ * concurrent one. The engine currently relies on per-(runId,
+ * correlationId) event uniqueness (EntityConflictError dedup) alone. This
+ * is a deliberate simplification while the engine is experimental — wiring
+ * the guard is tracked follow-up work; anyone adding new write paths here
+ * should not assume parity with the node engine on this axis.
+ */
+export declare function runWorkflowWithQuickJS(params: {
+    workflowCode: string;
+    workflowName: string;
+    workflowRun: WorkflowRun;
+    /**
+     * Events returned inline by `events.create('run_started', ...)` or by
+     * the lazy hook fast path's `hook_received` preload. When they indicate
+     * a first invocation — or when `preloadedEventsComplete` attests they
+     * are the complete log — they are used as the event log instead of
+     * fetching via `events.list`, matching the node:vm engine's fast path.
+     */
+    preloadedEvents?: Event[];
+    /**
+     * True when the caller has validated that `preloadedEvents` is the run's
+     * COMPLETE event log (e.g. the lazy hook fast path's hasMore-false
+     * replay preload). The first-invocation heuristic below only recognizes
+     * run_created/run_started-only preloads, so without this attestation a
+     * hook-resume preload would be discarded and refetched.
+     */
+    preloadedEventsComplete?: boolean;
+    /**
+     * Run input carried through the queue message on first delivery. Used
+     * as a last-resort fallback for `run_created.eventData.input` when
+     * the event log is incomplete.
+     */
+    runInput?: RunInput;
+    /**
+     * The parent OTel span (the outer `WORKFLOW {workflowName}` span from
+     * `runtime.ts`). When supplied, VM lifecycle attributes are attached
+     * to it for end-to-end visibility.
+     */
+    parentSpan?: Span;
+    /**
+     * Server-supplied per-run event ceiling from the run_started response
+     * (undefined ⇒ no enforcement). Mirrors the node:vm engine's guard:
+     * a runaway run is failed once its log reaches the ceiling. The throw
+     * propagates to the replay loop's catch in runtime.ts (the QuickJS
+     * dispatch runs inside that loop's try), which classifies it and
+     * records run_failed with MAX_EVENTS_EXCEEDED.
+     */
+    maxEventsLimit?: number;
+    /**
+     * Queue delivery attempt of the message driving this invocation (from
+     * the queue handler's metadata; 1 = first delivery). Surfaced in
+     * diagnostics; crash recovery itself is driven by the ownership-lease
+     * decision table in the loop, not by the attempt count.
+     */
+    deliveryAttempt?: number;
+    /**
+     * Queue message ID of the delivery driving this invocation, stamped as
+     * `ownerMessageId` on inline lazy step claims so wake replays defer to
+     * the in-flight body instead of requeueing the step.
+     */
+    ownerMessageId?: string;
+    /**
+     * Queue namespace resolved at route registration (runtime.ts). Must be
+     * threaded into every message publish: the builders bake the namespace
+     * into generated routes, so consumers listen on `__<ns>_wkf_workflow_*`
+     * — a publish without it lands on `__wkf_workflow_*` and is never
+     * picked up.
+     */
+    namespace?: string;
+    /**
+     * Run-origin trace carrier accessor from runtime.ts
+     * (getNextTraceCarrier). In the default `linked` trace mode every
+     * invocation must link back to the run's origin (workflow.start) in a
+     * star; capturing the current invocation context instead would chain
+     * invocations to each other and fragment the run view on async queues.
+     */
+    nextTraceCarrier?: () => Promise<Record<string, string>>;
+}): Promise<{
+    timeoutSeconds?: number;
+} | void>;
+//# sourceMappingURL=quickjs-entrypoint.d.ts.map