experimental-ash 0.22.2 → 0.23.0

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

@@ -0,0 +1,75 @@
+/**
+ * Server-only side-effect module that ensures `world.ts` is loaded so its
+ * module-load side effect — `globalThis[GetWorldFnKey] ??= getWorld` —
+ * fires in host bundles.
+ *
+ * # Why this exists
+ *
+ * `getWorldLazy()` in `./get-world-lazy.ts` checks the globalThis cache
+ * (populated by `world.ts`'s module-load side effect) before falling back
+ * to a runtime-built dynamic `import('./world.js')`. When a server route
+ * only consumes a single helper that goes through `getWorldLazy` — most
+ * commonly `start` from `workflow/api` — webpack/turbopack tree-shake the
+ * named import `{ getWorld } from './runtime/world.js'` out of
+ * `runtime.ts`, taking `world.ts`'s module evaluation with it. The
+ * globalThis registration never fires.
+ *
+ * `getWorldLazy` then falls through to its dynamic-import fallback, which
+ * itself fails: webpack inlines `get-world-lazy.js` into the bundled route
+ * file, so the relative specifier `./world.js` resolves against
+ * `/var/task/<app>/.next/server/app/<...>/route.js` — where no sibling
+ * `world.js` exists — and Node throws `MODULE_NOT_FOUND`. The symptom is a
+ * cold-start regression: the very first user request that goes through
+ * `start()` fails until some other code path (typically the queue-driven
+ * `/.well-known/workflow/v1/flow` route, which uses `getWorld` directly
+ * via `workflowEntrypoint`) has loaded `world.ts` and populated the
+ * cache.
+ *
+ * Importing this module for its side effect — exactly once, from the
+ * host-side `workflow/api` (`packages/workflow/src/api.ts`) — guarantees
+ * `world.ts` enters the bundle, the global is registered at module load,
+ * and `getWorldLazy()` short-circuits to the registered function on the
+ * first call.
+ *
+ * # Why a separate module instead of importing `./world.js` directly
+ *
+ * `world.ts` is internal to `@workflow/core` and not part of the public
+ * exports surface. Adding a dedicated public init entry (this file)
+ * keeps the side-effect intent obvious to anyone reading
+ * `packages/workflow/src/api.ts`, and lets the `workflow` export
+ * condition route to a stub for VM/step bundles (see below).
+ *
+ * # Why this doesn't break VM/step bundles
+ *
+ * The `@workflow/core/runtime/world-init` export resolves via the
+ * `workflow` condition to `./dist/workflow/world-init-stub.js`, an empty
+ * module. Esbuild runs the workflow VM and step bundlers with the
+ * `workflow` condition active, so they pick up the stub and never reach
+ * `world.ts`. Host bundlers (webpack, turbopack, Node.js) use the
+ * `default` (or `node`) condition and pick up this file, loading
+ * `world.ts` as intended. The split keeps `@workflow/world-vercel`,
+ * `@workflow/world-local`, `cbor-x`, and other server-only deps out of
+ * the workflow sandbox bundle.
+ *
+ * # Why we keep the `getWorldLazy` dynamic-import fallback
+ *
+ * The fallback remains in `./get-world-lazy.ts` as a defense-in-depth for
+ * environments we haven't accounted for (CJS test runners, scripts that
+ * import `start` without going through `workflow/api`, future bundlers
+ * with stricter tree-shaking). With this init module in place, the
+ * fallback should never fire in normal use — but if it does, the
+ * dynamic-import branch still resolves correctly when `world.js` is
+ * physically adjacent on disk (e.g., direct Node.js execution of
+ * unbundled source).
+ *
+ * # Maintenance notes
+ *
+ * If you add another `getWorldLazy()` consumer that's reachable from a
+ * host route without going through `workflow/api` (e.g., a new helper in
+ * `workflow/runtime`), make sure that entry also imports this module —
+ * or that it transitively reaches `world.ts` via a non-tree-shakeable
+ * path. Adding a regression test in `world-init.test.ts` is preferred to
+ * relying on careful manual tracing.
+ */
+import './world.js';
+//# sourceMappingURL=world-init.d.ts.map

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

