diff --git a/packages/buck-worker-tool/API.md b/packages/buck-worker-tool/API.md
index 205426a1cd..8610577493 100644
--- a/packages/buck-worker-tool/API.md
+++ b/packages/buck-worker-tool/API.md
@@ -4,7 +4,7 @@
 
 ```ts
 
-import type { Duplex } from 'node:stream';
+import type {Duplex} from 'node:stream';
 
 export function buckWorker(commands: Commands): Duplex;
 
diff --git a/packages/metro-babel-transformer/API.md b/packages/metro-babel-transformer/API.md
index a6da7b5871..f5a839648c 100644
--- a/packages/metro-babel-transformer/API.md
+++ b/packages/metro-babel-transformer/API.md
@@ -4,52 +4,52 @@
 
 ```ts
 
-import type { BabelFileMetadata } from '@babel/core';
-import type { File as File_2 } from '@babel/types';
-import { transformFromAstSync } from '@babel/core';
+import type {BabelFileMetadata} from '@babel/core';
+import type {File as File_2} from '@babel/types';
+import {transformFromAstSync} from '@babel/core';
 
 export type BabelFileFunctionMapMetadata = Readonly<{
-    names: ReadonlyArray<string>;
-    mappings: string;
+  names: ReadonlyArray<string>;
+  mappings: string;
 }>;
 
 export type BabelFileImportLocsMetadata = ReadonlySet<string>;
 
 export type BabelTransformer = Readonly<{
-    transform: (transformerArgs: BabelTransformerArgs) => Readonly<{
-        ast: File_2;
-        functionMap?: BabelFileFunctionMapMetadata | undefined;
-        metadata?: MetroBabelFileMetadata | undefined;
-    }>;
-    getCacheKey?: ((options?: BabelTransformerCacheKeyOptions) => string) | undefined;
+  transform: (transformerArgs: BabelTransformerArgs) => Readonly<{
+    ast: File_2;
+    functionMap?: BabelFileFunctionMapMetadata | undefined;
+    metadata?: MetroBabelFileMetadata | undefined;
+  }>;
+  getCacheKey?: ((options?: BabelTransformerCacheKeyOptions) => string) | undefined;
 }>;
 
 export type BabelTransformerArgs = Readonly<{
-    filename: string;
-    options: BabelTransformerOptions;
-    plugins?: BabelTransformOptions['plugins'] | undefined;
-    src: string;
+  filename: string;
+  options: BabelTransformerOptions;
+  plugins?: BabelTransformOptions['plugins'] | undefined;
+  src: string;
 }>;
 
 export type BabelTransformerCacheKeyOptions = Readonly<{
-    projectRoot?: string | undefined;
-    enableBabelRCLookup?: boolean | undefined;
+  projectRoot?: string | undefined;
+  enableBabelRCLookup?: boolean | undefined;
 }>;
 
 export type CustomTransformOptions = {
-    [key: string]: unknown;
+  [key: string]: unknown;
 };
 
 export function getCacheKey(options?: BabelTransformerCacheKeyOptions): string;
 
 export type MetroBabelFileMetadata = Omit<BabelFileMetadata, 'metro'> & {
-    metro?:
+  metro?:
     | null
     | undefined
     | {
         functionMap?: null | undefined | BabelFileFunctionMapMetadata;
         unstable_importDeclarationLocs?: null | undefined | BabelFileImportLocsMetadata;
-    };
+      };
 };
 
 export function transform(opts: BabelTransformerArgs): ReturnType<BabelTransformer['transform']>;
diff --git a/packages/metro-cache/API.md b/packages/metro-cache/API.md
index 118ba8abda..d466899eb0 100644
--- a/packages/metro-cache/API.md
+++ b/packages/metro-cache/API.md
@@ -6,57 +6,57 @@
 
 // @deprecated
 export class AutoCleanFileStore<T> extends FileStore<T> {
-    constructor(opts: CleanOptions);
+  constructor(opts: CleanOptions);
 }
 
 class Cache_2<T> {
-    constructor(stores: ReadonlyArray<CacheStore<T>>);
-    get(key: Buffer): Promise<null | undefined | T>;
-    get isDisabled(): boolean;
-    set(key: Buffer, value: T): Promise<void>;
+  constructor(stores: ReadonlyArray<CacheStore<T>>);
+  get(key: Buffer): Promise<null | undefined | T>;
+  get isDisabled(): boolean;
+  set(key: Buffer, value: T): Promise<void>;
 }
-export { Cache_2 as Cache }
+export {Cache_2 as Cache};
 
 export interface CacheStore<T> {
-    clear(): void | Promise<void>;
-    get(key: Buffer): (null | undefined | T) | Promise<null | undefined | T>;
-    name?: string | undefined;
-    set(key: Buffer, value: T): void | Promise<void>;
+  clear(): void | Promise<void>;
+  get(key: Buffer): (null | undefined | T) | Promise<null | undefined | T>;
+  name?: string | undefined;
+  set(key: Buffer, value: T): void | Promise<void>;
 }
 
 export type FileOptions = Readonly<{root: string}>;
 
 export class FileStore<T> {
-    constructor(options: FileOptions);
-    clear(): void;
-    get(key: Buffer): Promise<null | undefined | T>;
-    set(key: Buffer, value: T): Promise<void>;
+  constructor(options: FileOptions);
+  clear(): void;
+  get(key: Buffer): Promise<null | undefined | T>;
+  set(key: Buffer, value: T): Promise<void>;
 }
 
 export class HttpGetStore<T> extends HttpStore<T> {
-    constructor(options: HttpOptions);
-    get(key: Buffer): Promise<null | undefined | T>;
-    set(_key: Buffer, _value: T): Promise<void>;
+  constructor(options: HttpOptions);
+  get(key: Buffer): Promise<null | undefined | T>;
+  set(_key: Buffer, _value: T): Promise<void>;
 }
 
 export type HttpOptions = EndpointOptions | {getOptions: EndpointOptions; setOptions: EndpointOptions};
 
 export class HttpStore<T> {
-    constructor(options: HttpOptions);
-    clear(): void;
-    get(key: Buffer): Promise<null | undefined | T>;
-    static HttpError: typeof HttpError;
-    static NetworkError: typeof NetworkError;
-    set(key: Buffer, value: T): Promise<void>;
+  constructor(options: HttpOptions);
+  clear(): void;
+  get(key: Buffer): Promise<null | undefined | T>;
+  static HttpError: typeof HttpError;
+  static NetworkError: typeof NetworkError;
+  set(key: Buffer, value: T): Promise<void>;
 }
 
 export interface MetroCache {
-    readonly AutoCleanFileStore: typeof AutoCleanFileStore;
-    readonly Cache: typeof Cache_2;
-    readonly FileStore: typeof FileStore;
-    readonly HttpGetStore: typeof HttpGetStore;
-    readonly HttpStore: typeof HttpStore;
-    readonly stableHash: typeof stableHash;
+  readonly AutoCleanFileStore: typeof AutoCleanFileStore;
+  readonly Cache: typeof Cache_2;
+  readonly FileStore: typeof FileStore;
+  readonly HttpGetStore: typeof HttpGetStore;
+  readonly HttpStore: typeof HttpStore;
+  readonly stableHash: typeof stableHash;
 }
 
 export function stableHash(value: unknown): Buffer;
