vite-plugin-windmill 1.683.0

package/dist/index.mjs

@@ -0,0 +1,1044 @@
+import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { ApiError, AppService, JobService, setClient } from "windmill-client";
+import { createHash } from "node:crypto";
+import { parse } from "yaml";
+import { Readable } from "node:stream";
+import { scheduler } from "node:timers/promises";
+import { loadEnv } from "vite";
+//#region src/project.ts
+const WMILL_IMPORT_PATTERN = /^(?:\.\/|\/)?wmill(?:\.ts)?$|^(?:\.\.\/)+wmill(?:\.ts)?$/;
+const RAW_APP_FOLDER_SUFFIXES = [".raw_app", "__raw_app"];
+const RAW_APP_FILE_NAME = "raw_app.yaml";
+const WMILL_CONFIG_FILE_NAME = "wmill.yaml";
+const DEPLOY_IGNORED_FILE_NAMES = new Set([
+	"AGENTS.md",
+	"DATATABLES.md",
+	"package-lock.json",
+	"raw_app.yaml",
+	"wmill.d.ts"
+]);
+const DEPLOY_IGNORED_DIRECTORIES = new Set([
+	".claude",
+	"backend",
+	"dist",
+	"node_modules",
+	"sql_to_apply"
+]);
+const LANGUAGE_BY_EXTENSION = {
+	"bq.sql": "bigquery",
+	"bun.ts": "bun",
+	cs: "csharp",
+	"deno.ts": "deno",
+	"duckdb.sql": "duckdb",
+	"frontend.js": "frontend",
+	go: "go",
+	gql: "graphql",
+	java: "java",
+	"ms.sql": "mssql",
+	"my.sql": "mysql",
+	"native.ts": "nativets",
+	nu: "nu",
+	"odb.sql": "oracledb",
+	"pg.sql": "postgresql",
+	php: "php",
+	"playbook.yml": "ansible",
+	ps1: "powershell",
+	py: "python3",
+	rb: "ruby",
+	rs: "rust",
+	"sf.sql": "snowflake",
+	sh: "bash",
+	ts: "bun"
+};
+const isNodeError = (value) => value instanceof Error && "code" in value;
+const pathExists = async (filePath) => {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const normalizeToPosix = (value) => value.split(path.sep).join("/");
+const dirnameIfPossible = (value) => {
+	const parent = path.dirname(value);
+	return parent === value ? void 0 : parent;
+};
+const findUp = async (startDir, fileName) => {
+	let currentDir = path.resolve(startDir);
+	while (true) {
+		const candidate = path.join(currentDir, fileName);
+		if (await pathExists(candidate)) return candidate;
+		const parentDir = dirnameIfPossible(currentDir);
+		if (!parentDir) return void 0;
+		currentDir = parentDir;
+	}
+};
+const parseYamlFile = async (filePath) => {
+	return parse(await readFile(filePath, "utf8"));
+};
+const resolveRoot = async (explicitRoot, dir) => {
+	if (explicitRoot) {
+		const root = path.resolve(explicitRoot);
+		return {
+			path: await pathExists(path.join(root, WMILL_CONFIG_FILE_NAME)) ? path.join(root, WMILL_CONFIG_FILE_NAME) : void 0,
+			root
+		};
+	}
+	const configPath = await findUp(dir, WMILL_CONFIG_FILE_NAME);
+	return {
+		path: configPath,
+		root: configPath ? path.dirname(configPath) : dir
+	};
+};
+const resolveDir = async (explicitDir) => {
+	const candidate = path.resolve(explicitDir ?? process.cwd());
+	const rawAppPath = await findUp(candidate, RAW_APP_FILE_NAME);
+	if (!rawAppPath) throw new Error(`Could not find ${RAW_APP_FILE_NAME} from ${candidate}`);
+	return path.dirname(rawAppPath);
+};
+const stripRawAppSuffix = (folderName) => {
+	for (const suffix of RAW_APP_FOLDER_SUFFIXES) if (folderName.endsWith(suffix)) return folderName.slice(0, -suffix.length);
+};
+const inferPath = (dir, root) => {
+	const segments = normalizeToPosix(path.relative(root, dir)).split("/").filter(Boolean);
+	if (segments.length === 0) throw new Error(`Could not infer a Windmill app path from ${dir}`);
+	const lastSegment = segments.at(-1);
+	if (!lastSegment) throw new Error(`Could not infer a Windmill app path from ${dir}`);
+	const strippedSegment = stripRawAppSuffix(lastSegment);
+	if (!strippedSegment) throw new Error(`Expected ${dir} to end in .raw_app or __raw_app so the app path can be inferred`);
+	return [...segments.slice(0, -1), strippedSegment].join("/");
+};
+const inferBase = (pathValue) => `/apps_raw/get/${pathValue}/`;
+const resolveEntry = async (dir, value) => {
+	if (value) {
+		const entry = path.resolve(dir, value);
+		if (!await pathExists(entry)) throw new Error(`Entry file does not exist: ${entry}`);
+		return entry;
+	}
+	const tsEntry = path.join(dir, "index.ts");
+	if (await pathExists(tsEntry)) return tsEntry;
+	const tsxEntry = path.join(dir, "index.tsx");
+	if (await pathExists(tsxEntry)) return tsxEntry;
+	throw new Error(`Could not find index.ts or index.tsx inside ${dir}`);
+};
+const resolveEnv = (options) => ({
+	url: options.url ?? process.env.BASE_INTERNAL_URL ?? process.env.BASE_URL,
+	token: options.token ?? process.env.WM_TOKEN,
+	workspace: options.workspace ?? process.env.WM_WORKSPACE
+});
+const resolveProject = async (options = {}) => {
+	const dir = await resolveDir(options.dir);
+	const { path: config, root } = await resolveRoot(options.root, dir);
+	const wmillConfig = config ? await parseYamlFile(config) : {};
+	const pathValue = options.path ?? inferPath(dir, root);
+	const entry = await resolveEntry(dir, options.entry);
+	const { url, token, workspace } = resolveEnv(options);
+	return {
+		base: options.base ?? inferBase(pathValue),
+		config,
+		dir,
+		entry,
+		nonDotted: options.nonDotted ?? wmillConfig.nonDottedPaths ?? false,
+		path: pathValue,
+		root,
+		syncExcludes: wmillConfig.excludes ?? [],
+		ts: options.ts ?? wmillConfig.defaultTs ?? "bun",
+		workspace,
+		token,
+		url,
+		yaml: path.join(dir, RAW_APP_FILE_NAME)
+	};
+};
+const collectStaticFields = (fields) => Object.fromEntries(Object.entries(fields ?? {}).filter(([, field]) => field.type === "static").map(([name, field]) => [name, field.value]));
+const createRawscriptHash = (content) => createHash("sha256").update(content ?? "").digest("hex");
+const resolveTriggerableEntry = async (runnableId, runnable) => {
+	const staticInputs = collectStaticFields(runnable.fields);
+	const allowUserResources = Object.entries(runnable.fields ?? {}).filter(([, field]) => field.allowUserResources).map(([name]) => name);
+	if (runnable.inlineScript) return [`${runnableId}:rawscript/${createRawscriptHash(runnable.inlineScript.content)}`, {
+		allow_user_resources: allowUserResources,
+		one_of_inputs: {},
+		static_inputs: staticInputs
+	}];
+	if (runnable.path && runnable.runType) return [`${runnableId}:${runnable.runType === "hubscript" ? "script" : runnable.runType}/${runnable.path}`, {
+		allow_user_resources: allowUserResources,
+		one_of_inputs: {},
+		static_inputs: staticInputs
+	}];
+};
+const generateRawAppPolicy = async (runnables, policy, isPublic) => {
+	const resolvedTriggerableEntries = (await Promise.all(Object.entries(runnables).map(async ([runnableId, runnable]) => resolveTriggerableEntry(runnableId, runnable)))).filter((entry) => entry !== void 0);
+	return {
+		...policy,
+		execution_mode: isPublic ? "anonymous" : "publisher",
+		triggerables_v2: Object.fromEntries(resolvedTriggerableEntries)
+	};
+};
+const resolveRunnableLanguage = (extension, ts) => {
+	const language = LANGUAGE_BY_EXTENSION[extension];
+	if (!language) return void 0;
+	return extension === "ts" ? ts : language;
+};
+const findRunnableContentFile = async (backendDir, runnableId, allFileNames) => {
+	for (const fileName of allFileNames) {
+		if (fileName.endsWith(".yaml") || fileName.endsWith(".lock")) continue;
+		if (!fileName.startsWith(`${runnableId}.`)) continue;
+		const extension = fileName.slice(runnableId.length + 1);
+		if (!resolveRunnableLanguage(extension, "bun")) continue;
+		return {
+			content: await readFile(path.join(backendDir, fileName), "utf8"),
+			extension
+		};
+	}
+};
+const getRunnableIdFromCodeFile = (fileName) => {
+	if (fileName.endsWith(".yaml") || fileName.endsWith(".lock")) return void 0;
+	for (const extension of Object.keys(LANGUAGE_BY_EXTENSION)) if (fileName.endsWith(`.${extension}`)) return fileName.slice(0, -(extension.length + 1));
+};
+const inlinePathPrefix = "!inline ";
+const dereferenceInlineValue = async (value, localPath) => {
+	if (typeof value !== "string" || !value.startsWith(inlinePathPrefix)) return value;
+	const relativePath = value.slice(8);
+	return readFile(path.join(localPath, relativePath), "utf8");
+};
+const cloneRunnable = async (value, localPath) => {
+	if (Array.isArray(value)) return Promise.all(value.map(async (item) => cloneRunnable(item, localPath)));
+	if (typeof value !== "object" || value === null) return dereferenceInlineValue(value, localPath);
+	const entries = await Promise.all(Object.entries(value).map(async ([key, entryValue]) => [key, await cloneRunnable(entryValue, localPath)]));
+	return Object.fromEntries(entries);
+};
+const loadRunnablesFromBackend = async (backendDir, ts = "bun") => {
+	const runnables = {};
+	try {
+		const allFileNames = (await readdir(backendDir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name);
+		const processedIds = /* @__PURE__ */ new Set();
+		for (const fileName of allFileNames) {
+			if (!fileName.endsWith(".yaml")) continue;
+			const runnableId = fileName.slice(0, -5);
+			processedIds.add(runnableId);
+			const runnable = await parseYamlFile(path.join(backendDir, fileName));
+			if (runnable.type === "inline") {
+				const contentFile = await findRunnableContentFile(backendDir, runnableId, allFileNames);
+				if (contentFile) {
+					const lockPath = path.join(backendDir, `${runnableId}.lock`);
+					let lock;
+					try {
+						lock = await readFile(lockPath, "utf8");
+					} catch (error) {
+						if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+					}
+					runnable.inlineScript = {
+						...runnable.inlineScript,
+						content: contentFile.content,
+						language: resolveRunnableLanguage(contentFile.extension, ts),
+						...lock ? { lock } : {}
+					};
+				}
+			} else if (runnable.type === "flow" || runnable.type === "hubscript" || runnable.type === "script") {
+				const { type, schema: _schema, ...rest } = runnable;
+				runnables[runnableId] = {
+					...rest,
+					runType: type,
+					type: "path"
+				};
+				continue;
+			}
+			runnables[runnableId] = runnable;
+		}
+		for (const fileName of allFileNames) {
+			const runnableId = getRunnableIdFromCodeFile(fileName);
+			if (!runnableId || processedIds.has(runnableId)) continue;
+			processedIds.add(runnableId);
+			const contentFile = await findRunnableContentFile(backendDir, runnableId, allFileNames);
+			if (!contentFile) continue;
+			const lockPath = path.join(backendDir, `${runnableId}.lock`);
+			let lock;
+			try {
+				lock = await readFile(lockPath, "utf8");
+			} catch (error) {
+				if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+			}
+			runnables[runnableId] = {
+				inlineScript: {
+					content: contentFile.content,
+					language: resolveRunnableLanguage(contentFile.extension, ts),
+					...lock ? { lock } : {}
+				},
+				type: "inline"
+			};
+		}
+	} catch (error) {
+		if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+	}
+	return runnables;
+};
+const matchesSyncExclude = (relativePath, excludes) => excludes.some((pattern) => path.posix.matchesGlob(relativePath, pattern));
+const collectAppFiles = async (dir, options = {}) => {
+	const files = {};
+	const root = options.root ? path.resolve(options.root) : dir;
+	const excludes = options.excludes ?? [];
+	const walk = async (currentDir, relativeDir = "/") => {
+		const entries = await readdir(currentDir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(currentDir, entry.name);
+			const relativePath = `${relativeDir}${entry.name}`;
+			const relativeToRoot = normalizeToPosix(path.relative(root, fullPath));
+			if (entry.isDirectory()) {
+				if (DEPLOY_IGNORED_DIRECTORIES.has(entry.name)) continue;
+				await walk(fullPath, `${relativePath}/`);
+				continue;
+			}
+			if (DEPLOY_IGNORED_FILE_NAMES.has(entry.name)) continue;
+			if (matchesSyncExclude(relativeToRoot, excludes)) continue;
+			files[relativePath] = await readFile(fullPath, "utf8");
+		}
+	};
+	await walk(dir);
+	return files;
+};
+const loadRawAppProject = async (project) => {
+	const config = await parseYamlFile(project.yaml);
+	const backendDir = path.join(project.dir, "backend");
+	const backendRunnables = await loadRunnablesFromBackend(backendDir, project.ts);
+	const runnables = await cloneRunnable(Object.keys(backendRunnables).length > 0 ? backendRunnables : config.runnables ?? {}, backendDir);
+	const files = await collectAppFiles(project.dir, {
+		excludes: project.syncExcludes,
+		root: project.root
+	});
+	return {
+		config,
+		files,
+		policy: await generateRawAppPolicy(runnables, config.policy, Boolean(config.public)),
+		runnables,
+		value: {
+			...config.data !== void 0 ? { data: config.data } : {},
+			files,
+			runnables
+		}
+	};
+};
+const createArgsType = (_runnable) => "{}";
+const generateWmillDts = (runnables) => `// THIS FILE IS READ-ONLY
+// AND GENERATED AUTOMATICALLY FROM YOUR RUNNABLES
+
+export declare const backend: {
+${Object.entries(runnables).map(([name, runnable]) => `  ${name}: (args: ${createArgsType(runnable)}) => Promise<any>`).join("\n")}
+}
+
+export declare const backendAsync: {
+${Object.entries(runnables).map(([name, runnable]) => `  ${name}: (args: ${createArgsType(runnable)}) => Promise<string>`).join("\n")}
+}
+
+export type Job = {
+  type: 'QueuedJob' | 'CompletedJob'
+  id: string
+  created_at: number
+  started_at: number | undefined
+  duration_ms: number
+  success: boolean
+  args: any
+  result: any
+}
+
+export declare function waitJob(id: string): Promise<Job>
+export declare function getJob(id: string): Promise<Job>
+
+export type StreamUpdate = {
+  new_result_stream?: string
+  stream_offset?: number
+}
+
+export declare function streamJob(id: string, onUpdate?: (data: StreamUpdate) => void): Promise<any>
+`;
+const writeGeneratedWmillTypes = async (project) => {
+	const rawAppProject = await loadRawAppProject(project);
+	const filePath = path.join(project.dir, "wmill.d.ts");
+	const contents = generateWmillDts(rawAppProject.runnables);
+	await mkdir(path.dirname(filePath), { recursive: true });
+	await writeFile(filePath, contents);
+};
+//#endregion
+//#region src/deploy.ts
+const defaultDeploymentMessage = () => {
+	const sha = process.env.GITHUB_SHA;
+	return sha ? `vite-plugin-windmill deploy ${sha}` : "vite-plugin-windmill deploy";
+};
+const requireProjectConnection$1 = (project) => {
+	if (!project.workspace) throw new Error("Missing Windmill workspace. Set `workspace` or `WM_WORKSPACE`.");
+	if (!project.token) throw new Error("Missing Windmill token. Set `token` or `WM_TOKEN`.");
+	if (!project.url) throw new Error("Missing Windmill URL. Set `url`, `BASE_INTERNAL_URL`, or `BASE_URL`.");
+	return {
+		url: project.url,
+		token: project.token,
+		workspace: project.workspace
+	};
+};
+const readBundleFile = async (filePath, fallback = "") => {
+	try {
+		return await readFile(filePath, "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return fallback;
+		throw error;
+	}
+};
+const readBundleContents = async (dir, js = path.join(dir, "dist/windmill/bundle.js"), css = path.join(dir, "dist/windmill/bundle.css")) => ({
+	css: await readBundleFile(css, ""),
+	js: await readBundleFile(js)
+});
+const findExistingRawApp = async (workspace, pathValue) => {
+	try {
+		return await AppService.getAppByPath({
+			workspace,
+			path: pathValue
+		});
+	} catch (error) {
+		if (error instanceof ApiError && error.status === 404) return void 0;
+		throw error;
+	}
+};
+/**
+* Deploys a raw app to Windmill using `windmill-client` instead of shelling out to the CLI.
+*/
+const deploy = async (options) => {
+	const dir = options.dir ?? process.cwd();
+	const project = await resolveProject({
+		...options,
+		dir
+	});
+	const rawAppProject = await loadRawAppProject(project);
+	const connection = requireProjectConnection$1(project);
+	const bundles = options.bundles ?? await readBundleContents(dir, options.js, options.css);
+	if (!bundles.js) throw new Error("Cannot deploy a Windmill raw app without a JavaScript bundle");
+	if (options.dry) return {
+		action: "dry-run",
+		base: project.base,
+		path: project.path,
+		workspace: connection.workspace
+	};
+	setClient(connection.token, connection.url);
+	const existingApp = await findExistingRawApp(connection.workspace, project.path);
+	if (existingApp && !existingApp.raw_app) throw new Error(`${project.path} exists remotely but is not a raw app`);
+	const message = options.message ?? defaultDeploymentMessage();
+	const appPayload = {
+		...rawAppProject.config.custom_path ? { custom_path: rawAppProject.config.custom_path } : {},
+		deployment_message: message,
+		path: project.path,
+		policy: rawAppProject.policy,
+		summary: rawAppProject.config.summary,
+		value: rawAppProject.value
+	};
+	if (existingApp) {
+		await AppService.updateAppRaw({
+			workspace: connection.workspace,
+			path: project.path,
+			formData: {
+				app: appPayload,
+				css: bundles.css,
+				js: bundles.js
+			}
+		});
+		return {
+			action: "update",
+			base: project.base,
+			path: project.path,
+			workspace: connection.workspace
+		};
+	}
+	await AppService.createAppRaw({
+		workspace: connection.workspace,
+		formData: {
+			app: appPayload,
+			css: bundles.css,
+			js: bundles.js
+		}
+	});
+	return {
+		action: "create",
+		base: project.base,
+		path: project.path,
+		workspace: connection.workspace
+	};
+};
+//#endregion
+//#region src/dev-runtime-source.ts
+const devRuntimeSource = String.raw`
+const requestJson = async (path, body) => {
+	const response = await fetch(path, {
+		method: 'POST',
+		headers: { 'content-type': 'application/json' },
+		body: body ? JSON.stringify(body) : undefined,
+	})
+
+	const payload = await response.json()
+	if (!response.ok || payload.error) {
+		throw new Error(
+			payload.error ?? 'Windmill dev request failed with status ' + response.status,
+		)
+	}
+
+	return payload.result
+}
+
+export const backend = new Proxy(
+	{},
+	{
+		get(_, runnableId) {
+			return async (v) =>
+				requestJson('/__windmill__/backend', { runnableId, args: v ?? {} })
+		},
+	},
+)
+
+export const backendAsync = new Proxy(
+	{},
+	{
+		get(_, runnableId) {
+			return async (v) =>
+				requestJson('/__windmill__/backend-async', { runnableId, args: v ?? {} })
+		},
+	},
+)
+
+export const waitJob = async (jobId) => requestJson('/__windmill__/wait-job', { jobId })
+
+export const getJob = async (jobId) => requestJson('/__windmill__/get-job', { jobId })
+
+export const streamJob = async (jobId, onUpdate) =>
+	new Promise((resolve, reject) => {
+		const source = new EventSource(
+			'/__windmill__/stream-job/' + encodeURIComponent(jobId),
+		)
+
+		source.addEventListener('update', (event) => {
+			const data = JSON.parse(event.data)
+			onUpdate?.(data)
+		})
+
+		source.addEventListener('done', (event) => {
+			source.close()
+			resolve(JSON.parse(event.data))
+		})
+
+		source.addEventListener('error', (event) => {
+			source.close()
+			const message =
+				event instanceof MessageEvent && typeof event.data === 'string'
+					? event.data
+					: 'Windmill stream request failed'
+			reject(new Error(message))
+		})
+	})
+`;
+//#endregion
+//#region src/generated/upstream-build-runtime.ts
+const buildRuntimeSource = "let reqs = {};\nfunction doRequest(type, o, extra) {\n    return new Promise((resolve, reject) => {\n        const reqId = Math.random().toString(36);\n        reqs[reqId] = { resolve, reject, ...extra };\n        const req = { ...o, type, reqId };\n        parent.postMessage(req, '*');\n    });\n}\nexport const backend = new Proxy({}, {\n    get(_, runnable_id) {\n        return (v) => {\n            return doRequest('backend', { runnable_id, v });\n        };\n    }\n});\nexport const backendAsync = new Proxy({}, {\n    get(_, runnable_id) {\n        return (v) => {\n            return doRequest('backendAsync', { runnable_id, v });\n        };\n    }\n});\nexport function waitJob(jobId) {\n    return doRequest('waitJob', { jobId });\n}\nexport function getJob(jobId) {\n    return doRequest('getJob', { jobId });\n}\n/**\n * Stream job results using SSE. Calls onUpdate for each stream update,\n * and resolves with the final result when the job completes.\n * @param jobId - The job ID to stream\n * @param onUpdate - Callback for stream updates with new_result_stream data\n * @returns Promise that resolves with the final job result\n */\nexport function streamJob(jobId, onUpdate) {\n    return doRequest('streamJob', { jobId }, { onUpdate });\n}\nwindow.addEventListener('message', (e) => {\n    if (e.data.type === 'streamJobUpdate') {\n        // Handle streaming update\n        let job = reqs[e.data.reqId];\n        if (job && job.onUpdate) {\n            job.onUpdate({\n                new_result_stream: e.data.new_result_stream,\n                stream_offset: e.data.stream_offset\n            });\n        }\n    }\n    else if (e.data.type === 'streamJobRes') {\n        // Handle stream completion\n        let job = reqs[e.data.reqId];\n        if (job) {\n            if (e.data.error) {\n                job.reject(new Error(e.data.result?.stack ?? e.data.result?.message ?? 'Stream error'));\n            }\n            else {\n                job.resolve(e.data.result);\n            }\n            delete reqs[e.data.reqId];\n        }\n    }\n    else if (e.data.type === 'backendRes' ||\n        e.data.type === 'backendAsyncRes' ||\n        e.data.type === 'waitJobRes' ||\n        e.data.type === 'getJobRes') {\n        console.log('Message from parent backend', e.data);\n        let job = reqs[e.data.reqId];\n        if (job) {\n            const result = e.data.result;\n            if (e.data.error) {\n                job.reject(new Error(result.stack ?? result.message));\n            }\n            else {\n                job.resolve(result);\n            }\n            delete reqs[e.data.reqId];\n        }\n        else {\n            console.error('No job found for', e.data.reqId);\n        }\n    }\n});\n";
+//#endregion
+//#region src/runtime.ts
+const getWindmillRuntimeSource = (mode) => mode === "serve" ? devRuntimeSource : buildRuntimeSource;
+//#endregion
+//#region src/plugin.ts
+const RESOLVED_VIRTUAL_WMILL_ID = `\0virtual:vite-plugin-windmill/wmill`;
+const DEFAULT_BUILD_OUT_DIR = "dist/windmill";
+const DEFAULT_API_PROXY_CONTEXT = "/api";
+const DEPLOY_TRUE_VALUES = new Set([
+	"",
+	"1",
+	"on",
+	"true",
+	"yes"
+]);
+const DEPLOY_FALSE_VALUES = new Set([
+	"0",
+	"false",
+	"no",
+	"off"
+]);
+const DEPLOY_DRY_VALUES = new Set(["check", "dry"]);
+const normalizePath = (value) => value.split(path.sep).join("/");
+const buildHtmlDocument = (entryFile) => {
+	return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Windmill Dev</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/@vite/client"><\/script>
+    <script type="module" src="${normalizePath(entryFile.startsWith("/") ? entryFile : `/${entryFile}`)}"><\/script>
+  </body>
+</html>`;
+};
+const toErrorMessage = (value) => {
+	if (value instanceof Error) return value.message;
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return "Unknown error";
+	}
+};
+const requireString = (value, fieldName) => {
+	if (typeof value === "string" && value.length > 0) return value;
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	throw new Error(`Missing or invalid ${fieldName}`);
+};
+const requireProjectConnection = (project) => {
+	if (!project.workspace) throw new Error("Missing Windmill workspace. Set `workspace` or `WM_WORKSPACE`.");
+	if (!project.token) throw new Error("Missing Windmill token. Set `token` or `WM_TOKEN`.");
+	if (!project.url) throw new Error("Missing Windmill URL. Set `url`, `BASE_INTERNAL_URL`, or `BASE_URL`.");
+	return {
+		url: project.url,
+		token: project.token,
+		workspace: project.workspace
+	};
+};
+const readJsonBody = async (request) => {
+	const chunks = [];
+	for await (const chunk of request) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+	if (chunks.length === 0) return {};
+	return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+};
+const waitForJobResult = async (workspace, jobId) => {
+	let delay = 50;
+	for (;;) {
+		const result = await JobService.getCompletedJobResultMaybe({
+			workspace,
+			id: jobId,
+			getStarted: false
+		});
+		if (result.completed) {
+			if (!result.success && typeof result.result === "object" && result.result && "error" in result.result) throw new Error(toErrorMessage(result.result.error));
+			return result.result;
+		}
+		await scheduler.wait(delay);
+		delay = delay >= 500 ? 2e3 : 500;
+	}
+};
+const executeRunnable = async (project, workspace, runnableId, runnable, args) => {
+	const requestBody = {
+		args: args ?? {},
+		component: runnableId,
+		force_viewer_allow_user_resources: Object.entries(runnable.fields ?? {}).filter(([, field]) => field.allowUserResources).map(([name]) => name),
+		force_viewer_one_of_fields: {},
+		force_viewer_static_fields: Object.fromEntries(Object.entries(runnable.fields ?? {}).filter(([, field]) => field.type === "static").map(([name, field]) => [name, field.value]))
+	};
+	if (runnable.inlineScript) {
+		requestBody.raw_code = {
+			cache_ttl: runnable.inlineScript.cache_ttl,
+			content: runnable.inlineScript.id === void 0 ? runnable.inlineScript.content ?? "" : "",
+			language: runnable.inlineScript.language ?? "",
+			lock: runnable.inlineScript.id === void 0 ? runnable.inlineScript.lock : void 0,
+			path: `${project.path}/${runnableId}`
+		};
+		if (runnable.inlineScript.id !== void 0) requestBody.id = runnable.inlineScript.id;
+	} else if (runnable.path && runnable.runType) requestBody.path = `${runnable.runType === "hubscript" ? "script" : runnable.runType}/${runnable.path}`;
+	else throw new Error(`Runnable ${runnableId} is missing inline or path metadata`);
+	return AppService.executeComponent({
+		workspace,
+		path: project.path,
+		requestBody
+	});
+};
+const extractBundleContents = (bundle) => {
+	let css = "";
+	let js = "";
+	for (const output of Object.values(bundle)) {
+		if (output.type === "chunk" && output.fileName === "bundle.js") js = output.code;
+		if (output.type === "asset" && output.fileName === "bundle.css") css = typeof output.source === "string" ? output.source : Buffer.from(output.source).toString("utf8");
+	}
+	return {
+		css,
+		js
+	};
+};
+const hasAuthorizationHeader = (headers) => Object.keys(headers ?? {}).some((key) => key.toLowerCase() === "authorization");
+const resolveApiProxyConfig = (project, proxy) => {
+	if (proxy === false) return void 0;
+	const proxyOptions = proxy && typeof proxy === "object" ? { ...proxy } : void 0;
+	if (!(typeof proxy === "object" ? proxy.enabled ?? true : proxy ?? true)) return void 0;
+	const context = proxyOptions?.context ?? DEFAULT_API_PROXY_CONTEXT;
+	const target = proxyOptions?.target ?? project.url;
+	if (!target) return void 0;
+	const { context: _context, enabled: _enabled, target: _target, token, ...rest } = proxyOptions ?? {};
+	const headers = { ...rest.headers };
+	const resolvedToken = token ?? project.token;
+	if (!hasAuthorizationHeader(headers) && resolvedToken) headers.Authorization = `Bearer ${resolvedToken}`;
+	return { [context]: {
+		changeOrigin: rest.changeOrigin ?? true,
+		...rest,
+		headers,
+		target
+	} };
+};
+const resolveProjectFromViteConfig = async (options, root, mode) => {
+	const env = loadEnv(mode, root ?? process.cwd(), "");
+	return resolveProject({
+		...options,
+		dir: root ?? options.dir,
+		token: options.token ?? env.WM_TOKEN ?? process.env.WM_TOKEN,
+		url: options.url ?? env.BASE_INTERNAL_URL ?? env.BASE_URL ?? process.env.BASE_INTERNAL_URL ?? process.env.BASE_URL,
+		workspace: options.workspace ?? env.WM_WORKSPACE ?? process.env.WM_WORKSPACE
+	});
+};
+const normalizeDeployOptions = (deployOptions) => {
+	if (typeof deployOptions === "boolean") return { deploy: deployOptions };
+	if (!deployOptions) return void 0;
+	return {
+		deploy: deployOptions.deploy ?? true,
+		dry: deployOptions.dry,
+		message: deployOptions.message
+	};
+};
+const parseDeployEnv = (value) => {
+	if (value === void 0) return void 0;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "undefined" || normalized === "null") return void 0;
+	if (DEPLOY_TRUE_VALUES.has(normalized)) return { deploy: true };
+	if (DEPLOY_FALSE_VALUES.has(normalized)) return { deploy: false };
+	if (DEPLOY_DRY_VALUES.has(normalized)) return {
+		deploy: true,
+		dry: true
+	};
+	throw new Error(`Invalid WM_DEPLOY value \`${value}\`. Expected boolean-like values or \`dry\`.`);
+};
+const resolveDeployOptions = (options, root, mode) => {
+	const explicitDeploy = normalizeDeployOptions(options.deploy);
+	if (explicitDeploy) return explicitDeploy;
+	return parseDeployEnv(loadEnv(mode, root ?? process.cwd(), "").WM_DEPLOY ?? process.env.WM_DEPLOY) ?? { deploy: false };
+};
+/**
+* Generates the HTML host shell for `vite preview`. It embeds the production IIFE bundle
+* in a same-origin blob-URL iframe, mirroring how Windmill renders raw apps, and relays
+* postMessage backend requests to the local /__windmill__/ HTTP proxy.
+*/
+const buildPreviewHostShellHtml = (workspace) => `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Windmill Preview</title>
+  <style>html,body{margin:0;padding:0;width:100%;height:100%;overflow:hidden}iframe{position:fixed;inset:0;width:100%;height:100%;border:none}</style>
+</head>
+<body>
+  <iframe id="app" title="raw-app" sandbox="allow-scripts allow-same-origin allow-forms allow-popups allow-downloads allow-modals allow-pointer-lock allow-presentation allow-storage-access-by-user-activation allow-top-navigation-by-user-activation"></iframe>
+  <script type="module">
+    window.localStorage.setItem('workspace', ${JSON.stringify(workspace)})
+
+    window.addEventListener('message', async ({ data: msg }) => {
+      if (!msg?.type || !msg?.reqId) return
+      const { type, reqId } = msg
+      const frame = document.getElementById('app')
+      const send = (result, error) =>
+        frame.contentWindow?.postMessage({ type: type + 'Res', reqId, result, error: !!error }, '*')
+
+      try {
+        if (type === 'backend' || type === 'backendAsync') {
+          const ep = type === 'backend' ? '/__windmill__/backend' : '/__windmill__/backend-async'
+          const r = await fetch(ep, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ runnableId: msg.runnable_id, args: msg.v ?? {} }),
+          })
+          const p = await r.json()
+          send(p.result, !!p.error)
+        } else if (type === 'waitJob') {
+          const r = await fetch('/__windmill__/wait-job', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ jobId: msg.jobId }),
+          })
+          const p = await r.json()
+          send(p.result, !!p.error)
+        } else if (type === 'getJob') {
+          const r = await fetch('/__windmill__/get-job', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ jobId: msg.jobId }),
+          })
+          const p = await r.json()
+          send(p.result, !!p.error)
+        } else if (type === 'streamJob') {
+          const source = new EventSource('/__windmill__/stream-job/' + encodeURIComponent(msg.jobId))
+          source.addEventListener('update', (e) =>
+            frame.contentWindow?.postMessage({ type: 'streamJobUpdate', reqId, ...JSON.parse(e.data) }, '*'))
+          source.addEventListener('done', (e) => { source.close(); send(JSON.parse(e.data), false) })
+          source.addEventListener('error', () => { source.close(); send({ message: 'Stream error' }, true) })
+        }
+      } catch (err) {
+        send({ message: err?.message ?? String(err) }, true)
+      }
+    })
+
+    // Fetch the production bundle, wrap it in a blob URL, and load it into the iframe.
+    // Using a blob URL makes window.location.protocol === 'blob:' inside the iframe,
+    // which matches the production Windmill embedding behaviour.
+    const [cssRes, jsRes] = await Promise.all([fetch('/bundle.css'), fetch('/bundle.js')])
+    const [css, js] = await Promise.all([cssRes.text(), jsRes.text()])
+    const html = '<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8">'
+      + (css ? '<style>' + css + '</style>' : '')
+      + '</head><body><div id="root"></div><script>'
+      + js + '<\\/script></body></html>'
+    document.getElementById('app').src = URL.createObjectURL(new Blob([html], { type: 'text/html' }))
+  <\/script>
+</body>
+</html>`;
+/**
+* Creates a Vite plugin that aligns a SPA with Windmill raw-app build and deploy behavior.
+*/
+const windmill = (options = {}) => {
+	let project;
+	let command = "serve";
+	let deployOptions = { deploy: false };
+	/**
+	* Shared Connect middleware that handles all /__windmill__/ API routes.
+	* Used by both the dev server and the preview server.
+	*/
+	const windmillApiHandler = async (request, response, next) => {
+		try {
+			if (!project) return next();
+			const sendJson = (payload) => response.end(JSON.stringify(payload));
+			const connection = requireProjectConnection(project);
+			setClient(connection.token, connection.url);
+			if (request.url === "/__windmill__/backend" && request.method === "POST") {
+				try {
+					const body = await readJsonBody(request);
+					const rawAppProject = await loadRawAppProject(project);
+					const runnableId = requireString(body.runnableId, "runnableId");
+					const runnable = rawAppProject.runnables[runnableId];
+					if (!runnable) throw new Error(`Runnable not found: ${runnableId}`);
+					const jobId = await executeRunnable(project, connection.workspace, runnableId, runnable, body.args);
+					const result = await waitForJobResult(connection.workspace, jobId);
+					response.setHeader("content-type", "application/json");
+					sendJson({ result });
+				} catch (error) {
+					response.statusCode = 500;
+					response.setHeader("content-type", "application/json");
+					sendJson({ error: toErrorMessage(error) });
+				}
+				return;
+			}
+			if (request.url === "/__windmill__/backend-async" && request.method === "POST") {
+				try {
+					const body = await readJsonBody(request);
+					const rawAppProject = await loadRawAppProject(project);
+					const runnableId = requireString(body.runnableId, "runnableId");
+					const runnable = rawAppProject.runnables[runnableId];
+					if (!runnable) throw new Error(`Runnable not found: ${runnableId}`);
+					const jobId = await executeRunnable(project, connection.workspace, runnableId, runnable, body.args);
+					response.setHeader("content-type", "application/json");
+					sendJson({ result: jobId });
+				} catch (error) {
+					response.statusCode = 500;
+					response.setHeader("content-type", "application/json");
+					sendJson({ error: toErrorMessage(error) });
+				}
+				return;
+			}
+			if (request.url === "/__windmill__/wait-job" && request.method === "POST") {
+				try {
+					const body = await readJsonBody(request);
+					const result = await waitForJobResult(connection.workspace, requireString(body.jobId, "jobId"));
+					response.setHeader("content-type", "application/json");
+					sendJson({ result });
+				} catch (error) {
+					response.statusCode = 500;
+					response.setHeader("content-type", "application/json");
+					sendJson({ error: toErrorMessage(error) });
+				}
+				return;
+			}
+			if (request.url === "/__windmill__/get-job" && request.method === "POST") {
+				try {
+					const body = await readJsonBody(request);
+					const result = await JobService.getJob({
+						workspace: connection.workspace,
+						id: requireString(body.jobId, "jobId")
+					});
+					response.setHeader("content-type", "application/json");
+					sendJson({ result });
+				} catch (error) {
+					response.statusCode = 500;
+					response.setHeader("content-type", "application/json");
+					sendJson({ error: toErrorMessage(error) });
+				}
+				return;
+			}
+			if (request.url?.startsWith("/__windmill__/stream-job/") && request.method === "GET") {
+				try {
+					const jobId = decodeURIComponent(request.url.slice(25));
+					response.setHeader("cache-control", "no-cache");
+					response.setHeader("content-type", "text/event-stream");
+					response.setHeader("connection", "keep-alive");
+					const sseResponse = await fetch(`${connection.url.replace(/\/$/, "")}/api/w/${connection.workspace}/jobs_u/getupdate_sse/${jobId}?fast=true`, { headers: {
+						accept: "text/event-stream",
+						authorization: `Bearer ${connection.token}`
+					} });
+					if (!sseResponse.ok || !sseResponse.body) throw new Error(`Failed to stream Windmill job ${jobId}`);
+					const reader = Readable.fromWeb(sseResponse.body);
+					let buffer = "";
+					for await (const chunk of reader) {
+						buffer += chunk.toString();
+						const lines = buffer.split("\n");
+						buffer = lines.pop() ?? "";
+						for (const line of lines) {
+							if (!line.startsWith("data: ")) continue;
+							const payload = JSON.parse(line.slice(6));
+							if (payload.type === "ping") continue;
+							if (payload.type === "timeout") {
+								response.write(`event: error\ndata: ${JSON.stringify("Stream timed out")}\n\n`);
+								response.end();
+								return;
+							}
+							if (payload.type === "error") {
+								response.write(`event: error\ndata: ${JSON.stringify(payload.error ?? "Stream error")}\n\n`);
+								response.end();
+								return;
+							}
+							if (payload.new_result_stream !== void 0) response.write(`event: update\ndata: ${JSON.stringify({
+								new_result_stream: payload.new_result_stream,
+								stream_offset: payload.stream_offset
+							})}\n\n`);
+							if (payload.completed) {
+								response.write(`event: done\ndata: ${JSON.stringify(payload.only_result)}\n\n`);
+								response.end();
+								return;
+							}
+						}
+					}
+					response.end();
+				} catch (error) {
+					response.write(`event: error\ndata: ${JSON.stringify(toErrorMessage(error))}\n\n`);
+					response.end();
+				}
+				return;
+			}
+			next();
+		} catch (error) {
+			next(error);
+		}
+	};
+	return {
+		name: "vite-plugin-windmill",
+		async config(userConfig, env) {
+			project = await resolveProjectFromViteConfig(options, userConfig.root, env.mode);
+			command = env.command;
+			deployOptions = resolveDeployOptions(options, userConfig.root, env.mode);
+			const isServe = env.command === "serve";
+			const apiProxy = resolveApiProxyConfig(project, options.proxy);
+			return {
+				appType: "custom",
+				base: isServe ? "/" : project.base,
+				build: {
+					chunkSizeWarningLimit: 2048,
+					outDir: DEFAULT_BUILD_OUT_DIR,
+					...isServe ? {} : {
+						assetsInlineLimit: Number.MAX_SAFE_INTEGER,
+						cssCodeSplit: false,
+						modulePreload: false,
+						reportCompressedSize: false,
+						rolldownOptions: {
+							input: project.entry,
+							output: {
+								assetFileNames: (assetInfo) => assetInfo.name?.endsWith(".css") ? "bundle.css" : "assets/[name]-[hash][extname]",
+								entryFileNames: "bundle.js",
+								format: "iife"
+							}
+						}
+					}
+				},
+				...isServe ? { publicDir: false } : {},
+				define: { "process.env.NODE_ENV": JSON.stringify(isServe ? "development" : "production") },
+				preview: {
+					open: false,
+					...apiProxy ? { proxy: apiProxy } : {}
+				},
+				server: {
+					open: false,
+					...apiProxy ? { proxy: apiProxy } : {}
+				}
+			};
+		},
+		async configResolved(resolvedConfig) {
+			project = await resolveProjectFromViteConfig(options, resolvedConfig.root, resolvedConfig.mode);
+			deployOptions = resolveDeployOptions(options, resolvedConfig.root, resolvedConfig.mode);
+			await writeGeneratedWmillTypes(project);
+		},
+		resolveId(id) {
+			if (WMILL_IMPORT_PATTERN.test(id)) return RESOLVED_VIRTUAL_WMILL_ID;
+		},
+		load(id) {
+			if (id === RESOLVED_VIRTUAL_WMILL_ID) return getWindmillRuntimeSource(command);
+		},
+		configurePreviewServer(previewServer) {
+			return () => {
+				const previewHandler = async (request, response, next) => {
+					if (!project) return next();
+					const acceptsHtml = request.headers.accept?.includes("text/html") ?? false;
+					const url = request.url ?? "/";
+					if (request.method === "GET" && !url.startsWith("/__windmill__/") && (acceptsHtml || !path.extname(url) && !url.includes("?"))) {
+						if (!project.workspace) throw new Error("Missing Windmill workspace. Set `workspace` or `WM_WORKSPACE`.");
+						response.setHeader("content-type", "text/html");
+						response.end(buildPreviewHostShellHtml(project.workspace));
+						return;
+					}
+					return Promise.resolve(windmillApiHandler(request, response, next)).catch(next);
+				};
+				previewServer.middlewares.use((req, res, next) => Promise.resolve(previewHandler(req, res, next)).catch(next));
+			};
+		},
+		configureServer(configuredServer) {
+			return () => {
+				const handler = async (request, response, next) => {
+					try {
+						if (!project) return next();
+						if (request.url?.startsWith("/__windmill__/")) return Promise.resolve(windmillApiHandler(request, response, next)).catch(next);
+						const url = request.url ?? "/";
+						if (request.method === "GET" && !path.extname(url) && !url.includes("?")) {
+							const entryRelative = normalizePath(path.relative(project.dir, project.entry));
+							const html = await configuredServer.transformIndexHtml(url, buildHtmlDocument(entryRelative));
+							response.setHeader("content-type", "text/html");
+							response.end(html);
+							return;
+						}
+						next();
+					} catch (error) {
+						next(error);
+					}
+				};
+				configuredServer.middlewares.use((req, res, next) => Promise.resolve(handler(req, res, next)).catch(next));
+			};
+		},
+		async handleHotUpdate(context) {
+			if (!project) return;
+			if (context.file.startsWith(path.join(project.dir, "backend")) || context.file === project.yaml) {
+				await writeGeneratedWmillTypes(project);
+				context.server.ws.send({ type: "full-reload" });
+				return;
+			}
+		},
+		async writeBundle(_outputOptions, bundle) {
+			if (!project) return;
+			if (!deployOptions.deploy) return;
+			const result = await deploy({
+				base: project.base,
+				bundles: extractBundleContents(bundle),
+				dir: project.dir,
+				dry: deployOptions.dry,
+				message: deployOptions.message ?? options.message,
+				path: project.path,
+				root: project.root,
+				token: project.token,
+				url: project.url,
+				workspace: project.workspace
+			});
+			this.info(result.action === "dry-run" ? `Windmill deploy dry-run ready for ${result.path}` : `Windmill raw app ${result.action}d: ${result.path}`);
+		}
+	};
+};
+//#endregion
+export { windmill as default, windmill, deploy };
+
+//# sourceMappingURL=index.mjs.map