oxidejs 0.0.1 → 0.1.1

package/README.md

@@ -0,0 +1,135 @@
+# oxidejs
+
+One build command → a deployable tree:
+
+```
+dist/
+├── client/           # only if index.html exists
+└── server.js         # ESM server bundle
+```
+
+`preset: "celld"` also writes `dist/wrangler.jsonc` with `main: "./server.js"`.
+
+v1 targets **Vite** and **Rsbuild** via unplugin. Other bundlers are out of scope for now.
+
+## Vite
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import oxide from "oxidejs/vite";
+
+export default defineConfig({
+  plugins: [oxide()],
+});
+```
+
+```json
+// tsconfig.json
+{ "extends": "oxidejs/tsconfig" }
+```
+
+```bash
+vite build
+node dist/server.js
+```
+
+Default preset is `"fetch"`. No `index.html` → only `dist/server.js`. With `index.html` → client to `dist/client/`, then `/_action` (if you have `*.server.ts`) → `src/server.ts` (`undefined` continues) → static file → `index.html` for navigations. `public/` is copied next to the client. Hashed assets get `Cache-Control: immutable`. No `wrangler.jsonc`.
+
+```ts
+oxide({
+  preset: "celld",
+  wrangler: { name: "my-app", compatibility_date: "2026-01-01" },
+});
+```
+
+`"celld"` writes `dist/wrangler.jsonc` for celld, a self-hosted alternative to Cloudflare Workers, and skips asset serving (`ASSETS` does that).
+
+## Server actions
+
+Install `tacho` if you use actions. Files named `*.server.ts` / `*.server.js` are server-only. A client import is replaced with a tacho stub that POSTs `/_action`. The original module never enters the client graph. 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.ts` → the bundle does not import tacho.
+
+```ts
+// src/test.server.ts
+import { useRequest } from "oxidejs";
+
+export async function who() {
+  return useRequest().headers.get("x-user");
+}
+
+export async function ping() {
+  return "pong";
+}
+
+// src/client.ts
+import { ping } from "./test.server";
+console.log(await ping()); // "pong"
+
+// src/server.ts
+export default {
+  fetch(request: Request) {
+    if (new URL(request.url).pathname === "/api/ok") return new Response("ok");
+  },
+};
+```
+
+`async function*` exports stream over tacho SSE. `oxidejs/tsconfig` makes `await ticks()` typecheck. Pass `{ signal }` last on any action to abort the fetch. Types come from the real `*.server.ts`, so declare the last argument there:
+
+```ts
+// src/test.server.ts
+import type { ActionOptions } from "oxidejs";
+
+export async function* ticks(n: number, _opts?: ActionOptions) {
+  for (let i = 0; i < n; i++) yield i;
+}
+
+// src/client.ts
+import { ticks } from "./test.server";
+
+const ac = new AbortController();
+const stream = await ticks(10, { signal: ac.signal });
+ac.abort();
+```
+
+`vite dev` and `rsbuild dev` serve `/_action` via middleware. `oxide({ actions: "ws" })` uses a WebSocket instead (needs `crossws`; not with `preset: "celld"`). `actionHeaders` are static headers on the shared HTTP client.
+
+## Rsbuild
+
+```ts
+// rsbuild.config.ts
+import { defineConfig } from "@rsbuild/core";
+import oxide from "oxidejs/rsbuild";
+
+export default defineConfig({
+  plugins: [oxide()],
+});
+```
+
+Same factory as Vite: client stubs, `/_action`, and `dist/server.js`.
+
+## Options
+
+| Option                         | Default                  | Notes                                  |
+| ------------------------------ | ------------------------ | -------------------------------------- |
+| `preset`                       | `"fetch"`                | `"fetch"` or `"celld"`                 |
+| `workerEntry`                  | `src/server.ts`          | Relative to project root               |
+| `outDir`                       | `dist`                   | Output root                            |
+| `clientDir`                    | `client`                 | Must stay inside `outDir`              |
+| `wrangler.name`                | required if `emitConfig` |                                        |
+| `wrangler.compatibility_date`  | required if `emitConfig` |                                        |
+| `wrangler.compatibility_flags` | —                        | optional                               |
+| `wrangler.durable_objects`     | —                        | optional                               |
+| `wrangler.migrations`          | —                        | optional                               |
+| `wrangler.services`            | —                        | optional                               |
+| `wrangler.vars`                | —                        | optional                               |
+| `emitConfig`                   | `true` on `celld`        | Set `false` to skip `wrangler.jsonc`   |
+| `actions`                      | `"http"`                 | `"ws"` needs `crossws`; not with celld |
+| `actionHeaders`                | —                        | Static headers on the HTTP client      |
+
+`main` is always `./server.js`. `assets` is added only when `index.html` exists. Unknown wrangler keys fail at build time.
+
+## Non-goals
+
+- No `wrangler dev` / workerd emulation
+- No automatic `celld deploy`
+- No Node-builtin polyfills — Vite `ssr.noExternal: true` is a hard-fail for stray Node imports

