eve 0.13.3 → 0.13.4

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

@@ -1,6 +1,11 @@
 /**
  * Remaps an error stack trace using inline source maps to show original source locations.
  *
+ * Degrades gracefully when the bundle has no inline source map (e.g. production
+ * builds, where maps are off by default): the original stack is returned
+ * unchanged. A cheap `filename` presence check skips all work when no frame
+ * references the workflow file, and parsed source maps are memoized per bundle.
+ *
  * @param stack - The error stack trace to remap
  * @param filename - The workflow filename to match in stack frames
  * @param workflowCode - The workflow bundle code containing inline source maps

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

@@ -21,6 +21,33 @@ export type StepContext = {
     /** Deployment that owns the current workflow run, used for forwarded streams. */
     workflowDeploymentId?: string;
     ops: Promise<void>[];
+    /**
+     * Operations that MUST be durably committed before the step's
+     * `step_completed`/`step_failed` event is written, because the workflow
+     * continuation triggered by that event depends on them.
+     *
+     * 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
+     * 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
+     * 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
+     * `reviveAbortController` in serialization.ts). The await sites also
+     * defensively `.catch()` so ordering is all this bucket can ever enforce.
+     *
+     * Required (not optional) so a new step-context construction site that
+     * forgets to wire it fails at compile time, rather than silently regressing
+     * the ordering guarantee back to background-flush behavior.
+     */
+    preCompletionOps: Promise<void>[];
     closureVars?: Record<string, any>;
     encryptionKey?: CryptoKey;
     writables?: Map<string, CachedWritable>;

