oxidejs 0.2.4 → 0.3.1

package/README.md

@@ -45,11 +45,11 @@ oxide({
 });
 ```
 
-`"celld"` writes `dist/wrangler.jsonc` for celld, a self-hosted alternative to Cloudflare Workers, and skips asset serving (`ASSETS` does that).
+`"celld"` writes `dist/wrangler.jsonc` for celld, a self-hosted alternative to Cloudflare Workers, and skips asset serving (`ASSETS` does that). The generated worker imports `oxidejs/worker-dom/install` so Ilha SSR has a DOM before your entry evaluates. Oxide merges `nodejs_compat` into `compatibility_flags` when you do not set it.
 
 ## 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 Effect RPC stub that POSTs `/__oxide/action` as newline-delimited JSON-RPC (`application/json-rpc`). 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`. `action()` results are JSON-RPC data — returning a `Response` from an action is an error; return a raw `Response` from `src/server.ts` for raw HTTP responses.
 
 ```ts
 // src/test.server.ts
@@ -78,7 +78,18 @@ 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`:
+### Call shape
+
+Unary actions return a Promise and expose helpers for UI wiring:
+
+| Call                                        | What it does                                     |
+| ------------------------------------------- | ------------------------------------------------ |
+| `await ping()`                              | Run the action (always invokes RPC on client)    |
+| `ping.set(...args)`                         | Same as calling with args; also writes the atom  |
+| `ping.bind(...args)` / `ping.with(...args)` | Return an event handler that invokes the action  |
+| `ping.result`                               | Read the last `AsyncResult` from the client atom |
+
+`action()` 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 (not SSE). On the client the stub returns an async generator — iterate it directly. Inside server code, always read the non-optional signal from `useRequest().signal`:
 
 ```ts
 // src/test.server.ts
@@ -93,10 +104,14 @@ 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 ticks(10, { signal: ac.signal })) {
+  console.log(value);
+}
 ac.abort();
 ```
 
+Stream actions do not support `bind` / `with`. Breaking the `for await` loop or calling `return()` on the generator cleans up the server generator.
+
 `vite dev` and `rsbuild dev` serve the endpoint via middleware. `actions: "http"` (default) serves `/__oxide/action`; `actions: "ws"` uses a WebSocket instead (needs `crossws`; not with `preset: "celld"`). `actions.sameOrigin` defaults to `true` for both transports; set it to `false` only when you intentionally accept cross-origin requests. Set `actions.path` to move the endpoint. `actionHeaders` are static headers on the shared HTTP client and are ignored for WebSocket actions.
 
 ## Rsbuild
@@ -123,7 +138,7 @@ Same factory as Vite: client stubs, `/__oxide/action`, and `dist/server.js`.
 | `clientDir`                    | `client`                 | Must stay inside `outDir`                                                                   |
 | `wrangler.name`                | required if `emitConfig` |                                                                                             |
 | `wrangler.compatibility_date`  | required if `emitConfig` |                                                                                             |
-| `wrangler.compatibility_flags` | —                        | optional                                                                                    |
+| `wrangler.compatibility_flags` | —                        | optional; `nodejs_compat` is merged in automatically on `celld`                             |
 | `wrangler.durable_objects`     | —                        | optional                                                                                    |
 | `wrangler.migrations`          | —                        | optional                                                                                    |
 | `wrangler.services`            | —                        | optional                                                                                    |
@@ -176,13 +191,16 @@ 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 Effect 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.
+- Stream actions use newline-delimited JSON-RPC (`application/json-rpc`) over that same endpoint — not Server-Sent Events. Frames are scrubbed as they flush on HTTP and WebSocket.
 - The endpoint is POST-only. Non-POST requests return `405`.
 - Method dispatch uses `Object.hasOwn`, blocking `__proto__` / `constructor` walks.
 - Unknown or missing content-types → `415`.
 - Body size capped at 1 MB by default (enforced on the actual body, not just `Content-Length`).
 - Batch requests capped at 20 items (both HTTP and WebSocket transports).
