@ilha/router 0.11.5 → 0.11.6

package/dist/{head-BLtm0xtK.js → head-WG_AtbdX.js}

@@ -35,8 +35,36 @@ const ILHA_ROUTER_HTML_ATTR = "data-ilha-router-html";
 const ILHA_ROUTER_BODY_ATTR = "data-ilha-router-body";
 /** Browser-only fallback; SSR uses AsyncLocalStorage (see `withHeadStore`). */
 let _browserHeadStore = null;
+/** WebContainer fallback while a serialized `withHeadStore` entry is in flight. */
+let _headSyncStore = null;
+/** Serialize WebContainer head entries so overlapping renders cannot share sync state. */
+let _headFallbackTail = Promise.resolve(null);
 let _headAls = null;
 let _headAlsInit = null;
+let _headWcOverride = null;
+/** When true, activeHeadStore skips ALS so tests exercise the sync fallback. */
+let _headAlsBypassForTests = false;
+const headInWebcontainer = () => {
+	if (_headWcOverride !== null) return _headWcOverride;
+	if (isBrowser) return false;
+	try {
+		const versions = globalThis.process?.versions;
+		return Boolean(versions?.webcontainer);
+	} catch {
+		return false;
+	}
+};
+const withHeadFallbackEntry = async (fn) => {
+	const previous = _headFallbackTail;
+	const next = Promise.withResolvers();
+	_headFallbackTail = next.promise;
+	await previous;
+	try {
+		return await fn();
+	} finally {
+		next.resolve(null);
+	}
+};
 /** ESM dynamic import — Nitro/Vite SSR workers have no `require`. */
 const getHeadAlsAsync = async () => {
 	if (_headAls) return _headAls;
@@ -52,7 +80,8 @@ const getHeadAlsAsync = async () => {
 };
 const activeHeadStore = () => {
 	if (isBrowser) return _browserHeadStore;
-	return _headAls?.getStore() ?? null;
+	if (_headAlsBypassForTests) return _headSyncStore;
+	return _headAls?.getStore() ?? _headSyncStore ?? null;
 };
 const cssEscapeAttr = (value) => {
 	const cssApi = globalThis.CSS;
@@ -231,7 +260,17 @@ const withHeadStore = async (store, fn) => {
 			_browserHeadStore = prev;
 		}
 	}
-	return await (await getHeadAlsAsync()).run(store, () => Promise.resolve(fn()));
+	const als = await getHeadAlsAsync();
+	if (!headInWebcontainer()) return await als.run(store, () => Promise.resolve(fn()));
+	return withHeadFallbackEntry(async () => {
+		const previous = _headSyncStore;
+		_headSyncStore = store;
+		try {
+			return await als.run(store, () => Promise.resolve(fn()));
+		} finally {
+			_headSyncStore = previous;
+		}
+	});
 };
 let _flushScheduled = false;
 let _flushTarget = null;

package/dist/head.d.ts

@@ -42,6 +42,10 @@ export interface SerializedHead {
 export interface HeadStore {
     entries: HeadInput[];
 }
+/** Test-only: force WebContainer head fallback (mirrors request-scope). */
+export declare const __setHeadInWebcontainerForTests: (value: boolean | null) => void;
+/** Test-only: force activeHeadStore to skip ALS (simulates WebContainer ALS loss). */
+export declare const __setHeadAlsBypassForTests: (value: boolean) => void;
 export declare const cssEscapeAttr: (value: string) => string;
 export declare const escapeHeadAttr: <T>(value: T) => string;
 /** Escape text content for inline HTML (loader error messages etc.). */

package/dist/index.js

@@ -1,5 +1,5 @@
 import { t as REQUEST_ALS_KEY } from "./als-key-CVxbuM3z.js";
-import { a as withHeadStore, i as serializeHead, n as head, r as openBrowserHead, t as applyHeadEntriesToDocument } from "./head-BLtm0xtK.js";
+import { a as withHeadStore, i as serializeHead, n as head, r as openBrowserHead, t as applyHeadEntriesToDocument } from "./head-WG_AtbdX.js";
 import { h, mount, renderToString } from "ilha";
 
 //#region src/hash.ts

package/dist/{plugin-DCdQ9yO8.js → plugin-Ci-W2rMt.js}

@@ -1,4 +1,4 @@
-import { C as runWithIslandRequest, a as authorizeFrameRequest, b as setFrameAuth, c as frameScopedUrl, f as isSafeFramePath, h as parseFrameProps, n as FrameError, s as frameEnvelope, u as getFrameGuard, x as setFrameGuard, y as renderServerIslandResult } from "./ssr-Dvq_qXs4.js";
+import { C as runWithIslandRequest, a as authorizeFrameRequest, b as setFrameAuth, c as frameScopedUrl, f as isSafeFramePath, h as parseFrameProps, n as FrameError, s as frameEnvelope, u as getFrameGuard, x as setFrameGuard, y as renderServerIslandResult } from "./ssr-D9q5C-OV.js";
 import { existsSync, readFileSync, statSync, watch } from "node:fs";
 import path from "node:path";
 import * as Result from "effect/Result";
@@ -892,7 +892,7 @@ const renderAuthorizedFrame = async (req, res, ctx, raw, serverOrigin, identityH
 		headers: identityHeaders,
 		method: "POST"
 	});
