@vite-hub/workflow 0.0.4 → 0.1.0

package/README.md

@@ -1,15 +1,15 @@
 # @vite-hub/workflow
 
 <p>
-  <a href="https://vitehub.dev"><img alt="ViteHub" src="https://img.shields.io/badge/ViteHub-vitehub.dev-646cff?style=flat-square"></a>
-  <img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-ready-3178c6?style=flat-square">
-  <img alt="Vite" src="https://img.shields.io/badge/Vite-discovery-646cff?style=flat-square">
-  <img alt="Workflow" src="https://img.shields.io/badge/Workflow-durable%20steps-7c3aed?style=flat-square">
+  <a href="https://vitehub.dev"><img alt="ViteHub" src="https://comark-ui.onmax.me/badge.svg?label=ViteHub&amp;value=vitehub.dev"></a>
+  <img alt="TypeScript" src="https://comark-ui.onmax.me/badge.svg?label=TypeScript&amp;value=ready">
+  <img alt="Vite" src="https://comark-ui.onmax.me/badge.svg?label=Vite&amp;value=discovery">
+  <img alt="Workflow" src="https://comark-ui.onmax.me/badge.svg?label=Workflow&amp;value=durable+steps">
 </p>
 
 `@vite-hub/workflow` discovers named long-running work and exposes one provider-neutral API for starting and inspecting runs.
 
