hadars 0.1.28 → 0.1.30

package/dist/slim-react/index.js

@@ -47,10 +47,11 @@ function s() {
   }
   return g[GLOBAL_KEY];
 }
-function resetRenderState() {
+function resetRenderState(idPrefix = "") {
   const st = s();
   st.currentTreeContext = { ...EMPTY };
   st.localIdCounter = 0;
+  st.idPrefix = idPrefix;
 }
 function pushTreeContext(totalChildren, index) {
   const st = s();
@@ -91,6 +92,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,7 +115,7 @@ function makeId() {
   const st = s();
   const treeId = getTreeId();
   const n = st.localIdCounter++;
-  let id = "_" + st.idPrefix + "R_" + treeId;
+  let id = "_R_" + st.idPrefix + treeId;
   if (n > 0)
     id += "H" + n.toString(32);
   return id + "_";
@@ -207,6 +211,47 @@ function createContext(defaultValue) {
   return context;
 }
 
+// src/slim-react/dispatcher.ts
+import * as ReactNS from "react";
+var _internals = ReactNS.__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 +655,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 +669,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 +691,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();
@@ -732,8 +797,8 @@ async function renderSuspense(props, writer, isSvg = false) {
   const snap = snapshotContext();
   while (attempts < MAX_SUSPENSE_RETRIES) {
     restoreContext(snap);
+    let buffer = new BufferWriter();
     try {
-      const buffer = new BufferWriter();
       const r = renderNode(children, buffer, isSvg);
       if (r && typeof r.then === "function") {
         const m = captureMap();
@@ -767,12 +832,13 @@ async function renderSuspense(props, writer, isSvg = false) {
   }
   writer.write("<!--/$-->");
 }
-function renderToStream(element) {
+function renderToStream(element, options) {
   const encoder = new TextEncoder();
+  const idPrefix = options?.identifierPrefix ?? "";
   const contextMap = /* @__PURE__ */ new Map();
   return new ReadableStream({
     async start(controller) {
-      resetRenderState();
+      resetRenderState(idPrefix);
       const prev = swapContextMap(contextMap);
       const writer = {
         lastWasText: false,
@@ -801,12 +867,13 @@ function renderToStream(element) {
     }
   });
 }
-async function renderToString(element) {
+async function renderToString(element, options) {
+  const idPrefix = options?.identifierPrefix ?? "";
   const contextMap = /* @__PURE__ */ new Map();
   const prev = swapContextMap(contextMap);
   try {
     for (let attempt = 0; attempt < MAX_SUSPENSE_RETRIES; attempt++) {
-      resetRenderState();
+      resetRenderState(idPrefix);
       swapContextMap(contextMap);
       const chunks = [];
       const writer = {

package/dist/ssr-render-worker.js

@@ -48,7 +48,6 @@ var FRAGMENT_TYPE = Symbol.for("react.fragment");
 var SUSPENSE_TYPE = Symbol.for("react.suspense");
 
 // src/slim-react/jsx.ts
-var Fragment = FRAGMENT_TYPE;
 function createElement(type, props, ...children) {
   const normalizedProps = { ...props || {} };
   if (children.length === 1) {
@@ -105,10 +104,11 @@ function s() {
   }
   return g[GLOBAL_KEY];
 }
-function resetRenderState() {
+function resetRenderState(idPrefix = "") {
   const st = s();
   st.currentTreeContext = { ...EMPTY };
   st.localIdCounter = 0;
+  st.idPrefix = idPrefix;
 }
 function pushTreeContext(totalChildren, index) {
   const st = s();
@@ -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 = "_R_" + st.idPrefix + treeId;
+  if (n > 0)
+    id += "H" + n.toString(32);
+  return id + "_";
+}
+
+// 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 * as ReactNS from "react";
+var _internals = ReactNS.__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();
@@ -684,8 +822,8 @@ async function renderSuspense(props, writer, isSvg = false) {
   const snap = snapshotContext();
   while (attempts < MAX_SUSPENSE_RETRIES) {
     restoreContext(snap);
+    let buffer = new BufferWriter();
     try {
-      const buffer = new BufferWriter();
       const r = renderNode(children, buffer, isSvg);
       if (r && typeof r.then === "function") {
         const m = captureMap();
@@ -719,12 +857,13 @@ async function renderSuspense(props, writer, isSvg = false) {
   }
   writer.write("<!--/$-->");
 }
-async function renderToString(element) {
+async function renderToString(element, options) {
+  const idPrefix = options?.identifierPrefix ?? "";
   const contextMap = /* @__PURE__ */ new Map();
   const prev = swapContextMap(contextMap);
   try {
     for (let attempt = 0; attempt < MAX_SUSPENSE_RETRIES; attempt++) {
-      resetRenderState();
+      resetRenderState(idPrefix);
       swapContextMap(contextMap);
       const chunks = [];
       const writer = {
@@ -865,26 +1004,16 @@ parentPort.on("message", async (msg) => {
       return;
     const { finalAppProps, clientProps, unsuspend, headHtml, status } = await runFullLifecycle(request);
     const Component = _ssrMod.default;
-    const page = createElement(
-      Fragment,
-      null,
-      createElement("div", { id: "app" }, createElement(Component, finalAppProps)),
-      createElement("script", {
-        id: "hadars",
-        type: "application/json",
-        dangerouslySetInnerHTML: {
-          __html: JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c")
-        }
-      })
-    );
     globalThis.__hadarsUnsuspend = unsuspend;
-    let html;
+    let appHtml;
     try {
-      html = await renderToString(page);
+      appHtml = await renderToString(createElement(Component, finalAppProps));
     } finally {
       globalThis.__hadarsUnsuspend = null;
     }
-    html = processSegmentCache(html);
+    appHtml = processSegmentCache(appHtml);
+    const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c");
+    const html = `<div id="app">${appHtml}</div><script id="hadars" type="application/json">${scriptContent}</script>`;
     parentPort.postMessage({ id, html, headHtml, status });
   } catch (err) {
     parentPort.postMessage({ id, error: err?.message ?? String(err) });

package/dist/utils/Head.tsx

@@ -204,6 +204,9 @@ export function initServerDataCache(data: Record<string, unknown>) {
  *   awaited, the cache entry is then cleared so that the next render re-calls
  *   `fn()` — at that point the Suspense hook returns synchronously.
  *
+ * `fn` is **server-only**: it is never called in the browser. The resolved value
+ * is serialised into `__serverData` and returned from cache during hydration.
+ *
  * @example
  * const user = useServerData('current_user', () => db.getUser(id));
  * const post = useServerData(['post', postId], () => db.getPost(postId));
@@ -213,14 +216,9 @@ export function useServerData<T>(key: string | string[], fn: () => Promise<T> |
     const cacheKey = Array.isArray(key) ? JSON.stringify(key) : key;
 
     if (typeof window !== 'undefined') {
-        // Client: if the server serialised a value for this key, return it directly
-        // (normal async case — no re-fetch in the browser).
-        if (clientServerDataCache.has(cacheKey)) {
-            return clientServerDataCache.get(cacheKey) as T | undefined;
-        }
-        // Key not serialised → Suspense hook case (e.g. useSuspenseQuery).
-        // Call fn() directly so the hook runs with its own hydrated cache.
-        return fn() as T | undefined;
+        // Client: if the server serialised a value for this key, return it directly.
+        // fn() is a server-only operation and must never run in the browser.
+        return clientServerDataCache.get(cacheKey) as T | undefined;
     }
 
     // Server: communicate via globalThis.__hadarsUnsuspend which is set by the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hadars",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "description": "Minimal SSR framework for React — rspack, HMR, TypeScript, Bun/Node/Deno",
   "module": "./dist/index.js",
   "type": "module",
@@ -52,8 +52,8 @@
     "node": ">=18.0.0"
   },
   "peerDependencies": {
-    "react": "^19.1.1",
-    "react-dom": "^19.1.1",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
     "typescript": "^5"
   },
   "peerDependenciesMeta": {
@@ -73,6 +73,8 @@
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
     "esbuild": "^0.19.12",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
     "tsup": "^6.7.0",
     "typescript": "^5.9.3"
   },

package/src/build.ts

@@ -73,7 +73,7 @@ async function processHtmlTemplate(templatePath: string): Promise<string> {
 const HEAD_MARKER = '<meta name="HADARS_HEAD">';
 const BODY_MARKER = '<meta name="HADARS_BODY">';
 
-import { renderToString as slimRenderToString } from './slim-react/index';
+import { renderToString as slimRenderToString, createElement } from './slim-react/index';
 
 // Round-robin thread pool for SSR rendering — used on Bun/Deno where
 // node:cluster is not available but node:worker_threads is.
@@ -194,7 +194,9 @@ class RenderWorkerPool {
 }
 
 async function buildSsrResponse(
-    ReactPage: any,
+    App: any,
+    appProps: Record<string, unknown>,
+    clientProps: Record<string, unknown>,
     headHtml: string,
     status: number,
     getPrecontentHtml: (headHtml: string) => Promise<[string, string]>,
@@ -210,12 +212,15 @@ async function buildSsrResponse(
             let bodyHtml: string;
             try {
                 (globalThis as any).__hadarsUnsuspend = unsuspendForRender;
-                bodyHtml = await slimRenderToString(ReactPage);
+                bodyHtml = await slimRenderToString(createElement(App, appProps));
             } finally {
                 (globalThis as any).__hadarsUnsuspend = null;
             }
             bodyHtml = processSegmentCache(bodyHtml);
-            controller.enqueue(encoder.encode(bodyHtml + postContent));
+            const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, '\\u003c');
+            controller.enqueue(encoder.encode(
+                `<div id="app">${bodyHtml}</div><script id="hadars" type="application/json">${scriptContent}</script>` + postContent
+            ));
             controller.close();
         },
     });
@@ -685,7 +690,7 @@ export const dev = async (options: HadarsRuntimeOptions) => {
                 getFinalProps,
             } = (await import(importPath)) as HadarsEntryModule<any>;
 
-            const { ReactPage, unsuspend, status, headHtml } = await getReactResponse(request, {
+            const { App, appProps, clientProps, unsuspend, status, headHtml } = await getReactResponse(request, {
                 document: {
                     body: Component as React.FC<HadarsProps<object>>,
                     lang: 'en',
@@ -695,7 +700,7 @@ export const dev = async (options: HadarsRuntimeOptions) => {
                 },
             });
 
-            return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+            return buildSsrResponse(App, appProps, clientProps, headHtml, status, getPrecontentHtml, unsuspend);
         } catch (err: any) {
             console.error('[hadars] SSR render error:', err);
             const msg = (err?.stack ?? err?.message ?? String(err)).replace(/</g, '&lt;');
@@ -875,7 +880,7 @@ export const run = async (options: HadarsRuntimeOptions) => {
                 });
             }
 
-            const { ReactPage, unsuspend, status, headHtml } = await getReactResponse(request, {
+            const { App, appProps, clientProps, unsuspend, status, headHtml } = await getReactResponse(request, {
                 document: {
                     body: Component as React.FC<HadarsProps<object>>,
                     lang: 'en',
@@ -885,7 +890,7 @@ export const run = async (options: HadarsRuntimeOptions) => {
                 },
             });
 
-            return buildSsrResponse(ReactPage, headHtml, status, getPrecontentHtml, unsuspend);
+            return buildSsrResponse(App, appProps, clientProps, headHtml, status, getPrecontentHtml, unsuspend);
         } catch (err: any) {
             console.error('[hadars] SSR render error:', err);
             return new Response('Internal Server Error', { status: 500 });

package/src/slim-react/dispatcher.ts

@@ -0,0 +1,84 @@
+/**
+ * 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.
+ *
+ * In the Rspack SSR bundle `react` is aliased to `slim-react`, which does NOT
+ * export `__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE`.
+ * Accessing that property via a namespace import (`import * as`) always returns
+ * `undefined` safely — `import default from "react"` would crash via interop
+ * because Rspack compiles it as `require("react").default`, and slim-react has
+ * no `default` export, so `.default` itself is `undefined` and the subsequent
+ * property access throws.
+ *
+ * With the namespace import, `_internals` is `undefined` in the SSR bundle and
+ * the install/restore functions become no-ops, which is correct: the SSR bundle
+ * already routes all `React.*` hook calls to slim-react's own implementations.
+ */
+
+import { makeId, getContextValue } from "./renderContext";
+import {
+  useState, useReducer, useEffect, useLayoutEffect, useInsertionEffect,
+  useRef, useMemo, useCallback, useDebugValue, useImperativeHandle,
+  useSyncExternalStore, useTransition, useDeferredValue,
+  useOptimistic, useActionState, use,
+} from "./hooks";
+
+// Use namespace import so that when `react` is aliased to slim-react in the
+// Rspack SSR bundle, `ReactNS` is always an object (never undefined), and
+// accessing a missing property returns `undefined` rather than throwing.
+import * as ReactNS from "react";
+
+// React 19 exposes its shared internals under this key.
+const _internals: { H: object | null } | undefined =
+  (ReactNS 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/index.ts

@@ -75,7 +75,7 @@ export function useContext<T>(context: Context<T>): T {
 
 // ---- Rendering ----
 import { renderToStream, renderToString, renderToReadableStream } from "./render";
-export { renderToStream, renderToString, renderToReadableStream };
+export { renderToStream, renderToString, renderToReadableStream, type RenderOptions } from "./render";
 
 // ---- Suspense (as a JSX tag) ----
 import { SUSPENSE_TYPE } from "./types";