diff --git a/packages/metro-config/API.md b/packages/metro-config/API.md
index 9416141a1c..58a8d84074 100644
--- a/packages/metro-config/API.md
+++ b/packages/metro-config/API.md
@@ -5,15 +5,15 @@
 ```ts
 
 import EventEmitter from 'node:events';
-import type { HandleFunction } from 'connect';
-import type { IncomingMessage } from 'connect';
-import type { Server as Server_2 } from 'connect';
-import type { ServerResponse } from 'node:http';
+import type {HandleFunction} from 'connect';
+import type {IncomingMessage} from 'connect';
+import type {Server as Server_2} from 'connect';
+import type {ServerResponse} from 'node:http';
 
 export type CacheStoresConfigT = ReadonlyArray<CacheStore<TransformResult>>;
 
 export type ConfigT = Readonly<
-MetalConfigT & {
+  MetalConfigT & {
     cacheStores: CacheStoresConfigT;
     resolver: Readonly<ResolverConfigT>;
     server: Readonly<ServerConfigT>;
@@ -21,90 +21,90 @@ MetalConfigT & {
     symbolicator: Readonly<SymbolicatorConfigT>;
     transformer: Readonly<TransformerConfigT>;
     watcher: Readonly<WatcherConfigT>;
-}
+  }
 >;
 
 export type ExtraTransformOptions = Readonly<{
-    preloadedModules?: Readonly<{[path: string]: true}> | false | undefined;
-    ramGroups?: ReadonlyArray<string> | undefined;
-    transform?:
+  preloadedModules?: Readonly<{[path: string]: true}> | false | undefined;
+  ramGroups?: ReadonlyArray<string> | undefined;
+  transform?:
     | Readonly<{
         experimentalImportSupport?: boolean | undefined;
         inlineRequires?:
-        | Readonly<{
-            blockList: Readonly<{[absoluteModulePath: string]: true}>;
-        }>
-        | boolean
-        | undefined;
+          | Readonly<{
+              blockList: Readonly<{[absoluteModulePath: string]: true}>;
+            }>
+          | boolean
+          | undefined;
         nonInlinedRequires?: ReadonlyArray<string> | undefined;
         unstable_memoizeInlineRequires?: boolean | undefined;
         unstable_nonMemoizedInlineRequires?: ReadonlyArray<string> | undefined;
-    }>
+      }>
     | undefined;
 }>;
 
 export const getDefaultConfig: {
-    (rootPath?: string): Promise<ConfigT>;
-    getDefaultValues: (rootPath?: string) => ConfigT;
+  (rootPath?: string): Promise<ConfigT>;
+  getDefaultValues: (rootPath?: string) => ConfigT;
 };
 
 export type getDefaultConfig = typeof getDefaultConfig;
 
 export type GetTransformOptions = (
-entryPoints: ReadonlyArray<string>,
-options: GetTransformOptionsOpts,
-getDependenciesOf: (absoluteFilePath: string) => Promise<Array<string>>,
+  entryPoints: ReadonlyArray<string>,
+  options: GetTransformOptionsOpts,
+  getDependenciesOf: (absoluteFilePath: string) => Promise<Array<string>>,
 ) => Promise<Partial<ExtraTransformOptions>>;
 
 export type GetTransformOptionsOpts = {
-    dev: boolean;
-    hot: true;
-    platform: null | undefined | string;
+  dev: boolean;
+  hot: true;
+  platform: null | undefined | string;
 };
 
 export type InputConfigT = Partial<
-Readonly<
-MetalConfigT & {
-    cacheStores: CacheStoresConfigT | ((metroCache: MetroCache) => CacheStoresConfigT);
-    resolver: Readonly<Partial<ResolverConfigT>>;
-    server: Readonly<Partial<ServerConfigT>>;
-    serializer: Readonly<Partial<SerializerConfigT>>;
-    symbolicator: Readonly<Partial<SymbolicatorConfigT>>;
-    transformer: Readonly<Partial<TransformerConfigT>>;
-    watcher: Partial<
-    Readonly<
-    Omit<WatcherConfigT, 'healthCheck' | 'unstable_autoSaveCache' | 'watchman'> & {
-        healthCheck: Partial<Readonly<WatcherConfigT['healthCheck']>>;
-        unstable_autoSaveCache: Partial<Readonly<WatcherConfigT['unstable_autoSaveCache']>>;
-        watchman: Partial<Readonly<WatcherConfigT['watchman']>>;
+  Readonly<
+    MetalConfigT & {
+      cacheStores: CacheStoresConfigT | ((metroCache: MetroCache) => CacheStoresConfigT);
+      resolver: Readonly<Partial<ResolverConfigT>>;
+      server: Readonly<Partial<ServerConfigT>>;
+      serializer: Readonly<Partial<SerializerConfigT>>;
+      symbolicator: Readonly<Partial<SymbolicatorConfigT>>;
+      transformer: Readonly<Partial<TransformerConfigT>>;
+      watcher: Partial<
+        Readonly<
+          Omit<WatcherConfigT, 'healthCheck' | 'unstable_autoSaveCache' | 'watchman'> & {
+            healthCheck: Partial<Readonly<WatcherConfigT['healthCheck']>>;
+            unstable_autoSaveCache: Partial<Readonly<WatcherConfigT['unstable_autoSaveCache']>>;
+            watchman: Partial<Readonly<WatcherConfigT['watchman']>>;
+          }
+        >
+      >;
     }
-    >
-    >;
-}
->
+  >
 >;
 
 export function loadConfig(argvInput?: YargArguments, defaultConfigOverrides?: InputConfigT): Promise<ConfigT>;
 
 export function mergeConfig<T extends InputConfigT, R extends ReadonlyArray<InputConfigT | ((baseConfig: T) => InputConfigT) | ((baseConfig: T) => Promise<InputConfigT>)>>(
-base: T | (() => T),
-...configs: R
+  base: T | (() => T),
+  ...configs: R
 ): R extends ReadonlyArray<InputConfigT | ((baseConfig: T) => InputConfigT)> ? T : Promise<T>;
 
 export type MetalConfigT = {
-    cacheVersion: string;
-    fileMapCacheDirectory?: string | undefined;
-    hasteMapCacheDirectory?: string | undefined;
-    unstable_fileMapCacheManagerFactory?: CacheManagerFactory | undefined;
-    unstable_fileMapPlugins?: ReadonlyArray<InputFileMapPlugin> | undefined;
-    maxWorkers: number;
-    unstable_perfLoggerFactory?: null | undefined | PerfLoggerFactory;
-    projectRoot: string;
-    stickyWorkers: boolean;
-    transformerPath: string;
-    reporter: Reporter;
-    resetCache: boolean;
-    watchFolders: ReadonlyArray<string>;
+  cacheVersion: string;
+  fileMapCacheDirectory?: string | undefined;
+  hasteMapCacheDirectory?: string | undefined;
+  unstable_fileMapCacheManagerFactory?: CacheManagerFactory | undefined;
+  unstable_fileMapPlugins?: ReadonlyArray<InputFileMapPlugin> | undefined;
+  maxWorkers: number;
+  unstable_perfLoggerFactory?: null | undefined | PerfLoggerFactory;
+  projectRoot: string;
+  stickyWorkers: boolean;
+  transformerPath: string;
+  reporter: Reporter;
+  resetCache: boolean;
+  watchFolders: ReadonlyArray<string>;
 };
 
 export type MetroConfig = InputConfigT;
@@ -112,20 +112,20 @@ export type MetroConfig = InputConfigT;
 export type Middleware = HandleFunction;
 
 export type PerfAnnotations = Partial<{
-    string: Readonly<{[key: string]: string}>;
-    int: Readonly<{[key: string]: number}>;
-    double: Readonly<{[key: string]: number}>;
-    bool: Readonly<{[key: string]: boolean}>;
-    string_array: Readonly<{[key: string]: ReadonlyArray<string>}>;
-    int_array: Readonly<{[key: string]: ReadonlyArray<number>}>;
-    double_array: Readonly<{[key: string]: ReadonlyArray<number>}>;
-    bool_array: Readonly<{[key: string]: ReadonlyArray<boolean>}>;
+  string: Readonly<{[key: string]: string}>;
+  int: Readonly<{[key: string]: number}>;
+  double: Readonly<{[key: string]: number}>;
+  bool: Readonly<{[key: string]: boolean}>;
+  string_array: Readonly<{[key: string]: ReadonlyArray<string>}>;
+  int_array: Readonly<{[key: string]: ReadonlyArray<number>}>;
+  double_array: Readonly<{[key: string]: ReadonlyArray<number>}>;
+  bool_array: Readonly<{[key: string]: ReadonlyArray<boolean>}>;
 }>;
 
 export interface PerfLogger {
-    annotate(annotations: PerfAnnotations): void;
-    point(name: string, opts?: PerfLoggerPointOptions): void;
-    subSpan(label: string): PerfLogger;
+  annotate(annotations: PerfAnnotations): void;
+  point(name: string, opts?: PerfLoggerPointOptions): void;
+  subSpan(label: string): PerfLogger;
 }
 
 export type PerfLoggerFactory = (type: 'START_UP' | 'BUNDLING_REQUEST' | 'HMR', opts?: PerfLoggerFactoryOptions) => RootPerfLogger;
@@ -137,120 +137,120 @@ export type PerfLoggerPointOptions = Readonly<{timestamp?: number | undefined}>;
 export function resolveConfig(filePath?: string, cwd?: string): Promise<ResolveConfigResult>;
 
 export type ResolverConfigT = {
-    assetExts: ReadonlyArray<string>;
-    assetResolutions: ReadonlyArray<string>;
-    blockList: RegExp | Array<RegExp>;
-    disableHierarchicalLookup: boolean;
-    dependencyExtractor: null | undefined | string;
-    emptyModulePath: string;
-    enableGlobalPackages: boolean;
-    extraNodeModules: {[packageName: string]: string};
-    hasteImplModulePath: null | undefined | string;
-    nodeModulesPaths: ReadonlyArray<string>;
-    platforms: ReadonlyArray<string>;
-    resolveRequest: null | undefined | CustomResolver;
-    resolverMainFields: ReadonlyArray<string>;
-    schemeResolvers: Readonly<{[scheme: string]: CustomResolver}>;
-    sourceExts: ReadonlyArray<string>;
-    unstable_conditionNames: ReadonlyArray<string>;
-    unstable_conditionsByPlatform: Readonly<{
-        [platform: string]: ReadonlyArray<string>;
-    }>;
-    unstable_enablePackageExports: boolean;
-    unstable_incrementalResolution: boolean;
-    useWatchman: boolean;
-    requireCycleIgnorePatterns: ReadonlyArray<RegExp>;
-    unstable_forceFullRefreshPatterns: ReadonlyArray<RegExp>;
+  assetExts: ReadonlyArray<string>;
+  assetResolutions: ReadonlyArray<string>;
+  blockList: RegExp | Array<RegExp>;
+  disableHierarchicalLookup: boolean;
+  dependencyExtractor: null | undefined | string;
+  emptyModulePath: string;
+  enableGlobalPackages: boolean;
+  extraNodeModules: {[packageName: string]: string};
+  hasteImplModulePath: null | undefined | string;
+  nodeModulesPaths: ReadonlyArray<string>;
+  platforms: ReadonlyArray<string>;
+  resolveRequest: null | undefined | CustomResolver;
+  resolverMainFields: ReadonlyArray<string>;
+  schemeResolvers: Readonly<{[scheme: string]: CustomResolver}>;
+  sourceExts: ReadonlyArray<string>;
+  unstable_conditionNames: ReadonlyArray<string>;
+  unstable_conditionsByPlatform: Readonly<{
+    [platform: string]: ReadonlyArray<string>;
+  }>;
+  unstable_enablePackageExports: boolean;
+  unstable_incrementalResolution: boolean;
+  useWatchman: boolean;
+  requireCycleIgnorePatterns: ReadonlyArray<RegExp>;
+  unstable_forceFullRefreshPatterns: ReadonlyArray<RegExp>;
 };
 
 export interface RootPerfLogger extends PerfLogger {
-    end(status: 'SUCCESS' | 'FAIL' | 'CANCEL', opts?: PerfLoggerPointOptions): void;
-    start(opts?: PerfLoggerPointOptions): void;
+  end(status: 'SUCCESS' | 'FAIL' | 'CANCEL', opts?: PerfLoggerPointOptions): void;
+  start(opts?: PerfLoggerPointOptions): void;
 }
 
 export type SerializerConfigT = {
-    createModuleIdFactory: () => (path: string) => number;
-    customSerializer: null | undefined | ((entryPoint: string, preModules: ReadonlyArray<Module>, graph: ReadOnlyGraph, options: SerializerOptions) => Promise<string | {code: string; map: string}>);
-    experimentalSerializerHook: (graph: ReadOnlyGraph, delta: DeltaResult) => unknown;
-    getModulesRunBeforeMainModule: (entryFilePath: string) => Array<string>;
-    getPolyfills: (ctx: {platform: null | undefined | string}) => ReadonlyArray<string>;
-    getRunModuleStatement: (moduleId: number | string, globalPrefix: string) => string;
-    polyfillModuleNames: ReadonlyArray<string>;
-    processModuleFilter: (modules: Module) => boolean;
-    isThirdPartyModule: (module: Readonly<{path: string}>) => boolean;
-    unstable_inlineDependencyMap: boolean;
-    unstable_lazilyDefineModules: boolean;
+  createModuleIdFactory: () => (path: string) => number;
+  customSerializer: null | undefined | ((entryPoint: string, preModules: ReadonlyArray<Module>, graph: ReadOnlyGraph, options: SerializerOptions) => Promise<string | {code: string; map: string}>);
+  experimentalSerializerHook: (graph: ReadOnlyGraph, delta: DeltaResult) => unknown;
+  getModulesRunBeforeMainModule: (entryFilePath: string) => Array<string>;
+  getPolyfills: (ctx: {platform: null | undefined | string}) => ReadonlyArray<string>;
+  getRunModuleStatement: (moduleId: number | string, globalPrefix: string) => string;
+  polyfillModuleNames: ReadonlyArray<string>;
+  processModuleFilter: (modules: Module) => boolean;
+  isThirdPartyModule: (module: Readonly<{path: string}>) => boolean;
+  unstable_inlineDependencyMap: boolean;
+  unstable_lazilyDefineModules: boolean;
 };
 
 export type ServerConfigT = {
-    enhanceMiddleware: (middleware: Middleware, server: Server) => Middleware | Server_2;
-    forwardClientLogs: boolean;
-    port: number;
-    rewriteRequestUrl: (url: string) => string;
-    unstable_serverRoot: null | undefined | string;
-    useGlobalHotkey: boolean;
-    verifyConnections: boolean;
-    tls:
+  enhanceMiddleware: (middleware: Middleware, server: Server) => Middleware | Server_2;
+  forwardClientLogs: boolean;
+  port: number;
+  rewriteRequestUrl: (url: string) => string;
+  unstable_serverRoot: null | undefined | string;
+  useGlobalHotkey: boolean;
+  verifyConnections: boolean;
+  tls:
     | false
     | {
         ca?: string | Buffer | undefined;
         cert?: string | Buffer | undefined;
         key?: string | Buffer | undefined;
         requestCert?: boolean | undefined;
-    };
+      };
 };
 
 export type SymbolicatorConfigT = {
-    customizeFrame: (frame: {
-        readonly file: null | undefined | string;
-        readonly lineNumber: null | undefined | number;
-        readonly column: null | undefined | number;
-        readonly methodName: null | undefined | string;
-    }) => (null | undefined | {readonly collapse?: boolean | undefined}) | Promise<null | undefined | {readonly collapse?: boolean | undefined}>;
-    customizeStack: (symbolicatedStack: Array<IntermediateStackFrame>, extraData: unknown) => Array<IntermediateStackFrame> | Promise<Array<IntermediateStackFrame>>;
+  customizeFrame: (frame: {
+    readonly file: null | undefined | string;
+    readonly lineNumber: null | undefined | number;
+    readonly column: null | undefined | number;
+    readonly methodName: null | undefined | string;
+  }) => (null | undefined | {readonly collapse?: boolean | undefined}) | Promise<null | undefined | {readonly collapse?: boolean | undefined}>;
+  customizeStack: (symbolicatedStack: Array<IntermediateStackFrame>, extraData: unknown) => Array<IntermediateStackFrame> | Promise<Array<IntermediateStackFrame>>;
 };
 
 export type TransformerConfigT = Omit<JsTransformerConfig, 'getTransformOptions' | 'transformVariants' | 'publicPath' | 'unstable_workerThreads'> & {
-    getTransformOptions: GetTransformOptions;
-    transformVariants: {
-        readonly [name: string]: Partial<ExtraTransformOptions>;
-    };
-    publicPath: string;
-    unstable_workerThreads: boolean;
+  getTransformOptions: GetTransformOptions;
+  transformVariants: {
+    readonly [name: string]: Partial<ExtraTransformOptions>;
+  };
+  publicPath: string;
+  unstable_workerThreads: boolean;
 };
 
 export type WatcherConfigT = {
-    additionalExts: ReadonlyArray<string>;
-    healthCheck: Readonly<{
-        enabled: boolean;
-        interval: number;
-        timeout: number;
-        filePrefix: string;
-    }>;
-    unstable_autoSaveCache: Readonly<{
-        enabled: boolean;
-        debounceMs?: number | undefined;
-    }>;
-    unstable_lazySha1: boolean;
-    watchman: Readonly<{deferStates: ReadonlyArray<string>}>;
+  additionalExts: ReadonlyArray<string>;
+  healthCheck: Readonly<{
+    enabled: boolean;
+    interval: number;
+    timeout: number;
+    filePrefix: string;
+  }>;
+  unstable_autoSaveCache: Readonly<{
+    enabled: boolean;
+    debounceMs?: number | undefined;
+  }>;
+  unstable_lazySha1: boolean;
+  watchman: Readonly<{deferStates: ReadonlyArray<string>}>;
 };
 
 export type YargArguments = Readonly<{
-    config?: string | undefined;
-    cwd?: string | undefined;
-    port?: string | number | undefined;
-    host?: string | undefined;
-    projectRoot?: string | undefined;
-    watchFolders?: Array<string> | undefined;
-    assetExts?: Array<string> | undefined;
-    sourceExts?: Array<string> | undefined;
-    platforms?: Array<string> | undefined;
-    'max-workers'?: string | number | undefined;
-    maxWorkers?: string | number | undefined;
-    transformer?: string | undefined;
-    'reset-cache'?: boolean | undefined;
-    resetCache?: boolean | undefined;
-    verbose?: boolean | undefined;
+  config?: string | undefined;
+  cwd?: string | undefined;
+  port?: string | number | undefined;
+  host?: string | undefined;
+  projectRoot?: string | undefined;
+  watchFolders?: Array<string> | undefined;
+  assetExts?: Array<string> | undefined;
+  sourceExts?: Array<string> | undefined;
+  platforms?: Array<string> | undefined;
+  'max-workers'?: string | number | undefined;
+  maxWorkers?: string | number | undefined;
+  transformer?: string | undefined;
+  'reset-cache'?: boolean | undefined;
+  resetCache?: boolean | undefined;
+  verbose?: boolean | undefined;
 }>;
 
 ```