@@ -0,0 +1,32 @@
+import type { World } from '../_workflow-world.js';
+/**
+ * Create a new world instance based on environment variables.
+ * WORKFLOW_TARGET_WORLD is used to determine the target world.
+ *
+ * Note: WORKFLOW_VERCEL_* env vars (PROJECT, TEAM, AUTH_TOKEN, etc.) are
+ * intentionally NOT read here. Those are for CLI/observability tooling only
+ * and should not affect runtime behavior. The Vercel runtime provides
+ * authentication via OIDC tokens and project context via system env vars
+ * (VERCEL_DEPLOYMENT_ID, VERCEL_PROJECT_ID). Tooling that needs these env
+ * vars should call createVercelWorld() directly with an explicit config and
+ * use setWorld() to inject the instance.
+ */
+export declare const createWorld: () => Promise<World>;
+export type WorldHandlers = Pick<World, 'createQueueHandler' | 'specVersion'>;
+/**
+ * Some functions from the world are needed at build time, but we do NOT want
+ * to cache the world in those instances for general use, since we don't have
+ * the correct environment variables set yet. This is a safe function to
+ * call at build time, that only gives access to non-environment-bound world
+ * functions. The only binding value should be the target world.
+ * Once we migrate to a file-based configuration (workflow.config.ts), we should
+ * be able to re-combine getWorld and getWorldHandlers into one singleton.
+ */
+export declare const getWorldHandlers: () => Promise<WorldHandlers>;
+export declare const getWorld: () => Promise<World>;
+/**
+ * Reset the cached world instance. This should be called when environment
+ * variables change and you need to reinitialize the world with new config.
+ */
+export declare const setWorld: (world: World | undefined) => void;
+//# sourceMappingURL=world.d.ts.map

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

