bippy 0.6.1-dev.d7876ea → 0.6.1-dev.f9e6c65

package/src/core.ts

@@ -3,26 +3,23 @@
 import type * as React from "react";
 
 import type {
-  ContextDependency,
   Fiber,
   FiberRoot,
   HostFiber,
-  MemoizedState,
   ReactDevToolsGlobalHook,
   ReactRenderer,
-} from "./types.js";
-
-import { BippyInstrumentationError, BippyReactDevToolsError, runWithBippyError } from "./errors.js";
+} from "./react-internals/index.js";
 
 import {
   _onActiveListeners,
   BIPPY_INSTRUMENTATION_STRING,
+  createUnsubscribe,
   getRDTHook,
   hasRDTHook,
   isRealReactDevtools,
   onRDTHookReplace,
-  onRendererInject,
 } from "./rdt-hook.js";
+import type { Unsubscribe } from "./rdt-hook.js";
 import {
   getReactWorkTagsForFiber,
   MutationMask,
@@ -30,47 +27,23 @@ import {
   ReactFiberFlags,
   ReactSymbols,
   setReactWorkTagsForFiber,
-} from "./react-internals.js";
-import { toUnsubscribe, type Unsubscribe } from "./unsubscribe.js";
+} from "./react-internals/index.js";
 
-export { getReactWorkTags, ReactSymbols } from "./react-internals.js";
-export type { ReactWorkTagMap, ReactWorkTagVersion } from "./react-internals.js";
 export {
   BippyError,
-  BippyHookInstallationError,
   BippyHookInspectionError,
-  BippyHookListenerError,
   BippyHookRenderError,
-  BippyInstrumentationError,
-  BippyReactBuildError,
-  BippyReactDevToolsError,
   BippySourceMapError,
   BippyUnsupportedHookError,
 } from "./errors.js";
 
-const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null;
-
 const isComponentType = (value: unknown): value is React.ComponentType<unknown> =>
   typeof value === "function";
 
-const getPropertyValue = (value: object, key: PropertyKey): unknown => {
-  let currentValue: object | null = value;
-  while (currentValue) {
-    const descriptor = Object.getOwnPropertyDescriptor(currentValue, key);
-    if (descriptor) {
-      if ("value" in descriptor) return descriptor.value;
-      return descriptor.get?.call(value);
-    }
-    currentValue = Object.getPrototypeOf(currentValue);
-  }
-  return undefined;
-};
-
 const getTypeName = (value: object): string | null => {
-  const displayName = getPropertyValue(value, "displayName");
+  const displayName = "displayName" in value ? value.displayName : null;
   if (typeof displayName === "string" && displayName) return displayName;
-  const name = getPropertyValue(value, "name");
+  const name = "name" in value ? value.name : null;
   return typeof name === "string" && name ? name : null;
 };
 
@@ -78,18 +51,8 @@ interface FiberSelector {
   (node: Fiber): boolean | Promise<boolean | void> | void;
 }
 
