FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/@react-native/dev-middleware/README.md

@@ -0,0 +1,103 @@
+# @react-native/dev-middleware
+
+![npm package](https://img.shields.io/npm/v/@react-native/dev-middleware?color=brightgreen&label=npm%20package)
+
+Dev server middleware supporting core React Native development features. This package is preconfigured in all React Native projects.
+
+## Usage
+
+Middleware can be attached to a dev server (e.g. [Metro](https://facebook.github.io/metro/docs/getting-started)) using the `createDevMiddleware` API.
+
+```js
+import { createDevMiddleware } from '@react-native/dev-middleware';
+
+function myDevServerImpl(args) {
+  ...
+
+  const {middleware, websocketEndpoints} = createDevMiddleware({
+    projectRoot: metroConfig.projectRoot,
+    serverBaseUrl: new URL(`http://${args.host}:${args.port}`),
+    logger,
+  });
+
+  await Metro.runServer(metroConfig, {
+    host: args.host,
+    ...,
+    unstable_extraMiddleware: [
+      middleware,
+      // Optionally extend with additional HTTP middleware
+    ],
+    websocketEndpoints: {
+      ...websocketEndpoints,
+      // Optionally extend with additional WebSocket endpoints
+    },
+  });
+}
+```
+
+## Included middleware
+
+`@react-native/dev-middleware` is designed for integrators such as [`@expo/dev-server`](https://www.npmjs.com/package/@expo/dev-server) and [`@react-native/community-cli-plugin`](https://github.com/facebook/react-native/tree/main/packages/community-cli-plugin). It provides a common default implementation for core React Native dev server responsibilities.
+
+We intend to keep this to a narrow set of functionality, based around:
+
+- **Debugging** — The [Chrome DevTools protocol (CDP)](https://chromedevtools.github.io/devtools-protocol/) endpoints supported by React Native, including the Inspector Proxy, which facilitates connections with multiple devices.
+- **Dev actions** — Endpoints implementing core [Dev Menu](https://reactnative.dev/docs/debugging#accessing-the-dev-menu) actions, e.g. reloading the app, opening the debugger frontend.
+
+### HTTP endpoints
+
+<small>`DevMiddlewareAPI.middleware`</small>
+
+These are exposed as a [`connect`](https://www.npmjs.com/package/connect) middleware handler, assignable to `Metro.runServer` or other compatible HTTP servers.
+
+#### GET `/json/list`, `/json` ([CDP](https://chromedevtools.github.io/devtools-protocol/#endpoints))
+
+Returns the list of available WebSocket targets for all connected React Native app sessions.
+
+#### GET `/json/version` ([CDP](https://chromedevtools.github.io/devtools-protocol/#endpoints))
+
+Returns version metadata used by Chrome DevTools.
+
+#### GET `/debugger-frontend`
+
+Subpaths of this endpoint are reserved to serve the JavaScript debugger frontend.
+
+#### POST `/open-debugger`
+
+Open the JavaScript debugger for a given CDP target. Must be provided with one of the following query params:
+
+- `device`‌ — An ID unique to a combination of device and app, stable across installs. Implemented by `getInspectorDeviceId` on each native platform.
+- `target` — The target page ID as returned by `/json/list` for the current dev server session.
+- `appId` (deprecated, legacy only) — The application bundle identifier to match (non-unique across multiple connected devices). This param will only match legacy Hermes debugger targets.
+
+<details>
+<summary>Example</summary>
+
+    curl -X POST 'http://localhost:8081/open-debugger?target=<targetId>'
+</details>
+
+### WebSocket endpoints
+
+<small>`DevMiddlewareAPI.websocketEndpoints`</small>
+
+#### `/inspector/device`
+
+WebSocket handler for registering device connections.
+
+#### `/inspector/debug`
+
+WebSocket handler that proxies CDP messages to/from the corresponding device.
+
+## Experimental features
+
+React Native frameworks may pass an `unstable_experiments` option to `createDevMiddleware` to configure experimental features. Note that these features might not work correctly, and they may change or be removed in the future without notice. Some of the experiment flags available are documented below.
+
+### `unstable_experiments.enableStandaloneFuseboxShell`
+
+Enables launching the debugger frontend in a standalone app shell (provided by the `@react-native/debugger-shell` package) rather than in a browser window. Since React Native 0.83 this defaults to `true`, and may be disabled by explicitly passing `false`.
+
+The shell is powered by a separate binary that is downloaded and cached in the background (immediately after the call to `createDevMiddleware`). If there is a problem downloading or invoking this binary for the first time, the debugger frontend will revert to launching in a browser window until the next time `createDevMiddleware` is called (typically, on the next dev server start).
+
+## Contributing
+
+Changes to this package can be made locally and tested against the `rn-tester` app, per the [Contributing guide](https://reactnative.dev/contributing/overview#contributing-code). During development, this package is automatically run from source with no build step.

node_modules/@react-native/dev-middleware/dist/createDevMiddleware.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { CreateCustomMessageHandlerFn } from "./inspector-proxy/CustomMessageHandler";
+import type { DevToolLauncher } from "./types/DevToolLauncher";
+import type { EventReporter } from "./types/EventReporter";
+import type { ExperimentsConfig } from "./types/Experiments";
+import type { Logger } from "./types/Logger";
+import type { ReadonlyURL } from "./types/ReadonlyURL";
+import type { NextHandleFunction } from "connect";
+type Options = Readonly<{
+  /**
+   * The base URL to the dev server, as reachable from the machine on which
+   * dev-middleware is hosted. Typically `http://localhost:${metroPort}`.
+   */
+  serverBaseUrl: string | ReadonlyURL;
+  /**
+   * An implementation for logging messages to the terminal (recommended).
+   *
+   * In `@react-native/community-cli-plugin`, this reuses Metro's
+   * 'unstable_server_log' event in `TerminalReporter`.
+   */
+  logger?: Logger;
+  /**
+   * An `EventReporter` implementation for logging structured events
+   * (recommended).
+   *
+   * This is an unstable API with no semver guarantees.
+   */
+  unstable_eventReporter?: EventReporter;
+  /**
+   * The set of experimental features to enable.
+   *
+   * This is an unstable API with no semver guarantees.
+   */
+  unstable_experiments?: ExperimentsConfig;
+  /**
+   * Override the default handlers for launching external applications (the
+   * debugger frontend) on the host machine (or target dev machine).
+   *
+   * This is an unstable API with no semver guarantees.
+   */
+  unstable_toolLauncher?: DevToolLauncher;
+  /**
+   * Create custom handler to add support for unsupported CDP events, or debuggers.
+   * This handler is instantiated per logical device and debugger pair.
+   *
+   * This is an unstable API with no semver guarantees.
+   */
+  unstable_customInspectorMessageHandler?: CreateCustomMessageHandlerFn;
+  /**
+   * Whether to measure the event loop performance of inspector proxy and
+   * report it via the event reporter.
+   *
+   * This is an unstable API with no semver guarantees.
+   */
+  unstable_trackInspectorProxyEventLoopPerf?: boolean;
+}>;
+type DevMiddlewareAPI = Readonly<{
+  middleware: NextHandleFunction;
+  websocketEndpoints: { [path: string]: ws$WebSocketServer };
+}>;
+declare function createDevMiddleware($$PARAM_0$$: Options): DevMiddlewareAPI;
+export default createDevMiddleware;

node_modules/@react-native/dev-middleware/dist/createDevMiddleware.js

@@ -0,0 +1,130 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = createDevMiddleware;
+var _InspectorProxy = _interopRequireDefault(
+  require("./inspector-proxy/InspectorProxy"),
+);
+var _openDebuggerMiddleware = _interopRequireDefault(
+  require("./middleware/openDebuggerMiddleware"),
+);
+var _DefaultToolLauncher = _interopRequireDefault(
+  require("./utils/DefaultToolLauncher"),
+);
+var _debuggerFrontend = _interopRequireDefault(
+  require("@react-native/debugger-frontend"),
+);
+var _connect = _interopRequireDefault(require("connect"));
+var _path = _interopRequireDefault(require("path"));
+var _serveStatic = _interopRequireDefault(require("serve-static"));
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+function createDevMiddleware({
+  serverBaseUrl,
+  logger,
+  unstable_eventReporter,
+  unstable_experiments: experimentConfig = {},
+  unstable_toolLauncher = _DefaultToolLauncher.default,
+  unstable_customInspectorMessageHandler,
+  unstable_trackInspectorProxyEventLoopPerf = false,
+}) {
+  const normalizedServerBaseUrl = new URL(serverBaseUrl);
+  const experiments = getExperiments(experimentConfig);
+  const eventReporter = createWrappedEventReporter(
+    unstable_eventReporter,
+    logger,
+    experiments,
+  );
+  const inspectorProxy = new _InspectorProxy.default(
+    normalizedServerBaseUrl,
+    eventReporter,
+    experiments,
+    logger,
+    unstable_customInspectorMessageHandler,
+    unstable_trackInspectorProxyEventLoopPerf,
+  );
+  const middleware = (0, _connect.default)()
+    .use(
+      "/open-debugger",
+      (0, _openDebuggerMiddleware.default)({
+        serverBaseUrl: normalizedServerBaseUrl,
+        inspectorProxy,
+        toolLauncher: unstable_toolLauncher,
+        eventReporter,
+        experiments,
+        logger,
+      }),
+    )
+    .use(
+      "/debugger-frontend/embedder-static/embedderScript.js",
+      (_req, res) => {
+        res.setHeader("Content-Type", "application/javascript");
+        res.end("");
+      },
+    )
+    .use(
+      "/debugger-frontend",
+      (0, _serveStatic.default)(_path.default.join(_debuggerFrontend.default), {
+        fallthrough: false,
+      }),
+    )
+    .use((...args) => inspectorProxy.processRequest(...args));
+  return {
+    middleware,
+    websocketEndpoints: inspectorProxy.createWebSocketListeners(),
+  };
+}
+function getExperiments(config) {
+  return {
+    enableOpenDebuggerRedirect: config.enableOpenDebuggerRedirect ?? false,
+    enableNetworkInspector: config.enableNetworkInspector ?? false,
+    enableStandaloneFuseboxShell: config.enableStandaloneFuseboxShell ?? true,
+  };
+}
+function createWrappedEventReporter(reporter, logger, experiments) {
+  return {
+    logEvent(event) {
+      switch (event.type) {
+        case "profiling_target_registered":
+          logger?.info(
+            "Profiling build target '%s' registered for debugging",
+            event.appId ?? "unknown",
+          );
+          break;
+        case "fusebox_shell_preparation_attempt":
+          switch (event.result.code) {
+            case "success":
+            case "not_implemented":
+              break;
+            case "unexpected_error": {
+              let message =
+                event.result.humanReadableMessage ??
+                "An unknown error occurred while installing React Native DevTools.";
+              if (event.result.verboseInfo != null) {
+                message += ` Details:\n\n${event.result.verboseInfo}`;
+              } else {
+                message += ".";
+              }
+              logger?.error(message);
+              break;
+            }
+            case "possible_corruption":
+            case "platform_not_supported":
+            case "likely_offline":
+              logger?.warn(
+                event.result.humanReadableMessage ??
+                  `An error of type ${event.result.code} occurred while installing React Native DevTools.`,
+              );
+              break;
+            default:
+              event.result.code;
+              break;
+          }
+      }
+      reporter?.logEvent(event);
+    },
+  };
+}

node_modules/@react-native/dev-middleware/dist/createDevMiddleware.js.flow

@@ -0,0 +1,81 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type { CreateCustomMessageHandlerFn } from "./inspector-proxy/CustomMessageHandler";
+import type { DevToolLauncher } from "./types/DevToolLauncher";
+import type { EventReporter } from "./types/EventReporter";
+import type { ExperimentsConfig } from "./types/Experiments";
+import type { Logger } from "./types/Logger";
+import type { ReadonlyURL } from "./types/ReadonlyURL";
+import type { NextHandleFunction } from "connect";
+
+type Options = Readonly<{
+  /**
+   * The base URL to the dev server, as reachable from the machine on which
+   * dev-middleware is hosted. Typically `http://localhost:${metroPort}`.
+   */
+  serverBaseUrl: string | ReadonlyURL,
+
+  /**
+   * An implementation for logging messages to the terminal (recommended).
+   *
+   * In `@react-native/community-cli-plugin`, this reuses Metro's
+   * 'unstable_server_log' event in `TerminalReporter`.
+   */
+  logger?: Logger,
+
+  /**
+   * An `EventReporter` implementation for logging structured events
+   * (recommended).
+   *
+   * This is an unstable API with no semver guarantees.
+   */
+  unstable_eventReporter?: EventReporter,
+
+  /**
+   * The set of experimental features to enable.
+   *
+   * This is an unstable API with no semver guarantees.
+   */
+  unstable_experiments?: ExperimentsConfig,
+
+  /**
+   * Override the default handlers for launching external applications (the
+   * debugger frontend) on the host machine (or target dev machine).
+   *
+   * This is an unstable API with no semver guarantees.
+   */
+  unstable_toolLauncher?: DevToolLauncher,
+
+  /**
+   * Create custom handler to add support for unsupported CDP events, or debuggers.
+   * This handler is instantiated per logical device and debugger pair.
+   *
+   * This is an unstable API with no semver guarantees.
+   */
+  unstable_customInspectorMessageHandler?: CreateCustomMessageHandlerFn,
+
+  /**
+   * Whether to measure the event loop performance of inspector proxy and
+   * report it via the event reporter.
+   *
+   * This is an unstable API with no semver guarantees.
+   */
+  unstable_trackInspectorProxyEventLoopPerf?: boolean,
+}>;
+
+type DevMiddlewareAPI = Readonly<{
+  middleware: NextHandleFunction,
+  websocketEndpoints: { [path: string]: ws$WebSocketServer },
+}>;
+
+declare export default function createDevMiddleware(
+  $$PARAM_0$$: Options,
+): DevMiddlewareAPI;

node_modules/@react-native/dev-middleware/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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
+ */
+
+export type {
+  DevToolLauncher,
+  DebuggerShellPreparationResult,
+} from "./types/DevToolLauncher";
+export type { EventReporter, ReportableEvent } from "./types/EventReporter";
+export type {
+  CustomMessageHandler,
+  CustomMessageHandlerConnection,
+  CreateCustomMessageHandlerFn,
+} from "./inspector-proxy/CustomMessageHandler";
+export type { Logger } from "./types/Logger";
+export type { ReadonlyURL } from "./types/ReadonlyURL";
+export { default as unstable_DefaultToolLauncher } from "./utils/DefaultToolLauncher";
+export { default as createDevMiddleware } from "./createDevMiddleware";

node_modules/@react-native/dev-middleware/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+Object.defineProperty(exports, "createDevMiddleware", {
+  enumerable: true,
+  get: function () {
+    return _createDevMiddleware.default;
+  },
+});
+Object.defineProperty(exports, "unstable_DefaultToolLauncher", {
+  enumerable: true,
+  get: function () {
+    return _DefaultToolLauncher.default;
+  },
+});
+var _DefaultToolLauncher = _interopRequireDefault(
+  require("./utils/DefaultToolLauncher"),
+);
+var _createDevMiddleware = _interopRequireDefault(
+  require("./createDevMiddleware"),
+);
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}

node_modules/@react-native/dev-middleware/dist/index.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+export type {
+  DevToolLauncher,
+  DebuggerShellPreparationResult,
+} from "./types/DevToolLauncher";
+export type { EventReporter, ReportableEvent } from "./types/EventReporter";
+export type {
+  CustomMessageHandler,
+  CustomMessageHandlerConnection,
+  CreateCustomMessageHandlerFn,
+} from "./inspector-proxy/CustomMessageHandler";
+export type { Logger } from "./types/Logger";
+export type { ReadonlyURL } from "./types/ReadonlyURL";
+
+export { default as unstable_DefaultToolLauncher } from "./utils/DefaultToolLauncher";
+export { default as createDevMiddleware } from "./createDevMiddleware";

node_modules/@react-native/dev-middleware/dist/inspector-proxy/CdpDebugLogging.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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
+ */
+
+export type CDPMessageDestination =
+  | "DebuggerToProxy"
+  | "ProxyToDebugger"
+  | "DeviceToProxy"
+  | "ProxyToDevice";
+declare class CdpDebugLogging {
+  constructor();
+  log(destination: CDPMessageDestination, message: string): void;
+}
+export default CdpDebugLogging;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/CdpDebugLogging.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _timers = require("timers");
+var _util = _interopRequireDefault(require("util"));
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+const debug = require("debug")("Metro:InspectorProxy");
+const debugCDPMessages = require("debug")("Metro:InspectorProxyCDPMessages");
+const CDP_MESSAGES_BATCH_DEBUGGING_THROTTLE_MS = 5000;
+function getCDPLogPrefix(destination) {
+  return _util.default.format(
+    "[(Debugger) %s (Proxy) %s (Device)]",
+    destination === "DebuggerToProxy"
+      ? "->"
+      : destination === "ProxyToDebugger"
+        ? "<-"
+        : "  ",
+    destination === "ProxyToDevice"
+      ? "->"
+      : destination === "DeviceToProxy"
+        ? "<-"
+        : "  ",
+  );
+}
+class CdpDebugLogging {
+  #cdpMessagesLoggingBatchingFn = {
+    DebuggerToProxy: () => {},
+    ProxyToDebugger: () => {},
+    DeviceToProxy: () => {},
+    ProxyToDevice: () => {},
+  };
+  constructor() {
+    if (debug.enabled) {
+      this.#initializeThrottledCDPMessageLogging();
+    }
+  }
+  #initializeThrottledCDPMessageLogging() {
+    const batchingCounters = {
+      DebuggerToProxy: {
+        count: 0,
+        size: 0,
+      },
+      ProxyToDebugger: {
+        count: 0,
+        size: 0,
+      },
+      DeviceToProxy: {
+        count: 0,
+        size: 0,
+      },
+      ProxyToDevice: {
+        count: 0,
+        size: 0,
+      },
+    };
+    Object.keys(batchingCounters).forEach((destination) => {
+      let timeout = null;
+      this.#cdpMessagesLoggingBatchingFn[destination] = (message) => {
+        if (message.length > 1024 * 100) {
+          const messagePreview = JSON.stringify(
+            JSON.parse(message, (key, value) => {
+              if (Array.isArray(value)) {
+                return "[ARRAY]";
+              }
+              if (typeof value === "string" && value.length > 50) {
+                return value.slice(0, 50) + "...";
+              }
+              return value;
+            }),
+            null,
+            2,
+          );
+          debug(
+            "%s A large message (%s MB) was %s- %s",
+            getCDPLogPrefix(destination),
+            (message.length / (1024 * 1024)).toFixed(2),
+            destination.startsWith("Proxy") ? "  sent  " : "received",
+            messagePreview,
+          );
+        }
+        if (timeout == null) {
+          timeout = (0, _timers.setTimeout)(() => {
+            debug(
+              "%s %s CDP messages of size %s MB %s in the last %ss.",
+              getCDPLogPrefix(destination),
+              String(batchingCounters[destination].count).padStart(4),
+              String(
+                (batchingCounters[destination].size / (1024 * 1024)).toFixed(2),
+              ).padStart(6),
+              destination.startsWith("Proxy") ? "  sent  " : "received",
+              CDP_MESSAGES_BATCH_DEBUGGING_THROTTLE_MS / 1000,
+            );
+            batchingCounters[destination].count = 0;
+            batchingCounters[destination].size = 0;
+            timeout = null;
+          }, CDP_MESSAGES_BATCH_DEBUGGING_THROTTLE_MS).unref();
+        }
+        batchingCounters[destination].count++;
+        batchingCounters[destination].size += message.length;
+      };
+    });
+  }
+  log(destination, message) {
+    if (debugCDPMessages.enabled) {
+      debugCDPMessages("%s message: %s", getCDPLogPrefix(destination), message);
+    }
+    if (debug.enabled) {
+      this.#cdpMessagesLoggingBatchingFn[destination](message);
+    }
+  }
+}
+exports.default = CdpDebugLogging;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/CdpDebugLogging.js.flow

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+export type CDPMessageDestination =
+  | "DebuggerToProxy"
+  | "ProxyToDebugger"
+  | "DeviceToProxy"
+  | "ProxyToDevice";
+
+declare export default class CdpDebugLogging {
+  constructor(): void;
+  log(destination: CDPMessageDestination, message: string): void;
+}

node_modules/@react-native/dev-middleware/dist/inspector-proxy/CustomMessageHandler.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { JSONSerializable, Page } from "./types";
+type ExposedDevice = Readonly<{
+  appId: string;
+  id: string;
+  name: string;
+  sendMessage: (message: JSONSerializable) => void;
+}>;
+type ExposedDebugger = Readonly<{
+  userAgent: string | null;
+  sendMessage: (message: JSONSerializable) => void;
+}>;
+export type CustomMessageHandlerConnection = Readonly<{
+  page: Page;
+  device: ExposedDevice;
+  debugger: ExposedDebugger;
+}>;
+export type CreateCustomMessageHandlerFn = (
+  connection: CustomMessageHandlerConnection,
+) => null | undefined | CustomMessageHandler;
+/**
+ * The device message middleware allows implementers to handle unsupported CDP messages.
+ * It is instantiated per device and may contain state that is specific to that device.
+ * The middleware can also mark messages from the device or debugger as handled, which stops propagating.
+ */
+export interface CustomMessageHandler {
+  /**
+   * Handle a CDP message coming from the device.
+   * This is invoked before the message is sent to the debugger.
+   * When returning true, the message is considered handled and will not be sent to the debugger.
+   */
+  handleDeviceMessage(message: JSONSerializable): true | void;
+  /**
+   * Handle a CDP message coming from the debugger.
+   * This is invoked before the message is sent to the device.
+   * When returning true, the message is considered handled and will not be sent to the device.
+   */
+  handleDebuggerMessage(message: JSONSerializable): true | void;
+}

node_modules/@react-native/dev-middleware/dist/inspector-proxy/CustomMessageHandler.js

@@ -0,0 +1 @@
+"use strict";

node_modules/@react-native/dev-middleware/dist/inspector-proxy/CustomMessageHandler.js.flow

@@ -0,0 +1,54 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type { JSONSerializable, Page } from "./types";
+
+type ExposedDevice = Readonly<{
+  appId: string,
+  id: string,
+  name: string,
+  sendMessage: (message: JSONSerializable) => void,
+}>;
+
+type ExposedDebugger = Readonly<{
+  userAgent: string | null,
+  sendMessage: (message: JSONSerializable) => void,
+}>;
+
+export type CustomMessageHandlerConnection = Readonly<{
+  page: Page,
+  device: ExposedDevice,
+  debugger: ExposedDebugger,
+}>;
+
+export type CreateCustomMessageHandlerFn = (
+  connection: CustomMessageHandlerConnection,
+) => ?CustomMessageHandler;
+
+/**
+ * The device message middleware allows implementers to handle unsupported CDP messages.
+ * It is instantiated per device and may contain state that is specific to that device.
+ * The middleware can also mark messages from the device or debugger as handled, which stops propagating.
+ */
+export interface CustomMessageHandler {
+  /**
+   * Handle a CDP message coming from the device.
+   * This is invoked before the message is sent to the debugger.
+   * When returning true, the message is considered handled and will not be sent to the debugger.
+   */
+  handleDeviceMessage(message: JSONSerializable): true | void;
+
+  /**
+   * Handle a CDP message coming from the debugger.
+   * This is invoked before the message is sent to the device.
+   * When returning true, the message is considered handled and will not be sent to the device.
+   */
+  handleDebuggerMessage(message: JSONSerializable): true | void;
+}

node_modules/@react-native/dev-middleware/dist/inspector-proxy/Device.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { EventReporter } from "../types/EventReporter";
+import type { Experiments } from "../types/Experiments";
+import type { ReadonlyURL } from "../types/ReadonlyURL";
+import type { CreateCustomMessageHandlerFn } from "./CustomMessageHandler";
+import type { Page } from "./types";
+import WS from "ws";
+export declare const WS_CLOSE_REASON: {
+  PAGE_NOT_FOUND: "[PAGE_NOT_FOUND] Debugger page not found";
+  CONNECTION_LOST: "[CONNECTION_LOST] Connection lost to corresponding device";
+  RECREATING_DEVICE: "[RECREATING_DEVICE] Recreating device connection";
+  NEW_DEBUGGER_OPENED: "[NEW_DEBUGGER_OPENED] New debugger opened for the same app instance";
+};
+export declare type WS_CLOSE_REASON = typeof WS_CLOSE_REASON;
+export type DeviceOptions = Readonly<{
+  id: string;
+  name: string;
+  app: string;
+  socket: WS;
+  eventReporter: null | undefined | EventReporter;
+  createMessageMiddleware: null | undefined | CreateCustomMessageHandlerFn;
+  deviceRelativeBaseUrl: ReadonlyURL;
+  serverRelativeBaseUrl: ReadonlyURL;
+  isProfilingBuild: boolean;
+  experiments: Experiments;
+}>;
+/**
+ * Device class represents single device connection to Inspector Proxy. Each device
+ * can have multiple inspectable pages.
+ */
+declare class Device {
+  constructor(deviceOptions: DeviceOptions);
+  /**
+   * Used to recreate the device connection if there is a device ID collision.
+   * 1. Checks if the same device is attempting to reconnect for the same app.
+   * 2. If not, close both the device and debugger socket.
+   * 3. If the debugger connection can be reused, close the device socket only.
+   *
+   * This hack attempts to allow users to reload the app, either as result of a
+   * crash, or manually reloading, without having to restart the debugger.
+   */
+  dangerouslyRecreateDevice(deviceOptions: DeviceOptions): void;
+  getName(): string;
+  getApp(): string;
+  getPagesList(): ReadonlyArray<Page>;
+  handleDebuggerConnection(
+    socket: WS,
+    pageId: string,
+    $$PARAM_2$$: Readonly<{
+      debuggerRelativeBaseUrl: ReadonlyURL;
+      userAgent: string | null;
+    }>,
+  ): void;
+  dangerouslyGetSocket(): WS;
+}
+export default Device;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/Device.js