package/client.d.ts

@@ -0,0 +1,10 @@
+interface AsyncGenerator<T = unknown, TReturn = any, TNext = any> extends AsyncIteratorObject<
+  T,
+  TReturn,
+  TNext
+> {
+  then<TResult1 = AsyncIterable<T>, TResult2 = never>(
+    onfulfilled?: ((value: AsyncIterable<T>) => TResult1 | PromiseLike<TResult1>) | null,
+    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
+  ): Promise<TResult1 | TResult2>;
+}

package/dist/index.d.mts

@@ -0,0 +1,33 @@
+import { a as OxidejsWranglerOptions, i as OxidejsPreset, n as OxidejsActionTransport, o as ResolvedOptions, r as OxidejsOptions, t as OxidejsActionHeaders } from "./types-CFWyYfds.mjs";
+import { UnpluginFactory } from "unplugin";
+//#region src/context.d.ts
+type ExecutionContext = {
+  waitUntil?(promise: Promise<unknown>): void;
+  passThroughOnException?(): void;
+};
+/** Tacho procedure `ctx`. Starts as `{ req }` plus Worker extras. Middleware can add fields. */
+type ActionContext = {
+  req: Request;
+  env?: unknown;
+  fetchCtx?: ExecutionContext;
+  [key: string]: unknown;
+};
+/** Current tacho `ctx`. Throws outside `*.server.ts` running over `/_action`. */
+declare function useCtx<C extends ActionContext = ActionContext>(): C;
+/** Current action `Request`. Throws outside `*.server.ts` running over `/_action`. */
+declare function useRequest(): Request;
+/** Worker `env` from `fetch(request, env, ctx)`. `undefined` on the Node fetch preset. */
+declare function useEnv<E = unknown>(): E | undefined;
+/** Worker `ctx` from `fetch(request, env, ctx)` (`waitUntil`). Not tacho `ctx`. `undefined` on Node. */
+declare function useFetchCtx(): ExecutionContext | undefined;
+/** Optional last argument on a `*.server.ts` export so the client can pass `{ signal }`. */
+type ActionOptions = {
+  signal?: AbortSignal;
+};
+//#endregion
+//#region src/index.d.ts
+declare const unpluginFactory: UnpluginFactory<OxidejsOptions | undefined>;
+declare const oxidejs: import("unplugin").UnpluginInstance<OxidejsOptions | undefined, boolean>;
+declare const vite: (options?: OxidejsOptions | undefined) => import("vite").Plugin<any> | import("vite").Plugin<any>[];
+//#endregion
+export { type ActionContext, type ActionOptions, type ExecutionContext, type OxidejsActionHeaders, type OxidejsActionTransport, type OxidejsOptions, type OxidejsPreset, type OxidejsWranglerOptions, type ResolvedOptions, oxidejs as default, oxidejs, unpluginFactory, useCtx, useEnv, useFetchCtx, useRequest, vite };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { a as useEnv, i as useCtx, n as unpluginFactory, o as useFetchCtx, r as vite, s as useRequest, t as oxidejs } from "./src-B03PPyx9.mjs";
+export { oxidejs as default, oxidejs, unpluginFactory, useCtx, useEnv, useFetchCtx, useRequest, vite };

