eve 0.48.0 → 0.49.0

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

@@ -18,7 +18,7 @@ export declare function getDeserializeStream(revivers: Partial<Revivers>, crypto
  * Wraps each chunk of a byte stream in a 4-byte big-endian length
  * prefix. Used by the producer side of a framed byte-stream pipe.
  *
- * Empty chunks (length 0) are dropped — the resulting `[0x00 0x00 0x00 0x00]`
+ * Empty chunks (length 0) are dropped: the resulting `[0x00 0x00 0x00 0x00]`
  * frame would be ambiguous with the legacy "looks framed" detection in
  * `getDeserializeStream`, and it carries no information.
  *
@@ -27,7 +27,7 @@ export declare function getDeserializeStream(revivers: Partial<Revivers>, crypto
  * writable performs one wire write per chunk, preserving boundaries). The
  * server therefore stores one frame per chunk index, which is what allows
  * a future reconnecting reader to resume a framed byte stream at
- * `startIndex + consumedFrames` — the same arithmetic
+ * `startIndex + consumedFrames`, the same arithmetic
  * `createReconnectingFramedStream` relies on for object streams. Do not
  * coalesce or split frames here without revisiting that resume logic.
  */
@@ -36,7 +36,7 @@ export declare function getByteFramingStream(): TransformStream<Uint8Array, Uint
  * Unwraps length-prefixed byte-stream frames back into the original user
  * chunks. Used by the consumer side of a framed byte-stream pipe.
  *
- * Buffers across read boundaries — the transport may split a single
+ * Buffers across read boundaries, since the transport may split a single
  * frame across multiple reads (header in one chunk, payload in another)
  * or coalesce multiple frames into a single read. The transform emits
  * whole user chunks regardless of transport chunking.
@@ -55,7 +55,7 @@ export declare class WorkflowServerReadableStream extends ReadableStream<Uint8Ar
  * Maximum consecutive reconnect attempts for a single framed stream session.
  * The counter resets to zero whenever a reconnect makes forward progress (a
  * frame is delivered), so this bounds *consecutive* failures, not the lifetime
- * total — a long-lived serverless stream may legitimately reconnect far more
+ * total: a long-lived serverless stream may legitimately reconnect far more
  * than this many times as long as each reconnect keeps delivering data. We only
  * give up after this many reconnects in a row produce nothing.
  */
@@ -66,7 +66,7 @@ export declare const FRAMED_STREAM_MAX_RECONNECTS = 50;
  * correct for a well-behaved backend that honors `startIndex`. But if a World's
  * `streams.get` ever ignored `startIndex` and re-delivered earlier chunks,
  * "progress" would be reported every reconnect and the consecutive cap would
- * never trip — turning a bounded failure into an unbounded reconnect loop. This
+ * never trip, turning a bounded failure into an unbounded reconnect loop. This
  * hard ceiling guarantees the loop always terminates. It is set high enough
  * (hours of streaming at realistic per-session timeouts) to never interfere
  * with legitimate long-lived streams.
@@ -81,7 +81,7 @@ export declare const FRAMED_STREAM_MAX_TOTAL_RECONNECTS = 1000;
  * the writable buffers one frame per chunk when multi-writing). The wrapper
  * counts completed frames and, on upstream error, reopens the connection
  * with `startIndex = resolvedStartIndex + consumedFrames`. Partial-frame
- * bytes buffered before the cut are discarded — the server will resend the
+ * bytes buffered before the cut are discarded; the server will resend the
  * in-flight chunk in full from the new startIndex.
  *
  * A clean upstream close (EOF with no error) is NOT trusted as completion
@@ -97,7 +97,7 @@ export declare const FRAMED_STREAM_MAX_TOTAL_RECONNECTS = 1000;
  *
  * Negative `startIndex` values (last-N semantics) skip the reconnect
  * machinery because we cannot compute an absolute resume position without