+- Effect `Defect` / `Cause` payloads are scrubbed before they leave the endpoint. Clients see plain JSON-RPC errors (`code` + `message` only). Thrown messages become `Internal error` (`-32603`). Unknown methods → `-32601`; invalid params → `-32602`.
+- `actions.sameOrigin` defaults to `true`. Requests without both `Origin` and `Sec-Fetch-Site` are rejected when that check is on.
 
 ### Host header
 

package/dist/client-C-s6XXpS.mjs

@@ -0,0 +1,148 @@
+import { Effect, Layer, Scope, Stream } from "effect";
+import { RpcClient, RpcSchema, RpcSerialization } from "effect/unstable/rpc";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { Socket } from "effect/unstable/socket";
+//#region src/rpc/stream.ts
+function asyncGenToStream(gen) {
+	return Stream.fromAsyncIterable(gen, (error) => error instanceof Error ? error : new Error(String(error)));
+}
+/**
+* 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).
+*/
+function bindAsyncGenContext(gen, run) {
+	return {
+		next: (value) => run(() => gen.next(value)),
+		return: (value) => run(() => gen.return(value)),
+		throw: (error) => run(() => gen.throw(error)),
+		[Symbol.asyncIterator]() {
+			return this;
+		},
+		async [Symbol.asyncDispose]() {
+			await run(() => gen.return(void 0));
+		}
+	};
+}
+/** Create a generator inside `run`, then keep every subsequent pull inside `run`. */
+function asyncGenToStreamInContext(create, run) {
+	return asyncGenToStream(bindAsyncGenContext(run(create), run));
+}
+function streamToAsyncGen(stream) {
+	return Stream.toAsyncIterable(stream);
+}
+//#endregion
+//#region src/rpc/client.ts
+const clientCache = /* @__PURE__ */ new Map();
+let nextGroupId = 0;
+function cacheKey(group, options) {
+	const headerKey = options.headers ? Object.entries(options.headers).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join("&") : "";
+	let groupId = group.__oxideClientId;
+	if (groupId === void 0) {
+		groupId = ++nextGroupId;
+		group.__oxideClientId = groupId;
+	}
+	return `${groupId}|${options.transport ?? "http"}|${options.url}|${headerKey}`;
+}
+function httpLayer(options) {
+	const headers = options.headers;
+	return RpcClient.layerProtocolHttp({
+		url: options.url,
+		...headers ? { transformClient: (client) => HttpClient.mapRequest(client, (req) => {
+			for (const [key, value] of Object.entries(headers)) req = HttpClientRequest.setHeader(req, key, value);
+			return req;
+		}) } : {}
+	}).pipe(Layer.provide(RpcSerialization.layerNdJsonRpc()), Layer.provide(FetchHttpClient.layer));
+}
+function wsLayer(url) {
+	return RpcClient.layerProtocolSocket().pipe(Layer.provide(RpcSerialization.layerNdJsonRpc()), Layer.provide(Socket.layerWebSocket(url)), Layer.provide(Socket.layerWebSocketConstructorGlobal));
+}
+function clientLayer(options) {
+	return options.transport === "ws" ? wsLayer(options.url) : httpLayer(options);
+}
+function loadClient(group, options) {
+	return Effect.gen(function* () {
+		const scope = yield* Scope.make();
+		const context = yield* Scope.provide(scope)(Layer.build(clientLayer(options)));
+		return yield* Scope.provide(scope)(RpcClient.make(group).pipe(Effect.provide(context)));
+	});
+}
+function isStreamResult(value) {
+	return Stream.isStream(value);
+}
+function isStreamTag(group, tag) {
+	const rpc = group.requests.get(tag);
+	if (!rpc?.successSchema) return false;
+	return RpcSchema.isStreamSchema(rpc.successSchema);
+}
+function streamToAsyncGenerator(stream, signal) {
+	const iterable = streamToAsyncGen(stream);
+	return (async function* () {
+		if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+		const iterator = iterable[Symbol.asyncIterator]();
+		const onAbort = () => {
+			iterator.return?.();
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		try {
+			while (true) {
+				if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+				const next = await iterator.next();
+				if (next.done) return void 0;
+				yield next.value;
+			}
+		} finally {
+			signal?.removeEventListener("abort", onAbort);
+		}
+	})();
+}
+function callFlat(client, tag, args, callOpts) {
+	const caller = client[tag];
+	if (!caller) return Promise.reject(/* @__PURE__ */ new Error(`Unknown action ${tag}`));
+	const result = caller({ args }, callOpts);
+	if (isStreamResult(result)) return streamToAsyncGenerator(result, callOpts?.signal);
+	return Effect.runPromise(result, { signal: callOpts?.signal });
+}
+function nestClient(group, flat) {
+	const nested = {};
+	for (const tag of group.requests.keys()) {
+		const dot = tag.indexOf(".");
+		if (dot === -1) continue;
+		const mod = tag.slice(0, dot);
+		const name = tag.slice(dot + 1);
+		nested[mod] ??= {};
+		nested[mod][name] = (...args) => {
+			const opts = args.at(-1);
+			const hasSignal = opts && typeof opts === "object" && "signal" in opts && opts.signal instanceof AbortSignal && Object.keys(opts).length === 1;
+			const params = hasSignal ? args.slice(0, -1) : args;
+			return callFlat(flat, tag, params, hasSignal ? opts : void 0);
+		};
+	}
+	return nested;
+}
+function createClient(group, options) {
+	const key = cacheKey(group, options);
+	let entry = clientCache.get(key);
+	if (!entry) {
+		entry = { pending: Effect.runPromise(loadClient(group, options)).then((flat) => {
+			return nestClient(group, flat);
+		}).catch((error) => {
+			clientCache.delete(key);
+			throw error;
+		}) };
+		clientCache.set(key, entry);
+	}
+	return new Proxy({}, { get(_target, mod) {
+		if (typeof mod !== "string") return void 0;
+		return new Proxy({}, { get(_inner, name) {
+			if (typeof name !== "string") return void 0;
+			if (isStreamTag(group, `${mod}.${name}`)) return (...args) => (async function* () {
+				const out = (await entry.pending)[mod]?.[name]?.(...args);
+				if (!out) throw new Error(`Unknown action ${mod}.${name}`);
+				yield* out;
+			})();
+			return (...args) => entry.pending.then((client) => client[mod]?.[name]?.(...args) ?? Promise.reject(/* @__PURE__ */ new Error(`Unknown action ${mod}.${name}`)));
+		} });
+	} });
+}
+//#endregion
+export { streamToAsyncGen as a, bindAsyncGenContext as i, asyncGenToStream as n, asyncGenToStreamInContext as r, createClient as t };

package/dist/context-C1UFQ0Zc.d.mts

@@ -0,0 +1,64 @@
+import * as Atom from "effect/unstable/reactivity/Atom";
+import * as AsyncResult from "effect/unstable/reactivity/AsyncResult";
+//#region src/action.d.ts
+declare const ACTION_CALL: unique symbol;
+type CallOptions = {
+  signal?: AbortSignal;
+};
+type ServerActionHandle<Args extends unknown[], A> = {
+  (...args: Args | [...Args, CallOptions]): Promise<A>;
+  set(...args: Args): Promise<A>;
+  bind(...args: Args): (...ev: unknown[]) => void;
+  with(...args: Args): (...ev: unknown[]) => void;
+  /** Last `AsyncResult` for this action's client atom (does not invoke RPC). */
+  readonly result: AsyncResult.AsyncResult<A, unknown>;
+  readonly atom: Atom.Atom<unknown>;
+  readonly $$atom: 1;
+};
+type StreamActionHandle<Args extends unknown[], Y, R = void> = {
+  (...args: Args | [...Args, CallOptions]): AsyncGenerator<Y, R, undefined>;
+  set(...args: Args): AsyncGenerator<Y, R, undefined>;
+  bind(...args: Args): (...ev: unknown[]) => void;
+  with(...args: Args): (...ev: unknown[]) => void;
+  readonly atom: undefined;
+  readonly $$atom: 1;
+};
+/** Attach an ilha server-island capture key to an action handle. */
+declare function brandServerAction<Args extends unknown[], A>(key: string, handle: ServerActionHandle<Args, A>): ServerActionHandle<Args, A>;
+/** Wrap an RPC caller as an `Atom.fn`-shaped client action handle. */
+declare function wrapClientRpc<Args extends unknown[], A>(rpc: (...args: Args | [...Args, CallOptions]) => Promise<A>): ServerActionHandle<Args, A>;
+/**
+ * Wrap a streaming RPC caller so the client handle returns an async generator
+ * (awaiting the underlying client lazily), not `Promise<AsyncGenerator>`.
+ */
+declare function wrapClientStreamRpc<Args extends unknown[], Y, R = void>(rpc: (...args: Args | [...Args, CallOptions]) => AsyncGenerator<Y, R, undefined>): StreamActionHandle<Args, Y, R>;
+/**
+ * Marks a `*.server.ts` export as a remote RPC action. On the server the
+ * underlying function runs locally; on the client the build replaces the module
+ * with an `Atom.fn`-shaped RPC handle (`set`, `bind`, `result`).
+ */
+declare function action<Args extends unknown[], Y, R = void>(fn: (...args: Args) => AsyncGenerator<Y, R, unknown>): StreamActionHandle<Args, Y, R>;
+declare function action<Args extends unknown[], Result>(fn: (...args: Args) => Result): ServerActionHandle<Args, Awaited<Result>>;
+//#endregion
+//#region src/context.d.ts
+type ExecutionContext = {
+  waitUntil?(promise: Promise<unknown>): void;
+  passThroughOnException?(): void;
+};
+/** RPC procedure request context. Starts as `{ req }` plus Worker extras. Middleware can add fields. */
+type ActionContext = {
+  req: Request;
+  env?: unknown;
+  fetchCtx?: ExecutionContext;
+  [key: string]: unknown;
+};
+/** Current RPC or host request context. Throws outside request handling. */
+declare function useCtx<C extends ActionContext = ActionContext>(): C;
+/** Current server `Request`. Available in actions, SSR, and frame renders. */
+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`). `undefined` on Node. */
+declare function useFetchCtx(): ExecutionContext | undefined;
+//#endregion
+export { useFetchCtx as a, ServerActionHandle as c, brandServerAction as d, wrapClientRpc as f, useEnv as i, StreamActionHandle as l, ExecutionContext as n, useRequest as o, wrapClientStreamRpc as p, useCtx as r, ACTION_CALL as s, ActionContext as t, action as u };

package/dist/context-zrTZyYpF.mjs

@@ -0,0 +1,42 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/context.ts
+const ALS_KEY = Symbol.for("oxidejs.requestContext");
+const FETCH_KEY = Symbol.for("oxidejs.fetch");
+function als() {
+	const g = globalThis;
+	return g[ALS_KEY] ??= new AsyncLocalStorage();
+}
+function store() {
+	const current = als().getStore();
+	if (!current) throw new Error("oxidejs: request context is unavailable");
+	return current;
+}
+/** Current RPC or host request context. Throws outside request handling. */
+function useCtx() {
+	return store();
+}
+/** Current server `Request`. Available in actions, SSR, and frame renders. */
+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`). `undefined` on Node. */
+function useFetchCtx() {
+	return store().fetchCtx;
+}
+function runWithRequest(req, fn, extra) {
+	return als().run({
+		...extra,
+		req
+	}, fn);
+}
+const HOOK_KEY = Symbol.for("oxidejs.runWithRequest");
+globalThis[HOOK_KEY] ??= (req, fn) => {
+	const extra = req[FETCH_KEY];
+	return runWithRequest(req, fn, extra);
+};
+//#endregion
+export { useRequest as a, useFetchCtx as i, useCtx as n, useEnv as r, runWithRequest as t };

