hadars 0.1.23 → 0.1.25

package/src/slim-react/render.ts

@@ -30,6 +30,11 @@ import {
   popComponentScope,
   snapshotContext,
   restoreContext,
+  pushContextValue,
+  popContextValue,
+  getContextValue,
+  swapContextMap,
+  captureMap,
 } from "./renderContext";
 
 // ---------------------------------------------------------------------------
@@ -566,7 +571,7 @@ function renderComponent(
   // React.Consumer (React 19) — call the children render prop with the current value
   if (typeOf === REACT_CONSUMER) {
     const ctx = (type as any)._context;
-    const value = ctx?._currentValue;
+    const value = ctx ? getContextValue(ctx) : undefined;
     const result: SlimNode =
       typeof props.children === "function" ? props.children(value) : null;
     const savedScope = pushComponentScope();
@@ -594,8 +599,7 @@ function renderComponent(
   if (isProvider) {
     // Resolve the actual context object from any provider variant
     ctx = (type as any)._context ?? type;
-    prevCtxValue = ctx._currentValue;
-    ctx._currentValue = props.value;
+    prevCtxValue = pushContextValue(ctx, props.value);
   }
 
   // Each component gets a fresh local-ID counter (for multiple useId calls).
@@ -606,11 +610,15 @@ function renderComponent(
   if (isProvider && typeof type !== "function") {
     const finish = () => {
       popComponentScope(savedScope);
-      ctx._currentValue = prevCtxValue;
+      popContextValue(ctx, prevCtxValue);
     };
     const r = renderChildren(props.children, writer, isSvg);
     if (r && typeof (r as any).then === "function") {
-      return (r as Promise<void>).then(finish);
+      const m = captureMap();
+      return (r as Promise<void>).then(
+        () => { swapContextMap(m); finish(); },
+        (e) => { swapContextMap(m); finish(); throw e; },
+      );
     }
     finish();
     return;
@@ -631,30 +639,40 @@ function renderComponent(
     }
   } catch (e) {
     popComponentScope(savedScope);
-    if (isProvider) ctx._currentValue = prevCtxValue;
+    if (isProvider) popContextValue(ctx, prevCtxValue);
     throw e;
   }
 
   const finish = () => {
     popComponentScope(savedScope);
-    if (isProvider) ctx._currentValue = prevCtxValue;
+    if (isProvider) popContextValue(ctx, prevCtxValue);
   };
 
   // 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);
+        const m2 = captureMap();
+        return (r as Promise<void>).then(
+          () => { swapContextMap(m2); finish(); },
+          (e) => { swapContextMap(m2); finish(); throw e; },
+        );
       }
       finish();
-    });
+    }, (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);
+    const m = captureMap();
+    return (r as Promise<void>).then(
+      () => { swapContextMap(m); finish(); },
+      (e) => { swapContextMap(m); finish(); throw e; },
+    );
   }
   finish();
 }
@@ -688,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);
@@ -713,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);
       });
@@ -762,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 (<!--$--> … <!--/$-->).
@@ -772,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;
@@ -785,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("<!--/$-->");
 }
@@ -803,9 +827,11 @@ async function renderSuspense(
 export function renderToStream(element: SlimNode): ReadableStream<Uint8Array> {
   const encoder = new TextEncoder();
 
+  const contextMap = new Map<object, unknown>();
   return new ReadableStream({
     async start(controller) {
       resetRenderState();
+      const prev = swapContextMap(contextMap);
 
       const writer: Writer = {
         lastWasText: false,
@@ -821,10 +847,14 @@ 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);
       }
     },
   });
@@ -836,27 +866,36 @@ export function renderToStream(element: SlimNode): ReadableStream<Uint8Array> {
  * so useServerData and similar hooks work without requiring explicit <Suspense>.
  */
 export async function renderToString(element: SlimNode): Promise<string> {
-  for (let attempt = 0; attempt < MAX_SUSPENSE_RETRIES; attempt++) {
-    resetRenderState();
-    const chunks: string[] = [];
-    const writer: Writer = {
-      lastWasText: false,
-      write(c) { chunks.push(c); this.lastWasText = false; },
-      text(s) { chunks.push(s); this.lastWasText = true; },
-    };
-    try {
-      const r = renderNode(element, writer);
-      if (r && typeof (r as any).then === "function") await r;
-      return chunks.join("");
-    } catch (error) {
-      if (error && typeof (error as any).then === "function") {
-        await (error as Promise<unknown>);
-        continue;
+  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,
+        write(c) { chunks.push(c); this.lastWasText = false; },
+        text(s) { chunks.push(s); this.lastWasText = true; },
+      };
+      try {
+        const r = renderNode(element, writer);
+        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") {
+          const m = captureMap(); await (error as Promise<unknown>); swapContextMap(m);
+          continue;
+        }
+        throw error;
       }
-      throw error;
     }
+    throw new Error("[slim-react] renderToString exceeded maximum retries");
+  } finally {
+    swapContextMap(prev);
   }
-  throw new Error("[slim-react] renderToString exceeded maximum retries");
 }
 
 /** Alias matching React 18+ server API naming. */

package/src/slim-react/renderContext.ts

@@ -1,12 +1,67 @@
 /**
- * Render-time context for tree-position-based `useId`.
+ * Render-time context for tree-position-based `useId` and React Context values.
  *
  * State lives on `globalThis` rather than module-level variables so that
  * multiple slim-react instances (the render worker's direct import and the
- * SSR bundle's bundled copy) share the same context without any coordination.
- * Safe because each worker processes one render at a time; `resetRenderState`
- * is always called at the top of every `renderToString` / `renderToStream`.
+ * SSR bundle's bundled copy) share the same singletons without coordination.
+ *
+ * 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.
+ */
+
+// 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 (!("__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;
+}
+
+/** 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. */
+export function getContextValue<T>(context: object): 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 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 map: Map<object, unknown> | null = _g[MAP_KEY];
+  const c = context as any;
+  const prev = map && map.has(context)
+    ? map.get(context)
+    : ("_defaultValue" in c ? c._defaultValue : c._currentValue);
+  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 {
+  (_g[MAP_KEY] as Map<object, unknown> | null)?.set(context, prev);
+}
 
 export interface TreeContext {
   id: number;

package/src/utils/rspack.ts

@@ -226,6 +226,8 @@ const buildCompilerConfig = (
     } : undefined;
 
     const externals = isServerBuild ? [
+        // Node.js built-ins — must not be bundled; resolved by the runtime.
+        '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',