@workflow/core 4.0.1-beta.0

package/dist/workflow/hook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../src/workflow/hook.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAI3D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAIjE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,2BAA2B,IAChC,CAAC,GAAG,GAAG,EAAE,UAAS,WAAgB,KAAG,IAAI,CAAC,CAAC,CAAC,CAiI5E"}

package/dist/workflow/hook.js

@@ -0,0 +1,101 @@
+import { EventConsumerResult } from '../events-consumer.js';
+import { WorkflowSuspension } from '../global.js';
+import { webhookLogger } from '../logger.js';
+import { hydrateStepReturnValue } from '../serialization.js';
+import { withResolvers } from '../util.js';
+export function createCreateHook(ctx) {
+    return function createHookImpl(options = {}) {
+        // Generate hook ID and token
+        const correlationId = `hook_${ctx.generateUlid()}`;
+        const token = options.token ?? ctx.generateNanoid();
+        // Add hook creation to invocations queue
+        ctx.invocationsQueue.push({
+            type: 'hook',
+            correlationId,
+            token,
+            metadata: options.metadata,
+        });
+        // Queue of hook events that have been received but not yet processed
+        const payloadsQueue = [];
+        // Queue of promises that resolve to the next hook payload
+        const promises = [];
+        let eventLogEmpty = false;
+        webhookLogger.debug('Hook consumer setup', { correlationId, token });
+        ctx.eventsConsumer.subscribe((event) => {
+            // If there are no events and there are promises waiting,
+            // it means the hook has been awaited, but an incoming payload has not yet been received.
+            // In this case, the workflow should be suspended until the hook is resumed.
+            if (!event) {
+                eventLogEmpty = true;
+                if (promises.length > 0) {
+                    setTimeout(() => {
+                        ctx.onWorkflowError(new WorkflowSuspension(ctx.invocationsQueue, ctx.globalThis));
+                    }, 0);
+                    return EventConsumerResult.Finished;
+                }
+            }
+            // Check for hook_created event to remove this hook from the queue if it was already created
+            if (event?.eventType === 'hook_created' &&
+                event.correlationId === correlationId) {
+                // Remove this hook from the invocations queue if it exists
+                const index = ctx.invocationsQueue.findIndex((item) => item.type === 'hook' && item.correlationId === correlationId);
+                if (index !== -1) {
+                    ctx.invocationsQueue.splice(index, 1);
+                }
+                return EventConsumerResult.Consumed;
+            }
+            if (event?.eventType === 'hook_received' &&
+                event.correlationId === correlationId) {
+                if (promises.length > 0) {
+                    const next = promises.shift();
+                    if (next) {
+                        // Reconstruct the payload from the event data
+                        const payload = hydrateStepReturnValue(event.eventData.payload, ctx.globalThis);
+                        next.resolve(payload);
+                    }
+                }
+                else {
+                    payloadsQueue.push(event);
+                }
+                return EventConsumerResult.Consumed;
+            }
+            return EventConsumerResult.NotConsumed;
+        });
+        // Helper function to create a new promise that waits for the next hook payload
+        function createHookPromise() {
+            const resolvers = withResolvers();
+            if (payloadsQueue.length > 0) {
+                const nextPayload = payloadsQueue.shift();
+                if (nextPayload) {
+                    const payload = hydrateStepReturnValue(nextPayload.eventData.payload, ctx.globalThis);
+                    resolvers.resolve(payload);
+                    return resolvers.promise;
+                }
+            }
+            if (eventLogEmpty) {
+                // If the event log is already empty then we know the hook will not be resolved.
+                // Treat this case as a "step not run" scenario and suspend the workflow.
+                setTimeout(() => {
+                    ctx.onWorkflowError(new WorkflowSuspension(ctx.invocationsQueue, ctx.globalThis));
+                }, 0);
+            }
+            promises.push(resolvers);
+            return resolvers.promise;
+        }
+        const hook = {
+            token,
+            // biome-ignore lint/suspicious/noThenProperty: Intentionally thenable
+            then(onfulfilled, onrejected) {
+                return createHookPromise().then(onfulfilled, onrejected);
+            },
+            // Support `for await (const payload of hook) { … }` syntax
+            async *[Symbol.asyncIterator]() {
+                while (true) {
+                    yield await this;
+                }
+            },
+        };
+        return hook;
+    };
+}
+//# sourceMappingURL=hook.js.map