@@ -1,67 +1,22 @@
-export type Event = any;
-export type WorkflowRun = any;
-export type WorkflowReadableStream<T = unknown> = ReadableStream<T>;
-export interface WorkflowReadableStreamOptions {
-  [key: string]: unknown;
-}
-export interface WorkflowWritableStreamOptions {
-  namespace?: string | undefined;
-}
-export type HealthCheckEndpoint = any;
-export type HealthCheckOptions = any;
-export type HealthCheckResult = any;
-export type ReadStreamOptions = any;
-export type RecreateRunOptions = any;
-export type StartOptions = any;
-export type StartOptionsBase = any;
-export type StartOptionsWithDeploymentId = any;
-export type StartOptionsWithoutDeploymentId = any;
-export type StopSleepOptions = any;
-export type StopSleepResult = any;
-export interface WorkflowWorldCollection {
-  get(id: string, options?: Record<string, any>): Promise<any>;
-  get(params?: Record<string, any>, options?: Record<string, any>): Promise<any>;
-  list(
-    params?: Record<string, any>,
-  ): Promise<{ cursor?: string | null; data: any[]; hasMore?: boolean }>;
-}
-export interface WorkflowWorld {
-  readonly events: WorkflowWorldCollection;
-  readonly hooks: WorkflowWorldCollection;
-  readonly runs: WorkflowWorldCollection;
-  readonly steps: WorkflowWorldCollection;
-}
-export declare class Run<T = any> {
-  readonly runId: string;
-  readonly readable: ReadableStream<Uint8Array>;
-  readonly returnValue: Promise<T>;
-  readonly status: Promise<string>;
-  cancel(): Promise<void>;
-  getReadable(options?: WorkflowReadableStreamOptions): ReadableStream<Uint8Array>;
-}
-export declare class WorkflowSuspension extends Error {}
-export declare function cancelRun(...args: unknown[]): Promise<unknown>;
-export declare function createWorld(...args: unknown[]): Promise<unknown>;
-export declare function getHookByToken(...args: unknown[]): Promise<unknown>;
-export declare function getRun<T = unknown>(runId: string): Run<T>;
-export declare function getWorld(): Promise<WorkflowWorld>;
-export declare function getWorldHandlers(): Promise<any>;
-export declare function healthCheck(...args: unknown[]): Promise<HealthCheckResult>;
-export declare function listStreams(...args: unknown[]): Promise<unknown>;
-export declare function readStream<T = unknown>(
-  ...args: unknown[]
-): Promise<WorkflowReadableStream<T>>;
-export declare function recreateRunFromExisting(...args: unknown[]): Promise<unknown>;
-export declare function reenqueueRun(...args: unknown[]): Promise<unknown>;
-export declare function resumeHook<T = unknown>(token: string, value?: T): Promise<void>;
-export declare function resumeWebhook<T = unknown>(token: string, value?: T): Promise<Response>;
-export declare function setWorld(world: unknown): void;
-export declare function start<T = any>(
-  workflow: unknown,
-  args?: unknown[],
-  options?: StartOptions,
-): Promise<Run<T>>;
-export declare function wakeUpRun(...args: unknown[]): Promise<unknown>;
-export declare function workflowEntrypoint(
-  workflowCode: string,
-): (req: Request) => Promise<Response>;
+import { type Event, type WorkflowRun } from './_workflow-world.js';
+export type { Event, WorkflowRun };
+export { WorkflowSuspension } from './global.js';
+export { type HealthCheckEndpoint, type HealthCheckOptions, type HealthCheckResult, healthCheck, } from './runtime/helpers.js';
+export { getHookByToken, resumeHook, resumeWebhook, } from './runtime/resume-hook.js';
+export { getRun, Run, type WorkflowReadableStream, type WorkflowReadableStreamOptions, } from './runtime/run.js';
+export { cancelRun, listStreams, type ReadStreamOptions, type RecreateRunOptions, readStream, recreateRunFromExisting, reenqueueRun, type StopSleepOptions, type StopSleepResult, wakeUpRun, } from './runtime/runs.js';
+export { type StartOptions, type StartOptionsBase, type StartOptionsWithDeploymentId, type StartOptionsWithoutDeploymentId, start, } from './runtime/start.js';
+export { createWorld, getWorld, getWorldHandlers, setWorld, } from './runtime/world.js';
+/**
+ * Creates a single route which handles workflow execution requests,
+ * executing steps inline when possible to reduce function invocations
+ * and queue overhead.
+ *
+ * The handler loops: replay workflow → execute step inline → replay → ...
+ * until the workflow completes, times out, or encounters non-step suspensions.
+ *
+ * @param workflowCode - The workflow bundle code containing all workflow functions
+ * @returns A function that can be used as a Vercel API route
+ */
+export declare function workflowEntrypoint(workflowCode: string): (req: Request) => Promise<Response>;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * A serializable value:
+ * Any valid JSON object is serializable
+ *
+ * @example
+ *
+ * ```ts
+ * // any valid JSON object is serializable
+ * const anyJson: Serializable = { foo: "bar" };
+ * ```
+ */
+export type Serializable = string | number | boolean | null | undefined | Serializable[] | {
+    [key: string]: Serializable;
+} | ArrayBuffer | bigint | BigInt64Array | BigUint64Array | Date | DOMException | Error | Float32Array | Float64Array | Headers | Int8Array | Int16Array | Int32Array | Map<Serializable, Serializable> | ReadableStream<Uint8Array> | RegExp | Response | Set<Serializable> | URL | URLSearchParams | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | WritableStream<Uint8Array> | AbortController | AbortSignal | ((...args: Serializable[]) => Promise<Serializable>);
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1,17 @@
+/**
+ * Client (external) mode serialization.
+ *
+ * Used when starting workflows from the client side (serializing workflow
+ * arguments) and when receiving workflow return values. Supports encryption.
+ */
+import type { CodecOptions } from './codec.js';
+import { type CryptoKey } from './encryption.js';
+/**
+ * Serialize a value from the client environment (e.g. workflow arguments).
+ */
+export declare function serialize(value: unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<Uint8Array | unknown>;
+/**
+ * Deserialize a value for the client environment (e.g. workflow return value).
+ */
+export declare function deserialize(data: Uint8Array | unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<unknown>;
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,14 @@
+/**
+ * Devalue codec implementation.
+ *
+ * Uses the `devalue` library for serialization. Handles custom types via
+ * reducers (serialize) and revivers (deserialize) which are composed
+ * internally based on the serialization mode.
+ *
+ * The reducer/reviver pattern is specific to devalue — other codecs
+ * (CBOR, JSON) would handle types differently (e.g. CBOR supports Date,
+ * typed arrays, Map, Set natively).
+ */
+import type { Codec } from './codec.js';
+export declare const devalueCodec: Codec;
+//# sourceMappingURL=codec-devalue.d.ts.map

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

@@ -0,0 +1,90 @@
+/**
+ * Codec interface for serialization formats.
+ *
+ * A codec handles the core serialize/deserialize logic for a specific
+ * wire format (devalue, CBOR, JSON, etc.). Each codec is responsible
+ * for handling all supported data types internally — the caller only
+ * specifies which serialization mode to use.
+ *
+ * - **devalue**: Uses custom reducers/revivers for Date, Error, Map, Set,
+ *   typed arrays, class instances, etc.
+ * - **cbor**: Would handle Date, typed arrays, Map, Set natively via the
+ *   CBOR type system. Class instances would still need custom handling.
+ * - **json**: Would only support standard JSON types (primitives, arrays,
+ *   plain objects). No Date, Map, Set, typed arrays, etc.
+ */
+import type { FormatPrefix } from './types.js';
+/**
+ * The serialization mode determines which types are supported and how
+ * they're handled. Different modes compose different sets of type handlers.
+ *
+ * - `workflow`: Runs inside the workflow VM. Includes class serialization,
+ *   step function serialization. No stream handling.
+ * - `step`: Runs in the step handler (Node.js). Includes class serialization.
+ *   No step function serialization. Stream handling at call sites.
+ * - `client`: Runs on the client side. Includes class serialization.
+ *   No step function serialization. Stream handling at call sites.
+ */
+export type SerializationMode = 'workflow' | 'step' | 'client';
+/**
+ * Options passed to codec serialize/deserialize to support VM-context
+ * serialization and mode-specific type handling.
+ */
+export interface CodecOptions {
+    /**
+     * The global object to use for `instanceof` checks and constructors.
+     * Defaults to `globalThis`. Must be set to the VM's global when
+     * serializing/deserializing data that crosses VM boundaries.
+     */
+    global?: Record<string, any>;
+    /**
+     * Additional reducers to merge into the mode's default reducers.
+     * Used by dehydrate/hydrate functions that need stream handling
+     * or other mode-specific type reducers.
+     */
+    extraReducers?: Record<string, (value: any) => any>;
+    /**
+     * Additional revivers to merge into the mode's default revivers.
+     * Used by dehydrate/hydrate functions that need stream handling
+     * or other mode-specific type revivers.
+     */
+    extraRevivers?: Record<string, (value: any) => any>;
+}
+export interface Codec {
+    /** The 4-character format prefix identifier (e.g. "devl", "cbor", "json") */
+    readonly formatPrefix: FormatPrefix;
+    /**
+     * Serialize a value to bytes.
+     *
+     * The codec handles all supported types internally based on the mode.
+     *
+     * @param value - The value to serialize
+     * @param mode - The serialization mode
+     * @param options - Optional global, extra reducers/revivers
+     * @returns The serialized payload (without format prefix)
+     */
+    serialize(value: unknown, mode: SerializationMode, options?: CodecOptions): Uint8Array;
+    /**
+     * Deserialize bytes back to a value.
+     *
+     * The codec handles all supported types internally based on the mode.
+     *
+     * @param data - The serialized payload (without format prefix)
+     * @param mode - The serialization mode
+     * @param options - Optional global, extra revivers
+     * @returns The deserialized value
+     */
+    deserialize(data: Uint8Array, mode: SerializationMode, options?: CodecOptions): unknown;
+    /**
+     * Deserialize legacy (pre-format-prefix) data.
+     * Used for backwards compatibility with specVersion 1 runs that stored
+     * data as plain JSON arrays instead of binary.
+     *
+     * @param data - The legacy data
+     * @param mode - The serialization mode
+     * @param options - Optional global, extra revivers
+     * @returns The deserialized value
+     */
+    deserializeLegacy?(data: unknown, mode: SerializationMode, options?: CodecOptions): unknown;
+}
+//# sourceMappingURL=codec.d.ts.map

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

@@ -0,0 +1,32 @@
+/**
+ * Composable encryption layer for serialized data.
+ *
+ * Wraps/unwraps serialized payloads with AES-256-GCM encryption,
+ * using the format prefix system to mark encrypted data.
+ */
+import { type CryptoKey } from '../encryption.js';
+export type { CryptoKey };
+/**
+ * Encryption key parameter type. Accepts a resolved key, undefined (no encryption),
+ * or a promise that resolves to either.
+ */
+export type EncryptionKeyParam = CryptoKey | undefined | Promise<CryptoKey | undefined>;
+/**
+ * Encrypt a format-prefixed payload if a key is provided.
+ * Wraps the data with the 'encr' format prefix.
+ *
+ * @param data - The format-prefixed serialized data
+ * @param key - Encryption key (undefined to skip encryption)
+ * @returns The encrypted data with 'encr' prefix, or the original data if no key
+ */
+export declare function encrypt(data: Uint8Array | unknown, key: CryptoKey | undefined): Promise<Uint8Array | unknown>;
+/**
+ * Decrypt a format-prefixed payload if it's encrypted.
+ * Strips the 'encr' format prefix and decrypts the inner payload.
+ *
+ * @param data - The potentially encrypted data
+ * @param key - Encryption key (undefined to skip decryption)
+ * @returns The decrypted inner payload, or the original data if not encrypted
+ */
+export declare function decrypt(data: Uint8Array | unknown, key: CryptoKey | undefined): Promise<Uint8Array | unknown>;
+//# sourceMappingURL=encryption.d.ts.map

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

@@ -0,0 +1,21 @@
+/**
+ * Shared error formatting utility for serialization failures.
+ *
+ * Used by the mode-specific serializers (workflow, step, client) to
+ * produce consistent error messages with devalue path information.
+ *
+ * Returns a `{ message, hint }` pair so callers can throw a
+ * `SerializationError(message, { hint, cause })` and have the hint flow
+ * through the standard friendly-errors framing instead of being baked
+ * into the message string.
+ */
+/**
+ * Format a serialization error with context about what failed.
+ * Extracts path, value, and reason from devalue's DevalueError when available.
+ * Logs the problematic value to the console for better debugging.
+ */
+export declare function formatSerializationError(context: string, error: unknown): {
+    message: string;
+    hint: string;
+};
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,60 @@
+/**
+ * Format prefix system for serialized payloads.
+ *
+ * All serialized payloads are prefixed with a 4-byte format identifier that
+ * allows the deserializer to determine how to decode the payload. This enables:
+ *
+ * 1. Self-describing payloads — the World layer is agnostic to serialization format
+ * 2. Gradual migration — old runs keep working, new runs can use new formats
+ * 3. Composability — encryption can wrap any format ("encr" wrapping "devl")
+ * 4. Debugging — raw data inspection immediately reveals the format
+ *
+ * Format: [4 bytes: format identifier][payload]
+ *
+ * The format prefix is open-ended — any 4-character [a-z0-9] string is valid.
+ * This allows new codecs to be added without modifying this module.
+ */
+import { type FormatPrefix } from './types.js';
+/**
+ * Encode a payload with a format prefix.
+ *
+ * @param format - The format identifier (4 chars, [a-z0-9])
+ * @param payload - The serialized payload bytes
+ * @returns A new Uint8Array with format prefix prepended
+ */
+export declare function encodeWithFormatPrefix(format: FormatPrefix, payload: Uint8Array | unknown): Uint8Array | unknown;
+/**
+ * Peek at the format prefix without consuming it.
+ *
+ * Returns the prefix if it's a valid format prefix ([a-z0-9]{4}),
+ * or null if the data is legacy/non-binary or doesn't start with a
+ * valid prefix.
+ *
+ * @param data - The format-prefixed data
+ * @returns The format prefix, or null
+ */
+export declare function peekFormatPrefix(data: Uint8Array | unknown): FormatPrefix | null;
+/**
+ * Check if data is encrypted (has 'encr' format prefix).
+ */
+export declare function isEncrypted(data: Uint8Array | unknown): boolean;
+/**
+ * Decode a format-prefixed payload.
+ *
+ * Unlike the legacy implementation which only accepted known formats
+ * (`devl`, `encr`), this function accepts any valid format prefix
+ * (`[a-z0-9]{4}`). This is intentional for forward compatibility —
+ * new codecs (e.g. `cbor`) can be added without modifying this module.
+ * Callers are responsible for checking whether they support the returned
+ * format and throwing an appropriate error if not (e.g. "Unsupported
+ * serialization format").
+ *
+ * @param data - The format-prefixed data
+ * @returns An object with the format prefix and payload
+ * @throws Error if the data is too short or has an invalid prefix
+ */
+export declare function decodeFormatPrefix(data: Uint8Array | unknown): {
+    format: FormatPrefix;
+    payload: Uint8Array;
+};
+//# sourceMappingURL=format.d.ts.map

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

@@ -0,0 +1,18 @@
+/**
+ * Serialization module — public API.
+ *
+ * Re-exports the mode-specific serialize/deserialize functions and
+ * the codec/format/encryption abstractions.
+ */
+export type { FormatPrefix, SerializableSpecial, Reducers, Revivers, } from './types.js';
+export { SerializationFormat, isFormatPrefix } from './types.js';
+export type { Codec, SerializationMode } from './codec.js';
+export { devalueCodec } from './codec-devalue.js';
+export { encodeWithFormatPrefix, decodeFormatPrefix, peekFormatPrefix, isEncrypted, } from './format.js';
+export { encrypt, decrypt, type CryptoKey, type EncryptionKeyParam, } from './encryption.js';
+import * as workflow from './workflow.js';
+import * as step from './step.js';
+import * as client from './client.js';
+export { workflow, step, client };
+export { revive } from './reducers/common.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * Reducers and revivers for custom class serialization.
+ *
+ * Handles:
+ * - Class: class constructors with a `classId` property
+ * - Instance: instances of classes with custom WORKFLOW_SERIALIZE/DESERIALIZE methods
+ */
+import type { Reducers, Revivers } from '../types.js';
+export declare function getClassReducers(): Partial<Reducers>;
+export declare function getClassRevivers(global?: Record<string, any>): Partial<Revivers>;
+//# sourceMappingURL=class.d.ts.map

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

@@ -0,0 +1,16 @@
+/**
+ * Common reducers and revivers for types shared across all serialization modes.
+ *
+ * Handles: ArrayBuffer, BigInt, typed arrays, Date, Error, Headers, Map, Set,
+ * RegExp, Request, Response, URL, URLSearchParams.
+ *
+ * Note: Uses Node.js Buffer for base64 encoding/decoding. For environments
+ * without Buffer (e.g. QuickJS VM), a polyfill or alternative base64
+ * implementation will be needed.
+ */
+import type { Reducers, Revivers } from '../types.js';
+declare function revive(str: string): any;
+export declare function getCommonReducers(global?: Record<string, any>): Partial<Reducers>;
+export declare function getCommonRevivers(global?: Record<string, any>): Partial<Revivers>;
+export { revive };
+//# sourceMappingURL=common.d.ts.map

package/dist/src/compiled/@workflow/core/serialization/reducers/step-function.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reducer and reviver for step function references.
+ *
+ * In workflow mode, step functions are replaced by the SWC plugin with
+ * proxies created by `globalThis[Symbol.for("WORKFLOW_USE_STEP")]("stepId")`.
+ * These proxies have a `.stepId` property and optionally a `.__closureVarsFn`
+ * for captured closure variables. They may additionally have `.__boundThis`
+ * (and rarely `.__boundArgs`) when the SWC plugin emitted
+ * `useStep(...).bind(this)` for a nested arrow step that lexically
+ * captured `this` (see `packages/swc-plugin-workflow/spec.md` → "Lexical
+ * `this` Capture in Nested Arrow Steps").
+ *
+ * The reducer serializes them as
+ *   `{ stepId, closureVars?, boundThis?, boundArgs? }`.
+ * The reviver reconstructs them by calling WORKFLOW_USE_STEP and, when
+ * `boundThis` (or `boundArgs`) is present, re-binding the resulting
+ * proxy so the caller's captured `this` (and prefilled args) survive the
+ * round trip.
+ */
+import type { Reducers, Revivers } from '../types.js';
+export declare function getStepFunctionReducer(): Partial<Reducers>;
+/**
+ * Create the StepFunction reviver for workflow context.
+ *
+ * The reviver calls WORKFLOW_USE_STEP to create the step proxy,
+ * restoring the ability to call the step from workflow code. If the
+ * serialized payload includes `boundThis` (and optionally `boundArgs`),
+ * the reviver also re-binds the freshly-created proxy so a step proxy
+ * that was constructed with `.bind(this, …)` in the workflow bundle
+ * continues to carry that receiver and any prefilled arguments after
+ * being deserialized in another bundle (e.g. when passed as a step
+ * argument).
+ */
+export declare function getStepFunctionReviver(global?: Record<string, any>): Partial<Revivers>;
+//# sourceMappingURL=step-function.d.ts.map

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

@@ -0,0 +1,17 @@
+/**
+ * Step mode serialization.
+ *
+ * Used by the step handler for serializing step return values and
+ * deserializing step arguments. Supports encryption as a composable layer.
+ */
+import type { CodecOptions } from './codec.js';
+import { type CryptoKey } from './encryption.js';
+/**
+ * Serialize a value from the step execution environment.
+ */
+export declare function serialize(value: unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<Uint8Array | unknown>;
+/**
+ * Deserialize a value for the step execution environment.
+ */
+export declare function deserialize(data: Uint8Array | unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<unknown>;
+//# sourceMappingURL=step.d.ts.map