eve 0.5.4 → 0.6.0-beta.3

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

@@ -0,0 +1,22 @@
+/**
+ * The options for {@link getWritable}.
+ */
+export interface WorkflowWritableStreamOptions {
+    /**
+     * An optional namespace to distinguish between multiple streams associated
+     * with the same workflow run.
+     */
+    namespace?: string;
+}
+/**
+ * Retrieves a writable stream that is associated with the current workflow.
+ *
+ * The writable stream is intended to be used within step functions to write
+ * data that can be read outside the workflow by using the readable method of getRun.
+ *
+ * @param options - Optional configuration for the writable stream
+ * @returns The writable stream associated with the current workflow run
+ * @throws Error if called outside a workflow or step function
+ */
+export declare function getWritable<W = any>(options?: WorkflowWritableStreamOptions): WritableStream<W>;
+//# sourceMappingURL=writable-stream.d.ts.map

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

@@ -0,0 +1,4 @@
+import { type WorkflowOrchestratorContext } from './private.js';
+import type { Serializable } from './schemas.js';
+export declare function createUseStep(ctx: WorkflowOrchestratorContext): <Args extends Serializable[], Result>(stepName: string, closureVarsFn?: () => Record<string, Serializable>) => (this: unknown, ...args: Args) => Promise<Result>;
+//# sourceMappingURL=step.d.ts.map

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

@@ -0,0 +1,42 @@
+export declare const WORKFLOW_USE_STEP: unique symbol;
+export declare const WORKFLOW_CREATE_HOOK: unique symbol;
+export declare const WORKFLOW_SLEEP: unique symbol;
+export declare const WORKFLOW_CONTEXT: unique symbol;
+export declare const WORKFLOW_GET_STREAM_ID: unique symbol;
+export declare const STABLE_ULID: unique symbol;
+export declare const STREAM_NAME_SYMBOL: unique symbol;
+export declare const STREAM_TYPE_SYMBOL: unique symbol;
+/**
+ * Stamped on a real `WritableStream` (the user-visible `serialize.writable`
+ * returned from a step-side reviver or step-context `getWritable()`) to
+ * record the `runId` of the workflow run that owns the underlying server
+ * stream. Used together with `STREAM_NAME_SYMBOL`.
+ *
+ * When `getExternalReducers.WritableStream` (the dehydration path used by
+ * `start()`) sees both symbols on a writable, it includes the `runId` in
+ * the descriptor it emits. The child run's step-side reviver then opens
+ * a server writable against the original `(runId, name)` and resolves
+ * that run's encryption key directly — so the child's writes land on
+ * the parent's stream as-is, with no client process in the loop. That
+ * keeps the forwarding alive for the full lifetime of the child run,
+ * not just for the parent step that initiated `start()`.
+ */
+export declare const STREAM_SERVER_RUN_ID_SYMBOL: unique symbol;
+/**
+ * Stamped alongside `STREAM_SERVER_RUN_ID_SYMBOL` when the deployment that
+ * owns a forwarded writable stream is known. Cross-deployment consumers use
+ * it to resolve the owning run's encryption key without loading the run first.
+ */
+export declare const STREAM_SERVER_DEPLOYMENT_ID_SYMBOL: unique symbol;
+export declare const BODY_INIT_SYMBOL: unique symbol;
+export declare const WEBHOOK_RESPONSE_WRITABLE: unique symbol;
+/**
+ * Symbol used to store the class registry on globalThis in workflow mode.
+ * This allows the deserializer to find classes by classId in the VM context.
+ */
+export declare const WORKFLOW_CLASS_REGISTRY: unique symbol;
+export declare const ABORT_STREAM_NAME: unique symbol;
+export declare const ABORT_HOOK_TOKEN: unique symbol;
+export declare const ABORT_LISTENER_ATTACHED: unique symbol;
+export declare const ABORT_READER_CANCEL: unique symbol;
+//# sourceMappingURL=symbols.d.ts.map

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

