@vite-hub/workflow 0.0.3 → 0.1.0

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 };

package/dist/cloudflare-nF4abPd4.js

@@ -0,0 +1,59 @@
+import { t as workflowErrorDiagnostics } from "./error-diagnostics-pwNFvAHP.js";
+//#region ../internal/src/integrations/hex.ts
+const textEncoder = new TextEncoder();
+new TextDecoder();
+function encodeNameHex(name) {
+	return [...textEncoder.encode(name)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+//#endregion
+//#region src/integrations/cloudflare.ts
+const cloudflareWorkflowNameMaxLength = 64;
+function shortHash(value) {
+	let hash = 14695981039346656037n;
+	for (const char of value) {
+		hash ^= BigInt(char.codePointAt(0) || 0);
+		hash = BigInt.asUintN(64, hash * 1099511628211n);
+	}
+	return hash.toString(16).padStart(16, "0");
+}
+function legacyShortHash(value) {
+	let hash = 2166136261;
+	for (const char of value) {
+		hash ^= char.codePointAt(0) || 0;
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function workflowClassPrefix(name) {
+	return name.split(/[^a-z0-9]+/i).filter(Boolean).map((segment) => `${segment.charAt(0).toUpperCase()}${segment.slice(1)}`).join("") || "Default";
+}
+function getCloudflareWorkflowBindingName(name) {
+	return `WORKFLOW_${encodeNameHex(name).toUpperCase()}`;
+}
+function getCloudflareWorkflowName(name) {
+	const encoded = encodeNameHex(name);
+	const fullName = `workflow--${encoded}`;
+	if (fullName.length <= cloudflareWorkflowNameMaxLength) return fullName;
+	const hash = shortHash(name);
+	const prefixLength = 53 - hash.length;
+	return `workflow--${encoded.slice(0, prefixLength)}-${hash}`;
+}
+function getCloudflareWorkflowClassName(name) {
+	return `ViteHub${workflowClassPrefix(name)}${shortHash(name)}Workflow`;
+}
+/** The pre-64-bit class export kept for existing Cloudflare Workflow instances. */
+function getLegacyCloudflareWorkflowClassName(name) {
+	return `ViteHub${workflowClassPrefix(name)}${legacyShortHash(name)}Workflow`;
+}
+function createCloudflareWorkflowBindings(definitions, options) {
+	if (!definitions.length) return;
+	const configurable = definitions.filter((definition) => definition.source !== "agent-workflow-recovery");
+	if (configurable.length > 1 && options && (options.binding || options.name)) throw workflowErrorDiagnostics.WORKFLOW_R0001({ message: "Cloudflare workflow binding and name overrides are only supported when one workflow is discovered." });
+	return definitions.map((definition) => ({
+		binding: configurable.length === 1 && configurable[0] === definition && options ? options.binding || getCloudflareWorkflowBindingName(definition.name) : getCloudflareWorkflowBindingName(definition.name),
+		class_name: getCloudflareWorkflowClassName(definition.name),
+		name: configurable.length === 1 && configurable[0] === definition && options ? options.name || getCloudflareWorkflowName(definition.name) : getCloudflareWorkflowName(definition.name)
+	}));
+}
+//#endregion
+export { getLegacyCloudflareWorkflowClassName as a, getCloudflareWorkflowName as i, getCloudflareWorkflowBindingName as n, encodeNameHex as o, getCloudflareWorkflowClassName as r, createCloudflareWorkflowBindings as t };

package/dist/cloudflare-shared-CaxrMD1A.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/{cloudflare-vite-B0zel2Do.js → cloudflare-vite-B3IabBsv.js}

@@ -1,12 +1,17 @@
-import { t as normalizeWorkflowOptions } from "./config-BDqB6I4E.js";
-import { i as runWithActiveCloudflareEnv, t as createCloudflareRuntimeEvent } from "./cloudflare-env-mFp2Uj6Z.js";
+import { t as normalizeWorkflowOptions } from "./config-IJMb0eeZ.js";
+import { i as runWithActiveCloudflareEnv, t as createCloudflareRuntimeEvent } from "./cloudflare-env-BNrYo29x.js";
 import { runWithWorkflowRuntimeEvent, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry } from "./runtime/state.js";
-import { t as resolveAppFetch } from "./app-BZpq2cwC.js";
-import { H3, toWebHandler } from "h3/cloudflare";
+import { t as resolveAppFetch } from "./app-CzPoP84f.js";
 //#region ../internal/src/runtime/cloudflare-hosted.ts
 function createWebRequestHandler(appHandler) {
-	const defaultHandler = toWebHandler(new H3());
-	return async (request, context) => await Promise.resolve(appHandler ? appHandler(request, context) : defaultHandler(request, context));
+	return async (request, context) => await Promise.resolve(appHandler ? appHandler(request, context) : new Response(JSON.stringify({
+		status: 404,
+		message: `Cannot find any route matching [${request.method}] ${request.url}`
+	}), {
+		headers: { "content-type": "application/json;charset=UTF-8" },
+		status: 404,
+		statusText: "Not Found"
+	}));
 }
 function createCloudflareHostedWorker(adapter) {
 	const requestHandler = createWebRequestHandler(resolveAppFetch(adapter.label, adapter.app));
@@ -22,18 +27,21 @@ function createCloudflareHostedWorker(adapter) {
 }
 //#endregion
 //#region src/runtime/cloudflare-vite.ts
-function createWorkflowCloudflareWorker(options = {}) {
+function installWorkflowCloudflareRuntime(options = {}) {
 	const workflowConfig = options.workflow === false ? false : normalizeWorkflowOptions(options.workflow, { hosting: "cloudflare" });
+	setWorkflowRuntimeConfig(workflowConfig);
+	setWorkflowRuntimeRegistry(options.registry);
+}
+function createWorkflowCloudflareWorker(options = {}) {
 	return createCloudflareHostedWorker({
 		app: options.app,
 		label: "workflow",
 		async onRequest({ env, executionContext, handle }) {
-			setWorkflowRuntimeConfig(workflowConfig);
-			setWorkflowRuntimeRegistry(options.registry);
+			installWorkflowCloudflareRuntime(options);
 			const runtimeEvent = createCloudflareRuntimeEvent(env, executionContext);
 			return await runWithActiveCloudflareEnv(env, () => runWithWorkflowRuntimeEvent(runtimeEvent, () => handle(runtimeEvent.context)));
 		}
 	});
 }
 //#endregion
-export { createWorkflowCloudflareWorker as t };
+export { installWorkflowCloudflareRuntime as n, createWorkflowCloudflareWorker as t };