hadars 0.3.1 → 0.3.2

package/src/slim-react/render.ts

@@ -38,7 +38,21 @@ import {
   captureMap,
   captureUnsuspend,
   restoreUnsuspend,
+  type ContextSnapshot,
 } from "./renderContext";
+
+/**
+ * Capture all three concurrent-render globals in one call.
+ * Must be called immediately before every `await` and the returned token
+ * passed to restoreRenderCtx immediately after resuming — just like the
+ * individual captureMap / captureUnsuspend calls they replace.
+ */
+function captureRenderCtx(): { m: ReturnType<typeof captureMap>; u: unknown; t: ContextSnapshot } {
+  return { m: captureMap(), u: captureUnsuspend(), t: snapshotContext() };
+}
+function restoreRenderCtx(ctx: ReturnType<typeof captureRenderCtx>): void {
+  swapContextMap(ctx.m); restoreUnsuspend(ctx.u); restoreContext(ctx.t);
+}
 import { installDispatcher, restoreDispatcher } from "./dispatcher";
 
 // ---------------------------------------------------------------------------
@@ -627,9 +641,9 @@ function renderComponent(
       if (e && typeof (e as any).then === "function") {
         if (_suspenseRetries + 1 >= MAX_COMPONENT_SUSPENSE_RETRIES) throw SUSPENSE_RETRY_LIMIT;
         patchPromiseStatus(e as Promise<unknown>);
-        const m = captureMap(); const u = captureUnsuspend();
+        const rctx = captureRenderCtx();
         return (e as Promise<unknown>).then(() => {
-          swapContextMap(m); restoreUnsuspend(u);
+          restoreRenderCtx(rctx);
           return renderComponent(type, props, writer, isSvg, _suspenseRetries + 1);
         });
       }
@@ -686,10 +700,10 @@ function renderComponent(
     };
     const r = renderChildren(props.children, writer, isSvg);
     if (r && typeof (r as any).then === "function") {
-      const m = captureMap(); const u = captureUnsuspend();
+      const rctx = captureRenderCtx();
       return (r as Promise<void>).then(
-        () => { swapContextMap(m); restoreUnsuspend(u); finish(); },
-        (e) => { swapContextMap(m); restoreUnsuspend(u); finish(); throw e; },
+        () => { restoreRenderCtx(rctx); finish(); },
+        (e) => { restoreRenderCtx(rctx); finish(); throw e; },
       );
     }
     finish();
@@ -722,9 +736,9 @@ function renderComponent(
     if (e && typeof (e as any).then === "function") {
       if (_suspenseRetries + 1 >= MAX_COMPONENT_SUSPENSE_RETRIES) throw SUSPENSE_RETRY_LIMIT;
       patchPromiseStatus(e as Promise<unknown>);
-      const m = captureMap(); const u = captureUnsuspend();
+      const rctx = captureRenderCtx();
       return (e as Promise<unknown>).then(() => {
-        swapContextMap(m); restoreUnsuspend(u);
+        restoreRenderCtx(rctx);
         return renderComponent(type, props, writer, isSvg, _suspenseRetries + 1);
       });
     }
@@ -744,9 +758,9 @@ function renderComponent(
 
   // Async component
   if (result instanceof Promise) {
-    const m = captureMap(); const u = captureUnsuspend();
+    const rctx = captureRenderCtx();
     return result.then((resolved) => {
-      swapContextMap(m); restoreUnsuspend(u);
+      restoreRenderCtx(rctx);
       // Check useId after the async body has finished executing.
       let asyncSavedIdTree: number | undefined;
       if (componentCalledUseId()) {
@@ -754,17 +768,17 @@ function renderComponent(
       }
       const r = renderNode(resolved, writer, isSvg);
       if (r && typeof (r as any).then === "function") {
-        const m2 = captureMap(); const u2 = captureUnsuspend();
+        const rctx2 = captureRenderCtx();
         // Only allocate cleanup closures when actually going async.
         return (r as Promise<void>).then(
           () => {
-            swapContextMap(m2); restoreUnsuspend(u2);
+            restoreRenderCtx(rctx2);
             if (asyncSavedIdTree !== undefined) popTreeContext(asyncSavedIdTree);
             popComponentScope(savedScope);
             if (isProvider) popContextValue(ctx, prevCtxValue);
           },
           (e) => {
-            swapContextMap(m2); restoreUnsuspend(u2);
+            restoreRenderCtx(rctx2);
             if (asyncSavedIdTree !== undefined) popTreeContext(asyncSavedIdTree);
             popComponentScope(savedScope);
             if (isProvider) popContextValue(ctx, prevCtxValue);
@@ -777,7 +791,7 @@ function renderComponent(
       popComponentScope(savedScope);
       if (isProvider) popContextValue(ctx, prevCtxValue);
     }, (e) => {
-      swapContextMap(m); restoreUnsuspend(u);
+      restoreRenderCtx(rctx);
       // savedIdTree is always undefined here (async component skips the push).
       popComponentScope(savedScope);
       if (isProvider) popContextValue(ctx, prevCtxValue);
@@ -788,17 +802,17 @@ function renderComponent(
   const r = renderNode(result, writer, isSvg);
 
   if (r && typeof (r as any).then === "function") {
-    const m = captureMap(); const u = captureUnsuspend();
+    const rctx = captureRenderCtx();
     // Only allocate cleanup closures when actually going async.
     return (r as Promise<void>).then(
       () => {
-        swapContextMap(m); restoreUnsuspend(u);
+        restoreRenderCtx(rctx);
         if (savedIdTree !== undefined) popTreeContext(savedIdTree);
         popComponentScope(savedScope);
         if (isProvider) popContextValue(ctx, prevCtxValue);
       },
       (e) => {
-        swapContextMap(m); restoreUnsuspend(u);
+        restoreRenderCtx(rctx);
         if (savedIdTree !== undefined) popTreeContext(savedIdTree);
         popComponentScope(savedScope);
         if (isProvider) popContextValue(ctx, prevCtxValue);
@@ -839,9 +853,9 @@ function renderChildArrayFrom(
     const savedTree = pushTreeContext(totalChildren, i);
     const r = renderNode(child, writer, isSvg);
     if (r && typeof (r as any).then === "function") {
-      const m = captureMap(); const u = captureUnsuspend();
+      const rctx = captureRenderCtx();
       return (r as Promise<void>).then(() => {
-        swapContextMap(m); restoreUnsuspend(u);
+        restoreRenderCtx(rctx);
         popTreeContext(savedTree);
         return renderChildArrayFrom(children, i + 1, writer, isSvg);
       });
@@ -895,9 +909,9 @@ async function renderSuspense(
   try {
     const r = renderNode(children, buffer, isSvg);
     if (r && typeof (r as any).then === "function") {
-      const m = captureMap(); const u = captureUnsuspend();
+      const rctx = captureRenderCtx();
       await r;
-      swapContextMap(m); restoreUnsuspend(u);
+      restoreRenderCtx(rctx);
     }
     // Success – wrap with React's Suspense boundary markers so hydrateRoot
     // can locate the boundary in the DOM (<!--$--> … <!--/$-->).
@@ -918,9 +932,9 @@ async function renderSuspense(
       if (fallback) {
         const r = renderNode(fallback, writer, isSvg);
         if (r && typeof (r as any).then === "function") {
-          const m = captureMap(); const u = captureUnsuspend();
+          const rctx = captureRenderCtx();
           await r;
-          swapContextMap(m); restoreUnsuspend(u);
+          restoreRenderCtx(rctx);
         }
       }
       writer.write("<!--/$-->");
@@ -984,7 +998,7 @@ export function renderToStream(
       try {
         const r = renderNode(element, writer);
         if (r && typeof (r as any).then === "function") {
-          const m = captureMap(); await r; swapContextMap(m);
+          const rctx = captureRenderCtx(); await r; restoreRenderCtx(rctx);
         }
         writer.flush!(); // encode everything accumulated (sync renders: the whole page)
         controller.close();
@@ -1037,7 +1051,7 @@ export async function renderPreflight(
     // so a single pass is guaranteed to complete with all promises resolved.
     const r = renderNode(element, NULL_WRITER);
     if (r && typeof (r as any).then === "function") {
-      const m = captureMap(); await r; swapContextMap(m);
+      const rctx = captureRenderCtx(); await r; restoreRenderCtx(rctx);
     }
   } finally {
     swapContextMap(prev);
@@ -1075,7 +1089,7 @@ export async function renderToString(
     // so a single pass is guaranteed to complete with all promises resolved.
     const r = renderNode(element, writer);
     if (r && typeof (r as any).then === "function") {
-      const m = captureMap(); await r; swapContextMap(m);
+      const rctx = captureRenderCtx(); await r; restoreRenderCtx(rctx);
     }
     return output;
   } finally {

package/src/slim-react/renderContext.ts

@@ -220,21 +220,44 @@ export function componentCalledUseId(): boolean {
   return s().localIdCounter > 0;
 }
 
-export function snapshotContext(): { tree: TreeContext; localId: number; treeDepth: number } {
-  const st  = s();
-  const ctx = st.currentTreeContext;
-  // Copy scalars directly — avoids a spread allocation.
-  return { tree: { id: ctx.id, overflow: ctx.overflow }, localId: st.localIdCounter, treeDepth: _treeDepth };
+export interface ContextSnapshot {
+  tree: TreeContext;
+  localId: number;
+  treeDepth: number;
+  /** Saved parent-context id values for the stack slots 0..treeDepth-1.
+   *  Required so that concurrent renders cannot corrupt popTreeContext calls
+   *  that run after an await continuation. */
+  idStack: number[];
+  ovStack: string[];
 }
 
-export function restoreContext(snap: { tree: TreeContext; localId: number; treeDepth: number }): void {
+export function snapshotContext(): ContextSnapshot {
+  const st    = s();
+  const ctx   = st.currentTreeContext;
+  const depth = _treeDepth;
+  return {
+    tree:      { id: ctx.id, overflow: ctx.overflow },
+    localId:   st.localIdCounter,
+    treeDepth: depth,
+    // Snapshot the live stack so that popTreeContext reads correct saved values
+    // even if another concurrent render's resetRenderState stomped the arrays.
+    idStack:   _treeIdStack.slice(0, depth),
+    ovStack:   _treeOvStack.slice(0, depth),
+  };
+}
+
+export function restoreContext(snap: ContextSnapshot): void {
   const st  = s();
   const ctx = st.currentTreeContext;
-  // Mutate in place — avoids allocating a new TreeContext object.
-  ctx.id             = snap.tree.id;
-  ctx.overflow       = snap.tree.overflow;
-  st.localIdCounter  = snap.localId;
-  _treeDepth         = snap.treeDepth;
+  ctx.id            = snap.tree.id;
+  ctx.overflow      = snap.tree.overflow;
+  st.localIdCounter = snap.localId;
+  _treeDepth        = snap.treeDepth;
+  // Restore the stack so subsequent popTreeContext calls see the right values.
+  for (let i = 0; i < snap.treeDepth; i++) {
+    _treeIdStack[i] = snap.idStack[i]!;
+    _treeOvStack[i] = snap.ovStack[i]!;
+  }
 }
 
 /**

package/src/utils/rspack.ts

@@ -338,6 +338,12 @@ const buildCompilerConfig = (
         // changed files, making repeat dev starts significantly faster.
         cache: true,
         externals,
+        // externalsPresets.node externalises ALL Node.js built-ins (bare names
+        // and the node: prefix) for both static and dynamic imports.  This
+        // complements the explicit `externals` array: the preset handles the
+        // node: URI scheme that rspack cannot resolve as a file, while the
+        // array keeps '@emotion/server' as an explicit external.
+        ...(isServerBuild ? { externalsPresets: { node: true } } : {}),
         ...(optimization !== undefined ? { optimization } : {}),
         plugins: [
             !isServerBuild && new rspack.HtmlRspackPlugin({
@@ -393,7 +399,7 @@ const buildCompilerConfig = (
         // SSR watcher writing .hadars/index.ssr.js triggers the client compiler
         // and vice versa, causing an infinite rebuild loop.
         watchOptions: {
-            ignored: ['**/node_modules/**', '**/.hadars/**'],
+            ignored: ['**/node_modules/**', '**/.hadars/**', '/tmp/**'],
         },
     };
 };
@@ -418,7 +424,7 @@ export const compileEntry = async (entry: string, opts: EntryOptions & { watch?:
             let first = true;
             // Pass ignored patterns directly — compiler.watch(watchOptions) replaces
             // the config-level watchOptions, so we must repeat them here.
-            compiler.watch({ ignored: ['**/node_modules/**', '**/.hadars/**'] }, (err: any, stats: any) => {
+            compiler.watch({ ignored: ['**/node_modules/**', '**/.hadars/**', '/tmp/**'] }, (err: any, stats: any) => {
                 if (err) {
                     if (first) { first = false; reject(err); }
                     else { console.error('rspack watch error', err); }
@@ -452,10 +458,7 @@ export const compileEntry = async (entry: string, opts: EntryOptions & { watch?:
 
             console.log(stats?.toString({
                 colors: true,
-                modules: true,
-                children: true,
-                chunks: true,
-                chunkModules: true,
+                preset: 'minimal',
             }));
 
             resolve(stats);

package/src/utils/ssrHandler.ts

@@ -89,6 +89,18 @@ export const makePrecontentHtmlGetter = (htmlFilePromise: Promise<string>) => {
     let preHead: string | null = null;
     let postHead: string | null = null;
     let postContent: string | null = null;
+
+    // Parse the template as soon as the file read completes — during the
+    // process's idle time before the first request arrives.  This way the
+    // first real request finds preHead !== null and takes the sync path.
+    const primed = htmlFilePromise.then(html => {
+        const headEnd = html.indexOf(HEAD_MARKER);
+        const contentStart = html.indexOf(BODY_MARKER);
+        preHead = html.slice(0, headEnd);
+        postHead = html.slice(headEnd + HEAD_MARKER.length, contentStart);
+        postContent = html.slice(contentStart + BODY_MARKER.length);
+    });
+
     // Returns synchronously once the template has been loaded and parsed
     // (every request after the first).  Callers can check `instanceof Promise`
     // to take a zero-await hot path.
@@ -97,14 +109,7 @@ export const makePrecontentHtmlGetter = (htmlFilePromise: Promise<string>) => {
             // Hot path — sync return, no Promise allocation.
             return [preHead + headHtml + postHead!, postContent!];
         }
-        return htmlFilePromise.then(html => {
-            const headEnd = html.indexOf(HEAD_MARKER);
-            const contentStart = html.indexOf(BODY_MARKER);
-            preHead = html.slice(0, headEnd);
-            postHead = html.slice(headEnd + HEAD_MARKER.length, contentStart);
-            postContent = html.slice(contentStart + BODY_MARKER.length);
-            return [preHead + headHtml + postHead, postContent];
-        });
+        return primed.then(() => [preHead! + headHtml + postHead!, postContent!]);
     };
 };