diff --git a/packages/metro-core/API.md b/packages/metro-core/API.md
index 4ae8ebf327..f4ed7e8086 100644
--- a/packages/metro-core/API.md
+++ b/packages/metro-core/API.md
@@ -4,26 +4,26 @@
 
 ```ts
 
-import type { Socket } from 'node:net';
-import type { Writable } from 'node:stream';
+import type {Socket} from 'node:net';
+import type {Writable} from 'node:stream';
 
 type ActionLogEntryData = {
-    action_name: string;
-    log_entry_label?: string | undefined;
+  action_name: string;
+  log_entry_label?: string | undefined;
 };
 
 type ActionStartLogEntry = {
-    action_name?: string | undefined;
-    action_phase?: string | undefined;
-    log_entry_label: string;
-    log_session?: string | undefined;
-    start_timestamp?: [number, number] | undefined;
+  action_name?: string | undefined;
+  action_phase?: string | undefined;
+  log_entry_label: string;
+  log_session?: string | undefined;
+  start_timestamp?: [number, number] | undefined;
 };
 
 export class AmbiguousModuleResolutionError extends Error {
-    constructor(fromModulePath: string, hasteError: DuplicateHasteCandidatesError);
-    fromModulePath: string;
-    hasteError: DuplicateHasteCandidatesError;
+  constructor(fromModulePath: string, hasteError: DuplicateHasteCandidatesError);
+  fromModulePath: string;
+  hasteError: DuplicateHasteCandidatesError;
 }
 
 function createActionEndEntry(logEntry: ActionStartLogEntry, error?: null | undefined | Error): LogEntry;
@@ -35,54 +35,45 @@ function createEntry(data: LogEntry | string): LogEntry;
 function log(logEntry: LogEntry): LogEntry;
 
 type LogEntry = {
-    action_name?: string | undefined;
-    action_phase?: string | undefined;
-    action_result?: string | undefined;
-    duration_ms?: number | undefined;
-    entry_point?: string | undefined;
-    file_name?: string | undefined;
-    log_entry_label: string;
-    log_session?: string | undefined;
-    start_timestamp?: [number, number] | undefined;
-    outdated_modules?: number | undefined;
-    bundle_size?: number | undefined;
-    bundle_options?: BundleOptions | undefined;
-    bundle_hash?: string | undefined;
-    build_id?: string | undefined;
-    error_message?: string | undefined;
-    error_stack?: string | undefined;
+  action_name?: string | undefined;
+  action_phase?: string | undefined;
+  action_result?: string | undefined;
+  duration_ms?: number | undefined;
+  entry_point?: string | undefined;
+  file_name?: string | undefined;
+  log_entry_label: string;
+  log_session?: string | undefined;
+  start_timestamp?: [number, number] | undefined;
+  outdated_modules?: number | undefined;
+  bundle_size?: number | undefined;
+  bundle_options?: BundleOptions | undefined;
+  bundle_hash?: string | undefined;
+  build_id?: string | undefined;
+  error_message?: string | undefined;
+  error_stack?: string | undefined;
 };
 
 declare namespace Logger {
-    export {
-        ActionLogEntryData,
-        ActionStartLogEntry,
-        LogEntry,
-        on,
-        createEntry,
-        createActionStartEntry,
-        createActionEndEntry,
-        log
-    }
+  export {ActionLogEntryData, ActionStartLogEntry, LogEntry, on, createEntry, createActionStartEntry, createActionEndEntry, log};
 }
-export { Logger }
+export {Logger};
 
 function on(event: string, handler: (logEntry: LogEntry) => void): void;
 
 export class PackageResolutionError extends Error {
-    constructor(opts: {readonly originModulePath: string; readonly packageError: InvalidPackageError; readonly targetModuleName: string});
-    originModulePath: string;
-    packageError: InvalidPackageError;
-    targetModuleName: string;
+  constructor(opts: {readonly originModulePath: string; readonly packageError: InvalidPackageError; readonly targetModuleName: string});
+  originModulePath: string;
+  packageError: InvalidPackageError;
+  targetModuleName: string;
 }
 
 export class Terminal {
-    constructor(stream: UnderlyingStream, opts?: {ttyPrint?: boolean | undefined});
-    flush(): Promise<void>;
-    log(format: string, ...args: Array<unknown>): void;
-    persistStatus(): void;
-    status(format: string, ...args: Array<unknown>): string;
-    waitForUpdates(): Promise<void>;
+  constructor(stream: UnderlyingStream, opts?: {ttyPrint?: boolean | undefined});
+  flush(): Promise<void>;
+  log(format: string, ...args: Array<unknown>): void;
+  persistStatus(): void;
+  status(format: string, ...args: Array<unknown>): string;
+  waitForUpdates(): Promise<void>;
 }
 
 ```
diff --git a/packages/metro-file-map/API.md b/packages/metro-file-map/API.md
index 2111332e91..b95d448ce8 100644
--- a/packages/metro-file-map/API.md
+++ b/packages/metro-file-map/API.md
@@ -7,53 +7,53 @@
 import EventEmitter from 'node:events';
 
 export type BuildParameters = Readonly<{
-    computeSha1: boolean;
-    enableSymlinks: boolean;
-    extensions: ReadonlyArray<string>;
-    ignorePattern: RegExp;
-    plugins: ReadonlyArray<InputFileMapPlugin>;
-    retainAllFiles: boolean;
-    rootDir: string;
-    roots: ReadonlyArray<string>;
-    cacheBreaker: string;
+  computeSha1: boolean;
+  enableSymlinks: boolean;
+  extensions: ReadonlyArray<string>;
+  ignorePattern: RegExp;
+  plugins: ReadonlyArray<InputFileMapPlugin>;
+  retainAllFiles: boolean;
+  rootDir: string;
+  roots: ReadonlyArray<string>;
+  cacheBreaker: string;
 }>;
 
 export type BuildResult = {fileSystem: FileSystem_2};
 
 export type CacheData = Readonly<{
-    clocks: WatchmanClocks;
-    fileSystemData: unknown;
-    plugins: ReadonlyMap<string, void | V8Serializable>;
+  clocks: WatchmanClocks;
+  fileSystemData: unknown;
+  plugins: ReadonlyMap<string, void | V8Serializable>;
 }>;
 
 export interface CacheManager {
-    end(): Promise<void>;
-    read(): Promise<null | undefined | CacheData>;
-    write(getSnapshot: () => CacheData, opts: CacheManagerWriteOptions): Promise<void>;
+  end(): Promise<void>;
+  read(): Promise<null | undefined | CacheData>;
+  write(getSnapshot: () => CacheData, opts: CacheManagerWriteOptions): Promise<void>;
 }
 
 export type CacheManagerFactory = (options: CacheManagerFactoryOptions) => CacheManager;
 
 export type CacheManagerFactoryOptions = Readonly<{
-    buildParameters: BuildParameters;
+  buildParameters: BuildParameters;
 }>;
 
 export type CacheManagerWriteOptions = Readonly<{
-    changedSinceCacheRead: boolean;
-    eventSource: CacheManagerEventSource;
-    onWriteError: (error: Error) => void;
+  changedSinceCacheRead: boolean;
+  eventSource: CacheManagerEventSource;
+  onWriteError: (error: Error) => void;
 }>;
 
 export type ChangeEvent = Readonly<{
-    logger?: null | undefined | RootPerfLogger;
-    changes: ReadonlyFileSystemChanges<Readonly<ChangedFileMetadata>>;
-    rootDir: string;
+  logger?: null | undefined | RootPerfLogger;
+  changes: ReadonlyFileSystemChanges<Readonly<ChangedFileMetadata>>;
+  rootDir: string;
 }>;
 
 export type ChangeEventMetadata = {
-    modifiedTime: null | undefined | number;
-    size: null | undefined | number;
-    type: 'f' | 'd' | 'l';
+  modifiedTime: null | undefined | number;
+  size: null | undefined | number;
+  type: 'f' | 'd' | 'l';
 };
 
 export type Crawler = (options: CrawlerOptions) => Promise<CrawlResult>;
