@workflow/core 4.0.1-beta.35 → 4.0.1-beta.37

package/dist/flushable-stream.d.ts

@@ -0,0 +1,82 @@
+import { type PromiseWithResolvers } from '@workflow/utils';
+/**
+ * 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.
+ *
+ * 100ms is a compromise between:
+ * - Latency: how quickly we notice that the user has released their lock, and
+ * - Cost/CPU usage: how often timers fire, especially with many concurrent
+ *   streams or in serverless environments where billed time matters.
+ *
+ * This value should only be changed with care, as decreasing it will
+ * increase polling frequency (and thus potential cost), while increasing it
+ * will add worst-case delay before the `done` promise resolves after a lock
+ * is released.
+ */
+export declare const LOCK_POLL_INTERVAL_MS = 100;
+/**
+ * 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/flushable-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flushable-stream.d.ts","sourceRoot":"","sources":["../src/flushable-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,iBAAiB,CAAC;AAE3E;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,oBAAqB,SAAQ,oBAAoB,CAAC,IAAI,CAAC;IACtE,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAC;IACtB,gEAAgE;IAChE,WAAW,EAAE,OAAO,CAAC;IACrB,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;IACzD,wDAAwD;IACxD,uBAAuB,CAAC,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;CAC1D;AAED,wBAAgB,oBAAoB,IAAI,oBAAoB,CAO3D;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,oBAAoB,GAC1B,IAAI,CAwBN;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,cAAc,EACtB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,IAAI,CAAC,CAwDf"}

package/dist/flushable-stream.js

@@ -0,0 +1,214 @@
+import { withResolvers } from '@workflow/utils';
+/**
+ * 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.
+ *
+ * 100ms is a compromise between:
+ * - Latency: how quickly we notice that the user has released their lock, and
+ * - Cost/CPU usage: how often timers fire, especially with many concurrent
+ *   streams or in serverless environments where billed time matters.
+ *
+ * This value should only be changed with care, as decreasing it will
+ * increase polling frequency (and thus potential cost), while increasing it
+ * will add worst-case delay before the `done` promise resolves after a lock
+ * is released.
+ */
+export const LOCK_POLL_INTERVAL_MS = 100;
+export function createFlushableState() {
+    return {
+        ...withResolvers(),
+        pendingOps: 0,
+        doneResolved: false,
+        streamEnded: false,
+    };
+}
+/**
+ * Checks if a WritableStream is unlocked (user released lock) vs closed.
+ * When a stream is closed, .locked is false but getWriter() throws.
+ * We only want to resolve via polling when the stream is unlocked, not closed.
+ * If closed, the pump will handle resolution via the stream ending naturally.
+ */
+function isWritableUnlockedNotClosed(writable) {
+    if (writable.locked)
+        return false;
+    let writer;
+    try {
+        // Try to acquire writer - if successful, stream is unlocked (not closed)
+        writer = writable.getWriter();
+    }
+    catch {
+        // getWriter() throws if stream is closed/errored - let pump handle it
+        return false;
+    }
+    try {
+        writer.releaseLock();
+    }
+    catch {
+        // If releaseLock() throws for any reason, conservatively treat the
+        // stream as closed/errored so callers don't assume it's safe to use.
+        // The pump will observe the failure via the stream's end state.
+        return false;
+    }
+    return true;
+}
+/**
+ * Checks if a ReadableStream is unlocked (user released lock) vs closed.
+ */
+function isReadableUnlockedNotClosed(readable) {
+    if (readable.locked)
+        return false;
+    let reader;
+    try {
+        // Try to acquire reader - if successful, stream is unlocked (not closed)
+        reader = readable.getReader();
+    }
+    catch {
+        // getReader() throws if stream is closed/errored - let pump handle it
+        return false;
+    }
+    try {
+        reader.releaseLock();
+    }
+    catch {
+        // If releaseLock() throws for any reason, conservatively treat the
+        // stream as closed/errored so callers don't assume it's safe to use.
+        // The pump will observe the failure via the stream's end state.
+        return false;
+    }
+    return true;
+}
+/**
+ * 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 function pollWritableLock(writable, state) {
+    // Prevent multiple simultaneous polling on the same state
+    if (state.writablePollingInterval !== undefined) {
+        return;
+    }
+    const intervalId = setInterval(() => {
+        // Stop polling if already resolved or stream ended
+        if (state.doneResolved || state.streamEnded) {
+            clearInterval(intervalId);
+            state.writablePollingInterval = undefined;
+            return;
+        }
+        // Check if lock is released (not closed) and no pending ops
+        if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {
+            state.doneResolved = true;
+            state.resolve();
+            clearInterval(intervalId);
+            state.writablePollingInterval = undefined;
+        }
+    }, LOCK_POLL_INTERVAL_MS);
+    state.writablePollingInterval = intervalId;
+}
+/**
+ * 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 function pollReadableLock(readable, state) {
+    // Prevent multiple simultaneous polling on the same state
+    if (state.readablePollingInterval !== undefined) {
+        return;
+    }
+    const intervalId = setInterval(() => {
+        // Stop polling if already resolved or stream ended
+        if (state.doneResolved || state.streamEnded) {
+            clearInterval(intervalId);
+            state.readablePollingInterval = undefined;
+            return;
+        }
+        // Check if lock is released (not closed) and no pending ops
+        if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {
+            state.doneResolved = true;
+            state.resolve();
+            clearInterval(intervalId);
+            state.readablePollingInterval = undefined;
+        }
+    }, LOCK_POLL_INTERVAL_MS);
+    state.readablePollingInterval = intervalId;
+}
+/**
+ * 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 async function flushablePipe(source, sink, state) {
+    const reader = source.getReader();
+    const writer = sink.getWriter();
+    try {
+        while (true) {
+            // Check if stream has ended
+            if (state.streamEnded) {
+                return;
+            }
+            // Read from source - don't count as pending op since we're just waiting for data
+            // The important ops are writes to the sink (server)
+            const readResult = await reader.read();
+            // Check if stream has ended (e.g., due to error in another path) before processing
+            if (state.streamEnded) {
+                return;
+            }
+            if (readResult.done) {
+                // Source stream completed - close sink and resolve
+                state.streamEnded = true;
+                await writer.close();
+                // Resolve done promise if not already resolved
+                if (!state.doneResolved) {
+                    state.doneResolved = true;
+                    state.resolve();
+                }
+                return;
+            }
+            // Count write as a pending op - this is what we need to flush
+            state.pendingOps++;
+            try {
+                await writer.write(readResult.value);
+            }
+            finally {
+                state.pendingOps--;
+            }
+        }
+    }
+    catch (err) {
+        state.streamEnded = true;
+        if (!state.doneResolved) {
+            state.doneResolved = true;
+            state.reject(err);
+        }
+        // Propagate error through flushablePipe's own promise as well.
+        // Callers that rely on the FlushableStreamState should use `state.promise`,
+        // while other callers may depend on this rejection. Some known callers
+        // explicitly ignore this rejection (`.catch(() => {})`) and rely solely
+        // on `state.reject(err)` for error handling.
+        throw err;
+    }
+    finally {
+        reader.releaseLock();
+        writer.releaseLock();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/helpers.d.ts

@@ -1,4 +1,43 @@
-import type { Event, World } from '@workflow/world';
+import type { Event, HealthCheckPayload, World } from '@workflow/world';
+/**
+ * Result of a health check operation.
+ */
+export interface HealthCheckResult {
+    healthy: boolean;
+    /** Error message if health check failed */
+    error?: string;
+}
+/**
+ * Checks if the given message is a health check payload.
+ * If so, returns the parsed payload. Otherwise returns undefined.
+ */
+export declare function parseHealthCheckPayload(message: unknown): HealthCheckPayload | undefined;
+/**
+ * Handles a health check message by writing the result to the world's stream.
+ * The caller can listen to this stream to get the health check response.
+ *
+ * @param healthCheck - The parsed health check payload
+ * @param endpoint - Which endpoint is responding ('workflow' or 'step')
+ */
+export declare function handleHealthCheckMessage(healthCheck: HealthCheckPayload, endpoint: 'workflow' | 'step'): Promise<void>;
+export type HealthCheckEndpoint = 'workflow' | 'step';
+export interface HealthCheckOptions {
+    /** Timeout in milliseconds to wait for health check response. Default: 30000 (30s) */
+    timeout?: number;
+}
+/**
+ * Performs a health check by sending a message through the queue pipeline
+ * and verifying it is processed by the specified endpoint.
+ *
+ * This function bypasses Deployment Protection on Vercel because it goes
+ * through the queue infrastructure rather than direct HTTP.
+ *
+ * @param world - The World instance to use for the health check
+ * @param endpoint - Which endpoint to health check: 'workflow' or 'step'
+ * @param options - Optional configuration for the health check
+ * @returns Promise resolving to health check result
+ */
+export declare function healthCheck(world: World, endpoint: HealthCheckEndpoint, options?: HealthCheckOptions): Promise<HealthCheckResult>;
 /**
  * Loads all workflow run events by iterating through all pages of paginated results.
  * This ensures that *all* events are loaded into memory before running the workflow.

package/dist/runtime/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAKpD;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAwB7E;AAYD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,GAC3C,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAyBrC;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,iBAcxC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE;;cAS/D"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,KAAK,EACL,kBAAkB,EAElB,KAAK,EACN,MAAM,iBAAiB,CAAC;AAmBzB;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,GACf,kBAAkB,GAAG,SAAS,CAMhC;AAWD;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,kBAAkB,EAC/B,QAAQ,EAAE,UAAU,GAAG,MAAM,GAC5B,OAAO,CAAC,IAAI,CAAC,CAef;AAED,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CAkG5B;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAwB7E;AAYD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,GAC3C,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAyBrC;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,iBAcxC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE;;cAS/D"}

package/dist/runtime/helpers.js

@@ -1,6 +1,156 @@
+import { HealthCheckPayloadSchema } from '@workflow/world';
+import { monotonicFactory } from 'ulid';
 import * as Attribute from '../telemetry/semantic-conventions.js';
 import { getSpanKind, trace } from '../telemetry.js';
 import { getWorld } from './world.js';
+/** Default timeout for health checks in milliseconds */
+const DEFAULT_HEALTH_CHECK_TIMEOUT = 30_000;
+const generateId = monotonicFactory();
+/**
+ * Returns the stream name for a health check with the given correlation ID.
+ */
+function getHealthCheckStreamName(correlationId) {
+    return `__health_check__${correlationId}`;
+}
+/**
+ * Checks if the given message is a health check payload.
+ * If so, returns the parsed payload. Otherwise returns undefined.
+ */
+export function parseHealthCheckPayload(message) {
+    const result = HealthCheckPayloadSchema.safeParse(message);
+    if (result.success) {
+        return result.data;
+    }
+    return undefined;
+}
+/**
+ * Generates a fake runId for health check streams.
+ * This runId passes server validation but is not associated with a real run.
+ * The server skips run validation for streams starting with `__health_check__`.
+ */
+function generateHealthCheckRunId() {
+    return `wrun_${generateId()}`;
+}
+/**
+ * Handles a health check message by writing the result to the world's stream.
+ * The caller can listen to this stream to get the health check response.
+ *
+ * @param healthCheck - The parsed health check payload
+ * @param endpoint - Which endpoint is responding ('workflow' or 'step')
+ */
+export async function handleHealthCheckMessage(healthCheck, endpoint) {
+    const world = getWorld();
+    const streamName = getHealthCheckStreamName(healthCheck.correlationId);
+    const response = JSON.stringify({
+        healthy: true,
+        endpoint,
+        correlationId: healthCheck.correlationId,
+        timestamp: Date.now(),
+    });
+    // Use a fake runId that passes validation.
+    // The stream name includes the correlationId for identification.
+    // The server skips run validation for health check streams.
+    const fakeRunId = generateHealthCheckRunId();
+    await world.writeToStream(streamName, fakeRunId, response);
+    await world.closeStream(streamName, fakeRunId);
+}
+/**
+ * Performs a health check by sending a message through the queue pipeline
+ * and verifying it is processed by the specified endpoint.
+ *
+ * This function bypasses Deployment Protection on Vercel because it goes
+ * through the queue infrastructure rather than direct HTTP.
+ *
+ * @param world - The World instance to use for the health check
+ * @param endpoint - Which endpoint to health check: 'workflow' or 'step'
+ * @param options - Optional configuration for the health check
+ * @returns Promise resolving to health check result
+ */
+export async function healthCheck(world, endpoint, options) {
+    const timeout = options?.timeout ?? DEFAULT_HEALTH_CHECK_TIMEOUT;
+    const correlationId = `hc_${generateId()}`;
+    const streamName = getHealthCheckStreamName(correlationId);
+    // Determine which queue to use based on endpoint
+    const queueName = endpoint === 'workflow'
+        ? '__wkf_workflow_health_check'
+        : '__wkf_step_health_check';
+    const startTime = Date.now();
+    try {
+        // Send the health check message through the queue first
+        await world.queue(queueName, {
+            __healthCheck: true,
+            correlationId,
+        });
+        // Poll for the stream response with retries
+        // The stream may not exist immediately after queueing on Vercel
+        const pollInterval = 100; // ms between retries
+        while (Date.now() - startTime < timeout) {
+            try {
+                // Try to read from the stream by name (includes correlationId)
+                const stream = await world.readFromStream(streamName);
+                const reader = stream.getReader();
+                const chunks = [];
+                let done = false;
+                while (!done) {
+                    const result = await reader.read();
+                    done = result.done;
+                    if (result.value)
+                        chunks.push(result.value);
+                }
+                // If we got no data, the stream might not have been written yet
+                if (chunks.length === 0) {
+                    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+                    continue;
+                }
+                // Parse the response
+                const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+                const combined = new Uint8Array(totalLength);
+                let offset = 0;
+                for (const chunk of chunks) {
+                    combined.set(chunk, offset);
+                    offset += chunk.length;
+                }
+                const responseText = new TextDecoder().decode(combined);
+                let response;
+                try {
+                    response = JSON.parse(responseText);
+                }
+                catch {
+                    // Response might not be valid JSON yet, retry
+                    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+                    continue;
+                }
+                // Type guard: ensure response has the expected structure
+                if (typeof response !== 'object' ||
+                    response === null ||
+                    !('healthy' in response) ||
+                    typeof response.healthy !== 'boolean') {
+                    // Invalid structure, retry
+                    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+                    continue;
+                }
+                return {
+                    healthy: response.healthy,
+                };
+            }
+            catch {
+                // Stream might not exist yet, retry after a delay
+                await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            }
+        }
+        // Timeout reached
+        return {
+            healthy: false,
+            error: `Health check timed out after ${timeout}ms`,
+        };
+    }
+    catch (error) {
+        return {
+            healthy: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
 /**
  * Loads all workflow run events by iterating through all pages of paginated results.
  * This ensures that *all* events are loaded into memory before running the workflow.
@@ -90,4 +240,4 @@ export function getQueueOverhead(message) {
         return;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"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"}

package/dist/runtime/resume-hook.d.ts

@@ -13,7 +13,7 @@ export declare function getHookByToken(token: string): Promise<Hook>;
  * This function is called externally (e.g., from an API route or server action)
  * to send data to a hook and resume the associated workflow run.
  *
- * @param token - The unique token identifying the hook
+ * @param tokenOrHook - The unique token identifying the hook, or the hook object itself
  * @param payload - The data payload to send to the hook
  * @returns Promise resolving to the hook
  * @throws Error if the hook is not found or if there's an error during the process
@@ -36,7 +36,7 @@ export declare function getHookByToken(token: string): Promise<Hook>;
  * }
  * ```
  */
-export declare function resumeHook<T = any>(token: string, payload: T): Promise<Hook>;
+export declare function resumeHook<T = any>(tokenOrHook: string | Hook, payload: T): Promise<Hook>;
 /**
  * Resumes a webhook by sending a {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | Request}
  * object to a hook identified by its token.

package/dist/runtime/resume-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resume-hook.d.ts","sourceRoot":"","sources":["../../src/runtime/resume-hook.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAyB,MAAM,iBAAiB,CAAC;AAWnE;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,UAAU,CAAC,CAAC,GAAG,GAAG,EACtC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,IAAI,CAAC,CA6Ef;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,QAAQ,CAAC,CAkDnB"}
+{"version":3,"file":"resume-hook.d.ts","sourceRoot":"","sources":["../../src/runtime/resume-hook.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAyB,MAAM,iBAAiB,CAAC;AAWnE;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,UAAU,CAAC,CAAC,GAAG,GAAG,EACtC,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,IAAI,CAAC,CAkFf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,QAAQ,CAAC,CAkDnB"}

package/dist/runtime/resume-hook.js

@@ -27,7 +27,7 @@ export async function getHookByToken(token) {
  * This function is called externally (e.g., from an API route or server action)
  * to send data to a hook and resume the associated workflow run.
  *
- * @param token - The unique token identifying the hook
+ * @param tokenOrHook - The unique token identifying the hook, or the hook object itself
  * @param payload - The data payload to send to the hook
  * @returns Promise resolving to the hook
  * @throws Error if the hook is not found or if there's an error during the process
@@ -50,14 +50,16 @@ export async function getHookByToken(token) {
  * }
  * ```
  */
-export async function resumeHook(token, payload) {
+export async function resumeHook(tokenOrHook, payload) {
     return await waitedUntil(() => {
         return trace('HOOK.resume', async (span) => {
             const world = getWorld();
             try {
-                const hook = await getHookByToken(token);
+                const hook = typeof tokenOrHook === 'string'
+                    ? await getHookByToken(tokenOrHook)
+                    : tokenOrHook;
                 span?.setAttributes({
-                    ...Attribute.HookToken(token),
+                    ...Attribute.HookToken(hook.token),
                     ...Attribute.HookId(hook.hookId),
                     ...Attribute.WorkflowRunId(hook.runId),
                 });
@@ -101,7 +103,7 @@ export async function resumeHook(token, payload) {
             }
             catch (err) {
                 span?.setAttributes({
-                    ...Attribute.HookToken(token),
+                    ...Attribute.HookToken(typeof tokenOrHook === 'string' ? tokenOrHook : tokenOrHook.token),
                     ...Attribute.HookFound(false),
                 });
                 throw err;
@@ -169,7 +171,7 @@ export async function resumeWebhook(token, request) {
         // No `respondWith` value implies the default behavior of returning a 202
         response = new Response(null, { status: 202 });
     }
-    await resumeHook(hook.token, request);
+    await resumeHook(hook, request);
     if (responseReadable) {
         // Wait for the readable stream to emit one chunk,
         // which is the `Response` object
@@ -187,4 +189,4 @@ export async function resumeWebhook(token, request) {
     }
     return response;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/step-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/step-handler.ts"],"names":[],"mappings":"AA6aA;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CACjB,CAAC"}
+{"version":3,"file":"step-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/step-handler.ts"],"names":[],"mappings":"AA6bA;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CACjB,CAAC"}