bippy 0.7.2 → 0.7.3-dev.04de4f7

package/src/rdt-hook.ts

@@ -1,6 +1,7 @@
 // This module must load before React so renderers can inject into the hook.
 
-import type { ReactDevToolsGlobalHook, ReactRenderer } from "./react-internals/index.js";
+import { callListener } from "./call-listener.js";
+import type { FiberRoot, ReactDevToolsGlobalHook, ReactRenderer } from "./react-internals/index.js";
 
 export interface Unsubscribe extends Disposable {
   (): void;
@@ -14,8 +15,21 @@ interface RendererInjectListener {
   (renderer: ReactRenderer): void;
 }
 
+interface RendererInjectSubscription {
+  listener: RendererInjectListener;
+  target: ReactDevToolsTarget;
+}
+
 interface RDTHookReplaceListener {
-  (rdtHook: ReactDevToolsGlobalHook): void;
+  (rdtHook: ReactDevToolsGlobalHook, target: ReactDevToolsTarget): void;
+}
+
+interface RDTHookReplaceSubscription {
+  listener: RDTHookReplaceListener;
+}
+
+export interface ReactDevToolsTarget {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__?: ReactDevToolsGlobalHook;
 }
 
 export const version = process.env.VERSION;
@@ -25,10 +39,23 @@ const objectDefineProperty = Object.defineProperty;
 
 const noOp = (): void => {};
 
+const getTargetHook = (target: ReactDevToolsTarget): ReactDevToolsGlobalHook | undefined =>
+  target.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+
 export const createUnsubscribe = (unsubscribe: () => void): Unsubscribe =>
   Object.assign(unsubscribe, { [Symbol.dispose]: unsubscribe });
 
+export const isFiberRootUnmounted = (fiberRoot: FiberRoot): boolean => {
+  const rootState = fiberRoot.current.memoizedState;
+  return (
+    rootState === null ||
+    (rootState !== undefined && (rootState.element === null || rootState.element === undefined))
+  );
+};
+
 const checkDCE = (functionToCheck: unknown): void => {
+  // HACK: Node loads React's unbundled entrypoints, where development guards are intentionally not eliminated.
+  if (typeof process !== "undefined" && process.versions?.node) return;
   try {
     const code = Function.prototype.toString.call(functionToCheck);
     if (code.indexOf("^_^") > -1) {
@@ -47,7 +74,7 @@ const checkDCE = (functionToCheck: unknown): void => {
 export const isRealReactDevtools = (
   rdtHook: ReactDevToolsGlobalHook | undefined | null = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__,
 ): boolean => {
-  return Boolean(rdtHook && "getFiberRoots" in rdtHook);
+  return Boolean(rdtHook && "getFiberRoots" in rdtHook && rdtHook._isBippyHook !== true);
 };
 
 // HACK: react-refresh's inject wrapper is the only stock hook whose parameter is named
@@ -69,65 +96,90 @@ export const _onActiveListeners = new Set<ActiveListener>();
 
 export const _renderers = new Set<ReactRenderer>();
 
-const rendererInjectListeners = new Set<RendererInjectListener>();
-const rdtHookReplaceListeners = new Set<RDTHookReplaceListener>();
-// HACK: Hook replacement can leave an old inject wrapper in the call chain, so notifications must be deduplicated.
-const notifiedRenderers = new WeakSet<ReactRenderer>();
-const notifyingInjectByHook = new WeakMap<
-  ReactDevToolsGlobalHook,
-  ReactDevToolsGlobalHook["inject"]
->();
-
-const notifyActiveListeners = (): void => {
-  for (const listener of _onActiveListeners) {
-    listener();
+const activeListenerTargets = new WeakMap<ActiveListener, Set<ReactDevToolsTarget>>();
+const rendererInjectSubscriptions = new Set<RendererInjectSubscription>();
+const rdtHookReplaceSubscriptions = new Set<RDTHookReplaceSubscription>();
+const notifiedRenderersByTarget = new WeakMap<ReactDevToolsTarget, WeakSet<ReactRenderer>>();
+
+const addActiveListener = (listener: ActiveListener, target: ReactDevToolsTarget): void => {
+  _onActiveListeners.add(listener);
+  const targets = activeListenerTargets.get(listener) ?? new Set<ReactDevToolsTarget>();
+  targets.add(target);
+  activeListenerTargets.set(listener, targets);
+};
+
+export const removeActiveListener = (
+  listener: ActiveListener,
+  target: ReactDevToolsTarget,
+): void => {
+  const targets = activeListenerTargets.get(listener);
+  targets?.delete(target);
+  if (!targets || targets.size === 0) {
+    activeListenerTargets.delete(listener);
+    _onActiveListeners.delete(listener);
   }
 };
 
-const notifyRendererInjectListeners = (renderer: ReactRenderer): void => {
-  for (const listener of rendererInjectListeners) {
-    listener(renderer);
+const notifyActiveListeners = (
+  target: ReactDevToolsTarget,
+  pendingListeners = [..._onActiveListeners],
+): void => {
+  for (const listener of pendingListeners) {
+    if (activeListenerTargets.get(listener)?.has(target)) callListener(listener, undefined);
   }
 };
 
-const notifyRDTHookReplaceListeners = (rdtHook: ReactDevToolsGlobalHook): void => {
-  for (const listener of rdtHookReplaceListeners) {
-    listener(rdtHook);
+const notifyRendererInjectListeners = (
+  target: ReactDevToolsTarget,
+  renderer: ReactRenderer,
+): void => {
+  const subscriptionSnapshot = [...rendererInjectSubscriptions];
+  for (const subscription of subscriptionSnapshot) {
+    if (rendererInjectSubscriptions.has(subscription) && subscription.target === target) {
+      callListener(subscription.listener, subscription, renderer);
+    }
   }
 };
 
-const setRendererInjectDispatcher = (rdtHook: ReactDevToolsGlobalHook): void => {
-  if (rdtHook.inject === notifyingInjectByHook.get(rdtHook)) return;
-  const previousInject = rdtHook.inject;
-  const nextInject = (renderer: ReactRenderer) => {
-    const rendererId = previousInject.call(rdtHook, renderer);
-    if (!notifiedRenderers.has(renderer)) {
-      notifiedRenderers.add(renderer);
-      notifyRendererInjectListeners(renderer);
+const notifyRDTHookReplaceListeners = (
+  rdtHook: ReactDevToolsGlobalHook,
+  target: ReactDevToolsTarget,
+): void => {
+  const subscriptionSnapshot = [...rdtHookReplaceSubscriptions];
+  for (const subscription of subscriptionSnapshot) {
+    if (rdtHookReplaceSubscriptions.has(subscription)) {
+      callListener(subscription.listener, undefined, rdtHook, target);
     }
-    return rendererId;
-  };
-  rdtHook.inject = nextInject;
-  notifyingInjectByHook.set(rdtHook, nextInject);
+  }
 };
 
-export const onRendererInject = (listener: RendererInjectListener): Unsubscribe => {
-  setRendererInjectDispatcher(getRDTHook());
-  rendererInjectListeners.add(listener);
+export const onRendererInject = (
+  listener: RendererInjectListener,
+  target: ReactDevToolsTarget = globalThis,
+): Unsubscribe => {
+  getRDTHook(undefined, target);
+  const subscription = { listener, target };
+  rendererInjectSubscriptions.add(subscription);
   return createUnsubscribe(() => {
-    rendererInjectListeners.delete(listener);
+    rendererInjectSubscriptions.delete(subscription);
   });
 };
 
 export const onRDTHookReplace = (listener: RDTHookReplaceListener): Unsubscribe => {
-  rdtHookReplaceListeners.add(listener);
+  const subscription = { listener };
+  rdtHookReplaceSubscriptions.add(subscription);
   return createUnsubscribe(() => {
-    rdtHookReplaceListeners.delete(listener);
+    rdtHookReplaceSubscriptions.delete(subscription);
   });
 };
 
+// A Map built in another realm (an iframe target) fails instanceof, so replacing it
+// would discard that realm's renderer registry. Object.prototype.toString is realm-agnostic.
+export const isRendererMap = (value: unknown): value is Map<number, ReactRenderer> =>
+  Object.prototype.toString.call(value) === "[object Map]";
+
 const getRendererMap = (rdtHook: ReactDevToolsGlobalHook): Map<number, ReactRenderer> => {
-  if (!(rdtHook.renderers instanceof Map)) {
+  if (!isRendererMap(rdtHook.renderers)) {
     rdtHook.renderers = new Map();
   }
   return rdtHook.renderers;
@@ -135,6 +187,7 @@ const getRendererMap = (rdtHook: ReactDevToolsGlobalHook): Map<number, ReactRend
 
 const trackInjectedRenderer = (
   rdtHook: ReactDevToolsGlobalHook,
+  target: ReactDevToolsTarget,
   renderers: Map<number, ReactRenderer>,
   rendererId: number,
   renderer: ReactRenderer,
@@ -143,28 +196,47 @@ const trackInjectedRenderer = (
   _renderers.add(renderer);
   if (!rdtHook._instrumentationIsActive) {
     rdtHook._instrumentationIsActive = true;
-    notifyActiveListeners();
+    notifyActiveListeners(target);
   }
+  const notifiedRenderers = notifiedRenderersByTarget.get(target) ?? new WeakSet<ReactRenderer>();
+  notifiedRenderersByTarget.set(target, notifiedRenderers);
+  if (notifiedRenderers.has(renderer)) return;
+  notifiedRenderers.add(renderer);
+  notifyRendererInjectListeners(target, renderer);
 };
 
-export const installRDTHook = (onActive?: ActiveListener): ReactDevToolsGlobalHook => {
-  if (onActive) {
-    _onActiveListeners.add(onActive);
-  }
+export const installRDTHook = (
+  onActive?: ActiveListener,
+  target: ReactDevToolsTarget = globalThis,
+): ReactDevToolsGlobalHook => {
+  if (onActive) addActiveListener(onActive, target);
   const renderers = new Map<number, ReactRenderer>();
+  const fiberRoots = new Map<number, Set<FiberRoot>>();
+  // Callers register roots by mutating the returned set, so it must be memoized.
+  const getRendererFiberRoots = (rendererId: number): Set<FiberRoot> => {
+    const rendererRoots = fiberRoots.get(rendererId) ?? new Set<FiberRoot>();
+    fiberRoots.set(rendererId, rendererRoots);
+    return rendererRoots;
+  };
   let rendererIdCounter = 0;
   let rdtHook: ReactDevToolsGlobalHook = {
     _instrumentationIsActive: false,
     _instrumentationSource: BIPPY_INSTRUMENTATION_STRING,
+    _isBippyHook: true,
     checkDCE,
+    getFiberRoots: getRendererFiberRoots,
     hasUnsupportedRendererAttached: false,
     inject: (renderer) => {
       const nextRendererId = ++rendererIdCounter;
-      trackInjectedRenderer(rdtHook, renderers, nextRendererId, renderer);
+      trackInjectedRenderer(rdtHook, target, renderers, nextRendererId, renderer);
       return nextRendererId;
     },
     on: noOp,
-    onCommitFiberRoot: noOp,
+    onCommitFiberRoot: (rendererId, fiberRoot) => {
+      const rendererRoots = getRendererFiberRoots(rendererId);
+      if (isFiberRootUnmounted(fiberRoot)) rendererRoots.delete(fiberRoot);
+      else rendererRoots.add(fiberRoot);
+    },
     onCommitFiberUnmount: noOp,
     onPostCommitFiberRoot: noOp,
     renderers,
@@ -172,13 +244,11 @@ export const installRDTHook = (onActive?: ActiveListener): ReactDevToolsGlobalHo
     supportsFlight: true,
   };
   try {
-    objectDefineProperty(globalThis, "__REACT_DEVTOOLS_GLOBAL_HOOK__", {
+    objectDefineProperty(target, "__REACT_DEVTOOLS_GLOBAL_HOOK__", {
       configurable: true,
       enumerable: true,
-      get() {
-        return rdtHook;
-      },
-      set(newHook) {
+      get: () => rdtHook,
+      set: (newHook: ReactDevToolsGlobalHook | undefined) => {
         if (newHook && typeof newHook === "object") {
           const ourRenderers = rdtHook.renderers;
           rdtHook = newHook;
@@ -187,14 +257,15 @@ export const installRDTHook = (onActive?: ActiveListener): ReactDevToolsGlobalHo
             _renderers.add(renderer);
             nextRenderers.set(rendererId, renderer);
           });
-          if (ourRenderers.size > 0 || rdtHookReplaceListeners.size > 0) {
-            patchRDTHook(onActive);
+          if (ourRenderers.size > 0 || rdtHookReplaceSubscriptions.size > 0) {
+            patchRDTHook(undefined, target, () => notifyRDTHookReplaceListeners(newHook, target));
+          } else {
+            notifyRDTHookReplaceListeners(newHook, target);
           }
-          notifyRDTHookReplaceListeners(rdtHook);
         }
       },
     });
-    if (typeof window !== "undefined") {
+    if (target === globalThis && typeof window !== "undefined") {
       // HACK: The DevTools extension uses hasOwnProperty to decide whether it may replace an earlier hook.
       const originalWindowHasOwnProperty = window.hasOwnProperty.bind(window);
       const originalHasOwnPropertyDescriptor = Object.getOwnPropertyDescriptor(
@@ -224,17 +295,19 @@ export const installRDTHook = (onActive?: ActiveListener): ReactDevToolsGlobalHo
       });
     }
   } catch {
-    patchRDTHook(onActive);
+    patchRDTHook(onActive, target);
   }
   return rdtHook;
 };
 
-export const patchRDTHook = (onActive?: ActiveListener): void => {
-  if (onActive) {
-    _onActiveListeners.add(onActive);
-  }
-  let didNotifyActiveListeners = false;
-  const rdtHook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+export const patchRDTHook = (
+  onActive?: ActiveListener,
+  target: ReactDevToolsTarget = globalThis,
+  onReady?: () => void,
+): void => {
+  if (onActive) addActiveListener(onActive, target);
+  let shouldNotifyActiveListeners = false;
+  const rdtHook = getTargetHook(target);
   if (!rdtHook) return;
   const renderers = getRendererMap(rdtHook);
   if (!rdtHook._instrumentationSource) {
@@ -249,43 +322,42 @@ export const patchRDTHook = (onActive?: ActiveListener): void => {
     if (!isReactDevtools) {
       rdtHook.on = noOp;
     }
-    if (renderers.size) {
-      renderers.forEach((renderer) => _renderers.add(renderer));
-      rdtHook._instrumentationIsActive = true;
-      notifyActiveListeners();
-      didNotifyActiveListeners = true;
-    } else if (!isReactDevtools && isReactRefresh(rdtHook)) {
-      // HACK: react-refresh's stub inject never records renderers, so a React app
-      // that injected before bippy loaded is undetectable through the renderers map.
-      // A react-refresh hook implies a dev renderer, so activate immediately.
-      rdtHook._instrumentationIsActive = true;
-      notifyActiveListeners();
-      didNotifyActiveListeners = true;
-    }
+    const shouldActivate = renderers.size > 0 || (!isReactDevtools && isReactRefresh(rdtHook));
     const previousInject = rdtHook.inject;
     rdtHook.inject = (renderer) => {
       const rendererId = previousInject.call(rdtHook, renderer);
-      trackInjectedRenderer(rdtHook, renderers, rendererId, renderer);
+      trackInjectedRenderer(rdtHook, target, renderers, rendererId, renderer);
       return rendererId;
     };
+    if (shouldActivate) {
+      renderers.forEach((renderer) => _renderers.add(renderer));
+      rdtHook._instrumentationIsActive = true;
+      shouldNotifyActiveListeners = true;
+    }
   }
-  if (!didNotifyActiveListeners && (renderers.size || rdtHook._instrumentationIsActive)) {
-    onActive?.();
+  const pendingListeners = shouldNotifyActiveListeners ? [..._onActiveListeners] : [];
+  onReady?.();
+  if (shouldNotifyActiveListeners) {
+    notifyActiveListeners(target, pendingListeners);
+  } else if (onActive && (renderers.size || rdtHook._instrumentationIsActive)) {
+    callListener(onActive, undefined);
   }
 };
 
-export const hasRDTHook = (): boolean => {
-  return Object.hasOwn(globalThis, "__REACT_DEVTOOLS_GLOBAL_HOOK__");
-};
+export const hasRDTHook = (target: ReactDevToolsTarget = globalThis): boolean =>
+  Object.hasOwn(target, "__REACT_DEVTOOLS_GLOBAL_HOOK__");
 
 /**
  * Returns the current React DevTools global hook.
  */
-export const getRDTHook = (onActive?: ActiveListener): ReactDevToolsGlobalHook => {
-  if (!hasRDTHook()) {
-    return installRDTHook(onActive);
+export const getRDTHook = (
+  onActive?: ActiveListener,
+  target: ReactDevToolsTarget = globalThis,
+): ReactDevToolsGlobalHook => {
+  if (!hasRDTHook(target)) {
+    return installRDTHook(onActive, target);
   }
 
-  patchRDTHook(onActive);
-  return globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__ ?? installRDTHook(onActive);
+  patchRDTHook(onActive, target);
+  return getTargetHook(target) ?? installRDTHook(onActive, target);
 };

package/src/react-internals/current-fiber.ts

@@ -0,0 +1,84 @@
+// Adapted from ReactFiberTreeReflection.js. Copyright (c) Meta Platforms, Inc. and affiliates. MIT licensed.
+import type { Fiber } from "./types.js";
+import { getReactWorkTagsForFiber } from "./index.js";
+
+export const getCurrentFiberFromRoot = (fiber: Fiber): Fiber | null => {
+  const alternate = fiber.alternate;
+  if (!alternate) return null;
+  let firstBranch = fiber;
+  let secondBranch = alternate;
+
+  while (firstBranch.return) {
+    const firstParent = firstBranch.return;
+    const secondParent = firstParent.alternate;
+    if (!secondParent) {
+      const nextParent = firstParent.return;
+      if (!nextParent) return null;
+      firstBranch = secondBranch = nextParent;
+      continue;
+    }
+
+    if (firstParent.child === secondParent.child) {
+      let child = firstParent.child;
+      while (child) {
+        if (child === firstBranch || child === secondBranch) {
+          let root = firstParent;
+          while (root.return) root = root.return;
+          if (root.tag !== getReactWorkTagsForFiber(root).HostRoot) return null;
+          return child === firstBranch ? fiber : alternate;
+        }
+        child = child.sibling;
+      }
+      return null;
+    }
+
+    if (firstBranch.return !== secondBranch.return) {
+      firstBranch = firstParent;
+      secondBranch = secondParent;
+    } else {
+      let didFindChild = false;
+      let child = firstParent.child;
+      while (child) {
+        if (child === firstBranch) {
+          firstBranch = firstParent;
+          secondBranch = secondParent;
+          didFindChild = true;
+          break;
+        }
+        if (child === secondBranch) {
+          firstBranch = secondParent;
+          secondBranch = firstParent;
+          didFindChild = true;
+          break;
+        }
+        child = child.sibling;
+      }
+      if (!didFindChild) {
+        child = secondParent.child;
+        while (child) {
+          if (child === firstBranch) {
+            firstBranch = secondParent;
+            secondBranch = firstParent;
+            didFindChild = true;
+            break;
+          }
+          if (child === secondBranch) {
+            firstBranch = firstParent;
+            secondBranch = secondParent;
+            didFindChild = true;
+            break;
+          }
+          child = child.sibling;
+        }
+        if (!didFindChild) return null;
+      }
+    }
+    if (firstBranch.alternate !== secondBranch) return null;
+  }
+
+  if (firstBranch.tag !== getReactWorkTagsForFiber(firstBranch).HostRoot) return null;
+  const root = firstBranch.stateNode;
+  if (typeof root !== "object" || root === null || !("current" in root)) return null;
+  if (root.current === firstBranch) return fiber;
+  return root.current === secondBranch ? alternate : null;
+};

package/src/react-internals/generated/react-work-tags.ts

@@ -25,6 +25,9 @@ export const ReactSymbols = {
   DEPRECATED_ASYNC_MODE_SYMBOL_STRING: "Symbol(react.async_mode)",
   ELEMENT_SYMBOL_STRING: "Symbol(react.transitional.element)",
   LEGACY_ELEMENT_SYMBOL_STRING: "Symbol(react.element)",
+  STRICT_MODE_NUMBER: 60108,
+  STRICT_MODE_SYMBOL_DESCRIPTION: "react.strict_mode",
+  STRICT_MODE_SYMBOL_STRING: "Symbol(react.strict_mode)",
 } as const;
 
 export interface ReactWorkTagMap {

package/src/react-internals/index.ts

@@ -18,8 +18,24 @@ export type {
 } from "./generated/react-work-tags.js";
 export * from "./types.js";
 
+interface InheritedWorkTags {
+  workTags: Readonly<ReactWorkTagMap>;
+  generation: number;
+}
+
 const defaultReactWorkTags = getReactWorkTags();
 const fiberReactWorkTags = new WeakMap<Fiber, Readonly<ReactWorkTagMap>>();
+const inheritedFiberWorkTags = new WeakMap<Fiber, InheritedWorkTags>();
+let workTagGeneration = 0;
+
+const getCachedWorkTags = (fiber: Fiber): Readonly<ReactWorkTagMap> | undefined => {
+  const assignedWorkTags = fiberReactWorkTags.get(fiber);
+  if (assignedWorkTags) return assignedWorkTags;
+  const inheritedWorkTags = inheritedFiberWorkTags.get(fiber);
+  return inheritedWorkTags?.generation === workTagGeneration
+    ? inheritedWorkTags.workTags
+    : undefined;
+};
 
 // React's experimental channel historically reported "0.0.0-experimental-<sha>"
 // as the runtime version; those builds use modern work tags, not the 16.x rows
@@ -39,25 +55,36 @@ export const getReactWorkTagsForRenderer = (
 
 export const setReactWorkTagsForFiber = (fiber: Fiber, renderer?: ReactRenderer): void => {
   const workTags = getReactWorkTagsForRenderer(renderer);
+  if (
+    getCachedWorkTags(fiber) !== workTags ||
+    (fiber.alternate && getCachedWorkTags(fiber.alternate) !== workTags)
+  ) {
+    workTagGeneration++;
+  }
   fiberReactWorkTags.set(fiber, workTags);
   if (fiber.alternate) fiberReactWorkTags.set(fiber.alternate, workTags);
 };
 
 export const getReactWorkTagsForFiber = (fiber: Fiber): Readonly<ReactWorkTagMap> => {
-  const cachedWorkTags = fiberReactWorkTags.get(fiber);
-  if (cachedWorkTags) return cachedWorkTags;
-
-  const traversedFibers: Fiber[] = [fiber];
-  let rootFiber = fiber;
-  while (rootFiber.return) {
-    rootFiber = rootFiber.return;
-    traversedFibers.push(rootFiber);
+  let workTags = getCachedWorkTags(fiber);
+  if (workTags) return workTags;
+  const traversedFibers: Fiber[] = [];
+  let ancestor = fiber;
+  while (!workTags) {
+    traversedFibers.push(ancestor);
+    const parent = ancestor.return;
+    if (!parent) {
+      workTags = inheritedFiberWorkTags.get(ancestor)?.workTags ?? defaultReactWorkTags;
+      break;
+    }
+    ancestor = parent;
+    workTags = getCachedWorkTags(ancestor);
   }
-  const workTags = fiberReactWorkTags.get(rootFiber) ?? defaultReactWorkTags;
+  const inheritedWorkTags = { workTags, generation: workTagGeneration };
   for (const traversedFiber of traversedFibers) {
-    fiberReactWorkTags.set(traversedFiber, workTags);
+    inheritedFiberWorkTags.set(traversedFiber, inheritedWorkTags);
     if (traversedFiber.alternate) {
-      fiberReactWorkTags.set(traversedFiber.alternate, workTags);
+      inheritedFiberWorkTags.set(traversedFiber.alternate, inheritedWorkTags);
     }
   }
   return workTags;

package/src/react-internals/types.ts

@@ -31,12 +31,30 @@ export interface ServerComponentInfo {
   env?: string;
   owner?: Fiber | ServerComponentInfo | null;
   debugStack?: Error | null;
+  debugLocation?: Error | null;
+}
+
+export interface ReactIOInfo {
+  name: string;
+  start: number;
+  end: number;
+  byteSize?: number;
+  value?: Promise<unknown> | null;
+  env?: string;
+  owner?: ServerComponentInfo | null;
+  stack?: unknown[] | null;
+  debugStack?: Error | null;
 }
 
 export interface ReactDebugInfo {
-  debugLocation?: unknown;
+  awaited?: ReactIOInfo;
+  debugLocation?: Error | null;
   env?: string;
   name?: string;
+  owner?: ServerComponentInfo | null;
+  stack?: unknown[] | null;
+  debugStack?: Error | null;
+  time?: number;
 }
 
 export interface ReactMemoCache {
@@ -71,10 +89,10 @@ export interface Fiber<T = unknown> extends Omit<
   | "tag"
   | "updateQueue"
 > {
-  _debugInfo?: ReactDebugInfo[];
+  _debugInfo?: ReactDebugInfo[] | null;
   _debugOwner?: Fiber | ServerComponentInfo | null;
   _debugSource?: FiberDebugSource | null;
-  _debugStack?: Error & { stack: string };
+  _debugStack?: Error | null;
   alternate: Fiber | null;
   child: Fiber | null;
   deletions: Fiber[] | null;
@@ -96,6 +114,8 @@ export interface HostFiber<T = unknown> extends Fiber<T> {
 
 export interface FiberRoot {
   current: Fiber;
+  effectDuration?: number;
+  passiveEffectDuration?: number;
 }
 
 export interface MemoizedState {
@@ -115,6 +135,7 @@ export interface ReactDevToolsEventHandler {
 export interface ReactDevToolsGlobalHook {
   _instrumentationIsActive?: boolean;
   _instrumentationSource?: string;
+  _isBippyHook?: boolean;
   checkDCE: (fn: unknown) => void;
   emit?: (event: string, data?: unknown) => void;
   getFiberRoots?: (rendererID: number) => Set<FiberRoot>;
@@ -149,14 +170,20 @@ export type RendererDispatcherRef = CurrentDispatcherRef | LegacyDispatcherRef;
 
 export interface ReactRenderer extends Omit<
   ReactReconciler.DevToolsConfig<unknown, unknown, unknown>,
-  "findFiberByHostInstance"
+  "bundleType" | "findFiberByHostInstance"
 > {
+  bundleType: number;
   currentDispatcherRef?: RendererDispatcherRef | null;
   findFiberByHostInstance?: (hostInstance: unknown) => Fiber | null;
   getCurrentFiber?: () => Fiber | null;
   overrideContext?: (fiber: Fiber, contextType: unknown, path: string[], value: unknown) => void;
 
-  overrideHookState?: (fiber: Fiber, id: number, path: string[], value: unknown) => void;
+  overrideHookState?: (
+    fiber: Fiber,
+    id: number,
+    path: Array<number | string>,
+    value: unknown,
+  ) => void;
   overrideHookStateDeletePath?: (fiber: Fiber, id: number, path: Array<number | string>) => void;
   overrideHookStateRenamePath?: (
     fiber: Fiber,
@@ -164,7 +191,7 @@ export interface ReactRenderer extends Omit<
     oldPath: Array<number | string>,
     newPath: Array<number | string>,
   ) => void;
-  overrideProps?: (fiber: Fiber, path: string[], value: unknown) => void;
+  overrideProps?: (fiber: Fiber, path: Array<number | string>, value: unknown) => void;
   overridePropsDeletePath?: (fiber: Fiber, path: Array<number | string>) => void;
   overridePropsRenamePath?: (
     fiber: Fiber,