oxidejs 0.2.4 → 0.3.0

package/dist/rpc-DYFEdah8.mjs

@@ -0,0 +1,382 @@
+import { _ as matchesActionPath, t as ACTION_PATH } from "./actions-DE6p5Cyp.mjs";
+import { t as runWithRequest } from "./context-zrTZyYpF.mjs";
+import { Layer } from "effect";
+import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+import { HttpRouter } from "effect/unstable/http";
+//#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 };
+	}
+}
+/** 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) {
+			if (!matchesActionPath(new URL(req.url).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 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 { extractJsonRpcRequestIds as a, scrubRpcMessage as c, ensureNdjsonBody as i, createActionHandler as n, scrubNdjsonTransform as o, disposeActionHandler as r, scrubRpcJson as s, createWsHooks as t };

package/dist/rpc.d.mts

@@ -0,0 +1,75 @@
+import { t as ActionContext } from "./context-C1UFQ0Zc.mjs";
+import { RpcClientOptions, createClient } from "./rpc/client.mjs";
+import { Layer, Stream } from "effect";
+import { Rpc, RpcGroup } from "effect/unstable/rpc";
+//#region src/rpc/server.d.ts
+type ActionHandlerOptions = {
+  path?: string;
+  sameOrigin?: boolean;
+  transport?: "http" | "ws";
+  createContext?: (req: Request) => ActionContext | Promise<ActionContext>;
+};
+type ActionGroup = RpcGroup.RpcGroup<Rpc.Any>;
+declare function createActionHandler(group: ActionGroup, handlers: Layer.Layer<unknown, unknown, unknown>, options?: ActionHandlerOptions): (request: Request) => Promise<Response>;
+declare function disposeActionHandler(group: ActionGroup, path?: string, transport?: "http" | "ws"): Promise<void>;
+//#endregion
+//#region src/rpc/ws.d.ts
+type WsPeer = {
+  request?: Request;
+  context: Record<string, unknown>;
+  send: (data: unknown) => unknown;
+  /** Optional: register a listener when the peer disconnects. */
+  onClose?: (fn: () => void) => void;
+};
+type WsMessage = {
+  text: () => string;
+};
+type WsHooksOptions = {
+  path?: string;
+  sameOrigin?: boolean;
+  maxMessageSize?: number;
+  createContext?: (peer: WsPeer) => ActionContext | Promise<ActionContext>;
+};
+declare function createWsHooks(group: RpcGroup.RpcGroup<Rpc.Any>, handlers: Layer.Layer<unknown, unknown, unknown>, options?: WsHooksOptions): {
+  upgrade(req: Request): Response | undefined;
+  message(peer: WsPeer, message: WsMessage): Promise<void>;
+};
+//#endregion
+//#region src/rpc/stream.d.ts
+declare function asyncGenToStream<T>(gen: AsyncGenerator<T, unknown, unknown>): Stream.Stream<T, Error, never>;
+/**
+ * Re-enter `run` for every generator pull so AsyncLocalStorage request context
+ * stays available across yields (Effect may drain the stream after the outer ALS scope ends).
+ */
+declare function bindAsyncGenContext<T>(gen: AsyncGenerator<T, unknown, unknown>, run: <R>(fn: () => R) => R): AsyncGenerator<T, unknown, unknown>;
+/** Create a generator inside `run`, then keep every subsequent pull inside `run`. */
+declare function asyncGenToStreamInContext<T>(create: () => AsyncGenerator<T, unknown, unknown>, run: <R>(fn: () => R) => R): Stream.Stream<T, Error, never>;
+declare function streamToAsyncGen<T>(stream: Stream.Stream<T>): AsyncIterable<T>;
+//#endregion
+//#region src/rpc/scrub.d.ts
+/** Mutable repair state so each Defect can claim a distinct originating request id. */
+type IdRepairState = {
+  /** Request ids not yet claimed by a terminal (non-chunk) response. */
+  remaining: Set<unknown>;
+};
+/**
+ * Scrub one JSON-RPC response object.
+ * Effect encodes Defects with `id: -32603`; reclaim the originating request id from `state.remaining`.
+ */
+declare function scrubRpcMessage(msg: unknown, requestIds?: readonly unknown[], state?: IdRepairState): unknown;
+/**
+ * Rewrite a JSON / NDJSON body so clients never see Effect `_tag` / `data` trees.
+ * Accepts a single object, a JSON array, or newline-delimited frames.
+ */
+declare function scrubRpcJson(body: string, requestIds?: readonly unknown[]): string;
+/** Collect JSON-RPC request ids from a unary object or batch array body. */
+declare function extractJsonRpcRequestIds(body: ArrayBuffer | Uint8Array | string): unknown[];
+/** Ensure a body is a valid NDJSON frame (Effect's ndJsonRpc decode requires a trailing newline). */
+declare function ensureNdjsonBody(buf: ArrayBuffer): Uint8Array<ArrayBuffer>;
+/**
+ * TransformStream that scrubs Effect defect payloads one NDJSON line at a time,
+ * so long-running stream actions stay incremental.
+ */
+declare function scrubNdjsonTransform(requestIds?: readonly unknown[]): TransformStream<Uint8Array, Uint8Array>;
+//#endregion
+export { type ActionHandlerOptions, type RpcClientOptions, type WsHooksOptions, asyncGenToStream, asyncGenToStreamInContext, bindAsyncGenContext, createActionHandler, createClient, createWsHooks, disposeActionHandler, ensureNdjsonBody, extractJsonRpcRequestIds, scrubNdjsonTransform, scrubRpcJson, scrubRpcMessage, streamToAsyncGen };

