bippy 0.5.42 → 0.6.0

package/src/core.ts

@@ -13,12 +13,15 @@ import type {
 } from "./types.js";
 
 import {
+  _onActiveListeners,
   BIPPY_INSTRUMENTATION_STRING,
   getRDTHook,
   hasRDTHook,
   isReactRefresh,
   isRealReactDevtools,
+  onRendererInject,
 } from "./rdt-hook.js";
+import { toUnsubscribe, type Unsubscribe } from "./unsubscribe.js";
 
 // https://github.com/facebook/react/blob/main/packages/react-reconciler/src/ReactWorkTags.js
 export const FunctionComponentTag = 0;
@@ -48,6 +51,8 @@ export const ELEMENT_TYPE_SYMBOL_STRING = "Symbol(react.element)";
 export const TRANSITIONAL_ELEMENT_TYPE_SYMBOL_STRING = "Symbol(react.transitional.element)";
 export const CONCURRENT_MODE_SYMBOL_STRING = "Symbol(react.concurrent_mode)";
 export const DEPRECATED_ASYNC_MODE_SYMBOL_STRING = "Symbol(react.async_mode)";
+export const CONCURRENT_MODE_SYMBOL_DESCRIPTION = "react.concurrent_mode";
+export const DEPRECATED_ASYNC_MODE_SYMBOL_DESCRIPTION = "react.async_mode";
 
 // https://github.com/facebook/react/blob/main/packages/react-reconciler/src/ReactFiberFlags.js
 const PerformedWork = 0b1;
@@ -135,13 +140,6 @@ export const isFiber = (maybeFiber: unknown): maybeFiber is Fiber => {
   return "pendingProps" in maybeFiber && !("containerInfo" in maybeFiber);
 };
 
-/**
- * Returns `true` if the two {@link Fiber}s are the same reference
- */
-export const areFiberEqual = (fiberA: Fiber, fiberB: Fiber): boolean => {
-  return fiberA === fiberB || fiberA.alternate === fiberB || fiberB.alternate === fiberA;
-};
-
 /**
  * Traverses up or down a {@link Fiber}'s contexts, return `true` to stop and select the current and previous context value.
  */
