bippy 0.6.1-dev.0597fd5 → 0.6.1-dev.3702582

package/src/source/symbolication.ts

@@ -1,5 +1,7 @@
 import { decode, SourceMapMappings, type SourceMapSegment } from "@jridgewell/sourcemap-codec";
 
+import { BippySourceMapError } from "../errors.js";
+import { SCHEME_REGEX } from "./constants.js";
 import { StackFrame } from "./parse-stack.js";
 
 export interface DecodedSourceMapSection {
@@ -10,7 +12,7 @@ export interface DecodedSourceMapSection {
     names?: string[];
     sourceRoot?: string;
     sources: string[];
-    sourcesContent?: string[];
+    sourcesContent?: Array<string | null>;
     version: 3;
   };
   offset: {
@@ -19,20 +21,30 @@ export interface DecodedSourceMapSection {
   };
 }
 
-// https://tc39.es/ecma426/#sec-index-source-map
 export interface IndexSourceMap {
   file?: string;
   sections: Array<{
-    map: StandardSourceMap;
+    map?: StandardSourceMap;
     offset: {
       column: number;
       line: number;
     };
+    url?: string;
   }>;
   version: 3;
 }
 
-export type RawSourceMap = IndexSourceMap | StandardSourceMap;
+export interface SourceFetch {
+  (url: string, init?: RequestInit): Promise<Response>;
+}
+
+export interface SourceMapRequestOptions {
+  allowUnsafeServerFetch?: boolean;
+  maxBundleSizeBytes?: number;
+  maxSourceMapSizeBytes?: number;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
 
 export interface SourceMap {
   file?: string;
@@ -42,11 +54,10 @@ export interface SourceMap {
   sections?: DecodedSourceMapSection[];
   sourceRoot?: string;
   sources: string[];
-  sourcesContent?: string[];
+  sourcesContent?: Array<string | null>;
   version: 3;
 }
 
-// https://developer.chrome.com/blog/sourcemaps#the_anatomy_of_a_source_map
 export interface StandardSourceMap {
   file?: string;
   ignoreList?: number[];
@@ -54,27 +65,31 @@ export interface StandardSourceMap {
   names?: string[];
   sourceRoot?: string;
   sources: string[];
-  sourcesContent?: string[];
+  sourcesContent?: Array<string | null>;
   version: 3;
   x_google_ignoreList?: number[];
 }
 
-// has a scheme, e.g. http://, https://, file://, data:, etc.
-// https://datatracker.ietf.org/doc/html/rfc3986#section-3.1
-const SCHEME_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
-// inline sourcemap, e.g. data:application/json;base64,...
-const INLINE_SOURCEMAP_REGEX = /^data:application\/json[^,]+base64,/;
-// sourcemap url, e.g. //@ sourceMappingURL=... or /* @ sourceMappingURL=... */ at the end of the file
+const INLINE_SOURCEMAP_REGEX = /^data:application\/json(?:;[^,]*)?,/i;
 const SOURCEMAP_REGEX =
   /(?:\/\/[@#][ \t]+sourceMappingURL=([^\s'"]+?)[ \t]*$)|(?:\/\*[@#][ \t]+sourceMappingURL=([^*]+?)[ \t]*(?:\*\/)[ \t]*$)/;
 
 export const sourceMapCache = new Map<string, null | SourceMap>();
+const sourceMapCachesByFetch = new WeakMap<SourceFetch, Map<string, null | SourceMap>>();
 interface SourceMapResult {
   sourceMap: null | SourceMap;
   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 getSourceFromMappings = (
   mappings: SourceMapMappings,
@@ -92,8 +107,6 @@ const getSourceFromMappings = (
     return null;
   }
 
-  // Segments within a line are sorted by generated column, so binary search for
-  // the last segment at or before the column.
   let closestLineSegment: null | SourceMapSegment = null;
   let lowIndex = 0;
   let highIndex = lineMapping.length - 1;
@@ -137,7 +150,6 @@ export const getSourceFromSourceMap = (
   column: number,
 ): StackFrame | null => {
   if (sourceMap.sections) {
-    // Section offsets are 0-based while stack trace lines are 1-based.
     const lineIndex = line - 1;
     let targetSection: DecodedSourceMapSection | null = null;
 
@@ -178,9 +190,55 @@ export const getSourceFromSourceMap = (
   );
 };
 
+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 ? (sourcesContent[sourceIndex] ?? null) : null;
+};
+
+export const getSourceContentFromSourceMap = (
+  sourceMap: SourceMap,
+  originalFileName: string,
+): string | null => {
+  const directResult = findSourceContentByFileName(
+    sourceMap.sources,
+    sourceMap.sourcesContent,
+    originalFileName,
+  );
+  if (directResult) return directResult;
+
+  if (sourceMap.sections) {
+    for (const section of sourceMap.sections) {
+      const sectionResult = findSourceContentByFileName(
+        section.map.sources,
+        section.map.sourcesContent,
+        originalFileName,
+      );
+      if (sectionResult) return sectionResult;
+    }
+  }
+  return null;
+};
+
+const resolveUrl = (reference: string, baseUrl: string): string | null => {
+  if (INLINE_SOURCEMAP_REGEX.test(reference)) return reference;
+  try {
+    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}`;
+    } catch {
+      return null;
+    }
+  }
+};
+
 const getSourceMapUrl = (url: string, content: string): null | string => {
-  // Walk lines backwards without content.split("\n"), which would allocate a
-  // string per line of the entire bundle.
   let sourceMapUrl: string | undefined;
   let searchEnd = content.length;
   while (searchEnd > 0 && !sourceMapUrl) {
@@ -196,44 +254,173 @@ const getSourceMapUrl = (url: string, content: string): null | string => {
     return null;
   }
 
-  const hasScheme = SCHEME_REGEX.test(sourceMapUrl);
-  if (!(INLINE_SOURCEMAP_REGEX.test(sourceMapUrl) || hasScheme || sourceMapUrl.startsWith("/"))) {
-    const urlSegments = url.split("/");
-    urlSegments[urlSegments.length - 1] = sourceMapUrl;
-    sourceMapUrl = urlSegments.join("/");
+  return resolveUrl(sourceMapUrl, url);
+};
+
+const isStandardSourceMap = (value: unknown): value is StandardSourceMap => {
+  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,
+  );
+};
 
-  return sourceMapUrl;
+const isIndexSourceMap = (value: unknown): value is IndexSourceMap => {
+  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 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 &&
+      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 decodeStandardSourceMap = (rawSourceMap: StandardSourceMap): SourceMap => ({
-  file: rawSourceMap.file,
-  ignoredSourceIndices: getIgnoredSourceIndices(rawSourceMap),
-  mappings: decode(rawSourceMap.mappings),
-  names: rawSourceMap.names,
-  sourceRoot: rawSourceMap.sourceRoot,
-  sources: rawSourceMap.sources,
-  sourcesContent: rawSourceMap.sourcesContent,
-  version: 3,
-});
-
-const decodeIndexSourceMap = (rawSourceMap: IndexSourceMap): SourceMap => {
-  const decodedSections: DecodedSourceMapSection[] = rawSourceMap.sections.map(
-    ({ map, offset }) => ({
-      map: {
-        ...map,
-        ignoredSourceIndices: getIgnoredSourceIndices(map),
-        mappings: decode(map.mappings),
-      },
-      offset,
-    }),
+const resolveSourceRoot = (
+  sourceRoot: string | undefined,
+  source: string,
+  sourceMapUrl: string,
+): string => {
+  if (!sourceRoot || SCHEME_REGEX.test(source) || source.startsWith("/")) return source;
+  const normalizedSourceRoot = sourceRoot.endsWith("/") ? sourceRoot : `${sourceRoot}/`;
+  const normalizedSource = source.replace(/^\.\//, "");
+  try {
+    const baseUrl = SCHEME_REGEX.test(normalizedSourceRoot)
+      ? normalizedSourceRoot
+      : new URL(normalizedSourceRoot, sourceMapUrl).toString();
+    return new URL(normalizedSource, baseUrl).toString();
+  } catch {
+    const pathSegments = `${normalizedSourceRoot}${normalizedSource}`.split("/");
+    const normalizedPathSegments: string[] = [];
+    for (const pathSegment of pathSegments) {
+      if (pathSegment === "..") {
+        normalizedPathSegments.pop();
+      } else if (pathSegment !== ".") {
+        normalizedPathSegments.push(pathSegment);
+      }
+    }
+    return normalizedPathSegments.join("/");
+  }
+};
+
+const resolveSourceMapSources = (rawSourceMap: StandardSourceMap, sourceMapUrl: string): string[] =>
+  rawSourceMap.sources.map((source) =>
+    resolveSourceRoot(rawSourceMap.sourceRoot, source, sourceMapUrl),
   );
 
+const decodeStandardSourceMap = (
+  rawSourceMap: StandardSourceMap,
+  sourceMapUrl: string,
+): SourceMap | null => {
+  try {
+    return {
+      file: rawSourceMap.file,
+      ignoredSourceIndices: getIgnoredSourceIndices(rawSourceMap),
+      mappings: decode(rawSourceMap.mappings),
+      names: rawSourceMap.names,
+      sourceRoot: rawSourceMap.sourceRoot,
+      sources: resolveSourceMapSources(rawSourceMap, sourceMapUrl),
+      sourcesContent: rawSourceMap.sourcesContent,
+      version: 3,
+    };
+  } catch {
+    return null;
+  }
+};
+
+interface LoadStandardSourceMap {
+  (url: string): Promise<StandardSourceMap | null>;
+}
+
+const decodeIndexSourceMap = async (
+  rawSourceMap: IndexSourceMap,
+  sourceMapUrl: string,
+  loadStandardSourceMap: LoadStandardSourceMap,
+): Promise<SourceMap | null> => {
+  const decodedSections: DecodedSourceMapSection[] = [];
+  let previousOffsetLine = -1;
+  let previousOffsetColumn = -1;
+  for (const section of rawSourceMap.sections) {
+    if (
+      section.offset.line < previousOffsetLine ||
+      (section.offset.line === previousOffsetLine && section.offset.column <= previousOffsetColumn)
+    ) {
+      return null;
+    }
+    previousOffsetLine = section.offset.line;
+    previousOffsetColumn = section.offset.column;
+    const sectionUrl = section.url ? resolveUrl(section.url, sourceMapUrl) : null;
+    const map = section.map ?? (sectionUrl ? await loadStandardSourceMap(sectionUrl) : null);
+    if (!map) return null;
+    const sectionSourceMapUrl = sectionUrl ?? sourceMapUrl;
+    try {
+      decodedSections.push({
+        map: {
+          ...map,
+          ignoredSourceIndices: getIgnoredSourceIndices(map),
+          mappings: decode(map.mappings),
+          sources: resolveSourceMapSources(map, sectionSourceMapUrl),
+        },
+        offset: section.offset,
+      });
+    } catch {
+      return null;
+    }
+  }
+
   const allSources = new Set<string>();
   for (const section of decodedSections) {
     for (const source of section.map.sources) {
@@ -275,84 +462,322 @@ const isFetchableUrl = (url: string): boolean => {
   return scheme === "http:" || scheme === "https:";
 };
 
-// Resolves a bundle's source map, or null when the bundle definitively has
-// none. A thrown fetch (network error or aborted request) is left to propagate
-// so getSourceMap can treat it as transient and avoid caching it: a non-ok
-// response, a missing sourceMappingURL, or an undecodable map are definitive and
-// return null, but a dropped connection is not and must stay retryable.
-export const getSourceMapImpl = async (
-  bundleUrl: string,
-  fetchFn: (url: string) => Promise<Response> = fetch,
-): Promise<null | SourceMap> => {
-  if (!isFetchableUrl(bundleUrl)) {
-    return null;
+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 bundleResponse = await fetchFn(bundleUrl);
-  if (!bundleResponse.ok) {
-    return null;
+const isSameOrigin = (firstUrl: string, secondUrl: string): boolean => {
+  try {
+    return new URL(firstUrl).origin === new URL(secondUrl).origin;
+  } catch {
+    return false;
   }
-  const bundleContent = await bundleResponse.text();
-  if (!bundleContent) {
-    return null;
+};
+
+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 sourceMapUrl = getSourceMapUrl(bundleUrl, bundleContent);
+interface RequestSignal {
+  cleanup: () => void;
+  signal?: AbortSignal;
+}
 
-  if (!sourceMapUrl) return null;
-  // inline data: maps (vite dev, babel inline sourcemaps) are decoded by
-  // fetch itself, so they bypass the network-url check
-  if (!isFetchableUrl(sourceMapUrl) && !INLINE_SOURCEMAP_REGEX.test(sourceMapUrl)) {
-    return null;
+const createRequestSignal = (options: SourceMapRequestOptions): RequestSignal => {
+  if (options.timeoutMs === undefined || options.timeoutMs < 0) {
+    return { cleanup: () => {}, signal: options.signal };
+  }
+  const abortController = new AbortController();
+  const abortFromSource = (): void => abortController.abort(options.signal?.reason);
+  if (options.signal?.aborted) {
+    abortFromSource();
+  } else {
+    options.signal?.addEventListener("abort", abortFromSource, { once: true });
+  }
+  const timeoutHandle = setTimeout(
+    () => abortController.abort(new BippySourceMapError("Source map request timed out")),
+    options.timeoutMs,
+  );
+  return {
+    cleanup: () => {
+      clearTimeout(timeoutHandle);
+      options.signal?.removeEventListener("abort", abortFromSource);
+    },
+    signal: abortController.signal,
+  };
+};
+
+const readResponseText = async (
+  response: Response,
+  maxSizeBytes: number,
+): Promise<string | null> => {
+  const contentLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > maxSizeBytes) return null;
+  if (!response.body) return "";
+
+  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 sourceMapResponse = await fetchFn(sourceMapUrl);
-  if (!sourceMapResponse.ok) {
+const decodeBase64 = (encodedContent: string): string | null => {
+  try {
+    if (typeof globalThis.atob === "function") {
+      return new TextDecoder().decode(
+        Uint8Array.from(globalThis.atob(encodedContent), (character) => character.charCodeAt(0)),
+      );
+    }
+  } catch {
     return null;
   }
 
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  const normalizedContent = encodedContent.replace(/\s/g, "").replace(/=+$/, "");
+  const bytes: number[] = [];
+  let bitBuffer = 0;
+  let bitCount = 0;
+  for (const character of normalizedContent) {
+    const value = alphabet.indexOf(character);
+    if (value === -1) return null;
+    bitBuffer = bitBuffer * 64 + value;
+    bitCount += 6;
+    if (bitCount >= 8) {
+      bitCount -= 8;
+      bytes.push(Math.floor(bitBuffer / 2 ** bitCount) & 255);
+      bitBuffer %= 2 ** bitCount;
+    }
+  }
+  return new TextDecoder().decode(Uint8Array.from(bytes));
+};
+
+const readInlineSourceMap = (sourceMapUrl: string, maxSizeBytes: number): unknown => {
+  const commaIndex = sourceMapUrl.indexOf(",");
+  if (commaIndex === -1) return null;
+  const metadata = sourceMapUrl.slice(0, commaIndex);
+  const encodedContent = sourceMapUrl.slice(commaIndex + 1);
+  if (encodedContent.length > maxSizeBytes * 2) return null;
   try {
-    const rawSourceMap = (await sourceMapResponse.json()) as RawSourceMap;
+    const content = metadata.toLowerCase().includes(";base64")
+      ? decodeBase64(encodedContent)
+      : decodeURIComponent(encodedContent);
+    if (content === null) return null;
+    if (new TextEncoder().encode(content).byteLength > maxSizeBytes) return null;
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+};
 
-    return "sections" in rawSourceMap
-      ? decodeIndexSourceMap(rawSourceMap)
-      : decodeStandardSourceMap(rawSourceMap);
+const readSourceMapDocument = async (
+  sourceMapUrl: string,
+  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, {
+    redirect: shouldRejectRedirects ? "error" : "follow",
+    signal,
+  });
+  if (!assertResponseIsCacheable(sourceMapResponse)) return null;
+  const sourceMapContent = await readResponseText(sourceMapResponse, maxSizeBytes);
+  if (sourceMapContent === null) return null;
+  try {
+    return JSON.parse(sourceMapContent);
   } catch {
     return null;
   }
 };
 
+const getSourceMapUncachedInternal = async (
+  bundleUrl: string,
+  fetchFn?: SourceFetch,
+  options: SourceMapRequestOptions = {},
+): Promise<null | SourceMap> => {
+  if (!isFetchableUrl(bundleUrl)) {
+    return null;
+  }
+
+  const shouldRejectRedirects = isServerRuntime();
+  if (shouldRejectRedirects) {
+    if ((!fetchFn && !options.allowUnsafeServerFetch) || !isAbsoluteHttpUrl(bundleUrl)) return null;
+  }
+  const isBlockedCrossOriginUrl = (url: string): boolean =>
+    shouldRejectRedirects && !INLINE_SOURCEMAP_REGEX.test(url) && !isSameOrigin(bundleUrl, url);
+
+  const sourceFetch =
+    fetchFn ??
+    (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : undefined);
+  if (!sourceFetch) return null;
+  const maxBundleSizeBytes = options.maxBundleSizeBytes ?? defaultMaxBundleSizeBytes;
+  const maxSourceMapSizeBytes = options.maxSourceMapSizeBytes ?? defaultMaxSourceMapSizeBytes;
+  if (maxBundleSizeBytes < 0 || maxSourceMapSizeBytes < 0) return null;
+  const requestSignal = createRequestSignal(options);
+  try {
+    const bundleResponse = await sourceFetch(bundleUrl, {
+      redirect: shouldRejectRedirects ? "error" : "follow",
+      signal: requestSignal.signal,
+    });
+    if (!assertResponseIsCacheable(bundleResponse)) return null;
+    const bundleContent = await readResponseText(bundleResponse, maxBundleSizeBytes);
+    if (!bundleContent) return null;
+    const sourceMapUrl = getSourceMapUrl(bundleUrl, bundleContent);
+    if (!sourceMapUrl) return null;
+    if (!isFetchableUrl(sourceMapUrl) && !INLINE_SOURCEMAP_REGEX.test(sourceMapUrl)) return null;
+    if (isBlockedCrossOriginUrl(sourceMapUrl)) {
+      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 (isBlockedCrossOriginUrl(sectionUrl)) {
+        return null;
+      }
+      const sectionSourceMap = await readSourceMapDocument(
+        sectionUrl,
+        sourceFetch,
+        requestSignal.signal,
+        maxSourceMapSizeBytes,
+        shouldRejectRedirects,
+      );
+      return isStandardSourceMap(sectionSourceMap) ? sectionSourceMap : null;
+    });
+  } finally {
+    requestSignal.cleanup();
+  }
+};
+
+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;
+  }
+};
+
+const getPerFetchMap = <Value>(
+  mapsByFetch: WeakMap<SourceFetch, Map<string, Value>>,
+  globalMap: Map<string, Value>,
+  fetchFn: SourceFetch | undefined,
+): 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.allowUnsafeServerFetch ?? ""}\0${options.maxBundleSizeBytes ?? ""}\0${options.maxSourceMapSizeBytes ?? ""}\0${options.timeoutMs ?? ""}`;
+
 export const getSourceMap = async (
   file: string,
   useCache = true,
-  fetchFn?: (url: string) => Promise<Response>,
+  fetchFn?: SourceFetch,
+  options: SourceMapRequestOptions = {},
 ): Promise<null | SourceMap> => {
-  if (useCache && sourceMapCache.has(file)) {
-    return sourceMapCache.get(file) ?? null;
+  const shouldUseCache = useCache && options.signal === undefined;
+  const cache = getSourceMapCache(fetchFn);
+  const pendingRequests = getPendingSourceMapRequests(fetchFn);
+  const cacheKey = getSourceMapCacheKey(file, options);
+  if (shouldUseCache && cache.has(cacheKey)) {
+    return cache.get(cacheKey) ?? null;
   }
 
-  const pendingRequest = useCache ? _pendingSourceMapRequests.get(file) : undefined;
+  const pendingRequest = shouldUseCache ? pendingRequests.get(cacheKey) : undefined;
   if (pendingRequest) {
     return (await pendingRequest).sourceMap;
   }
 
-  // A transient fetch failure (aborted request or network error) rejects; a
-  // definitive "no map" resolves to null. Only definitive results are cached:
-  // caching a transient null would pin the bundle to a degraded result for the
-  // rest of the page's lifetime, even after the network recovers.
-  const fetchPromise: Promise<SourceMapResult> = getSourceMapImpl(file, fetchFn).then(
+  const fetchPromise: Promise<SourceMapResult> = getSourceMapUncachedInternal(
+    file,
+    fetchFn,
+    options,
+  ).then(
     (sourceMap) => ({ sourceMap, isTransientFailure: false }),
     () => ({ sourceMap: null, isTransientFailure: true }),
   );
-  if (useCache) {
-    _pendingSourceMapRequests.set(file, fetchPromise);
+  if (shouldUseCache) {
+    pendingRequests.set(cacheKey, fetchPromise);
   }
 
   const { sourceMap, isTransientFailure } = await fetchPromise;
-  if (useCache) {
-    _pendingSourceMapRequests.delete(file);
+  if (shouldUseCache) {
+    pendingRequests.delete(cacheKey);
     if (!isTransientFailure) {
-      sourceMapCache.set(file, sourceMap);
+      cache.set(cacheKey, sourceMap);
     }
   }
 
@@ -362,9 +787,9 @@ export const getSourceMap = async (
 export const symbolicateStack = async (
   stack: StackFrame[],
   cache = true,
-  fetchFn?: (url: string) => Promise<Response>,
+  fetchFn?: SourceFetch,
 ): Promise<StackFrame[]> => {
-  return await Promise.all(
+  return Promise.all(
     stack.map(async (stackFrame) => {
       if (!stackFrame.fileName) return stackFrame;
       const sourceMap = await getSourceMap(stackFrame.fileName, cache, fetchFn);