package/dist/workflow/hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.js","sourceRoot":"","sources":["../../src/workflow/hook.ts"],"names":[],"mappings":"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"}

package/dist/workflow/index.d.ts

@@ -0,0 +1,10 @@
+import type { StepMetadata } from '../step/get-step-metadata.js';
+export { FatalError, RetryableError, type RetryableErrorOptions, } from '@workflow/errors';
+export type { Hook, HookOptions } from '../create-hook.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

package/dist/workflow/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAInD,wBAAgB,eAAe,IAAI,YAAY,CAI9C;AACD,wBAAgB,UAAU,SAIzB"}

package/dist/workflow/index.js

@@ -0,0 +1,14 @@
+export { FatalError, RetryableError, } from '@workflow/errors';
+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';
+// workflows can't use these functions, but we still need to provide
+// the export so bundling doesn't fail when step and workflow are in same file
+export function getStepMetadata() {
+    throw new Error('`getStepMetadata()` can only be called inside a step function');
+}
+export function resumeHook() {
+    throw new Error('`resumeHook()` can only be called from outside a workflow function');
+}
+//# sourceMappingURL=index.js.map

package/dist/workflow/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,UAAU,EACV,cAAc,GAEf,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAEnD,oEAAoE;AACpE,8EAA8E;AAC9E,MAAM,UAAU,eAAe;IAC7B,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAC;AACJ,CAAC;AACD,MAAM,UAAU,UAAU;IACxB,MAAM,IAAI,KAAK,CACb,oEAAoE,CACrE,CAAC;AACJ,CAAC"}

package/dist/workflow/writable-stream.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowWritableStreamOptions } from '../writable-stream.js';
+export declare function getWritable<W = any>(options?: WorkflowWritableStreamOptions): WritableStream<W>;
+//# sourceMappingURL=writable-stream.d.ts.map

package/dist/workflow/writable-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writable-stream.d.ts","sourceRoot":"","sources":["../../src/workflow/writable-stream.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AAE3E,wBAAgB,WAAW,CAAC,CAAC,GAAG,GAAG,EACjC,OAAO,GAAE,6BAAkC,GAC1C,cAAc,CAAC,CAAC,CAAC,CASnB"}

package/dist/workflow/writable-stream.js

@@ -0,0 +1,12 @@
+import { STREAM_NAME_SYMBOL, WORKFLOW_GET_STREAM_ID } from '../symbols.js';
+export function getWritable(options = {}) {
+    const { namespace } = options;
+    const name = globalThis[WORKFLOW_GET_STREAM_ID](namespace);
+    return Object.create(globalThis.WritableStream.prototype, {
+        [STREAM_NAME_SYMBOL]: {
+            value: name,
+            writable: false,
+        },
+    });
+}
+//# sourceMappingURL=writable-stream.js.map

package/dist/workflow/writable-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writable-stream.js","sourceRoot":"","sources":["../../src/workflow/writable-stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG3E,MAAM,UAAU,WAAW,CACzB,UAAyC,EAAE;IAE3C,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;IAC9B,MAAM,IAAI,GAAI,UAAkB,CAAC,sBAAsB,CAAC,CAAC,SAAS,CAAC,CAAC;IACpE,OAAO,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,cAAc,CAAC,SAAS,EAAE;QACxD,CAAC,kBAAkB,CAAC,EAAE;YACpB,KAAK,EAAE,IAAI;YACX,QAAQ,EAAE,KAAK;SAChB;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/workflow.d.ts

@@ -0,0 +1,3 @@
+import type { Event, WorkflowRun } from '@workflow/world';
+export declare function runWorkflow(workflowCode: string, workflowRun: WorkflowRun, events: Event[]): Promise<unknown>;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../src/workflow.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAyB1D,wBAAsB,WAAW,CAC/B,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,KAAK,EAAE,GACd,OAAO,CAAC,OAAO,CAAC,CAuhBlB"}

package/dist/workflow.js

