bippy 0.7.2-dev.23cd194 → 0.7.2-dev.e113600

package/src/rdt-hook.ts

@@ -1,6 +1,6 @@
 // This module must load before React so renderers can inject into the hook.
 
-import type { ReactDevToolsGlobalHook, ReactRenderer } from "./react-internals/index.js";
+import type { FiberRoot, ReactDevToolsGlobalHook, ReactRenderer } from "./react-internals/index.js";
 
 export interface Unsubscribe extends Disposable {
   (): void;
@@ -14,8 +14,17 @@ interface RendererInjectListener {
   (renderer: ReactRenderer): void;
 }
 
+interface RendererInjectSubscription {
+  listener: RendererInjectListener;
+  target: ReactDevToolsTarget;
+}
+
 interface RDTHookReplaceListener {
-  (rdtHook: ReactDevToolsGlobalHook): void;
+  (rdtHook: ReactDevToolsGlobalHook, target: ReactDevToolsTarget): void;
+}
+
+export interface ReactDevToolsTarget {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__?: ReactDevToolsGlobalHook;
 }
 
 export const version = process.env.VERSION;
@@ -25,9 +34,20 @@ 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 => {
   try {
     const code = Function.prototype.toString.call(functionToCheck);
@@ -47,7 +67,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,53 +89,63 @@ export const _onActiveListeners = new Set<ActiveListener>();
 
 export const _renderers = new Set<ReactRenderer>();
 
-const rendererInjectListeners = new Set<RendererInjectListener>();
+const activeListenerTargets = new WeakMap<ActiveListener, Set<ReactDevToolsTarget>>();
+const rendererInjectSubscriptions = new Set<RendererInjectSubscription>();
 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 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): void => {
+  for (const listener of _onActiveListeners) {
+    if (activeListenerTargets.get(listener)?.has(target)) listener();
   }
 };
 
-const notifyRDTHookReplaceListeners = (rdtHook: ReactDevToolsGlobalHook): void => {
-  for (const listener of rdtHookReplaceListeners) {
-    listener(rdtHook);
+const notifyRendererInjectListeners = (
+  target: ReactDevToolsTarget,
+  renderer: ReactRenderer,
+): void => {
+  for (const subscription of rendererInjectSubscriptions) {
+    if (subscription.target === target) subscription.listener(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);
-    }
-    return rendererId;
-  };
-  rdtHook.inject = nextInject;
-  notifyingInjectByHook.set(rdtHook, nextInject);
+const notifyRDTHookReplaceListeners = (
+  rdtHook: ReactDevToolsGlobalHook,
+  target: ReactDevToolsTarget,
+): void => {
+  for (const listener of rdtHookReplaceListeners) {
+    listener(rdtHook, target);
+  }
 };
 
-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);
   });
 };
 
@@ -126,8 +156,13 @@ export const onRDTHookReplace = (listener: RDTHookReplaceListener): Unsubscribe
   });
 };
 
+// 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 +170,7 @@ const getRendererMap = (rdtHook: ReactDevToolsGlobalHook): Map<number, ReactRend
 
 const trackInjectedRenderer = (
   rdtHook: ReactDevToolsGlobalHook,
+  target: ReactDevToolsTarget,
   renderers: Map<number, ReactRenderer>,
   rendererId: number,
   renderer: ReactRenderer,
@@ -143,28 +179,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 +227,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;
@@ -188,13 +241,13 @@ export const installRDTHook = (onActive?: ActiveListener): ReactDevToolsGlobalHo
             nextRenderers.set(rendererId, renderer);
           });
           if (ourRenderers.size > 0 || rdtHookReplaceListeners.size > 0) {
-            patchRDTHook(onActive);
+            patchRDTHook(onActive, target);
           }
-          notifyRDTHookReplaceListeners(rdtHook);
+          notifyRDTHookReplaceListeners(rdtHook, target);
         }
       },
     });
