oxidejs 0.2.4 → 0.3.1

package/dist/plugin-HZKRDuCS.mjs

@@ -0,0 +1,602 @@
+import { A as pluginShouldStub, C as isServerFileId, D as nodeToWebRequest, E as moduleKey, M as sendWebResponseFrom, O as parseExportedNames, S as generateWorkerWrapper, T as matchesActionPath, b as generateClientModule, d as RESOLVED_VIRTUAL_CLIENT_ID, f as RESOLVED_VIRTUAL_WORKER_ID, g as VIRTUAL_WORKER_ID, j as scanServerFiles, k as parseStreamExports, 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 generateActionsClientModule, w as loadClientStub, x as generateClientStub, y as generateActionsModule } from "./rpc-DzUkWWgQ.mjs";
+import { ensureWorkerDom } from "./worker-dom.mjs";
+import { createUnplugin } from "unplugin";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#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"];
+function createEmitState() {
+	return { emitted: false };
+}
+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`);
+}
+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 || "."})`);
+}
+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;
+}
+function flattenInput(input) {
+	if (!input) return [];
+	if (typeof input === "string") return [input];
+	if (Array.isArray(input)) return input;
+	return Object.values(input);
+}
+function envInput(env) {
+	if (!env || typeof env !== "object") return;
+	const rec = env;
+	return rec.build?.rolldownOptions?.input || rec.build?.rollupOptions?.input || rec.build?.input || rec.input;
+}
+/** Vite client input: rolldown/rollup `input`, else `path.resolve(root, "index.html")`. */
+function hasHtmlEntry(root, config) {
+	const cfg = config;
+	return flattenInput(envInput(cfg?.environments?.["client"]) || envInput(cfg?.environments?.["web"]) || cfg?.build?.rolldownOptions?.input || cfg?.build?.rollupOptions?.input || path.resolve(root, "index.html")).some((entry) => {
+		const file = path.resolve(root, entry);
+		return file.endsWith(".html") && fs.existsSync(file);
+	});
+}
+function resolveActions(raw) {
+	if (raw === void 0 || typeof raw === "string") {
+		const transport = raw ?? "http";
+		if (transport !== "http" && transport !== "ws") throw new Error(`oxidejs: unknown actions transport "${String(transport)}"`);
+		return {
+			transport,
+			path: ACTION_PATH,
+			sameOrigin: true
+		};
+	}
+	const transport = raw.transport ?? "http";
+	if (transport !== "http" && transport !== "ws") throw new Error(`oxidejs: unknown actions transport "${String(transport)}"`);
+	const path = raw.path ?? "/__oxide/action";
+	if (!path.startsWith("/") || path.includes("?")) throw new Error(`oxidejs: actions.path must start with "/" and contain no query string (got "${path}")`);
+	return {
+		transport,
+		path,
+		sameOrigin: raw.sameOrigin ?? true
+	};
+}
+function resolveOptions(raw, root, config) {
+	const preset = raw?.preset ?? "fetch";
+	if (preset !== "fetch" && preset !== "celld") throw new Error(`oxidejs: unknown preset "${String(preset)}"`);
+	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 workerEntry = raw?.workerEntry ?? "src/server.ts";
+	const outDirInput = raw?.outDir ?? "dist";
+	const clientDir = raw?.clientDir ?? "client";
+	const emitConfig = raw?.emitConfig ?? preset === "celld";
+	const rootAbs = path.resolve(root);
+	const outDir = path.resolve(rootAbs, outDirInput);
+	const workerEntryAbs = path.resolve(rootAbs, workerEntry);
+	const hasClient = hasHtmlEntry(rootAbs, config);
+	const hasPublic = fs.existsSync(path.join(rootAbs, "public"));
+	if (hasClient || hasPublic) assertContained(outDir, path.resolve(outDir, clientDir), "clientDir");
+	if (raw?.wrangler) validateWranglerOptions(raw.wrangler);
+	return {
+		root: rootAbs,
+		preset,
+		workerEntry,
+		workerEntryAbs,
+		outDir,
+		clientDir,
+		wrangler: emitConfig ? requireWranglerFields(raw?.wrangler) : raw?.wrangler,
+		emitConfig,
+		hasClient,
+		hasPublic,
+		actions,
+		actionPath,
+		actionSameOrigin,
+		actionHeaders: raw?.actionHeaders,
+		middleware: raw?.middleware ?? [],
+		imports: raw?.imports ?? [],
+		bodyLimit: raw?.bodyLimit ?? 1048576,
+		notFound: raw?.notFound,
+		env: raw?.env
+	};
+}
+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), {
+		recursive: true,
+		force: true
+	});
+}
+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 = {
+		name: wrangler.name,
+		main: "./server.js",
+		compatibility_date: wrangler.compatibility_date,
+		compatibility_flags: [.../* @__PURE__ */ new Set([...wrangler.compatibility_flags ?? [], "nodejs_compat"])],
+		...wrangler.durable_objects ? { durable_objects: wrangler.durable_objects } : {},
+		...wrangler.migrations ? { migrations: wrangler.migrations } : {},
+		...wrangler.services ? { services: wrangler.services } : {},
+		...wrangler.vars ? { vars: wrangler.vars } : {},
+		...opts.hasClient ? { assets: {
+			directory: `./${opts.clientDir}`,
+			binding: "ASSETS"
+		} } : {}
+	};
+	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. */
+function oxideRpcAliases() {
+	const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+	const client = path.join(root, "src/rpc/client.ts");
+	if (!fs.existsSync(client)) return [];
+	return [{
+		find: /^oxidejs\/rpc\/client$/,
+		replacement: client
+	}, {
+		find: /^oxidejs\/rpc$/,
+		replacement: path.join(root, "src/rpc/index.ts")
+	}];
+}
+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"
+];
+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 ??= {};
+	config.environments["ssr"] = {
+		consumer: "server",
+		build: {
+			outDir: opts.outDir,
+			emptyOutDir: true,
+			ssr: true,
+			rolldownOptions: {
+				input: VIRTUAL_WORKER_ID,
+				external: celld ? [/^cloudflare:/] : [],
+				output: {
+					format: "es",
+					entryFileNames: "server.js"
+				}
+			},
+			rollupOptions: {
+				input: VIRTUAL_WORKER_ID,
+				external: celld ? [/^cloudflare:/] : [],
+				output: {
+					format: "es",
+					entryFileNames: "server.js"
+				}
+			}
+		},
+		resolve: celld ? {
+			conditions: ["worker"],
+			noExternal: true
+		} : { noExternal: ["effect", "oxidejs"] },
+		ssr: celld ? {
+			target: "webworker",
+			noExternal: true,
+			external: [/^cloudflare:/]
+		} : { noExternal: ["effect", "oxidejs"] }
+	};
+	config.build ??= {};
+	if (opts.hasClient) {
+		const clientOutDir = path.join(opts.outDir, opts.clientDir);
+		const existingClient = config.environments["client"];
+		config.environments["client"] = {
+			...existingClient,
+			consumer: "client",
+			build: {
+				...existingClient?.build,
+				outDir: clientOutDir,
+				emptyOutDir: true,
+				manifest: true
+			}
+		};
+		config.environments["ssr"].build.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;
+}
+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,
+				target: "web",
+				distPath: {
+					...existingClient?.output?.distPath,
+					root: clientOutDir
+				},
+				manifest: true
+			}
+		};
+	} else {
+		delete config.environments["web"];
+		delete config.environments["client"];
+	}
+	const server = {
+		source: { entry: { server: {
+			import: VIRTUAL_WORKER_ID,
+			html: false
+		} } },
+		output: {
+			target: opts.preset === "celld" ? "web-worker" : "node",
+			filename: { js: "server.js" },
+			distPath: { root: opts.outDir }
+		}
+	};
+	if (opts.preset === "celld") server.resolve = { conditionNames: ["worker", "..."] };
+	config.environments["server"] = server;
+	return config;
+}
+//#endregion
+//#region src/plugin.ts
+function actionMiddleware(loadRouter, loadRpc, path, sameOrigin, bodyLimit, onError) {
+	return (req, res, next) => {
+		if (!matchesActionPath((req.url ?? "").split("?")[0] ?? "", path)) {
+			next();
+			return;
+		}
+		(async () => {
+			const [mod, rpc] = await Promise.all([loadRouter(), loadRpc()]);
+			const response = await rpc.createActionHandler(mod.default, mod.actionsHandlers, {
+				path,
+				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);
+			res.statusCode = 503;
+			res.setHeader("content-type", "application/json");
+			res.end(JSON.stringify({ error: "oxide action handler failed" }));
+		});
+	};
+}
+function attachActionUpgrade(httpServer, loadRouter, loadRpc, path, sameOrigin) {
+	if (!httpServer) return;
+	import(
+		/* @vite-ignore */
+		"crossws/adapters/node"
+).then(({ default: crossws }) => {
+		httpServer.on("upgrade", (req, socket, head) => {
+			if (!matchesActionPath((req.url ?? "").split("?")[0] ?? "", path)) return;
+			Promise.all([loadRouter(), loadRpc()]).then(([mod, rpc]) => crossws({ hooks: rpc.createWsHooks(mod.default, mod.actionsHandlers, {
+				path,
+				sameOrigin
+			}) }).handleUpgrade(req, socket, head)).catch(() => {
+				socket.destroy();
+			});
+		});
+	});
+}
+function previewMiddleware(file) {
+	return (req, res, next) => {
+		(async () => {
+			const mod = await import(
+				/* @vite-ignore */
+				pathToFileURL(file).href
+);
+			await sendWebResponseFrom(req, res, await mod.default.fetch(await nodeToWebRequest(req)));
+		})().catch(next);
+	};
+}
+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 import(pathToFileURL(file).href).finally(() => {
+		fs.rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+	});
+}
+const unpluginFactory = (options) => {
+	let resolved;
+	const emitState = createEmitState();
+	return {
+		name: "oxidejs",
+		enforce: "pre",
+		buildStart() {
+			resolved ??= resolveOptions(options, process.cwd());
+			emitState.emitted = false;
+		},
+		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;
+		},
+		load(id, extra) {
+			if (id === RESOLVED_VIRTUAL_CLIENT_ID) {
+				const transport = resolved?.actions ?? (typeof options?.actions === "string" || options?.actions === void 0 ? options?.actions : options.actions.transport) ?? "http";
+				return generateClientModule(transport, resolved?.actionHeaders ?? options?.actionHeaders, resolved?.actionPath);
+			}
+			if (id === RESOLVED_VIRTUAL_WORKER_ID && pluginShouldStub(this, extra)) throw new Error(`oxidejs: ${VIRTUAL_WORKER_ID} is server-only`);
+			if (id === RESOLVED_VIRTUAL_ACTIONS_ID) {
+				const modules = scanServerFiles(resolved?.root ?? process.cwd());
+				if (pluginShouldStub(this, extra)) return generateActionsClientModule(modules);
+				for (const mod of modules) this.addWatchFile(mod.abs);
+				return generateActionsModule(modules);
+			}
+			if (id === RESOLVED_VIRTUAL_WORKER_ID) {
+				if (!resolved) return;
+				this.addWatchFile(resolved.workerEntryAbs);
+				const modules = scanServerFiles(resolved.root);
+				for (const mod of modules) this.addWatchFile(mod.abs);
+				return generateWorkerWrapper(resolved.workerEntryAbs, {
+					preset: resolved.preset,
+					clientDir: resolved.clientDir,
+					hasClient: resolved.hasClient,
+					hasPublic: resolved.hasPublic,
+					hasActions: modules.length > 0,
+					actions: resolved.actions,
+					actionPath: resolved.actionPath,
+					actionSameOrigin: resolved.actionSameOrigin,
+					middleware: resolved.middleware,
+					imports: resolved.imports,
+					bodyLimit: resolved.bodyLimit,
+					notFound: resolved.notFound,
+					env: resolved.env
+				});
+			}
+			if (isServerFileId(id) && pluginShouldStub(this, extra)) {
+				const file = id.split("?")[0] ?? id;
+				this.addWatchFile(file);
+				return loadClientStub(id);
+			}
+		},
+		transform(code, id, extra) {
+			if (!isServerFileId(id) || !pluginShouldStub(this, extra) || code.startsWith("// oxidejs:client-stub\n")) return;
+			return generateClientStub({
+				key: moduleKey(id.split("?")[0] ?? id),
+				exports: parseExportedNames(code),
+				streams: parseStreamExports(code)
+			});
+		},
+		vite: {
+			config(config) {
+				resolved = resolveOptions(options, typeof config.root === "string" ? config.root : process.cwd(), config);
+				applyViteEnvironments(config, resolved);
+			},
+			configureServer(server) {
+				if (resolved?.preset === "celld") {
+					ensureWorkerDom();
+					const ssr = server.environments.ssr;
+					const resolve = ssr?.config?.resolve;
+					if (resolve) {
+						resolve.conditions = [
+							"node",
+							"import",
+							"module",
+							"default"
+						];
+						resolve.noExternal = ["effect", "oxidejs"];
+					}
+					const ssrOpts = ssr?.config?.ssr;
+					if (ssrOpts && typeof ssrOpts === "object") {
+						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 = () => {
+					const current = routerReady ??= fetchRouter();
+					return 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 wireActions = () => server.middlewares.use(actionMiddleware(loadRouter, loadRpc, resolved.actionPath, resolved.actionSameOrigin, resolved.bodyLimit, logActionError));
+				if (resolved?.actions === "ws") {
+					attachActionUpgrade(server.httpServer, loadRouter, loadRpc, resolved.actionPath, resolved.actionSameOrigin);
+					return async () => {
+						try {
+							await loadRouter();
+						} catch (error) {
+							server.config.logger.error("oxidejs: failed to prewarm actions: " + String(error));
+						}
+					};
+				}
+				let handlersPromise = Promise.resolve([]);
+				if ((resolved?.middleware?.length ?? 0) > 0 || (resolved?.imports?.length ?? 0) > 0) {
+					handlersPromise = (async () => {
+						try {
+							for (const spec of resolved.imports ?? []) await server.ssrLoadModule(spec);
+							const handlers = [];
+							for (const entry of resolved.middleware ?? []) {
+								const spec = typeof entry === "string" ? entry : entry.module;
+								const mod = await server.ssrLoadModule(spec);
+								if (typeof mod.default !== "function") 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 [];
+						}
+					})();
+					server.middlewares.use((creq, cres, next) => {
+						if (matchesActionPath((creq.url ?? "").split("?")[0] ?? "", resolved.actionPath)) {
+							next();
+							return;
+						}
+						(async () => {
+							try {
+								const handlers = await handlersPromise;
+								if (handlers.length === 0) {
+									next();
+									return;
+								}
+								const { nodeToWebRequest, sendWebResponseFrom } = await import("./rpc-DzUkWWgQ.mjs").then((n) => n._);
+								const request = await nodeToWebRequest(creq, resolved.bodyLimit);
+								const context = {
+									env: resolved.env,
+									ctx: void 0
+								};
+								for (const handler of handlers) {
+									const hit = await handler(request, context);
+									if (hit) {
+										await sendWebResponseFrom(creq, cres, hit);
+										return;
+									}
+								}
+								next();
+							} catch (error) {
+								if (cres.headersSent) return;
+								cres.statusCode = error instanceof RequestBodyTooLargeError ? 413 : 500;
+								cres.end(error instanceof RequestBodyTooLargeError ? void 0 : String(error));
+							}
+						})();
+					});
+				}
+				wireActions();
+				return async () => {
+					try {
+						await loadRouter();
+						await handlersPromise;
+					} catch (error) {
+						server.config.logger.error("oxidejs: failed to prewarm dev server: " + String(error));
+					}
+				};
+			},
+			configurePreviewServer(server) {
+				if (resolved?.preset !== "fetch") return;
+				server.middlewares.use(previewMiddleware(path.join(resolved.outDir, "server.js")));
+			}
+		},
+		rsbuild: { setup(api) {
+			api.modifyRsbuildConfig((config) => {
+				resolved = resolveOptions(options, typeof config.root === "string" ? config.root : process.cwd(), config);
+				applyRsbuildEnvironments(config, resolved);
+			});
+			api.onBeforeStartDevServer(({ server }) => {
+				const loadRouter = async () => {
+					return loadActions(resolved?.root ?? process.cwd());
+				};
+				const loadRpc = async () => ({
+					createActionHandler,
+					createWsHooks
+				});
+				if (resolved?.actions === "ws") attachActionUpgrade(server.httpServer, loadRouter, loadRpc, resolved.actionPath, resolved.actionSameOrigin);
+				else server.middlewares.use(actionMiddleware(loadRouter, loadRpc, resolved.actionPath, resolved.actionSameOrigin, resolved.bodyLimit));
+			});
+			api.onBeforeStartPreviewServer?.(({ server }) => {
+				if (resolved?.preset !== "fetch") return;
+				server.middlewares.use(previewMiddleware(path.join(resolved.outDir, "server.js")));
+			});
+		} },
+		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.mjs

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

package/dist/rpc/client.d.mts

@@ -0,0 +1,13 @@
+import { t as OxidejsActionHeaders } from "../types-BM4NAnzy.mjs";
+import { Rpc, RpcGroup } from "effect/unstable/rpc";
+//#region src/rpc/client.d.ts
+type RpcClientOptions = {
+  url: string;
+  transport?: "http" | "ws";
+  headers?: OxidejsActionHeaders;
+};
+type NestedClient = Record<string, Record<string, (...args: unknown[]) => Promise<unknown> | AsyncGenerator<unknown>>>;
+type ActionGroup = RpcGroup.RpcGroup<Rpc.Any>;
+declare function createClient(group: ActionGroup, options: RpcClientOptions): NestedClient;
+//#endregion
+export { RpcClientOptions, createClient };

package/dist/rpc/client.mjs

@@ -0,0 +1,2 @@
+import { t as createClient } from "../client-C-s6XXpS.mjs";
+export { createClient };