package/dist/rsbuild.d.mts

@@ -0,0 +1,5 @@
+import { r as OxidejsOptions } from "./types-CFWyYfds.mjs";
+//#region src/rsbuild.d.ts
+declare const _default: (options?: OxidejsOptions | undefined) => any;
+//#endregion
+export { type OxidejsOptions, _default as default };

package/dist/rsbuild.mjs

@@ -0,0 +1,5 @@
+import { t as oxidejs } from "./src-B03PPyx9.mjs";
+//#region src/rsbuild.ts
+var rsbuild_default = oxidejs.rsbuild;
+//#endregion
+export { rsbuild_default as default };

package/dist/src-B03PPyx9.mjs

@@ -0,0 +1,760 @@
+import { createUnplugin } from "unplugin";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import fs from "node:fs";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/actions.ts
+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 = "/_action";
+const IGNORE_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	"dist",
+	".git",
+	".wrangler"
+]);
+const EXPORT_RE = /^\s*export\s+(?:async\s+)?function\s*\*?\s+([A-Za-z_$][\w$]*)|^\s*export\s+const\s+([A-Za-z_$][\w$]*)\s*=/gm;
+function isServerFileId(id) {
+	const file = id.split("?")[0]?.replace(/\\/g, "/") ?? "";
+	return file.endsWith(".server.ts") || file.endsWith(".server.js");
+}
+function moduleKey(absFile) {
+	return path.basename(absFile).replace(/\.server\.(ts|js)$/i, "");
+}
+function parseExportedNames(source) {
+	const names = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(EXPORT_RE)) {
+		const name = match[1] ?? match[2];
+		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);
+		modules.push({
+			abs,
+			key,
+			exports: parseExportedNames(fs.readFileSync(abs, "utf8"))
+		});
+	}
+	return modules;
+}
+function generateClientModule(transport = "http", headers) {
+	if (transport === "ws") return `import { createClient } from "tacho/client/ws";
+const __proto = typeof location === "undefined" ? "ws:" : location.protocol === "https:" ? "wss:" : "ws:";
+const __host = typeof location === "undefined" ? "localhost" : location.host;
+export const client = createClient({ url: __proto + "//" + __host + ${JSON.stringify(ACTION_PATH)} });
+`;
+	const opts = { url: ACTION_PATH };
+	if (headers) opts.headers = headers;
+	return `import { createClient } from "tacho/client/http";
+export const client = createClient(${JSON.stringify(opts)});
+`;
+}
+function generateClientStub(mod) {
+	const lines = [`import { client } from ${JSON.stringify(VIRTUAL_CLIENT_ID)};`];
+	for (const name of mod.exports) lines.push(`export const ${name} = (...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
+    ? client[${JSON.stringify(mod.key)}][${JSON.stringify(name)}](args.slice(0, -1), opts)
+    : client[${JSON.stringify(mod.key)}][${JSON.stringify(name)}](args);
+};`);
+	return `${lines.join("\n")}\n`;
+}
+function generateActionsModule(modules, opts) {
+	const lines = [
+		`import { AsyncLocalStorage } from "node:async_hooks";`,
+		`import { tacho } from "tacho";`,
+		`const __als = globalThis.__oxidejsRequest ??= new AsyncLocalStorage();`
+	];
+	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)};`);
+		return {
+			alias,
+			mod
+		};
+	});
+	lines.push(`const rpc = tacho();`);
+	lines.push(`const actions = rpc({`);
+	for (const { alias, mod } of aliases) {
+		lines.push(`  ${JSON.stringify(mod.key)}: {`);
+		for (const name of mod.exports) lines.push(`    ${JSON.stringify(name)}: rpc.run(({ input, ctx }) => __als.run(ctx, () => {
+      const out = ${alias}[${JSON.stringify(name)}].apply(null, Array.isArray(input) ? input : []);
+      if (!out || typeof out !== "object" || typeof out.next !== "function") return out;
+      return {
+        next: (v) => __als.run(ctx, () => out.next(v)),
+        return: (v) => __als.run(ctx, () => out.return(v)),
+        throw: (e) => __als.run(ctx, () => out.throw(e)),
+        [Symbol.asyncIterator]() { return this; },
+      };
+    })),`);
+		lines.push(`  },`);
+	}
+	lines.push(`});`);
+	lines.push(`export default actions;`);
+	lines.push(`export { 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 serveAssets = preset === "fetch" && (opts.hasClient === true || opts.hasPublic === true);
+	const hasActions = opts.hasActions !== false;
+	const ws = hasActions && opts.actions === "ws";
+	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;
+  return file.slice(1);
+}
+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;
+    return new Response(body, { headers });
+  } catch {
+    return;
+  }
+}
+` : "";
+	const afterAction = serveAssets ? `if (typeof user.fetch === "function") {
+      const hit = await user.fetch(request, env, ctx);
+      if (hit) return hit;
+    }
+    return (await __asset(request)) ?? (__nav(request) ? await __asset(request, true) : undefined) ?? new Response("Not Found", { status: 404 });` : `return typeof user.fetch === "function"
+      ? user.fetch(request, env, ctx)
+      : new Response("Not Found", { status: 404 });`;
+	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 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 = [];
+    if (method !== "GET" && method !== "HEAD") for await (const chunk of req) 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 (req.url?.split("?")[0] === ${JSON.stringify(ACTION_PATH)}) ws.handleUpgrade(req, socket, head);
+    });
+  });` : ""}
+  server.listen(port, () => console.log(\`oxidejs listening on \${port}\`));
+}
+` : "";
+	const actionImports = hasActions ? ws ? `import { handle as handleWs } from "tacho/transport/ws";
+import actions from ${JSON.stringify(VIRTUAL_ACTIONS_ID)};
+const __ws = handleWs(actions, { path: ${JSON.stringify(ACTION_PATH)} });
+` : `import { handle } from "tacho/transport/fetch";
+import actions from ${JSON.stringify(VIRTUAL_ACTIONS_ID)};
+const __fetch = Symbol.for("oxidejs.fetch");
+const __rpc = handle(actions, { path: ${JSON.stringify(ACTION_PATH)}, createContext: (req) => req[__fetch] ?? {} });
+` : "";
+	const actionGate = hasActions && !ws ? `if (new URL(request.url).pathname === ${JSON.stringify(ACTION_PATH)}) {
+      request[__fetch] = { env, fetchCtx: ctx };
+      return __rpc(request);
+    }
+    ` : "";
+	return `export * from ${JSON.stringify(userWorkerAbs)};
+import user from ${JSON.stringify(userWorkerAbs)};
+${actionImports}${assetBlock}const app = {
+  ...user,
+  async fetch(request, env, ctx) {
+    ${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;
+	return generateClientStub({
+		key: moduleKey(file),
+		exports: parseExportedNames(fs.readFileSync(file, "utf8"))
+	});
+}
+async function nodeToWebRequest(req) {
+	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 = [];
+	for await (const chunk of req) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+	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/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 resolveOptions(raw, root, config) {
+	const preset = raw?.preset ?? "fetch";
+	if (preset !== "fetch" && preset !== "celld") throw new Error(`oxidejs: unknown preset "${String(preset)}"`);
+	const actions = raw?.actions ?? "http";
+	if (actions !== "http" && actions !== "ws") throw new Error(`oxidejs: unknown actions transport "${String(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,
+		actionHeaders: raw?.actionHeaders
+	};
+}
+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,
+		...wrangler.compatibility_flags ? { compatibility_flags: wrangler.compatibility_flags } : {},
+		...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
+function applyViteEnvironments(config, opts) {
+	config.builder ??= {};
+	config.environments ??= {};
+	const celld = opts.preset === "celld";
+	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: true },
+		ssr: celld ? {
+			target: "webworker",
+			noExternal: true,
+			external: [/^cloudflare:/]
+		} : { noExternal: true }
+	};
+	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/context.ts
+const ALS_KEY = "__oxidejsRequest";
+function als() {
+	const g = globalThis;
+	return g[ALS_KEY] ??= new AsyncLocalStorage();
+}
+function store() {
+	const current = als().getStore();
+	if (!current) throw new Error("oxidejs: useRequest() called outside an action");
+	return current;
+}
+/** Current tacho `ctx`. Throws outside `*.server.ts` running over `/_action`. */
+function useCtx() {
+	return store();
+}
+/** Current action `Request`. Throws outside `*.server.ts` running over `/_action`. */
+function useRequest() {
+	return store().req;
+}
+/** Worker `env` from `fetch(request, env, ctx)`. `undefined` on the Node fetch preset. */
+function useEnv() {
+	return store().env;
+}
+/** Worker `ctx` from `fetch(request, env, ctx)` (`waitUntil`). Not tacho `ctx`. `undefined` on Node. */
+function useFetchCtx() {
+	return store().fetchCtx;
+}
+//#endregion
+//#region src/index.ts
+function actionMiddleware(loadRouter) {
+	return (req, res, next) => {
+		if ((req.url ?? "").split("?")[0] !== "/_action") {
+			next();
+			return;
+		}
+		(async () => {
+			const { handle } = await import(
+				/* @vite-ignore */
+				"tacho/transport/fetch"
+);
+			await sendWebResponseFrom(req, res, await handle(await loadRouter(), { path: ACTION_PATH })(await nodeToWebRequest(req)));
+		})().catch(next);
+	};
+}
+function attachActionUpgrade(httpServer, loadRouter) {
+	if (!httpServer) return;
+	Promise.all([import(
+		/* @vite-ignore */
+		"tacho/transport/ws"
+), import(
+		/* @vite-ignore */
+		"crossws/adapters/node"
+)]).then(([{ handle }, { default: crossws }]) => {
+		httpServer.on("upgrade", (req, socket, head) => {
+			if ((req.url ?? "").split("?")[0] !== "/_action") return;
+			loadRouter().then((router) => crossws({ hooks: handle(router, { path: ACTION_PATH }) }).handleUpgrade(req, socket, head)).catch(() => {
+				socket.destroy();
+			});
+		});
+	});
+}
+function previewMiddleware(file) {
+	return (req, res, next) => {
+		(async () => {
+			await sendWebResponseFrom(req, res, await (await import(
+				/* @vite-ignore */
+				pathToFileURL(file).href
+)).default.fetch(await nodeToWebRequest(req)));
+		})().catch(next);
+	};
+}
+function loadActions(root) {
+	const code = generateActionsModule(scanServerFiles(root), { bust: true });
+	return import(
+		/* @vite-ignore */
+		`data:text/javascript,${encodeURIComponent(code)}`
+);
+}
+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) return generateClientModule(resolved?.actions ?? options?.actions ?? "http", resolved?.actionHeaders ?? options?.actionHeaders);
+			if (id === RESOLVED_VIRTUAL_ACTIONS_ID || id === RESOLVED_VIRTUAL_WORKER_ID) {
+				if (pluginShouldStub(this, extra)) throw new Error(`oxidejs: ${id === RESOLVED_VIRTUAL_ACTIONS_ID ? VIRTUAL_ACTIONS_ID : VIRTUAL_WORKER_ID} is server-only`);
+			}
+			if (id === RESOLVED_VIRTUAL_ACTIONS_ID) {
+				const modules = scanServerFiles(resolved?.root ?? process.cwd());
+				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
+				});
+			}
+			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)) return;
+			return generateClientStub({
+				key: moduleKey(id.split("?")[0] ?? id),
+				exports: parseExportedNames(code)
+			});
+		},
+		vite: {
+			config(config) {
+				resolved = resolveOptions(options, typeof config.root === "string" ? config.root : process.cwd(), config);
+				applyViteEnvironments(config, resolved);
+			},
+			configureServer(server) {
+				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);
+					}
+				};
+				server.watcher.on("all", (_event, file) => {
+					if (isServerFileId(file)) invalidateActions();
+				});
+				const loadRouter = async () => {
+					return (await server.ssrLoadModule(VIRTUAL_ACTIONS_ID)).default;
+				};
+				if (resolved?.actions === "ws") attachActionUpgrade(server.httpServer, loadRouter);
+				else server.middlewares.use(actionMiddleware(loadRouter));
+			},
+			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 (await loadActions(resolved?.root ?? process.cwd())).default;
+				};
+				if (resolved?.actions === "ws") attachActionUpgrade(server.httpServer, loadRouter);
+				else server.middlewares.use(actionMiddleware(loadRouter));
+			});
+			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 { useEnv as a, useCtx as i, unpluginFactory as n, useFetchCtx as o, vite as r, useRequest as s, oxidejs as t };