@@ -0,0 +1,846 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = exports.WS_CLOSE_REASON = void 0;
+var _CdpDebugLogging = _interopRequireDefault(require("./CdpDebugLogging"));
+var _DeviceEventReporter = _interopRequireDefault(
+  require("./DeviceEventReporter"),
+);
+var _crypto = _interopRequireDefault(require("crypto"));
+var _invariant = _interopRequireDefault(require("invariant"));
+var _ws = _interopRequireDefault(require("ws"));
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+const debug = require("debug")("Metro:InspectorProxy");
+const PAGES_POLLING_INTERVAL = 1000;
+const WS_CLOSURE_CODE = {
+  NORMAL: 1000,
+  INTERNAL_ERROR: 1011,
+};
+const WS_CLOSE_REASON = (exports.WS_CLOSE_REASON = {
+  PAGE_NOT_FOUND: "[PAGE_NOT_FOUND] Debugger page not found",
+  CONNECTION_LOST: "[CONNECTION_LOST] Connection lost to corresponding device",
+  RECREATING_DEVICE: "[RECREATING_DEVICE] Recreating device connection",
+  NEW_DEBUGGER_OPENED:
+    "[NEW_DEBUGGER_OPENED] New debugger opened for the same app instance",
+});
+const FILE_PREFIX = "file://";
+const REACT_NATIVE_RELOADABLE_PAGE_ID = "-1";
+class Device {
+  #id;
+  #name;
+  #app;
+  #deviceSocket;
+  #pages = new Map();
+  #debuggerConnections = new Map();
+  #lastConnectedLegacyReactNativePage = null;
+  #isLegacyPageReloading = false;
+  #lastGetPagesMessage = "";
+  #scriptIdToSourcePathMapping = new Map();
+  #deviceEventReporter;
+  #pagesPollingIntervalId;
+  #createCustomMessageHandler;
+  #deviceRelativeBaseUrl;
+  #serverRelativeBaseUrl;
+  #cdpDebugLogging;
+  #experiments;
+  constructor(deviceOptions) {
+    this.#experiments = deviceOptions.experiments;
+    this.#dangerouslyConstruct(deviceOptions);
+  }
+  #dangerouslyConstruct({
+    id,
+    name,
+    app,
+    socket,
+    eventReporter,
+    createMessageMiddleware,
+    serverRelativeBaseUrl,
+    deviceRelativeBaseUrl,
+    isProfilingBuild,
+  }) {
+    this.#cdpDebugLogging = new _CdpDebugLogging.default();
+    this.#id = id;
+    this.#name = name;
+    this.#app = app;
+    this.#deviceSocket = socket;
+    this.#serverRelativeBaseUrl = serverRelativeBaseUrl;
+    this.#deviceRelativeBaseUrl = deviceRelativeBaseUrl;
+    this.#deviceEventReporter = eventReporter
+      ? new _DeviceEventReporter.default(eventReporter, {
+          deviceId: id,
+          deviceName: name,
+          appId: app,
+        })
+      : null;
+    this.#createCustomMessageHandler = createMessageMiddleware;
+    if (isProfilingBuild) {
+      this.#deviceEventReporter?.logProfilingTargetRegistered();
+    }
+    this.#deviceSocket.on("message", (message) => {
+      try {
+        const parsedMessage = JSON.parse(message);
+        if (parsedMessage.event === "getPages") {
+          if (message !== this.#lastGetPagesMessage) {
+            debug("Device getPages ping has changed: %s", message);
+            this.#lastGetPagesMessage = message;
+          }
+        } else {
+          this.#cdpDebugLogging.log("DeviceToProxy", message);
+        }
+        this.#handleMessageFromDevice(parsedMessage);
+      } catch (error) {
+        debug("%O\nHandling device message: %s", error, message);
+        try {
+          this.#deviceEventReporter?.logProxyMessageHandlingError(
+            "device",
+            error,
+            message,
+          );
+        } catch (loggingError) {
+          debug(
+            "Error logging message handling error to reporter: %O",
+            loggingError,
+          );
+        }
+      }
+    });
+    this.#pagesPollingIntervalId = setInterval(
+      () =>
+        this.#sendMessageToDevice({
+          event: "getPages",
+        }),
+      PAGES_POLLING_INTERVAL,
+    );
+    this.#deviceSocket.on("close", () => {
+      if (socket === this.#deviceSocket) {
+        this.#deviceEventReporter?.logDisconnection("device");
+        this.#terminateDebuggerConnection(
+          WS_CLOSURE_CODE.NORMAL,
+          WS_CLOSE_REASON.CONNECTION_LOST,
+        );
+        clearInterval(this.#pagesPollingIntervalId);
+      }
+    });
+  }
+  #terminateDebuggerConnection(code, reason, sessionId) {
+    if (sessionId != null) {
+      const debuggerConnection = this.#debuggerConnections.get(sessionId);
+      if (debuggerConnection) {
+        this.#debuggerConnections.delete(sessionId);
+        this.#sendDisconnectEventToDevice(
+          this.#mapToDevicePageId(debuggerConnection.pageId),
+          sessionId,
+        );
+        debuggerConnection.socket.close(code, reason);
+      }
+    } else {
+      const connections = Array.from(this.#debuggerConnections.entries());
+      this.#debuggerConnections.clear();
+      for (const [sid, debuggerConnection] of connections) {
+        this.#sendDisconnectEventToDevice(
+          this.#mapToDevicePageId(debuggerConnection.pageId),
+          sid,
+        );
+        debuggerConnection.socket.close(code, reason);
+      }
+    }
+  }
+  dangerouslyRecreateDevice(deviceOptions) {
+    (0, _invariant.default)(
+      deviceOptions.id === this.#id,
+      "dangerouslyRecreateDevice() can only be used for the same device ID",
+    );
+    const oldDebuggerConnections = new Map(this.#debuggerConnections);
+    if (this.#app !== deviceOptions.app || this.#name !== deviceOptions.name) {
+      this.#deviceSocket.close(
+        WS_CLOSURE_CODE.NORMAL,
+        WS_CLOSE_REASON.RECREATING_DEVICE,
+      );
+      this.#terminateDebuggerConnection(
+        WS_CLOSURE_CODE.NORMAL,
+        WS_CLOSE_REASON.RECREATING_DEVICE,
+      );
+    }
+    this.#debuggerConnections.clear();
+    if (oldDebuggerConnections.size > 0) {
+      this.#deviceSocket.close(
+        WS_CLOSURE_CODE.NORMAL,
+        WS_CLOSE_REASON.RECREATING_DEVICE,
+      );
+    }
+    this.#dangerouslyConstruct(deviceOptions);
+    for (const oldDebugger of oldDebuggerConnections.values()) {
+      oldDebugger.socket.removeAllListeners();
+      this.handleDebuggerConnection(oldDebugger.socket, oldDebugger.pageId, {
+        debuggerRelativeBaseUrl: oldDebugger.debuggerRelativeBaseUrl,
+        userAgent: oldDebugger.userAgent,
+      });
+    }
+  }
+  getName() {
+    return this.#name;
+  }
+  getApp() {
+    return this.#app;
+  }
+  getPagesList() {
+    if (this.#lastConnectedLegacyReactNativePage) {
+      return [...this.#pages.values(), this.#createSyntheticPage()];
+    } else {
+      return [...this.#pages.values()];
+    }
+  }
+  handleDebuggerConnection(
+    socket,
+    pageId,
+    { debuggerRelativeBaseUrl, userAgent },
+  ) {
+    const page =
+      pageId === REACT_NATIVE_RELOADABLE_PAGE_ID
+        ? this.#createSyntheticPage()
+        : this.#pages.get(pageId);
+    if (!page) {
+      debug(
+        `Got new debugger connection via ${debuggerRelativeBaseUrl.href} for ` +
+          `page ${pageId} of ${this.#name}, but no such page exists`,
+      );
+      socket.close(
+        WS_CLOSURE_CODE.INTERNAL_ERROR,
+        WS_CLOSE_REASON.PAGE_NOT_FOUND,
+      );
+      return;
+    }
+    this.#deviceEventReporter?.logDisconnection("debugger");
+    if (!this.#pageHasCapability(page, "supportsMultipleDebuggers")) {
+      for (const [sid, conn] of this.#debuggerConnections) {
+        if (conn.pageId === pageId) {
+          this.#terminateDebuggerConnection(
+            WS_CLOSURE_CODE.NORMAL,
+            WS_CLOSE_REASON.NEW_DEBUGGER_OPENED,
+            sid,
+          );
+        }
+      }
+    }
+    const sessionId = _crypto.default.randomUUID();
+    this.#deviceEventReporter?.logConnection("debugger", {
+      pageId,
+      frontendUserAgent: userAgent,
+    });
+    const debuggerInfo = {
+      socket,
+      prependedFilePrefix: false,
+      pageId,
+      userAgent: userAgent,
+      customHandler: null,
+      debuggerRelativeBaseUrl,
+      sessionId,
+    };
+    this.#debuggerConnections.set(sessionId, debuggerInfo);
+    debug(
+      `Got new debugger connection via ${debuggerRelativeBaseUrl.href} for ` +
+        `page ${pageId} of ${this.#name} with sessionId ${sessionId}`,
+    );
+    if (this.#createCustomMessageHandler) {
+      debuggerInfo.customHandler = this.#createCustomMessageHandler({
+        page,
+        debugger: {
+          userAgent: debuggerInfo.userAgent,
+          sendMessage: (message) => {
+            try {
+              const payload = JSON.stringify(message);
+              this.#cdpDebugLogging.log("ProxyToDebugger", payload);
+              socket.send(payload);
+            } catch {}
+          },
+        },
+        device: {
+          appId: this.#app,
+          id: this.#id,
+          name: this.#name,
+          sendMessage: (message) => {
+            try {
+              const payload = JSON.stringify({
+                event: "wrappedEvent",
+                payload: {
+                  pageId: this.#mapToDevicePageId(pageId),
+                  wrappedEvent: JSON.stringify(message),
+                  sessionId,
+                },
+              });
+              this.#cdpDebugLogging.log("DebuggerToProxy", payload);
+              this.#deviceSocket.send(payload);
+            } catch {}
+          },
+        },
+      });
+      if (debuggerInfo.customHandler) {
+        debug("Created new custom message handler for debugger connection");
+      } else {
+        debug(
+          "Skipping new custom message handler for debugger connection, factory function returned null",
+        );
+      }
+    }
+    this.#sendConnectEventToDevice(this.#mapToDevicePageId(pageId), sessionId);
+    socket.on("message", (message) => {
+      this.#cdpDebugLogging.log("DebuggerToProxy", message);
+      const debuggerRequest = JSON.parse(message);
+      this.#deviceEventReporter?.logRequest(debuggerRequest, "debugger", {
+        pageId: debuggerInfo.pageId,
+        frontendUserAgent: userAgent,
+      });
+      let processedReq = debuggerRequest;
+      if (
+        debuggerInfo.customHandler?.handleDebuggerMessage(debuggerRequest) ===
+        true
+      ) {
+        return;
+      }
+      if (!this.#pageHasCapability(page, "nativeSourceCodeFetching")) {
+        processedReq = this.#interceptClientMessageForSourceFetching(
+          debuggerRequest,
+          debuggerInfo,
+          socket,
+        );
+      }
+      if (processedReq) {
+        this.#sendMessageToDevice({
+          event: "wrappedEvent",
+          payload: {
+            pageId: this.#mapToDevicePageId(pageId),
+            wrappedEvent: JSON.stringify(processedReq),
+            sessionId,
+          },
+        });
+      }
+    });
+    socket.on("close", () => {
+      debug(
+        `Debugger for page ${pageId} and ${this.#name} disconnected (sessionId: ${sessionId}).`,
+      );
+      this.#deviceEventReporter?.logDisconnection("debugger");
+      this.#terminateDebuggerConnection(undefined, undefined, sessionId);
+    });
+    const cdpDebugLogging = this.#cdpDebugLogging;
+    const sendFunc = socket.send;
+    socket.send = function (message) {
+      cdpDebugLogging.log("ProxyToDebugger", message);
+      return sendFunc.call(socket, message);
+    };
+  }
+  #sendConnectEventToDevice(devicePageId, sessionId) {
+    this.#sendMessageToDevice({
+      event: "connect",
+      payload: {
+        pageId: devicePageId,
+        sessionId,
+      },
+    });
+  }
+  #sendDisconnectEventToDevice(devicePageId, sessionId) {
+    this.#sendMessageToDevice({
+      event: "disconnect",
+      payload: {
+        pageId: devicePageId,
+        sessionId,
+      },
+    });
+  }
+  #pageHasCapability(page, flag) {
+    return page.capabilities[flag] === true;
+  }
+  #createSyntheticPage() {
+    return {
+      id: REACT_NATIVE_RELOADABLE_PAGE_ID,
+      title: "React Native Experimental (Improved Chrome Reloads)",
+      vm: "don't use",
+      app: this.#app,
+      capabilities: {},
+    };
+  }
+  #handleMessageFromDevice(message) {
+    if (message.event === "getPages") {
+      const shouldDisableMultipleDebuggers =
+        !this.#experiments.enableStandaloneFuseboxShell;
+      this.#pages = new Map(
+        message.payload.map(({ capabilities: rawCapabilities, ...page }) => {
+          const capabilities = shouldDisableMultipleDebuggers
+            ? {
+                ...(rawCapabilities ?? {}),
+                supportsMultipleDebuggers: false,
+              }
+            : (rawCapabilities ?? {});
+          return [
+            page.id,
+            {
+              ...page,
+              capabilities,
+            },
+          ];
+        }),
+      );
+      if (message.payload.length !== this.#pages.size) {
+        const duplicateIds = new Set();
+        const idsSeen = new Set();
+        for (const page of message.payload) {
+          if (!idsSeen.has(page.id)) {
+            idsSeen.add(page.id);
+          } else {
+            duplicateIds.add(page.id);
+          }
+        }
+        debug(
+          `Received duplicate page IDs from device: ${[...duplicateIds].join(", ")}`,
+        );
+      }
+      for (const page of this.#pages.values()) {
+        if (this.#pageHasCapability(page, "nativePageReloads")) {
+          continue;
+        }
+        if (page.title.includes("React")) {
+          if (page.id !== this.#lastConnectedLegacyReactNativePage?.id) {
+            this.#newLegacyReactNativePage(page);
+            break;
+          }
+        }
+      }
+    } else if (message.event === "disconnect") {
+      const pageId = message.payload.pageId;
+      const sessionId = message.payload.sessionId;
+      const page = this.#pages.get(pageId);
+      if (page != null && this.#pageHasCapability(page, "nativePageReloads")) {
+        return;
+      }
+      if (sessionId != null) {
+        const debuggerConnection = this.#debuggerConnections.get(sessionId);
+        if (
+          debuggerConnection &&
+          debuggerConnection.socket.readyState === _ws.default.OPEN
+        ) {
+          if (debuggerConnection.pageId !== REACT_NATIVE_RELOADABLE_PAGE_ID) {
+            debug(
+              `Legacy page ${pageId} is reloading (sessionId: ${sessionId}).`,
+            );
+            debuggerConnection.socket.send(
+              JSON.stringify({
+                method: "reload",
+              }),
+            );
+          }
+        }
+      } else {
+        for (const debuggerConnection of this.#debuggerConnections.values()) {
+          if (
+            debuggerConnection.pageId !== REACT_NATIVE_RELOADABLE_PAGE_ID &&
+            debuggerConnection.socket.readyState === _ws.default.OPEN
+          ) {
+            debug(`Legacy page ${pageId} is reloading.`);
+            debuggerConnection.socket.send(
+              JSON.stringify({
+                method: "reload",
+              }),
+            );
+          }
+        }
+      }
+    } else if (message.event === "wrappedEvent") {
+      const sessionId = message.payload.sessionId;
+      let debuggerConnection = null;
+      if (sessionId != null) {
+        debuggerConnection = this.#debuggerConnections.get(sessionId);
+      } else {
+        if (this.#debuggerConnections.size > 1) {
+          debug(
+            "WARNING: Device sent message without sessionId but multiple debuggers are connected. " +
+              "This indicates a device/proxy version mismatch.",
+          );
+        }
+        debuggerConnection =
+          this.#debuggerConnections.values().next().value ?? null;
+      }
+      if (debuggerConnection == null) {
+        return;
+      }
+      const debuggerSocket = debuggerConnection.socket;
+      if (
+        debuggerSocket == null ||
+        debuggerSocket.readyState !== _ws.default.OPEN
+      ) {
+        return;
+      }
+      const parsedPayload = JSON.parse(message.payload.wrappedEvent);
+      const pageId = debuggerConnection.pageId;
+      if ("id" in parsedPayload) {
+        this.#deviceEventReporter?.logResponse(parsedPayload, "device", {
+          pageId,
+          frontendUserAgent: debuggerConnection.userAgent ?? null,
+        });
+      }
+      if (
+        debuggerConnection.customHandler?.handleDeviceMessage(parsedPayload) ===
+        true
+      ) {
+        return;
+      }
+      this.#processMessageFromDeviceLegacy(
+        parsedPayload,
+        debuggerConnection,
+        pageId,
+      );
+      const messageToSend = JSON.stringify(parsedPayload);
+      debuggerSocket.send(messageToSend);
+    }
+  }
+  #sendMessageToDevice(message) {
+    try {
+      const messageToSend = JSON.stringify(message);
+      if (message.event !== "getPages") {
+        this.#cdpDebugLogging.log("ProxyToDevice", messageToSend);
+      }
+      this.#deviceSocket.send(messageToSend);
+    } catch (error) {}
+  }
+  #newLegacyReactNativePage(page) {
+    debug(`React Native page updated to ${page.id}`);
+    let reloadablePageDebugger = null;
+    for (const debuggerConnection of this.#debuggerConnections.values()) {
+      if (debuggerConnection.pageId === REACT_NATIVE_RELOADABLE_PAGE_ID) {
+        reloadablePageDebugger = debuggerConnection;
+        break;
+      }
+    }
+    if (reloadablePageDebugger == null) {
+      this.#lastConnectedLegacyReactNativePage = page;
+      return;
+    }
+    const oldPageId = this.#lastConnectedLegacyReactNativePage?.id;
+    this.#lastConnectedLegacyReactNativePage = page;
+    this.#isLegacyPageReloading = true;
+    if (oldPageId != null) {
+      this.#sendDisconnectEventToDevice(
+        oldPageId,
+        reloadablePageDebugger.sessionId,
+      );
+    }
+    this.#sendConnectEventToDevice(page.id, reloadablePageDebugger.sessionId);
+    const toSend = [
+      {
+        method: "Runtime.enable",
+        id: 1e9,
+      },
+      {
+        method: "Debugger.enable",
+        id: 1e9,
+      },
+    ];
+    for (const message of toSend) {
+      const pageId = reloadablePageDebugger.pageId;
+      this.#deviceEventReporter?.logRequest(message, "proxy", {
+        pageId,
+        frontendUserAgent: reloadablePageDebugger.userAgent ?? null,
+      });
+      this.#sendMessageToDevice({
+        event: "wrappedEvent",
+        payload: {
+          pageId: this.#mapToDevicePageId(page.id),
+          wrappedEvent: JSON.stringify(message),
+          sessionId: reloadablePageDebugger.sessionId,
+        },
+      });
+    }
+  }
+  #debuggerRelativeToDeviceRelativeUrl(
+    debuggerRelativeUrl,
+    { debuggerRelativeBaseUrl },
+  ) {
+    const deviceRelativeUrl = new URL(debuggerRelativeUrl.href);
+    if (debuggerRelativeUrl.origin === debuggerRelativeBaseUrl.origin) {
+      deviceRelativeUrl.hostname = this.#deviceRelativeBaseUrl.hostname;
+      deviceRelativeUrl.port = this.#deviceRelativeBaseUrl.port;
+      deviceRelativeUrl.protocol = this.#deviceRelativeBaseUrl.protocol;
+    }
+    return deviceRelativeUrl;
+  }
+  #deviceRelativeUrlToDebuggerRelativeUrl(
+    deviceRelativeUrl,
+    { debuggerRelativeBaseUrl },
+  ) {
+    const debuggerRelativeUrl = new URL(deviceRelativeUrl.href);
+    if (deviceRelativeUrl.origin === this.#deviceRelativeBaseUrl.origin) {
+      debuggerRelativeUrl.hostname = debuggerRelativeBaseUrl.hostname;
+      debuggerRelativeUrl.port = debuggerRelativeBaseUrl.port;
+      debuggerRelativeUrl.protocol = debuggerRelativeUrl.protocol;
+    }
+    return debuggerRelativeUrl;
+  }
+  #deviceRelativeUrlToServerRelativeUrl(deviceRelativeUrl) {
+    const debuggerRelativeUrl = new URL(deviceRelativeUrl.href);
+    if (deviceRelativeUrl.origin === this.#deviceRelativeBaseUrl.origin) {
+      debuggerRelativeUrl.hostname = this.#serverRelativeBaseUrl.hostname;
+      debuggerRelativeUrl.port = this.#serverRelativeBaseUrl.port;
+      debuggerRelativeUrl.protocol = this.#serverRelativeBaseUrl.protocol;
+    }
+    return debuggerRelativeUrl;
+  }
+  #processMessageFromDeviceLegacy(payload, debuggerInfo, pageId) {
+    const page = pageId != null ? this.#pages.get(pageId) : null;
+    if (
+      (!page || !this.#pageHasCapability(page, "nativeSourceCodeFetching")) &&
+      payload.method === "Debugger.scriptParsed" &&
+      payload.params != null
+    ) {
+      const params = payload.params;
+      if ("sourceMapURL" in params) {
+        const sourceMapURL = this.#tryParseHTTPURL(params.sourceMapURL);
+        if (sourceMapURL) {
+          payload.params.sourceMapURL =
+            this.#deviceRelativeUrlToDebuggerRelativeUrl(
+              sourceMapURL,
+              debuggerInfo,
+            ).href;
+        }
+      }
+      if ("url" in params) {
+        let serverRelativeUrl = params.url;
+        const parsedUrl = this.#tryParseHTTPURL(params.url);
+        if (parsedUrl) {
+          payload.params.url = this.#deviceRelativeUrlToDebuggerRelativeUrl(
+            parsedUrl,
+            debuggerInfo,
+          ).href;
+          serverRelativeUrl =
+            this.#deviceRelativeUrlToServerRelativeUrl(parsedUrl).href;
+        }
+        if (payload.params.url.match(/^[0-9a-z]+$/)) {
+          payload.params.url = FILE_PREFIX + payload.params.url;
+          debuggerInfo.prependedFilePrefix = true;
+        }
+        if ("scriptId" in params && params.scriptId != null) {
+          this.#scriptIdToSourcePathMapping.set(
+            params.scriptId,
+            serverRelativeUrl,
+          );
+        }
+      }
+    }
+    if (
+      payload.method === "Runtime.executionContextCreated" &&
+      this.#isLegacyPageReloading
+    ) {
+      debuggerInfo.socket.send(
+        JSON.stringify({
+          method: "Runtime.executionContextsCleared",
+        }),
+      );
+      const resumeMessage = {
+        method: "Debugger.resume",
+        id: 0,
+      };
+      this.#deviceEventReporter?.logRequest(resumeMessage, "proxy", {
+        pageId: debuggerInfo.pageId,
+        frontendUserAgent: debuggerInfo.userAgent ?? null,
+      });
+      this.#sendMessageToDevice({
+        event: "wrappedEvent",
+        payload: {
+          pageId: this.#mapToDevicePageId(debuggerInfo.pageId),
+          wrappedEvent: JSON.stringify(resumeMessage),
+          sessionId: debuggerInfo.sessionId,
+        },
+      });
+      this.#isLegacyPageReloading = false;
+    }
+    if (payload.method === "Runtime.consoleAPICalled") {
+      const callFrames = payload.params?.stackTrace?.callFrames ?? [];
+      for (const callFrame of callFrames) {
+        if (callFrame.url) {
+          const parsedUrl = this.#tryParseHTTPURL(callFrame.url);
+          if (parsedUrl) {
+            callFrame.url = this.#deviceRelativeUrlToDebuggerRelativeUrl(
+              parsedUrl,
+              debuggerInfo,
+            ).href;
+          }
+        }
+      }
+    }
+  }
+  #interceptClientMessageForSourceFetching(req, debuggerInfo, socket) {
+    switch (req.method) {
+      case "Debugger.setBreakpointByUrl":
+        return this.#processDebuggerSetBreakpointByUrl(req, debuggerInfo);
+      case "Debugger.getScriptSource":
+        void this.#processDebuggerGetScriptSource(req, socket, debuggerInfo);
+        return null;
+      case "Network.loadNetworkResource":
+        const response = {
+          id: req.id,
+          result: {
+            error: {
+              code: -32601,
+              message:
+                "[inspector-proxy]: Page lacks nativeSourceCodeFetching capability.",
+            },
+          },
+        };
+        socket.send(JSON.stringify(response));
+        const pageId = debuggerInfo.pageId;
+        this.#deviceEventReporter?.logResponse(response, "proxy", {
+          pageId,
+          frontendUserAgent: debuggerInfo.userAgent ?? null,
+        });
+        return null;
+      default:
+        return req;
+    }
+  }
+  #processDebuggerSetBreakpointByUrl(req, debuggerInfo) {
+    const { debuggerRelativeBaseUrl, prependedFilePrefix } = debuggerInfo;
+    const processedReq = {
+      ...req,
+      params: {
+        ...req.params,
+      },
+    };
+    if (processedReq.params.url != null) {
+      const originalUrlParam = processedReq.params.url;
+      const httpUrl = this.#tryParseHTTPURL(originalUrlParam);
+      if (httpUrl) {
+        processedReq.params.url = this.#debuggerRelativeToDeviceRelativeUrl(
+          httpUrl,
+          debuggerInfo,
+        ).href;
+      } else if (
+        originalUrlParam.startsWith(FILE_PREFIX) &&
+        prependedFilePrefix
+      ) {
+        processedReq.params.url = originalUrlParam.slice(FILE_PREFIX.length);
+      }
+    }
+    if (
+      new Set(["10.0.2.2", "10.0.3.2"]).has(
+        this.#deviceRelativeBaseUrl.hostname,
+      ) &&
+      debuggerRelativeBaseUrl.hostname === "localhost" &&
+      processedReq.params.urlRegex != null
+    ) {
+      processedReq.params.urlRegex = processedReq.params.urlRegex.replaceAll(
+        "localhost",
+        this.#deviceRelativeBaseUrl.hostname.replaceAll(".", "\\."),
+      );
+    }
+    return processedReq;
+  }
+  async #processDebuggerGetScriptSource(req, socket, debuggerInfo) {
+    const sendSuccessResponse = (scriptSource) => {
+      const response = {
+        id: req.id,
+        result: {
+          scriptSource,
+        },
+      };
+      socket.send(JSON.stringify(response));
+      const pageId = debuggerInfo.pageId;
+      this.#deviceEventReporter?.logResponse(response, "proxy", {
+        pageId,
+        frontendUserAgent: debuggerInfo.userAgent ?? null,
+      });
+    };
+    const sendErrorResponse = (error) => {
+      const response = {
+        id: req.id,
+        result: {
+          error: {
+            message: error,
+          },
+        },
+      };
+      socket.send(JSON.stringify(response));
+      this.#sendErrorToDebugger(error, debuggerInfo);
+      const pageId = debuggerInfo.pageId;
+      this.#deviceEventReporter?.logResponse(response, "proxy", {
+        pageId,
+        frontendUserAgent: debuggerInfo.userAgent ?? null,
+      });
+    };
+    const pathToSource = this.#scriptIdToSourcePathMapping.get(
+      req.params.scriptId,
+    );
+    try {
+      const httpURL =
+        pathToSource == null ? null : this.#tryParseHTTPURL(pathToSource);
+      if (!httpURL) {
+        throw new Error(
+          `Can't parse requested URL ${pathToSource === undefined ? "undefined" : JSON.stringify(pathToSource)}`,
+        );
+      }
+      const text = await this.#fetchText(httpURL);
+      sendSuccessResponse(text);
+    } catch (err) {
+      sendErrorResponse(
+        `Failed to fetch source url ${pathToSource === undefined ? "undefined" : JSON.stringify(pathToSource)} for scriptId ${req.params.scriptId}: ${err.message}`,
+      );
+    }
+  }
+  #mapToDevicePageId(pageId) {
+    if (
+      pageId === REACT_NATIVE_RELOADABLE_PAGE_ID &&
+      this.#lastConnectedLegacyReactNativePage != null
+    ) {
+      return this.#lastConnectedLegacyReactNativePage.id;
+    } else {
+      return pageId;
+    }
+  }
+  #tryParseHTTPURL(url) {
+    let parsedURL;
+    try {
+      parsedURL = new URL(url);
+    } catch {}
+    const protocol = parsedURL?.protocol;
+    if (protocol !== "http:" && protocol !== "https:") {
+      parsedURL = undefined;
+    }
+    return parsedURL;
+  }
+  async #fetchText(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error("HTTP " + response.status + " " + response.statusText);
+    }
+    const text = await response.text();
+    if (text.length > 350000000) {
+      throw new Error("file too large to fetch via HTTP");
+    }
+    return text;
+  }
+  #sendErrorToDebugger(message, debuggerInfo) {
+    const debuggerSocket = debuggerInfo?.socket;
+    if (debuggerSocket && debuggerSocket.readyState === _ws.default.OPEN) {
+      debuggerSocket.send(
+        JSON.stringify({
+          method: "Runtime.consoleAPICalled",
+          params: {
+            args: [
+              {
+                type: "string",
+                value: message,
+              },
+            ],
+            executionContextId: 0,
+            type: "error",
+          },
+        }),
+      );
+    }
+  }
+  dangerouslyGetSocket() {
+    return this.#deviceSocket;
+  }
+}
+exports.default = Device;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/Device.js.flow

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type { EventReporter } from "../types/EventReporter";
+import type { Experiments } from "../types/Experiments";
+import type { ReadonlyURL } from "../types/ReadonlyURL";
+import type { CreateCustomMessageHandlerFn } from "./CustomMessageHandler";
+import type { Page } from "./types";
+
+import WS from "ws";
+
+// should be aligned with
+// https://github.com/facebook/react-native-devtools-frontend/blob/3d17e0fd462dc698db34586697cce2371b25e0d3/front_end/ui/legacy/components/utils/TargetDetachedDialog.ts#L50-L64
+declare export const WS_CLOSE_REASON: {
+  PAGE_NOT_FOUND: "[PAGE_NOT_FOUND] Debugger page not found",
+  CONNECTION_LOST: "[CONNECTION_LOST] Connection lost to corresponding device",
+  RECREATING_DEVICE: "[RECREATING_DEVICE] Recreating device connection",
+  NEW_DEBUGGER_OPENED: "[NEW_DEBUGGER_OPENED] New debugger opened for the same app instance",
+};
+
+export type DeviceOptions = Readonly<{
+  id: string,
+  name: string,
+  app: string,
+  socket: WS,
+  eventReporter: ?EventReporter,
+  createMessageMiddleware: ?CreateCustomMessageHandlerFn,
+  deviceRelativeBaseUrl: ReadonlyURL,
+  serverRelativeBaseUrl: ReadonlyURL,
+  isProfilingBuild: boolean,
+  experiments: Experiments,
+}>;
+
+/**
+ * Device class represents single device connection to Inspector Proxy. Each device
+ * can have multiple inspectable pages.
+ */
+declare export default class Device {
+  constructor(deviceOptions: DeviceOptions): void;
+  /**
+   * Used to recreate the device connection if there is a device ID collision.
+   * 1. Checks if the same device is attempting to reconnect for the same app.
+   * 2. If not, close both the device and debugger socket.
+   * 3. If the debugger connection can be reused, close the device socket only.
+   *
+   * This hack attempts to allow users to reload the app, either as result of a
+   * crash, or manually reloading, without having to restart the debugger.
+   */
+  dangerouslyRecreateDevice(deviceOptions: DeviceOptions): void;
+  getName(): string;
+  getApp(): string;
+  getPagesList(): ReadonlyArray<Page>;
+  // Handles new debugger connection to this device:
+  // 1. Sends connect event to device
+  // 2. Forwards all messages from the debugger to device as wrappedEvent
+  // 3. Sends disconnect event to device when debugger connection socket closes.
+  handleDebuggerConnection(
+    socket: WS,
+    pageId: string,
+    $$PARAM_2$$: Readonly<{
+      debuggerRelativeBaseUrl: ReadonlyURL,
+      userAgent: string | null,
+    }>,
+  ): void;
+  dangerouslyGetSocket(): WS;
+}

node_modules/@react-native/dev-middleware/dist/inspector-proxy/DeviceEventReporter.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { EventReporter } from "../types/EventReporter";
+import type { CDPResponse } from "./cdp-types/messages";
+import type { DeepReadOnly } from "./types";
+type DeviceMetadata = Readonly<{
+  appId: string;
+  deviceId: string;
+  deviceName: string;
+}>;
+type RequestMetadata = Readonly<{
+  pageId: string | null;
+  frontendUserAgent: string | null;
+}>;
+type ResponseMetadata = Readonly<{
+  pageId: string | null;
+  frontendUserAgent: string | null;
+}>;
+declare class DeviceEventReporter {
+  constructor(eventReporter: EventReporter, metadata: DeviceMetadata);
+  logRequest(
+    req: Readonly<{ id: number; method: string }>,
+    origin: "debugger" | "proxy",
+    metadata: RequestMetadata,
+  ): void;
+  logResponse(
+    res: DeepReadOnly<CDPResponse>,
+    origin: "device" | "proxy",
+    metadata: ResponseMetadata,
+  ): void;
+  logProfilingTargetRegistered(): void;
+  logConnection(
+    connectedEntity: "debugger",
+    metadata: Readonly<{ pageId: string; frontendUserAgent: string | null }>,
+  ): void;
+  logDisconnection(disconnectedEntity: "device" | "debugger"): void;
+  logProxyMessageHandlingError(
+    messageOrigin: "device" | "debugger",
+    error: Error,
+    message: string,
+  ): void;
+}
+export default DeviceEventReporter;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/DeviceEventReporter.js

@@ -0,0 +1,184 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _ttlcache = _interopRequireDefault(require("@isaacs/ttlcache"));
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+class DeviceEventReporter {
+  #eventReporter;
+  #pendingCommands = new _ttlcache.default({
+    ttl: 10000,
+    dispose: (command, id, reason) => {
+      if (reason === "delete" || reason === "set") {
+        return;
+      }
+      this.#logExpiredCommand(command);
+    },
+  });
+  #metadata;
+  #deviceConnectedTimestamp;
+  constructor(eventReporter, metadata) {
+    this.#eventReporter = eventReporter;
+    this.#metadata = metadata;
+    this.#deviceConnectedTimestamp = Date.now();
+  }
+  logRequest(req, origin, metadata) {
+    this.#pendingCommands.set(req.id, {
+      method: req.method,
+      requestOrigin: origin,
+      requestTime: Date.now(),
+      metadata,
+    });
+  }
+  logResponse(res, origin, metadata) {
+    const pendingCommand = this.#pendingCommands.get(res.id);
+    if (!pendingCommand) {
+      this.#eventReporter.logEvent({
+        type: "debugger_command",
+        protocol: "CDP",
+        requestOrigin: null,
+        method: null,
+        status: "coded_error",
+        errorCode: "UNMATCHED_REQUEST_ID",
+        responseOrigin: "proxy",
+        timeSinceStart: null,
+        appId: this.#metadata.appId,
+        deviceId: this.#metadata.deviceId,
+        deviceName: this.#metadata.deviceName,
+        pageId: metadata.pageId,
+        frontendUserAgent: metadata.frontendUserAgent,
+        connectionUptime: this.#deviceConnectedTimestamp - Date.now(),
+      });
+      return;
+    }
+    const timeSinceStart = Date.now() - pendingCommand.requestTime;
+    this.#pendingCommands.delete(res.id);
+    if (res.error) {
+      let { message } = res.error;
+      if ("data" in res.error) {
+        message += ` (${String(res.error.data)})`;
+      }
+      this.#eventReporter.logEvent({
+        type: "debugger_command",
+        requestOrigin: pendingCommand.requestOrigin,
+        method: pendingCommand.method,
+        protocol: "CDP",
+        status: "coded_error",
+        errorCode: "PROTOCOL_ERROR",
+        errorDetails: message,
+        responseOrigin: origin,
+        timeSinceStart,
+        appId: this.#metadata.appId,
+        deviceId: this.#metadata.deviceId,
+        deviceName: this.#metadata.deviceName,
+        pageId: pendingCommand.metadata.pageId,
+        frontendUserAgent: pendingCommand.metadata.frontendUserAgent,
+        connectionUptime: this.#deviceConnectedTimestamp - Date.now(),
+      });
+      return;
+    }
+    this.#eventReporter.logEvent({
+      type: "debugger_command",
+      protocol: "CDP",
+      requestOrigin: pendingCommand.requestOrigin,
+      method: pendingCommand.method,
+      status: "success",
+      responseOrigin: origin,
+      timeSinceStart,
+      appId: this.#metadata.appId,
+      deviceId: this.#metadata.deviceId,
+      deviceName: this.#metadata.deviceName,
+      pageId: pendingCommand.metadata.pageId,
+      frontendUserAgent: pendingCommand.metadata.frontendUserAgent,
+      connectionUptime: this.#deviceConnectedTimestamp - Date.now(),
+    });
+  }
+  logProfilingTargetRegistered() {
+    this.#eventReporter.logEvent({
+      type: "profiling_target_registered",
+      status: "success",
+      appId: this.#metadata.appId,
+      deviceName: this.#metadata.deviceName,
+      deviceId: this.#metadata.deviceId,
+      pageId: null,
+    });
+  }
+  logConnection(connectedEntity, metadata) {
+    this.#eventReporter.logEvent({
+      type: "connect_debugger_frontend",
+      status: "success",
+      appId: this.#metadata.appId,
+      deviceName: this.#metadata.deviceName,
+      deviceId: this.#metadata.deviceId,
+      pageId: metadata.pageId,
+      frontendUserAgent: metadata.frontendUserAgent,
+    });
+  }
+  logDisconnection(disconnectedEntity) {
+    const eventReporter = this.#eventReporter;
+    if (!eventReporter) {
+      return;
+    }
+    const errorCode =
+      disconnectedEntity === "device"
+        ? "DEVICE_DISCONNECTED"
+        : "DEBUGGER_DISCONNECTED";
+    for (const pendingCommand of this.#pendingCommands.values()) {
+      this.#eventReporter.logEvent({
+        type: "debugger_command",
+        protocol: "CDP",
+        requestOrigin: pendingCommand.requestOrigin,
+        method: pendingCommand.method,
+        status: "coded_error",
+        errorCode,
+        responseOrigin: "proxy",
+        timeSinceStart: Date.now() - pendingCommand.requestTime,
+        appId: this.#metadata.appId,
+        deviceId: this.#metadata.deviceId,
+        deviceName: this.#metadata.deviceName,
+        pageId: pendingCommand.metadata.pageId,
+        frontendUserAgent: pendingCommand.metadata.frontendUserAgent,
+        connectionUptime: this.#deviceConnectedTimestamp - Date.now(),
+      });
+    }
+    this.#pendingCommands.clear();
+  }
+  logProxyMessageHandlingError(messageOrigin, error, message) {
+    this.#eventReporter.logEvent({
+      type: "proxy_error",
+      status: "error",
+      messageOrigin,
+      message,
+      error: error.message,
+      errorStack: error.stack,
+      appId: this.#metadata.appId,
+      deviceId: this.#metadata.deviceId,
+      deviceName: this.#metadata.deviceName,
+      pageId: null,
+      connectionUptime: this.#deviceConnectedTimestamp - Date.now(),
+    });
+  }
+  #logExpiredCommand(pendingCommand) {
+    this.#eventReporter.logEvent({
+      type: "debugger_command",
+      protocol: "CDP",
+      requestOrigin: pendingCommand.requestOrigin,
+      method: pendingCommand.method,
+      status: "coded_error",
+      errorCode: "TIMED_OUT",
+      responseOrigin: "proxy",
+      timeSinceStart: Date.now() - pendingCommand.requestTime,
+      appId: this.#metadata.appId,
+      deviceId: this.#metadata.deviceId,
+      deviceName: this.#metadata.deviceName,
+      pageId: pendingCommand.metadata.pageId,
+      frontendUserAgent: pendingCommand.metadata.frontendUserAgent,
+      connectionUptime: this.#deviceConnectedTimestamp - Date.now(),
+    });
+  }
+}
+var _default = (exports.default = DeviceEventReporter);

node_modules/@react-native/dev-middleware/dist/inspector-proxy/DeviceEventReporter.js.flow

