hadars 0.1.28 → 0.1.29

package/dist/cli.js

@@ -242,6 +242,9 @@ function pushComponentScope() {
 function popComponentScope(saved) {
   s().localIdCounter = saved;
 }
+function componentCalledUseId() {
+  return s().localIdCounter > 0;
+}
 function snapshotContext() {
   const st = s();
   return { tree: { ...st.currentTreeContext }, localId: st.localIdCounter };
@@ -251,6 +254,121 @@ function restoreContext(snap) {
   st.currentTreeContext = { ...snap.tree };
   st.localIdCounter = snap.localId;
 }
+function getTreeId() {
+  const { id, overflow } = s().currentTreeContext;
+  if (id === 1)
+    return overflow;
+  const stripped = (id & ~(1 << 31 - Math.clz32(id))).toString(32);
+  return stripped + overflow;
+}
+function makeId() {
+  const st = s();
+  const treeId = getTreeId();
+  const n = st.localIdCounter++;
+  let id = "\xAB" + st.idPrefix + "R" + treeId;
+  if (n > 0)
+    id += "H" + n.toString(32);
+  return id + "\xBB";
+}
+
+// src/slim-react/hooks.ts
+function useState(initialState) {
+  const value = typeof initialState === "function" ? initialState() : initialState;
+  return [value, () => {
+  }];
+}
+function useReducer(_reducer, initialState) {
+  return [initialState, () => {
+  }];
+}
+function useEffect(_effect, _deps) {
+}
+function useLayoutEffect(_effect, _deps) {
+}
+function useInsertionEffect(_effect, _deps) {
+}
+function useRef(initialValue) {
+  return { current: initialValue };
+}
+function useMemo(factory, _deps) {
+  return factory();
+}
+function useCallback(callback, _deps) {
+  return callback;
+}
+function useDebugValue(_value, _format) {
+}
+function useImperativeHandle(_ref, _createHandle, _deps) {
+}
+function useSyncExternalStore(_subscribe, getSnapshot, getServerSnapshot) {
+  return (getServerSnapshot || getSnapshot)();
+}
+function useTransition() {
+  return [false, (cb) => cb()];
+}
+function useDeferredValue(value) {
+  return value;
+}
+function useOptimistic(passthrough) {
+  return [passthrough, () => {
+  }];
+}
+function useActionState(_action, initialState, _permalink) {
+  return [initialState, () => {
+  }, false];
+}
+function use(usable) {
+  if (typeof usable === "object" && usable !== null && ("_currentValue" in usable || "_defaultValue" in usable)) {
+    return getContextValue(usable);
+  }
+  const promise = usable;
+  if (promise.status === "fulfilled")
+    return promise.value;
+  if (promise.status === "rejected")
+    throw promise.reason;
+  throw promise;
+}
+
+// src/slim-react/dispatcher.ts
+import ReactPkg from "react";
+var _internals = ReactPkg.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+var slimDispatcher = {
+  useId: makeId,
+  readContext: (ctx) => getContextValue(ctx),
+  useContext: (ctx) => getContextValue(ctx),
+  useState,
+  useReducer,
+  useEffect,
+  useLayoutEffect,
+  useInsertionEffect,
+  useRef,
+  useMemo,
+  useCallback,
+  useDebugValue,
+  useImperativeHandle,
+  useSyncExternalStore,
+  useTransition,
+  useDeferredValue,
+  useOptimistic,
+  useActionState,
+  use,
+  // React internals that compiled output may call
+  useMemoCache: (size) => new Array(size).fill(void 0),
+  useCacheRefresh: () => () => {
+  },
+  useHostTransitionStatus: () => false
+};
+function installDispatcher() {
+  if (!_internals)
+    return null;
+  const prev = _internals.H;
+  _internals.H = slimDispatcher;
+  return prev;
+}
+function restoreDispatcher(prev) {
+  if (_internals)
+    _internals.H = prev;
+}
 
 // src/slim-react/render.ts
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
@@ -655,6 +773,7 @@ function renderComponent(type, props, writer, isSvg) {
     return;
   }
   let result;
+  const prevDispatcher = installDispatcher();
   try {
     if (type.prototype && typeof type.prototype.render === "function") {
       const instance = new type(props);
@@ -668,12 +787,20 @@ function renderComponent(type, props, writer, isSvg) {
       result = type(props);
     }
   } catch (e) {
+    restoreDispatcher(prevDispatcher);
     popComponentScope(savedScope);
     if (isProvider)
       popContextValue(ctx, prevCtxValue);
     throw e;
   }
+  restoreDispatcher(prevDispatcher);
+  let savedIdTree;
+  if (!(result instanceof Promise) && componentCalledUseId()) {
+    savedIdTree = pushTreeContext(1, 0);
+  }
   const finish = () => {
+    if (savedIdTree !== void 0)
+      popTreeContext(savedIdTree);
     popComponentScope(savedScope);
     if (isProvider)
       popContextValue(ctx, prevCtxValue);
@@ -682,22 +809,33 @@ function renderComponent(type, props, writer, isSvg) {
     const m = captureMap();
     return result.then((resolved) => {
       swapContextMap(m);
+      let asyncSavedIdTree;
+      if (componentCalledUseId()) {
+        asyncSavedIdTree = pushTreeContext(1, 0);
+      }
+      const asyncFinish = () => {
+        if (asyncSavedIdTree !== void 0)
+          popTreeContext(asyncSavedIdTree);
+        popComponentScope(savedScope);
+        if (isProvider)
+          popContextValue(ctx, prevCtxValue);
+      };
       const r2 = renderNode(resolved, writer, isSvg);
       if (r2 && typeof r2.then === "function") {
         const m2 = captureMap();
         return r2.then(
           () => {
             swapContextMap(m2);
-            finish();
+            asyncFinish();
           },
           (e) => {
             swapContextMap(m2);
-            finish();
+            asyncFinish();
             throw e;
           }
         );
       }
-      finish();
+      asyncFinish();
     }, (e) => {
       swapContextMap(m);
       finish();

package/dist/slim-react/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/slim-react/index.ts
@@ -182,6 +192,9 @@ function pushComponentScope() {
 function popComponentScope(saved) {
   s().localIdCounter = saved;
 }
+function componentCalledUseId() {
+  return s().localIdCounter > 0;
+}
 function snapshotContext() {
   const st = s();
   return { tree: { ...st.currentTreeContext }, localId: st.localIdCounter };
@@ -202,10 +215,10 @@ function makeId() {
   const st = s();
   const treeId = getTreeId();
   const n = st.localIdCounter++;
-  let id = "_" + st.idPrefix + "R_" + treeId;
+  let id = "\xAB" + st.idPrefix + "R" + treeId;
   if (n > 0)
     id += "H" + n.toString(32);
-  return id + "_";
+  return id + "\xBB";
 }
 
 // src/slim-react/hooks.ts
@@ -298,6 +311,47 @@ function createContext(defaultValue) {
   return context;
 }
 
+// src/slim-react/dispatcher.ts
+var import_react = __toESM(require("react"), 1);
+var _internals = import_react.default.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+var slimDispatcher = {
+  useId: makeId,
+  readContext: (ctx) => getContextValue(ctx),
+  useContext: (ctx) => getContextValue(ctx),
+  useState,
+  useReducer,
+  useEffect,
+  useLayoutEffect,
+  useInsertionEffect,
+  useRef,
+  useMemo,
+  useCallback,
+  useDebugValue,
+  useImperativeHandle,
+  useSyncExternalStore,
+  useTransition,
+  useDeferredValue,
+  useOptimistic,
+  useActionState,
+  use,
+  // React internals that compiled output may call
+  useMemoCache: (size) => new Array(size).fill(void 0),
+  useCacheRefresh: () => () => {
+  },
+  useHostTransitionStatus: () => false
+};
+function installDispatcher() {
+  if (!_internals)
+    return null;
+  const prev = _internals.H;
+  _internals.H = slimDispatcher;
+  return prev;
+}
+function restoreDispatcher(prev) {
+  if (_internals)
+    _internals.H = prev;
+}
+
 // src/slim-react/render.ts
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
   "area",
@@ -701,6 +755,7 @@ function renderComponent(type, props, writer, isSvg) {
     return;
   }
   let result;
+  const prevDispatcher = installDispatcher();
   try {
     if (type.prototype && typeof type.prototype.render === "function") {
       const instance = new type(props);
@@ -714,12 +769,20 @@ function renderComponent(type, props, writer, isSvg) {
       result = type(props);
     }
   } catch (e) {
+    restoreDispatcher(prevDispatcher);
     popComponentScope(savedScope);
     if (isProvider)
       popContextValue(ctx, prevCtxValue);
     throw e;
   }
+  restoreDispatcher(prevDispatcher);
+  let savedIdTree;
+  if (!(result instanceof Promise) && componentCalledUseId()) {
+    savedIdTree = pushTreeContext(1, 0);
+  }
   const finish = () => {
+    if (savedIdTree !== void 0)
+      popTreeContext(savedIdTree);
     popComponentScope(savedScope);
     if (isProvider)
       popContextValue(ctx, prevCtxValue);
@@ -728,22 +791,33 @@ function renderComponent(type, props, writer, isSvg) {
     const m = captureMap();
     return result.then((resolved) => {
       swapContextMap(m);
+      let asyncSavedIdTree;
+      if (componentCalledUseId()) {
+        asyncSavedIdTree = pushTreeContext(1, 0);
+      }
+      const asyncFinish = () => {
+        if (asyncSavedIdTree !== void 0)
+          popTreeContext(asyncSavedIdTree);
+        popComponentScope(savedScope);
+        if (isProvider)
+          popContextValue(ctx, prevCtxValue);
+      };
       const r2 = renderNode(resolved, writer, isSvg);
       if (r2 && typeof r2.then === "function") {
         const m2 = captureMap();
         return r2.then(
           () => {
             swapContextMap(m2);
-            finish();
+            asyncFinish();
           },
           (e) => {
             swapContextMap(m2);
-            finish();
+            asyncFinish();
             throw e;
           }
         );
       }
-      finish();
+      asyncFinish();
     }, (e) => {
       swapContextMap(m);
       finish();

package/dist/slim-react/index.js

@@ -91,6 +91,9 @@ function pushComponentScope() {
 function popComponentScope(saved) {
   s().localIdCounter = saved;
 }
+function componentCalledUseId() {
+  return s().localIdCounter > 0;
+}
 function snapshotContext() {
   const st = s();
   return { tree: { ...st.currentTreeContext }, localId: st.localIdCounter };
@@ -111,10 +114,10 @@ function makeId() {
   const st = s();
   const treeId = getTreeId();
   const n = st.localIdCounter++;
-  let id = "_" + st.idPrefix + "R_" + treeId;
+  let id = "\xAB" + st.idPrefix + "R" + treeId;
   if (n > 0)
     id += "H" + n.toString(32);
-  return id + "_";
+  return id + "\xBB";
 }
 
 // src/slim-react/hooks.ts
@@ -207,6 +210,47 @@ function createContext(defaultValue) {
   return context;
 }
 
+// src/slim-react/dispatcher.ts
+import ReactPkg from "react";
+var _internals = ReactPkg.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+var slimDispatcher = {
+  useId: makeId,
+  readContext: (ctx) => getContextValue(ctx),
+  useContext: (ctx) => getContextValue(ctx),
+  useState,
+  useReducer,
+  useEffect,
+  useLayoutEffect,
+  useInsertionEffect,
+  useRef,
+  useMemo,
+  useCallback,
+  useDebugValue,
+  useImperativeHandle,
+  useSyncExternalStore,
+  useTransition,
+  useDeferredValue,
+  useOptimistic,
+  useActionState,
+  use,
+  // React internals that compiled output may call
+  useMemoCache: (size) => new Array(size).fill(void 0),
+  useCacheRefresh: () => () => {
+  },
+  useHostTransitionStatus: () => false
+};
+function installDispatcher() {
+  if (!_internals)
+    return null;
+  const prev = _internals.H;
+  _internals.H = slimDispatcher;
+  return prev;
+}
+function restoreDispatcher(prev) {
+  if (_internals)
+    _internals.H = prev;
+}
+
 // src/slim-react/render.ts
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
   "area",
@@ -610,6 +654,7 @@ function renderComponent(type, props, writer, isSvg) {
     return;
   }
   let result;
+  const prevDispatcher = installDispatcher();
   try {
     if (type.prototype && typeof type.prototype.render === "function") {
       const instance = new type(props);
@@ -623,12 +668,20 @@ function renderComponent(type, props, writer, isSvg) {
       result = type(props);
     }
   } catch (e) {
+    restoreDispatcher(prevDispatcher);
     popComponentScope(savedScope);
     if (isProvider)
       popContextValue(ctx, prevCtxValue);
     throw e;
   }
+  restoreDispatcher(prevDispatcher);
+  let savedIdTree;
+  if (!(result instanceof Promise) && componentCalledUseId()) {
+    savedIdTree = pushTreeContext(1, 0);
+  }
   const finish = () => {
+    if (savedIdTree !== void 0)
+      popTreeContext(savedIdTree);
     popComponentScope(savedScope);
     if (isProvider)
       popContextValue(ctx, prevCtxValue);
@@ -637,22 +690,33 @@ function renderComponent(type, props, writer, isSvg) {
     const m = captureMap();
     return result.then((resolved) => {
       swapContextMap(m);
+      let asyncSavedIdTree;
+      if (componentCalledUseId()) {
+        asyncSavedIdTree = pushTreeContext(1, 0);
+      }
+      const asyncFinish = () => {
+        if (asyncSavedIdTree !== void 0)
+          popTreeContext(asyncSavedIdTree);
+        popComponentScope(savedScope);
+        if (isProvider)
+          popContextValue(ctx, prevCtxValue);
+      };
       const r2 = renderNode(resolved, writer, isSvg);
       if (r2 && typeof r2.then === "function") {
         const m2 = captureMap();
         return r2.then(
           () => {
             swapContextMap(m2);
-            finish();
+            asyncFinish();
           },
           (e) => {
             swapContextMap(m2);
-            finish();
+            asyncFinish();
             throw e;
           }
         );
       }
-      finish();
+      asyncFinish();
     }, (e) => {
       swapContextMap(m);
       finish();

package/dist/ssr-render-worker.js

@@ -149,6 +149,9 @@ function pushComponentScope() {
 function popComponentScope(saved) {
   s().localIdCounter = saved;
 }
+function componentCalledUseId() {
+  return s().localIdCounter > 0;
+}
 function snapshotContext() {
   const st = s();
   return { tree: { ...st.currentTreeContext }, localId: st.localIdCounter };
@@ -158,6 +161,121 @@ function restoreContext(snap) {
   st.currentTreeContext = { ...snap.tree };
   st.localIdCounter = snap.localId;
 }
+function getTreeId() {
+  const { id, overflow } = s().currentTreeContext;
+  if (id === 1)
+    return overflow;
+  const stripped = (id & ~(1 << 31 - Math.clz32(id))).toString(32);
+  return stripped + overflow;
+}
+function makeId() {
+  const st = s();
+  const treeId = getTreeId();
+  const n = st.localIdCounter++;
+  let id = "\xAB" + st.idPrefix + "R" + treeId;
+  if (n > 0)
+    id += "H" + n.toString(32);
+  return id + "\xBB";
+}
+
+// src/slim-react/hooks.ts
+function useState(initialState) {
+  const value = typeof initialState === "function" ? initialState() : initialState;
+  return [value, () => {
+  }];
+}
+function useReducer(_reducer, initialState) {
+  return [initialState, () => {
+  }];
+}
+function useEffect(_effect, _deps) {
+}
+function useLayoutEffect(_effect, _deps) {
+}
+function useInsertionEffect(_effect, _deps) {
+}
+function useRef(initialValue) {
+  return { current: initialValue };
+}
+function useMemo(factory, _deps) {
+  return factory();
+}
+function useCallback(callback, _deps) {
+  return callback;
+}
+function useDebugValue(_value, _format) {
+}
+function useImperativeHandle(_ref, _createHandle, _deps) {
+}
+function useSyncExternalStore(_subscribe, getSnapshot, getServerSnapshot) {
+  return (getServerSnapshot || getSnapshot)();
+}
+function useTransition() {
+  return [false, (cb) => cb()];
+}
+function useDeferredValue(value) {
+  return value;
+}
+function useOptimistic(passthrough) {
+  return [passthrough, () => {
+  }];
+}
+function useActionState(_action, initialState, _permalink) {
+  return [initialState, () => {
+  }, false];
+}
+function use(usable) {
+  if (typeof usable === "object" && usable !== null && ("_currentValue" in usable || "_defaultValue" in usable)) {
+    return getContextValue(usable);
+  }
+  const promise = usable;
+  if (promise.status === "fulfilled")
+    return promise.value;
+  if (promise.status === "rejected")
+    throw promise.reason;
+  throw promise;
+}
+
+// src/slim-react/dispatcher.ts
+import ReactPkg from "react";
+var _internals = ReactPkg.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+var slimDispatcher = {
+  useId: makeId,
+  readContext: (ctx) => getContextValue(ctx),
+  useContext: (ctx) => getContextValue(ctx),
+  useState,
+  useReducer,
+  useEffect,
+  useLayoutEffect,
+  useInsertionEffect,
+  useRef,
+  useMemo,
+  useCallback,
+  useDebugValue,
+  useImperativeHandle,
+  useSyncExternalStore,
+  useTransition,
+  useDeferredValue,
+  useOptimistic,
+  useActionState,
+  use,
+  // React internals that compiled output may call
+  useMemoCache: (size) => new Array(size).fill(void 0),
+  useCacheRefresh: () => () => {
+  },
+  useHostTransitionStatus: () => false
+};
+function installDispatcher() {
+  if (!_internals)
+    return null;
+  const prev = _internals.H;
+  _internals.H = slimDispatcher;
+  return prev;
+}
+function restoreDispatcher(prev) {
+  if (_internals)
+    _internals.H = prev;
+}
 
 // src/slim-react/render.ts
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
@@ -562,6 +680,7 @@ function renderComponent(type, props, writer, isSvg) {
     return;
   }
   let result;
+  const prevDispatcher = installDispatcher();
   try {
     if (type.prototype && typeof type.prototype.render === "function") {
       const instance = new type(props);
@@ -575,12 +694,20 @@ function renderComponent(type, props, writer, isSvg) {
       result = type(props);
     }
   } catch (e) {
+    restoreDispatcher(prevDispatcher);
     popComponentScope(savedScope);
     if (isProvider)
       popContextValue(ctx, prevCtxValue);
     throw e;
   }
+  restoreDispatcher(prevDispatcher);
+  let savedIdTree;
+  if (!(result instanceof Promise) && componentCalledUseId()) {
+    savedIdTree = pushTreeContext(1, 0);
+  }
   const finish = () => {
+    if (savedIdTree !== void 0)
+      popTreeContext(savedIdTree);
     popComponentScope(savedScope);
     if (isProvider)
       popContextValue(ctx, prevCtxValue);
@@ -589,22 +716,33 @@ function renderComponent(type, props, writer, isSvg) {
     const m = captureMap();
     return result.then((resolved) => {
       swapContextMap(m);
+      let asyncSavedIdTree;
+      if (componentCalledUseId()) {
+        asyncSavedIdTree = pushTreeContext(1, 0);
+      }
+      const asyncFinish = () => {
+        if (asyncSavedIdTree !== void 0)
+          popTreeContext(asyncSavedIdTree);
+        popComponentScope(savedScope);
+        if (isProvider)
+          popContextValue(ctx, prevCtxValue);
+      };
       const r2 = renderNode(resolved, writer, isSvg);
       if (r2 && typeof r2.then === "function") {
         const m2 = captureMap();
         return r2.then(
           () => {
             swapContextMap(m2);
-            finish();
+            asyncFinish();
           },
           (e) => {
             swapContextMap(m2);
-            finish();
+            asyncFinish();
             throw e;
           }
         );
       }
-      finish();
+      asyncFinish();
     }, (e) => {
       swapContextMap(m);
       finish();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hadars",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "description": "Minimal SSR framework for React — rspack, HMR, TypeScript, Bun/Node/Deno",
   "module": "./dist/index.js",
   "type": "module",

package/src/slim-react/dispatcher.ts

@@ -0,0 +1,69 @@
+/**
+ * React dispatcher shim for slim-react SSR.
+ *
+ * During a slim-react render, `React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE.H`
+ * is null, so any component that calls `React.useId()` (or another hook) via
+ * React's own package will hit `resolveDispatcher()` → null → error.
+ *
+ * We install a minimal dispatcher object for the duration of each component
+ * call so that `React.useId()` routes through slim-react's tree-aware
+ * `makeId()`.  All other hooks already have working SSR stubs in hooks.ts;
+ * they are forwarded here so libraries that call them via `React.*` also work.
+ */
+
+import { makeId, getContextValue } from "./renderContext";
+import {
+  useState, useReducer, useEffect, useLayoutEffect, useInsertionEffect,
+  useRef, useMemo, useCallback, useDebugValue, useImperativeHandle,
+  useSyncExternalStore, useTransition, useDeferredValue,
+  useOptimistic, useActionState, use,
+} from "./hooks";
+
+import ReactPkg from "react";
+
+// React 19 exposes its shared internals under this key.
+const _internals: { H: object | null } | undefined =
+  (ReactPkg as any).__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+
+// The dispatcher object we install. We keep a stable reference so the same
+// object is reused across every component call.
+const slimDispatcher: Record<string, unknown> = {
+  useId: makeId,
+  readContext: (ctx: any) => getContextValue(ctx),
+  useContext: (ctx: any) => getContextValue(ctx),
+  useState,
+  useReducer,
+  useEffect,
+  useLayoutEffect,
+  useInsertionEffect,
+  useRef,
+  useMemo,
+  useCallback,
+  useDebugValue,
+  useImperativeHandle,
+  useSyncExternalStore,
+  useTransition,
+  useDeferredValue,
+  useOptimistic,
+  useActionState,
+  use,
+  // React internals that compiled output may call
+  useMemoCache: (size: number) => new Array(size).fill(undefined),
+  useCacheRefresh: () => () => {},
+  useHostTransitionStatus: () => false,
+};
+
+/**
+ * Install the slim dispatcher and return the previous value.
+ * Call `restoreDispatcher(prev)` when the component finishes.
+ */
+export function installDispatcher(): object | null {
+  if (!_internals) return null;
+  const prev = _internals.H;
+  _internals.H = slimDispatcher;
+  return prev;
+}
+
+export function restoreDispatcher(prev: object | null): void {
+  if (_internals) _internals.H = prev;
+}

package/src/slim-react/render.ts

@@ -28,6 +28,7 @@ import {
   popTreeContext,
   pushComponentScope,
   popComponentScope,
+  componentCalledUseId,
   snapshotContext,
   restoreContext,
   pushContextValue,
@@ -35,7 +36,9 @@ import {
   getContextValue,
   swapContextMap,
   captureMap,
+  type TreeContext,
 } from "./renderContext";
+import { installDispatcher, restoreDispatcher } from "./dispatcher";
 
 // ---------------------------------------------------------------------------
 // HTML helpers
@@ -630,6 +633,7 @@ function renderComponent(
   }
 
   let result: SlimNode;
+  const prevDispatcher = installDispatcher();
   try {
     if (type.prototype && typeof type.prototype.render === "function") {
       const instance = new (type as any)(props);
@@ -643,12 +647,25 @@ function renderComponent(
       result = type(props);
     }
   } catch (e) {
+    restoreDispatcher(prevDispatcher);
     popComponentScope(savedScope);
     if (isProvider) popContextValue(ctx, prevCtxValue);
     throw e;
   }
+  restoreDispatcher(prevDispatcher);
+
+  // React 19 finishFunctionComponent: if the component called useId, push a
+  // tree-context slot for the component's OUTPUT children — matching React 19's
+  // `pushTreeContext(keyPath, 1, 0)` call inside finishFunctionComponent.
+  // This ensures that useId IDs produced by child components of a useId-calling
+  // component are tree-positioned identically to React's own renderer.
+  let savedIdTree: TreeContext | undefined;
+  if (!(result instanceof Promise) && componentCalledUseId()) {
+    savedIdTree = pushTreeContext(1, 0);
+  }
 
   const finish = () => {
+    if (savedIdTree !== undefined) popTreeContext(savedIdTree);
     popComponentScope(savedScope);
     if (isProvider) popContextValue(ctx, prevCtxValue);
   };
@@ -658,15 +675,25 @@ function renderComponent(
     const m = captureMap();
     return result.then((resolved) => {
       swapContextMap(m);
+      // Check useId after the async body has finished executing.
+      let asyncSavedIdTree: TreeContext | undefined;
+      if (componentCalledUseId()) {
+        asyncSavedIdTree = pushTreeContext(1, 0);
+      }
+      const asyncFinish = () => {
+        if (asyncSavedIdTree !== undefined) popTreeContext(asyncSavedIdTree);
+        popComponentScope(savedScope);
+        if (isProvider) popContextValue(ctx, prevCtxValue);
+      };
       const r = renderNode(resolved, writer, isSvg);
       if (r && typeof (r as any).then === "function") {
         const m2 = captureMap();
         return (r as Promise<void>).then(
-          () => { swapContextMap(m2); finish(); },
-          (e) => { swapContextMap(m2); finish(); throw e; },
+          () => { swapContextMap(m2); asyncFinish(); },
+          (e) => { swapContextMap(m2); asyncFinish(); throw e; },
         );
       }
-      finish();
+      asyncFinish();
     }, (e) => { swapContextMap(m); finish(); throw e; });
   }
 

package/src/slim-react/renderContext.ts

@@ -160,6 +160,11 @@ export function popComponentScope(saved: number) {
   s().localIdCounter = saved;
 }
 
+/** True if the current component has called useId at least once. */
+export function componentCalledUseId(): boolean {
+  return s().localIdCounter > 0;
+}
+
 export function snapshotContext(): { tree: TreeContext; localId: number } {
   const st = s();
   return { tree: { ...st.currentTreeContext }, localId: st.localIdCounter };
@@ -187,19 +192,20 @@ function getTreeId(): string {
 /**
  * Generate a `useId`-compatible ID for the current call site.
  *
- * Format: `_<idPrefix>R_<treeId>_`
- *   with an optional `H<n>` suffix when the same component calls useId
- *   more than once (matching React 19's `localIdCounter` behaviour).
+ * Format: `«<idPrefix>R<treeId>»`  (React 19.1+)
+ *   with an optional `H<n>` suffix for the n-th useId call in the same
+ *   component (matching React 19's `localIdCounter` behaviour).
  *
- * This matches React 19's `mountId` output on both the Fizz SSR renderer
- * and the client hydration path, so the IDs produced here will agree with
- * the real React runtime during `hydrateRoot`.
+ * React 19.1 switched from `_R_<id>_` to `«R<id>»` (U+00AB / U+00BB).
+ * This matches React 19.1's `mountId` output on the Fizz SSR renderer and
+ * the client hydration path, so the IDs produced here will agree with the
+ * real React runtime during `hydrateRoot`.
  */
 export function makeId(): string {
   const st = s();
   const treeId = getTreeId();
   const n = st.localIdCounter++;
-  let id = "_" + st.idPrefix + "R_" + treeId;
+  let id = "\u00ab" + st.idPrefix + "R" + treeId;
   if (n > 0) id += "H" + n.toString(32);
-  return id + "_";
+  return id + "\u00bb";
 }