oxidejs 0.2.4 → 0.3.1

package/dist/rpc-DzUkWWgQ.mjs

@@ -0,0 +1,915 @@
+import { t as runWithRequest } from "./context-zrTZyYpF.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { Layer } from "effect";
+import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+import { HttpRouter } from "effect/unstable/http";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/actions.ts
+var actions_exports = /* @__PURE__ */ __exportAll({
+	ACTION_PATH: () => ACTION_PATH,
+	RESOLVED_VIRTUAL_ACTIONS_ID: () => RESOLVED_VIRTUAL_ACTIONS_ID,
+	RESOLVED_VIRTUAL_CLIENT_ID: () => RESOLVED_VIRTUAL_CLIENT_ID,
+	RESOLVED_VIRTUAL_WORKER_ID: () => RESOLVED_VIRTUAL_WORKER_ID,
+	RequestBodyTooLargeError: () => RequestBodyTooLargeError,
+	VIRTUAL_ACTIONS_ID: () => VIRTUAL_ACTIONS_ID,
+	VIRTUAL_CLIENT_ID: () => VIRTUAL_CLIENT_ID,
+	VIRTUAL_WORKER_ID: () => VIRTUAL_WORKER_ID,
+	generateActionsClientModule: () => generateActionsClientModule,
+	generateActionsModule: () => generateActionsModule,
+	generateClientModule: () => generateClientModule,
+	generateClientStub: () => generateClientStub,
+	generateWorkerWrapper: () => generateWorkerWrapper,
+	isServerFileId: () => isServerFileId,
+	loadClientStub: () => loadClientStub,
+	matchesActionPath: () => matchesActionPath,
+	moduleKey: () => moduleKey,
+	nodeToWebRequest: () => nodeToWebRequest,
+	parseExportedNames: () => parseExportedNames,
+	parseStreamExports: () => parseStreamExports,
+	pluginShouldStub: () => pluginShouldStub,
+	scanServerFiles: () => scanServerFiles,
+	sendWebResponseFrom: () => sendWebResponseFrom,
+	shouldStubServerModule: () => shouldStubServerModule
+});
+const VIRTUAL_ACTIONS_ID = "virtual:oxide/actions";
+const RESOLVED_VIRTUAL_ACTIONS_ID = `\0${VIRTUAL_ACTIONS_ID}`;
+const VIRTUAL_WORKER_ID = "virtual:oxide/worker";
+const RESOLVED_VIRTUAL_WORKER_ID = `\0${VIRTUAL_WORKER_ID}`;
+const VIRTUAL_CLIENT_ID = "virtual:oxide/client";
+const RESOLVED_VIRTUAL_CLIENT_ID = `\0${VIRTUAL_CLIENT_ID}`;
+const ACTION_PATH = "/__oxide/action";
+/** Match the action endpoint with or without a trailing slash (Effect RPC posts to `path/`). */
+function matchesActionPath(pathname, path = ACTION_PATH) {
+	return pathname === path || pathname === `${path}/`;
+}
+const IGNORE_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	".git",
+	".wrangler"
+]);
+/** Only `export const name = action(...)` become remote RPC actions. Everything else stays server-local. */
+const EXPORT_RE = /^\s*export\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?action\s*\(/gm;
+const STREAM_EXPORT_RE = /^\s*export\s+const\s+([A-Za-z_$][\w$]*)\s*=\s*action\s*\(\s*async\s+function\s*\*/gm;
+function isServerFileId(id) {
+	const file = id.split("?")[0]?.replace(/\\/g, "/") ?? "";
+	return [
+		".ts",
+		".tsx",
+		".js",
+		".jsx"
+	].some((ext) => file.endsWith(`.server${ext}`));
+}
+function moduleKey(absFile) {
+	return path.basename(absFile).replace(/\.server\.(?:[jt]sx?)$/i, "");
+}
+function parseExportedNames(source) {
+	const names = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(EXPORT_RE)) {
+		const name = match[1];
+		if (name) names.add(name);
+	}
+	return [...names];
+}
+function parseStreamExports(source) {
+	const names = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(STREAM_EXPORT_RE)) {
+		const name = match[1];
+		if (name) names.add(name);
+	}
+	return [...names];
+}
+function scanServerFiles(root) {
+	const files = [];
+	const walk = (dir) => {
+		let entries;
+		try {
+			entries = fs.readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (entry.name.startsWith(".")) continue;
+			const abs = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				if (IGNORE_DIRS.has(entry.name)) continue;
+				walk(abs);
+				continue;
+			}
+			if (entry.isFile() && isServerFileId(entry.name)) files.push(abs);
+		}
+	};
+	walk(root);
+	const byKey = /* @__PURE__ */ new Map();
+	const modules = [];
+	for (const abs of files.sort()) {
+		const key = moduleKey(abs);
+		if (!key) throw new Error(`oxidejs: invalid server module name: ${abs}`);
+		const existing = byKey.get(key);
+		if (existing) throw new Error(`oxidejs: duplicate server module key "${key}": ${existing} and ${abs}`);
+		byKey.set(key, abs);
+		const source = fs.readFileSync(abs, "utf8");
+		modules.push({
+			abs,
+			key,
+			exports: parseExportedNames(source),
+			streams: parseStreamExports(source)
+		});
+	}
+	return modules;
+}
+function generateClientModule(transport = "http", headers, path = ACTION_PATH) {
+	const opts = { url: path };
+	if (transport === "ws") opts.transport = "ws";
+	if (headers) opts.headers = headers;
+	if (transport === "ws") return `import { createClient } from "oxidejs/rpc/client";
+import { actionsGroup } from ${JSON.stringify(VIRTUAL_ACTIONS_ID)};
+const __proto = typeof location === "undefined" ? "ws:" : location.protocol === "https:" ? "wss:" : "ws:";
+const __host = typeof location === "undefined" ? "localhost" : location.host;
+export const client = createClient(actionsGroup, { ...${JSON.stringify(opts)}, url: __proto + "//" + __host + ${JSON.stringify(path)} });
+`;
+	return `import { createClient } from "oxidejs/rpc/client";
+import { actionsGroup } from ${JSON.stringify(VIRTUAL_ACTIONS_ID)};
+export const client = createClient(actionsGroup, ${JSON.stringify(opts)});
+`;
+}
+function generateClientStub(mod) {
+	const streams = new Set(mod.streams ?? []);
+	const lines = [
+		`// oxidejs:client-stub`,
+		`import { wrapClientRpc, wrapClientStreamRpc } from "oxidejs";`,
+		`import { client } from ${JSON.stringify(VIRTUAL_CLIENT_ID)};`
+	];
+	for (const name of mod.exports) {
+		const call = `client[${JSON.stringify(mod.key)}][${JSON.stringify(name)}]`;
+		const peel = `(...args) => {
+  const opts = args.at(-1);
+  // ponytail: peel last { signal } only. A lone payload { signal: AbortSignal } is treated as CallOptions.
+  return opts && typeof opts === "object" && opts.signal instanceof AbortSignal && Object.keys(opts).length === 1
+    ? ${call}(...args.slice(0, -1), opts)
+    : ${call}(...args);
+}`;
+		if (streams.has(name)) lines.push(`export const ${name} = wrapClientStreamRpc(${peel});`);
+		else lines.push(`export const ${name} = wrapClientRpc(${peel});`);
+	}
+	return `${lines.join("\n")}\n`;
+}
+function generateActionsClientModule(modules) {
+	const lines = [`import { Schema } from "effect";`, `import { Rpc, RpcGroup } from "effect/unstable/rpc";`];
+	const rpcNames = [];
+	modules.forEach((mod, i) => {
+		for (const name of mod.exports) {
+			const rpc = `__rpc_${i}_${name}`;
+			rpcNames.push(rpc);
+			const tag = `${mod.key}.${name}`;
+			const stream = mod.streams?.includes(name) ?? false;
+			lines.push(`const ${rpc} = Rpc.make(${JSON.stringify(tag)}, { payload: Schema.Struct({ args: Schema.Array(Schema.Unknown) }), success: Schema.Unknown${stream ? ", stream: true" : ""} });`);
+		}
+	});
+	lines.push(`export const actionsGroup = RpcGroup.make(${rpcNames.join(", ")});`);
+	lines.push(`export default actionsGroup;`);
+	lines.push(`export { actionsGroup as actions };`);
+	return `${lines.join("\n")}\n`;
+}
+function generateActionsModule(modules, opts) {
+	const lines = [
+		`import { Effect } from "effect";`,
+		`import { Schema } from "effect";`,
+		`import { Rpc, RpcGroup } from "effect/unstable/rpc";`,
+		`import { AsyncLocalStorage } from "node:async_hooks";`,
+		`import { asyncGenToStreamInContext } from "oxidejs/rpc";`,
+		`const __alsKey = Symbol.for("oxidejs.requestContext");`,
+		`const __als = globalThis[__alsKey] ??= new AsyncLocalStorage();`,
+		`const __store = () => {`,
+		`  const ctx = __als.getStore();`,
+		`  if (!ctx) throw new Error("oxidejs: request context is unavailable");`,
+		`  return ctx;`,
+		`};`,
+		`const __run = (fn) =>`,
+		`  Effect.promise(() => __als.run(__store(), fn)).pipe(`,
+		`    Effect.map((value) => {`,
+		`      if (value instanceof Response) {`,
+		`        console.error("oxidejs: action() returned a Response; actions must return serializable data. Return a Response from src/server.ts for raw HTTP responses.");`,
+		`        throw new Error("action() returned a Response; return it from src/server.ts instead");`,
+		`      }`,
+		`      return value === undefined ? null : value;`,
+		`    }),`,
+		`  );`,
+		`const __withStore = (store, fn) => __als.run(store, fn);`
+	];
+	const rpcNames = [];
+	const aliases = modules.map((mod, i) => {
+		const alias = `__m${i}`;
+		const spec = opts?.bust === true ? `${mod.abs}?t=${fs.statSync(mod.abs).mtimeMs}` : mod.abs;
+		lines.push(`import * as ${alias} from ${JSON.stringify(spec)};`);
+		for (const name of mod.exports) {
+			const rpc = `__rpc_${i}_${name}`;
+			rpcNames.push(rpc);
+			const tag = `${mod.key}.${name}`;
+			const stream = mod.streams?.includes(name) ?? false;
+			lines.push(`const ${rpc} = Rpc.make(${JSON.stringify(tag)}, { payload: Schema.Struct({ args: Schema.Array(Schema.Unknown) }), success: Schema.Unknown${stream ? ", stream: true" : ""} });`);
+		}
+		return {
+			alias,
+			mod
+		};
+	});
+	lines.push(`export const actionsGroup = RpcGroup.make(${rpcNames.join(", ")});`);
+	lines.push(`export const actionsHandlers = actionsGroup.toLayer({`);
+	for (const { alias, mod } of aliases) for (const name of mod.exports) {
+		const tag = `${mod.key}.${name}`;
+		const stream = mod.streams?.includes(name) ?? false;
+		lines.push(stream ? `  ${JSON.stringify(tag)}: ({ args }) => { const __s = __store(); return asyncGenToStreamInContext(() => ${alias}[${JSON.stringify(name)}].apply(null, args), (fn) => __withStore(__s, fn)); },` : `  ${JSON.stringify(tag)}: ({ args }) => __run(() => ${alias}[${JSON.stringify(name)}].apply(null, args)),`);
+	}
+	lines.push(`});`);
+	lines.push(`export default actionsGroup;`);
+	lines.push(`export { actionsGroup as actions };`);
+	return `${lines.join("\n")}\n`;
+}
+function pipeResponse(req, res, response) {
+	return new Promise((resolve, reject) => {
+		res.statusCode = response.status;
+		response.headers.forEach((value, key) => {
+			res.setHeader(key, value);
+		});
+		if (!response.body) {
+			res.end();
+			resolve();
+			return;
+		}
+		const reader = response.body.getReader();
+		const abort = () => {
+			reader.cancel();
+		};
+		req.once("aborted", abort);
+		const pull = () => {
+			reader.read().then(({ done, value }) => {
+				if (done) {
+					req.off("aborted", abort);
+					res.end();
+					resolve();
+					return;
+				}
+				if (value) res.write(value);
+				pull();
+			}, reject);
+		};
+		pull();
+	});
+}
+function generateWorkerWrapper(userWorkerAbs, opts = {}) {
+	const preset = opts.preset ?? "fetch";
+	const clientDir = opts.clientDir ?? "client";
+	const actionPath = opts.actionPath ?? "/__oxide/action";
+	const sameOrigin = opts.actionSameOrigin ?? false;
+	const serveAssets = preset === "fetch" && (opts.hasClient === true || opts.hasPublic === true);
+	const hasActions = opts.hasActions !== false;
+	const ws = hasActions && opts.actions === "ws";
+	const bodyLimit = opts.bodyLimit ?? 1048576;
+	const nfBlock = `const __nf = ${`() => new Response(${JSON.stringify(opts.notFound ?? "<h1>404 Not Found</h1>")}, { status: 404, headers: { "content-type": "text/html; charset=utf-8" } })`};\n`;
+	const assetBlock = serveAssets ? `import { readFile } from "node:fs/promises";
+import { extname, join } from "node:path";
+const __assets = join(import.meta.dirname, ${JSON.stringify(clientDir)});
+const __types = { ".html": "text/html; charset=utf-8", ".js": "text/javascript", ".css": "text/css", ".json": "application/json", ".svg": "image/svg+xml", ".png": "image/png", ".ico": "image/x-icon", ".woff2": "font/woff2", ".webp": "image/webp" };
+function __nav(request) {
+  const dest = request.headers.get("sec-fetch-dest");
+  if (dest) return dest === "document";
+  return (request.headers.get("accept") ?? "").includes("text/html");
+}
+function __cache(file) {
+  if (file === "index.html") return "no-cache";
+  return /[-.][0-9a-f]{8,}.[a-z0-9]+$/i.test(file) ? "public, max-age=31536000, immutable" : undefined;
+}
+function __rel(pathname, spa) {
+  if (pathname.includes("\0")) return;
+  let file;
+  try { file = decodeURIComponent(pathname); } catch { return; }
+  if (file.includes("\0")) return;
+  if (file === "/" || spa) file = "/index.html";
+  if (!file.startsWith("/") || file.split("/").includes("..")) return;
+  const rel = file.slice(1);
+  if (rel.startsWith("/")) return;
+  return rel;
+}
+async function __asset(request, spa) {
+  const file = __rel(new URL(request.url).pathname, spa);
+  if (!file) return;
+  try {
+    const body = await readFile(join(__assets, file));
+    const headers = { "content-type": __types[extname(file)] ?? "application/octet-stream" };
+    const cache = __cache(file);
+    if (cache) headers["cache-control"] = cache;
+    const etag = '"' + body.length.toString(16) + "-" + file + '"';
+    headers["etag"] = etag;
+    if (request.headers.get("if-none-match") === etag) {
+      return new Response(null, { status: 304, headers });
+    }
+    return new Response(body, { headers });
+  } catch {
+    return;
+  }
+}
+` : "";
+	const envJson = JSON.stringify(opts.env ?? {});
+	const celldAfterAction = `{
+    const hit = typeof user.fetch === "function" ? await user.fetch(request, env ?? ${envJson}, ctx) : undefined;
+    if (hit) return hit;
+    const assets = env?.ASSETS;
+    if (assets && typeof assets.fetch === "function") return assets.fetch(request);
+    return __nf();
+  }`;
+	const afterAction = serveAssets ? `if (typeof user.fetch === "function") {
+      const hit = await user.fetch(request, env ?? ${envJson}, ctx);
+      if (hit) return hit;
+    }
+    return (await __asset(request)) ?? (__nav(request) ? await __asset(request, true) : undefined) ?? __nf();` : preset === "celld" ? celldAfterAction : `return typeof user.fetch === "function"
+      ? user.fetch(request, env, ctx)
+      : __nf();`;
+	const listen = preset === "fetch" ? `
+import { createServer } from "node:http";
+import { pathToFileURL } from "node:url";
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const port = Number(process.env.PORT) || 3000;
+  const bodyLimit = ${bodyLimit};
+  const server = createServer(async (req, res) => {
+    const url = \`http://\${req.headers.host ?? "localhost"}\${req.url ?? "/"}\`;
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+      if (value === undefined) continue;
+      if (Array.isArray(value)) for (const item of value) headers.append(key, item);
+      else headers.set(key, value);
+    }
+    const ac = new AbortController();
+    req.once("aborted", () => ac.abort());
+    const method = req.method ?? "GET";
+    const chunks = [];
+    let size = 0;
+    if (method !== "GET" && method !== "HEAD") for await (const chunk of req) {
+      size += chunk.length;
+      // Bound request buffering — unbounded bodies are a memory DoS vector.
+      if (size > ${bodyLimit}) { res.statusCode = 413; res.end(); return; }
+      chunks.push(chunk);
+    }
+    const init = { method, headers, signal: ac.signal };
+    if (chunks.length) init.body = Buffer.concat(chunks);
+    const response = await app.fetch(new Request(url, init));
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => res.setHeader(key, value));
+    if (!response.body) { res.end(); return; }
+    const reader = response.body.getReader();
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) res.write(value);
+    }
+    res.end();
+  });${ws ? `
+  import("crossws/adapters/node").then(({ default: crossws }) => {
+    const ws = crossws({ hooks: __ws });
+    server.on("upgrade", (req, socket, head) => {
+      if ((__actionMatch)(req.url?.split("?")[0] ?? "")) ws.handleUpgrade(req, socket, head);
+    });
+  });` : ""}
+  server.listen(port, () => console.log(\`oxidejs listening on \${port}\`));
+}
+  for (const signal of ["SIGTERM", "SIGINT"]) {
+    process.on(signal, () => {
+      server.close(() => process.exit(0));
+      setTimeout(() => process.exit(0), 5000).unref();
+    });
+  }
+` : "";
+	const actionImports = hasActions ? ws ? `import { createWsHooks } from "oxidejs/rpc";
+import { actionsGroup, actionsHandlers } from ${JSON.stringify(VIRTUAL_ACTIONS_ID)};
+const __ws = createWsHooks(actionsGroup, actionsHandlers, { path: ${JSON.stringify(actionPath)}, sameOrigin: ${sameOrigin} });
+` : `import { createActionHandler } from "oxidejs/rpc";
+import { actionsGroup, actionsHandlers } from ${JSON.stringify(VIRTUAL_ACTIONS_ID)};
+const __fetch = Symbol.for("oxidejs.fetch");
+const __rpc = createActionHandler(actionsGroup, actionsHandlers, { path: ${JSON.stringify(actionPath)}, sameOrigin: ${sameOrigin}, createContext: (req) => req[__fetch] ?? {} });
+` : "";
+	const actionMatchFn = `const __actionMatch = (p) => p === ${JSON.stringify(actionPath)} || p === ${JSON.stringify(`${actionPath}/`)};`;
+	const actionGate = hasActions && !ws ? `if ((__actionMatch)(new URL(request.url).pathname)) {
+      return __rpc(request);
+    }
+    ` : "";
+	const ILHA_SSR_IMPLICIT = ["ilha:pages/server", "ilha:loaders"];
+	const middlewareImports = (opts.middleware ?? []).map((m) => typeof m === "string" ? {
+		module: m,
+		imports: m === "@ilha/router/ssr" ? ILHA_SSR_IMPLICIT : []
+	} : m).map((m, i) => (m.imports ?? []).map((spec) => `import ${JSON.stringify(spec)};`).join("\n") + `\nimport __mw${i} from ${JSON.stringify(m.module)};`).join("\n") + "\n";
+	const middlewareList = (opts.middleware ?? []).map((_, i) => `__mw${i}`).join(", ");
+	const middlewareGate = opts.middleware?.length ? `for (const __mw of [${middlewareList}]) {
+      const hit = await __mw(request, { env, ctx });
+      if (hit) return hit;
+    }
+    ` : "";
+	return `${(opts.imports ?? []).map((spec) => `import ${JSON.stringify(spec)};`).join("\n")}${preset === "celld" ? `import "oxidejs/worker-dom/install";\n` : ""}export * from ${JSON.stringify(userWorkerAbs)};
+import user from ${JSON.stringify(userWorkerAbs)};
+${middlewareImports}${actionImports}${hasActions ? `${actionMatchFn}\n` : ""}${assetBlock}${nfBlock}const app = {
+  ...user,
+  async fetch(request, env, ctx) {
+    request[__fetch] = { env, fetchCtx: ctx };
+    ${middlewareGate}${actionGate}${afterAction}
+  },
+};
+export default app;
+${listen}`;
+}
+const SERVER_TARGETS = /* @__PURE__ */ new Set([
+	"node",
+	"async-node",
+	"webworker",
+	"web-worker"
+]);
+const CLIENT_TARGETS = /* @__PURE__ */ new Set(["web", "browserslist"]);
+const SERVER_NAMES = /* @__PURE__ */ new Set([
+	"server",
+	"ssr",
+	"worker",
+	"node"
+]);
+const CLIENT_NAMES = /* @__PURE__ */ new Set(["client", "web"]);
+/** Stub unless the graph is a known server. Unknown graphs stub so *.server.ts never ships. */
+function shouldStubServerModule(environment, extra) {
+	if (extra?.ssr) return false;
+	const consumer = environment?.config?.consumer ?? environment?.consumer;
+	if (consumer === "server") return false;
+	if (consumer === "client") return true;
+	const name = environment?.name;
+	if (name && CLIENT_NAMES.has(name)) return true;
+	if (name && SERVER_NAMES.has(name)) return false;
+	const targets = extra?.target == null ? [] : [extra.target].flat();
+	if (targets.some((target) => SERVER_TARGETS.has(target))) return false;
+	if (targets.some((target) => CLIENT_TARGETS.has(target))) return true;
+	return true;
+}
+function pluginShouldStub(pluginThis, options) {
+	const ctx = pluginThis;
+	const compiler = ctx.getNativeBuildContext?.()?.compiler;
+	const env = {};
+	const name = ctx.environment?.name ?? compiler?.name ?? compiler?.options?.name;
+	if (name) env.name = name;
+	if (ctx.environment?.consumer) env.consumer = ctx.environment.consumer;
+	if (ctx.environment?.config) env.config = ctx.environment.config;
+	const extra = {};
+	if (options?.ssr) extra.ssr = true;
+	if (compiler?.options?.target) extra.target = compiler.options.target;
+	return shouldStubServerModule(env, extra);
+}
+function loadClientStub(id) {
+	const file = id.split("?")[0] ?? id;
+	const source = fs.readFileSync(file, "utf8");
+	return generateClientStub({
+		key: moduleKey(file),
+		exports: parseExportedNames(source),
+		streams: parseStreamExports(source)
+	});
+}
+var RequestBodyTooLargeError = class extends Error {};
+async function nodeToWebRequest(req, maxBytes = Number.POSITIVE_INFINITY) {
+	const url = `http://${req.headers.host ?? "localhost"}${req.url ?? "/"}`;
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(req.headers)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(key, item);
+		else headers.set(key, value);
+	}
+	const ac = new AbortController();
+	req.once("aborted", () => ac.abort());
+	const method = req.method ?? "GET";
+	const init = {
+		method,
+		headers,
+		signal: ac.signal
+	};
+	if (method === "GET" || method === "HEAD") return new Request(url, init);
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of req) {
+		const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+		size += buffer.length;
+		if (size > maxBytes) throw new RequestBodyTooLargeError();
+		chunks.push(buffer);
+	}
+	const body = Buffer.concat(chunks);
+	if (body.length > 0) init.body = body;
+	return new Request(url, init);
+}
+async function sendWebResponseFrom(req, res, response) {
+	return pipeResponse(req, res, response);
+}
+//#endregion
+//#region src/rpc/same-origin.ts
+function isSameOrigin(request) {
+	const site = request.headers.get("sec-fetch-site");
+	const origin = request.headers.get("origin");
+	if (!origin && !site) return false;
+	if (site && site !== "same-origin" && site !== "none") return false;
+	if (!origin) return site === "same-origin" || site === "none";
+	try {
+		return new URL(origin).host === (request.headers.get("host") ?? new URL(request.url).host);
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/rpc/scrub.ts
+/** Strip Effect RPC `Defect` / `Cause` payloads down to plain JSON-RPC errors. */
+const INTERNAL = {
+	code: -32603,
+	message: "Internal error"
+};
+const NDJSON_CONTENT = "application/json-rpc";
+function isRecord(value) {
+	return value !== null && typeof value === "object";
+}
+function classifyCause(error) {
+	const blob = `${String(error["message"] ?? "")}${JSON.stringify(error["data"] ?? "")}`;
+	if (/Unknown request tag/i.test(blob)) return {
+		code: -32601,
+		message: "Method not found"
+	};
+	if (/Missing key/i.test(blob) || /Expected/i.test(blob) && /\["args"\]|\[\\"args\\"\]/.test(blob)) return {
+		code: -32602,
+		message: "Invalid params"
+	};
+	return { ...INTERNAL };
+}
+function scrubError(error) {
+	if (!isRecord(error)) return { ...INTERNAL };
+	if (error["_tag"] === "Defect") return { ...INTERNAL };
+	if (error["_tag"] === "Cause") return classifyCause(error);
+	if (typeof error["code"] === "number" && typeof error["message"] === "string") return {
+		code: error["code"],
+		message: error["message"]
+	};
+	return { ...INTERNAL };
+}
+function createIdRepairState(requestIds = []) {
+	return { remaining: new Set(requestIds) };
+}
+/**
+* Scrub one JSON-RPC response object.
+* Effect encodes Defects with `id: -32603`; reclaim the originating request id from `state.remaining`.
+*/
+function scrubRpcMessage(msg, requestIds = [], state = createIdRepairState(requestIds)) {
+	if (!isRecord(msg) || !("error" in msg) || msg["error"] == null) {
+		if (isRecord(msg) && msg["chunk"] !== true && msg["id"] !== -32603 && "id" in msg) state.remaining.delete(msg["id"]);
+		return msg;
+	}
+	const error = scrubError(msg["error"]);
+	let id = msg["id"];
+	if (id === -32603) {
+		const next = state.remaining.values().next();
+		if (!next.done) {
+			id = next.value;
+			state.remaining.delete(next.value);
+		} else id = null;
+	} else if (id !== void 0 && id !== null) state.remaining.delete(id);
+	if (id === void 0) id = null;
+	return {
+		jsonrpc: "2.0",
+		id,
+		error
+	};
+}
+/**
+* Rewrite a JSON / NDJSON body so clients never see Effect `_tag` / `data` trees.
+* Accepts a single object, a JSON array, or newline-delimited frames.
+*/
+function scrubRpcJson(body, requestIds = []) {
+	const trimmed = body.replace(/^\uFEFF/, "");
+	if (!trimmed) return body;
+	const state = createIdRepairState(requestIds);
+	if (trimmed.includes("\n")) {
+		const lines = trimmed.split("\n");
+		const out = [];
+		for (const line of lines) {
+			if (line === "") continue;
+			out.push(scrubRpcLine(line, state));
+		}
+		return trimmed.endsWith("\n") ? `${out.join("\n")}\n` : out.join("\n");
+	}
+	try {
+		const parsed = JSON.parse(trimmed);
+		if (Array.isArray(parsed)) return JSON.stringify(parsed.map((msg) => scrubRpcMessage(msg, requestIds, state)));
+		return JSON.stringify(scrubRpcMessage(parsed, requestIds, state));
+	} catch {
+		return body;
+	}
+}
+function scrubRpcLine(line, state) {
+	try {
+		return JSON.stringify(scrubRpcMessage(JSON.parse(line), [], state));
+	} catch {
+		return line;
+	}
+}
+/** Collect JSON-RPC request ids from a unary object or batch array body. */
+function extractJsonRpcRequestIds(body) {
+	try {
+		let text = typeof body === "string" ? body : new TextDecoder().decode(body instanceof Uint8Array ? body : new Uint8Array(body));
+		text = text.replace(/^\uFEFF/, "").trimEnd();
+		if (text.includes("\n")) {
+			const ids = [];
+			for (const line of text.split("\n")) {
+				if (!line) continue;
+				const parsed = JSON.parse(line);
+				if (isRecord(parsed) && "id" in parsed) ids.push(parsed["id"]);
+			}
+			return ids;
+		}
+		const parsed = JSON.parse(text);
+		if (Array.isArray(parsed)) return parsed.filter(isRecord).filter((item) => "id" in item).map((item) => item["id"]);
+		if (isRecord(parsed) && "id" in parsed) return [parsed["id"]];
+	} catch {}
+	return [];
+}
+/** Ensure a body is a valid NDJSON frame (Effect's ndJsonRpc decode requires a trailing newline). */
+function ensureNdjsonBody(buf) {
+	const bytes = new Uint8Array(buf);
+	if (bytes.length > 0 && bytes[bytes.length - 1] === 10) return bytes;
+	const out = new Uint8Array(bytes.length + 1);
+	out.set(bytes);
+	out[bytes.length] = 10;
+	return out;
+}
+/**
+* TransformStream that scrubs Effect defect payloads one NDJSON line at a time,
+* so long-running stream actions stay incremental.
+*/
+function scrubNdjsonTransform(requestIds = []) {
+	const decoder = new TextDecoder();
+	const encoder = new TextEncoder();
+	const state = createIdRepairState(requestIds);
+	let pending = "";
+	return new TransformStream({
+		transform(chunk, controller) {
+			pending += decoder.decode(chunk, { stream: true });
+			let nl = pending.indexOf("\n");
+			while (nl !== -1) {
+				const line = pending.slice(0, nl);
+				pending = pending.slice(nl + 1);
+				if (line.length > 0) controller.enqueue(encoder.encode(`${scrubRpcLine(line, state)}\n`));
+				nl = pending.indexOf("\n");
+			}
+		},
+		flush(controller) {
+			pending += decoder.decode();
+			if (pending.length > 0) {
+				controller.enqueue(encoder.encode(`${scrubRpcLine(pending, state)}\n`));
+				pending = "";
+			}
+		}
+	});
+}
+//#endregion
+//#region src/rpc/server.ts
+const JSON_RPC_FORBIDDEN = {
+	jsonrpc: "2.0",
+	error: {
+		code: -32600,
+		message: "Forbidden"
+	},
+	id: null
+};
+const bundles = /* @__PURE__ */ new Map();
+const groupIds = /* @__PURE__ */ new WeakMap();
+let nextGroupId = 0;
+const serialization = RpcSerialization.layerNdJsonRpc();
+function bundleKey(group, path, transport) {
+	let id = groupIds.get(group);
+	if (id === void 0) {
+		id = nextGroupId++;
+		groupIds.set(group, id);
+	}
+	return `${id}:${path}:${transport}`;
+}
+function forbidden() {
+	return new Response(JSON.stringify(JSON_RPC_FORBIDDEN), {
+		status: 403,
+		headers: { "content-type": "application/json" }
+	});
+}
+function methodNotAllowed() {
+	return new Response("Method Not Allowed", {
+		status: 405,
+		headers: { Allow: "POST" }
+	});
+}
+function buildBundle(group, handlers, path, transport) {
+	const app = RpcServer.layerHttp({
+		group,
+		path,
+		protocol: transport === "ws" ? "websocket" : "http"
+	}).pipe(Layer.provide(handlers), Layer.provide(serialization));
+	return HttpRouter.toWebHandler(app, { disableLogger: true });
+}
+function bundleFor(group, handlers, path, transport) {
+	const key = bundleKey(group, path, transport);
+	const cached = bundles.get(key);
+	if (cached) return cached;
+	const built = buildBundle(group, handlers, path, transport);
+	bundles.set(key, built);
+	return built;
+}
+function scrubJsonResponse(response, requestIds) {
+	const contentType = response.headers.get("content-type") ?? "";
+	if (!contentType.includes("json")) return response;
+	if (response.body && (contentType.includes("application/json-rpc") || contentType.includes("ndjson"))) {
+		const headers = new Headers(response.headers);
+		headers.delete("content-length");
+		return new Response(response.body.pipeThrough(scrubNdjsonTransform(requestIds)), {
+			status: response.status,
+			statusText: response.statusText,
+			headers
+		});
+	}
+	return response;
+}
+async function scrubBufferedJson(response, requestIds) {
+	const text = await response.text();
+	const headers = new Headers(response.headers);
+	headers.delete("content-length");
+	return new Response(scrubRpcJson(text, requestIds), {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+function createActionHandler(group, handlers, options = {}) {
+	const path = options.path ?? "/__oxide/action";
+	const transport = options.transport ?? "http";
+	const sameOrigin = options.sameOrigin ?? true;
+	return async (request) => {
+		if (!matchesActionPath(new URL(request.url).pathname, path)) return new Response("Not Found", { status: 404 });
+		if (transport === "http" && request.method !== "POST") return methodNotAllowed();
+		if (sameOrigin && !isSameOrigin(request)) return forbidden();
+		const rawBody = ensureNdjsonBody(await request.arrayBuffer());
+		const requestIds = extractJsonRpcRequestIds(rawBody);
+		const headers = new Headers(request.headers);
+		headers.set("content-type", NDJSON_CONTENT);
+		const forwarded = new Request(request.url, {
+			method: request.method,
+			headers,
+			body: rawBody,
+			signal: request.signal
+		});
+		const extra = await options.createContext?.(forwarded) ?? {};
+		const { handler } = bundleFor(group, handlers, path, transport);
+		const response = await runWithRequest(forwarded, () => handler(forwarded), extra);
+		const contentType = response.headers.get("content-type") ?? "";
+		if (contentType.includes("application/json-rpc") || contentType.includes("ndjson")) return scrubJsonResponse(response, requestIds);
+		if (contentType.includes("json")) return scrubBufferedJson(response, requestIds);
+		return response;
+	};
+}
+function disposeActionHandler(group, path = ACTION_PATH, transport = "http") {
+	const key = bundleKey(group, path, transport);
+	const bundle = bundles.get(key);
+	bundles.delete(key);
+	return bundle?.dispose() ?? Promise.resolve();
+}
+//#endregion
+//#region src/rpc/ws.ts
+function parseMessage(message, maxBytes) {
+	try {
+		const raw = message.text();
+		if (new TextEncoder().encode(raw).byteLength > maxBytes) return {
+			ok: false,
+			tooLarge: true
+		};
+		return {
+			ok: true,
+			value: raw
+		};
+	} catch {
+		return { ok: false };
+	}
+}
+/**
+* Effect's socket client sends `@effect/rpc/Ping` keepalives (no id) and hangs
+* up unless the server answers `@effect/rpc/Pong`. Handle control messages here
+* so they never reach the action handler.
+*/
+function controlReply(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed && typeof parsed === "object" && parsed.method === "@effect/rpc/Ping") return JSON.stringify({
+			jsonrpc: "2.0",
+			method: "@effect/rpc/Pong"
+		});
+	} catch {}
+}
+/** Forward each complete NDJSON line as its own WS message (keeps streams incremental). */
+async function sendNdjsonFrames(peer, response, signal) {
+	if (signal.aborted) {
+		await response.body?.cancel();
+		return;
+	}
+	if (!response.body) {
+		const text = await response.text();
+		if (text && !signal.aborted) peer.send(text);
+		return;
+	}
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let pending = "";
+	const onAbort = () => {
+		reader.cancel();
+	};
+	signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		while (!signal.aborted) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			pending += decoder.decode(value, { stream: true });
+			let nl = pending.indexOf("\n");
+			while (nl !== -1) {
+				const line = pending.slice(0, nl);
+				pending = pending.slice(nl + 1);
+				if (line.length > 0 && !signal.aborted) peer.send(`${line}\n`);
+				nl = pending.indexOf("\n");
+			}
+		}
+		if (!signal.aborted) {
+			pending += decoder.decode();
+			if (pending.length > 0) peer.send(pending.endsWith("\n") ? pending : `${pending}\n`);
+		}
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+function createWsHooks(group, handlers, options = {}) {
+	const path = options.path ?? "/__oxide/action";
+	const maxBytes = options.maxMessageSize ?? 1048576;
+	const sameOrigin = options.sameOrigin ?? true;
+	const baseOptions = {
+		path,
+		transport: "http",
+		sameOrigin
+	};
+	return {
+		upgrade(req) {
+			let pathname;
+			try {
+				pathname = new URL(req.url).pathname;
+			} catch {
+				return new Response("Bad Request", { status: 400 });
+			}
+			if (!matchesActionPath(pathname, path)) return new Response("Not Found", { status: 404 });
+			if (sameOrigin && !isSameOrigin(req)) return new Response("Forbidden", { status: 403 });
+		},
+		async message(peer, message) {
+			const parsed = parseMessage(message, maxBytes);
+			if (!parsed.ok) {
+				peer.send(JSON.stringify({
+					jsonrpc: "2.0",
+					error: {
+						code: -32600,
+						message: parsed.tooLarge ? "Payload too large" : "Parse error"
+					},
+					id: null
+				}));
+				return;
+			}
+			const pingReply = controlReply(parsed.value);
+			if (pingReply !== void 0) {
+				peer.send(pingReply);
+				return;
+			}
+			const abort = new AbortController();
+			peer.onClose?.(() => abort.abort());
+			const host = peer.request?.headers.get("host") ?? "localhost";
+			const headers = new Headers(peer.request?.headers);
+			headers.set("content-type", NDJSON_CONTENT);
+			const peerCtx = await options.createContext?.(peer) ?? peer.context;
+			await sendNdjsonFrames(peer, await createActionHandler(group, handlers, {
+				...baseOptions,
+				createContext: (req) => ({
+					...peerCtx,
+					req
+				})
+			})(new Request(`http://${host}${path}`, {
+				method: "POST",
+				headers,
+				body: parsed.value,
+				signal: abort.signal
+			})), abort.signal);
+		}
+	};
+}
+//#endregion
+export { pluginShouldStub as A, isServerFileId as C, nodeToWebRequest as D, moduleKey as E, sendWebResponseFrom as M, parseExportedNames as O, generateWorkerWrapper as S, matchesActionPath as T, actions_exports as _, extractJsonRpcRequestIds as a, generateClientModule as b, scrubRpcMessage as c, RESOLVED_VIRTUAL_CLIENT_ID as d, RESOLVED_VIRTUAL_WORKER_ID as f, VIRTUAL_WORKER_ID as g, VIRTUAL_CLIENT_ID as h, ensureNdjsonBody as i, scanServerFiles as j, parseStreamExports as k, ACTION_PATH as l, VIRTUAL_ACTIONS_ID as m, createActionHandler as n, scrubNdjsonTransform as o, RequestBodyTooLargeError as p, disposeActionHandler as r, scrubRpcJson as s, createWsHooks as t, RESOLVED_VIRTUAL_ACTIONS_ID as u, generateActionsClientModule as v, loadClientStub as w, generateClientStub as x, generateActionsModule as y };