bippy 0.7.2-dev.b756bd6 → 0.7.2-dev.e113600

package/src/source/inspect-hooks.ts

@@ -1,3 +1,5 @@
+import { getRenderer } from "../core.js";
+import type { ReactDevToolsTarget } from "../rdt-hook.js";
 import type {
   Fiber,
   ContextDependency,
@@ -548,6 +550,19 @@ const parseHookName = (functionName: string | undefined): string => {
   return functionName.slice(startIndex);
 };
 
+// Unlike upstream, bippy routes every dispatcher method through a shared log helper, so those
+// frames appear in captured stacks and must not become tree levels. Names are read off the
+// live functions rather than matched by prefix, so user hooks cannot collide and minified
+// builds stay accurate.
+const INTERNAL_HOOK_FRAME_NAMES = new Set(
+  [pushHookLogEntry, ...Object.values(dispatcher)].map((internalFunction) =>
+    parseHookName(internalFunction.name),
+  ),
+);
+
+const isInternalHookFrame = (hookName: string): boolean =>
+  hookName !== "" && INTERNAL_HOOK_FRAME_NAMES.has(hookName);
+
 const isReactWrapper = (functionName: string | undefined, wrapperName: string): boolean => {
   const hookName = parseHookName(functionName);
   if (wrapperName === "HostTransitionStatus") {
@@ -618,8 +633,10 @@ const buildTree = (rootStack: StackFrame[], capturedHookLog: HookLogEntry[]): Ho
     const [primitiveFrame, stack] = parseTrimmedStack(rootStack, hook);
     let displayName = hook.displayName;
     if (displayName === null && primitiveFrame !== null) {
-      displayName =
-        parseHookName(primitiveFrame.functionName) || parseHookName(hook.dispatcherHookName);
+      const primitiveName = parseHookName(primitiveFrame.functionName);
+      displayName = isInternalHookFrame(primitiveName)
+        ? null
+        : primitiveName || parseHookName(hook.dispatcherHookName);
     }
 
     if (stack !== null) {
@@ -684,17 +701,40 @@ const buildTree = (rootStack: StackFrame[], capturedHookLog: HookLogEntry[]): Ho
   }
 
   processDebugValues(rootChildren, null);
+  removeInternalHookFrames(rootChildren, null);
   return rootChildren;
 };
 
+const removeInternalHookFrames = (
+  hooksTree: HooksTree,
+  parentHooksNode: HooksNode | null,
+): void => {
+  for (let nodeIndex = 0; nodeIndex < hooksTree.length; nodeIndex++) {
+    const hooksNode = hooksTree[nodeIndex];
+    if (isInternalHookFrame(hooksNode.name)) {
+      if (parentHooksNode !== null && hooksNode.value !== undefined) {
+        if (parentHooksNode.value === undefined) parentHooksNode.value = hooksNode.value;
+        else if (Array.isArray(parentHooksNode.value)) {
+          parentHooksNode.value = [...parentHooksNode.value, hooksNode.value];
+        } else parentHooksNode.value = [parentHooksNode.value, hooksNode.value];
+      }
+      hooksTree.splice(nodeIndex, 1, ...hooksNode.subHooks);
+      nodeIndex--;
+    } else {
+      removeInternalHookFrames(hooksNode.subHooks, hooksNode);
+    }
+  }
+};
+
 const processDebugValues = (hooksTree: HooksTree, parentHooksNode: HooksNode | null): void => {
   const debugValueNodes: HooksNode[] = [];
   for (let nodeIndex = 0; nodeIndex < hooksTree.length; nodeIndex++) {
     const hooksNode = hooksTree[nodeIndex];
-    if (hooksNode.name === "DebugValue" && hooksNode.subHooks.length === 0) {
-      hooksTree.splice(nodeIndex, 1);
+    if (hooksNode.name === "DebugValue") {
+      hooksTree.splice(nodeIndex, 1, ...hooksNode.subHooks);
       nodeIndex--;
-      debugValueNodes.push(hooksNode);
+      // Internal frames surface as valueless DebugValue levels; only real labels bubble up.
+      if (hooksNode.value !== undefined) debugValueNodes.push(hooksNode);
     } else {
       processDebugValues(hooksNode.subHooks, hooksNode);
     }
@@ -785,9 +825,12 @@ const restoreConsole = (originalMethods: Record<string, unknown>): void => {
   }
 };
 
-const performDispatcherInspection = (
+// The render call must happen in the same frame that captures the ancestor stack,
+// otherwise an extra frame lands in every hook's trimmed stack and becomes a bogus tree level.
+const performDispatcherInspection = <TArgs extends unknown[]>(
   dispatcherRef: RendererDispatcherRef,
-  renderFn: () => void,
+  renderFunction: (...args: TArgs) => unknown,
+  ...renderArgs: TArgs
 ): HooksTree => {
   const previousDispatcher = readDispatcher(dispatcherRef);
   writeDispatcher(dispatcherRef, dispatcherProxy);
@@ -797,7 +840,7 @@ const performDispatcherInspection = (
 
   try {
     ancestorStackError = new Error();
-    renderFn();
+    renderFunction(...renderArgs);
   } catch (renderError) {
     handleRenderFunctionError(renderError);
   } finally {
@@ -810,8 +853,12 @@ const performDispatcherInspection = (
   return buildTree(rootStack, capturedHookLog);
 };
 
-const requireDispatcherRef = (): RendererDispatcherRef => {
-  const dispatcherRef = getRendererDispatcherRefs()[0];
+const requireDispatcherRef = (
+  fiber?: Fiber,
+  target: ReactDevToolsTarget = globalThis,
+): RendererDispatcherRef => {
+  const rendererDispatcherRef = fiber ? getRenderer(fiber, target)?.currentDispatcherRef : null;
+  const dispatcherRef = rendererDispatcherRef ?? getRendererDispatcherRefs(target)[0];
   if (!dispatcherRef) {
     throw new BippyHookInspectionError(
       "Bippy couldn’t find a React renderer. Load React and install Bippy’s hook.",
@@ -848,8 +895,73 @@ const resolveContextDependency = (fiber: Fiber): void => {
   }
 };
 
+const normalizeStandaloneHooks = (hooksTree: HooksTree): HooksTree => {
+  const normalizeNode = (hooksNode: HooksNode): HooksNode => {
+    const subHooks = hooksNode.subHooks.map(normalizeNode);
+    if (subHooks.length === 1) {
+      const childHook = subHooks[0];
+      if (hooksNode.name === "Context" && childHook.id === null) {
+        return { ...childHook, hookSource: hooksNode.hookSource };
+      }
+      if (hooksNode.name === "FormStatus" && childHook.name === "HostTransitionStatus") {
+        return { ...hooksNode, subHooks: [], value: childHook.value };
+      }
+      if (hooksNode.name === "Use") {
+        if (childHook.name === "Context") {
+          return { ...childHook, hookSource: hooksNode.hookSource };
+        }
+        if (childHook.name === "Promise" || childHook.name === "Unresolved") {
+          return {
+            ...hooksNode,
+            debugInfo: childHook.debugInfo,
+            subHooks: [],
+            value: childHook.value,
+          };
+        }
+      }
+      if (
+        hooksNode.id === null &&
+        hooksNode.value === undefined &&
+        (hooksNode.name === childHook.name || hooksNode.name === "<anonymous>")
+      ) {
+        return { ...childHook, hookSource: hooksNode.hookSource };
+      }
+    }
+    return { ...hooksNode, subHooks };
+  };
+
+  return hooksTree.map(normalizeNode);
+};
+
+export const inspectHooks = (
+  renderFunction: (props: Record<string, unknown>) => unknown,
+  props: Record<string, unknown>,
+  target: ReactDevToolsTarget = globalThis,
+): HooksTree => {
+  const dispatcherRef = requireDispatcherRef(undefined, target);
+  getPrimitiveStackCache();
+  currentHook = null;
+  currentFiber = null;
+  currentContextDependency = null;
+  currentThenableState = null;
+  currentThenableIndex = 0;
+  const originalConsoleMethods = suppressConsole();
+  try {
+    return normalizeStandaloneHooks(
+      performDispatcherInspection(dispatcherRef, renderFunction, props),
+    );
+  } finally {
+    currentHook = null;
+    currentFiber = null;
+    currentContextDependency = null;
+    currentThenableState = null;
+    currentThenableIndex = 0;
+    restoreConsole(originalConsoleMethods);
+  }
+};
+
 export const getFiberHooks = (fiber: Fiber): HooksTree => {
-  const dispatcherRef = requireDispatcherRef();
+  const dispatcherRef = requireDispatcherRef(fiber);
   const workTags = getReactWorkTagsForFiber(fiber);
 
   if (
@@ -895,9 +1007,15 @@ export const getFiberHooks = (fiber: Fiber): HooksTree => {
       if (!isForwardRefRenderType(type)) {
         throw new BippyHookInspectionError("ForwardRef fiber is missing its render function.");
       }
-      return performDispatcherInspection(dispatcherRef, () => {
-        type.render(props, fiber.ref);
-      });
+      const hooksTree = normalizeStandaloneHooks(
+        performDispatcherInspection(dispatcherRef, type.render, props, fiber.ref),
+      );
+      for (const hooksNode of hooksTree) {
+        if (hooksNode.hookSource?.functionName === "Object.render") {
+          hooksNode.hookSource.functionName = null;
+        }
+      }
+      return hooksTree;
     }
 
     if (typeof type !== "function") {
@@ -905,9 +1023,7 @@ export const getFiberHooks = (fiber: Fiber): HooksTree => {
         "Function component fiber is missing its component function.",
       );
     }
-    return performDispatcherInspection(dispatcherRef, () => {
-      type(props);
-    });
+    return normalizeStandaloneHooks(performDispatcherInspection(dispatcherRef, type, props));
   } finally {
     currentFiber = null;
     currentHook = null;

package/src/source/owner-stack.ts

@@ -18,7 +18,11 @@ import {
   readDispatcher,
   writeDispatcher,
 } from "./renderer-dispatchers.js";
-import { symbolicateStack, type SourceFetch } from "./symbolication.js";
+import {
+  symbolicateStack,
+  type SourceFetch,
+  type SourceMapRequestOptions,
+} from "./symbolication.js";
 
 interface RendererDispatcherSnapshot {
   currentDispatcherRef: RendererDispatcherRef;
@@ -534,7 +538,7 @@ const markFlightServerFrame = (stackFrame: StackFrame): StackFrame =>
  * carries `.debugStack`). This is exact - no re-invoking components, no
  * name-matching heuristics - but requires React 19.
  */
-const getOwnerStackFromDebugStacks = (fiber: Fiber): StackFrame[] => {
+export const getRawOwnerStack = (fiber: Fiber): StackFrame[] => {
   const ownerStackFrames: StackFrame[] = [];
   let owner: Fiber | ServerComponentInfo | null | undefined = fiber;
   while (owner) {
@@ -625,9 +629,11 @@ export const getRawParentStack = (fiber: Fiber): StackFrame[] => {
  */
 export const getParentStack = async (
   fiber: Fiber,
-  shouldCache = true,
-  fetchFunction?: SourceFetch,
-): Promise<StackFrame[]> => symbolicateStack(getRawParentStack(fiber), shouldCache, fetchFunction);
+  shouldUseCache = true,
+  sourceFetch?: SourceFetch,
+  requestOptions: SourceMapRequestOptions = {},
+): Promise<StackFrame[]> =>
+  symbolicateStack(getRawParentStack(fiber), shouldUseCache, sourceFetch, requestOptions);
 
 // an owner frame is only actionable if it can point an editor somewhere:
 // it needs a file location and must not be ignore-listed bundler/framework code
@@ -646,10 +652,11 @@ const isLocatableFrame = (stackFrame: StackFrame): boolean =>
  */
 export const getOwnerStack = async (
   fiber: Fiber,
-  shouldCache = true,
-  fetchFunction?: SourceFetch,
+  shouldUseCache = true,
+  sourceFetch?: SourceFetch,
+  requestOptions: SourceMapRequestOptions = {},
 ): Promise<StackFrame[]> => {
-  const debugStackFrames = getOwnerStackFromDebugStacks(fiber);
+  const debugStackFrames = getRawOwnerStack(fiber);
   if (debugStackFrames.length > 0) {
     // the owner chain does not include the fiber itself, but bippy's stacks
     // always start with the fiber's own frame
@@ -657,8 +664,9 @@ export const getOwnerStack = async (
     selfFrame.functionName = getDisplayName(fiber.type) ?? selfFrame.functionName;
     const symbolicatedFrames = await symbolicateStack(
       [selfFrame, ...debugStackFrames],
-      shouldCache,
-      fetchFunction,
+      shouldUseCache,
+      sourceFetch,
+      requestOptions,
     );
     const hasLocatableOwnerFrame = symbolicatedFrames.some(
       (stackFrame, frameIndex) => frameIndex > 0 && isLocatableFrame(stackFrame),
@@ -668,5 +676,5 @@ export const getOwnerStack = async (
     }
   }
 
-  return getParentStack(fiber, shouldCache, fetchFunction);
+  return getParentStack(fiber, shouldUseCache, sourceFetch, requestOptions);
 };

package/src/source/parse-hook-names.ts

@@ -4,6 +4,7 @@ import {
   getSourceFromSourceMap,
   getSourceMap,
   type SourceFetch,
+  type SourceMapRequestOptions,
 } from "./symbolication.js";
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
@@ -19,8 +20,10 @@ const UNNAMED_HOOKS = new Set([
 
 // HACK: matches `const/let/var [name, ...] = use...(...` or `const/let/var name = use...(...`
 // across up to 10 lines; handles TypeScript generics like `useState<T>(`
+// The member-access prefix consumes one dotless segment per repetition. Letting a segment
+// span dots too would make the parse ambiguous and backtrack exponentially on long chains.
 const HOOK_DECLARATION_REGEX =
-  /(?:const|let|var)\s+((?:\[[\s\S]*?\]|\w+))\s*=\s*(?:[\w$.]+\.)*use[A-Z]\w*\s*(?:<[\s\S]*?>)?\s*\(/g;
+  /(?:const|let|var)\s+((?:\[[\s\S]*?\]|\w+))\s*=\s*(?:(?:[\w$]+|require\s*\([^)]*\))\.)*use[A-Z]\w*\s*(?:<[\s\S]*?>)?\s*\(/g;
 
 export const getHookSourceLocationKey = (hookSource: HookSource): string =>
   `${hookSource.fileName ?? ""}:${hookSource.lineNumber ?? 0}:${hookSource.columnNumber ?? 0}`;
@@ -63,12 +66,13 @@ export const extractHookVariableName = (
 
   const allMatches = [...sourceChunk.matchAll(HOOK_DECLARATION_REGEX)];
 
-  const hookPositionInChunk = sourceChunk.lastIndexOf("\n") + 1 + columnNumber;
-  const closestMatch = allMatches.filter((match) => match.index! <= hookPositionInChunk).at(-1);
+  const hookLineStart = sourceChunk.lastIndexOf("\n") + 1;
+  const hookPositionInChunk = hookLineStart + columnNumber;
+  const closestMatch =
+    allMatches.filter((match) => match.index! <= hookPositionInChunk).at(-1) ??
+    (columnNumber === 0 ? allMatches.find((match) => match.index! >= hookLineStart) : undefined);
 
-  if (closestMatch) {
-    return extractVariableNameFromBinding(closestMatch[1]);
-  }
+  if (closestMatch) return extractVariableNameFromBinding(closestMatch[1]);
 
   return null;
 };
@@ -82,6 +86,7 @@ interface ResolvedSource {
 interface SourceResolutionContext {
   sourceContentCache: Map<string, string | null>;
   fetchFn?: SourceFetch;
+  requestOptions?: SourceMapRequestOptions;
 }
 
 const resolveOriginalSource = async (
@@ -90,9 +95,9 @@ const resolveOriginalSource = async (
   runtimeColumn: number,
   context: SourceResolutionContext,
 ): Promise<ResolvedSource | null> => {
-  const { sourceContentCache, fetchFn } = context;
+  const { sourceContentCache, fetchFn, requestOptions } = context;
 
-  const sourceMap = await getSourceMap(runtimeFileName, true, fetchFn);
+  const sourceMap = await getSourceMap(runtimeFileName, true, fetchFn, requestOptions);
 
   if (sourceMap) {
     const originalLocation = getSourceFromSourceMap(sourceMap, runtimeLine, runtimeColumn);
@@ -136,6 +141,7 @@ const resolveOriginalSource = async (
 export const parseHookNames = async (
   hooksTree: HooksTree,
   fetchFn?: SourceFetch,
+  requestOptions?: SourceMapRequestOptions,
 ): Promise<HookNames> => {
   const hookNames: HookNames = new Map();
   const hooksList = flattenHooksTree(hooksTree);
@@ -145,6 +151,7 @@ export const parseHookNames = async (
   const resolutionContext: SourceResolutionContext = {
     sourceContentCache: new Map(),
     fetchFn,
+    requestOptions,
   };
 
   await Promise.all(

package/src/source/renderer-dispatchers.ts

@@ -1,9 +1,14 @@
 import type { RendererDispatcherRef } from "../react-internals/index.js";
-import { _renderers, getRDTHook } from "../rdt-hook.js";
+import { _renderers, getRDTHook, isRendererMap } from "../rdt-hook.js";
+import type { ReactDevToolsTarget } from "../rdt-hook.js";
 
-export const getRendererDispatcherRefs = (): RendererDispatcherRef[] => {
-  const rdtHook = getRDTHook();
-  const renderers = new Set([..._renderers, ...rdtHook.renderers.values()]);
+export const getRendererDispatcherRefs = (
+  target: ReactDevToolsTarget = globalThis,
+): RendererDispatcherRef[] => {
+  const rdtHook = getRDTHook(undefined, target);
+  const targetRenderers = isRendererMap(rdtHook.renderers) ? rdtHook.renderers.values() : [];
+  const renderers =
+    target === globalThis ? new Set([..._renderers, ...targetRenderers]) : new Set(targetRenderers);
   const currentDispatcherRefs: RendererDispatcherRef[] = [];
   const seenCurrentDispatcherRefs = new Set<object>();
   for (const renderer of renderers) {

package/src/source/symbolication.ts

@@ -39,6 +39,7 @@ export interface SourceFetch {
 }
 
 export interface SourceMapRequestOptions {
+  allowCrossOriginSourceMap?: boolean;
   allowUnsafeServerFetch?: boolean;
   maxBundleSizeBytes?: number;
   maxSourceMapSizeBytes?: number;
@@ -49,6 +50,7 @@ export interface SourceMapRequestOptions {
 export interface SourceMap {
   file?: string;
   ignoredSourceIndices?: Set<number>;
+  sourceMapUrl?: string;
   mappings: SourceMapSegment[][];
   names?: string[];
   sections?: DecodedSourceMapSection[];
@@ -298,10 +300,14 @@ const resolveUrl = (reference: string, baseUrl: string): string | null => {
     return new URL(reference, baseUrl).toString();
   } catch {
     try {
-      const resolvedUrl = new URL(reference, new URL(baseUrl, "https://bippy.invalid/"));
-      return `${resolvedUrl.pathname}${resolvedUrl.search}${resolvedUrl.hash}`;
+      return new URL(reference).toString();
     } catch {
-      return null;
+      try {
+        const resolvedUrl = new URL(reference, new URL(baseUrl, "https://bippy.invalid/"));
+        return `${resolvedUrl.pathname}${resolvedUrl.search}${resolvedUrl.hash}`;
+      } catch {
+        return null;
+      }
     }
   }
 };
@@ -460,6 +466,11 @@ const resolveSourceMapSources = (rawSourceMap: StandardSourceMap, sourceMapUrl:
     resolveSourceRoot(rawSourceMap.sourceRoot, source, sourceMapUrl),
   );
 
+// An inline URL carries the whole encoded map, so retaining it in the cache would
+// double the memory held per source map for the lifetime of the process.
+const getRetainableSourceMapUrl = (sourceMapUrl: string): string | undefined =>
+  INLINE_SOURCEMAP_REGEX.test(sourceMapUrl) ? undefined : sourceMapUrl;
+
 const decodeStandardSourceMap = (
   rawSourceMap: StandardSourceMap,
   sourceMapUrl: string,
@@ -470,6 +481,7 @@ const decodeStandardSourceMap = (
       ignoredSourceIndices: getIgnoredSourceIndices(rawSourceMap),
       mappings: decode(rawSourceMap.mappings),
       names: rawSourceMap.names,
+      sourceMapUrl: getRetainableSourceMapUrl(sourceMapUrl),
       sourceRoot: rawSourceMap.sourceRoot,
       sources: resolveSourceMapSources(rawSourceMap, sourceMapUrl),
       sourcesContent: rawSourceMap.sourcesContent,
@@ -532,6 +544,7 @@ const decodeIndexSourceMap = async (
     mappings: [],
     names: [],
     sections: decodedSections,
+    sourceMapUrl: getRetainableSourceMapUrl(sourceMapUrl),
     sourceRoot: undefined,
     sources: Array.from(allSources),
     sourcesContent: undefined,
@@ -782,22 +795,23 @@ const readSourceMapDocument = async (
 
 const getSourceMapUncachedInternal = async (
   bundleUrl: string,
-  fetchFn?: SourceFetch,
+  sourceFetchOverride?: SourceFetch,
   options: SourceMapRequestOptions = {},
 ): Promise<null | SourceMap> => {
-  const shouldAllowCustomProtocol = fetchFn !== undefined;
+  const shouldAllowCustomProtocol = sourceFetchOverride !== undefined;
   if (!isFetchableUrl(bundleUrl, shouldAllowCustomProtocol)) {
     return null;
   }
 
   const isServer = isServerRuntime();
-  const shouldRejectRedirects = isServer || isExtensionUrl(bundleUrl);
-  if (isServer && !fetchFn) {
+  const shouldRejectRedirects =
+    (isServer || isExtensionUrl(bundleUrl)) && !options.allowCrossOriginSourceMap;
+  if (isServer && !sourceFetchOverride) {
     if (!options.allowUnsafeServerFetch || !isAbsoluteHttpUrl(bundleUrl)) return null;
   }
 
   const sourceFetch =
-    fetchFn ??
+    sourceFetchOverride ??
     (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : undefined);
   if (!sourceFetch) return null;
   const maxBundleSizeBytes = options.maxBundleSizeBytes ?? defaultMaxBundleSizeBytes;
@@ -864,11 +878,11 @@ const getSourceMapUncachedInternal = async (
 
 export const getSourceMapUncached = async (
   bundleUrl: string,
-  fetchFn?: SourceFetch,
+  sourceFetch?: SourceFetch,
   options: SourceMapRequestOptions = {},
 ): Promise<null | SourceMap> => {
   try {
-    return await getSourceMapUncachedInternal(bundleUrl, fetchFn, options);
+    return await getSourceMapUncachedInternal(bundleUrl, sourceFetch, options);
   } catch (error) {
     if (error instanceof TransientSourceMapError) return null;
     throw error;
@@ -878,66 +892,67 @@ export const getSourceMapUncached = async (
 const getPerFetchMap = <Value>(
   mapsByFetch: WeakMap<SourceFetch, Map<string, Value>>,
   globalMap: Map<string, Value>,
-  fetchFn: SourceFetch | undefined,
+  sourceFetch: SourceFetch | undefined,
 ): Map<string, Value> => {
-  if (!fetchFn) return globalMap;
-  let map = mapsByFetch.get(fetchFn);
+  if (!sourceFetch) return globalMap;
+  let map = mapsByFetch.get(sourceFetch);
   if (!map) {
     map = new Map();
-    mapsByFetch.set(fetchFn, map);
+    mapsByFetch.set(sourceFetch, map);
   }
   return map;
 };
 
-const getSourceMapCache = (fetchFn: SourceFetch | undefined): Map<string, null | SourceMap> =>
-  getPerFetchMap(sourceMapCachesByFetch, sourceMapCache, fetchFn);
+const getSourceMapCache = (sourceFetch: SourceFetch | undefined): Map<string, null | SourceMap> =>
+  getPerFetchMap(sourceMapCachesByFetch, sourceMapCache, sourceFetch);
 
 const getPendingSourceMapRequests = (
-  fetchFn: SourceFetch | undefined,
+  sourceFetch: SourceFetch | undefined,
 ): Map<string, Promise<SourceMapResult>> =>
-  getPerFetchMap(pendingSourceMapRequestsByFetch, pendingSourceMapRequests, fetchFn);
+  getPerFetchMap(pendingSourceMapRequestsByFetch, pendingSourceMapRequests, sourceFetch);
 
 const getSourceMapCacheKey = (file: string, options: SourceMapRequestOptions): string =>
+  options.allowCrossOriginSourceMap === undefined &&
   options.allowUnsafeServerFetch === undefined &&
   options.maxBundleSizeBytes === undefined &&
   options.maxSourceMapSizeBytes === undefined &&
   options.timeoutMs === undefined
     ? file
-    : `${file}\0${options.allowUnsafeServerFetch ?? ""}\0${options.maxBundleSizeBytes ?? ""}\0${options.maxSourceMapSizeBytes ?? ""}\0${options.timeoutMs ?? ""}`;
+    : `${file}\0${options.allowCrossOriginSourceMap ?? ""}\0${options.allowUnsafeServerFetch ?? ""}\0${options.maxBundleSizeBytes ?? ""}\0${options.maxSourceMapSizeBytes ?? ""}\0${options.timeoutMs ?? ""}`;
 
 export const getSourceMap = async (
   file: string,
-  useCache = true,
-  fetchFn?: SourceFetch,
+  shouldUseCache = true,
+  sourceFetch?: SourceFetch,
   options: SourceMapRequestOptions = {},
 ): Promise<null | SourceMap> => {
-  const shouldUseCache = useCache && options.signal === undefined;
-  const cache = getSourceMapCache(fetchFn);
-  const pendingRequests = getPendingSourceMapRequests(fetchFn);
+  const canUseCache = shouldUseCache && options.signal === undefined;
+  const cache = getSourceMapCache(sourceFetch);
+  const pendingRequests = getPendingSourceMapRequests(sourceFetch);
   const cacheKey = getSourceMapCacheKey(file, options);
-  if (shouldUseCache && cache.has(cacheKey)) {
+  if (canUseCache && cache.has(cacheKey)) {
     return cache.get(cacheKey) ?? null;
   }
 
-  const pendingRequest = shouldUseCache ? pendingRequests.get(cacheKey) : undefined;
+  const pendingRequest = canUseCache ? pendingRequests.get(cacheKey) : undefined;
   if (pendingRequest) {
     return (await pendingRequest).sourceMap;
   }
 
   const fetchPromise: Promise<SourceMapResult> = getSourceMapUncachedInternal(
     file,
-    fetchFn,
+    sourceFetch,
     options,
   ).then(
     (sourceMap) => ({ sourceMap, isTransientFailure: false }),
     () => ({ sourceMap: null, isTransientFailure: true }),
   );
-  if (shouldUseCache) {
+  if (canUseCache) {
     pendingRequests.set(cacheKey, fetchPromise);
   }
 
   const { sourceMap, isTransientFailure } = await fetchPromise;
-  if (shouldUseCache) {
+  if (canUseCache) {
     pendingRequests.delete(cacheKey);
     if (!isTransientFailure) {
       cache.set(cacheKey, sourceMap);
@@ -949,13 +964,19 @@ export const getSourceMap = async (
 
 export const symbolicateStack = async (
   stack: StackFrame[],
-  cache = true,
-  fetchFn?: SourceFetch,
+  shouldUseCache = true,
+  sourceFetch?: SourceFetch,
+  requestOptions: SourceMapRequestOptions = {},
 ): Promise<StackFrame[]> => {
   return Promise.all(
     stack.map(async (stackFrame) => {
       if (!stackFrame.fileName) return stackFrame;
-      const sourceMap = await getSourceMap(stackFrame.fileName, cache, fetchFn);
+      const sourceMap = await getSourceMap(
+        stackFrame.fileName,
+        shouldUseCache,
+        sourceFetch,
+        requestOptions,
+      );
       if (
         !sourceMap ||
         typeof stackFrame.lineNumber !== "number" ||