metro 0.76.0 → 0.76.1

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

@@ -0,0 +1,27 @@
+/**
+ * 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
+ */
+
+export type ContextMode = 'sync' | 'eager' | 'lazy' | 'lazy-once';
+
+export interface ContextFilter {
+  pattern: string;
+  flags: string;
+}
+
+export interface RequireContextParams {
+  /* Should search for files recursively. Optional, default `true` when `require.context` is used */
+  readonly recursive: boolean;
+  /* Filename filter pattern for use in `require.context`. Optional, default `.*` (any file) when `require.context` is used */
+  readonly filter: Readonly<ContextFilter>;
+  /** Mode for resolving dynamic dependencies. Defaults to `sync` */
+  readonly mode: ContextMode;
+}
+
+export type DynamicRequiresBehavior = 'throwAtRuntime' | 'reject';

package/src/ModuleGraph/worker/collectDependencies.js

@@ -31,8 +31,7 @@ function collectDependencies(ast, options) {
   const state = {
     asyncRequireModulePathStringLiteral: null,
     dependencyCalls: new Set(),
-    dependencyRegistry:
-      options.dependencyRegistry ?? new DefaultModuleDependencyRegistry(),
+    dependencyRegistry: new DependencyRegistry(),
     dependencyTransformer:
       options.dependencyTransformer ?? DefaultDependencyTransformer,
     dependencyMapIdentifier: null,
@@ -429,10 +428,16 @@ const dynamicRequireErrorTemplate = template.expression(`
  * "require(...)" call to the asyncRequire specified.
  */
 const makeAsyncRequireTemplate = template.expression(`
-  require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, MODULE_NAME, DEPENDENCY_MAP.paths)
+  require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, DEPENDENCY_MAP.paths)
+`);
+const makeAsyncRequireTemplateWithName = template.expression(`
+  require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, DEPENDENCY_MAP.paths, MODULE_NAME)
 `);
 const makeAsyncPrefetchTemplate = template.expression(`
-  require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, MODULE_NAME, DEPENDENCY_MAP.paths)
+  require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, DEPENDENCY_MAP.paths)
+`);
+const makeAsyncPrefetchTemplateWithName = template.expression(`
+  require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, DEPENDENCY_MAP.paths, MODULE_NAME)
 `);
 const makeResolveWeakTemplate = template.expression(`
   MODULE_ID