@@ -215,13 +213,12 @@ export const traverseProps = (
     const nextProps = fiber.memoizedProps;
     const prevProps = fiber.alternate?.memoizedProps || {};
 
-    const allKeys = new Set([...Object.keys(nextProps), ...Object.keys(prevProps)]);
-
-    for (const propName of allKeys) {
-      const prevValue = prevProps?.[propName];
-      const nextValue = nextProps?.[propName];
-
-      if (selector(propName, nextValue, prevValue) === true) return true;
+    for (const propName of Object.keys(nextProps)) {
+      if (selector(propName, nextProps[propName], prevProps[propName]) === true) return true;
+    }
+    for (const propName of Object.keys(prevProps)) {
+      if (propName in nextProps) continue;
+      if (selector(propName, nextProps[propName], prevProps[propName]) === true) return true;
     }
   } catch {}
   return false;
@@ -308,7 +305,7 @@ export const getFiberStack = (fiber: Fiber): Fiber[] => {
 /**
  * Returns `true` if the {@link Fiber} should be filtered out during reconciliation.
  */
-export const shouldFilterFiber = (fiber: Fiber): boolean => {
+const shouldFilterFiber = (fiber: Fiber): boolean => {
   switch (fiber.tag) {
     case DehydratedSuspenseComponentTag:
       // TODO: ideally we would show dehydrated Suspense immediately.
@@ -332,10 +329,14 @@ export const shouldFilterFiber = (fiber: Fiber): boolean => {
       const symbolOrNumber =
         typeof fiber.type === "object" && fiber.type !== null ? fiber.type.$$typeof : fiber.type;
 
-      const typeSymbol =
-        typeof symbolOrNumber === "symbol" ? symbolOrNumber.toString() : symbolOrNumber;
+      if (typeof symbolOrNumber === "symbol") {
+        return (
+          symbolOrNumber.description === CONCURRENT_MODE_SYMBOL_DESCRIPTION ||
+          symbolOrNumber.description === DEPRECATED_ASYNC_MODE_SYMBOL_DESCRIPTION
+        );
+      }
 
-      switch (typeSymbol) {
+      switch (symbolOrNumber) {
         case CONCURRENT_MODE_NUMBER:
         case CONCURRENT_MODE_SYMBOL_STRING:
         case DEPRECATED_ASYNC_MODE_SYMBOL_STRING:
@@ -439,7 +440,7 @@ export function traverseFiber(
   return null;
 }
 
-export const traverseFiberSync = (
+const traverseFiberSync = (
   fiber: Fiber | null,
   selector: (node: Fiber) => boolean | void,
   ascending = false,
@@ -457,7 +458,7 @@ export const traverseFiberSync = (
   return null;
 };
 
-export const traverseFiberAsync = async (
+const traverseFiberAsync = async (
   fiber: Fiber | null,
   selector: (node: Fiber) => Promise<boolean | void>,
   ascending = false,
@@ -568,6 +569,8 @@ export const isInstrumentationActive = (): boolean => {
   );
 };
 
+export const _fiberRoots = new Set<FiberRoot>();
+
 /**
  * Returns the latest fiber (since it may be double-buffered).
  */
@@ -591,7 +594,7 @@ export type RenderHandler = <S>(fiber: Fiber, phase: RenderPhase, state?: S) =>
 export type RenderPhase = "mount" | "unmount" | "update";
 
 let fiberId = 0;
-export const fiberIdMap = new WeakMap<Fiber, number>();
+const fiberIdMap = new WeakMap<Fiber, number>();
 
 export const setFiberId = (fiber: Fiber, id: number = fiberId++): void => {
   fiberIdMap.set(fiber, id);
@@ -612,7 +615,7 @@ export const getFiberId = (fiber: Fiber): number => {
   return id;
 };
 
-export const mountFiberRecursively = (
+const mountFiberRecursively = (
   onRender: RenderHandler,
   firstChild: Fiber,
   traverseSiblings: boolean,
@@ -661,7 +664,7 @@ export const mountFiberRecursively = (
   }
 };
 
-export const updateFiberRecursively = (
+const updateFiberRecursively = (
   onRender: RenderHandler,
   nextFiber: Fiber,
   prevFiber: Fiber,
@@ -761,7 +764,7 @@ export const updateFiberRecursively = (
   }
 };
 
-export const unmountFiber = (onRender: RenderHandler, fiber: Fiber): void => {
+const unmountFiber = (onRender: RenderHandler, fiber: Fiber): void => {
   const isRoot = fiber.tag === HostRootTag;
 
   if (isRoot || !shouldFilterFiber(fiber)) {
@@ -769,7 +772,7 @@ export const unmountFiber = (onRender: RenderHandler, fiber: Fiber): void => {
   }
 };
 
-export const unmountFiberChildrenRecursively = (onRender: RenderHandler, fiber: Fiber): void => {
+const unmountFiberChildrenRecursively = (onRender: RenderHandler, fiber: Fiber): void => {
   // We might meet a nested Suspense on our way.
   const isTimedOutSuspense = fiber.tag === SuspenseComponentTag && fiber.memoizedState !== null;
   let child = fiber.child;
@@ -852,80 +855,85 @@ export const traverseRenderedFibers = (root: FiberRoot, onRender: RenderHandler)
   rootInstance.prevFiber = fiber;
 };
 
-let _overrideProps: null | ReactRenderer["overrideProps"] = null;
-let _overrideHookState: null | ReactRenderer["overrideHookState"] = null;
-let _overrideContext: null | ReactRenderer["overrideContext"] = null;
+const overrideRenderers = new Set<ReactRenderer>();
+let areOverrideRenderersWired = false;
 
-export const injectOverrideMethods = () => {
-  if (!hasRDTHook()) return null;
+const wireOverrideRenderers = (): void => {
+  if (areOverrideRenderersWired) return;
+  if (!hasRDTHook()) return;
   const rdtHook = getRDTHook();
-  if (!rdtHook?.renderers) return null;
+  if (!rdtHook?.renderers) return;
+  areOverrideRenderersWired = true;
 
-  if (_overrideProps || _overrideHookState || _overrideContext) {
-    return {
-      overrideContext: _overrideContext,
-      overrideHookState: _overrideHookState,
-      overrideProps: _overrideProps,
-    };
+  ensureHookDispatchesToListeners(rdtHook);
+  for (const renderer of rdtHook.renderers.values()) {
+    overrideRenderers.add(renderer);
   }
+  onRendererInject((renderer) => {
+    overrideRenderers.add(renderer);
+  });
+};
 
-  for (const [, renderer] of Array.from(rdtHook.renderers)) {
-    try {
-      if (_overrideHookState) {
-        const prevOverrideHookState = _overrideHookState;
-        _overrideHookState = (fiber: Fiber, id: string, path: string[], value: unknown) => {
-          let current = fiber.memoizedState;
-          for (let i = 0; i < Number(id); i++) {
-            if (!current?.next) break;
-            current = current.next;
-          }
+const getRootRenderer = (fiber: Fiber): ReactRenderer | null => {
+  if (!hasRDTHook()) return null;
+  let hostRootFiber = fiber;
+  while (hostRootFiber.return) {
+    hostRootFiber = hostRootFiber.return;
+  }
+  const rendererId = rootRendererIds.get(hostRootFiber.stateNode);
+  if (rendererId === undefined) return null;
+  return getRDTHook().renderers?.get(rendererId) ?? null;
+};
 
-          if (current?.queue) {
-            const queue = current.queue;
-            if (isPOJO(queue) && "dispatch" in queue) {
-              const dispatch = queue.dispatch as (value: unknown) => void;
-              dispatch(value);
-              return;
-            }
-          }
+// dispatch to the renderer that owns the fiber's root when known; renderers
+// that never committed through bippy's hook patch fall back to "try all",
+// which matches the pre-ownership behavior for single-renderer apps
+const resolveOverrideRenderers = (fiber: Fiber): ReactRenderer[] => {
+  wireOverrideRenderers();
+  const rootRenderer = getRootRenderer(fiber);
+  if (rootRenderer) return [rootRenderer];
+  return Array.from(overrideRenderers);
+};
 
-          prevOverrideHookState(fiber, id, path, value);
-          renderer.overrideHookState?.(fiber, id, path, value);
-        };
-      } else if (renderer.overrideHookState) {
-        _overrideHookState = renderer.overrideHookState;
-      }
+const applyPropsOverride = (
+  renderers: ReactRenderer[],
+  fiber: Fiber,
+  path: string[],
+  value: unknown,
+): void => {
+  for (const renderer of renderers) {
+    try {
+      renderer.overrideProps?.(fiber, path, value);
+    } catch {}
+  }
+};
 
-      if (_overrideProps) {
-        const prevOverrideProps = _overrideProps;
-        _overrideProps = (fiber: Fiber, path: Array<string>, value: unknown) => {
-          prevOverrideProps(fiber, path, value);
-          renderer.overrideProps?.(fiber, path, value);
-        };
-      } else if (renderer.overrideProps) {
-        _overrideProps = renderer.overrideProps;
-      }
+const getHookStateDispatch = (
+  fiber: Fiber,
+  hookIndex: number,
+): ((value: unknown) => void) | null => {
+  let hookState = fiber.memoizedState;
+  for (let i = 0; i < hookIndex; i++) {
+    if (!hookState?.next) return null;
+    hookState = hookState.next;
+  }
+  const queue = hookState?.queue;
+  if (isPOJO(queue) && typeof queue.dispatch === "function") {
+    return queue.dispatch as (value: unknown) => void;
+  }
+  return null;
+};
 
-      _overrideContext = (fiber: Fiber, contextType: unknown, path: string[], value: unknown) => {
-        let current: Fiber | null = fiber;
-        while (current) {
-          const type = current.type as { Provider?: unknown };
-          if (type === contextType || type?.Provider === contextType) {
-            if (_overrideProps) {
-              _overrideProps(current, ["value", ...path], value);
-              if (current.alternate) {
-                _overrideProps(current.alternate, ["value", ...path], value);
-              }
-            }
-            break;
-          }
-          current = current.return;
-        }
-      };
-    } catch {
-      /**/
+const findContextProviderFiber = (fiber: Fiber, contextType: unknown): Fiber | null => {
+  let currentFiber: Fiber | null = fiber;
+  while (currentFiber) {
+    const fiberType = currentFiber.type;
+    if (fiberType === contextType || fiberType?.Provider === contextType) {
+      return currentFiber;
     }
+    currentFiber = currentFiber.return;
   }
+  return null;
 };
 
 const isPOJO = (maybePOJO: unknown): maybePOJO is Record<string, unknown> => {
@@ -960,61 +968,54 @@ const buildPathsFromValue = (
   return paths;
 };
 
-export const overrideProps = (fiber: Fiber, partialValue: Record<string, unknown>) => {
-  injectOverrideMethods();
-
-  const paths = buildPathsFromValue(partialValue);
+const buildValueWrites = (partialValue: unknown): Array<{ path: string[]; value: unknown }> =>
+  isPOJO(partialValue) ? buildPathsFromValue(partialValue) : [{ path: [], value: partialValue }];
 
-  for (const { path, value } of paths) {
-    try {
-      _overrideProps?.(fiber, path, value);
-    } catch {}
+export const overrideProps = (fiber: Fiber, partialValue: Record<string, unknown>) => {
+  const renderers = resolveOverrideRenderers(fiber);
+  for (const { path, value } of buildValueWrites(partialValue)) {
+    applyPropsOverride(renderers, fiber, path, value);
   }
 };
 
-export const overrideHookState = (
-  fiber: Fiber,
-  id: number,
-  partialValue: Record<string, unknown>,
-) => {
-  injectOverrideMethods();
-
-  const hookId = String(id);
-
-  if (isPOJO(partialValue)) {
-    const paths = buildPathsFromValue(partialValue);
-
-    for (const { path, value } of paths) {
-      try {
-        _overrideHookState?.(fiber, hookId, path, value);
-      } catch {}
+export const overrideHookState = (fiber: Fiber, id: number, partialValue: unknown) => {
+  const renderers = resolveOverrideRenderers(fiber).filter((renderer) =>
+    Boolean(renderer.overrideHookState),
+  );
+  const writes = buildValueWrites(partialValue);
+
+  if (renderers.length > 0) {
+    const hookId = String(id);
+    for (const renderer of renderers) {
+      for (const { path, value } of writes) {
+        try {
+          renderer.overrideHookState?.(fiber, hookId, path, value);
+        } catch {}
+      }
     }
-  } else {
-    try {
-      _overrideHookState?.(fiber, hookId, [], partialValue);
-    } catch {}
+    return;
   }
-};
 
-export const overrideContext = (
-  fiber: Fiber,
-  contextType: unknown,
-  partialValue: Record<string, unknown>,
-) => {
-  injectOverrideMethods();
-
-  if (isPOJO(partialValue)) {
-    const paths = buildPathsFromValue(partialValue);
+  // production renderers don't expose overrideHookState; dispatching through
+  // the hook's own queue still works there, but only for whole-value writes
+  // (a path write through dispatch would replace the entire hook state)
+  if (isPOJO(partialValue)) return;
+  const dispatch = getHookStateDispatch(fiber, id);
+  if (!dispatch) return;
+  try {
+    dispatch(partialValue);
+  } catch {}
+};
 
-    for (const { path, value } of paths) {
-      try {
-        _overrideContext?.(fiber, contextType, path, value);
-      } catch {}
+export const overrideContext = (fiber: Fiber, contextType: unknown, partialValue: unknown) => {
+  const providerFiber = findContextProviderFiber(fiber, contextType);
+  if (!providerFiber) return;
+  const renderers = resolveOverrideRenderers(providerFiber);
+  for (const { path, value } of buildValueWrites(partialValue)) {
+    applyPropsOverride(renderers, providerFiber, ["value", ...path], value);
+    if (providerFiber.alternate) {
+      applyPropsOverride(renderers, providerFiber.alternate, ["value", ...path], value);
     }
-  } else {
-    try {
-      _overrideContext?.(fiber, contextType, [], partialValue);
-    } catch {}
   }
 };
 
@@ -1027,10 +1028,133 @@ export interface InstrumentationOptions {
   onScheduleFiberRoot?: (rendererID: number, root: FiberRoot, children: React.ReactNode) => unknown;
 }
 
+const commitFiberRootListeners = new Set<
+  NonNullable<InstrumentationOptions["onCommitFiberRoot"]>
+>();
+const commitFiberUnmountListeners = new Set<
+  NonNullable<InstrumentationOptions["onCommitFiberUnmount"]>
+>();
+const postCommitFiberRootListeners = new Set<
+  NonNullable<InstrumentationOptions["onPostCommitFiberRoot"]>
+>();
+const scheduleFiberRootListeners = new Set<
+  NonNullable<InstrumentationOptions["onScheduleFiberRoot"]>
+>();
+
+interface HookDispatchers {
+  onCommitFiberRoot: ReactDevToolsGlobalHook["onCommitFiberRoot"];
+  onCommitFiberUnmount: ReactDevToolsGlobalHook["onCommitFiberUnmount"];
+  onPostCommitFiberRoot: ReactDevToolsGlobalHook["onPostCommitFiberRoot"];
+  onScheduleFiberRoot: NonNullable<ReactDevToolsGlobalHook["onScheduleFiberRoot"]>;
+}
+
+const hookDispatchers = new WeakMap<ReactDevToolsGlobalHook, Partial<HookDispatchers>>();
+
+const rootRendererIds = new WeakMap<FiberRoot, number>();
+
+// each hook event is dispatched from a single re-installable wrapper. If
+// something overwrites the hook method (devtools, direct assignment), the
+// next instrument() call installs a fresh wrapper over it; a superseded
+// wrapper still forwards the previous chain but skips the listeners so
+// they never fire twice.
+const ensureHookDispatchesToListeners = (rdtHook: ReactDevToolsGlobalHook): void => {
+  const dispatchers = hookDispatchers.get(rdtHook) ?? {};
+  hookDispatchers.set(rdtHook, dispatchers);
+
+  if (
+    !dispatchers.onCommitFiberRoot ||
+    rdtHook.onCommitFiberRoot !== dispatchers.onCommitFiberRoot
+  ) {
+    const prevOnCommitFiberRoot = rdtHook.onCommitFiberRoot;
+    const dispatchCommitFiberRoot: HookDispatchers["onCommitFiberRoot"] = (
+      rendererID,
+      root,
+      priority,
+    ) => {
+      prevOnCommitFiberRoot?.(rendererID, root, priority);
+      if (hookDispatchers.get(rdtHook)?.onCommitFiberRoot !== dispatchCommitFiberRoot) return;
+      _fiberRoots.add(root);
+      rootRendererIds.set(root, rendererID);
+      for (const listener of commitFiberRootListeners) {
+        listener(rendererID, root, priority);
+      }
+    };
+    dispatchers.onCommitFiberRoot = dispatchCommitFiberRoot;
+    rdtHook.onCommitFiberRoot = dispatchCommitFiberRoot;
+  }
+
+  if (
+    !dispatchers.onCommitFiberUnmount ||
+    rdtHook.onCommitFiberUnmount !== dispatchers.onCommitFiberUnmount
+  ) {
+    const prevOnCommitFiberUnmount = rdtHook.onCommitFiberUnmount;
+    const dispatchCommitFiberUnmount: HookDispatchers["onCommitFiberUnmount"] = (
+      rendererID,
+      fiber,
+    ) => {
+      prevOnCommitFiberUnmount?.(rendererID, fiber);
+      if (hookDispatchers.get(rdtHook)?.onCommitFiberUnmount !== dispatchCommitFiberUnmount) {
+        return;
+      }
+      for (const listener of commitFiberUnmountListeners) {
+        listener(rendererID, fiber);
+      }
+    };
+    dispatchers.onCommitFiberUnmount = dispatchCommitFiberUnmount;
+    rdtHook.onCommitFiberUnmount = dispatchCommitFiberUnmount;
+  }
+
+  if (
+    !dispatchers.onPostCommitFiberRoot ||
+    rdtHook.onPostCommitFiberRoot !== dispatchers.onPostCommitFiberRoot
+  ) {
+    const prevOnPostCommitFiberRoot = rdtHook.onPostCommitFiberRoot;
+    const dispatchPostCommitFiberRoot: HookDispatchers["onPostCommitFiberRoot"] = (
+      rendererID,
+      root,
+    ) => {
+      prevOnPostCommitFiberRoot?.(rendererID, root);
+      if (hookDispatchers.get(rdtHook)?.onPostCommitFiberRoot !== dispatchPostCommitFiberRoot) {
+        return;
+      }
+      for (const listener of postCommitFiberRootListeners) {
+        listener(rendererID, root);
+      }
+    };
+    dispatchers.onPostCommitFiberRoot = dispatchPostCommitFiberRoot;
+    rdtHook.onPostCommitFiberRoot = dispatchPostCommitFiberRoot;
+  }
+
+  if (
+    !dispatchers.onScheduleFiberRoot ||
+    rdtHook.onScheduleFiberRoot !== dispatchers.onScheduleFiberRoot
+  ) {
+    const prevOnScheduleFiberRoot = rdtHook.onScheduleFiberRoot;
+    const dispatchScheduleFiberRoot: HookDispatchers["onScheduleFiberRoot"] = (
+      rendererID,
+      root,
+      children,
+    ) => {
+      prevOnScheduleFiberRoot?.(rendererID, root, children);
+      if (hookDispatchers.get(rdtHook)?.onScheduleFiberRoot !== dispatchScheduleFiberRoot) return;
+      for (const listener of scheduleFiberRootListeners) {
+        listener(rendererID, root, children);
+      }
+    };
+    dispatchers.onScheduleFiberRoot = dispatchScheduleFiberRoot;
+    rdtHook.onScheduleFiberRoot = dispatchScheduleFiberRoot;
+  }
+};
+
 /**
- * Instruments the DevTools hook.
+ * Instruments the DevTools hook. Each hook event is patched once and
+ * dispatches to a set of listeners, so multiple `instrument` calls compose
+ * without stacking patches. Returns an unsubscribe function that removes
+ * exactly the handlers this call registered.
+ * The returned function is also a `Disposable`, so it composes with other
+ * bippy subscriptions through `using`.
  * @example
- * const hook = instrument({
+ * const unsubscribe = instrument({
  *   onActive() {
  *     console.log('initialized');
  *   },
@@ -1038,51 +1162,45 @@ export interface InstrumentationOptions {
  *     console.log('fiberRoot', root.current)
  *   },
  * });
+ * unsubscribe();
  */
-export const instrument = (options: InstrumentationOptions): ReactDevToolsGlobalHook => {
+export const instrument = (options: InstrumentationOptions): Unsubscribe => {
   const rdtHook = getRDTHook(options.onActive);
 
   rdtHook._instrumentationSource = options.name ?? BIPPY_INSTRUMENTATION_STRING;
 
-  const prevOnCommitFiberRoot = rdtHook.onCommitFiberRoot;
-  if (options.onCommitFiberRoot) {
-    const nextOnCommitFiberRoot = (
-      rendererID: number,
-      root: FiberRoot,
-      priority: number | void,
-    ) => {
-      if (prevOnCommitFiberRoot === nextOnCommitFiberRoot) return;
-      // TODO: validate whether the bottom version is more correct here
-      // for preventing infinite loops
-      // if (rdtHook.onCommitFiberRoot !== handler) return;
-      prevOnCommitFiberRoot?.(rendererID, root, priority);
-      options.onCommitFiberRoot?.(rendererID, root, priority);
-    };
-    rdtHook.onCommitFiberRoot = nextOnCommitFiberRoot;
-  }
-
-  const prevOnCommitFiberUnmount = rdtHook.onCommitFiberUnmount;
-  if (options.onCommitFiberUnmount) {
-    const handler = (rendererID: number, root: FiberRoot) => {
-      if (rdtHook.onCommitFiberUnmount !== handler) return;
-      prevOnCommitFiberUnmount?.(rendererID, root);
-      options.onCommitFiberUnmount?.(rendererID, root);
-    };
-    rdtHook.onCommitFiberUnmount = handler;
-  }
+  ensureHookDispatchesToListeners(rdtHook);
+
+  const {
+    onActive,
+    onCommitFiberRoot,
+    onCommitFiberUnmount,
+    onPostCommitFiberRoot,
+    onScheduleFiberRoot,
+  } = options;
+  if (onCommitFiberRoot) commitFiberRootListeners.add(onCommitFiberRoot);
+  if (onCommitFiberUnmount) commitFiberUnmountListeners.add(onCommitFiberUnmount);
+  if (onPostCommitFiberRoot) postCommitFiberRootListeners.add(onPostCommitFiberRoot);
+  if (onScheduleFiberRoot) scheduleFiberRootListeners.add(onScheduleFiberRoot);
+
+  return toUnsubscribe(() => {
+    if (onActive) _onActiveListeners.delete(onActive);
+    if (onCommitFiberRoot) commitFiberRootListeners.delete(onCommitFiberRoot);
+    if (onCommitFiberUnmount) commitFiberUnmountListeners.delete(onCommitFiberUnmount);
+    if (onPostCommitFiberRoot) postCommitFiberRootListeners.delete(onPostCommitFiberRoot);
+    if (onScheduleFiberRoot) scheduleFiberRootListeners.delete(onScheduleFiberRoot);
+  });
+};
 
-  const prevOnPostCommitFiberRoot = rdtHook.onPostCommitFiberRoot;
-  if (options.onPostCommitFiberRoot) {
-    const handler = (rendererID: number, root: FiberRoot) => {
-      if (rdtHook.onPostCommitFiberRoot !== handler) return;
-      prevOnPostCommitFiberRoot?.(rendererID, root);
-      options.onPostCommitFiberRoot?.(rendererID, root);
-    };
-    rdtHook.onPostCommitFiberRoot = handler;
-  }
+// React stamps fibers under per-renderer random-suffix keys (`__reactFiber$<suffix>`);
+// caching discovered keys makes repeat lookups a single property read instead of a
+// scan over every own key of the element.
+const knownFiberPropertyKeys = new Set<string>();
 
-  return rdtHook;
-};
+const isFiberPropertyKey = (key: string): boolean =>
+  key.startsWith("__reactContainer$") ||
+  key.startsWith("__reactInternalInstance$") ||
+  key.startsWith("__reactFiber");
 
 export const getFiberFromHostInstance = <T>(hostInstance: T): Fiber | null => {
   const rdtHook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
@@ -1101,174 +1219,34 @@ export const getFiberFromHostInstance = <T>(hostInstance: T): Fiber | null => {
       return (hostInstance._reactRootContainer as any)?._internalRoot?.current?.child;
     }
 
-    for (const key in hostInstance) {
-      if (
-        key.startsWith("__reactContainer$") ||
-        key.startsWith("__reactInternalInstance$") ||
-        key.startsWith("__reactFiber")
-      ) {
-        return (hostInstance[key] || null) as Fiber | null;
-      }
-    }
-  }
-  return null;
-};
-
-export const INSTALL_ERROR = new Error();
-
-export const _fiberRoots = new Set<FiberRoot>();
-
-export const secure = (
-  options: InstrumentationOptions,
-  secureOptions: {
-    dangerouslyRunInProduction?: boolean;
-    installCheckTimeout?: number;
-    isProduction?: boolean;
-    minReactMajorVersion?: number;
-    onError?: (error?: unknown) => unknown;
-  } = {},
-): InstrumentationOptions => {
-  const onActive = options.onActive;
-  const isRDTHookInstalled = hasRDTHook();
-  const isUsingRealReactDevtools = isRealReactDevtools();
-  const isUsingReactRefresh = isReactRefresh();
-  let timeout: number | undefined;
-  let isDevelopment = !secureOptions.isProduction;
-
-  options.onActive = () => {
-    clearTimeout(timeout);
-    let isSecure = true;
-    try {
-      const rdtHook = getRDTHook();
-
-      for (const renderer of rdtHook.renderers.values()) {
-        const [majorVersion] = renderer.version.split(".");
-        if (Number(majorVersion) < (secureOptions.minReactMajorVersion ?? 17)) {
-          isSecure = false;
-        }
-        const buildType = detectReactBuildType(renderer);
-        if (buildType === "development") {
-          isDevelopment = true;
-        } else if (!secureOptions.dangerouslyRunInProduction) {
-          isSecure = false;
-        }
-      }
-    } catch (err) {
-      secureOptions.onError?.(err);
+    // React Native Fabric public instances (ReactNativeElement /
+    // ReactFabricHostComponent) store their fiber as the "internal instance
+    // handle" instead of a __reactFiber$-prefixed key
+    const fabricInstanceHandle =
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (hostInstance as any).__internalInstanceHandle ??
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (hostInstance as any)._internalInstanceHandle;
+    if (isFiber(fabricInstanceHandle)) {
+      return fabricInstanceHandle;
     }
 
-    if (!isSecure) {
-      options.onCommitFiberRoot = undefined;
-      options.onCommitFiberUnmount = undefined;
-      options.onPostCommitFiberRoot = undefined;
-      options.onActive = undefined;
-      return;
+    const hostInstanceRecord = hostInstance as Record<string, unknown>;
+    for (const knownKey of knownFiberPropertyKeys) {
+      const fiber = hostInstanceRecord[knownKey];
+      if (fiber) return fiber as Fiber;
     }
-    onActive?.();
 
-    try {
-      const onCommitFiberRoot = options.onCommitFiberRoot;
-      if (onCommitFiberRoot) {
-        options.onCommitFiberRoot = (rendererID, root, priority) => {
-          if (!_fiberRoots.has(root)) {
-            _fiberRoots.add(root);
-          }
-          try {
-            onCommitFiberRoot(rendererID, root, priority);
-          } catch (err) {
-            secureOptions.onError?.(err);
-          }
-        };
-      }
-
-      const onCommitFiberUnmount = options.onCommitFiberUnmount;
-      if (onCommitFiberUnmount) {
-        options.onCommitFiberUnmount = (rendererID, root) => {
-          try {
-            onCommitFiberUnmount(rendererID, root);
-          } catch (err) {
-            secureOptions.onError?.(err);
-          }
-        };
+    for (const key of Object.keys(hostInstanceRecord)) {
+      if (isFiberPropertyKey(key)) {
+        knownFiberPropertyKeys.add(key);
+        return (hostInstanceRecord[key] || null) as Fiber | null;
       }
-
-      const onPostCommitFiberRoot = options.onPostCommitFiberRoot;
-      if (onPostCommitFiberRoot) {
-        options.onPostCommitFiberRoot = (rendererID, root) => {
-          try {
-            onPostCommitFiberRoot(rendererID, root);
-          } catch (err) {
-            secureOptions.onError?.(err);
-          }
-        };
-      }
-    } catch (err) {
-      secureOptions.onError?.(err);
     }
-  };
-
-  if (!isRDTHookInstalled && !isUsingRealReactDevtools && !isUsingReactRefresh) {
-    timeout = setTimeout(() => {
-      if (isDevelopment) {
-        secureOptions.onError?.(INSTALL_ERROR);
-      }
-      stop();
-    }, secureOptions.installCheckTimeout ?? 100) as unknown as number;
   }
-
-  return options;
-};
-
-const swapFiberAndSchedule = (
-  fiber: Fiber,
-  nextType: React.ComponentType<unknown>,
-  renderer: ReactRenderer,
-): void => {
-  fiber.type = nextType;
-  if (fiber.alternate) {
-    fiber.alternate.type = nextType;
-  }
-  // HACK: shallow-clone memoizedProps so React sees oldProps !== newProps
-  // and skips the bailout path (same trick as overrideHookState in ReactFiberReconciler)
-  fiber.memoizedProps = { ...fiber.memoizedProps };
-
-  if (renderer.scheduleUpdate) {
-    renderer.scheduleUpdate(fiber);
-  }
-};
-
-/**
- * Replaces every fiber whose type matches `prevType` with `nextType` and
- * triggers a synchronous re-render for each one.
- * The new function must follow the same Rules of Hooks as the original.
- * DEV-only — `renderer.scheduleUpdate` is not available in production builds.
- */
-export const hotSwapFiberType = (fiber: Fiber, nextType: React.ComponentType<unknown>): void => {
-  const rdtHook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
-  if (!rdtHook?.renderers) return;
-
-  const renderer = Array.from(rdtHook.renderers.values()).find(
-    (innerRenderer) => !!innerRenderer.scheduleUpdate,
-  );
-  if (!renderer) return;
-
-  const prevType = getType(fiber.type);
-  if (!prevType) {
-    swapFiberAndSchedule(fiber, nextType, renderer);
-    return;
-  }
-
-  let rootFiber: Fiber = fiber;
-  while (rootFiber.return) {
-    rootFiber = rootFiber.return;
-  }
-
-  traverseFiberSync(rootFiber, (innerFiber) => {
-    if (getType(innerFiber.type) === prevType) {
-      swapFiberAndSchedule(innerFiber, nextType, renderer);
-    }
-  });
+  return null;
 };
 
 export * from "./rdt-hook.js";
+export * from "./unsubscribe.js";
 export type * from "./types.js";