@@ -0,0 +1,454 @@
+import { runInContext } from 'node:vm';
+import { ERROR_SLUGS } from '@workflow/errors';
+import * as nanoid from 'nanoid';
+import { monotonicFactory } from 'ulid';
+import { EventConsumerResult, EventsConsumer } from './events-consumer.js';
+import { ENOTSUP } from './global.js';
+import { dehydrateWorkflowReturnValue, hydrateWorkflowArguments, } from './serialization.js';
+import { createUseStep } from './step.js';
+import { BODY_INIT_SYMBOL, WORKFLOW_CREATE_HOOK, WORKFLOW_GET_STREAM_ID, WORKFLOW_USE_STEP, } from './symbols.js';
+import * as Attribute from './telemetry/semantic-conventions.js';
+import { trace } from './telemetry.js';
+import { getWorkflowRunStreamId, withResolvers } from './util.js';
+import { createContext } from './vm/index.js';
+import { WORKFLOW_CONTEXT_SYMBOL } from './workflow/get-workflow-metadata.js';
+import { createCreateHook } from './workflow/hook.js';
+export async function runWorkflow(workflowCode, workflowRun, events) {
+    return trace(`WORKFLOW.run ${workflowRun.workflowName}`, async (span) => {
+        span?.setAttributes({
+            ...Attribute.WorkflowName(workflowRun.workflowName),
+            ...Attribute.WorkflowRunId(workflowRun.runId),
+            ...Attribute.WorkflowRunStatus(workflowRun.status),
+            ...Attribute.WorkflowEventsCount(events.length),
+        });
+        const startedAt = workflowRun.startedAt;
+        if (!startedAt) {
+            throw new Error(`Workflow run "${workflowRun.runId}" has no "startedAt" timestamp (should not happen)`);
+        }
+        const { context, globalThis: vmGlobalThis, updateTimestamp, } = createContext({
+            seed: workflowRun.runId,
+            fixedTimestamp: +startedAt,
+        });
+        const workflowDiscontinuation = withResolvers();
+        const ulid = monotonicFactory(() => vmGlobalThis.Math.random());
+        const generateNanoid = nanoid.customRandom(nanoid.urlAlphabet, 21, (size) => new Uint8Array(size).map(() => 256 * vmGlobalThis.Math.random()));
+        const workflowContext = {
+            globalThis: vmGlobalThis,
+            onWorkflowError: workflowDiscontinuation.reject,
+            eventsConsumer: new EventsConsumer(events),
+            generateUlid: () => ulid(+startedAt),
+            generateNanoid,
+            invocationsQueue: [],
+        };
+        // Subscribe to the events log to update the timestamp in the vm context
+        workflowContext.eventsConsumer.subscribe((event) => {
+            const createdAt = event?.createdAt;
+            if (createdAt) {
+                updateTimestamp(+createdAt);
+            }
+            // Never consume events - this is only a passive subscriber
+            return EventConsumerResult.NotConsumed;
+        });
+        const useStep = createUseStep(workflowContext);
+        const createHook = createCreateHook(workflowContext);
+        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+        vmGlobalThis[WORKFLOW_USE_STEP] = useStep;
+        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+        vmGlobalThis[WORKFLOW_CREATE_HOOK] = createHook;
+        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+        vmGlobalThis[WORKFLOW_GET_STREAM_ID] = (namespace) => getWorkflowRunStreamId(workflowRun.runId, namespace);
+        // TODO: there should be a getUrl method on the world interface itself. This
+        // solution only works for vercel + embedded worlds.
+        const url = process.env.VERCEL_URL
+            ? `https://${process.env.VERCEL_URL}`
+            : `http://localhost:${process.env.PORT || 3000}`;
+        // For the workflow VM, we store the context in a symbol on the `globalThis` object
+        const ctx = {
+            workflowRunId: workflowRun.runId,
+            workflowStartedAt: new vmGlobalThis.Date(+startedAt),
+            url,
+        };
+        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+        vmGlobalThis[WORKFLOW_CONTEXT_SYMBOL] = ctx;
+        // NOTE: Will have a config override to use the custom fetch step.
+        //       For now `fetch` must be explicitly imported from `workflow`.
+        vmGlobalThis.fetch = () => {
+            throw new vmGlobalThis.Error(`Global "fetch" is unavailable in workflow functions. Use the "fetch" step function from "workflow" to make HTTP requests.\n\nLearn more: https://useworkflow.dev/err/${ERROR_SLUGS.FETCH_IN_WORKFLOW_FUNCTION}`);
+        };
+        // `Request` and `Response` are special built-in classes that invoke steps
+        // for the `json()`, `text()` and `arrayBuffer()` instance methods
+        class Request {
+            cache;
+            credentials;
+            destination;
+            headers;
+            integrity;
+            method;
+            mode;
+            redirect;
+            referrer;
+            referrerPolicy;
+            url;
+            keepalive;
+            signal;
+            duplex;
+            body;
+            constructor(input, init) {
+                // Handle URL input
+                if (typeof input === 'string' || input instanceof vmGlobalThis.URL) {
+                    const urlString = String(input);
+                    // Validate URL format
+                    try {
+                        new vmGlobalThis.URL(urlString);
+                        this.url = urlString;
+                    }
+                    catch (cause) {
+                        throw new TypeError(`Failed to parse URL from ${urlString}`, {
+                            cause,
+                        });
+                    }
+                }
+                else {
+                    // Input is a Request object - clone its properties
+                    this.url = input.url;
+                    if (!init) {
+                        this.method = input.method;
+                        this.headers = new vmGlobalThis.Headers(input.headers);
+                        this.body = input.body;
+                        this.mode = input.mode;
+                        this.credentials = input.credentials;
+                        this.cache = input.cache;
+                        this.redirect = input.redirect;
+                        this.referrer = input.referrer;
+                        this.referrerPolicy = input.referrerPolicy;
+                        this.integrity = input.integrity;
+                        this.keepalive = input.keepalive;
+                        this.signal = input.signal;
+                        this.duplex = input.duplex;
+                        this.destination = input.destination;
+                        return;
+                    }
+                    // If init is provided, merge: use source properties, then override with init
+                    // Copy all properties from the source Request first
+                    this.method = input.method;
+                    this.headers = new vmGlobalThis.Headers(input.headers);
+                    this.body = input.body;
+                    this.mode = input.mode;
+                    this.credentials = input.credentials;
+                    this.cache = input.cache;
+                    this.redirect = input.redirect;
+                    this.referrer = input.referrer;
+                    this.referrerPolicy = input.referrerPolicy;
+                    this.integrity = input.integrity;
+                    this.keepalive = input.keepalive;
+                    this.signal = input.signal;
+                    this.duplex = input.duplex;
+                    this.destination = input.destination;
+                }
+                // Override with init options if provided
+                // Set method
+                if (init?.method) {
+                    this.method = init.method.toUpperCase();
+                }
+                else if (typeof this.method !== 'string') {
+                    // Fallback to default for string input case
+                    this.method = 'GET';
+                }
+                // Set headers
+                if (init?.headers) {
+                    this.headers = new vmGlobalThis.Headers(init.headers);
+                }
+                else if (typeof input === 'string' ||
+                    input instanceof vmGlobalThis.URL) {
+                    // For string/URL input, create empty headers
+                    this.headers = new vmGlobalThis.Headers();
+                }
+                // Set other properties with init values or defaults
+                if (init?.mode !== undefined) {
+                    this.mode = init.mode;
+                }
+                else if (typeof this.mode !== 'string') {
+                    this.mode = 'cors';
+                }
+                if (init?.credentials !== undefined) {
+                    this.credentials = init.credentials;
+                }
+                else if (typeof this.credentials !== 'string') {
+                    this.credentials = 'same-origin';
+                }
+                if (init?.cache !== undefined) {
+                    this.cache = init.cache;
+                }
+                else if (typeof this.cache !== 'string') {
+                    this.cache = 'default';
+                }
+                if (init?.redirect !== undefined) {
+                    this.redirect = init.redirect;
+                }
+                else if (typeof this.redirect !== 'string') {
+                    this.redirect = 'follow';
+                }
+                if (init?.referrer !== undefined) {
+                    this.referrer = init.referrer;
+                }
+                else if (typeof this.referrer !== 'string') {
+                    this.referrer = 'about:client';
+                }
+                if (init?.referrerPolicy !== undefined) {
+                    this.referrerPolicy = init.referrerPolicy;
+                }
+                else if (typeof this.referrerPolicy !== 'string') {
+                    this.referrerPolicy = '';
+                }
+                if (init?.integrity !== undefined) {
+                    this.integrity = init.integrity;
+                }
+                else if (typeof this.integrity !== 'string') {
+                    this.integrity = '';
+                }
+                if (init?.keepalive !== undefined) {
+                    this.keepalive = init.keepalive;
+                }
+                else if (typeof this.keepalive !== 'boolean') {
+                    this.keepalive = false;
+                }
+                if (init?.signal !== undefined) {
+                    // @ts-expect-error - AbortSignal stub
+                    this.signal = init.signal;
+                }
+                else if (!this.signal) {
+                    // @ts-expect-error - AbortSignal stub
+                    this.signal = { aborted: false };
+                }
+                if (!this.duplex) {
+                    this.duplex = 'half';
+                }
+                if (!this.destination) {
+                    this.destination = 'document';
+                }
+                const body = init?.body;
+                // Validate that GET/HEAD methods don't have a body
+                if (body !== null &&
+                    body !== undefined &&
+                    (this.method === 'GET' || this.method === 'HEAD')) {
+                    throw new TypeError(`Request with GET/HEAD method cannot have body.`);
+                }
+                // Store the original BodyInit for serialization
+                if (body !== null && body !== undefined) {
+                    // Create a "fake" ReadableStream that stores the original body
+                    // This avoids doing async work during workflow replay
+                    this.body = Object.create(vmGlobalThis.ReadableStream.prototype, {
+                        [BODY_INIT_SYMBOL]: {
+                            value: body,
+                            writable: false,
+                        },
+                    });
+                }
+                else {
+                    this.body = null;
+                }
+            }
+            clone() {
+                ENOTSUP();
+            }
+            get bodyUsed() {
+                return false;
+            }
+            // TODO: implement these
+            blob;
+            formData;
+            async arrayBuffer() {
+                return resArrayBuffer(this);
+            }
+            async bytes() {
+                return new Uint8Array(await resArrayBuffer(this));
+            }
+            async json() {
+                return resJson(this);
+            }
+            async text() {
+                return resText(this);
+            }
+        }
+        vmGlobalThis.Request = Request;
+        const resJson = useStep('__builtin_response_json');
+        const resText = useStep('__builtin_response_text');
+        const resArrayBuffer = useStep('__builtin_response_array_buffer');
+        class Response {
+            type;
+            url;
+            status;
+            statusText;
+            body;
+            headers;
+            redirected;
+            constructor(body, init) {
+                this.status = init?.status ?? 200;
+                this.statusText = init?.statusText ?? '';
+                this.headers = new vmGlobalThis.Headers(init?.headers);
+                this.type = 'default';
+                this.url = '';
+                this.redirected = false;
+                // Validate that null-body status codes don't have a body
+                // Per HTTP spec: 204 (No Content), 205 (Reset Content), and 304 (Not Modified)
+                if (body !== null &&
+                    body !== undefined &&
+                    (this.status === 204 || this.status === 205 || this.status === 304)) {
+                    throw new TypeError(`Response constructor: Invalid response status code ${this.status}`);
+                }
+                // Store the original BodyInit for serialization
+                if (body !== null && body !== undefined) {
+                    // Create a "fake" ReadableStream that stores the original body
+                    // This avoids doing async work during workflow replay
+                    this.body = Object.create(vmGlobalThis.ReadableStream.prototype, {
+                        [BODY_INIT_SYMBOL]: {
+                            value: body,
+                            writable: false,
+                        },
+                    });
+                }
+                else {
+                    this.body = null;
+                }
+            }
+            // TODO: implement these
+            clone;
+            blob;
+            formData;
+            get ok() {
+                return this.status >= 200 && this.status < 300;
+            }
+            get bodyUsed() {
+                return false;
+            }
+            async arrayBuffer() {
+                return resArrayBuffer(this);
+            }
+            async bytes() {
+                return new Uint8Array(await resArrayBuffer(this));
+            }
+            async json() {
+                return resJson(this);
+            }
+            static json(data, init) {
+                const body = JSON.stringify(data);
+                const headers = new vmGlobalThis.Headers(init?.headers);
+                if (!headers.has('content-type')) {
+                    headers.set('content-type', 'application/json');
+                }
+                return new Response(body, { ...init, headers });
+            }
+            async text() {
+                return resText(this);
+            }
+            static error() {
+                ENOTSUP();
+            }
+            static redirect(url, status = 302) {
+                // Validate status code - only specific redirect codes are allowed
+                if (![301, 302, 303, 307, 308].includes(status)) {
+                    throw new RangeError(`Invalid redirect status code: ${status}. Must be one of: 301, 302, 303, 307, 308`);
+                }
+                // Create response with Location header
+                const headers = new vmGlobalThis.Headers();
+                headers.set('Location', String(url));
+                const response = Object.create(Response.prototype);
+                response.status = status;
+                response.statusText = '';
+                response.headers = headers;
+                response.body = null;
+                response.type = 'default';
+                response.url = '';
+                response.redirected = false;
+                return response;
+            }
+        }
+        vmGlobalThis.Response = Response;
+        class ReadableStream {
+            constructor() {
+                ENOTSUP();
+            }
+            get locked() {
+                return false;
+            }
+            cancel() {
+                ENOTSUP();
+            }
+            getReader() {
+                ENOTSUP();
+            }
+            pipeThrough() {
+                ENOTSUP();
+            }
+            pipeTo() {
+                ENOTSUP();
+            }
+            tee() {
+                ENOTSUP();
+            }
+            values() {
+                ENOTSUP();
+            }
+            static from() {
+                ENOTSUP();
+            }
+            [Symbol.asyncIterator]() {
+                ENOTSUP();
+            }
+        }
+        vmGlobalThis.ReadableStream = ReadableStream;
+        class WritableStream {
+            constructor() {
+                ENOTSUP();
+            }
+            get locked() {
+                return false;
+            }
+            abort() {
+                ENOTSUP();
+            }
+            close() {
+                ENOTSUP();
+            }
+            getWriter() {
+                ENOTSUP();
+            }
+        }
+        vmGlobalThis.WritableStream = WritableStream;
+        class TransformStream {
+            readable;
+            writable;
+            constructor() {
+                ENOTSUP();
+            }
+        }
+        vmGlobalThis.TransformStream = TransformStream;
+        // Eventually we'll probably want to provide our own `console` object,
+        // but for now we'll just expose the global one.
+        vmGlobalThis.console = globalThis.console;
+        // HACK: propagate symbol needed for AI gateway usage
+        const SYMBOL_FOR_REQ_CONTEXT = Symbol.for('@vercel/request-context');
+        // @ts-expect-error - `@types/node` says symbol is not valid, but it does work
+        vmGlobalThis[SYMBOL_FOR_REQ_CONTEXT] = globalThis[SYMBOL_FOR_REQ_CONTEXT];
+        // Get a reference to the user-defined workflow function
+        const workflowFn = runInContext(`${workflowCode}; globalThis.__private_workflows?.get(${JSON.stringify(workflowRun.workflowName)})`, context);
+        if (typeof workflowFn !== 'function') {
+            throw new ReferenceError(`Workflow ${JSON.stringify(workflowRun.workflowName)} must be a function, but got "${typeof workflowFn}" instead`);
+        }
+        const args = hydrateWorkflowArguments(workflowRun.input, vmGlobalThis);
+        span?.setAttributes({
+            ...Attribute.WorkflowArgumentsCount(args.length),
+        });
+        // Invoke user workflow
+        const result = await Promise.race([
+            workflowFn(...args),
+            workflowDiscontinuation.promise,
+        ]);
+        const dehydrated = dehydrateWorkflowReturnValue(result, vmGlobalThis);
+        span?.setAttributes({
+            ...Attribute.WorkflowResultType(typeof result),
+        });
+        return dehydrated;
+    });
+}
+//# sourceMappingURL=workflow.js.map