oxidejs 0.3.1 → 0.3.3

package/dist/plugin-BIb3YnN7.mjs

@@ -0,0 +1,674 @@
+import { A as scanServerFiles, C as loadClientStub, D as parseExportedNames, E as nodeToWebRequest, O as parseStreamExports, S as isServerFileId, T as moduleKey, _ as generateActionsClientModule, b as generateClientStub, d as RESOLVED_VIRTUAL_CLIENT_ID, f as RESOLVED_VIRTUAL_WORKER_ID, g as VIRTUAL_WORKER_ID, j as sendWebResponseFrom, k as pluginShouldStub, l as ACTION_PATH, m as VIRTUAL_ACTIONS_ID, n as createActionHandler, p as RequestBodyTooLargeError, t as createWsHooks, u as RESOLVED_VIRTUAL_ACTIONS_ID, v as generateActionsModule, w as matchesActionPath, x as generateWorkerWrapper, y as generateClientModule } from "./rpc-gCOSJXql.mjs";
+import { ensureWorkerDom } from "./worker-dom.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { createUnplugin } from "unplugin";
+//#region src/core.ts
+const CELLD_ALLOWED_KEYS = [
+	"name",
+	"main",
+	"compatibility_date",
+	"compatibility_flags",
+	"durable_objects",
+	"migrations",
+	"assets",
+	"services",
+	"vars"
+];
+const USER_FORBIDDEN_KEYS = ["main", "assets"];
+const createEmitState = function createEmitState() {
+	return { emitted: false };
+};
+const validateWranglerOptions = function validateWranglerOptions(wrangler) {
+	const allowed = CELLD_ALLOWED_KEYS;
+	const invalid = Object.keys(wrangler).filter((key) => !allowed.includes(key));
+	if (invalid.length) throw new Error(`oxidejs: these wrangler keys are not supported by celld deploy: ${invalid.join(", ")}`);
+	const forbidden = USER_FORBIDDEN_KEYS.filter((key) => key in wrangler);
+	if (forbidden.length) throw new Error(`oxidejs: wrangler keys ${forbidden.join(", ")} are computed by the plugin and cannot be user-supplied`);
+};
+const assertContained = function assertContained(outDirAbs, childAbs, label) {
+	const outDir = path.resolve(outDirAbs);
+	const child = path.resolve(childAbs);
+	const relative = path.relative(outDir, child);
+	if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`oxidejs: ${label} must resolve inside outDir (got ${relative || "."})`);
+};
+const requireWranglerFields = function requireWranglerFields(wrangler) {
+	if (!wrangler?.name || !wrangler.compatibility_date) throw new Error("oxidejs: wrangler.name and wrangler.compatibility_date are required when emitConfig is true");
+	return wrangler;
+};
+const flattenInput = function flattenInput(input) {
+	if (input === void 0) return [];
+	if (Array.isArray(input)) return input;
+	if (Object.prototype.toString.call(input) === "[object Object]") return Object.values(input);
+	return [input];
+};
+const envInput = function envInput(env) {
+	if (env === void 0) return;
+	return env.build?.rolldownOptions?.input || env.build?.rollupOptions?.input || env.build?.input || env.input;
+};
+/** Vite client input: rolldown/rollup `input`, else `path.resolve(root, "index.html")`. */
+const hasHtmlEntry = function hasHtmlEntry(root, config) {
+	const explicit = envInput(config?.environments?.["client"]) || envInput(config?.environments?.["web"]) || config?.build?.rolldownOptions?.input || config?.build?.rollupOptions?.input;
+	return flattenInput(explicit || path.resolve(root, "index.html")).some((entry) => {
+		const file = path.resolve(root, entry);
+		return file.endsWith(".html") && fs.existsSync(file);
+	});
+};
+const resolveActions = function resolveActions(raw) {
+	if (raw === void 0) return {
+		path: ACTION_PATH,
+		sameOrigin: true,
+		transport: "http"
+	};
+	if (raw === "http" || raw === "ws") return {
+		path: ACTION_PATH,
+		sameOrigin: true,
+		transport: raw
+	};
+	if (Object.prototype.toString.call(raw) !== "[object Object]") throw new Error(`oxidejs: unknown actions transport "${String(raw)}"`);
+	const transport = raw.transport ?? "http";
+	if (transport !== "http" && transport !== "ws") throw new Error(`oxidejs: unknown actions transport "${String(transport)}"`);
+	const actionsPath = raw.path ?? "/__oxide/action";
+	if (!actionsPath.startsWith("/") || actionsPath.includes("?")) throw new Error(`oxidejs: actions.path must start with "/" and contain no query string (got "${actionsPath}")`);
+	return {
+		path: actionsPath,
+		sameOrigin: raw.sameOrigin ?? true,
+		transport
+	};
+};
+const resolvePreset = function resolvePreset(raw) {
+	const preset = raw?.preset ?? "fetch";
+	if (preset !== "fetch" && preset !== "celld") throw new Error(`oxidejs: unknown preset "${String(preset)}"`);
+	return preset;
+};
+const resolvePaths = function resolvePaths(raw, root) {
+	const workerEntry = raw?.workerEntry ?? "src/server.ts";
+	const outDirInput = raw?.outDir ?? "dist";
+	const clientDir = raw?.clientDir ?? "client";
+	const rootAbs = path.resolve(root);
+	return {
+		clientDir,
+		outDir: path.resolve(rootAbs, outDirInput),
+		rootAbs,
+		workerEntry,
+		workerEntryAbs: path.resolve(rootAbs, workerEntry)
+	};
+};
+const resolveWrangler = function resolveWrangler(raw, emitConfig) {
+	if (raw?.wrangler) validateWranglerOptions(raw.wrangler);
+	return emitConfig ? requireWranglerFields(raw?.wrangler) : raw?.wrangler;
+};
+const assertClientDir = function assertClientDir(outDir, clientDir, hasClient, hasPublic) {
+	if (hasClient || hasPublic) assertContained(outDir, path.resolve(outDir, clientDir), "clientDir");
+};
+const resolveOptions = function resolveOptions(raw, root, config) {
+	const preset = resolvePreset(raw);
+	const { transport: actions, path: actionPath, sameOrigin: actionSameOrigin } = resolveActions(raw?.actions);
+	if (actions === "ws" && preset === "celld") throw new Error("oxidejs: actions: \"ws\" is not supported with preset: \"celld\"");
+	const emitConfig = raw?.emitConfig ?? preset === "celld";
+	const { clientDir, outDir, rootAbs, workerEntry, workerEntryAbs } = resolvePaths(raw, root);
+	const hasClient = hasHtmlEntry(rootAbs, config);
+	const hasPublic = fs.existsSync(path.join(rootAbs, "public"));
+	assertClientDir(outDir, clientDir, hasClient, hasPublic);
+	const wrangler = resolveWrangler(raw, emitConfig);
+	return {
+		actionHeaders: raw?.actionHeaders,
+		actionPath,
+		actionSameOrigin,
+		actions,
+		bodyLimit: raw?.bodyLimit ?? 1048576,
+		clientDir,
+		emitConfig,
+		env: raw?.env,
+		hasClient,
+		hasPublic,
+		imports: raw?.imports ?? [],
+		middleware: raw?.middleware ?? [],
+		notFound: raw?.notFound,
+		outDir,
+		preset,
+		root: rootAbs,
+		workerEntry,
+		workerEntryAbs,
+		wrangler
+	};
+};
+const copyPublicDir = function copyPublicDir(opts) {
+	if (opts.preset !== "fetch") return;
+	const src = path.join(opts.root, "public");
+	if (!fs.existsSync(src)) return;
+	fs.cpSync(src, path.join(opts.outDir, opts.clientDir), {
+		force: true,
+		recursive: true
+	});
+};
+const tryEmitWranglerConfig = function tryEmitWranglerConfig(opts, state) {
+	if (state.emitted || opts.emitConfig === false) return;
+	const wrangler = requireWranglerFields(opts.wrangler);
+	const serverFile = path.join(opts.outDir, "server.js");
+	const clientDirPath = path.join(opts.outDir, opts.clientDir);
+	if (!fs.existsSync(serverFile)) return;
+	if (opts.hasClient && !fs.existsSync(clientDirPath)) return;
+	assertContained(opts.outDir, serverFile, "main");
+	if (opts.hasClient) assertContained(opts.outDir, clientDirPath, "assets.directory");
+	const config = {
+		compatibility_date: wrangler.compatibility_date,
+		compatibility_flags: [.../* @__PURE__ */ new Set([...wrangler.compatibility_flags ?? [], "nodejs_compat"])],
+		main: "./server.js",
+		name: wrangler.name
+	};
+	if (wrangler.durable_objects) config.durable_objects = wrangler.durable_objects;
+	if (wrangler.migrations) config.migrations = wrangler.migrations;
+	if (wrangler.services) config.services = wrangler.services;
+	if (wrangler.vars) config.vars = wrangler.vars;
+	if (opts.hasClient) config.assets = {
+		binding: "ASSETS",
+		directory: `./${opts.clientDir}`
+	};
+	fs.writeFileSync(path.join(opts.outDir, "wrangler.jsonc"), `${JSON.stringify(config, null, 2)}\n`);
+	state.emitted = true;
+};
+//#endregion
+//#region src/worker-build.ts
+/** Dev aliases so Vite transforms RPC helpers with the app's single effect copy. */
+const oxideRpcAliases = function oxideRpcAliases() {
+	const root = path.resolve(import.meta.dirname, "..");
+	const client = path.join(root, "src/rpc/client.ts");
+	if (!fs.existsSync(client)) return [];
+	return [{
+		find: /^oxidejs\/rpc\/client$/u,
+		replacement: client
+	}, {
+		find: /^oxidejs\/rpc$/u,
+		replacement: path.join(root, "src/rpc/index.ts")
+	}];
+};
+const mergeAliases = function mergeAliases(config, extra) {
+	if (extra.length === 0) return;
+	config.resolve ??= {};
+	const current = config.resolve.alias;
+	if (!current) {
+		config.resolve.alias = extra;
+		return;
+	}
+	if (Array.isArray(current)) {
+		config.resolve.alias = [...current, ...extra];
+		return;
+	}
+	config.resolve.alias = [...Object.entries(current).map(([find, replacement]) => ({
+		find,
+		replacement
+	})), ...extra];
+};
+const OPTIMIZE_DEPS = [
+	"effect",
+	"effect/unstable/rpc",
+	"effect/unstable/http",
+	"effect/unstable/socket",
+	"oxidejs",
+	"oxidejs/rpc/client"
+];
+const applyViteEnvironments = function applyViteEnvironments(config, opts) {
+	config.builder ??= {};
+	config.resolve ??= {};
+	const dedupe = /* @__PURE__ */ new Set([
+		...Array.isArray(config.resolve.dedupe) ? config.resolve.dedupe : [],
+		"effect",
+		"oxidejs"
+	]);
+	config.resolve.dedupe = [...dedupe];
+	config.optimizeDeps ??= {};
+	const optimizeInclude = /* @__PURE__ */ new Set([...Array.isArray(config.optimizeDeps.include) ? config.optimizeDeps.include : [], ...OPTIMIZE_DEPS]);
+	config.optimizeDeps.include = [...optimizeInclude];
+	const celld = opts.preset === "celld";
+	mergeAliases(config, oxideRpcAliases());
+	config.environments ??= {};
+	const ssrBuild = {
+		emptyOutDir: true,
+		outDir: opts.outDir,
+		rolldownOptions: {
+			external: celld ? [/^cloudflare:/u] : [],
+			input: VIRTUAL_WORKER_ID,
+			output: {
+				entryFileNames: "server.js",
+				format: "es"
+			}
+		},
+		rollupOptions: {
+			external: celld ? [/^cloudflare:/u] : [],
+			input: VIRTUAL_WORKER_ID,
+			output: {
+				entryFileNames: "server.js",
+				format: "es"
+			}
+		},
+		ssr: true
+	};
+	const ssrEnvironment = {
+		build: ssrBuild,
+		consumer: "server",
+		resolve: celld ? {
+			conditions: ["worker"],
+			noExternal: true
+		} : { noExternal: ["effect", "oxidejs"] },
+		ssr: celld ? {
+			external: [/^cloudflare:/u],
+			noExternal: true,
+			target: "webworker"
+		} : { noExternal: ["effect", "oxidejs"] }
+	};
+	config.environments["ssr"] = ssrEnvironment;
+	config.build ??= {};
+	if (opts.hasClient) {
+		const clientOutDir = path.join(opts.outDir, opts.clientDir);
+		const existingClient = config.environments["client"];
+		config.environments["client"] = {
+			...existingClient,
+			build: {
+				...existingClient?.build,
+				emptyOutDir: true,
+				manifest: true,
+				outDir: clientOutDir
+			},
+			consumer: "client"
+		};
+		ssrBuild.emptyOutDir = false;
+		config.build.outDir ??= clientOutDir;
+		config.build.manifest ??= true;
+	} else {
+		delete config.environments["client"];
+		config.appType = "custom";
+		config.build.outDir ??= opts.outDir;
+		config.build.emptyOutDir ??= true;
+		config.builder.buildApp ??= async (builder) => {
+			const server = builder.environments["ssr"];
+			if (server) await builder.build(server);
+		};
+	}
+	return config;
+};
+const applyRsbuildEnvironments = function applyRsbuildEnvironments(config, opts) {
+	config.environments ??= {};
+	if (opts.hasClient) {
+		const clientOutDir = path.join(opts.outDir, opts.clientDir);
+		const existingClient = config.environments["web"] ?? config.environments["client"];
+		config.environments["web"] = {
+			...existingClient,
+			output: {
+				...existingClient?.output,
+				distPath: {
+					...existingClient?.output?.distPath,
+					root: clientOutDir
+				},
+				manifest: true,
+				target: "web"
+			}
+		};
+	} else {
+		delete config.environments["web"];
+		delete config.environments["client"];
+	}
+	const server = {
+		output: {
+			distPath: { root: opts.outDir },
+			filename: { js: "server.js" },
+			target: opts.preset === "celld" ? "web-worker" : "node"
+		},
+		source: { entry: { server: {
+			html: false,
+			import: VIRTUAL_WORKER_ID
+		} } }
+	};
+	if (opts.preset === "celld") server.resolve = { conditionNames: ["worker", "..."] };
+	config.environments["server"] = server;
+	return config;
+};
+//#endregion
+//#region src/plugin.ts
+const isString = function isString(value) {
+	return typeof value === "string";
+};
+const isMiddlewareDefault = function isMiddlewareDefault(value) {
+	return typeof value === "function";
+};
+const isObject = function isObject(value) {
+	return typeof value === "object" && value !== null;
+};
+const resolveActionTransport = function resolveActionTransport(resolved, options) {
+	if (resolved?.actions) return resolved.actions;
+	const actions = options?.actions;
+	if (isString(actions) || actions === void 0) return actions ?? "http";
+	return actions.transport ?? "http";
+};
+const loadRpcModule = function loadRpcModule() {
+	return Promise.resolve({
+		createActionHandler,
+		createWsHooks
+	});
+};
+const actionMiddleware = function actionMiddleware(loadRouter, loadRpc, actionPath, sameOrigin, bodyLimit, onError) {
+	return (req, res, next) => {
+		if (!matchesActionPath((req.url ?? "").split("?")[0] ?? "", actionPath)) return next();
+		(async () => {
+			try {
+				const [mod, rpc] = await Promise.all([loadRouter(), loadRpc()]);
+				const response = await rpc.createActionHandler(mod.default, mod.actionsHandlers, {
+					path: actionPath,
+					sameOrigin
+				})(await nodeToWebRequest(req, bodyLimit));
+				await sendWebResponseFrom(req, res, response);
+			} catch (error) {
+				if (res.headersSent) return;
+				if (error instanceof RequestBodyTooLargeError) {
+					res.statusCode = 413;
+					res.end();
+					return;
+				}
+				onError?.(error instanceof Error ? error : new Error(String(error)));
+				res.statusCode = 503;
+				res.setHeader("content-type", "application/json");
+				res.end(JSON.stringify({ error: "oxide action handler failed" }));
+			}
+		})();
+	};
+};
+const attachActionUpgrade = function attachActionUpgrade(httpServer, loadRouter, loadRpc, actionPath, sameOrigin) {
+	if (!httpServer) return;
+	const crosswsNode = "crossws/adapters/node";
+	(async () => {
+		const { default: crossws } = await import(
+			/* @vite-ignore */
+			crosswsNode
+);
+		httpServer.on("upgrade", (req, socket, head) => {
+			if (!matchesActionPath((req.url ?? "").split("?")[0] ?? "", actionPath)) return;
+			(async () => {
+				try {
+					const [mod, rpc] = await Promise.all([loadRouter(), loadRpc()]);
+					const hooks = rpc.createWsHooks(mod.default, mod.actionsHandlers, {
+						path: actionPath,
+						sameOrigin
+					});
+					await crossws({ hooks }).handleUpgrade(req, socket, head);
+				} catch {
+					socket.destroy();
+				}
+			})();
+		});
+	})();
+};
+const previewMiddleware = function previewMiddleware(file) {
+	return (req, res, next) => {
+		(async () => {
+			try {
+				const mod = await import(
+					/* @vite-ignore */
+					pathToFileURL(file).href
+);
+				await sendWebResponseFrom(req, res, await mod.default.fetch(await nodeToWebRequest(req)));
+			} catch (error) {
+				return next(error instanceof Error ? error : new Error(String(error)));
+			}
+		})();
+	};
+};
+const loadActions = function loadActions(root) {
+	const code = generateActionsModule(scanServerFiles(root), { bust: true });
+	const dir = fs.mkdtempSync(path.join(root, ".oxide-actions-"));
+	const file = path.join(dir, "actions.mjs");
+	fs.writeFileSync(file, code);
+	return (async () => {
+		try {
+			return await import(pathToFileURL(file).href);
+		} finally {
+			fs.rmSync(dir, {
+				force: true,
+				recursive: true
+			});
+		}
+	})();
+};
+const loadVirtualClient = function loadVirtualClient(resolved, options) {
+	const transport = resolveActionTransport(resolved, options);
+	return generateClientModule(transport, resolved?.actionHeaders ?? options?.actionHeaders, resolved?.actionPath);
+};
+const loadVirtualActions = function loadVirtualActions(ctx, resolved, extra) {
+	const modules = scanServerFiles(resolved?.root ?? process.cwd());
+	if (pluginShouldStub(ctx, extra)) return generateActionsClientModule(modules);
+	for (const mod of modules) ctx.addWatchFile(mod.abs);
+	return generateActionsModule(modules);
+};
+const loadVirtualWorker = function loadVirtualWorker(ctx, resolved) {
+	ctx.addWatchFile(resolved.workerEntryAbs);
+	const modules = scanServerFiles(resolved.root);
+	for (const mod of modules) ctx.addWatchFile(mod.abs);
+	return generateWorkerWrapper(resolved.workerEntryAbs, {
+		actionPath: resolved.actionPath,
+		actionSameOrigin: resolved.actionSameOrigin,
+		actions: resolved.actions,
+		bodyLimit: resolved.bodyLimit,
+		clientDir: resolved.clientDir,
+		env: resolved.env,
+		hasActions: modules.length > 0,
+		hasClient: resolved.hasClient,
+		hasPublic: resolved.hasPublic,
+		imports: resolved.imports,
+		middleware: resolved.middleware,
+		notFound: resolved.notFound,
+		preset: resolved.preset
+	});
+};
+const loadPluginModule = function loadPluginModule(ctx, id, resolved, options, extra) {
+	if (id === RESOLVED_VIRTUAL_CLIENT_ID) return loadVirtualClient(resolved, options);
+	if (id === RESOLVED_VIRTUAL_WORKER_ID && pluginShouldStub(ctx, extra)) throw new Error(`oxidejs: ${VIRTUAL_WORKER_ID} is server-only`);
+	if (id === RESOLVED_VIRTUAL_ACTIONS_ID) return loadVirtualActions(ctx, resolved, extra);
+	if (id === RESOLVED_VIRTUAL_WORKER_ID) {
+		if (!resolved) return;
+		return loadVirtualWorker(ctx, resolved);
+	}
+	if (isServerFileId(id) && pluginShouldStub(ctx, extra)) {
+		const file = id.split("?")[0] ?? id;
+		ctx.addWatchFile(file);
+		return loadClientStub(id);
+	}
+};
+const runMiddlewareHandlers = async function runMiddlewareHandlers(handlers, request, context, index) {
+	if (index >= handlers.length) return;
+	const handler = handlers[index];
+	if (!handler) return runMiddlewareHandlers(handlers, request, context, index + 1);
+	const hit = await handler(request, context);
+	if (hit) return hit;
+	return runMiddlewareHandlers(handlers, request, context, index + 1);
+};
+const loadDevMiddlewareHandlers = async function loadDevMiddlewareHandlers(server, resolved) {
+	try {
+		await Promise.all((resolved.imports ?? []).map((spec) => server.ssrLoadModule(spec)));
+		const entries = resolved.middleware ?? [];
+		const mods = await Promise.all(entries.map(async (entry) => {
+			const spec = isString(entry) ? entry : entry.module;
+			return await server.ssrLoadModule(spec);
+		}));
+		const handlers = [];
+		for (const mod of mods) {
+			if (!isMiddlewareDefault(mod.default)) continue;
+			const fn = mod.default;
+			handlers.push((request, context) => Promise.resolve(fn(request, context)));
+		}
+		return handlers;
+	} catch (error) {
+		server.config.logger.error(`oxidejs: failed to wire dev middleware: ${String(error)}`);
+		return [];
+	}
+};
+/** Register the Connect bridge that runs production middleware modules in Vite dev. */
+const attachDevMiddlewareBridge = function attachDevMiddlewareBridge(server, opts) {
+	if ((opts.middleware?.length ?? 0) === 0 && (opts.imports?.length ?? 0) === 0) return Promise.resolve([]);
+	const handlersPromise = loadDevMiddlewareHandlers(server, opts);
+	server.middlewares.use((creq, cres, next) => {
+		if (matchesActionPath((creq.url ?? "").split("?")[0] ?? "", opts.actionPath)) return next();
+		(async () => {
+			try {
+				const handlers = await handlersPromise;
+				if (handlers.length === 0) return next();
+				const request = await nodeToWebRequest(creq, opts.bodyLimit);
+				const context = {
+					ctx: void 0,
+					env: opts.env
+				};
+				const hit = await runMiddlewareHandlers(handlers, request, context, 0);
+				if (hit) {
+					await sendWebResponseFrom(creq, cres, hit);
+					return;
+				}
+				return next();
+			} catch (error) {
+				if (cres.headersSent) return;
+				cres.statusCode = error instanceof RequestBodyTooLargeError ? 413 : 500;
+				cres.end(error instanceof RequestBodyTooLargeError ? void 0 : String(error));
+			}
+		})();
+	});
+	return handlersPromise;
+};
+const unpluginFactory = (options) => {
+	let resolved;
+	const emitState = createEmitState();
+	return {
+		buildStart() {
+			resolved ??= resolveOptions(options, process.cwd());
+			emitState.emitted = false;
+		},
+		enforce: "pre",
+		load(id, extra) {
+			return loadPluginModule(this, id, resolved, options, extra);
+		},
+		name: "oxidejs",
+		resolveId(id) {
+			if (id === "virtual:oxide/actions") return RESOLVED_VIRTUAL_ACTIONS_ID;
+			if (id === "virtual:oxide/worker") return RESOLVED_VIRTUAL_WORKER_ID;
+			if (id === "virtual:oxide/client") return RESOLVED_VIRTUAL_CLIENT_ID;
+			return null;
+		},
+		rsbuild: { setup(api) {
+			api.modifyRsbuildConfig((config) => {
+				const root = isString(config.root) ? config.root : process.cwd();
+				resolved = resolveOptions(options, root, config);
+				applyRsbuildEnvironments(config, resolved);
+			});
+			api.onBeforeStartDevServer(({ server }) => {
+				const loadRouter = () => {
+					const root = resolved?.root ?? process.cwd();
+					return loadActions(root);
+				};
+				const opts = resolved;
+				if (!opts) return;
+				if (opts.actions === "ws") attachActionUpgrade(server.httpServer, loadRouter, loadRpcModule, opts.actionPath, opts.actionSameOrigin);
+				else server.middlewares.use(actionMiddleware(loadRouter, loadRpcModule, opts.actionPath, opts.actionSameOrigin, opts.bodyLimit));
+			});
+			api.onBeforeStartPreviewServer?.(({ server }) => {
+				if (resolved?.preset !== "fetch") return;
+				server.middlewares.use(previewMiddleware(path.join(resolved.outDir, "server.js")));
+			});
+		} },
+		transform(code, id, extra) {
+			const ctx = this;
+			if (!isServerFileId(id) || !pluginShouldStub(ctx, extra) || code.startsWith("// oxidejs:client-stub\n")) return;
+			return generateClientStub({
+				exports: parseExportedNames(code),
+				key: moduleKey(id.split("?")[0] ?? id),
+				streams: parseStreamExports(code)
+			});
+		},
+		vite: {
+			config(config) {
+				const root = isString(config.root) ? config.root : process.cwd();
+				resolved = resolveOptions(options, root, config);
+				applyViteEnvironments(config, resolved);
+			},
+			configurePreviewServer(server) {
+				if (resolved?.preset !== "fetch") return;
+				server.middlewares.use(previewMiddleware(path.join(resolved.outDir, "server.js")));
+			},
+			configureServer(server) {
+				if (resolved?.preset === "celld") {
+					ensureWorkerDom();
+					const { ssr } = server.environments;
+					const resolve = ssr?.config?.resolve;
+					if (resolve) {
+						resolve.conditions = [
+							"node",
+							"import",
+							"module",
+							"default"
+						];
+						resolve.noExternal = ["effect", "oxidejs"];
+					}
+					const ssrOpts = ssr?.config?.ssr;
+					if (ssrOpts && isObject(ssrOpts)) {
+						ssrOpts.target = "node";
+						ssrOpts.noExternal = ["effect", "oxidejs"];
+					}
+				}
+				const invalidateActions = () => {
+					for (const env of Object.values(server.environments)) {
+						const mod = env.moduleGraph.getModuleById(RESOLVED_VIRTUAL_ACTIONS_ID);
+						if (mod) env.moduleGraph.invalidateModule(mod);
+					}
+				};
+				const fetchRouter = async () => {
+					return await server.ssrLoadModule(VIRTUAL_ACTIONS_ID);
+				};
+				let routerReady;
+				const loadRouter = async () => {
+					if (routerReady === void 0) routerReady = fetchRouter();
+					const current = routerReady;
+					try {
+						return await current;
+					} catch (error) {
+						if (routerReady === current) routerReady = void 0;
+						throw error;
+					}
+				};
+				const refreshRouter = () => {
+					routerReady = void 0;
+				};
+				server.watcher.on("all", (_event, file) => {
+					if (isServerFileId(file)) {
+						invalidateActions();
+						refreshRouter();
+					}
+				});
+				const loadRpc = () => server.ssrLoadModule("oxidejs/rpc");
+				const logActionError = (error) => {
+					server.config.logger.error(`oxidejs: action handler failed: ${String(error)}`);
+				};
+				const opts = resolved;
+				const wireActions = () => {
+					if (!opts) return;
+					server.middlewares.use(actionMiddleware(loadRouter, loadRpc, opts.actionPath, opts.actionSameOrigin, opts.bodyLimit, logActionError));
+				};
+				if (opts?.actions === "ws") attachActionUpgrade(server.httpServer, loadRouter, loadRpc, opts.actionPath, opts.actionSameOrigin);
+				const handlersPromise = opts ? attachDevMiddlewareBridge(server, opts) : Promise.resolve([]);
+				if (opts?.actions !== "ws") wireActions();
+				return async () => {
+					try {
+						await loadRouter();
+						await handlersPromise;
+					} catch (error) {
+						server.config.logger.error(`oxidejs: failed to prewarm dev server: ${String(error)}`);
+					}
+				};
+			}
+		},
+		writeBundle() {
+			if (!resolved) return;
+			copyPublicDir(resolved);
+			tryEmitWranglerConfig(resolved, emitState);
+		}
+	};
+};
+const oxidejs = /* @__PURE__ */ createUnplugin(unpluginFactory);
+const vite = /* @__PURE__ */ (() => oxidejs.vite)();
+//#endregion
+export { unpluginFactory as n, vite as r, oxidejs as t };

package/dist/plugin.d.mts

@@ -1,4 +1,4 @@
-import { r as OxidejsOptions } from "./types-BM4NAnzy.mjs";
+import { i as OxidejsOptions } from "./types-BaZeMYcP.mjs";
 import { UnpluginFactory } from "unplugin";
 //#region src/plugin.d.ts
 declare const unpluginFactory: UnpluginFactory<OxidejsOptions | undefined>;

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { n as unpluginFactory, r as vite, t as oxidejs } from "./plugin-HZKRDuCS.mjs";
+import { n as unpluginFactory, r as vite, t as oxidejs } from "./plugin-BIb3YnN7.mjs";
 export { oxidejs as default, oxidejs, unpluginFactory, vite };