@tanstack/redact 0.0.21 → 0.1.1

package/dist/dom/reconcile.js

@@ -1,19 +1,27 @@
-// packages/redact/src/dom/reconcile.ts
+// src/dom/reconcile.ts
 import {
   FiberTag,
   createFiber,
   REACT_ELEMENT_TYPE,
   REACT_LEGACY_ELEMENT_TYPE,
   REACT_FRAGMENT_TYPE
-} from "../core";
+} from "../core/index.js";
 import {
   ReactSharedInternals,
   REACT_LAZY_TYPE,
   REACT_STRICT_MODE_TYPE,
-  REACT_PROFILER_TYPE
-} from "../react";
-import { createHostNode, setProp } from "./dom";
-import { makeDispatcher } from "./dispatcher";
+  REACT_PROFILER_TYPE,
+  REACT_VIEW_TRANSITION_TYPE
+} from "../react/index.js";
+import { createHostNode, setProp, syncInputValue, syncTextareaValue } from "./dom.js";
+import { HOOK_BAILOUT, renderWithHooks } from "./dispatcher.js";
+import { rememberRetainedEffect, setLayoutDisconnected } from "./retained-effects.js";
+import { componentStack } from "./error-info.js";
+import { resourceKind } from "../core/resource-hints.js";
+import { acquireResource } from "./resources.js";
+import { currentCommit, commitSynchronously, queueMutation, queueText, queueCommitEffects, setCommitCheckpointHook, onCommitRollback, onCommitFailure, checkpointCommit, rewindCommit, rememberChildList } from "./commit.js";
+import { markTransitionUpdate, deferTransition, cancelTransitions, deferTransitionLayout, deferTransitionPassive } from "./features/view-transition/index.js";
+import { createFragmentInstance, updateFragmentHost, refreshFragmentInstances } from "./features/fragment-refs/index.js";
 import {
   adoptHostDom,
   adoptTextDom,
@@ -22,19 +30,28 @@ import {
   clearHydrationCursor,
   findHostParent as findHydrationHost,
   abortHydration,
-  recoverHydration
-} from "./features/hydration";
+  recoverHydration,
+  isHydrationBailout
+} from "./features/hydration/index.js";
 var currentRoot = null;