@@ -0,0 +1,283 @@
+/**
+ * OpenTelemetry semantic conventions for Vercel Workflow telemetry.
+ *
+ * This module provides standardized telemetry attributes following OpenTelemetry semantic conventions
+ * for instrumenting workflow execution, step processing, and related operations. Each exported function
+ * creates a properly formatted attribute object that can be used with OpenTelemetry spans.
+ *
+ * The semantic conventions are organized into several categories:
+ * - **Workflow attributes**: Track workflow lifecycle, status, and metadata
+ * - **Step attributes**: Monitor individual step execution, retries, and results
+ * - **Queue attributes**: Instrument message queue operations
+ * - **Deployment attributes**: Capture deployment environment information
+ *
+ * All attribute functions are type-safe and leverage existing backend types to ensure
+ * consistency between telemetry data and actual system state.
+ *
+ * @example
+ * ```typescript
+ * import * as Attribute from './telemetry/semantic-conventions.js';
+ *
+ * // Set workflow attributes on a span
+ * span.setAttributes({
+ *   ...Attribute.WorkflowName('my-workflow'),
+ *   ...Attribute.WorkflowOperation('start'),
+ *   ...Attribute.WorkflowRunStatus('running'),
+ * });
+ *
+ * // Set step attributes
+ * span.setAttributes({
+ *   ...Attribute.StepName('process-data'),
+ *   ...Attribute.StepStatus('completed'),
+ *   ...Attribute.StepAttempt(1),
+ * });
+ * ```
+ *
+ * @see {@link https://opentelemetry.io/docs/specs/semconv/} OpenTelemetry Semantic Conventions
+ * @packageDocumentation
+ */
+/** The name of the workflow being executed */
+export declare const WorkflowName: (value: string) => {
+    [k: string]: string;
+};
+/** The operation being performed on the workflow */
+export declare const WorkflowOperation: (value: "run" | "start" | "execute" | "execute_v2") => {
+    [k: string]: "run" | "start" | "execute" | "execute_v2";
+};
+/** Unique identifier for a specific workflow run instance */
+export declare const WorkflowRunId: (value: string) => {
+    [k: string]: string;
+};
+/** Current status of the workflow run */
+export declare const WorkflowRunStatus: (value: "pending" | "running" | "cancelled" | "completed" | "failed" | "workflow_suspended") => {
+    [k: string]: "pending" | "running" | "cancelled" | "completed" | "failed" | "workflow_suspended";
+};
+/** Timestamp when the workflow execution started (Unix timestamp) */
+export declare const WorkflowStartedAt: (value: number) => {
+    [k: string]: number;
+};
+/** Number of events processed during workflow execution */
+export declare const WorkflowEventsCount: (value: number) => {
+    [k: string]: number;
+};
+/** Number of arguments passed to the workflow */
+export declare const WorkflowArgumentsCount: (value: number) => {
+    [k: string]: number;
+};
+/** Type of the workflow result */
+export declare const WorkflowResultType: (value: string) => {
+    [k: string]: string;
+};
+/** Whether trace context was propagated to this workflow execution */
+export declare const WorkflowTracePropagated: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Name of the error that caused workflow failure */
+export declare const WorkflowErrorName: (value: string) => {
+    [k: string]: string;
+};
+/** Error message when workflow fails */
+export declare const WorkflowErrorMessage: (value: string) => {
+    [k: string]: string;
+};
+/** Error classification code (USER_ERROR, RUNTIME_ERROR, etc.) */
+export declare const WorkflowErrorCode: (value: string) => {
+    [k: string]: string;
+};
+/** Number of steps created during workflow execution */
+export declare const WorkflowStepsCreated: (value: number) => {
+    [k: string]: number;
+};
+/** Number of hooks created during workflow execution */
+export declare const WorkflowHooksCreated: (value: number) => {
+    [k: string]: number;
+};
+/** Number of waits created during workflow execution */
+export declare const WorkflowWaitsCreated: (value: number) => {
+    [k: string]: number;
+};
+/** Name of the step function being executed */
+export declare const StepName: (value: string) => {
+    [k: string]: string;
+};
+/** Unique identifier for the step instance */
+export declare const StepId: (value: string) => {
+    [k: string]: string;
+};
+/** Current attempt number for step execution (starts at 1) */
+export declare const StepAttempt: (value: number) => {
+    [k: string]: number;
+};
+/** Current status of the step */
+export declare const StepStatus: (value: "pending" | "running" | "cancelled" | "completed" | "failed") => {
+    [k: string]: "pending" | "running" | "cancelled" | "completed" | "failed";
+};
+/** Maximum number of retries allowed for this step */
+export declare const StepMaxRetries: (value: number) => {
+    [k: string]: number;
+};
+/** Whether trace context was propagated to this step execution */
+export declare const StepTracePropagated: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Whether the step was skipped during execution */
+export declare const StepSkipped: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Reason why the step was skipped */
+export declare const StepSkipReason: (value: "pending" | "running" | "cancelled" | "completed" | "failed") => {
+    [k: string]: "pending" | "running" | "cancelled" | "completed" | "failed";
+};
+/** Number of arguments passed to the step function */
+export declare const StepArgumentsCount: (value: number) => {
+    [k: string]: number;
+};
+/** Type of the step result */
+export declare const StepResultType: (value: string) => {
+    [k: string]: string;
+};
+/** Name of the error that caused step failure */
+export declare const StepErrorName: (value: string) => {
+    [k: string]: string;
+};
+/** Error message when step fails */
+export declare const StepErrorMessage: (value: string) => {
+    [k: string]: string;
+};
+/** Whether the step failed with a fatal error (no retries) */
+export declare const StepFatalError: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Whether all retry attempts have been exhausted */
+export declare const StepRetryExhausted: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Number of seconds to wait before next retry attempt */
+export declare const StepRetryTimeoutSeconds: (value: number) => {
+    [k: string]: number;
+};
+/** Whether the step will be retried after this failure */
+export declare const StepRetryWillRetry: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Messaging system identifier (standard OTEL: messaging.system) */
+export declare const MessagingSystem: (value: string) => {
+    [k: string]: string;
+};
+/** Destination name/queue name (standard OTEL: messaging.destination.name) */
+export declare const MessagingDestinationName: (value: string) => {
+    [k: string]: string;
+};
+/** The message id being handled (standard OTEL: messaging.message.id) */
+export declare const MessagingMessageId: (value: string & import("zod").$brand<"MessageId">) => {
+    [k: string]: string & import("zod").$brand<"MessageId">;
+};
+/** Operation type (standard OTEL: messaging.operation.type) */
+export declare const MessagingOperationType: (value: "publish" | "receive" | "process") => {
+    [k: string]: "publish" | "receive" | "process";
+};
+/** Time taken to enqueue the message in milliseconds (workflow-specific) */
+export declare const QueueOverheadMs: (value: number) => {
+    [k: string]: number;
+};
+/** Unique identifier for the deployment environment */
+export declare const DeploymentId: (value: string) => {
+    [k: string]: string;
+};
+/** Token identifying a specific hook */
+export declare const HookToken: (value: string) => {
+    [k: string]: string;
+};
+/** Unique identifier for a hook instance */
+export declare const HookId: (value: string) => {
+    [k: string]: string;
+};
+/** Whether a hook was found by its token */
+export declare const HookFound: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Number of webhook handlers triggered */
+export declare const WebhookHandlersTriggered: (value: number) => {
+    [k: string]: number;
+};
+export declare const WorkflowSuspensionState: (value: "suspended") => {
+    [k: string]: "suspended";
+};
+export declare const WorkflowSuspensionHookCount: (value: number) => {
+    [k: string]: number;
+};
+export declare const WorkflowSuspensionStepCount: (value: number) => {
+    [k: string]: number;
+};
+export declare const WorkflowSuspensionWaitCount: (value: number) => {
+    [k: string]: number;
+};
+/** HTTP request method (standard OTEL: http.request.method) */
+export declare const HttpRequestMethod: (value: string) => {
+    [k: string]: string;
+};
+/** Full URL of the request (standard OTEL: url.full) */
+export declare const UrlFull: (value: string) => {
+    [k: string]: string;
+};
+/** Server hostname (standard OTEL: server.address) */
+export declare const ServerAddress: (value: string) => {
+    [k: string]: string;
+};
+/** Server port (standard OTEL: server.port) */
+export declare const ServerPort: (value: number) => {
+    [k: string]: number;
+};
+/** HTTP response status code (standard OTEL: http.response.status_code) */
+export declare const HttpResponseStatusCode: (value: number) => {
+    [k: string]: number;
+};
+/** Error type when request fails (standard OTEL: error.type) */
+export declare const ErrorType: (value: string) => {
+    [k: string]: string;
+};
+/** Format used for parsing response body (cbor or json) */
+export declare const WorldParseFormat: (value: "cbor" | "json") => {
+    [k: string]: "cbor" | "json";
+};
+/** Number of pagination pages loaded when fetching workflow events */
+export declare const WorkflowEventsPagesLoaded: (value: number) => {
+    [k: string]: number;
+};
+/** Time spent deserializing the queue message in milliseconds */
+export declare const QueueDeserializeTimeMs: (value: number) => {
+    [k: string]: number;
+};
+/** Time spent executing the handler logic in milliseconds */
+export declare const QueueExecutionTimeMs: (value: number) => {
+    [k: string]: number;
+};
+/** Time spent serializing the response in milliseconds */
+export declare const QueueSerializeTimeMs: (value: number) => {
+    [k: string]: number;
+};
+/** The remote service name for Datadog service maps (Datadog-specific: peer.service) */
+export declare const PeerService: (value: string) => {
+    [k: string]: string;
+};
+/** RPC system identifier (standard OTEL: rpc.system) */
+export declare const RpcSystem: (value: string) => {
+    [k: string]: string;
+};
+/** RPC service name (standard OTEL: rpc.service) */
+export declare const RpcService: (value: string) => {
+    [k: string]: string;
+};
+/** RPC method name (standard OTEL: rpc.method) */
+export declare const RpcMethod: (value: string) => {
+    [k: string]: string;
+};
+/** Whether the error is retryable (workflow-specific) */
+export declare const ErrorRetryable: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Error category (workflow-specific: fatal, retryable, transient) */
+export declare const ErrorCategory: (value: "fatal" | "retryable" | "transient") => {
+    [k: string]: "fatal" | "retryable" | "transient";
+};
+//# sourceMappingURL=semantic-conventions.d.ts.map

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

