@vite-hub/workflow 0.0.3 → 0.1.0

package/dist/index.js

@@ -1,354 +1,45 @@
-import { t as normalizeWorkflowOptions } from "./config-BDqB6I4E.js";
-import { a as encodeNameHex, i as getCloudflareWorkflowName, n as getCloudflareWorkflowBindingName, r as getCloudflareWorkflowClassName } from "./cloudflare-Cds1VIWa.js";
-import { i as createWorkflowError, n as runWorkflowProviderOperation, r as safeWorkflowName } from "./provider-operation-CWIV4k42.js";
-import { n as getCloudflareEnv, r as resolveWaitUntil } from "./cloudflare-env-mFp2Uj6Z.js";
-import { runWorkflowHandler } from "./runtime/execute.js";
-import { getOpenWorkflowRun, runOpenWorkflow } from "./runtime/openworkflow.js";
-import { getWorkflowRunState, getWorkflowRuntimeConfig, getWorkflowRuntimeEvent, loadWorkflowDefinition, registerInlineWorkflowDefinition, runWithWorkflowRuntimeEvent, setWorkflowRun } from "./runtime/state.js";
-import { a as startVercelWorkflow, n as inspectVercelWorkflowRun, r as resumeVercelWorkflowSignal, t as cancelVercelWorkflow } from "./vercel-D2_J5D_Y.js";
-import { t as createWorkflowCloudflareWorker } from "./cloudflare-vite-B0zel2Do.js";
+import { t as normalizeWorkflowOptions } from "./config-IJMb0eeZ.js";
+import { t as workflowErrorDiagnostics } from "./error-diagnostics-pwNFvAHP.js";
+import { i as getCloudflareWorkflowName, n as getCloudflareWorkflowBindingName, r as getCloudflareWorkflowClassName } from "./cloudflare-nF4abPd4.js";
+import { a as resumeWorkflowSignal, i as getWorkflowRun, n as createWorkflow, o as runWorkflow, r as deferWorkflow, s as getVercelWorkflowName, t as cancelWorkflow } from "./client-DsGM3M4U.js";
+import { t as createWorkflowCloudflareWorker } from "./cloudflare-vite-B3IabBsv.js";
 //#region src/definition.ts
 function defineWorkflow(handler, options) {
-	if (typeof handler !== "function") throw new TypeError("`defineWorkflow()` requires a workflow handler.");
-	if (typeof options !== "undefined" && (!options || typeof options !== "object" || Array.isArray(options))) throw new TypeError("`defineWorkflow()` options must be a plain object.");
-	if (options?.native !== void 0 && typeof options.native !== "function") throw new TypeError("`defineWorkflow()` native entry must be a workflow handler.");
+	if (typeof handler !== "function") throw workflowErrorDiagnostics.WORKFLOW_C0014({ message: "`defineWorkflow()` requires a workflow handler." });
+	if (typeof options !== "undefined" && (!options || typeof options !== "object" || Array.isArray(options))) throw workflowErrorDiagnostics.WORKFLOW_C0015({ message: "`defineWorkflow()` options must be a plain object." });
+	if (options?.native !== void 0 && typeof options.native !== "function") throw workflowErrorDiagnostics.WORKFLOW_C0016({ message: "`defineWorkflow()` native entry must be a workflow handler." });
 	return {
 		handler,
 		options
 	};
 }
 //#endregion