package/dist/index.d.mts

@@ -1,30 +1,3 @@
+import { a as useFetchCtx, c as ServerActionHandle, d as brandServerAction, f as wrapClientRpc, i as useEnv, l as StreamActionHandle, n as ExecutionContext, o as useRequest, p as wrapClientStreamRpc, r as useCtx, s as ACTION_CALL, t as ActionContext, u as action } from "./context-C1UFQ0Zc.mjs";
 import { a as OxidejsWranglerOptions, i as OxidejsPreset, n as OxidejsActionTransport, o as ResolvedOptions, r as OxidejsOptions, t as OxidejsActionHeaders } from "./types-BM4NAnzy.mjs";
-//#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 or host request context. Throws outside request handling. */
-declare function useCtx<C extends ActionContext = ActionContext>(): C;
-/** Current server `Request`. Available in actions, SSR, and frame renders. */
-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;
-/**
- * Marks a `*.server.ts` export as a remote RPC action. Runtime identity; the
- * second call signature adds the transport-only `{ signal }` argument.
- */
-declare function action<Args extends unknown[], Result>(fn: (...args: Args) => Result): typeof fn & ((...args: [...Args, options: {
-  signal?: AbortSignal;
-}]) => Result);
-//#endregion
-export { type ActionContext, type ExecutionContext, type OxidejsActionHeaders, type OxidejsActionTransport, type OxidejsOptions, type OxidejsPreset, type OxidejsWranglerOptions, type ResolvedOptions, action, useCtx, useEnv, useFetchCtx, useRequest };
+export { ACTION_CALL, type ActionContext, type ExecutionContext, type OxidejsActionHeaders, type OxidejsActionTransport, type OxidejsOptions, type OxidejsPreset, type OxidejsWranglerOptions, type ResolvedOptions, type ServerActionHandle, type StreamActionHandle, action, brandServerAction, useCtx, useEnv, useFetchCtx, useRequest, wrapClientRpc, wrapClientStreamRpc };