@@ -0,0 +1,53 @@
+import type * as api from '#compiled/@opentelemetry/api/index.js';
+import type { Span, SpanKind, SpanOptions } from '#compiled/@opentelemetry/api/index.js';
+/**
+ * Serializes the current trace context into a format that can be passed through queues
+ * @returns A record of strings representing the trace context
+ */
+export declare function serializeTraceCarrier(): Promise<Record<string, string>>;
+/**
+ * Deserializes trace context and returns a context that can be used to continue the trace
+ * @param traceCarrier The serialized trace context
+ * @returns OpenTelemetry context with the restored trace
+ */
+export declare function deserializeTraceCarrier(traceCarrier: Record<string, string>): Promise<api.Context | undefined>;
+/**
+ * Runs a function within the context of a deserialized trace
+ * @param traceCarrier The serialized trace carrier (optional)
+ * @param fn The function to run within the trace context
+ * @returns The result of the function
+ */
+export declare function withTraceContext<T>(traceCarrier: Record<string, string> | undefined, fn: () => Promise<T>): Promise<T>;
+export declare function trace<T>(spanName: string, ...args: [fn: (span?: Span) => Promise<T>] | [opts: SpanOptions, fn: (span?: Span) => Promise<T>]): Promise<T>;
+export declare function getSpanContextForTraceCarrier(carrier: Record<string, string>): Promise<api.SpanContext | undefined>;
+export declare function getActiveSpan(): Promise<api.Span | undefined>;
+/**
+ * Wraps all methods of an object with tracing spans.
+ * @param prefix - Prefix for span names (e.g., "WORLD.runs")
+ * @param o - Object with methods to instrument
+ * @returns Instrumented object with same interface
+ */
+export declare function instrumentObject<T extends object>(prefix: string, o: T): T;
+export declare function getSpanKind(field: keyof typeof SpanKind): Promise<api.SpanKind | undefined>;
+export declare function withOtel<T>(fn: (otel: typeof api) => T): Promise<Awaited<T> | undefined>;
+export declare function linkToCurrentContext(): Promise<[api.Link] | undefined>;
+/**
+ * Workflow context to propagate via baggage
+ */
+export interface WorkflowBaggageContext {
+    workflowRunId: string;
+    workflowName: string;
+}
+/**
+ * Sets workflow context as OTEL baggage for automatic propagation.
+ * Baggage is propagated across service boundaries via HTTP headers.
+ * @param context - Workflow context to set as baggage
+ * @returns A function to run within the baggage context
+ */
+export declare function withWorkflowBaggage<T>(context: WorkflowBaggageContext, fn: () => Promise<T>): Promise<T>;
+/**
+ * Retrieves workflow context from OTEL baggage.
+ * @returns Workflow context if present in baggage, undefined otherwise
+ */
+export declare function getWorkflowBaggage(): Promise<WorkflowBaggageContext | undefined>;
+//# sourceMappingURL=telemetry.d.ts.map

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