package/dist/types-CFWyYfds.d.mts

@@ -0,0 +1,52 @@
+//#region src/types.d.ts
+type OxidejsPreset = "fetch" | "celld";
+interface OxidejsWranglerOptions {
+  name: string;
+  compatibility_date: string;
+  compatibility_flags?: string[];
+  durable_objects?: Record<string, unknown>;
+  migrations?: unknown[];
+  services?: unknown[];
+  vars?: Record<string, unknown>;
+}
+type OxidejsActionTransport = "http" | "ws";
+/** Static headers inlined into the shared action client. Functions cannot ship to the browser. */
+type OxidejsActionHeaders = Record<string, string> | [string, string][];
+interface OxidejsOptions {
+  /** "fetch" (default) skips wrangler.jsonc and serves client assets. "celld" emits wrangler.jsonc. */
+  preset?: OxidejsPreset;
+  /** Path to server entry, relative to project root. Default: "src/server.ts" */
+  workerEntry?: string;
+  /** Output root. Default: "dist" */
+  outDir?: string;
+  /** Client subdirectory under outDir. Default: "client" */
+  clientDir?: string;
+  /** Wrangler config fields to merge into the generated wrangler.jsonc. */
+  wrangler?: OxidejsWranglerOptions;
+  /** Skip config emission. Defaults to false for celld, true for fetch. */
+  emitConfig?: boolean;
+  /** Transport for `*.server.ts` stubs. Default: "http". */
+  actions?: OxidejsActionTransport;
+  /** Extra headers on the shared HTTP action client. Ignored when `actions` is "ws". */
+  actionHeaders?: OxidejsActionHeaders;
+}
+interface ResolvedOptions {
+  root: string;
+  preset: OxidejsPreset;
+  workerEntry: string;
+  workerEntryAbs: string;
+  /** Absolute output root. */
+  outDir: string;
+  /** Relative segment only. */
+  clientDir: string;
+  wrangler: OxidejsWranglerOptions | undefined;
+  emitConfig: boolean;
+  /** False when there is no index.html — server-only, no client env or assets. */
+  hasClient: boolean;
+  /** True when `<root>/public` exists. Copied next to client assets on fetch. */
+  hasPublic: boolean;
+  actions: OxidejsActionTransport;
+  actionHeaders: OxidejsActionHeaders | undefined;
+}
+//#endregion
+export { OxidejsWranglerOptions as a, OxidejsPreset as i, OxidejsActionTransport as n, ResolvedOptions as o, OxidejsOptions as r, OxidejsActionHeaders as t };

