oxidejs 0.3.1 → 0.3.3

package/README.md

@@ -71,23 +71,24 @@ 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");
-  },
-};
+import type { FetchHandler } from "oxidejs";
+
+export const fetch = ((request) => {
+  if (new URL(request.url).pathname === "/api/ok") return new Response("ok");
+  return;
+}) satisfies FetchHandler;
 ```
 
 ### 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 |
+| 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`:
 
@@ -130,27 +131,27 @@ Same factory as Vite: client stubs, `/__oxide/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; `nodejs_compat` is merged in automatically on `celld`                             |
-| `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`; object form: `{ transport, path, sameOrigin }` (`sameOrigin: true`) |
-| `actionHeaders`                | —                        | Static headers on the HTTP client                                                           |
-| `middleware`                   | `[]`                     | Fetch middleware, run in order before actions and the server entry                          |
-| `imports`                      | `[]`                     | Modules imported for side effects at server startup                                         |
-| `bodyLimit`                    | `1048576`                | Max Node request body size; larger requests get 413                                         |
-| `notFound`                     | —                        | Custom HTML 404 body when no route or asset matches                                         |
-| `env`                          | —                        | Node preset value passed to `fetch(request, env, ctx)`                                      |
+| 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; `nodejs_compat` is merged in automatically on `celld` |
+| `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`; object form: `{ transport, path, sameOrigin }` (`sameOrigin: true`) |
+| `actionHeaders` | — | Static headers on the HTTP client |
+| `middleware` | `[]` | Fetch middleware, run in order before actions and the server entry |
+| `imports` | `[]` | Modules imported for side effects at server startup |
+| `bodyLimit` | `1048576` | Max Node request body size; larger requests get 413 |
+| `notFound` | — | Custom HTML 404 body when no route or asset matches |
+| `env` | — | Node preset value passed to `fetch(request, env, ctx)` |
 
 ### `middleware` and `imports`
 
@@ -177,15 +178,15 @@ Middleware modules receive `(request, { env, ctx })`. They run before actions, t
 
 The generated server serves static files from `dist/client/` (or the `public/` directory merged into it). These guards are active:
 
-| Attack vector                      | Guard                                                                                                                                  |
-| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
-| **Traversal** (`%2e%2e/`, `..%2f`) | `__rel()` rejects paths containing `..` segments.                                                                                      |
-| **Double-slash** (`///etc/passwd`) | `__rel()` rejects results that still start with `/` after `slice(1)`.                                                                  |
-| **Null byte** (`%00`, `\0`)        | `__rel()` rejects paths containing null bytes before and after `decodeURIComponent`.                                                   |
-| **Absolute path** (`/etc/passwd`)  | `__rel()` returns `null` for paths not starting with `/`.                                                                              |
-| **SPA fallback**                   | Unknown paths → `index.html`, never a directory listing.                                                                               |
-| **`clientDir` escape**             | `resolveOptions` throws at build time if `clientDir` resolves outside `outDir`.                                                        |
-| **Hashed assets**                  | Files matching `[-.][0-9a-f]{8,}.ext` get `Cache-Control: public, max-age=31536000, immutable`. Other files are not cached by default. |
+| Attack vector | Guard |
+| --- | --- |
+| **Traversal** (`%2e%2e/`, `..%2f`) | `__rel()` rejects paths containing `..` segments. |
+| **Double-slash** (`///etc/passwd`) | `__rel()` rejects results that still start with `/` after `slice(1)`. |
+| **Null byte** (`%00`, `\0`) | `__rel()` rejects paths containing null bytes before and after `decodeURIComponent`. |
+| **Absolute path** (`/etc/passwd`) | `__rel()` returns `null` for paths not starting with `/`. |
+| **SPA fallback** | Unknown paths → `index.html`, never a directory listing. |
+| **`clientDir` escape** | `resolveOptions` throws at build time if `clientDir` resolves outside `outDir`. |
+| **Hashed assets** | Files matching `[-.][0-9a-f]{8,}.ext` get `Cache-Control: public, max-age=31536000, immutable`. Other files are not cached by default. |
 
 The generated `__asset` function uses `path.join` — not `path.resolve` — so a leading `/` in the relative path stays inside the asset root.
 
