hadars 0.1.24 → 0.1.26

package/src/slim-react/render.ts

@@ -33,7 +33,8 @@ import {
   pushContextValue,
   popContextValue,
   getContextValue,
-  runWithContextStore,
+  swapContextMap,
+  captureMap,
 } from "./renderContext";
 
 // ---------------------------------------------------------------------------
@@ -613,7 +614,11 @@ function renderComponent(
     };
     const r = renderChildren(props.children, writer, isSvg);
     if (r && typeof (r as any).then === "function") {
-      return (r as Promise<void>).then(finish, (e) => { finish(); throw e; });
+      const m = captureMap();
+      return (r as Promise<void>).then(
+        () => { swapContextMap(m); finish(); },
+        (e) => { swapContextMap(m); finish(); throw e; },
+      );
     }
     finish();
     return;
@@ -645,19 +650,29 @@ function renderComponent(
 
   // Async component
   if (result instanceof Promise) {
+    const m = captureMap();
     return result.then((resolved) => {
+      swapContextMap(m);
       const r = renderNode(resolved, writer, isSvg);
       if (r && typeof (r as any).then === "function") {
-        return (r as Promise<void>).then(finish, (e) => { finish(); throw e; });
+        const m2 = captureMap();
+        return (r as Promise<void>).then(
+          () => { swapContextMap(m2); finish(); },
+          (e) => { swapContextMap(m2); finish(); throw e; },
+        );
       }
       finish();
-    }, (e) => { finish(); throw e; });
+    }, (e) => { swapContextMap(m); finish(); throw e; });
   }
 
   const r = renderNode(result, writer, isSvg);
 
   if (r && typeof (r as any).then === "function") {
-    return (r as Promise<void>).then(finish, (e) => { finish(); throw e; });
+    const m = captureMap();
+    return (r as Promise<void>).then(
+      () => { swapContextMap(m); finish(); },
+      (e) => { swapContextMap(m); finish(); throw e; },
+    );
   }
   finish();
 }
