@teardown/cli 1.2.28 → 1.2.30

package/dist/modules/dev/dev-server/inspector/inspector.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Inspector = void 0;
+const ws_1 = require("ws");
+const node_url_1 = require("node:url");
+const node_url_2 = __importDefault(require("node:url"));
+const device_1 = require("./device");
+const WS_DEVICE_PATH = "/inspector/device";
+const WS_DEBUGGER_PATH = "/inspector/debug";
+const JSON_VERSION_PATH = "/json/version";
+const JSON_LIST_PATH = "/json";
+const JSON_LIST_PATH_2 = "/json/list";
+const HEARTBEAT_INTERVAL = 10000;
+const MAX_PONG_TIMEOUT = 5000;
+const INTERNAL_ERROR_CODE = 1011;
+class Inspector {
+    devices = new Map();
+    deviceCounter = 0;
+    projectRoot;
+    serverBaseUrl;
+    eventReporter;
+    cdpAdapter;
+    constructor(options) {
+        this.projectRoot = options.projectRoot;
+        this.serverBaseUrl = options.serverBaseUrl;
+        this.eventReporter = options.eventReporter;
+        this.cdpAdapter = options.cdpAdapter;
+        this.handleHttpRequest = this.handleHttpRequest.bind(this);
+        this.sendJsonResponse = this.sendJsonResponse.bind(this);
+    }
+    getPageDescriptions() {
+        const descriptions = [];
+        for (const [deviceId, device] of this.devices.entries()) {
+            const devicePages = device
+                .getPagesList()
+                .map((page) => this.createPageDescription(deviceId, device, page));
+            descriptions.push(...devicePages);
+        }
+        return descriptions;
+    }
+    handleHttpRequest = (req, res, next) => {
+        const pathname = new node_url_1.URL(req.url || "", "http://localhost").pathname;
+        if (pathname === JSON_LIST_PATH || pathname === JSON_LIST_PATH_2) {
+            this.sendJsonResponse(res, this.getPageDescriptions());
+        }
+        else if (pathname === JSON_VERSION_PATH) {
+            this.sendJsonResponse(res, {
+                Browser: "Mobile JavaScript",
+                "Protocol-Version": "1.1",
+            });
+        }
+        else {
+            next();
+        }
+    };
+    createWebSocketServers() {
+        return {
+            [WS_DEVICE_PATH]: this.createDeviceWebSocketServer(),
+            [WS_DEBUGGER_PATH]: this.createDebuggerWebSocketServer(),
+        };
+    }
+    createPageDescription(deviceId, device, page) {
+        const { host, protocol } = new node_url_1.URL(this.serverBaseUrl);
+        const wsProtocol = protocol === "https:" ? "wss" : "ws";
+        const wsPath = `${host}${WS_DEBUGGER_PATH}?device=${deviceId}&page=${page.id}`;
+        return {
+            id: `${deviceId}-${page.id}`,
+            title: page.title,
+            // @ts-ignore
+            description: page.description || page.app,
+            type: "node",
+            webSocketDebuggerUrl: `${wsProtocol}://${wsPath}`,
+            devtoolsFrontendUrl: `devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&${wsProtocol}=${encodeURIComponent(wsPath)}`,
+            deviceName: device.getName(),
+            appId: page.app,
+            vm: page.vm,
+            reactNative: {
+                logicalDeviceId: deviceId,
+                capabilities: page.capabilities,
+            },
+        };
+    }
+    createDeviceWebSocketServer() {
+        const wss = new ws_1.WebSocketServer({
+            noServer: true,
+            perMessageDeflate: true,
+            maxPayload: 0,
+        });
+        wss.on("connection", (socket, req) => {
+            try {
+                const fallbackDeviceId = String(this.deviceCounter++);
+                const query = node_url_2.default.parse(req.url || "", true).query || {};
+                const deviceId = query.device || fallbackDeviceId;
+                const deviceName = query.name || "Unknown";
+                const appName = query.app || "Unknown";
+                const actualDeviceId = Array.isArray(deviceId) ? deviceId[0] : deviceId;
+                const actualDeviceName = Array.isArray(deviceName)
+                    ? deviceName[0]
+                    : deviceName;
+                const actualAppName = Array.isArray(appName) ? appName[0] : appName;
+                const oldDevice = this.devices.get(actualDeviceId);
+                let newDevice;
+                if (oldDevice) {
+                    oldDevice.dangerouslyRecreateDevice(actualDeviceId, actualDeviceName, actualAppName, socket, this.projectRoot, this.eventReporter);
+                    newDevice = oldDevice;
+                }
+                else {
+                    newDevice = new device_1.Device(actualDeviceId, actualDeviceName, actualAppName, socket, this.projectRoot, this.eventReporter);
+                }
+                this.devices.set(actualDeviceId, newDevice);
+                socket.on("close", () => {
+                    if (this.devices.get(actualDeviceId)?.dangerouslyGetSocket() === socket) {
+                        this.devices.delete(actualDeviceId);
+                    }
+                    // debug(`Device ${deviceName} disconnected.`);
+                });
+            }
+            catch (e) {
+                console.error("error", e);
+                socket.close(INTERNAL_ERROR_CODE, e?.toString() ?? "Unknown error");
+            }
+        });
+        return wss;
+    }
+    createDebuggerWebSocketServer() {
+        const wss = new ws_1.WebSocketServer({
+            noServer: true,
+            maxPayload: 0,
+        });
+        wss.on("connection", (ws, req) => {
+            try {
+                const query = new node_url_1.URL(req.url || "", "http://localhost").searchParams;
+                const deviceId = query.get("device");
+                const pageId = query.get("page");
+                if (!deviceId || !pageId) {
+                    throw new Error("Missing device or page ID");
+                }
+                const device = this.devices.get(deviceId);
+                if (!device) {
+                    throw new Error(`Unknown device: ${deviceId}`);
+                }
+                this.setupHeartbeat(ws);
+                device.handleDebuggerConnection(ws, pageId, {
+                    userAgent: req.headers["user-agent"] || null,
+                });
+            }
+            catch (err) {
+                console.error(err);
+                ws.close(INTERNAL_ERROR_CODE, err instanceof Error ? err.message : "Unknown error");
+                this.eventReporter?.logEvent({
+                    type: "connect_debugger_frontend",
+                    status: "error",
+                    error: err,
+                });
+            }
+        });
+        return wss;
+    }
+    setupHeartbeat(ws) {
+        let pendingPong = false;
+        let terminateTimeout = null;
+        const heartbeat = setInterval(() => {
+            if (ws.readyState !== ws_1.WebSocket.OPEN) {
+                return;
+            }
+            pendingPong = true;
+            ws.ping(() => {
+                if (!pendingPong)
+                    return;
+                terminateTimeout = setTimeout(() => {
+                    if (ws.readyState === ws_1.WebSocket.OPEN) {
+                        ws.terminate();
+                    }
+                }, MAX_PONG_TIMEOUT);
+            });
+        }, HEARTBEAT_INTERVAL);
+        const resetHeartbeat = () => {
+            pendingPong = false;
+            if (terminateTimeout) {
+                clearTimeout(terminateTimeout);
+                terminateTimeout = null;
+            }
+        };
+        ws.on("pong", resetHeartbeat);
+        ws.on("message", resetHeartbeat);
+        ws.on("close", () => {
+            clearInterval(heartbeat);
+            resetHeartbeat();
+        });
+    }
+    sendJsonResponse = (res, data) => {
+        const json = JSON.stringify(data, null, 2);
+        res.writeHead(200, {
+            "Content-Type": "application/json; charset=UTF-8",
+            "Cache-Control": "no-cache",
+            "Content-Length": Buffer.byteLength(json),
+            Connection: "close",
+        });
+        res.end(json);
+    };
+}
+exports.Inspector = Inspector;