@@ -447,28 +452,40 @@ const DefaultDependencyTransformer = {
     }
   },
   transformImportCall(path, dependency, state) {
-    path.replaceWith(
-      makeAsyncRequireTemplate({
-        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
-          state.asyncRequireModulePathStringLiteral
-        ),
-        MODULE_ID: createModuleIDExpression(dependency, state),
-        MODULE_NAME: createModuleNameLiteral(dependency),
-        DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
-      })
-    );
+    const makeNode = state.keepRequireNames
+      ? makeAsyncRequireTemplateWithName
+      : makeAsyncRequireTemplate;
+    const opts = {
+      ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+        state.asyncRequireModulePathStringLiteral
+      ),
+      MODULE_ID: createModuleIDExpression(dependency, state),
+      DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
+      ...(state.keepRequireNames
+        ? {
+            MODULE_NAME: createModuleNameLiteral(dependency),
+          }
+        : null),
+    };
+    path.replaceWith(makeNode(opts));
   },
   transformPrefetch(path, dependency, state) {
-    path.replaceWith(
-      makeAsyncPrefetchTemplate({
-        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
-          state.asyncRequireModulePathStringLiteral
-        ),
-        MODULE_ID: createModuleIDExpression(dependency, state),
-        MODULE_NAME: createModuleNameLiteral(dependency),
-        DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
-      })
-    );
+    const makeNode = state.keepRequireNames
+      ? makeAsyncPrefetchTemplateWithName
+      : makeAsyncPrefetchTemplate;
+    const opts = {
+      ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+        state.asyncRequireModulePathStringLiteral
+      ),
+      MODULE_ID: createModuleIDExpression(dependency, state),
+      DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
+      ...(state.keepRequireNames
+        ? {
+            MODULE_NAME: createModuleNameLiteral(dependency),
+          }
+        : null),
+    };
+    path.replaceWith(makeNode(opts));
   },
   transformIllegalDynamicRequire(path, state) {
     path.replaceWith(
@@ -530,7 +547,7 @@ function getKeyForDependency(qualifier) {
   }
   return key;
 }
-class DefaultModuleDependencyRegistry {
+class DependencyRegistry {
   _dependencies = new Map();
   registerDependency(qualifier) {
     const key = getKeyForDependency(qualifier);

package/src/ModuleGraph/worker/collectDependencies.js.flow

@@ -72,7 +72,7 @@ export type InternalDependency = $ReadOnly<MutableInternalDependency>;
 export type State = {
   asyncRequireModulePathStringLiteral: ?StringLiteral,
   dependencyCalls: Set<string>,
-  dependencyRegistry: ModuleDependencyRegistry,
+  dependencyRegistry: DependencyRegistry,
   dependencyTransformer: DependencyTransformer,
   dynamicRequires: DynamicRequiresBehavior,
   dependencyMapIdentifier: ?Identifier,
@@ -89,7 +89,6 @@ export type Options = $ReadOnly<{
   inlineableCalls: $ReadOnlyArray<string>,
   keepRequireNames: boolean,
   allowOptionalDependencies: AllowOptionalDependencies,
-  dependencyRegistry?: ModuleDependencyRegistry,
   dependencyTransformer?: DependencyTransformer,
   /** Enable `require.context` statements which can be used to import multiple files in a directory. */
   unstable_allowRequireContext: boolean,
@@ -101,15 +100,6 @@ export type CollectedDependencies = $ReadOnly<{
   dependencies: $ReadOnlyArray<Dependency>,
 }>;
 
-// Registry for the dependency of a module.
-// Defines when dependencies should be collapsed.
-// E.g. should a module that's once required optionally and once not
-// be treated as the same or different dependencies.
-export interface ModuleDependencyRegistry {
-  registerDependency(qualifier: ImportQualifier): InternalDependency;
-  getDependencies(): Array<InternalDependency>;
-}
-
 export interface DependencyTransformer {
   transformSyncRequire(
     path: NodePath<CallExpression>,
@@ -149,8 +139,7 @@ function collectDependencies(
   const state: State = {
     asyncRequireModulePathStringLiteral: null,
     dependencyCalls: new Set(),
-    dependencyRegistry:
-      options.dependencyRegistry ?? new DefaultModuleDependencyRegistry(),
+    dependencyRegistry: new DependencyRegistry(),
     dependencyTransformer:
       options.dependencyTransformer ?? DefaultDependencyTransformer,
     dependencyMapIdentifier: null,
@@ -626,11 +615,19 @@ const dynamicRequireErrorTemplate = template.expression(`
  * "require(...)" call to the asyncRequire specified.
  */
 const makeAsyncRequireTemplate = template.expression(`
-  require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, MODULE_NAME, DEPENDENCY_MAP.paths)
+  require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, DEPENDENCY_MAP.paths)
+`);
+
+const makeAsyncRequireTemplateWithName = template.expression(`
+  require(ASYNC_REQUIRE_MODULE_PATH)(MODULE_ID, DEPENDENCY_MAP.paths, MODULE_NAME)
 `);
 
 const makeAsyncPrefetchTemplate = template.expression(`
-  require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, MODULE_NAME, DEPENDENCY_MAP.paths)
+  require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, DEPENDENCY_MAP.paths)
+`);
+
+const makeAsyncPrefetchTemplateWithName = template.expression(`
+  require(ASYNC_REQUIRE_MODULE_PATH).prefetch(MODULE_ID, DEPENDENCY_MAP.paths, MODULE_NAME)
 `);
 
 const makeResolveWeakTemplate = template.expression(`
@@ -661,16 +658,20 @@ const DefaultDependencyTransformer: DependencyTransformer = {
     dependency: InternalDependency,
     state: State,
   ): void {
-    path.replaceWith(
-      makeAsyncRequireTemplate({
-        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
-          state.asyncRequireModulePathStringLiteral,
-        ),
-        MODULE_ID: createModuleIDExpression(dependency, state),
-        MODULE_NAME: createModuleNameLiteral(dependency),
-        DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
-      }),
-    );
+    const makeNode = state.keepRequireNames
+      ? makeAsyncRequireTemplateWithName
+      : makeAsyncRequireTemplate;
+    const opts = {
+      ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+        state.asyncRequireModulePathStringLiteral,
+      ),
+      MODULE_ID: createModuleIDExpression(dependency, state),
+      DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
+      ...(state.keepRequireNames
+        ? {MODULE_NAME: createModuleNameLiteral(dependency)}
+        : null),
+    };
+    path.replaceWith(makeNode(opts));
   },
 
   transformPrefetch(
@@ -678,16 +679,20 @@ const DefaultDependencyTransformer: DependencyTransformer = {
     dependency: InternalDependency,
     state: State,
   ): void {
-    path.replaceWith(
-      makeAsyncPrefetchTemplate({
-        ASYNC_REQUIRE_MODULE_PATH: nullthrows(
-          state.asyncRequireModulePathStringLiteral,
-        ),
-        MODULE_ID: createModuleIDExpression(dependency, state),
-        MODULE_NAME: createModuleNameLiteral(dependency),
-        DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
-      }),
-    );
+    const makeNode = state.keepRequireNames
+      ? makeAsyncPrefetchTemplateWithName
+      : makeAsyncPrefetchTemplate;
+    const opts = {
+      ASYNC_REQUIRE_MODULE_PATH: nullthrows(
+        state.asyncRequireModulePathStringLiteral,
+      ),
+      MODULE_ID: createModuleIDExpression(dependency, state),
+      DEPENDENCY_MAP: nullthrows(state.dependencyMapIdentifier),
+      ...(state.keepRequireNames
+        ? {MODULE_NAME: createModuleNameLiteral(dependency)}
+        : null),
+    };
+    path.replaceWith(makeNode(opts));
   },
 
   transformIllegalDynamicRequire(path: NodePath<>, state: State): void {
@@ -758,7 +763,7 @@ function getKeyForDependency(qualifier: ImportQualifier): string {
   return key;
 }
 
-class DefaultModuleDependencyRegistry implements ModuleDependencyRegistry {
+class DependencyRegistry {
   _dependencies: Map<string, InternalDependency> = new Map();
 
   registerDependency(qualifier: ImportQualifier): InternalDependency {

package/src/Server/MultipartResponse.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 {IncomingMessage, ServerResponse} from 'http';
+
+export type Data = string | Buffer | Uint8Array;
+export interface Headers {
+  [name: string]: string | number;
+}
+
+export default 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;
+}

package/src/Server.d.ts

@@ -0,0 +1,113 @@
+/**
+ * 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 './Asset';
+import type {RamBundleInfo} from './DeltaBundler/Serializers/getRamBundleInfo';
+import IncrementalBundler, {RevisionId} from './IncrementalBundler';
+import type {GraphId} from './lib/getGraphId';
+import type MultipartResponse from './Server/MultipartResponse';
+import type {
+  BundleOptions,
+  GraphOptions,
+  SplitBundleOptions,
+} from './shared/types';
+import type {IncomingMessage, ServerResponse} from 'http';
+import type {
+  CustomTransformOptions,
+  TransformProfile,
+} from 'metro-babel-transformer';
+import type {ConfigT, RootPerfLogger} from 'metro-config';
+import type {CustomResolverOptions} from 'metro-resolver';
+
+export interface SegmentLoadData {
+  [index: number]: [number[], number | null];
+}
+
+export interface BundleMetadata {
+  hash: string;
+  otaBuildNumber: string | null;
+  mobileConfigs: string[];
+  segmentHashes: string[];
+  segmentLoadData: SegmentLoadData;
+}
+
+export interface ProcessStartContext extends SplitBundleOptions {
+  readonly buildNumber: number;
+  readonly bundleOptions: BundleOptions;
+  readonly graphId: GraphId;
+  readonly graphOptions: GraphOptions;
+  readonly mres: MultipartResponse | ServerResponse;
+  readonly req: IncomingMessage;
+  readonly revisionId?: RevisionId | null;
+  readonly bundlePerfLogger: RootPerfLogger;
+}
+
+export interface ProcessDeleteContext {
+  readonly graphId: GraphId;
+  readonly req: IncomingMessage;
+  readonly res: ServerResponse;
+}
+
+export interface ProcessEndContext<T> extends ProcessStartContext {
+  readonly result: T;
+}
+
+export type ServerOptions = Readonly<{
+  hasReducedPerformance?: boolean;
+  onBundleBuilt?: (bundlePath: string) => void;
+  watch?: boolean;
+}>;
+
+export interface DefaultGraphOptions {
+  customResolverOptions: CustomResolverOptions;
+  customTransformOptions: CustomTransformOptions;
+  dev: boolean;
+  hot: boolean;
+  minify: boolean;
+  runtimeBytecodeVersion?: number;
+  unstable_transformProfile: TransformProfile;
+}
+
+export interface DefaultBundleOptions extends DefaultGraphOptions {
+  excludeSource: false;
+  inlineSourceMap: false;
+  modulesOnly: false;
+  onProgress: null;
+  runModule: true;
+  shallow: false;
+  sourceMapUrl: null;
+  sourceUrl: null;
+}
+
+export default class Server {
+  static DEFAULT_GRAPH_OPTIONS: DefaultGraphOptions;
+  static DEFAULT_BUNDLE_OPTIONS: BundleOptions;
+  constructor(config: ConfigT, options?: ServerOptions);
+  end(): void;
+  getBundler(): IncrementalBundler;
+  getCreateModuleId(): (path: string) => number;
+  build(options: BundleOptions): Promise<{
+    code: string;
+    map: string;
+  }>;
+  getRamBundleInfo(options: BundleOptions): Promise<RamBundleInfo>;
+  getAssets(options: BundleOptions): Promise<ReadonlyArray<AssetData>>;
+  getOrderedDependencyPaths(options: {
+    readonly dev: boolean;
+    readonly entryFile: string;
+    readonly minify: boolean;
+    readonly platform: string;
+  }): Promise<string[]>;
+  processRequest(
+    IncomingMessage: IncomingMessage,
+    ServerResponse: ServerResponse,
+    next: (e: Error | null) => unknown,
+  ): void;
+}

package/src/Server.js

@@ -12,7 +12,6 @@
 "use strict";
 
 const { getAsset } = require("./Assets");
-const baseBytecodeBundle = require("./DeltaBundler/Serializers/baseBytecodeBundle");
 const baseJSBundle = require("./DeltaBundler/Serializers/baseJSBundle");
 const getAllFiles = require("./DeltaBundler/Serializers/getAllFiles");
 const getAssets = require("./DeltaBundler/Serializers/getAssets");
@@ -23,7 +22,6 @@ const getRamBundleInfo = require("./DeltaBundler/Serializers/getRamBundleInfo");
 const sourceMapString = require("./DeltaBundler/Serializers/sourceMapString");
 const IncrementalBundler = require("./IncrementalBundler");
 const ResourceNotFoundError = require("./IncrementalBundler/ResourceNotFoundError");
-const bundleToBytecode = require("./lib/bundleToBytecode");
 const bundleToString = require("./lib/bundleToString");
 const formatBundlingError = require("./lib/formatBundlingError");
 const getGraphId = require("./lib/getGraphId");
@@ -54,9 +52,6 @@ const noopLogger = {
 };
 const DELTA_ID_HEADER = "X-Metro-Delta-ID";
 const FILES_CHANGED_COUNT_HEADER = "X-Metro-Files-Changed-Count";
-function getBytecodeVersion() {
-  return require("metro-hermes-compiler").VERSION;
-}
 class Server {
   constructor(config, options) {
     this._config = config;
@@ -290,10 +285,10 @@ class Server {
         "Accept-Ranges": "bytes",
         "Content-Length": chunksize.toString(),
         "Content-Range": `bytes ${dataStart}-${dataEnd}/${data.length}`,
-        "Content-Type": mime.lookup(path.basename(assetPath)),
       });
       return data.slice(dataStart, dataEnd + 1);
     }
+    res.setHeader("Content-Length", String(Buffer.byteLength(data)));
     return data;
   }
   async _processSingleAssetRequest(req, res) {
@@ -334,6 +329,7 @@ class Server {
       if (process.env.REACT_NATIVE_ENABLE_ASSET_CACHING === true) {
         res.setHeader("Cache-Control", "max-age=31536000");
       }
+      res.setHeader("Content-Type", mime.lookup(path.basename(assetPath)));
       res.end(this._rangeRequestMiddleware(req, res, data, assetPath));
       process.nextTick(() => {
         log(createActionEndEntry(processingAssetRequestLogEntry));
@@ -348,11 +344,7 @@ class Server {
     this._processRequest(req, res, next).catch(next);
   };
   _parseOptions(url) {
-    return parseOptionsFromUrl(
-      url,
-      new Set(this._config.resolver.platforms),
-      getBytecodeVersion()
-    );
+    return parseOptionsFromUrl(url, new Set(this._config.resolver.platforms));
   }
   async _processRequest(req, res, next) {
     const originalUrl = req.url;
@@ -372,20 +364,13 @@ class Server {
     const buildNumber = this.getNewBuildNumber();
     if (pathname.endsWith(".bundle")) {
       const options = this._parseOptions(formattedUrl);
-      if (options.runtimeBytecodeVersion) {
-        await this._processBytecodeBundleRequest(req, res, options, {
-          buildNumber,
-          bundlePerfLogger: noopLogger,
-        });
-      } else {
-        await this._processBundleRequest(req, res, options, {
-          buildNumber,
-          bundlePerfLogger:
-            this._config.unstable_perfLoggerFactory?.("BUNDLING_REQUEST", {
-              key: buildNumber,
-            }) ?? noopLogger,
-        });
-      }
+      await this._processBundleRequest(req, res, options, {
+        buildNumber,
+        bundlePerfLogger:
+          this._config.unstable_perfLoggerFactory?.("BUNDLING_REQUEST", {
+            key: buildNumber,
+          }) ?? noopLogger,
+      });
       if (this._serverOptions && this._serverOptions.onBundleBuilt) {
         this._serverOptions.onBundleBuilt(pathname);
       }
@@ -533,7 +518,6 @@ class Server {
           entryFile: resolvedEntryFilePath,
           minify: transformOptions.minify,
           platform: transformOptions.platform,
-          runtimeBytecodeVersion: transformOptions.runtimeBytecodeVersion,
         },
         isPrefetch: req.method === "HEAD",
         type: "bundle_build_started",
@@ -742,110 +726,6 @@ class Server {
       res.end();
     },
   });
-  _processBytecodeBundleRequest = this._createRequestProcessor({
-    createStartEntry(context) {
-      return {
-        action_name: "Requesting bundle",
-        bundle_url: context.req.url,
-        entry_point: context.entryFile,
-        bundler: "delta",
-        build_id: getBuildID(context.buildNumber),
-        bundle_options: context.bundleOptions,
-        bundle_hash: context.graphId,
-      };
-    },
-    createEndEntry(context) {
-      return {
-        outdated_modules: context.result.numModifiedFiles,
-      };
-    },
-    build: async ({
-      entryFile,
-      graphId,
-      graphOptions,
-      onProgress,
-      resolverOptions,
-      serializerOptions,
-      transformOptions,
-    }) => {
-      const revPromise = this._bundler.getRevisionByGraphId(graphId);
-      const { delta, revision } = await (revPromise != null
-        ? this._bundler.updateGraph(await revPromise, false)
-        : this._bundler.initializeGraph(
-            entryFile,
-            transformOptions,
-            resolverOptions,
-            {
-              onProgress,
-              shallow: graphOptions.shallow,
-            }
-          ));
-      const bundle = bundleToBytecode(
-        baseBytecodeBundle(entryFile, revision.prepend, revision.graph, {
-          asyncRequireModulePath: await this._resolveRelativePath(
-            this._config.transformer.asyncRequireModulePath,
-            {
-              relativeTo: "project",
-              resolverOptions,
-              transformOptions,
-            }
-          ),
-          processModuleFilter: this._config.serializer.processModuleFilter,
-          createModuleId: this._createModuleId,
-          getRunModuleStatement: this._config.serializer.getRunModuleStatement,
-          includeAsyncPaths:
-            this._config.server.experimentalImportBundleSupport,
-          dev: transformOptions.dev,
-          projectRoot: this._config.projectRoot,
-          modulesOnly: serializerOptions.modulesOnly,
-          runBeforeMainModule:
-            this._config.serializer.getModulesRunBeforeMainModule(
-              path.relative(this._config.projectRoot, entryFile)
-            ),
-          runModule: serializerOptions.runModule,
-          sourceMapUrl: serializerOptions.sourceMapUrl,
-          sourceUrl: serializerOptions.sourceUrl,
-          inlineSourceMap: serializerOptions.inlineSourceMap,
-          serverRoot:
-            this._config.server.unstable_serverRoot ?? this._config.projectRoot,
-        })
-      );
-      return {
-        numModifiedFiles: delta.reset
-          ? delta.added.size + revision.prepend.length
-          : delta.added.size + delta.modified.size + delta.deleted.size,
-        lastModifiedDate: revision.date,
-        nextRevId: revision.id,
-        bytecode: bundle.bytecode,
-      };
-    },
-    finish({ req, mres, result }) {
-      if (
-        // We avoid parsing the dates since the client should never send a more
-        // recent date than the one returned by the Delta Bundler (if that's the
-        // case it's fine to return the whole bundle).
-        req.headers["if-modified-since"] ===
-        result.lastModifiedDate.toUTCString()
-      ) {
-        debug("Responding with 304");
-        mres.writeHead(304);
-        mres.end();
-      } else {
-        mres.setHeader(
-          FILES_CHANGED_COUNT_HEADER,
-          String(result.numModifiedFiles)
-        );
-        mres.setHeader(DELTA_ID_HEADER, String(result.nextRevId));
-        mres.setHeader("Content-Type", "application/x-metro-bytecode-bundle");
-        mres.setHeader("Last-Modified", result.lastModifiedDate.toUTCString());
-        mres.setHeader(
-          "Content-Length",
-          String(Buffer.byteLength(result.bytecode))
-        );
-        mres.end(result.bytecode);
-      }
-    },
-  });
 
   // This function ensures that modules in source maps are sorted in the same
   // order as in a plain JS bundle.
@@ -1061,8 +941,7 @@ class Server {
   async _explodedSourceMapForURL(reqUrl) {
     const options = parseOptionsFromUrl(
       reqUrl,
-      new Set(this._config.resolver.platforms),
-      getBytecodeVersion()
+      new Set(this._config.resolver.platforms)
     );
     const {
       entryFile,
@@ -1146,7 +1025,6 @@ class Server {
     dev: true,
     hot: false,
     minify: false,
-    runtimeBytecodeVersion: null,
     unstable_transformProfile: "default",
   };
   static DEFAULT_BUNDLE_OPTIONS = {