package/dist/rpc.mjs

@@ -0,0 +1,3 @@
+import { a as streamToAsyncGen, i as bindAsyncGenContext, n as asyncGenToStream, r as asyncGenToStreamInContext, t as createClient } from "./client-Bc4g9AEw.mjs";
+import { a as extractJsonRpcRequestIds, c as scrubRpcMessage, i as ensureNdjsonBody, n as createActionHandler, o as scrubNdjsonTransform, r as disposeActionHandler, s as scrubRpcJson, t as createWsHooks } from "./rpc-DYFEdah8.mjs";
+export { asyncGenToStream, asyncGenToStreamInContext, bindAsyncGenContext, createActionHandler, createClient, createWsHooks, disposeActionHandler, ensureNdjsonBody, extractJsonRpcRequestIds, scrubNdjsonTransform, scrubRpcJson, scrubRpcMessage, streamToAsyncGen };

package/dist/rsbuild.mjs

@@ -1,4 +1,4 @@
-import { t as oxidejs } from "./plugin-nO0yjtk0.mjs";
+import { t as oxidejs } from "./plugin-IQa_lKkT.mjs";
 //#region src/rsbuild.ts
 var rsbuild_default = oxidejs.rsbuild;
 //#endregion

package/dist/vite.mjs

@@ -1,4 +1,4 @@
-import { t as oxidejs } from "./plugin-nO0yjtk0.mjs";
+import { t as oxidejs } from "./plugin-IQa_lKkT.mjs";
 //#region src/vite.ts
 var vite_default = oxidejs.vite;
 //#endregion

package/dist/worker-dom/install.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/worker-dom/install.mjs

@@ -0,0 +1,6 @@
+import { ensureWorkerDom } from "../worker-dom.mjs";
+//#region src/worker-dom/install.ts
+/** Side-effect import: install Worker DOM before any user worker module evaluates. */
+ensureWorkerDom();
+//#endregion
+export {};

package/dist/worker-dom.d.mts

@@ -0,0 +1,5 @@
+//#region src/worker-dom.d.ts
+/** Install a minimal DOM on `globalThis` for Ilha `renderToString` in Workers. */
+declare function ensureWorkerDom(): void;
+//#endregion
+export { ensureWorkerDom };

package/dist/worker-dom.mjs

@@ -0,0 +1,16 @@
+import * as linkedom from "linkedom";
+//#region src/worker-dom.ts
+/** Install a minimal DOM on `globalThis` for Ilha `renderToString` in Workers. */
+function ensureWorkerDom() {
+	if (typeof globalThis.document !== "undefined") return;
+	const window = linkedom.parseHTML("<!DOCTYPE html><html><body></body></html>");
+	const g = globalThis;
+	g.document = window.document;
+	g.window = window;
+	for (const [key, value] of Object.entries(linkedom)) {
+		if (key === "parseHTML" || key === "parseJSON" || key === "toJSON" || key === "Document") continue;
+		if (typeof value === "function" && /^[A-Z]/.test(key)) g[key] = value;
+	}
+}
+//#endregion
+export { ensureWorkerDom };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxidejs",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Vite/Rsbuild plugin. One build → dist/server.js + optional client. Server actions via *.server.ts.",
   "keywords": [
     "cloudflare",
@@ -45,6 +45,22 @@
     "./client": {
       "types": "./client.d.ts"
     },
+    "./rpc": {
+      "types": "./dist/rpc.d.mts",
+      "import": "./dist/rpc.mjs"
+    },
+    "./rpc/client": {
+      "types": "./dist/rpc/client.d.mts",
+      "import": "./dist/rpc/client.mjs"
+    },
+    "./worker-dom": {
+      "types": "./dist/worker-dom.d.mts",
+      "import": "./dist/worker-dom.mjs"
+    },
+    "./worker-dom/install": {
+      "types": "./dist/worker-dom/install.d.mts",
+      "import": "./dist/worker-dom/install.mjs"
+    },
     "./tsconfig": "./tsconfig.app.json"
   },
   "scripts": {
@@ -56,15 +72,13 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
+    "effect": "~4.0.0-rc.112",
+    "linkedom": "^0.18.13",
     "unplugin": "^3.3.0"
   },
-  "devDependencies": {
-    "tacho": "^0.6.1"
-  },
   "peerDependencies": {
     "@rsbuild/core": "*",
     "crossws": "*",
-    "tacho": "*",
     "vite": "*"
   },
   "peerDependenciesMeta": {
@@ -76,9 +90,6 @@
     },
     "vite": {
       "optional": true
-    },
-    "tacho": {
-      "optional": true
     }
   },
   "engines": {

package/virtual.d.ts

@@ -1,8 +1,11 @@
 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 };
+  import type { Rpc, RpcGroup } from "effect/unstable/rpc";
+  import type { Layer } from "effect";
+
+  const actionsGroup: RpcGroup.RpcGroup<Rpc.Any>;
+  export const actionsHandlers: Layer.Layer<unknown, unknown, unknown>;
+  export default actionsGroup;
+  export { actionsGroup as actions };
 }
 
 declare module "virtual:oxide/client" {