-export interface FiberTimings {
-  selfTime: number;
-  totalTime: number;
-}
-
 export interface RenderHandler {
-  <State>(fiber: Fiber, phase: RenderPhase, state?: State): unknown;
-}
-
-interface ValueWrite {
-  path: string[];
-  value: unknown;
+  (fiber: Fiber, phase: RenderPhase): unknown;
 }
 
 /**
@@ -101,9 +64,8 @@ export const isValidElement = (element: unknown): element is React.ReactElement
   typeof element === "object" &&
   element !== null &&
   "$$typeof" in element &&
-  [ReactSymbols.LEGACY_ELEMENT_SYMBOL_STRING, ReactSymbols.ELEMENT_SYMBOL_STRING].includes(
-    String(element.$$typeof),
-  );
+  (String(element.$$typeof) === ReactSymbols.LEGACY_ELEMENT_SYMBOL_STRING ||
+    String(element.$$typeof) === ReactSymbols.ELEMENT_SYMBOL_STRING);
 
 /**
  * Returns `true` if object is a React Fiber.
@@ -118,6 +80,12 @@ export const isValidFiber = (fiber: unknown): fiber is Fiber =>
   "sibling" in fiber &&
   "flags" in fiber;
 
+const isFiberRoot = (fiberRoot: unknown): fiberRoot is FiberRoot =>
+  typeof fiberRoot === "object" &&
+  fiberRoot !== null &&
+  "current" in fiberRoot &&
+  isValidFiber(fiberRoot.current);
+
 /**
  * Returns `true` if fiber is a host fiber. Host fibers are DOM nodes in react-dom, `View` in react-native, etc.
  *
@@ -165,90 +133,6 @@ export const isFiber = (maybeFiber: unknown): maybeFiber is Fiber => {
   return "pendingProps" in maybeFiber && !("containerInfo" in maybeFiber);
 };
 
-/**
- * Traverses up or down a {@link Fiber}'s contexts, return `true` to stop and select the current and previous context value.
- */
-export const traverseContexts = (
-  fiber: Fiber,
-  selector: (
-    nextValue: ContextDependency<unknown> | null | undefined,
-    prevValue: ContextDependency<unknown> | null | undefined,
-  ) => boolean | void,
-): boolean => {
-  try {
-    const nextDependencies = fiber.dependencies;
-    const prevDependencies = fiber.alternate?.dependencies;
-
-    if (!nextDependencies || !prevDependencies) return false;
-    if (
-      typeof nextDependencies !== "object" ||
-      !("firstContext" in nextDependencies) ||
-      typeof prevDependencies !== "object" ||
-      !("firstContext" in prevDependencies)
-    ) {
-      return false;
-    }
-    let nextContext: ContextDependency<unknown> | null | undefined = nextDependencies.firstContext;
-    let prevContext: ContextDependency<unknown> | null | undefined = prevDependencies.firstContext;
-    while (
-      (nextContext && typeof nextContext === "object" && "memoizedValue" in nextContext) ||
-      (prevContext && typeof prevContext === "object" && "memoizedValue" in prevContext)
-    ) {
-      if (selector(nextContext, prevContext) === true) return true;
-
-      nextContext = nextContext?.next;
-      prevContext = prevContext?.next;
-    }
-  } catch {}
-  return false;
-};
-
-/**
- * Traverses up or down a {@link Fiber}'s states, return `true` to stop and select the current and previous state value. This stores both state values and effects.
- */
-export const traverseState = (
-  fiber: Fiber,
-  selector: (
-    nextValue: MemoizedState | null | undefined,
-    prevValue: MemoizedState | null | undefined,
-  ) => boolean | void,
-): boolean => {
-  try {
-    let nextState: MemoizedState | null | undefined = fiber.memoizedState;
-    let prevState: MemoizedState | null | undefined = fiber.alternate?.memoizedState;
-
-    while (nextState || prevState) {
-      if (selector(nextState, prevState) === true) return true;
-
-      nextState = nextState?.next;
-      prevState = prevState?.next;
-    }
-  } catch {}
-  return false;
-};
-
-/**
- * Traverses up or down a {@link Fiber}'s props, return `true` to stop and select the current and previous props value.
- */
-export const traverseProps = (
-  fiber: Fiber,
-  selector: (propName: string, nextValue: unknown, prevValue: unknown) => boolean | void,
-): boolean => {
-  try {
-    const nextProps = fiber.memoizedProps;
-    const prevProps = fiber.alternate?.memoizedProps || {};
-
-    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;
-};
-
 /**
  * Returns `true` if the {@link Fiber} has rendered. Note that this does not mean the fiber has rendered in the current commit, just that it has rendered in the past.
  */
@@ -288,47 +172,6 @@ export const didFiberCommit = (fiber: Fiber): boolean => {
   );
 };
 
-/**
- * Returns all host {@link Fiber}s that have committed and rendered.
- */
-export const getMutatedHostFibers = (fiber: Fiber): Fiber[] => {
-  const mutations: Fiber[] = [];
-  const stack: Fiber[] = [fiber];
-
-  while (stack.length) {
-    const node = stack.pop();
-    if (!node) continue;
-
-    if (isHostFiber(node) && didFiberCommit(node) && didFiberRender(node)) {
-      mutations.push(node);
-    }
-
-    if (node.child) stack.push(node.child);
-    if (node.sibling) stack.push(node.sibling);
-  }
-
-  return mutations;
-};
-
-/**
- * Returns the stack of {@link Fiber}s from the current fiber to the root fiber.
- *
- * @example
- * ```ts
- * [fiber, fiber.return, fiber.return.return, ...]
- * ```
- */
-export const getFiberStack = (fiber: Fiber): Fiber[] => {
-  const stack: Fiber[] = [];
-  let currentFiber = fiber;
-  while (currentFiber.return) {
-    stack.push(currentFiber);
-    const parentFiber = currentFiber.return;
-    currentFiber = parentFiber;
-  }
-  return stack;
-};
-
 /**
  * Returns `true` if the {@link Fiber} should be filtered out during reconciliation.
  */
@@ -377,47 +220,6 @@ const shouldFilterFiber = (fiber: Fiber): boolean => {
   }
 };
 