package/dist/src/compiled/@workflow/core/step-hydration-cache.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Per-run memoization cache for hydrated step return values.
+ *
+ * ## Why
+ *
+ * The inline replay loop (`runtime.ts`) re-runs the workflow body from the top
+ * on every iteration, re-consuming the full event log each time. For every
+ * already-completed step, the step consumer (`step.ts`) re-runs
+ * `hydrateStepReturnValue` — which AES-GCM-decrypts and devalue-parses the
+ * serialized result — even though that exact result was already hydrated on
+ * every prior replay. For a sequential workflow of N steps, replay K hydrates
+ * K results, so the total work across a single invocation is O(N²)
+ * decrypt+parse operations.
+ *
+ * This cache makes a completed step's hydrated result available in O(1) on
+ * subsequent replays within the SAME invocation, turning the aggregate cost
+ * into O(N).
+ *
+ * ## Scope / lifetime
+ *
+ * The cache is owned by the inline loop in `runtime.ts` (one per workflow run
+ * invocation) and passed into `runWorkflow` so it survives across the loop's
+ * iterations but never leaks across unrelated runs or process-level
+ * invocations. A fresh `runWorkflow` / `WorkflowOrchestratorContext` is created
+ * each iteration, so the cache must live OUTSIDE the per-iteration context.
+ *
+ * ## Keying
+ *
+ * Entries are keyed by the persisted event's `eventId` — a stable,
+ * world-assigned identifier for the `step_completed` event whose serialized
+ * `result` is being hydrated. The same event (same `eventId`) carries the same
+ * immutable serialized bytes across every replay, so a hit is guaranteed to
+ * correspond to the identical input.
+ *
+ * ## Identity safety (why primitives only)
+ *
+ * `hydrateStepReturnValue` (devalue.parse) produces a FRESH object graph on
+ * every call, and each replay iteration runs in a FRESH workflow VM. The
+ * current (uncached) behavior therefore hands the workflow a brand-new value
+ * on every replay. If we cached and returned the SAME object reference across
+ * replays, workflow code that mutates a step result (`const r = await step();
+ * r.count++`) would observe the mutation from a previous replay on the next
+ * replay — a non-deterministic divergence. Structured-cloning on each hit is
+ * both lossy (revivers reconstruct stream handles, step-function proxies,
+ * Request/Response, and AbortController/AbortSignal class instances that don't
+ * survive a structured clone) and still O(size).
+ *
+ * So we only cache values for which returning the same reference on every
+ * replay is provably indistinguishable from re-hydrating: JavaScript
+ * primitives (string, number, boolean, bigint, symbol, null, undefined).
+ * Primitives are immutable and compared by value, so sharing the reference is
+ * byte-for-byte equivalent to re-parsing. Any non-primitive result falls
+ * through to a full re-hydrate every replay, preserving current behavior
+ * exactly. This trades some of the optimization away in the object-returning
+ * case in exchange for keeping deterministic replay airtight.
+ *
+ * ## Memory characteristic
+ *
+ * Cached entries hold the decrypted/devalue-parsed *plaintext* of a step
+ * result, which is retained for the rest of the invocation on top of the
+ * serialized bytes already held in `cachedEvents`. So the residual cost is:
+ *
+ * - **Scoped to one workflow-run invocation.** A fresh `Map` is created per
+ *   invocation (in `runtime.ts`) and is unreachable / GC'd when the invocation
+ *   returns. Nothing accumulates across runs or across process-level
+ *   invocations.
+ * - **Bounded by the number of primitive-returning completed steps in that
+ *   run** — at most one small entry per such step.
+ * - **Primitives only, and additionally byte-bounded.** Most primitives
+ *   (numbers, booleans, null/undefined, symbols, short ids/strings) are tiny
+ *   and fixed-size. The only primitive that can be large is a string (or a
+ *   pathologically long bigint), so to keep the doubled-residency worst case
+ *   bounded we *do not* memoize string/bigint results whose character length
+ *   exceeds {@link MAX_MEMOIZED_PRIMITIVE_LENGTH}. A large string is cheap to
+ *   re-hydrate relative to its footprint, so letting it fall through to the
+ *   existing per-replay re-hydrate path costs little and caps peak retained
+ *   memory.
+ *
+ * (This is a much weaker concern than a *process-wide* cache: the dominant
+ * residency — the full event log in `cachedEvents` — already exists for the
+ * same lifetime, and everything here is freed together with it when the
+ * invocation ends.)
+ */
+/**
+ * Upper bound, in characters, on a string/bigint primitive that may be
+ * memoized. Beyond this, the value falls through to a fresh re-hydrate on every
+ * replay so the cache never holds a large plaintext payload for the lifetime of
+ * the invocation. 4 KiB comfortably covers ids, counts, flags, and typical
+ * short string results while excluding the large-payload case the bound exists
+ * to guard. Other primitive types (number, boolean, symbol, null, undefined)
+ * are inherently small and are never length-checked.
+ */
+export declare const MAX_MEMOIZED_PRIMITIVE_LENGTH = 4096;
+/**
+ * Returns true for values that are safe to memoize and return by reference
+ * across replays: JS primitives. Objects and functions are excluded because
+ * sharing a mutable reference across replays could change observable behavior.
+ *
+ * Strings and bigints are additionally bounded by length: a value longer than
+ * {@link MAX_MEMOIZED_PRIMITIVE_LENGTH} characters is treated as non-memoizable
+ * so the cache never retains a large plaintext payload for the whole invocation
+ * (see the module-level "Memory characteristic" docs). It re-hydrates fresh on
+ * every replay instead — cheap relative to its footprint.
+ *
+ * Note: `typeof null === 'object'`, so it is handled explicitly. `undefined`,
+ * `string`, `number`, `boolean`, `bigint`, and `symbol` are all primitives.
+ */
+export declare function isMemoizablePrimitive(value: unknown): boolean;
+/**
+ * Cache of hydrated step return values for a single workflow run invocation.
+ *
+ * Keyed by `step_completed` event id; the value is the already-hydrated
+ * primitive result. Only successful, primitive hydrations are stored (see
+ * {@link getOrHydrateStepReturnValue}), so a non-`undefined` `has(eventId)`
+ * always means "this step completed with a memoizable primitive value".
+ */
+export type StepHydrationCache = Map<string, unknown>;
+/**
+ * Create an empty per-invocation step hydration cache.
+ */
+export declare function createStepHydrationCache(): StepHydrationCache;
+/**
+ * Return the hydrated step result for `eventId`, using `cache` as a per-run
+ * memo. On a hit, the cached primitive is returned without re-running the
+ * expensive decrypt + devalue-parse. On a miss, `hydrate()` runs and its
+ * result is memoized only when it is a small primitive (see the module docs for
+ * the identity-safety rationale and the length bound on string/bigint results).
+ *
+ * This always returns a `Promise` and `await`s `hydrate()` even on the miss
+ * path, so the caller's `await` inside its serial `promiseQueue` slot keeps the
+ * same scheduling on both hit and miss — a cache hit resolves through the exact
+ * same promise-chain position a re-hydrate would have, preserving the
+ * deterministic delivery order that `pendingDeliveries`, the delivery barriers,
+ * and `Promise.race`/`Promise.all` replay all depend on.
+ *
+ * `has(eventId)` is used rather than `get(eventId) !== undefined` so that a
+ * legitimately memoized `undefined` step result still registers as a hit.
+ *
+ * When `cache` or `eventId` is absent (lightweight test harnesses, or a context
+ * that predates this plumbing), this degrades to calling `hydrate()` directly
+ * with no memoization — identical to the previous behavior.
+ *
+ * Errors are intentionally never cached: a rejected hydrate propagates to the
+ * caller (which rejects the step promise) and the next replay re-attempts it,
+ * matching the uncached behavior and avoiding a parked rejected promise.
+ */
+export declare function getOrHydrateStepReturnValue(cache: StepHydrationCache | undefined, eventId: string | undefined, hydrate: () => Promise<unknown>): Promise<unknown>;
+//# sourceMappingURL=step-hydration-cache.d.ts.map

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