package/dist/vite.d.mts

@@ -0,0 +1,5 @@
+import { r as OxidejsOptions } from "./types-CFWyYfds.mjs";
+//#region src/vite.d.ts
+declare const _default: (options?: OxidejsOptions | undefined) => import("vite").Plugin<any> | import("vite").Plugin<any>[];
+//#endregion
+export { type OxidejsOptions, _default as default };

package/dist/vite.mjs

@@ -0,0 +1,5 @@
+import { t as oxidejs } from "./src-B03PPyx9.mjs";
+//#region src/vite.ts
+var vite_default = oxidejs.vite;
+//#endregion
+export { vite_default as default };

package/package.json

@@ -1,12 +1,87 @@
 {
   "name": "oxidejs",
-  "version": "0.0.1",
-  "module": "index.ts",
+  "version": "0.1.1",
+  "description": "Vite/Rsbuild plugin. One build → dist/server.js + optional client. Server actions via *.server.ts.",
+  "keywords": [
+    "cloudflare",
+    "rsbuild",
+    "server-actions",
+    "typescript",
+    "unplugin",
+    "vite"
+  ],
+  "homepage": "https://github.com/ryuzcorp/oxide/tree/main/packages/oxidejs#readme",
+  "bugs": "https://github.com/ryuzcorp/oxide/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ryuzcorp/oxide.git",
+    "directory": "packages/oxidejs"
+  },
+  "files": [
+    "dist",
+    "virtual.d.ts",
+    "client.d.ts",
+    "tsconfig.app.json"
+  ],
   "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.mts",