-/**
- * Returns the nearest host {@link Fiber} to the current {@link Fiber}.
- */
-export const getNearestHostFiber = (fiber: Fiber, ascending = false): Fiber | null => {
-  let hostFiber = traverseFiber(fiber, isHostFiber, ascending);
-  if (!hostFiber) {
-    hostFiber = traverseFiber(fiber, isHostFiber, !ascending);
-  }
-  return hostFiber;
-};
-
-/**
- * Returns all host {@link Fiber}s in the tree that are associated with the current {@link Fiber}.
- */
-export const getNearestHostFibers = (fiber: Fiber): Fiber[] => {
-  const hostFibers: Fiber[] = [];
-  const stack: Fiber[] = [];
-
-  if (isHostFiber(fiber)) {
-    hostFibers.push(fiber);
-  } else if (fiber.child) {
-    stack.push(fiber.child);
-  }
-
-  while (stack.length) {
-    const currentNode = stack.pop();
-    if (!currentNode) break;
-    if (isHostFiber(currentNode)) {
-      hostFibers.push(currentNode);
-    } else if (currentNode.child) {
-      stack.push(currentNode.child);
-    }
-
-    if (currentNode.sibling) {
-      stack.push(currentNode.sibling);
-    }
-  }
-
-  return hostFibers;
-};
-
 /**
  * Traverses up or down a {@link Fiber}, return `true` to stop and select a node.
  */
@@ -431,6 +233,11 @@ export function traverseFiber(
   selector: (node: Fiber) => Promise<boolean | void>,
   ascending?: boolean,
 ): Promise<Fiber | null>;