+var preparedParent = null;
 var flushing = false;
 var isBatching = false;
 var pendingRoots = /* @__PURE__ */ new Set();
 var forceRerenderingFiber = null;
 function scheduleUpdate(fiber) {
-  if (fiber.um) return;
+  if (fiber.um || fiber.pd) return;
+  fiber.dy = true;
+  if (ReactSharedInternals.F === fiber) return;
   const root = findRoot(fiber);
   if (!root) return;
+  while (fiber.su) {
+    fiber = fiber.su;
+    fiber.ms.u = true;
+    fiber.dy = true;
+  }
+  markTransitionUpdate(root);
   root.p.add(fiber);
-  fiber.dy = true;
   pendingRoots.add(root);
   if (isBatching) return;
   if (!root.s) {
@@ -43,14 +60,19 @@ function scheduleUpdate(fiber) {
   }
 }
 function flushSyncWork(fn) {
+  cancelTransitions();
+  const transition = ReactSharedInternals.T;
+  ReactSharedInternals.T = null;
   const wasBatching = isBatching;
   isBatching = true;
   try {
     fn();
+    isBatching = wasBatching;
+    flushPending();
   } finally {
     isBatching = wasBatching;
+    ReactSharedInternals.T = transition;
   }
-  flushPending();
 }
 function batchedUpdates(fn) {
   const wasBatching = isBatching;
@@ -69,7 +91,7 @@ function flushPending() {
     let guard = 0;
     while (pendingRoots.size > 0) {
       if (++guard > 50) {
-        if (true) {
+        if (process.env.NODE_ENV !== "production") {
           throw new Error("flushPending exceeded 50 iterations \u2014 suspected infinite update loop.");
         }
         throw new Error();
@@ -78,47 +100,92 @@ function flushPending() {
       pendingRoots.clear();
       for (const root of roots) {
         root.s = false;
-        const pending = [...root.p];
-        root.p.clear();
-        pending.sort((a, b) => fiberDepth(a) - fiberDepth(b));
-        for (const fiber of pending) {
+        const render = () => flushRoot(root);
+        if (!deferTransition(root, render, flushPending)) {
           try {
-            rerenderFiber(fiber, root);
+            commitSynchronously(render);
           } catch (error) {
-            if (!recoverHydration(root, error)) throw error;
-            break;
+            if (!recoverRootError(error)) throw error;
           }
         }
-        runEffects(root);
       }
     }
   } finally {
     flushing = false;
   }
 }
+function flushRoot(root) {
+  if (root.er) {
+    flushRootErrors(root);
+    return;
+  }
+  const render = root.u;
+  root.u = void 0;
+  if (render) render();
+  const pending = [...root.p];
+  root.p.clear();
+  pending.sort((a, b) => fiberDepth(a) - fiberDepth(b));
+  for (const fiber of pending) {
+    if (!fiber.dy || fiber.um || fiber.pd) continue;
+    const boundary = root.eb && findErrorBoundary(fiber);
+    const checkpoint = boundary || root.sp && findSuspenseBoundary(fiber) ? checkpointCommit(fiber) : -1;
+    try {
+      rerenderFiber(fiber, root);
+    } catch (error) {
+      if (error instanceof RenderSuspenseCapture) {
+        rewindCommit(checkpoint);
+        error.boundary.ms.u = true;
+        scheduleUpdate(error.boundary);
+        continue;
+      }
+      if (error instanceof RenderErrorCapture) {
+        if (error.boundary.tag === FiberTag.Root) throw error;
+        rewindCommit(checkpoint);
+        captureError(error);
+        continue;
+      }
+      if (!recoverHydration(root, error)) throw error;
+      break;
+    }
+  }
+  runEffects(root);
+}
+function scheduleRootRender(root, render) {
+  markTransitionUpdate(root);
+  root.u = render;
+  pendingRoots.add(root);
+  if (isBatching) return;
+  flushPending();
+}
 function discardPendingWork(root) {
+  root.u = void 0;
   root.p.clear();
   root.s = false;
   pendingRoots.delete(root);
 }
-function fiberDepth(fiber) {
-  let d = 0;
-  let p = fiber.parent;
-  while (p) {
-    d++;
-    p = p.parent;
+function discardPendingEffects(root) {
+  for (const queue of [pendingEffects, pendingInsertionEffects, pendingCommits]) {
+    for (let index = queue.length - 1; index >= 0; index--) {
+      if (findRoot(queue[index][0]) === root) removePendingEffect(queue, index);
+    }
   }
-  return d;
+  for (const fiber of stagedCommits.keys()) {
+    if (findRoot(fiber) === root) removeStagedCommits(fiber);
+  }
+}
+function fiberDepth(fiber) {
+  return fiber.depth ??= fiber.parent ? fiberDepth(fiber.parent) + 1 : 0;
 }
 function findRoot(fiber) {
   let f = fiber;
   while (f) {
-    if (f.root) return f.root;
+    if (f.root) return fiber.root = f.root;
     f = f.parent;
   }
   return null;
 }
 function renderRoot(root, children) {
+  if (!currentCommit) return commitSynchronously(() => renderRoot(root, children));
   const rootFiber = root.r;
   rootFiber.pp = { children };
   currentRoot = root;
@@ -133,7 +200,7 @@ function renderRoot(root, children) {
 }
 function rerenderFiber(fiber, root) {
   if (!fiber.dy) return;
-  if (fiber.um) return;
+  if (fiber.um || fiber.pd) return;
   fiber.dy = false;
   currentRoot = root;
   const resumeHydration = fiber.ms && fiber.ms.p === true;
@@ -145,7 +212,8 @@ function rerenderFiber(fiber, root) {
   const prevForcing = forceRerenderingFiber;
   forceRerenderingFiber = fiber;
   try {
-    renderFiber(fiber, getHostParent(fiber), getAnchor(fiber));
+    const domParent = getHostParent(fiber);
+    renderFiber(fiber, domParent, getAnchor(fiber, domParent));
   } finally {
     forceRerenderingFiber = prevForcing;
     if (resumeHydration) {
@@ -178,10 +246,6 @@ function pushChildren(node, out) {
     for (let i = 0; i < node.length; i++) pushChildren(node[i], out);
     return;
   }
-  if (isIterable(node)) {
-    for (const item of node) pushChildren(item, out);
-    return;
-  }
   if (typeof node === "object") {
     const t = node.$$typeof;
     if (ACCEPTED_ELEMENT_MARKERS.has(t)) {
@@ -195,6 +259,9 @@ function pushChildren(node, out) {
       return;
     }
   }
+  if (isIterable(node)) {
+    for (const item of node) pushChildren(item, out);
+  }
 }
 function isIterable(obj) {
   return obj != null && typeof obj[Symbol.iterator] == "function";
@@ -220,7 +287,7 @@ function fiberFromChild(child, parent) {
   const marker = type && type.$$typeof;
   if (typeof type === "string") tag = FiberTag.Host;
   else if (type === REACT_FRAGMENT_TYPE) tag = FiberTag.Fragment;
-  else if (type === REACT_STRICT_MODE_TYPE || type === REACT_PROFILER_TYPE) tag = FiberTag.Fragment;
+  else if (type === REACT_STRICT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_VIEW_TRANSITION_TYPE) tag = FiberTag.Fragment;
   else {
     let matched = null;
     for (const m of TYPE_MATCHERS) {
@@ -244,18 +311,18 @@ function reconcileChildren(parent, newChildren, domParent, anchor) {
     let ok = true;
     for (let i = 0; i < newChildren.length; i++) {
       const child = newChildren[i];
-      if (child == null || !f || f.key != null) {
+      if (child == null || !f) {
         ok = false;
         break;
       }
       if (typeof child === "string") {
-        if (f.tag !== FiberTag.Text) {
+        if (f.tag !== FiberTag.Text || f.key != null) {
           ok = false;
           break;
         }
         f.pp = child;
       } else {
-        if (child.key != null) {
+        if (!sameKey(f.key, child.key)) {
           ok = false;
           break;
         }
@@ -269,21 +336,28 @@ function reconcileChildren(parent, newChildren, domParent, anchor) {
       f = f.sibling;
     }
     if (ok && f === null) {
-      for (let r = parent.child; r; r = r.sibling) {
-        let a = anchor;
-        for (let s = r.sibling; s; s = s.sibling) {
-          const d = firstDomNode(s);
-          if (d && d.parentNode === domParent) {
-            a = d;
-            break;
-          }
-        }
-        renderFiber(r, domParent, a);
-      }
+      renderChildChain(parent, domParent, anchor, false);
       return;
     }
   }
+  if (!parent.child) {
+    rememberChildList(parent);
+    let previous = null;
+    for (const child of newChildren) {
+      if (child == null) continue;
+      const fiber = fiberFromChild(child, parent);
+      if (previous) previous.sibling = fiber;
+      else parent.child = fiber;
+      previous = fiber;
+    }
+    renderChildChain(parent, domParent, anchor, true);
+    if (previous && !currentRoot?.h && domParent.nodeName !== "HEAD") {
+      placeChildrenInOrder(parent, domParent, anchor);
+    }
+    return;
+  }
   const existing = collectChildren(parent);
+  rememberChildList(parent, existing);
   const keyed = /* @__PURE__ */ new Map();
   for (const f of existing) {
     if (f.key != null) keyed.set("k" + f.key, f);
@@ -312,7 +386,7 @@ function reconcileChildren(parent, newChildren, domParent, anchor) {
     if (!match) {
       while (existingIdx < existing.length) {
         const cand = existing[existingIdx];
-        if (claimed.has(cand) || cand.key != null) {
+        if (cand.key != null) {
           existingIdx++;
           continue;
         }
@@ -352,32 +426,14 @@ function reconcileChildren(parent, newChildren, domParent, anchor) {
     prevNewFiber = fiber;
   }
   const hydrating = !!currentRoot?.h;
-  for (let f = parent.child; f; f = f.sibling) {
-    let a = anchor;
-    if (!hydrating) {
-      for (let s = f.sibling; s; s = s.sibling) {
-        const d = firstDomNode(s);
-        if (d && d.parentNode === domParent) {
-          a = d;
-          break;
-        }
-      }
-    }
-    renderFiber(f, domParent, a);
-  }
+  if (prevNewFiber) renderChildChain(parent, domParent, anchor, hydrating || existing.length === 0);
   if (!prevNewFiber) parent.child = null;
   else prevNewFiber.sibling = null;
   const parentIsHeadHost = parent.tag === FiberTag.Host && typeof parent.type === "string" && parent.type.toLowerCase() === "head";
   if (!parentIsHeadHost) {
     for (const f of existing) {
       if (!claimed.has(f)) {
-        unmountFiber(f);
-        structurallyChanged = true;
-      }
-    }
-    for (const f of keyed.values()) {
-      if (!claimed.has(f)) {
-        unmountFiber(f);
+        unmountFiber(f, domParent);
         structurallyChanged = true;
       }
     }
@@ -387,19 +443,43 @@ function reconcileChildren(parent, newChildren, domParent, anchor) {
     placeChildrenInOrder(parent, domParent, anchor);
   }
 }
+function renderChildChain(parent, domParent, anchor, skipAnchors) {
+  for (let f = parent.child; f; f = f.sibling) {
+    let nextAnchor = anchor;
+    if (!skipAnchors) {
+      for (let sibling = f.sibling; sibling; sibling = sibling.sibling) {
+        const dom = firstDomNode(sibling, domParent);
+        if (dom) {
+          nextAnchor = dom;
+          break;
+        }
+      }
+    }
+    renderFiber(f, domParent, nextAnchor);
+  }
+}
 function placeChildrenInOrder(parent, domParent, anchor) {
-  const doms = [];
   let c = parent.child;
+  if ((!currentCommit || domParent === preparedParent) && c && !c.sibling && (c.tag === FiberTag.Host || c.tag === FiberTag.Text) && c.dom?.parentNode === domParent && c.dom.nextSibling === anchor) return;
+  const doms = [];
   while (c) {
     collectHostDoms(c, doms);
     c = c.sibling;
   }
+  if (currentCommit && domParent !== preparedParent) {
+    if (doms.length) queuePlacement(doms, domParent, anchor);
+  } else placeDomsInOrder(doms, domParent, anchor);
+}
+function queuePlacement(doms, parent, anchor) {
+  queueMutation(() => placeDomsInOrder(doms, parent, anchor));
+}
+function placeDomsInOrder(doms, domParent, anchor) {
   if (doms.length > 0) {
     let current = doms[0];
     let inOrder = current.parentNode === domParent;
     for (let i = 1; inOrder && i < doms.length; i++) {
       current = current.nextSibling;
-      while (current && !doms.includes(current)) {
+      while (current && current !== doms[i] && !doms.includes(current)) {
         current = current.nextSibling;
       }
       if (current !== doms[i]) inOrder = false;
@@ -432,6 +512,7 @@ function collectHostDoms(fiber, out) {
     collectHostDoms(c, out);
     c = c.sibling;
   }
+  if (fiber.tag === FiberTag.Suspense && fiber.ms?.f) collectHostDoms(fiber.ms.f, out);
 }
 function collectChildren(parent) {
   const out = [];
@@ -474,11 +555,25 @@ function getForceRerenderingFiber() {
 }
 registerRenderer(FiberTag.Text, renderText);
 registerRenderer(FiberTag.Host, renderHost);
+registerRenderer(FiberTag.Resource, renderHost);
 registerRenderer(FiberTag.Function, renderFunction);
 registerRenderer(FiberTag.Fragment, renderFragment);
 function renderFiber(fiber, domParent, anchor) {
+  if (fiber.tag !== FiberTag.Memo) fiber.dy = false;
+  fiber.root ||= currentRoot || findRoot(fiber);
+  if (fiber.root?.sp && fiber.parent?.ld && fiber.mp === null) setLayoutDisconnected(fiber, true);
+  if (fiber.root?.a) CAPABILITIES.prepareActivityFiber(fiber);
   const fn = RENDERERS[fiber.tag];
-  if (fn) fn(fiber, domParent, anchor);
+  try {
+    if (fn) fn(fiber, domParent, anchor);
+  } catch (error) {
+    removeStagedCommits(fiber);
+    if (currentRoot?.h || error instanceof RenderErrorCapture || error instanceof RenderSuspenseCapture || isHydrationBailout(error)) throw error;
+    if (isThenable(error)) handleSuspended(fiber, error);
+    else handleErrorInRender(fiber, error);
+  }
+  if (fiber.root?.a) CAPABILITIES.syncActivity(fiber);
+  if (lastStagedFiber === fiber) flushFiberCommits(fiber);
 }
 function renderText(fiber, domParent, anchor) {
   const text = fiber.pp;
@@ -489,25 +584,55 @@ function renderText(fiber, domParent, anchor) {
       fiber.dom = document.createTextNode(text);
       insertInto(domParent, fiber.dom, anchor);
     }
+    updateFragmentHost(fiber, true);
   } else {
-    ;
-    fiber.dom.data = text;
+    queueText(fiber.dom, text);
   }
   fiber.mp = text;
 }
 function renderHost(fiber, domParent, anchor) {
+  const hadDom = !!fiber.dom;
   const props = fiber.pp ?? {};
   const prev = fiber.mp ?? {};
   const type = fiber.type;
   const isSvg = type === "svg" || domParent.namespaceURI === "http://www.w3.org/2000/svg";
+  const isResource = fiber.tag === FiberTag.Resource;
+  const canAcquire = !isSvg && (isResource || !fiber.mp) && resourceKind(type, props);
+  if (isResource || canAcquire) {
+    fiber.tag = FiberTag.Resource;
+    if (canAcquire) {
+      let container = domParent.nodeType === 9 ? domParent : domParent.ownerDocument;
+      if (type !== "script") {
+        container = fiber.root?.c || domParent;
+        for (let parent = fiber.parent; parent; parent = parent.parent) {
+          if (parent.tag === FiberTag.Portal) {
+            container = parent.pp.container;
+            break;
+          }
+        }
+      }
+      queueMutation(() => {
+        const resource = acquireResource(type, props, container);
+        fiber.sn ||= resource;
+      });
+    }
+    if (fiber.mp) syncRefIfChanged(fiber, fiber.sn);
+    else attachRef(fiber, null);
+    fiber.mp = props;
+    return;
+  }
   const isSelect = type === "select";
+  const isInput = !isSvg && type === "input";
+  const isTextarea = !isSvg && type === "textarea";
+  const deferValue = isSelect || isInput || isTextarea;
+  let hydrated = false;
   const deferredSelectValue = isSelect && (props.value !== void 0 || props.defaultValue !== void 0) ? props.value !== void 0 ? props.value : props.defaultValue : void 0;
   if (!fiber.dom) {
-    const hydrated = currentRoot?.h ? adoptHostDom(fiber, fiber.parent) : false;
+    hydrated = currentRoot?.h ? adoptHostDom(fiber, fiber.parent) : false;
     if (!hydrated) {
       fiber.dom = createHostNode(type, isSvg);
       for (const k in props) {
-        if (isSelect && (k === "value" || k === "defaultValue")) continue;
+        if (deferValue && (k === "value" || k === "defaultValue") || isInput && (k === "checked" || k === "defaultChecked" || k === "name")) continue;
         if (isEventProp(k)) continue;
         setProp(fiber.dom, k, props[k], void 0, isSvg);
       }
@@ -515,96 +640,115 @@ function renderHost(fiber, domParent, anchor) {
         if (!isEventProp(k)) continue;
         setProp(fiber.dom, k, props[k], void 0, isSvg);
       }
+      if (isInput) {
+        syncInputValue(fiber.dom, props);
+        setProp(fiber.dom, "name", props.name, void 0, false);
+      }
+      if (isTextarea) syncTextareaValue(fiber.dom, props, true);
       insertInto(domParent, fiber.dom, anchor);
     }
+    updateFragmentHost(fiber, true);
     attachRef(fiber, fiber.dom);
-  } else if (prev !== props) {
-    const el = fiber.dom;
-    let deferredEvents = null;
-    for (const k in props) {
-      if (isSelect && (k === "value" || k === "defaultValue")) continue;
-      if (isEventProp(k)) {
-        if (prev[k] !== props[k]) {
-          deferredEvents ||= [];
-          deferredEvents.push(k);
-        }
-        continue;
-      }
-      if (prev[k] !== props[k]) setProp(el, k, props[k], prev[k], isSvg);
-    }
-    for (const k in prev) {
-      if (!(k in props)) setProp(el, k, void 0, prev[k], isSvg);
-    }
-    if (deferredEvents) {
-      for (let i = 0; i < deferredEvents.length; i++) {
-        const k = deferredEvents[i];
-        setProp(el, k, props[k], prev[k], isSvg);
-      }
-    }
-    syncRefIfChanged(fiber, fiber.dom);
+  } else if (prev !== props && (isInput || isTextarea || hostNeedsUpdate(props, prev))) {
+    queueHostProps(fiber.dom, props, prev, isSvg, isInput, isTextarea, deferValue);
   }
-  reconcileChildren(fiber, childrenToArray(props.children), fiber.dom, null);
+  if (hadDom) syncRefIfChanged(fiber, fiber.dom);
+  if (!hadDom && !hydrated) {
+    const previous = preparedParent;
+    preparedParent = fiber.dom;
+    try {
+      reconcileChildren(fiber, isTextarea ? [] : childrenToArray(props.children), fiber.dom, null);
+    } finally {
+      preparedParent = previous;
+    }
+  } else reconcileChildren(fiber, isTextarea ? [] : childrenToArray(props.children), fiber.dom, null);
   if (currentRoot?.h) {
     const parentTag = fiber.type.toLowerCase();
-    const hasOpaqueHydrationChildren = props.dangerouslySetInnerHTML != null || parentTag === "textarea" && (props.value != null || props.defaultValue != null);
+    const hasOpaqueHydrationChildren = props.dangerouslySetInnerHTML != null || isTextarea;
     if (parentTag !== "head" && parentTag !== "html" && parentTag !== "body" && !hasOpaqueHydrationChildren) {
       const cursor = getHydrationCursor(fiber);
       if (cursor) {
         if (cursor.has()) {
           const error = new Error(
-            true ? `Hydration mismatch: server rendered extra nodes inside <${parentTag}>.` : "Hydration mismatch."
+            process.env.NODE_ENV !== "production" ? `Hydration mismatch: server rendered extra nodes inside <${parentTag}>.` : "Hydration mismatch."
           );
-          if (currentRoot.re) currentRoot.re(error);
+          if (currentRoot.re) currentRoot.re(error, { componentStack: null });
           abortHydration(error, fiber);
         }
       }
     }
   }
-  if (isSelect && deferredSelectValue !== void 0) {
-    const select = fiber.dom;
-    if (Array.isArray(deferredSelectValue)) {
-      const asStrings = deferredSelectValue.map((v) => "" + v);
-      for (const opt of Array.from(select.options)) {
-        opt.selected = asStrings.includes(opt.value);
+  if (isSelect && !hydrated && deferredSelectValue !== void 0) {
+    queueSelectValue(fiber.dom, deferredSelectValue);
+  }
+  fiber.mp = props;
+}
+function queueSelectValue(select, value) {
+  queueMutation(() => {
+    if (Array.isArray(value)) {
+      const selected = new Set(value.map((v) => "" + v));
+      const options = select.options;
+      for (let i = 0; i < options.length; i++) {
+        const opt = options[i];
+        opt.selected = selected.has(opt.value);
       }
     } else {
-      select.value = "" + deferredSelectValue;
+      select.value = "" + value;
     }
+  });
+}
+function hostNeedsUpdate(props, previous) {
+  for (const key in props) {
+    if (props[key] !== previous[key] && key !== "children" && key !== "ref" && key !== "key") return true;
   }
-  fiber.mp = props;
+  for (const key in previous) {
+    if (key !== "children" && key !== "ref" && key !== "key" && !(key in props)) return true;
+  }
+  return false;
+}
+function queueHostProps(el, props, prev, isSvg, isInput, isTextarea, deferValue) {
+  queueMutation(() => {
+    if (isInput) setProp(el, "name", "", void 0, false);
+    let events;
+    for (const key in props) {
+      const next = props[key], previous = prev[key];
+      if (next === previous || key === "children" || key === "ref" || key === "key" || deferValue && (key === "value" || key === "defaultValue") || isInput && (key === "checked" || key === "defaultChecked" || key === "name")) continue;
+      if (isEventProp(key)) {
+        (events ||= []).push(key);
+      } else setProp(el, key, next, previous, isSvg);
+    }
+    for (const key in prev) {
+      if (key === "children" || key === "ref" || key === "key" || (isInput || isTextarea) && (key === "value" || key === "defaultValue") || isInput && (key === "checked" || key === "defaultChecked" || key === "name")) continue;
+      if (!(key in props)) setProp(el, key, void 0, prev[key], isSvg);
+    }
+    if (events) for (const key of events) setProp(el, key, props[key], prev[key], isSvg);
+    if (isInput) {
+      syncInputValue(el, props, prev);
+      setProp(el, "name", props.name, prev.name, false);
+    } else if (isTextarea) syncTextareaValue(el, props);
+  });
 }
 function renderFunction(fiber, domParent, anchor) {
-  const prevDispatcher = ReactSharedInternals.H;
-  const prevFiber = ReactSharedInternals.F;
-  const prevHook = ReactSharedInternals.K;
-  const prevIndex = ReactSharedInternals.I;
-  ReactSharedInternals.H = makeDispatcher();
-  ReactSharedInternals.F = fiber;
-  ReactSharedInternals.K = null;
-  ReactSharedInternals.I = 0;
+  const canBail = fiber === forceRerenderingFiber && fiber.pp === fiber.mp;
+  fiber.cx?.clear();
   let rendered;
   let deferredForHydration = false;
   try {
-    rendered = fiber.type(fiber.pp ?? {});
+    rendered = renderWithHooks(fiber, fiber.type, fiber.pp ?? {}, void 0, canBail);
   } catch (e) {
     if (isThenable(e)) {
       if (deferHydration(fiber, e)) {
         deferredForHydration = true;
       } else {
-        CAPABILITIES.handleSuspended(fiber, e);
-        rendered = null;
+        handleSuspended(fiber, e);
+        return;
       }
     } else {
       handleErrorInRender(fiber, e);
       return;
     }
-  } finally {
-    ReactSharedInternals.H = prevDispatcher;
-    ReactSharedInternals.F = prevFiber;
-    ReactSharedInternals.K = prevHook;
-    ReactSharedInternals.I = prevIndex;
   }
-  if (deferredForHydration) return;
+  if (deferredForHydration || rendered === HOOK_BAILOUT) return;
   reconcileChildren(fiber, childrenToArray(rendered), domParent, anchor);
   fiber.mp = fiber.pp;
 }
@@ -633,6 +777,28 @@ function deferHydration(fiber, thenable) {
 function renderFragment(fiber, domParent, anchor) {
   const props = fiber.pp ?? {};
   reconcileChildren(fiber, childrenToArray(props.children), domParent, anchor);
+  if (fiber.type === REACT_FRAGMENT_TYPE) {
+    if (fiber.ref && !fiber.sn) fiber.sn = createFragmentInstance(fiber);
+    const previous = fiber.ms?.ref;
+    if (previous !== fiber.ref) {
+      if (fiber.cu) {
+        const cleanups = fiber.cu;
+        queueMutation(() => {
+          for (const cleanup of cleanups) {
+            try {
+              cleanup();
+            } catch (error) {
+              handleCommitError(fiber, error);
+            }
+          }
+        });
+        fiber.cu = null;
+      }
+      detachRef(previous, fiber);
+      fiber.ms = { ...fiber.ms, ref: fiber.ref };
+      if (fiber.sn) attachRef(fiber, fiber.sn);
+    }
+  }
   fiber.mp = props;
 }
 function defaultHandleSuspended(fiber, thenable) {
@@ -643,83 +809,244 @@ function defaultHandleSuspended(fiber, thenable) {
 }
 var CAPABILITIES = {
   handleSuspended: defaultHandleSuspended,
-  readContext: defaultReadContext
+  readContext: defaultReadContext,
+  isActivityHidden: () => false,
+  activityIsDisconnected: () => false,
+  prepareActivityFiber: () => {
+  },
+  syncActivity: () => {
+  }
 };
+function isActivityHidden(fiber) {
+  return !!(fiber.root ?? currentRoot ?? findRoot(fiber))?.a && CAPABILITIES.isActivityHidden(fiber);
+}
+function activityIsDisconnected(fiber) {
+  return !!fiber.root?.a && CAPABILITIES.activityIsDisconnected(fiber);
+}
+function layoutIsDisconnected(fiber) {
+  return !!fiber.ld || activityIsDisconnected(fiber);
+}
+function rememberActivityEffect(fiber, hook, effect) {
+  if (fiber.root?.a || fiber.root?.sp && effect.t === 1 && !effect.s) rememberRetainedEffect(fiber, hook, effect);
+}
 function installCapability(name, fn) {
   CAPABILITIES[name] = fn;
 }
 function handleSuspended(fiber, thenable) {
+  if (isActivityHidden(fiber) && !findSuspenseBoundary(fiber)) {
+    defaultHandleSuspended(fiber, thenable);
+    return;
+  }
   CAPABILITIES.handleSuspended(fiber, thenable);
 }
+var RenderSuspenseCapture = class {
+  constructor(boundary) {
+    this.boundary = boundary;
+  }
+  boundary;
+};
+function findSuspenseBoundary(fiber) {
+  let child = fiber;
+  for (let parent = fiber.parent; parent; parent = parent.parent) {
+    if (parent.tag === FiberTag.Suspense && parent.ms?.f !== child) return parent;
+    if (parent.tag === FiberTag.Activity && parent.pp?.mode === "hidden") return null;
+    child = parent;
+  }
+  return null;
+}
+var RenderErrorCapture = class {
+  constructor(boundary, error, source = boundary) {
+    this.boundary = boundary;
+    this.error = error;
+    this.stack = componentStack(source);
+  }
+  boundary;
+  error;
+  stack;
+};
+function captureError(capture) {
+  const fiber = capture.boundary;
+  fiber.ms = { ...fiber.ms, error: capture };
+  scheduleUpdate(fiber);
+}
+function findErrorBoundary(fiber) {
+  for (let parent = fiber.parent; parent; parent = parent.parent) {
+    if (parent.um || parent.pd) continue;
+    const instance = parent.sn;
+    if (instance?._fiber === parent && (parent.ms?.b?.getDerivedStateFromError || instance.componentDidCatch)) return parent;
+  }
+  return null;
+}
+function captureRootError(root, stack, error) {
+  const errors = root.er ||= [];
+  if (!errors.length) root.u = void 0;
+  errors.push({ error, stack });
+  scheduleUpdate(root.r);
+}
+function flushRootErrors(root) {
+  const errors = root.er;
+  root.er = void 0;
+  if (root.r.mp === null) queueMutation(() => {
+    root.c.textContent = "";
+  });
+  renderRoot(root, null);
+  queueCommitEffects(() => {
+    for (const captured of errors) {
+      try {
+        if (root.ue) root.ue(captured.error, { componentStack: captured.stack });
+        else if (typeof reportError === "function") reportError(captured.error);
+        else queueMicrotask(() => {
+          throw captured.error;
+        });
+      } catch (error) {
+        setTimeout(() => {
+          throw error;
+        });
+      }
+    }
+  });
+  if (root.u) pendingRoots.add(root);
+}
+function recoverRootError(error, abort) {
+  if (!(error instanceof RenderErrorCapture) || error.boundary.tag !== FiberTag.Root) return false;
+  const root = error.boundary.root;
+  abort?.();
+  discardPendingWork(root);
+  discardPendingEffects(root);
+  captureRootError(root, error.stack, error.error);
+  return true;
+}
+function handleCommitError(fiber, error) {
+  const boundary = findErrorBoundary(fiber);
+  if (boundary) {
+    captureError(new RenderErrorCapture(boundary, error, fiber));
+    return;
+  }
+  const root = findRoot(fiber);
+  if (root) captureRootError(root, componentStack(fiber), error);
+  else queueMicrotask(() => {
+    throw error;
+  });
+}
 function handleErrorInRender(fiber, err) {
+  if (err instanceof RenderErrorCapture) throw err;
+  removeStagedCommits(fiber);
+  for (const queue of [pendingEffects, pendingInsertionEffects, pendingCommits]) {
+    for (let index = queue.length - 1; index >= 0; index--) {
+      if (queue[index][0] === fiber) removePendingEffect(queue, index);
+    }
+  }
   if (currentRoot?.h) {
     abortHydration(err, fiber);
   }
-  let f = fiber.parent;
-  while (f) {
-    if (f.tag === FiberTag.Class) {
-      const Ctor = f.type;
-      const instance = f.sn;
-      if (Ctor.getDerivedStateFromError) {
-        const update = Ctor.getDerivedStateFromError(err);
-        instance.state = { ...instance.state, ...update };
-      }
-      if (instance.componentDidCatch) {
-        try {
-          instance.componentDidCatch(err, { componentStack: "" });
-        } catch {
-        }
-      }
-      scheduleUpdate(f);
-      return;
-    }
-    f = f.parent;
+  const boundary = findErrorBoundary(fiber);
+  if (boundary) {
+    const capture = new RenderErrorCapture(boundary, err, fiber);
+    if (currentCommit) throw capture;
+    captureError(capture);
+    return;
   }
-  if (currentRoot?.ue) currentRoot.ue(err);
+  const root = currentRoot ?? findRoot(fiber);
+  if (root && currentCommit && (flushing || root.ue)) throw new RenderErrorCapture(root.r, err, fiber);
+  if (root?.ue) root.ue(err, { componentStack: componentStack(fiber) });
   else throw err;
 }
 function isThenable(x) {
   return x != null && typeof x.then == "function";
 }
-function unmountFiber(fiber, removeDom = true) {
+function unmountFiber(fiber, domParent, remove = true) {
+  if (fiber.um) return;
+  if (currentCommit) return queueUnmount(fiber, domParent, remove);
+  removeStagedCommits(fiber);
+  if (fiber.type === REACT_FRAGMENT_TYPE && fiber.sn) {
+    if (fiber.cu) {
+      for (const cleanup of fiber.cu) {
+        try {
+          cleanup();
+        } catch (error) {
+          handleCommitError(fiber, error);
+        }
+      }
+      fiber.cu = null;
+    }
+    detachRef(fiber.cr ?? fiber.ref, fiber);
+  }
   fiber.um = true;
-  let c = fiber.child;
-  while (c) {
-    const next = c.sibling;
-    unmountFiber(c, removeDom || fiber.tag === FiberTag.Portal);
-    c = next;
+  if (fiber.tag === FiberTag.Host || fiber.tag === FiberTag.Text) updateFragmentHost(fiber, false);
+  if (fiber.type === REACT_FRAGMENT_TYPE && fiber.sn) fiber.sn.dispose();
+  if (fiber.tag === FiberTag.Suspense && fiber.ms?.f) {
+    unmountFiber(fiber.ms.f, domParent, remove);
+    fiber.ms.f = null;
   }
-  fiber.child = null;
   if (fiber.cu) {
-    for (const cleanup of fiber.cu) {
+    const cleanups = fiber.cu;
+    fiber.cu = null;
+    for (const cleanup of cleanups) {
       try {
         cleanup();
       } catch (e) {
-        if (currentRoot?.re) currentRoot.re(e);
+        handleCommitError(fiber, e);
       }
     }
-    fiber.cu = null;
   }
-  if (fiber.tag === FiberTag.Class && fiber.sn) {
+  if (fiber.sn?._fiber === fiber) {
+    const committed = fiber.ms?.c;
+    if (committed) {
+      fiber.sn.props = committed.props;
+      fiber.sn.state = committed.state;
+    }
+    if (fiber.sn.componentWillUnmount && !layoutIsDisconnected(fiber)) {
+      try {
+        fiber.sn.componentWillUnmount();
+      } catch (e) {
+        handleCommitError(fiber, e);
+      }
+    }
     fiber.sn._fiber = null;
     fiber.sn._enqueueUpdate = null;
     fiber.sn._forceUpdate = null;
   }
-  if (fiber.ref) detachRef(fiber.ref);
-  if (removeDom) {
-    fiber.dom?.parentNode?.removeChild(fiber.dom);
+  if (fiber.cr ?? fiber.ref) detachRef(fiber.cr ?? fiber.ref, fiber);
+  let c = fiber.child;
+  while (c) {
+    const next = c.sibling;
+    unmountFiber(c, fiber.tag === FiberTag.Host ? fiber.dom : domParent, fiber.tag === FiberTag.Portal || remove && fiber.tag !== FiberTag.Host);
+    c = next;
+  }
+  fiber.child = null;
+  if (remove && (fiber.tag === FiberTag.Host || fiber.tag === FiberTag.Text) && fiber.dom?.parentNode) {
+    fiber.dom.parentNode.removeChild(fiber.dom);
   }
 }
-function unmountAllChildren(parent) {
+function queueUnmount(fiber, domParent, remove) {
+  if (fiber.pd) return;
+  const deleted = [];
+  markPendingDeletion(fiber, deleted);
+  const restore = () => {
+    for (const child of deleted) child.pd = false;
+  };
+  onCommitRollback(restore);
+  onCommitFailure(restore);
+  queueMutation(() => unmountFiber(fiber, domParent, remove));
+}
+function markPendingDeletion(fiber, deleted) {
+  if (fiber.pd) return;
+  fiber.pd = true;
+  deleted.push(fiber);
+  for (let child = fiber.child; child; child = child.sibling) markPendingDeletion(child, deleted);
+  if (fiber.tag === FiberTag.Suspense && fiber.ms?.f) markPendingDeletion(fiber.ms.f, deleted);
+}
+function unmountAllChildren(parent, domParent) {
   let c = parent.child;
   while (c) {
     const next = c.sibling;
-    unmountFiber(c);
+    unmountFiber(c, domParent);
     c = next;
   }
   parent.child = null;
 }
 function insertInto(parent, node, anchor) {
+  if (currentCommit && parent !== preparedParent) return queueInsertion(parent, node, anchor);
   const projectedHeadParent = getDocumentHeadInsertionParent(parent, node);
   if (projectedHeadParent) {
     projectedHeadParent.appendChild(node);
@@ -731,6 +1058,9 @@ function insertInto(parent, node, anchor) {
     parent.appendChild(node);
   }
 }
+function queueInsertion(parent, node, anchor) {
+  queueMutation(() => insertInto(parent, node, anchor));
+}
 var DOCUMENT_HEAD_TAGS = /* @__PURE__ */ new Set(["base", "link", "meta", "script", "style", "title"]);
 function getDocumentHeadInsertionParent(parent, node) {
   if (parent.nodeType !== 9 || node.nodeType !== 1) return null;
@@ -750,37 +1080,36 @@ function getHostParent(fiber) {
     }
     p = p.parent;
   }
-  if (true) {
+  if (process.env.NODE_ENV !== "production") {
     throw new Error("No host parent found.");
   }
   throw new Error();
 }
-function getAnchor(fiber) {
-  let f = fiber.sibling;
-  while (f) {
-    const d = firstDomNode(f);
-    if (d) return d;
-    f = f.sibling;
-  }
-  let p = fiber.parent;
-  while (p && p.tag !== FiberTag.Host && p.tag !== FiberTag.Root && p.tag !== FiberTag.Portal) {
-    if (p.sibling) {
-      const d = firstDomNode(p.sibling);
+function getAnchor(fiber, domParent) {
+  let p = fiber;
+  while (p) {
+    let sibling = p.sibling;
+    while (sibling) {
+      const d = firstDomNode(sibling, domParent);
       if (d) return d;
+      sibling = sibling.sibling;
     }
     p = p.parent;
+    if (p?.tag === FiberTag.Host || p?.tag === FiberTag.Root || p?.tag === FiberTag.Portal) break;
   }
   return null;
 }
-function firstDomNode(fiber) {
-  if (fiber.tag === FiberTag.Host || fiber.tag === FiberTag.Text) return fiber.dom;
+function firstDomNode(fiber, domParent) {
+  if (fiber.tag === FiberTag.Host || fiber.tag === FiberTag.Text) {
+    return fiber.dom?.parentNode === domParent ? fiber.dom : null;
+  }
   let c = fiber.child;
   while (c) {
-    const d = firstDomNode(c);
+    const d = firstDomNode(c, domParent);
     if (d) return d;
     c = c.sibling;
   }
-  return null;
+  return fiber.tag === FiberTag.Suspense && fiber.ms?.f ? firstDomNode(fiber.ms.f, domParent) : null;
 }
 function readContext(fiber, ctx) {
   return CAPABILITIES.readContext(fiber, ctx);
@@ -791,63 +1120,185 @@ function defaultReadContext(_fiber, ctx) {
 function attachRef(fiber, value) {
   const ref = fiber.ref ?? (fiber.pp?.ref ?? null);
   if (!ref) return;
-  if (typeof ref == "function") {
-    scheduleLifecycle(fiber, () => {
+  if (isActivityHidden(fiber) || layoutIsDisconnected(fiber)) return;
+  stageCommit(fiber, () => {
+    if (fiber.tag === FiberTag.Resource) value = fiber.sn;
+    fiber.cr = ref;
+    if (typeof ref == "function") {
       const cleanup = ref(value);
       fiber.cu ||= [];
-      fiber.cu.push(typeof cleanup == "function" ? cleanup : () => ref(null));
-    });
-  } else {
-    ref.current = value;
-  }
+      const detach = typeof cleanup == "function" ? cleanup : () => ref(null);
+      fiber.rc = detach;
+      fiber.cu.push(detach);
+    } else {
+      ref.current = value;
+    }
+  }, true);
 }
 function syncRefIfChanged(fiber, value) {
   const ref = fiber.ref ?? (fiber.pp?.ref ?? null);
-  if (!ref) return;
-  if (typeof ref === "object" && ref.current !== value) ref.current = value;
+  if (!ref && !fiber.cr) return;
+  if (isActivityHidden(fiber) || layoutIsDisconnected(fiber)) return;
+  const previous = fiber.cr ?? null;
+  if (previous !== ref) {
+    const cleanup = fiber.rc;
+    queueMutation(() => {
+      if (cleanup) {
+        const index = fiber.cu?.indexOf(cleanup) ?? -1;
+        if (index >= 0) fiber.cu.splice(index, 1);
+        fiber.rc = null;
+        try {
+          cleanup();
+        } catch (error) {
+          handleCommitError(fiber, error);
+        }
+      }
+      detachRef(previous, fiber);
+      fiber.cr = null;
+    });
+    attachRef(fiber, value);
+  } else if (ref && typeof ref === "object" && ref.current !== value) attachRef(fiber, value);
 }
-function detachRef(ref) {
+function detachRef(ref, fiber) {
   if (ref && typeof ref === "object") {
-    ref.current = null;
+    queueMutation(() => {
+      try {
+        ref.current = null;
+      } catch (error) {
+        if (fiber) handleCommitError(fiber, error);
+        else throw error;
+      }
+    });
   }
 }
 var pendingEffects = [];
-var pendingLayoutEffects = [];
-var pendingLifecycles = [];
-function enqueueEffect(fiber, effect) {
-  if (effect.t) {
-    pendingLayoutEffects.push([fiber, effect]);
+var pendingInsertionEffects = [];
+var pendingCommits = [];
+var stagedCommits = /* @__PURE__ */ new Map();
+var stagedFibers = [];
+var lastStagedFiber;
+function removePendingEffect(queue, index) {
+  const entry = queue[index];
+  queue.splice(index, 1);
+  if (currentCommit?.c.length) onCommitRollback(() => {
+    queue.splice(index, 0, entry);
+  });
+}
+function stageCommit(fiber, work, ref = false) {
+  let entries = stagedCommits.get(fiber);
+  if (!entries) {
+    stagedCommits.set(fiber, entries = []);
+    stagedFibers.push(fiber);
+    lastStagedFiber = fiber;
+  }
+  entries.push([fiber, work, ref]);
+}
+function removeStagedCommits(fiber) {
+  if (!stagedCommits.delete(fiber)) return;
+  if (lastStagedFiber === fiber) stagedFibers.pop();
+  else stagedFibers.splice(stagedFibers.lastIndexOf(fiber), 1);
+  lastStagedFiber = stagedFibers[stagedFibers.length - 1];
+}
+function flushFiberCommits(fiber) {
+  const entries = stagedCommits.get(fiber);
+  if (!entries) return;
+  removeStagedCommits(fiber);
+  if (fiber.type === REACT_FRAGMENT_TYPE) {
+    let index = pendingCommits.length;
+    outer: for (let i = 0; i < pendingCommits.length; i++) {
+      for (let parent = pendingCommits[i][0].parent; parent; parent = parent.parent) {
+        if (parent === fiber) {
+          index = i;
+          break outer;
+        }
+      }
+    }
+    if (index < pendingCommits.length && currentCommit?.c.length) {
+      const count = entries.length;
+      onCommitRollback(() => {
+        pendingCommits.splice(index, count);
+      });
+    }
+    pendingCommits.splice(index, 0, ...entries);
+  } else if (fiber.tag === FiberTag.Class || fiber.sn?._fiber === fiber) {
+    for (const entry of entries) if (!entry[2]) pendingCommits.push(entry);
+    for (const entry of entries) if (entry[2]) pendingCommits.push(entry);
   } else {
-    pendingEffects.push([fiber, effect]);
+    for (const entry of entries) pendingCommits.push(entry);
   }
 }
+function enqueueEffect(fiber, effect) {
+  if (effect.t !== 2 && (isActivityHidden(fiber) || activityIsDisconnected(fiber) || effect.t === 1 && !effect.s && fiber.ld)) return;
+  if (effect.t === 2) pendingInsertionEffects.push([fiber, effect]);
+  else if (effect.t === 1) stageCommit(fiber, effect);
+  else pendingEffects.push([fiber, effect]);
+}
 function scheduleLifecycle(fiber, fn) {
-  pendingLifecycles.push(() => {
-    if (!fiber.um) fn();
-  });
+  if (isActivityHidden(fiber) || layoutIsDisconnected(fiber)) return;
+  stageCommit(fiber, fn);
 }
 function runEffects(root) {
-  while (pendingLayoutEffects.length) {
-    const [fiber, effect] = pendingLayoutEffects.shift();
-    runEffect(fiber, effect, root);
-  }
-  while (pendingLifecycles.length) {
-    const fn = pendingLifecycles.shift();
-    try {
-      fn();
-    } catch (e) {
-      if (root.ce) root.ce(e);
+  if (root.fr) refreshFragmentInstances(root);
+  if (!pendingInsertionEffects.length && !pendingCommits.length && !pendingEffects.length) return;
+  flushEffects(root);
+}
+function flushEffects(root) {
+  const insertion = pendingInsertionEffects.splice(0);
+  const layout = pendingCommits.splice(0);
+  const batch = pendingEffects.splice(0);
+  if (currentCommit?.c.length) onCommitRollback(() => {
+    pendingInsertionEffects.unshift(...insertion);
+    pendingCommits.unshift(...layout);
+    pendingEffects.unshift(...batch);
+  });
+  queueCommitEffects(() => {
+    for (const [fiber, effect] of insertion) runEffect(fiber, effect, root);
+    if (layout.length) {
+      for (const [fiber, work] of layout) {
+        if (typeof work !== "function" && !fiber.um && !isActivityHidden(fiber) && !layoutIsDisconnected(fiber)) work.d?.();
+      }
+      const runLayout = () => {
+        for (const [fiber, work] of layout) {
+          if (typeof work !== "function") runEffect(fiber, work, root);
+          else if (!fiber.um && !isActivityHidden(fiber) && !layoutIsDisconnected(fiber)) {
+            try {
+              work();
+            } catch (error) {
+              handleCommitError(fiber, error);
+            }
+          }
+        }
+      };
+      if (!deferTransitionLayout(runLayout)) runLayout();
     }
-  }
-  if (pendingEffects.length) {
-    const batch = pendingEffects.splice(0);
-    queueMicrotask(() => {
-      for (const [fiber, effect] of batch) runEffect(fiber, effect, root);
-    });
-  }
+    if (batch.length) {
+      const passive = () => {
+        for (const [fiber, effect] of batch) runEffect(fiber, effect, root);
+      };
+      if (!deferTransitionPassive(passive)) queueMicrotask(passive);
+    }
+  });
 }
+setCommitCheckpointHook(() => {
+  const parent = preparedParent;
+  const children = parent && Array.from(parent.childNodes);
+  const effects = pendingEffects.length, insertion = pendingInsertionEffects.length, commits = pendingCommits.length;
+  const staged = new Map([...stagedCommits].map(([fiber, work]) => [fiber, work.slice()]));
+  const stack = stagedFibers.slice(), last = lastStagedFiber;
+  onCommitRollback(() => {
+    if (parent) parent.replaceChildren(...children);
+    pendingEffects.length = effects;
+    pendingInsertionEffects.length = insertion;
+    pendingCommits.length = commits;
+    stagedCommits.clear();
+    for (const [fiber, work] of staged) stagedCommits.set(fiber, work);
+    stagedFibers.splice(0, stagedFibers.length, ...stack);
+    lastStagedFiber = last;
+  });
+});
 function runEffect(fiber, effect, root) {
   if (fiber.um) return;
+  if (effect.t !== 2 && (isActivityHidden(fiber) || activityIsDisconnected(fiber) || effect.t === 1 && !effect.s && fiber.ld)) return;
   try {
     const cleanup = effect.c();
     if (typeof cleanup == "function") {
@@ -855,36 +1306,53 @@ function runEffect(fiber, effect, root) {
       fiber.cu.push(cleanup);
     }
   } catch (e) {
-    if (root.ce) root.ce(e);
+    handleCommitError(fiber, e);
   }
 }
 function isEventProp(name) {
   return name.length > 2 && name.charCodeAt(0) === 111 && name.charCodeAt(1) === 110 && name.charCodeAt(2) >= 65;
 }
 export {
+  RenderErrorCapture,
+  RenderSuspenseCapture,
+  activityIsDisconnected,
+  attachRef,
   batchedUpdates,
   childrenToArray,
   deferHydration,
+  detachRef,
+  discardPendingEffects,
   discardPendingWork,
   enqueueEffect,
   findRoot,
+  findSuspenseBoundary,
+  flushFiberCommits,
   flushSyncWork,
+  getAnchor,
   getCurrentRoot,
   getForceRerenderingFiber,
+  getHostParent,
+  handleCommitError,
   handleErrorInRender,
   handleSuspended,
   installCapability,
+  isActivityHidden,
   isThenable,
+  layoutIsDisconnected,
   readContext,
   reconcileChildren,
+  recoverRootError,
   registerElementMarker,
   registerRenderer,
   registerTypeMatcher,
+  rememberActivityEffect,
   renderFiber,
   renderRoot,
   runEffects,
   scheduleLifecycle,
+  scheduleRootRender,
   scheduleUpdate,
+  syncRefIfChanged,
   unmountAllChildren,
   unmountFiber,
   withCurrentRoot