@@ -0,0 +1,20 @@
+export declare function getErrorName(v: unknown): string;
+export declare function getErrorStack(v: unknown): string;
+export declare function isAbortError(value: unknown): value is {
+    name: 'AbortError';
+    message: string;
+    stack?: string;
+};
+export declare function promoteAbortErrorToFatal(value: unknown): unknown;
+export interface NormalizedUnknownError {
+    name: string;
+    message: string;
+    stack: string;
+}
+/**
+ * Normalizes unknown thrown values into a stable error shape.
+ * This handles Promise/thenable throw values so logs/events never end up
+ * with unhelpful "[object Promise]" messages.
+ */
+export declare function normalizeUnknownError(value: unknown): Promise<NormalizedUnknownError>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,40 @@
+/**
+ * Builds a workflow suspension log message based on the counts of steps,
+ * hooks, and waits. The structured logger attaches the run context, so the
+ * message itself only describes what's being enqueued.
+ * @param stepCount - Number of steps to be enqueued
+ * @param hookCount - Number of hooks to be enqueued
+ * @param waitCount - Number of waits to be enqueued
+ * @returns The formatted log message or null if all counts are 0
+ */
+export declare function buildWorkflowSuspensionMessage(stepCount: number, hookCount: number, waitCount: number): string | null;
+/**
+ * Generates a stream ID for a workflow run.
+ * User-defined streams include a "user" segment for isolation from future system-defined streams.
+ * Namespaces are base64-encoded to handle characters not allowed in Redis key names.
+ *
+ * @param runId - The workflow run ID
+ * @param namespace - Optional namespace for the stream
+ * @returns The stream ID in format: `strm_{ULID}_user_{base64(namespace)?}`
+ */
+export declare function getWorkflowRunStreamId(runId: string, namespace?: string): string;
+/**
+ * Generate a stream ID for an abort signal's backing stream.
+ * Uses the "_system_abort" namespace to isolate from user-defined streams.
+ *
+ * @param id - A unique identifier (typically a ULID)
+ * @returns The stream ID in format: `strm_{id}_system_abort`
+ */
+export declare function getAbortStreamId(id: string): string;
+/**
+ * Derive the abort stream name from a hook token.
+ * Hook tokens use the format `abrt_{id}`, and the corresponding stream is
+ * `strm_{id}_system_abort`.
+ */
+export declare function getAbortStreamIdFromToken(hookToken: string): string;
+/**
+ * A small wrapper around `waitUntil` that also returns
+ * the result of the awaited promise.
+ */
+export declare function waitedUntil<T>(fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=util.d.ts.map

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

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

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

@@ -0,0 +1,17 @@
+export interface CreateContextOptions {
+    seed: string;
+    fixedTimestamp: number;
+}
+/**
+ * Creates a Node.js `vm.Context` configured to be usable for
+ * executing workflow logic in a deterministic environment.
+ *
+ * @param options - The options for the context.
+ * @returns The context.
+ */
+export declare function createContext(options: CreateContextOptions): {
+    context: import("vm").Context;
+    globalThis: typeof globalThis;
+    updateTimestamp: (timestamp: number) => void;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/compiled/@workflow/core/vm/uint8array-base64.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Polyfill for the TC39 Uint8Array base64/hex proposal (Stage 4).
+ *
+ * Implements:
+ *  - Uint8Array.prototype.toBase64([options])
+ *  - Uint8Array.prototype.toHex()
+ *  - Uint8Array.fromBase64(string[, options])
+ *  - Uint8Array.fromHex(string)
+ *  - Uint8Array.prototype.setFromBase64(string[, options])
+ *  - Uint8Array.prototype.setFromHex(string)
+ *
+ * @see https://tc39.es/proposal-arraybuffer-base64/spec/
+ */
+/**
+ * Installs the Uint8Array base64/hex polyfill onto the given
+ * Uint8Array constructor and prototype. This is designed to be
+ * used inside the workflow VM context, operating on the VM's
+ * own Uint8Array rather than the host's.
+ */
+export declare function installUint8ArrayBase64(Uint8ArrayCtor: typeof Uint8Array): void;
+//# sourceMappingURL=uint8array-base64.d.ts.map

package/dist/src/compiled/@workflow/core/vm/uuid.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns a function that generates a random UUID, based on the given RNG.
+ *
+ * `rng` is expected to be a seeded random number generator (i.e. `seedrandom.PRNG` instance).
+ *
+ * @param rng - A function that returns a random number between 0 and 1.
+ * @returns A `crypto.randomUUID`-like function.
+ */
+export declare function createRandomUUID(rng: () => number): () => ReturnType<typeof crypto.randomUUID>;
+//# sourceMappingURL=uuid.d.ts.map

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

@@ -0,0 +1,65 @@
+import type { WorkflowOrchestratorContext } from '../private.js';
+import { ABORT_HOOK_TOKEN, ABORT_STREAM_NAME } from '../symbols.js';
+/**
+ * A lightweight AbortSignal implementation for the workflow VM context.
+ *
+ * `signal.aborted` and listeners are updated in two scenarios:
+ * 1. On first-run: when `abort()` is called in the workflow code
+ * 2. On replay: when the events consumer processes the `hook_received`
+ *    event (chained through promiseQueue for deterministic ordering)
+ *
+ * On replay, `abort()` in the workflow code becomes a no-op since
+ * `_setAborted` was already called by the events consumer.
+ */
+export declare class WorkflowAbortSignal {
+    #private;
+    aborted: boolean;
+    reason: unknown;
+    readonly [ABORT_STREAM_NAME]: string;
+    readonly [ABORT_HOOK_TOKEN]: string;
+    get onabort(): ((this: WorkflowAbortSignal) => void) | null;
+    set onabort(handler: ((this: WorkflowAbortSignal) => void) | null);
+    constructor(streamName: string, hookToken: string);
+    /**
+     * @internal Sets aborted state and fires listeners.
+     * Called by abort() on first-run, or by the events consumer on replay.
+     * Idempotent — second call is a no-op.
+     */
+    _setAborted(reason?: unknown): void;
+    addEventListener(type: string, listener: () => void): void;
+    removeEventListener(type: string, listener: () => void): void;
+    throwIfAborted(): void;
+}
+/**
+ * Creates a workflow-context `AbortController` class that uses hooks for
+ * durable state and streams for real-time step propagation.
+ *
+ * Follows the same pattern as `createCreateHook()` in `workflow/hook.ts`:
+ * - Registers a hook in the invocations queue on construction
+ * - Subscribes to the events consumer for hook_created/hook_received events
+ * - `abort()` calls `_setAborted` + marks the hook for resumption
+ * - The suspension handler processes the abort (creates event + writes stream)
+ * - On replay, the events consumer calls `_setAborted` when hook_received
+ *   is processed, and `abort()` in the workflow code becomes a no-op
+ */
+export declare function createCreateAbortController(ctx: WorkflowOrchestratorContext): {
+    new (): {
+        readonly signal: WorkflowAbortSignal;
+        abort(reason?: unknown): void;
+        readonly [ABORT_STREAM_NAME]: string;
+        readonly [ABORT_HOOK_TOKEN]: string;
+    };
+};
+/**
+ * Creates a workflow-context `AbortSignal` object with static methods.
+ */
+export declare function createAbortSignalStatics(): {
+    abort: (reason?: unknown) => WorkflowAbortSignal;
+    any: (signals: Iterable<{
+        aborted: boolean;
+        reason?: unknown;
+        addEventListener?: Function;
+    }>) => WorkflowAbortSignal;
+    timeout: () => never;
+};
+//# sourceMappingURL=abort-controller.d.ts.map

package/dist/src/compiled/@workflow/core/workflow/create-hook.d.ts

@@ -0,0 +1,7 @@
+import type { Hook, HookOptions, RequestWithResponse, Webhook, WebhookOptions } from '../create-hook.js';
+export declare function createHook<T = any>(options?: HookOptions): Hook<T>;
+export declare function createWebhook(options: WebhookOptions & {
+    respondWith: 'manual';
+}): Webhook<RequestWithResponse>;
+export declare function createWebhook(options?: WebhookOptions): Webhook<Request>;
+//# sourceMappingURL=create-hook.d.ts.map

package/dist/src/compiled/@workflow/core/workflow/define-hook.d.ts

@@ -0,0 +1,10 @@
+import type { Hook as HookEntity } from '#compiled/@workflow/world/index.js';
+import type { Hook, HookOptions } from '../create-hook.js';
+/**
+ * NOTE: This is the implementation of `defineHook()` that is used in workflow contexts.
+ */
+export declare function defineHook<TInput, TOutput = TInput>(): {
+    create(options?: HookOptions): Hook<TOutput>;
+    resume: (_token: string, _payload: TInput) => Promise<HookEntity | null>;
+};
+//# sourceMappingURL=define-hook.d.ts.map

package/dist/src/compiled/@workflow/core/workflow/get-workflow-metadata.d.ts

@@ -0,0 +1,32 @@
+export interface WorkflowMetadata {
+    /**
+     * The name of the workflow.
+     */
+    workflowName: string;
+    /**
+     * Unique identifier for the workflow run.
+     */
+    workflowRunId: string;
+    /**
+     * Timestamp when the workflow run started.
+     */
+    workflowStartedAt: Date;
+    /**
+     * The URL where the workflow can be triggered.
+     */
+    url: string;
+    /**
+     * Feature flags indicating which capabilities are active for this workflow run.
+     */
+    features: {
+        /**
+         * Whether encryption is enabled for this workflow run.
+         * When `true`, step inputs, outputs, and other serialized data
+         * are encrypted at rest.
+         */
+        encryption: boolean;
+    };
+}
+export declare const WORKFLOW_CONTEXT_SYMBOL: unique symbol;
+export declare function getWorkflowMetadata(): WorkflowMetadata;
+//# sourceMappingURL=get-workflow-metadata.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { Hook, HookOptions } from '../create-hook.js';
+import { type WorkflowOrchestratorContext } from '../private.js';
+export declare function createCreateHook(ctx: WorkflowOrchestratorContext): <T = any>(options?: HookOptions) => Hook<T>;
+//# sourceMappingURL=hook.d.ts.map

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

@@ -0,0 +1,12 @@
+import type { StepMetadata } from '../step/get-step-metadata.js';
+export { FatalError, RetryableError, type RetryableErrorOptions, } from '#compiled/@workflow/errors/index.js';
+export type { Hook, HookOptions } from '../create-hook.js';
+export { experimental_setAttributes } from './set-attributes.js';
+export { sleep } from '../sleep.js';
+export { createHook, createWebhook } from './create-hook.js';
+export { defineHook } from './define-hook.js';
+export { getWorkflowMetadata } from './get-workflow-metadata.js';
+export { getWritable } from './writable-stream.js';
+export declare function getStepMetadata(): StepMetadata;
+export declare function resumeHook(): void;
+//# sourceMappingURL=index.d.ts.map