@@ -61,219 +61,219 @@ export type Crawler = (options: CrawlerOptions) => Promise<CrawlResult>;
 export type CrawlerFactory = (options: CrawlerFactoryOptions) => Crawler;
 
 export type CrawlerFactoryOptions = Readonly<{
-    buildParameters: BuildParameters;
-    pluginDataIndices: ReadonlyMap<string, number>;
+  buildParameters: BuildParameters;
+  pluginDataIndices: ReadonlyMap<string, number>;
 }>;
 
 export type CrawlerOptions = {
-    abortSignal?: null | undefined | AbortSignal;
-    computeSha1: boolean;
-    console: Console_2;
-    extensions: ReadonlyArray<string>;
-    ignore: IgnoreMatcher;
-    includeSymlinks: boolean;
-    perfLogger?: null | undefined | PerfLogger;
-    previousState: Readonly<{
-        clocks: ReadonlyMap<CanonicalPath, WatchmanClockSpec>;
-        fileSystem: FileSystem_2;
-    }>;
-    rootDir: string;
-    roots: ReadonlyArray<string>;
-    onStatus: (status: WatcherStatus) => void;
-    subpath?: string | undefined;
+  abortSignal?: null | undefined | AbortSignal;
+  computeSha1: boolean;
+  console: Console_2;
+  extensions: ReadonlyArray<string>;
+  ignore: IgnoreMatcher;
+  includeSymlinks: boolean;
+  perfLogger?: null | undefined | PerfLogger;
+  previousState: Readonly<{
+    clocks: ReadonlyMap<CanonicalPath, WatchmanClockSpec>;
+    fileSystem: FileSystem_2;
+  }>;
+  rootDir: string;
+  roots: ReadonlyArray<string>;
+  onStatus: (status: WatcherStatus) => void;
+  subpath?: string | undefined;
 };
 
 export type CrawlResult = {changedFiles: FileData; removedFiles: Set<Path>; clocks: WatchmanClocks} | {changedFiles: FileData; removedFiles: Set<Path>};
 
 export type DependencyExtractor = {
-    extract: (content: string, absoluteFilePath: string, defaultExtractor?: DependencyExtractor['extract']) => Set<string>;
-    getCacheKey: () => string;
+  extract: (content: string, absoluteFilePath: string, defaultExtractor?: DependencyExtractor['extract']) => Set<string>;
+  getCacheKey: () => string;
 };
 
 export class DependencyPlugin extends FileDataPlugin<ReadonlyArray<string> | null> {
-    constructor(options: DependencyPluginOptions);
-    getDependencies(mixedPath: Path): null | undefined | ReadonlyArray<string>;
+  constructor(options: DependencyPluginOptions);
+  getDependencies(mixedPath: Path): null | undefined | ReadonlyArray<string>;
 }
 
 export type DependencyPluginOptions = Readonly<{
-    dependencyExtractor: null | undefined | string;
-    computeDependencies: boolean;
+  dependencyExtractor: null | undefined | string;
+  computeDependencies: boolean;
 }>;
 
 export class DiskCacheManager implements CacheManager {
-    constructor(opts: CacheManagerFactoryOptions, config: DiskCacheConfig);
-    end(): Promise<void>;
-    static getCacheFilePath(buildParameters: BuildParameters, cacheFilePrefix?: null | undefined | string, cacheDirectory?: null | undefined | string): string;
-    getCacheFilePath(): string;
-    read(): Promise<null | undefined | CacheData>;
-    write(getSnapshot: () => CacheData, opts: CacheManagerWriteOptions): Promise<void>;
+  constructor(opts: CacheManagerFactoryOptions, config: DiskCacheConfig);
+  end(): Promise<void>;
+  static getCacheFilePath(buildParameters: BuildParameters, cacheFilePrefix?: null | undefined | string, cacheDirectory?: null | undefined | string): string;
+  getCacheFilePath(): string;
+  read(): Promise<null | undefined | CacheData>;
+  write(getSnapshot: () => CacheData, opts: CacheManagerWriteOptions): Promise<void>;
 }
 
 export class DuplicateHasteCandidatesError extends Error {
-    constructor(name: string, platform: string, supportsNativePlatform: boolean, duplicatesSet: DuplicatesSet);
-    duplicatesSet: DuplicatesSet;
-    hasteName: string;
-    platform: string | null;
-    supportsNativePlatform: boolean;
+  constructor(name: string, platform: string, supportsNativePlatform: boolean, duplicatesSet: DuplicatesSet);
+  duplicatesSet: DuplicatesSet;
+  hasteName: string;
+  platform: string | null;
+  supportsNativePlatform: boolean;
 }
 
 export type FileData = Map<CanonicalPath, FileMetadata>;
 
 class FileMap extends EventEmitter {
-    constructor(options: InputOptions);
-    build(): Promise<BuildResult>;
-    static create(options: InputOptions): FileMap;
-    end(): Promise<void>;
-    static H: HType;
-    read(): Promise<null | undefined | CacheData>;
+  constructor(options: InputOptions);
+  build(): Promise<BuildResult>;
+  static create(options: InputOptions): FileMap;
+  end(): Promise<void>;
+  static H: HType;
+  read(): Promise<null | undefined | CacheData>;
 }
-export { FileMap }
+export {FileMap};
 export default FileMap;
 
 interface FileSystem_2 {
-    exists(file: Path): boolean;
-    getAllFiles(): Array<Path>;
-    getDifference(
+  exists(file: Path): boolean;
+  getAllFiles(): Array<Path>;
+  getDifference(
     files: FileData,
     options?: Readonly<{
-        subpath?: string | undefined;
+      subpath?: string | undefined;
     }>,
-    ): {changedFiles: FileData; removedFiles: Set<string>};
-    getOrComputeSha1(file: Path): Promise<null | undefined | {sha1: string; content?: Buffer | undefined}>;
-    getSerializableSnapshot(): CacheData['fileSystemData'];
-    getSha1(file: Path): null | undefined | string;
-    hierarchicalLookup(
+  ): {changedFiles: FileData; removedFiles: Set<string>};
+  getOrComputeSha1(file: Path): Promise<null | undefined | {sha1: string; content?: Buffer | undefined}>;
+  getSerializableSnapshot(): CacheData['fileSystemData'];
+  getSha1(file: Path): null | undefined | string;
+  hierarchicalLookup(
     mixedStartPath: string,
     subpath: string,
     opts: {
-        breakOnSegment?: null | undefined | string;
-        invalidatedBy?: null | undefined | Set<string>;
-        subpathType: 'f' | 'd';
+      breakOnSegment?: null | undefined | string;
+      invalidatedBy?: null | undefined | Set<string>;
+      subpathType: 'f' | 'd';
     },
-    ): null | undefined | {absolutePath: string; containerRelativePath: string};
-    linkStats(file: Path): null | undefined | FileStats;
-    lookup(mixedPath: Path): LookupResult;
-    matchFiles(opts: {
-        filter?: RegExp | null | undefined;
-        filterCompareAbsolute?: boolean | undefined;
-        filterComparePosix?: boolean | undefined;
-        follow?: boolean | undefined;
-        recursive?: boolean | undefined;
-        rootDir?: Path | null | undefined;
-    }): Iterable<Path>;
+  ): null | undefined | {absolutePath: string; containerRelativePath: string};
+  linkStats(file: Path): null | undefined | FileStats;
+  lookup(mixedPath: Path): LookupResult;
+  matchFiles(opts: {
+    filter?: RegExp | null | undefined;
+    filterCompareAbsolute?: boolean | undefined;
+    filterComparePosix?: boolean | undefined;
+    follow?: boolean | undefined;
+    recursive?: boolean | undefined;
+    rootDir?: Path | null | undefined;
+  }): Iterable<Path>;
 }
-export { FileSystem_2 as FileSystem }
+export {FileSystem_2 as FileSystem};
 
 export class HasteConflictsError extends Error {
-    constructor(conflicts: ReadonlyArray<HasteConflict>);
-    getDetailedMessage(pathsRelativeToRoot: null | undefined | string): string;
+  constructor(conflicts: ReadonlyArray<HasteConflict>);
+  getDetailedMessage(pathsRelativeToRoot: null | undefined | string): string;
 }
 
 export interface HasteMap {
-    computeConflicts(): Array<HasteConflict>;
-    getModule(name: string, platform?: null | undefined | string, supportsNativePlatform?: null | undefined | boolean, type?: null | undefined | HTypeValue): null | undefined | Path;
-    getModuleNameByPath(file: Path): null | undefined | string;
-    getPackage(name: string, platform: null | undefined | string, _supportsNativePlatform: null | undefined | boolean): null | undefined | Path;
+  computeConflicts(): Array<HasteConflict>;
+  getModule(name: string, platform?: null | undefined | string, supportsNativePlatform?: null | undefined | boolean, type?: null | undefined | HTypeValue): null | undefined | Path;
+  getModuleNameByPath(file: Path): null | undefined | string;
+  getPackage(name: string, platform: null | undefined | string, _supportsNativePlatform: null | undefined | boolean): null | undefined | Path;
 }
 
 export type HasteMapData = Map<string, HasteMapItem>;
 
 export type HasteMapItem = {
-    [platform: string]: HasteMapItemMetadata;
+  [platform: string]: HasteMapItemMetadata;
 };
 
 export class HastePlugin implements HasteMap, FileMapPlugin<null, string | null> {
-    constructor(options: HasteMapOptions);
-    assertValid(): void;
-    computeConflicts(): Array<HasteConflict>;
-    getCacheKey(): string;
-    getModule(name: string, platform?: null | undefined | string, supportsNativePlatform?: null | undefined | boolean, type?: null | undefined | HTypeValue): null | undefined | Path;
-    getModuleNameByPath(mixedPath: Path): null | undefined | string;
-    getPackage(name: string, platform: null | undefined | string, _supportsNativePlatform?: null | undefined | boolean): null | undefined | Path;
-    getSerializableSnapshot(): null;
-    getWorker(): FileMapPluginWorker;
-    initialize(opts: FileMapPluginInitOptions<null, string | null>): Promise<void>;
-    readonly name: 'haste';
-    onChanged(delta: ReadonlyFileSystemChanges<null | undefined | string>): void;
-    setModule(id: string, module: HasteMapItemMetadata): void;
+  constructor(options: HasteMapOptions);
+  assertValid(): void;
+  computeConflicts(): Array<HasteConflict>;
+  getCacheKey(): string;
+  getModule(name: string, platform?: null | undefined | string, supportsNativePlatform?: null | undefined | boolean, type?: null | undefined | HTypeValue): null | undefined | Path;
+  getModuleNameByPath(mixedPath: Path): null | undefined | string;
+  getPackage(name: string, platform: null | undefined | string, _supportsNativePlatform?: null | undefined | boolean): null | undefined | Path;
+  getSerializableSnapshot(): null;
+  getWorker(): FileMapPluginWorker;
+  initialize(opts: FileMapPluginInitOptions<null, string | null>): Promise<void>;
+  readonly name: 'haste';
+  onChanged(delta: ReadonlyFileSystemChanges<null | undefined | string>): void;
+  setModule(id: string, module: HasteMapItemMetadata): void;
 }
 
 export type HealthCheckResult =
-| {
-    type: 'error';
-    timeout: number;
-    error: Error;
-    watcher: null | undefined | string;
-}
-| {
-    type: 'success';
-    timeout: number;
-    timeElapsed: number;
-    watcher: null | undefined | string;
-}
-| {
-    type: 'timeout';
-    timeout: number;
-    watcher: null | undefined | string;
-    pauseReason: null | undefined | string;
-};
+  | {
+      type: 'error';
+      timeout: number;
+      error: Error;
+      watcher: null | undefined | string;
+    }
+  | {
+      type: 'success';
+      timeout: number;
+      timeElapsed: number;
+      watcher: null | undefined | string;
+    }
+  | {
+      type: 'timeout';
+      timeout: number;
+      watcher: null | undefined | string;
+      pauseReason: null | undefined | string;
+    };
 
 export type InputFileMapPlugin = FileMapPlugin<
-/**
-* >     | export type InputFileMapPlugin = FileMapPlugin<empty, empty>;
-*       |                                                ^^^^^ Unsupported feature: Translating "empty type" is currently not supported.
-**/
-any,
-/**
-* >     | export type InputFileMapPlugin = FileMapPlugin<empty, empty>;
-*       |                                                       ^^^^^ Unsupported feature: Translating "empty type" is currently not supported.
-**/
-any
+  /**
+   * >     | export type InputFileMapPlugin = FileMapPlugin<empty, empty>;
+   *       |                                                ^^^^^ Unsupported feature: Translating "empty type" is currently not supported.
+   **/
+  any,
+  /**
+   * >     | export type InputFileMapPlugin = FileMapPlugin<empty, empty>;
+   *       |                                                       ^^^^^ Unsupported feature: Translating "empty type" is currently not supported.
+   **/
+  any
 >;
 
 export type InputOptions = Readonly<{
-    computeSha1?: null | undefined | boolean;
-    enableSymlinks?: null | undefined | boolean;
-    extensions: ReadonlyArray<string>;
-    ignorePattern?: null | undefined | RegExp;
-    plugins?: ReadonlyArray<InputFileMapPlugin> | undefined;
-    retainAllFiles: boolean;
-    rootDir: string;
-    roots: ReadonlyArray<string>;
-    cacheManagerFactory?: null | undefined | CacheManagerFactory;
-    console?: Console_2 | undefined;
-    crawlerFactory?: null | undefined | CrawlerFactory;
-    healthCheck: HealthCheckOptions;
-    maxFilesPerWorker?: null | undefined | number;
-    maxWorkers: number;
-    perfLoggerFactory?: null | undefined | PerfLoggerFactory;
-    resetCache?: null | undefined | boolean;
-    useWatchman?: null | undefined | boolean;
-    watch?: null | undefined | boolean;
-    watchmanDeferStates?: ReadonlyArray<string> | undefined;
+  computeSha1?: null | undefined | boolean;
+  enableSymlinks?: null | undefined | boolean;
+  extensions: ReadonlyArray<string>;
+  ignorePattern?: null | undefined | RegExp;
+  plugins?: ReadonlyArray<InputFileMapPlugin> | undefined;
+  retainAllFiles: boolean;
+  rootDir: string;
+  roots: ReadonlyArray<string>;
+  cacheManagerFactory?: null | undefined | CacheManagerFactory;
+  console?: Console_2 | undefined;
+  crawlerFactory?: null | undefined | CrawlerFactory;
+  healthCheck: HealthCheckOptions;
+  maxFilesPerWorker?: null | undefined | number;
+  maxWorkers: number;
+  perfLoggerFactory?: null | undefined | PerfLoggerFactory;
+  resetCache?: null | undefined | boolean;
+  useWatchman?: null | undefined | boolean;
+  watch?: null | undefined | boolean;
+  watchmanDeferStates?: ReadonlyArray<string> | undefined;
 }>;
 
 export class NoopCacheManager implements CacheManager {
-    end(): Promise<void>;
-    read(): Promise<null | undefined | CacheData>;
-    write(): Promise<void>;
+  end(): Promise<void>;
+  read(): Promise<null | undefined | CacheData>;
+  write(): Promise<void>;
 }
 
 export type WatcherStatus =
