metro 0.83.4 → 0.83.5

package/src/ModuleGraph/worker/collectDependencies.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+import type {ReadonlySourceLocation} from '../../shared/types';
+import type {NodePath} from '@babel/traverse';
+import type {
+  CallExpression,
+  File as BabelNodeFile,
+  Identifier,
+  StringLiteral,
+} from '@babel/types';
+import type {
+  AllowOptionalDependencies,
+  AsyncDependencyType,
+} from 'metro/private/DeltaBundler/types';
+
+export type Dependency = Readonly<{data: DependencyData; name: string}>;
+export type ContextMode = 'sync' | 'eager' | 'lazy' | 'lazy-once';
+type ContextFilter = Readonly<{pattern: string; flags: string}>;
+export type RequireContextParams = Readonly<{
+  recursive: boolean;
+  filter: Readonly<ContextFilter>;
+  /** Mode for resolving dynamic dependencies. Defaults to `sync` */
+  mode: ContextMode;
+}>;
+type DependencyData = Readonly<{
+  key: string;
+  asyncType: AsyncDependencyType | null;
+  isESMImport: boolean;
+  isOptional?: boolean;
+  locs: ReadonlyArray<ReadonlySourceLocation>;
+  /** Context for requiring a collection of modules. */
+  contextParams?: RequireContextParams;
+}>;
+export type MutableInternalDependency = Omit<
+  DependencyData,
+  keyof {locs: Array<ReadonlySourceLocation>; index: number; name: string}
+> & {locs: Array<ReadonlySourceLocation>; index: number; name: string};
+export type InternalDependency = Readonly<MutableInternalDependency>;
+export type State = {
+  asyncRequireModulePathStringLiteral: null | undefined | StringLiteral;
+  dependencyCalls: Set<string>;
+  dependencyRegistry: DependencyRegistry;
+  dependencyTransformer: DependencyTransformer;
+  dynamicRequires: DynamicRequiresBehavior;
+  dependencyMapIdentifier: null | undefined | Identifier;
+  keepRequireNames: boolean;
+  allowOptionalDependencies: AllowOptionalDependencies;
+  /** Enable `require.context` statements which can be used to import multiple files in a directory. */
+  unstable_allowRequireContext: boolean;
+  unstable_isESMImportAtSource:
+    | null
+    | undefined
+    | (($$PARAM_0$$: ReadonlySourceLocation) => boolean);
+};
+export type Options = Readonly<{
+  asyncRequireModulePath: string;
+  dependencyMapName: null | undefined | string;
+  dynamicRequires: DynamicRequiresBehavior;
+  inlineableCalls: ReadonlyArray<string>;
+  keepRequireNames: boolean;
+  allowOptionalDependencies: AllowOptionalDependencies;
+  dependencyTransformer?: DependencyTransformer;
+  /** Enable `require.context` statements which can be used to import multiple files in a directory. */
+  unstable_allowRequireContext: boolean;
+  unstable_isESMImportAtSource?:
+    | null
+    | undefined
+    | (($$PARAM_0$$: ReadonlySourceLocation) => boolean);
+}>;
+export type CollectedDependencies = Readonly<{
+  ast: BabelNodeFile;
+  dependencyMapName: string;
+  dependencies: ReadonlyArray<Dependency>;
+}>;
+export interface DependencyTransformer {
+  transformSyncRequire(
+    path: NodePath<CallExpression>,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformImportCall(
+    path: NodePath,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformImportMaybeSyncCall(
+    path: NodePath,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformPrefetch(
+    path: NodePath,
+    dependency: InternalDependency,
+    state: State,
+  ): void;
+  transformIllegalDynamicRequire(path: NodePath, state: State): void;
+}
+export type DynamicRequiresBehavior = 'throwAtRuntime' | 'reject';
+/**
+ * Transform all the calls to `require()` and `import()` in a file into ID-
+ * independent code, and return the list of dependencies. For example, a call
+ * like `require('Foo')` could be transformed to `require(_depMap[3], 'Foo')`
+ * where `_depMap` is provided by the outer scope. As such, we don't need to
+ * know the actual module ID.
+ *
+ * The second argument is only provided for debugging purposes.
+ */
+declare function collectDependencies(
+  ast: BabelNodeFile,
+  options: Options,
+): CollectedDependencies;
+export default collectDependencies;
+export type ImportQualifier = Readonly<{
+  name: string;
+  asyncType: AsyncDependencyType | null;
+  isESMImport: boolean;
+  optional: boolean;
+  contextParams?: RequireContextParams;
+}>;
+declare class DependencyRegistry {
+  _dependencies: Map<string, InternalDependency>;
+  registerDependency(qualifier: ImportQualifier): InternalDependency;
+  getDependencies(): Array<InternalDependency>;
+}

package/src/ModuleGraph/worker/collectDependencies.js

@@ -20,10 +20,7 @@ function _interopRequireWildcard(e, t) {
     if (!t && e && e.__esModule) return e;
     var o,
       i,
-      f = {
-        __proto__: null,
-        default: e,
-      };
+      f = { __proto__: null, default: e };
     if (null === e || ("object" != typeof e && "function" != typeof e))
       return f;
     if ((o = t ? n : r)) {
@@ -43,11 +40,7 @@ function _interopRequireWildcard(e, t) {
   })(e, t);
 }
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 function collectDependencies(ast, options) {
   const visited = new WeakSet();

package/src/ModuleGraph/worker/generateImportNames.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+import type {Node} from '@babel/types';
+/**
+ * Select unused names for "metroImportDefault" and "metroImportAll", by
+ * calling "generateUid".
+ */
+declare function generateImportNames(ast: Node): {
+  importAll: string;
+  importDefault: string;
+};
+export default generateImportNames;

package/src/ModuleGraph/worker/generateImportNames.js

@@ -7,11 +7,7 @@ exports.default = generateImportNames;
 var _traverse = _interopRequireDefault(require("@babel/traverse"));
 var _nullthrows = _interopRequireDefault(require("nullthrows"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 function generateImportNames(ast) {
   let importDefault;

package/src/ModuleGraph/worker/importLocationsPlugin.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import type {ReadonlySourceLocation} from '../../shared/types';
+import type {PluginObj} from '@babel/core';
+import type * as $$IMPORT_TYPEOF_1$$ from '@babel/types';
+import type {MetroBabelFileMetadata} from 'metro-babel-transformer';
+
+type Types = typeof $$IMPORT_TYPEOF_1$$;
+type ImportDeclarationLocs = Set<string>;
+type State = {
+  importDeclarationLocs: ImportDeclarationLocs;
+  file: {metadata?: MetroBabelFileMetadata};
+};
+declare function importLocationsPlugin($$PARAM_0$$: {
+  types: Types;
+}): PluginObj<State>;
+declare function locToKey(loc: ReadonlySourceLocation): string;
+export {importLocationsPlugin, locToKey};

package/src/Server/MultipartResponse.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import type {IncomingMessage, ServerResponse} from 'http';
+
+type Data = string | Buffer | Uint8Array;
+type Headers = {[$$Key$$: string]: string | number};
+declare class MultipartResponse {
+  static wrapIfSupported(
+    req: IncomingMessage,
+    res: ServerResponse,
+  ): MultipartResponse | ServerResponse;
+  static serializeHeaders(headers: Headers): string;
+  res: ServerResponse;
+  headers: Headers;
+  constructor(res: ServerResponse);
+  writeChunk(headers: Headers | null, data?: Data, isLast?: boolean): void;
+  writeHead(status: number, headers?: Headers): void;
+  setHeader(name: string, value: string | number): void;
+  end(data?: Data): void;
+  once(name: string, fn: () => unknown): this;
+}
+export default MultipartResponse;

package/src/Server/MultipartResponse.js

@@ -6,11 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _accepts = _interopRequireDefault(require("accepts"));
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const CRLF = "\r\n";
 const BOUNDARY = "3beqjf3apnqeu3h5jqorms4i";

package/src/Server/symbolicate.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import type {ExplodedSourceMap} from '../DeltaBundler/Serializers/getExplodedSourceMap';
+import type {ConfigT} from 'metro-config';
+
+export type StackFrameInput = {
+  readonly file: null | undefined | string;
+  readonly lineNumber: null | undefined | number;
+  readonly column: null | undefined | number;
+  readonly methodName: null | undefined | string;
+};
+export type IntermediateStackFrame = Omit<
+  StackFrameInput,
+  keyof {collapse?: boolean}
+> & {collapse?: boolean};
+export type StackFrameOutput = Readonly<IntermediateStackFrame>;
+declare function symbolicate(
+  stack: ReadonlyArray<StackFrameInput>,
+  maps: Iterable<[string, ExplodedSourceMap]>,
+  config: ConfigT,
+  extraData: unknown,
+): Promise<ReadonlyArray<StackFrameOutput>>;
+export default symbolicate;

package/src/Server.d.ts

@@ -0,0 +1,271 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall react_native
+ */
+
+import type {AssetData} from './Assets';
+import type {ExplodedSourceMap} from './DeltaBundler/Serializers/getExplodedSourceMap';
+import type {RamBundleInfo} from './DeltaBundler/Serializers/getRamBundleInfo';
+import type {
+  Module,
+  ReadOnlyDependencies,
+  ReadOnlyGraph,
+  TransformInputOptions,
+} from './DeltaBundler/types';
+import type {RevisionId} from './IncrementalBundler';
+import type {GraphId} from './lib/getGraphId';
+import type {Reporter} from './lib/reporting';
+import type {
+  BuildOptions,
+  BundleOptions,
+  GraphOptions,
+  ResolverInputOptions,
+  SplitBundleOptions,
+} from './shared/types';
+import type {IncomingMessage} from 'connect';
+import type {ServerResponse} from 'http';
+import type {ConfigT, RootPerfLogger} from 'metro-config';
+import type {
+  ActionLogEntryData,
+  ActionStartLogEntry,
+} from 'metro-core/private/Logger';
+import type {CustomResolverOptions} from 'metro-resolver/private/types';
+import type {CustomTransformOptions} from 'metro-transform-worker';
+
+import IncrementalBundler from './IncrementalBundler';
+import MultipartResponse from './Server/MultipartResponse';
+import {SourcePathsMode} from './shared/types';
+import {Logger} from 'metro-core';
+
+export type SegmentLoadData = {
+  [$$Key$$: number]: [Array<number>, null | undefined | number];
+};
+export type BundleMetadata = {
+  hash: string;
+  otaBuildNumber: null | undefined | string;
+  mobileConfigs: Array<string>;
+  segmentHashes: Array<string>;
+  segmentLoadData: SegmentLoadData;
+};
+type ProcessStartContext = Omit<
+  SplitBundleOptions,
+  keyof {
+    readonly buildNumber: number;
+    readonly bundleOptions: BundleOptions;
+    readonly graphId: GraphId;
+    readonly graphOptions: GraphOptions;
+    readonly mres: MultipartResponse | ServerResponse;
+    readonly req: IncomingMessage;
+    readonly revisionId?: null | undefined | RevisionId;
+    readonly bundlePerfLogger: RootPerfLogger;
+    readonly requestStartTimestamp: number;
+  }
+> & {
+  readonly buildNumber: number;
+  readonly bundleOptions: BundleOptions;
+  readonly graphId: GraphId;
+  readonly graphOptions: GraphOptions;
+  readonly mres: MultipartResponse | ServerResponse;
+  readonly req: IncomingMessage;
+  readonly revisionId?: null | undefined | RevisionId;
+  readonly bundlePerfLogger: RootPerfLogger;
+  readonly requestStartTimestamp: number;
+};
+type ProcessDeleteContext = {
+  readonly graphId: GraphId;
+  readonly req: IncomingMessage;
+  readonly res: ServerResponse;
+};
+type ProcessEndContext<T> = Omit<
+  ProcessStartContext,
+  keyof {readonly result: T}
+> & {readonly result: T};
+export type ServerOptions = Readonly<{
+  hasReducedPerformance?: boolean;
+  onBundleBuilt?: (bundlePath: string) => void;
+  watch?: boolean;
+}>;
+type FetchTiming = {
+  graphId: GraphId;
+  startTime: number;
+  endTime: number | null;
+  isPrefetch: boolean;
+};
+declare class Server {
+  _bundler: IncrementalBundler;
+  _config: ConfigT;
+  _createModuleId: (path: string) => number;
+  _isEnded: boolean;
+  _logger: typeof Logger;
+  _nextBundleBuildNumber: number;
+  _platforms: Set<string>;
+  _reporter: Reporter;
+  _serverOptions: ServerOptions | void;
+  _allowedSuffixesForSourceRequests: ReadonlyArray<string>;
+  _sourceRequestRoutingMap: ReadonlyArray<
+    [pathnamePrefix: string, normalizedRootDir: string]
+  >;
+  _fetchTimings: Array<FetchTiming>;
+  _activeFetchCount: number;
+  constructor(config: ConfigT, options?: ServerOptions);
+  end(): void;
+  getBundler(): IncrementalBundler;
+  getCreateModuleId(): (path: string) => number;
+  _serializeGraph(
+    $$PARAM_0$$: Readonly<{
+      splitOptions: SplitBundleOptions;
+      prepend: ReadonlyArray<Module>;
+      graph: ReadOnlyGraph;
+    }>,
+  ): Promise<{code: string; map: string}>;
+  build(
+    bundleOptions: BundleOptions,
+    $$PARAM_1$$?: BuildOptions,
+  ): Promise<{code: string; map: string; assets?: ReadonlyArray<AssetData>}>;
+  getRamBundleInfo(options: BundleOptions): Promise<RamBundleInfo>;
+  getAssets(options: BundleOptions): Promise<ReadonlyArray<AssetData>>;
+  _getAssetsFromDependencies(
+    dependencies: ReadOnlyDependencies,
+    platform: null | undefined | string,
+  ): Promise<ReadonlyArray<AssetData>>;
+  getOrderedDependencyPaths(options: {
+    readonly dev: boolean;
+    readonly entryFile: string;
+    readonly minify: boolean;
+    readonly platform: null | undefined | string;
+  }): Promise<Array<string>>;
+  _rangeRequestMiddleware(
+    req: IncomingMessage,
+    res: ServerResponse,
+    data: string | Buffer,
+    assetPath: string,
+  ): Buffer | string;
+  _processSingleAssetRequest(
+    req: IncomingMessage,
+    res: ServerResponse,
+  ): Promise<void>;
+  processRequest: (
+    $$PARAM_0$$: IncomingMessage,
+    $$PARAM_1$$: ServerResponse,
+    $$PARAM_2$$: (e: null | undefined | Error) => void,
+  ) => void;
+  _parseOptions(url: string): BundleOptions;
+  _rewriteAndNormalizeUrl(requestUrl: string): string;
+  _processRequest(
+    req: IncomingMessage,
+    res: ServerResponse,
+    next: ($$PARAM_0$$: null | undefined | Error) => void,
+  ): Promise<void>;
+  _processSourceRequest(
+    relativeFilePathname: string,
+    rootDir: string,
+    res: ServerResponse,
+  ): Promise<void>;
+  _createRequestProcessor<T>($$PARAM_0$$: {
+    readonly bundleType: 'assets' | 'bundle' | 'map';
+    readonly createStartEntry: (
+      context: ProcessStartContext,
+    ) => ActionLogEntryData;
+    readonly createEndEntry: (
+      context: ProcessEndContext<T>,
+    ) => Partial<ActionStartLogEntry>;
+    readonly build: (context: ProcessStartContext) => Promise<T>;
+    readonly delete?: (context: ProcessDeleteContext) => Promise<void>;
+    readonly finish: (context: ProcessEndContext<T>) => void;
+  }): (
+    req: IncomingMessage,
+    res: ServerResponse,
+    bundleOptions: BundleOptions,
+    buildContext: Readonly<{
+      buildNumber: number;
+      bundlePerfLogger: RootPerfLogger;
+    }>,
+  ) => Promise<void>;
+  _processBundleRequest: (
+    req: IncomingMessage,
+    res: ServerResponse,
+    bundleOptions: BundleOptions,
+    buildContext: Readonly<{
+      buildNumber: number;
+      bundlePerfLogger: RootPerfLogger;
+    }>,
+  ) => Promise<void>;
+  _getSortedModules(graph: ReadOnlyGraph): ReadonlyArray<Module>;
+  _processSourceMapRequest: (
+    req: IncomingMessage,
+    res: ServerResponse,
+    bundleOptions: BundleOptions,
+    buildContext: Readonly<{
+      buildNumber: number;
+      bundlePerfLogger: RootPerfLogger;
+    }>,
+  ) => Promise<void>;
+  _processAssetsRequest: (
+    req: IncomingMessage,
+    res: ServerResponse,
+    bundleOptions: BundleOptions,
+    buildContext: Readonly<{
+      buildNumber: number;
+      bundlePerfLogger: RootPerfLogger;
+    }>,
+  ) => Promise<void>;
+  _symbolicate(req: IncomingMessage, res: ServerResponse): Promise<void>;
+  _explodedSourceMapForBundleOptions(
+    bundleOptions: BundleOptions,
+  ): Promise<ExplodedSourceMap>;
+  _resolveRelativePath(
+    filePath: string,
+    $$PARAM_1$$: Readonly<{
+      relativeTo: 'project' | 'server';
+      resolverOptions: ResolverInputOptions;
+      transformOptions: TransformInputOptions;
+    }>,
+  ): Promise<string>;
+  getNewBuildNumber(): number;
+  getPlatforms(): ReadonlyArray<string>;
+  getWatchFolders(): ReadonlyArray<string>;
+  static DEFAULT_GRAPH_OPTIONS: Readonly<{
+    customResolverOptions: CustomResolverOptions;
+    customTransformOptions: CustomTransformOptions;
+    dev: boolean;
+    minify: boolean;
+    unstable_transformProfile: 'default';
+  }>;
+  static DEFAULT_BUNDLE_OPTIONS: Omit<
+    typeof Server.DEFAULT_GRAPH_OPTIONS,
+    keyof {
+      excludeSource: false;
+      inlineSourceMap: false;
+      lazy: false;
+      modulesOnly: false;
+      onProgress: null;
+      runModule: true;
+      shallow: false;
+      sourceMapUrl: null;
+      sourceUrl: null;
+      sourcePaths: SourcePathsMode;
+    }
+  > & {
+    excludeSource: false;
+    inlineSourceMap: false;
+    lazy: false;
+    modulesOnly: false;
+    onProgress: null;
+    runModule: true;
+    shallow: false;
+    sourceMapUrl: null;
+    sourceUrl: null;
+    sourcePaths: SourcePathsMode;
+  };
+  _getServerRootDir(): string;
+  _getEntryPointAbsolutePath(entryFile: string): string;
+  ready(): Promise<void>;
+  _shouldAddModuleToIgnoreList(module: Module): boolean;
+  _getModuleSourceUrl(module: Module, mode: SourcePathsMode): string;
+}
+export default Server;

package/src/Server.js

@@ -25,6 +25,7 @@ var _IncrementalBundler = _interopRequireDefault(
 var _ResourceNotFoundError = _interopRequireDefault(
   require("./IncrementalBundler/ResourceNotFoundError"),
 );
+var _bundleProgressUtils = require("./lib/bundleProgressUtils");
 var _bundleToString = _interopRequireDefault(require("./lib/bundleToString"));
 var _formatBundlingError = _interopRequireDefault(
   require("./lib/formatBundlingError"),
@@ -66,10 +67,7 @@ function _interopRequireWildcard(e, t) {
     if (!t && e && e.__esModule) return e;
     var o,
       i,
-      f = {
-        __proto__: null,
-        default: e,
-      };
+      f = { __proto__: null, default: e };
     if (null === e || ("object" != typeof e && "function" != typeof e))
       return f;
     if ((o = t ? n : r)) {
@@ -89,11 +87,7 @@ function _interopRequireWildcard(e, t) {
   })(e, t);
 }
 function _interopRequireDefault(e) {
-  return e && e.__esModule
-    ? e
-    : {
-        default: e,
-      };
+  return e && e.__esModule ? e : { default: e };
 }
 const debug = require("debug")("Metro:Server");
 const { createActionStartEntry, createActionEndEntry, log } = _metroCore.Logger;
@@ -136,6 +130,8 @@ class Server {
       ]),
     ];
     this._isEnded = false;
+    this._fetchTimings = [];
+    this._activeFetchCount = 0;
     this._createModuleId = config.serializer.createModuleIdFactory();
     this._bundler = new _IncrementalBundler.default(config, {
       hasReducedPerformance: options && options.hasReducedPerformance,
@@ -684,14 +680,16 @@ class Server {
       }
       const mres = _MultipartResponse.default.wrapIfSupported(req, res);
       let onProgress = null;
-      let lastProgress = -1;
+      let lastRatio = -1;
       if (this._config.reporter) {
         onProgress = (transformedFileCount, totalFileCount) => {
-          const currentProgress = parseInt(
-            (transformedFileCount / totalFileCount) * 100,
-            10,
+          const newRatio = (0,
+          _bundleProgressUtils.calculateBundleProgressRatio)(
+            transformedFileCount,
+            totalFileCount,
+            lastRatio,
           );
-          if (currentProgress > lastProgress || totalFileCount < 10) {
+          if (newRatio > lastRatio) {
             if (mres instanceof _MultipartResponse.default) {
               mres.writeChunk(
                 {
@@ -700,13 +698,14 @@ class Server {
                 JSON.stringify({
                   done: transformedFileCount,
                   total: totalFileCount,
+                  percent: Math.floor(newRatio * 100),
                 }),
               );
             }
             if (res.socket != null && res.socket.uncork != null) {
               res.socket.uncork();
             }
-            lastProgress = currentProgress;
+            lastRatio = newRatio;
           }
           this._reporter.update({
             buildID: getBuildID(buildNumber),
@@ -748,8 +747,16 @@ class Server {
       const logEntry = log(
         createActionStartEntry(createStartEntry(startContext)),
       );
+      const fetchTiming = {
+        graphId,
+        startTime: requestStartTimestamp,
+        endTime: null,
+        isPrefetch: req.method === "HEAD",
+      };
       let result;
       try {
+        this._fetchTimings.push(fetchTiming);
+        this._activeFetchCount++;
         result = await build(startContext);
       } catch (error) {
         const formattedError = (0, _formatBundlingError.default)(error);
@@ -779,6 +786,31 @@ class Server {
         debug("Bundling error", error);
         buildContext.bundlePerfLogger.end("FAIL");
         return;
+      } finally {
+        fetchTiming.endTime =
+          _perf_hooks.performance.timeOrigin + _perf_hooks.performance.now();
+        if (!fetchTiming.isPrefetch) {
+          buildContext.bundlePerfLogger.annotate({
+            bool: {
+              had_competing_prefetch: this._fetchTimings
+                .filter((t) => t.isPrefetch && t.graphId !== graphId)
+                .some((prefetch) => {
+                  const prefetchEndTime =
+                    prefetch.endTime ?? Number.MAX_SAFE_INTEGER;
+                  const fetchEndTime =
+                    fetchTiming.endTime ?? Number.MAX_SAFE_INTEGER;
+                  return (
+                    prefetch.startTime < fetchEndTime &&
+                    prefetchEndTime > fetchTiming.startTime
+                  );
+                }),
+            },
+          });
+        }
+        this._activeFetchCount--;
+        if (this._activeFetchCount === 0) {
+          this._fetchTimings = [];
+        }
       }
       const endContext = {
         ...startContext,