- * a tail-index lookup — the returned stream behaves as a single-shot read.
+ * a tail-index lookup; the returned stream behaves as a single-shot read.
  */
 export declare function createReconnectingFramedStream(runId: string, name: string, startIndex?: number): ReadableStream<Uint8Array>;
 export declare class WorkflowServerWritableStream extends WritableStream<Uint8Array> {
@@ -125,11 +125,11 @@ import type { ByteStreamFraming, Reducers, Revivers } from './serialization/type
  * @param framedByteStreams - When `true`, byte streams (`type: 'bytes'`)
  *   are wrapped in length-prefixed frames on the wire so the consumer
  *   can reconnect on transient errors. Should match the target run's
- *   capability — see `getRunCapabilities` in `capabilities.ts`. Defaults
+ *   capability: see `getRunCapabilities` in `capabilities.ts`. Defaults
  *   to `false` for backwards compatibility with older runs.
  * @returns
  */
-export declare function getExternalReducers(global: Record<string, any> | undefined, ops: Promise<void>[], runId: string, cryptoKey: EncryptionKeyParam, framedByteStreams?: boolean, runReadyBarrier?: Promise<unknown>): Partial<Reducers>;
+export declare function getExternalReducers(global: Record<string, any> | undefined, ops: Promise<void>[], runId: string, cryptoKey: EncryptionKeyParam, framedByteStreams?: boolean, runReadyBarrier?: Promise<unknown>, readbackOps?: Promise<void>[]): Partial<Reducers>;
 export declare function getWorkflowReducers(global?: Record<string, any>): Partial<Reducers>;
 /**
  * Cancel dangling abort-stream readers on any AbortController instances found
@@ -381,12 +381,12 @@ export declare function deserializePreparedStepError(prepared: PreparedReplayPay
  * @param global - Global object for serialization context
  * @param v1Compat - Enable legacy v1 compatibility mode
  * @param framedByteStreams - Whether the target run can decode wire-framed
- *   byte streams. Should match the target deployment's capability — see
+ *   byte streams. Should match the target deployment's capability: see
  *   `getRunCapabilities` in `capabilities.ts`. Defaults to `false` for
  *   backwards compatibility with older runs.
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateWorkflowArguments(value: unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateWorkflowArguments(value: unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean, readbackOps?: Promise<void>[]): Promise<Uint8Array | unknown>;
 /**
  * Called from workflow execution environment to hydrate the workflow
  * arguments from the database at the start of workflow execution. A prepared
@@ -398,12 +398,11 @@ export declare function hydrateWorkflowArguments(value: Uint8Array | unknown, _r
  */
 export declare function dehydrateWorkflowReturnValue(value: unknown, _runId: string, key: PayloadKey | undefined, global?: Record<string, any>, v1Compat?: boolean, compression?: boolean, 
 /**
- * Optional sink receiving every workflow-code execution serialization could
- * not avoid, for callers that need them programmatically (e.g. a
- * retained-VM gate deciding whether the VM is still reusable). The
- * executions are emitted as span attributes either way, so omitting this
- * loses nothing observability-wise. The retained-VM gate in
- * runtime/suspension-handler.ts passes one for step-input dehydration.
+ * Optional sink receiving the first five samples and exact total count of
+ * workflow-code executions serialization could not avoid. The diagnostics
+ * are emitted as span attributes either way, so omitting this loses nothing
+ * observability-wise. The retained-VM gate in runtime/suspension-handler.ts
+ * passes one for step-input dehydration.
  */
 guestCodeStatsOut?: GuestCodeStats): Promise<Uint8Array | unknown>;
 /**
@@ -435,12 +434,12 @@ export declare function hydrateStepArguments(value: Uint8Array | unknown, runId:
  * @param global - Global object for serialization context
  * @param v1Compat - Enable legacy v1 compatibility mode
  * @param framedByteStreams - Whether the target run can decode wire-framed
- *   byte streams. Should match the target deployment's capability — see
+ *   byte streams. Should match the target deployment's capability: see
  *   `getRunCapabilities` in `capabilities.ts`. Defaults to `false` for
  *   backwards compatibility with older runs.
  * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateStepReturnValue(value: unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean, runReadyBarrier?: Promise<unknown>): Promise<Uint8Array | unknown>;
+export declare function dehydrateStepReturnValue(value: unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean, compression?: boolean, runReadyBarrier?: Promise<unknown>, readbackOps?: Promise<void>[]): Promise<Uint8Array | unknown>;
 /**
  * Called from the step executor when a step throws. Dehydrates the thrown
  * value from within the step execution environment into a format that can

package/dist/src/compiled/@workflow/core/source-map.d.ts

@@ -4,7 +4,7 @@
  * present.
  *
  * Use this on the host side before evaluating workflow bundles inside
- * the QuickJS VM — the inline map can account for several MB of bundle
+ * the QuickJS VM: the inline map can account for several MB of bundle
  * text (measured ~30%+ of VM heap bytes on the example workbench's
  * bundle), and the VM never needs it; only host-side `remapErrorStack`
  * reads the map (and it can do so against the original, unstripped

package/dist/src/compiled/@workflow/core/step/context-storage.d.ts

@@ -9,7 +9,7 @@ import type { StepMetadata } from './get-step-metadata.js';
  * Holds the user-facing `WritableStream` and the shared `FlushableStreamState`
  * driving the background pipe to the workflow server. Re-used so repeat calls
  * to `getWritable()` within the same step return the same handle instead of
- * spawning racing pipes — see https://github.com/vercel/workflow/issues/2058.
+ * spawning racing pipes; see https://github.com/vercel/workflow/issues/2058.
  */
 export interface CachedWritable {
     writable: WritableStream<any>;
@@ -35,14 +35,14 @@ export type StepContext = {
      * The canonical case is a step-initiated `AbortController.abort()`: the
      * durable `hook_received` event records the cancellation in the workflow's
      * event log. If it is flushed in the background (like `ops`), the workflow
-     * continuation enqueued by `step_completed` can run — and advance past the
-     * abort, dispatching a later step with a stale, non-aborted `signal` — before
+     * continuation enqueued by `step_completed` can run (and advance past the
+     * abort, dispatching a later step with a stale, non-aborted `signal`) before
      * the `hook_received` event exists. Awaiting these inline before completion
      * guarantees the abort is ordered ahead of any continuation that observes the
      * step's result. Unlike these, `ops` holds best-effort real-time stream
      * writes that should fire ASAP and are intentionally left in the background.
      *
-     * Contract: producers MUST NOT push a promise that can reject — these are
+     * Contract: producers MUST NOT push a promise that can reject; these are
      * awaited only to enforce ordering, never to surface an outcome. A rejection
      * here would propagate as an infra error (queue re-delivery), not the
      * user-code failure path, so each producer swallows its own errors (see
@@ -60,7 +60,7 @@ export type StepContext = {
     /**
      * Turbo mode only: a promise that resolves once the backgrounded
      * `run_started` has landed (the run exists). Set when the step body runs
-     * optimistically — before `run_started`/`step_started` are confirmed — so a
+     * optimistically (before `run_started`/`step_started` are confirmed), so a
      * direct step-body world write (e.g. `setAttributes`, which
      * resolves to a host-side `attr_set` create) can gate on it and never race
      * ahead of the run's creation. `undefined` outside turbo and on the await

package/dist/src/compiled/@workflow/core/step/writable-stream.d.ts

@@ -9,10 +9,10 @@ export interface WorkflowWritableStreamOptions {
     namespace?: string;
 }
 /**
- * Retrieves a writable stream that is associated with the current workflow.
+ * Retrieves the writable stream associated with the current workflow.
  *
- * The writable stream is intended to be used within step functions to write
- * data that can be read outside the workflow by using the readable method of getRun.
+ * Use the writable stream within step functions to write data. Read the data
+ * outside the workflow by using the readable method of `getRun`.
  *
  * @param options - Optional configuration for the writable stream
  * @returns The writable stream associated with the current workflow run

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

@@ -18,7 +18,7 @@ export declare const STREAM_FRAMING_SYMBOL: unique symbol;
  * `start()`) sees both symbols on a writable, it includes the `runId` in
  * the descriptor it emits. The child run's step-side reviver then opens
  * a server writable against the original `(runId, name)` and resolves
- * that run's encryption key directly — so the child's writes land on
+ * that run's encryption key directly, so the child's writes land on
  * the parent's stream as-is, with no client process in the loop. That
  * keeps the forwarding alive for the full lifetime of the child run,
  * not just for the parent step that initiated `start()`.
@@ -39,7 +39,7 @@ export declare const STREAM_SERVER_DEPLOYMENT_ID_SYMBOL: unique symbol;
  * when it creates the stream, so the key travels inside the serialized
  * descriptor; a child on another deployment can then seal frames immediately.
  * Without it the child would have to either fetch the owning run or fetch its
- * symmetric key from the API — the round trip this whole mechanism exists to
+ * symmetric key from the API, the round trip this whole mechanism exists to
  * avoid.
  */
 export declare const STREAM_SERVER_PUBLIC_KEY_SYMBOL: unique symbol;

package/dist/src/compiled/@workflow/core/telemetry/semantic-conventions.d.ts

@@ -3,7 +3,7 @@
  *
  * This module provides standardized telemetry attributes following OpenTelemetry semantic conventions
  * for instrumenting workflow execution, step processing, and related operations. Each exported function
- * creates a properly formatted attribute object that can be used with OpenTelemetry spans.
+ * creates a properly formatted attribute object for use with OpenTelemetry spans.
  *
  * The semantic conventions are organized into several categories:
  * - **Workflow attributes**: Track workflow lifecycle, status, and metadata
@@ -11,7 +11,7 @@
  * - **Queue attributes**: Instrument message queue operations
  * - **Deployment attributes**: Capture deployment environment information
  *
- * All attribute functions are type-safe and leverage existing backend types to ensure
+ * All attribute functions are type-safe and use existing backend types to ensure
  * consistency between telemetry data and actual system state.
  *
  * @example
@@ -64,6 +64,15 @@ export declare const WorkflowEventsCount: (value: number) => {
 export declare const WorkflowExecutionMode: (value: "replay" | "retained") => {
     [k: string]: "replay" | "retained";
 };
+/** Whether the compiled application workflow bundle was cached. */
+export declare const WorkflowBundleCompileCacheHit: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Operation that supplied events to the current replay. */
+export type WorkflowReplayLoadSource = 'run_started' | 'hook_preload' | 'events_list' | 'events_list_incremental';
+export declare const WorkflowReplayLoadSource: (value: WorkflowReplayLoadSource) => {
+    [k: string]: WorkflowReplayLoadSource;
+};
 /**
  * Events the replay walked past that no consumer claimed, still held when the
  * replay stopped.
@@ -159,10 +168,18 @@ export declare const WorkflowHooksCreated: (value: number) => {
 export declare const WorkflowWaitsCreated: (value: number) => {
     [k: string]: number;
 };
+/**
+ * Number of steps this suspension finalized as failed because their
+ * arguments refused to serialize (step_created placeholder + step_failed
+ * carrying the SerializationError; see finalizeUnserializableStep).
+ */
+export declare const WorkflowStepsFailedSerialization: (value: number) => {
+    [k: string]: number;
+};
 /**
  * Number of inline-owned steps this invocation re-executed because it is a
  * redelivery of their owning queue message (crash recovery for inline
- * steps — see the inline step ownership changelog, workflow#2780).
+ * steps; see the inline step ownership changelog, workflow#2780).
  */
 export declare const WorkflowOwnedRecoverySteps: (value: number) => {
     [k: string]: number;
@@ -196,7 +213,7 @@ export declare const WorkflowRouteModuleBodyInitMs: (value: number) => {
     [k: string]: number;
 };
 /**
- * Compute instance handling this route — the synthesized `COMPUTE_INSTANCE_ID`.
+ * Compute instance handling this route: the synthesized `COMPUTE_INSTANCE_ID`.
  * Uses OTEL `faas.instance` (execution-environment id, reused across
  * invocations to the same function):
  * https://opentelemetry.io/docs/specs/semconv/attributes-registry/faas/
@@ -259,11 +276,11 @@ export declare const StepRsfsMs: (value: number) => {
 /**
  * Client-measured synchronous workflow-function replay duration in
  * milliseconds, excluding awaited network I/O, of only the FINAL replay pass
- * within the rsfs window — the pass that reached and scheduled the first
+ * within the rsfs window: the pass that reached and scheduled the first
  * step. Not accumulated across earlier pre-first-step passes (e.g. a
  * workflow-body `setAttributes()` detour replays more than once, and a
  * redelivery omits earlier invocations' work entirely), so this must not be
- * read as "the replay portion of rsfs" — step.rsfs_ms covers the whole
+ * read as "the replay portion of rsfs"; step.rsfs_ms covers the whole
  * window. Only present alongside step.rsfs_ms and only for the run's first
  * step (see runtime/step-latency.ts).
  */
@@ -370,20 +387,50 @@ export declare const HookFound: (value: boolean) => {
  * `hook_received` write failed transiently but the queue dispatch succeeded, so
  * the resume is recovered via the consumer's re-ensure. Corresponds to
  * `ResumedHook.resilientResume === true`.
+ *
+ * No longer emitted: current producers require the durable event write to
+ * succeed. Retained so dashboards and queries built on the attribute keep
+ * resolving while older producers are still deployed.
  */
 export declare const HookResilientResume: (value: boolean) => {
     [k: string]: boolean;
 };
+/**
+ * Producer-side signal (on the `hook.resume` span) that the durable
+ * `hook_received` write COMMITTED. Stamped after the write resolves, so it
+ * distinguishes a committed resume from an attempted one — an entry-time
+ * attribute cannot, because a span that later records an exception may have
+ * failed either before or after the commit.
+ */
+export declare const HookResumeCommitted: (value: boolean) => {
+    [k: string]: boolean;
+};
+/**
+ * Producer-side signal (on the `hook.resume` span) that the workflow wake was
+ * ACCEPTED by the queue, stamped after the publish resolves.
+ *
+ * Together with {@link HookResumeCommitted} this makes stranded resumes
+ * queryable: `resume_committed=true` with `wake_published` absent is a resume
+ * whose durable event exists but whose wake publish failed (the caller was
+ * told, but nothing re-drives it), and `resume_committed=true` +
+ * `wake_published=true` with no subsequent workflow execution for the run is
+ * a wake the queue accepted but never delivered. Both are detection-only
+ * signals — nothing recovers such a run automatically today beyond a later
+ * wake from any other source.
+ */
+export declare const HookWakePublished: (value: boolean) => {
+    [k: string]: boolean;
+};
 /**
  * Consumer-side signal (on the workflow execution span) that this replay
  * materialized the `hook_received` event from the queue message's `hookInput`
- * because the producer's direct write had not landed — the completion of the
- * recovery path {@link HookResilientResume} began.
+ * because no committed event was found, which completes the recovery path
+ * {@link HookResilientResume} began.
  *
- * Legacy / non-atomic re-ensure signal only. Atomic lazy resumes
+ * Legacy / non-atomic re-ensure signal only. Legacy atomic lazy resumes
  * (resumeId + digest) go through the hoisted preload write instead, whose
  * response cannot tell whether the producer or the consumer won the
- * `(runId, resumeId)` claim — so this attribute is deliberately NOT emitted
+ * `(runId, resumeId)` claim, so this attribute is deliberately NOT emitted
  * for them (emitting `true` unconditionally would count every producer-won
  * resume as a recovery). The producer-begin ({@link HookResilientResume}) /
  * consumer-materialized pairing is therefore no longer complete for atomic
@@ -396,10 +443,10 @@ export declare const HookResilientResumeMaterialized: (value: boolean) => {
  * Consumer-side signal (on the workflow execution span) of how a lazy hook
  * resume initialized its replay state:
  *
- * - `hook_received_stream` — the hoisted `hook_received` write returned a
+ * - `hook_received_stream`: the hoisted `hook_received` write returned a
  *   usable replay preload (run + complete event log), so the invocation
  *   skipped both the `run_started` write and the initial `events.list`.
- * - `hook_received_fallback` — the hoisted write succeeded but returned no
+ * - `hook_received_fallback`: the hoisted write succeeded but returned no
  *   usable preload (a CBOR response from an older server, a World that
  *   ignored the opt-in, a bounded `hasMore` page, or a preload that failed
  *   validation); the invocation fell back to the `run_started` setup without
@@ -410,8 +457,8 @@ export declare const HookResilientResumeMaterialized: (value: boolean) => {
  *
  * This is a latency/setup-path signal: it says which requests initialized
  * the invocation, NOT that this consumer created the `hook_received` event
- * (the hoisted write may equally have converged on the producer's — claim
- * ownership is not observable client-side; cf.
+ * (the hoisted write may equally have converged on the producer's, since
+ * claim ownership is not observable client-side; cf.
  * {@link HookResilientResumeMaterialized}).
  */
 export declare const HookResumeSetupSource: (value: string) => {
@@ -429,7 +476,7 @@ export declare const StepResilientDispatchRecovered: (value: number) => {
 /**
  * Consumer-side signal (on the workflow execution span) that this delivery
  * materialized the `step_created` event from the queue message's `stepInput`
- * because the producer's direct write had not landed — the completion of the
+ * because the producer's direct write had not landed, which completes the
  * recovery path {@link StepResilientDispatchRecovered} began.
  */
 export declare const StepResilientDispatchMaterialized: (value: boolean) => {
@@ -480,9 +527,13 @@ export declare const ResumeStepPrepareMs: (value: number) => {
 export declare const ResumeTrigger: (value: "hook") => {
     [k: string]: "hook";
 };
-/** Which `resumeHook()` dispatch path produced this resume. */
-export declare const ResumeStrategy: (value: "parallel" | "sequential") => {
-    [k: string]: "parallel" | "sequential";
+/**
+ * Which `resumeHook()` dispatch path produced this resume. `parallel` only
+ * appears for messages published by an older producer, which wrote
+ * `hook_received` itself in parallel with the publish.
+ */
+export declare const ResumeStrategy: (value: "lazy" | "parallel" | "sequential") => {
+    [k: string]: "lazy" | "parallel" | "sequential";
 };
 /**
  * How the consuming invocation initialized replay state. Distinct from the
@@ -491,8 +542,8 @@ export declare const ResumeStrategy: (value: "parallel" | "sequential") => {
  * hoisted-write outcome; this one is the TTR dimension and shares the metric's
  * three-value vocabulary.
  */
-export declare const ResumeSetupSource: (value: "hook_preload" | "run_started" | "event_load") => {
-    [k: string]: "hook_preload" | "run_started" | "event_load";
+export declare const ResumeSetupSource: (value: "run_started" | "hook_preload" | "event_load") => {
+    [k: string]: "run_started" | "hook_preload" | "event_load";
 };
 /** Whether the measured step ran in the resuming invocation or a queued one. */
 export declare const ResumeStepExecution: (value: "inline" | "dispatched") => {

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

@@ -25,7 +25,7 @@ export declare function getWorkflowTraceMode(): WorkflowTraceMode;
  * Returns whether a serialized trace carrier is usable, i.e. present and
  * non-empty. `serializeTraceCarrier()` returns `{}` when no OTEL SDK is
  * registered or no span is active, and `start()` always attaches the
- * carrier to the first queue message — so an empty carrier must be treated
+ * carrier to the first queue message, so an empty carrier must be treated
  * the same as an absent one wherever the trace-mode logic branches.
  */
 export declare function isUsableTraceCarrier(carrier: Record<string, string> | undefined): carrier is Record<string, string>;
@@ -33,7 +33,7 @@ export declare function isUsableTraceCarrier(carrier: Record<string, string> | u
  * Returns the trace carrier to attach to messages the current invocation
  * enqueues. In `linked` mode the ORIGINAL run-origin carrier is forwarded
  * unchanged (when usable) so every future invocation links back to the same
- * origin; otherwise — `continuous` mode, or no usable incoming carrier —
+ * origin; otherwise (`continuous` mode, or no usable incoming carrier)
  * the current (active) context is serialized, so the trace keeps chaining
  * (continuous) or the first instrumented invocation becomes the de-facto
  * origin (linked).
@@ -45,7 +45,7 @@ export declare function getNextTraceCarrier(traceMode: WorkflowTraceMode, incomi
  *
  * - In `linked` mode the invocation span is a CHILD of the local delivery
  *   (flow-route) context, so the only link is to the run-origin context
- *   from the message's trace carrier — connecting this bounded per-invocation
+ *   from the message's trace carrier, connecting this bounded per-invocation
  *   trace back to where the run was started. The run-origin context is a
  *   link, never a parent, and re-enqueues forward the original carrier
  *   unchanged, so the whole run is never stitched into one giant trace.
@@ -73,6 +73,18 @@ export declare function deserializeTraceCarrier(traceCarrier: Record<string, str
  */
 export declare function withTraceContext<T>(traceCarrier: Record<string, string> | undefined, fn: () => Promise<T>): Promise<T>;
 export declare function trace<T>(spanName: string, ...args: [fn: (span?: Span) => Promise<T>] | [opts: SpanOptions, fn: (span?: Span) => Promise<T>]): Promise<T>;
+/** Starts a child span without installing it as the active context. */
+export declare function startTraceSpan(spanName: string): Promise<{
+    end: () => void;
+    fail: (error: unknown) => void;
+}>;
+/** Bind work to the currently active span even when it starts from a child. */
+export declare function bindActiveTraceContext<Args extends unknown[], Result>(fn: (...args: Args) => Result): Promise<(...args: Args) => Result>;
+/** Keeps a parked workflow's ambient trace context aligned with each resume. */
+export declare function createRefreshableTraceContext(): Promise<{
+    refresh(): void;
+    run: <T>(fn: () => T) => T;
+}>;
 /**
  * Emit a span whose start is back-dated to `startEpochMs` and whose end is now,
  * so its duration reflects an interval only measurable at its end (e.g.

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

@@ -1,2 +1,2 @@
-export declare const version = "5.0.0-beta.43";
+export declare const version = "5.0.0-beta.47";
 //# sourceMappingURL=version.d.ts.map

package/dist/src/compiled/@workflow/core/vm/script-cache.d.ts

@@ -1,27 +1,25 @@
-import { type Context, Script } from 'node:vm';
+import { Script } from 'node:vm';
 /**
- * Returns a compiled `vm.Script` for the given workflow bundle code and
- * filename, compiling and caching it on first use. Subsequent calls with the
- * same `(code, filename)` return the cached `Script`.
+ * Returns a compiled `vm.Script` for the given source code and filename,
+ * compiling and caching it on first use. Subsequent calls with the same
+ * `(code, filename)` return the cached `Script`.
  *
  * The returned `Script` is not yet bound to any context; the caller runs it
  * against a specific VM context via `script.runInContext(context)`. This is
  * equivalent to `vm.runInContext(code, context, { filename })` but skips the
  * recompile.
  */
-export declare function getCachedWorkflowScript(code: string, filename: string): Script;
-/**
- * Runs the cached workflow-bundle `Script` against `context`. Compiles and
- * caches the `Script` on first use for the given `(code, filename)`.
- */
-export declare function runCachedWorkflowScript(code: string, filename: string, context: Context): unknown;
+export declare function getCachedWorkflowScript(code: string, filename: string): {
+    script: Script;
+    cacheHit: boolean;
+};
 /**
  * Clears the compiled-script cache. Intended for tests that want to assert
  * compile-vs-cache behaviour in isolation; not used on the hot path.
  */
 export declare function clearWorkflowScriptCache(): void;
 /**
- * Number of distinct bundle (`code`) versions currently retained. Exposed for
+ * Number of distinct script source strings currently retained. Exposed for
  * tests asserting the LRU bound; not used on the hot path.
  */
 export declare function workflowScriptCacheSize(): number;

package/dist/src/compiled/@workflow/core/workflow/abort-controller.d.ts

@@ -23,7 +23,7 @@ export declare class WorkflowAbortSignal {
     /**
      * @internal Sets aborted state and fires listeners.
      * Called by abort() on first-run, or by the events consumer on replay.
-     * Idempotent — second call is a no-op.
+     * Idempotent: second call is a no-op.
      */
     _setAborted(reason?: unknown): void;
     addEventListener(type: string, listener: () => void): void;

package/dist/src/compiled/@workflow/core/workflow/set-attributes.d.ts

@@ -35,7 +35,7 @@ export interface SetAttributesOptions {
  * framework/library code (telemetry, agent metadata, etc.). User code
  * trying to write a `$`-prefixed key throws `FatalError`. If you are a
  * framework author and need to set a reserved key, pass
- * `{ allowReservedAttributes: true }` as the second argument — see
+ * `{ allowReservedAttributes: true }` as the second argument; see
  * `SetAttributesOptions` for the trade-offs.
  *
  * **WARNING**: Calling e.g.

package/dist/src/compiled/@workflow/core/workflow/world-init-stub.d.ts

@@ -1,7 +1,7 @@
 /**
  * VM/step-bundle stub for `@workflow/core/runtime/world-init`.
  *
- * Resolved via the `workflow` export condition. Empty by design — the host
+ * Resolved via the `workflow` export condition. Empty by design: the host
  * is responsible for loading `world.ts` and populating the globalThis
  * world cache before any VM or step code executes. Including this module
  * (rather than letting the resolver fall through to the host file) keeps

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

@@ -1 +1 @@
-import{Qn as e,Zn as t,br as n,pr as r,vr as i,yr as a}from"../../_chunks/workflow/wait-until-BZHmJCAW.js";import{i as o,u as s}from"../../_chunks/workflow/dist-CqvWKNQv.js";import"../../_chunks/workflow/dist-DpYyXbJv.js";import{i as c}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-DXbpwBdw.js";import{t as m}from"../../_chunks/workflow/sleep-CxFsdxB_.js";import{t as h}from"../../_chunks/workflow/run-cIeex2KF.js";e(t,h);function g(e){let t=globalThis[i];return t||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(e)}function _(e){let{respondWith:t,token:n,...r}=e??{};if(n!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always generated for you. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let i;t!==void 0&&(i={respondWith:t});let a=g({...r,metadata:i,isWebhook:!0}),{url:o}=l();return a.url=c(o,{type:`webhook`,token:a.token}),a}function v(){function e(t,n){d(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}async function y(e,t={}){let r=p(e,t);if(r.length===0)return;let i=t.allowReservedAttributes===!0,a=globalThis[n];if(!a)throw new o("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:t}=e,n=globalThis[a](t);return Object.create(globalThis.WritableStream.prototype,{[r]:{value:n,writable:!1}})}function x(){f(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){d(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{o as FatalError,s as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,l as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};
+import{Cr as e,Sr as t,_r as n,nr as r,tr as i,wr as a}from"../../_chunks/workflow/wait-until-BtySPYD0.js";import{i as o,u as s}from"../../_chunks/workflow/dist-DjojkP5e.js";import{i as c}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-BwAadFfB.js";import{t as m}from"../../_chunks/workflow/sleep-3_A5uOp-.js";import{t as h}from"../../_chunks/workflow/run-DzyAoGh4.js";r(i,h);function g(e){let n=globalThis[t];return n||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),n(e)}function _(e){let{respondWith:t,token:n,...r}=e??{};if(n!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always generated for you. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let i;t!==void 0&&(i={respondWith:t});let a=g({...r,metadata:i,isWebhook:!0}),{url:o}=l();return a.url=c(o,{type:`webhook`,token:a.token}),a}function v(){function e(t,n){d(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}async function y(e,t={}){let n=p(e,t);if(n.length===0)return;let r=t.allowReservedAttributes===!0,i=globalThis[a];if(!i)throw new o("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await i(n,r?{allowReservedAttributes:!0}:{})}function b(t={}){let{namespace:r}=t,i=globalThis[e](r);return Object.create(globalThis.WritableStream.prototype,{[n]:{value:i,writable:!1}})}function x(){f(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){d(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{o as FatalError,s as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,l as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};