oxidejs 0.2.3 → 0.3.0

package/README.md

@@ -12,6 +12,8 @@ dist/
 
 v1 targets **Vite** and **Rsbuild** via unplugin. Other bundlers are out of scope for now.
 
+The `oxidejs` entry exports runtime helpers (`action`, `useRequest`, …). The bundler plugin lives at `oxidejs/vite` or `oxidejs/rsbuild` — keep those separate so `*.server.ts` can import `oxidejs` under `preset: "celld"` without pulling Node build tooling into the worker graph.
+
 ## Vite
 
 ```ts
@@ -47,7 +49,7 @@ oxide({
 
 ## Server actions
 
-Install `tacho` if you use actions. Files named `*.server.ts`, `*.server.tsx`, `*.server.js`, or `*.server.jsx` are server-only. A client import is replaced with a tacho stub that POSTs `/__oxide/action`. The original module never enters the client graph. **Only exports wrapped in `action()` become remote actions** — any other export stays server-local and is not callable over the wire. Server and Vite SSR (`import.meta.env.SSR === true`) keep the real functions. Methods are `<file>.<fn>` (`test.ping`). Call `useRequest()` inside an action for the inbound `Request`. `useCtx()` is tacho `ctx` (`{ req }` plus anything middleware or `createContext` added). On `preset: "celld"`, `useEnv()` and `useFetchCtx()` are the Worker `env` and `ctx` from `fetch(request, env, ctx)` — same values as `useCtx().env` / `useCtx().fetchCtx`. Return `undefined` from `src/server.ts` to fall through to static files. No server action files → the bundle does not import tacho.
+Files named `*.server.ts`, `*.server.tsx`, `*.server.js`, or `*.server.jsx` are server-only. A client import is replaced with an RPC stub that POSTs `/__oxide/action`. The original module never enters the client graph. **Only exports wrapped in `action()` become remote actions** — any other export stays server-local and is not callable over the wire. Server and Vite SSR (`import.meta.env.SSR === true`) keep the real functions. Methods are `<file>.<fn>` (`test.ping`). Call `useRequest()` inside an action for the inbound `Request`. `useCtx()` is the request context (`{ req }` plus anything middleware or `createContext` added). On `preset: "celld"`, `useEnv()` and `useFetchCtx()` are the Worker `env` and `ctx` from `fetch(request, env, ctx)` — same values as `useCtx().env` / `useCtx().fetchCtx`. Return `undefined` from `src/server.ts` to fall through to static files. No server action files → the bundle does not import `oxidejs/rpc`.
 
 ```ts
 // src/test.server.ts
@@ -76,7 +78,7 @@ export default {
 };
 ```
 
-`action()` is runtime identity — it marks the export and adds a typed transport-only `{ signal }` argument. Wrap `async function*` in it to stream over tacho SSE. Inside server code, always read the non-optional signal from `useRequest().signal`:
+`action()` is runtime identity — it marks the export and adds a typed transport-only `{ signal }` argument. Wrap `async function*` in it to stream over Effect RPC as newline-delimited JSON-RPC (`application/json-rpc` frames, not SSE). On the client, await the call to get the async generator. Inside server code, always read the non-optional signal from `useRequest().signal`:
 
 ```ts
 // src/test.server.ts
@@ -91,7 +93,9 @@ export const ticks = action(async function* (n: number) {
 import { ticks } from "./test.server";
 
 const ac = new AbortController();
-const stream = await ticks(10, { signal: ac.signal });
+for await (const value of await ticks(10, { signal: ac.signal })) {
+  console.log(value);
+}
 ac.abort();
 ```
 
@@ -174,7 +178,7 @@ The generated `__asset` function uses `path.join` — not `path.resolve` — so
 
 ### Server actions (`*.server.{ts,tsx,js,jsx}`)
 
-- Server action code is **never bundled into the client**. Client imports are replaced with tacho stubs that POST the action endpoint (default `/__oxide/action`). The original source stays server-only.
+- Server action code is **never bundled into the client**. Client imports are replaced with RPC stubs that POST the action endpoint (default `/__oxide/action`). The original source stays server-only.
 - Only `action()`-wrapped exports are exposed as RPC; other exports stay server-local.
 - The endpoint is POST-only. Non-POST requests return `405`.
 - Method dispatch uses `Object.hasOwn`, blocking `__proto__` / `constructor` walks.

package/dist/actions-DE6p5Cyp.mjs

@@ -0,0 +1,504 @@
+import fs from "node:fs";
+import path from "node:path";
+//#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) => (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
+export { scanServerFiles as C, pluginShouldStub as S, matchesActionPath as _, RequestBodyTooLargeError as a, parseExportedNames as b, VIRTUAL_WORKER_ID as c, generateActionsModule as d, generateClientModule as f, loadClientStub as g, isServerFileId as h, RESOLVED_VIRTUAL_WORKER_ID as i, actions_exports as l, generateWorkerWrapper as m, RESOLVED_VIRTUAL_ACTIONS_ID as n, VIRTUAL_ACTIONS_ID as o, generateClientStub as p, RESOLVED_VIRTUAL_CLIENT_ID as r, VIRTUAL_CLIENT_ID as s, ACTION_PATH as t, generateActionsClientModule as u, moduleKey as v, sendWebResponseFrom as w, parseStreamExports as x, nodeToWebRequest as y };