@@ -201,6 +202,7 @@ The generated `__asset` function uses `path.join` — not `path.resolve` — so
 - 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.
+- StackBlitz WebContainers do not keep `AsyncLocalStorage` across `async/await`. Oxide detects `process.versions.webcontainer` and falls back to a sync request store, capturing context before Effect schedules work and serializing handler entry so concurrent requests do not stomp that store. Stream pulls re-enter the captured store. This is a demo/dev workaround, not a concurrency model for production.
 
 ### Host header
 

package/client.d.ts

@@ -1,10 +1,16 @@
-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>;
+interface AsyncGenerator<
+  T = unknown,
+  TReturn = unknown,
+  TNext = unknown,
+> extends AsyncIteratorObject<T, TReturn, TNext> {
+  then: <TResult1 = AsyncIterable<T>, TResult2 = never>(
+    onfulfilled?:
+      | ((value: AsyncIterable<T>) => TResult1 | PromiseLike<TResult1>)
+      | null,
+    onrejected?:
+      | ((
+          reason: Error | string | number | boolean | null | undefined
+        ) => TResult2 | PromiseLike<TResult2>)
+      | null
+  ) => Promise<TResult1 | TResult2>;
 }

package/dist/client-DOfB6wxk.mjs

@@ -0,0 +1,207 @@
+import { n as inWebcontainer } from "./context-DUN_VWJF.mjs";
+import { Effect, Layer, Scope, Stream } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { RpcClient, RpcSchema, RpcSerialization } from "effect/unstable/rpc";
+import { Socket } from "effect/unstable/socket";
+//#region src/rpc/stream.ts
+const onAsyncIterableError = function onAsyncIterableError(cause) {
+	return cause instanceof Error ? cause : new Error(String(cause));
+};
+const asyncGenToStream = function asyncGenToStream(gen) {
+	return Stream.fromAsyncIterable(gen, onAsyncIterableError);
+};
+/** Serialize WebContainer stream pulls so the shared syncStore is not stomped. */
+let pullTail = Promise.resolve(null);
+/**
+* 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.
+*/
+const bindAsyncGenContext = function bindAsyncGenContext(gen, run) {
+	const runPull = function runPull(fn) {
+		if (!inWebcontainer()) return run(fn);
+		const { promise: gate, resolve: release } = Promise.withResolvers();
+		const prev = pullTail;
+		pullTail = gate;
+		return async function runSerialized() {
+			await prev;
+			try {
+				return await run(fn);
+			} finally {
+				release(null);
+			}
+		}();
+	};
+	return {
+		next: (...args) => runPull(() => gen.next(...args)),
+		return: (...args) => runPull(() => gen.return(...args)),
+		throw: (...args) => runPull(() => gen.throw(...args)),
+		[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`. */
+const asyncGenToStreamInContext = function asyncGenToStreamInContext(create, run) {
+	return asyncGenToStream(bindAsyncGenContext(run(create), run));
+};
+const streamToAsyncGen = function streamToAsyncGen(stream) {
+	return Stream.toAsyncIterable(stream);
+};
+//#endregion
+//#region src/rpc/client.ts
+const clientCache = /* @__PURE__ */ new Map();
+let nextGroupId = 0;
+const isStringPropertyKey = function isStringPropertyKey(key) {
+	return typeof key === "string";
+};
+const normalizeActionHeaders = function normalizeActionHeaders(headers) {
+	if (Array.isArray(headers)) {
+		const out = {};
+		for (const [key, value] of headers) out[key] = value;
+		return out;
+	}
+	return headers;
+};
+const cacheKey = function cacheKey(group, options) {
+	let headerKey = "";
+	if (options.headers) {
+		const entries = Object.entries(normalizeActionHeaders(options.headers));
+		entries.sort(([a], [b]) => a.localeCompare(b));
+		headerKey = entries.map(([k, v]) => `${k}=${v}`).join("&");
+	}
+	const stamped = group;
+	let groupId = stamped.__oxideClientId;
+	if (groupId === void 0) {
+		nextGroupId += 1;
+		groupId = nextGroupId;
+		stamped.__oxideClientId = groupId;
+	}
+	return `${groupId}|${options.transport ?? "http"}|${options.url}|${headerKey}`;
+};
+const httpLayer = function httpLayer(options) {
+	const { headers } = options;
+	if (!headers) return RpcClient.layerProtocolHttp({ url: options.url }).pipe(Layer.provide(RpcSerialization.layerNdJsonRpc()), Layer.provide(FetchHttpClient.layer));
+	const headerMap = normalizeActionHeaders(headers);
+	return RpcClient.layerProtocolHttp({
+		transformClient: (client) => HttpClient.mapRequest(client, (req) => {
+			let next = req;
+			for (const [key, value] of Object.entries(headerMap)) next = HttpClientRequest.setHeader(next, key, value);
+			return next;
+		}),
+		url: options.url
+	}).pipe(Layer.provide(RpcSerialization.layerNdJsonRpc()), Layer.provide(FetchHttpClient.layer));
+};
+const wsLayer = function wsLayer(url) {
+	return RpcClient.layerProtocolSocket().pipe(Layer.provide(RpcSerialization.layerNdJsonRpc()), Layer.provide(Socket.layerWebSocket(url)), Layer.provide(Socket.layerWebSocketConstructorGlobal));
+};
+const clientLayer = function clientLayer(options) {
+	return options.transport === "ws" ? wsLayer(options.url) : httpLayer(options);
+};
+const loadClient = function loadClient(group, options) {
+	return Effect.gen(function* loadClientGen() {
+		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)));
+	});
+};
+const isStreamResult = function isStreamResult(value) {
+	return Stream.isStream(value);
+};
+const isStreamTag = function isStreamTag(group, tag) {
+	const rpc = group.requests.get(tag);
+	if (!rpc?.successSchema) return false;
+	return RpcSchema.isStreamSchema(rpc.successSchema);
+};
+const streamToAsyncGenerator = function streamToAsyncGenerator(stream, signal) {
+	const iterable = streamToAsyncGen(stream);
+	return (async function* streamProxy() {
+		if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+		const iterator = iterable[Symbol.asyncIterator]();
+		const onAbort = function onAbort() {
+			iterator.return?.();
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+		const pull = async function* pull() {
+			for (;;) {
+				if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+				const next = await iterator.next();
+				if (next.done) return;
+				yield next.value;
+			}
+		};
+		try {
+			yield* pull();
+		} finally {
+			signal?.removeEventListener("abort", onAbort);
+		}
+	})();
+};
+const callFlat = 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 });
+};
+const isCallOptions = function isCallOptions(value) {
+	return value !== null && typeof value === "object" && "signal" in value && value.signal instanceof AbortSignal && Object.keys(value).length === 1;
+};
+const nestClient = 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 !== void 0 && isCallOptions(opts);
+			const params = hasSignal ? args.slice(0, -1) : args;
+			return callFlat(flat, tag, params, hasSignal ? opts : void 0);
+		};
+	}
+	return nested;
+};
+const createClient = function createClient(group, options) {
+	const key = cacheKey(group, options);
+	let entry = clientCache.get(key);
+	if (!entry) {
+		entry = { pending: (async function loadNestedClient() {
+			try {
+				const flat = await Effect.runPromise(loadClient(group, options));
+				return nestClient(group, flat);
+			} catch (error) {
+				clientCache.delete(key);
+				throw error;
+			}
+		})() };
+		clientCache.set(key, entry);
+	}
+	const cached = entry;
+	return new Proxy({}, { get(_target, mod) {
+		if (!isStringPropertyKey(mod)) return;
+		return new Proxy({}, { get(_inner, name) {
+			if (!isStringPropertyKey(name)) return;
+			const tag = `${mod}.${name}`;
+			if (isStreamTag(group, tag)) return (...args) => (async function* streamAction() {
+				const out = (await cached.pending)[mod]?.[name]?.(...args);
+				if (!out) throw new Error(`Unknown action ${mod}.${name}`);
+				yield* out;
+			})();
+			return async (...args) => {
+				const out = (await cached.pending)[mod]?.[name]?.(...args);
+				if (!out) throw new Error(`Unknown action ${mod}.${name}`);
+				return out;
+			};
+		} });
+	} });
+};
+//#endregion
+export { streamToAsyncGen as a, bindAsyncGenContext as i, asyncGenToStream as n, asyncGenToStreamInContext as r, createClient as t };

package/dist/context-CmChiQ2W.d.mts

@@ -0,0 +1,98 @@
+import { r as OxidejsJson } from "./types-BaZeMYcP.mjs";
+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;
+interface CallOptions {
+  signal?: AbortSignal;
+}
+interface 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;
+}
+interface 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 const 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 const 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 const 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
+interface ExecutionContext {
+  passThroughOnException?: () => void;
+  waitUntil?: (promise: PromiseLike<OxidejsJson | object | null | undefined>) => void;
+}
+/** Return from `src/server.ts` `fetch`. `undefined` falls through to assets. */
+type FetchResult = Response | undefined;
+/**
+ * `src/server.ts` fetch handler. The generated wrapper always calls
+ * `fetch(request, env, ctx)` — `env` may be `{}` on Node without the `env` option.
+ * Return `undefined` (or bare `return`) to fall through to assets.
+ */
+type FetchHandler<Env extends object = {
+  [key: string]: OxidejsJson;
+}> = (request: Request, env: Env, ctx: ExecutionContext) => FetchResult | Promise<FetchResult>;
+/** Default export shape for `src/server.ts`. */
+interface ServerEntry<Env extends object = {
+  [key: string]: OxidejsJson;
+}> {
+  fetch: FetchHandler<Env>;
+}
+/** Values middleware may attach on the request context bag. */
+type ActionContextValue = Request | ExecutionContext | OxidejsJson | {
+  [key: string]: OxidejsJson;
+} | undefined;
+/** RPC procedure request context. Starts as `{ req }` plus Worker extras. Middleware can add fields. */
+interface ActionContext {
+  [key: string]: ActionContextValue;
+  req: Request;
+  env?: {
+    [key: string]: OxidejsJson;
+  };
+  fetchCtx?: ExecutionContext;
+}
+/** Current request context: ALS first, then the WebContainer sync fallback. */
+declare const 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 const withRequestStore: <T>(ctx: ActionContext, fn: () => T) => T;
+/** Current RPC or host request context. Throws outside request handling. */
+declare const useCtx: <C extends ActionContext = ActionContext>() => C;
+/** Current server `Request`. Available in actions, SSR, and frame renders. */
+declare const useRequest: () => Request;
+/** Worker `env` from `fetch(request, env, ctx)`. `undefined` on the Node fetch preset. */
+declare const useEnv: <E = {
+  [key: string]: OxidejsJson;
+}>() => E | undefined;
+/** Worker `ctx` from `fetch(request, env, ctx)` (`waitUntil`). `undefined` on Node. */
+declare const useFetchCtx: () => ExecutionContext | undefined;
+//#endregion
+export { brandServerAction as _, FetchResult as a, useCtx as c, useRequest as d, withRequestStore as f, action as g, StreamActionHandle as h, FetchHandler as i, useEnv as l, ServerActionHandle as m, ActionContextValue as n, ServerEntry as o, ACTION_CALL as p, ExecutionContext as r, getRequestStore as s, ActionContext as t, useFetchCtx as u, wrapClientRpc as v, wrapClientStreamRpc as y };

package/dist/context-DUN_VWJF.mjs

@@ -0,0 +1,108 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import process from "node:process";
+//#region src/context.ts
+const ALS_KEY = Symbol.for("oxidejs.requestContext");
+const FETCH_KEY = Symbol.for("oxidejs.fetch");
+/** StackBlitz WebContainers lose AsyncLocalStorage across `async/await`. */
+const inWebcontainer = function inWebcontainer() {
+	if (process === void 0) return false;
+	const versions = process.versions;
+	return Boolean(versions.webcontainer);
+};
+/** Module fallback when ALS does not survive awaits (WebContainer). */
+let syncStore = null;
+/** Serialize handler *entry* on WebContainer so syncStore is not stomped. */
+let entryTail = Promise.resolve(null);
+const als = function als() {
+	const g = globalThis;
+	const existing = g[ALS_KEY];
+	if (existing) return existing;
+	const created = new AsyncLocalStorage();
+	g[ALS_KEY] = created;
+	return created;
+};
+const isPromiseLike = function isPromiseLike(value) {
+	if (value === null || value === void 0) return false;
+	return typeof value.then === "function";
+};
+/** Current request context: ALS first, then the WebContainer sync fallback. */
+const getRequestStore = function getRequestStore() {
+	const current = als().getStore() ?? syncStore;
+	if (!current) throw new Error("oxidejs: request context is unavailable");
+	return current;
+};
+const store = function store() {
+	return getRequestStore();
+};
+/**
+* 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.
+*/
+const withRequestStore = function withRequestStore(ctx, fn) {
+	const previous = syncStore;
+	syncStore = ctx;
+	let deferRestore = false;
+	try {
+		const result = als().run(ctx, fn);
+		if (inWebcontainer() && isPromiseLike(result)) {
+			deferRestore = true;
+			return (async () => {
+				try {
+					return await result;
+				} finally {
+					if (syncStore === ctx) syncStore = previous;
+				}
+			})();
+		}
+		return result;
+	} finally {
+		if (!deferRestore) syncStore = previous;
+	}
+};
+/**
+* Serialize async work that installs request context on WebContainer.
+* Release as soon as `fn` settles — do not wait for streamed response bodies.
+*/
+const withRequestEntry = async function withRequestEntry(fn) {
+	if (!inWebcontainer()) return fn();
+	const { promise: gate, resolve: release } = Promise.withResolvers();
+	const previous = entryTail;
+	entryTail = gate;
+	await previous;
+	try {
+		return await fn();
+	} finally {
+		release(null);
+	}
+};
+/** Current RPC or host request context. Throws outside request handling. */
+const useCtx = function useCtx() {
+	return store();
+};
+/** Current server `Request`. Available in actions, SSR, and frame renders. */
+const useRequest = function useRequest() {
+	return store().req;
+};
+/** Worker `env` from `fetch(request, env, ctx)`. `undefined` on the Node fetch preset. */
+const useEnv = function useEnv() {
+	return store().env;
+};
+/** Worker `ctx` from `fetch(request, env, ctx)` (`waitUntil`). `undefined` on Node. */
+const useFetchCtx = function useFetchCtx() {
+	return store().fetchCtx;
+};
+const runWithRequest = function runWithRequest(req, fn, extra) {
+	return withRequestStore({
+		...extra,
+		req
+	}, fn);
+};
+const HOOK_KEY = Symbol.for("oxidejs.runWithRequest");
+const hookGlobal = globalThis;
+hookGlobal[HOOK_KEY] ??= function oxideRunWithRequest(req, fn) {
+	return runWithRequest(req, fn, req[FETCH_KEY]);
+};
+//#endregion
+export { useEnv as a, withRequestEntry as c, useCtx as i, withRequestStore as l, inWebcontainer as n, useFetchCtx as o, runWithRequest as r, useRequest as s, getRequestStore as t };

package/dist/index.d.mts

@@ -1,3 +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";
-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 };
+import { a as OxidejsPreset, i as OxidejsOptions, n as OxidejsActionTransport, o as OxidejsWranglerOptions, s as ResolvedOptions, t as OxidejsActionHeaders } from "./types-BaZeMYcP.mjs";
+import { _ as brandServerAction, a as FetchResult, c as useCtx, d as useRequest, f as withRequestStore, g as action, h as StreamActionHandle, i as FetchHandler, l as useEnv, m as ServerActionHandle, o as ServerEntry, p as ACTION_CALL, r as ExecutionContext, s as getRequestStore, t as ActionContext, u as useFetchCtx, v as wrapClientRpc, y as wrapClientStreamRpc } from "./context-CmChiQ2W.mjs";
+export { ACTION_CALL, type ActionContext, type ExecutionContext, type FetchHandler, type FetchResult, type OxidejsActionHeaders, type OxidejsActionTransport, type OxidejsOptions, type OxidejsPreset, type OxidejsWranglerOptions, type ResolvedOptions, type ServerActionHandle, type ServerEntry, type StreamActionHandle, action, brandServerAction, getRequestStore, useCtx, useEnv, useFetchCtx, useRequest, withRequestStore, wrapClientRpc, wrapClientStreamRpc };