@vite-hub/workflow 0.0.0 → 0.0.1

package/dist/nitro.d.ts

@@ -0,0 +1,19 @@
+import { l as ResolvedWorkflowOptions, y as WorkflowModuleOptions } from "./types-ThDitg7Z.js";
+import { NitroModule } from "nitro/types";
+
+//#region src/nitro/module.d.ts
+declare const workflowNitroModule: NitroModule;
+declare module "nitro/types" {
+  interface NitroConfig {
+    workflow?: WorkflowModuleOptions;
+  }
+  interface NitroOptions {
+    workflow?: WorkflowModuleOptions;
+  }
+  interface NitroRuntimeConfig {
+    hosting?: string;
+    workflow?: false | ResolvedWorkflowOptions;
+  }
+}
+//#endregion
+export { workflowNitroModule as default };

package/dist/nitro.js

@@ -0,0 +1,2 @@
+import { t as workflowNitroModule } from "./module-UYEnVfxy.js";
+export { workflowNitroModule as default };

package/dist/openworkflow-amN7IkGO.d.ts

@@ -0,0 +1,24 @@
+import { f as WorkflowDeferOptions, l as ResolvedWorkflowOptions, p as WorkflowDefinition, w as WorkflowRun } from "./types-ThDitg7Z.js";
+import * as _$openworkflow from "openworkflow";
+import * as _$openworkflow_postgres0 from "openworkflow/postgres";
+
+//#region src/runtime/openworkflow.d.ts
+type OpenWorkflowModule = typeof _$openworkflow;
+type OpenWorkflowPostgresModule = typeof _$openworkflow_postgres0;
+type OpenWorkflowClient = InstanceType<OpenWorkflowModule["OpenWorkflow"]>;
+type OpenWorkflowBackend = Awaited<ReturnType<OpenWorkflowPostgresModule["BackendPostgres"]["connect"]>>;
+type OpenWorkflowRunnable = ReturnType<OpenWorkflowClient["defineWorkflow"]>;
+type OpenWorkflowImporter = <T>(specifier: string) => Promise<T>;
+interface OpenWorkflowRuntime {
+  backend: OpenWorkflowBackend;
+  client: OpenWorkflowClient;
+  workflows: Map<string, OpenWorkflowRunnable>;
+}
+declare function getOpenWorkflowRuntime(config: ResolvedWorkflowOptions): Promise<OpenWorkflowRuntime>;
+declare function registerOpenWorkflowDefinition(runtime: OpenWorkflowRuntime, name: string, definition: WorkflowDefinition): Promise<OpenWorkflowRunnable>;
+declare function runOpenWorkflow<TPayload = unknown, TResult = unknown>(config: ResolvedWorkflowOptions, name: string, payload: TPayload | undefined, definition: WorkflowDefinition<TPayload, TResult>, options: WorkflowDeferOptions): Promise<WorkflowRun<TPayload, TResult>>;
+declare function getOpenWorkflowRun<TPayload = unknown, TResult = unknown>(config: ResolvedWorkflowOptions, name: string, id: string): Promise<WorkflowRun<TPayload, TResult>>;
+declare function resetOpenWorkflowRuntime(): Promise<void>;
+declare function setOpenWorkflowImporter(importer: OpenWorkflowImporter): void;
+//#endregion
+export { runOpenWorkflow as a, resetOpenWorkflowRuntime as i, getOpenWorkflowRuntime as n, setOpenWorkflowImporter as o, registerOpenWorkflowDefinition as r, getOpenWorkflowRun as t };

package/dist/runtime/cloudflare-runner.d.ts