@@ -0,0 +1,59 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type { EventReporter } from "../types/EventReporter";
+import type { CDPResponse } from "./cdp-types/messages";
+import type { DeepReadOnly } from "./types";
+
+type DeviceMetadata = Readonly<{
+  appId: string,
+  deviceId: string,
+  deviceName: string,
+}>;
+
+type RequestMetadata = Readonly<{
+  pageId: string | null,
+  frontendUserAgent: string | null,
+}>;
+
+type ResponseMetadata = Readonly<{
+  pageId: string | null,
+  frontendUserAgent: string | null,
+}>;
+
+declare class DeviceEventReporter {
+  constructor(eventReporter: EventReporter, metadata: DeviceMetadata): void;
+  logRequest(
+    req: Readonly<{ id: number, method: string, ... }>,
+    origin: "debugger" | "proxy",
+    metadata: RequestMetadata,
+  ): void;
+  logResponse(
+    res: DeepReadOnly<CDPResponse<>>,
+    origin: "device" | "proxy",
+    metadata: ResponseMetadata,
+  ): void;
+  logProfilingTargetRegistered(): void;
+  logConnection(
+    connectedEntity: "debugger",
+    metadata: Readonly<{
+      pageId: string,
+      frontendUserAgent: string | null,
+    }>,
+  ): void;
+  logDisconnection(disconnectedEntity: "device" | "debugger"): void;
+  logProxyMessageHandlingError(
+    messageOrigin: "device" | "debugger",
+    error: Error,
+    message: string,
+  ): void;
+}
+
+declare export default typeof DeviceEventReporter;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/EventLoopPerfTracker.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
+ */
+
+import type { DebuggerSessionIDs } from "../types/EventReporter";
+export type EventLoopPerfTrackerArgs = {
+  perfMeasurementDuration: number;
+  minDelayPercentToReport: number;
+  onHighDelay: (args: OnHighDelayArgs) => void;
+};
+export type OnHighDelayArgs = {
+  eventLoopUtilization: number;
+  maxEventLoopDelayPercent: number;
+  duration: number;
+  debuggerSessionIDs: DebuggerSessionIDs;
+  connectionUptime: number;
+};
+declare class EventLoopPerfTracker {
+  constructor(args: EventLoopPerfTrackerArgs);
+  trackPerfThrottled(
+    debuggerSessionIDs: DebuggerSessionIDs,
+    connectionUptime: number,
+  ): void;
+}
+export default EventLoopPerfTracker;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/EventLoopPerfTracker.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _perf_hooks = require("perf_hooks");
+var _timers = require("timers");
+class EventLoopPerfTracker {
+  #perfMeasurementDuration;
+  #minDelayPercentToReport;
+  #onHighDelay;
+  #eventLoopPerfMeasurementOngoing;
+  constructor(args) {
+    this.#perfMeasurementDuration = args.perfMeasurementDuration;
+    this.#minDelayPercentToReport = args.minDelayPercentToReport;
+    this.#onHighDelay = args.onHighDelay;
+    this.#eventLoopPerfMeasurementOngoing = false;
+  }
+  trackPerfThrottled(debuggerSessionIDs, connectionUptime) {
+    if (this.#eventLoopPerfMeasurementOngoing) {
+      return;
+    }
+    this.#eventLoopPerfMeasurementOngoing = true;
+    const eluStart = _perf_hooks.performance.eventLoopUtilization();
+    const h = (0, _perf_hooks.monitorEventLoopDelay)({
+      resolution: 20,
+    });
+    h.enable();
+    (0, _timers.setTimeout)(() => {
+      const eluEnd = _perf_hooks.performance.eventLoopUtilization(eluStart);
+      h.disable();
+      const eventLoopUtilization = Math.floor(eluEnd.utilization * 100);
+      const maxEventLoopDelayPercent = Math.floor(
+        (h.max / 1e6 / this.#perfMeasurementDuration) * 100,
+      );
+      if (maxEventLoopDelayPercent >= this.#minDelayPercentToReport) {
+        this.#onHighDelay({
+          eventLoopUtilization,
+          maxEventLoopDelayPercent,
+          duration: this.#perfMeasurementDuration,
+          debuggerSessionIDs,
+          connectionUptime,
+        });
+      }
+      this.#eventLoopPerfMeasurementOngoing = false;
+    }, this.#perfMeasurementDuration).unref();
+  }
+}
+exports.default = EventLoopPerfTracker;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/EventLoopPerfTracker.js.flow

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// $FlowFixMe[cannot-resolve-module] libdef missing in RN OSS
+import type { DebuggerSessionIDs } from "../types/EventReporter";
+
+export type EventLoopPerfTrackerArgs = {
+  perfMeasurementDuration: number,
+  minDelayPercentToReport: number,
+  onHighDelay: (args: OnHighDelayArgs) => void,
+};
+
+export type OnHighDelayArgs = {
+  eventLoopUtilization: number,
+  maxEventLoopDelayPercent: number,
+  duration: number,
+  debuggerSessionIDs: DebuggerSessionIDs,
+  connectionUptime: number,
+};
+
+declare export default class EventLoopPerfTracker {
+  constructor(args: EventLoopPerfTrackerArgs): void;
+  trackPerfThrottled(
+    debuggerSessionIDs: DebuggerSessionIDs,
+    connectionUptime: number,
+  ): void;
+}

node_modules/@react-native/dev-middleware/dist/inspector-proxy/InspectorProxy.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { EventReporter } from "../types/EventReporter";
+import type { Experiments } from "../types/Experiments";
+import type { Logger } from "../types/Logger";
+import type { ReadonlyURL } from "../types/ReadonlyURL";
+import type { CreateCustomMessageHandlerFn } from "./CustomMessageHandler";
+import type { PageDescription } from "./types";
+import type { IncomingMessage, ServerResponse } from "http";
+import WS from "ws";
+export type GetPageDescriptionsConfig = {
+  requestorRelativeBaseUrl: ReadonlyURL;
+  logNoPagesForConnectedDevice?: boolean;
+};
+export interface InspectorProxyQueries {
+  /**
+   * Returns list of page descriptions ordered by device connection order, then
+   * page addition order.
+   */
+  getPageDescriptions(
+    config: GetPageDescriptionsConfig,
+  ): Array<PageDescription>;
+}
+/**
+ * Main Inspector Proxy class that connects JavaScript VM inside Android/iOS apps and JS debugger.
+ */
+declare class InspectorProxy implements InspectorProxyQueries {
+  constructor(
+    serverBaseUrl: ReadonlyURL,
+    eventReporter: null | undefined | EventReporter,
+    experiments: Experiments,
+    logger?: Logger,
+    customMessageHandler: null | undefined | CreateCustomMessageHandlerFn,
+    trackEventLoopPerf?: boolean,
+  );
+  getPageDescriptions(
+    $$PARAM_0$$: GetPageDescriptionsConfig,
+  ): Array<PageDescription>;
+  processRequest(
+    request: IncomingMessage,
+    response: ServerResponse,
+    next: ($$PARAM_0$$: null | undefined | Error) => unknown,
+  ): void;
+  createWebSocketListeners(): { [path: string]: WS.Server };
+}
+export default InspectorProxy;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/InspectorProxy.js

@@ -0,0 +1,509 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _getBaseUrlFromRequest = _interopRequireDefault(
+  require("../utils/getBaseUrlFromRequest"),
+);
+var _getDevToolsFrontendUrl = _interopRequireDefault(
+  require("../utils/getDevToolsFrontendUrl"),
+);
+var _Device = _interopRequireDefault(require("./Device"));
+var _EventLoopPerfTracker = _interopRequireDefault(
+  require("./EventLoopPerfTracker"),
+);
+var _InspectorProxyHeartbeat = _interopRequireDefault(
+  require("./InspectorProxyHeartbeat"),
+);
+var _nullthrows = _interopRequireDefault(require("nullthrows"));
+var _ws = _interopRequireDefault(require("ws"));
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+const debug = require("debug")("Metro:InspectorProxy");
+const WS_DEBUGGER_ALLOWED_ORIGIN_HOSTNAMES = new Set([
+  "localhost",
+  "127.0.0.1",
+  "0.0.0.0",
+  "[::]",
+]);
+const WS_DEVICE_URL = "/inspector/device";
+const WS_DEBUGGER_URL = "/inspector/debug";
+const PAGES_LIST_JSON_URL = "/json";
+const PAGES_LIST_JSON_URL_2 = "/json/list";
+const PAGES_LIST_JSON_VERSION_URL = "/json/version";
+const HEARTBEAT_TIME_BETWEEN_PINGS_MS = 5000;
+const HEARTBEAT_TIMEOUT_MS = 60000;
+const MIN_PING_TO_REPORT = 500;
+const EVENT_LOOP_PERF_MEASUREMENT_MS = 5000;
+const MIN_EVENT_LOOP_DELAY_PERCENT_TO_REPORT = 20;
+const INTERNAL_ERROR_CODE = 1011;
+const INTERNAL_ERROR_MESSAGES = {
+  UNREGISTERED_DEVICE:
+    "[UNREGISTERED_DEVICE] Debugger connection attempted for a device that was not registered",
+  INCORRECT_URL:
+    "[INCORRECT_URL] Incorrect URL - device and page IDs must be provided",
+};
+class InspectorProxy {
+  #serverBaseUrl;
+  #devices;
+  #deviceCounter = 0;
+  #eventReporter;
+  #experiments;
+  #customMessageHandler;
+  #logger;
+  #lastMessageTimestamp = null;
+  #eventLoopPerfTracker;
+  constructor(
+    serverBaseUrl,
+    eventReporter,
+    experiments,
+    logger,
+    customMessageHandler,
+    trackEventLoopPerf = false,
+  ) {
+    this.#serverBaseUrl = serverBaseUrl;
+    this.#devices = new Map();
+    this.#eventReporter = eventReporter;
+    this.#experiments = experiments;
+    this.#logger = logger;
+    this.#customMessageHandler = customMessageHandler;
+    if (trackEventLoopPerf) {
+      this.#eventLoopPerfTracker = new _EventLoopPerfTracker.default({
+        perfMeasurementDuration: EVENT_LOOP_PERF_MEASUREMENT_MS,
+        minDelayPercentToReport: MIN_EVENT_LOOP_DELAY_PERCENT_TO_REPORT,
+        onHighDelay: ({
+          eventLoopUtilization,
+          maxEventLoopDelayPercent,
+          duration,
+          debuggerSessionIDs,
+          connectionUptime,
+        }) => {
+          debug(
+            "[perf] high event loop delay in the last %ds- event loop utilization='%d%' max event loop delay percent='%d%'",
+            duration / 1000,
+            eventLoopUtilization,
+            maxEventLoopDelayPercent,
+          );
+          this.#eventReporter?.logEvent({
+            type: "high_event_loop_delay",
+            eventLoopUtilization,
+            maxEventLoopDelayPercent,
+            duration,
+            connectionUptime,
+            ...debuggerSessionIDs,
+          });
+        },
+      });
+    }
+  }
+  getPageDescriptions({
+    requestorRelativeBaseUrl,
+    logNoPagesForConnectedDevice = false,
+  }) {
+    let result = [];
+    Array.from(this.#devices.entries()).forEach(([deviceId, device]) => {
+      const devicePages = device
+        .getPagesList()
+        .map((page) =>
+          this.#buildPageDescription(
+            deviceId,
+            device,
+            page,
+            requestorRelativeBaseUrl,
+          ),
+        );
+      if (
+        logNoPagesForConnectedDevice &&
+        devicePages.length === 0 &&
+        device.dangerouslyGetSocket()?.readyState === _ws.default.OPEN
+      ) {
+        this.#logger?.warn(
+          `Waiting for a DevTools connection to app='%s' on device='%s'.
+    Try again when the main bundle for the app is built and connection is established.
+    If no connection occurs, try to:
+    - Restart the app. For Android, force stopping the app first might be required.
+    - Ensure a stable connection to the device.
+    - Ensure that the app is built in a mode that supports debugging.
+    - Take the app out of running in the background.`,
+          device.getApp(),
+          device.getName(),
+        );
+        this.#eventReporter?.logEvent({
+          type: "no_debug_pages_for_device",
+          appId: device.getApp(),
+          deviceName: device.getName(),
+          deviceId: deviceId,
+          pageId: null,
+        });
+      }
+      result = result.concat(devicePages);
+    });
+    return result;
+  }
+  processRequest(request, response, next) {
+    const pathname = new URL(request.url, "http://example.com").pathname;
+    if (
+      pathname === PAGES_LIST_JSON_URL ||
+      pathname === PAGES_LIST_JSON_URL_2
+    ) {
+      this.#sendJsonResponse(
+        response,
+        this.getPageDescriptions({
+          requestorRelativeBaseUrl:
+            (0, _getBaseUrlFromRequest.default)(request) ?? this.#serverBaseUrl,
+          logNoPagesForConnectedDevice: true,
+        }),
+      );
+    } else if (pathname === PAGES_LIST_JSON_VERSION_URL) {
+      this.#sendJsonResponse(response, {
+        Browser: "Mobile JavaScript",
+        "Protocol-Version": "1.1",
+      });
+    } else {
+      next();
+    }
+  }
+  createWebSocketListeners() {
+    return {
+      [WS_DEVICE_URL]: this.#createDeviceConnectionWSServer(),
+      [WS_DEBUGGER_URL]: this.#createDebuggerConnectionWSServer(),
+    };
+  }
+  #buildPageDescription(deviceId, device, page, requestorRelativeBaseUrl) {
+    const { host, protocol } = requestorRelativeBaseUrl;
+    const webSocketScheme = protocol === "https:" ? "wss" : "ws";
+    const webSocketUrlWithoutProtocol = `${host}${WS_DEBUGGER_URL}?device=${deviceId}&page=${page.id}`;
+    const webSocketDebuggerUrl = `${webSocketScheme}://${webSocketUrlWithoutProtocol}`;
+    const devtoolsFrontendUrl = (0, _getDevToolsFrontendUrl.default)(
+      this.#experiments,
+      webSocketDebuggerUrl,
+      new URL(this.#serverBaseUrl),
+      {
+        relative: true,
+      },
+    );
+    return {
+      id: `${deviceId}-${page.id}`,
+      title: page.title,
+      description: page.description ?? page.app,
+      appId: page.app,
+      type: "node",
+      devtoolsFrontendUrl,
+      webSocketDebuggerUrl,
+      ...(page.vm != null
+        ? {
+            vm: page.vm,
+          }
+        : null),
+      deviceName: device.getName(),
+      reactNative: {
+        logicalDeviceId: deviceId,
+        capabilities: (0, _nullthrows.default)(page.capabilities),
+      },
+    };
+  }
+  #sendJsonResponse(response, object) {
+    const data = JSON.stringify(object, null, 2);
+    response.writeHead(200, {
+      "Content-Type": "application/json; charset=UTF-8",
+      "Cache-Control": "no-cache",
+      "Content-Length": Buffer.byteLength(data).toString(),
+      Connection: "close",
+    });
+    response.end(data);
+  }
+  #getTimeSinceLastCommunication() {
+    const timestamp = this.#lastMessageTimestamp;
+    return timestamp == null ? null : Date.now() - timestamp;
+  }
+  #onMessageFromDeviceOrDebugger(
+    message,
+    debuggerSessionIDs,
+    connectionUptime,
+  ) {
+    if (message.includes('"event":"getPages"')) {
+      return;
+    }
+    this.#lastMessageTimestamp = Date.now();
+    this.#eventLoopPerfTracker?.trackPerfThrottled(
+      debuggerSessionIDs,
+      connectionUptime,
+    );
+  }
+  #createDeviceConnectionWSServer() {
+    const wss = new _ws.default.Server({
+      noServer: true,
+      perMessageDeflate: true,
+      maxPayload: 0,
+    });
+    wss.on("connection", async (socket, req) => {
+      const wssTimestamp = Date.now();
+      const fallbackDeviceId = String(this.#deviceCounter++);
+      const query = tryParseQueryParams(req.url);
+      const deviceId = query?.get("device") || fallbackDeviceId;
+      const deviceName = query?.get("name") || "Unknown";
+      const appName = query?.get("app") || "Unknown";
+      const isProfilingBuild = query?.get("profiling") === "true";
+      try {
+        const deviceRelativeBaseUrl =
+          (0, _getBaseUrlFromRequest.default)(req) ?? this.#serverBaseUrl;
+        const oldDevice = this.#devices.get(deviceId);
+        let newDevice;
+        const deviceOptions = {
+          id: deviceId,
+          name: deviceName,
+          app: appName,
+          socket,
+          eventReporter: this.#eventReporter,
+          createMessageMiddleware: this.#customMessageHandler,
+          deviceRelativeBaseUrl,
+          serverRelativeBaseUrl: this.#serverBaseUrl,
+          isProfilingBuild,
+          experiments: this.#experiments,
+        };
+        if (oldDevice) {
+          oldDevice.dangerouslyRecreateDevice(deviceOptions);
+          newDevice = oldDevice;
+        } else {
+          newDevice = new _Device.default(deviceOptions);
+        }
+        this.#devices.set(deviceId, newDevice);
+        debug(
+          "Got new device connection: name='%s', app=%s, device=%s, via=%s",
+          deviceName,
+          appName,
+          deviceId,
+          deviceRelativeBaseUrl.origin,
+        );
+        const debuggerSessionIDs = {
+          appId: newDevice?.getApp() || null,
+          deviceId,
+          deviceName: newDevice?.getName() || null,
+          pageId: null,
+        };
+        const heartbeat = new _InspectorProxyHeartbeat.default({
+          socket,
+          timeBetweenPings: HEARTBEAT_TIME_BETWEEN_PINGS_MS,
+          minHighPingToReport: MIN_PING_TO_REPORT,
+          timeoutMs: HEARTBEAT_TIMEOUT_MS,
+          onHighPing: (roundtripDuration) => {
+            debug(
+              "[high ping] [ Device ] %sms for app='%s' on device='%s'",
+              String(roundtripDuration).padStart(5),
+              debuggerSessionIDs.appId,
+              debuggerSessionIDs.deviceName,
+            );
+            this.#eventReporter?.logEvent({
+              type: "device_high_ping",
+              duration: roundtripDuration,
+              timeSinceLastCommunication: this.#getTimeSinceLastCommunication(),
+              connectionUptime: Date.now() - wssTimestamp,
+              ...debuggerSessionIDs,
+            });
+          },
+          onTimeout: (roundtripDuration) => {
+            socket.terminate();
+            this.#logger?.error(
+              "[timeout] connection terminated with Device for app='%s' on device='%s' after not responding for %s seconds.",
+              debuggerSessionIDs.appId ?? "unknown",
+              debuggerSessionIDs.deviceName ?? "unknown",
+              String(roundtripDuration / 1000),
+            );
+            this.#eventReporter?.logEvent({
+              type: "device_timeout",
+              duration: roundtripDuration,
+              timeSinceLastCommunication: this.#getTimeSinceLastCommunication(),
+              connectionUptime: Date.now() - wssTimestamp,
+              ...debuggerSessionIDs,
+            });
+          },
+        });
+        heartbeat.start();
+        socket.on("message", (message) =>
+          this.#onMessageFromDeviceOrDebugger(
+            message.toString(),
+            debuggerSessionIDs,
+            Date.now() - wssTimestamp,
+          ),
+        );
+        socket.on("close", (code, reason) => {
+          debug(
+            "Connection closed to device='%s' for app='%s' with code='%s' and reason='%s'.",
+            deviceName,
+            appName,
+            String(code),
+            reason,
+          );
+          this.#eventReporter?.logEvent({
+            type: "device_connection_closed",
+            code,
+            reason,
+            timeSinceLastCommunication: this.#getTimeSinceLastCommunication(),
+            connectionUptime: Date.now() - wssTimestamp,
+            ...debuggerSessionIDs,
+          });
+          if (this.#devices.get(deviceId)?.dangerouslyGetSocket() === socket) {
+            this.#devices.delete(deviceId);
+          }
+        });
+      } catch (error) {
+        this.#logger?.error(
+          "Connection failed to be established with app='%s' on device='%s' with error:",
+          appName,
+          deviceName,
+          error,
+        );
+        socket.close(INTERNAL_ERROR_CODE, error?.toString() ?? "Unknown error");
+      }
+    });
+    return wss;
+  }
+  #createDebuggerConnectionWSServer() {
+    const wss = new _ws.default.Server({
+      noServer: true,
+      perMessageDeflate: false,
+      maxPayload: 0,
+      verifyClient: (info) => {
+        if (this.#serverBaseUrl.origin === info.origin) {
+          return true;
+        }
+        if (URL.canParse(info.origin)) {
+          const { hostname } = new URL(info.origin);
+          if (WS_DEBUGGER_ALLOWED_ORIGIN_HOSTNAMES.has(hostname)) {
+            return true;
+          }
+        }
+        this.#logger?.error(
+          "Connection from DevTools failed to be established for origin '%s' and path '%s'. Was expecting origin: '%s', or origin hostname to be one of: %s",
+          info.origin,
+          info.req.url,
+          this.#serverBaseUrl.origin,
+          Array.from(WS_DEBUGGER_ALLOWED_ORIGIN_HOSTNAMES).join(", "),
+        );
+        return false;
+      },
+    });
+    wss.on("connection", async (socket, req) => {
+      const wssTimestamp = Date.now();
+      const query = tryParseQueryParams(req.url);
+      const deviceId = query?.get("device") || null;
+      const pageId = query?.get("page") || null;
+      const debuggerRelativeBaseUrl =
+        (0, _getBaseUrlFromRequest.default)(req) ?? this.#serverBaseUrl;
+      const device = deviceId ? this.#devices.get(deviceId) : undefined;
+      const debuggerSessionIDs = {
+        appId: device?.getApp() || null,
+        deviceId,
+        deviceName: device?.getName() || null,
+        pageId,
+      };
+      try {
+        if (deviceId == null || pageId == null) {
+          throw new Error(INTERNAL_ERROR_MESSAGES.INCORRECT_URL);
+        }
+        if (device == null) {
+          throw new Error(INTERNAL_ERROR_MESSAGES.UNREGISTERED_DEVICE);
+        }
+        debug(
+          "Connection established to DevTools for app='%s' on device='%s'.",
+          device.getApp() || "unknown",
+          device.getName() || "unknown",
+        );
+        const heartbeat = new _InspectorProxyHeartbeat.default({
+          socket,
+          timeBetweenPings: HEARTBEAT_TIME_BETWEEN_PINGS_MS,
+          minHighPingToReport: MIN_PING_TO_REPORT,
+          timeoutMs: HEARTBEAT_TIMEOUT_MS,
+          onHighPing: (roundtripDuration) => {
+            debug(
+              "[high ping] [DevTools] %sms for app='%s' on device='%s'",
+              String(roundtripDuration).padStart(5),
+              debuggerSessionIDs.appId,
+              debuggerSessionIDs.deviceName,
+            );
+            this.#eventReporter?.logEvent({
+              type: "debugger_high_ping",
+              duration: roundtripDuration,
+              timeSinceLastCommunication: this.#getTimeSinceLastCommunication(),
+              connectionUptime: Date.now() - wssTimestamp,
+              ...debuggerSessionIDs,
+            });
+          },
+          onTimeout: (roundtripDuration) => {
+            socket.terminate();
+            this.#logger?.error(
+              "[timeout] connection terminated with DevTools for app='%s' on device='%s' after not responding for %s seconds.",
+              debuggerSessionIDs.appId ?? "unknown",
+              debuggerSessionIDs.deviceName ?? "unknown",
+              String(roundtripDuration / 1000),
+            );
+            this.#eventReporter?.logEvent({
+              type: "debugger_timeout",
+              duration: roundtripDuration,
+              timeSinceLastCommunication: this.#getTimeSinceLastCommunication(),
+              connectionUptime: Date.now() - wssTimestamp,
+              ...debuggerSessionIDs,
+            });
+          },
+        });
+        heartbeat.start();
+        socket.on("message", (message) =>
+          this.#onMessageFromDeviceOrDebugger(
+            message.toString(),
+            debuggerSessionIDs,
+            Date.now() - wssTimestamp,
+          ),
+        );
+        device.handleDebuggerConnection(socket, pageId, {
+          debuggerRelativeBaseUrl,
+          userAgent:
+            req.headers["user-agent"] ?? query?.get("userAgent") ?? null,
+        });
+        socket.on("close", (code, reason) => {
+          debug(
+            "Connection closed to DevTools for app='%s' on device='%s' with code='%s' and reason='%s'.",
+            device.getApp() || "unknown",
+            device.getName() || "unknown",
+            String(code),
+            reason,
+          );
+          this.#eventReporter?.logEvent({
+            type: "debugger_connection_closed",
+            code,
+            reason,
+            timeSinceLastCommunication: this.#getTimeSinceLastCommunication(),
+            connectionUptime: Date.now() - wssTimestamp,
+            ...debuggerSessionIDs,
+          });
+        });
+      } catch (error) {
+        this.#logger?.error(
+          "Connection failed to be established with DevTools for app='%s' on device='%s' and device id='%s' with error:",
+          device?.getApp() || "unknown",
+          device?.getName() || "unknown",
+          deviceId || "unknown",
+          error,
+        );
+        socket.close(INTERNAL_ERROR_CODE, error?.toString() ?? "Unknown error");
+        this.#eventReporter?.logEvent({
+          type: "connect_debugger_frontend",
+          status: "error",
+          error,
+          ...debuggerSessionIDs,
+        });
+      }
+    });
+    return wss;
+  }
+}
+exports.default = InspectorProxy;
+function tryParseQueryParams(urlString) {
+  try {
+    return new URL(urlString, "http://example.com").searchParams;
+  } catch {
+    return null;
+  }
+}

node_modules/@react-native/dev-middleware/dist/inspector-proxy/InspectorProxy.js.flow

@@ -0,0 +1,63 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type { EventReporter } from "../types/EventReporter";
+import type { Experiments } from "../types/Experiments";
+import type { Logger } from "../types/Logger";
+import type { ReadonlyURL } from "../types/ReadonlyURL";
+import type { CreateCustomMessageHandlerFn } from "./CustomMessageHandler";
+import type { PageDescription } from "./types";
+import type { IncomingMessage, ServerResponse } from "http";
+
+import WS from "ws";
+
+export type GetPageDescriptionsConfig = {
+  requestorRelativeBaseUrl: ReadonlyURL,
+  logNoPagesForConnectedDevice?: boolean,
+};
+
+export interface InspectorProxyQueries {
+  /**
+   * Returns list of page descriptions ordered by device connection order, then
+   * page addition order.
+   */
+  getPageDescriptions(
+    config: GetPageDescriptionsConfig,
+  ): Array<PageDescription>;
+}
+
+/**
+ * Main Inspector Proxy class that connects JavaScript VM inside Android/iOS apps and JS debugger.
+ */
+declare export default class InspectorProxy implements InspectorProxyQueries {
+  constructor(
+    serverBaseUrl: ReadonlyURL,
+    eventReporter: ?EventReporter,
+    experiments: Experiments,
+    logger?: Logger,
+    customMessageHandler: ?CreateCustomMessageHandlerFn,
+    trackEventLoopPerf?: boolean,
+  ): void;
+  getPageDescriptions(
+    $$PARAM_0$$: GetPageDescriptionsConfig,
+  ): Array<PageDescription>;
+  // Process HTTP request sent to server. We only respond to 2 HTTP requests:
+  // 1. /json/version returns Chrome debugger protocol version that we use
+  // 2. /json and /json/list returns list of page descriptions (list of inspectable apps).
+  // This list is combined from all the connected devices.
+  processRequest(
+    request: IncomingMessage,
+    response: ServerResponse,
+    next: (?Error) => unknown,
+  ): void;
+  createWebSocketListeners(): {
+    [path: string]: WS.Server,
+  };
+}

node_modules/@react-native/dev-middleware/dist/inspector-proxy/InspectorProxyHeartbeat.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import WS from "ws";
+export type HeartbeatTrackerArgs = {
+  socket: WS;
+  timeBetweenPings: number;
+  minHighPingToReport: number;
+  timeoutMs: number;
+  onTimeout: (roundtripDuration: number) => void;
+  onHighPing: (roundtripDuration: number) => void;
+};
+declare class InspectorProxyHeartbeat {
+  constructor(args: HeartbeatTrackerArgs);
+  start(): void;
+}
+export default InspectorProxyHeartbeat;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/InspectorProxyHeartbeat.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _timers = require("timers");
+var _ws = _interopRequireDefault(require("ws"));
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+class InspectorProxyHeartbeat {
+  #socket;
+  #timeBetweenPings;
+  #minHighPingToReport;
+  #timeoutMs;
+  #onTimeout;
+  #onHighPing;
+  constructor(args) {
+    this.#socket = args.socket;
+    this.#timeBetweenPings = args.timeBetweenPings;
+    this.#minHighPingToReport = args.minHighPingToReport;
+    this.#timeoutMs = args.timeoutMs;
+    this.#onTimeout = args.onTimeout;
+    this.#onHighPing = args.onHighPing;
+  }
+  start() {
+    let latestPingMs = Date.now();
+    let terminateTimeout;
+    const pingTimeout = (0, _timers.setTimeout)(() => {
+      if (this.#socket.readyState !== _ws.default.OPEN) {
+        pingTimeout.refresh();
+        return;
+      }
+      if (!terminateTimeout) {
+        terminateTimeout = (0, _timers.setTimeout)(() => {
+          if (this.#socket.readyState !== _ws.default.OPEN) {
+            terminateTimeout?.refresh();
+            return;
+          }
+          this.#onTimeout(this.#timeoutMs);
+        }, this.#timeoutMs).unref();
+      }
+      latestPingMs = Date.now();
+      this.#socket.ping();
+    }, this.#timeBetweenPings).unref();
+    this.#socket.on("pong", () => {
+      const roundtripDuration = Date.now() - latestPingMs;
+      if (roundtripDuration >= this.#minHighPingToReport) {
+        this.#onHighPing(roundtripDuration);
+      }
+      terminateTimeout?.refresh();
+      pingTimeout.refresh();
+    });
+    this.#socket.on("message", () => {
+      terminateTimeout?.refresh();
+    });
+    this.#socket.on("close", (code, reason) => {
+      terminateTimeout && (0, _timers.clearTimeout)(terminateTimeout);
+      (0, _timers.clearTimeout)(pingTimeout);
+    });
+  }
+}
+exports.default = InspectorProxyHeartbeat;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/InspectorProxyHeartbeat.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import WS from "ws";
+
+export type HeartbeatTrackerArgs = {
+  socket: WS,
+  timeBetweenPings: number,
+  minHighPingToReport: number,
+  timeoutMs: number,
+  onTimeout: (roundtripDuration: number) => void,
+  onHighPing: (roundtripDuration: number) => void,
+};
+
+declare export default class InspectorProxyHeartbeat {
+  constructor(args: HeartbeatTrackerArgs): void;
+  start(): void;
+}

node_modules/@react-native/dev-middleware/dist/inspector-proxy/__docs__/README.md