+      "import": "./dist/vite.mjs"
+    },
+    "./rsbuild": {
+      "types": "./dist/rsbuild.d.mts",
+      "import": "./dist/rsbuild.mjs"
+    },
+    "./virtual": {
+      "types": "./virtual.d.ts"
+    },
+    "./client": {
+      "types": "./client.d.ts"
+    },
+    "./tsconfig": "./tsconfig.app.json"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint",
+    "fmt": "oxfmt --write .",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "unplugin": "^3.3.0"
+  },
   "devDependencies": {
-    "@types/bun": "latest"
+    "tacho": "^0.4.1"
   },
   "peerDependencies": {
-    "typescript": "^5"
+    "@rsbuild/core": "*",
+    "crossws": "*",
+    "tacho": "*",
+    "vite": "*"
+  },
+  "peerDependenciesMeta": {
+    "@rsbuild/core": {
+      "optional": true
+    },
+    "crossws": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    },
+    "tacho": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=20"
   }
 }

package/tsconfig.app.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "moduleDetection": "force",
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "allowJs": true,
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "noImplicitOverride": true,
+    "jsx": "preserve",
+    "types": ["vite/client", "oxidejs/client", "oxidejs/virtual"]
+  }
+}

package/virtual.d.ts

@@ -0,0 +1,10 @@
+declare module "virtual:oxide/actions" {
+  // Generated tacho router. Typed loosely so apps can pass it to handle().
+  const actions: Record<string, never>;
+  export default actions;
+  export { actions };
+}
+
+declare module "virtual:oxide/client" {
+  export const client: Record<string, Record<string, (...args: unknown[]) => Promise<unknown>>>;
+}