@@ -76,6 +76,10 @@ export declare const WorkflowTracePropagated: (value: boolean) => {
 export declare const WorkflowTraceMode: (value: "linked" | "continuous") => {
     [k: string]: "linked" | "continuous";
 };
+/** Whether this workflow invocation is using the turbo first-delivery path */
+export declare const WorkflowTurbo: (value: boolean) => {
+    [k: string]: boolean;
+};
 /** Name of the error that caused workflow failure */
 export declare const WorkflowErrorName: (value: string) => {
     [k: string]: string;
@@ -100,6 +104,26 @@ export declare const WorkflowHooksCreated: (value: number) => {
 export declare const WorkflowWaitsCreated: (value: number) => {
     [k: string]: number;
 };
+/** The workflow runtime route being handled */
+export declare const WorkflowRouteType: (value: "step" | "flow") => {
+    [k: string]: "step" | "flow";
+};
+/** Whether this route invocation reused an already-created request handler */
+export declare const WorkflowRouteHandlerCached: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Number of times this in-memory route handler has been invoked */
+export declare const WorkflowRouteInvocationCount: (value: number) => {
+    [k: string]: number;
+};
+/** Time since this route entrypoint was constructed, in milliseconds */
+export declare const WorkflowRouteEntrypointAgeMs: (value: number) => {
+    [k: string]: number;
+};
+/** Time spent evaluating the generated route module body before creating the entrypoint */
+export declare const WorkflowRouteModuleBodyInitMs: (value: number) => {
+    [k: string]: number;
+};
 /** Name of the step function being executed */
 export declare const StepName: (value: string) => {
     [k: string]: string;
@@ -220,6 +244,10 @@ export declare const WorkflowSuspensionWaitCount: (value: number) => {
 export declare const HttpRequestMethod: (value: string) => {
     [k: string]: string;
 };
+/** Route pattern for the request (standard OTEL: http.route) */
+export declare const HttpRoute: (value: string) => {
+    [k: string]: string;
+};
 /** Full URL of the request (standard OTEL: url.full) */
 export declare const UrlFull: (value: string) => {
     [k: string]: string;

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

@@ -42,12 +42,15 @@ export declare function getNextTraceCarrier(traceMode: WorkflowTraceMode, incomi
  * Builds the span links for a queue-delivered invocation span
  * (`workflow.execute` / `step.execute`):
  *
- * - a link to the incoming delivery context (the active span extracted from
- *   the queue delivery request, i.e. the enqueue site once the queue
- *   propagates producer context), and
- * - in `linked` mode, a link to the run-origin context from the message's
- *   trace carrier (skipped when absent, empty, invalid, or identical to the
- *   delivery context).
+ * - 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
+ *   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.
+ *   The link is skipped when the carrier is absent, empty, or invalid.
+ * - In `continuous` mode the run-origin context is restored as the parent
+ *   instead, and the link points at the incoming delivery context.
  */
 export declare function buildInvocationSpanLinks(traceMode: WorkflowTraceMode, incomingCarrier: Record<string, string> | undefined): Promise<api.Link[] | undefined>;
 /**

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

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

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

@@ -0,0 +1,28 @@
+import { type Context, 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`.
+ *
+ * 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;
+/**
+ * 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
+ * tests asserting the LRU bound; not used on the hot path.
+ */
+export declare function workflowScriptCacheSize(): number;
+//# sourceMappingURL=script-cache.d.ts.map

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

@@ -1 +1 @@
-import{c as e,i as t}from"../../_chunks/workflow/dist-Dxrjttr2.js";import{$n as n,Kt as r,Zt as i,er as a,ir as o,nn as s,nr as c,qt as l,rn as u,t as d,tn as f}from"../../_chunks/workflow/attribute-changes-Bi5DLT8S.js";import{t as p}from"../../_chunks/workflow/sleep-DPjVkRY-.js";import{t as m}from"../../_chunks/workflow/run-XM8dTRAo.js";async function h(e,n={}){let r=d(e,n);if(r.length===0)return;let i=n.allowReservedAttributes===!0,a=globalThis[u];if(!a)throw new t("experimental_setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}l(r,m);function g(e){let t=globalThis[f];return t||a(`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 randomly generated. 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:s}=o();return a.url=`${s}/.well-known/workflow/v1/webhook/${encodeURIComponent(a.token)}`,a}function v(){function e(t,n){c(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}function y(e={}){let{namespace:t}=e,n=globalThis[s](t);return Object.create(globalThis.WritableStream.prototype,{[i]:{value:n,writable:!1}})}function b(){n(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,b)}function x(){c(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,x)}export{t as FatalError,e as RetryableError,g as createHook,_ as createWebhook,v as defineHook,h as experimental_setAttributes,b as getStepMetadata,o as getWorkflowMetadata,y as getWritable,x as resumeHook,p as sleep};
+import{c as e,i as t}from"../../_chunks/workflow/dist-Dxrjttr2.js";import{dn as n,fn as r,fr as i,lr as a,mr as o,nn as s,on as c,t as l,tn as u,un as d,ur as f}from"../../_chunks/workflow/attribute-changes-DUxG-Gic.js";import{t as p}from"../../_chunks/workflow/sleep-Dxuzj5to.js";import{t as m}from"../../_chunks/workflow/run-CVlF84yI.js";async function h(e,n={}){let i=l(e,n);if(i.length===0)return;let a=n.allowReservedAttributes===!0,o=globalThis[r];if(!o)throw new t("experimental_setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await o(i,a?{allowReservedAttributes:!0}:{})}s(u,m);function g(e){let t=globalThis[d];return t||f(`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 randomly generated. 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:s}=o();return a.url=`${s}/.well-known/workflow/v1/webhook/${encodeURIComponent(a.token)}`,a}function v(){function e(t,n){i(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}function y(e={}){let{namespace:t}=e,r=globalThis[n](t);return Object.create(globalThis.WritableStream.prototype,{[c]:{value:r,writable:!1}})}function b(){a(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,b)}function x(){i(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,x)}export{t as FatalError,e as RetryableError,g as createHook,_ as createWebhook,v as defineHook,h as experimental_setAttributes,b as getStepMetadata,o as getWorkflowMetadata,y as getWritable,x as resumeHook,p as sleep};

package/dist/src/compiled/@workflow/world/events.d.ts

@@ -164,6 +164,7 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     correlationId: z.ZodString;
     eventData: z.ZodObject<{
         stepName: z.ZodString;
+        workflowName: z.ZodOptional<z.ZodString>;
         input: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
@@ -172,6 +173,7 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     correlationId: z.ZodString;
     eventData: z.ZodObject<{
         stepName: z.ZodOptional<z.ZodString>;
+        workflowName: z.ZodOptional<z.ZodString>;
         result: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
@@ -198,6 +200,8 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     eventData: z.ZodOptional<z.ZodObject<{
         stepName: z.ZodOptional<z.ZodString>;
         attempt: z.ZodOptional<z.ZodNumber>;
+        workflowName: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
@@ -306,6 +310,7 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     correlationId: z.ZodString;
     eventData: z.ZodObject<{
         stepName: z.ZodString;
+        workflowName: z.ZodOptional<z.ZodString>;
         input: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
@@ -314,6 +319,7 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     correlationId: z.ZodString;
     eventData: z.ZodObject<{
         stepName: z.ZodOptional<z.ZodString>;
+        workflowName: z.ZodOptional<z.ZodString>;
         result: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
@@ -340,6 +346,8 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     eventData: z.ZodOptional<z.ZodObject<{
         stepName: z.ZodOptional<z.ZodString>;
         attempt: z.ZodOptional<z.ZodNumber>;
+        workflowName: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
@@ -392,6 +400,7 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     runId: z.ZodString;
     eventId: z.ZodString;
     createdAt: z.ZodCoercedDate<unknown>;
+    occurredAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     specVersion: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>>;
 export type Event = z.infer<typeof EventSchema>;
@@ -417,6 +426,55 @@ export interface CreateEventParams {
     resolveData?: ResolveData;
     /** Request ID (x-vercel-id when on Vercel) for correlating request logs with workflow events. */
     requestId?: string;
+    /**
+     * Timestamp for when the event occurred on the client side. Worlds that
+     * support this can persist it separately from `createdAt`, which represents
+     * when the backing service accepted or stored the event.
+     */
+    occurredAt?: Date;
+    /**
+     * Inline-delta optimization (opt-in). When set, the World MAY return,
+     * on the resulting {@link EventResult}, the first page of events written
+     * strictly after this cursor (via `events`/`cursor`/`hasMore`) — the
+     * same page an `events.list({ cursor: sinceCursor, sortOrder: 'asc' })`
+     * call would return immediately after this write. The inline runtime
+     * loop uses this to skip a redundant `events.list` round-trip between
+     * sequential steps: instead of re-reading its own just-written events
+     * (and any events interleaved in-band, such as `hook_received`), it
+     * consumes the authoritative delta the write already had to compute.
+     *
+     * The cursor MUST share `events.list` semantics: the returned `events`
+     * are everything sorted strictly after `sinceCursor`, `cursor` is the
+     * position past the last returned event, and `hasMore` indicates a
+     * further page exists. A World MAY return a single page and set
+     * `hasMore: true` rather than paginating to exhaustion — the runtime
+     * does not consume a truncated delta, it falls back to a full
+     * incremental fetch whenever `hasMore` is true. (For that reason a step
+     * body emitting more in-band events than one page silently bypasses this
+     * fast path, which is correct but forgoes the saved round-trip.)
+     * Returning these fields at all is OPTIONAL — a World that omits them is
+     * fully supported; the runtime falls back to `events.list`. This
+     * preserves the same divergence guarantees as the fetch path because the
+     * delta is computed atomically against the same log the fetch would read.
+     */
+    sinceCursor?: string;
+    /**
+     * Run-started preload opt-out (advisory). On a `run_started` write a World
+     * MAY preload the run's event log onto the {@link EventResult}
+     * (`events`/`cursor`/`hasMore`) so the runtime can skip its initial
+     * `events.list`. The turbo first invocation backgrounds `run_started`
+     * purely as a write barrier and never reads that preload, so it sets this
+     * to tell the World to skip the wasted list+resolve — trimming the
+     * `run_started` round-trip that the chained first `step_started` waits on.
+     * A World that ignores it (or doesn't preload) remains fully correct: the
+     * runtime falls back to `events.list` whenever it actually needs the log.
+     * Only honored for `run_started`; ignored for other event types.
+     *
+     * Named to match the World boundary, the wire frame meta, and the backend
+     * option end-to-end (cf. {@link sinceCursor}) so the single name greps
+     * across the SDK and the backend.
+     */
+    skipPreload?: boolean;
 }
 /**
  * Result of creating an event. Includes the created event and optionally
@@ -436,15 +494,32 @@ export interface EventResult {
     /** The wait entity (for wait_created/wait_completed events) */
     wait?: import('./waits.js').Wait;
     /**
-     * All events up to this point, with data resolved. When populated
-     * on a run_started response, the runtime uses these to skip the
-     * initial events.list call and reduce TTFB.
+     * Events with data resolved. Two producers populate this:
+     *
+     * - On a `run_started` response: all events up to this point, so the
+     *   runtime can skip the initial `events.list` call and reduce TTFB.
+     * - On a step-terminal write (`step_completed` / `step_failed`) when
+     *   the caller passed {@link CreateEventParams.sinceCursor}: the delta
+     *   of events written strictly after that cursor, so the inline loop
+     *   can skip the per-step incremental `events.list` round-trip.
      */
     events?: Event[];
     /** Pagination cursor for `events`, matching events.list semantics. */
     cursor?: string | null;
     /** Whether additional event pages are available for `events`. */
     hasMore?: boolean;
+    /**
+     * Lazy step start: set to `true` only when a `step_started` event with
+     * step-creation data atomically *created* the step on this call (the
+     * caller won the create-claim), as opposed to transitioning a step that
+     * already existed. The owned-inline runtime path uses this as the
+     * exactly-once ownership signal — it runs the step body inline only when
+     * it created the step, so a concurrent handler that lost the create race
+     * (and gets `EntityConflictError`/skipped) never double-executes. Absent
+     * (undefined) on the legacy path and from older servers/worlds, which is
+     * the safe default (treated as "not the lazy creator").
+     */
+    stepCreated?: boolean;
 }
 export interface GetEventParams {
     resolveData?: ResolveData;

package/dist/src/compiled/@workflow/world/index.d.ts

@@ -16,7 +16,7 @@ export type * from './shared.js';
 export type { GetChunksOptions, StreamChunk, StreamChunksResponse, StreamInfoResponse, } from './shared.js';
 export { PaginatedResponseSchema, StructuredErrorSchema, } from './shared.js';
 export type { SpecVersion } from './spec-version.js';
-export { isLegacySpecVersion, requiresNewerWorld, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, SPEC_VERSION_SUPPORTS_ATTRIBUTES, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_EVENT_SOURCING, } from './spec-version.js';
+export { isLegacySpecVersion, requiresNewerWorld, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, SPEC_VERSION_SUPPORTS_ATTRIBUTES, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_COMPRESSION, SPEC_VERSION_SUPPORTS_EVENT_SOURCING, } from './spec-version.js';
 export type * from './steps.js';
 export { StepSchema, StepStatusSchema } from './steps.js';
 export { DEFAULT_TIMESTAMP_THRESHOLD_FUTURE_MS, DEFAULT_TIMESTAMP_THRESHOLD_MS, DEFAULT_TIMESTAMP_THRESHOLD_PAST_MS, ulidToDate, validateUlidTimestamp, } from './ulid.js';

package/dist/src/compiled/@workflow/world/spec-version.d.ts

@@ -20,7 +20,17 @@ export declare const SPEC_VERSION_LEGACY: SpecVersion;
 export declare const SPEC_VERSION_SUPPORTS_EVENT_SOURCING: SpecVersion;
 export declare const SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT: SpecVersion;
 export declare const SPEC_VERSION_SUPPORTS_ATTRIBUTES: SpecVersion;
-/** Current spec version (event-sourced architecture with native attributes). */
+/**
+ * Runs at this spec version or later may contain gzip-compressed payloads
+ * ('gzip' format prefix). Readers older than this version cannot decode
+ * such payloads and reject the run via `requiresNewerWorld()` instead of
+ * failing on individual payloads.
+ */
+export declare const SPEC_VERSION_SUPPORTS_COMPRESSION: SpecVersion;
+/**
+ * Current spec version (event-sourced architecture with native attributes
+ * and compressed payloads).
+ */
 export declare const SPEC_VERSION_CURRENT: SpecVersion;
 /**
  * Check if a spec version is legacy (<= SPEC_VERSION_LEGACY or undefined).