hadars 0.1.27 → 0.1.29

package/dist/cli.js

@@ -190,7 +190,7 @@ function popContextValue(context, prev) {
   _g[MAP_KEY]?.set(context, prev);
 }
 var GLOBAL_KEY = "__slimReactRenderState";
-var EMPTY = { id: 0, overflow: "", bits: 0 };
+var EMPTY = { id: 1, overflow: "" };
 function s() {
   const g = globalThis;
   if (!g[GLOBAL_KEY]) {
@@ -206,20 +206,27 @@ function resetRenderState() {
 function pushTreeContext(totalChildren, index) {
   const st = s();
   const saved = { ...st.currentTreeContext };
-  const pendingBits = 32 - Math.clz32(totalChildren);
+  const baseIdWithLeadingBit = st.currentTreeContext.id;
+  const baseOverflow = st.currentTreeContext.overflow;
+  const baseLength = 31 - Math.clz32(baseIdWithLeadingBit);
+  let baseId = baseIdWithLeadingBit & ~(1 << baseLength);
   const slot = index + 1;
-  const totalBits = st.currentTreeContext.bits + pendingBits;
-  if (totalBits <= 30) {
+  const newBits = 32 - Math.clz32(totalChildren);
+  const length = newBits + baseLength;
+  if (30 < length) {
+    const numberOfOverflowBits = baseLength - baseLength % 5;
+    const overflowStr = (baseId & (1 << numberOfOverflowBits) - 1).toString(32);
+    baseId >>= numberOfOverflowBits;
+    const newBaseLength = baseLength - numberOfOverflowBits;
     st.currentTreeContext = {
-      id: st.currentTreeContext.id << pendingBits | slot,
-      overflow: st.currentTreeContext.overflow,
-      bits: totalBits
+      id: 1 << newBits + newBaseLength | slot << newBaseLength | baseId,
+      overflow: overflowStr + baseOverflow
     };
   } else {
-    let newOverflow = st.currentTreeContext.overflow;
-    if (st.currentTreeContext.bits > 0)
-      newOverflow += st.currentTreeContext.id.toString(32);
-    st.currentTreeContext = { id: 1 << pendingBits | slot, overflow: newOverflow, bits: pendingBits };
+    st.currentTreeContext = {
+      id: 1 << length | slot << baseLength | baseId,
+      overflow: baseOverflow
+    };
   }
   return saved;
 }
@@ -235,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 };
@@ -244,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([
@@ -425,7 +550,11 @@ function renderAttributes(props, isSvg) {
       continue;
     }
     if (value === true) {
-      attrs += ` ${attrName}=""`;
+      if (attrName.startsWith("aria-") || attrName.startsWith("data-")) {
+        attrs += ` ${attrName}="true"`;
+      } else {
+        attrs += ` ${attrName}=""`;
+      }
       continue;
     }
     if (key === "style" && typeof value === "object") {
@@ -644,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);
@@ -657,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);
@@ -671,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
@@ -130,7 +140,7 @@ function popContextValue(context, prev) {
   _g[MAP_KEY]?.set(context, prev);
 }
 var GLOBAL_KEY = "__slimReactRenderState";
-var EMPTY = { id: 0, overflow: "", bits: 0 };
+var EMPTY = { id: 1, overflow: "" };
 function s() {
   const g = globalThis;
   if (!g[GLOBAL_KEY]) {
@@ -146,20 +156,27 @@ function resetRenderState() {
 function pushTreeContext(totalChildren, index) {
   const st = s();
   const saved = { ...st.currentTreeContext };
-  const pendingBits = 32 - Math.clz32(totalChildren);
+  const baseIdWithLeadingBit = st.currentTreeContext.id;
+  const baseOverflow = st.currentTreeContext.overflow;
+  const baseLength = 31 - Math.clz32(baseIdWithLeadingBit);
+  let baseId = baseIdWithLeadingBit & ~(1 << baseLength);
   const slot = index + 1;
-  const totalBits = st.currentTreeContext.bits + pendingBits;
-  if (totalBits <= 30) {
+  const newBits = 32 - Math.clz32(totalChildren);
+  const length = newBits + baseLength;
+  if (30 < length) {
+    const numberOfOverflowBits = baseLength - baseLength % 5;
+    const overflowStr = (baseId & (1 << numberOfOverflowBits) - 1).toString(32);
+    baseId >>= numberOfOverflowBits;
+    const newBaseLength = baseLength - numberOfOverflowBits;
     st.currentTreeContext = {
-      id: st.currentTreeContext.id << pendingBits | slot,
-      overflow: st.currentTreeContext.overflow,
-      bits: totalBits
+      id: 1 << newBits + newBaseLength | slot << newBaseLength | baseId,
+      overflow: overflowStr + baseOverflow
     };
   } else {
-    let newOverflow = st.currentTreeContext.overflow;
-    if (st.currentTreeContext.bits > 0)
-      newOverflow += st.currentTreeContext.id.toString(32);
-    st.currentTreeContext = { id: 1 << pendingBits | slot, overflow: newOverflow, bits: pendingBits };
+    st.currentTreeContext = {
+      id: 1 << length | slot << baseLength | baseId,
+      overflow: baseOverflow
+    };
   }
   return saved;
 }
@@ -175,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 };
@@ -185,20 +205,20 @@ function restoreContext(snap) {
   st.localIdCounter = snap.localId;
 }
 function getTreeId() {
-  const { id, overflow, bits } = s().currentTreeContext;
-  return bits > 0 ? overflow + id.toString(32) : overflow;
+  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 = ":" + st.idPrefix + "R";
-  if (treeId.length > 0)
-    id += treeId;
-  id += ":";
+  let id = "\xAB" + st.idPrefix + "R" + treeId;
   if (n > 0)
-    id += "H" + n.toString(32) + ":";
-  return id;
+    id += "H" + n.toString(32);
+  return id + "\xBB";
 }
 
 // src/slim-react/hooks.ts
@@ -291,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",
@@ -471,7 +532,11 @@ function renderAttributes(props, isSvg) {
       continue;
     }
     if (value === true) {
-      attrs += ` ${attrName}=""`;
+      if (attrName.startsWith("aria-") || attrName.startsWith("data-")) {
+        attrs += ` ${attrName}="true"`;
+      } else {
+        attrs += ` ${attrName}=""`;
+      }
       continue;
     }
     if (key === "style" && typeof value === "object") {
@@ -690,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);
@@ -703,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);
@@ -717,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

@@ -39,7 +39,7 @@ function popContextValue(context, prev) {
   _g[MAP_KEY]?.set(context, prev);
 }
 var GLOBAL_KEY = "__slimReactRenderState";
-var EMPTY = { id: 0, overflow: "", bits: 0 };
+var EMPTY = { id: 1, overflow: "" };
 function s() {
   const g = globalThis;
   if (!g[GLOBAL_KEY]) {
@@ -55,20 +55,27 @@ function resetRenderState() {
 function pushTreeContext(totalChildren, index) {
   const st = s();
   const saved = { ...st.currentTreeContext };
-  const pendingBits = 32 - Math.clz32(totalChildren);
+  const baseIdWithLeadingBit = st.currentTreeContext.id;
+  const baseOverflow = st.currentTreeContext.overflow;
+  const baseLength = 31 - Math.clz32(baseIdWithLeadingBit);
+  let baseId = baseIdWithLeadingBit & ~(1 << baseLength);
   const slot = index + 1;
-  const totalBits = st.currentTreeContext.bits + pendingBits;
-  if (totalBits <= 30) {
+  const newBits = 32 - Math.clz32(totalChildren);
+  const length = newBits + baseLength;
+  if (30 < length) {
+    const numberOfOverflowBits = baseLength - baseLength % 5;
+    const overflowStr = (baseId & (1 << numberOfOverflowBits) - 1).toString(32);
+    baseId >>= numberOfOverflowBits;
+    const newBaseLength = baseLength - numberOfOverflowBits;
     st.currentTreeContext = {
-      id: st.currentTreeContext.id << pendingBits | slot,
-      overflow: st.currentTreeContext.overflow,
-      bits: totalBits
+      id: 1 << newBits + newBaseLength | slot << newBaseLength | baseId,
+      overflow: overflowStr + baseOverflow
     };
   } else {
-    let newOverflow = st.currentTreeContext.overflow;
-    if (st.currentTreeContext.bits > 0)
-      newOverflow += st.currentTreeContext.id.toString(32);
-    st.currentTreeContext = { id: 1 << pendingBits | slot, overflow: newOverflow, bits: pendingBits };
+    st.currentTreeContext = {
+      id: 1 << length | slot << baseLength | baseId,
+      overflow: baseOverflow
+    };
   }
   return saved;
 }
@@ -84,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 };
@@ -94,20 +104,20 @@ function restoreContext(snap) {
   st.localIdCounter = snap.localId;
 }
 function getTreeId() {
-  const { id, overflow, bits } = s().currentTreeContext;
-  return bits > 0 ? overflow + id.toString(32) : overflow;
+  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 = ":" + st.idPrefix + "R";
-  if (treeId.length > 0)
-    id += treeId;
-  id += ":";
+  let id = "\xAB" + st.idPrefix + "R" + treeId;
   if (n > 0)
-    id += "H" + n.toString(32) + ":";
-  return id;
+    id += "H" + n.toString(32);
+  return id + "\xBB";
 }
 
 // src/slim-react/hooks.ts
@@ -200,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",
@@ -380,7 +431,11 @@ function renderAttributes(props, isSvg) {
       continue;
     }
     if (value === true) {
-      attrs += ` ${attrName}=""`;
+      if (attrName.startsWith("aria-") || attrName.startsWith("data-")) {
+        attrs += ` ${attrName}="true"`;
+      } else {
+        attrs += ` ${attrName}=""`;
+      }
       continue;
     }
     if (key === "style" && typeof value === "object") {
@@ -599,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);
@@ -612,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);
@@ -626,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

@@ -97,7 +97,7 @@ function popContextValue(context, prev) {
   _g[MAP_KEY]?.set(context, prev);
 }
 var GLOBAL_KEY = "__slimReactRenderState";
-var EMPTY = { id: 0, overflow: "", bits: 0 };
+var EMPTY = { id: 1, overflow: "" };
 function s() {
   const g = globalThis;
   if (!g[GLOBAL_KEY]) {
@@ -113,20 +113,27 @@ function resetRenderState() {
 function pushTreeContext(totalChildren, index) {
   const st = s();
   const saved = { ...st.currentTreeContext };
-  const pendingBits = 32 - Math.clz32(totalChildren);
+  const baseIdWithLeadingBit = st.currentTreeContext.id;
+  const baseOverflow = st.currentTreeContext.overflow;
+  const baseLength = 31 - Math.clz32(baseIdWithLeadingBit);
+  let baseId = baseIdWithLeadingBit & ~(1 << baseLength);
   const slot = index + 1;
-  const totalBits = st.currentTreeContext.bits + pendingBits;
-  if (totalBits <= 30) {
+  const newBits = 32 - Math.clz32(totalChildren);
+  const length = newBits + baseLength;
+  if (30 < length) {
+    const numberOfOverflowBits = baseLength - baseLength % 5;
+    const overflowStr = (baseId & (1 << numberOfOverflowBits) - 1).toString(32);
+    baseId >>= numberOfOverflowBits;
+    const newBaseLength = baseLength - numberOfOverflowBits;
     st.currentTreeContext = {
-      id: st.currentTreeContext.id << pendingBits | slot,
-      overflow: st.currentTreeContext.overflow,
-      bits: totalBits
+      id: 1 << newBits + newBaseLength | slot << newBaseLength | baseId,
+      overflow: overflowStr + baseOverflow
     };
   } else {
-    let newOverflow = st.currentTreeContext.overflow;
-    if (st.currentTreeContext.bits > 0)
-      newOverflow += st.currentTreeContext.id.toString(32);
-    st.currentTreeContext = { id: 1 << pendingBits | slot, overflow: newOverflow, bits: pendingBits };
+    st.currentTreeContext = {
+      id: 1 << length | slot << baseLength | baseId,
+      overflow: baseOverflow
+    };
   }
   return saved;
 }
@@ -142,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 };
@@ -151,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([
@@ -332,7 +457,11 @@ function renderAttributes(props, isSvg) {
       continue;
     }
     if (value === true) {
-      attrs += ` ${attrName}=""`;
+      if (attrName.startsWith("aria-") || attrName.startsWith("data-")) {
+        attrs += ` ${attrName}="true"`;
+      } else {
+        attrs += ` ${attrName}=""`;
+      }
       continue;
     }
     if (key === "style" && typeof value === "object") {
@@ -551,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);
@@ -564,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);
@@ -578,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.27",
+  "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
@@ -287,8 +290,13 @@ function renderAttributes(props: Record<string, any>, isSvg: boolean): string {
       continue;
     }
     if (value === true) {
-      // Emit as attr="" to match React's server output exactly.
-      attrs += ` ${attrName}=""`;
+      // aria-* and data-* are string attributes: true must serialize to "true".
+      // HTML boolean attributes (disabled, hidden, checked, …) use attr="" (present-without-value).
+      if (attrName.startsWith("aria-") || attrName.startsWith("data-")) {
+        attrs += ` ${attrName}="true"`;
+      } else {
+        attrs += ` ${attrName}=""`;
+      }
       continue;
     }
     if (key === "style" && typeof value === "object") {
@@ -625,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);
@@ -638,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);
   };
@@ -653,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

@@ -63,10 +63,15 @@ export function popContextValue(context: object, prev: unknown): void {
   (_g[MAP_KEY] as Map<object, unknown> | null)?.set(context, prev);
 }
 
+// TreeContext matches React 19's representation exactly:
+// `id` is a packed bitfield with a leading sentinel `1` bit followed by tree
+// path slots. The most-recently-pushed slot occupies the HIGHEST non-sentinel
+// bits, matching React 19's Fizz `pushTreeContext` bit-packing order.
+// `overflow` accumulates segments that no longer fit in the 30-bit budget,
+// prepended newest-first (same as React 19).
 export interface TreeContext {
-  id: number;
-  overflow: string;
-  bits: number;
+  id: number;       // bitfield with sentinel; 1 = empty (just sentinel, no data)
+  overflow: string; // base-32 partial path segments that overflowed
 }
 
 interface RenderState {
@@ -76,7 +81,8 @@ interface RenderState {
 }
 
 const GLOBAL_KEY = "__slimReactRenderState";
-const EMPTY: TreeContext = { id: 0, overflow: "", bits: 0 };
+// React 19's initial context is { id: 1, overflow: "" } — sentinel bit only.
+const EMPTY: TreeContext = { id: 1, overflow: "" };
 
 function s(): RenderState {
   const g = globalThis as any;
@@ -96,23 +102,45 @@ export function setIdPrefix(prefix: string) {
   s().idPrefix = prefix;
 }
 
+/**
+ * Push a new level onto the tree context — matches React 19's Fizz
+ * `pushTreeContext` exactly:
+ *   - new slot occupies the HIGHER bit positions (above the old base data)
+ *   - on overflow, the LOWEST bits of the old data move to the overflow string
+ *     (rounded to a multiple of 5 so base-32 digits align on byte boundaries)
+ */
 export function pushTreeContext(totalChildren: number, index: number): TreeContext {
   const st = s();
   const saved: TreeContext = { ...st.currentTreeContext };
-  const pendingBits = 32 - Math.clz32(totalChildren);
-  const slot = index + 1;
-  const totalBits = st.currentTreeContext.bits + pendingBits;
 
-  if (totalBits <= 30) {
+  const baseIdWithLeadingBit = st.currentTreeContext.id;
+  const baseOverflow = st.currentTreeContext.overflow;
+  // Number of data bits currently stored (excludes the sentinel bit).
+  const baseLength = 31 - Math.clz32(baseIdWithLeadingBit);
+  // Strip the sentinel to get the pure data portion.
+  let baseId = baseIdWithLeadingBit & ~(1 << baseLength);
+
+  const slot = index + 1; // 1-indexed
+  const newBits = 32 - Math.clz32(totalChildren); // bits required for the new slot
+  const length = newBits + baseLength;             // total data bits after push
+
+  if (30 < length) {
+    // Overflow: flush the lowest bits of the old data to the overflow string.
+    // Round down to a multiple of 5 so each base-32 character covers exactly
+    // 5 bits (no fractional digits that would corrupt adjacent chars).
+    const numberOfOverflowBits = baseLength - (baseLength % 5);
+    const overflowStr = (baseId & ((1 << numberOfOverflowBits) - 1)).toString(32);
+    baseId >>= numberOfOverflowBits;
+    const newBaseLength = baseLength - numberOfOverflowBits;
     st.currentTreeContext = {
-      id: (st.currentTreeContext.id << pendingBits) | slot,
-      overflow: st.currentTreeContext.overflow,
-      bits: totalBits,
+      id: (1 << (newBits + newBaseLength)) | (slot << newBaseLength) | baseId,
+      overflow: overflowStr + baseOverflow,
     };
   } else {
-    let newOverflow = st.currentTreeContext.overflow;
-    if (st.currentTreeContext.bits > 0) newOverflow += st.currentTreeContext.id.toString(32);
-    st.currentTreeContext = { id: (1 << pendingBits) | slot, overflow: newOverflow, bits: pendingBits };
+    st.currentTreeContext = {
+      id: (1 << length) | (slot << baseLength) | baseId,
+      overflow: baseOverflow,
+    };
   }
   return saved;
 }
@@ -132,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 };
@@ -143,18 +176,36 @@ export function restoreContext(snap: { tree: TreeContext; localId: number }) {
   st.localIdCounter = snap.localId;
 }
 
+/**
+ * Produce the base-32 tree path string from the current context.
+ * Strips the sentinel bit then concatenates stripped_id + overflow —
+ * the same formula React 19 uses in both its Fizz SSR renderer and
+ * the client-side `mountId`.
+ */
 function getTreeId(): string {
-  const { id, overflow, bits } = s().currentTreeContext;
-  return bits > 0 ? overflow + id.toString(32) : overflow;
+  const { id, overflow } = s().currentTreeContext;
+  if (id === 1) return overflow; // sentinel only → no local path segment
+  const stripped = (id & ~(1 << (31 - Math.clz32(id)))).toString(32);
+  return stripped + overflow;
 }
 
+/**
+ * Generate a `useId`-compatible ID for the current call site.
+ *
+ * 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).
+ *
+ * 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";
-  if (treeId.length > 0) id += treeId;
-  id += ":";
-  if (n > 0) id += "H" + n.toString(32) + ":";
-  return id;
+  let id = "\u00ab" + st.idPrefix + "R" + treeId;
+  if (n > 0) id += "H" + n.toString(32);
+  return id + "\u00bb";
 }