package/dist/index.mjs

@@ -1,49 +1,108 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-//#region src/context.ts
-const ALS_KEY = Symbol.for("oxidejs.requestContext");
-const FETCH_KEY = Symbol.for("oxidejs.fetch");
-function als() {
-	const g = globalThis;
-	return g[ALS_KEY] ??= new AsyncLocalStorage();
-}
-function store() {
-	const current = als().getStore();
-	if (!current) throw new Error("oxidejs: request context is unavailable");
-	return current;
-}
-/** Current tacho or host request context. Throws outside request handling. */
-function useCtx() {
-	return store();
-}
-/** Current server `Request`. Available in actions, SSR, and frame renders. */
-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;
-}
-function runWithRequest(req, fn, extra) {
-	return als().run({
-		...extra,
-		req
-	}, fn);
-}
-const HOOK_KEY = Symbol.for("oxidejs.runWithRequest");
-globalThis[HOOK_KEY] ??= (req, fn) => {
-	const extra = req[FETCH_KEY];
-	return runWithRequest(req, fn, extra);
-};
+import { a as useRequest, i as useFetchCtx, n as useCtx, r as useEnv } from "./context-zrTZyYpF.mjs";
+import * as Effect from "effect/Effect";
+import * as Atom from "effect/unstable/reactivity/Atom";
+import * as Registry from "effect/unstable/reactivity/AtomRegistry";
+//#region src/action.ts
+const ACTION_CALL = Symbol.for("ilha.actionCall");
+const ACTION_KEY = Symbol.for("oxidejs.actionKey");
+const AsyncGeneratorFunction = Object.getPrototypeOf(async function* () {}).constructor;
+let defaultRegistry;
+function registry() {
+	return defaultRegistry ??= Registry.make();
+}
+function isAsyncGeneratorFunction(fn) {
+	return typeof fn === "function" && fn instanceof AsyncGeneratorFunction;
+}
+function splitCallOptions(args) {
+	if (args.length === 0) return { args: [] };
+	const last = args[args.length - 1];
+	if (last && typeof last === "object" && "signal" in last && last.signal instanceof AbortSignal && Object.keys(last).length === 1) return {
+		args: args.slice(0, -1),
+		options: last
+	};
+	return { args };
+}
+function bindHandler(key, invoke, args) {
+	const handler = ((..._ev) => invoke(...args));
+	if (key) handler[ACTION_CALL] = {
+		k: key,
+		a: args
+	};
+	return handler;
+}
+function defineServerAction(atom, invoke, opts) {
+	const captureKey = opts?.captureKey;
+	const stripCallOptions = opts?.stripCallOptions ?? true;
+	const run = ((...allArgs) => {
+		if (!stripCallOptions) return Promise.resolve(invoke(...allArgs));
+		const { args } = splitCallOptions(allArgs);
+		return Promise.resolve(invoke(...args));
+	});
+	const set = (...args) => {
+		registry().set(atom, args);
+		return Promise.resolve(invoke(...args));
+	};
+	const bind = (...args) => {
+		return bindHandler(captureKey ?? run[ACTION_KEY], (...a) => void set(...a), args);
+	};
+	Object.assign(run, {
+		set,
+		bind,
+		with: bind,
+		atom,
+		$$atom: 1
+	});
+	Object.defineProperty(run, "result", {
+		enumerable: true,
+		get: () => registry().get(atom)
+	});
+	if (captureKey) run[ACTION_KEY] = captureKey;
+	return run;
+}
+function defineStreamAction(fn) {
+	const call = ((...allArgs) => {
+		const { args } = splitCallOptions(allArgs);
+		return fn(...args);
+	});
+	const deny = () => {
+		throw new Error("oxidejs: stream actions cannot be bound to DOM events");
+	};
+	Object.assign(call, {
+		set: call,
+		bind: deny,
+		with: deny,
+		atom: void 0,
+		$$atom: 1
+	});
+	return call;
+}
+/** Attach an ilha server-island capture key to an action handle. */
+function brandServerAction(key, handle) {
+	handle[ACTION_KEY] = key;
+	return handle;
+}
+/** Wrap an RPC caller as an `Atom.fn`-shaped client action handle. */
+function wrapClientRpc(rpc) {
+	const invoke = (...args) => Promise.resolve(rpc(...args));
+	return defineServerAction(Atom.make(Atom.fn((packed) => Effect.tryPromise({
+		try: () => invoke(...packed),
+		catch: (error) => error instanceof Error ? error : new Error(String(error))
+	}))), (...args) => invoke(...args), { stripCallOptions: false });
+}
 /**
-* Marks a `*.server.ts` export as a remote RPC action. Runtime identity; the
-* second call signature adds the transport-only `{ signal }` argument.
+* Wrap a streaming RPC caller so the client handle returns an async generator
+* (awaiting the underlying client lazily), not `Promise<AsyncGenerator>`.
 */
+function wrapClientStreamRpc(rpc) {
+	return defineStreamAction((...args) => rpc(...args));
+}
 function action(fn) {
-	return fn;
+	if (isAsyncGeneratorFunction(fn)) return defineStreamAction(fn);
+	const invoke = (...args) => Promise.resolve(fn(...args));
+	return defineServerAction(Atom.make(Atom.fn((packed) => Effect.tryPromise({
+		try: () => invoke(...packed),
+		catch: (error) => error instanceof Error ? error : new Error(String(error))
+	}))), invoke);
 }
 //#endregion
-export { action, useCtx, useEnv, useFetchCtx, useRequest };
+export { ACTION_CALL, action, brandServerAction, useCtx, useEnv, useFetchCtx, useRequest, wrapClientRpc, wrapClientStreamRpc };