-Use a Workflow when the application needs a run id, durable state, retries, cancellation, or resumable work. Use [Queue](https://vitehub.dev/docs/server-primitives/queue) when background delivery is enough and the application does not need to inspect a run.
+Use a Workflow when the application needs a run id, durable state, retries, cancellation, or resumable work. Use [Queue](https://vitehub.dev/docs/queue) when background delivery is enough and the application does not need to inspect a run.
 
 ## Install
 
@@ -23,10 +23,14 @@ Then install the dependency required by the selected provider:
 | -------------------- | ------------------------------------------------------------------ | ------------------------------------------------------------------------ |
 | Cloudflare Workflows | None in application code                                           | Cloudflare owns run state.                                               |
 | Vercel Workflow      | `workflow` and `@workflow/builders` for native durable definitions | Native definitions survive function restarts; plain handlers run inline. |
-| OpenWorkflow         | `openworkflow`; add `postgres` when using Postgres                 | Requires explicit SQLite or Postgres storage.                            |
+| OpenWorkflow         | `openworkflow`; add `postgres` when using Postgres                 | Uses local SQLite by default. Configure durable storage for deployment. |
 
 Importing the provider-neutral package root does not load OpenWorkflow types. Worker lifecycle helpers live at `@vite-hub/workflow/runtime/openworkflow-worker`.
 
+Set `workflow.sqlite.path` or `workflow.postgres.url` to select OpenWorkflow storage. An explicit value takes precedence over ambient storage environment variables. A configured environment declaration must resolve to a value; missing configuration rejects before opening a backend. With no storage configuration or storage environment variables, OpenWorkflow uses `.vitehub/data/openworkflow.sqlite.db`.
+
+The former `workflow.database` option was never connected to Named Databases. It now rejects instead of silently selecting fallback storage. Replace it with `workflow.sqlite.path` or `workflow.postgres.url`.
+
 ## Define a workflow
 
 ```ts
@@ -52,7 +56,6 @@ ViteHub discovers `server/workflows/<name>.ts`, folder workflows such as `server
 // server/workflow-runtime.ts
 import type {
   ResolvedWorkflowOptions,
-  WorkflowDefinition,
   WorkflowDefinitionRegistry,
 } from "@vite-hub/workflow";
 import {
@@ -70,9 +73,7 @@ export const workflowConfig = {
 } satisfies ResolvedWorkflowOptions;
 
 const workflowRegistry = {
-  "onboard-user": async () => ({
-    default: (await import("./workflows/onboard-user.ts")).default as WorkflowDefinition,
-  }),
+  "onboard-user": () => import("./workflows/onboard-user.ts"),
 } satisfies WorkflowDefinitionRegistry;
 
 export function installWorkflowRuntime() {
@@ -147,6 +148,10 @@ The other runtime helpers are:
 
 Unsupported provider operations fail with `WORKFLOW_OPERATION_UNSUPPORTED`; ViteHub does not pretend that an inline run was cancelled or resumed.
 
+Inline runs buffer the response body before completion. Each inspection and duplicate start returns a fresh response, so reading or cancelling one result does not consume later results. A body read failure marks the run as failed.
+
+Inline run inspection uses weak references while execution is active. A reachable execution remains inspectable; an abandoned execution with no remaining owner can be garbage-collected and then reports `unknown`. Completed inline runs are retained for five minutes, up to 1,024 entries per runtime. Completed history does not evict active executions. If either `WeakRef` or `FinalizationRegistry` is unavailable, active inspection uses strong references capped at 1,024 entries. Starting another run evicts the oldest active inspection entry, even if execution is still reachable; it reports `unknown` and completion does not restore it. Use a durable provider when inspection must survive abandonment or a process restart.
+
 ## Make a Vercel workflow durable
 
 A plain Vercel definition executes inline and does not survive a function restart. For durable execution, keep the same context-shaped handler and register a native Workflow DevKit entry:
@@ -156,7 +161,7 @@ pnpm add workflow @workflow/builders
 ```
 
 ```ts
-import { defineWorkflow, type WorkflowExecutionContext } from "@vite-hub/workflow";
+import { defineWorkflow, type WorkflowExecutionContext, type WorkflowProviderContext } from "@vite-hub/workflow";
 
 interface OnboardPayload {
   email: string;
@@ -168,7 +173,7 @@ async function upsertUserStep(email: string) {
   return await upsertUser(email, { idempotencyKey: `onboard-user:${email}` });
 }
 
-async function durableOnboard({ payload }: WorkflowExecutionContext<OnboardPayload>) {
+async function durableOnboard({ payload }: WorkflowProviderContext<OnboardPayload>) {
   "use workflow";
 
   const user = await upsertUserStep(payload.email);
@@ -183,7 +188,7 @@ async function inlineOnboard({ payload }: WorkflowExecutionContext<OnboardPayloa
 export default defineWorkflow(inlineOnboard, { native: durableOnboard });
 ```
 
-ViteHub transforms `native` when it generates Vercel output. Other providers keep using the normal handler. Put external side effects in idempotent `use step` functions because a durable step may be retried.
+ViteHub transforms `native` when it generates Vercel output. Other providers keep using the normal handler. Vercel calls `native` with a `WorkflowProviderContext`, which has no `steps` runner. Put external side effects in idempotent `use step` functions because a durable step may be retried.
 
 ## Handle stable failures
 
@@ -216,8 +221,23 @@ async function transcribe(recordingId: string) {
 
 ## Documentation
 
-- [Workflow guide](https://vitehub.dev/docs/server-primitives/workflows)
+- [Workflow guide](https://vitehub.dev/docs/workflows)
 - [Runtime and host support](https://vitehub.dev/docs/frameworks-hosts/support-matrix)
 - [OpenWorkflow](https://openworkflow.dev/docs/overview)
 - [Cloudflare Workflows](https://developers.cloudflare.com/workflows/)
 - [Vercel Workflow](https://vercel.com/docs/workflow)
+
+
+## Required handle input
+
+A typed Workflow handle requires a payload when its handler requires one. Both `run()` and `defer()` use this rule. A handle with an optional payload or `void` input can still run with no argument. To set start options for a no-input Workflow, pass `undefined` first.
+
+```ts
+const welcome = createWorkflow<{ email: string }>("welcome", async ({ payload }) => {
+  await sendWelcomeEmail(payload.email)
+})
+await welcome.run({ email: "ada@example.com" })
+// welcome.run() is a type error.
+```
+
+This is a breaking type correction. Supply the required payload at each handle call. Named operational functions do not infer a handler from a string, and persisted run results remain unknown.

package/dist/{_app-DgwN4ulW.d.ts → app-BojnC_yf.d.ts}

@@ -5,7 +5,4 @@ type VitehubApp = AppHandler | {
   request?: (request: Request, options?: RequestInit, context?: Record<string, unknown>) => Response | Promise<Response>;
 };
 //#endregion
-//#region src/runtime/_app.d.ts
-type WorkflowApp = VitehubApp;
-//#endregion
-export { WorkflowApp as t };
+export { VitehubApp as t };

package/dist/{app-BZpq2cwC.js → app-CzPoP84f.js}

@@ -1,10 +1,11 @@
+import { t as internalErrorDiagnostics } from "./error-diagnostics-A_8Kp-48.js";
 //#region ../internal/src/runtime/app.ts
 function resolveAppFetch(label, app) {
 	if (!app) return;
 	if (typeof app === "function") return app;
 	if (typeof app.request === "function") return (request, context) => app.request(request, void 0, context);
 	if (typeof app.fetch === "function") return app.fetch.bind(app);
-	throw new TypeError(`Invalid ${label} app. Expected an h3 app or a fetch-compatible handler.`);
+	throw internalErrorDiagnostics.INTERNAL_R0011({ message: `Invalid ${label} app. Expected an h3 app or a fetch-compatible handler.` });
 }
 //#endregion
 export { resolveAppFetch as t };

package/dist/client-DsGM3M4U.js

@@ -0,0 +1,389 @@
+import { t as normalizeWorkflowOptions } from "./config-IJMb0eeZ.js";
+import { t as workflowErrorDiagnostics } from "./error-diagnostics-pwNFvAHP.js";
+import { n as getCloudflareWorkflowBindingName, o as encodeNameHex } from "./cloudflare-nF4abPd4.js";
+import { t as hasRuntimeType } from "./runtime-type-DBCvIh5x.js";
+import { a as createWorkflowError, i as safeWorkflowName, r as runWorkflowProviderOperation } from "./provider-operation-CW2cYfVy.js";
+import { n as getCloudflareEnv, r as resolveWaitUntil } from "./cloudflare-env-BNrYo29x.js";
+import { runSerializedWorkflowHandler } from "./runtime/execute.js";
+import { getOpenWorkflowRun, runOpenWorkflow } from "./runtime/openworkflow.js";
+import { getWorkflowRunState, getWorkflowRuntimeConfig, getWorkflowRuntimeEvent, getWorkflowRuntimeRegistry, loadWorkflowDefinition, registerInlineWorkflowDefinition, runWithWorkflowRuntimeEvent, setWorkflowRun } from "./runtime/state.js";
+import { a as startVercelWorkflow, n as inspectVercelWorkflowRun, r as resumeVercelWorkflowSignal, t as cancelVercelWorkflow } from "./vercel-D-ZNtB_u.js";
+import { deserializeResponse, isSerializedResponse } from "@vite-hub/runtime";
+//#region src/integrations/vercel.ts
+function getVercelWorkflowName(name) {
+	return `workflow--${encodeNameHex(name)}`;
+}
+//#endregion
+//#region ../internal/src/runtime/random.ts
+function randomId(prefix) {
+	const body = `${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+	return prefix ? `${prefix}_${body}` : body;
+}
+//#endregion
+//#region src/runtime/adapters.ts
+function resolveDispatchObserver(event) {
+	if (!event || !hasRuntimeType(event, "object")) return void 0;
+	const candidate = Object.hasOwn(event, "onDispatch") ? Reflect.get(event, "onDispatch") : void 0;
+	return hasRuntimeType(candidate, "function") ? candidate : void 0;
+}
+function resolveSettlementObserver(event) {
+	if (!event || !hasRuntimeType(event, "object")) return void 0;
+	const candidate = Object.hasOwn(event, "settled") ? Reflect.get(event, "settled") : void 0;
+	if (hasRuntimeType(candidate, "function")) return candidate;
+	const context = Object.hasOwn(event, "context") ? Reflect.get(event, "context") : void 0;
+	if (!context || !hasRuntimeType(context, "object")) return void 0;
+	const contextObject = Object(context);
+	const nested = Object.hasOwn(contextObject, "settled") ? Reflect.get(contextObject, "settled") : void 0;
+	return hasRuntimeType(nested, "function") ? nested : void 0;
+}
+function unsupportedOperation(provider, operation) {
+	throw createWorkflowError({
+		code: "WORKFLOW_OPERATION_UNSUPPORTED",
+		details: {
+			operation,
+			provider
+		}
+	});
+}
+function resolveCloudflareBinding(event, binding, name, definition) {
+	const env = getCloudflareEnv(event);
+	const bindingName = definition?.internalAgentInvocationRecovery ? getCloudflareWorkflowBindingName(name) : binding || getCloudflareWorkflowBindingName(name);
+	return env && Object.hasOwn(env, bindingName) ? env[bindingName] : void 0;
+}
+function resolveCloudflareInspectionBinding(event, binding, name) {
+	return resolveCloudflareBinding(event, binding, name, getWorkflowRuntimeRegistry()?.[name]);
+}
+function normalizeCloudflareWorkflowStart(value, expectedId) {
+	if (!hasRuntimeType(value, "object") || value === null) throw new Error("Cloudflare Workflow provider returned an invalid workflow instance.");
+	let id;
+	try {
+		id = Reflect.get(value, "id");
+	} catch (cause) {
+		throw new Error("Cloudflare Workflow provider returned an invalid workflow instance.", { cause });
+	}
+	if (!hasRuntimeType(id, "string") || !id || id !== expectedId) throw new Error("Cloudflare Workflow provider returned an invalid workflow instance.");
+	return { id };
+}
+const cloudflareStatusMap = {
+	cancelled: "cancelled",
+	complete: "completed",
+	completed: "completed",
+	errored: "failed",
+	failed: "failed",
+	queued: "queued",
+	running: "running",
+	success: "completed",
+	terminated: "failed"
+};
+function normalizeCloudflareStatus(status) {
+	const value = hasRuntimeType(status, "object") && status && Object.hasOwn(status, "status") ? status.status : status;
+	const normalized = String(value || "").toLowerCase();
+	return Object.hasOwn(cloudflareStatusMap, normalized) ? cloudflareStatusMap[normalized] : "unknown";
+}
+function ownSerializedOutput(metadata) {
+	if (!hasRuntimeType(metadata, "object") || metadata === null || !Object.hasOwn(metadata, "output")) return void 0;
+	const output = metadata.output;
+	return isSerializedResponse(output) ? output : void 0;
+}
+function hasUnknownWorkflowAcknowledgement(error) {
+	if (!error || !hasRuntimeType(error, "object")) return false;
+	const details = error.details;
+	return Boolean(details && hasRuntimeType(details, "object") && details.acknowledgement === "unknown");
+}
+function createCloudflareAdapter(config) {
+	return {
+		cancel: () => unsupportedOperation("cloudflare", "cancellation"),
+		async get({ event, id, name }) {
+			const binding = resolveCloudflareInspectionBinding(event, config.binding, name);
+			if (binding) {
+				const instance = await runWorkflowProviderOperation("cloudflare", "get", () => binding.get(id));
+				const metadata = await runWorkflowProviderOperation("cloudflare", "status", () => instance.status());
+				const output = ownSerializedOutput(metadata);
+				return {
+					id,
+					metadata,
+					provider: "cloudflare",
+					result: output ? deserializeResponse(output) : void 0,
+					status: normalizeCloudflareStatus(metadata)
+				};
+			}
+			return await inlineAdapter(config).get({
+				event,
+				id,
+				name
+			});
+		},
+		async run({ definition, event, id, name, options, payload }) {
+			const binding = resolveCloudflareBinding(event, config.binding, name, definition);
+			if (binding) {
+				resolveDispatchObserver(event)?.();
+				const start = () => runWorkflowProviderOperation("cloudflare", "create", async () => normalizeCloudflareWorkflowStart((await binding.createBatch([{
+					id,
+					params: payload
+				}]))[0] || await binding.get(id), id), { acknowledgementUnknown: (_error, status) => status === void 0 });
+				const creation = start().catch(async (firstError) => {
+					try {
+						return await start();
+					} catch (retryError) {
+						if (hasUnknownWorkflowAcknowledgement(firstError)) throw firstError;
+						throw retryError;
+					}
+				});
+				const waitUntil = options.deferred ? resolveWaitUntil(event) : void 0;
+				if (waitUntil) waitUntil(creation);
+				return {
+					id: (await creation).id,
+					payload,
+					provider: "cloudflare",
+					status: "queued"
+				};
+			}
+			return await inlineAdapter(config).run({
+				definition,
+				event,
+				id,
+				name,
+				options,
+				payload
+			});
+		},
+		resume: () => unsupportedOperation("cloudflare", "signals")
+	};
+}
+function createOpenWorkflowAdapter(config) {
+	return {
+		cancel: () => unsupportedOperation("openworkflow", "cancellation"),
+		get: async ({ id, name }) => await getOpenWorkflowRun(config, name, id),
+		resume: () => unsupportedOperation("openworkflow", "signals"),
+		run: async ({ definition, event, name, options, payload }) => await runOpenWorkflow(config, name, payload, definition, options, resolveDispatchObserver(event))
+	};
+}
+function inlineAdapter(config) {
+	return {
+		cancel: () => unsupportedOperation(config.provider, "cancellation"),
+		async get({ id, name }) {
+			const run = getWorkflowRunState(name, id);
+			if (run) {
+				if (run.status === "running") return {
+					id,
+					provider: config.provider,
+					status: "running"
+				};
+				return {
+					id,
+					metadata: run.error,
+					provider: config.provider,
+					result: isSerializedResponse(run.result) ? deserializeResponse(run.result) : run.result,
+					status: run.status
+				};
+			}
+			return {
+				id,
+				provider: config.provider,
+				status: "unknown"
+			};
+		},
+		async run({ definition, event, id, name, payload }) {
+			const existing = getWorkflowRunState(name, id);
+			if (existing) return {
+				id,
+				metadata: existing.error ?? (config.provider === "vercel" ? {
+					mode: "inline",
+					workflow: getVercelWorkflowName(name)
+				} : void 0),
+				payload: existing.payload,
+				provider: config.provider,
+				result: isSerializedResponse(existing.result) ? deserializeResponse(existing.result) : existing.result,
+				status: existing.status === "running" ? "queued" : existing.status
+			};
+			resolveDispatchObserver(event)?.();
+			const run = Promise.resolve().then(() => runSerializedWorkflowHandler({
+				id,
+				name,
+				payload,
+				provider: config.provider
+			}, definition)).then((result) => ({
+				result,
+				status: "completed"
+			})).catch((error) => ({
+				error,
+				status: "failed"
+			}));
+			const runState = setWorkflowRun(name, id, run, payload, true);
+			const waitUntil = resolveWaitUntil(event);
+			if (waitUntil) waitUntil(runState.promise);
+			return {
+				id,
+				metadata: config.provider === "vercel" ? {
+					mode: "inline",
+					workflow: getVercelWorkflowName(name)
+				} : void 0,
+				payload,
+				provider: config.provider,
+				status: "queued"
+			};
+		},
+		resume: () => unsupportedOperation(config.provider, "signals")
+	};
+}
+function createVercelAdapter(config) {
+	const fallback = inlineAdapter(config);
+	return {
+		async cancel({ id, name }) {
+			const definition = await loadWorkflowDefinition(name);
+			if (!definition?.options?.native) return await fallback.cancel({
+				event: void 0,
+				id,
+				name
+			});
+			return await cancelVercelWorkflow(name, definition, id);
+		},
+		async get({ id, name }) {
+			const definition = await loadWorkflowDefinition(name);
+			return definition?.options?.native ? await inspectVercelWorkflowRun(name, definition, id) : await fallback.get({
+				event: void 0,
+				id,
+				name
+			});
+		},
+		resume: async (token, payload) => await resumeVercelWorkflowSignal(token, payload),
+		async run({ definition, event, id, name, options, payload }) {
+			if (!definition.options?.native) return await fallback.run({
+				definition,
+				event,
+				id,
+				name,
+				options,
+				payload
+			});
+			if (options.id) throw createWorkflowError({
+				code: "WORKFLOW_RUN_ID_UNSUPPORTED",
+				details: {
+					...safeWorkflowName(name) ? { name } : {},
+					provider: "vercel"
+				}
+			});
+			return await startVercelWorkflow(name, definition, payload, resolveSettlementObserver(event), resolveDispatchObserver(event));
+		}
+	};
+}
+function getWorkflowRuntimeAdapter(config) {
+	if (config.provider === "cloudflare") return createCloudflareAdapter(config);
+	if (config.provider === "openworkflow") return createOpenWorkflowAdapter(config);
+	return createVercelAdapter(config);
+}
+//#endregion
+//#region src/runtime/client.ts
+function getActiveWorkflowConfig() {
+	const config = getWorkflowRuntimeConfig();
+	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
+	return config || normalizeWorkflowOptions(void 0, { hosting: "vercel" });
+}
+async function loadRequiredWorkflowDefinition(name) {
+	const definition = await loadWorkflowDefinition(name);
+	if (!definition) throw createWorkflowError({
+		code: "WORKFLOW_DEFINITION_NOT_FOUND",
+		details: safeWorkflowName(name) ? { name } : void 0
+	});
+	return definition;
+}
+function normalizeWorkflowRunIdValue(value) {
+	if (value === void 0) return null;
+	if (value === null || !hasRuntimeType(value, "object")) return value;
+	if (Array.isArray(value)) return value.map((item) => normalizeWorkflowRunIdValue(item));
+	const record = value;
+	return Object.fromEntries(Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => [key, normalizeWorkflowRunIdValue(record[key])]));
+}
+async function sha256Hex(value) {
+	const data = new TextEncoder().encode(value);
+	const digest = await crypto.subtle.digest("SHA-256", data);
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function createStableWorkflowRunId(name, value) {
+	const hash = await sha256Hex(`${name}:${JSON.stringify(normalizeWorkflowRunIdValue(value))}`);
+	return `${name.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || "workflow"}-${hash.slice(0, 32)}`;
+}
+async function resolveWorkflowStartOptions(name, payload, createOptions, startOptions) {
+	if (startOptions.id || !createOptions?.id) return startOptions;
+	return {
+		...startOptions,
+		id: await createStableWorkflowRunId(name, await createOptions.id({
+			name,
+			payload
+		}))
+	};
+}
+function createWorkflow(nameOrOptions, handlerOrOptions, options) {
+	let name;
+	let handler;
+	let createOptions;
+	if (hasRuntimeType(nameOrOptions, "object") && nameOrOptions !== null) {
+		createOptions = nameOrOptions;
+		if (!createOptions.name || !hasRuntimeType(createOptions.name, "string")) throw workflowErrorDiagnostics.WORKFLOW_R0009({ message: "`createWorkflow()` requires a workflow name." });
+		if (!hasRuntimeType(createOptions.handler, "function")) throw workflowErrorDiagnostics.WORKFLOW_R0010({ message: "`createWorkflow()` requires a workflow handler." });
+		name = createOptions.name;
+		handler = createOptions.handler;
+	} else {
+		name = nameOrOptions;
+		if (!name || !hasRuntimeType(name, "string")) throw workflowErrorDiagnostics.WORKFLOW_R0011({ message: "`createWorkflow()` requires a workflow name." });
+		handler = hasRuntimeType(handlerOrOptions, "function") ? handlerOrOptions : hasRuntimeType(handlerOrOptions, "object") && handlerOrOptions !== null ? handlerOrOptions.handler : void 0;
+		createOptions = hasRuntimeType(handlerOrOptions, "function") ? options : handlerOrOptions;
+		if (handler !== void 0 && !hasRuntimeType(handler, "function")) throw workflowErrorDiagnostics.WORKFLOW_R0012({ message: "`createWorkflow()` requires a workflow handler." });
+		if (handler === void 0 && handlerOrOptions !== void 0 && (!hasRuntimeType(handlerOrOptions, "object") || handlerOrOptions === null)) throw workflowErrorDiagnostics.WORKFLOW_R0013({ message: "`createWorkflow()` options must be an object." });
+	}
+	if (handler !== void 0) registerInlineWorkflowDefinition(name, {
+		handler,
+		...createOptions?.rootStep === void 0 ? {} : { options: { rootStep: createOptions.rootStep } }
+	});
+	return {
+		cancel: (id) => cancelWorkflow(name, id),
+		name,
+		defer: async (payload, options = {}) => deferWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options)),
+		getRun: (id) => getWorkflowRun(name, id),
+		async run(payload, options = {}) {
+			return await runWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options));
+		}
+	};
+}
+async function runWorkflow(name, payload, options = {}) {
+	const config = getActiveWorkflowConfig();
+	const id = options.id || randomId("wrun");
+	const definition = await loadRequiredWorkflowDefinition(name);
+	return await getWorkflowRuntimeAdapter(config).run({
+		definition,
+		event: getWorkflowRuntimeEvent(),
+		id,
+		name,
+		options,
+		payload
+	});
+}
+async function getWorkflowRun(name, id) {
+	return await getWorkflowRuntimeAdapter(getActiveWorkflowConfig()).get({
+		event: getWorkflowRuntimeEvent(),
+		id,
+		name
+	});
+}
+async function cancelWorkflow(name, id) {
+	const config = getActiveWorkflowConfig();
+	await loadRequiredWorkflowDefinition(name);
+	return await getWorkflowRuntimeAdapter(config).cancel({
+		event: getWorkflowRuntimeEvent(),
+		id,
+		name
+	});
+}
+async function resumeWorkflowSignal(token, payload) {
+	if (!token || !hasRuntimeType(token, "string")) throw workflowErrorDiagnostics.WORKFLOW_R0014({ message: "`resumeWorkflowSignal()` requires an opaque signal token." });
+	return await getWorkflowRuntimeAdapter(getActiveWorkflowConfig()).resume(token, payload);
+}
+function deferWorkflow(name, payload, options = {}) {
+	const request = getWorkflowRuntimeEvent();
+	return runWithWorkflowRuntimeEvent(request, () => runWorkflow(name, payload, {
+		...options,
+		deferred: true
+	}));
+}
+//#endregion
+export { resumeWorkflowSignal as a, getWorkflowRun as i, createWorkflow as n, runWorkflow as o, deferWorkflow as r, getVercelWorkflowName as s, cancelWorkflow as t };

package/dist/cloudflare-env-BNrYo29x.js

@@ -0,0 +1,113 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region ../internal/src/runtime/cloudflare-env.ts
+let activeEnv;
+const activeEnvStorageKey = Symbol.for("vitehub.cloudflare.env-storage");
+const runtimeGlobal = globalThis;
+const activeEnvStorage = runtimeGlobal[activeEnvStorageKey] ||= new AsyncLocalStorage();
+const globalEnvProbe = Symbol("vitehub.cloudflare.global-env-probe");
+/**
+* Under the Nitro Cloudflare dev server, `cloudflare:workers` exports unenv's env proxy, which reads every key from
+* `globalThis.__env__`. Storing that proxy in `__env__` makes it read itself, and the next read overflows the stack.
+*/
+function readsGlobalEnv(env) {
+	const scope = globalThis;
+	const owned = Object.hasOwn(scope, "__env__");
+	const previous = scope.__env__;
+	scope.__env__ = { [globalEnvProbe]: true };
+	try {
+		return Reflect.get(env, globalEnvProbe) === true;
+	} catch {
+		return false;
+	} finally {
+		if (owned) scope.__env__ = previous;
+		else delete scope.__env__;
+	}
+}
+function setActiveCloudflareEnv(env) {
+	activeEnv = env;
+	if (!env || !readsGlobalEnv(env)) globalThis.__env__ = env;
+	try {
+		activeEnvStorage.enterWith({ env });
+	} catch {}
+}
+function runWithActiveCloudflareEnv(env, callback) {
+	return activeEnvStorage.run({ env }, callback);
+}
+function getActiveCloudflareEnv() {
+	const scoped = activeEnvStorage.getStore();
+	if (scoped) return scoped.env;
+	const host = globalThis;
+	return Object.hasOwn(host, "__env__") && host.__env__ !== void 0 ? host.__env__ : activeEnv;
+}
+function ownValue(value, key) {
+	if (value === null || typeof value !== "object" && typeof value !== "function" || !Object.hasOwn(value, key)) return void 0;
+	return Reflect.get(value, key);
+}
+function ownObject(value) {
+	return value !== null && (typeof value === "object" || typeof value === "function") ? value : void 0;
+}
+/** The objects where H3 1, H3 2, and Nitro hosts put Cloudflare `env` and `context`, in lookup order. */
+function cloudflareOwners(target) {
+	const context = ownObject(ownValue(target, "context"));
+	const platform = ownObject(ownValue(context, "_platform"));
+	const req = ownObject(ownValue(target, "req"));
+	const nodeReq = ownObject(ownValue(ownObject(ownValue(target, "node")), "req"));
+	return [
+		ownObject(ownValue(context, "cloudflare")),
+		ownObject(ownValue(platform, "cloudflare")),
+		ownObject(ownValue(ownObject(ownValue(req, "runtime")), "cloudflare")),
+		ownObject(ownValue(ownObject(ownValue(nodeReq, "runtime")), "cloudflare"))
+	];
+}
+function getCloudflareEnv(event, options = {}) {
+	const target = ownObject(event);
+	for (const candidate of [ownValue(target, "env"), ...cloudflareOwners(target).map((owner) => ownValue(owner, "env"))]) if (candidate) return candidate;
+	return options.fallback === false ? void 0 : getActiveCloudflareEnv();
+}
+function resolveWaitUntil(event, options = {}) {
+	const target = ownObject(event);
+	const context = ownObject(ownValue(target, "context"));
+	const cloudflare = ownObject(ownValue(context, "cloudflare"));
+	const cloudflareContext = ownObject(ownValue(cloudflare, "context"));
+	const platformCloudflare = ownObject(ownValue(ownObject(ownValue(context, "_platform")), "cloudflare"));
+	const platformCloudflareContext = ownObject(ownValue(platformCloudflare, "context"));
+	const req = ownObject(ownValue(target, "req"));
+	const reqCloudflare = ownObject(ownValue(ownObject(ownValue(req, "runtime")), "cloudflare"));
+	const reqCloudflareContext = ownObject(ownValue(reqCloudflare, "context"));
+	const nodeReq = ownObject(ownValue(ownObject(ownValue(target, "node")), "req"));
+	const nodeCloudflare = ownObject(ownValue(ownObject(ownValue(nodeReq, "runtime")), "cloudflare"));
+	const hosts = [
+		context,
+		cloudflare,
+		cloudflareContext,
+		platformCloudflare,
+		platformCloudflareContext,
+		req,
+		reqCloudflare,
+		reqCloudflareContext,
+		nodeReq,
+		nodeCloudflare,
+		ownObject(ownValue(nodeCloudflare, "context"))
+	];
+	const owners = options.preferHost ? [...hosts, target] : [target, ...hosts];
+	for (const owner of owners) {
+		const waitUntil = ownValue(owner, "waitUntil");
+		if (typeof waitUntil === "function") return waitUntil.bind(owner);
+	}
+}
+function createCloudflareRuntimeEvent(env, context) {
+	const waitUntil = typeof context?.waitUntil === "function" ? context.waitUntil.bind(context) : void 0;
+	return {
+		context: {
+			cloudflare: {
+				env,
+				context
+			},
+			waitUntil
+		},
+		env,
+		waitUntil
+	};
+}
+//#endregion
+export { setActiveCloudflareEnv as a, runWithActiveCloudflareEnv as i, getCloudflareEnv as n, resolveWaitUntil as r, createCloudflareRuntimeEvent as t };