@@ -691,7 +706,9 @@ function renderChildArray(
     const r = renderNode(children[i], writer, isSvg);
     if (r && typeof (r as any).then === "function") {
       // One child went async – continue the rest asynchronously
+      const m = captureMap();
       return (r as Promise<void>).then(() => {
+        swapContextMap(m);
         popTreeContext(savedTree);
         // Continue with remaining children
         return renderChildArrayFrom(children, i + 1, writer, isSvg);
@@ -716,7 +733,9 @@ function renderChildArrayFrom(
     const savedTree = pushTreeContext(totalChildren, i);
     const r = renderNode(children[i], writer, isSvg);
     if (r && typeof (r as any).then === "function") {
+      const m = captureMap();
       return (r as Promise<void>).then(() => {
+        swapContextMap(m);
         popTreeContext(savedTree);
         return renderChildArrayFrom(children, i + 1, writer, isSvg);
       });
@@ -765,7 +784,7 @@ async function renderSuspense(
       const buffer = new BufferWriter();
       const r = renderNode(children, buffer, isSvg);
       if (r && typeof (r as any).then === "function") {
-        await r;
+        const m = captureMap(); await r; swapContextMap(m);
       }
       // Success – wrap with React's Suspense boundary markers so hydrateRoot
       // can locate the boundary in the DOM (<!--$--> … <!--/$-->).
@@ -775,7 +794,7 @@ async function renderSuspense(
       return;
     } catch (error: unknown) {
       if (error && typeof (error as any).then === "function") {
-        await (error as Promise<unknown>);
+        const m = captureMap(); await (error as Promise<unknown>); swapContextMap(m);
         attempts++;
       } else {
         throw error;
@@ -788,7 +807,9 @@ async function renderSuspense(
   writer.write("<!--$?-->");
   if (fallback) {
     const r = renderNode(fallback, writer, isSvg);
-    if (r && typeof (r as any).then === "function") await r;
+    if (r && typeof (r as any).then === "function") {
+      const m = captureMap(); await r; swapContextMap(m);
+    }
   }
   writer.write("<!--/$-->");
 }
@@ -806,9 +827,11 @@ async function renderSuspense(
 export function renderToStream(element: SlimNode): ReadableStream<Uint8Array> {
   const encoder = new TextEncoder();
 
-  return runWithContextStore(() => new ReadableStream({
+  const contextMap = new Map<object, unknown>();
+  return new ReadableStream({
     async start(controller) {
       resetRenderState();
+      const prev = swapContextMap(contextMap);
 
       const writer: Writer = {
         lastWasText: false,
@@ -824,13 +847,17 @@ export function renderToStream(element: SlimNode): ReadableStream<Uint8Array> {
 
       try {
         const r = renderNode(element, writer);
-        if (r && typeof (r as any).then === "function") await r;
+        if (r && typeof (r as any).then === "function") {
+          const m = captureMap(); await r; swapContextMap(m);
+        }
         controller.close();
       } catch (error) {
         controller.error(error);
+      } finally {
+        swapContextMap(prev);
       }
     },
-  }));
+  });
 }
 
 /**
@@ -838,10 +865,13 @@ export function renderToStream(element: SlimNode): ReadableStream<Uint8Array> {
  * Retries the full tree when a component throws a Promise (Suspense protocol),
  * so useServerData and similar hooks work without requiring explicit <Suspense>.
  */
-export function renderToString(element: SlimNode): Promise<string> {
-  return runWithContextStore(async () => {
+export async function renderToString(element: SlimNode): Promise<string> {
+  const contextMap = new Map<object, unknown>();
+  const prev = swapContextMap(contextMap);
+  try {
     for (let attempt = 0; attempt < MAX_SUSPENSE_RETRIES; attempt++) {
       resetRenderState();
+      swapContextMap(contextMap); // re-activate our map on each retry
       const chunks: string[] = [];
       const writer: Writer = {
         lastWasText: false,
@@ -850,18 +880,22 @@ export function renderToString(element: SlimNode): Promise<string> {
       };
       try {
         const r = renderNode(element, writer);
-        if (r && typeof (r as any).then === "function") await r;
+        if (r && typeof (r as any).then === "function") {
+          const m = captureMap(); await r; swapContextMap(m);
+        }
         return chunks.join("");
       } catch (error) {
         if (error && typeof (error as any).then === "function") {
-          await (error as Promise<unknown>);
+          const m = captureMap(); await (error as Promise<unknown>); swapContextMap(m);
           continue;
         }
         throw error;
       }
     }
     throw new Error("[slim-react] renderToString exceeded maximum retries");
-  });
+  } finally {
+    swapContextMap(prev);
+  }
 }
 
 /** Alias matching React 18+ server API naming. */

package/src/slim-react/renderContext.ts

@@ -5,66 +5,62 @@
  * multiple slim-react instances (the render worker's direct import and the
  * SSR bundle's bundled copy) share the same singletons without coordination.
  *
- * Context values are stored in an AsyncLocalStorage<Map> so each concurrent
- * SSR request gets its own isolated scope that propagates through all awaits.
- * Call `runWithContextStore` at the start of every render to establish the scope.
+ * Context values are stored in a plain Map that is created per render call.
+ * Node.js is single-threaded: only one render is executing between any two
+ * await points. The renderer captures the map reference before every await
+ * and restores it in the continuation, so concurrent renders stay isolated
+ * without any external dependencies.
  */
 
-// Shared AsyncLocalStorage instance — kept on globalThis so both copies of
-// slim-react (direct import + SSR bundle) use the same store.
-// The import is done with require() inside a try/catch so that bundlers that
-// cannot resolve node:async_hooks (e.g. rspack without target:node set) do
-// not fail at build time — the SSR render process always runs in Node.js and
-// will find the module at runtime regardless.
-const CONTEXT_STORE_KEY = "__slimReactContextStore";
+// The context map for the render that is currently executing (between awaits).
+// Kept on globalThis so both slim-react instances share the same slot.
+const MAP_KEY = "__slimReactContextMap";
 const _g = globalThis as any;
-if (!_g[CONTEXT_STORE_KEY]) {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { AsyncLocalStorage } = require("node:async_hooks") as typeof import("node:async_hooks");
-    _g[CONTEXT_STORE_KEY] = new AsyncLocalStorage<Map<object, unknown>>();
-  } catch {
-    // Fallback: no-op store — context values fall back to _defaultValue.
-    // This should never happen in a real SSR environment.
-    _g[CONTEXT_STORE_KEY] = null;
-  }
+if (!("__slimReactContextMap" in _g)) _g[MAP_KEY] = null;
+
+/**
+ * Swap in a new context map and return the previous one.
+ * Called at render entry-points and at every await/then continuation to
+ * restore the correct map for the resuming render.
+ */
+export function swapContextMap(
+  map: Map<object, unknown> | null,
+): Map<object, unknown> | null {
+  const prev: Map<object, unknown> | null = _g[MAP_KEY];
+  _g[MAP_KEY] = map;
+  return prev;
 }
-const _contextStore: { run<T>(store: Map<object,unknown>, fn: () => T): T; getStore(): Map<object,unknown> | undefined } | null = _g[CONTEXT_STORE_KEY];
 
-/** Wrap a render entry-point so it gets its own isolated context-value scope. */
-export function runWithContextStore<T>(fn: () => T): T {
-  return _contextStore ? _contextStore.run(new Map(), fn) : fn();
+/** Return the active map without changing it (used to capture before an await). */
+export function captureMap(): Map<object, unknown> | null {
+  return _g[MAP_KEY];
 }
 
-/**
- * Read the current value for a context within the active render.
- * Falls back to `_defaultValue` (or `_currentValue` for external contexts).
- */
+/** Read the current value for a context within the active render. */
 export function getContextValue<T>(context: object): T {
-  const store = _contextStore?.getStore();
-  if (store && store.has(context)) return store.get(context) as T;
+  const map: Map<object, unknown> | null = _g[MAP_KEY];
+  if (map && map.has(context)) return map.get(context) as T;
   const c = context as any;
   return ("_defaultValue" in c ? c._defaultValue : c._currentValue) as T;
 }
 
 /**
- * Push a new value for a context Provider onto the per-request store.
- * Returns the previous value so the caller can restore it later.
+ * Push a new Provider value into the active map.
+ * Returns the previous value so the caller can restore it on exit.
  */
 export function pushContextValue(context: object, value: unknown): unknown {
-  const store = _contextStore?.getStore();
+  const map: Map<object, unknown> | null = _g[MAP_KEY];
   const c = context as any;
-  const prev = store && store.has(context)
-    ? store.get(context)
+  const prev = map && map.has(context)
+    ? map.get(context)
     : ("_defaultValue" in c ? c._defaultValue : c._currentValue);
-  if (store) store.set(context, value);
+  map?.set(context, value);
   return prev;
 }
 
 /** Restore a previously saved context value (called by Provider on exit). */
 export function popContextValue(context: object, prev: unknown): void {
-  const store = _contextStore?.getStore();
-  if (store) store.set(context, prev);
+  (_g[MAP_KEY] as Map<object, unknown> | null)?.set(context, prev);
 }
 
 export interface TreeContext {

package/src/utils/rspack.ts

@@ -218,25 +218,18 @@ const buildCompilerConfig = (
         react:                slimReactIndex,
         'react/jsx-runtime':  slimReactJsx,
         'react/jsx-dev-runtime': slimReactJsx,
-        // Keep emotion on the project's node_modules (server-safe entry).
-        '@emotion/react':  path.resolve(process.cwd(), 'node_modules', '@emotion', 'react'),
-        '@emotion/server': path.resolve(process.cwd(), 'node_modules', '@emotion', 'server'),
-        '@emotion/cache':  path.resolve(process.cwd(), 'node_modules', '@emotion', 'cache'),
-        '@emotion/styled': path.resolve(process.cwd(), 'node_modules', '@emotion', 'styled'),
+        // @emotion/* is bundled (not external) so that its `react` imports are
+        // resolved through the alias above to slim-react. If left external,
+        // emotion loads real React from node_modules and calls
+        // ReactSharedInternals.H.useContext which requires React's dispatcher.
     } : undefined;
 
     const externals = isServerBuild ? [
         // Node.js built-ins — must not be bundled; resolved by the runtime.
-        // Both the bare name and the node: prefix are listed because rspack
-        // may encounter either form depending on how the import is written.
-        'node:async_hooks', 'async_hooks',
         'node:fs', 'node:path', 'node:os', 'node:stream', 'node:util',
-        // react / react-dom are replaced by slim-react via alias above — not external.
-        // emotion should be external on server builds to avoid client/browser code
-        '@emotion/react',
+        // @emotion/server is only used outside component rendering (CSS extraction)
+        // and does not call React hooks, so it is safe to leave as external.
         '@emotion/server',
-        '@emotion/cache',
-        '@emotion/styled',
     ] : undefined;
 
     const extraPlugins: any[] = [];
@@ -256,6 +249,9 @@ const buildCompilerConfig = (
         alias: resolveAliases,
         // for server builds prefer the package "main"/"module" fields and avoid "browser" so we don't pick browser-specific entrypoints
         mainFields: isServerBuild ? ['main', 'module'] : ['browser', 'module', 'main'],
+        // for server builds exclude the "browser" condition so packages with package.json
+        // "exports" conditions (e.g. @emotion/*) resolve their Node/CJS entry, not the browser build
+        ...(isServerBuild ? { conditionNames: ['node', 'require', 'default'] } : {}),
     };
 
     // Production client builds get vendor splitting and deterministic module IDs.

package/dist/chunk-EZUCZHGV.js

@@ -1,11 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw new Error('Dynamic require of "' + x + '" is not supported');
-});
-
-export {
-  __require
-};