@@ -0,0 +1,27 @@
+import { C as WorkflowProviderStep, h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-ThDitg7Z.js";
+import { t as CloudflareWorkerEnv } from "../cloudflare-env-BVUMOgFK.js";
+
+//#region src/runtime/cloudflare-runner.d.ts
+interface CloudflareWorkflowEvent {
+  id?: string;
+  instanceId?: string;
+  payload?: unknown;
+}
+interface RunCloudflareWorkflowOptions {
+  config: false | ResolvedWorkflowOptions | undefined;
+  env: CloudflareWorkerEnv;
+  event: CloudflareWorkflowEvent;
+  name: string;
+  registry: WorkflowDefinitionRegistry;
+  step?: WorkflowProviderStep;
+}
+declare function runCloudflareWorkflow({
+  config,
+  env,
+  event,
+  name,
+  registry,
+  step
+}: RunCloudflareWorkflowOptions): Promise<unknown>;
+//#endregion
+export { CloudflareWorkflowEvent, RunCloudflareWorkflowOptions, runCloudflareWorkflow };

package/dist/runtime/cloudflare-runner.js

@@ -0,0 +1,23 @@
+import { i as setActiveCloudflareEnv } from "../cloudflare-env-g0Rf3ClH.js";
+import { runWorkflowHandler } from "./execute.js";
+import { loadWorkflowDefinition, runWithWorkflowRuntimeEvent, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry } from "./state.js";
+//#region src/runtime/cloudflare-runner.ts
+async function runCloudflareWorkflow({ config, env, event, name, registry, step }) {
+	setWorkflowRuntimeConfig(config);
+	setWorkflowRuntimeRegistry(registry);
+	setActiveCloudflareEnv(env);
+	const definition = await loadWorkflowDefinition(name);
+	if (!definition) throw new Error(`Missing workflow definition: ${name}`);
+	return await runWithWorkflowRuntimeEvent({
+		env,
+		step
+	}, () => runWorkflowHandler({
+		id: event?.instanceId || event?.id,
+		name,
+		payload: event?.payload,
+		provider: "cloudflare",
+		step
+	}, definition));
+}
+//#endregion
+export { runCloudflareWorkflow };

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

@@ -0,0 +1,2 @@
+import { i as setActiveCloudflareEnv, n as CloudflareWorkerExecutionContext, r as createCloudflareRuntimeEvent, t as CloudflareWorkerEnv } from "../cloudflare-env-BVUMOgFK.js";
+export { CloudflareWorkerEnv, CloudflareWorkerExecutionContext, createCloudflareRuntimeEvent, setActiveCloudflareEnv };

package/dist/runtime/cloudflare-shared.js

@@ -0,0 +1,2 @@
+import { i as setActiveCloudflareEnv, t as createCloudflareRuntimeEvent } from "../cloudflare-env-g0Rf3ClH.js";
+export { createCloudflareRuntimeEvent, setActiveCloudflareEnv };

package/dist/runtime/cloudflare-vite.d.ts

@@ -0,0 +1,17 @@
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-ThDitg7Z.js";
+import { t as WorkflowApp } from "../_app-BVWpnNHo.js";
+import { n as CloudflareWorkerExecutionContext, t as CloudflareWorkerEnv } from "../cloudflare-env-BVUMOgFK.js";
+
+//#region src/runtime/cloudflare-vite.d.ts
+type CloudflareWorkerApp = WorkflowApp;
+interface WorkflowCloudflareWorkerOptions {
+  app?: CloudflareWorkerApp;
+  registry?: WorkflowDefinitionRegistry;
+  workflow?: false | ResolvedWorkflowOptions;
+}
+interface WorkflowCloudflareWorker {
+  fetch: (request: Request, env: CloudflareWorkerEnv, context: CloudflareWorkerExecutionContext) => Promise<Response>;
+}
+declare function createWorkflowCloudflareWorker(options?: WorkflowCloudflareWorkerOptions): WorkflowCloudflareWorker;
+//#endregion
+export { CloudflareWorkerApp, WorkflowCloudflareWorker, WorkflowCloudflareWorkerOptions, createWorkflowCloudflareWorker };

package/dist/runtime/cloudflare-vite.js

@@ -0,0 +1,2 @@
+import { t as createWorkflowCloudflareWorker } from "../cloudflare-vite-DcM5YVTP.js";
+export { createWorkflowCloudflareWorker };

package/dist/runtime/execute.d.ts

@@ -0,0 +1,11 @@
+import { C as WorkflowProviderStep, O as WorkflowStepFunction, g as WorkflowExecutionContext, k as WorkflowStepOptions, p as WorkflowDefinition } from "../types-ThDitg7Z.js";
+
+//#region src/runtime/execute.d.ts
+declare function runProviderStep<TResult>(step: WorkflowProviderStep | undefined, name: string, run: () => TResult | Promise<TResult>, options?: WorkflowStepOptions): Promise<TResult>;
+declare function createWorkflowSteps(context: WorkflowExecutionContext, stepModules: Array<{
+  name: string;
+  run: WorkflowStepFunction;
+}>): Record<string, WorkflowStepFunction>;
+declare function runWorkflowHandler<TPayload, TResult>(context: WorkflowExecutionContext<TPayload>, definition: WorkflowDefinition<TPayload, TResult>): Promise<TResult>;
+//#endregion
+export { createWorkflowSteps, runProviderStep, runWorkflowHandler };

package/dist/runtime/execute.js

@@ -0,0 +1,25 @@
+//#region src/runtime/execute.ts
+const defaultStepOptions = { retries: {
+	backoff: "exponential",
+	delay: "10 seconds",
+	limit: 3
+} };
+async function runProviderStep(step, name, run, options = defaultStepOptions) {
+	if (typeof step?.do === "function") return await step.do(name, options, run);
+	return await run();
+}
+function toStepPropertyName(file) {
+	return file.split("/").pop().replace(/\.(?:c|m)?[jt]s$/i, "").replace(/^\d+[.-]?/, "").replace(/[-_.]+([a-z0-9])/gi, (_, char) => char.toUpperCase());
+}
+function createWorkflowSteps(context, stepModules) {
+	return Object.fromEntries(stepModules.map((module) => {
+		return [toStepPropertyName(module.name), async (input) => await runProviderStep(context.step, `${context.name}/${module.name}`, () => module.run(input))];
+	}));
+}
+async function runWorkflowHandler(context, definition) {
+	const run = () => definition.handler(context);
+	if (definition.options?.rootStep === false) return await run();
+	return await runProviderStep(context.step, context.name, run);
+}
+//#endregion
+export { createWorkflowSteps, runProviderStep, runWorkflowHandler };

package/dist/runtime/nitro-plugin.d.ts

@@ -0,0 +1,6 @@
+import { definePlugin } from "nitro";
+
+//#region src/runtime/nitro-plugin.d.ts
+declare const workflowNitroPlugin: ReturnType<typeof definePlugin>;
+//#endregion
+export { workflowNitroPlugin as default };

package/dist/runtime/nitro-plugin.js

@@ -0,0 +1,14 @@
+import { enterWorkflowRuntimeEvent, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry } from "./state.js";
+import { definePlugin } from "nitro";
+import { useRuntimeConfig } from "nitro/runtime-config";
+import workflowRegistry from "#vitehub/workflow/registry";
+//#region src/runtime/nitro-plugin.ts
+const workflowNitroPlugin = definePlugin((nitroApp) => {
+	setWorkflowRuntimeConfig(useRuntimeConfig().workflow);
+	setWorkflowRuntimeRegistry(workflowRegistry);
+	nitroApp.hooks.hook("request", (event) => {
+		enterWorkflowRuntimeEvent(event);
+	});
+});
+//#endregion
+export { workflowNitroPlugin as default };

package/dist/runtime/openworkflow-worker.d.ts

@@ -0,0 +1,18 @@
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-ThDitg7Z.js";
+import { n as getOpenWorkflowRuntime } from "../openworkflow-amN7IkGO.js";
+
+//#region src/runtime/openworkflow-worker.d.ts
+type OpenWorkflowWorker = ReturnType<Awaited<ReturnType<typeof getOpenWorkflowRuntime>>["client"]["newWorker"]>;
+interface CreateOpenWorkflowWorkerOptions {
+  concurrency?: number;
+  config?: false | ResolvedWorkflowOptions;
+  registry?: WorkflowDefinitionRegistry;
+}
+interface StartOpenWorkflowWorkerOptions extends CreateOpenWorkflowWorkerOptions {
+  signal?: AbortSignal;
+  signals?: boolean;
+}
+declare function createOpenWorkflowWorker(options?: CreateOpenWorkflowWorkerOptions): Promise<OpenWorkflowWorker>;
+declare function startOpenWorkflowWorker(options?: StartOpenWorkflowWorkerOptions): Promise<OpenWorkflowWorker>;
+//#endregion
+export { CreateOpenWorkflowWorkerOptions, StartOpenWorkflowWorkerOptions, createOpenWorkflowWorker, startOpenWorkflowWorker };

package/dist/runtime/openworkflow-worker.js

@@ -0,0 +1,55 @@
+import { getOpenWorkflowRuntime, registerOpenWorkflowDefinition } from "./openworkflow.js";
+import { getInlineWorkflowDefinitions, getWorkflowRuntimeConfig, getWorkflowRuntimeRegistry, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry, takeInlineWorkflowDefinitionForModule } from "./state.js";
+//#region src/runtime/openworkflow-worker.ts
+function getProcess() {
+	return globalThis.process;
+}
+async function loadRegistryDefinitions(registry) {
+	const definitions = /* @__PURE__ */ new Map();
+	for (const name of Object.keys(registry).sort()) {
+		const loaded = await registry[name]?.();
+		const definition = loaded && typeof loaded === "object" && "default" in loaded ? loaded.default : loaded;
+		if (definition && typeof definition === "object" && "handler" in definition && typeof definition.handler === "function") {
+			definitions.set(name, definition);
+			continue;
+		}
+		const inlineDefinition = takeInlineWorkflowDefinitionForModule(name, loaded);
+		if (inlineDefinition) definitions.set(name, inlineDefinition);
+	}
+	return definitions;
+}
+function mergeInlineDefinitions(definitions) {
+	for (const [name, definition] of getInlineWorkflowDefinitions()) {
+		const existing = definitions.get(name);
+		if (existing && existing !== definition) throw new Error(`Duplicate workflow name "${name}" from inline and discovered definitions.`);
+		definitions.set(name, definition);
+	}
+}
+async function createOpenWorkflowWorker(options = {}) {
+	const config = options.config ?? getWorkflowRuntimeConfig();
+	if (!config || config.provider !== "openworkflow") throw new Error("OpenWorkflow worker requires workflow.provider \"openworkflow\".");
+	const registry = options.registry ?? getWorkflowRuntimeRegistry() ?? {};
+	setWorkflowRuntimeConfig(config);
+	setWorkflowRuntimeRegistry(registry);
+	const runtime = await getOpenWorkflowRuntime(config);
+	const definitions = await loadRegistryDefinitions(registry);
+	mergeInlineDefinitions(definitions);
+	for (const [name, definition] of definitions) await registerOpenWorkflowDefinition(runtime, name, definition);
+	return runtime.client.newWorker({ concurrency: options.concurrency ?? config.worker?.concurrency });
+}
+async function startOpenWorkflowWorker(options = {}) {
+	const worker = await createOpenWorkflowWorker(options);
+	await worker.start();
+	const stop = () => {
+		worker.stop();
+	};
+	options.signal?.addEventListener("abort", stop, { once: true });
+	const proc = getProcess();
+	if (options.signals !== false) {
+		proc?.on?.("SIGINT", stop);
+		proc?.on?.("SIGTERM", stop);
+	}
+	return worker;
+}
+//#endregion
+export { createOpenWorkflowWorker, startOpenWorkflowWorker };

package/dist/runtime/openworkflow.d.ts

@@ -0,0 +1,2 @@
+import { a as runOpenWorkflow, i as resetOpenWorkflowRuntime, n as getOpenWorkflowRuntime, o as setOpenWorkflowImporter, r as registerOpenWorkflowDefinition, t as getOpenWorkflowRun } from "../openworkflow-amN7IkGO.js";
+export { getOpenWorkflowRun, getOpenWorkflowRuntime, registerOpenWorkflowDefinition, resetOpenWorkflowRuntime, runOpenWorkflow, setOpenWorkflowImporter };

package/dist/runtime/openworkflow.js

@@ -0,0 +1,143 @@
+import { runWorkflowHandler } from "./execute.js";
+//#region src/runtime/openworkflow.ts
+const defaultImporter = new Function("specifier", "return import(specifier)");
+let openWorkflowImporter = defaultImporter;
+const runtimes = /* @__PURE__ */ new Map();
+function readEnv(name) {
+	const value = (globalThis.process?.env)?.[name];
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function getOpenWorkflowConfig(config) {
+	if (config.provider !== "openworkflow") throw new Error(`OpenWorkflow runtime requires workflow.provider "openworkflow", received "${config.provider}".`);
+	const postgres = config.postgres || {};
+	const url = postgres.url || readEnv("OPENWORKFLOW_POSTGRES_URL") || readEnv("DATABASE_URL");
+	if (!url) throw new Error("Missing OpenWorkflow Postgres URL. Set workflow.postgres.url, OPENWORKFLOW_POSTGRES_URL, or DATABASE_URL.");
+	return {
+		namespaceId: postgres.namespaceId || readEnv("OPENWORKFLOW_NAMESPACE_ID") || "production",
+		runMigrations: postgres.runMigrations,
+		schema: postgres.schema || readEnv("OPENWORKFLOW_SCHEMA") || "openworkflow",
+		url
+	};
+}
+function getRuntimeKey(config) {
+	return JSON.stringify(getOpenWorkflowConfig(config));
+}
+async function createOpenWorkflowRuntime(config) {
+	const options = getOpenWorkflowConfig(config);
+	const [{ OpenWorkflow }, { BackendPostgres }] = await Promise.all([openWorkflowImporter("openworkflow"), openWorkflowImporter("openworkflow/postgres")]);
+	const backend = await BackendPostgres.connect(options.url, {
+		namespaceId: options.namespaceId,
+		...typeof options.runMigrations === "boolean" ? { runMigrations: options.runMigrations } : {},
+		schema: options.schema
+	});
+	return {
+		backend,
+		client: new OpenWorkflow({ backend }),
+		workflows: /* @__PURE__ */ new Map()
+	};
+}
+async function getOpenWorkflowRuntime(config) {
+	const key = getRuntimeKey(config);
+	let runtime = runtimes.get(key);
+	if (!runtime) {
+		runtime = createOpenWorkflowRuntime(config);
+		runtimes.set(key, runtime);
+	}
+	return await runtime;
+}
+function toOpenWorkflowRetryPolicy(options) {
+	const retries = options.retries;
+	if (!retries) return;
+	return {
+		...retries.backoff ? { backoffCoefficient: retries.backoff === "exponential" ? 2 : 1 } : {},
+		...retries.delay ? { initialInterval: retries.delay } : {},
+		...typeof retries.limit === "number" ? { maximumAttempts: retries.limit } : {}
+	};
+}
+function createOpenWorkflowProviderStep(step) {
+	return { async do(name, options, run) {
+		return await step.run({
+			name,
+			...toOpenWorkflowRetryPolicy(options) ? { retryPolicy: toOpenWorkflowRetryPolicy(options) } : {}
+		}, run);
+	} };
+}
+async function registerOpenWorkflowDefinition(runtime, name, definition) {
+	const existing = runtime.workflows.get(name);
+	if (existing) return existing;
+	const workflow = runtime.client.defineWorkflow({ name }, async ({ input, run, step }) => {
+		return await runWorkflowHandler({
+			id: run.id,
+			name,
+			payload: input,
+			provider: "openworkflow",
+			step: createOpenWorkflowProviderStep(step)
+		}, definition);
+	});
+	runtime.workflows.set(name, workflow);
+	return workflow;
+}
+function normalizeOpenWorkflowStatus(status) {
+	switch (String(status || "").toLowerCase()) {
+		case "completed":
+		case "succeeded": return "completed";
+		case "canceled":
+		case "failed": return "failed";
+		case "pending": return "queued";
+		case "running":
+		case "sleeping": return "running";
+		default: return "unknown";
+	}
+}
+function serializeOpenWorkflowRun(run, name) {
+	if (!run || run.workflowName !== name) return {
+		id: run?.id || "",
+		provider: "openworkflow",
+		status: "unknown"
+	};
+	return {
+		id: run.id,
+		metadata: run.error || {
+			namespaceId: run.namespaceId,
+			version: run.version,
+			workflowName: run.workflowName
+		},
+		provider: "openworkflow",
+		result: run.output ?? void 0,
+		status: normalizeOpenWorkflowStatus(run.status)
+	};
+}
+async function runOpenWorkflow(config, name, payload, definition, options) {
+	const handle = await (await registerOpenWorkflowDefinition(await getOpenWorkflowRuntime(config), name, definition)).run(payload, options.id ? { idempotencyKey: options.id } : void 0);
+	return {
+		id: handle.workflowRun.id,
+		metadata: {
+			...options.id ? { idempotencyKey: options.id } : {},
+			workflow: name
+		},
+		payload,
+		provider: "openworkflow",
+		status: normalizeOpenWorkflowStatus(handle.workflowRun.status)
+	};
+}
+async function getOpenWorkflowRun(config, name, id) {
+	const serialized = serializeOpenWorkflowRun(await (await getOpenWorkflowRuntime(config)).backend.getWorkflowRun({ workflowRunId: id }), name);
+	return serialized.id ? serialized : {
+		id,
+		provider: "openworkflow",
+		status: "unknown"
+	};
+}
+async function resetOpenWorkflowRuntime() {
+	const settled = await Promise.allSettled(runtimes.values());
+	runtimes.clear();
+	openWorkflowImporter = defaultImporter;
+	await Promise.all(settled.map(async (entry) => {
+		if (entry.status === "fulfilled") await entry.value.backend.stop();
+	}));
+}
+function setOpenWorkflowImporter(importer) {
+	openWorkflowImporter = importer;
+}
+//#endregion
+export { getOpenWorkflowRun, getOpenWorkflowRuntime, registerOpenWorkflowDefinition, resetOpenWorkflowRuntime, runOpenWorkflow, setOpenWorkflowImporter };

package/dist/runtime/state.d.ts

@@ -0,0 +1,35 @@
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions, p as WorkflowDefinition } from "../types-ThDitg7Z.js";
+
+//#region src/runtime/state.d.ts
+interface WorkflowRunState<TResult = unknown> {
+  error?: unknown;
+  expiresAt?: number;
+  promise: Promise<{
+    result?: TResult;
+    status: "completed" | "failed";
+    error?: unknown;
+  }>;
+  result?: TResult;
+  status: "running" | "completed" | "failed";
+}
+declare function setWorkflowRuntimeConfig(config: false | ResolvedWorkflowOptions | undefined): void;
+declare function getWorkflowRuntimeConfig(): false | ResolvedWorkflowOptions | undefined;
+declare function setWorkflowRuntimeRegistry(registry: WorkflowDefinitionRegistry | undefined): void;
+declare function getWorkflowRuntimeRegistry(): WorkflowDefinitionRegistry | undefined;
+declare function getInlineWorkflowDefinitions(): ReadonlyMap<string, WorkflowDefinition>;
+declare function takeInlineWorkflowDefinition(name: string): WorkflowDefinition | undefined;
+declare function takeInlineWorkflowDefinitionForModule(name: string, loaded: unknown): WorkflowDefinition | undefined;
+declare function registerInlineWorkflowDefinition(name: string, definition: WorkflowDefinition): void;
+declare function enterWorkflowRuntimeEvent(event: unknown): void;
+declare function getWorkflowRuntimeEvent(): unknown;
+declare function runWithWorkflowRuntimeEvent<T>(event: unknown, run: () => T | Promise<T>): Promise<T>;
+declare function loadWorkflowDefinition(name: string): Promise<WorkflowDefinition | undefined>;
+declare function setWorkflowRun<TResult = unknown>(name: string, id: string, promise: Promise<{
+  result?: TResult;
+  status: "completed" | "failed";
+  error?: unknown;
+}>): WorkflowRunState<TResult>;
+declare function getWorkflowRunState(name: string, id: string): WorkflowRunState | undefined;
+declare function resetWorkflowRuntime(): void;
+//#endregion
+export { WorkflowRunState, enterWorkflowRuntimeEvent, getInlineWorkflowDefinitions, getWorkflowRunState, getWorkflowRuntimeConfig, getWorkflowRuntimeEvent, getWorkflowRuntimeRegistry, loadWorkflowDefinition, registerInlineWorkflowDefinition, resetWorkflowRuntime, runWithWorkflowRuntimeEvent, setWorkflowRun, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry, takeInlineWorkflowDefinition, takeInlineWorkflowDefinitionForModule };

package/dist/runtime/state.js

@@ -0,0 +1,179 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/runtime/state.ts
+const RUNS_LIMIT = 1024;
+const RUNS_TTL_MS = 300 * 1e3;
+let runtimeConfig;
+let runtimeRegistry;
+const inlineRegistry = /* @__PURE__ */ new Map();
+const loadingRegistryEntries = /* @__PURE__ */ new Map();
+const loadedRegistryEntries = /* @__PURE__ */ new Map();
+let fallbackEvent;
+const eventStorage = new AsyncLocalStorage();
+const loadingRegistryStorage = new AsyncLocalStorage();
+const loadingInlineRegistryStorage = new AsyncLocalStorage();
+const runs = /* @__PURE__ */ new Map();
+function getRunKey(name, id) {
+	return `${name}\0${id}`;
+}
+function pruneWorkflowRuns() {
+	const now = Date.now();
+	for (const [key, run] of runs) if (run.expiresAt && run.expiresAt <= now) runs.delete(key);
+}
+function setWorkflowRuntimeConfig(config) {
+	runtimeConfig = config;
+}
+function getWorkflowRuntimeConfig() {
+	return runtimeConfig;
+}
+function setWorkflowRuntimeRegistry(registry) {
+	runtimeRegistry = registry;
+	loadedRegistryEntries.clear();
+}
+function getWorkflowRuntimeRegistry() {
+	return runtimeRegistry;
+}
+function getInlineWorkflowDefinitions() {
+	return inlineRegistry;
+}
+function takeInlineWorkflowDefinition(name) {
+	const definition = inlineRegistry.get(name);
+	inlineRegistry.delete(name);
+	loadingInlineRegistryStorage.getStore()?.delete(name);
+	return definition;
+}
+function isWorkflowHandle(value) {
+	return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.defer === "function" && typeof value.getRun === "function" && typeof value.run === "function";
+}
+function findExportedInlineWorkflowDefinition(name, loaded, definitions) {
+	const namedDefinition = definitions.get(name);
+	if (namedDefinition) return {
+		definition: namedDefinition,
+		name
+	};
+	if (!loaded || typeof loaded !== "object") return void 0;
+	if ("default" in loaded && isWorkflowHandle(loaded.default)) {
+		const definition = definitions.get(loaded.default.name);
+		if (definition) return {
+			definition,
+			name: loaded.default.name
+		};
+	}
+	const matches = /* @__PURE__ */ new Map();
+	for (const value of Object.values(loaded)) {
+		if (!isWorkflowHandle(value)) continue;
+		const definition = definitions.get(value.name);
+		if (definition) matches.set(value.name, definition);
+	}
+	if (matches.size !== 1) return void 0;
+	const [matchedName, definition] = matches.entries().next().value;
+	return {
+		definition,
+		name: matchedName
+	};
+}
+function takeInlineWorkflowDefinitionForModule(name, loaded) {
+	const match = findExportedInlineWorkflowDefinition(name, loaded, inlineRegistry);
+	if (!match) return void 0;
+	inlineRegistry.delete(match.name);
+	return match.definition;
+}
+function consumeInlineWorkflowDefinition(name, expected) {
+	const definition = inlineRegistry.get(name);
+	if (!expected || definition === expected) inlineRegistry.delete(name);
+	return definition;
+}
+function registerInlineWorkflowDefinition(name, definition) {
+	if (!name || typeof name !== "string") throw new TypeError("`createWorkflow()` requires a workflow name.");
+	const loadingDefinitions = loadingInlineRegistryStorage.getStore();
+	const existing = inlineRegistry.get(name);
+	if (existing && existing !== definition) {
+		if (!loadingDefinitions) throw new Error(`Duplicate workflow name "${name}" from inline definitions.`);
+	}
+	inlineRegistry.set(name, definition);
+	loadingDefinitions?.set(name, definition);
+}
+function enterWorkflowRuntimeEvent(event) {
+	fallbackEvent = event;
+	try {
+		eventStorage.enterWith(event);
+	} catch {}
+}
+function getWorkflowRuntimeEvent() {
+	return eventStorage.getStore() ?? fallbackEvent;
+}
+async function runWithWorkflowRuntimeEvent(event, run) {
+	return await eventStorage.run(event, run);
+}
+async function loadWorkflowDefinition(name) {
+	const inlineDefinition = inlineRegistry.get(name);
+	const entry = runtimeRegistry?.[name];
+	if (entry && loadedRegistryEntries.has(name)) return loadedRegistryEntries.get(name);
+	if (inlineDefinition) {
+		if (entry) throw new Error(`Duplicate workflow name "${name}" from inline and discovered definitions.`);
+		return inlineDefinition;
+	}
+	if (!entry) return;
+	const activeLoads = loadingRegistryStorage.getStore();
+	const inFlightEntry = loadingRegistryEntries.get(name);
+	if (inFlightEntry) return activeLoads?.has(name) ? void 0 : await inFlightEntry;
+	const nextActiveLoads = new Set(activeLoads);
+	nextActiveLoads.add(name);
+	const loadingEntry = Promise.resolve().then(() => loadingRegistryStorage.run(nextActiveLoads, async () => {
+		const loadingInlineDefinitions = /* @__PURE__ */ new Map();
+		const loaded = await loadingInlineRegistryStorage.run(loadingInlineDefinitions, entry);
+		if (!loaded || typeof loaded !== "object") return;
+		const registeredInlineDefinition = loadingInlineDefinitions.get(name) ?? consumeInlineWorkflowDefinition(name);
+		if (registeredInlineDefinition) {
+			consumeInlineWorkflowDefinition(name, registeredInlineDefinition);
+			return registeredInlineDefinition;
+		}
+		const definition = "default" in loaded ? loaded.default : loaded;
+		if (definition && typeof definition.handler === "function") return definition;
+		const exportedInlineDefinition = findExportedInlineWorkflowDefinition(name, loaded, loadingInlineDefinitions);
+		if (!exportedInlineDefinition) return void 0;
+		consumeInlineWorkflowDefinition(exportedInlineDefinition.name, exportedInlineDefinition.definition);
+		return exportedInlineDefinition.definition;
+	}));
+	loadingRegistryEntries.set(name, loadingEntry);
+	try {
+		const loaded = await loadingEntry;
+		loadedRegistryEntries.set(name, loaded);
+		return loaded;
+	} finally {
+		loadingRegistryEntries.delete(name);
+	}
+}
+function setWorkflowRun(name, id, promise) {
+	pruneWorkflowRuns();
+	if (runs.size >= RUNS_LIMIT) {
+		const oldest = runs.keys().next().value;
+		if (oldest !== void 0) runs.delete(oldest);
+	}
+	const state = {
+		promise: promise.then((resolved) => {
+			state.status = resolved.status;
+			state.result = resolved.result;
+			state.error = resolved.error;
+			state.expiresAt = Date.now() + RUNS_TTL_MS;
+			return resolved;
+		}),
+		status: "running"
+	};
+	runs.set(getRunKey(name, id), state);
+	return state;
+}
+function getWorkflowRunState(name, id) {
+	pruneWorkflowRuns();
+	return runs.get(getRunKey(name, id));
+}
+function resetWorkflowRuntime() {
+	runtimeConfig = void 0;
+	runtimeRegistry = void 0;
+	inlineRegistry.clear();
+	loadingRegistryEntries.clear();
+	loadedRegistryEntries.clear();
+	fallbackEvent = void 0;
+	runs.clear();
+}
+//#endregion
+export { enterWorkflowRuntimeEvent, getInlineWorkflowDefinitions, getWorkflowRunState, getWorkflowRuntimeConfig, getWorkflowRuntimeEvent, getWorkflowRuntimeRegistry, loadWorkflowDefinition, registerInlineWorkflowDefinition, resetWorkflowRuntime, runWithWorkflowRuntimeEvent, setWorkflowRun, setWorkflowRuntimeConfig, setWorkflowRuntimeRegistry, takeInlineWorkflowDefinition, takeInlineWorkflowDefinitionForModule };

package/dist/runtime/vercel-vite.d.ts

@@ -0,0 +1,14 @@
+import { h as WorkflowDefinitionRegistry, l as ResolvedWorkflowOptions } from "../types-ThDitg7Z.js";
+import { t as WorkflowApp } from "../_app-BVWpnNHo.js";
+import { IncomingMessage, ServerResponse } from "node:http";
+
+//#region src/runtime/vercel-vite.d.ts
+interface WorkflowVercelServerOptions {
+  app?: WorkflowApp;
+  registry?: WorkflowDefinitionRegistry;
+  workflow?: false | ResolvedWorkflowOptions;
+}
+type WorkflowVercelServer = (req: IncomingMessage, res: ServerResponse) => unknown;
+declare function createWorkflowVercelServer(options?: WorkflowVercelServerOptions): WorkflowVercelServer;
+//#endregion
+export { WorkflowVercelServer, createWorkflowVercelServer };