experimental-ash 0.22.2 → 0.24.0

package/dist/src/compiled/@workflow/core/describe-error.d.ts

@@ -0,0 +1,70 @@
+import { type RunErrorCode } from '#compiled/@workflow/errors/index.js';
+/**
+ * Attribution of a workflow/step failure for presentation.
+ *
+ * - `user`: the error came from customer code (a step or workflow function
+ *   threw, or a value they passed across a boundary wasn't serializable).
+ * - `sdk`: the SDK produced the error itself — an internal invariant broke,
+ *   or a runtime guard rejected the call. These should be rare; when they
+ *   happen we want to frame the terminal output as "this is us, not you."
+ */
+export type ErrorAttribution = 'user' | 'sdk';
+export interface ErrorDescription {
+    attribution: ErrorAttribution;
+    errorCode: RunErrorCode;
+    /**
+     * Short, class-aware hint to help a user understand what the error means.
+     * Only set for well-known SDK error classes (SerializationError,
+     * WorkflowRuntimeError, context-violation errors); `undefined` for plain
+     * user errors, where the stack is already the most useful thing to show.
+     */
+    hint?: string;
+}
+/**
+ * Error signal fields carried on persisted failure events (e.g.
+ * `run_failed` / `step_failed`). The shape is intentionally loose:
+ *
+ * - `errorCode` is typed as `string` rather than `RunErrorCode` because
+ *   the value comes from stored JSON/CBOR and may predate the current
+ *   enum — callers should not narrow on it blindly. Values that don't
+ *   match a known `RUN_ERROR_CODES` entry fall through to USER_ERROR.
+ * - `errorName` is the thrown `Error#name`. It is not universally
+ *   persisted today; callers that have access to it (either via an
+ *   in-memory throw or a richer payload) can pass it in to sharpen
+ *   the attribution and hint. When absent, `describeRunError` still
+ *   returns a sensible attribution from `errorCode` alone.
+ */
+export interface PersistedErrorSignal {
+    errorCode?: string;
+    errorName?: string;
+}
+/**
+ * Data-driven variant of {@link describeError} that works from persisted
+ * event fields instead of a live `Error` instance. Intended for CLI/web
+ * renderers that read failure events and no longer have the original
+ * thrown object.
+ */
+export declare function describeRunError(signal: PersistedErrorSignal): ErrorDescription;
+/**
+ * Describe an error for user-facing presentation. Purely informational —
+ * does not change any persisted event data or error classification used by
+ * the runtime.
+ *
+ * The attribution here is more nuanced than `classifyRunError`:
+ *
+ * - `SerializationError` is technically raised by the SDK, but it almost
+ *   always points at something the caller did (passed a non-serializable
+ *   value, didn't register a class). We attribute it to the user.
+ * - Context-violation errors (`NotInWorkflowContextError`, etc.) likewise
+ *   describe a user mistake.
+ * - `WorkflowRuntimeError` (and subclasses like `StepNotRegisteredError`)
+ *   indicates an internal SDK invariant broke — surface that as `sdk`.
+ *
+ * @param err The error value thrown by the workflow / step.
+ * @param errorCode Optional precomputed error code. Callers that already
+ *   know the code (e.g. `REPLAY_TIMEOUT` or `MAX_DELIVERIES_EXCEEDED`, which
+ *   `classifyRunError` can't derive from the error alone) should pass it so
+ *   the attribution and hint reflect the actual failure category.
+ */
+export declare function describeError(err: unknown, errorCode?: RunErrorCode): ErrorDescription;
+//# sourceMappingURL=describe-error.d.ts.map

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