+export function traverseFiber(
+  fiber: Fiber | null,
+  selector: FiberSelector,
+  ascending?: boolean,
+): Fiber | null | Promise<Fiber | null>;
 export function traverseFiber(
   fiber: Fiber | null,
   selector: FiberSelector,
@@ -438,89 +245,47 @@ export function traverseFiber(
 ): Fiber | null | Promise<Fiber | null> {
   if (!fiber) return null;
 
-  const firstResult = selector(fiber);
-  if (firstResult instanceof Promise) {
-    return (async () => {
-      if ((await firstResult) === true) return fiber;
-
-      let child = ascending ? fiber.return : fiber.child;
-      while (child) {
-        const match = await traverseFiberAsync(child, selector, ascending);
-        if (match) return match;
-        child = ascending ? null : child.sibling;
-      }
-      return null;
-    })();
+  const selection = selector(fiber);
+  if (isPromiseLike<boolean | void>(selection)) {
+    return Promise.resolve(selection).then((didSelectFiber) =>
+      didSelectFiber === true ? fiber : traverseFiberChildren(fiber, selector, ascending),
+    );
   }
+  if (selection === true) return fiber;
 
-  if (firstResult === true) return fiber;
-
-  let child = ascending ? fiber.return : fiber.child;
-  while (child) {
-    const match = traverseFiberSync(child, selector, ascending);
-    if (match) return match;
-    child = ascending ? null : child.sibling;
-  }
-  return null;
+  return traverseFiberChildren(fiber, selector, ascending);
 }
 
-const traverseFiberSync = (
-  fiber: Fiber | null,
-  selector: FiberSelector,
-  ascending = false,
-): Fiber | null => {
-  if (!fiber) return null;
-  const selection = selector(fiber);
-  if (selection instanceof Promise) return null;
-  if (selection === true) return fiber;
-
-  let child = ascending ? fiber.return : fiber.child;
-  while (child) {
-    const match = traverseFiberSync(child, selector, ascending);
-    if (match) return match;
+const isPromiseLike = <Result>(value: unknown): value is PromiseLike<Result> =>
+  (typeof value === "object" || typeof value === "function") &&
+  value !== null &&
+  "then" in value &&
+  typeof value.then === "function";
 
-    child = ascending ? null : child.sibling;
-  }
-  return null;
+const traverseFiberChildren = (
+  fiber: Fiber,
+  selector: FiberSelector,
+  ascending: boolean,
+): Fiber | null | Promise<Fiber | null> => {
+  const firstChild = ascending ? fiber.return : fiber.child;
+  return traverseFiberSiblings(firstChild, selector, ascending);
 };
 
-const traverseFiberAsync = async (
+const traverseFiberSiblings = (
   fiber: Fiber | null,
   selector: FiberSelector,
-  ascending = false,
-): Promise<Fiber | null> => {
+  ascending: boolean,
+): Fiber | null | Promise<Fiber | null> => {
   if (!fiber) return null;
-  if ((await selector(fiber)) === true) return fiber;
-
-  let child = ascending ? fiber.return : fiber.child;
-  while (child) {
-    const match = await traverseFiberAsync(child, selector, ascending);
-    if (match) return match;
 
-    child = ascending ? null : child.sibling;
+  const nextSibling = ascending ? null : fiber.sibling;
+  const match = traverseFiber(fiber, selector, ascending);
+  if (isPromiseLike<Fiber | null>(match)) {
+    return Promise.resolve(match).then(
+      (resolvedMatch) => resolvedMatch ?? traverseFiberSiblings(nextSibling, selector, ascending),
+    );
   }
-  return null;
-};
-
-/**
- * Returns the timings of the {@link Fiber}.
- *
- * @example
- * ```ts
- * const { selfTime, totalTime } = getTimings(fiber);
- * console.log(selfTime, totalTime);
- * ```
- */
-export const getTimings = (fiber?: Fiber | null): FiberTimings => {
-  const totalTime = fiber?.actualDuration ?? 0;
-  let selfTime = totalTime;
-  // TODO: calculate a DOM time, which is just host component summed up
-  let child = fiber?.child ?? null;
-  while (totalTime > 0 && child !== null) {
-    selfTime -= child.actualDuration ?? 0;
-    child = child.sibling;
-  }
-  return { selfTime, totalTime };
+  return match ?? traverseFiberSiblings(nextSibling, selector, ascending);
 };
 
 /**
@@ -535,8 +300,8 @@ export const hasMemoCache = (fiber: Fiber): boolean => {
  */
 export const getType = (type: unknown): null | React.ComponentType<unknown> => {
   if (isComponentType(type)) return type;
-  if (!isObjectRecord(type)) return null;
-  return getType(type.type ?? type.render);
+  if (typeof type !== "object" || type === null) return null;
+  return getType(Reflect.get(type, "type") ?? Reflect.get(type, "render"));
 };
 
 /**
@@ -576,6 +341,7 @@ export const isInstrumentationActive = (): boolean => {
 };
 
 export const _fiberRoots = new Set<FiberRoot>();
+const rootRendererIds = new WeakMap<FiberRoot, number>();
 
 /**
  * Returns the latest fiber (since it may be double-buffered).
@@ -588,13 +354,32 @@ export const getLatestFiber = (fiber: Fiber): Fiber => {
   }
   for (const root of _fiberRoots) {
     const latestFiber = traverseFiber(root.current, (innerFiber) => {
-      if (innerFiber === fiber) return true;
+      if (innerFiber === fiber || innerFiber === alternate) return true;
     });
     if (latestFiber) return latestFiber;
   }
   return fiber;
 };
 
+/**
+ * Returns the renderer that owns the {@link Fiber}.
+ */
+export const getRenderer = (fiber: Fiber): ReactRenderer | null => {
+  if (!hasRDTHook()) return null;
+
+  let rootFiber = fiber;
+  while (rootFiber.return) {
+    rootFiber = rootFiber.return;
+  }
+
+  const fiberRoot = rootFiber.stateNode;
+  if (!isFiberRoot(fiberRoot)) return null;
+
+  const rendererID = rootRendererIds.get(fiberRoot);
+  if (rendererID === undefined) return null;
+  return getRDTHook().renderers.get(rendererID) ?? null;
+};
+
 export type RenderPhase = "mount" | "unmount" | "update";
 
 let nextFiberId = 0;
@@ -602,6 +387,9 @@ const fiberIdMap = new WeakMap<Fiber, number>();
 
 export const setFiberId = (fiber: Fiber, fiberId: number = nextFiberId++): void => {
   fiberIdMap.set(fiber, fiberId);
+  if (Number.isSafeInteger(fiberId) && fiberId >= nextFiberId) {
+    nextFiberId = fiberId + 1;
+  }
 };
 
 export const getFiberId = (fiber: Fiber): number => {
@@ -624,9 +412,7 @@ const mountFiberRecursively = (
   let fiber: Fiber | null = firstChild;
 
   while (fiber !== null) {
-    if (!fiberIdMap.has(fiber)) {
-      getFiberId(fiber);
-    }
+    getFiberId(fiber);
     const shouldIncludeInTree = !shouldFilterFiber(fiber);
     if (shouldIncludeInTree && didFiberRender(fiber)) {
       onRender(fiber, "mount");
@@ -662,16 +448,11 @@ const mountFiberRecursively = (
 const updateFiberRecursively = (
   onRender: RenderHandler,
   nextFiber: Fiber,
-  prevFiber: Fiber,
-  parentFiber: Fiber | null,
+  prevFiber: Fiber | null,
 ): void => {
-  if (!fiberIdMap.has(nextFiber)) {
-    getFiberId(nextFiber);
-  }
+  getFiberId(nextFiber);
   if (!prevFiber) return;
-  if (!fiberIdMap.has(prevFiber)) {
-    getFiberId(prevFiber);
-  }
+  getFiberId(prevFiber);
 
   const isSuspense = nextFiber.tag === getReactWorkTagsForFiber(nextFiber).SuspenseComponent;
 
@@ -702,7 +483,7 @@ const updateFiberRecursively = (
     const prevFallbackChildSet = prevFiber.child?.sibling ?? null;
 
     if (nextFallbackChildSet !== null && prevFallbackChildSet !== null) {
-      updateFiberRecursively(onRender, nextFallbackChildSet, prevFallbackChildSet, nextFiber);
+      updateFiberRecursively(onRender, nextFallbackChildSet, prevFallbackChildSet);
     }
   } else if (prevDidTimeout && !nextDidTimeOut) {
     // Fallback -> Primary:
@@ -741,14 +522,7 @@ const updateFiberRecursively = (
       // Schedule updates and mounts depending on whether alternates exist.
       // We don't track deletions here because they are reported separately.
       if (nextChild.alternate) {
-        const prevChild = nextChild.alternate;
-
-        updateFiberRecursively(
-          onRender,
-          nextChild,
-          prevChild,
-          shouldIncludeInTree ? nextFiber : parentFiber,
-        );
+        updateFiberRecursively(onRender, nextChild, nextChild.alternate);
       } else {
         mountFiberRecursively(onRender, nextChild, false);
       }
@@ -794,11 +568,9 @@ const unmountFiberChildrenRecursively = (onRender: RenderHandler, fiber: Fiber):
   }
 };
 
-let commitId = 0;
 const rootInstanceMap = new WeakMap<
-  FiberRoot,
+  Fiber | FiberRoot,
   {
-    id: number;
     prevFiber: Fiber | null;
   }
 >();
@@ -810,23 +582,23 @@ const rootInstanceMap = new WeakMap<
  *   console.log(phase)
  * })
  */
-export const traverseRenderedFibers = (root: FiberRoot, onRender: RenderHandler): void => {
+export const traverseRenderedFibers = (root: Fiber | FiberRoot, onRender: RenderHandler): void => {
   const fiber = "current" in root ? root.current : root;
 
   let rootInstance = rootInstanceMap.get(root);
 
   if (!rootInstance) {
-    rootInstance = { id: commitId++, prevFiber: null };
+    rootInstance = { prevFiber: null };
     rootInstanceMap.set(root, rootInstance);
   }
 
   const { prevFiber } = rootInstance;
-  // if fiberRoot don't have current instance, means it's been unmounted
   if (!fiber) {
-    unmountFiber(onRender, fiber);
+    if (prevFiber) {
+      unmountFiber(onRender, prevFiber);
+    }
   } else if (prevFiber !== null) {
     const wasMounted =
-      prevFiber &&
       prevFiber.memoizedState !== null &&
       prevFiber.memoizedState.element !== null &&
       prevFiber.memoizedState.element !== undefined &&
@@ -842,7 +614,7 @@ export const traverseRenderedFibers = (root: FiberRoot, onRender: RenderHandler)
     if (!wasMounted && isMounted) {
       mountFiberRecursively(onRender, fiber, false);
     } else if (wasMounted && isMounted) {
-      updateFiberRecursively(onRender, fiber, fiber.alternate, null);
+      updateFiberRecursively(onRender, fiber, fiber.alternate);
     } else if (wasMounted && !isMounted) {
       unmountFiber(onRender, fiber);
     }
@@ -853,164 +625,6 @@ export const traverseRenderedFibers = (root: FiberRoot, onRender: RenderHandler)
   rootInstance.prevFiber = fiber;
 };
 
-const overrideRenderers = new Set<ReactRenderer>();
-let areOverrideRenderersWired = false;
-
-const wireOverrideRenderers = (): void => {
-  if (!hasRDTHook()) return;
-  const rdtHook = getRDTHook();
-
-  setHookEventDispatchers(rdtHook);
-  for (const renderer of rdtHook.renderers.values()) {
-    overrideRenderers.add(renderer);
-  }
-  if (areOverrideRenderersWired) return;
-  areOverrideRenderersWired = true;
-  onRendererInject((renderer) => {
-    overrideRenderers.add(renderer);
-  });
-};
-
-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;
-};
-
-const resolveOverrideRenderers = (fiber: Fiber): ReactRenderer[] => {
-  wireOverrideRenderers();
-  const rootRenderer = getRootRenderer(fiber);
-  if (rootRenderer) return [rootRenderer];
-  return Array.from(overrideRenderers);
-};
-
-const applyPropsOverride = (
-  renderers: ReactRenderer[],
-  fiber: Fiber,
-  path: string[],
-  value: unknown,
-): void => {
-  for (const renderer of renderers) {
-    try {
-      renderer.overrideProps?.(fiber, path, value);
-    } catch {}
-  }
-};
-
-const getHookStateDispatch = (
-  fiber: Fiber,
-  hookIndex: number,
-): ((value: unknown) => void) | null => {
-  let hookState = fiber.memoizedState;
-  for (let currentHookIndex = 0; currentHookIndex < hookIndex; currentHookIndex++) {
-    if (!hookState?.next) return null;
-    hookState = hookState.next;
-  }
-  const queue = hookState?.queue;
-  if (!isPOJO(queue)) return null;
-  const dispatch = queue.dispatch;
-  return typeof dispatch === "function" ? (value) => dispatch(value) : null;
-};
-
-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> => {
-  return (
-    Object.prototype.toString.call(maybePOJO) === "[object Object]" &&
-    (Object.getPrototypeOf(maybePOJO) === Object.prototype ||
-      Object.getPrototypeOf(maybePOJO) === null)
-  );
-};
-
-const buildPathsFromValue = (
-  maybePOJO: Record<string, unknown>,
-  basePath: string[] = [],
-): ValueWrite[] => {
-  if (!isPOJO(maybePOJO)) {
-    return [{ path: basePath, value: maybePOJO }];
-  }
-
-  const paths: ValueWrite[] = [];
-
-  for (const key in maybePOJO) {
-    const value = maybePOJO[key];
-    const path = basePath.concat(key);
-
-    if (isPOJO(value)) {
-      paths.push(...buildPathsFromValue(value, path));
-    } else {
-      paths.push({ path, value });
-    }
-  }
-
-  return paths;
-};
-
-const buildValueWrites = (partialValue: unknown): ValueWrite[] =>
-  isPOJO(partialValue) ? buildPathsFromValue(partialValue) : [{ path: [], value: partialValue }];
-
-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: unknown) => {
-  const renderers = resolveOverrideRenderers(fiber).filter((renderer) =>
-    Boolean(renderer.overrideHookState),
-  );
-  const writes = buildValueWrites(partialValue);
-
-  if (renderers.length > 0) {
-    for (const renderer of renderers) {
-      for (const { path, value } of writes) {
-        try {
-          renderer.overrideHookState?.(fiber, id, path, value);
-        } catch {}
-      }
-    }
-    return;
-  }
-
-  // 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 {}
-};
-
-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);
-    }
-  }
-};
-
 export interface InstrumentationOptions {
   name?: string;
   onActive?: () => unknown;
@@ -1031,19 +645,6 @@ interface InstrumentationSubscription {
 
 const instrumentationSubscriptions = new Set<InstrumentationSubscription>();
 
-const runInstrumentationCallback = (
-  instrumentationName: string,
-  callbackName: string,
-  callback: () => unknown,
-): void =>
-  runWithBippyError(
-    callback,
-    (cause) => new BippyInstrumentationError(instrumentationName, callbackName, cause),
-  );
-
-const runReactDevToolsCallback = (callbackName: string, callback: () => unknown): void =>
-  runWithBippyError(callback, (cause) => new BippyReactDevToolsError(callbackName, cause));
-
 interface HookDispatchers {
   onCommitFiberRoot: ReactDevToolsGlobalHook["onCommitFiberRoot"];
   onCommitFiberUnmount: ReactDevToolsGlobalHook["onCommitFiberUnmount"];
@@ -1054,8 +655,6 @@ interface HookDispatchers {
 const hookDispatchers = new WeakMap<ReactDevToolsGlobalHook, Partial<HookDispatchers>>();
 let didSubscribeToHookReplacements = false;
 
-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
@@ -1077,9 +676,7 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
       didError,
     ) => {
       if (prevOnCommitFiberRoot) {
-        runReactDevToolsCallback("onCommitFiberRoot", () =>
-          prevOnCommitFiberRoot(rendererID, root, priority, didError),
-        );
+        prevOnCommitFiberRoot.call(rdtHook, rendererID, root, priority, didError);
       }
       if (hookDispatchers.get(rdtHook)?.onCommitFiberRoot !== dispatchCommitFiberRoot) return;
       setReactWorkTagsForFiber(root.current, rdtHook.renderers.get(rendererID));
@@ -1097,11 +694,7 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
       }
       for (const { options } of instrumentationSubscriptions) {
         if (options.onCommitFiberRoot) {
-          runInstrumentationCallback(
-            options.name ?? BIPPY_INSTRUMENTATION_STRING,
-            "onCommitFiberRoot",
-            () => options.onCommitFiberRoot?.(rendererID, root, priority, didError),
-          );
+          options.onCommitFiberRoot(rendererID, root, priority, didError);
         }
       }
     };
@@ -1120,20 +713,14 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
     ) => {
       setReactWorkTagsForFiber(fiber, rdtHook.renderers.get(rendererID));
       if (prevOnCommitFiberUnmount) {
-        runReactDevToolsCallback("onCommitFiberUnmount", () =>
-          prevOnCommitFiberUnmount(rendererID, fiber),
-        );
+        prevOnCommitFiberUnmount.call(rdtHook, rendererID, fiber);
       }
       if (hookDispatchers.get(rdtHook)?.onCommitFiberUnmount !== dispatchCommitFiberUnmount) {
         return;
       }
       for (const { options } of instrumentationSubscriptions) {
         if (options.onCommitFiberUnmount) {
-          runInstrumentationCallback(
-            options.name ?? BIPPY_INSTRUMENTATION_STRING,
-            "onCommitFiberUnmount",
-            () => options.onCommitFiberUnmount?.(rendererID, fiber),
-          );
+          options.onCommitFiberUnmount(rendererID, fiber);
         }
       }
     };
@@ -1151,20 +738,14 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
       root,
     ) => {
       if (prevOnPostCommitFiberRoot) {
-        runReactDevToolsCallback("onPostCommitFiberRoot", () =>
-          prevOnPostCommitFiberRoot(rendererID, root),
-        );
+        prevOnPostCommitFiberRoot.call(rdtHook, rendererID, root);
       }
       if (hookDispatchers.get(rdtHook)?.onPostCommitFiberRoot !== dispatchPostCommitFiberRoot) {
         return;
       }
       for (const { options } of instrumentationSubscriptions) {
         if (options.onPostCommitFiberRoot) {
-          runInstrumentationCallback(
-            options.name ?? BIPPY_INSTRUMENTATION_STRING,
-            "onPostCommitFiberRoot",
-            () => options.onPostCommitFiberRoot?.(rendererID, root),
-          );
+          options.onPostCommitFiberRoot(rendererID, root);
         }
       }
     };
@@ -1183,18 +764,12 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
       children,
     ) => {
       if (prevOnScheduleFiberRoot) {
-        runReactDevToolsCallback("onScheduleFiberRoot", () =>
-          prevOnScheduleFiberRoot(rendererID, root, children),
-        );
+        prevOnScheduleFiberRoot.call(rdtHook, rendererID, root, children);
       }
       if (hookDispatchers.get(rdtHook)?.onScheduleFiberRoot !== dispatchScheduleFiberRoot) return;
       for (const { options } of instrumentationSubscriptions) {
         if (options.onScheduleFiberRoot) {
-          runInstrumentationCallback(
-            options.name ?? BIPPY_INSTRUMENTATION_STRING,
-            "onScheduleFiberRoot",
-            () => options.onScheduleFiberRoot?.(rendererID, root, children),
-          );
+          options.onScheduleFiberRoot(rendererID, root, children);
         }
       }
     };
@@ -1203,13 +778,24 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
   }
 };
 
+const wireHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
+  if (!didSubscribeToHookReplacements) {
+    onRDTHookReplace(setHookEventDispatchers);
+    didSubscribeToHookReplacements = true;
+  }
+  setHookEventDispatchers(rdtHook);
+};
+
+if (hasRDTHook()) {
+  wireHookEventDispatchers(getRDTHook());
+}
+
 /**
  * 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`.
+ * The unsubscribe function can also be disposed through `using`.
  * @example
  * const unsubscribe = instrument({
  *   onActive() {
@@ -1222,30 +808,15 @@ const setHookEventDispatchers = (rdtHook: ReactDevToolsGlobalHook): void => {
  * unsubscribe();
  */
 export const instrument = (options: InstrumentationOptions): Unsubscribe => {
-  const onActiveListener = options.onActive;
-  const onActive = onActiveListener
-    ? () =>
-        runInstrumentationCallback(
-          options.name ?? BIPPY_INSTRUMENTATION_STRING,
-          "onActive",
-          onActiveListener,
-        )
-    : undefined;
-  const rdtHook = getRDTHook(onActive);
-
-  if (!didSubscribeToHookReplacements) {
-    onRDTHookReplace(setHookEventDispatchers);
-    didSubscribeToHookReplacements = true;
-  }
-
+  const rdtHook = getRDTHook(options.onActive);
   rdtHook._instrumentationSource = options.name ?? BIPPY_INSTRUMENTATION_STRING;
 
-  setHookEventDispatchers(rdtHook);
+  wireHookEventDispatchers(rdtHook);
   const subscription: InstrumentationSubscription = { options };
   instrumentationSubscriptions.add(subscription);
 
-  return toUnsubscribe(() => {
-    if (onActive) _onActiveListeners.delete(onActive);
+  return createUnsubscribe(() => {
+    if (options.onActive) _onActiveListeners.delete(options.onActive);
     instrumentationSubscriptions.delete(subscription);
   });
 };
@@ -1258,33 +829,38 @@ const isFiberPropertyKey = (key: string): boolean =>
   key.startsWith("__reactInternalInstance$") ||
   key.startsWith("__reactFiber");
 
-const getLegacyRootFiber = (hostInstance: Record<string, unknown>): Fiber | null => {
-  const reactRootContainer = hostInstance._reactRootContainer;
-  if (!isObjectRecord(reactRootContainer)) return null;
-  const internalRoot = reactRootContainer._internalRoot;
-  if (!isObjectRecord(internalRoot)) return null;
-  const current = internalRoot.current;
-  if (!isObjectRecord(current)) return null;
-  const child = current.child;
+const getLegacyRootFiber = (hostInstance: object): Fiber | null => {
+  const reactRootContainer = Reflect.get(hostInstance, "_reactRootContainer");
+  if (typeof reactRootContainer !== "object" || reactRootContainer === null) return null;
+  const internalRoot = Reflect.get(reactRootContainer, "_internalRoot");
+  if (typeof internalRoot !== "object" || internalRoot === null) return null;
+  const current = Reflect.get(internalRoot, "current");
+  if (typeof current !== "object" || current === null) return null;
+  const child = Reflect.get(current, "child");
   return isValidFiber(child) ? child : null;
 };
 
-const getInternalInstanceHandle = (hostInstance: Record<string, unknown>): Fiber | null => {
+const getInternalInstanceHandle = (hostInstance: object): Fiber | null => {
   const internalInstanceHandle =
-    hostInstance.__internalInstanceHandle ?? hostInstance._internalInstanceHandle;
+    Reflect.get(hostInstance, "__internalInstanceHandle") ??
+    Reflect.get(hostInstance, "_internalInstanceHandle");
   return isValidFiber(internalInstanceHandle) ? internalInstanceHandle : null;
 };
 
 const getPublicHostInstance = (stateNode: unknown): unknown => {
-  if (!isObjectRecord(stateNode)) return stateNode;
-  const canonical = stateNode.canonical;
-  if (isObjectRecord(canonical) && isObjectRecord(canonical.publicInstance)) {
-    return canonical.publicInstance;
+  if (typeof stateNode !== "object" || stateNode === null) return stateNode;
+  const canonical = Reflect.get(stateNode, "canonical");
+  if (typeof canonical === "object" && canonical !== null) {
+    const publicInstance = Reflect.get(canonical, "publicInstance");
+    if (typeof publicInstance === "object" && publicInstance !== null) {
+      return publicInstance;
+    }
   }
-  return typeof stateNode._nativeTag === "number" ? stateNode._nativeTag : stateNode;
+  const nativeTag = Reflect.get(stateNode, "_nativeTag");
+  return typeof nativeTag === "number" ? nativeTag : stateNode;
 };
 
-export const getFiberFromHostInstance = <T>(hostInstance: T): Fiber | null => {
+export const getFiber = <T>(hostInstance: T): Fiber | null => {
   const rdtHook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
   if (rdtHook?.renderers) {
     for (const renderer of rdtHook.renderers.values()) {
@@ -1295,7 +871,7 @@ export const getFiberFromHostInstance = <T>(hostInstance: T): Fiber | null => {
     }
   }
 
-  if (isObjectRecord(hostInstance)) {
+  if (typeof hostInstance === "object" && hostInstance !== null) {
     const legacyRootFiber = getLegacyRootFiber(hostInstance);
     if (legacyRootFiber) return legacyRootFiber;
 
@@ -1303,14 +879,14 @@ export const getFiberFromHostInstance = <T>(hostInstance: T): Fiber | null => {
     if (internalInstanceHandle) return internalInstanceHandle;
 
     for (const knownKey of knownFiberPropertyKeys) {
-      const fiber = hostInstance[knownKey];
+      const fiber = Reflect.get(hostInstance, knownKey);
       if (isValidFiber(fiber)) return fiber;
     }
 
     for (const key of Object.keys(hostInstance)) {
       if (isFiberPropertyKey(key)) {
         knownFiberPropertyKeys.add(key);
-        const fiber = hostInstance[key];
+        const fiber = Reflect.get(hostInstance, key);
         if (isValidFiber(fiber)) return fiber;
       }
     }
@@ -1334,6 +910,8 @@ export const getFiberFromHostInstance = <T>(hostInstance: T): Fiber | null => {
   return null;
 };
 
+export const getFiberFromHostInstance = getFiber;
+
 export {
   BIPPY_INSTRUMENTATION_STRING,
   _onActiveListeners,
@@ -1344,8 +922,7 @@ export {
   isRealReactDevtools,
   onRendererInject,
   patchRDTHook,
-  safelyInstallRDTHook,
   version,
 } from "./rdt-hook.js";
-export * from "./unsubscribe.js";
-export type * from "./types.js";
+export type { Unsubscribe } from "./rdt-hook.js";
+export * from "./react-internals/index.js";