-//#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 unsupportedOperation(provider, operation) {
-	throw createWorkflowError({
-		code: "WORKFLOW_OPERATION_UNSUPPORTED",
-		details: {
-			operation,
-			provider
-		}
-	});
-}
-function resolveCloudflareBinding(event, binding, name) {
-	const bindingName = binding || getCloudflareWorkflowBindingName(name);
-	return getCloudflareEnv(event)?.[bindingName];
-}
-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 = typeof status === "object" && status ? status.status : status;
-	return cloudflareStatusMap[String(value || "").toLowerCase()] || "unknown";
-}
-function createCloudflareAdapter(config) {
-	return {
-		cancel: () => unsupportedOperation("cloudflare", "cancellation"),
-		async get({ event, id, name }) {
-			const binding = resolveCloudflareBinding(event, config.binding, name);
-			if (binding) {
-				const instance = await runWorkflowProviderOperation("cloudflare", "get", () => binding.get(id));
-				const metadata = await runWorkflowProviderOperation("cloudflare", "status", () => instance.status());
-				return {
-					id,
-					metadata,
-					provider: "cloudflare",
-					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);
-			if (binding) {
-				const start = runWorkflowProviderOperation("cloudflare", "create", () => binding.create({
-					id,
-					params: payload
-				}));
-				const waitUntil = options.deferred ? resolveWaitUntil(event) : void 0;
-				if (waitUntil) waitUntil(start);
-				const instance = await start;
-				return {
-					id: instance.id,
-					metadata: await runWorkflowProviderOperation("cloudflare", "status", () => instance.status()),
-					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, name, options, payload }) => await runOpenWorkflow(config, name, payload, definition, options)
-	};
-}
-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: run.result,
-					status: run.status
-				};
-			}
-			return {
-				id,
-				provider: config.provider,
-				status: "unknown"
-			};
-		},
-		async run({ definition, event, id, name, payload }) {
-			const runState = setWorkflowRun(name, id, Promise.resolve().then(() => runWorkflowHandler({
-				id,
-				name,
-				payload,
-				provider: config.provider
-			}, definition)).then((result) => ({
-				result,
-				status: "completed"
-			})).catch((error) => ({
-				error,
-				status: "failed"
-			})));
-			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);
-		}
-	};
-}
-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) return false;
-	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 || typeof 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) {
-	if (typeof nameOrOptions === "object" && nameOrOptions !== null) {
-		const createOptions = nameOrOptions;
-		const { handler, name } = createOptions;
-		if (!name || typeof name !== "string") throw new TypeError("`createWorkflow()` requires a workflow name.");
-		if (typeof handler !== "function") throw new TypeError("`createWorkflow()` requires a workflow handler.");
-		registerInlineWorkflowDefinition(name, { handler });
-		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),
-			run: async (payload, options = {}) => runWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options))
-		};
-	}
-	const name = nameOrOptions;
-	if (!name || typeof name !== "string") throw new TypeError("`createWorkflow()` requires a workflow name.");
-	const handler = typeof handlerOrOptions === "function" ? handlerOrOptions : typeof handlerOrOptions === "object" && handlerOrOptions !== null ? handlerOrOptions.handler : void 0;
-	const createOptions = typeof handlerOrOptions === "function" ? options : handlerOrOptions;
-	if (handler !== void 0) {
-		if (typeof handler !== "function") throw new TypeError("`createWorkflow()` requires a workflow handler.");
-		registerInlineWorkflowDefinition(name, { handler });
-	} else if (handlerOrOptions !== void 0 && (typeof handlerOrOptions !== "object" || handlerOrOptions === null)) throw new TypeError("`createWorkflow()` options must be an object.");
-	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),
-		run: async (payload, options = {}) => runWorkflow(name, payload, await resolveWorkflowStartOptions(name, payload, createOptions, options))
-	};
-}
-async function runWorkflow(name, payload, options = {}) {
-	const config = getActiveWorkflowConfig();
-	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
-	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) {
-	const config = getActiveWorkflowConfig();
-	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
-	return await getWorkflowRuntimeAdapter(config).get({
-		event: getWorkflowRuntimeEvent(),
-		id,
-		name
-	});
-}
-async function cancelWorkflow(name, id) {
-	const config = getActiveWorkflowConfig();
-	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
-	await loadRequiredWorkflowDefinition(name);
-	return await getWorkflowRuntimeAdapter(config).cancel({
-		event: getWorkflowRuntimeEvent(),
-		id,
-		name
-	});
-}
-async function resumeWorkflowSignal(token, payload) {
-	if (!token || typeof token !== "string") throw new TypeError("`resumeWorkflowSignal()` requires an opaque signal token.");
-	const config = getActiveWorkflowConfig();
-	if (config === false) throw createWorkflowError({ code: "WORKFLOW_DISABLED" });
-	return await getWorkflowRuntimeAdapter(config).resume(token, payload);
-}
-function deferWorkflow(name, payload, options = {}) {
-	return runWithWorkflowRuntimeEvent(getWorkflowRuntimeEvent(), () => runWorkflow(name, payload, {
-		...options,
-		deferred: true
-	}));
-}
-//#endregion
 //#region src/runtime/payload.ts
 async function readRequestPayload(request) {
-	if ((request.headers.get("content-type") || "").includes("application/json")) return await request.json();
+	if (request.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === "application/json") return await request.json();
 	return await request.text();
 }
 async function validatePayload(payload, schema) {
 	if (typeof schema === "function") return await schema(payload);
-	if ("safeParse" in schema && typeof schema.safeParse === "function") {
+	if (hasSchemaMethod(schema, "safeParse") && typeof schema.safeParse === "function") {
 		const result = schema.safeParse(payload);
-		if (!result.success) throw result.error || /* @__PURE__ */ new TypeError("Invalid workflow payload.");
+		if (!result.success) throw result.error || workflowErrorDiagnostics.WORKFLOW_R0021({ message: "Invalid workflow payload." });
 		return result.data;
 	}
-	if ("parse" in schema && typeof schema.parse === "function") return schema.parse(payload);
-	throw new TypeError("Invalid workflow payload schema.");
+	if (hasSchemaMethod(schema, "parse") && typeof schema.parse === "function") return schema.parse(payload);
+	throw workflowErrorDiagnostics.WORKFLOW_R0022({ message: "Invalid workflow payload schema." });
+}
+function hasSchemaMethod(value, key) {
+	if (Object.hasOwn(value, key)) return true;
+	let prototype = Object.getPrototypeOf(value);
+	while (prototype !== null) {
+		if (Object.hasOwn(prototype, key)) {
+			const constructor = Object.hasOwn(prototype, "constructor") ? prototype.constructor : void 0;
+			return typeof constructor === "function" && constructor.prototype === prototype && Function.prototype.toString.call(constructor) !== Function.prototype.toString.call(Object);
+		}
+		prototype = Object.getPrototypeOf(prototype);
+	}
+	return false;
 }
 async function readValidatedPayload(request, schema) {
 	return await validatePayload(await readRequestPayload(request), schema);

package/dist/inspect-B72iFyj-.js

@@ -0,0 +1,70 @@
+import { relative } from "pathe";
+//#region ../internal/src/inspect.ts
+function relativeDefinitionFile(projectRoot, file) {
+	return relative(projectRoot, file).replaceAll("\\", "/");
+}
+const redactedInspectionValue = "[redacted]";
+const secretKeyPattern = /secret|token|passw(?:or)?d|credential|api[-_\s]?key|private[-_\s]?key|authorization|cookie|signature|dsn|connection[-_\s]?string/i;
+const secretValuePattern = /^(?:[a-z][a-z0-9+.-]*:\/\/[^/\s?#]*@|bearer\s)/i;
+/** Whether an inspection field names a credential, regardless of its value. */
+function isSecretInspectionKey(key) {
+	return secretKeyPattern.test(key);
+}
+const embeddedUrlCredentialPattern = /\b([a-z][a-z0-9+.-]*:\/\/)[^/\s?#]*@/gi;
+const embeddedCookiePattern = /\b([\w-]*cookie[\w-]*["']?\s*[:=]\s*)(?:"(?:\\[^\r\n]|[^"\\\r\n])*"(?:\s*;\s*[\w.-]+\s*=[^;\r\n]*)*|'(?:\\[^\r\n]|[^'\\\r\n])*'(?:\s*;\s*[\w.-]+\s*=[^;\r\n]*)*|[^\r\n]+?(?=\s*(?:;\s*[^;=\r\n/]+\s*(?:\r?\n|$)|&|\r?\n|$)))/gi;
+const embeddedBearerPattern = /\bbearer\s+[^\s,;]+/gi;
+const embeddedAuthorizationPattern = new RegExp(String.raw`\b([\w-]*authorization[\w-]*["']?\s*[:=]\s*)(?!\[redacted\](?=$|[\s,;}&]))(?:"(?:\\[^\r\n]|[^"\\\r\n])*"|'(?:\\[^\r\n]|[^'\\\r\n])*'|[^\r\n]+?(?=\s*(?:[,;])?\s*(?:${secretKeyPattern.source})[\w-]*\s*[:=]|\s+rejected\b|$))`, "gi");
+const embeddedSecretAssignmentPattern = new RegExp(String.raw`\b([\w-]*(?:${secretKeyPattern.source})[\w-]*["']?\s*[:=]\s*)(?!\[redacted\](?=$|[\s,;}&]))(?:"(?:\\[^\r\n]|[^"\\\r\n])*"|'(?:\\[^\r\n]|[^'\\\r\n])*'|[^\s,;&#&]+)`, "gi");
+/**
+* Removes credentials inside free text, for example an error message. URL credentials, bearer tokens, and
+* `name=value` pairs with a secret name are replaced with `[redacted]`.
+*/
+function redactInspectionText(value) {
+	return value.replace(embeddedUrlCredentialPattern, `$1${redactedInspectionValue}@`).replace(embeddedAuthorizationPattern, `$1${redactedInspectionValue}`).replace(embeddedCookiePattern, `$1${redactedInspectionValue}`).replace(embeddedBearerPattern, `Bearer ${redactedInspectionValue}`).replace(embeddedSecretAssignmentPattern, `$1${redactedInspectionValue}`);
+}
+/**
+* Removes values that can carry credentials before inspection output leaves the process.
+* Keys that name secrets, plaintext Worker `vars`, and URLs with embedded credentials are redacted.
+*/
+function redactInspectionValue(value, key) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	let remaining = 1e3;
+	function visit(entry, entryKey, depth = 0) {
+		if (entryKey && isSecretInspectionKey(entryKey)) return redactedInspectionValue;
+		if (--remaining < 0 || depth > 10) return "[truncated]";
+		if (typeof entry === "string") {
+			const text = entry.slice(0, 1e4);
+			return secretValuePattern.test(text) ? redactedInspectionValue : redactInspectionText(text);
+		}
+		if (typeof entry === "bigint") return entry.toString();
+		if (typeof entry === "number") return Number.isFinite(entry) ? entry : String(entry);
+		if (entry === null || typeof entry === "boolean") return entry;
+		if (typeof entry !== "object") return entry === void 0 ? null : "[unsupported]";
+		if (seen.has(entry)) return "[circular]";
+		seen.add(entry);
+		try {
+			let dateTime;
+			try {
+				dateTime = Date.prototype.getTime.call(entry);
+			} catch {}
+			if (dateTime !== void 0) return Number.isNaN(dateTime) ? "Invalid Date" : Date.prototype.toISOString.call(entry);
+			if (Array.isArray(entry)) return entry.slice(0, 100).map((item) => visit(item, void 0, depth + 1));
+			let setValues;
+			try {
+				setValues = [...Set.prototype.values.call(entry)];
+			} catch {}
+			if (setValues) return setValues.slice(0, 100).map((item) => visit(item, void 0, depth + 1));
+			let mapEntries;
+			try {
+				mapEntries = [...Map.prototype.entries.call(entry)];
+			} catch {}
+			const entries = mapEntries ? mapEntries.map(([name, item]) => [String(name), item]) : Object.entries(entry);
+			return Object.fromEntries(entries.slice(0, 100).map(([name, item]) => [name, name === "vars" && item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.keys(item).slice(0, 100).map((variable) => [variable, redactedInspectionValue])) : visit(item, name, depth + 1)]));
+		} finally {
+			seen.delete(entry);
+		}
+	}
+	return visit(value, key);
+}
+//#endregion
+export { redactInspectionValue as n, relativeDefinitionFile as r, redactInspectionText as t };

package/dist/operations-B_rYG71W.js

@@ -0,0 +1,230 @@
+import { a as resumeWorkflowSignal, i as getWorkflowRun, o as runWorkflow, t as cancelWorkflow } from "./client-DsGM3M4U.js";
+import { getInlineWorkflowDefinitions, getWorkflowRuntimeConfig, getWorkflowRuntimeRegistry } from "./runtime/state.js";
+import { n as redactInspectionValue, t as redactInspectionText } from "./inspect-B72iFyj-.js";
+//#region src/results.ts
+const inlineRunNote = "Runs the Workflow inline in the Nitro runtime, as the app does in development. Inline runs are not durable and have no retries.";
+function unsupported(note) {
+	return {
+		note,
+		supported: false
+	};
+}
+/**
+* Operations that each provider supports. A supported operation can still fail when the runtime decides, for example
+* cancel on an inline Vercel run.
+*/
+function resolveWorkflowOperationSupport(provider) {
+	if (provider === "cloudflare") return {
+		cancel: unsupported("Cloudflare Workflows do not support cancellation through ViteHub."),
+		get: {
+			note: "Reads the run from the Cloudflare Workflow binding when the runtime has one.",
+			supported: true
+		},
+		resume: unsupported("Cloudflare Workflows do not support ViteHub signals."),
+		start: {
+			note: `Uses the Cloudflare Workflow binding when the runtime has one. Otherwise: ${inlineRunNote}`,
+			supported: true
+		}
+	};
+	if (provider === "openworkflow") return {
+		cancel: unsupported("OpenWorkflow does not support cancellation through ViteHub."),
+		get: {
+			note: "Reads the run from OpenWorkflow storage.",
+			supported: true
+		},
+		resume: unsupported("OpenWorkflow does not support ViteHub signals."),
+		start: {
+			note: "Enqueues the run in OpenWorkflow storage. The run stays queued until an OpenWorkflow worker processes the same storage.",
+			supported: true
+		}
+	};
+	return {
+		cancel: {
+			note: "Only native Vercel Workflow runs can be cancelled. Inline runs return an unsupported error.",
+			supported: true
+		},
+		get: {
+			note: "Reads inline runs, which expire 5 minutes after they finish. Native Vercel Workflow runs need the Workflow DevKit runtime.",
+			supported: true
+		},
+		resume: {
+			note: "Signals need a native Vercel Workflow run and the Workflow DevKit runtime.",
+			supported: true
+		},
+		start: {
+			note: `${inlineRunNote} Native Vercel Workflow Definitions need the Workflow DevKit runtime.`,
+			supported: true
+		}
+	};
+}
+//#endregion
+//#region src/runtime/operations.ts
+const maxRememberedRuns = 1024;
+/** A failure of a Workflow operation, with the status and code that every surface reports. */
+var WorkflowOperationError = class extends Error {
+	code;
+	fix;
+	status;
+	constructor(message, status, code, fix) {
+		super(message);
+		this.name = "WorkflowOperationError";
+		this.code = code;
+		this.status = status;
+		if (fix) this.fix = fix;
+	}
+};
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isResponse(value) {
+	if (value instanceof Response) return true;
+	const statusGetter = Object.getOwnPropertyDescriptor(Response.prototype, "status")?.get;
+	if (!statusGetter) return false;
+	try {
+		statusGetter.call(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function jsonReplacer(_key, value) {
+	if (typeof value === "bigint") return value.toString();
+	if (value instanceof Error) return serializeError(value);
+	if (isResponse(value)) return { response: {
+		status: value.status,
+		statusText: value.statusText
+	} };
+	return value;
+}
+function toJsonValue(value) {
+	if (value === void 0) return void 0;
+	try {
+		const text = JSON.stringify(value, jsonReplacer);
+		return text === void 0 ? void 0 : redactInspectionValue(JSON.parse(text));
+	} catch {
+		return "[unserializable]";
+	}
+}
+function errorCode(error) {
+	if (!error || typeof error !== "object") return;
+	const code = Reflect.get(error, "code");
+	return typeof code === "string" ? code : void 0;
+}
+function serializeError(error) {
+	const code = errorCode(error);
+	return {
+		...code ? { code } : {},
+		message: redactInspectionText(error.message),
+		...error.name && error.name !== "Error" ? { name: error.name } : {}
+	};
+}
+function toIsoDate(value) {
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? void 0 : value.toISOString();
+	return typeof value === "string" ? value : void 0;
+}
+function isErrorLike(value) {
+	return value instanceof Error || isRecord(value) && typeof value.message === "string";
+}
+async function readResult(result) {
+	if (!isResponse(result)) return result;
+	const text = await result.clone().text();
+	if (!text) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+/**
+* Converts a runtime Workflow run to JSON data. The view omits the start
+* payload and redacts credentials in the metadata, result, and error message.
+*/
+async function toWorkflowRunView(run, workflow) {
+	const createdAt = toIsoDate(run.createdAt);
+	const startedAt = toIsoDate(run.startedAt);
+	const completedAt = toIsoDate(run.completedAt);
+	const error = run.status === "failed" && isErrorLike(run.metadata) ? serializeError(run.metadata) : void 0;
+	const metadata = error ? void 0 : toJsonValue(run.metadata);
+	const result = toJsonValue(await readResult(run.result));
+	return {
+		...completedAt ? { completedAt } : {},
+		...createdAt ? { createdAt } : {},
+		...error ? { error } : {},
+		id: run.id,
+		...metadata === void 0 ? {} : { metadata },
+		provider: run.provider,
+		...result === void 0 ? {} : { result },
+		...startedAt ? { startedAt } : {},
+		status: run.status,
+		workflow
+	};
+}
+function runtimeFailure(operation, provider, error) {
+	if (error instanceof WorkflowOperationError) return error;
+	const code = errorCode(error);
+	if (code === "WORKFLOW_OPERATION_UNSUPPORTED") return new WorkflowOperationError(`workflow ${operation} is not supported by the ${provider} provider for this run.`, 501, code);
+	if (code === "WORKFLOW_DISABLED") return new WorkflowOperationError("Workflow is disabled in this runtime.", 409, code, "Enable Workflow with `vitehub({ workflow: true })` or `hubWorkflow()`.");
+	if (code === "WORKFLOW_DEFINITION_NOT_FOUND") return new WorkflowOperationError("Workflow definition was not found.", 404, code);
+	if (code === "VERCEL_WORKFLOW_SDK_LOAD_FAILED" || code === "WORKFLOW_NATIVE_ENTRY_INVALID" || code === "WORKFLOW_NATIVE_ENTRY_REQUIRED") return new WorkflowOperationError(`workflow ${operation} needs the Vercel Workflow DevKit runtime, which the runtime could not load.`, 501, code);
+	if (code === "WORKFLOW_PROVIDER_OPERATION_FAILED") {
+		const cause = error instanceof Error ? error.cause : void 0;
+		return new WorkflowOperationError(`workflow ${operation} failed in the ${provider} provider.${cause instanceof Error && cause.message ? ` ${redactInspectionText(cause.message)}` : ""}`, 502, code);
+	}
+	const message = error instanceof Error ? error.message : String(error);
+	return new WorkflowOperationError(redactInspectionText(message || "The Workflow operation failed."), 500, code || "WORKFLOW_OPERATION_FAILED");
+}
+function startableWorkflows() {
+	return [.../* @__PURE__ */ new Set([...Object.keys(getWorkflowRuntimeRegistry() ?? {}), ...getInlineWorkflowDefinitions().keys()])].sort();
+}
+const startedRuns = /* @__PURE__ */ new Map();
+function rememberRun(id, workflow) {
+	startedRuns.delete(id);
+	startedRuns.set(id, workflow);
+	if (startedRuns.size > maxRememberedRuns) {
+		const oldest = startedRuns.keys().next().value;
+		if (oldest !== void 0) startedRuns.delete(oldest);
+	}
+}
+/**
+* Runs one Workflow operation in the runtime of the app, so it uses the same Workflow state and registry as the app.
+* It redacts credentials in run data and error messages. Failures are `WorkflowOperationError`s.
+*/
+async function runWorkflowOperation(operation, input) {
+	const runtimeConfig = getWorkflowRuntimeConfig();
+	if (runtimeConfig === false) throw new WorkflowOperationError("Workflow is disabled in this runtime.", 409, "WORKFLOW_DISABLED", "Enable Workflow with `vitehub({ workflow: true })` or `hubWorkflow()`.");
+	const provider = runtimeConfig?.provider ?? "vercel";
+	const support = resolveWorkflowOperationSupport(provider)[operation];
+	if (!support.supported) throw new WorkflowOperationError(`workflow ${operation} is not supported by the ${provider} provider. ${support.note}`, 501, "WORKFLOW_OPERATION_UNSUPPORTED");
+	try {
+		return await run(operation, input);
+	} catch (error) {
+		throw runtimeFailure(operation, provider, error);
+	}
+}
+async function run(operation, input) {
+	if (operation === "start") {
+		const { payload, workflow } = input;
+		const workflows = startableWorkflows();
+		if (!workflows.includes(workflow)) {
+			if (!getWorkflowRuntimeRegistry()) throw new WorkflowOperationError(`Unknown Workflow: ${workflow}. The runtime has no Workflow registry.`, 409, "WORKFLOW_REGISTRY_MISSING", "Restart the dev server. In development the Workflow Vite plugin installs the registry with the Nitro plugin .vitehub/nitro/workflow/dev-plugin.mjs.");
+			throw new WorkflowOperationError(`Unknown Workflow: ${workflow}.${workflows.length ? ` Available Workflows: ${workflows.join(", ")}.` : " The Workflow registry of the runtime is empty."}`, 404, "WORKFLOW_DEFINITION_NOT_FOUND");
+		}
+		const started = await runWorkflow(workflow, payload);
+		rememberRun(started.id, workflow);
+		return { run: await toWorkflowRunView(started, workflow) };
+	}
+	if (operation === "resume") {
+		const { payload, token } = input;
+		const signal = await resumeWorkflowSignal(token, payload);
+		return { signal: {
+			id: signal.id,
+			provider: signal.provider
+		} };
+	}
+	const { runId, workflow: named } = input;
+	const workflow = named ?? startedRuns.get(runId);
+	if (!workflow) throw new WorkflowOperationError(`Run ${runId} was not started by \`workflow.start\` in this runtime.`, 400, "WORKFLOW_RUN_UNKNOWN", "Pass the name of the Workflow with `--workflow <name>`.");
+	return { run: await toWorkflowRunView(operation === "get" ? await getWorkflowRun(workflow, runId) : await cancelWorkflow(workflow, runId), workflow) };
+}
+//#endregion
+export { WorkflowOperationError, runWorkflowOperation, toWorkflowRunView };