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

package/src/source/symbolication.ts

@@ -1,7 +1,8 @@
-import { decode, SourceMapMappings, type SourceMapSegment } from "@jridgewell/sourcemap-codec";
+import { decode, type SourceMapMappings, type SourceMapSegment } from "@jridgewell/sourcemap-codec";
 
 import { BippySourceMapError } from "../errors.js";
-import { StackFrame } from "./parse-stack.js";
+import { SCHEME_REGEX } from "./constants.js";
+import type { StackFrame } from "./parse-stack.js";
 
 export interface DecodedSourceMapSection {
   map: {
@@ -38,6 +39,7 @@ export interface SourceFetch {
 }
 
 export interface SourceMapRequestOptions {
+  allowUnsafeServerFetch?: boolean;
   maxBundleSizeBytes?: number;
   maxSourceMapSizeBytes?: number;
   signal?: AbortSignal;
@@ -68,7 +70,6 @@ export interface StandardSourceMap {
   x_google_ignoreList?: number[];
 }
 
-const SCHEME_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
 const INLINE_SOURCEMAP_REGEX = /^data:application\/json(?:;[^,]*)?,/i;
 const SOURCEMAP_REGEX =
   /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*(?:\*\/)[ \t]*$)/;
@@ -80,13 +81,44 @@ interface SourceMapResult {
   isTransientFailure: boolean;
 }
 
-const _pendingSourceMapRequests = new Map<string, Promise<SourceMapResult>>();
+class TransientSourceMapError extends Error {}
+
+const pendingSourceMapRequests = new Map<string, Promise<SourceMapResult>>();
 const pendingSourceMapRequestsByFetch = new WeakMap<
   SourceFetch,
   Map<string, Promise<SourceMapResult>>
 >();
 const defaultMaxBundleSizeBytes = 25 * 1024 * 1024;
 const defaultMaxSourceMapSizeBytes = 100 * 1024 * 1024;
+const extensionProtocols = new Set([
+  "chrome-extension:",
+  "moz-extension:",
+  "safari-web-extension:",
+]);
+const defaultFetchableProtocols = new Set(["http:", "https:", ...extensionProtocols]);
+
+const getSourceFromSegment = (
+  segment: SourceMapSegment,
+  sources: string[],
+  ignoredSourceIndices?: Set<number>,
+  names?: string[],
+): StackFrame | null => {
+  const [, sourceIndex, sourceLine, sourceColumn, nameIndex] = segment;
+  if (sourceIndex === undefined || sourceLine === undefined || sourceColumn === undefined) {
+    return null;
+  }
+
+  const fileName = sources[sourceIndex];
+  if (!fileName) return null;
+
+  return {
+    columnNumber: sourceColumn,
+    fileName,
+    functionName: nameIndex === undefined ? undefined : names?.[nameIndex] || undefined,
+    isIgnoreListed: ignoredSourceIndices?.has(sourceIndex) ?? false,
+    lineNumber: sourceLine + 1,
+  };
+};
 
 const getSourceFromMappings = (
   mappings: SourceMapMappings,
@@ -94,6 +126,7 @@ const getSourceFromMappings = (
   lineIndexInMappings: number,
   column: number,
   ignoredSourceIndices?: Set<number>,
+  names?: string[],
 ): StackFrame | null => {
   if (lineIndexInMappings < 0 || lineIndexInMappings >= mappings.length) {
     return null;
@@ -121,24 +154,7 @@ const getSourceFromMappings = (
     return null;
   }
 
-  const [, sourceIndex, sourceLine, sourceColumn] = closestLineSegment;
-
-  if (sourceIndex === undefined || sourceLine === undefined || sourceColumn === undefined) {
-    return null;
-  }
-
-  const fileName = sources[sourceIndex];
-
-  if (!fileName) {
-    return null;
-  }
-
-  return {
-    columnNumber: sourceColumn,
-    fileName,
-    lineNumber: sourceLine + 1,
-    isIgnoreListed: ignoredSourceIndices?.has(sourceIndex) ?? false,
-  };
+  return getSourceFromSegment(closestLineSegment, sources, ignoredSourceIndices, names);
 };
 
 export const getSourceFromSourceMap = (
@@ -175,6 +191,7 @@ export const getSourceFromSourceMap = (
       relativeLine,
       relativeColumn,
       targetSection.map.ignoredSourceIndices,
+      targetSection.map.names,
     );
   }
 
@@ -184,9 +201,97 @@ export const getSourceFromSourceMap = (
     line - 1,
     column,
     sourceMap.ignoredSourceIndices,
+    sourceMap.names,
   );
 };
 
+const getSourceFromMappingsByFunctionName = (
+  mappings: SourceMapMappings,
+  sources: string[],
+  names: string[] | undefined,
+  functionName: string,
+  ignoredSourceIndices?: Set<number>,
+): StackFrame | null => {
+  if (!names) return null;
+  const functionNameIndex = names.indexOf(functionName);
+  if (functionNameIndex === -1) return null;
+
+  let ignoredSource: StackFrame | null = null;
+  for (const lineMapping of mappings) {
+    for (const segment of lineMapping) {
+      if (segment[4] !== functionNameIndex) continue;
+      const source = getSourceFromSegment(segment, sources, ignoredSourceIndices, names);
+      if (!source) continue;
+      if (!source.isIgnoreListed) return source;
+      ignoredSource ??= source;
+    }
+  }
+  return ignoredSource;
+};
+
+export const getSourceFromSourceMapByFunctionName = (
+  sourceMap: SourceMap,
+  functionName: string,
+): StackFrame | null => {
+  if (sourceMap.sections) {
+    let ignoredSource: StackFrame | null = null;
+    for (const section of sourceMap.sections) {
+      const source = getSourceFromMappingsByFunctionName(
+        section.map.mappings,
+        section.map.sources,
+        section.map.names,
+        functionName,
+        section.map.ignoredSourceIndices,
+      );
+      if (!source) continue;
+      if (!source.isIgnoreListed) return source;
+      ignoredSource ??= source;
+    }
+    return ignoredSource;
+  }
+
+  return getSourceFromMappingsByFunctionName(
+    sourceMap.mappings,
+    sourceMap.sources,
+    sourceMap.names,
+    functionName,
+    sourceMap.ignoredSourceIndices,
+  );
+};
+
+const findSourceContentByFileName = (
+  sources: string[],
+  sourcesContent: Array<string | null> | undefined,
+  fileName: string,
+): string | null => {
+  if (!sourcesContent) return null;
+  const sourceIndex = sources.indexOf(fileName);
+  return sourceIndex === -1 ? null : (sourcesContent[sourceIndex] ?? null);
+};
+
+export const getSourceContentFromSourceMap = (
+  sourceMap: SourceMap,
+  originalFileName: string,
+): string | null => {
+  const sourceContent = findSourceContentByFileName(
+    sourceMap.sources,
+    sourceMap.sourcesContent,
+    originalFileName,
+  );
+  if (sourceContent !== null) return sourceContent;
+
+  if (!sourceMap.sections) return null;
+  for (const section of sourceMap.sections) {
+    const sectionSourceContent = findSourceContentByFileName(
+      section.map.sources,
+      section.map.sourcesContent,
+      originalFileName,
+    );
+    if (sectionSourceContent !== null) return sectionSourceContent;
+  }
+  return null;
+};
+
 const resolveUrl = (reference: string, baseUrl: string): string | null => {
   if (INLINE_SOURCEMAP_REGEX.test(reference)) return reference;
   try {
@@ -201,12 +306,43 @@ const resolveUrl = (reference: string, baseUrl: string): string | null => {
   }
 };
 
-const getSourceMapUrl = (url: string, content: string): null | string => {
+const getMetroSourceMapUrl = (bundleUrl: string): string | null => {
+  try {
+    const parsedBundleUrl = new URL(bundleUrl);
+    const bundleExtensionIndex = parsedBundleUrl.pathname.lastIndexOf(".bundle");
+    if (bundleExtensionIndex === -1) return null;
+    const embeddedSearch = parsedBundleUrl.pathname.slice(bundleExtensionIndex + ".bundle".length);
+    if (embeddedSearch && !embeddedSearch.startsWith("//&")) return null;
+    parsedBundleUrl.pathname = `${parsedBundleUrl.pathname.slice(0, bundleExtensionIndex)}.map`;
+    if (embeddedSearch) {
+      const embeddedSearchParameters = new URLSearchParams(embeddedSearch.slice("//&".length));
+      for (const [parameterName, parameterValue] of embeddedSearchParameters) {
+        parsedBundleUrl.searchParams.set(parameterName, parameterValue);
+      }
+    }
+    parsedBundleUrl.hash = "";
+    return parsedBundleUrl.toString();
+  } catch {
+    return null;
+  }
+};
+
+const getSourceMapUrl = (
+  bundleUrl: string,
+  bundleContent: string,
+  bundleResponse: Response,
+): null | string => {
+  const sourceMapHeader =
+    bundleResponse.headers.get("sourcemap") ?? bundleResponse.headers.get("x-sourcemap");
+  if (sourceMapHeader) {
+    return resolveUrl(sourceMapHeader.trim(), bundleUrl);
+  }
+
   let sourceMapUrl: string | undefined;
-  let searchEnd = content.length;
+  let searchEnd = bundleContent.length;
   while (searchEnd > 0 && !sourceMapUrl) {
-    const lineStart = content.lastIndexOf("\n", searchEnd - 1) + 1;
-    const regexMatch = content.slice(lineStart, searchEnd).match(SOURCEMAP_REGEX);
+    const lineStart = bundleContent.lastIndexOf("\n", searchEnd - 1) + 1;
+    const regexMatch = bundleContent.slice(lineStart, searchEnd).match(SOURCEMAP_REGEX);
     if (regexMatch) {
       sourceMapUrl = regexMatch[1] || regexMatch[2];
     }
@@ -214,65 +350,82 @@ const getSourceMapUrl = (url: string, content: string): null | string => {
   }
 
   if (!sourceMapUrl) {
-    return null;
+    return getMetroSourceMapUrl(bundleUrl);
   }
 
-  return resolveUrl(sourceMapUrl, url);
+  return resolveUrl(sourceMapUrl, bundleUrl);
 };
 
-const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null;
-
-const isStringArray = (value: unknown): value is string[] =>
-  Array.isArray(value) && value.every((entry) => typeof entry === "string");
-
-const isSourcesContent = (value: unknown): value is Array<string | null> =>
-  Array.isArray(value) && value.every((entry) => typeof entry === "string" || entry === null);
-
-const isOptionalNumberArray = (value: unknown): value is number[] | undefined =>
-  value === undefined ||
-  (Array.isArray(value) && value.every((entry) => Number.isInteger(entry) && entry >= 0));
-
 const isStandardSourceMap = (value: unknown): value is StandardSourceMap => {
-  if (!isObjectRecord(value)) return false;
-  const hasValidShape =
-    value.version === 3 &&
-    typeof value.mappings === "string" &&
-    isStringArray(value.sources) &&
-    (value.file === undefined || typeof value.file === "string") &&
-    (value.names === undefined || isStringArray(value.names)) &&
-    (value.sourceRoot === undefined || typeof value.sourceRoot === "string") &&
-    (value.sourcesContent === undefined || isSourcesContent(value.sourcesContent)) &&
-    isOptionalNumberArray(value.ignoreList) &&
-    isOptionalNumberArray(value.x_google_ignoreList);
-  if (!hasValidShape) return false;
-  if (value.sourcesContent && value.sourcesContent.length !== value.sources.length) return false;
-  return [...(value.ignoreList ?? []), ...(value.x_google_ignoreList ?? [])].every(
-    (sourceIndex) => sourceIndex < value.sources.length,
+  if (typeof value !== "object" || value === null) return false;
+  const version = Reflect.get(value, "version");
+  const mappings = Reflect.get(value, "mappings");
+  const file = Reflect.get(value, "file");
+  const names = Reflect.get(value, "names");
+  const sourceRoot = Reflect.get(value, "sourceRoot");
+  const sources = Reflect.get(value, "sources");
+  const sourcesContent = Reflect.get(value, "sourcesContent");
+  const ignoreList = Reflect.get(value, "ignoreList");
+  const googleIgnoreList = Reflect.get(value, "x_google_ignoreList");
+  if (
+    version !== 3 ||
+    typeof mappings !== "string" ||
+    (file !== undefined && typeof file !== "string") ||
+    (names !== undefined &&
+      (!Array.isArray(names) || names.some((entry) => typeof entry !== "string"))) ||
+    (sourceRoot !== undefined && typeof sourceRoot !== "string") ||
+    (sourcesContent !== undefined &&
+      (!Array.isArray(sourcesContent) ||
+        sourcesContent.some((entry) => typeof entry !== "string" && entry !== null))) ||
+    (ignoreList !== undefined &&
+      (!Array.isArray(ignoreList) ||
+        ignoreList.some((entry) => !Number.isInteger(entry) || entry < 0))) ||
+    (googleIgnoreList !== undefined &&
+      (!Array.isArray(googleIgnoreList) ||
+        googleIgnoreList.some((entry) => !Number.isInteger(entry) || entry < 0)))
+  ) {
+    return false;
+  }
+  if (!Array.isArray(sources) || sources.some((entry) => typeof entry !== "string")) return false;
+  if (sourcesContent && sourcesContent.length !== sources.length) return false;
+  const sourceCount = sources.length;
+  return [...(ignoreList ?? []), ...(googleIgnoreList ?? [])].every(
+    (sourceIndex) => sourceIndex < sourceCount,
   );
 };
 
 const isIndexSourceMap = (value: unknown): value is IndexSourceMap => {
-  if (!isObjectRecord(value) || value.version !== 3 || !Array.isArray(value.sections)) {
+  if (typeof value !== "object" || value === null) return false;
+  const version = Reflect.get(value, "version");
+  const sections = Reflect.get(value, "sections");
+  if (version !== 3 || !Array.isArray(sections)) {
     return false;
   }
-  return value.sections.every((section) => {
-    if (!isObjectRecord(section) || !isObjectRecord(section.offset)) return false;
-    const hasMap = isStandardSourceMap(section.map);
-    const hasUrl = typeof section.url === "string" && section.url.length > 0;
+  return sections.every((section: unknown) => {
+    if (typeof section !== "object" || section === null) return false;
+    const map = Reflect.get(section, "map");
+    const url = Reflect.get(section, "url");
+    const offset = Reflect.get(section, "offset");
+    if (typeof offset !== "object" || offset === null) return false;
+    const offsetColumn = Reflect.get(offset, "column");
+    const offsetLine = Reflect.get(offset, "line");
+    const hasMap = isStandardSourceMap(map);
+    const hasUrl = typeof url === "string" && url.length > 0;
     return (
       hasMap !== hasUrl &&
-      Number.isInteger(section.offset.column) &&
-      section.offset.column >= 0 &&
-      Number.isInteger(section.offset.line) &&
-      section.offset.line >= 0
+      typeof offsetColumn === "number" &&
+      Number.isInteger(offsetColumn) &&
+      offsetColumn >= 0 &&
+      typeof offsetLine === "number" &&
+      Number.isInteger(offsetLine) &&
+      offsetLine >= 0
     );
   });
 };
 
 const getIgnoredSourceIndices = (rawSourceMap: StandardSourceMap): Set<number> | undefined => {
   const ignoreList = rawSourceMap.ignoreList ?? rawSourceMap.x_google_ignoreList;
-  return Array.isArray(ignoreList) && ignoreList.length > 0 ? new Set(ignoreList) : undefined;
+  return ignoreList?.length ? new Set(ignoreList) : undefined;
 };
 
 const resolveSourceRoot = (
@@ -386,7 +539,7 @@ const decodeIndexSourceMap = async (
   };
 };
 
-const isFetchableUrl = (url: string): boolean => {
+const isFetchableUrl = (url: string, shouldAllowCustomProtocol = false): boolean => {
   if (!url) {
     return false;
   }
@@ -405,17 +558,100 @@ const isFetchableUrl = (url: string): boolean => {
 
   const scheme = schemeMatch[0].toLowerCase();
 
-  return scheme === "http:" || scheme === "https:";
+  return shouldAllowCustomProtocol || defaultFetchableProtocols.has(scheme);
+};
+
+const isServerRuntime = (): boolean =>
+  typeof window === "undefined" &&
+  typeof process !== "undefined" &&
+  typeof process.versions?.node === "string";
+
+const isAbsoluteHttpUrl = (url: string): boolean => {
+  try {
+    const parsedUrl = new URL(url);
+    return (
+      (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:") &&
+      !parsedUrl.username &&
+      !parsedUrl.password
+    );
+  } catch {
+    return false;
+  }
+};
+
+const getUrlProtocol = (url: string): string | null => {
+  try {
+    return new URL(url).protocol;
+  } catch {
+    return null;
+  }
+};
+
+const isExtensionUrl = (url: string): boolean => {
+  const protocol = getUrlProtocol(url);
+  return protocol !== null && extensionProtocols.has(protocol);
+};
+
+const isSameOrigin = (firstUrl: string, secondUrl: string): boolean => {
+  try {
+    const firstParsedUrl = new URL(firstUrl);
+    const secondParsedUrl = new URL(secondUrl);
+    return (
+      firstParsedUrl.protocol === secondParsedUrl.protocol &&
+      firstParsedUrl.host === secondParsedUrl.host
+    );
+  } catch {
+    return false;
+  }
+};
+
+const isAllowedSourceMapUrl = (
+  bundleUrl: string,
+  sourceMapUrl: string,
+  shouldRejectCrossOrigin: boolean,
+  shouldAllowCustomProtocol: boolean,
+): boolean => {
+  if (INLINE_SOURCEMAP_REGEX.test(sourceMapUrl)) return true;
+  if (!isFetchableUrl(sourceMapUrl, shouldAllowCustomProtocol)) return false;
+  const bundleProtocol = getUrlProtocol(bundleUrl);
+  const sourceMapProtocol = getUrlProtocol(sourceMapUrl);
+  const hasCustomProtocol =
+    (bundleProtocol !== null && !defaultFetchableProtocols.has(bundleProtocol)) ||
+    (sourceMapProtocol !== null && !defaultFetchableProtocols.has(sourceMapProtocol));
+  const shouldRequireSameOrigin =
+    shouldRejectCrossOrigin ||
+    hasCustomProtocol ||
+    isExtensionUrl(bundleUrl) ||
+    isExtensionUrl(sourceMapUrl);
+  return !shouldRequireSameOrigin || isSameOrigin(bundleUrl, sourceMapUrl);
+};
+
+const isTransientHttpStatus = (status: number): boolean =>
+  status === 408 || status === 425 || status === 429 || status >= 500;
+
+const assertResponseIsCacheable = (response: Response): boolean => {
+  if (response.ok) return true;
+  if (isTransientHttpStatus(response.status)) {
+    throw new TransientSourceMapError();
+  }
+  return false;
 };
 
+const isResponseUrlAllowed = (
+  requestedUrl: string,
+  response: Response,
+  shouldRejectCrossOrigin: boolean,
+): boolean =>
+  !shouldRejectCrossOrigin || response.url.length === 0 || isSameOrigin(requestedUrl, response.url);
+
 interface RequestSignal {
   cleanup: () => void;
   signal?: AbortSignal;
 }
 
 const createRequestSignal = (options: SourceMapRequestOptions): RequestSignal => {
-  if (!options.signal && options.timeoutMs === undefined) {
-    return { cleanup: () => {} };
+  if (options.timeoutMs === undefined || options.timeoutMs < 0) {
+    return { cleanup: () => {}, signal: options.signal };
   }
   const abortController = new AbortController();
   const abortFromSource = (): void => abortController.abort(options.signal?.reason);
@@ -424,16 +660,13 @@ const createRequestSignal = (options: SourceMapRequestOptions): RequestSignal =>
   } else {
     options.signal?.addEventListener("abort", abortFromSource, { once: true });
   }
-  const timeoutHandle =
-    options.timeoutMs !== undefined && options.timeoutMs >= 0
-      ? setTimeout(
-          () => abortController.abort(new BippySourceMapError("Source map request timed out")),
-          options.timeoutMs,
-        )
-      : undefined;
+  const timeoutHandle = setTimeout(
+    () => abortController.abort(new BippySourceMapError("Source map request timed out")),
+    options.timeoutMs,
+  );
   return {
     cleanup: () => {
-      if (timeoutHandle !== undefined) clearTimeout(timeoutHandle);
+      clearTimeout(timeoutHandle);
       options.signal?.removeEventListener("abort", abortFromSource);
     },
     signal: abortController.signal,
@@ -446,8 +679,32 @@ const readResponseText = async (
 ): Promise<string | null> => {
   const contentLength = Number(response.headers.get("content-length"));
   if (Number.isFinite(contentLength) && contentLength > maxSizeBytes) return null;
-  const content = await response.text();
-  return new TextEncoder().encode(content).byteLength <= maxSizeBytes ? content : null;
+  if (!response.body) {
+    const responseText = await response.text();
+    return new TextEncoder().encode(responseText).byteLength > maxSizeBytes ? null : responseText;
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const decodedChunks: string[] = [];
+  let totalSizeBytes = 0;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalSizeBytes += value.byteLength;
+      if (totalSizeBytes > maxSizeBytes) {
+        await reader.cancel();
+        return null;
+      }
+      decodedChunks.push(decoder.decode(value, { stream: true }));
+    }
+    decodedChunks.push(decoder.decode());
+    return decodedChunks.join("");
+  } finally {
+    reader.releaseLock();
+  }
 };
 
 const decodeBase64 = (encodedContent: string): string | null => {
@@ -503,12 +760,17 @@ const readSourceMapDocument = async (
   sourceFetch: SourceFetch,
   signal: AbortSignal | undefined,
   maxSizeBytes: number,
+  shouldRejectRedirects: boolean,
 ): Promise<unknown> => {
   if (INLINE_SOURCEMAP_REGEX.test(sourceMapUrl)) {
     return readInlineSourceMap(sourceMapUrl, maxSizeBytes);
   }
-  const sourceMapResponse = await sourceFetch(sourceMapUrl, { signal });
-  if (!sourceMapResponse.ok) return null;
+  const sourceMapResponse = await sourceFetch(sourceMapUrl, {
+    redirect: shouldRejectRedirects ? "error" : "follow",
+    signal,
+  });
+  if (!assertResponseIsCacheable(sourceMapResponse)) return null;
+  if (!isResponseUrlAllowed(sourceMapUrl, sourceMapResponse, shouldRejectRedirects)) return null;
   const sourceMapContent = await readResponseText(sourceMapResponse, maxSizeBytes);
   if (sourceMapContent === null) return null;
   try {
@@ -518,15 +780,22 @@ const readSourceMapDocument = async (
   }
 };
 
-export const getSourceMapUncached = async (
+const getSourceMapUncachedInternal = async (
   bundleUrl: string,
   fetchFn?: SourceFetch,
   options: SourceMapRequestOptions = {},
 ): Promise<null | SourceMap> => {
-  if (!isFetchableUrl(bundleUrl)) {
+  const shouldAllowCustomProtocol = fetchFn !== undefined;
+  if (!isFetchableUrl(bundleUrl, shouldAllowCustomProtocol)) {
     return null;
   }
 
+  const isServer = isServerRuntime();
+  const shouldRejectRedirects = isServer || isExtensionUrl(bundleUrl);
+  if (isServer && !fetchFn) {
+    if (!options.allowUnsafeServerFetch || !isAbsoluteHttpUrl(bundleUrl)) return null;
+  }
+
   const sourceFetch =
     fetchFn ??
     (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : undefined);
@@ -536,30 +805,55 @@ export const getSourceMapUncached = async (
   if (maxBundleSizeBytes < 0 || maxSourceMapSizeBytes < 0) return null;
   const requestSignal = createRequestSignal(options);
   try {
-    const bundleResponse = await sourceFetch(bundleUrl, { signal: requestSignal.signal });
-    if (!bundleResponse.ok) return null;
+    const bundleResponse = await sourceFetch(bundleUrl, {
+      redirect: shouldRejectRedirects ? "error" : "follow",
+      signal: requestSignal.signal,
+    });
+    if (!assertResponseIsCacheable(bundleResponse)) return null;
+    if (!isResponseUrlAllowed(bundleUrl, bundleResponse, shouldRejectRedirects)) return null;
     const bundleContent = await readResponseText(bundleResponse, maxBundleSizeBytes);
-    if (!bundleContent) return null;
-    const sourceMapUrl = getSourceMapUrl(bundleUrl, bundleContent);
+    if (bundleContent === null) return null;
+    const sourceMapUrl = getSourceMapUrl(bundleUrl, bundleContent, bundleResponse);
     if (!sourceMapUrl) return null;
-    if (!isFetchableUrl(sourceMapUrl) && !INLINE_SOURCEMAP_REGEX.test(sourceMapUrl)) return null;
+    if (
+      !isAllowedSourceMapUrl(
+        bundleUrl,
+        sourceMapUrl,
+        shouldRejectRedirects,
+        shouldAllowCustomProtocol,
+      )
+    ) {
+      return null;
+    }
 
     const rawSourceMap = await readSourceMapDocument(
       sourceMapUrl,
       sourceFetch,
       requestSignal.signal,
       maxSourceMapSizeBytes,
+      shouldRejectRedirects,
     );
     if (isStandardSourceMap(rawSourceMap)) {
       return decodeStandardSourceMap(rawSourceMap, sourceMapUrl);
     }
     if (!isIndexSourceMap(rawSourceMap)) return null;
     return decodeIndexSourceMap(rawSourceMap, sourceMapUrl, async (sectionUrl) => {
+      if (
+        !isAllowedSourceMapUrl(
+          bundleUrl,
+          sectionUrl,
+          shouldRejectRedirects,
+          shouldAllowCustomProtocol,
+        )
+      ) {
+        return null;
+      }
       const sectionSourceMap = await readSourceMapDocument(
         sectionUrl,
         sourceFetch,
         requestSignal.signal,
         maxSourceMapSizeBytes,
+        shouldRejectRedirects,
       );
       return isStandardSourceMap(sectionSourceMap) ? sectionSourceMap : null;
     });
@@ -568,34 +862,48 @@ export const getSourceMapUncached = async (
   }
 };
 
-const getSourceMapCache = (fetchFn: SourceFetch | undefined): Map<string, null | SourceMap> => {
-  if (!fetchFn) return sourceMapCache;
-  let cache = sourceMapCachesByFetch.get(fetchFn);
-  if (!cache) {
-    cache = new Map();
-    sourceMapCachesByFetch.set(fetchFn, cache);
+export const getSourceMapUncached = async (
+  bundleUrl: string,
+  fetchFn?: SourceFetch,
+  options: SourceMapRequestOptions = {},
+): Promise<null | SourceMap> => {
+  try {
+    return await getSourceMapUncachedInternal(bundleUrl, fetchFn, options);
+  } catch (error) {
+    if (error instanceof TransientSourceMapError) return null;
+    throw error;
   }
-  return cache;
 };
 
-const getPendingSourceMapRequests = (
+const getPerFetchMap = <Value>(
+  mapsByFetch: WeakMap<SourceFetch, Map<string, Value>>,
+  globalMap: Map<string, Value>,
   fetchFn: SourceFetch | undefined,
-): Map<string, Promise<SourceMapResult>> => {
-  if (!fetchFn) return _pendingSourceMapRequests;
-  let pendingRequests = pendingSourceMapRequestsByFetch.get(fetchFn);
-  if (!pendingRequests) {
-    pendingRequests = new Map();
-    pendingSourceMapRequestsByFetch.set(fetchFn, pendingRequests);
-  }
-  return pendingRequests;
+): Map<string, Value> => {
+  if (!fetchFn) return globalMap;
+  let map = mapsByFetch.get(fetchFn);
+  if (!map) {
+    map = new Map();
+    mapsByFetch.set(fetchFn, map);
+  }
+  return map;
 };
 
+const getSourceMapCache = (fetchFn: SourceFetch | undefined): Map<string, null | SourceMap> =>
+  getPerFetchMap(sourceMapCachesByFetch, sourceMapCache, fetchFn);
+
+const getPendingSourceMapRequests = (
+  fetchFn: SourceFetch | undefined,
+): Map<string, Promise<SourceMapResult>> =>
+  getPerFetchMap(pendingSourceMapRequestsByFetch, pendingSourceMapRequests, fetchFn);
+
 const getSourceMapCacheKey = (file: string, options: SourceMapRequestOptions): string =>
+  options.allowUnsafeServerFetch === undefined &&
   options.maxBundleSizeBytes === undefined &&
   options.maxSourceMapSizeBytes === undefined &&
   options.timeoutMs === undefined
     ? file
-    : `${file}\0${options.maxBundleSizeBytes ?? ""}\0${options.maxSourceMapSizeBytes ?? ""}\0${options.timeoutMs ?? ""}`;
+    : `${file}\0${options.allowUnsafeServerFetch ?? ""}\0${options.maxBundleSizeBytes ?? ""}\0${options.maxSourceMapSizeBytes ?? ""}\0${options.timeoutMs ?? ""}`;
 
 export const getSourceMap = async (
   file: string,
@@ -616,7 +924,11 @@ export const getSourceMap = async (
     return (await pendingRequest).sourceMap;
   }
 
-  const fetchPromise: Promise<SourceMapResult> = getSourceMapUncached(file, fetchFn, options).then(
+  const fetchPromise: Promise<SourceMapResult> = getSourceMapUncachedInternal(
+    file,
+    fetchFn,
+    options,
+  ).then(
     (sourceMap) => ({ sourceMap, isTransientFailure: false }),
     () => ({ sourceMap: null, isTransientFailure: true }),
   );
@@ -638,7 +950,7 @@ export const getSourceMap = async (
 export const symbolicateStack = async (
   stack: StackFrame[],
   cache = true,
-  fetchFn?: (url: string) => Promise<Response>,
+  fetchFn?: SourceFetch,
 ): Promise<StackFrame[]> => {
   return Promise.all(
     stack.map(async (stackFrame) => {
@@ -664,6 +976,7 @@ export const symbolicateStack = async (
             ? stackFrame.source.replace(stackFrame.fileName, symbolicatedSource.fileName)
             : stackFrame.source,
         fileName: symbolicatedSource.fileName,
+        functionName: symbolicatedSource.functionName ?? stackFrame.functionName,
         lineNumber: symbolicatedSource.lineNumber,
         columnNumber: symbolicatedSource.columnNumber,
         isIgnoreListed: symbolicatedSource.isIgnoreListed,