@@ -0,0 +1,324 @@
+# Inspector Proxy Protocol
+
+[🏠 Home](../../../../../__docs__/README.md)
+
+The inspector-proxy protocol facilitates Chrome DevTools Protocol (CDP) target
+discovery and communication between **debuggers** (e.g., Chrome DevTools, VS
+Code) and **devices** (processes containing React Native hosts). The proxy
+multiplexes connections over a single WebSocket per device, allowing multiple
+debuggers to connect to multiple pages on the same device.
+
+## 🚀 Usage
+
+### Target Discovery (HTTP)
+
+We implement a subset of the
+[Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/)'s
+[HTTP endpoints](https://chromedevtools.github.io/devtools-protocol/#:~:text=a%20reconnect%20button.-,HTTP%20Endpoints,-If%20started%20with)
+to allow debuggers to discover targets.
+
+| Endpoint                    | Description              |
+| --------------------------- | ------------------------ |
+| `GET /json` or `/json/list` | List of debuggable pages |
+| `GET /json/version`         | Protocol version info    |
+
+### Device Registration (WebSocket)
+
+Devices register themselves with the proxy by connecting to `/inspector/device`:
+
+```text
+ws://{host}/inspector/device?device={id}&name={name}&app={bundle_id}&profiling={true|false}
+```
+
+| Parameter   | Required | Description                                                  |
+| ----------- | -------- | ------------------------------------------------------------ |
+| `device`    | No\*     | Logical device identifier. Auto-generated if omitted.        |
+| `name`      | No       | Human-readable device name. Defaults to "Unknown".           |
+| `app`       | No       | App bundle identifier. Defaults to "Unknown".                |
+| `profiling` | No       | "true" if this is a profiling build. (Used for logging only) |
+
+\*Recommended for connection persistence across app restarts.
+
+#### Requirements for the `device` parameter
+
+The intent of the logical device ID is to help with target discovery and
+especially *re*discovery - to reduce the number of times users need to
+explicitly close and restart the debugger frontend (e.g. after an app crash).
+
+If provided, the logical device ID:
+
+1. SHOULD be stable for the current combination of physical device (or emulator
+   instance) and app.
+2. SHOULD be stable across installs/launches of the same app on the same device
+   (or emulator instance), though it MAY be user-resettable (so as to not
+   require any special privacy permissions).
+3. MUST be unique across different apps on the same physical device (or
+   emulator).
+4. MUST be unique across physical devices (or emulators).
+5. MUST be unique for each concurrent _instance_ of the same app on the same
+   physical device (or emulator).
+
+NOTE: The uniqueness requirements are stronger (MUST) than the stability
+requirements (SHOULD). In particular, on platforms that allow multiple instances
+of the same app to run concurrently, requirements 1 and/or 2 MAY be violated in
+order to meet requirement 5. This is relevant, for example, on desktop
+platforms.
+
+### Debugger Connection (WebSocket)
+
+Debuggers connect to `/inspector/debug` to form a CDP session with a page:
+
+```text
+ws://{host}/inspector/debug?device={device_id}&page={page_id}
+```
+
+Both `device` and `page` query parameters are required.
+
+## 📐 Design
+
+### Architecture
+
+```text
+┌─────────────────┐     ┌─────────────────────────┐     ┌────────────────┐
+│    Debugger     │────▶│    Inspector Proxy      │◀────│     Device     │
+│ (Chrome/VSCode) │     │      (Node.js)          │     │ (iOS/Android)  │
+└─────────────────┘     └─────────────────────────┘     └────────────────┘
+   WebSocket               HTTP + WebSocket               WebSocket
+   /inspector/debug        /json, /json/list              /inspector/device
+                           /json/version
+```
+
+### Device ↔ Proxy Protocol
+
+All messages are JSON-encoded WebSocket text frames:
+
+```typescript
+interface Message {
+  event: string;
+  payload?: /* depends on event */;
+}
+```
+
+#### Proxy → Device Messages
+
+| Event          | Payload                                                       | Description                                   |
+| -------------- | ------------------------------------------------------------- | --------------------------------------------- |
+| `getPages`     | _(none)_                                                      | Request current page list. Sent periodically. |
+| `connect`      | `{ pageId: string, sessionId: string }`                       | Prepare for debugger connection to page.      |
+| `disconnect`   | `{ pageId: string, sessionId: string }`                       | Terminate debugger session for page.          |
+| `wrappedEvent` | `{ pageId: string, sessionId: string, wrappedEvent: string }` | Forward CDP message (JSON string) to page.    |
+
+#### Device → Proxy Messages
+
+| Event          | Payload                                                        | Description                                           |
+| -------------- | -------------------------------------------------------------- | ----------------------------------------------------- |
+| `getPages`     | `Page[]`                                                       | Current list of inspectable pages.                    |
+| `disconnect`   | `{ pageId: string, sessionId?: string }`                       | Notify that page disconnected or rejected connection. |
+| `wrappedEvent` | `{ pageId: string, sessionId?: string, wrappedEvent: string }` | Forward CDP message (JSON string) from page.          |
+
+#### Page Object
+
+```typescript
+interface Page {
+  id: string; // Unique page identifier (typically numeric string)
+  title: string; // Display title
+  app: string; // App bundle identifier
+  description?: string; // Additional description
+  capabilities?: {
+    nativePageReloads?: boolean; // Target keeps the socket open across reloads
+    nativeSourceCodeFetching?: boolean; // Target supports Network.loadNetworkResource
+    supportsMultipleDebuggers?: boolean; // Supports concurrent debugger sessions
+  };
+}
+```
+
+**Note**: The value of `supportsMultipleDebuggers` SHOULD be consistent across
+all pages for a given device.
+
+### Connection Lifecycle
+
+**Device Registration:**
+
+```text
+Device                              Proxy
+   │                                  │
+   │──── WS Connect ─────────────────▶│
+   │     /inspector/device?...        │
+   │                                  │
+   │◀──── getPages ───────────────────│  (periodically)
+   │                                  │
+   │───── getPages response ─────────▶│
+   │      (page list)                 │
+```
+
+**Debugger Session:**
+
+```text
+Debugger            Proxy                        Device
+   │                  │                            │
+   │── WS Connect ───▶│                            │
+   │   ?device&page   │── connect ────────────────▶│
+   │                  │   {pageId, sessionId}      │
+   │                  │                            │
+   │── CDP Request ──▶│── wrappedEvent ───────────▶│
+   │                  │   {pageId, sessionId,      │
+   │                  │    wrappedEvent}           │
+   │                  │                            │
+   │                  │◀── wrappedEvent ───────────│
+   │◀── CDP Response ─│   {pageId, sessionId,      │
+   │                  │    wrappedEvent}           │
+   │                  │                            │
+   │── WS Close ─────▶│── disconnect ─────────────▶│
+   │                  │   {pageId, sessionId}      │
+```
+
+**Connection Rejection:**
+
+If a device cannot accept a `connect` (e.g., page doesn't exist), it should send
+a `disconnect` back to the proxy for that `pageId`.
+
+### Connection Semantics
+
+#### Multi-Debugger Support
+
+Multiple debuggers can connect simultaneously to the same page when **both** the
+proxy and device support session multiplexing:
+
+1. **Session IDs**: The proxy assigns a unique, non-empty `sessionId` to each
+   debugger connection. All messages include this `sessionId` for routing. This
+   SHOULD be a UUID or other suitably unique and ephemeral identifier.
+
+2. **Capability Detection**: Devices report `supportsMultipleDebuggers: true` in
+   their page capabilities to indicate session support.
+
+3. **Backwards Compatibility**: Legacy devices ignore `sessionId` fields in
+   incoming messages and don't include them in responses.
+
+#### Connection Rules
+
+1. **Session-Capable Device**: Multiple debuggers can connect to the same page
+   simultaneously. Each connection has an independent session.
+
+2. **Legacy Device (no `supportsMultipleDebuggers`)**: New debugger connections
+   to an already-connected page disconnect the existing debugger. The proxy MUST
+   NOT allow multiple debuggers to connect to the same page.
+
+3. **Device Reconnection**: If a device reconnects with the same `device` ID
+   while debugger connections to the same logical device are open in the proxy,
+   the proxy may attempt to preserve active debugger sessions by forwarding them
+   to the new device.
+
+### WebSocket Close Reasons
+
+The proxy uses specific close reasons that DevTools frontends may recognize:
+
+| Reason                  | Context                                 |
+| ----------------------- | --------------------------------------- |
+| `[PAGE_NOT_FOUND]`      | Debugger connected to non-existent page |
+| `[CONNECTION_LOST]`     | Device disconnected                     |
+| `[RECREATING_DEVICE]`   | Device is reconnecting                  |
+| `[NEW_DEBUGGER_OPENED]` | Another debugger took over this page    |
+| `[UNREGISTERED_DEVICE]` | Device ID not found                     |
+| `[INCORRECT_URL]`       | Missing device/page query parameters    |
+
+### PageDescription (HTTP Response)
+
+The `/json` endpoint returns enriched page descriptions based on those reported
+by the device.
+
+```typescript
+interface PageDescription {
+  // Used for target selection
+  id: string; // "{deviceId}-{pageId}"
+
+  // Used for display
+  title: string;
+  description: string;
+  deviceName: string;
+
+  // Used for target matching
+  appId: string;
+
+  // Used for debugger connection
+  webSocketDebuggerUrl: string;
+
+  // React Native-specific metadata
+  reactNative: {
+    logicalDeviceId: string; // Used for target matching
+    capabilities: {
+      nativePageReloads?: boolean; // Used for target filtering
+    };
+  };
+}
+```
+
+## 🔗 Relationship with other systems
+
+### Part of this
+
+- **Device.js** - Per-device connection handler in the proxy
+- **InspectorProxy.js** - Main proxy HTTP/WebSocket server
+
+### Used by this
+
+- **Chrome DevTools Protocol (CDP)** - The wrapped messages are CDP messages
+  exchanged between DevTools frontends and JavaScript runtimes.
+- **WebSocket** - Transport layer for device and debugger connections.
+
+### Uses this
+
+- **InspectorPackagerConnection (C++)** - Shared device-side protocol
+  implementation in `ReactCommon/jsinspector-modern/`.
+- **Platform layers** - iOS (`RCTInspectorDevServerHelper.mm`), Android
+  (`DevServerHelper.kt`), and ReactCxxPlatform (`Inspector.cpp`) provide
+  WebSocket I/O and threading.
+- **openDebuggerMiddleware** - Uses `/json` to discover targets for the
+  `/open-debugger` endpoint.
+- **OpenDebuggerKeyboardHandler** - Uses `/json` to display target selection in
+  the CLI.
+
+---
+
+## Legacy Features
+
+The following features exist for backward compatibility with older React Native
+targets that lack modern capabilities. New implementations should set
+appropriate capability flags and may ignore this section.
+
+### Synthetic Reloadable Page (Page ID `-1`)
+
+For targets without the `nativePageReloads` capability, the proxy exposes a
+synthetic page with ID `-1` titled "React Native Experimental (Improved Chrome
+Reloads)". Debuggers connecting to this page are automatically redirected to the
+most recent React Native page, surviving page reloads.
+
+When a new React Native page appears while a debugger is connected to `-1`:
+
+1. Proxy sends `disconnect` for the old page, `connect` for the new page
+2. Proxy sends `Runtime.enable` and `Debugger.enable` CDP commands to the new
+   page
+3. When `Runtime.executionContextCreated` is received, proxy sends
+   `Runtime.executionContextsCleared` to debugger, then `Debugger.resume` to
+   device
+
+### URL Rewriting
+
+For targets without the `nativeSourceCodeFetching` capability, the proxy
+rewrites URLs in CDP messages:
+
+- **Debugger.scriptParsed** (device → debugger): Device-relative URLs are
+  rewritten to debugger-relative URLs
+- **Debugger.setBreakpointByUrl** (debugger → device): URLs are rewritten back
+  to device-relative form
+- **Debugger.getScriptSource**: Intercepted and handled by proxy via HTTP fetch
+- **Network.loadNetworkResource**: Returns CDP error (code -32601) to force
+  frontend fallback
+
+Additionally, if a script URL matches `^[0-9a-z]+$` (alphanumeric ID), the proxy
+prepends `file://` to ensure Chrome downloads source maps.
+
+### Legacy Reload Notification
+
+For targets without `nativePageReloads`, when a `disconnect` event is received
+for a page, the proxy sends `{method: 'reload'}` to the connected debugger to
+signal a page reload.

node_modules/@react-native/dev-middleware/dist/inspector-proxy/cdp-types/messages.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { JSONSerializable } from "../types";
+import type { Commands, Events } from "./protocol";
+export type CDPEvent<TEvent extends keyof Events = "unknown"> = {
+  method: TEvent;
+  params: Events[TEvent];
+};
+export type CDPRequest<TCommand extends keyof Commands = "unknown"> = {
+  method: TCommand;
+  params: Commands[TCommand]["paramsType"];
+  id: number;
+};
+export type CDPResponse<TCommand extends keyof Commands = "unknown"> =
+  | { result: Commands[TCommand]["resultType"]; id: number }
+  | { error: CDPRequestError; id: number };
+export type CDPRequestError = {
+  code: number;
+  message: string;
+  data?: JSONSerializable;
+};
+export type CDPClientMessage =
+  | CDPRequest<"Debugger.getScriptSource">
+  | CDPRequest<"Debugger.scriptParsed">
+  | CDPRequest<"Debugger.setBreakpointByUrl">
+  | CDPRequest<"Network.loadNetworkResource">
+  | CDPRequest;
+export type CDPServerMessage =
+  | CDPEvent<"Debugger.scriptParsed">
+  | CDPEvent<"Runtime.consoleAPICalled">
+  | CDPEvent
+  | CDPResponse<"Debugger.getScriptSource">
+  | CDPResponse;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/cdp-types/messages.js

@@ -0,0 +1 @@
+"use strict";

node_modules/@react-native/dev-middleware/dist/inspector-proxy/cdp-types/messages.js.flow

@@ -0,0 +1,54 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type { JSONSerializable } from "../types";
+import type { Commands, Events } from "./protocol";
+
+// Note: A CDP event is a JSON-RPC notification with no `id` member.
+export type CDPEvent<TEvent: keyof Events = "unknown"> = {
+  method: TEvent,
+  params: Events[TEvent],
+};
+
+export type CDPRequest<TCommand: keyof Commands = "unknown"> = {
+  method: TCommand,
+  params: Commands[TCommand]["paramsType"],
+  id: number,
+};
+
+export type CDPResponse<TCommand: keyof Commands = "unknown"> =
+  | {
+      result: Commands[TCommand]["resultType"],
+      id: number,
+    }
+  | {
+      error: CDPRequestError,
+      id: number,
+    };
+
+export type CDPRequestError = {
+  code: number,
+  message: string,
+  data?: JSONSerializable,
+};
+
+export type CDPClientMessage =
+  | CDPRequest<"Debugger.getScriptSource">
+  | CDPRequest<"Debugger.scriptParsed">
+  | CDPRequest<"Debugger.setBreakpointByUrl">
+  | CDPRequest<"Network.loadNetworkResource">
+  | CDPRequest<>;
+
+export type CDPServerMessage =
+  | CDPEvent<"Debugger.scriptParsed">
+  | CDPEvent<"Runtime.consoleAPICalled">
+  | CDPEvent<>
+  | CDPResponse<"Debugger.getScriptSource">
+  | CDPResponse<>;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/cdp-types/protocol.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { JSONSerializable } from "../types";
+type integer = number;
+export interface Debugger {
+  GetScriptSourceParams: {
+    /**
+     * Id of the script to get source for.
+     */
+    scriptId: string;
+  };
+  GetScriptSourceResult: {
+    /**
+     * Script source (empty in case of Wasm bytecode).
+     */
+    scriptSource: string;
+    /**
+     * Wasm bytecode. (Encoded as a base64 string when passed over JSON)
+     */
+    bytecode?: string;
+  };
+  SetBreakpointByUrlParams: {
+    /**
+     * Line number to set breakpoint at.
+     */
+    lineNumber: integer;
+    /**
+     * URL of the resources to set breakpoint on.
+     */
+    url?: string;
+    /**
+     * Regex pattern for the URLs of the resources to set breakpoints on. Either `url` or
+     * `urlRegex` must be specified.
+     */
+    urlRegex?: string;
+    /**
+     * Script hash of the resources to set breakpoint on.
+     */
+    scriptHash?: string;
+    /**
+     * Offset in the line to set breakpoint at.
+     */
+    columnNumber?: integer;
+    /**
+     * Expression to use as a breakpoint condition. When specified, debugger will only stop on the
+     * breakpoint if this expression evaluates to true.
+     */
+    condition?: string;
+  };
+  ScriptParsedEvent: {
+    /**
+     * Identifier of the script parsed.
+     */
+    scriptId: string;
+    /**
+     * URL or name of the script parsed (if any).
+     */
+    url: string;
+    /**
+     * URL of source map associated with script (if any).
+     */
+    sourceMapURL: string;
+  };
+  ConsoleAPICalled: {
+    args: Array<{ type: string; value: string }>;
+    executionContextId: number;
+    stackTrace: {
+      timestamp: number;
+      type: string;
+      callFrames: Array<{
+        columnNumber: number;
+        lineNumber: number;
+        functionName: string;
+        scriptId: string;
+        url: string;
+      }>;
+    };
+  };
+}
+export type Events = {
+  "Debugger.scriptParsed": Debugger["ScriptParsedEvent"];
+  "Runtime.consoleAPICalled": Debugger["ConsoleAPICalled"];
+  [method: string]: JSONSerializable;
+};
+export type Commands = {
+  "Debugger.getScriptSource": {
+    paramsType: Debugger["GetScriptSourceParams"];
+    resultType: Debugger["GetScriptSourceResult"];
+  };
+  "Debugger.setBreakpointByUrl": {
+    paramsType: Debugger["SetBreakpointByUrlParams"];
+    resultType: void;
+  };
+  [method: string]: {
+    paramsType: JSONSerializable;
+    resultType: JSONSerializable;
+  };
+};

node_modules/@react-native/dev-middleware/dist/inspector-proxy/cdp-types/protocol.js

@@ -0,0 +1 @@
+"use strict";

node_modules/@react-native/dev-middleware/dist/inspector-proxy/cdp-types/protocol.js.flow

@@ -0,0 +1,124 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// Adapted from https://github.com/ChromeDevTools/devtools-protocol/blob/master/types/protocol.d.ts
+
+import type { JSONSerializable } from "../types";
+
+type integer = number;
+
+export interface Debugger {
+  GetScriptSourceParams: {
+    /**
+     * Id of the script to get source for.
+     */
+    scriptId: string,
+  };
+
+  GetScriptSourceResult: {
+    /**
+     * Script source (empty in case of Wasm bytecode).
+     */
+    scriptSource: string,
+
+    /**
+     * Wasm bytecode. (Encoded as a base64 string when passed over JSON)
+     */
+    bytecode?: string,
+  };
+
+  SetBreakpointByUrlParams: {
+    /**
+     * Line number to set breakpoint at.
+     */
+    lineNumber: integer,
+
+    /**
+     * URL of the resources to set breakpoint on.
+     */
+    url?: string,
+
+    /**
+     * Regex pattern for the URLs of the resources to set breakpoints on. Either `url` or
+     * `urlRegex` must be specified.
+     */
+    urlRegex?: string,
+
+    /**
+     * Script hash of the resources to set breakpoint on.
+     */
+    scriptHash?: string,
+
+    /**
+     * Offset in the line to set breakpoint at.
+     */
+    columnNumber?: integer,
+
+    /**
+     * Expression to use as a breakpoint condition. When specified, debugger will only stop on the
+     * breakpoint if this expression evaluates to true.
+     */
+    condition?: string,
+  };
+
+  ScriptParsedEvent: {
+    /**
+     * Identifier of the script parsed.
+     */
+    scriptId: string,
+
+    /**
+     * URL or name of the script parsed (if any).
+     */
+    url: string,
+
+    /**
+     * URL of source map associated with script (if any).
+     */
+    sourceMapURL: string,
+  };
+
+  ConsoleAPICalled: {
+    args: Array<{ type: string, value: string }>,
+    executionContextId: number,
+    stackTrace: {
+      timestamp: number,
+      type: string,
+      callFrames: Array<{
+        columnNumber: number,
+        lineNumber: number,
+        functionName: string,
+        scriptId: string,
+        url: string,
+      }>,
+    },
+  };
+}
+
+export type Events = {
+  "Debugger.scriptParsed": Debugger["ScriptParsedEvent"],
+  "Runtime.consoleAPICalled": Debugger["ConsoleAPICalled"],
+  [method: string]: JSONSerializable,
+};
+
+export type Commands = {
+  "Debugger.getScriptSource": {
+    paramsType: Debugger["GetScriptSourceParams"],
+    resultType: Debugger["GetScriptSourceResult"],
+  },
+  "Debugger.setBreakpointByUrl": {
+    paramsType: Debugger["SetBreakpointByUrlParams"],
+    resultType: void,
+  },
+  [method: string]: {
+    paramsType: JSONSerializable,
+    resultType: JSONSerializable,
+  },
+};

node_modules/@react-native/dev-middleware/dist/inspector-proxy/types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * 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
+ */
+
+/**
+ * A capability flag disables a specific feature/hack in the InspectorProxy
+ * layer by indicating that the target supports one or more modern CDP features.
+ */
+export type TargetCapabilityFlags = Readonly<{
+  /**
+   * The target supports a stable page representation across reloads.
+   *
+   * In the proxy, this disables legacy page reload emulation and the
+   * additional 'React Native Experimental' target in `/json/list`.
+   *
+   * In the launch flow, this allows targets to be matched directly by
+   * `logicalDeviceId`.
+   */
+  nativePageReloads?: boolean;
+  /**
+   * The target supports fetching source code and source maps.
+   *
+   * In the proxy, this disables source fetching emulation and host rewrites.
+   */
+  nativeSourceCodeFetching?: boolean;
+  /**
+   * The target supports multiple concurrent debugger connections.
+   *
+   * When true, the proxy allows multiple debuggers to connect to the same
+   * page simultaneously, each identified by a unique session ID.
+   * When false (default/legacy), connecting a new debugger disconnects
+   * any existing debugger connection to that page.
+   */
+  supportsMultipleDebuggers?: boolean;
+}>;
+export type PageFromDevice = Readonly<{
+  id: string;
+  title: string;
+  /** Sent from modern targets only */
+  description?: string;
+  /** @deprecated This is sent from legacy targets only */
+  vm?: string;
+  app: string;
+  capabilities?: TargetCapabilityFlags;
+}>;
+export type Page = Readonly<
+  Omit<
+    PageFromDevice,
+    keyof { capabilities: NonNullable<PageFromDevice["capabilities"]> }
+  > & { capabilities: NonNullable<PageFromDevice["capabilities"]> }
+>;
+export type WrappedEventFromDevice = Readonly<{
+  event: "wrappedEvent";
+  payload: Readonly<{
+    pageId: string;
+    wrappedEvent: string;
+    sessionId?: string;
+  }>;
+}>;
+export type WrappedEventToDevice = Readonly<{
+  event: "wrappedEvent";
+  payload: Readonly<{
+    pageId: string;
+    wrappedEvent: string;
+    sessionId: string;
+  }>;
+}>;
+export type ConnectRequest = Readonly<{
+  event: "connect";
+  payload: Readonly<{ pageId: string; sessionId: string }>;
+}>;
+export type DisconnectRequest = Readonly<{
+  event: "disconnect";
+  payload: Readonly<{ pageId: string; sessionId: string }>;
+}>;
+export type GetPagesRequest = { event: "getPages" };
+export type GetPagesResponse = {
+  event: "getPages";
+  payload: ReadonlyArray<PageFromDevice>;
+};
+export type MessageFromDevice =
+  | GetPagesResponse
+  | WrappedEventFromDevice
+  | DisconnectRequest;
+export type MessageToDevice =
+  | GetPagesRequest
+  | WrappedEventToDevice
+  | ConnectRequest
+  | DisconnectRequest;
+export type PageDescription = Readonly<{
+  id: string;
+  title: string;
+  appId: string;
+  description: string;
+  type: string;
+  devtoolsFrontendUrl: string;
+  webSocketDebuggerUrl: string;
+  /** @deprecated Prefer `title` */
+  deviceName: string;
+  /** @deprecated This is sent from legacy targets only */
+  vm?: string;
+  reactNative: Readonly<{
+    logicalDeviceId: string;
+    capabilities: Page["capabilities"];
+  }>;
+}>;
+export type JsonPagesListResponse = Array<PageDescription>;
+export type JsonVersionResponse = Readonly<{
+  Browser: string;
+  "Protocol-Version": string;
+}>;
+export type JSONSerializable =
+  | boolean
+  | number
+  | string
+  | null
+  | ReadonlyArray<JSONSerializable>
+  | { readonly [$$Key$$: string]: JSONSerializable };
+export type DeepReadOnly<T> =
+  T extends ReadonlyArray<infer V>
+    ? ReadonlyArray<DeepReadOnly<V>>
+    : T extends {}
+      ? { readonly [K in keyof T]: DeepReadOnly<T[K]> }
+      : T;

node_modules/@react-native/dev-middleware/dist/inspector-proxy/types.js

@@ -0,0 +1 @@
+"use strict";

node_modules/@react-native/dev-middleware/dist/inspector-proxy/types.js.flow

@@ -0,0 +1,166 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+/**
+ * A capability flag disables a specific feature/hack in the InspectorProxy
+ * layer by indicating that the target supports one or more modern CDP features.
+ */
+export type TargetCapabilityFlags = Readonly<{
+  /**
+   * The target supports a stable page representation across reloads.
+   *
+   * In the proxy, this disables legacy page reload emulation and the
+   * additional 'React Native Experimental' target in `/json/list`.
+   *
+   * In the launch flow, this allows targets to be matched directly by
+   * `logicalDeviceId`.
+   */
+  nativePageReloads?: boolean,
+
+  /**
+   * The target supports fetching source code and source maps.
+   *
+   * In the proxy, this disables source fetching emulation and host rewrites.
+   */
+  nativeSourceCodeFetching?: boolean,
+
+  /**
+   * The target supports multiple concurrent debugger connections.
+   *
+   * When true, the proxy allows multiple debuggers to connect to the same
+   * page simultaneously, each identified by a unique session ID.
+   * When false (default/legacy), connecting a new debugger disconnects
+   * any existing debugger connection to that page.
+   */
+  supportsMultipleDebuggers?: boolean,
+}>;
+
+// Page information received from the device. New page is created for
+// each new instance of VM and can appear when user reloads React Native
+// application.
+
+export type PageFromDevice = Readonly<{
+  id: string,
+  title: string,
+  /** Sent from modern targets only */
+  description?: string,
+  /** @deprecated This is sent from legacy targets only */
+  vm?: string,
+  app: string,
+  capabilities?: TargetCapabilityFlags,
+}>;
+
+export type Page = Readonly<{
+  ...PageFromDevice,
+  capabilities: NonNullable<PageFromDevice["capabilities"]>,
+}>;
+
+// Chrome Debugger Protocol message/event passed from device to proxy.
+export type WrappedEventFromDevice = Readonly<{
+  event: "wrappedEvent",
+  payload: Readonly<{
+    pageId: string,
+    wrappedEvent: string,
+    sessionId?: string,
+  }>,
+}>;
+
+// Chrome Debugger Protocol message/event passed from proxy to device.
+export type WrappedEventToDevice = Readonly<{
+  event: "wrappedEvent",
+  payload: Readonly<{
+    pageId: string,
+    wrappedEvent: string,
+    sessionId: string,
+  }>,
+}>;
+
+// Request sent from Inspector Proxy to Device when new debugger is connected
+// to particular page.
+export type ConnectRequest = Readonly<{
+  event: "connect",
+  payload: Readonly<{ pageId: string, sessionId: string }>,
+}>;
+
+// Request sent from Inspector Proxy to Device to notify that debugger is
+// disconnected.
+export type DisconnectRequest = Readonly<{
+  event: "disconnect",
+  payload: Readonly<{ pageId: string, sessionId: string }>,
+}>;
+
+// Request sent from Inspector Proxy to Device to get a list of pages.
+export type GetPagesRequest = { event: "getPages" };
+
+// Response to GetPagesRequest containing a list of page infos.
+export type GetPagesResponse = {
+  event: "getPages",
+  payload: ReadonlyArray<PageFromDevice>,
+};
+
+// Union type for all possible messages sent from device to Inspector Proxy.
+export type MessageFromDevice =
+  | GetPagesResponse
+  | WrappedEventFromDevice
+  | DisconnectRequest;
+
+// Union type for all possible messages sent from Inspector Proxy to device.
+export type MessageToDevice =
+  | GetPagesRequest
+  | WrappedEventToDevice
+  | ConnectRequest
+  | DisconnectRequest;
+
+// Page description object that is sent in response to /json HTTP request from debugger.
+export type PageDescription = Readonly<{
+  id: string,
+  title: string,
+  appId: string,
+  description: string,
+  type: string,
+  devtoolsFrontendUrl: string,
+  webSocketDebuggerUrl: string,
+
+  // React Native specific fields
+  /** @deprecated Prefer `title` */
+  deviceName: string,
+  /** @deprecated This is sent from legacy targets only */
+  vm?: string,
+
+  // React Native specific metadata
+  reactNative: Readonly<{
+    logicalDeviceId: string,
+    capabilities: Page["capabilities"],
+  }>,
+}>;
+
+export type JsonPagesListResponse = Array<PageDescription>;
+
+// Response to /json/version HTTP request from the debugger specifying browser type and
+// Chrome protocol version.
+export type JsonVersionResponse = Readonly<{
+  Browser: string,
+  "Protocol-Version": string,
+}>;
+
+export type JSONSerializable =
+  | boolean
+  | number
+  | string
+  | null
+  | ReadonlyArray<JSONSerializable>
+  | { +[string]: JSONSerializable };
+
+export type DeepReadOnly<T> =
+  T extends ReadonlyArray<infer V>
+    ? ReadonlyArray<DeepReadOnly<V>>
+    : T extends { ... }
+      ? { +[K in keyof T]: DeepReadOnly<T[K]> }
+      : T;

node_modules/@react-native/dev-middleware/dist/middleware/openDebuggerMiddleware.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { InspectorProxyQueries } from "../inspector-proxy/InspectorProxy";
+import type { DevToolLauncher } from "../types/DevToolLauncher";
+import type { EventReporter } from "../types/EventReporter";
+import type { Experiments } from "../types/Experiments";
+import type { Logger } from "../types/Logger";
+import type { ReadonlyURL } from "../types/ReadonlyURL";
+import type { NextHandleFunction } from "connect";
+type Options = Readonly<{
+  serverBaseUrl: ReadonlyURL;
+  logger?: Logger;
+  toolLauncher: DevToolLauncher;
+  eventReporter?: EventReporter;
+  experiments: Experiments;
+  inspectorProxy: InspectorProxyQueries;
+}>;
+/**
+ * Open the debugger frontend for a given CDP target.
+ *
+ * @see https://chromedevtools.github.io/devtools-protocol/
+ */
+declare function openDebuggerMiddleware(
+  $$PARAM_0$$: Options,
+): NextHandleFunction;
+export default openDebuggerMiddleware;

node_modules/@react-native/dev-middleware/dist/middleware/openDebuggerMiddleware.js

@@ -0,0 +1,206 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = openDebuggerMiddleware;
+var _getDevToolsFrontendUrl = _interopRequireDefault(
+  require("../utils/getDevToolsFrontendUrl"),
+);
+var _crypto = require("crypto");
+function _interopRequireDefault(e) {
+  return e && e.__esModule ? e : { default: e };
+}
+const LEGACY_SYNTHETIC_PAGE_TITLE =
+  "React Native Experimental (Improved Chrome Reloads)";
+function openDebuggerMiddleware({
+  serverBaseUrl,
+  logger,
+  toolLauncher,
+  eventReporter,
+  experiments,
+  inspectorProxy,
+}) {
+  let shellPreparationPromise;
+  if (experiments.enableStandaloneFuseboxShell) {
+    shellPreparationPromise =
+      toolLauncher?.prepareDebuggerShell?.() ??
+      Promise.resolve({
+        code: "not_implemented",
+      });
+    shellPreparationPromise = shellPreparationPromise.then((result) => {
+      eventReporter?.logEvent({
+        type: "fusebox_shell_preparation_attempt",
+        result,
+      });
+      return result;
+    });
+  }
+  return async (req, res, next) => {
+    if (
+      req.method === "POST" ||
+      (experiments.enableOpenDebuggerRedirect && req.method === "GET")
+    ) {
+      const { searchParams } = new URL(req.url, "http://example.com");
+      const query = Object.fromEntries(searchParams);
+      const targets = inspectorProxy
+        .getPageDescriptions({
+          requestorRelativeBaseUrl: serverBaseUrl,
+        })
+        .filter((app) => {
+          const betterReloadingSupport =
+            app.title === LEGACY_SYNTHETIC_PAGE_TITLE ||
+            app.reactNative.capabilities?.nativePageReloads === true;
+          if (!betterReloadingSupport) {
+            logger?.warn(
+              "Ignoring DevTools app debug target for '%s' with title '%s' and 'nativePageReloads' capability set to '%s'. ",
+              app.appId,
+              app.title,
+              String(app.reactNative.capabilities?.nativePageReloads),
+            );
+          }
+          return betterReloadingSupport;
+        });
+      let target;
+      const launchType = req.method === "POST" ? "launch" : "redirect";
+      if (
+        typeof query.target === "string" ||
+        typeof query.appId === "string" ||
+        typeof query.device === "string"
+      ) {
+        logger?.info(
+          (launchType === "launch" ? "Launching" : "Redirecting to") +
+            " DevTools...",
+        );
+        target = targets.find(
+          (_target) =>
+            (query.target == null || _target.id === query.target) &&
+            (query.appId == null ||
+              (_target.appId === query.appId &&
+                _target.title === LEGACY_SYNTHETIC_PAGE_TITLE)) &&
+            (query.device == null ||
+              _target.reactNative.logicalDeviceId === query.device),
+        );
+      } else if (targets.length > 0) {
+        logger?.info(
+          (launchType === "launch" ? "Launching" : "Redirecting to") +
+            ` DevTools${targets.length === 1 ? "" : " for most recently connected target"}...`,
+        );
+        target = targets[targets.length - 1];
+      }
+      if (!target) {
+        res.writeHead(404);
+        res.end("Unable to find debugger target");
+        logger?.warn(
+          "No compatible apps connected. React Native DevTools can only be used with the Hermes engine.",
+        );
+        eventReporter?.logEvent({
+          type: "launch_debugger_frontend",
+          launchType,
+          status: "coded_error",
+          errorCode: "NO_APPS_FOUND",
+        });
+        return;
+      }
+      try {
+        switch (launchType) {
+          case "launch": {
+            const frontendUrl = (0, _getDevToolsFrontendUrl.default)(
+              experiments,
+              target.webSocketDebuggerUrl,
+              new URL(serverBaseUrl),
+              {
+                launchId: query.launchId,
+                telemetryInfo: query.telemetryInfo,
+                appId: target.appId,
+                panel: query.panel,
+              },
+            );
+            let shouldUseStandaloneFuseboxShell =
+              experiments.enableStandaloneFuseboxShell;
+            if (shouldUseStandaloneFuseboxShell) {
+              const shellPreparationResult = await shellPreparationPromise;
+              switch (shellPreparationResult.code) {
+                case "success":
+                case "not_implemented":
+                  break;
+                case "platform_not_supported":
+                case "possible_corruption":
+                case "likely_offline":
+                case "unexpected_error":
+                  shouldUseStandaloneFuseboxShell = false;
+                  break;
+                default:
+                  shellPreparationResult.code;
+              }
+            }
+            if (shouldUseStandaloneFuseboxShell) {
+              const windowKey = (0, _crypto.createHash)("sha256")
+                .update(
+                  [
+                    serverBaseUrl,
+                    target.webSocketDebuggerUrl,
+                    target.appId,
+                  ].join("-"),
+                )
+                .digest("hex");
+              if (!toolLauncher.launchDebuggerShell) {
+                throw new Error(
+                  "Fusebox shell is not supported by the current app launcher",
+                );
+              }
+              await toolLauncher.launchDebuggerShell(frontendUrl, windowKey);
+            } else {
+              await toolLauncher.launchDebuggerAppWindow(frontendUrl);
+            }
+            res.writeHead(200);
+            res.end();
+            break;
+          }
+          case "redirect":
+            res.writeHead(302, {
+              Location: (0, _getDevToolsFrontendUrl.default)(
+                experiments,
+                target.webSocketDebuggerUrl,
+                new URL(serverBaseUrl),
+                {
+                  relative: true,
+                  launchId: query.launchId,
+                  telemetryInfo: query.telemetryInfo,
+                  appId: target.appId,
+                },
+              ),
+            });
+            res.end();
+            break;
+          default:
+        }
+        eventReporter?.logEvent({
+          type: "launch_debugger_frontend",
+          launchType,
+          status: "success",
+          appId: target.appId,
+          deviceId: target.reactNative.logicalDeviceId,
+          pageId: target.id,
+          deviceName: target.deviceName,
+          targetDescription: target.description,
+        });
+        return;
+      } catch (e) {
+        logger?.error(
+          "Error launching DevTools: " + e.message ?? "Unknown error",
+        );
+        res.writeHead(500);
+        res.end();
+        eventReporter?.logEvent({
+          type: "launch_debugger_frontend",
+          launchType,
+          status: "error",
+          error: e,
+        });
+        return;
+      }
+    }
+    next();
+  };
+}

node_modules/@react-native/dev-middleware/dist/middleware/openDebuggerMiddleware.js.flow

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type { InspectorProxyQueries } from "../inspector-proxy/InspectorProxy";
+import type { DevToolLauncher } from "../types/DevToolLauncher";
+import type { EventReporter } from "../types/EventReporter";
+import type { Experiments } from "../types/Experiments";
+import type { Logger } from "../types/Logger";
+import type { ReadonlyURL } from "../types/ReadonlyURL";
+import type { NextHandleFunction } from "connect";
+type Options = Readonly<{
+  serverBaseUrl: ReadonlyURL,
+  logger?: Logger,
+  toolLauncher: DevToolLauncher,
+  eventReporter?: EventReporter,
+  experiments: Experiments,
+  inspectorProxy: InspectorProxyQueries,
+}>;
+
+/**
+ * Open the debugger frontend for a given CDP target.
+ *
+ * @see https://chromedevtools.github.io/devtools-protocol/
+ */
+declare export default function openDebuggerMiddleware(
+  $$PARAM_0$$: Options,
+): NextHandleFunction;

node_modules/@react-native/dev-middleware/dist/types/DevToolLauncher.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { DebuggerShellPreparationResult } from "@react-native/debugger-shell";
+export type { DebuggerShellPreparationResult };
+/**
+ * An interface for integrators to provide a custom implementation for
+ * launching external applications on the host machine (or target dev machine).
+ *
+ * This is an unstable API with no semver guarantees.
+ */
+export interface DevToolLauncher {
+  /**
+   * Attempt to open a debugger frontend URL in a browser app window. The
+   * browser used should be capable of running Chrome DevTools.
+   *
+   * The provided URL is based on serverBaseUrl, and therefore reachable from
+   * the host of dev-middleware. Implementations are responsible for rewriting
+   * this as necessary where the server is remote.
+   */
+  readonly launchDebuggerAppWindow: (url: string) => Promise<void>;
+  /**
+   * Attempt to open a debugger frontend URL in a standalone shell window
+   * designed specifically for React Native DevTools. The provided windowKey
+   * should be used to identify an existing window that can be reused instead
+   * of opening a new one.
+   *
+   * Implementations SHOULD treat an existing session with the same windowKey
+   * (as long as it's still connected and healthy) as equaivalent to a new
+   * session with the new URL, even if the launch URLs for the two sessions are
+   * not identical. Implementations SHOULD NOT unnecessarily close and reopen
+   * the connection when reusing a session. Implementations SHOULD process any
+   * changed/new parameters in the URL and update the session accordingly (e.g.
+   * to preserve telemetry data that may have changed).
+   *
+   * The provided URL is based on serverBaseUrl, and therefore reachable from
+   * the host of dev-middleware. Implementations are responsible for rewriting
+   * this as necessary where the server is remote.
+   */
+  readonly launchDebuggerShell?: (
+    url: string,
+    windowKey: string,
+  ) => Promise<void>;
+  /**
+   * Attempt to prepare the debugger shell for use and returns a coded result
+   * that can be used to advise the user on how to proceed in case of failure.
+   *
+   * This function MAY be called multiple times or not at all. Implementers
+   * SHOULD use the opportunity to prefetch and cache any expensive resources (e.g
+   * platform-specific binaries needed in order to show the Fusebox shell). After a
+   * successful call, subsequent calls SHOULD complete quickly. The implementation
+   * SHOULD NOT return a rejecting promise in any case, and instead SHOULD report
+   * errors via the returned result object.
+   */
+  readonly prepareDebuggerShell?: () => Promise<DebuggerShellPreparationResult>;
+}

node_modules/@react-native/dev-middleware/dist/types/DevToolLauncher.js

@@ -0,0 +1 @@
+"use strict";

node_modules/@react-native/dev-middleware/dist/types/DevToolLauncher.js.flow

@@ -0,0 +1,64 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type { DebuggerShellPreparationResult } from "@react-native/debugger-shell";
+
+export type { DebuggerShellPreparationResult };
+
+/**
+ * An interface for integrators to provide a custom implementation for
+ * launching external applications on the host machine (or target dev machine).
+ *
+ * This is an unstable API with no semver guarantees.
+ */
+export interface DevToolLauncher {
+  /**
+   * Attempt to open a debugger frontend URL in a browser app window. The
+   * browser used should be capable of running Chrome DevTools.
+   *
+   * The provided URL is based on serverBaseUrl, and therefore reachable from
+   * the host of dev-middleware. Implementations are responsible for rewriting
+   * this as necessary where the server is remote.
+   */
+  +launchDebuggerAppWindow: (url: string) => Promise<void>;
+
+  /**
+   * Attempt to open a debugger frontend URL in a standalone shell window
+   * designed specifically for React Native DevTools. The provided windowKey
+   * should be used to identify an existing window that can be reused instead
+   * of opening a new one.
+   *
+   * Implementations SHOULD treat an existing session with the same windowKey
+   * (as long as it's still connected and healthy) as equaivalent to a new
+   * session with the new URL, even if the launch URLs for the two sessions are
+   * not identical. Implementations SHOULD NOT unnecessarily close and reopen
+   * the connection when reusing a session. Implementations SHOULD process any
+   * changed/new parameters in the URL and update the session accordingly (e.g.
+   * to preserve telemetry data that may have changed).
+   *
+   * The provided URL is based on serverBaseUrl, and therefore reachable from
+   * the host of dev-middleware. Implementations are responsible for rewriting
+   * this as necessary where the server is remote.
+   */
+  +launchDebuggerShell?: (url: string, windowKey: string) => Promise<void>;
+
+  /**
+   * Attempt to prepare the debugger shell for use and returns a coded result
+   * that can be used to advise the user on how to proceed in case of failure.
+   *
+   * This function MAY be called multiple times or not at all. Implementers
+   * SHOULD use the opportunity to prefetch and cache any expensive resources (e.g
+   * platform-specific binaries needed in order to show the Fusebox shell). After a
+   * successful call, subsequent calls SHOULD complete quickly. The implementation
+   * SHOULD NOT return a rejecting promise in any case, and instead SHOULD report
+   * errors via the returned result object.
+   */
+  +prepareDebuggerShell?: () => Promise<DebuggerShellPreparationResult>;
+}

node_modules/@react-native/dev-middleware/dist/types/EventReporter.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { DebuggerShellPreparationResult } from "./DevToolLauncher";
+type SuccessResult<Props extends {} | void = {}> =
+  /**
+   * > 15 |   ...Props,
+   *      |   ^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any;
+type ErrorResult<ErrorT = unknown, Props extends {} | void = {}> =
+  /**
+   * > 21 |   ...Props,
+   *      |   ^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any;
+type CodedErrorResult<ErrorCode extends string> = {
+  status: "coded_error";
+  errorCode: ErrorCode;
+  errorDetails?: string;
+};
+export type DebuggerSessionIDs = {
+  appId: string | null;
+  deviceName: string | null;
+  deviceId: string | null;
+  pageId: string | null;
+};
+export type ConnectionUptime = { connectionUptime: number };
+export type ReportableEvent =
+  | /**
+   * > 45 |       ...
+   *      |       ^^^
+   * > 46 |         | SuccessResult<{
+   *      | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   * > 47 |             targetDescription: string,
+   *      | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   * > 48 |             ...DebuggerSessionIDs,
+   *      | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   * > 49 |           }>
+   *      | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   * > 50 |         | ErrorResult<unknown>
+   *      | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   * > 51 |         | CodedErrorResult<"NO_APPS_FOUND">,
+   *      | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any
+  | /**
+   * > 55 |       ...
+   *      |       ^^^
+   * > 56 |         | SuccessResult<{
+   *      | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   * > 57 |             ...DebuggerSessionIDs,
+   *      | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   * > 58 |             frontendUserAgent: string | null,
+   *      | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   * > 59 |           }>
+   *      | ^^^^^^^^^^^^^^^^^^^^^^^^^
+   * > 60 |         | ErrorResult<unknown, DebuggerSessionIDs>,
+   *      | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any
+  | /**
+   * > 70 |       ...DebuggerSessionIDs,
+   *      |       ^^^^^^^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any
+  | /**
+   * > 86 |       ...DebuggerSessionIDs,
+   *      |       ^^^^^^^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any
+  | /**
+   * > 90 |       ...DebuggerSessionIDs,
+   *      |       ^^^^^^^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any
+  | /**
+   * > 99 |       ...ConnectionUptime,
+   *      |       ^^^^^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any
+  | /**
+   * > 106 |       ...ConnectionUptime,
+   *       |       ^^^^^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any
+  | /**
+   * > 113 |       ...ConnectionUptime,
+   *       |       ^^^^^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any
+  | /**
+   * > 121 |       ...ConnectionUptime,
+   *       |       ^^^^^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any
+  | /**
+   * > 129 |       ...ConnectionUptime,
+   *       |       ^^^^^^^^^^^^^^^^^^^ Unsupported feature: Translating "object types with spreads in the middle or at the end" is currently not supported.
+   **/
+  any
+  | {
+      type: "fusebox_shell_preparation_attempt";
+      result: DebuggerShellPreparationResult;
+    };
+/**
+ * A simple interface for logging events, to be implemented by integrators of
+ * `dev-middleware`.
+ *
+ * This is an unstable API with no semver guarantees.
+ */
+export interface EventReporter {
+  logEvent(event: ReportableEvent): void;
+}

node_modules/@react-native/dev-middleware/dist/types/EventReporter.js

@@ -0,0 +1 @@
+"use strict";

node_modules/@react-native/dev-middleware/dist/types/EventReporter.js.flow

@@ -0,0 +1,145 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type { DebuggerShellPreparationResult } from "./DevToolLauncher";
+
+type SuccessResult<Props: { ... } | void = {}> = {
+  status: "success",
+  ...Props,
+};
+
+type ErrorResult<ErrorT = unknown, Props: { ... } | void = {}> = {
+  status: "error",
+  error: ErrorT,
+  ...Props,
+};
+
+type CodedErrorResult<ErrorCode: string> = {
+  status: "coded_error",
+  errorCode: ErrorCode,
+  errorDetails?: string,
+};
+
+export type DebuggerSessionIDs = {
+  appId: string | null,
+  deviceName: string | null,
+  deviceId: string | null,
+  pageId: string | null,
+};
+
+export type ConnectionUptime = {
+  connectionUptime: number,
+};
+
+export type ReportableEvent =
+  | {
+      type: "launch_debugger_frontend",
+      launchType: "launch" | "redirect",
+      ...
+        | SuccessResult<{
+            targetDescription: string,
+            ...DebuggerSessionIDs,
+          }>
+        | ErrorResult<unknown>
+        | CodedErrorResult<"NO_APPS_FOUND">,
+    }
+  | {
+      type: "connect_debugger_frontend",
+      ...
+        | SuccessResult<{
+            ...DebuggerSessionIDs,
+            frontendUserAgent: string | null,
+          }>
+        | ErrorResult<unknown, DebuggerSessionIDs>,
+    }
+  | {
+      type: "debugger_command",
+      protocol: "CDP",
+      // With some errors, the method might not be known
+      method: string | null,
+      requestOrigin: "proxy" | "debugger" | null,
+      responseOrigin: "proxy" | "device",
+      timeSinceStart: number | null,
+      ...DebuggerSessionIDs,
+      ...ConnectionUptime,
+      frontendUserAgent: string | null,
+      ...
+        | SuccessResult<void>
+        | CodedErrorResult<
+            | "TIMED_OUT"
+            | "DEVICE_DISCONNECTED"
+            | "DEBUGGER_DISCONNECTED"
+            | "UNMATCHED_REQUEST_ID"
+            | "PROTOCOL_ERROR",
+          >,
+    }
+  | {
+      type: "profiling_target_registered",
+      status: "success",
+      ...DebuggerSessionIDs,
+    }
+  | {
+      type: "no_debug_pages_for_device",
+      ...DebuggerSessionIDs,
+    }
+  | {
+      type: "proxy_error",
+      status: "error",
+      messageOrigin: "debugger" | "device",
+      message: string,
+      error: string,
+      errorStack: string,
+      ...ConnectionUptime,
+      ...DebuggerSessionIDs,
+    }
+  | {
+      type: "debugger_high_ping" | "device_high_ping",
+      duration: number,
+      timeSinceLastCommunication: number | null,
+      ...ConnectionUptime,
+      ...DebuggerSessionIDs,
+    }
+  | {
+      type: "debugger_timeout" | "device_timeout",
+      duration: number,
+      timeSinceLastCommunication: number | null,
+      ...ConnectionUptime,
+      ...DebuggerSessionIDs,
+    }
+  | {
+      type: "debugger_connection_closed" | "device_connection_closed",
+      code: number,
+      reason: string,
+      timeSinceLastCommunication: number | null,
+      ...ConnectionUptime,
+      ...DebuggerSessionIDs,
+    }
+  | {
+      type: "high_event_loop_delay",
+      eventLoopUtilization: number,
+      maxEventLoopDelayPercent: number,
+      duration: number,
+      ...ConnectionUptime,
+      ...DebuggerSessionIDs,
+    }
+  | {
+      type: "fusebox_shell_preparation_attempt",
+      result: DebuggerShellPreparationResult,
+    };
+
+/**
+ * A simple interface for logging events, to be implemented by integrators of
+ * `dev-middleware`.
+ *
+ * This is an unstable API with no semver guarantees.
+ */
+export interface EventReporter {
+  logEvent(event: ReportableEvent): void;
+}

node_modules/@react-native/dev-middleware/dist/types/Experiments.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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
+ */
+
+export type Experiments = Readonly<{
+  /**
+   * Enables the handling of GET requests in the /open-debugger endpoint,
+   * in addition to POST requests. GET requests respond by redirecting to
+   * the debugger frontend, instead of opening it using the DevToolLauncher
+   * interface.
+   */
+  enableOpenDebuggerRedirect: boolean;
+  /**
+   * Enables the Network panel in the debugger frontend.
+   */
+  enableNetworkInspector: boolean;
+  /**
+   * Launch the debugger frontend in a standalone shell instead of a browser.
+   * When this is enabled, we will use the optional launchDebuggerShell
+   * method on the DevToolLauncher, or throw an error if the method is missing.
+   *
+   * NOTE: Disabling this also disables support for concurrent sessions in the
+   * inspector proxy. Without the standalone shell, the proxy remains responsible
+   * for keeping only one debugger frontend active at a time per page.
+   */
+  enableStandaloneFuseboxShell: boolean;
+}>;
+export type ExperimentsConfig = Partial<Experiments>;

node_modules/@react-native/dev-middleware/dist/types/Experiments.js

@@ -0,0 +1 @@
+"use strict";

node_modules/@react-native/dev-middleware/dist/types/Experiments.js.flow

@@ -0,0 +1,38 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+export type Experiments = Readonly<{
+  /**
+   * Enables the handling of GET requests in the /open-debugger endpoint,
+   * in addition to POST requests. GET requests respond by redirecting to
+   * the debugger frontend, instead of opening it using the DevToolLauncher
+   * interface.
+   */
+  enableOpenDebuggerRedirect: boolean,
+
+  /**
+   * Enables the Network panel in the debugger frontend.
+   */
+  // NOTE: Used by Expo, exposing a tab labelled "Network (Expo)"
+  enableNetworkInspector: boolean,
+
+  /**
+   * Launch the debugger frontend in a standalone shell instead of a browser.
+   * When this is enabled, we will use the optional launchDebuggerShell
+   * method on the DevToolLauncher, or throw an error if the method is missing.
+   *
+   * NOTE: Disabling this also disables support for concurrent sessions in the
+   * inspector proxy. Without the standalone shell, the proxy remains responsible
+   * for keeping only one debugger frontend active at a time per page.
+   */
+  enableStandaloneFuseboxShell: boolean,
+}>;
+
+export type ExperimentsConfig = Partial<Experiments>;

node_modules/@react-native/dev-middleware/dist/types/Logger.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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
+ */
+
+export type Logger = Readonly<{
+  error: (...message: Array<string>) => void;
+  info: (...message: Array<string>) => void;
+  warn: (...message: Array<string>) => void;
+}>;

node_modules/@react-native/dev-middleware/dist/types/Logger.js

@@ -0,0 +1 @@
+"use strict";

node_modules/@react-native/dev-middleware/dist/types/Logger.js.flow

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ * @format
+ */
+
+export type Logger = Readonly<{
+  error: (...message: Array<string>) => void,
+  info: (...message: Array<string>) => void,
+  warn: (...message: Array<string>) => void,
+  ...
+}>;

node_modules/@react-native/dev-middleware/dist/types/ReadonlyURL.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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
+ */
+
+/**
+ * A readonly view of URLSearchParams that only exposes read operations.
+ */
+export interface ReadonlyURLSearchParams {
+  get(name: string): string | null;
+  getAll(name: string): Array<string>;
+  has(name: string, value?: string): boolean;
+  readonly size: number;
+  entries(): Iterator<[string, string]>;
+  keys(): Iterator<string>;
+  values(): Iterator<string>;
+  forEach<This>(
+    callback: (
+      this: This,
+      value: string,
+      name: string,
+      params: URLSearchParams,
+    ) => unknown,
+    thisArg: This,
+  ): void;
+  toString(): string;
+  @@iterator(): Iterator<[string, string]>;
+}
+/**
+ * A readonly view of URL that prevents mutation of URL properties.
+ * Used for URLs passed between module boundaries.
+ */
+export interface ReadonlyURL {
+  readonly hash: string;
+  readonly host: string;
+  readonly hostname: string;
+  readonly href: string;
+  readonly origin: string;
+  readonly password: string;
+  readonly pathname: string;
+  readonly port: string;
+  readonly protocol: string;
+  readonly search: string;
+  readonly searchParams: ReadonlyURLSearchParams;
+  readonly username: string;
+  toString(): string;
+  toJSON(): string;
+}

node_modules/@react-native/dev-middleware/dist/types/ReadonlyURL.js

@@ -0,0 +1 @@
+"use strict";

node_modules/@react-native/dev-middleware/dist/types/ReadonlyURL.js.flow

@@ -0,0 +1,54 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+/**
+ * A readonly view of URLSearchParams that only exposes read operations.
+ */
+export interface ReadonlyURLSearchParams {
+  get(name: string): string | null;
+  getAll(name: string): Array<string>;
+  has(name: string, value?: string): boolean;
+  +size: number;
+  entries(): Iterator<[string, string]>;
+  keys(): Iterator<string>;
+  values(): Iterator<string>;
+  forEach<This>(
+    callback: (
+      this: This,
+      value: string,
+      name: string,
+      params: URLSearchParams,
+    ) => mixed,
+    thisArg: This,
+  ): void;
+  toString(): string;
+  @@iterator(): Iterator<[string, string]>;
+}
+
+/**
+ * A readonly view of URL that prevents mutation of URL properties.
+ * Used for URLs passed between module boundaries.
+ */
+export interface ReadonlyURL {
+  +hash: string;
+  +host: string;
+  +hostname: string;
+  +href: string;
+  +origin: string;
+  +password: string;
+  +pathname: string;
+  +port: string;
+  +protocol: string;
+  +search: string;
+  +searchParams: ReadonlyURLSearchParams;
+  +username: string;
+  toString(): string;
+  toJSON(): string;
+}

node_modules/@react-native/dev-middleware/dist/utils/DefaultToolLauncher.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { DebuggerShellPreparationResult } from "../types/DevToolLauncher";
+/**
+ * Default `DevToolLauncher` implementation which handles opening apps on the
+ * local machine.
+ */
+declare const DefaultToolLauncher: {
+  launchDebuggerAppWindow: (url: string) => Promise<void>;
+  launchDebuggerShell(url: string, windowKey: string): Promise<void>;
+  prepareDebuggerShell(
+    prebuiltBinaryPath?: null | undefined | string,
+  ): Promise<DebuggerShellPreparationResult>;
+};
+declare const $$EXPORT_DEFAULT_DECLARATION$$: typeof DefaultToolLauncher;
+declare type $$EXPORT_DEFAULT_DECLARATION$$ =
+  typeof $$EXPORT_DEFAULT_DECLARATION$$;
+export default $$EXPORT_DEFAULT_DECLARATION$$;

node_modules/@react-native/dev-middleware/dist/utils/DefaultToolLauncher.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+const {
+  unstable_prepareDebuggerShell,
+  unstable_spawnDebuggerShellWithArgs,
+} = require("@react-native/debugger-shell");
+const { spawn } = require("child_process");
+const ChromeLauncher = require("chrome-launcher");
+const { Launcher: EdgeLauncher } = require("chromium-edge-launcher");
+const open = require("open");
+const DefaultToolLauncher = {
+  launchDebuggerAppWindow: async (url) => {
+    if (process.env.NODE_ENV === "test") {
+      assertMockedInTests();
+    }
+    let chromePath;
+    try {
+      chromePath = ChromeLauncher.getChromePath();
+    } catch (e) {
+      chromePath = EdgeLauncher.getFirstInstallation();
+    }
+    if (chromePath == null) {
+      await open(url);
+      return;
+    }
+    const chromeFlags = [`--app=${url}`, "--window-size=1200,600"];
+    return new Promise((resolve, reject) => {
+      const childProcess = spawn(chromePath, chromeFlags, {
+        detached: true,
+        stdio: "ignore",
+      });
+      childProcess.on("data", () => {
+        resolve();
+      });
+      childProcess.on("close", (code) => {
+        if (code !== 0) {
+          reject(
+            new Error(
+              `Failed to launch debugger app window: ${chromePath} exited with code ${code}`,
+            ),
+          );
+        }
+      });
+    });
+  },
+  async launchDebuggerShell(url, windowKey) {
+    if (process.env.NODE_ENV === "test") {
+      assertMockedInTests();
+    }
+    return await unstable_spawnDebuggerShellWithArgs([
+      "--frontendUrl=" + url,
+      "--windowKey=" + windowKey,
+    ]);
+  },
+  async prepareDebuggerShell(prebuiltBinaryPath) {
+    if (process.env.NODE_ENV === "test") {
+      assertMockedInTests();
+    }
+    return await unstable_prepareDebuggerShell();
+  },
+};
+function assertMockedInTests() {
+  if (process.env.NODE_ENV === "test") {
+    throw new Error(
+      "DefaultToolLauncher must be mocked or overridden in tests. " +
+        "Add jest.mock('../utils/DefaultAppLauncher') to test setup.",
+    );
+  }
+}
+var _default = (exports.default = DefaultToolLauncher);

node_modules/@react-native/dev-middleware/dist/utils/DefaultToolLauncher.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type { DebuggerShellPreparationResult } from "../types/DevToolLauncher";
+
+/**
+ * Default `DevToolLauncher` implementation which handles opening apps on the
+ * local machine.
+ */
+declare const DefaultToolLauncher: {
+  launchDebuggerAppWindow: (url: string) => Promise<void>,
+  launchDebuggerShell(url: string, windowKey: string): Promise<void>,
+  prepareDebuggerShell(
+    prebuiltBinaryPath?: ?string,
+  ): Promise<DebuggerShellPreparationResult>,
+};
+
+declare export default typeof DefaultToolLauncher;

node_modules/@react-native/dev-middleware/dist/utils/getBaseUrlFromRequest.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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
+ */
+
+declare function getBaseUrlFromRequest(
+  req: http$IncomingMessage<tls$TLSSocket> | http$IncomingMessage<net$Socket>,
+): null | undefined | URL;
+export default getBaseUrlFromRequest;

node_modules/@react-native/dev-middleware/dist/utils/getBaseUrlFromRequest.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = getBaseUrlFromRequest;
+function getBaseUrlFromRequest(req) {
+  const hostHeader = req.headers.host;
+  if (hostHeader == null) {
+    return null;
+  }
+  const scheme = req.socket.encrypted === true ? "https" : "http";
+  const url = `${scheme}://${req.headers.host}`;
+  try {
+    return new URL(url);
+  } catch {
+    return null;
+  }
+}

node_modules/@react-native/dev-middleware/dist/utils/getBaseUrlFromRequest.js.flow

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+// Determine the base URL (scheme and host) used by a client to reach this
+// server.
+//
+// TODO: Support X-Forwarded-Host, etc. for trusted proxies
+declare export default function getBaseUrlFromRequest(
+  req: http$IncomingMessage<tls$TLSSocket> | http$IncomingMessage<net$Socket>,
+): ?URL;

node_modules/@react-native/dev-middleware/dist/utils/getDevToolsFrontendUrl.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ */
+
+import type { Experiments } from "../types/Experiments";
+import type { ReadonlyURL } from "../types/ReadonlyURL";
+/**
+ * Get the DevTools frontend URL to debug a given React Native CDP target.
+ */
+declare function getDevToolsFrontendUrl(
+  experiments: Experiments,
+  webSocketDebuggerUrl: string,
+  devServerUrl: ReadonlyURL,
+  options?: Readonly<{
+    relative?: boolean;
+    launchId?: string;
+    telemetryInfo?: string;
+    appId?: string;
+    panel?: string;
+  }>,
+): string;
+export default getDevToolsFrontendUrl;

node_modules/@react-native/dev-middleware/dist/utils/getDevToolsFrontendUrl.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = getDevToolsFrontendUrl;
+function getDevToolsFrontendUrl(
+  experiments,
+  webSocketDebuggerUrl,
+  devServerUrl,
+  options,
+) {
+  const wsParam = getWsParam({
+    webSocketDebuggerUrl,
+    devServerUrl,
+  });
+  const appUrl =
+    (options?.relative === true ? "" : devServerUrl.origin) +
+    "/debugger-frontend/rn_fusebox.html";
+  const searchParams = new URLSearchParams([
+    [wsParam.key, wsParam.value],
+    ["sources.hide_add_folder", "true"],
+  ]);
+  if (experiments.enableNetworkInspector) {
+    searchParams.append("unstable_enableNetworkPanel", "true");
+  }
+  if (options?.launchId != null && options.launchId !== "") {
+    searchParams.append("launchId", options.launchId);
+  }
+  if (options?.appId != null && options.appId !== "") {
+    searchParams.append("appId", options.appId);
+  }
+  if (options?.telemetryInfo != null && options.telemetryInfo !== "") {
+    searchParams.append("telemetryInfo", options.telemetryInfo);
+  }
+  if (options?.panel != null && options.panel !== "") {
+    searchParams.append("panel", options.panel);
+  }
+  return appUrl + "?" + searchParams.toString();
+}
+function getWsParam({ webSocketDebuggerUrl, devServerUrl }) {
+  const wsUrl = new URL(webSocketDebuggerUrl);
+  const serverHost = devServerUrl.host;
+  let value;
+  if (wsUrl.host === serverHost) {
+    value = wsUrl.pathname + wsUrl.search + wsUrl.hash;
+  } else {
+    value = wsUrl.host + wsUrl.pathname + wsUrl.search + wsUrl.hash;
+  }
+  const key = wsUrl.protocol.slice(0, -1);
+  return {
+    key,
+    value,
+  };
+}

node_modules/@react-native/dev-middleware/dist/utils/getDevToolsFrontendUrl.js.flow

@@ -0,0 +1,28 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+import type { Experiments } from "../types/Experiments";
+import type { ReadonlyURL } from "../types/ReadonlyURL";
+
+/**
+ * Get the DevTools frontend URL to debug a given React Native CDP target.
+ */
+declare export default function getDevToolsFrontendUrl(
+  experiments: Experiments,
+  webSocketDebuggerUrl: string,
+  devServerUrl: ReadonlyURL,
+  options?: Readonly<{
+    relative?: boolean,
+    launchId?: string,
+    telemetryInfo?: string,
+    appId?: string,
+    panel?: string,
+  }>,
+): string;

node_modules/@react-native/dev-middleware/node_modules/node-gyp-build/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Mathias Buus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/@react-native/dev-middleware/node_modules/node-gyp-build/README.md

@@ -0,0 +1,58 @@
+# node-gyp-build
+
+> Build tool and bindings loader for [`node-gyp`][node-gyp] that supports prebuilds.
+
+```
+npm install node-gyp-build
+```
+
+[![Test](https://github.com/prebuild/node-gyp-build/actions/workflows/test.yml/badge.svg)](https://github.com/prebuild/node-gyp-build/actions/workflows/test.yml)
+
+Use together with [`prebuildify`][prebuildify] to easily support prebuilds for your native modules.
+
+## Usage
+
+> **Note.** Prebuild names have changed in [`prebuildify@3`][prebuildify] and `node-gyp-build@4`. Please see the documentation below.
+
+`node-gyp-build` works similar to [`node-gyp build`][node-gyp] except that it will check if a build or prebuild is present before rebuilding your project.
+
+It's main intended use is as an npm install script and bindings loader for native modules that bundle prebuilds using [`prebuildify`][prebuildify].
+
+First add `node-gyp-build` as an install script to your native project
+
+``` js
+{
+  ...
+  "scripts": {
+    "install": "node-gyp-build"
+  }
+}
+```
+
+Then in your `index.js`, instead of using the [`bindings`](https://www.npmjs.com/package/bindings) module use `node-gyp-build` to load your binding.
+
+``` js
+var binding = require('node-gyp-build')(__dirname)
+```
+
+If you do these two things and bundle prebuilds with [`prebuildify`][prebuildify] your native module will work for most platforms
+without having to compile on install time AND will work in both node and electron without the need to recompile between usage.
+
+Users can override `node-gyp-build` and force compiling by doing `npm install --build-from-source`.
+
+Prebuilds will be attempted loaded from `MODULE_PATH/prebuilds/...` and then next `EXEC_PATH/prebuilds/...` (the latter allowing use with `zeit/pkg`)
+
+## Supported prebuild names
+
+If so desired you can bundle more specific flavors, for example `musl` builds to support Alpine, or targeting a numbered ARM architecture version.
+
+These prebuilds can be bundled in addition to generic prebuilds; `node-gyp-build` will try to find the most specific flavor first. Prebuild filenames are composed of _tags_. The runtime tag takes precedence, as does an `abi` tag over `napi`. For more details on tags, please see [`prebuildify`][prebuildify].
+
+Values for the `libc` and `armv` tags are auto-detected but can be overridden through the `LIBC` and `ARM_VERSION` environment variables, respectively.
+
+## License
+
+MIT
+
+[prebuildify]: https://github.com/prebuild/prebuildify
+[node-gyp]: https://www.npmjs.com/package/node-gyp

node_modules/@react-native/dev-middleware/node_modules/node-gyp-build/SECURITY.md

@@ -0,0 +1,5 @@
+## Security contact information
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.

node_modules/@react-native/dev-middleware/node_modules/node-gyp-build/bin.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+var proc = require('child_process')
+var os = require('os')
+var path = require('path')
+
+if (!buildFromSource()) {
+  proc.exec('node-gyp-build-test', function (err, stdout, stderr) {
+    if (err) {
+      if (verbose()) console.error(stderr)
+      preinstall()
+    }
+  })
+} else {
+  preinstall()
+}
+
+function build () {
+  var win32 = os.platform() === 'win32'
+  var shell = win32
+  var args = [win32 ? 'node-gyp.cmd' : 'node-gyp', 'rebuild']
+
+  try {
+    var pkg = require('node-gyp/package.json')
+    args = [
+      process.execPath,
+      path.join(require.resolve('node-gyp/package.json'), '..', typeof pkg.bin === 'string' ? pkg.bin : pkg.bin['node-gyp']),
+      'rebuild'
+    ]
+    shell = false
+  } catch (_) {}
+
+  proc.spawn(args[0], args.slice(1), { stdio: 'inherit', shell, windowsHide: true }).on('exit', function (code) {
+    if (code || !process.argv[3]) process.exit(code)
+    exec(process.argv[3]).on('exit', function (code) {
+      process.exit(code)
+    })
+  })
+}
+
+function preinstall () {
+  if (!process.argv[2]) return build()
+  exec(process.argv[2]).on('exit', function (code) {
+    if (code) process.exit(code)
+    build()
+  })
+}
+
+function exec (cmd) {
+  if (process.platform !== 'win32') {
+    var shell = os.platform() === 'android' ? 'sh' : true
+    return proc.spawn(cmd, [], {
+      shell,
+      stdio: 'inherit'
+    })
+  }
+
+  return proc.spawn(cmd, [], {
+    windowsVerbatimArguments: true,
+    stdio: 'inherit',
+    shell: true,
+    windowsHide: true
+  })
+}
+
+function buildFromSource () {
+  return hasFlag('--build-from-source') || process.env.npm_config_build_from_source === 'true'
+}
+
+function verbose () {
+  return hasFlag('--verbose') || process.env.npm_config_loglevel === 'verbose'
+}
+
+// TODO (next major): remove in favor of env.npm_config_* which works since npm
+// 0.1.8 while npm_config_argv will stop working in npm 7. See npm/rfcs#90
+function hasFlag (flag) {
+  if (!process.env.npm_config_argv) return false
+
+  try {
+    return JSON.parse(process.env.npm_config_argv).original.indexOf(flag) !== -1
+  } catch (_) {
+    return false
+  }
+}

node_modules/@react-native/dev-middleware/node_modules/node-gyp-build/build-test.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+process.env.NODE_ENV = 'test'
+
+var path = require('path')
+var test = null
+
+try {
+  var pkg = require(path.join(process.cwd(), 'package.json'))
+  if (pkg.name && process.env[pkg.name.toUpperCase().replace(/-/g, '_')]) {
+    process.exit(0)
+  }
+  test = pkg.prebuild.test
+} catch (err) {
+  //  do nothing
+}
+
+if (test) require(path.join(process.cwd(), test))
+else require('./')()

node_modules/@react-native/dev-middleware/node_modules/node-gyp-build/index.js

@@ -0,0 +1,6 @@
+const runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require // eslint-disable-line
+if (typeof runtimeRequire.addon === 'function') { // if the platform supports native resolving prefer that
+  module.exports = runtimeRequire.addon.bind(runtimeRequire)
+} else { // else use the runtime version here
+  module.exports = require('./node-gyp-build.js')
+}

node_modules/@react-native/dev-middleware/node_modules/node-gyp-build/node-gyp-build.js

@@ -0,0 +1,207 @@
+var fs = require('fs')
+var path = require('path')
+var os = require('os')
+
+// Workaround to fix webpack's build warnings: 'the request of a dependency is an expression'
+var runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require // eslint-disable-line
+
+var vars = (process.config && process.config.variables) || {}
+var prebuildsOnly = !!process.env.PREBUILDS_ONLY
+var abi = process.versions.modules // TODO: support old node where this is undef
+var runtime = isElectron() ? 'electron' : (isNwjs() ? 'node-webkit' : 'node')
+
+var arch = process.env.npm_config_arch || os.arch()
+var platform = process.env.npm_config_platform || os.platform()
+var libc = process.env.LIBC || (isAlpine(platform) ? 'musl' : 'glibc')
+var armv = process.env.ARM_VERSION || (arch === 'arm64' ? '8' : vars.arm_version) || ''
+var uv = (process.versions.uv || '').split('.')[0]
+
+module.exports = load
+
+function load (dir) {
+  return runtimeRequire(load.resolve(dir))
+}
+
+load.resolve = load.path = function (dir) {
+  dir = path.resolve(dir || '.')
+
+  try {
+    var name = runtimeRequire(path.join(dir, 'package.json')).name.toUpperCase().replace(/-/g, '_')
+    if (process.env[name + '_PREBUILD']) dir = process.env[name + '_PREBUILD']
+  } catch (err) {}
+
+  if (!prebuildsOnly) {
+    var release = getFirst(path.join(dir, 'build/Release'), matchBuild)
+    if (release) return release
+
+    var debug = getFirst(path.join(dir, 'build/Debug'), matchBuild)
+    if (debug) return debug
+  }
+
+  var prebuild = resolve(dir)
+  if (prebuild) return prebuild
+
+  var nearby = resolve(path.dirname(process.execPath))
+  if (nearby) return nearby
+
+  var target = [
+    'platform=' + platform,
+    'arch=' + arch,
+    'runtime=' + runtime,
+    'abi=' + abi,
+    'uv=' + uv,
+    armv ? 'armv=' + armv : '',
+    'libc=' + libc,
+    'node=' + process.versions.node,
+    process.versions.electron ? 'electron=' + process.versions.electron : '',
+    typeof __webpack_require__ === 'function' ? 'webpack=true' : '' // eslint-disable-line
+  ].filter(Boolean).join(' ')
+
+  throw new Error('No native build was found for ' + target + '\n    loaded from: ' + dir + '\n')
+
+  function resolve (dir) {
+    // Find matching "prebuilds/<platform>-<arch>" directory
+    var tuples = readdirSync(path.join(dir, 'prebuilds')).map(parseTuple)
+    var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0]
+    if (!tuple) return
+
+    // Find most specific flavor first
+    var prebuilds = path.join(dir, 'prebuilds', tuple.name)
+    var parsed = readdirSync(prebuilds).map(parseTags)
+    var candidates = parsed.filter(matchTags(runtime, abi))
+    var winner = candidates.sort(compareTags(runtime))[0]
+    if (winner) return path.join(prebuilds, winner.file)
+  }
+}
+
+function readdirSync (dir) {
+  try {
+    return fs.readdirSync(dir)
+  } catch (err) {
+    return []
+  }
+}
+
+function getFirst (dir, filter) {
+  var files = readdirSync(dir).filter(filter)
+  return files[0] && path.join(dir, files[0])
+}
+
+function matchBuild (name) {
+  return /\.node$/.test(name)
+}
+
+function parseTuple (name) {
+  // Example: darwin-x64+arm64
+  var arr = name.split('-')
+  if (arr.length !== 2) return
+
+  var platform = arr[0]
+  var architectures = arr[1].split('+')
+
+  if (!platform) return
+  if (!architectures.length) return
+  if (!architectures.every(Boolean)) return
+
+  return { name, platform, architectures }
+}
+
+function matchTuple (platform, arch) {
+  return function (tuple) {
+    if (tuple == null) return false
+    if (tuple.platform !== platform) return false
+    return tuple.architectures.includes(arch)
+  }
+}
+
+function compareTuples (a, b) {
+  // Prefer single-arch prebuilds over multi-arch
+  return a.architectures.length - b.architectures.length
+}
+
+function parseTags (file) {
+  var arr = file.split('.')
+  var extension = arr.pop()
+  var tags = { file: file, specificity: 0 }
+
+  if (extension !== 'node') return
+
+  for (var i = 0; i < arr.length; i++) {
+    var tag = arr[i]
+
+    if (tag === 'node' || tag === 'electron' || tag === 'node-webkit') {
+      tags.runtime = tag
+    } else if (tag === 'napi') {
+      tags.napi = true
+    } else if (tag.slice(0, 3) === 'abi') {
+      tags.abi = tag.slice(3)
+    } else if (tag.slice(0, 2) === 'uv') {
+      tags.uv = tag.slice(2)
+    } else if (tag.slice(0, 4) === 'armv') {
+      tags.armv = tag.slice(4)
+    } else if (tag === 'glibc' || tag === 'musl') {
+      tags.libc = tag
+    } else {
+      continue
+    }
+
+    tags.specificity++
+  }
+
+  return tags
+}
+
+function matchTags (runtime, abi) {
+  return function (tags) {
+    if (tags == null) return false
+    if (tags.runtime && tags.runtime !== runtime && !runtimeAgnostic(tags)) return false
+    if (tags.abi && tags.abi !== abi && !tags.napi) return false
+    if (tags.uv && tags.uv !== uv) return false
+    if (tags.armv && tags.armv !== armv) return false
+    if (tags.libc && tags.libc !== libc) return false
+
+    return true
+  }
+}
+
+function runtimeAgnostic (tags) {
+  return tags.runtime === 'node' && tags.napi
+}
+
+function compareTags (runtime) {
+  // Precedence: non-agnostic runtime, abi over napi, then by specificity.
+  return function (a, b) {
+    if (a.runtime !== b.runtime) {
+      return a.runtime === runtime ? -1 : 1
+    } else if (a.abi !== b.abi) {
+      return a.abi ? -1 : 1
+    } else if (a.specificity !== b.specificity) {
+      return a.specificity > b.specificity ? -1 : 1
+    } else {
+      return 0
+    }
+  }
+}
+
+function isNwjs () {
+  return !!(process.versions && process.versions.nw)
+}
+
+function isElectron () {
+  if (process.versions && process.versions.electron) return true
+  if (process.env.ELECTRON_RUN_AS_NODE) return true
+  return typeof window !== 'undefined' && window.process && window.process.type === 'renderer'
+}
+
+function isAlpine (platform) {
+  return platform === 'linux' && fs.existsSync('/etc/alpine-release')
+}
+
+// Exposed for unit tests
+// TODO: move to lib
+load.parseTags = parseTags
+load.matchTags = matchTags
+load.compareTags = compareTags
+load.parseTuple = parseTuple
+load.matchTuple = matchTuple
+load.compareTuples = compareTuples

node_modules/@react-native/dev-middleware/node_modules/node-gyp-build/optional.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+/*
+I am only useful as an install script to make node-gyp not compile for purely optional native deps
+*/
+
+process.exit(0)

node_modules/@react-native/dev-middleware/node_modules/node-gyp-build/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "node-gyp-build",
+  "version": "4.8.4",
+  "description": "Build tool and bindings loader for node-gyp that supports prebuilds",
+  "main": "index.js",
+  "imports": {
+    "fs": {
+      "bare": "builtin:fs",
+      "default": "fs"
+    },
+    "path": {
+      "bare": "builtin:path",
+      "default": "path"
+    },
+    "os": {
+      "bare": "builtin:os",
+      "default": "os"
+    }
+  },
+  "devDependencies": {
+    "array-shuffle": "^1.0.1",
+    "standard": "^14.0.0",
+    "tape": "^5.0.0"
+  },
+  "scripts": {
+    "test": "standard && node test"
+  },
+  "bin": {
+    "node-gyp-build": "./bin.js",
+    "node-gyp-build-optional": "./optional.js",
+    "node-gyp-build-test": "./build-test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prebuild/node-gyp-build.git"
+  },
+  "author": "Mathias Buus (@mafintosh)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/prebuild/node-gyp-build/issues"
+  },
+  "homepage": "https://github.com/prebuild/node-gyp-build"
+}

node_modules/@react-native/dev-middleware/node_modules/utf-8-validate/LICENSE

@@ -0,0 +1,30 @@
+This project is licensed for use as follows:
+
+"""
+Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com> (http://2x.io)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""
+
+This license applies to parts originating from
+https://www.cl.cam.ac.uk/~mgk25/ucs/utf8_check.c:
+
+"""
+Markus Kuhn <http://www.cl.cam.ac.uk/~mgk25/> -- 2005-03-30
+License: http://www.cl.cam.ac.uk/~mgk25/short-license.html
+"""

node_modules/@react-native/dev-middleware/node_modules/utf-8-validate/README.md

@@ -0,0 +1,50 @@
+# utf-8-validate
+
+[![Version npm](https://img.shields.io/npm/v/utf-8-validate.svg?logo=npm)](https://www.npmjs.com/package/utf-8-validate)
+[![Linux/macOS/Windows Build](https://img.shields.io/github/workflow/status/websockets/utf-8-validate/CI/master?label=build&logo=github)](https://github.com/websockets/utf-8-validate/actions?query=workflow%3ACI+branch%3Amaster)
+
+Check if a buffer contains valid UTF-8 encoded text.
+
+## Installation
+
+```
+npm install utf-8-validate --save-optional
+```
+
+The `--save-optional` flag tells npm to save the package in your package.json
+under the
+[`optionalDependencies`](https://docs.npmjs.com/files/package.json#optionaldependencies)
+key.
+
+## API
+
+The module exports a single function which takes one argument.
+
+### `isValidUTF8(buffer)`
+
+Checks whether a buffer contains valid UTF-8.
+
+#### Arguments
+
+- `buffer` - The buffer to check.
+
+#### Return value
+
+`true` if the buffer contains only correct UTF-8, else `false`.
+
+#### Example
+
+```js
+'use strict';
+
+const isValidUTF8 = require('utf-8-validate');
+
+const buf = Buffer.from([0xf0, 0x90, 0x80, 0x80]);
+
+console.log(isValidUTF8(buf));
+// => true
+```
+
+## License
+
+[MIT](LICENSE)

node_modules/@react-native/dev-middleware/node_modules/utf-8-validate/binding.gyp

@@ -0,0 +1,18 @@
+{
+  'targets': [
+    {
+      'target_name': 'validation',
+      'sources': ['src/validation.c'],
+      'cflags': ['-std=c99'],
+      'conditions': [
+        ["OS=='mac'", {
+          'xcode_settings': {
+            'MACOSX_DEPLOYMENT_TARGET': '10.7',
+            'OTHER_CFLAGS': ['-arch x86_64', '-arch arm64'],
+            'OTHER_LDFLAGS': ['-arch x86_64', '-arch arm64']
+          }
+        }]
+      ]
+    }
+  ]
+}

node_modules/@react-native/dev-middleware/node_modules/utf-8-validate/fallback.js

@@ -0,0 +1,62 @@
+'use strict';
+
+/**
+ * Checks if a given buffer contains only correct UTF-8.
+ * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
+ * Markus Kuhn.
+ *
+ * @param {Buffer} buf The buffer to check
+ * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
+ * @public
+ */
+function isValidUTF8(buf) {
+  const len = buf.length;
+  let i = 0;
+
+  while (i < len) {
+    if ((buf[i] & 0x80) === 0x00) {  // 0xxxxxxx
+      i++;
+    } else if ((buf[i] & 0xe0) === 0xc0) {  // 110xxxxx 10xxxxxx
+      if (
+        i + 1 === len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i] & 0xfe) === 0xc0  // overlong
+      ) {
+        return false;
+      }
+
+      i += 2;
+    } else if ((buf[i] & 0xf0) === 0xe0) {  // 1110xxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 2 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80 ||  // overlong
+        buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0  // surrogate (U+D800 - U+DFFF)
+      ) {
+        return false;
+      }
+
+      i += 3;
+    } else if ((buf[i] & 0xf8) === 0xf0) {  // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 3 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        (buf[i + 3] & 0xc0) !== 0x80 ||
+        buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80 ||  // overlong
+        buf[i] === 0xf4 && buf[i + 1] > 0x8f || buf[i] > 0xf4  // > U+10FFFF
+      ) {
+        return false;
+      }
+
+      i += 4;
+    } else {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+module.exports = isValidUTF8;

node_modules/@react-native/dev-middleware/node_modules/utf-8-validate/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+try {
+  module.exports = require('node-gyp-build')(__dirname);
+} catch (e) {
+  module.exports = require('./fallback');
+}

node_modules/@react-native/dev-middleware/node_modules/utf-8-validate/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "utf-8-validate",
+  "version": "5.0.10",
+  "description": "Check if a buffer contains valid UTF-8",
+  "main": "index.js",
+  "engines": {
+    "node": ">=6.14.2"
+  },
+  "scripts": {
+    "install": "node-gyp-build",
+    "prebuild": "prebuildify --napi --strip --target=14.0.0",
+    "prebuild-darwin-x64+arm64": "prebuildify --arch x64+arm64 --napi --strip --target=14.0.0",
+    "test": "mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/websockets/utf-8-validate"
+  },
+  "keywords": [
+    "utf-8-validate"
+  ],
+  "author": "Einar Otto Stangvik <einaros@gmail.com> (http://2x.io)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/websockets/utf-8-validate/issues"
+  },
+  "homepage": "https://github.com/websockets/utf-8-validate",
+  "dependencies": {
+    "node-gyp-build": "^4.3.0"
+  },
+  "devDependencies": {
+    "mocha": "^10.0.0",
+    "node-gyp": "^9.1.0",
+    "prebuildify": "^5.0.0"
+  }
+}

node_modules/@react-native/dev-middleware/node_modules/utf-8-validate/src/validation.c

@@ -0,0 +1,109 @@
+#define NAPI_VERSION 1
+#include <assert.h>
+#include <string.h>
+#include <node_api.h>
+
+napi_value IsValidUTF8(napi_env env, napi_callback_info info) {
+  napi_status status;
+  size_t argc = 1;
+  napi_value argv[1];
+
+  status = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(status == napi_ok);
+
+  uint8_t *buf;
+  size_t len;
+
+  status = napi_get_buffer_info(env, argv[0], (void **)&buf, &len);
+  assert(status == napi_ok);
+
+  size_t i = 0;
+
+  //
+  // This code has been taken from utf8_check.c which was developed by
+  // Markus Kuhn <http://www.cl.cam.ac.uk/~mgk25/>.
+  //
+  // For original code / licensing please refer to
+  // https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c
+  //
+  while (i < len) {
+    size_t j = i + 8;
+
+    if (j <= len) {
+      //
+      // Read 8 bytes and check if they are ASCII.
+      //
+      uint64_t chunk;
+      memcpy(&chunk, buf + i, 8);
+
+      if ((chunk & 0x8080808080808080) == 0x00) {
+        i = j;
+        continue;
+      }
+    }
+
+    while ((buf[i] & 0x80) == 0x00) { // 0xxxxxxx
+      if (++i == len) {
+        goto exit;
+      }
+    }
+
+    if ((buf[i] & 0xe0) == 0xc0) {  // 110xxxxx 10xxxxxx
+      if (
+        i + 1 == len ||
+        (buf[i + 1] & 0xc0) != 0x80 ||
+        (buf[i] & 0xfe) == 0xc0  // overlong
+      ) {
+        break;
+      }
+
+      i += 2;
+    } else if ((buf[i] & 0xf0) == 0xe0) {  // 1110xxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 2 >= len ||
+        (buf[i + 1] & 0xc0) != 0x80 ||
+        (buf[i + 2] & 0xc0) != 0x80 ||
+        (buf[i] == 0xe0 && (buf[i + 1] & 0xe0) == 0x80) ||  // overlong
+        (buf[i] == 0xed && (buf[i + 1] & 0xe0) == 0xa0)  // surrogate (U+D800 - U+DFFF)
+      ) {
+        break;
+      }
+
+      i += 3;
+    } else if ((buf[i] & 0xf8) == 0xf0) {  // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 3 >= len ||
+        (buf[i + 1] & 0xc0) != 0x80 ||
+        (buf[i + 2] & 0xc0) != 0x80 ||
+        (buf[i + 3] & 0xc0) != 0x80 ||
+        (buf[i] == 0xf0 && (buf[i + 1] & 0xf0) == 0x80) ||  // overlong
+        (buf[i] == 0xf4 && buf[i + 1] > 0x8f) || buf[i] > 0xf4  // > U+10FFFF
+      ) {
+        break;
+      }
+
+      i += 4;
+    } else {
+      break;
+    }
+  }
+
+exit:;
+  napi_value result;
+  status = napi_get_boolean(env, i == len, &result);
+  assert(status == napi_ok);
+
+  return result;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_value isValidUTF8;
+
+  status = napi_create_function(env, NULL, 0, IsValidUTF8, NULL, &isValidUTF8);
+  assert(status == napi_ok);
+
+  return isValidUTF8;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)

node_modules/@react-native/dev-middleware/node_modules/ws/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/@react-native/dev-middleware/node_modules/ws/README.md

@@ -0,0 +1,495 @@
+# ws: a Node.js WebSocket library
+
+[![Version npm](https://img.shields.io/npm/v/ws.svg?logo=npm)](https://www.npmjs.com/package/ws)
+[![CI](https://img.shields.io/github/workflow/status/websockets/ws/CI/master?label=CI&logo=github)](https://github.com/websockets/ws/actions?query=workflow%3ACI+branch%3Amaster)
+[![Coverage Status](https://img.shields.io/coveralls/websockets/ws/master.svg?logo=coveralls)](https://coveralls.io/github/websockets/ws)
+
+ws is a simple to use, blazing fast, and thoroughly tested WebSocket client and
+server implementation.
+
+Passes the quite extensive Autobahn test suite: [server][server-report],
+[client][client-report].
+
+**Note**: This module does not work in the browser. The client in the docs is a
+reference to a back end with the role of a client in the WebSocket
+communication. Browser clients must use the native
+[`WebSocket`](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket)
+object. To make the same code work seamlessly on Node.js and the browser, you
+can use one of the many wrappers available on npm, like
+[isomorphic-ws](https://github.com/heineiuo/isomorphic-ws).
+
+## Table of Contents
+
+- [Protocol support](#protocol-support)
+- [Installing](#installing)
+  - [Opt-in for performance](#opt-in-for-performance)
+- [API docs](#api-docs)
+- [WebSocket compression](#websocket-compression)
+- [Usage examples](#usage-examples)
+  - [Sending and receiving text data](#sending-and-receiving-text-data)
+  - [Sending binary data](#sending-binary-data)
+  - [Simple server](#simple-server)
+  - [External HTTP/S server](#external-https-server)
+  - [Multiple servers sharing a single HTTP/S server](#multiple-servers-sharing-a-single-https-server)
+  - [Client authentication](#client-authentication)
+  - [Server broadcast](#server-broadcast)
+  - [echo.websocket.org demo](#echowebsocketorg-demo)
+  - [Use the Node.js streams API](#use-the-nodejs-streams-api)
+  - [Other examples](#other-examples)
+- [FAQ](#faq)
+  - [How to get the IP address of the client?](#how-to-get-the-ip-address-of-the-client)
+  - [How to detect and close broken connections?](#how-to-detect-and-close-broken-connections)
+  - [How to connect via a proxy?](#how-to-connect-via-a-proxy)
+- [Changelog](#changelog)
+- [License](#license)
+
+## Protocol support
+
+- **HyBi drafts 07-12** (Use the option `protocolVersion: 8`)
+- **HyBi drafts 13-17** (Current default, alternatively option
+  `protocolVersion: 13`)
+
+## Installing
+
+```
+npm install ws
+```
+
+### Opt-in for performance
+
+There are 2 optional modules that can be installed along side with the ws
+module. These modules are binary addons which improve certain operations.
+Prebuilt binaries are available for the most popular platforms so you don't
+necessarily need to have a C++ compiler installed on your machine.
+
+- `npm install --save-optional bufferutil`: Allows to efficiently perform
+  operations such as masking and unmasking the data payload of the WebSocket
+  frames.
+- `npm install --save-optional utf-8-validate`: Allows to efficiently check if a
+  message contains valid UTF-8.
+
+## API docs
+
+See [`/doc/ws.md`](./doc/ws.md) for Node.js-like documentation of ws classes and
+utility functions.
+
+## WebSocket compression
+
+ws supports the [permessage-deflate extension][permessage-deflate] which enables
+the client and server to negotiate a compression algorithm and its parameters,
+and then selectively apply it to the data payloads of each WebSocket message.
+
+The extension is disabled by default on the server and enabled by default on the
+client. It adds a significant overhead in terms of performance and memory
+consumption so we suggest to enable it only if it is really needed.
+
+Note that Node.js has a variety of issues with high-performance compression,
+where increased concurrency, especially on Linux, can lead to [catastrophic
+memory fragmentation][node-zlib-bug] and slow performance. If you intend to use
+permessage-deflate in production, it is worthwhile to set up a test
+representative of your workload and ensure Node.js/zlib will handle it with
+acceptable performance and memory usage.
+
+Tuning of permessage-deflate can be done via the options defined below. You can
+also use `zlibDeflateOptions` and `zlibInflateOptions`, which is passed directly
+into the creation of [raw deflate/inflate streams][node-zlib-deflaterawdocs].
+
+See [the docs][ws-server-options] for more options.
+
+```js
+const WebSocket = require('ws');
+
+const wss = new WebSocket.Server({
+  port: 8080,
+  perMessageDeflate: {
+    zlibDeflateOptions: {
+      // See zlib defaults.
+      chunkSize: 1024,
+      memLevel: 7,
+      level: 3
+    },
+    zlibInflateOptions: {
+      chunkSize: 10 * 1024
+    },
+    // Other options settable:
+    clientNoContextTakeover: true, // Defaults to negotiated value.
+    serverNoContextTakeover: true, // Defaults to negotiated value.
+    serverMaxWindowBits: 10, // Defaults to negotiated value.
+    // Below options specified as default values.
+    concurrencyLimit: 10, // Limits zlib concurrency for perf.
+    threshold: 1024 // Size (in bytes) below which messages
+    // should not be compressed.
+  }
+});
+```
+
+The client will only use the extension if it is supported and enabled on the
+server. To always disable the extension on the client set the
+`perMessageDeflate` option to `false`.
+
+```js
+const WebSocket = require('ws');
+
+const ws = new WebSocket('ws://www.host.com/path', {
+  perMessageDeflate: false
+});
+```
+
+## Usage examples
+
+### Sending and receiving text data
+
+```js
+const WebSocket = require('ws');
+
+const ws = new WebSocket('ws://www.host.com/path');
+
+ws.on('open', function open() {
+  ws.send('something');
+});
+
+ws.on('message', function incoming(data) {
+  console.log(data);
+});
+```
+
+### Sending binary data
+
+```js
+const WebSocket = require('ws');
+
+const ws = new WebSocket('ws://www.host.com/path');
+
+ws.on('open', function open() {
+  const array = new Float32Array(5);
+
+  for (var i = 0; i < array.length; ++i) {
+    array[i] = i / 2;
+  }
+
+  ws.send(array);
+});
+```
+
+### Simple server
+
+```js
+const WebSocket = require('ws');
+
+const wss = new WebSocket.Server({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('message', function incoming(message) {
+    console.log('received: %s', message);
+  });
+
+  ws.send('something');
+});
+```
+
+### External HTTP/S server
+
+```js
+const fs = require('fs');
+const https = require('https');
+const WebSocket = require('ws');
+
+const server = https.createServer({
+  cert: fs.readFileSync('/path/to/cert.pem'),
+  key: fs.readFileSync('/path/to/key.pem')
+});
+const wss = new WebSocket.Server({ server });
+
+wss.on('connection', function connection(ws) {
+  ws.on('message', function incoming(message) {
+    console.log('received: %s', message);
+  });
+
+  ws.send('something');
+});
+
+server.listen(8080);
+```
+
+### Multiple servers sharing a single HTTP/S server
+
+```js
+const http = require('http');
+const WebSocket = require('ws');
+const url = require('url');
+
+const server = http.createServer();
+const wss1 = new WebSocket.Server({ noServer: true });
+const wss2 = new WebSocket.Server({ noServer: true });
+
+wss1.on('connection', function connection(ws) {
+  // ...
+});
+
+wss2.on('connection', function connection(ws) {
+  // ...
+});
+
+server.on('upgrade', function upgrade(request, socket, head) {
+  const pathname = url.parse(request.url).pathname;
+
+  if (pathname === '/foo') {
+    wss1.handleUpgrade(request, socket, head, function done(ws) {
+      wss1.emit('connection', ws, request);
+    });
+  } else if (pathname === '/bar') {
+    wss2.handleUpgrade(request, socket, head, function done(ws) {
+      wss2.emit('connection', ws, request);
+    });
+  } else {
+    socket.destroy();
+  }
+});
+
+server.listen(8080);
+```
+
+### Client authentication
+
+```js
+const http = require('http');
+const WebSocket = require('ws');
+
+const server = http.createServer();
+const wss = new WebSocket.Server({ noServer: true });
+
+wss.on('connection', function connection(ws, request, client) {
+  ws.on('message', function message(msg) {
+    console.log(`Received message ${msg} from user ${client}`);
+  });
+});
+
+server.on('upgrade', function upgrade(request, socket, head) {
+  // This function is not defined on purpose. Implement it with your own logic.
+  authenticate(request, (err, client) => {
+    if (err || !client) {
+      socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+      socket.destroy();
+      return;
+    }
+
+    wss.handleUpgrade(request, socket, head, function done(ws) {
+      wss.emit('connection', ws, request, client);
+    });
+  });
+});
+
+server.listen(8080);
+```
+
+Also see the provided [example][session-parse-example] using `express-session`.
+
+### Server broadcast
+
+A client WebSocket broadcasting to all connected WebSocket clients, including
+itself.
+
+```js
+const WebSocket = require('ws');
+
+const wss = new WebSocket.Server({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('message', function incoming(data) {
+    wss.clients.forEach(function each(client) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    });
+  });
+});
+```
+
+A client WebSocket broadcasting to every other connected WebSocket clients,
+excluding itself.
+
+```js
+const WebSocket = require('ws');
+
+const wss = new WebSocket.Server({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.on('message', function incoming(data) {
+    wss.clients.forEach(function each(client) {
+      if (client !== ws && client.readyState === WebSocket.OPEN) {
+        client.send(data);
+      }
+    });
+  });
+});
+```
+
+### echo.websocket.org demo
+
+```js
+const WebSocket = require('ws');
+
+const ws = new WebSocket('wss://echo.websocket.org/', {
+  origin: 'https://websocket.org'
+});
+
+ws.on('open', function open() {
+  console.log('connected');
+  ws.send(Date.now());
+});
+
+ws.on('close', function close() {
+  console.log('disconnected');
+});
+
+ws.on('message', function incoming(data) {
+  console.log(`Roundtrip time: ${Date.now() - data} ms`);
+
+  setTimeout(function timeout() {
+    ws.send(Date.now());
+  }, 500);
+});
+```
+
+### Use the Node.js streams API
+
+```js
+const WebSocket = require('ws');
+
+const ws = new WebSocket('wss://echo.websocket.org/', {
+  origin: 'https://websocket.org'
+});
+
+const duplex = WebSocket.createWebSocketStream(ws, { encoding: 'utf8' });
+
+duplex.pipe(process.stdout);
+process.stdin.pipe(duplex);
+```
+
+### Other examples
+
+For a full example with a browser client communicating with a ws server, see the
+examples folder.
+
+Otherwise, see the test cases.
+
+## FAQ
+
+### How to get the IP address of the client?
+
+The remote IP address can be obtained from the raw socket.
+
+```js
+const WebSocket = require('ws');
+
+const wss = new WebSocket.Server({ port: 8080 });
+
+wss.on('connection', function connection(ws, req) {
+  const ip = req.socket.remoteAddress;
+});
+```
+
+When the server runs behind a proxy like NGINX, the de-facto standard is to use
+the `X-Forwarded-For` header.
+
+```js
+wss.on('connection', function connection(ws, req) {
+  const ip = req.headers['x-forwarded-for'].split(',')[0].trim();
+});
+```
+
+### How to detect and close broken connections?
+
+Sometimes the link between the server and the client can be interrupted in a way
+that keeps both the server and the client unaware of the broken state of the
+connection (e.g. when pulling the cord).
+
+In these cases ping messages can be used as a means to verify that the remote
+endpoint is still responsive.
+
+```js
+const WebSocket = require('ws');
+
+function noop() {}
+
+function heartbeat() {
+  this.isAlive = true;
+}
+
+const wss = new WebSocket.Server({ port: 8080 });
+
+wss.on('connection', function connection(ws) {
+  ws.isAlive = true;
+  ws.on('pong', heartbeat);
+});
+
+const interval = setInterval(function ping() {
+  wss.clients.forEach(function each(ws) {
+    if (ws.isAlive === false) return ws.terminate();
+
+    ws.isAlive = false;
+    ws.ping(noop);
+  });
+}, 30000);
+
+wss.on('close', function close() {
+  clearInterval(interval);
+});
+```
+
+Pong messages are automatically sent in response to ping messages as required by
+the spec.
+
+Just like the server example above your clients might as well lose connection
+without knowing it. You might want to add a ping listener on your clients to
+prevent that. A simple implementation would be:
+
+```js
+const WebSocket = require('ws');
+
+function heartbeat() {
+  clearTimeout(this.pingTimeout);
+
+  // Use `WebSocket#terminate()`, which immediately destroys the connection,
+  // instead of `WebSocket#close()`, which waits for the close timer.
+  // Delay should be equal to the interval at which your server
+  // sends out pings plus a conservative assumption of the latency.
+  this.pingTimeout = setTimeout(() => {
+    this.terminate();
+  }, 30000 + 1000);
+}
+
+const client = new WebSocket('wss://echo.websocket.org/');
+
+client.on('open', heartbeat);
+client.on('ping', heartbeat);
+client.on('close', function clear() {
+  clearTimeout(this.pingTimeout);
+});
+```
+
+### How to connect via a proxy?
+
+Use a custom `http.Agent` implementation like [https-proxy-agent][] or
+[socks-proxy-agent][].
+
+## Changelog
+
+We're using the GitHub [releases][changelog] for changelog entries.
+
+## License
+
+[MIT](LICENSE)
+
+[changelog]: https://github.com/websockets/ws/releases
+[client-report]: http://websockets.github.io/ws/autobahn/clients/
+[https-proxy-agent]: https://github.com/TooTallNate/node-https-proxy-agent
+[node-zlib-bug]: https://github.com/nodejs/node/issues/8871
+[node-zlib-deflaterawdocs]:
+  https://nodejs.org/api/zlib.html#zlib_zlib_createdeflateraw_options
+[permessage-deflate]: https://tools.ietf.org/html/rfc7692
+[server-report]: http://websockets.github.io/ws/autobahn/servers/
+[session-parse-example]: ./examples/express-session-parse
+[socks-proxy-agent]: https://github.com/TooTallNate/node-socks-proxy-agent
+[ws-server-options]:
+  https://github.com/websockets/ws/blob/master/doc/ws.md#new-websocketserveroptions-callback

node_modules/@react-native/dev-middleware/node_modules/ws/browser.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function () {
+  throw new Error(
+    'ws does not work in the browser. Browser clients must use the native ' +
+      'WebSocket object'
+  );
+};

node_modules/@react-native/dev-middleware/node_modules/ws/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const WebSocket = require('./lib/websocket');
+
+WebSocket.createWebSocketStream = require('./lib/stream');
+WebSocket.Server = require('./lib/websocket-server');
+WebSocket.Receiver = require('./lib/receiver');
+WebSocket.Sender = require('./lib/sender');
+
+module.exports = WebSocket;

node_modules/@react-native/dev-middleware/node_modules/ws/lib/buffer-util.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const { EMPTY_BUFFER } = require('./constants');
+
+/**
+ * Merges an array of buffers into a new buffer.
+ *
+ * @param {Buffer[]} list The array of buffers to concat
+ * @param {Number} totalLength The total length of buffers in the list
+ * @return {Buffer} The resulting buffer
+ * @public
+ */
+function concat(list, totalLength) {
+  if (list.length === 0) return EMPTY_BUFFER;
+  if (list.length === 1) return list[0];
+
+  const target = Buffer.allocUnsafe(totalLength);
+  let offset = 0;
+
+  for (let i = 0; i < list.length; i++) {
+    const buf = list[i];
+    target.set(buf, offset);
+    offset += buf.length;
+  }
+
+  if (offset < totalLength) return target.slice(0, offset);
+
+  return target;
+}
+
+/**
+ * Masks a buffer using the given mask.
+ *
+ * @param {Buffer} source The buffer to mask
+ * @param {Buffer} mask The mask to use
+ * @param {Buffer} output The buffer where to store the result
+ * @param {Number} offset The offset at which to start writing
+ * @param {Number} length The number of bytes to mask.
+ * @public
+ */
+function _mask(source, mask, output, offset, length) {
+  for (let i = 0; i < length; i++) {
+    output[offset + i] = source[i] ^ mask[i & 3];
+  }
+}
+
+/**
+ * Unmasks a buffer using the given mask.
+ *
+ * @param {Buffer} buffer The buffer to unmask
+ * @param {Buffer} mask The mask to use
+ * @public
+ */
+function _unmask(buffer, mask) {
+  // Required until https://github.com/nodejs/node/issues/9006 is resolved.
+  const length = buffer.length;
+  for (let i = 0; i < length; i++) {
+    buffer[i] ^= mask[i & 3];
+  }
+}
+
+/**
+ * Converts a buffer to an `ArrayBuffer`.
+ *
+ * @param {Buffer} buf The buffer to convert
+ * @return {ArrayBuffer} Converted buffer
+ * @public
+ */
+function toArrayBuffer(buf) {
+  if (buf.byteLength === buf.buffer.byteLength) {
+    return buf.buffer;
+  }
+
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+
+/**
+ * Converts `data` to a `Buffer`.
+ *
+ * @param {*} data The data to convert
+ * @return {Buffer} The buffer
+ * @throws {TypeError}
+ * @public
+ */
+function toBuffer(data) {
+  toBuffer.readOnly = true;
+
+  if (Buffer.isBuffer(data)) return data;
+
+  let buf;
+
+  if (data instanceof ArrayBuffer) {
+    buf = Buffer.from(data);
+  } else if (ArrayBuffer.isView(data)) {
+    buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  } else {
+    buf = Buffer.from(data);
+    toBuffer.readOnly = false;
+  }
+
+  return buf;
+}
+
+try {
+  const bufferUtil = require('bufferutil');
+  const bu = bufferUtil.BufferUtil || bufferUtil;
+
+  module.exports = {
+    concat,
+    mask(source, mask, output, offset, length) {
+      if (length < 48) _mask(source, mask, output, offset, length);
+      else bu.mask(source, mask, output, offset, length);
+    },
+    toArrayBuffer,
+    toBuffer,
+    unmask(buffer, mask) {
+      if (buffer.length < 32) _unmask(buffer, mask);
+      else bu.unmask(buffer, mask);
+    }
+  };
+} catch (e) /* istanbul ignore next */ {
+  module.exports = {
+    concat,
+    mask: _mask,
+    toArrayBuffer,
+    toBuffer,
+    unmask: _unmask
+  };
+}

node_modules/@react-native/dev-middleware/node_modules/ws/lib/constants.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = {
+  BINARY_TYPES: ['nodebuffer', 'arraybuffer', 'fragments'],
+  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+  kStatusCode: Symbol('status-code'),
+  kWebSocket: Symbol('websocket'),
+  EMPTY_BUFFER: Buffer.alloc(0),
+  NOOP: () => {}
+};

node_modules/@react-native/dev-middleware/node_modules/ws/lib/event-target.js

@@ -0,0 +1,184 @@
+'use strict';
+
+/**
+ * Class representing an event.
+ *
+ * @private
+ */
+class Event {
+  /**
+   * Create a new `Event`.
+   *
+   * @param {String} type The name of the event
+   * @param {Object} target A reference to the target to which the event was
+   *     dispatched
+   */
+  constructor(type, target) {
+    this.target = target;
+    this.type = type;
+  }
+}
+
+/**
+ * Class representing a message event.
+ *
+ * @extends Event
+ * @private
+ */
+class MessageEvent extends Event {
+  /**
+   * Create a new `MessageEvent`.
+   *
+   * @param {(String|Buffer|ArrayBuffer|Buffer[])} data The received data
+   * @param {WebSocket} target A reference to the target to which the event was
+   *     dispatched
+   */
+  constructor(data, target) {
+    super('message', target);
+
+    this.data = data;
+  }
+}
+
+/**
+ * Class representing a close event.
+ *
+ * @extends Event
+ * @private
+ */
+class CloseEvent extends Event {
+  /**
+   * Create a new `CloseEvent`.
+   *
+   * @param {Number} code The status code explaining why the connection is being
+   *     closed
+   * @param {String} reason A human-readable string explaining why the
+   *     connection is closing
+   * @param {WebSocket} target A reference to the target to which the event was
+   *     dispatched
+   */
+  constructor(code, reason, target) {
+    super('close', target);
+
+    this.wasClean = target._closeFrameReceived && target._closeFrameSent;
+    this.reason = reason;
+    this.code = code;
+  }
+}
+
+/**
+ * Class representing an open event.
+ *
+ * @extends Event
+ * @private
+ */
+class OpenEvent extends Event {
+  /**
+   * Create a new `OpenEvent`.
+   *
+   * @param {WebSocket} target A reference to the target to which the event was
+   *     dispatched
+   */
+  constructor(target) {
+    super('open', target);
+  }
+}
+
+/**
+ * Class representing an error event.
+ *
+ * @extends Event
+ * @private
+ */
+class ErrorEvent extends Event {
+  /**
+   * Create a new `ErrorEvent`.
+   *
+   * @param {Object} error The error that generated this event
+   * @param {WebSocket} target A reference to the target to which the event was
+   *     dispatched
+   */
+  constructor(error, target) {
+    super('error', target);
+
+    this.message = error.message;
+    this.error = error;
+  }
+}
+
+/**
+ * This provides methods for emulating the `EventTarget` interface. It's not
+ * meant to be used directly.
+ *
+ * @mixin
+ */
+const EventTarget = {
+  /**
+   * Register an event listener.
+   *
+   * @param {String} type A string representing the event type to listen for
+   * @param {Function} listener The listener to add
+   * @param {Object} [options] An options object specifies characteristics about
+   *     the event listener
+   * @param {Boolean} [options.once=false] A `Boolean`` indicating that the
+   *     listener should be invoked at most once after being added. If `true`,
+   *     the listener would be automatically removed when invoked.
+   * @public
+   */
+  addEventListener(type, listener, options) {
+    if (typeof listener !== 'function') return;
+
+    function onMessage(data) {
+      listener.call(this, new MessageEvent(data, this));
+    }
+
+    function onClose(code, message) {
+      listener.call(this, new CloseEvent(code, message, this));
+    }
+
+    function onError(error) {
+      listener.call(this, new ErrorEvent(error, this));
+    }
+
+    function onOpen() {
+      listener.call(this, new OpenEvent(this));
+    }
+
+    const method = options && options.once ? 'once' : 'on';
+
+    if (type === 'message') {
+      onMessage._listener = listener;
+      this[method](type, onMessage);
+    } else if (type === 'close') {
+      onClose._listener = listener;
+      this[method](type, onClose);
+    } else if (type === 'error') {
+      onError._listener = listener;
+      this[method](type, onError);
+    } else if (type === 'open') {
+      onOpen._listener = listener;
+      this[method](type, onOpen);
+    } else {
+      this[method](type, listener);
+    }
+  },
+
+  /**
+   * Remove an event listener.
+   *
+   * @param {String} type A string representing the event type to remove
+   * @param {Function} listener The listener to remove
+   * @public
+   */
+  removeEventListener(type, listener) {
+    const listeners = this.listeners(type);
+
+    for (let i = 0; i < listeners.length; i++) {
+      if (listeners[i] === listener || listeners[i]._listener === listener) {
+        this.removeListener(type, listeners[i]);
+      }
+    }
+  }
+};
+
+module.exports = EventTarget;

node_modules/@react-native/dev-middleware/node_modules/ws/lib/extension.js

@@ -0,0 +1,223 @@
+'use strict';
+
+//
+// Allowed token characters:
+//
+// '!', '#', '$', '%', '&', ''', '*', '+', '-',
+// '.', 0-9, A-Z, '^', '_', '`', a-z, '|', '~'
+//
+// tokenChars[32] === 0 // ' '
+// tokenChars[33] === 1 // '!'
+// tokenChars[34] === 0 // '"'
+// ...
+//
+// prettier-ignore
+const tokenChars = [
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 - 15
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
+  0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32 - 47
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 - 63
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80 - 95
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0 // 112 - 127
+];
+
+/**
+ * Adds an offer to the map of extension offers or a parameter to the map of
+ * parameters.
+ *
+ * @param {Object} dest The map of extension offers or parameters
+ * @param {String} name The extension or parameter name
+ * @param {(Object|Boolean|String)} elem The extension parameters or the
+ *     parameter value
+ * @private
+ */
+function push(dest, name, elem) {
+  if (dest[name] === undefined) dest[name] = [elem];
+  else dest[name].push(elem);
+}
+
+/**
+ * Parses the `Sec-WebSocket-Extensions` header into an object.
+ *
+ * @param {String} header The field value of the header
+ * @return {Object} The parsed object
+ * @public
+ */
+function parse(header) {
+  const offers = Object.create(null);
+
+  if (header === undefined || header === '') return offers;
+
+  let params = Object.create(null);
+  let mustUnescape = false;
+  let isEscaping = false;
+  let inQuotes = false;
+  let extensionName;
+  let paramName;
+  let start = -1;
+  let end = -1;
+  let i = 0;
+
+  for (; i < header.length; i++) {
+    const code = header.charCodeAt(i);
+
+    if (extensionName === undefined) {
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (code === 0x20 /* ' ' */ || code === 0x09 /* '\t' */) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b /* ';' */ || code === 0x2c /* ',' */) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        const name = header.slice(start, end);
+        if (code === 0x2c) {
+          push(offers, name, params);
+          params = Object.create(null);
+        } else {
+          extensionName = name;
+        }
+
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else if (paramName === undefined) {
+      if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (code === 0x20 || code === 0x09) {
+        if (end === -1 && start !== -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        push(params, header.slice(start, end), true);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        start = end = -1;
+      } else if (code === 0x3d /* '=' */ && start !== -1 && end === -1) {
+        paramName = header.slice(start, i);
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    } else {
+      //
+      // The value of a quoted-string after unescaping must conform to the
+      // token ABNF, so only token characters are valid.
+      // Ref: https://tools.ietf.org/html/rfc6455#section-9.1
+      //
+      if (isEscaping) {
+        if (tokenChars[code] !== 1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+        if (start === -1) start = i;
+        else if (!mustUnescape) mustUnescape = true;
+        isEscaping = false;
+      } else if (inQuotes) {
+        if (tokenChars[code] === 1) {
+          if (start === -1) start = i;
+        } else if (code === 0x22 /* '"' */ && start !== -1) {
+          inQuotes = false;
+          end = i;
+        } else if (code === 0x5c /* '\' */) {
+          isEscaping = true;
+        } else {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+      } else if (code === 0x22 && header.charCodeAt(i - 1) === 0x3d) {
+        inQuotes = true;
+      } else if (end === -1 && tokenChars[code] === 1) {
+        if (start === -1) start = i;
+      } else if (start !== -1 && (code === 0x20 || code === 0x09)) {
+        if (end === -1) end = i;
+      } else if (code === 0x3b || code === 0x2c) {
+        if (start === -1) {
+          throw new SyntaxError(`Unexpected character at index ${i}`);
+        }
+
+        if (end === -1) end = i;
+        let value = header.slice(start, end);
+        if (mustUnescape) {
+          value = value.replace(/\\/g, '');
+          mustUnescape = false;
+        }
+        push(params, paramName, value);
+        if (code === 0x2c) {
+          push(offers, extensionName, params);
+          params = Object.create(null);
+          extensionName = undefined;
+        }
+
+        paramName = undefined;
+        start = end = -1;
+      } else {
+        throw new SyntaxError(`Unexpected character at index ${i}`);
+      }
+    }
+  }
+
+  if (start === -1 || inQuotes) {
+    throw new SyntaxError('Unexpected end of input');
+  }
+
+  if (end === -1) end = i;
+  const token = header.slice(start, end);
+  if (extensionName === undefined) {
+    push(offers, token, params);
+  } else {
+    if (paramName === undefined) {
+      push(params, token, true);
+    } else if (mustUnescape) {
+      push(params, paramName, token.replace(/\\/g, ''));
+    } else {
+      push(params, paramName, token);
+    }
+    push(offers, extensionName, params);
+  }
+
+  return offers;
+}
+
+/**
+ * Builds the `Sec-WebSocket-Extensions` header field value.
+ *
+ * @param {Object} extensions The map of extensions and parameters to format
+ * @return {String} A string representing the given object
+ * @public
+ */
+function format(extensions) {
+  return Object.keys(extensions)
+    .map((extension) => {
+      let configurations = extensions[extension];
+      if (!Array.isArray(configurations)) configurations = [configurations];
+      return configurations
+        .map((params) => {
+          return [extension]
+            .concat(
+              Object.keys(params).map((k) => {
+                let values = params[k];
+                if (!Array.isArray(values)) values = [values];
+                return values
+                  .map((v) => (v === true ? k : `${k}=${v}`))
+                  .join('; ');
+              })
+            )
+            .join('; ');
+        })
+        .join(', ');
+    })
+    .join(', ');
+}
+
+module.exports = { format, parse };

node_modules/@react-native/dev-middleware/node_modules/ws/lib/limiter.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const kDone = Symbol('kDone');
+const kRun = Symbol('kRun');
+
+/**
+ * A very simple job queue with adjustable concurrency. Adapted from
+ * https://github.com/STRML/async-limiter
+ */
+class Limiter {
+  /**
+   * Creates a new `Limiter`.
+   *
+   * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
+   *     to run concurrently
+   */
+  constructor(concurrency) {
+    this[kDone] = () => {
+      this.pending--;
+      this[kRun]();
+    };
+    this.concurrency = concurrency || Infinity;
+    this.jobs = [];
+    this.pending = 0;
+  }
+
+  /**
+   * Adds a job to the queue.
+   *
+   * @param {Function} job The job to run
+   * @public
+   */
+  add(job) {
+    this.jobs.push(job);
+    this[kRun]();
+  }
+
+  /**
+   * Removes a job from the queue and runs it if possible.
+   *
+   * @private
+   */
+  [kRun]() {
+    if (this.pending === this.concurrency) return;
+
+    if (this.jobs.length) {
+      const job = this.jobs.shift();
+
+      this.pending++;
+      job(this[kDone]);
+    }
+  }
+}
+
+module.exports = Limiter;

node_modules/@react-native/dev-middleware/node_modules/ws/lib/permessage-deflate.js

@@ -0,0 +1,518 @@
+'use strict';
+
+const zlib = require('zlib');
+
+const bufferUtil = require('./buffer-util');
+const Limiter = require('./limiter');
+const { kStatusCode, NOOP } = require('./constants');
+
+const TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
+const kPerMessageDeflate = Symbol('permessage-deflate');
+const kTotalLength = Symbol('total-length');
+const kCallback = Symbol('callback');
+const kBuffers = Symbol('buffers');
+const kError = Symbol('error');
+
+//
+// We limit zlib concurrency, which prevents severe memory fragmentation
+// as documented in https://github.com/nodejs/node/issues/8871#issuecomment-250915913
+// and https://github.com/websockets/ws/issues/1202
+//
+// Intentionally global; it's the global thread pool that's an issue.
+//
+let zlibLimiter;
+
+/**
+ * permessage-deflate implementation.
+ */
+class PerMessageDeflate {
+  /**
+   * Creates a PerMessageDeflate instance.
+   *
+   * @param {Object} [options] Configuration options
+   * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
+   *     disabling of server context takeover
+   * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
+   *     acknowledge disabling of client context takeover
+   * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
+   *     use of a custom server window size
+   * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
+   *     for, or request, a custom client window size
+   * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
+   *     deflate
+   * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
+   *     inflate
+   * @param {Number} [options.threshold=1024] Size (in bytes) below which
+   *     messages should not be compressed
+   * @param {Number} [options.concurrencyLimit=10] The number of concurrent
+   *     calls to zlib
+   * @param {Boolean} [isServer=false] Create the instance in either server or
+   *     client mode
+   * @param {Number} [maxPayload=0] The maximum allowed message length
+   */
+  constructor(options, isServer, maxPayload) {
+    this._maxPayload = maxPayload | 0;
+    this._options = options || {};
+    this._threshold =
+      this._options.threshold !== undefined ? this._options.threshold : 1024;
+    this._isServer = !!isServer;
+    this._deflate = null;
+    this._inflate = null;
+
+    this.params = null;
+
+    if (!zlibLimiter) {
+      const concurrency =
+        this._options.concurrencyLimit !== undefined
+          ? this._options.concurrencyLimit
+          : 10;
+      zlibLimiter = new Limiter(concurrency);
+    }
+  }
+
+  /**
+   * @type {String}
+   */
+  static get extensionName() {
+    return 'permessage-deflate';
+  }
+
+  /**
+   * Create an extension negotiation offer.
+   *
+   * @return {Object} Extension parameters
+   * @public
+   */
+  offer() {
+    const params = {};
+
+    if (this._options.serverNoContextTakeover) {
+      params.server_no_context_takeover = true;
+    }
+    if (this._options.clientNoContextTakeover) {
+      params.client_no_context_takeover = true;
+    }
+    if (this._options.serverMaxWindowBits) {
+      params.server_max_window_bits = this._options.serverMaxWindowBits;
+    }
+    if (this._options.clientMaxWindowBits) {
+      params.client_max_window_bits = this._options.clientMaxWindowBits;
+    } else if (this._options.clientMaxWindowBits == null) {
+      params.client_max_window_bits = true;
+    }
+
+    return params;
+  }
+
+  /**
+   * Accept an extension negotiation offer/response.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Object} Accepted configuration
+   * @public
+   */
+  accept(configurations) {
+    configurations = this.normalizeParams(configurations);
+
+    this.params = this._isServer
+      ? this.acceptAsServer(configurations)
+      : this.acceptAsClient(configurations);
+
+    return this.params;
+  }
+
+  /**
+   * Releases all resources used by the extension.
+   *
+   * @public
+   */
+  cleanup() {
+    if (this._inflate) {
+      this._inflate.close();
+      this._inflate = null;
+    }
+
+    if (this._deflate) {
+      const callback = this._deflate[kCallback];
+
+      this._deflate.close();
+      this._deflate = null;
+
+      if (callback) {
+        callback(
+          new Error(
+            'The deflate stream was closed while data was being processed'
+          )
+        );
+      }
+    }
+  }
+
+  /**
+   *  Accept an extension negotiation offer.
+   *
+   * @param {Array} offers The extension negotiation offers
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsServer(offers) {
+    const opts = this._options;
+    const accepted = offers.find((params) => {
+      if (
+        (opts.serverNoContextTakeover === false &&
+          params.server_no_context_takeover) ||
+        (params.server_max_window_bits &&
+          (opts.serverMaxWindowBits === false ||
+            (typeof opts.serverMaxWindowBits === 'number' &&
+              opts.serverMaxWindowBits > params.server_max_window_bits))) ||
+        (typeof opts.clientMaxWindowBits === 'number' &&
+          !params.client_max_window_bits)
+      ) {
+        return false;
+      }
+
+      return true;
+    });
+
+    if (!accepted) {
+      throw new Error('None of the extension offers can be accepted');
+    }
+
+    if (opts.serverNoContextTakeover) {
+      accepted.server_no_context_takeover = true;
+    }
+    if (opts.clientNoContextTakeover) {
+      accepted.client_no_context_takeover = true;
+    }
+    if (typeof opts.serverMaxWindowBits === 'number') {
+      accepted.server_max_window_bits = opts.serverMaxWindowBits;
+    }
+    if (typeof opts.clientMaxWindowBits === 'number') {
+      accepted.client_max_window_bits = opts.clientMaxWindowBits;
+    } else if (
+      accepted.client_max_window_bits === true ||
+      opts.clientMaxWindowBits === false
+    ) {
+      delete accepted.client_max_window_bits;
+    }
+
+    return accepted;
+  }
+
+  /**
+   * Accept the extension negotiation response.
+   *
+   * @param {Array} response The extension negotiation response
+   * @return {Object} Accepted configuration
+   * @private
+   */
+  acceptAsClient(response) {
+    const params = response[0];
+
+    if (
+      this._options.clientNoContextTakeover === false &&
+      params.client_no_context_takeover
+    ) {
+      throw new Error('Unexpected parameter "client_no_context_takeover"');
+    }
+
+    if (!params.client_max_window_bits) {
+      if (typeof this._options.clientMaxWindowBits === 'number') {
+        params.client_max_window_bits = this._options.clientMaxWindowBits;
+      }
+    } else if (
+      this._options.clientMaxWindowBits === false ||
+      (typeof this._options.clientMaxWindowBits === 'number' &&
+        params.client_max_window_bits > this._options.clientMaxWindowBits)
+    ) {
+      throw new Error(
+        'Unexpected or invalid parameter "client_max_window_bits"'
+      );
+    }
+
+    return params;
+  }
+
+  /**
+   * Normalize parameters.
+   *
+   * @param {Array} configurations The extension negotiation offers/reponse
+   * @return {Array} The offers/response with normalized parameters
+   * @private
+   */
+  normalizeParams(configurations) {
+    configurations.forEach((params) => {
+      Object.keys(params).forEach((key) => {
+        let value = params[key];
+
+        if (value.length > 1) {
+          throw new Error(`Parameter "${key}" must have only a single value`);
+        }
+
+        value = value[0];
+
+        if (key === 'client_max_window_bits') {
+          if (value !== true) {
+            const num = +value;
+            if (!Number.isInteger(num) || num < 8 || num > 15) {
+              throw new TypeError(
+                `Invalid value for parameter "${key}": ${value}`
+              );
+            }
+            value = num;
+          } else if (!this._isServer) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+        } else if (key === 'server_max_window_bits') {
+          const num = +value;
+          if (!Number.isInteger(num) || num < 8 || num > 15) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+          value = num;
+        } else if (
+          key === 'client_no_context_takeover' ||
+          key === 'server_no_context_takeover'
+        ) {
+          if (value !== true) {
+            throw new TypeError(
+              `Invalid value for parameter "${key}": ${value}`
+            );
+          }
+        } else {
+          throw new Error(`Unknown parameter "${key}"`);
+        }
+
+        params[key] = value;
+      });
+    });
+
+    return configurations;
+  }
+
+  /**
+   * Decompress data. Concurrency limited.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  decompress(data, fin, callback) {
+    zlibLimiter.add((done) => {
+      this._decompress(data, fin, (err, result) => {
+        done();
+        callback(err, result);
+      });
+    });
+  }
+
+  /**
+   * Compress data. Concurrency limited.
+   *
+   * @param {Buffer} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @public
+   */
+  compress(data, fin, callback) {
+    zlibLimiter.add((done) => {
+      this._compress(data, fin, (err, result) => {
+        done();
+        callback(err, result);
+      });
+    });
+  }
+
+  /**
+   * Decompress data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _decompress(data, fin, callback) {
+    const endpoint = this._isServer ? 'client' : 'server';
+
+    if (!this._inflate) {
+      const key = `${endpoint}_max_window_bits`;
+      const windowBits =
+        typeof this.params[key] !== 'number'
+          ? zlib.Z_DEFAULT_WINDOWBITS
+          : this.params[key];
+
+      this._inflate = zlib.createInflateRaw({
+        ...this._options.zlibInflateOptions,
+        windowBits
+      });
+      this._inflate[kPerMessageDeflate] = this;
+      this._inflate[kTotalLength] = 0;
+      this._inflate[kBuffers] = [];
+      this._inflate.on('error', inflateOnError);
+      this._inflate.on('data', inflateOnData);
+    }
+
+    this._inflate[kCallback] = callback;
+
+    this._inflate.write(data);
+    if (fin) this._inflate.write(TRAILER);
+
+    this._inflate.flush(() => {
+      const err = this._inflate[kError];
+
+      if (err) {
+        this._inflate.close();
+        this._inflate = null;
+        callback(err);
+        return;
+      }
+
+      const data = bufferUtil.concat(
+        this._inflate[kBuffers],
+        this._inflate[kTotalLength]
+      );
+
+      if (this._inflate._readableState.endEmitted) {
+        this._inflate.close();
+        this._inflate = null;
+      } else {
+        this._inflate[kTotalLength] = 0;
+        this._inflate[kBuffers] = [];
+
+        if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+          this._inflate.reset();
+        }
+      }
+
+      callback(null, data);
+    });
+  }
+
+  /**
+   * Compress data.
+   *
+   * @param {Buffer} data Data to compress
+   * @param {Boolean} fin Specifies whether or not this is the last fragment
+   * @param {Function} callback Callback
+   * @private
+   */
+  _compress(data, fin, callback) {
+    const endpoint = this._isServer ? 'server' : 'client';
+
+    if (!this._deflate) {
+      const key = `${endpoint}_max_window_bits`;
+      const windowBits =
+        typeof this.params[key] !== 'number'
+          ? zlib.Z_DEFAULT_WINDOWBITS
+          : this.params[key];
+
+      this._deflate = zlib.createDeflateRaw({
+        ...this._options.zlibDeflateOptions,
+        windowBits
+      });
+
+      this._deflate[kTotalLength] = 0;
+      this._deflate[kBuffers] = [];
+
+      //
+      // An `'error'` event is emitted, only on Node.js < 10.0.0, if the
+      // `zlib.DeflateRaw` instance is closed while data is being processed.
+      // This can happen if `PerMessageDeflate#cleanup()` is called at the wrong
+      // time due to an abnormal WebSocket closure.
+      //
+      this._deflate.on('error', NOOP);
+      this._deflate.on('data', deflateOnData);
+    }
+
+    this._deflate[kCallback] = callback;
+
+    this._deflate.write(data);
+    this._deflate.flush(zlib.Z_SYNC_FLUSH, () => {
+      if (!this._deflate) {
+        //
+        // The deflate stream was closed while data was being processed.
+        //
+        return;
+      }
+
+      let data = bufferUtil.concat(
+        this._deflate[kBuffers],
+        this._deflate[kTotalLength]
+      );
+
+      if (fin) data = data.slice(0, data.length - 4);
+
+      //
+      // Ensure that the callback will not be called again in
+      // `PerMessageDeflate#cleanup()`.
+      //
+      this._deflate[kCallback] = null;
+
+      this._deflate[kTotalLength] = 0;
+      this._deflate[kBuffers] = [];
+
+      if (fin && this.params[`${endpoint}_no_context_takeover`]) {
+        this._deflate.reset();
+      }
+
+      callback(null, data);
+    });
+  }
+}
+
+module.exports = PerMessageDeflate;
+
+/**
+ * The listener of the `zlib.DeflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function deflateOnData(chunk) {
+  this[kBuffers].push(chunk);
+  this[kTotalLength] += chunk.length;
+}
+
+/**
+ * The listener of the `zlib.InflateRaw` stream `'data'` event.
+ *
+ * @param {Buffer} chunk A chunk of data
+ * @private
+ */
+function inflateOnData(chunk) {
+  this[kTotalLength] += chunk.length;
+
+  if (
+    this[kPerMessageDeflate]._maxPayload < 1 ||
+    this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload
+  ) {
+    this[kBuffers].push(chunk);
+    return;
+  }
+
+  this[kError] = new RangeError('Max payload size exceeded');
+  this[kError].code = 'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH';
+  this[kError][kStatusCode] = 1009;
+  this.removeListener('data', inflateOnData);
+  this.reset();
+}
+
+/**
+ * The listener of the `zlib.InflateRaw` stream `'error'` event.
+ *
+ * @param {Error} err The emitted error
+ * @private
+ */
+function inflateOnError(err) {
+  //
+  // There is no need to call `Zlib#close()` as the handle is automatically
+  // closed when an error is emitted.
+  //
+  this[kPerMessageDeflate]._inflate = null;
+  err[kStatusCode] = 1007;
+  this[kCallback](err);
+}

node_modules/@react-native/dev-middleware/node_modules/ws/lib/receiver.js

@@ -0,0 +1,607 @@
+'use strict';
+
+const { Writable } = require('stream');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const {
+  BINARY_TYPES,
+  EMPTY_BUFFER,
+  kStatusCode,
+  kWebSocket
+} = require('./constants');
+const { concat, toArrayBuffer, unmask } = require('./buffer-util');
+const { isValidStatusCode, isValidUTF8 } = require('./validation');
+
+const GET_INFO = 0;
+const GET_PAYLOAD_LENGTH_16 = 1;
+const GET_PAYLOAD_LENGTH_64 = 2;
+const GET_MASK = 3;
+const GET_DATA = 4;
+const INFLATING = 5;
+
+/**
+ * HyBi Receiver implementation.
+ *
+ * @extends Writable
+ */
+class Receiver extends Writable {
+  /**
+   * Creates a Receiver instance.
+   *
+   * @param {String} [binaryType=nodebuffer] The type for binary data
+   * @param {Object} [extensions] An object containing the negotiated extensions
+   * @param {Boolean} [isServer=false] Specifies whether to operate in client or
+   *     server mode
+   * @param {Number} [maxPayload=0] The maximum allowed message length
+   */
+  constructor(binaryType, extensions, isServer, maxPayload) {
+    super();
+
+    this._binaryType = binaryType || BINARY_TYPES[0];
+    this[kWebSocket] = undefined;
+    this._extensions = extensions || {};
+    this._isServer = !!isServer;
+    this._maxPayload = maxPayload | 0;
+
+    this._bufferedBytes = 0;
+    this._buffers = [];
+
+    this._compressed = false;
+    this._payloadLength = 0;
+    this._mask = undefined;
+    this._fragmented = 0;
+    this._masked = false;
+    this._fin = false;
+    this._opcode = 0;
+
+    this._totalPayloadLength = 0;
+    this._messageLength = 0;
+    this._fragments = [];
+
+    this._state = GET_INFO;
+    this._loop = false;
+  }
+
+  /**
+   * Implements `Writable.prototype._write()`.
+   *
+   * @param {Buffer} chunk The chunk of data to write
+   * @param {String} encoding The character encoding of `chunk`
+   * @param {Function} cb Callback
+   * @private
+   */
+  _write(chunk, encoding, cb) {
+    if (this._opcode === 0x08 && this._state == GET_INFO) return cb();
+
+    this._bufferedBytes += chunk.length;
+    this._buffers.push(chunk);
+    this.startLoop(cb);
+  }
+
+  /**
+   * Consumes `n` bytes from the buffered data.
+   *
+   * @param {Number} n The number of bytes to consume
+   * @return {Buffer} The consumed bytes
+   * @private
+   */
+  consume(n) {
+    this._bufferedBytes -= n;
+
+    if (n === this._buffers[0].length) return this._buffers.shift();
+
+    if (n < this._buffers[0].length) {
+      const buf = this._buffers[0];
+      this._buffers[0] = buf.slice(n);
+      return buf.slice(0, n);
+    }
+
+    const dst = Buffer.allocUnsafe(n);
+
+    do {
+      const buf = this._buffers[0];
+      const offset = dst.length - n;
+
+      if (n >= buf.length) {
+        dst.set(this._buffers.shift(), offset);
+      } else {
+        dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n), offset);
+        this._buffers[0] = buf.slice(n);
+      }
+
+      n -= buf.length;
+    } while (n > 0);
+
+    return dst;
+  }
+
+  /**
+   * Starts the parsing loop.
+   *
+   * @param {Function} cb Callback
+   * @private
+   */
+  startLoop(cb) {
+    let err;
+    this._loop = true;
+
+    do {
+      switch (this._state) {
+        case GET_INFO:
+          err = this.getInfo();
+          break;
+        case GET_PAYLOAD_LENGTH_16:
+          err = this.getPayloadLength16();
+          break;
+        case GET_PAYLOAD_LENGTH_64:
+          err = this.getPayloadLength64();
+          break;
+        case GET_MASK:
+          this.getMask();
+          break;
+        case GET_DATA:
+          err = this.getData(cb);
+          break;
+        default:
+          // `INFLATING`
+          this._loop = false;
+          return;
+      }
+    } while (this._loop);
+
+    cb(err);
+  }
+
+  /**
+   * Reads the first two bytes of a frame.
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getInfo() {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(2);
+
+    if ((buf[0] & 0x30) !== 0x00) {
+      this._loop = false;
+      return error(
+        RangeError,
+        'RSV2 and RSV3 must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_RSV_2_3'
+      );
+    }
+
+    const compressed = (buf[0] & 0x40) === 0x40;
+
+    if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
+      this._loop = false;
+      return error(
+        RangeError,
+        'RSV1 must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_RSV_1'
+      );
+    }
+
+    this._fin = (buf[0] & 0x80) === 0x80;
+    this._opcode = buf[0] & 0x0f;
+    this._payloadLength = buf[1] & 0x7f;
+
+    if (this._opcode === 0x00) {
+      if (compressed) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'RSV1 must be clear',
+          true,
+          1002,
+          'WS_ERR_UNEXPECTED_RSV_1'
+        );
+      }
+
+      if (!this._fragmented) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'invalid opcode 0',
+          true,
+          1002,
+          'WS_ERR_INVALID_OPCODE'
+        );
+      }
+
+      this._opcode = this._fragmented;
+    } else if (this._opcode === 0x01 || this._opcode === 0x02) {
+      if (this._fragmented) {
+        this._loop = false;
+        return error(
+          RangeError,
+          `invalid opcode ${this._opcode}`,
+          true,
+          1002,
+          'WS_ERR_INVALID_OPCODE'
+        );
+      }
+
+      this._compressed = compressed;
+    } else if (this._opcode > 0x07 && this._opcode < 0x0b) {
+      if (!this._fin) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'FIN must be set',
+          true,
+          1002,
+          'WS_ERR_EXPECTED_FIN'
+        );
+      }
+
+      if (compressed) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'RSV1 must be clear',
+          true,
+          1002,
+          'WS_ERR_UNEXPECTED_RSV_1'
+        );
+      }
+
+      if (this._payloadLength > 0x7d) {
+        this._loop = false;
+        return error(
+          RangeError,
+          `invalid payload length ${this._payloadLength}`,
+          true,
+          1002,
+          'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
+        );
+      }
+    } else {
+      this._loop = false;
+      return error(
+        RangeError,
+        `invalid opcode ${this._opcode}`,
+        true,
+        1002,
+        'WS_ERR_INVALID_OPCODE'
+      );
+    }
+
+    if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
+    this._masked = (buf[1] & 0x80) === 0x80;
+
+    if (this._isServer) {
+      if (!this._masked) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'MASK must be set',
+          true,
+          1002,
+          'WS_ERR_EXPECTED_MASK'
+        );
+      }
+    } else if (this._masked) {
+      this._loop = false;
+      return error(
+        RangeError,
+        'MASK must be clear',
+        true,
+        1002,
+        'WS_ERR_UNEXPECTED_MASK'
+      );
+    }
+
+    if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
+    else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
+    else return this.haveLength();
+  }
+
+  /**
+   * Gets extended payload length (7+16).
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getPayloadLength16() {
+    if (this._bufferedBytes < 2) {
+      this._loop = false;
+      return;
+    }
+
+    this._payloadLength = this.consume(2).readUInt16BE(0);
+    return this.haveLength();
+  }
+
+  /**
+   * Gets extended payload length (7+64).
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  getPayloadLength64() {
+    if (this._bufferedBytes < 8) {
+      this._loop = false;
+      return;
+    }
+
+    const buf = this.consume(8);
+    const num = buf.readUInt32BE(0);
+
+    //
+    // The maximum safe integer in JavaScript is 2^53 - 1. An error is returned
+    // if payload length is greater than this number.
+    //
+    if (num > Math.pow(2, 53 - 32) - 1) {
+      this._loop = false;
+      return error(
+        RangeError,
+        'Unsupported WebSocket frame: payload length > 2^53 - 1',
+        false,
+        1009,
+        'WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH'
+      );
+    }
+
+    this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
+    return this.haveLength();
+  }
+
+  /**
+   * Payload length has been read.
+   *
+   * @return {(RangeError|undefined)} A possible error
+   * @private
+   */
+  haveLength() {
+    if (this._payloadLength && this._opcode < 0x08) {
+      this._totalPayloadLength += this._payloadLength;
+      if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
+        this._loop = false;
+        return error(
+          RangeError,
+          'Max payload size exceeded',
+          false,
+          1009,
+          'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+        );
+      }
+    }
+
+    if (this._masked) this._state = GET_MASK;
+    else this._state = GET_DATA;
+  }
+
+  /**
+   * Reads mask bytes.
+   *
+   * @private
+   */
+  getMask() {
+    if (this._bufferedBytes < 4) {
+      this._loop = false;
+      return;
+    }
+
+    this._mask = this.consume(4);
+    this._state = GET_DATA;
+  }
+
+  /**
+   * Reads data bytes.
+   *
+   * @param {Function} cb Callback
+   * @return {(Error|RangeError|undefined)} A possible error
+   * @private
+   */
+  getData(cb) {
+    let data = EMPTY_BUFFER;
+
+    if (this._payloadLength) {
+      if (this._bufferedBytes < this._payloadLength) {
+        this._loop = false;
+        return;
+      }
+
+      data = this.consume(this._payloadLength);
+      if (this._masked) unmask(data, this._mask);
+    }
+
+    if (this._opcode > 0x07) return this.controlMessage(data);
+
+    if (this._compressed) {
+      this._state = INFLATING;
+      this.decompress(data, cb);
+      return;
+    }
+
+    if (data.length) {
+      //
+      // This message is not compressed so its lenght is the sum of the payload
+      // length of all fragments.
+      //
+      this._messageLength = this._totalPayloadLength;
+      this._fragments.push(data);
+    }
+
+    return this.dataMessage();
+  }
+
+  /**
+   * Decompresses data.
+   *
+   * @param {Buffer} data Compressed data
+   * @param {Function} cb Callback
+   * @private
+   */
+  decompress(data, cb) {
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+
+    perMessageDeflate.decompress(data, this._fin, (err, buf) => {
+      if (err) return cb(err);
+
+      if (buf.length) {
+        this._messageLength += buf.length;
+        if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
+          return cb(
+            error(
+              RangeError,
+              'Max payload size exceeded',
+              false,
+              1009,
+              'WS_ERR_UNSUPPORTED_MESSAGE_LENGTH'
+            )
+          );
+        }
+
+        this._fragments.push(buf);
+      }
+
+      const er = this.dataMessage();
+      if (er) return cb(er);
+
+      this.startLoop(cb);
+    });
+  }
+
+  /**
+   * Handles a data message.
+   *
+   * @return {(Error|undefined)} A possible error
+   * @private
+   */
+  dataMessage() {
+    if (this._fin) {
+      const messageLength = this._messageLength;
+      const fragments = this._fragments;
+
+      this._totalPayloadLength = 0;
+      this._messageLength = 0;
+      this._fragmented = 0;
+      this._fragments = [];
+
+      if (this._opcode === 2) {
+        let data;
+
+        if (this._binaryType === 'nodebuffer') {
+          data = concat(fragments, messageLength);
+        } else if (this._binaryType === 'arraybuffer') {
+          data = toArrayBuffer(concat(fragments, messageLength));
+        } else {
+          data = fragments;
+        }
+
+        this.emit('message', data);
+      } else {
+        const buf = concat(fragments, messageLength);
+
+        if (!isValidUTF8(buf)) {
+          this._loop = false;
+          return error(
+            Error,
+            'invalid UTF-8 sequence',
+            true,
+            1007,
+            'WS_ERR_INVALID_UTF8'
+          );
+        }
+
+        this.emit('message', buf.toString());
+      }
+    }
+
+    this._state = GET_INFO;
+  }
+
+  /**
+   * Handles a control message.
+   *
+   * @param {Buffer} data Data to handle
+   * @return {(Error|RangeError|undefined)} A possible error
+   * @private
+   */
+  controlMessage(data) {
+    if (this._opcode === 0x08) {
+      this._loop = false;
+
+      if (data.length === 0) {
+        this.emit('conclude', 1005, '');
+        this.end();
+      } else if (data.length === 1) {
+        return error(
+          RangeError,
+          'invalid payload length 1',
+          true,
+          1002,
+          'WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH'
+        );
+      } else {
+        const code = data.readUInt16BE(0);
+
+        if (!isValidStatusCode(code)) {
+          return error(
+            RangeError,
+            `invalid status code ${code}`,
+            true,
+            1002,
+            'WS_ERR_INVALID_CLOSE_CODE'
+          );
+        }
+
+        const buf = data.slice(2);
+
+        if (!isValidUTF8(buf)) {
+          return error(
+            Error,
+            'invalid UTF-8 sequence',
+            true,
+            1007,
+            'WS_ERR_INVALID_UTF8'
+          );
+        }
+
+        this.emit('conclude', code, buf.toString());
+        this.end();
+      }
+    } else if (this._opcode === 0x09) {
+      this.emit('ping', data);
+    } else {
+      this.emit('pong', data);
+    }
+
+    this._state = GET_INFO;
+  }
+}
+
+module.exports = Receiver;
+
+/**
+ * Builds an error object.
+ *
+ * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
+ * @param {String} message The error message
+ * @param {Boolean} prefix Specifies whether or not to add a default prefix to
+ *     `message`
+ * @param {Number} statusCode The status code
+ * @param {String} errorCode The exposed error code
+ * @return {(Error|RangeError)} The error
+ * @private
+ */
+function error(ErrorCtor, message, prefix, statusCode, errorCode) {
+  const err = new ErrorCtor(
+    prefix ? `Invalid WebSocket frame: ${message}` : message
+  );
+
+  Error.captureStackTrace(err, error);
+  err.code = errorCode;
+  err[kStatusCode] = statusCode;
+  return err;
+}

node_modules/@react-native/dev-middleware/node_modules/ws/lib/sender.js

@@ -0,0 +1,409 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^net|tls$" }] */
+
+'use strict';
+
+const net = require('net');
+const tls = require('tls');
+const { randomFillSync } = require('crypto');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const { EMPTY_BUFFER } = require('./constants');
+const { isValidStatusCode } = require('./validation');
+const { mask: applyMask, toBuffer } = require('./buffer-util');
+
+const mask = Buffer.alloc(4);
+
+/**
+ * HyBi Sender implementation.
+ */
+class Sender {
+  /**
+   * Creates a Sender instance.
+   *
+   * @param {(net.Socket|tls.Socket)} socket The connection socket
+   * @param {Object} [extensions] An object containing the negotiated extensions
+   */
+  constructor(socket, extensions) {
+    this._extensions = extensions || {};
+    this._socket = socket;
+
+    this._firstFragment = true;
+    this._compress = false;
+
+    this._bufferedBytes = 0;
+    this._deflating = false;
+    this._queue = [];
+  }
+
+  /**
+   * Frames a piece of data according to the HyBi WebSocket protocol.
+   *
+   * @param {Buffer} data The data to frame
+   * @param {Object} options Options object
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @return {Buffer[]} The framed data as a list of `Buffer` instances
+   * @public
+   */
+  static frame(data, options) {
+    const merge = options.mask && options.readOnly;
+    let offset = options.mask ? 6 : 2;
+    let payloadLength = data.length;
+
+    if (data.length >= 65536) {
+      offset += 8;
+      payloadLength = 127;
+    } else if (data.length > 125) {
+      offset += 2;
+      payloadLength = 126;
+    }
+
+    const target = Buffer.allocUnsafe(merge ? data.length + offset : offset);
+
+    target[0] = options.fin ? options.opcode | 0x80 : options.opcode;
+    if (options.rsv1) target[0] |= 0x40;
+
+    target[1] = payloadLength;
+
+    if (payloadLength === 126) {
+      target.writeUInt16BE(data.length, 2);
+    } else if (payloadLength === 127) {
+      target.writeUInt32BE(0, 2);
+      target.writeUInt32BE(data.length, 6);
+    }
+
+    if (!options.mask) return [target, data];
+
+    randomFillSync(mask, 0, 4);
+
+    target[1] |= 0x80;
+    target[offset - 4] = mask[0];
+    target[offset - 3] = mask[1];
+    target[offset - 2] = mask[2];
+    target[offset - 1] = mask[3];
+
+    if (merge) {
+      applyMask(data, mask, target, offset, data.length);
+      return [target];
+    }
+
+    applyMask(data, mask, data, 0, data.length);
+    return [target, data];
+  }
+
+  /**
+   * Sends a close message to the other peer.
+   *
+   * @param {Number} [code] The status code component of the body
+   * @param {String} [data] The message component of the body
+   * @param {Boolean} [mask=false] Specifies whether or not to mask the message
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  close(code, data, mask, cb) {
+    let buf;
+
+    if (code === undefined) {
+      buf = EMPTY_BUFFER;
+    } else if (typeof code !== 'number' || !isValidStatusCode(code)) {
+      throw new TypeError('First argument must be a valid error code number');
+    } else if (data === undefined || data === '') {
+      buf = Buffer.allocUnsafe(2);
+      buf.writeUInt16BE(code, 0);
+    } else {
+      const length = Buffer.byteLength(data);
+
+      if (length > 123) {
+        throw new RangeError('The message must not be greater than 123 bytes');
+      }
+
+      buf = Buffer.allocUnsafe(2 + length);
+      buf.writeUInt16BE(code, 0);
+      buf.write(data, 2);
+    }
+
+    if (this._deflating) {
+      this.enqueue([this.doClose, buf, mask, cb]);
+    } else {
+      this.doClose(buf, mask, cb);
+    }
+  }
+
+  /**
+   * Frames and sends a close message.
+   *
+   * @param {Buffer} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  doClose(data, mask, cb) {
+    this.sendFrame(
+      Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 0x08,
+        mask,
+        readOnly: false
+      }),
+      cb
+    );
+  }
+
+  /**
+   * Sends a ping message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  ping(data, mask, cb) {
+    const buf = toBuffer(data);
+
+    if (buf.length > 125) {
+      throw new RangeError('The data size must not be greater than 125 bytes');
+    }
+
+    if (this._deflating) {
+      this.enqueue([this.doPing, buf, mask, toBuffer.readOnly, cb]);
+    } else {
+      this.doPing(buf, mask, toBuffer.readOnly, cb);
+    }
+  }
+
+  /**
+   * Frames and sends a ping message.
+   *
+   * @param {Buffer} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  doPing(data, mask, readOnly, cb) {
+    this.sendFrame(
+      Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 0x09,
+        mask,
+        readOnly
+      }),
+      cb
+    );
+  }
+
+  /**
+   * Sends a pong message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  pong(data, mask, cb) {
+    const buf = toBuffer(data);
+
+    if (buf.length > 125) {
+      throw new RangeError('The data size must not be greater than 125 bytes');
+    }
+
+    if (this._deflating) {
+      this.enqueue([this.doPong, buf, mask, toBuffer.readOnly, cb]);
+    } else {
+      this.doPong(buf, mask, toBuffer.readOnly, cb);
+    }
+  }
+
+  /**
+   * Frames and sends a pong message.
+   *
+   * @param {Buffer} data The message to send
+   * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
+   * @param {Boolean} [readOnly=false] Specifies whether `data` can be modified
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  doPong(data, mask, readOnly, cb) {
+    this.sendFrame(
+      Sender.frame(data, {
+        fin: true,
+        rsv1: false,
+        opcode: 0x0a,
+        mask,
+        readOnly
+      }),
+      cb
+    );
+  }
+
+  /**
+   * Sends a data message to the other peer.
+   *
+   * @param {*} data The message to send
+   * @param {Object} options Options object
+   * @param {Boolean} [options.compress=false] Specifies whether or not to
+   *     compress `data`
+   * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
+   *     or text
+   * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
+   *     last one
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  send(data, options, cb) {
+    const buf = toBuffer(data);
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+    let opcode = options.binary ? 2 : 1;
+    let rsv1 = options.compress;
+
+    if (this._firstFragment) {
+      this._firstFragment = false;
+      if (rsv1 && perMessageDeflate) {
+        rsv1 = buf.length >= perMessageDeflate._threshold;
+      }
+      this._compress = rsv1;
+    } else {
+      rsv1 = false;
+      opcode = 0;
+    }
+
+    if (options.fin) this._firstFragment = true;
+
+    if (perMessageDeflate) {
+      const opts = {
+        fin: options.fin,
+        rsv1,
+        opcode,
+        mask: options.mask,
+        readOnly: toBuffer.readOnly
+      };
+
+      if (this._deflating) {
+        this.enqueue([this.dispatch, buf, this._compress, opts, cb]);
+      } else {
+        this.dispatch(buf, this._compress, opts, cb);
+      }
+    } else {
+      this.sendFrame(
+        Sender.frame(buf, {
+          fin: options.fin,
+          rsv1: false,
+          opcode,
+          mask: options.mask,
+          readOnly: toBuffer.readOnly
+        }),
+        cb
+      );
+    }
+  }
+
+  /**
+   * Dispatches a data message.
+   *
+   * @param {Buffer} data The message to send
+   * @param {Boolean} [compress=false] Specifies whether or not to compress
+   *     `data`
+   * @param {Object} options Options object
+   * @param {Number} options.opcode The opcode
+   * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
+   *     modified
+   * @param {Boolean} [options.fin=false] Specifies whether or not to set the
+   *     FIN bit
+   * @param {Boolean} [options.mask=false] Specifies whether or not to mask
+   *     `data`
+   * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
+   *     RSV1 bit
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  dispatch(data, compress, options, cb) {
+    if (!compress) {
+      this.sendFrame(Sender.frame(data, options), cb);
+      return;
+    }
+
+    const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
+
+    this._bufferedBytes += data.length;
+    this._deflating = true;
+    perMessageDeflate.compress(data, options.fin, (_, buf) => {
+      if (this._socket.destroyed) {
+        const err = new Error(
+          'The socket was closed while data was being compressed'
+        );
+
+        if (typeof cb === 'function') cb(err);
+
+        for (let i = 0; i < this._queue.length; i++) {
+          const callback = this._queue[i][4];
+
+          if (typeof callback === 'function') callback(err);
+        }
+
+        return;
+      }
+
+      this._bufferedBytes -= data.length;
+      this._deflating = false;
+      options.readOnly = false;
+      this.sendFrame(Sender.frame(buf, options), cb);
+      this.dequeue();
+    });
+  }
+
+  /**
+   * Executes queued send operations.
+   *
+   * @private
+   */
+  dequeue() {
+    while (!this._deflating && this._queue.length) {
+      const params = this._queue.shift();
+
+      this._bufferedBytes -= params[1].length;
+      Reflect.apply(params[0], this, params.slice(1));
+    }
+  }
+
+  /**
+   * Enqueues a send operation.
+   *
+   * @param {Array} params Send operation parameters.
+   * @private
+   */
+  enqueue(params) {
+    this._bufferedBytes += params[1].length;
+    this._queue.push(params);
+  }
+
+  /**
+   * Sends a frame.
+   *
+   * @param {Buffer[]} list The frame to send
+   * @param {Function} [cb] Callback
+   * @private
+   */
+  sendFrame(list, cb) {
+    if (list.length === 2) {
+      this._socket.cork();
+      this._socket.write(list[0]);
+      this._socket.write(list[1], cb);
+      this._socket.uncork();
+    } else {
+      this._socket.write(list[0], cb);
+    }
+  }
+}
+
+module.exports = Sender;

node_modules/@react-native/dev-middleware/node_modules/ws/lib/stream.js

@@ -0,0 +1,180 @@
+'use strict';
+
+const { Duplex } = require('stream');
+
+/**
+ * Emits the `'close'` event on a stream.
+ *
+ * @param {Duplex} stream The stream.
+ * @private
+ */
+function emitClose(stream) {
+  stream.emit('close');
+}
+
+/**
+ * The listener of the `'end'` event.
+ *
+ * @private
+ */
+function duplexOnEnd() {
+  if (!this.destroyed && this._writableState.finished) {
+    this.destroy();
+  }
+}
+
+/**
+ * The listener of the `'error'` event.
+ *
+ * @param {Error} err The error
+ * @private
+ */
+function duplexOnError(err) {
+  this.removeListener('error', duplexOnError);
+  this.destroy();
+  if (this.listenerCount('error') === 0) {
+    // Do not suppress the throwing behavior.
+    this.emit('error', err);
+  }
+}
+
+/**
+ * Wraps a `WebSocket` in a duplex stream.
+ *
+ * @param {WebSocket} ws The `WebSocket` to wrap
+ * @param {Object} [options] The options for the `Duplex` constructor
+ * @return {Duplex} The duplex stream
+ * @public
+ */
+function createWebSocketStream(ws, options) {
+  let resumeOnReceiverDrain = true;
+  let terminateOnDestroy = true;
+
+  function receiverOnDrain() {
+    if (resumeOnReceiverDrain) ws._socket.resume();
+  }
+
+  if (ws.readyState === ws.CONNECTING) {
+    ws.once('open', function open() {
+      ws._receiver.removeAllListeners('drain');
+      ws._receiver.on('drain', receiverOnDrain);
+    });
+  } else {
+    ws._receiver.removeAllListeners('drain');
+    ws._receiver.on('drain', receiverOnDrain);
+  }
+
+  const duplex = new Duplex({
+    ...options,
+    autoDestroy: false,
+    emitClose: false,
+    objectMode: false,
+    writableObjectMode: false
+  });
+
+  ws.on('message', function message(msg) {
+    if (!duplex.push(msg)) {
+      resumeOnReceiverDrain = false;
+      ws._socket.pause();
+    }
+  });
+
+  ws.once('error', function error(err) {
+    if (duplex.destroyed) return;
+
+    // Prevent `ws.terminate()` from being called by `duplex._destroy()`.
+    //
+    // - If the `'error'` event is emitted before the `'open'` event, then
+    //   `ws.terminate()` is a noop as no socket is assigned.
+    // - Otherwise, the error is re-emitted by the listener of the `'error'`
+    //   event of the `Receiver` object. The listener already closes the
+    //   connection by calling `ws.close()`. This allows a close frame to be
+    //   sent to the other peer. If `ws.terminate()` is called right after this,
+    //   then the close frame might not be sent.
+    terminateOnDestroy = false;
+    duplex.destroy(err);
+  });
+
+  ws.once('close', function close() {
+    if (duplex.destroyed) return;
+
+    duplex.push(null);
+  });
+
+  duplex._destroy = function (err, callback) {
+    if (ws.readyState === ws.CLOSED) {
+      callback(err);
+      process.nextTick(emitClose, duplex);
+      return;
+    }
+
+    let called = false;
+
+    ws.once('error', function error(err) {
+      called = true;
+      callback(err);
+    });
+
+    ws.once('close', function close() {
+      if (!called) callback(err);
+      process.nextTick(emitClose, duplex);
+    });
+
+    if (terminateOnDestroy) ws.terminate();
+  };
+
+  duplex._final = function (callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once('open', function open() {
+        duplex._final(callback);
+      });
+      return;
+    }
+
+    // If the value of the `_socket` property is `null` it means that `ws` is a
+    // client websocket and the handshake failed. In fact, when this happens, a
+    // socket is never assigned to the websocket. Wait for the `'error'` event
+    // that will be emitted by the websocket.
+    if (ws._socket === null) return;
+
+    if (ws._socket._writableState.finished) {
+      callback();
+      if (duplex._readableState.endEmitted) duplex.destroy();
+    } else {
+      ws._socket.once('finish', function finish() {
+        // `duplex` is not destroyed here because the `'end'` event will be
+        // emitted on `duplex` after this `'finish'` event. The EOF signaling
+        // `null` chunk is, in fact, pushed when the websocket emits `'close'`.
+        callback();
+      });
+      ws.close();
+    }
+  };
+
+  duplex._read = function () {
+    if (
+      (ws.readyState === ws.OPEN || ws.readyState === ws.CLOSING) &&
+      !resumeOnReceiverDrain
+    ) {
+      resumeOnReceiverDrain = true;
+      if (!ws._receiver._writableState.needDrain) ws._socket.resume();
+    }
+  };
+
+  duplex._write = function (chunk, encoding, callback) {
+    if (ws.readyState === ws.CONNECTING) {
+      ws.once('open', function open() {
+        duplex._write(chunk, encoding, callback);
+      });
+      return;
+    }
+
+    ws.send(chunk, callback);
+  };
+
+  duplex.on('end', duplexOnEnd);
+  duplex.on('error', duplexOnError);
+  return duplex;
+}
+
+module.exports = createWebSocketStream;

node_modules/@react-native/dev-middleware/node_modules/ws/lib/validation.js

@@ -0,0 +1,104 @@
+'use strict';
+
+/**
+ * Checks if a status code is allowed in a close frame.
+ *
+ * @param {Number} code The status code
+ * @return {Boolean} `true` if the status code is valid, else `false`
+ * @public
+ */
+function isValidStatusCode(code) {
+  return (
+    (code >= 1000 &&
+      code <= 1014 &&
+      code !== 1004 &&
+      code !== 1005 &&
+      code !== 1006) ||
+    (code >= 3000 && code <= 4999)
+  );
+}
+
+/**
+ * Checks if a given buffer contains only correct UTF-8.
+ * Ported from https://www.cl.cam.ac.uk/%7Emgk25/ucs/utf8_check.c by
+ * Markus Kuhn.
+ *
+ * @param {Buffer} buf The buffer to check
+ * @return {Boolean} `true` if `buf` contains only correct UTF-8, else `false`
+ * @public
+ */
+function _isValidUTF8(buf) {
+  const len = buf.length;
+  let i = 0;
+
+  while (i < len) {
+    if ((buf[i] & 0x80) === 0) {
+      // 0xxxxxxx
+      i++;
+    } else if ((buf[i] & 0xe0) === 0xc0) {
+      // 110xxxxx 10xxxxxx
+      if (
+        i + 1 === len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i] & 0xfe) === 0xc0 // Overlong
+      ) {
+        return false;
+      }
+
+      i += 2;
+    } else if ((buf[i] & 0xf0) === 0xe0) {
+      // 1110xxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 2 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        (buf[i] === 0xe0 && (buf[i + 1] & 0xe0) === 0x80) || // Overlong
+        (buf[i] === 0xed && (buf[i + 1] & 0xe0) === 0xa0) // Surrogate (U+D800 - U+DFFF)
+      ) {
+        return false;
+      }
+
+      i += 3;
+    } else if ((buf[i] & 0xf8) === 0xf0) {
+      // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+      if (
+        i + 3 >= len ||
+        (buf[i + 1] & 0xc0) !== 0x80 ||
+        (buf[i + 2] & 0xc0) !== 0x80 ||
+        (buf[i + 3] & 0xc0) !== 0x80 ||
+        (buf[i] === 0xf0 && (buf[i + 1] & 0xf0) === 0x80) || // Overlong
+        (buf[i] === 0xf4 && buf[i + 1] > 0x8f) ||
+        buf[i] > 0xf4 // > U+10FFFF
+      ) {
+        return false;
+      }
+
+      i += 4;
+    } else {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+try {
+  let isValidUTF8 = require('utf-8-validate');
+
+  /* istanbul ignore if */
+  if (typeof isValidUTF8 === 'object') {
+    isValidUTF8 = isValidUTF8.Validation.isValidUTF8; // utf-8-validate@<3.0.0
+  }
+
+  module.exports = {
+    isValidStatusCode,
+    isValidUTF8(buf) {
+      return buf.length < 150 ? _isValidUTF8(buf) : isValidUTF8(buf);
+    }
+  };
+} catch (e) /* istanbul ignore next */ {
+  module.exports = {
+    isValidStatusCode,
+    isValidUTF8: _isValidUTF8
+  };
+}

node_modules/@react-native/dev-middleware/node_modules/ws/lib/websocket-server.js

@@ -0,0 +1,449 @@
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "^net|tls|https$" }] */
+
+'use strict';
+
+const EventEmitter = require('events');
+const http = require('http');
+const https = require('https');
+const net = require('net');
+const tls = require('tls');
+const { createHash } = require('crypto');
+
+const PerMessageDeflate = require('./permessage-deflate');
+const WebSocket = require('./websocket');
+const { format, parse } = require('./extension');
+const { GUID, kWebSocket } = require('./constants');
+
+const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
+
+const RUNNING = 0;
+const CLOSING = 1;
+const CLOSED = 2;
+
+/**
+ * Class representing a WebSocket server.
+ *
+ * @extends EventEmitter
+ */
+class WebSocketServer extends EventEmitter {
+  /**
+   * Create a `WebSocketServer` instance.
+   *
+   * @param {Object} options Configuration options
+   * @param {Number} [options.backlog=511] The maximum length of the queue of
+   *     pending connections
+   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
+   *     track clients
+   * @param {Function} [options.handleProtocols] A hook to handle protocols
+   * @param {String} [options.host] The hostname where to bind the server
+   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
+   *     size
+   * @param {Boolean} [options.noServer=false] Enable no server mode
+   * @param {String} [options.path] Accept only connections matching this path
+   * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
+   *     permessage-deflate
+   * @param {Number} [options.port] The port where to bind the server
+   * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
+   *     server to use
+   * @param {Function} [options.verifyClient] A hook to reject connections
+   * @param {Function} [callback] A listener for the `listening` event
+   */
+  constructor(options, callback) {
+    super();
+
+    options = {
+      maxPayload: 100 * 1024 * 1024,
+      perMessageDeflate: false,
+      handleProtocols: null,
+      clientTracking: true,
+      verifyClient: null,
+      noServer: false,
+      backlog: null, // use default (511 as implemented in net.js)
+      server: null,
+      host: null,
+      path: null,
+      port: null,
+      ...options
+    };
+
+    if (
+      (options.port == null && !options.server && !options.noServer) ||
+      (options.port != null && (options.server || options.noServer)) ||
+      (options.server && options.noServer)
+    ) {
+      throw new TypeError(
+        'One and only one of the "port", "server", or "noServer" options ' +
+          'must be specified'
+      );
+    }
+
+    if (options.port != null) {
+      this._server = http.createServer((req, res) => {
+        const body = http.STATUS_CODES[426];
+
+        res.writeHead(426, {
+          'Content-Length': body.length,
+          'Content-Type': 'text/plain'
+        });
+        res.end(body);
+      });
+      this._server.listen(
+        options.port,
+        options.host,
+        options.backlog,
+        callback
+      );
+    } else if (options.server) {
+      this._server = options.server;
+    }
+
+    if (this._server) {
+      const emitConnection = this.emit.bind(this, 'connection');
+
+      this._removeListeners = addListeners(this._server, {
+        listening: this.emit.bind(this, 'listening'),
+        error: this.emit.bind(this, 'error'),
+        upgrade: (req, socket, head) => {
+          this.handleUpgrade(req, socket, head, emitConnection);
+        }
+      });
+    }
+
+    if (options.perMessageDeflate === true) options.perMessageDeflate = {};
+    if (options.clientTracking) this.clients = new Set();
+    this.options = options;
+    this._state = RUNNING;
+  }
+
+  /**
+   * Returns the bound address, the address family name, and port of the server
+   * as reported by the operating system if listening on an IP socket.
+   * If the server is listening on a pipe or UNIX domain socket, the name is
+   * returned as a string.
+   *
+   * @return {(Object|String|null)} The address of the server
+   * @public
+   */
+  address() {
+    if (this.options.noServer) {
+      throw new Error('The server is operating in "noServer" mode');
+    }
+
+    if (!this._server) return null;
+    return this._server.address();
+  }
+
+  /**
+   * Close the server.
+   *
+   * @param {Function} [cb] Callback
+   * @public
+   */
+  close(cb) {
+    if (cb) this.once('close', cb);
+
+    if (this._state === CLOSED) {
+      process.nextTick(emitClose, this);
+      return;
+    }
+
+    if (this._state === CLOSING) return;
+    this._state = CLOSING;
+
+    //
+    // Terminate all associated clients.
+    //
+    if (this.clients) {
+      for (const client of this.clients) client.terminate();
+    }
+
+    const server = this._server;
+
+    if (server) {
+      this._removeListeners();
+      this._removeListeners = this._server = null;
+
+      //
+      // Close the http server if it was internally created.
+      //
+      if (this.options.port != null) {
+        server.close(emitClose.bind(undefined, this));
+        return;
+      }
+    }
+
+    process.nextTick(emitClose, this);
+  }
+
+  /**
+   * See if a given request should be handled by this server instance.
+   *
+   * @param {http.IncomingMessage} req Request object to inspect
+   * @return {Boolean} `true` if the request is valid, else `false`
+   * @public
+   */
+  shouldHandle(req) {
+    if (this.options.path) {
+      const index = req.url.indexOf('?');
+      const pathname = index !== -1 ? req.url.slice(0, index) : req.url;
+
+      if (pathname !== this.options.path) return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Handle a HTTP Upgrade request.
+   *
+   * @param {http.IncomingMessage} req The request object
+   * @param {(net.Socket|tls.Socket)} socket The network socket between the
+   *     server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Function} cb Callback
+   * @public
+   */
+  handleUpgrade(req, socket, head, cb) {
+    socket.on('error', socketOnError);
+
+    const key =
+      req.headers['sec-websocket-key'] !== undefined
+        ? req.headers['sec-websocket-key'].trim()
+        : false;
+    const upgrade = req.headers.upgrade;
+    const version = +req.headers['sec-websocket-version'];
+    const extensions = {};
+
+    if (
+      req.method !== 'GET' ||
+      upgrade === undefined ||
+      upgrade.toLowerCase() !== 'websocket' ||
+      !key ||
+      !keyRegex.test(key) ||
+      (version !== 8 && version !== 13) ||
+      !this.shouldHandle(req)
+    ) {
+      return abortHandshake(socket, 400);
+    }
+
+    if (this.options.perMessageDeflate) {
+      const perMessageDeflate = new PerMessageDeflate(
+        this.options.perMessageDeflate,
+        true,
+        this.options.maxPayload
+      );
+
+      try {
+        const offers = parse(req.headers['sec-websocket-extensions']);
+
+        if (offers[PerMessageDeflate.extensionName]) {
+          perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
+          extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
+        }
+      } catch (err) {
+        return abortHandshake(socket, 400);
+      }
+    }
+
+    //
+    // Optionally call external client verification handler.
+    //
+    if (this.options.verifyClient) {
+      const info = {
+        origin:
+          req.headers[`${version === 8 ? 'sec-websocket-origin' : 'origin'}`],
+        secure: !!(req.socket.authorized || req.socket.encrypted),
+        req
+      };
+
+      if (this.options.verifyClient.length === 2) {
+        this.options.verifyClient(info, (verified, code, message, headers) => {
+          if (!verified) {
+            return abortHandshake(socket, code || 401, message, headers);
+          }
+
+          this.completeUpgrade(key, extensions, req, socket, head, cb);
+        });
+        return;
+      }
+
+      if (!this.options.verifyClient(info)) return abortHandshake(socket, 401);
+    }
+
+    this.completeUpgrade(key, extensions, req, socket, head, cb);
+  }
+
+  /**
+   * Upgrade the connection to WebSocket.
+   *
+   * @param {String} key The value of the `Sec-WebSocket-Key` header
+   * @param {Object} extensions The accepted extensions
+   * @param {http.IncomingMessage} req The request object
+   * @param {(net.Socket|tls.Socket)} socket The network socket between the
+   *     server and client
+   * @param {Buffer} head The first packet of the upgraded stream
+   * @param {Function} cb Callback
+   * @throws {Error} If called more than once with the same socket
+   * @private
+   */
+  completeUpgrade(key, extensions, req, socket, head, cb) {
+    //
+    // Destroy the socket if the client has already sent a FIN packet.
+    //
+    if (!socket.readable || !socket.writable) return socket.destroy();
+
+    if (socket[kWebSocket]) {
+      throw new Error(
+        'server.handleUpgrade() was called more than once with the same ' +
+          'socket, possibly due to a misconfiguration'
+      );
+    }
+
+    if (this._state > RUNNING) return abortHandshake(socket, 503);
+
+    const digest = createHash('sha1')
+      .update(key + GUID)
+      .digest('base64');
+
+    const headers = [
+      'HTTP/1.1 101 Switching Protocols',
+      'Upgrade: websocket',
+      'Connection: Upgrade',
+      `Sec-WebSocket-Accept: ${digest}`
+    ];
+
+    const ws = new WebSocket(null);
+    let protocol = req.headers['sec-websocket-protocol'];
+
+    if (protocol) {
+      protocol = protocol.split(',').map(trim);
+
+      //
+      // Optionally call external protocol selection handler.
+      //
+      if (this.options.handleProtocols) {
+        protocol = this.options.handleProtocols(protocol, req);
+      } else {
+        protocol = protocol[0];
+      }
+
+      if (protocol) {
+        headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+        ws._protocol = protocol;
+      }
+    }
+
+    if (extensions[PerMessageDeflate.extensionName]) {
+      const params = extensions[PerMessageDeflate.extensionName].params;
+      const value = format({
+        [PerMessageDeflate.extensionName]: [params]
+      });
+      headers.push(`Sec-WebSocket-Extensions: ${value}`);
+      ws._extensions = extensions;
+    }
+
+    //
+    // Allow external modification/inspection of handshake headers.
+    //
+    this.emit('headers', headers, req);
+
+    socket.write(headers.concat('\r\n').join('\r\n'));
+    socket.removeListener('error', socketOnError);
+
+    ws.setSocket(socket, head, this.options.maxPayload);
+
+    if (this.clients) {
+      this.clients.add(ws);
+      ws.on('close', () => this.clients.delete(ws));
+    }
+
+    cb(ws, req);
+  }
+}
+
+module.exports = WebSocketServer;
+
+/**
+ * Add event listeners on an `EventEmitter` using a map of <event, listener>
+ * pairs.
+ *
+ * @param {EventEmitter} server The event emitter
+ * @param {Object.<String, Function>} map The listeners to add
+ * @return {Function} A function that will remove the added listeners when
+ *     called
+ * @private
+ */
+function addListeners(server, map) {
+  for (const event of Object.keys(map)) server.on(event, map[event]);
+
+  return function removeListeners() {
+    for (const event of Object.keys(map)) {
+      server.removeListener(event, map[event]);
+    }
+  };
+}
+
+/**
+ * Emit a `'close'` event on an `EventEmitter`.
+ *
+ * @param {EventEmitter} server The event emitter
+ * @private
+ */
+function emitClose(server) {
+  server._state = CLOSED;
+  server.emit('close');
+}
+
+/**
+ * Handle premature socket errors.
+ *
+ * @private
+ */
+function socketOnError() {
+  this.destroy();
+}
+
+/**
+ * Close the connection when preconditions are not fulfilled.
+ *
+ * @param {(net.Socket|tls.Socket)} socket The socket of the upgrade request
+ * @param {Number} code The HTTP response status code
+ * @param {String} [message] The HTTP response body
+ * @param {Object} [headers] Additional HTTP response headers
+ * @private
+ */
+function abortHandshake(socket, code, message, headers) {
+  if (socket.writable) {
+    message = message || http.STATUS_CODES[code];
+    headers = {
+      Connection: 'close',
+      'Content-Type': 'text/html',
+      'Content-Length': Buffer.byteLength(message),
+      ...headers
+    };
+
+    socket.write(
+      `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r\n` +
+        Object.keys(headers)
+          .map((h) => `${h}: ${headers[h]}`)
+          .join('\r\n') +
+        '\r\n\r\n' +
+        message
+    );
+  }
+
+  socket.removeListener('error', socketOnError);
+  socket.destroy();
+}
+
+/**
+ * Remove whitespace characters from both ends of a string.
+ *
+ * @param {String} str The string
+ * @return {String} A new string representing `str` stripped of whitespace
+ *     characters from both its beginning and end
+ * @private
+ */
+function trim(str) {
+  return str.trim();
+}