package/dist/modules/dev/dev-server/inspector/types.d.ts

@@ -0,0 +1,156 @@
+import type WS from "ws";
+export type JSONSerializable = boolean | number | string | null | ReadonlyArray<JSONSerializable> | {
+    [key: string]: JSONSerializable;
+};
+export interface PageFromDevice {
+    id: string;
+    title: string;
+    vm: string;
+    app: string;
+    capabilities: Record<string, boolean>;
+}
+export type Page = Omit<PageFromDevice, "capabilities"> & {
+    capabilities: NonNullable<PageFromDevice["capabilities"]>;
+};
+export type WrappedEvent = {
+    event: "wrappedEvent";
+    payload: {
+        pageId: string;
+        wrappedEvent: string;
+    };
+};
+export type ConnectRequest = {
+    event: "connect";
+    payload: {
+        pageId: string;
+    };
+};
+export type DisconnectRequest = {
+    event: "disconnect";
+    payload: {
+        pageId: string;
+    };
+};
+export type GetPagesRequest = {
+    event: "getPages";
+};
+export type GetPagesResponse = {
+    event: "getPages";
+    payload: ReadonlyArray<PageFromDevice>;
+};
+export type MessageFromDevice = GetPagesResponse | WrappedEvent | DisconnectRequest;
+export type MessageToDevice = GetPagesRequest | WrappedEvent | ConnectRequest | DisconnectRequest;
+export type PageDescription = {
+    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: {
+        logicalDeviceId: string;
+        capabilities: Page["capabilities"];
+    };
+};
+export interface CDPMessage {
+    id?: number;
+    method?: string;
+    params?: any;
+    result?: any;
+}
+export interface DebuggerConnection {
+    socket: WS;
+    originalSourceURLAddress?: string;
+    prependedFilePrefix: boolean;
+    pageId: string;
+    userAgent: string | null;
+    customHandler: any | null;
+}
+type SuccessResult<Props extends Record<string, any> = {}> = {
+    status: "success";
+} & Props;
+type ErrorResult<ErrorT = unknown> = {
+    status: "error";
+    error: ErrorT;
+    prefersFuseboxFrontend?: boolean | null;
+};
+type CodedErrorResult<ErrorCode extends string> = {
+    status: "coded_error";
+    errorCode: ErrorCode;
+    errorDetails?: string;
+};
+type DebuggerSessionIDs = {
+    appId: string;
+    deviceName: string;
+    deviceId: string;
+    pageId: string | null;
+};
+export type ReportableEvent = ({
+    type: "launch_debugger_frontend";
+    launchType: "launch" | "redirect";
+} & (SuccessResult<{
+    appId: string | null;
+    deviceId: string | null;
+    resolvedTargetDescription: string;
+    resolvedTargetAppId: string;
+    prefersFuseboxFrontend: boolean;
+}> | ErrorResult | CodedErrorResult<"NO_APPS_FOUND">)) | ({
+    type: "connect_debugger_frontend";
+} & (SuccessResult<{
+    frontendUserAgent: string | null;
+} & DebuggerSessionIDs> | ErrorResult)) | ({
+    type: "debugger_command";
+    protocol: "CDP";
+    method: string | null;
+    requestOrigin: "proxy" | "debugger" | null;
+    responseOrigin: "proxy" | "device";
+    timeSinceStart: number | null;
+    frontendUserAgent: string | null;
+    prefersFuseboxFrontend: boolean | null;
+} & DebuggerSessionIDs & (SuccessResult | CodedErrorResult<"TIMED_OUT" | "DEVICE_DISCONNECTED" | "DEBUGGER_DISCONNECTED" | "UNMATCHED_REQUEST_ID" | "PROTOCOL_ERROR">)) | ({
+    type: "proxy_error";
+    status: "error";
+    messageOrigin: "debugger" | "device";
+    message: string;
+    error: string;
+    errorStack: string;
+} & DebuggerSessionIDs);
+export interface EventReporter {
+    logEvent(event: ReportableEvent): void;
+}
+export type ExposedDevice = {
+    appId: string;
+    id: string;
+    name: string;
+    sendMessage: (message: JSONSerializable) => void;
+};
+export type ExposedDebugger = {
+    userAgent: string | null;
+    sendMessage: (message: JSONSerializable) => void;
+};
+export type CustomMessageHandlerConnection = {
+    page: Page;
+    device: ExposedDevice;
+    debugger: ExposedDebugger;
+};
+export type CreateCustomMessageHandlerFn = (connection: CustomMessageHandlerConnection) => CustomMessageHandler;
+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): boolean;
+    /**
+     * 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): boolean;
+}
+export {};

package/dist/modules/dev/dev-server/inspector/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/dev/dev-server/inspector/wss/servers/debugger-connection.server.d.ts

@@ -0,0 +1,14 @@
+import WS from "ws";
+import type { EventReporter } from "../../types";
+import type { Device } from "../../device";
+interface DebuggerConnectionServerConfig {
+    devices: Map<string, Device>;
+    eventReporter: EventReporter | null;
+    startHeartbeat: (socket: WS, intervalMs: number) => void;
+}
+export default class DebuggerConnectionServer {
+    #private;
+    constructor({ devices, eventReporter, startHeartbeat, }: DebuggerConnectionServerConfig);
+    createServer(): WS.Server;
+}
+export {};

package/dist/modules/dev/dev-server/inspector/wss/servers/debugger-connection.server.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_url_1 = __importDefault(require("node:url"));
+const ws_1 = __importDefault(require("ws"));
+const debug = require("debug")("Metro:InspectorProxy");
+const INTERNAL_ERROR_CODE = 1011;
+const DEBUGGER_HEARTBEAT_INTERVAL_MS = 10000;
+const MAX_PONG_LATENCY_MS = 5000;
+class DebuggerConnectionServer {
+    #devices;
+    #eventReporter;
+    #startHeartbeat;
+    constructor({ devices, eventReporter, startHeartbeat, }) {
+        this.#devices = devices;
+        this.#eventReporter = eventReporter;
+        this.#startHeartbeat = startHeartbeat;
+    }
+    createServer() {
+        const wss = new ws_1.default.Server({
+            noServer: true,
+            perMessageDeflate: false,
+            // Don't crash on exceptionally large messages - assume the debugger is
+            // well-behaved and the device is prepared to handle large messages.
+            maxPayload: 0,
+        });
+        wss.on("connection", async (socket, req) => {
+            try {
+                const query = node_url_1.default.parse(req.url || "", true).query || {};
+                const deviceId = query.device;
+                const pageId = query.page;
+                if (deviceId == null || pageId == null) {
+                    throw new Error("Incorrect URL - must provide device and page IDs");
+                }
+                const device = this.#devices.get(deviceId);
+                if (device == null) {
+                    throw new Error(`Unknown device with ID ${deviceId}`);
+                }
+                this.#startHeartbeat(socket, DEBUGGER_HEARTBEAT_INTERVAL_MS);
+                device.handleDebuggerConnection(socket, pageId, {
+                    userAgent: Array.isArray(req.headers["user-agent"])
+                        ? req.headers["user-agent"][0]
+                        : req.headers["user-agent"] || query.userAgent || null,
+                });
+            }
+            catch (e) {
+                console.error(e);
+                socket.close(INTERNAL_ERROR_CODE, e?.toString() ?? "Unknown error");
+                this.#eventReporter?.logEvent({
+                    type: "connect_debugger_frontend",
+                    status: "error",
+                    error: e,
+                });
+            }
+        });
+        return wss;
+    }
+}
+exports.default = DebuggerConnectionServer;

package/dist/modules/dev/dev-server/inspector/wss/servers/device-connection.server.d.ts

@@ -0,0 +1,19 @@
+import WS from "ws";
+import { Device } from "../../device";
+import type { EventReporter, CreateCustomMessageHandlerFn } from "../../types";
+interface DeviceCounter {
+    value: number;
+}
+interface DeviceConnectionServerConfig {
+    devices: Map<string, Device>;
+    deviceCounter: DeviceCounter;
+    projectRoot: string;
+    eventReporter?: EventReporter;
+    customMessageHandler: CreateCustomMessageHandlerFn | null;
+}
+export default class DeviceConnectionServer {
+    #private;
+    constructor({ devices, deviceCounter, projectRoot, eventReporter, customMessageHandler, }: DeviceConnectionServerConfig);
+    createServer(): WS.Server;
+}
+export {};

package/dist/modules/dev/dev-server/inspector/wss/servers/device-connection.server.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ws_1 = __importDefault(require("ws"));
+const node_url_1 = __importDefault(require("node:url"));
+const device_1 = require("../../device");
+const debug = require("debug")("Metro:InspectorProxy");
+const INTERNAL_ERROR_CODE = 1011;
+class DeviceConnectionServer {
+    #devices;
+    #deviceCounter;
+    #projectRoot;
+    #eventReporter;
+    #customMessageHandler;
+    constructor({ devices, deviceCounter, projectRoot, eventReporter, customMessageHandler, }) {
+        this.#devices = devices;
+        this.#deviceCounter = deviceCounter;
+        this.#projectRoot = projectRoot;
+        this.#eventReporter = eventReporter;
+        this.#customMessageHandler = customMessageHandler;
+    }
+    createServer() {
+        const wss = new ws_1.default.Server({
+            noServer: true,
+            perMessageDeflate: true,
+            maxPayload: 0,
+        });
+        wss.on("connection", async (socket, req) => {
+            try {
+                const fallbackDeviceId = String(this.#deviceCounter.value++);
+                const query = node_url_1.default.parse(req.url || "", true).query || {};
+                const deviceId = query.device || fallbackDeviceId;
+                const deviceName = query.name || "Unknown";
+                const appName = query.app || "Unknown";
+                const oldDevice = this.#devices.get(deviceId);
+                let newDevice;
+                if (oldDevice) {
+                    oldDevice.dangerouslyRecreateDevice(deviceId, deviceName, appName, socket, this.#projectRoot, this.#eventReporter);
+                    newDevice = oldDevice;
+                }
+                else {
+                    newDevice = new device_1.Device(deviceId, deviceName, appName, socket, this.#projectRoot, this.#eventReporter);
+                }
+                this.#devices.set(deviceId, newDevice);
+                debug(`Got new connection: name=${deviceName}, app=${appName}, device=${deviceId}`);
+                socket.on("close", () => {
+                    const device = this.#devices.get(deviceId);
+                    if (device?.dangerouslyGetSocket() === socket) {
+                        this.#devices.delete(deviceId);
+                    }
+                    debug(`Device ${deviceName} disconnected.`);
+                });
+            }
+            catch (e) {
+                console.error("error", e);
+                socket.close(INTERNAL_ERROR_CODE, e?.toString() ?? "Unknown error");
+            }
+        });
+        return wss;
+    }
+}
+exports.default = DeviceConnectionServer;

package/dist/modules/dev/dev-server/plugins/favicon.plugin.js

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.faviconPlugin = void 0;
-const fastify_favicon_1 = __importDefault(require("fastify-favicon"));
 const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_url_1 = require("node:url");
@@ -13,7 +12,7 @@ const dirname = node_path_1.default.dirname((0, node_url_1.fileURLToPath)(import
 const pathToImgDir = node_path_1.default.join(dirname, "../img");
 exports.faviconPlugin = (0, fastify_plugin_1.default)(async (instance) => {
     console.log("pathToImgDir", pathToImgDir);
-    instance.register(fastify_favicon_1.default, { path: pathToImgDir });
+    // instance.register(fastifyFavicon, { path: pathToImgDir });
 }, {
     name: "favicon-plugin",
 });

package/dist/modules/dev/dev-server/sybmolicate/sybmolicate.plugin.d.ts

@@ -8,4 +8,7 @@ type SymbolicatePluginOptions = {
     onSymbolicate: (request: SymbolicateRequest, reply: SymbolicateReply) => void;
 };
 export declare const symbolicatePlugin: import("fastify").FastifyPluginCallback<SymbolicatePluginOptions, import("fastify").RawServerDefault, import("fastify").FastifyTypeProviderDefault, import("fastify").FastifyBaseLogger>;
+export declare const rawBodyPlugin: import("fastify").FastifyPluginCallback<{
+    rawBody: string;
+}, import("fastify").RawServerDefault, import("fastify").FastifyTypeProviderDefault, import("fastify").FastifyBaseLogger>;
 export {};

package/dist/modules/dev/dev-server/sybmolicate/sybmolicate.plugin.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.symbolicatePlugin = void 0;
+exports.rawBodyPlugin = exports.symbolicatePlugin = void 0;
 const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
 exports.symbolicatePlugin = (0, fastify_plugin_1.default)(async (instance, options) => {
     instance.log.info("Symbolicate plugin registered");
@@ -28,3 +28,9 @@ exports.symbolicatePlugin = (0, fastify_plugin_1.default)(async (instance, optio
     name: "symbolicate-plugin",
     dependencies: ["@fastify/sensible"],
 });
+exports.rawBodyPlugin = (0, fastify_plugin_1.default)((instance, options) => {
+    instance.addHook("preHandler", (request, reply, next) => {
+        // request.rawBody = "";
+        next();
+    });
+});

package/dist/modules/dev/terminal/terminal.reporter.d.ts

@@ -1,7 +1,8 @@
 import type { TerminalReportableEvent } from "metro/src/lib/TerminalReporter";
 import type { DevServer } from "../dev-server/dev-server";
 import { BaseTerminalReporter } from "./base.terminal.reporter";
-export declare class TeardownTerminalReporter extends BaseTerminalReporter {
+import { EventReporter, ReportableEvent } from "../dev-server/inspector/types";
+export declare class TeardownTerminalReporter extends BaseTerminalReporter implements EventReporter {
     readonly devServer: DevServer;
     constructor(devServer: DevServer);
     _log(event: TerminalReportableEvent): void;
@@ -9,4 +10,5 @@ export declare class TeardownTerminalReporter extends BaseTerminalReporter {
     dependencyGraphLoading(hasReducedPerformance: boolean): void;
     _logWorkerChunk(origin: "stdout" | "stderr", chunk: string): void;
     update(event: TerminalReportableEvent): void;
+    logEvent(event: ReportableEvent): void;
 }

package/dist/modules/dev/terminal/terminal.reporter.js

@@ -69,5 +69,8 @@ class TeardownTerminalReporter extends base_terminal_reporter_1.BaseTerminalRepo
                 break;
         }
     }
+    logEvent(event) {
+        // this.devServer?.reportMetroEvent(event);
+    }
 }
 exports.TeardownTerminalReporter = TeardownTerminalReporter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teardown/cli",
-  "version": "1.2.28",
+  "version": "1.2.30",
   "description": "Teardown CLI",
   "main": "dist/index.js",
   "bin": {
@@ -23,8 +23,8 @@
     "@fastify/cors": "^10.0.1",
     "@fastify/middie": "^9.0.2",
     "@fastify/sensible": "^6.0.1",
+    "@isaacs/ttlcache": "^1.4.1",
     "@react-native-community/cli-server-api": "^15.0.1",
-    "@react-native/dev-middleware": "0.76.1",
     "@react-native/metro-config": "0.76.1",
     "@types/bun": "^1.1.13",
     "bun": "1.1.34",
@@ -42,10 +42,10 @@
     "metro": "^0.81.0",
     "metro-config": "^0.81.0",
     "metro-core": "^0.81.0",
-    "metro-runtime": "^0.81.0",
     "pretty-format": "^29.7.0",
     "prompts": "^2.4.2",
-    "source-map": "^0.7.4"
+    "source-map": "^0.7.4",
+    "timers": "^0.1.1"
   },
   "devDependencies": {
     "@types/babel__code-frame": "^7.0.6",