hadars 0.3.0 → 0.3.2

package/dist/ssr-render-worker.js

@@ -134,7 +134,16 @@ function componentCalledUseId() {
 function snapshotContext() {
   const st = s();
   const ctx = st.currentTreeContext;
-  return { tree: { id: ctx.id, overflow: ctx.overflow }, localId: st.localIdCounter, treeDepth: _treeDepth };
+  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)
+  };
 }
 function restoreContext(snap) {
   const st = s();
@@ -143,6 +152,10 @@ function restoreContext(snap) {
   ctx.overflow = snap.tree.overflow;
   st.localIdCounter = snap.localId;
   _treeDepth = snap.treeDepth;
+  for (let i = 0; i < snap.treeDepth; i++) {
+    _treeIdStack[i] = snap.idStack[i];
+    _treeOvStack[i] = snap.ovStack[i];
+  }
 }
 function getTreeId() {
   const { id, overflow } = s().currentTreeContext;
@@ -256,6 +269,14 @@ function restoreDispatcher(prev) {
 }
 
 // src/slim-react/render.ts
+function captureRenderCtx() {
+  return { m: captureMap(), u: captureUnsuspend(), t: snapshotContext() };
+}
+function restoreRenderCtx(ctx) {
+  swapContextMap(ctx.m);
+  restoreUnsuspend(ctx.u);
+  restoreContext(ctx.t);
+}
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
   "area",
   "base",
@@ -699,11 +720,9 @@ function renderComponent(type, props, writer, isSvg, _suspenseRetries = 0) {
       if (e && typeof e.then === "function") {
         if (_suspenseRetries + 1 >= MAX_COMPONENT_SUSPENSE_RETRIES) throw SUSPENSE_RETRY_LIMIT;
         patchPromiseStatus(e);
-        const m = captureMap();
-        const u = captureUnsuspend();
+        const rctx = captureRenderCtx();
         return e.then(() => {
-          swapContextMap(m);
-          restoreUnsuspend(u);
+          restoreRenderCtx(rctx);
           return renderComponent(type, props, writer, isSvg, _suspenseRetries + 1);
         });
       }
@@ -740,17 +759,14 @@ function renderComponent(type, props, writer, isSvg, _suspenseRetries = 0) {
     };
     const r2 = renderChildren(props.children, writer, isSvg);
     if (r2 && typeof r2.then === "function") {
-      const m = captureMap();
-      const u = captureUnsuspend();
+      const rctx = captureRenderCtx();
       return r2.then(
         () => {
-          swapContextMap(m);
-          restoreUnsuspend(u);
+          restoreRenderCtx(rctx);
           finish();
         },
         (e) => {
-          swapContextMap(m);
-          restoreUnsuspend(u);
+          restoreRenderCtx(rctx);
           finish();
           throw e;
         }
@@ -779,11 +795,9 @@ function renderComponent(type, props, writer, isSvg, _suspenseRetries = 0) {
     if (e && typeof e.then === "function") {
       if (_suspenseRetries + 1 >= MAX_COMPONENT_SUSPENSE_RETRIES) throw SUSPENSE_RETRY_LIMIT;
       patchPromiseStatus(e);
-      const m = captureMap();
-      const u = captureUnsuspend();
+      const rctx = captureRenderCtx();
       return e.then(() => {
-        swapContextMap(m);
-        restoreUnsuspend(u);
+        restoreRenderCtx(rctx);
         return renderComponent(type, props, writer, isSvg, _suspenseRetries + 1);
       });
     }
@@ -795,30 +809,25 @@ function renderComponent(type, props, writer, isSvg, _suspenseRetries = 0) {
     savedIdTree = pushTreeContext(1, 0);
   }
   if (result instanceof Promise) {
-    const m = captureMap();
-    const u = captureUnsuspend();
+    const rctx = captureRenderCtx();
     return result.then((resolved) => {
-      swapContextMap(m);
-      restoreUnsuspend(u);
+      restoreRenderCtx(rctx);
       let asyncSavedIdTree;
       if (componentCalledUseId()) {
         asyncSavedIdTree = pushTreeContext(1, 0);
       }
       const r2 = renderNode(resolved, writer, isSvg);
       if (r2 && typeof r2.then === "function") {
-        const m2 = captureMap();
-        const u2 = captureUnsuspend();
+        const rctx2 = captureRenderCtx();
         return r2.then(
           () => {
-            swapContextMap(m2);
-            restoreUnsuspend(u2);
+            restoreRenderCtx(rctx2);
             if (asyncSavedIdTree !== void 0) popTreeContext(asyncSavedIdTree);
             popComponentScope(savedScope);
             if (isProvider) popContextValue(ctx, prevCtxValue);
           },
           (e) => {
-            swapContextMap(m2);
-            restoreUnsuspend(u2);
+            restoreRenderCtx(rctx2);
             if (asyncSavedIdTree !== void 0) popTreeContext(asyncSavedIdTree);
             popComponentScope(savedScope);
             if (isProvider) popContextValue(ctx, prevCtxValue);
@@ -830,8 +839,7 @@ function renderComponent(type, props, writer, isSvg, _suspenseRetries = 0) {
       popComponentScope(savedScope);
       if (isProvider) popContextValue(ctx, prevCtxValue);
     }, (e) => {
-      swapContextMap(m);
-      restoreUnsuspend(u);
+      restoreRenderCtx(rctx);
       popComponentScope(savedScope);
       if (isProvider) popContextValue(ctx, prevCtxValue);
       throw e;
@@ -839,19 +847,16 @@ function renderComponent(type, props, writer, isSvg, _suspenseRetries = 0) {
   }
   const r = renderNode(result, writer, isSvg);
   if (r && typeof r.then === "function") {
-    const m = captureMap();
-    const u = captureUnsuspend();
+    const rctx = captureRenderCtx();
     return r.then(
       () => {
-        swapContextMap(m);
-        restoreUnsuspend(u);
+        restoreRenderCtx(rctx);
         if (savedIdTree !== void 0) popTreeContext(savedIdTree);
         popComponentScope(savedScope);
         if (isProvider) popContextValue(ctx, prevCtxValue);
       },
       (e) => {
-        swapContextMap(m);
-        restoreUnsuspend(u);
+        restoreRenderCtx(rctx);
         if (savedIdTree !== void 0) popTreeContext(savedIdTree);
         popComponentScope(savedScope);
         if (isProvider) popContextValue(ctx, prevCtxValue);
@@ -876,11 +881,9 @@ function renderChildArrayFrom(children, startIndex, writer, isSvg) {
     const savedTree = pushTreeContext(totalChildren, i);
     const r = renderNode(child, writer, isSvg);
     if (r && typeof r.then === "function") {
-      const m = captureMap();
-      const u = captureUnsuspend();
+      const rctx = captureRenderCtx();
       return r.then(() => {
-        swapContextMap(m);
-        restoreUnsuspend(u);
+        restoreRenderCtx(rctx);
         popTreeContext(savedTree);
         return renderChildArrayFrom(children, i + 1, writer, isSvg);
       });
@@ -904,11 +907,9 @@ async function renderSuspense(props, writer, isSvg = false) {
   try {
     const r = renderNode(children, buffer, isSvg);
     if (r && typeof r.then === "function") {
-      const m = captureMap();
-      const u = captureUnsuspend();
+      const rctx = captureRenderCtx();
       await r;
-      swapContextMap(m);
-      restoreUnsuspend(u);
+      restoreRenderCtx(rctx);
     }
     writer.write("<!--$-->");
     buffer.flushTo(writer);
@@ -922,11 +923,9 @@ async function renderSuspense(props, writer, isSvg = false) {
       if (fallback) {
         const r = renderNode(fallback, writer, isSvg);
         if (r && typeof r.then === "function") {
-          const m = captureMap();
-          const u = captureUnsuspend();
+          const rctx = captureRenderCtx();
           await r;
-          swapContextMap(m);
-          restoreUnsuspend(u);
+          restoreRenderCtx(rctx);
         }
       }
       writer.write("<!--/$-->");
@@ -955,9 +954,9 @@ async function renderToString(element, options) {
     resetRenderState(idPrefix);
     const r = renderNode(element, writer);
     if (r && typeof r.then === "function") {
-      const m = captureMap();
+      const rctx = captureRenderCtx();
       await r;
-      swapContextMap(m);
+      restoreRenderCtx(rctx);
     }
     return output;
   } finally {

package/dist/ssr-watch.js

@@ -265,6 +265,12 @@ var buildCompilerConfig = (entry2, opts, includeHotPlugin) => {
     // 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 !== void 0 ? { optimization } : {},
     plugins: [
       !isServerBuild && new rspack.HtmlRspackPlugin({
@@ -317,7 +323,7 @@ var buildCompilerConfig = (entry2, opts, includeHotPlugin) => {
     // 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/**"]
     }
   };
 };
@@ -326,7 +332,7 @@ var compileEntry = async (entry2, opts) => {
   if (opts.watch) {
     await new Promise((resolve, reject) => {
       let first = true;
-      compiler.watch({ ignored: ["**/node_modules/**", "**/.hadars/**"] }, (err, stats) => {
+      compiler.watch({ ignored: ["**/node_modules/**", "**/.hadars/**", "/tmp/**"] }, (err, stats) => {
         if (err) {
           if (first) {
             first = false;
@@ -359,10 +365,7 @@ var compileEntry = async (entry2, opts) => {
       }
       console.log(stats?.toString({
         colors: true,
-        modules: true,
-        children: true,
-        chunks: true,
-        chunkModules: true
+        preset: "minimal"
       }));
       resolve(stats);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hadars",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Minimal SSR framework for React — rspack, HMR, TypeScript, Bun/Node/Deno",
   "module": "./dist/index.js",
   "type": "module",
@@ -41,7 +41,7 @@
   "scripts": {
     "build:lib": "tsup src/index.tsx src/lambda.ts src/cloudflare.ts src/slim-react/index.ts src/slim-react/jsx-runtime.ts --format esm,cjs --dts --out-dir dist --clean --external '@rspack/*' --external '@rspack/binding'",
     "build:cli": "node build-scripts/build-cli.mjs",
-    "build:all": "npm run build:lib && npm run build:cli",
+    "build:all": "node build-scripts/build-all.mjs",
     "test": "bun test test/render-compare.test.tsx && bun test test/ssr.test.ts",
     "prepare": "npm run build:all",
     "prepublishOnly": "npm run build:all"

package/src/build.ts

@@ -701,6 +701,14 @@ export const run = async (options: HadarsRuntimeOptions) => {
         fs.readFile(pathMod.join(__dirname, StaticPath, 'out.html'), 'utf-8')
     );
 
+    // Hoist and pre-import the SSR module at startup so the first request does
+    // not pay the module parse/eval cost.  The file: URL is stable for the life
+    // of the process (no cache-busting needed in run mode).
+    const componentPath = pathToFileURL(
+        pathMod.resolve(__dirname, HadarsFolder, SSR_FILENAME)
+    ).href;
+    const ssrModulePromise = import(componentPath) as Promise<HadarsEntryModule<any>>;
+
     const runHandler: CacheFetchHandler = async (req, ctx) => {
         const request = parseRequest(req);
         if (handler) {
@@ -733,16 +741,12 @@ export const run = async (options: HadarsRuntimeOptions) => {
             if (routeRes) return routeRes;
         }
 
-        const componentPath = pathToFileURL(
-            pathMod.resolve(__dirname, HadarsFolder, SSR_FILENAME)
-        ).href;
-
         try {
             const {
                 default: Component,
                 getInitProps,
                 getFinalProps,
-            } = (await import(componentPath)) as HadarsEntryModule<any>;
+            } = await ssrModulePromise;
 
             if (renderPool && request.headers.get('Accept') !== 'application/json') {
                 // Worker runs the full lifecycle — no non-serializable objects cross the thread boundary.

package/src/lambda.ts

@@ -193,20 +193,13 @@ export function createLambdaHandler(options: HadarsOptions, bundled?: LambdaBund
         ? makePrecontentHtmlGetter(Promise.resolve(bundled.outHtml))
         : makePrecontentHtmlGetter(fs.readFile(pathMod.join(cwd, StaticPath, 'out.html'), 'utf-8'));
 
-    // Hoist the SSR module reference so it is resolved once, not on every
-    // request. In bundled mode the module is already in-memory; in file-based
-    // mode we lazily import it and cache the promise so Node's module cache is
-    // only consulted once.
-    let ssrModulePromise: Promise<HadarsEntryModule<any>> | null = null;
-    const getSsrModule = (): Promise<HadarsEntryModule<any>> => {
-        if (bundled) return Promise.resolve(bundled.ssrModule);
-        if (!ssrModulePromise) {
-            ssrModulePromise = import(
-                pathToFileURL(pathMod.resolve(cwd, HadarsFolder, SSR_FILENAME)).href
-            ) as Promise<HadarsEntryModule<any>>;
-        }
-        return ssrModulePromise;
-    };
+    // Start loading the SSR module immediately — during Lambda's init phase this
+    // is "free" time not billed against request latency.  Lazy loading would
+    // push the module parse cost onto the first request.
+    const ssrModulePromise: Promise<HadarsEntryModule<any>> = bundled
+        ? Promise.resolve(bundled.ssrModule)
+        : import(pathToFileURL(pathMod.resolve(cwd, HadarsFolder, SSR_FILENAME)).href) as Promise<HadarsEntryModule<any>>;
+    const getSsrModule = () => ssrModulePromise;
 
     const runHandler = async (req: Request): Promise<Response> => {
         const request = parseRequest(req);

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/serve.ts

@@ -58,33 +58,6 @@ function withRequestLogging(handler: FetchHandler): FetchHandler {
     };
 }
 
-const COMPRESSIBLE_RE = /^text\/|\/json|\/javascript|\/xml|\/wasm/;
-
-/**
- * Wraps a handler to apply on-the-fly gzip compression via CompressionStream.
- * Unlike a buffering approach, this pipes the response ReadableStream through
- * a CompressionStream so bytes are compressed and flushed as they arrive —
- * streaming responses remain streaming.
- */
-function withCompression(handler: FetchHandler): FetchHandler {
-    return async (req, ctx) => {
-        const res = await handler(req, ctx);
-        if (!res || !res.body) return res;
-        const accept = req.headers.get('Accept-Encoding') ?? '';
-        if (!accept.includes('gzip')) return res;
-        // Skip if already encoded (e.g. pre-compressed cache entry).
-        if (res.headers.has('content-encoding')) return res;
-        const ct = res.headers.get('content-type') ?? '';
-        if (!COMPRESSIBLE_RE.test(ct)) return res;
-        const compressed = res.body.pipeThrough(
-            new (globalThis as any).CompressionStream('gzip'),
-        );
-        const headers = new Headers(res.headers);
-        headers.set('content-encoding', 'gzip');
-        headers.delete('content-length'); // length is unknown after compression
-        return new Response(compressed, { status: res.status, headers });
-    };
-}
 
 export async function serve(
     port: number,
@@ -92,7 +65,7 @@ export async function serve(
     /** Bun WebSocketHandler — ignored on Deno and Node.js. */
     websocket?: unknown,
 ): Promise<void> {
-    fetchHandler = withCompression(withRequestLogging(fetchHandler));
+    fetchHandler = withRequestLogging(fetchHandler);
 
     // ── Bun ────────────────────────────────────────────────────────────────
     if (isBun) {