-| {
-    type: 'watchman_slow_command';
-    timeElapsed: number;
-    command: 'watch-project' | 'query';
-}
-| {
-    type: 'watchman_slow_command_complete';
-    timeElapsed: number;
-    command: 'watch-project' | 'query';
-}
-| {
-    type: 'watchman_warning';
-    warning: unknown;
-    command: 'watch-project' | 'query';
-};
+  | {
+      type: 'watchman_slow_command';
+      timeElapsed: number;
+      command: 'watch-project' | 'query';
+    }
+  | {
+      type: 'watchman_slow_command_complete';
+      timeElapsed: number;
+      command: 'watch-project' | 'query';
+    }
+  | {
+      type: 'watchman_warning';
+      warning: unknown;
+      command: 'watch-project' | 'query';
+    };
 
 ```
diff --git a/packages/metro-resolver/API.md b/packages/metro-resolver/API.md
index e8f9b621cc..7f2a36fd85 100644
--- a/packages/metro-resolver/API.md
+++ b/packages/metro-resolver/API.md
@@ -11,38 +11,38 @@ export type CustomResolutionContext = Readonly<Omit<ResolutionContext, 'resolveR
 export type CustomResolver = (context: CustomResolutionContext, moduleName: string, platform: string | null) => Resolution;
 
 export type CustomResolverOptions = {
-    readonly [key: string]: unknown;
+  readonly [key: string]: unknown;
 };
 
 export type DoesFileExist = (filePath: string) => boolean;
 
 export class FailedToResolveNameError extends Error {
-    constructor(dirPaths: ReadonlyArray<string>, extraPaths: ReadonlyArray<string>);
-    dirPaths: ReadonlyArray<string>;
-    extraPaths: ReadonlyArray<string>;
+  constructor(dirPaths: ReadonlyArray<string>, extraPaths: ReadonlyArray<string>);
+  dirPaths: ReadonlyArray<string>;
+  extraPaths: ReadonlyArray<string>;
 }
 
 export class FailedToResolvePathError extends Error {
-    constructor(candidates: FileAndDirCandidates);
-    candidates: FileAndDirCandidates;
+  constructor(candidates: FileAndDirCandidates);
+  candidates: FileAndDirCandidates;
 }
 
 export class FailedToResolveUnsupportedError extends Error {
-    constructor(message: string, options?: {cause?: unknown | undefined});
+  constructor(message: string, options?: {cause?: unknown | undefined});
 }
 
 export type FileAndDirCandidates = {
-    readonly dir: null | undefined | FileCandidates;
-    readonly file: null | undefined | FileCandidates;
+  readonly dir: null | undefined | FileCandidates;
+  readonly file: null | undefined | FileCandidates;
 };
 
 export type FileCandidates =
-| {readonly type: 'asset'; readonly name: string}
-| {
-    readonly type: 'sourceFile';
-    filePathPrefix: string;
-    readonly candidateExts: ReadonlyArray<string>;
-};
+  | {readonly type: 'asset'; readonly name: string}
+  | {
+      readonly type: 'sourceFile';
+      filePathPrefix: string;
+      readonly candidateExts: ReadonlyArray<string>;
+    };
 
 export type FileResolution = AssetResolution | SourceFileResolution;
 
@@ -51,46 +51,46 @@ export type FileSystemLookup = (absoluteOrProjectRelativePath: string) => {exist
 export function formatFileCandidates(candidates: FileCandidates): string;
 
 export class InvalidPackageError extends Error {
-    constructor(opts: {readonly fileCandidates: FileCandidates; readonly indexCandidates: FileCandidates; readonly mainModulePath: string; readonly packageJsonPath: string});
-    fileCandidates: FileCandidates;
-    indexCandidates: FileCandidates;
-    mainModulePath: string;
-    packageJsonPath: string;
+  constructor(opts: {readonly fileCandidates: FileCandidates; readonly indexCandidates: FileCandidates; readonly mainModulePath: string; readonly packageJsonPath: string});
+  fileCandidates: FileCandidates;
+  indexCandidates: FileCandidates;
+  mainModulePath: string;
+  packageJsonPath: string;
 }
 
 export type Resolution = FileResolution | VirtualResolution | {readonly type: 'empty'};
 
 export type ResolutionContext = Readonly<{
-    allowHaste: boolean;
-    assetExts: ReadonlySet<string>;
-    customResolverOptions: CustomResolverOptions;
-    disableHierarchicalLookup: boolean;
-    doesFileExist: DoesFileExist;
-    extraNodeModules: null | undefined | {[packageName: string]: string};
-    dev: boolean;
-    getPackage: (packageJsonPath: string) => null | undefined | PackageJson;
-    getPackageForModule: (absoluteModulePath: string) => null | undefined | PackageForModule;
-    dependency?: TransformResultDependency | undefined;
-    isESMImport?: boolean | undefined;
-    fileSystemLookup: FileSystemLookup;
-    mainFields: ReadonlyArray<string>;
-    originModulePath: string;
-    nodeModulesPaths: ReadonlyArray<string>;
-    preferNativePlatform: boolean;
-    resolveAsset: ResolveAsset;
-    redirectModulePath: (modulePath: string) => string | false;
-    resolveHasteModule: (name: string) => null | undefined | string;
-    resolveHastePackage: (name: string) => null | undefined | string;
-    resolveRequest?: null | undefined | CustomResolver;
-    schemeResolvers?: Readonly<{[scheme: string]: CustomResolver}> | undefined;
-    sourceExts: ReadonlyArray<string>;
-    unstable_conditionNames: ReadonlyArray<string>;
-    unstable_conditionsByPlatform: Readonly<{
-        [platform: string]: ReadonlyArray<string>;
-    }>;
-    unstable_enablePackageExports: boolean;
-    unstable_incrementalResolution: boolean;
-    unstable_logWarning: (message: string) => void;
+  allowHaste: boolean;
+  assetExts: ReadonlySet<string>;
+  customResolverOptions: CustomResolverOptions;
+  disableHierarchicalLookup: boolean;
+  doesFileExist: DoesFileExist;
+  extraNodeModules: null | undefined | {[packageName: string]: string};
+  dev: boolean;
+  getPackage: (packageJsonPath: string) => null | undefined | PackageJson;
+  getPackageForModule: (absoluteModulePath: string) => null | undefined | PackageForModule;
+  dependency?: TransformResultDependency | undefined;
+  isESMImport?: boolean | undefined;
+  fileSystemLookup: FileSystemLookup;
+  mainFields: ReadonlyArray<string>;
+  originModulePath: string;
+  nodeModulesPaths: ReadonlyArray<string>;
+  preferNativePlatform: boolean;
+  resolveAsset: ResolveAsset;
+  redirectModulePath: (modulePath: string) => string | false;
+  resolveHasteModule: (name: string) => null | undefined | string;
+  resolveHastePackage: (name: string) => null | undefined | string;
+  resolveRequest?: null | undefined | CustomResolver;
+  schemeResolvers?: Readonly<{[scheme: string]: CustomResolver}> | undefined;
+  sourceExts: ReadonlyArray<string>;
+  unstable_conditionNames: ReadonlyArray<string>;
+  unstable_conditionsByPlatform: Readonly<{
+    [platform: string]: ReadonlyArray<string>;
+  }>;
+  unstable_enablePackageExports: boolean;
+  unstable_incrementalResolution: boolean;
+  unstable_logWarning: (message: string) => void;
 }>;
 
 export function resolve(context: ResolutionContext, specifier: string, platform: string | null): Resolution;
diff --git a/packages/metro-source-map/API.md b/packages/metro-source-map/API.md
index 4a937c51f8..b9eba61720 100644
--- a/packages/metro-source-map/API.md
+++ b/packages/metro-source-map/API.md
@@ -4,42 +4,42 @@
 
 ```ts
 
-import type { Node as Node_2 } from '@babel/types';
-import type { PluginObj } from '@babel/core';
+import type {Node as Node_2} from '@babel/types';
+import type {PluginObj} from '@babel/core';
 
 export type BabelDecodedMap = {
-    readonly mappings: ReadonlyArray<ReadonlyArray<BabelDecodedMapSegment>>;
-    readonly names: ReadonlyArray<string>;
+  readonly mappings: ReadonlyArray<ReadonlyArray<BabelDecodedMapSegment>>;
+  readonly names: ReadonlyArray<string>;
 };
 
 export type BabelSourceMapSegment = Readonly<{
-    generated: Readonly<{column: number; line: number}>;
-    original?: Readonly<{column: number; line: number}> | undefined;
-    source?: null | undefined | string;
-    name?: null | undefined | string;
+  generated: Readonly<{column: number; line: number}>;
+  original?: Readonly<{column: number; line: number}> | undefined;
+  source?: null | undefined | string;
+  name?: null | undefined | string;
 }>;
 
 export type BasicSourceMap = {
-    readonly file?: string | undefined;
-    readonly mappings: string;
-    readonly names: Array<string>;
-    readonly sourceRoot?: string | undefined;
-    readonly sources: Array<string>;
-    readonly sourcesContent?: Array<null | undefined | string> | undefined;
-    readonly version: number;
-    readonly x_facebook_offsets?: Array<number> | undefined;
-    readonly x_metro_module_paths?: Array<string> | undefined;
-    readonly x_facebook_sources?: FBSourcesArray | undefined;
-    readonly x_facebook_segments?: FBSegmentMap | undefined;
-    readonly x_hermes_function_offsets?: HermesFunctionOffsets | undefined;
-    readonly x_google_ignoreList?: Array<number> | undefined;
+  readonly file?: string | undefined;
+  readonly mappings: string;
+  readonly names: Array<string>;
+  readonly sourceRoot?: string | undefined;
+  readonly sources: Array<string>;
+  readonly sourcesContent?: Array<null | undefined | string> | undefined;
+  readonly version: number;
+  readonly x_facebook_offsets?: Array<number> | undefined;
+  readonly x_metro_module_paths?: Array<string> | undefined;
+  readonly x_facebook_sources?: FBSourcesArray | undefined;
+  readonly x_facebook_segments?: FBSegmentMap | undefined;
+  readonly x_hermes_function_offsets?: HermesFunctionOffsets | undefined;
+  readonly x_google_ignoreList?: Array<number> | undefined;
 };
 
 export class BundleBuilder {
-    constructor(file: string);
-    append(code: string, map: null | undefined | MixedSourceMap): this;
-    getCode(): string;
-    getMap(): MixedSourceMap;
+  constructor(file: string);
+  append(code: string, map: null | undefined | MixedSourceMap): this;
+  getCode(): string;
+  getMap(): MixedSourceMap;
 }
 
 export function composeSourceMaps(maps: ReadonlyArray<MixedSourceMap>): MixedSourceMap;