@@ -0,0 +1,51 @@
+/**
+ * Browser-compatible AES-256-GCM encryption module.
+ *
+ * Uses the Web Crypto API (`globalThis.crypto.subtle`) which works in
+ * both modern browsers and Node.js 20+. This module is intentionally
+ * free of Node.js-specific imports so it can be bundled for the browser.
+ *
+ * The World interface (`getEncryptionKeyForRun`) returns a raw 32-byte
+ * AES-256 key. Callers should use `importKey()` once to convert it to a
+ * `CryptoKey`, then pass that to `encrypt()`/`decrypt()` for all
+ * operations within the same run. This avoids repeated `importKey()`
+ * calls on every encrypt/decrypt invocation.
+ *
+ * Wire format: `[nonce (12 bytes)][ciphertext + auth tag]`
+ * The `encr` format prefix is NOT part of this module — it's added/stripped
+ * by the serialization layer in `maybeEncrypt`/`maybeDecrypt`.
+ */
+export type CryptoKey = import('node:crypto').webcrypto.CryptoKey;
+/**
+ * Import a raw AES-256 key as a `CryptoKey` for use with `encrypt()`/`decrypt()`.
+ *
+ * Callers should call this once per run (after `getEncryptionKeyForRun()`)
+ * and pass the resulting `CryptoKey` to all subsequent encrypt/decrypt calls.
+ *
+ * Pass `usages: ['encrypt']` (or `['decrypt']`) for cross-run scenarios
+ * where the caller should not be able to perform the inverse operation
+ * with the key — for example a child workflow writing into a parent
+ * run's forwarded WritableStream only needs to encrypt, never decrypt.
+ *
+ * @param raw - Raw 32-byte AES-256 key (from World.getEncryptionKeyForRun)
+ * @param usages - Key usages. Defaults to `['encrypt', 'decrypt']`.
+ * @returns CryptoKey ready for AES-GCM operations
+ */
+export declare function importKey(raw: Uint8Array, usages?: ReadonlyArray<'encrypt' | 'decrypt'>): Promise<import("crypto").webcrypto.CryptoKey>;
+/**
+ * Encrypt data using AES-256-GCM.
+ *
+ * @param key - CryptoKey from `importKey()`
+ * @param data - Plaintext to encrypt
+ * @returns `[nonce (12 bytes)][ciphertext + GCM auth tag]`
+ */
+export declare function encrypt(key: CryptoKey, data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decrypt data using AES-256-GCM.
+ *
+ * @param key - CryptoKey from `importKey()`
+ * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`
+ * @returns Decrypted plaintext
+ */
+export declare function decrypt(key: CryptoKey, data: Uint8Array): Promise<Uint8Array>;
+//# sourceMappingURL=encryption.d.ts.map

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

@@ -0,0 +1,64 @@
+import type { Event } from './_workflow-world.js';
+/**
+ * Delay before firing the deferred unconsumed-event check after the promise
+ * queue has drained. Must be long enough for cross-VM microtask chains to
+ * propagate (resolve in host → workflow code in VM → subscribe call back
+ * in host). Any subscribe() arriving during this window cancels the check.
+ */
+export declare const DEFERRED_CHECK_DELAY_MS = 100;
+export declare enum EventConsumerResult {
+    /**
+     * Callback consumed the event, but should not be removed from the callbacks list
+     */
+    Consumed = 0,
+    /**
+     * Callback did not consume the event, so it should be passed to the next callback
+     */
+    NotConsumed = 1,
+    /**
+     * Callback consumed the event, and should be removed from the callbacks list
+     */
+    Finished = 2
+}
+type EventConsumerCallback = (event: Event | null) => EventConsumerResult;
+export interface EventsConsumerOptions {
+    /**
+     * Callback invoked when a non-null event cannot be consumed by any registered
+     * callback, indicating an orphaned or invalid event in the event log. The
+     * check is deferred until after the promise queue has drained, ensuring that
+     * any pending async work (e.g., deserialization/decryption) completes and
+     * downstream subscribe() calls have a chance to cancel the check first.
+     */
+    onUnconsumedEvent: (event: Event) => void;
+    /**
+     * Returns the current promise queue. The unconsumed event check is chained
+     * onto this queue so it only fires after all pending async work (e.g.,
+     * deserialization) has completed. This prevents false positives when async
+     * deserialization delays the resolve() that triggers the next subscribe().
+     */
+    getPromiseQueue: () => Promise<void>;
+}
+export declare class EventsConsumer {
+    eventIndex: number;
+    readonly events: Event[];
+    readonly callbacks: EventConsumerCallback[];
+    private onUnconsumedEvent;
+    private getPromiseQueue;
+    private pendingUnconsumedCheck;
+    private pendingUnconsumedTimeout;
+    private unconsumedCheckVersion;
+    constructor(events: Event[], options: EventsConsumerOptions);
+    /**
+     * Registers a callback function to be called after an event has been consumed
+     * by a different callback. The callback can return:
+     *  - `EventConsumerResult.Consumed` the event is considered consumed and will not be passed to any other callback, but the callback will remain in the callbacks list
+     *  - `EventConsumerResult.NotConsumed` the event is passed to the next callback
+     *  - `EventConsumerResult.Finished` the event is considered consumed and the callback is removed from the callbacks list
+     *
+     * @param fn - The callback function to register.
+     */
+    subscribe(fn: EventConsumerCallback): void;
+    private consume;
+}
+export {};
+//# sourceMappingURL=events-consumer.d.ts.map

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

@@ -0,0 +1,82 @@
+import { type PromiseWithResolvers } from './_workflow-utils.js';
+/**
+ * Polling interval (in ms) for lock release detection.
+ *
+ * The Web Streams API does not expose an event for "lock released but stream
+ * still open"; we can only distinguish that state by periodically attempting
+ * to acquire a reader/writer. For that reason we use polling instead of a
+ * fully event-driven approach here.
+ *
+ * 10ms is chosen so the polling tick almost never sits on the critical path:
+ * the V2 step-executor's `opsSettled` race waits for this state to resolve
+ * after each step body returns, so a coarser interval (the previous 100ms)
+ * adds visible per-step latency to streaming workflows. With a uniformly
+ * distributed offset between step return and the next tick, the expected
+ * wait is half the interval — so 10ms means ~5ms average wait per step
+ * instead of ~50ms. The per-tick work is `writable.locked` plus a
+ * `getWriter()`/`releaseLock()` probe, both microsecond-scale; 10× more
+ * ticks during a stream's lifetime is not measurable in practice.
+ */
+export declare const LOCK_POLL_INTERVAL_MS = 10;
+/**
+ * State tracker for flushable stream operations.
+ * Resolves when either:
+ * 1. Stream completes (close/error), OR
+ * 2. Lock is released AND all pending operations are flushed
+ *
+ * Note: `doneResolved` and `streamEnded` are separate:
+ * - `doneResolved`: The `done` promise has been resolved (step can complete)
+ * - `streamEnded`: The underlying stream has actually closed/errored
+ *
+ * Once `doneResolved` is set to true, the `done` promise will not resolve
+ * again. Re-acquiring locks after release is not supported as a way to
+ * trigger additional completion signaling.
+ */
+export interface FlushableStreamState extends PromiseWithResolvers<void> {
+    /** Number of write operations currently in flight to the server */
+    pendingOps: number;
+    /** Whether the `done` promise has been resolved */
+    doneResolved: boolean;
+    /** Whether the underlying stream has actually closed/errored */
+    streamEnded: boolean;
+    /** Interval ID for writable lock polling (if active) */
+    writablePollingInterval?: ReturnType<typeof setInterval>;
+    /** Interval ID for readable lock polling (if active) */
+    readablePollingInterval?: ReturnType<typeof setInterval>;
+}
+export declare function createFlushableState(): FlushableStreamState;
+/**
+ * Polls a WritableStream to check if the user has released their lock.
+ * Resolves the done promise when lock is released and no pending ops remain.
+ *
+ * Note: Only resolves if stream is unlocked but NOT closed. If the user closes
+ * the stream, the pump will handle resolution via the stream ending naturally.
+ *
+ * Protection: If polling is already active on this state, the existing interval
+ * is used to avoid creating multiple simultaneous polling operations.
+ */
+export declare function pollWritableLock(writable: WritableStream, state: FlushableStreamState): void;
+/**
+ * Polls a ReadableStream to check if the user has released their lock.
+ * Resolves the done promise when lock is released and no pending ops remain.
+ *
+ * Note: Only resolves if stream is unlocked but NOT closed. If the user closes
+ * the stream, the pump will handle resolution via the stream ending naturally.
+ *
+ * Protection: If polling is already active on this state, the existing interval
+ * is used to avoid creating multiple simultaneous polling operations.
+ */
+export declare function pollReadableLock(readable: ReadableStream, state: FlushableStreamState): void;
+/**
+ * Creates a flushable pipe from a ReadableStream to a WritableStream.
+ * Unlike pipeTo(), this resolves when:
+ * 1. The source stream completes (close/error), OR
+ * 2. The user releases their lock on userStream AND all pending writes are flushed
+ *
+ * @param source - The readable stream to read from (e.g., transform's readable)
+ * @param sink - The writable stream to write to (e.g., server writable)
+ * @param state - The flushable state tracker
+ * @returns Promise that resolves when stream ends (not when done promise resolves)
+ */
+export declare function flushablePipe(source: ReadableStream, sink: WritableStream, state: FlushableStreamState): Promise<void>;
+//# sourceMappingURL=flushable-stream.d.ts.map

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

@@ -0,0 +1,48 @@
+import type { Serializable } from './schemas.js';
+export interface StepInvocationQueueItem {
+    type: 'step';
+    correlationId: string;
+    stepName: string;
+    args: Serializable[];
+    closureVars?: Record<string, Serializable>;
+    thisVal?: Serializable;
+    hasCreatedEvent?: boolean;
+}
+export interface HookInvocationQueueItem {
+    type: 'hook';
+    correlationId: string;
+    token: string;
+    metadata?: Serializable;
+    hasCreatedEvent?: boolean;
+    disposed?: boolean;
+    isWebhook?: boolean;
+    isSystem?: boolean;
+    abortRequested?: boolean;
+    abortReason?: unknown;
+}
+export interface WaitInvocationQueueItem {
+    type: 'wait';
+    correlationId: string;
+    resumeAt: Date;
+    hasCreatedEvent?: boolean;
+}
+export type QueueItem = StepInvocationQueueItem | HookInvocationQueueItem | WaitInvocationQueueItem;
+/**
+ * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do
+ * not yet have corresponding entries in the event log. The workflow
+ * dispatcher will catch this error and push the operations
+ * onto the queue.
+ */
+export declare class WorkflowSuspension extends Error {
+    steps: QueueItem[];
+    globalThis: typeof globalThis;
+    stepCount: number;
+    hookCount: number;
+    waitCount: number;
+    hookDisposedCount: number;
+    abortCount: number;
+    constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis);
+    static is(value: unknown): value is WorkflowSuspension;
+}
+export declare function ENOTSUP(): never;
+//# sourceMappingURL=global.d.ts.map

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

@@ -1,38 +1,19 @@
-import type { WorkflowWritableStreamOptions } from "./runtime.js";
-
-export interface Hook<T = unknown> extends AsyncIterable<T> {
-  readonly token: string;
-  dispose(): void;
-  [Symbol.dispose](): void;
-}
-export interface HookOptions {
-  token?: string | undefined;
-  timeout?: string | number | undefined;
-}
-export type RequestWithResponse<T = unknown> = any;
-export type RetryableErrorOptions = any;
-export type Webhook<T = unknown> = any;
-export type WebhookOptions = HookOptions;
-export interface StepMetadata {
-  [key: string]: unknown;
-}
-export interface WorkflowMetadata {
-  readonly url: string;
-  readonly workflowRunId: string;
-  readonly workflowName: string;
-  readonly workflowStartedAt: Date;
-  [key: string]: unknown;
-}
-export declare class FatalError extends Error {}
-export declare class RetryableError extends Error {
-  constructor(message: string, options?: RetryableErrorOptions);
-}
-export declare function createHook<T = unknown>(options?: HookOptions): Hook<T>;
-export declare function createWebhook<T = unknown>(options?: WebhookOptions): Webhook<T>;
-export declare function defineHook<T = unknown>(): Hook<T>;
-export declare function getStepMetadata(): StepMetadata;
-export declare function getWorkflowMetadata(): WorkflowMetadata;
-export declare function getWritable<T = unknown>(
-  options?: WorkflowWritableStreamOptions,
-): WritableStream<T>;
-export declare function sleep(duration: string | number): Promise<void>;
+/**
+ * Just the core utilities that are meant to be imported by user
+ * steps/workflows. This allows the bundler to tree-shake and limit what goes
+ * into the final user bundles. Logic for running/handling steps/workflows
+ * should live in runtime. Eventually these might be separate packages
+ * `workflow` and `workflow/runtime`?
+ *
+ * Everything here will get re-exported under the 'workflow' top level package.
+ * This should be a minimal set of APIs so **do not anything here** unless it's
+ * needed for userland workflow code.
+ */
+export { FatalError, RetryableError, type RetryableErrorOptions, } from '#compiled/@workflow/errors/index.js';
+export { createHook, createWebhook, type Hook, type HookOptions, type RequestWithResponse, type Webhook, type WebhookOptions, } from './create-hook.js';
+export { defineHook, type TypedHook } from './define-hook.js';
+export { sleep } from './sleep.js';
+export { getStepMetadata, type StepMetadata, } from './step/get-step-metadata.js';
+export { getWorkflowMetadata, type WorkflowMetadata, } from './step/get-workflow-metadata.js';
+export { getWritable, type WorkflowWritableStreamOptions, } from './step/writable-stream.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -1,2 +1,2 @@
-import{o as e,r as t}from"../../_chunks/workflow/dist-0iNBqPYp.js";import{i as n,n as r,r as i}from"../../_chunks/workflow/context-errors-zbKocOyk.js";import{Bt as a,Ht as o,L as s,S as c,Vt as l,h as u,n as d,w as f,z as p}from"../../_chunks/workflow/resume-hook-CL8Ed91K.js";import{t as m}from"../../_chunks/workflow/sleep-Dn3i9nxI.js";function h(e){i(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,h)}function g(e){i(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,g)}function _({schema:e}={}){function t(e){i(`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 d(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 d(t,r.value)}}}function v(){let e=p.getStore();return e||r(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,v),e.stepMetadata}function y(){let e=p.getStore();return e||n(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,y),e.workflowMetadata}function b(e={}){let t=p.getStore();t||n(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,b);let{namespace:r}=e,i=t.workflowMetadata.workflowRunId,d=s(i,r),m=f(c(globalThis,t.ops,i,t.encryptionKey),t.encryptionKey),h=new u(i,d),g=a();return t.ops.push(g.promise),l(m.readable,h,g).catch(()=>{}),o(m.writable,g),m.writable}export{t as FatalError,e as RetryableError,h as createHook,g as createWebhook,_ as defineHook,v as getStepMetadata,y as getWorkflowMetadata,b as getWritable,m as sleep};
+import{i as e,s as t}from"../../_chunks/workflow/dist-C7wPwOI9.js";import{i as n,n as r,r as i}from"../../_chunks/workflow/context-errors-Bbvvp-li.js";import{c as a,s as o}from"../../_chunks/workflow/symbols-QezhMuLg.js";import{Bt as s,Ht as c,L as l,S as u,Vt as d,h as f,n as p,w as m,z as h}from"../../_chunks/workflow/resume-hook-C3VWUPii.js";import{t as g}from"../../_chunks/workflow/sleep-QTkC1VFe.js";function _(e){i(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,_)}function v(e){i(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,v)}function y({schema:e}={}){function t(e){i(`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 p(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 p(t,r.value)}}}function b(){let e=h.getStore();return e||r(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,b),e.stepMetadata}function x(){let e=h.getStore();return e||n(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,x),e.workflowMetadata}function S(e={}){let t=h.getStore();t||n(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,S);let{namespace:r}=e,i=t.workflowMetadata.workflowRunId,p=l(i,r),g=m(u(globalThis,t.ops,i,t.encryptionKey),t.encryptionKey),_=new f(i,p),v=s();return t.ops.push(v.promise),d(g.readable,_,v).catch(()=>{}),c(g.writable,v),Object.defineProperty(g.writable,o,{value:p,writable:!1}),Object.defineProperty(g.writable,a,{value:i,writable:!1}),g.writable}export{e as FatalError,t as RetryableError,_ as createHook,v as createWebhook,y as defineHook,b as getStepMetadata,x as getWorkflowMetadata,S as getWritable,g as sleep};

package/dist/src/compiled/@workflow/core/log-format.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Structured-log composition for `console.error` / `console.warn`. Emits
+ * one string in three sections so the most useful information is at the
+ * top, stack trace at the bottom:
+ *
+ *     [workflow-sdk] <framing line>
+ *       user error · FatalError
+ *       run    wrun_…
+ *       step   step_… · add (./workflows/x)
+ *       hint:  Move the call to a step function.
+ *     FatalError: …
+ *         at … (trimmed stack — internals collapsed)
+ *
+ * Without this composition, callers passing `${framing}\n${stack}` as the
+ * message and structured fields as the metadata object got `util.inspect`'s
+ * default object dump appended *after* the stack, which buries the run ID
+ * and attribution badge under 30+ lines of `node_modules/.pnpm/...` frames.
+ *
+ * The same metadata is also emitted as structured OTel span events from
+ * the logger itself, so backends that want JSON-shaped data still get it.
+ * web/web-shared do not consume stderr at all — they read CBOR/JSON event
+ * payloads from the World event log.
+ */
+export declare function composeLogLine(prefix: string, message: string, metadata: Record<string, unknown> | undefined): string;
+//# sourceMappingURL=log-format.d.ts.map

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

@@ -0,0 +1,29 @@
+type LogMetadata = Record<string, unknown>;
+type LogFn = (message: string, metadata?: LogMetadata) => void;
+export interface Logger {
+    debug: LogFn;
+    info: LogFn;
+    warn: LogFn;
+    error: LogFn;
+    /**
+     * Returns a child logger that merges the given metadata into every call.
+     * Useful for attaching stable context (e.g. `workflowRunId`, `workflowName`,
+     * `stepId`) so callers don't have to repeat it on every log.
+     *
+     * Call-site metadata wins on conflict, so children can still override.
+     */
+    child: (metadata: LogMetadata) => Logger;
+    /**
+     * Convenience child logger for a workflow run. Equivalent to
+     * `logger.child({ workflowRunId, workflowName })`, but centralized so all
+     * runtime code structures run metadata consistently.
+     */
+    forRun: (workflowRunId: string, workflowName?: string, extra?: LogMetadata) => Logger;
+}
+export declare const stepLogger: Logger;
+export declare const runtimeLogger: Logger;
+export declare const webhookLogger: Logger;
+export declare const eventsLogger: Logger;
+export declare const adapterLogger: Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

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

@@ -1,6 +1,6 @@
 {
   "name": "experimental-ash-compiled-workflow-core",
-  "version": "5.0.0-beta.5",
+  "version": "5.0.0-beta.7",
   "private": true,
   "type": "module",
   "license": "Apache-2.0"

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

@@ -1,14 +1,63 @@
-export type Serializable = unknown;
-export type StepFunction<Args extends unknown[] = unknown[], Result = unknown> = ((
-  ...args: Args
-) => Promise<Result>) & {
-  maxRetries?: number | undefined;
-  stepId?: string | undefined;
+/**
+ * Utils used by the bundler when transforming code
+ */
+import type { CryptoKey } from './encryption.js';
+import type { EventsConsumer } from './events-consumer.js';
+import type { QueueItem } from './global.js';
+import type { Serializable } from './schemas.js';
+export type StepFunction<Args extends Serializable[] = any[], Result extends Serializable | unknown = unknown> = ((...args: Args) => Promise<Result>) & {
+    maxRetries?: number;
+    stepId?: string;
 };
+/**
+ * Register a step function to be served in the server bundle.
+ * Also sets the stepId property on the function for serialization support.
+ *
+ * Note: The SWC compiler plugin no longer generates calls to this function.
+ * Step registration is now inlined as a self-contained IIFE that writes
+ * directly to the global Map at Symbol.for("@workflow/core//registeredSteps").
+ * This function is kept for internal/test use only.
+ */
+export declare function registerStepFunction(stepId: string, stepFn: StepFunction): void;
+/**
+ * Find a registered step function by name
+ */
+export declare function getStepFunction(stepId: string): StepFunction | undefined;
 export interface WorkflowOrchestratorContext {
-  [key: string]: unknown;
+    runId: string;
+    encryptionKey: CryptoKey | undefined;
+    globalThis: typeof globalThis;
+    eventsConsumer: EventsConsumer;
+    /**
+     * Map of pending invocations keyed by correlationId.
+     * Using Map instead of Array for O(1) lookup/delete operations.
+     */
+    invocationsQueue: Map<string, QueueItem>;
+    onWorkflowError: (error: Error) => void;
+    generateUlid: () => string;
+    generateNanoid: () => string;
+    /**
+     * Sequential promise queue that ensures all event-driven promise resolutions
+     * (step results, hook payloads, failures, suspensions) happen in event log
+     * order. Every resolve, reject, or workflow error is chained through this
+     * queue so that even if individual operations take variable time (e.g.,
+     * async decryption), promises resolve deterministically.
+     */
+    promiseQueue: Promise<void>;
+    /**
+     * Counter of in-flight async data delivery operations (step result
+     * hydration, hook payload hydration). Suspensions must wait for this
+     * to reach 0 before firing, to avoid preempting data delivery.
+     */
+    pendingDeliveries: number;
 }
-export declare function __private_getClosureVars(): Record<string, unknown>;
-export declare function getStepFunction(stepId: string): StepFunction | undefined;
-export declare function registerStepFunction(stepId: string, stepFn: StepFunction): void;
+/**
+ * Schedule a callback to fire only after all pending data deliveries
+ * (step results, hook payloads) and async deserialization have completed.
+ * Uses a polling loop: setTimeout(0) → check pendingDeliveries →
+ * if > 0, wait for promiseQueue → repeat. This handles the multi-round
+ * delivery pattern where each hook payload delivery cycle appends new
+ * async work to the promiseQueue.
+ */
 export declare function scheduleWhenIdle(ctx: WorkflowOrchestratorContext, fn: () => void): void;
+//# sourceMappingURL=private.d.ts.map

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

@@ -0,0 +1,51 @@
+export declare const MAX_QUEUE_DELIVERIES = 48;
+/**
+ * Default maximum time allowed for the *replay* portion of a single workflow
+ * handler invocation (in ms). This budget only covers deterministic-replay
+ * and workflow-VM execution between step boundaries — inline step bodies
+ * (`"use step"` functions invoked via `executeStep`) do NOT count against
+ * it. Step bodies are bounded separately by the platform's function
+ * `maxDuration` (e.g. 800s on Vercel Pro Fluid) and `NO_INLINE_REPLAY_AFTER_MS`.
+ *
+ * If the non-step ("replay") time within a single invocation exceeds this
+ * budget, the handler exits so the queue can retry. After
+ * `REPLAY_TIMEOUT_MAX_RETRIES` exhausted attempts the run is failed with
+ * `RUN_ERROR_CODES.REPLAY_TIMEOUT`.
+ *
+ * Note that on Vercel Hobby (standard functions), the platform `maxDuration`
+ * is 60s — well below this budget, so the platform SIGTERM will fire first
+ * and the queue will re-deliver until the visibility window expires. With
+ * Fluid Compute on Hobby the per-function ceiling rises to 300s, still
+ * under the default budget.
+ *
+ * Override via the `WORKFLOW_REPLAY_TIMEOUT_MS` env var (clamped to
+ * `MIN_REPLAY_TIMEOUT_MS`..`MAX_REPLAY_TIMEOUT_MS`).
+ */
+export declare const REPLAY_TIMEOUT_MS = 240000;
+/** Lower bound for the replay-timeout env var override. */
+export declare const MIN_REPLAY_TIMEOUT_MS = 30000;
+/**
+ * Upper bound for the replay-timeout env var override. 780s leaves ≥20s of
+ * headroom under Vercel Pro Fluid's 800s function ceiling so the handler
+ * can write `run_failed` before SIGTERM.
+ */
+export declare const MAX_REPLAY_TIMEOUT_MS = 780000;
+/**
+ * Resolve the effective replay-timeout budget for the current process.
+ *
+ * Reads `process.env.WORKFLOW_REPLAY_TIMEOUT_MS` lazily so tests and
+ * deployments can override per invocation. Invalid / out-of-range values
+ * fall back to a safe value (no throw — the env var is an escape hatch,
+ * not a hard requirement) and emit a one-time warning so misconfiguration
+ * is observable.
+ */
+export declare function getReplayTimeoutMs(): number;
+/**
+ * Reset the warn-once cache. Test-only — exported so unit tests can
+ * exercise the warn path repeatedly without sharing state.
+ *
+ * @internal
+ */
+export declare function _resetReplayTimeoutWarnCacheForTests(): void;
+export declare const REPLAY_TIMEOUT_MAX_RETRIES = 3;
+//# sourceMappingURL=constants.d.ts.map

package/dist/src/compiled/@workflow/core/runtime/get-port-lazy.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Lazy loader for getPort that prevents bundlers (Turbopack, esbuild)
+ * from statically tracing @workflow/utils/get-port and its filesystem
+ * operations (readdir, readFile, readlink) into the flow route bundle.
+ *
+ * Uses createRequire with a dynamically constructed specifier so the
+ * dependency is invisible to bundler static analysis.
+ */
+export declare function getPortLazy(): Promise<number | undefined>;
+//# sourceMappingURL=get-port-lazy.d.ts.map

package/dist/src/compiled/@workflow/core/runtime/get-world-lazy.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Lazy accessor for the World singleton via globalThis symbols.
+ *
+ * This module exists to break the static import chain from step-side
+ * modules (serialization, run, helpers, start) to world.ts. Without it,
+ * esbuild bundles world.ts (and its transitive deps: world-local,
+ * world-vercel, process.cwd(), etc.) into the step registrations bundle,
+ * which triggers Turbopack NFT tracing errors in the V2 combined flow route.
+ *
+ * Resolution order, in priority:
+ *
+ * 1. `globalThis[WorldCacheKey]` — populated by a successful prior
+ *    `getWorld()` call. This is the steady-state hot path.
+ * 2. `globalThis[GetWorldFnKey]` — populated by the module-load side
+ *    effect at the bottom of `./world.ts`. Fires on every server bundle
+ *    that reaches this file via `workflow/api` (which imports
+ *    `./world-init.ts` for its side effect; see that file for the full
+ *    rationale). This is the cold-start path for routes that consume
+ *    `start` without any prior workflow run.
+ * 3. Dynamic `import('./world.js')` — last-resort fallback for
+ *    environments where neither (1) nor (2) is available (CJS test
+ *    runners, scripts that import deeply into `@workflow/core` without
+ *    going through `workflow/api`, future bundlers we haven't validated).
+ *    The specifier is built at runtime so esbuild can't trace it into
+ *    step bundles. Note: this branch is unreliable in webpack-bundled
+ *    routes because webpack inlines this module into the route file and
+ *    the relative path resolves against the bundle location — paths (1)
+ *    and (2) cover those cases instead.
+ */
+import type { World } from '../_workflow-world.js';
+export declare function getWorldLazy(): Promise<World>;
+//# sourceMappingURL=get-world-lazy.d.ts.map