-    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 +277,18 @@ 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);
-  }
+export const patchRDTHook = (
+  onActive?: ActiveListener,
+  target: ReactDevToolsTarget = globalThis,
+): void => {
+  if (onActive) addActiveListener(onActive, target);
   let didNotifyActiveListeners = false;
-  const rdtHook = globalThis.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  const rdtHook = getTargetHook(target);
   if (!rdtHook) return;
   const renderers = getRendererMap(rdtHook);
   if (!rdtHook._instrumentationSource) {
@@ -252,20 +306,20 @@ export const patchRDTHook = (onActive?: ActiveListener): void => {
     if (renderers.size) {
       renderers.forEach((renderer) => _renderers.add(renderer));
       rdtHook._instrumentationIsActive = true;
-      notifyActiveListeners();
+      notifyActiveListeners(target);
       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();
+      notifyActiveListeners(target);
       didNotifyActiveListeners = true;
     }
     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;
     };
   }
@@ -274,18 +328,20 @@ export const patchRDTHook = (onActive?: ActiveListener): void => {
   }
 };
 
-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/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,

package/src/react.ts

@@ -38,6 +38,7 @@ const captureFiberFromHook = (useCaptureHook: () => void): Fiber | null => {
 };
 
 const useExternalStoreCapture = (): void => {
+  if (typeof useSyncExternalStore !== "function") return;
   Reflect.apply(useSyncExternalStore, React, [
     subscribeToEmptyStore,
     readEmptySnapshot,

package/src/source/constants.ts

@@ -25,9 +25,7 @@ export const BUNDLED_FILE_PATTERN_REGEX =
 
 export const QUERY_PARAMETER_PATTERN_REGEX = /^\?[\w~.-]+(?:=[^&#]*)?(?:&[\w~.-]+(?:=[^&#]*)?)*$/;
 
-export const SERVER_FRAME_MARKER = "(at Server)";
-
-export const SERVER_ENV_PATTERN = /\(at [^)]+\)$/;
+export const SERVER_ENV_PATTERN = /\[[^\]]+\]$/;
 
 export const REACT_STACK_BOTTOM_FRAME_PATTERNS = [
   "react_stack_bottom_frame",

package/src/source/get-display-name-from-source.ts

@@ -6,6 +6,7 @@ import {
   getSourceFromSourceMap,
   getSourceMap,
   type SourceFetch,
+  type SourceMapRequestOptions,
 } from "./symbolication.js";
 import type { StackFrame } from "./parse-stack.js";
 
@@ -53,8 +54,9 @@ const extractComponentNameFromSource = (
 
 export const getDisplayNameFromSource = async (
   fiber: Fiber,
-  cache = true,
-  fetchFn?: SourceFetch,
+  shouldUseCache = true,
+  sourceFetch?: SourceFetch,
+  requestOptions: SourceMapRequestOptions = {},
 ): Promise<string | null> => {
   const stackFrame =
     getDefinitionFrameFromOwnedChild(fiber) ??
@@ -64,7 +66,12 @@ export const getDisplayNameFromSource = async (
     return getDisplayName(fiber.type);
   }
 
-  const bundleSourceMap = await getSourceMap(stackFrame.fileName, cache, fetchFn);
+  const bundleSourceMap = await getSourceMap(
+    stackFrame.fileName,
+    shouldUseCache,
+    sourceFetch,
+    requestOptions,
+  );
 
   if (!bundleSourceMap) {
     return getDisplayName(fiber.type);

package/src/source/get-source.ts

@@ -19,6 +19,7 @@ import {
   getSourceMap,
   symbolicateStack,
   type SourceFetch,
+  type SourceMapRequestOptions,
 } from "./symbolication.js";
 
 export const hasDebugSource = (
@@ -67,10 +68,17 @@ const getUsageFrameFromDebugStack = (fiber: Fiber): StackFrame | null => {
   return null;
 };
 
+export const getRawSource = (fiber: Fiber): FiberSource | null => {
+  if (hasDebugSource(fiber)) return fiber._debugSource;
+  const stackFrame = getUsageFrameFromDebugStack(fiber) ?? getDefinitionFrameFromOwnedChild(fiber);
+  return stackFrame ? toFiberSource(stackFrame) : null;
+};
+
 const getSourceByComponentName = async (
   fiber: Fiber,
-  cache: boolean,
-  fetchFn: SourceFetch | undefined,
+  shouldUseCache: boolean,
+  sourceFetch: SourceFetch | undefined,
+  requestOptions: SourceMapRequestOptions,
 ): Promise<FiberSource | null> => {
   const functionName = getDisplayName(fiber.type);
   if (!functionName) return null;
@@ -83,7 +91,7 @@ const getSourceByComponentName = async (
       continue;
     }
     visitedFileNames.add(fileName);
-    const sourceMap = await getSourceMap(fileName, cache, fetchFn);
+    const sourceMap = await getSourceMap(fileName, shouldUseCache, sourceFetch, requestOptions);
     if (!sourceMap) continue;
     const source = getSourceFromSourceMapByFunctionName(sourceMap, functionName);
     if (source && !source.isIgnoreListed) return toFiberSource(source);
@@ -119,30 +127,42 @@ const getSourceByComponentName = async (
  */
 export const getSource = async (
   fiber: Fiber,
-  cache = true,
-  fetchFn?: SourceFetch,
+  shouldUseCache = true,
+  sourceFetch?: SourceFetch,
+  requestOptions: SourceMapRequestOptions = {},
 ): Promise<FiberSource | null> => {
-  if (hasDebugSource(fiber)) {
-    return fiber._debugSource;
-  }
-
-  const debugStackFrame =
-    getUsageFrameFromDebugStack(fiber) ?? getDefinitionFrameFromOwnedChild(fiber);
-  if (debugStackFrame) {
-    const [symbolicatedFrame] = await symbolicateStack([debugStackFrame], cache, fetchFn);
-    const debugStackSource = toFiberSource(symbolicatedFrame);
-    if (debugStackSource) {
-      return debugStackSource;
-    }
+  if (hasDebugSource(fiber)) return fiber._debugSource;
+  const rawSource = getRawSource(fiber);
+  if (rawSource) {
+    const [symbolicatedFrame] = await symbolicateStack(
+      [
+        {
+          columnNumber: rawSource.columnNumber,
+          fileName: rawSource.fileName,
+          functionName: rawSource.functionName,
+          lineNumber: rawSource.lineNumber,
+        },
+      ],
+      shouldUseCache,
+      sourceFetch,
+      requestOptions,
+    );
+    const symbolicatedSource = toFiberSource(symbolicatedFrame);
+    if (symbolicatedSource) return symbolicatedSource;
   }
 
-  const parentStackFrames = await getParentStack(fiber, cache, fetchFn);
+  const parentStackFrames = await getParentStack(
+    fiber,
+    shouldUseCache,
+    sourceFetch,
+    requestOptions,
+  );
   for (const stackFrame of parentStackFrames) {
     if (stackFrame.fileName) {
       return toFiberSource(stackFrame);
     }
   }
-  return getSourceByComponentName(fiber, cache, fetchFn);
+  return getSourceByComponentName(fiber, shouldUseCache, sourceFetch, requestOptions);
 };
 
 const getPathSegmentCount = (path: string): number => path.split("/").filter(Boolean).length;

package/src/source/index.ts

@@ -1,5 +1,13 @@
-export { formatOwnerStack, getOwnerStack, getParentStack, hasDebugStack } from "./owner-stack.js";
-export { getSource, isSourceFile, normalizeFileName } from "./get-source.js";
+export {
+  formatOwnerStack,
+  getDefinitionFrameFromOwnedChild,
+  getFallbackParentStack,
+  getOwnerStack,
+  getParentStack,
+  getRawOwnerStack,
+  hasDebugStack,
+} from "./owner-stack.js";
+export { getRawSource, getSource, isSourceFile, normalizeFileName } from "./get-source.js";
 export {
   getSourceContentFromSourceMap,
   getSourceFromSourceMap,
@@ -23,5 +31,11 @@ export {
   BippySourceMapError,
   BippyUnsupportedHookError,
 } from "../errors.js";
-export { getFiberHooks, type HookSource, type HooksNode, type HooksTree } from "./inspect-hooks.js";
+export {
+  getFiberHooks,
+  inspectHooks,
+  type HookSource,
+  type HooksNode,
+  type HooksTree,
+} from "./inspect-hooks.js";
 export { parseHookNames, type HookNames } from "./parse-hook-names.js";