@nifrajs/web-react 2.1.0 → 2.2.0

package/dist/compose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAyC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAM7E;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,SAAS,CAmBhF"}
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAyC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAM7E;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,SAAS,CA0BhF"}

package/dist/compose.js

@@ -18,7 +18,10 @@ export function compose(chain, props) {
     let node = createElement(chain[last], props);
     for (let i = last - 1; i >= 0; i--) {
         // children passed as the 3rd arg (not a `children` prop) — React's canonical form.
-        node = createElement(chain[i], null, node);
+        // Each layout receives its own loader data at its own index. Layouts are the chain's leading
+        // prefix, so `layoutData[i]` belongs to `chain[i]`; anything past that end (a client-only `_error`
+        // boundary marker, the page) reads `undefined` and is unaffected.
+        node = createElement(chain[i], { data: props.layoutData?.[i] ?? null }, node);
     }
     return createElement(RouterContext.Provider, {
         value: {

package/dist/compose.js.map

@@ -1 +1 @@
-{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAA0C,MAAM,OAAO,CAAA;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,oGAAoG;AACpG,MAAM,YAAY,GAAqC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;AAExE;;;;;;;;;;GAUG;AACH,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB;IACnE,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAA;IAC7B,IAAI,IAAI,GAAc,aAAa,CAAC,KAAK,CAAC,IAAI,CAAmC,EAAE,KAAK,CAAC,CAAA;IACzF,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,mFAAmF;QACnF,IAAI,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC,CAAsB,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;IACjE,CAAC;IACD,OAAO,aAAa,CAClB,aAAa,CAAC,QAAQ,EACtB;QACE,KAAK,EAAE;YACL,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,YAAY;YACpC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE;YACtB,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,KAAK;YAC/B,WAAW,EAAE,KAAK,CAAC,WAAW;SAC/B;KACF,EACD,IAAI,CACL,CAAA;AACH,CAAC"}
+{"version":3,"file":"compose.js","sourceRoot":"","sources":["../src/compose.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAA0C,MAAM,OAAO,CAAA;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,oGAAoG;AACpG,MAAM,YAAY,GAAqC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;AAExE;;;;;;;;;;GAUG;AACH,MAAM,UAAU,OAAO,CAAC,KAAyB,EAAE,KAAkB;IACnE,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,CAAA;IAC7B,IAAI,IAAI,GAAc,aAAa,CAAC,KAAK,CAAC,IAAI,CAAmC,EAAE,KAAK,CAAC,CAAA;IACzF,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,mFAAmF;QACnF,6FAA6F;QAC7F,mGAAmG;QACnG,kEAAkE;QAClE,IAAI,GAAG,aAAa,CAClB,KAAK,CAAC,CAAC,CAAyC,EAChD,EAAE,IAAI,EAAE,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE,EACvC,IAAI,CACL,CAAA;IACH,CAAC;IACD,OAAO,aAAa,CAClB,aAAa,CAAC,QAAQ,EACtB;QACE,KAAK,EAAE;YACL,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,YAAY;YACpC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE;YACtB,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,KAAK;YAC/B,WAAW,EAAE,KAAK,CAAC,WAAW;SAC/B;KACF,EACD,IAAI,CACL,CAAA;AACH,CAAC"}

package/dist/react-dom-server.d.ts

@@ -37,6 +37,27 @@ export interface ReactDomServer {
 export declare function reactDomServer(): Promise<ReactDomServer>;
 /** A `Bun.resolveSync`-shaped function (specifier, from) → absolute path. */
 type ResolveSync = (specifier: string, from: string) => string;
+/**
+ * The dual-React crash, caught on the RESOLVED graph instead of after it detonates.
+ *
+ * The re-root above makes `react-dom/server` load from the app root, which is right almost always. What it
+ * cannot guarantee is that react-dom then pulls in the SAME physical `react` the route components import -
+ * a nested `react` under react-dom, or a components tree resolving react elsewhere, still yields two cores.
+ * Two cores is two hook dispatchers, and the renderer sees a null (or foreign) one: the SSR throws
+ * `resolveDispatcher().useState is null` from deep inside react-dom-server, naming a React internal and
+ * nothing about the two directories that actually caused it. That is hours of inference from a message
+ * that points nowhere useful.
+ *
+ * `nifra doctor` checks what is INSTALLED; this checks what SSR actually RESOLVED, which is the only thing
+ * that can catch a duplicate the two dev pipelines introduce (Bun for SSR, Vite for the client) rather
+ * than the install. It compares the realpath of the `react` react-dom will render with against the
+ * `react` the components import, and if they differ throws with BOTH paths - turning a five-hour hunt into
+ * a five-second read. Silent when they agree, which is the single-copy common case.
+ *
+ * Never manufactures a failure: if either side cannot be resolved it returns, because a resolver that
+ * cannot answer is not evidence of a duplicate. Exported for direct unit testing.
+ */
+export declare function assertSingleReactCore(reactDomServerPath: string, resolve: ResolveSync, realpath?: (path: string) => string): void;
 /**
  * Load `react-dom/server`, preferring the app-root-resolved copy under the Bun runtime. Exported for unit
  * tests: `resolve` defaults to the ambient `Bun.resolveSync` (undefined on non-Bun hosts), and a test can

package/dist/react-dom-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react-dom-server.d.ts","sourceRoot":"","sources":["../src/react-dom-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC;wFACwF;AACxF,MAAM,WAAW,cAAc;IAC7B,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAAA;IACvC,sBAAsB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAA;CAC7E;AA4BD;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAAC,cAAc,CAAC,CAIxD;AAED,6EAA6E;AAC7E,KAAK,WAAW,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;AAE9D;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,GAAE,WAAW,GAAG,SAA2B,GACjD,OAAO,CAAC,cAAc,CAAC,CAiBzB;AAED;;;;;;;;kEAQkE;AAClE,wBAAgB,aAAa,IAAI,WAAW,GAAG,SAAS,CAKvD"}
+{"version":3,"file":"react-dom-server.d.ts","sourceRoot":"","sources":["../src/react-dom-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC;wFACwF;AACxF,MAAM,WAAW,cAAc;IAC7B,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAAA;IACvC,sBAAsB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAA;CAC7E;AA6CD;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAAC,cAAc,CAAC,CAIxD;AAED,6EAA6E;AAC7E,KAAK,WAAW,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;AAE9D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CACnC,kBAAkB,EAAE,MAAM,EAC1B,OAAO,EAAE,WAAW,EACpB,QAAQ,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAwB,GACnD,IAAI,CAsBN;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,GAAE,WAAW,GAAG,SAA2B,GACjD,OAAO,CAAC,cAAc,CAAC,CAyBzB;AAED;;;;;;;;kEAQkE;AAClE,wBAAgB,aAAa,IAAI,WAAW,GAAG,SAAS,CAKvD"}

package/dist/react-dom-server.js

@@ -30,6 +30,15 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+function dirnamePortable(path) {
+    const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+    return slash <= 0 ? "." : path.slice(0, slash);
+}
+function runtimeRealpath(path) {
+    const runtimeProcess = globalThis.process;
+    const fs = runtimeProcess?.getBuiltinModule?.("node:fs");
+    return fs?.realpathSync?.(path) ?? path;
+}
 const bunResolver = globalThis.Bun;
 const hasBunResolveSync = typeof bunResolver?.resolveSync === "function";
 // Resolve once and cache: the module identity is stable for the process lifetime, and re-resolving per
@@ -57,6 +66,49 @@ export function reactDomServer() {
     cached = loadReactDomServer();
     return cached;
 }
+/**
+ * The dual-React crash, caught on the RESOLVED graph instead of after it detonates.
+ *
+ * The re-root above makes `react-dom/server` load from the app root, which is right almost always. What it
+ * cannot guarantee is that react-dom then pulls in the SAME physical `react` the route components import -
+ * a nested `react` under react-dom, or a components tree resolving react elsewhere, still yields two cores.
+ * Two cores is two hook dispatchers, and the renderer sees a null (or foreign) one: the SSR throws
+ * `resolveDispatcher().useState is null` from deep inside react-dom-server, naming a React internal and
+ * nothing about the two directories that actually caused it. That is hours of inference from a message
+ * that points nowhere useful.
+ *
+ * `nifra doctor` checks what is INSTALLED; this checks what SSR actually RESOLVED, which is the only thing
+ * that can catch a duplicate the two dev pipelines introduce (Bun for SSR, Vite for the client) rather
+ * than the install. It compares the realpath of the `react` react-dom will render with against the
+ * `react` the components import, and if they differ throws with BOTH paths - turning a five-hour hunt into
+ * a five-second read. Silent when they agree, which is the single-copy common case.
+ *
+ * Never manufactures a failure: if either side cannot be resolved it returns, because a resolver that
+ * cannot answer is not evidence of a duplicate. Exported for direct unit testing.
+ */
+export function assertSingleReactCore(reactDomServerPath, resolve, realpath = runtimeRealpath) {
+    let rendererReact;
+    let componentsReact;
+    try {
+        // The `react` react-dom/server itself resolves - the core whose dispatcher the renderer sets.
+        rendererReact = realpath(resolve("react", dirnamePortable(reactDomServerPath)));
+        // The `react` the app's route components import - the core they call hooks on.
+        componentsReact = realpath(resolve("react", appRoot()));
+    }
+    catch {
+        return;
+    }
+    if (rendererReact === componentsReact)
+        return;
+    throw new Error("[nifra/web-react] two copies of React reached SSR, so hooks render against a null dispatcher " +
+        "(the `resolveDispatcher().useState is null` crash). react-dom renders with a DIFFERENT React " +
+        "than your components import:\n" +
+        `  react-dom's react:  ${rendererReact}\n` +
+        `  components' react:  ${componentsReact}\n` +
+        "Module identity is path-based, so two copies fail even at the same version. Dedupe react to one " +
+        "physical copy - usually a single hoisted install at the workspace root (`nifra doctor` locates " +
+        "the duplicate). A Vite `resolve.dedupe`/alias fixes only the client bundle, not this SSR path.");
+}
 /**
  * Load `react-dom/server`, preferring the app-root-resolved copy under the Bun runtime. Exported for unit
  * tests: `resolve` defaults to the ambient `Bun.resolveSync` (undefined on non-Bun hosts), and a test can
@@ -71,9 +123,18 @@ export async function loadReactDomServer(resolve = bunResolverFn()) {
         // rather than crashing — degraded (possible duplicate) but never a hard failure.
         try {
             const resolved = resolve("react-dom/server", appRoot());
+            // Before returning the module, verify the react-dom we just re-rooted shares the components' React.
+            // The re-root fixes the common case; this catches the residual duplicate loudly, with both paths,
+            // instead of leaving it to throw a dispatcher-null error on the first hook render. Runs once (this
+            // whole function is cached), dev/unbundled Bun only (the branch `resolve` gates).
+            assertSingleReactCore(resolved, resolve);
             return (await import(__rewriteRelativeImportExtension(resolved)));
         }
-        catch {
+        catch (err) {
+            // A genuine duplicate is surfaced (re-thrown with both paths); any other failure (react-dom not at
+            // the app root, an odd nested layout) falls through to the bundled specifier rather than crashing.
+            if (err instanceof Error && err.message.includes("two copies of React"))
+                throw err;
             // App-root resolution failed; use the specifier resolved from this module's own location below.
         }
     }

package/dist/react-dom-server.js.map

@@ -1 +1 @@
-{"version":3,"file":"react-dom-server.js","sourceRoot":"","sources":["../src/react-dom-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;;;;;;;;;AAkBH,MAAM,WAAW,GAAI,UAA6C,CAAC,GAAG,CAAA;AACtE,MAAM,iBAAiB,GAAG,OAAO,WAAW,EAAE,WAAW,KAAK,UAAU,CAAA;AAExE,uGAAuG;AACvG,qGAAqG;AACrG,8EAA8E;AAC9E,IAAI,MAA2C,CAAA;AAE/C;;;;;;GAMG;AACH,SAAS,OAAO;IACd,OAAO,OAAO,CAAC,GAAG,EAAE,CAAA;AACtB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc;IAC5B,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAA;IACvC,MAAM,GAAG,kBAAkB,EAAE,CAAA;IAC7B,OAAO,MAAM,CAAA;AACf,CAAC;AAKD;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACtC,UAAmC,aAAa,EAAE;IAElD,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,oGAAoG;QACpG,8FAA8F;QAC9F,oGAAoG;QACpG,iFAAiF;QACjF,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,OAAO,CAAC,kBAAkB,EAAE,OAAO,EAAE,CAAC,CAAA;YACvD,OAAO,CAAC,MAAM,MAAM,kCAAC,QAAQ,EAAC,CAAmB,CAAA;QACnD,CAAC;QAAC,MAAM,CAAC;YACP,gGAAgG;QAClG,CAAC;IACH,CAAC;IACD,8FAA8F;IAC9F,oGAAoG;IACpG,kGAAkG;IAClG,OAAO,CAAC,MAAM,MAAM,CAAC,kBAAkB,CAAC,CAAmB,CAAA;AAC7D,CAAC;AAED;;;;;;;;kEAQkE;AAClE,MAAM,UAAU,aAAa;IAC3B,IAAI,OAAO,CAAC,GAAG,CAAC,iBAAiB,KAAK,GAAG;QAAE,OAAO,SAAS,CAAA;IAC3D,OAAO,iBAAiB,IAAI,WAAW,EAAE,WAAW,KAAK,SAAS;QAChE,CAAC,CAAC,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC;QAC3C,CAAC,CAAC,SAAS,CAAA;AACf,CAAC"}
+{"version":3,"file":"react-dom-server.js","sourceRoot":"","sources":["../src/react-dom-server.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nifrajs/web-react",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "React render adapter for @nifrajs/web — SSR + hydration (Bun-native JSX, no Babel).",
   "keywords": [
     "bun",
@@ -80,10 +80,10 @@
     "access": "public"
   },
   "dependencies": {
-    "@nifrajs/core": "2.1.0",
-    "@nifrajs/i18n": "2.1.0",
-    "@nifrajs/image": "2.1.0",
-    "@nifrajs/web": "2.1.0"
+    "@nifrajs/core": "2.2.0",
+    "@nifrajs/i18n": "2.2.0",
+    "@nifrajs/image": "2.2.0",
+    "@nifrajs/web": "2.2.0"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/compose.ts

@@ -21,7 +21,14 @@ export function compose(chain: readonly unknown[], props: RenderProps): ReactNod
   let node: ReactNode = createElement(chain[last] as FunctionComponent<RenderProps>, props)
   for (let i = last - 1; i >= 0; i--) {
     // children passed as the 3rd arg (not a `children` prop) — React's canonical form.
-    node = createElement(chain[i] as FunctionComponent, null, node)
+    // Each layout receives its own loader data at its own index. Layouts are the chain's leading
+    // prefix, so `layoutData[i]` belongs to `chain[i]`; anything past that end (a client-only `_error`
+    // boundary marker, the page) reads `undefined` and is unaffected.
+    node = createElement(
+      chain[i] as FunctionComponent<{ data: unknown }>,
+      { data: props.layoutData?.[i] ?? null },
+      node,
+    )
   }
   return createElement(
     RouterContext.Provider,

package/src/react-dom-server.ts

@@ -32,6 +32,23 @@ export interface ReactDomServer {
   renderToReadableStream(node: ReactNode): Promise<ReadableStream<Uint8Array>>
 }
 
+interface RuntimeProcess {
+  getBuiltinModule?(specifier: string): unknown
+}
+
+function dirnamePortable(path: string): string {
+  const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"))
+  return slash <= 0 ? "." : path.slice(0, slash)
+}
+
+function runtimeRealpath(path: string): string {
+  const runtimeProcess = (globalThis as { process?: RuntimeProcess }).process
+  const fs = runtimeProcess?.getBuiltinModule?.("node:fs") as
+    | { realpathSync?: (value: string) => string }
+    | undefined
+  return fs?.realpathSync?.(path) ?? path
+}
+
 // `globalThis.Bun` isn't in the ambient lib types; narrow exactly the one method we need so we never
 // reach for `any`. `resolveSync(specifier, from)` returns the absolute path the specifier resolves to
 // when required from `from` — Bun's runtime resolver, the only lever that re-roots a BARE specifier
@@ -72,6 +89,54 @@ export function reactDomServer(): Promise<ReactDomServer> {
 /** A `Bun.resolveSync`-shaped function (specifier, from) → absolute path. */
 type ResolveSync = (specifier: string, from: string) => string
 
+/**
+ * The dual-React crash, caught on the RESOLVED graph instead of after it detonates.
+ *
+ * The re-root above makes `react-dom/server` load from the app root, which is right almost always. What it
+ * cannot guarantee is that react-dom then pulls in the SAME physical `react` the route components import -
+ * a nested `react` under react-dom, or a components tree resolving react elsewhere, still yields two cores.
+ * Two cores is two hook dispatchers, and the renderer sees a null (or foreign) one: the SSR throws
+ * `resolveDispatcher().useState is null` from deep inside react-dom-server, naming a React internal and
+ * nothing about the two directories that actually caused it. That is hours of inference from a message
+ * that points nowhere useful.
+ *
+ * `nifra doctor` checks what is INSTALLED; this checks what SSR actually RESOLVED, which is the only thing
+ * that can catch a duplicate the two dev pipelines introduce (Bun for SSR, Vite for the client) rather
+ * than the install. It compares the realpath of the `react` react-dom will render with against the
+ * `react` the components import, and if they differ throws with BOTH paths - turning a five-hour hunt into
+ * a five-second read. Silent when they agree, which is the single-copy common case.
+ *
+ * Never manufactures a failure: if either side cannot be resolved it returns, because a resolver that
+ * cannot answer is not evidence of a duplicate. Exported for direct unit testing.
+ */
+export function assertSingleReactCore(
+  reactDomServerPath: string,
+  resolve: ResolveSync,
+  realpath: (path: string) => string = runtimeRealpath,
+): void {
+  let rendererReact: string
+  let componentsReact: string
+  try {
+    // The `react` react-dom/server itself resolves - the core whose dispatcher the renderer sets.
+    rendererReact = realpath(resolve("react", dirnamePortable(reactDomServerPath)))
+    // The `react` the app's route components import - the core they call hooks on.
+    componentsReact = realpath(resolve("react", appRoot()))
+  } catch {
+    return
+  }
+  if (rendererReact === componentsReact) return
+  throw new Error(
+    "[nifra/web-react] two copies of React reached SSR, so hooks render against a null dispatcher " +
+      "(the `resolveDispatcher().useState is null` crash). react-dom renders with a DIFFERENT React " +
+      "than your components import:\n" +
+      `  react-dom's react:  ${rendererReact}\n` +
+      `  components' react:  ${componentsReact}\n` +
+      "Module identity is path-based, so two copies fail even at the same version. Dedupe react to one " +
+      "physical copy - usually a single hoisted install at the workspace root (`nifra doctor` locates " +
+      "the duplicate). A Vite `resolve.dedupe`/alias fixes only the client bundle, not this SSR path.",
+  )
+}
+
 /**
  * Load `react-dom/server`, preferring the app-root-resolved copy under the Bun runtime. Exported for unit
  * tests: `resolve` defaults to the ambient `Bun.resolveSync` (undefined on non-Bun hosts), and a test can
@@ -88,8 +153,16 @@ export async function loadReactDomServer(
     // rather than crashing — degraded (possible duplicate) but never a hard failure.
     try {
       const resolved = resolve("react-dom/server", appRoot())
+      // Before returning the module, verify the react-dom we just re-rooted shares the components' React.
+      // The re-root fixes the common case; this catches the residual duplicate loudly, with both paths,
+      // instead of leaving it to throw a dispatcher-null error on the first hook render. Runs once (this
+      // whole function is cached), dev/unbundled Bun only (the branch `resolve` gates).
+      assertSingleReactCore(resolved, resolve)
       return (await import(resolved)) as ReactDomServer
-    } catch {
+    } catch (err) {
+      // A genuine duplicate is surfaced (re-thrown with both paths); any other failure (react-dom not at
+      // the app root, an odd nested layout) falls through to the bundled specifier rather than crashing.
+      if (err instanceof Error && err.message.includes("two copies of React")) throw err
       // App-root resolution failed; use the specifier resolved from this module's own location below.
     }
   }