oxidejs 0.3.2 → 0.3.3

package/dist/rpc.d.mts

@@ -1,42 +1,46 @@
-import { t as ActionContext } from "./context-Ct8u5XUC.mjs";
+import { r as OxidejsJson } from "./types-BaZeMYcP.mjs";
+import { n as ActionContextValue, t as ActionContext } from "./context-CmChiQ2W.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 = {
+interface ActionHandlerOptions {
+  createContext?: (req: Request) => ActionContext | Promise<ActionContext>;
   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>;
+declare const createActionHandler: (group: ActionGroup, handlers: Layer.Layer<unknown, unknown, unknown>, options?: ActionHandlerOptions) => (request: Request) => Promise<Response>;
+declare const 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;
+interface WsPeerContext {
+  [key: string]: ActionContextValue;
+}
+interface WsPeer {
+  context: WsPeerContext;
   /** Optional: register a listener when the peer disconnects. */
   onClose?: (fn: () => void) => void;
-};
-type WsMessage = {
+  request?: Request;
+  send: (data: string) => void;
+}
+interface WsMessage {
   text: () => string;
-};
-type WsHooksOptions = {
+}
+interface WsHooksOptions {
+  createContext?: (peer: WsPeer) => ActionContext | Promise<ActionContext>;
+  maxMessageSize?: number;
   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;
+}
+declare const createWsHooks: (group: RpcGroup.RpcGroup<Rpc.Any>, handlers: Layer.Layer<unknown, unknown, unknown>, options?: WsHooksOptions) => {
   message(peer: WsPeer, message: WsMessage): Promise<void>;
+  upgrade(req: Request): Response | undefined;
 };
 //#endregion
 //#region src/rpc/stream.d.ts
-declare function asyncGenToStream<T>(gen: AsyncGenerator<T, unknown, unknown>): Stream.Stream<T, Error, never>;
+declare const asyncGenToStream: <T>(gen: AsyncGenerator<T, unknown, unknown>) => Stream.Stream<T, Error, never>;
 /**
  * Re-enter `run` for every generator pull so request context stays available
  * across yields (Effect may drain the stream after the outer ALS scope ends;
@@ -44,35 +48,37 @@ declare function asyncGenToStream<T>(gen: AsyncGenerator<T, unknown, unknown>):
  * On WebContainer, pulls are serialized through settlement so concurrent streams
  * cannot replace the sync fallback mid-pull. `withRequestEntry` is unchanged.
  */
-declare function bindAsyncGenContext<T>(gen: AsyncGenerator<T, unknown, unknown>, run: <R>(fn: () => R) => R): AsyncGenerator<T, unknown, unknown>;
+declare const 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>;
+declare const asyncGenToStreamInContext: <T>(create: () => AsyncGenerator<T, unknown, unknown>, run: <R>(fn: () => R) => R) => Stream.Stream<T, Error, never>;
+declare const streamToAsyncGen: <T>(stream: Stream.Stream<T>) => AsyncIterable<T>;
 //#endregion
 //#region src/rpc/scrub.d.ts
+/** JSON-RPC request/response id. */
+type JsonRpcId = string | number | null;
 /** Mutable repair state so each Defect can claim a distinct originating request id. */
-type IdRepairState = {
+interface IdRepairState {
   /** Request ids not yet claimed by a terminal (non-chunk) response. */
-  remaining: Set<unknown>;
-};
+  remaining: Set<JsonRpcId>;
+}
 /**
  * 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;
+declare const scrubRpcMessage: (msg: OxidejsJson, requestIds?: readonly JsonRpcId[], state?: IdRepairState) => OxidejsJson;
 /**
  * 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;
+declare const scrubRpcJson: (body: string, requestIds?: readonly JsonRpcId[]) => string;
 /** Collect JSON-RPC request ids from a unary object or batch array body. */
-declare function extractJsonRpcRequestIds(body: ArrayBuffer | Uint8Array | string): unknown[];
+declare const extractJsonRpcRequestIds: (body: ArrayBuffer | Uint8Array | string) => JsonRpcId[];
 /** Ensure a body is a valid NDJSON frame (Effect's ndJsonRpc decode requires a trailing newline). */
-declare function ensureNdjsonBody(buf: ArrayBuffer): Uint8Array<ArrayBuffer>;
+declare const 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>;
+declare const scrubNdjsonTransform: (requestIds?: readonly JsonRpcId[]) => 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

@@ -1,3 +1,3 @@
-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-tYqxQToi.mjs";
-import { a as streamToAsyncGen, i as bindAsyncGenContext, n as asyncGenToStream, r as asyncGenToStreamInContext, t as createClient } from "./client-BgBfkZDx.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-gCOSJXql.mjs";
+import { a as streamToAsyncGen, i as bindAsyncGenContext, n as asyncGenToStream, r as asyncGenToStreamInContext, t as createClient } from "./client-DOfB6wxk.mjs";
 export { asyncGenToStream, asyncGenToStreamInContext, bindAsyncGenContext, createActionHandler, createClient, createWsHooks, disposeActionHandler, ensureNdjsonBody, extractJsonRpcRequestIds, scrubNdjsonTransform, scrubRpcJson, scrubRpcMessage, streamToAsyncGen };

package/dist/rsbuild.d.mts

@@ -1,4 +1,4 @@
-import { r as OxidejsOptions } from "./types-BM4NAnzy.mjs";
+import { i as OxidejsOptions } from "./types-BaZeMYcP.mjs";
 //#region src/rsbuild.d.ts
 declare const _default: (options?: OxidejsOptions | undefined) => any;
 //#endregion

package/dist/rsbuild.mjs

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

package/dist/{types-BM4NAnzy.d.mts → types-BaZeMYcP.d.mts}

@@ -1,13 +1,21 @@
 //#region src/types.d.ts
 type OxidejsPreset = "fetch" | "celld";
+/** JSON-compatible value used for opaque wrangler / env bags. */
+type OxidejsJson = string | number | boolean | null | OxidejsJson[] | {
+  [key: string]: OxidejsJson;
+};
 interface OxidejsWranglerOptions {
   name: string;
   compatibility_date: string;
   compatibility_flags?: string[];
-  durable_objects?: Record<string, unknown>;
-  migrations?: unknown[];
-  services?: unknown[];
-  vars?: Record<string, unknown>;
+  durable_objects?: {
+    [key: string]: OxidejsJson;
+  };
+  migrations?: OxidejsJson[];
+  services?: OxidejsJson[];
+  vars?: {
+    [key: string]: OxidejsJson;
+  };
 }
 type OxidejsActionTransport = "http" | "ws";
 /** `actions` config: transport string, or an object with `transport`, `path`, `sameOrigin`. */
@@ -19,7 +27,9 @@ type OxidejsActions = OxidejsActionTransport | {
   sameOrigin?: boolean;
 };
 /** Static headers inlined into the shared action client. Functions cannot ship to the browser. */
-type OxidejsActionHeaders = Record<string, string> | [string, string][];
+type OxidejsActionHeaders = {
+  [key: string]: string;
+} | [string, string][];
 interface OxidejsOptions {
   /** "fetch" (default) skips wrangler.jsonc and serves client assets. "celld" emits wrangler.jsonc. */
   preset?: OxidejsPreset;
@@ -55,7 +65,9 @@ interface OxidejsOptions {
   notFound?: string;
   /** Extra env passed as the second argument to fetch(request, env, ctx) on
    * the Node fetch preset — read it with useEnv(). */
-  env?: Record<string, unknown>;
+  env?: {
+    [key: string]: OxidejsJson;
+  };
 }
 interface ResolvedOptions {
   root: string;
@@ -85,7 +97,9 @@ interface ResolvedOptions {
   imports: string[];
   bodyLimit: number;
   notFound: string | undefined;
-  env: Record<string, unknown> | undefined;
+  env: {
+    [key: string]: OxidejsJson;
+  } | undefined;
 }
 //#endregion
-export { OxidejsWranglerOptions as a, OxidejsPreset as i, OxidejsActionTransport as n, ResolvedOptions as o, OxidejsOptions as r, OxidejsActionHeaders as t };
+export { OxidejsPreset as a, OxidejsOptions as i, OxidejsActionTransport as n, OxidejsWranglerOptions as o, OxidejsJson as r, ResolvedOptions as s, OxidejsActionHeaders as t };

package/dist/vite.d.mts

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

package/dist/vite.mjs

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

package/dist/worker-dom.d.mts

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

package/dist/worker-dom.mjs

@@ -1,16 +1,23 @@
 import * as linkedom from "linkedom";
 //#region src/worker-dom.ts
+const SKIP_LINKEDOM_KEYS = /* @__PURE__ */ new Set([
+	"parseHTML",
+	"parseJSON",
+	"toJSON",
+	"Document"
+]);
 /** Install a minimal DOM on `globalThis` for Ilha `renderToString` in Workers. */
-function ensureWorkerDom() {
-	if (typeof globalThis.document !== "undefined") return;
+const ensureWorkerDom = function ensureWorkerDom() {
+	if (globalThis.document !== void 0) return;
 	const window = linkedom.parseHTML("<!DOCTYPE html><html><body></body></html>");
-	const g = globalThis;
-	g.document = window.document;
-	g.window = window;
+	Reflect.set(globalThis, "document", window.document);
+	Reflect.set(globalThis, "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;
+		if (SKIP_LINKEDOM_KEYS.has(key)) continue;
+		if (!/^[A-Z]/u.test(key)) continue;
+		if (!("prototype" in value)) continue;
+		Reflect.set(globalThis, key, value);
 	}
-}
+};
 //#endregion
 export { ensureWorkerDom };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxidejs",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Vite/Rsbuild plugin. One build → dist/server.js + optional client. Server actions via *.server.ts.",
   "keywords": [
     "cloudflare",
@@ -93,6 +93,6 @@
     }
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=20.11"
   }
 }

package/virtual.d.ts

@@ -1,13 +1,26 @@
 declare module "virtual:oxide/actions" {
-  import type { Rpc, RpcGroup } from "effect/unstable/rpc";
   import type { Layer } from "effect";
+  import type { Rpc, RpcGroup } from "effect/unstable/rpc";
 
   const actionsGroup: RpcGroup.RpcGroup<Rpc.Any>;
-  export const actionsHandlers: Layer.Layer<unknown, unknown, unknown>;
+  export const actionsHandlers: Layer.Layer<Rpc.Any, never, never>;
   export default actionsGroup;
   export { actionsGroup as actions };
 }
 
 declare module "virtual:oxide/client" {
-  export const client: Record<string, Record<string, (...args: unknown[]) => Promise<unknown>>>;
+  type ActionValue =
+    | string
+    | number
+    | boolean
+    | null
+    | ActionValue[]
+    | { [key: string]: ActionValue };
+  type ActionFn = (
+    ...args: ActionValue[]
+  ) =>
+    | Promise<ActionValue>
+    | AsyncGenerator<ActionValue, ActionValue | undefined, undefined>;
+  type ActionModule = Record<string, ActionFn>;
+  export const client: Record<string, ActionModule>;
 }

package/dist/client-BgBfkZDx.mjs

@@ -1,166 +0,0 @@
-import { n as inWebcontainer } from "./context-DQDDwFYi.mjs";
-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)));
-}
-/** Serialize WebContainer stream pulls so the shared syncStore is not stomped. */
-let pullTail = Promise.resolve();
-/**
-* Re-enter `run` for every generator pull so request context stays available
-* across yields (Effect may drain the stream after the outer ALS scope ends;
-* WebContainer also loses ALS across awaits, so `run` must reinstall the store).
-* On WebContainer, pulls are serialized through settlement so concurrent streams
-* cannot replace the sync fallback mid-pull. `withRequestEntry` is unchanged.
-*/
-function bindAsyncGenContext(gen, run) {
-	const runPull = (fn) => {
-		if (!inWebcontainer()) return run(fn);
-		let release;
-		const gate = new Promise((resolve) => {
-			release = resolve;
-		});
-		const prev = pullTail;
-		pullTail = gate;
-		return prev.then(() => Promise.resolve(run(fn))).finally(() => {
-			release();
-		});
-	};
-	return {
-		next: (value) => runPull(() => gen.next(value)),
-		return: (value) => runPull(() => gen.return(value)),
-		throw: (error) => runPull(() => gen.throw(error)),
-		[Symbol.asyncIterator]() {
-			return this;
-		},
-		async [Symbol.asyncDispose]() {
-			await runPull(() => 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-Ct8u5XUC.d.mts

@@ -1,73 +0,0 @@
-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 request context: ALS first, then the WebContainer sync fallback. */
-declare function getRequestStore(): ActionContext;
-/**
- * Run `fn` with `store` on ALS and the sync fallback. On WebContainer the sync
- * slot is restored only after an async `fn` settles (streams capture the store
- * at invoke time and re-enter via this helper on each pull). Sync returns and
- * throws restore immediately so a completed request is not left visible.
- */
-declare function withRequestStore<T>(ctx: ActionContext, fn: () => T): T;
-/** 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 { useEnv as a, withRequestStore as c, StreamActionHandle as d, action as f, wrapClientStreamRpc as h, useCtx as i, ACTION_CALL as l, wrapClientRpc as m, ExecutionContext as n, useFetchCtx as o, brandServerAction as p, getRequestStore as r, useRequest as s, ActionContext as t, ServerActionHandle as u };