@@ -53,8 +53,8 @@ export function createIndexMap(file: null | undefined | string, sections: Array<
 export type FBSegmentMap = {[id: string]: MixedSourceMap};
 
 export type FBSourceFunctionMap = {
-    readonly names: ReadonlyArray<string>;
-    readonly mappings: string;
+  readonly names: ReadonlyArray<string>;
+  readonly mappings: string;
 };
 
 export type FBSourceMetadata = [null | undefined | FBSourceFunctionMap];
@@ -72,34 +72,34 @@ export function functionMapBabelPlugin(): PluginObj;
 export function generateFunctionMap(ast: Node_2, context?: Context): FBSourceFunctionMap;
 
 export type HermesFunctionOffsets = {
-    [functionId: number]: ReadonlyArray<number>;
+  [functionId: number]: ReadonlyArray<number>;
 };
 
 export interface IConsumer {
-    eachMapping(callback: (mapping: Mapping) => unknown, context?: unknown, order?: IterationOrder): void;
-    get file(): null | undefined | string;
-    generatedMappings(): Iterable<Mapping>;
-    originalPositionFor(generatedPosition: GeneratedPositionLookup): SourcePosition;
-    sourceContentFor(source: string, nullOnMissing: true): null | undefined | string;
+  eachMapping(callback: (mapping: Mapping) => unknown, context?: unknown, order?: IterationOrder): void;
+  get file(): null | undefined | string;
+  generatedMappings(): Iterable<Mapping>;
+  originalPositionFor(generatedPosition: GeneratedPositionLookup): SourcePosition;
+  sourceContentFor(source: string, nullOnMissing: true): null | undefined | string;
 }
 
 export type IndexMap = {
-    readonly file?: string | undefined;
-    readonly mappings?: void | undefined;
-    readonly sourcesContent?: void | undefined;
-    readonly sections: Array<IndexMapSection>;
-    readonly version: number;
-    readonly x_facebook_offsets?: Array<number> | undefined;
-    readonly x_metro_module_paths?: Array<string> | undefined;
-    readonly x_facebook_sources?: void | undefined;
-    readonly x_facebook_segments?: FBSegmentMap | undefined;
-    readonly x_hermes_function_offsets?: HermesFunctionOffsets | undefined;
-    readonly x_google_ignoreList?: void | undefined;
+  readonly file?: string | undefined;
+  readonly mappings?: void | undefined;
+  readonly sourcesContent?: void | undefined;
+  readonly sections: Array<IndexMapSection>;
+  readonly version: number;
+  readonly x_facebook_offsets?: Array<number> | undefined;
+  readonly x_metro_module_paths?: Array<string> | undefined;
+  readonly x_facebook_sources?: void | undefined;
+  readonly x_facebook_segments?: FBSegmentMap | undefined;
+  readonly x_hermes_function_offsets?: HermesFunctionOffsets | undefined;
+  readonly x_google_ignoreList?: void | undefined;
 };
 
 export type IndexMapSection = {
-    map: IndexMap | BasicSourceMap;
-    offset: {line: number; column: number};
+  map: IndexMap | BasicSourceMap;
+  offset: {line: number; column: number};
 };
 
 export function isVlqMap(map: (null | undefined | ReadonlyArray<MetroSourceMapSegmentTuple>) | VlqMap): map is VlqMap;
@@ -111,18 +111,18 @@ export type MixedSourceMap = IndexMap | BasicSourceMap;
 export function normalizeSourcePath(sourceInput: string, map: {readonly sourceRoot?: null | undefined | string}): string;
 
 export type RawMappingsModule = {
-    readonly map: (null | undefined | ReadonlyArray<MetroSourceMapSegmentTuple>) | VlqMap;
-    readonly functionMap: null | undefined | FBSourceFunctionMap;
-    readonly path: string;
-    readonly source: string;
-    readonly code: string;
-    readonly isIgnored: boolean;
-    readonly lineCount?: number | undefined;
+  readonly map: (null | undefined | ReadonlyArray<MetroSourceMapSegmentTuple>) | VlqMap;
+  readonly functionMap: null | undefined | FBSourceFunctionMap;
+  readonly path: string;
+  readonly source: string;
+  readonly code: string;
+  readonly isIgnored: boolean;
+  readonly lineCount?: number | undefined;
 };
 
 export interface SourceMapGenerator {
-    toMap(file?: string, options?: {excludeSource?: boolean | undefined}): MixedSourceMap;
-    toString(file?: string, options?: {excludeSource?: boolean | undefined}): string;
+  toMap(file?: string, options?: {excludeSource?: boolean | undefined}): MixedSourceMap;
+  toString(file?: string, options?: {excludeSource?: boolean | undefined}): string;
 }
 
 export function toBabelSegments(sourceMap: BasicSourceMap): Array<BabelSourceMapSegment>;
@@ -132,8 +132,8 @@ export function toSegmentTuple(mapping: BabelSourceMapSegment): MetroSourceMapSe
 export function tuplesFromBabelDecodedMap(decodedMap: BabelDecodedMap): Array<MetroSourceMapSegmentTuple>;
 
 export type VlqMap = {
-    readonly mappings: string;
-    readonly names: ReadonlyArray<string>;
+  readonly mappings: string;
+  readonly names: ReadonlyArray<string>;
 };
 
 export function vlqMapFromBabelDecodedMap(decodedMap: BabelDecodedMap, terminatingMapping: [number, number]): VlqMap;
diff --git a/packages/metro-transform-worker/API.md b/packages/metro-transform-worker/API.md
index df45164685..ff078cbedf 100644
--- a/packages/metro-transform-worker/API.md
+++ b/packages/metro-transform-worker/API.md
@@ -5,7 +5,7 @@
 ```ts
 
 export type CustomTransformOptions = {
-    [key: string]: unknown;
+  [key: string]: unknown;
 };
 
 export const getCacheKey: (config: JsTransformerConfig, opts?: Readonly<{projectRoot: string}>) => string;
@@ -13,63 +13,63 @@ export const getCacheKey: (config: JsTransformerConfig, opts?: Readonly<{project
 export type getCacheKey = typeof getCacheKey;
 
 export type JsOutput = Readonly<{
-    data: Readonly<{
-        code: string;
-        lineCount: number;
-        map: VlqMap;
-        functionMap: null | undefined | FBSourceFunctionMap;
-    }>;
-    type: JSFileType;
+  data: Readonly<{
+    code: string;
+    lineCount: number;
+    map: VlqMap;
+    functionMap: null | undefined | FBSourceFunctionMap;
+  }>;
+  type: JSFileType;
 }>;
 
 export type JsTransformerConfig = Readonly<{
-    assetPlugins: ReadonlyArray<string>;
-    assetRegistryPath: string;
-    asyncRequireModulePath: string;
-    babelTransformerPath: string;
-    dynamicDepsInPackages: DynamicRequiresBehavior;
-    enableBabelRCLookup: boolean;
-    enableBabelRuntime: boolean | string;
-    globalPrefix: string;
-    hermesParser: boolean;
-    minifierConfig: MinifierConfig;
-    minifierPath: string;
-    optimizationSizeLimit: number;
-    publicPath: string;
-    allowOptionalDependencies: AllowOptionalDependencies;
-    unstable_dependencyMapReservedName: null | undefined | string;
-    unstable_disableModuleWrapping: boolean;
-    unstable_disableNormalizePseudoGlobals: boolean;
-    unstable_compactOutput: boolean;
-    unstable_allowRequireContext: boolean;
-    unstable_memoizeInlineRequires?: boolean | undefined;
-    unstable_nonMemoizedInlineRequires?: ReadonlyArray<string> | undefined;
+  assetPlugins: ReadonlyArray<string>;
+  assetRegistryPath: string;
+  asyncRequireModulePath: string;
+  babelTransformerPath: string;
+  dynamicDepsInPackages: DynamicRequiresBehavior;
+  enableBabelRCLookup: boolean;
+  enableBabelRuntime: boolean | string;
+  globalPrefix: string;
+  hermesParser: boolean;
+  minifierConfig: MinifierConfig;
+  minifierPath: string;
+  optimizationSizeLimit: number;
+  publicPath: string;
+  allowOptionalDependencies: AllowOptionalDependencies;
+  unstable_dependencyMapReservedName: null | undefined | string;
+  unstable_disableModuleWrapping: boolean;
+  unstable_disableNormalizePseudoGlobals: boolean;
+  unstable_compactOutput: boolean;
+  unstable_allowRequireContext: boolean;
+  unstable_memoizeInlineRequires?: boolean | undefined;
+  unstable_nonMemoizedInlineRequires?: ReadonlyArray<string> | undefined;
 }>;
 
 export type JsTransformOptions = Readonly<{
-    customTransformOptions?: CustomTransformOptions | undefined;
-    dev: boolean;
-    experimentalImportSupport?: boolean | undefined;
-    inlinePlatform: boolean;
-    inlineRequires: boolean;
-    minify: boolean;
-    nonInlinedRequires?: ReadonlyArray<string> | undefined;
-    platform: null | undefined | string;
-    type: Type;
-    unstable_memoizeInlineRequires?: boolean | undefined;
-    unstable_nonMemoizedInlineRequires?: ReadonlyArray<string> | undefined;
-    unstable_staticHermesOptimizedRequire?: boolean | undefined;
-    unstable_transformProfile: TransformProfile;
+  customTransformOptions?: CustomTransformOptions | undefined;
+  dev: boolean;
+  experimentalImportSupport?: boolean | undefined;
+  inlinePlatform: boolean;
+  inlineRequires: boolean;
+  minify: boolean;
+  nonInlinedRequires?: ReadonlyArray<string> | undefined;
+  platform: null | undefined | string;
+  type: Type;
+  unstable_memoizeInlineRequires?: boolean | undefined;
+  unstable_nonMemoizedInlineRequires?: ReadonlyArray<string> | undefined;
+  unstable_staticHermesOptimizedRequire?: boolean | undefined;
+  unstable_transformProfile: TransformProfile;
 }>;
 
 export type Minifier = (opts: MinifierOptions) => MinifierResult | Promise<MinifierResult>;
 
 export type MinifierOptions = {
-    code: string;
-    map: null | undefined | BasicSourceMap;
-    filename: string;
-    reserved: ReadonlyArray<string>;
-    config: MinifierConfig;
+  code: string;
+  map: null | undefined | BasicSourceMap;
+  filename: string;
+  reserved: ReadonlyArray<string>;
+  config: MinifierConfig;
 };
 
 export type MinifierResult = {code: string; map?: BasicSourceMap | undefined};
diff --git a/packages/metro/API.md b/packages/metro/API.md
index ac706fcfd6..42ed74e233 100644
--- a/packages/metro/API.md
+++ b/packages/metro/API.md
@@ -6,19 +6,19 @@
 
 import type $$IMPORT_TYPEOF_1$$ from 'yargs';
 import EventEmitter from 'node:events';
-import type { HandleFunction } from 'connect';
-import type { IncomingMessage } from 'connect';
-import type { Server } from 'connect';
-import type { Server as Server_2 } from 'node:http';
-import type { Server as Server_3 } from 'node:https';
-import type { Server as Server_4 } from 'ws';
-import type { ServerOptions as ServerOptions_2 } from 'node:https';
-import type { ServerResponse } from 'node:http';
-import type { Socket } from 'node:net';
-import type { Writable } from 'node:stream';
+import type {HandleFunction} from 'connect';
+import type {IncomingMessage} from 'connect';
+import type {Server} from 'connect';
+import type {Server as Server_2} from 'node:http';
+import type {Server as Server_3} from 'node:https';
+import type {Server as Server_4} from 'ws';
+import type {ServerOptions as ServerOptions_2} from 'node:https';
+import type {ServerResponse} from 'node:http';
+import type {Socket} from 'node:net';
+import type {Writable} from 'node:stream';
 
 export type AssetData = AssetDataWithoutFiles & {
-    readonly files: Array<string>;
+  readonly files: Array<string>;
 };
 
 export type AsyncDependencyType = 'async' | 'maybeSync' | 'prefetch' | 'weak';
@@ -32,13 +32,13 @@ export const buildGraph: (config: InputConfigT, opts: BuildGraphOptions) => Prom
 export type buildGraph = typeof buildGraph;
 
 export type BundleDetails = {
-    bundleType: string;
-    customResolverOptions: CustomResolverOptions;
-    customTransformOptions: CustomTransformOptions;
-    dev: boolean;
-    entryFile: string;
-    minify: boolean;
-    platform: null | undefined | string;
+  bundleType: string;
+  customResolverOptions: CustomResolverOptions;
+  customTransformOptions: CustomTransformOptions;
+  dev: boolean;
+  entryFile: string;
+  minify: boolean;
+  platform: null | undefined | string;
 };
 
 export type ContextMode = 'sync' | 'eager' | 'lazy' | 'lazy-once';
@@ -48,169 +48,169 @@ export const createConnectMiddleware: (config: ConfigT, options?: RunMetroOption
 export type createConnectMiddleware = typeof createConnectMiddleware;
 
 export type DeltaResult<T = MixedOutput> = {
-    readonly added: Map<string, Module<T>>;
-    readonly modified: Map<string, Module<T>>;
-    readonly deleted: Set<string>;
-    readonly reset: boolean;
+  readonly added: Map<string, Module<T>>;
+  readonly modified: Map<string, Module<T>>;
+  readonly deleted: Set<string>;
+  readonly reset: boolean;
 };
 
 export type Dependency = ResolvedDependency | Readonly<{data: TransformResultDependency}>;
 
 export class DependencyGraph extends EventEmitter {
-    constructor(
+  constructor(
     config: ConfigT,
     options?: {
-        readonly hasReducedPerformance?: boolean | undefined;
-        readonly watch?: boolean | undefined;
+      readonly hasReducedPerformance?: boolean | undefined;
+      readonly watch?: boolean | undefined;
     },
-    );
-    doesFileExist: (filePath: string) => boolean;
-    end(): Promise<void>;
-    getAllFiles(): Array<string>;
-    getDependencies(filePath: string): Array<string>;
-    getHasteName(filePath: string): string;
-    getOrComputeSha1(mixedPath: string): Promise<{content?: Buffer | undefined; sha1: string}>;
-    getWatcher(): EventEmitter;
-    matchFilesWithContext(from: string, context: Readonly<{recursive: boolean; filter: RegExp}>): Iterable<string>;
-    ready(): Promise<void>;
-    resolveDependency(
+  );
+  doesFileExist: (filePath: string) => boolean;
+  end(): Promise<void>;
+  getAllFiles(): Array<string>;
+  getDependencies(filePath: string): Array<string>;
+  getHasteName(filePath: string): string;
+  getOrComputeSha1(mixedPath: string): Promise<{content?: Buffer | undefined; sha1: string}>;
+  getWatcher(): EventEmitter;
+  matchFilesWithContext(from: string, context: Readonly<{recursive: boolean; filter: RegExp}>): Iterable<string>;
+  ready(): Promise<void>;
+  resolveDependency(
     originModulePath: string,
     dependency: TransformResultDependency,
     platform: string | null,
     resolverOptions: ResolverInputOptions,
     extraOptions?: {assumeFlatNodeModules: boolean},
-    ): BundlerResolution;
+  ): BundlerResolution;
 }
 
 export function getSchemeResolvers(): Readonly<{
-    [scheme: string]: CustomResolver;
+  [scheme: string]: CustomResolver;
 }>;
 
 export class JsonReporter<TEvent extends {readonly [prop: string]: unknown}> {
-    constructor(stream: Writable);
-    update(event: TEvent): void;
+  constructor(stream: Writable);
+  update(event: TEvent): void;
 }
 
 export function loadConfig(argvInput?: YargArguments, defaultConfigOverrides?: InputConfigT): Promise<ConfigT>;
 
 export function mergeConfig<T extends InputConfigT, R extends ReadonlyArray<InputConfigT | ((baseConfig: T) => InputConfigT) | ((baseConfig: T) => Promise<InputConfigT>)>>(
-base: T | (() => T),
-...configs: R
+  base: T | (() => T),
+  ...configs: R
 ): R extends ReadonlyArray<InputConfigT | ((baseConfig: T) => InputConfigT)> ? T : Promise<T>;
 
 export type MetroConfig = InputConfigT;
 
 export class MetroServer {
-    constructor(config: ConfigT, options?: ServerOptions);
-    build(
+  constructor(config: ConfigT, options?: ServerOptions);
+  build(
     bundleOptions: BundleOptions,
     buildOptions?: BuildOptions,
-    ): Promise<{
-        code: string;
-        map: string;
-        assets?: ReadonlyArray<AssetData> | undefined;
-    }>;
-    static DEFAULT_BUNDLE_OPTIONS: Omit<
+  ): Promise<{
+    code: string;
+    map: string;
+    assets?: ReadonlyArray<AssetData> | undefined;
+  }>;
+  static DEFAULT_BUNDLE_OPTIONS: Omit<
     typeof MetroServer.DEFAULT_GRAPH_OPTIONS,
     'excludeSource' | 'inlineSourceMap' | 'lazy' | 'modulesOnly' | 'onProgress' | 'runModule' | 'shallow' | 'sourceMapUrl' | 'sourceUrl' | 'sourcePaths'
-    > & {
-        excludeSource: false;
-        inlineSourceMap: false;
-        lazy: false;
-        modulesOnly: false;
-        onProgress: null;
-        runModule: true;
-        shallow: false;
-        sourceMapUrl: null;
-        sourceUrl: null;
-        sourcePaths: SourcePathsMode;
-    };
-    static DEFAULT_GRAPH_OPTIONS: Readonly<{
-        customResolverOptions: CustomResolverOptions;
-        customTransformOptions: CustomTransformOptions;
-        dev: boolean;
-        minify: boolean;
-        unstable_transformProfile: 'default';
-    }>;
-    end(): Promise<void>;
-    getAssets(options: BundleOptions): Promise<ReadonlyArray<AssetData>>;
-    getBundler(): IncrementalBundler;
-    getCreateModuleId(): (path: string) => number;
-    getNewBuildNumber(): number;
-    getOrderedDependencyPaths(options: {readonly dev: boolean; readonly entryFile: string; readonly minify: boolean; readonly platform: null | undefined | string}): Promise<Array<string>>;
-    getPlatforms(): ReadonlyArray<string>;
-    getRamBundleInfo(options: BundleOptions): Promise<RamBundleInfo>;
-    getWatchFolders(): ReadonlyArray<string>;
-    processRequest: (req: IncomingMessage, res: ServerResponse, next: (e: null | undefined | Error) => void) => void;
-    ready(): Promise<void>;
+  > & {
+    excludeSource: false;
+    inlineSourceMap: false;
+    lazy: false;
+    modulesOnly: false;
+    onProgress: null;
+    runModule: true;
+    shallow: false;
+    sourceMapUrl: null;
+    sourceUrl: null;
+    sourcePaths: SourcePathsMode;
+  };
+  static DEFAULT_GRAPH_OPTIONS: Readonly<{
+    customResolverOptions: CustomResolverOptions;
+    customTransformOptions: CustomTransformOptions;
+    dev: boolean;
+    minify: boolean;
+    unstable_transformProfile: 'default';
+  }>;
+  end(): Promise<void>;
+  getAssets(options: BundleOptions): Promise<ReadonlyArray<AssetData>>;
+  getBundler(): IncrementalBundler;
+  getCreateModuleId(): (path: string) => number;
+  getNewBuildNumber(): number;
+  getOrderedDependencyPaths(options: {readonly dev: boolean; readonly entryFile: string; readonly minify: boolean; readonly platform: null | undefined | string}): Promise<Array<string>>;
+  getPlatforms(): ReadonlyArray<string>;
+  getRamBundleInfo(options: BundleOptions): Promise<RamBundleInfo>;
+  getWatchFolders(): ReadonlyArray<string>;
+  processRequest: (req: IncomingMessage, res: ServerResponse, next: (e: null | undefined | Error) => void) => void;
+  ready(): Promise<void>;
 }
 
 export type MixedOutput = {readonly data: unknown; readonly type: string};
 
 export type Module<T = MixedOutput> = Readonly<{
-    dependencies: Map<string, Dependency>;
-    inverseDependencies: CountingSet<string>;
-    output: ReadonlyArray<T>;
-    path: string;
-    getSource: () => Buffer;
-    unstable_transformResultKey?: null | undefined | string;
+  dependencies: Map<string, Dependency>;
+  inverseDependencies: CountingSet<string>;
+  output: ReadonlyArray<T>;
+  path: string;
+  getSource: () => Buffer;
+  unstable_transformResultKey?: null | undefined | string;
 }>;
 
 export type ReadOnlyDependencies<T = MixedOutput> = ReadonlyMap<string, Module<T>>;
 
 export interface ReadOnlyGraph<T = MixedOutput> {
-    readonly dependencies: ReadOnlyDependencies<T>;
-    readonly entryPoints: ReadonlySet<string>;
-    readonly transformOptions: Readonly<TransformInputOptions>;
+  readonly dependencies: ReadOnlyDependencies<T>;
+  readonly entryPoints: ReadonlySet<string>;
+  readonly transformOptions: Readonly<TransformInputOptions>;
 }
 
 export type ReportableEvent =
-| {port: number; hasReducedPerformance: boolean; type: 'initialize_started'}
-| {type: 'initialize_failed'; port: number; error: Error}
-| {type: 'initialize_done'; port: number}
-| {buildID: string; type: 'bundle_build_done'}
-| {buildID: string; type: 'bundle_build_failed'}
-| {type: 'bundle_save_log'; message: string}
-| {
-    buildID: string;
-    bundleDetails: BundleDetails;
-    isPrefetch?: boolean | undefined;
-    type: 'bundle_build_started';
-}
-| {error: Error; type: 'bundling_error'}
-| {type: 'dep_graph_loading'; hasReducedPerformance: boolean}
-| {type: 'dep_graph_loaded'}
-| {
-    buildID: string;
-    type: 'bundle_transform_progressed';
-    transformedFileCount: number;
-    totalFileCount: number;
-}
-| {type: 'cache_read_error'; error: Error}
-| {type: 'cache_write_error'; error: Error}
-| {type: 'transform_cache_reset'}
-| {type: 'worker_stdout_chunk'; chunk: string}
-| {type: 'worker_stderr_chunk'; chunk: string}
-| {type: 'hmr_client_error'; error: Error}
-| {
-    type: 'client_log';
-    level: 'trace' | 'info' | 'warn' | 'log' | 'group' | 'groupCollapsed' | 'groupEnd' | 'debug';
-    data: Array<unknown>;
-}
-| {type: 'resolver_warning'; message: string}
-| {type: 'server_listening'; port: number; address: string; family: string}
-| {type: 'transformer_load_started'}
-| {type: 'transformer_load_done'}
-| {type: 'transformer_load_failed'; error: Error}
-| {type: 'watcher_health_check_result'; result: HealthCheckResult}
-| {type: 'watcher_status'; status: WatcherStatus};
+  | {port: number; hasReducedPerformance: boolean; type: 'initialize_started'}
+  | {type: 'initialize_failed'; port: number; error: Error}
+  | {type: 'initialize_done'; port: number}
+  | {buildID: string; type: 'bundle_build_done'}
+  | {buildID: string; type: 'bundle_build_failed'}
+  | {type: 'bundle_save_log'; message: string}
+  | {
+      buildID: string;
+      bundleDetails: BundleDetails;
+      isPrefetch?: boolean | undefined;
+      type: 'bundle_build_started';
+    }
+  | {error: Error; type: 'bundling_error'}
+  | {type: 'dep_graph_loading'; hasReducedPerformance: boolean}
+  | {type: 'dep_graph_loaded'}
+  | {
+      buildID: string;
+      type: 'bundle_transform_progressed';
+      transformedFileCount: number;
+      totalFileCount: number;
+    }
+  | {type: 'cache_read_error'; error: Error}
+  | {type: 'cache_write_error'; error: Error}
+  | {type: 'transform_cache_reset'}
+  | {type: 'worker_stdout_chunk'; chunk: string}
+  | {type: 'worker_stderr_chunk'; chunk: string}
+  | {type: 'hmr_client_error'; error: Error}
+  | {
+      type: 'client_log';
+      level: 'trace' | 'info' | 'warn' | 'log' | 'group' | 'groupCollapsed' | 'groupEnd' | 'debug';
+      data: Array<unknown>;
+    }
+  | {type: 'resolver_warning'; message: string}
+  | {type: 'server_listening'; port: number; address: string; family: string}
+  | {type: 'transformer_load_started'}
+  | {type: 'transformer_load_done'}
+  | {type: 'transformer_load_failed'; error: Error}
+  | {type: 'watcher_health_check_result'; result: HealthCheckResult}
+  | {type: 'watcher_status'; status: WatcherStatus};
 
 export type Reporter = {update(event: ReportableEvent): void};
 
 export type RequireContextParams = Readonly<{
-    recursive: boolean;
-    filter: Readonly<ContextFilter>;
-    mode: ContextMode;
+  recursive: boolean;
+  filter: Readonly<ContextFilter>;
+  mode: ContextMode;
 }>;
 
 export function resolveConfig(filePath?: string, cwd?: string): Promise<ResolveConfigResult>;
@@ -220,48 +220,48 @@ export const runBuild: (config: ConfigT, opts: RunBuildOptions) => Promise<RunBu
 export type runBuild = typeof runBuild;
 
 export type RunBuildOptions = {
-    entry: string;
-    assets?: boolean | undefined;
-    dev?: boolean | undefined;
-    out?: string | undefined;
-    bundleOut?: string | undefined;
-    sourceMapOut?: string | undefined;
-    onBegin?: (() => void) | undefined;
-    onComplete?: (() => void) | undefined;
-    onProgress?: ((transformedFileCount: number, totalFileCount: number) => void) | undefined;
-    minify?: boolean | undefined;
-    output?:
+  entry: string;
+  assets?: boolean | undefined;
+  dev?: boolean | undefined;
+  out?: string | undefined;
+  bundleOut?: string | undefined;
+  sourceMapOut?: string | undefined;
+  onBegin?: (() => void) | undefined;
+  onComplete?: (() => void) | undefined;
+  onProgress?: ((transformedFileCount: number, totalFileCount: number) => void) | undefined;
+  minify?: boolean | undefined;
+  output?:
     | Readonly<{
         build: (
-        server: MetroServer,
-        requestOptions: RequestOptions,
-        buildOptions?: BuildOptions,
+          server: MetroServer,
+          requestOptions: RequestOptions,
+          buildOptions?: BuildOptions,
         ) => Promise<{
-            code: string;
-            map: string;
-            assets?: ReadonlyArray<AssetData> | undefined;
+          code: string;
+          map: string;
+          assets?: ReadonlyArray<AssetData> | undefined;
         }>;
         save: (output: {code: string; map: string}, opts: OutputOptions, logger: (logMessage: string) => void) => Promise<unknown>;
-    }>
+      }>
     | undefined;
-    platform?: string | undefined;
-    sourceMap?: boolean | undefined;
-    sourceMapUrl?: string | undefined;
-    customResolverOptions?: CustomResolverOptions | undefined;
-    customTransformOptions?: CustomTransformOptions | undefined;
-    unstable_transformProfile?: TransformProfile | undefined;
+  platform?: string | undefined;
+  sourceMap?: boolean | undefined;
+  sourceMapUrl?: string | undefined;
+  customResolverOptions?: CustomResolverOptions | undefined;
+  customTransformOptions?: CustomTransformOptions | undefined;
+  unstable_transformProfile?: TransformProfile | undefined;
 };
 
 export type RunBuildResult = {
-    code: string;
-    map: string;
-    assets?: ReadonlyArray<AssetData> | undefined;
+  code: string;
+  map: string;
+  assets?: ReadonlyArray<AssetData> | undefined;
 };
 
 export function runMetro(config: InputConfigT, options?: RunMetroOptions): Promise<MetroServer>;
 
 export type RunMetroOptions = Omit<ServerOptions, 'waitForBundler'> & {
-    waitForBundler?: boolean | undefined;
+  waitForBundler?: boolean | undefined;
 };
 
 export const runServer: (config: ConfigT, opts?: RunServerOptions) => Promise<RunServerResult>;
@@ -269,101 +269,101 @@ export const runServer: (config: ConfigT, opts?: RunServerOptions) => Promise<Ru
 export type runServer = typeof runServer;
 
 export type RunServerOptions = Readonly<{
-    hasReducedPerformance?: boolean | undefined;
-    host?: string | undefined;
-    onError?: ((err: Error & {code?: string | undefined}) => void) | undefined;
-    onReady?: ((server: Server_2 | Server_3) => void) | undefined;
-    onClose?: (() => void) | undefined;
-    secureServerOptions?: ServerOptions_2 | undefined;
-    secure?: boolean | undefined;
-    secureCert?: string | undefined;
-    secureKey?: string | undefined;
-    unstable_extraMiddleware?: ReadonlyArray<HandleFunction> | undefined;
-    waitForBundler?: boolean | undefined;
-    watch?: boolean | undefined;
-    websocketEndpoints?: Readonly<{[path: string]: Server_4}> | undefined;
+  hasReducedPerformance?: boolean | undefined;
+  host?: string | undefined;
+  onError?: ((err: Error & {code?: string | undefined}) => void) | undefined;
+  onReady?: ((server: Server_2 | Server_3) => void) | undefined;
+  onClose?: (() => void) | undefined;
+  secureServerOptions?: ServerOptions_2 | undefined;
+  secure?: boolean | undefined;
+  secureCert?: string | undefined;
+  secureKey?: string | undefined;
+  unstable_extraMiddleware?: ReadonlyArray<HandleFunction> | undefined;
+  waitForBundler?: boolean | undefined;
+  watch?: boolean | undefined;
+  websocketEndpoints?: Readonly<{[path: string]: Server_4}> | undefined;
 }>;
 
 export type RunServerResult = {httpServer: Server_2 | Server_3};
 
 export type SerializerOptions = Readonly<{
-    asyncRequireModulePath: string;
-    createModuleId: (absolutePath: string) => number;
-    dependencyMapReservedName?: null | undefined | string;
-    dev: boolean;
-    getRunModuleStatement: (moduleId: number | string, globalPrefix: string) => string;
-    globalPrefix: string;
-    includeAsyncPaths: boolean;
-    inlineSourceMap?: null | undefined | boolean;
-    modulesOnly: boolean;
-    processModuleFilter: (module: Module) => boolean;
-    projectRoot: string;
-    runBeforeMainModule: ReadonlyArray<string>;
-    runModule: boolean;
-    serverRoot: string;
-    shouldAddToIgnoreList: (module: Module) => boolean;
-    sourceMapUrl?: null | undefined | string;
-    sourceUrl?: null | undefined | string;
-    getSourceUrl?: null | undefined | ((module: Module) => string);
-    unstable_inlineDependencyMap?: boolean | undefined;
-    unstable_getAsyncDependencyPath?: ((dependency: ResolvedDependency, options: unknown) => null | undefined | ReadonlyJsonData) | undefined;
+  asyncRequireModulePath: string;
+  createModuleId: (absolutePath: string) => number;
+  dependencyMapReservedName?: null | undefined | string;
+  dev: boolean;
+  getRunModuleStatement: (moduleId: number | string, globalPrefix: string) => string;
+  globalPrefix: string;
+  includeAsyncPaths: boolean;
+  inlineSourceMap?: null | undefined | boolean;
+  modulesOnly: boolean;
+  processModuleFilter: (module: Module) => boolean;
+  projectRoot: string;
+  runBeforeMainModule: ReadonlyArray<string>;
+  runModule: boolean;
+  serverRoot: string;
+  shouldAddToIgnoreList: (module: Module) => boolean;
+  sourceMapUrl?: null | undefined | string;
+  sourceUrl?: null | undefined | string;
+  getSourceUrl?: null | undefined | ((module: Module) => string);
+  unstable_inlineDependencyMap?: boolean | undefined;
+  unstable_getAsyncDependencyPath?: ((dependency: ResolvedDependency, options: unknown) => null | undefined | ReadonlyJsonData) | undefined;
 }>;
 
 export type ServerOptions = Readonly<{
-    hasReducedPerformance?: boolean | undefined;
-    onBundleBuilt?: ((bundlePath: string) => void) | undefined;
-    watch?: boolean | undefined;
+  hasReducedPerformance?: boolean | undefined;
+  onBundleBuilt?: ((bundlePath: string) => void) | undefined;
+  watch?: boolean | undefined;
 }>;
 
 export class Terminal {
-    constructor(stream: UnderlyingStream, opts?: {ttyPrint?: boolean | undefined});
-    flush(): Promise<void>;
-    log(format: string, ...args: Array<unknown>): void;
-    persistStatus(): void;
-    status(format: string, ...args: Array<unknown>): string;
-    waitForUpdates(): Promise<void>;
+  constructor(stream: UnderlyingStream, opts?: {ttyPrint?: boolean | undefined});
+  flush(): Promise<void>;
+  log(format: string, ...args: Array<unknown>): void;
+  persistStatus(): void;
+  status(format: string, ...args: Array<unknown>): string;
+  waitForUpdates(): Promise<void>;
 }
 
 export type TerminalReportableEvent =
-| ReportableEvent
-| {
-    buildID: string;
-    type: 'bundle_transform_progressed_throttled';
-    transformedFileCount: number;
-    totalFileCount: number;
-}
-| {
-    type: 'unstable_server_log';
-    level: 'info' | 'warn' | 'error';
-    data: string | Array<unknown>;
-}
-| {type: 'unstable_server_menu_updated'; message: string}
-| {type: 'unstable_server_menu_cleared'};
+  | ReportableEvent
+  | {
+      buildID: string;
+      type: 'bundle_transform_progressed_throttled';
+      transformedFileCount: number;
+      totalFileCount: number;
+    }
+  | {
+      type: 'unstable_server_log';
+      level: 'info' | 'warn' | 'error';
+      data: string | Array<unknown>;
+    }
+  | {type: 'unstable_server_menu_updated'; message: string}
+  | {type: 'unstable_server_menu_cleared'};
 
 export class TerminalReporter {
-    constructor(terminal: Terminal);
-    readonly terminal: Terminal;
-    update(event: TerminalReportableEvent): void;
+  constructor(terminal: Terminal);
+  readonly terminal: Terminal;
+  update(event: TerminalReportableEvent): void;
 }
 
 export type TransformInputOptions = Omit<JsTransformOptions, 'inlinePlatform' | 'inlineRequires'>;
 
 export type TransformResult<T = MixedOutput> = Readonly<{
-    dependencies: ReadonlyArray<TransformResultDependency>;
-    output: ReadonlyArray<T>;
-    unstable_transformResultKey?: null | undefined | string;
+  dependencies: ReadonlyArray<TransformResultDependency>;
+  output: ReadonlyArray<T>;
+  unstable_transformResultKey?: null | undefined | string;
 }>;
 
 export type TransformResultDependency = Readonly<{
-    name: string;
-    data: Readonly<{
-        key: string;
-        asyncType: AsyncDependencyType | null;
-        isESMImport: boolean;
-        isOptional?: boolean | undefined;
-        locs: ReadonlyArray<ReadonlySourceLocation>;
-        contextParams?: RequireContextParams | undefined;
-    }>;
+  name: string;
+  data: Readonly<{
+    key: string;
+    asyncType: AsyncDependencyType | null;
+    isESMImport: boolean;
+    isOptional?: boolean | undefined;
+    locs: ReadonlyArray<ReadonlySourceLocation>;
+    contextParams?: RequireContextParams | undefined;
+  }>;
 }>;
 
 ```
diff --git a/scripts/generateApiSnapshots.js b/scripts/generateApiSnapshots.js
index 32dae7231d..d8dd04ef6a 100644
--- a/scripts/generateApiSnapshots.js
+++ b/scripts/generateApiSnapshots.js
@@ -24,6 +24,7 @@ import {
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import * as prettier from 'prettier';
 
 const WORKSPACE_ROOT = path.resolve(__dirname, '..');
 const PACKAGES_DIR = path.join(WORKSPACE_ROOT, 'packages');
@@ -262,6 +263,29 @@ function cleanReport(report: string): string {
   return result.join('\n');
 }
 
+// Reformat the TypeScript code block of a cleaned report with Prettier. API
+// Extractor strips the leading whitespace from every line of a declaration and
+// re-indents only between `{` and `}`, so any declaration Prettier wrapped in
+// the source `.d.ts` (parameter lists, type arguments) otherwise loses its
+// indentation. The options match the `.d.ts` generator's, so declarations wrap
+// as they do in the published definitions.
+async function formatReport(report: string): Promise<string> {
+  const match = report.match(/^([\s\S]*?```ts\n)([\s\S]*)(```\n?)$/);
+  if (match == null) {
+    throw new Error('Could not find the TypeScript code block in the report');
+  }
+  const [, header, code, footer] = match;
+  const filepath = path.join(__dirname, 'dummy.d.ts');
+  const formatted = await prettier.format(code, {
+    ...(await prettier.resolveConfig(filepath)),
+    filepath,
+    printWidth: 200,
+    requirePragma: false,
+  });
+  // Keep the blank lines API Extractor leaves inside the fences.
+  return header + '\n' + (formatted === '' ? '' : formatted + '\n') + footer;
+}
+
 // Build the API Extractor config for one entry point. The report is written to
 // a scratch folder; the caller owns writing it to its committed location so we
 // control the file name, path, and post-processing.
@@ -448,7 +472,7 @@ export async function generateApiSnapshots(
               continue;
             }
 
-            const snapshot = cleanReport(report);
+            const snapshot = await formatReport(cleanReport(report));
             const outputPath = path.join(
               entryPoint.packageDir,
               entryPoint.outputFileName,