package/bun.lock

@@ -1,26 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "oxide-placeholder",
-      "devDependencies": {
-        "@types/bun": "latest",
-      },
-      "peerDependencies": {
-        "typescript": "^5",
-      },
-    },
-  },
-  "packages": {
-    "@types/bun": ["@types/bun@1.3.8", "", { "dependencies": { "bun-types": "1.3.8" } }, "sha512-3LvWJ2q5GerAXYxO2mffLTqOzEu5qnhEAlh48Vnu8WQfnmSwbgagjGZV6BoHKJztENYEDn6QmVd949W4uESRJA=="],
-
-    "@types/node": ["@types/node@25.1.0", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-t7frlewr6+cbx+9Ohpl0NOTKXZNV9xHRmNOvql47BFJKcEG1CxtxlPEEe+gR9uhVWM4DwhnvTF110mIL4yP9RA=="],
-
-    "bun-types": ["bun-types@1.3.8", "", { "dependencies": { "@types/node": "*" } }, "sha512-fL99nxdOWvV4LqjmC+8Q9kW3M4QTtTR1eePs94v5ctGqU8OeceWrSUaRw3JYb7tU3FkMIAjkueehrHPPPGKi5Q=="],
-
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
-
-    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
-  }
-}

package/index.ts

@@ -1 +0,0 @@
-console.log("Hello via Bun!");

package/readme.md

@@ -1 +0,0 @@
-Placeholder for https://github.com/oxidejs/oxide release

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-  "compilerOptions": {
-    // Environment setup & latest features
-    "lib": ["ESNext"],
-    "target": "ESNext",
-    "module": "Preserve",
-    "moduleDetection": "force",
-    "jsx": "react-jsx",
-    "allowJs": true,
-
-    // Bundler mode
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "noEmit": true,
-
-    // Best practices
-    "strict": true,
-    "skipLibCheck": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-
-    // Some stricter flags (disabled by default)
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noPropertyAccessFromIndexSignature": false
-  }
-}