@vrowzer/vite-plugin 0.0.0

package/dist/index.mjs

@@ -0,0 +1,1335 @@
+import { generateManifest } from "./manifest-generate.mjs";
+import { createRequire } from "node:module";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import path, { dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import inject from "@rollup/plugin-inject";
+import ServiceWorker from "@vrowzer/unplugin-service-worker/vite";
+import { createDebug } from "obug";
+import { minifySync, parseSync } from "rolldown/experimental";
+import { rolldown } from "rolldown";
+import { createBirpc } from "birpc";
+import { WebSocketServer } from "ws";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/auto-manifest.ts
+/**
+* Auto-manifest plugin for Vrowzer.
+*
+* When `auto: true`, this plugin:
+* 1. Auto-generates the vrowzer manifest in `configResolved`
+* 2. Caches results in `node_modules/.vrowzer-manifest/`
+* 3. Provides the manifest via `virtual:vrowzer-manifest` virtual module
+*
+* @module auto-manifest
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const debug$8 = createDebug("vite-plugin-vrowzer:auto-manifest");
+const VIRTUAL_MODULE_ID = "virtual:vrowzer-manifest";
+const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+const CACHE_DIR_NAME = ".vrowzer-manifest";
+const MANIFEST_FILENAME = "manifest.json";
+const HASH_FILENAME = "_hash";
+const LOCKFILE_NAMES = [
+	"pnpm-lock.yaml",
+	"package-lock.json",
+	"yarn.lock",
+	"bun.lock"
+];
+const MINIFIABLE_EXTENSIONS$1 = new Set([
+	".js",
+	".mjs",
+	".cjs"
+]);
+/**
+* Simple 32-bit string hash (same algorithm as unplugin-service-worker hash).
+*/
+function hash(input) {
+	let h = 0;
+	for (let i = 0; i < input.length; i++) {
+		const char = input.charCodeAt(i);
+		h = (h << 5) - h + char;
+		h = h & h;
+	}
+	return Math.abs(h).toString(36).slice(0, 8);
+}
+/**
+* Compute cache key from package.json dependencies, lockfile, and manifest options.
+*/
+function computeCacheHash(root, manifestOptions) {
+	const parts = [];
+	if (manifestOptions?.sourceDir) parts.push(`sourceDir:${manifestOptions.sourceDir}`);
+	if (manifestOptions?.targets) parts.push(`targets:${manifestOptions.targets.join(",")}`);
+	const pkgPath = join(root, "package.json");
+	if (existsSync(pkgPath)) try {
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		parts.push(JSON.stringify(pkg.dependencies || {}));
+		parts.push(JSON.stringify(pkg.devDependencies || {}));
+	} catch {}
+	for (const lockfile of LOCKFILE_NAMES) {
+		const lockPath = join(root, lockfile);
+		if (existsSync(lockPath)) {
+			try {
+				parts.push(readFileSync(lockPath, "utf-8"));
+			} catch {}
+			break;
+		}
+	}
+	return hash(parts.join("\n"));
+}
+function getCacheDir(root) {
+	return resolve(root, "node_modules", CACHE_DIR_NAME);
+}
+function readCachedHash(cacheDir) {
+	const hashPath = join(cacheDir, HASH_FILENAME);
+	if (existsSync(hashPath)) try {
+		return readFileSync(hashPath, "utf-8").trim();
+	} catch {
+		return null;
+	}
+	return null;
+}
+function readCachedManifest(cacheDir) {
+	const manifestPath = join(cacheDir, MANIFEST_FILENAME);
+	if (existsSync(manifestPath)) try {
+		return JSON.parse(readFileSync(manifestPath, "utf-8"));
+	} catch {
+		return null;
+	}
+	return null;
+}
+function writeCache(cacheDir, manifest, cacheHash) {
+	mkdirSync(cacheDir, { recursive: true });
+	writeFileSync(join(cacheDir, MANIFEST_FILENAME), JSON.stringify(manifest, null, 2) + "\n");
+	writeFileSync(join(cacheDir, HASH_FILENAME), cacheHash + "\n");
+}
+/**
+* Resolve manifest path references to actual file contents.
+* This is equivalent to what VrowzerManifest() does for manual manifests.
+*/
+function resolveManifestContents(manifest, manifestDir) {
+	function resolveFiles(files, minify) {
+		if (!files) return {};
+		const resolved = {};
+		for (const [virtualPath, relPath] of Object.entries(files)) try {
+			let content = readFileSync(resolve(manifestDir, relPath), "utf-8");
+			if (minify && MINIFIABLE_EXTENSIONS$1.has(extname(virtualPath))) {
+				const result = minifySync(virtualPath, content);
+				if (result.code) content = result.code;
+			}
+			resolved[virtualPath] = content;
+		} catch {
+			debug$8("failed to read %s", relPath);
+		}
+		return resolved;
+	}
+	return {
+		name: manifest.name,
+		files: resolveFiles(manifest.files, false),
+		nodeModules: resolveFiles(manifest.nodeModules, true),
+		activeFile: manifest.activeFile
+	};
+}
+/**
+* Create the auto-manifest plugin.
+*
+* This plugin is included in the `Vrowzer()` array when `auto: true`.
+*/
+function autoManifestPlugin(manifestOptions) {
+	let sourceDir;
+	let manifest = null;
+	return {
+		name: "vrowzer:auto-manifest",
+		resolveId(id) {
+			if (id === VIRTUAL_MODULE_ID) return RESOLVED_VIRTUAL_MODULE_ID;
+		},
+		async configResolved(config) {
+			const root = config.root;
+			sourceDir = manifestOptions?.sourceDir ? resolve(root, manifestOptions.sourceDir) : root;
+			const pkgDir = manifestOptions?.pkgDir ? resolve(root, manifestOptions.pkgDir) : root;
+			const cacheDir = getCacheDir(root);
+			const currentHash = computeCacheHash(pkgDir, manifestOptions);
+			const cachedHash = readCachedHash(cacheDir);
+			if (currentHash === cachedHash) {
+				manifest = readCachedManifest(cacheDir);
+				if (manifest) {
+					debug$8("cache hit (hash: %s), using cached manifest", currentHash);
+					return;
+				}
+			}
+			debug$8("cache miss (current: %s, cached: %s), generating manifest...", currentHash, cachedHash);
+			manifest = await generateManifest({
+				pkgDir,
+				sourceDir,
+				...manifestOptions?.targets ? { targets: manifestOptions.targets } : {}
+			}, (msg) => debug$8(msg));
+			writeCache(cacheDir, manifest, currentHash);
+			debug$8("manifest cached to %s", cacheDir);
+		},
+		load(id) {
+			if (id !== RESOLVED_VIRTUAL_MODULE_ID) return;
+			if (!manifest) {
+				debug$8("no manifest available");
+				return {
+					code: "export default {}",
+					moduleType: "js"
+				};
+			}
+			const resolved = resolveManifestContents(manifest, sourceDir);
+			debug$8("virtual module loaded: %s (%d files, %d nodeModules)", resolved.name, Object.keys(resolved.files).length, Object.keys(resolved.nodeModules || {}).length);
+			return {
+				code: `export default ${JSON.stringify(resolved)}`,
+				moduleType: "js"
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/alias.ts
+/**
+* Node.js builtin → browser polyfill alias mappings.
+*
+* Shared between env.ts (host Vite config) and prebundle.ts (Worker config bundling).
+*
+* @module alias
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Node.js builtin module → browser polyfill mapping.
+* Each entry maps both `node:xxx` and bare `xxx` specifiers.
+*/
+const NODE_POLYFILL_MAP = {
+	events: "@vrowzer/node-polyfill/events",
+	path: "pathe",
+	stream: "readable-stream/lib/stream",
+	buffer: "buffer",
+	dns: "@vrowzer/node-polyfill/dns",
+	fs: "@vrowzer/fs",
+	"fs/promises": "@vrowzer/fs/promises",
+	url: "@vrowzer/node-polyfill/url",
+	readline: "@vrowzer/node-polyfill/readline",
+	util: "@vrowzer/node-polyfill/util",
+	perf_hooks: "@vrowzer/node-polyfill/perf_hooks",
+	crypto: "@vrowzer/node-polyfill/crypto",
+	tty: "@vrowzer/node-polyfill/tty",
+	module: "@vrowzer/node-polyfill/module",
+	os: "@vrowzer/node-polyfill/os",
+	net: "@vrowzer/node-polyfill/net"
+};
+/**
+* Build a flat alias record from NODE_POLYFILL_MAP + additional aliases.
+* Generates both `node:xxx` and bare `xxx` entries for each builtin.
+*
+* @param extra - Additional alias entries to merge (e.g. `{ process: '...', 'process/': '...' }`)
+*/
+function resolveAliases(extra) {
+	const aliases = {};
+	for (const [mod, polyfill] of Object.entries(NODE_POLYFILL_MAP)) {
+		aliases[`node:${mod}`] = polyfill;
+		aliases[mod] = polyfill;
+	}
+	if (extra) Object.assign(aliases, extra);
+	return aliases;
+}
+
+//#endregion
+//#region src/env.ts
+/**
+* Environment plugin — Node.js polyfills, CORS headers, and Worker config
+* for browser/Worker environments.
+*
+* @module env
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const debug$7 = createDebug("vite-plugin-vrowzer:env");
+const picocolorsBrowser = resolve(dirname(createRequire(import.meta.url).resolve("picocolors")), "picocolors.browser.js");
+function envPlugin(_options) {
+	return {
+		name: "vrowzer:env",
+		options(inputOptions) {
+			inputOptions.transform ??= {};
+			inputOptions.transform.inject = {
+				...inputOptions.transform.inject ?? {},
+				process: "@vrowzer/node-polyfill/process"
+			};
+			debug$7("options hook: inputOptions.transform.inject ", inputOptions.transform.inject);
+		},
+		config(_config, _env) {
+			return {
+				define: { "import.meta.env.DEBUG": JSON.stringify(process.env.DEBUG || "") },
+				resolve: { alias: resolveAliases({
+					"node:process": "@vrowzer/node-polyfill/process",
+					"process/": "@vrowzer/node-polyfill/process",
+					process: "@vrowzer/node-polyfill/process",
+					picocolors: picocolorsBrowser
+				}) },
+				worker: { format: "es" },
+				server: { headers: {
+					"Service-Worker-Allowed": "/",
+					"Cross-Origin-Opener-Policy": "same-origin",
+					"Cross-Origin-Embedder-Policy": "credentialless"
+				} },
+				preview: { headers: {
+					"Service-Worker-Allowed": "/",
+					"Cross-Origin-Opener-Policy": "same-origin",
+					"Cross-Origin-Embedder-Policy": "credentialless"
+				} }
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/ide.ts
+/**
+* Browser IDE plugin for Vrowzer.
+*
+* When `experimental.ide` is enabled, serves a pre-built browser IDE at `/__vrowzer__/`.
+* The IDE is a self-contained Vue app with Monaco Editor, File Explorer, and Preview,
+* bundled into dist/ide/ at build time.
+*
+* Phase 3: birpc WebSocket for file sync (write-back to local FS).
+*
+* @module ide
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const debug$6 = createDebug("vite-plugin-vrowzer:ide");
+const IDE_BASE = "/__vrowzer__";
+const IDE_CLIENT_PATH = `${IDE_BASE}/client.js`;
+const __dir = dirname(fileURLToPath(import.meta.url));
+const ideDistDir = resolve(__dir, __dir.endsWith("/dist") ? "ide" : "../dist/ide");
+const MIME_TYPES = {
+	".js": "application/javascript",
+	".mjs": "application/javascript",
+	".css": "text/css",
+	".html": "text/html",
+	".json": "application/json",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf"
+};
+function generateIdeClientCode(basePath, rpcPort, devtoolsUrl) {
+	return `
+import { Vrowzer } from 'vrowzer'
+import manifest from 'virtual:vrowzer-manifest'
+
+// mountIde is loaded via script tag in HTML and exposed as global
+window.__vrowzer_ide_mount__({
+  manifest,
+  basePath: '${basePath}',
+  Vrowzer,
+  rpcPort: ${rpcPort},
+  devtoolsUrl: ${devtoolsUrl ? `'${devtoolsUrl}'` : "null"}
+})
+`;
+}
+function generateIdeHtml(base, cssFile) {
+	return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Vrowzer IDE</title>
+  ${cssFile ? `<link rel="stylesheet" href="${base}${IDE_BASE.slice(1)}/dist/${cssFile}" />` : ""}
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    html, body, #app { height: 100%; }
+    body { font-family: system-ui, -apple-system, sans-serif; overflow: hidden; }
+  </style>
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="${base}${IDE_BASE.slice(1)}/dist/ide.js"><\/script>
+  <script type="module" src="${base}${IDE_BASE.slice(1)}/client.js"><\/script>
+</body>
+</html>`;
+}
+function findAvailablePort(preferredPort) {
+	return new Promise((resolve$1, reject) => {
+		const { createServer } = __require("node:net");
+		const server = createServer();
+		const port = preferredPort ?? 7900;
+		server.listen(port, () => {
+			server.close(() => resolve$1(port));
+		});
+		server.on("error", () => {
+			server.close();
+			const next = createServer();
+			next.listen(0, () => {
+				const addr = next.address();
+				const p = typeof addr === "object" && addr ? addr.port : 0;
+				next.close(() => resolve$1(p));
+			});
+			next.on("error", reject);
+		});
+	});
+}
+function idePlugin(options) {
+	let viteBase = "/";
+	let ideCssFile = null;
+	let rpcPort = 0;
+	let projectRoot = "";
+	let sourceDir = "";
+	let devtoolsUrl = null;
+	if (existsSync(ideDistDir)) try {
+		ideCssFile = readdirSync(ideDistDir).find((f) => f.endsWith(".css")) ?? null;
+	} catch {}
+	return {
+		name: "vrowzer:ide",
+		apply: "serve",
+		async configResolved(config) {
+			viteBase = config.base || "/";
+			projectRoot = config.root;
+			sourceDir = options.manifest?.sourceDir ? resolve(projectRoot, options.manifest.sourceDir) : projectRoot;
+			rpcPort = await findAvailablePort(options.ide.port);
+			debug$6("RPC port:", rpcPort);
+			if (options.ide.devtools) {
+				if (config.plugins.some((p) => p.name === "vite:devtools:server")) {
+					devtoolsUrl = "/.devtools/";
+					debug$6("DevTools detected, URL:", devtoolsUrl);
+				}
+			}
+		},
+		resolveId(id) {
+			if (id === IDE_CLIENT_PATH) return id;
+		},
+		load(id) {
+			if (id === IDE_CLIENT_PATH) return generateIdeClientCode(options.basePath, rpcPort, devtoolsUrl);
+		},
+		configureServer(server) {
+			const ideUrl = `${IDE_BASE}/`;
+			if (devtoolsUrl) {
+				server.middlewares.use((req, res, next) => {
+					if ((req.url ?? "").startsWith("/.devtools")) {
+						const originalWriteHead = res.writeHead.bind(res);
+						res.writeHead = function(statusCode, ...args) {
+							res.setHeader("Cross-Origin-Embedder-Policy", "credentialless");
+							res.setHeader("Cross-Origin-Opener-Policy", "same-origin");
+							return originalWriteHead(statusCode, ...args);
+						};
+					}
+					next();
+				});
+				debug$6("COEP middleware added for /.devtools*");
+			}
+			const wss = new WebSocketServer({ port: rpcPort });
+			debug$6("birpc WebSocket server listening on port", rpcPort);
+			wss.on("connection", (ws) => {
+				debug$6("IDE client connected");
+				const rpc = createBirpc({ async writeFile(path$1, content) {
+					const absPath = resolve(sourceDir, path$1.startsWith("/") ? path$1.slice(1) : path$1);
+					debug$6("writeFile:", absPath);
+					writeFileSync(absPath, content, "utf-8");
+				} }, {
+					post: (data) => ws.send(data),
+					on: (handler) => ws.on("message", handler),
+					serialize: (v) => JSON.stringify(v),
+					deserialize: (v) => JSON.parse(String(v))
+				});
+				const watcher = server.watcher;
+				const onFileChange = (filePath) => {
+					if (filePath.startsWith(sourceDir) && !filePath.includes("node_modules")) {
+						const relPath = "/" + filePath.slice(sourceDir.length + 1).replace(/\\/g, "/");
+						try {
+							const content = readFileSync(filePath, "utf-8");
+							debug$6("external file change:", relPath);
+							rpc.onFileChanged(relPath, content);
+						} catch {}
+					}
+				};
+				watcher.on("change", onFileChange);
+				ws.on("close", () => {
+					debug$6("IDE client disconnected");
+					watcher.off("change", onFileChange);
+				});
+			});
+			server.httpServer?.on("close", () => {
+				wss.close();
+				debug$6("birpc WebSocket server closed");
+			});
+			server.httpServer?.once("listening", () => {
+				const info = server.config.server;
+				const protocol = info.https ? "https" : "http";
+				const host = typeof info.host === "string" ? info.host : "localhost";
+				const port = info.port || 5173;
+				setTimeout(() => {
+					server.config.logger.info(`  \x1b[36m➜\x1b[0m  \x1b[1mVrowzer IDE\x1b[0m: \x1b[36m${protocol}://${host}:${port}${ideUrl}\x1b[0m`);
+				}, 100);
+			});
+			server.middlewares.use((req, res, next) => {
+				const url = req.url ?? "";
+				if (url === IDE_BASE || url === ideUrl) {
+					debug$6("serving IDE HTML");
+					res.writeHead(200, {
+						"Content-Type": "text/html; charset=utf-8",
+						"Cross-Origin-Opener-Policy": "same-origin",
+						"Cross-Origin-Embedder-Policy": "credentialless"
+					});
+					res.end(generateIdeHtml(viteBase, ideCssFile));
+					return;
+				}
+				if (url.startsWith(`${IDE_BASE}/dist/`)) {
+					const assetName = url.slice(`${IDE_BASE}/dist/`.length);
+					const assetPath = join(ideDistDir, assetName);
+					if (existsSync(assetPath)) {
+						const mime = MIME_TYPES[extname(assetName)] || "application/octet-stream";
+						debug$6("serving IDE asset:", assetName);
+						res.writeHead(200, {
+							"Content-Type": mime,
+							"Cross-Origin-Opener-Policy": "same-origin",
+							"Cross-Origin-Embedder-Policy": "credentialless",
+							"Cache-Control": "no-cache"
+						});
+						res.end(readFileSync(assetPath));
+						return;
+					}
+				}
+				next();
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/extract.ts
+/**
+* Static analysis of vite.config.ts for Worker plugin extraction.
+*
+* Parses the user's vite.config.ts with OXC (via rolldown/experimental),
+* removes Vrowzer() calls and their imports,
+* and generates a Worker-compatible config source.
+*
+* @module extract
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const debug$5 = createDebug("vite-plugin-vrowzer:extract");
+/**
+* Packages that should be excluded from Worker config.
+* These are host-only plugins that cannot run in Web Worker.
+*/
+const WORKER_EXCLUDED_SOURCES = [
+	"@vrowzer/vite-plugin",
+	"@vrowzer/vite-plugin/config",
+	"@vitejs/devtools"
+];
+/**
+* Check if an import source should be excluded from Worker config.
+*/
+function isWorkerExcludedImport(source) {
+	return WORKER_EXCLUDED_SOURCES.some((s) => source === s || source.startsWith(`${s}/`));
+}
+/**
+* Check if an import source is from Vite (should be excluded from Worker config).
+*/
+function isViteImport(source) {
+	return source === "vite" || source.startsWith("vite/");
+}
+/**
+* Extract Worker config source from vite.config.ts.
+*
+* 1. Parse the source with OXC
+* 2. Collect all imports
+* 3. Find `export default defineConfig(...)` or `export default { ... }`
+* 4. Extract plugins array
+* 5. Remove Vrowzer() calls
+* 6. Generate Worker config source
+*/
+function extractWorkerConfig(source, configPath, _options = {}) {
+	const unsupported = [];
+	const ast = parseSync(configPath, source).program;
+	const imports = collectImports(ast);
+	debug$5("imports", imports.map((i) => `${i.localName} from ${i.source}`));
+	const exportDefault = ast.body.find((n) => n.type === "ExportDefaultDeclaration");
+	if (!exportDefault) return {
+		code: generateFallbackCode(),
+		unsupported: ["no export default found"]
+	};
+	const configObj = unwrapDefineConfig(exportDefault.declaration);
+	if (!configObj || configObj.type !== "ObjectExpression") return {
+		code: generateFallbackCode(),
+		unsupported: ["config is not an object expression"]
+	};
+	const pluginsProp = configObj.properties.find((p) => p.type === "Property" && p.key.type === "Identifier" && p.key.name === "plugins");
+	if (!pluginsProp || pluginsProp.value.type !== "ArrayExpression") return {
+		code: generateFallbackCode(),
+		unsupported: ["plugins is not an array"]
+	};
+	const pluginsArray = pluginsProp.value;
+	const pluginCalls = [];
+	for (const element of pluginsArray.elements) {
+		if (element === null) continue;
+		if (element.type === "SpreadElement") {
+			unsupported.push(`spread element: ${source.slice(element.start, element.end)}`);
+			continue;
+		}
+		const expr = element;
+		if (expr.type === "CallExpression") {
+			const info = analyzeCallExpression(expr, imports);
+			if (info) pluginCalls.push(info);
+			else unsupported.push(`unanalyzable call: ${source.slice(expr.start, expr.end)}`);
+		} else if (expr.type === "ConditionalExpression" || expr.type === "LogicalExpression") unsupported.push(`conditional plugin: ${source.slice(expr.start, expr.end)}`);
+		else unsupported.push(`non-call plugin: ${source.slice(expr.start, expr.end)}`);
+	}
+	if (unsupported.length > 0) debug$5("unsupported patterns", unsupported);
+	const workerPlugins = pluginCalls.filter((p) => {
+		if (!p.importSource) return true;
+		return !isWorkerExcludedImport(p.importSource);
+	});
+	debug$5("workerPlugins", workerPlugins.map((p) => p.calleeName));
+	const neededImportSources = /* @__PURE__ */ new Set();
+	const neededLocalNames = /* @__PURE__ */ new Set();
+	for (const plugin of workerPlugins) {
+		if (plugin.importSource) neededImportSources.add(plugin.importSource);
+		neededLocalNames.add(plugin.calleeName);
+	}
+	for (const plugin of workerPlugins) if (plugin.hasArgs) {
+		const argSource = source.slice(plugin.start, plugin.end);
+		for (const imp of imports) {
+			if (imp.isTypeOnly) continue;
+			if (isViteImport(imp.source)) continue;
+			if (isWorkerExcludedImport(imp.source)) continue;
+			if (argSource.includes(imp.localName)) {
+				neededImportSources.add(imp.source);
+				neededLocalNames.add(imp.localName);
+			}
+		}
+	}
+	const localPluginNames = workerPlugins.filter((p) => !p.importSource).map((p) => p.calleeName);
+	if (localPluginNames.length > 0) {
+		const localFuncSources = [];
+		for (const stmt of ast.body) if (stmt.type === "FunctionDeclaration" && stmt.id) {
+			const funcName = stmt.id.name;
+			if (localPluginNames.includes(funcName)) localFuncSources.push(source.slice(stmt.start, stmt.end));
+		}
+		for (const funcSource of localFuncSources) for (const imp of imports) {
+			if (imp.isTypeOnly) continue;
+			if (isViteImport(imp.source)) continue;
+			if (isWorkerExcludedImport(imp.source)) continue;
+			if (funcSource.includes(imp.localName)) {
+				neededImportSources.add(imp.source);
+				neededLocalNames.add(imp.localName);
+			}
+		}
+		for (const stmt of ast.body) {
+			if (stmt.type !== "VariableDeclaration") continue;
+			for (const decl of stmt.declarations) {
+				if (!decl.id?.name) continue;
+				const varName = decl.id.name;
+				if (localPluginNames.includes(varName)) continue;
+				if (localFuncSources.some((funcSrc) => funcSrc.includes(varName))) {
+					const varSource = source.slice(stmt.start, stmt.end);
+					for (const imp of imports) {
+						if (imp.isTypeOnly) continue;
+						if (isViteImport(imp.source)) continue;
+						if (isWorkerExcludedImport(imp.source)) continue;
+						if (varSource.includes(imp.localName)) {
+							neededImportSources.add(imp.source);
+							neededLocalNames.add(imp.localName);
+						}
+					}
+				}
+			}
+		}
+	}
+	return {
+		code: generateWorkerSource(source, ast, imports, workerPlugins, neededImportSources, neededLocalNames),
+		unsupported
+	};
+}
+function collectImports(ast) {
+	const imports = [];
+	for (const node of ast.body) {
+		if (node.type !== "ImportDeclaration") continue;
+		const decl = node;
+		const source = decl.source.value;
+		const isTypeOnly = decl.importKind === "type";
+		for (const spec of decl.specifiers) if (spec.type === "ImportDefaultSpecifier") imports.push({
+			source,
+			localName: spec.local.name,
+			importedName: null,
+			start: decl.start,
+			end: decl.end,
+			isTypeOnly
+		});
+		else if (spec.type === "ImportSpecifier") {
+			const importedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+			imports.push({
+				source,
+				localName: spec.local.name,
+				importedName,
+				start: decl.start,
+				end: decl.end,
+				isTypeOnly: isTypeOnly || spec.importKind === "type"
+			});
+		} else if (spec.type === "ImportNamespaceSpecifier") imports.push({
+			source,
+			localName: spec.local.name,
+			importedName: "*",
+			start: decl.start,
+			end: decl.end,
+			isTypeOnly
+		});
+	}
+	return imports;
+}
+function unwrapDefineConfig(expr) {
+	if (expr.type === "CallExpression") {
+		const call = expr;
+		if (call.callee.type === "Identifier" && call.callee.name === "defineConfig") return call.arguments[0];
+	}
+	if (expr.type === "ObjectExpression") return expr;
+	return null;
+}
+function analyzeCallExpression(call, imports) {
+	let calleeName = null;
+	if (call.callee.type === "Identifier") calleeName = call.callee.name;
+	if (!calleeName) return null;
+	const matchingImport = imports.find((i) => i.localName === calleeName && !i.isTypeOnly);
+	return {
+		calleeName,
+		importSource: matchingImport?.source ?? null,
+		start: call.start,
+		end: call.end,
+		hasArgs: call.arguments.length > 0
+	};
+}
+function generateWorkerSource(source, ast, imports, plugins, neededImportSources, neededLocalNames) {
+	const lines = [];
+	const emittedSources = /* @__PURE__ */ new Set();
+	for (const imp of imports) {
+		if (imp.isTypeOnly) continue;
+		if (isViteImport(imp.source)) continue;
+		if (isWorkerExcludedImport(imp.source)) continue;
+		if (!neededImportSources.has(imp.source)) continue;
+		if (!neededLocalNames.has(imp.localName)) continue;
+		if (emittedSources.has(`${imp.source}:${imp.localName}`)) continue;
+		emittedSources.add(`${imp.source}:${imp.localName}`);
+		if (imp.importedName === null) lines.push(`import ${imp.localName} from '${imp.source}'`);
+		else if (imp.importedName === "*") lines.push(`import * as ${imp.localName} from '${imp.source}'`);
+		else if (imp.importedName === imp.localName) lines.push(`import { ${imp.localName} } from '${imp.source}'`);
+		else lines.push(`import { ${imp.importedName} as ${imp.localName} } from '${imp.source}'`);
+	}
+	const localPluginNames = plugins.filter((p) => !p.importSource).map((p) => p.calleeName);
+	const localFuncSources = [];
+	for (const stmt of ast.body) if (stmt.type === "FunctionDeclaration" && stmt.id) {
+		const funcName = stmt.id.name;
+		if (localPluginNames.includes(funcName)) localFuncSources.push(source.slice(stmt.start, stmt.end));
+	}
+	const emittedVarNames = /* @__PURE__ */ new Set();
+	for (const stmt of ast.body) {
+		if (stmt.type !== "VariableDeclaration") continue;
+		for (const decl of stmt.declarations) {
+			if (!decl.id?.name) continue;
+			const varName = decl.id.name;
+			if (localFuncSources.some((funcSrc) => funcSrc.includes(varName)) && !localPluginNames.includes(varName)) {
+				if (!emittedVarNames.has(varName)) {
+					emittedVarNames.add(varName);
+					lines.push("");
+					lines.push(source.slice(stmt.start, stmt.end));
+					const varSource = source.slice(stmt.start, stmt.end);
+					for (const imp of imports) {
+						if (imp.isTypeOnly) continue;
+						if (isViteImport(imp.source)) continue;
+						if (isWorkerExcludedImport(imp.source)) continue;
+						if (varSource.includes(imp.localName)) {
+							neededImportSources.add(imp.source);
+							neededLocalNames.add(imp.localName);
+						}
+					}
+				}
+				break;
+			}
+		}
+	}
+	for (const stmt of ast.body) {
+		if (stmt.type === "FunctionDeclaration" && stmt.id) {
+			const funcName = stmt.id.name;
+			if (localPluginNames.includes(funcName)) {
+				lines.push("");
+				lines.push(source.slice(stmt.start, stmt.end));
+			}
+		}
+		if (stmt.type === "VariableDeclaration") {
+			for (const decl of stmt.declarations) if (decl.id?.name && localPluginNames.includes(decl.id.name)) {
+				lines.push("");
+				lines.push(source.slice(stmt.start, stmt.end));
+				break;
+			}
+		}
+	}
+	lines.push("");
+	lines.push("export default {");
+	lines.push("  plugins: [");
+	for (const plugin of plugins) {
+		const callSource = source.slice(plugin.start, plugin.end);
+		lines.push(`    ${callSource},`);
+	}
+	lines.push("  ]");
+	lines.push("}");
+	return lines.join("\n");
+}
+function generateFallbackCode() {
+	return "export default { plugins: [] }";
+}
+
+//#endregion
+//#region src/options.ts
+/**
+* vite-plugin-vrowzer options
+*
+* @module options
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+function resolveDefaultServiceWorkerEntry() {
+	try {
+		return fileURLToPath(import.meta.resolve("vrowzer/service-worker"));
+	} catch {
+		return "";
+	}
+}
+function resolveOptions(options) {
+	const ide = options.experimental?.ide;
+	return {
+		auto: options.auto ?? true,
+		manifest: options.manifest,
+		ide: {
+			enabled: !!ide,
+			port: typeof ide === "object" ? ide.port : void 0,
+			devtools: options.experimental?.devtools ?? false
+		},
+		basePath: options.basePath ?? "/__preview__/",
+		serviceWorkerScope: options.serviceWorkerScope ?? "/",
+		serviceWorkerVersion: options.serviceWorkerVersion ?? "SERVICE_WORKER_VERSION",
+		serviceWorkerEntry: options.serviceWorkerEntry ?? resolveDefaultServiceWorkerEntry(),
+		resolve: options.resolve
+	};
+}
+
+//#endregion
+//#region src/prebundle.ts
+/**
+* Pre-bundle Worker config using rolldown.
+*
+* Takes the extracted Worker source from extract.ts and bundles it
+* into node_modules/.vrowzer/ for Worker consumption.
+*
+* @module prebundle
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const debug$4 = createDebug("vite-plugin-vrowzer:prebundle");
+const OUTPUT_DIR_NAME = ".vrowzer";
+const BUNDLED_FILENAME = "config.bundled.mjs";
+/**
+* Resolve the output directory path for prebundled Worker config.
+*/
+function resolveOutputDir(root) {
+	return resolve(root, "node_modules", OUTPUT_DIR_NAME);
+}
+/**
+* Remove the prebundle output directory.
+*/
+function cleanOutputDir(root) {
+	const outputDir = resolveOutputDir(root);
+	if (existsSync(outputDir)) {
+		rmSync(outputDir, { recursive: true });
+		debug$4("cleaned output dir:", outputDir);
+	}
+}
+/**
+* Pre-bundle Worker config source using rolldown.
+*
+* @returns Absolute path to the bundled config file.
+*/
+async function prebundleWorkerConfig(options) {
+	const { workerSource, root, configDir } = options;
+	const outputDir = resolveOutputDir(root);
+	const bundledPath = resolve(outputDir, BUNDLED_FILENAME);
+	debug$4("prebundling worker config...");
+	mkdirSync(outputDir, { recursive: true });
+	const entryPath = resolve(outputDir, "_entry.mts");
+	writeFileSync(entryPath, workerSource);
+	await (await rolldown({
+		input: entryPath,
+		external: [
+			/* @__PURE__ */ new RegExp("^@vrowzer/"),
+			"assert",
+			"v8"
+		],
+		transform: {
+			define: {
+				"process.env.NODE_ENV": JSON.stringify("development"),
+				global: "globalThis"
+			},
+			inject: { process: "@vrowzer/node-polyfill/process" }
+		},
+		resolve: {
+			alias: resolveAliases({ "node:process": "@vrowzer/node-polyfill/process" }),
+			mainFields: ["module", "main"],
+			conditionNames: [
+				"browser",
+				"import",
+				"default"
+			]
+		},
+		platform: "neutral",
+		plugins: [
+			viteAliasPlugin(),
+			inlineReadFileSyncPlugin(configDir),
+			inlineCreateRequirePlugin()
+		]
+	})).write({
+		format: "esm",
+		dir: outputDir,
+		entryFileNames: BUNDLED_FILENAME,
+		chunkFileNames: "chunks/[name].mjs",
+		minify: false
+	});
+	debug$4("prebundle complete:", bundledPath);
+	return bundledPath;
+}
+/**
+* Rolldown plugin to redirect `vite` imports to `@vrowzer/vite-dev-server/vite`.
+* Handles both exact `vite` and subpaths like `vite/internal`.
+*/
+function viteAliasPlugin() {
+	const VITE_INTERNAL_ID = "\0vrowzer:vite-internal-stub";
+	return {
+		name: "vrowzer:vite-alias",
+		resolveId(id) {
+			if (id === "vite") return {
+				id: "@vrowzer/vite-dev-server/vite",
+				external: true
+			};
+			if (id === "vite/internal") return {
+				id: VITE_INTERNAL_ID,
+				external: false
+			};
+			if (id.startsWith("vite/")) return {
+				id: id.replace(/^vite\//, "@vrowzer/vite-dev-server/vite/"),
+				external: true
+			};
+		},
+		load(id) {
+			if (id === VITE_INTERNAL_ID) return "export {}";
+		}
+	};
+}
+/**
+* Rolldown plugin to inline `readFileSync(...)` calls at prebundle time.
+*
+* When the Worker config source contains `readFileSync(path, 'utf-8')`,
+* this plugin evaluates the call at prebundle time (Node.js) and replaces
+* it with the file content as a string literal. This is necessary because
+* Worker environments cannot access the host filesystem.
+*
+* Supported patterns:
+*   readFileSync('literal/path', 'utf-8')
+*   readFileSync(resolve(import.meta.dirname, 'path'), 'utf-8')
+*/
+function inlineReadFileSyncPlugin(configDir) {
+	const RE = /readFileSync\(\s*([\s\S]+?)\s*,\s*['"]utf-?8['"]\s*\)/g;
+	return {
+		name: "vrowzer:inline-readFileSync",
+		transform(code, id) {
+			if (!id.includes("_entry.mt") && !id.includes(".vrowzer/")) return;
+			if (!code.includes("readFileSync")) return;
+			let modified = false;
+			const result = code.replace(RE, (match, pathExpr) => {
+				const resolvedPath = tryEvalPathExpr(pathExpr.trim(), configDir);
+				if (!resolvedPath) {
+					debug$4("inlineReadFileSync: could not evaluate path expr:", pathExpr);
+					return match;
+				}
+				try {
+					const content = readFileSync(resolvedPath, "utf-8");
+					modified = true;
+					debug$4("inlineReadFileSync: inlined", resolvedPath, `(${content.length} bytes)`);
+					return JSON.stringify(content);
+				} catch (e) {
+					debug$4("inlineReadFileSync: failed to read:", resolvedPath, e);
+					return match;
+				}
+			});
+			if (modified) return {
+				code: result.replace(/import\s*\{[^}]*readFileSync[^}]*\}\s*from\s*['"]node:fs['"]\s*;?\n?/g, "").replace(/import\s*\{[^}]*resolve[^}]*\}\s*from\s*['"]node:path['"]\s*;?\n?/g, ""),
+				map: null
+			};
+		}
+	};
+}
+/**
+* Try to evaluate a path expression to an absolute path string.
+*/
+function tryEvalPathExpr(expr, configDir) {
+	const strMatch = expr.match(/^['"](.+)['"]$/);
+	if (strMatch) return resolve(configDir, strMatch[1]);
+	const resolveMatch = expr.match(/^resolve\(\s*(?:import\.meta\.dirname|__dirname)\s*,\s*['"](.+)['"]\s*\)$/);
+	if (resolveMatch) return resolve(configDir, resolveMatch[1]);
+	return null;
+}
+/**
+* Rolldown plugin to inline `createRequire(...)("pkg/path")` calls at prebundle time.
+*
+* Some plugins (e.g. @sveltejs/vite-plugin-svelte) use `createRequire` at module
+* init time to load package.json files. This fails in Worker environments where
+* `require()` is not available. This plugin detects the pattern and replaces it
+* with the actual file content at prebundle time.
+*/
+function inlineCreateRequirePlugin() {
+	const RE = /createRequire\([^)]+\)\(\s*['"]([^'"]+)['"]\s*\)/g;
+	return {
+		name: "vrowzer:inline-createRequire",
+		transform(code, id) {
+			if (!code.includes("createRequire")) return;
+			let modified = false;
+			const result = code.replace(RE, (match, specifier) => {
+				if (!specifier.endsWith(".json")) return match;
+				try {
+					const content = readFileSync(createRequire(id).resolve(specifier), "utf-8");
+					modified = true;
+					debug$4("inlineCreateRequire: inlined", specifier, "from", id);
+					return JSON.stringify(JSON.parse(content));
+				} catch {
+					debug$4("inlineCreateRequire: could not resolve", specifier, "from", id);
+					return match;
+				}
+			});
+			if (modified) return {
+				code: result,
+				map: null
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/rolldown.ts
+/**
+* rolldown processing
+*
+* @module rolldown
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const debug$3 = createDebug("vite-plugin-vrowzer:rolldown");
+const rolldownDistDir = path.resolve(path.dirname(fileURLToPath(import.meta.resolve("@vrowzer/rolldown/package.json"))), "dist");
+debug$3("rolldownDistDir ", rolldownDistDir);
+function rolldownPlugin(_options) {
+	let resolvedOutDir = "";
+	return {
+		name: "vrowzer:rolldown",
+		configResolved(config) {
+			resolvedOutDir = path.resolve(config.root, config.build.outDir);
+		},
+		writeBundle() {
+			const assetsDir = path.resolve(resolvedOutDir, "assets");
+			debug$3("copy-rolldown-wasm: assetsDir ", assetsDir);
+			const wasmSrc = path.resolve(rolldownDistDir, "rolldown-binding.wasm32-wasi.wasm");
+			debug$3("copy-rolldown-wasm: wasmSrc ", wasmSrc);
+			const workerSrc = path.resolve(rolldownDistDir, "worker.js");
+			debug$3("copy-rolldown-wasm: workerSrc ", workerSrc);
+			if (existsSync(wasmSrc)) copyFileSync(wasmSrc, path.resolve(assetsDir, "rolldown-binding.wasm32-wasi.wasm"));
+			if (existsSync(workerSrc)) copyFileSync(workerSrc, path.resolve(assetsDir, "rolldown-worker.js"));
+		}
+	};
+}
+
+//#endregion
+//#region src/server.ts
+/**
+* server middleware
+*
+* @module server
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const debug$2 = createDebug("vite-plugin-vrowzer:server");
+/**
+* NOTE(kazupon):
+* Prevent Vite's SPA fallback from serving index.html for preview URL (e.g '/__preview__/') requests.
+* When service worker is not yet controlling the page (e.g. after hard reload),
+* preview requests bypass service worker and hit Vite directly.
+* Without this guard, Vite returns the main page HTML, causing recursive display.
+*/
+function previewGuardMiddleware(previewBase = "/__preview__") {
+	return (req, res, next) => {
+		debug$2("previewGuardMiddleware: previewBase ", previewBase, " req.url ", req.url);
+		if (req.url?.startsWith(previewBase)) {
+			res.writeHead(503, {
+				"Content-Type": "text/html",
+				"Retry-After": "1"
+			});
+			res.end(`<!doctype html><html><head><meta charset="utf-8"><title>Preview</title></head><body>
+<script>setTimeout(() => location.reload(), 1000)<\/script>
+<p>Waiting for Service Worker...</p></body></html>`);
+			return;
+		}
+		next();
+	};
+}
+function serverMiddlewarePlugin(options) {
+	const middleware = previewGuardMiddleware(normalizeBasePath(options.basePath));
+	return {
+		name: "vrowzer:server-middleware",
+		configureServer(server) {
+			server.middlewares.use(middleware);
+		},
+		configurePreviewServer(server) {
+			server.middlewares.use(middleware);
+		}
+	};
+}
+function normalizeBasePath(basePath) {
+	debug$2("normalizeBasePath: basePath ", basePath);
+	if (basePath.endsWith("/")) return basePath.slice(0, -1);
+	else return basePath;
+}
+
+//#endregion
+//#region src/virtual.ts
+function generateWebWorkerEntry(configPath, resolve$1) {
+	return `
+import { initWebWorker } from 'vrowzer/web-worker-core'
+import config from '${configPath}'
+const resolved = config.default ?? config
+${resolve$1 ? `\nconst workerResolve = ${JSON.stringify(resolve$1)}\nObject.assign(resolved, { resolve: workerResolve })` : ""}
+initWebWorker(resolved)
+`;
+}
+
+//#endregion
+//#region src/manifest.ts
+/**
+* Vite plugin that transforms vrowzer-manifest.json imports.
+*
+* Replaces file path values with actual file contents so that
+* the imported manifest can be passed directly to Vrowzer.ready().
+*
+* Use the `?vrowzer` query suffix to trigger this plugin:
+*   import manifest from './vrowzer-manifest.json?vrowzer'
+*
+* @module manifest
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const MINIFIABLE_EXTENSIONS = new Set([
+	".js",
+	".mjs",
+	".cjs"
+]);
+const debug$1 = createDebug("vite-plugin-vrowzer:manifest");
+function parseId(id) {
+	try {
+		const url = new URL(id, "file://");
+		return {
+			filePath: url.pathname,
+			isVrowzer: url.searchParams.has("vrowzer")
+		};
+	} catch {
+		return {
+			filePath: id,
+			isVrowzer: false
+		};
+	}
+}
+function VrowzerManifest() {
+	return {
+		name: "vrowzer:manifest-loader",
+		resolveId(id) {
+			if (parseId(id).isVrowzer) {
+				debug$1("resolveId:", id);
+				return id;
+			}
+		},
+		load(id) {
+			const { filePath, isVrowzer } = parseId(id);
+			if (!isVrowzer) return;
+			debug$1("loading manifest:", filePath);
+			const raw = readFileSync(filePath, "utf-8");
+			const manifest = JSON.parse(raw);
+			const manifestDir = dirname(filePath);
+			function resolveFiles(field, files, minify = false) {
+				if (!files) return {};
+				const resolved = {};
+				for (const [virtualPath, relPath] of Object.entries(files)) try {
+					let content = readFileSync(resolve(manifestDir, relPath), "utf-8");
+					if (minify && MINIFIABLE_EXTENSIONS.has(extname(virtualPath))) {
+						const result$1 = minifySync(virtualPath, content);
+						if (result$1.code) content = result$1.code;
+					}
+					resolved[virtualPath] = content;
+				} catch (e) {
+					debug$1("failed to read %s %s: %s", field, relPath, e.message);
+				}
+				debug$1("%s: %d files resolved", field, Object.keys(resolved).length);
+				return resolved;
+			}
+			const result = {
+				name: manifest.name,
+				files: resolveFiles("files", manifest.files),
+				vendor: resolveFiles("vendor", manifest.vendor, true),
+				nodeModules: resolveFiles("nodeModules", manifest.nodeModules, true),
+				activeFile: manifest.activeFile
+			};
+			debug$1("manifest loaded: %s (%d files, %d vendor, %d nodeModules)", result.name, Object.keys(result.files).length, Object.keys(result.vendor).length, Object.keys(result.nodeModules).length);
+			return {
+				code: `export default ${JSON.stringify(result)}`,
+				moduleType: "js"
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* vite-plugin-vrowzer entry
+*
+* @module default
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const debug = createDebug("vite-plugin-vrowzer:index");
+function Vrowzer(options = {}) {
+	const resolvedOptions = resolveOptions(options);
+	const root = process.cwd();
+	let bundledConfigPath = null;
+	let isBuild = false;
+	function workerEntryTransform(code, id) {
+		if (!bundledConfigPath) return;
+		const cleanId = id.split("?")[0];
+		if (cleanId?.endsWith("web-worker.ts") && !cleanId.endsWith("web-worker-core.ts") && code.includes("initWebWorker()")) return {
+			code: generateWebWorkerEntry(bundledConfigPath, resolvedOptions.resolve),
+			map: null
+		};
+	}
+	const plugins = [
+		{
+			name: "vrowzer:config",
+			resolveId(id) {
+				if (id.startsWith("@vrowzer/")) try {
+					return fileURLToPath(import.meta.resolve(id));
+				} catch {}
+			},
+			config() {
+				const workerPlugins = [
+					{
+						name: "vrowzer:worker-resolve",
+						resolveId(id) {
+							if (id.startsWith("@vrowzer/")) try {
+								return fileURLToPath(import.meta.resolve(id));
+							} catch {}
+						}
+					},
+					{
+						name: "vrowzer:worker-process-inject",
+						options(inputOptions) {
+							inputOptions.transform ??= {};
+							inputOptions.transform.inject = {
+								...inputOptions.transform.inject,
+								process: "@vrowzer/node-polyfill/process"
+							};
+						}
+					},
+					{
+						name: "vrowzer:web-worker-config-inject",
+						transform: workerEntryTransform
+					}
+				];
+				return {
+					resolve: { alias: [{
+						find: /^vite$/,
+						replacement: "@vrowzer/vite-dev-server/vite"
+					}] },
+					worker: { plugins: () => workerPlugins }
+				};
+			},
+			async configResolved(config) {
+				isBuild = config.command === "build";
+				const viteConfigPath = config.configFile;
+				if (!viteConfigPath) {
+					debug("no vite.config.ts found, skipping extraction");
+					return;
+				}
+				debug("extracting worker config from:", viteConfigPath);
+				cleanOutputDir(config.root);
+				const configDir = dirname(viteConfigPath);
+				const { code: workerSource, unsupported } = extractWorkerConfig(readFileSync(viteConfigPath, "utf-8"), viteConfigPath);
+				if (unsupported.length > 0) debug("unsupported patterns found:", unsupported);
+				debug("generated worker source:\n", workerSource);
+				bundledConfigPath = await prebundleWorkerConfig({
+					workerSource,
+					root: config.root,
+					configDir
+				});
+				debug("bundled config path:", bundledConfigPath);
+			},
+			closeBundle() {
+				if (isBuild && bundledConfigPath) {
+					cleanOutputDir(root);
+					debug("cleaned up prebundle output after build");
+				}
+			},
+			transform(code, id) {
+				return workerEntryTransform(code, id);
+			}
+		},
+		serverMiddlewarePlugin(resolvedOptions),
+		{
+			...inject({
+				process: "@vrowzer/node-polyfill/process",
+				exclude: [/node_modules\/\.vite\//, /node_modules\/\.vrowzer\//]
+			}),
+			apply: "serve"
+		},
+		envPlugin(resolvedOptions),
+		rolldownPlugin(resolvedOptions),
+		ServiceWorker({
+			serviceWorkerAllowed: "/",
+			format: "esm",
+			...resolvedOptions.serviceWorkerEntry ? { entry: resolvedOptions.serviceWorkerEntry } : {}
+		})
+	];
+	if (resolvedOptions.auto) plugins.unshift(autoManifestPlugin(resolvedOptions.manifest));
+	if (resolvedOptions.ide.enabled) plugins.push(idePlugin(resolvedOptions));
+	return plugins;
+}
+
+//#endregion
+export { Vrowzer, VrowzerManifest, generateManifest };
+//# sourceMappingURL=index.mjs.map