-	const result = await renderServerIslandResult(body.id ?? "", request, (r, fn) => runWithIslandRequest(r, fn), incomingProps);
+	const result = await renderServerIslandResult(body.id ?? "", request, (r, fn) => Promise.resolve(runWithIslandRequest(r, fn)), incomingProps);
 	if (Result.isFailure(result)) {
 		const err = result.failure;
 		if (err.redirect) {

package/dist/request-scope.d.ts

@@ -12,10 +12,24 @@
  * is `useContext()` from the main `@ilha/router` entry, which reads the
  * storage without importing `node:async_hooks`; this node-only module is the
  * sole place that constructs it.
+ *
+ * StackBlitz WebContainers lose AsyncLocalStorage across `async/await`. A
+ * module sync fallback keeps `useContext().request` readable, and unrelated
+ * fallback entries are serialized so concurrent renders cannot stomp each
+ * other. Nested calls reenter only while owned by the active entry (sync nest
+ * or ALS owner) so a suspended outer cannot admit unrelated concurrent work.
  */
 export { REQUEST_ALS_KEY } from "./als-key";
+export { __setInWebcontainerForTests } from "./webcontainer";
 export type { IslandContext } from "./index";
-/** Run `fn` with `request` available to `useContext().request`. When oxidejs
+/** Test-only: force getStore() to skip ALS (simulates WebContainer ALS loss). */
+export declare const __setAlsBypassForTests: (value: boolean) => void;
+/**
+ * Run `fn` with `request` available to `useContext().request`. When oxidejs
  * is loaded, its action scope is entered too, so `useRequest()` works in
- * island renders and streamed frames. */
-export declare const runWithIslandRequest: <T>(request: Request, fn: () => T) => T;
+ * island renders and streamed frames.
+ *
+ * On WebContainer the return is always a `Promise` (fallback lock). Elsewhere
+ * the return matches `fn` (sync or async).
+ */
+export declare const runWithIslandRequest: <T>(request: Request, fn: () => T) => T | Promise<Awaited<T>>;

package/dist/rsbuild.js

@@ -1,4 +1,4 @@
-import { t as ilhaPages } from "./plugin-DCdQ9yO8.js";
+import { t as ilhaPages } from "./plugin-Ci-W2rMt.js";
 
 //#region src/rsbuild.ts
 /** Rsbuild plugin — use via `@ilha/router/rsbuild`. */

package/dist/server-island.js

@@ -1,4 +1,4 @@
-import { t as applyHeadEntriesToDocument } from "./head-BLtm0xtK.js";
+import { t as applyHeadEntriesToDocument } from "./head-WG_AtbdX.js";
 import { t as parseSnapshotAttr } from "./snapshot-XpAkSV8s.js";
 
 //#region src/server-island.ts

package/dist/{ssr-Dvq_qXs4.js → ssr-D9q5C-OV.js}

@@ -1,5 +1,5 @@
 import { t as REQUEST_ALS_KEY } from "./als-key-CVxbuM3z.js";
-import { a as withHeadStore } from "./head-BLtm0xtK.js";
+import { a as withHeadStore } from "./head-WG_AtbdX.js";
 import { n as sanitizeSnapshotObject } from "./snapshot-XpAkSV8s.js";
 import { renderToString } from "ilha";
 import * as Result from "effect/Result";
@@ -8,6 +8,25 @@ import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import { action, brandServerAction } from "oxidejs";
 
+//#region src/webcontainer.ts
+/**
+* StackBlitz WebContainer detection for AsyncLocalStorage fallbacks.
+* Safe to import from browser-shared modules: on the client this always
+* returns false (no `process.versions.webcontainer`).
+*/
+let webcontainerOverride = null;
+/** StackBlitz sets `process.versions.webcontainer` inside WebContainers. */
+const inWebcontainer = () => {
+	if (webcontainerOverride !== null) return webcontainerOverride;
+	try {
+		const versions = globalThis.process?.versions;
+		return Boolean(versions?.webcontainer);
+	} catch {
+		return false;
+	}
+};
+
+//#endregion
 //#region src/request-scope.ts
 /**
 * Request scope for server-owned island rendering.
@@ -23,25 +42,86 @@ import { action, brandServerAction } from "oxidejs";
 * is `useContext()` from the main `@ilha/router` entry, which reads the
 * storage without importing `node:async_hooks`; this node-only module is the
 * sole place that constructs it.
+*
+* StackBlitz WebContainers lose AsyncLocalStorage across `async/await`. A
+* module sync fallback keeps `useContext().request` readable, and unrelated
+* fallback entries are serialized so concurrent renders cannot stomp each
+* other. Nested calls reenter only while owned by the active entry (sync nest
+* or ALS owner) so a suspended outer cannot admit unrelated concurrent work.
 */
 /** Installed by oxidejs when its module loads. Lets `useRequest()` resolve
 * inside island renders and frames, not just `/__oxide/action`. */
 const OXIDE_RUN_WITH_REQUEST = Symbol.for("oxidejs.runWithRequest");
-/** Run `fn` with `request` available to `useContext().request`. When oxidejs
-* is loaded, its action scope is entered too, so `useRequest()` works in
-* island renders and streamed frames. */
-const runWithIslandRequest = (request, fn) => {
+const innerAls = new AsyncLocalStorage();
+/** Tracks the active fallback lock owner across awaits where ALS survives. */
+const entryOwnerAls = new AsyncLocalStorage();
+let syncStore = null;
+/** When true, getStore ignores ALS so tests exercise the sync fallback path. */
+let alsBypassForTests = false;
+/** Serialize unrelated WebContainer fallback entries (set syncStore → run → clear). */
+let fallbackTail = Promise.resolve(null);
+/** Lock holder identity — nested reentry requires matching ALS owner (or sync nest). */
+let activeOwner = null;
+/**
+* Sync-only nest depth while `runScoped` is invoking `fn`. Lets nested
+* `runWithIslandRequest` reenter before `fn` awaits; cleared before awaiting
+* so a suspended entry does not admit unrelated concurrent requests.
+*/
+let syncNestDepth = 0;
+const withFallbackEntry = async (fn) => {
+	const owner = alsBypassForTests ? void 0 : entryOwnerAls.getStore();
+	if (syncNestDepth > 0 || owner !== void 0 && owner === activeOwner) return await fn();
+	const previous = fallbackTail;
+	const next = Promise.withResolvers();
+	fallbackTail = next.promise;
+	await previous;
+	const myOwner = {};
+	activeOwner = myOwner;
+	try {
+		return await entryOwnerAls.run(myOwner, fn);
+	} finally {
+		activeOwner = null;
+		next.resolve(null);
+	}
+};
+const ensureScope = () => {
 	const g = globalThis;
 	const existing = g[REQUEST_ALS_KEY];
-	let als;
-	if (existing instanceof AsyncLocalStorage) als = existing;
-	else {
-		als = new AsyncLocalStorage();
-		g[REQUEST_ALS_KEY] = als;
-	}
-	const oxideSlot = g[OXIDE_RUN_WITH_REQUEST];
+	if (existing && "getStore" in existing) return existing;
+	const scope = { getStore: () => (alsBypassForTests ? void 0 : innerAls.getStore()) ?? syncStore ?? void 0 };
+	g[REQUEST_ALS_KEY] = scope;
+	return scope;
+};
+const runScoped = (request, oxide, fn) => innerAls.run(request, () => oxide ? oxide(request, fn) : fn());
+/**
+* Run `fn` with `request` available to `useContext().request`. When oxidejs
+* is loaded, its action scope is entered too, so `useRequest()` works in
+* island renders and streamed frames.
+*
+* On WebContainer the return is always a `Promise` (fallback lock). Elsewhere
+* the return matches `fn` (sync or async).
+*/
+const runWithIslandRequest = (request, fn) => {
+	ensureScope();
+	const oxideSlot = globalThis[OXIDE_RUN_WITH_REQUEST];
 	const oxide = oxideSlot === void 0 ? void 0 : oxideSlot;
-	return als.run(request, () => oxide ? oxide(request, fn) : fn());
+	if (!inWebcontainer()) return runScoped(request, oxide, fn);
+	return withFallbackEntry(async () => {
+		const previous = syncStore;
+		syncStore = request;
+		try {
+			syncNestDepth += 1;
+			let result;
+			try {
+				result = runScoped(request, oxide, fn);
+			} finally {
+				syncNestDepth -= 1;
+			}
+			return await Promise.resolve(result);
+		} finally {
+			syncStore = previous;
+		}
+	});
 };
 
 //#endregion

package/dist/ssr.js

@@ -1,3 +1,3 @@
-import { S as ssrWithImports, _ as registerServerIsland, a as authorizeFrameRequest, b as setFrameAuth, c as frameScopedUrl, d as getServerIslandEntry, f as isSafeFramePath, g as readBodyBounded, h as parseFrameProps, i as __ilhaServerAction, l as getFrameAuth, m as json, n as FrameError, o as forwardIdentityHeaders, p as isTrustedOrigin, r as MAX_BODY, s as frameEnvelope, t as FRAME_ENDPOINT, u as getFrameGuard, v as renderServerIsland, x as setFrameGuard, y as renderServerIslandResult } from "./ssr-Dvq_qXs4.js";
+import { S as ssrWithImports, _ as registerServerIsland, a as authorizeFrameRequest, b as setFrameAuth, c as frameScopedUrl, d as getServerIslandEntry, f as isSafeFramePath, g as readBodyBounded, h as parseFrameProps, i as __ilhaServerAction, l as getFrameAuth, m as json, n as FrameError, o as forwardIdentityHeaders, p as isTrustedOrigin, r as MAX_BODY, s as frameEnvelope, t as FRAME_ENDPOINT, u as getFrameGuard, v as renderServerIsland, x as setFrameGuard, y as renderServerIslandResult } from "./ssr-D9q5C-OV.js";
 
 export { FRAME_ENDPOINT, FrameError, MAX_BODY, __ilhaServerAction, authorizeFrameRequest, ssrWithImports as default, forwardIdentityHeaders, frameEnvelope, frameScopedUrl, getFrameAuth, getFrameGuard, getServerIslandEntry, isSafeFramePath, isTrustedOrigin, json, parseFrameProps, readBodyBounded, registerServerIsland, renderServerIsland, renderServerIslandResult, setFrameAuth, setFrameGuard };

package/dist/vite.js

@@ -1,4 +1,4 @@
-import { t as ilhaPages } from "./plugin-DCdQ9yO8.js";
+import { t as ilhaPages } from "./plugin-Ci-W2rMt.js";
 
 //#region src/vite.ts
 /** Vite plugin — use via `@ilha/router/vite`. */

package/dist/webcontainer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * StackBlitz WebContainer detection for AsyncLocalStorage fallbacks.
+ * Safe to import from browser-shared modules: on the client this always
+ * returns false (no `process.versions.webcontainer`).
+ */
+/** StackBlitz sets `process.versions.webcontainer` inside WebContainers. */
+export declare const inWebcontainer: () => boolean;
+/** Test-only: force or clear the WebContainer detection path. */
+export declare const __setInWebcontainerForTests: (value: boolean | null) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilha/router",
-  "version": "0.11.5",
+  "version": "0.11.6",
   "description": "A tiny SPA router for Ilha",
   "keywords": [
     "frontend",
@@ -74,12 +74,12 @@
   },
   "devDependencies": {
     "ilha": "^0.14.4",
-    "oxidejs": "^0.3.1",
+    "oxidejs": "^0.3.2",
     "vite": "^8.2.2"
   },
   "peerDependencies": {
     "ilha": ">=0.14.4",
-    "oxidejs": ">=0.3.1"
+    "oxidejs": ">=0.3.2"
   },
   "peerDependenciesMeta": {
     "oxidejs": {