bippy 0.7.2 → 0.7.3-dev.04de4f7

package/src/source/normalize-file-name.ts

@@ -0,0 +1,416 @@
+import {
+  ABOUT_REACT_PREFIX,
+  ANONYMOUS_FILE_PATTERNS,
+  BUNDLED_FILE_PATTERN_REGEX,
+  INTERNAL_SCHEME_PREFIXES,
+  QUERY_PARAMETER_PATTERN_REGEX,
+  SCHEME_REGEX,
+  SOURCE_FILE_EXTENSION_REGEX,
+} from "./constants.js";
+
+const VITE_FS_PREFIX = "/@fs/";
+const VITE_ID_PREFIX = "/@id/";
+const VITE_NULL_BYTE_PLACEHOLDER = "__x00__";
+const NEXT_WEBPACK_NAMESPACE = "_N_E/";
+const TURBOPACK_PROJECT_TOKEN = "[project]/";
+const WINDOWS_DRIVE_PREFIX = /^[a-zA-Z]:[\\/]/;
+const WINDOWS_DRIVE_SEGMENT = /^[a-zA-Z]:$/;
+const APP_PAGES_BROWSER_PREFIX = /^\/?(?:app-pages-browser|\(app-pages-browser\))\//;
+const NEXT_BUNDLER_LAYER_PREFIX =
+  /^\/?\((?:action-browser|api-edge|api-node|edge-asset|instrument|middleware|pages-dir-browser|pages-dir-edge|pages-dir-node|rsc|shared|ssr)\)\//;
+const ENCODED_SEPARATOR = /%(?:2f|5c)/i;
+const WINDOWS_EXTENDED_PATH_PREFIX = "\\\\?\\";
+const REACT_ENVIRONMENT_PREFIX = /^React\/[^/]+\//;
+const TURBOPACK_MAGIC_IDENTIFIER = /__TURBOPACK__[a-zA-Z0-9_$]+__/g;
+const TURBOPACK_MAGIC_IDENTIFIER_EXACT = /^__TURBOPACK__([a-zA-Z0-9_$]+)__$/;
+const IMPORTED_MODULE_PREFIX = "imported module ";
+const BUNDLER_LAYER_SUFFIX =
+  /\s\[(?:app-[a-z0-9-]+|action-browser|api-edge|api-node|edge-asset|instrument|middleware|pages-dir-browser|pages-dir-edge|pages-dir-node|rsc|shared|ssr)\]$/;
+const BUNDLER_MODULE_TYPE_SUFFIX =
+  /\s\((?:asset|client reference proxy|css(?: client reference| module)?|ecmascript(?: client reference to (?:client|ssr))?|javascript|json|less|mdx|raw|sass|scss|static|typescript|unknown|wasm)\b[^)]*\)$/;
+const BUNDLER_EXPORT_SUFFIX = /\s<(?:exports?|locals|namespace)\b[^>]*>$/;
+const BUNDLER_MODULE_SUFFIXES = [
+  BUNDLER_MODULE_TYPE_SUFFIX,
+  BUNDLER_LAYER_SUFFIX,
+  BUNDLER_EXPORT_SUFFIX,
+];
+
+const isWindowsDrivePath = (filePath: string): boolean => WINDOWS_DRIVE_PREFIX.test(filePath);
+
+const VIRTUAL_SCHEME_PREFIXES = ["astro:", "cloudflare:", "nitro:"] as const;
+
+const isVirtualModuleId = (filePath: string): boolean =>
+  filePath.startsWith("\0") ||
+  filePath.startsWith("virtual:") ||
+  VIRTUAL_SCHEME_PREFIXES.some((prefix) => filePath.startsWith(prefix));
+
+const decodeHex = (hexText: string): string => {
+  if (hexText.trim() === "") throw new Error("empty hex");
+  const codePoint = Number.parseInt(hexText, 16);
+  if (Number.isNaN(codePoint)) throw new Error("invalid hex");
+  return String.fromCodePoint(codePoint);
+};
+
+const decodeMagicIdentifier = (identifier: string): string => {
+  const innerIdentifier = identifier.match(TURBOPACK_MAGIC_IDENTIFIER_EXACT)?.[1];
+  if (!innerIdentifier) return identifier;
+
+  let output = "";
+  let mode: "text" | "underscore" | "hex" | "long-hex" = "text";
+  let buffer = "";
+
+  for (const character of innerIdentifier) {
+    if (mode === "text") {
+      if (character === "_") mode = "underscore";
+      else if (character === "$") mode = "hex";
+      else output += character;
+      continue;
+    }
+
+    if (mode === "underscore") {
+      if (character === "_") output += " ";
+      else if (character === "$") {
+        output += "_";
+        mode = "hex";
+        continue;
+      } else output += character;
+      mode = "text";
+      continue;
+    }
+
+    if (mode === "hex") {
+      if (buffer.length === 2) {
+        output += decodeHex(buffer);
+        buffer = "";
+      }
+      if (character === "_") {
+        if (buffer !== "") throw new Error("invalid hex");
+        mode = "long-hex";
+      } else if (character === "$") {
+        if (buffer !== "") throw new Error("invalid hex");
+        mode = "text";
+      } else {
+        buffer += character;
+      }
+      continue;
+    }
+
+    if (character === "_") throw new Error("invalid hex");
+    if (character === "$") {
+      output += decodeHex(buffer);
+      buffer = "";
+      mode = "text";
+      continue;
+    }
+    buffer += character;
+  }
+
+  return output;
+};
+
+const decodeMagicIdentifiers = (filePath: string): string => {
+  if (!filePath.includes("__TURBOPACK__")) return filePath;
+  const decodedFilePath = filePath.replace(TURBOPACK_MAGIC_IDENTIFIER, (identifier) => {
+    try {
+      return decodeMagicIdentifier(identifier);
+    } catch {
+      return identifier;
+    }
+  });
+  if (!decodedFilePath.startsWith(IMPORTED_MODULE_PREFIX)) return decodedFilePath;
+  return decodedFilePath.slice(IMPORTED_MODULE_PREFIX.length);
+};
+
+const stripBundlerModuleMetadata = (filePath: string): string => {
+  let strippedFilePath = filePath;
+  let didStripMetadata = true;
+  while (didStripMetadata) {
+    didStripMetadata = false;
+    for (const suffix of BUNDLER_MODULE_SUFFIXES) {
+      const suffixMatch = strippedFilePath.match(suffix);
+      if (!suffixMatch?.[0]) continue;
+      strippedFilePath = strippedFilePath.slice(0, -suffixMatch[0].length).trimEnd();
+      didStripMetadata = true;
+      break;
+    }
+  }
+  return strippedFilePath;
+};
+
+const stripWebpackLoaders = (filePath: string): string => {
+  const separatorIndex = filePath.lastIndexOf("!");
+  if (separatorIndex <= 0) return filePath;
+  const loaderPath = filePath.slice(0, separatorIndex);
+  const resourcePath = filePath.slice(separatorIndex + 1);
+  if (!loaderPath.includes("/") && !loaderPath.includes("\\")) return filePath;
+  const isResourcePath =
+    resourcePath.startsWith("./") ||
+    resourcePath.startsWith("../") ||
+    resourcePath.startsWith("/") ||
+    resourcePath.startsWith("\\") ||
+    resourcePath.includes("/") ||
+    resourcePath.includes("\\") ||
+    isWindowsDrivePath(resourcePath);
+  if (!isResourcePath) return filePath;
+  return resourcePath;
+};
+
+const decodePath = (filePath: string): string => {
+  if (!filePath.includes("%")) return filePath;
+  return filePath
+    .split("/")
+    .map((segment) => {
+      if (!segment.includes("%") || ENCODED_SEPARATOR.test(segment)) return segment;
+      try {
+        return decodeURIComponent(segment);
+      } catch {
+        return segment;
+      }
+    })
+    .join("/");
+};
+
+const resolveFileProtocol = (specifier: string): string => {
+  const afterScheme = specifier.slice("file://".length);
+  const postfixIndex = afterScheme.search(/[?#]/);
+  const pathWithHost = postfixIndex === -1 ? afterScheme : afterScheme.slice(0, postfixIndex);
+
+  let hostname = "";
+  let pathname = pathWithHost;
+  if (pathWithHost.startsWith("/")) {
+    pathname = pathWithHost.replace(/^\/+/, "/");
+  } else if (isWindowsDrivePath(pathWithHost)) {
+    pathname = pathWithHost;
+  } else {
+    const slashIndex = pathWithHost.indexOf("/");
+    hostname = slashIndex === -1 ? pathWithHost : pathWithHost.slice(0, slashIndex);
+    pathname = slashIndex === -1 ? "/" : pathWithHost.slice(slashIndex);
+  }
+
+  if (hostname.toLowerCase() === "localhost") hostname = "";
+  if (hostname) {
+    return `//${hostname}${pathname.startsWith("/") ? pathname : `/${pathname}`}`;
+  }
+
+  if (pathname.startsWith("/") && isWindowsDrivePath(pathname.slice(1))) {
+    return pathname.slice(1);
+  }
+  if (isWindowsDrivePath(pathname)) return pathname;
+  return pathname.startsWith("/") ? pathname : `/${pathname}`;
+};
+
+const unwrapViteId = (filePath: string): string => {
+  if (filePath.startsWith(VITE_FS_PREFIX)) {
+    const absolutePath = filePath.slice(VITE_FS_PREFIX.length);
+    if (isWindowsDrivePath(absolutePath)) return absolutePath;
+    return absolutePath.startsWith("/") ? absolutePath : `/${absolutePath}`;
+  }
+
+  if (!filePath.startsWith(VITE_ID_PREFIX)) return filePath;
+  const unwrappedId = filePath
+    .slice(VITE_ID_PREFIX.length)
+    .replaceAll(VITE_NULL_BYTE_PLACEHOLDER, "\0");
+  if (unwrappedId.startsWith("\0") || unwrappedId.startsWith("virtual:")) return "";
+  return unwrappedId;
+};
+
+const stripWebpackNamespace = (filePath: string): string => {
+  if (filePath.startsWith(NEXT_WEBPACK_NAMESPACE)) {
+    return filePath.slice(NEXT_WEBPACK_NAMESPACE.length);
+  }
+  const slashIndex = filePath.indexOf("/");
+  if (slashIndex <= 0) return filePath;
+  const remainder = filePath.slice(slashIndex + 1);
+  if (remainder.startsWith("./") || remainder.startsWith("../")) return remainder;
+  return filePath;
+};
+
+const stripBundlerLayer = (filePath: string, didStripBundlerScheme: boolean): string => {
+  const appPagesMatch = filePath.match(APP_PAGES_BROWSER_PREFIX);
+  if (appPagesMatch?.[0]) return filePath.slice(appPagesMatch[0].length);
+  if (!didStripBundlerScheme) return filePath;
+  const layerMatch = filePath.match(NEXT_BUNDLER_LAYER_PREFIX);
+  if (!layerMatch?.[0]) return filePath;
+  return filePath.slice(layerMatch[0].length);
+};
+
+const stripUrlPostfix = (filePath: string): string => {
+  const hashIndex = filePath.indexOf("#");
+  const withoutHash = hashIndex === -1 ? filePath : filePath.slice(0, hashIndex);
+  const queryParameterIndex = withoutHash.indexOf("?");
+  if (queryParameterIndex === -1) return withoutHash;
+  const potentialQueryParameters = withoutHash.slice(queryParameterIndex);
+  if (!QUERY_PARAMETER_PATTERN_REGEX.test(potentialQueryParameters)) return withoutHash;
+  return withoutHash.slice(0, queryParameterIndex);
+};
+
+const normalizeLexicalPath = (filePath: string): string => {
+  if (!filePath || filePath.includes("\\")) return filePath;
+  const isAbsolute = filePath.startsWith("/");
+  const isNetworkPath = filePath.startsWith("//");
+  const hasRelativeDotPrefix = filePath.startsWith("./");
+  const normalizedSegments: string[] = [];
+
+  for (const segment of filePath.split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      const previousSegment = normalizedSegments[normalizedSegments.length - 1];
+      if (
+        previousSegment &&
+        previousSegment !== ".." &&
+        (!isNetworkPath || normalizedSegments.length > 2) &&
+        !WINDOWS_DRIVE_SEGMENT.test(previousSegment)
+      ) {
+        normalizedSegments.pop();
+      } else if (!isAbsolute && !WINDOWS_DRIVE_SEGMENT.test(previousSegment ?? "")) {
+        normalizedSegments.push("..");
+      }
+      continue;
+    }
+    normalizedSegments.push(segment);
+  }
+
+  if (isAbsolute) return `${isNetworkPath ? "//" : "/"}${normalizedSegments.join("/")}`;
+  const joinedPath = normalizedSegments.join("/");
+  if (!joinedPath) return hasRelativeDotPrefix ? "./" : "";
+  if (hasRelativeDotPrefix && !joinedPath.startsWith("../")) return `./${joinedPath}`;
+  return joinedPath;
+};
+
+export const normalizeFileName = (fileName: string): string => {
+  if (!fileName) return "";
+  if (ANONYMOUS_FILE_PATTERNS.some((pattern) => pattern === fileName)) return "";
+  if (isVirtualModuleId(fileName)) return "";
+
+  let normalizedFileName = fileName;
+  if (normalizedFileName.startsWith(WINDOWS_EXTENDED_PATH_PREFIX)) {
+    const extendedPath = normalizedFileName.slice(WINDOWS_EXTENDED_PATH_PREFIX.length);
+    if (isWindowsDrivePath(extendedPath)) normalizedFileName = extendedPath;
+  }
+  normalizedFileName = decodeMagicIdentifiers(normalizedFileName);
+  if (isVirtualModuleId(normalizedFileName)) return "";
+
+  let didStripWebpackScheme = false;
+  let didStripBundlerScheme = false;
+  let didStripRscScheme = false;
+  let didResolveFileProtocol = false;
+
+  const isHttpUrl =
+    normalizedFileName.startsWith("http://") || normalizedFileName.startsWith("https://");
+  if (isHttpUrl) {
+    try {
+      normalizedFileName = new URL(normalizedFileName).pathname;
+    } catch {}
+    normalizedFileName = stripSingleBasePathPrefix(normalizedFileName);
+  }
+
+  if (normalizedFileName.startsWith(ABOUT_REACT_PREFIX)) {
+    const remainder = normalizedFileName.slice(ABOUT_REACT_PREFIX.length);
+    const slashIndex = remainder.indexOf("/");
+    const colonIndex = remainder.indexOf(":");
+    normalizedFileName =
+      slashIndex !== -1 && (colonIndex === -1 || slashIndex < colonIndex)
+        ? remainder.slice(slashIndex + 1)
+        : remainder;
+  }
+
+  let didStripPrefix = true;
+  while (didStripPrefix) {
+    didStripPrefix = false;
+    if (normalizedFileName.startsWith("file://")) {
+      const resolvedFilePath = resolveFileProtocol(normalizedFileName);
+      if (resolvedFilePath === normalizedFileName) break;
+      normalizedFileName = resolvedFilePath;
+      didResolveFileProtocol = true;
+      didStripPrefix = true;
+      continue;
+    }
+    if (didStripRscScheme) {
+      const reactEnvironmentMatch = normalizedFileName.match(REACT_ENVIRONMENT_PREFIX);
+      if (reactEnvironmentMatch?.[0]) {
+        normalizedFileName = normalizedFileName.slice(reactEnvironmentMatch[0].length);
+        didStripRscScheme = false;
+        didStripPrefix = true;
+        continue;
+      }
+    }
+    for (const prefix of INTERNAL_SCHEME_PREFIXES) {
+      if (!normalizedFileName.startsWith(prefix)) continue;
+      if (prefix === "rsc://") didStripRscScheme = true;
+      if (prefix === "webpack://" || prefix === "rspack://") didStripWebpackScheme = true;
+      if (
+        prefix === "webpack://" ||
+        prefix === "webpack-internal://" ||
+        prefix === "rspack://" ||
+        prefix === "rspack-internal://" ||
+        prefix === "turbopack://"
+      ) {
+        didStripBundlerScheme = true;
+      }
+      normalizedFileName = normalizedFileName.slice(prefix.length);
+      didStripPrefix = true;
+      break;
+    }
+  }
+
+  if (isVirtualModuleId(normalizedFileName)) return "";
+
+  if (!isWindowsDrivePath(normalizedFileName)) {
+    const schemeMatch = normalizedFileName.match(SCHEME_REGEX);
+    if (schemeMatch) normalizedFileName = normalizedFileName.slice(schemeMatch[0].length);
+  }
+
+  if (!didResolveFileProtocol && normalizedFileName.startsWith("//")) {
+    const firstPathSlashIndex = normalizedFileName.indexOf("/", 2);
+    normalizedFileName =
+      firstPathSlashIndex === -1 ? "" : normalizedFileName.slice(firstPathSlashIndex);
+  }
+
+  normalizedFileName = unwrapViteId(normalizedFileName);
+  if (didStripWebpackScheme) normalizedFileName = stripWebpackNamespace(normalizedFileName);
+  normalizedFileName = stripBundlerLayer(normalizedFileName, didStripBundlerScheme);
+  if (normalizedFileName.startsWith(TURBOPACK_PROJECT_TOKEN)) {
+    normalizedFileName = `./${normalizedFileName.slice(TURBOPACK_PROJECT_TOKEN.length)}`;
+  } else if (normalizedFileName.startsWith(`/${TURBOPACK_PROJECT_TOKEN}`)) {
+    normalizedFileName = normalizedFileName.slice(TURBOPACK_PROJECT_TOKEN.length);
+  }
+  normalizedFileName = stripBundlerModuleMetadata(normalizedFileName);
+  const resourcePath = stripWebpackLoaders(normalizedFileName);
+  if (resourcePath !== normalizedFileName) return normalizeFileName(resourcePath);
+  normalizedFileName = stripUrlPostfix(normalizedFileName);
+  normalizedFileName = decodePath(normalizedFileName);
+  normalizedFileName = normalizeLexicalPath(normalizedFileName);
+  if (isVirtualModuleId(normalizedFileName)) return "";
+  return normalizedFileName;
+};
+
+const getPathSegmentCount = (path: string): number => path.split("/").filter(Boolean).length;
+
+const stripSingleBasePathPrefix = (path: string): string => {
+  const firstSlashIndex = path.indexOf("/", 1);
+  if (firstSlashIndex === -1) return path;
+
+  const basePath = path.slice(0, firstSlashIndex);
+  if (getPathSegmentCount(basePath) !== 1) return path;
+  if (basePath === "/@fs" || basePath === "/@id") return path;
+
+  const remainderPath = path.slice(firstSlashIndex);
+  if (!SOURCE_FILE_EXTENSION_REGEX.test(remainderPath)) return path;
+
+  const remainderSegments = remainderPath.split("/").filter(Boolean);
+  if (remainderSegments.length < 2) return path;
+
+  const firstRemainderSegment = remainderSegments[0];
+  if (!firstRemainderSegment || firstRemainderSegment.startsWith("@")) return path;
+  if (firstRemainderSegment.length > 4) return path;
+  return remainderPath;
+};
+
+export const isSourceFile = (fileName: string): boolean => {
+  const normalizedFileName = normalizeFileName(fileName);
+  if (!normalizedFileName) return false;
+  if (normalizedFileName.includes("\0") || normalizedFileName.startsWith("virtual:")) return false;
+  if (!SOURCE_FILE_EXTENSION_REGEX.test(normalizedFileName)) return false;
+  if (BUNDLED_FILE_PATTERN_REGEX.test(normalizedFileName)) return false;
+  return true;
+};

package/src/source/owner-stack.ts

@@ -7,7 +7,6 @@ import type {
 } from "../react-internals/index.js";
 import {
   REACT_STACK_BOTTOM_FRAME_PATTERNS,
-  SERVER_FRAME_MARKER,
   SERVER_ENV_PATTERN,
   SERVER_COMPONENT_URL_PREFIXES,
 } from "./constants.js";
@@ -19,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;
@@ -101,12 +104,18 @@ const describeBuiltInComponentFrame = (name: string): string => {
   return `\n    in ${name}`;
 };
 
-export const describeDebugInfoFrame = (name: string, env?: string): string => {
-  let frameDescription = describeBuiltInComponentFrame(name);
-  if (env) {
-    frameDescription += ` (at ${env})`;
+export const describeDebugInfoFrame = (
+  name: string,
+  env?: string,
+  location?: Error | null,
+): string => {
+  if (location) {
+    const childStack = formatOwnerStack(location.stack ?? "");
+    const lastNewlineIndex = childStack.lastIndexOf("\n");
+    const lastLine = lastNewlineIndex === -1 ? childStack : childStack.slice(lastNewlineIndex + 1);
+    if (lastLine.includes(name)) return `\n${lastLine}`;
   }
-  return frameDescription;
+  return describeBuiltInComponentFrame(`${name}${env ? ` [${env}]` : ""}`);
 };
 
 let reEntry = false;
@@ -115,7 +124,7 @@ let reEntry = false;
 // component type like React DevTools does.
 const componentFrameCache = new WeakMap<React.ComponentType<unknown>, string>();
 
-// https://github.com/facebook/react/blob/f739642745577a8e4dcb9753836ac3589b9c590a/packages/react-devtools-shared/src/backend/shared/DevToolsComponentStackFrame.js#L22
+// https://github.com/facebook/react/blob/eafeac0/packages/shared/ReactComponentStackFrame.js#L64
 const describeNativeComponentFrame = (
   component: React.ComponentType<unknown>,
   construct: boolean,
@@ -153,21 +162,12 @@ const describeNativeComponentFrame = (
                 throw Error();
               },
             });
-            if (typeof Reflect === "object" && Reflect.construct) {
-              try {
-                Reflect.construct(ThrowingConstructor, []);
-              } catch (caughtError) {
-                control = caughtError;
-              }
-              Reflect.construct(component, [], ThrowingConstructor);
-            } else {
-              try {
-                Function.prototype.apply.call(ThrowingConstructor, undefined, []);
-              } catch (caughtError) {
-                control = caughtError;
-              }
-              Function.prototype.apply.call(component, ThrowingConstructor.prototype, []);
+            try {
+              Reflect.construct(ThrowingConstructor, []);
+            } catch (caughtError) {
+              control = caughtError;
             }
+            Reflect.construct(component, [], ThrowingConstructor);
           } else {
             try {
               throw Error();
@@ -312,7 +312,7 @@ const describeNativeComponentFrame = (
   return syntheticFrame;
 };
 
-// https://github.com/facebook/react/blob/ac3e705a18696168acfcaed39dce0cfaa6be8836/packages/react-reconciler/src/ReactFiberComponentStack.js#L180
+// https://github.com/facebook/react/blob/eafeac0/packages/react-reconciler/src/ReactFiberComponentStack.js#L37
 export const describeFiber = (fiber: Fiber, childFiber: Fiber | null): string => {
   let stackFrame = "";
   const workTags = getReactWorkTagsForFiber(fiber);
@@ -384,7 +384,11 @@ export const getFallbackParentStack = (thisFiber: Fiber): string => {
         for (let debugInfoIndex = debugInfo.length - 1; debugInfoIndex >= 0; debugInfoIndex--) {
           const debugEntry = debugInfo[debugInfoIndex];
           if (typeof debugEntry.name === "string") {
-            componentStack += describeDebugInfoFrame(debugEntry.name, debugEntry.env);
+            componentStack += describeDebugInfoFrame(
+              debugEntry.name,
+              debugEntry.env,
+              debugEntry.debugLocation,
+            );
           }
         }
       }
@@ -511,7 +515,7 @@ const getEnrichedServerStackFrame = (
     lineNumber: resolvedRscFrame.lineNumber,
     columnNumber: resolvedRscFrame.columnNumber,
     source: serverFrame.source?.replace(
-      SERVER_FRAME_MARKER,
+      SERVER_ENV_PATTERN,
       `(${resolvedRscFrame.fileName}:${resolvedRscFrame.lineNumber}:${resolvedRscFrame.columnNumber})`,
     ),
   };
@@ -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-debug-stack.ts

@@ -1,6 +1,6 @@
 import { JSX_FACTORY_FRAME_COUNT, REACT_STACK_BOTTOM_FRAME_PATTERNS } from "./constants.js";
 import { getPrepareStackTrace, setPrepareStackTrace } from "./error-stack.js";
-import { parseStack, StackFrame } from "./parse-stack.js";
+import { parseStack, type StackFrame } from "./parse-stack.js";
 
 interface V8CallSite {
   getFunctionName?: () => string | null;

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(