miniflare 0.0.0-e51304ca0 → 0.0.0-e5dbedd78

package/dist/src/index.js

@@ -628,7 +628,7 @@ __export(src_exports, {
   deserialiseRegExps: () => deserialiseRegExps,
   deserialiseSiteRegExps: () => deserialiseSiteRegExps,
   encodeSitesKey: () => encodeSitesKey,
-  fetch: () => fetch3,
+  fetch: () => fetch4,
   formatZodError: () => formatZodError,
   getAccessibleHosts: () => getAccessibleHosts,
   getAssetsBindingsNames: () => getAssetsBindingsNames,
@@ -770,7 +770,7 @@ function zod_worker_default() {
 }
 
 // src/index.ts
-var import_ws3 = require("ws");
+var import_ws5 = require("ws");
 var import_zod23 = require("zod");
 
 // src/cf.ts
@@ -2359,7 +2359,7 @@ function headersFromIncomingRequest(req) {
   );
   return new undici.Headers(Object.fromEntries(entries));
 }
-async function fetch3(input, init2) {
+async function fetch4(input, init2) {
   const requestInit = init2;
   const request = new Request(input, requestInit);
   if (request.method === "GET" && request.headers.get("upgrade") === "websocket") {
@@ -2558,8 +2558,8 @@ function valueOrFile(value, filePath) {
 var import_os = require("os");
 function getAccessibleHosts(ipv4Only = false) {
   const hosts = [];
-  Object.values((0, import_os.networkInterfaces)()).forEach((net2) => {
-    net2?.forEach(({ family, address }) => {
+  Object.values((0, import_os.networkInterfaces)()).forEach((net3) => {
+    net3?.forEach(({ family, address }) => {
       if (family === "IPv4" || family === 4) {
         hosts.push(address);
       } else if (!ipv4Only) {
@@ -11884,6 +11884,7 @@ var CoreOptionsSchemaInput = import_zod12.z.intersection(
     rootPath: UnusableStringSchema.optional(),
     compatibilityDate: import_zod12.z.string().optional(),
     compatibilityFlags: import_zod12.z.string().array().optional(),
+    unsafeInspectorProxy: import_zod12.z.boolean().optional(),
     routes: import_zod12.z.string().array().optional(),
     bindings: import_zod12.z.record(JsonSchema).optional(),
     wasmBindings: import_zod12.z.record(import_zod12.z.union([PathSchema, import_zod12.z.instanceof(Uint8Array)])).optional(),
@@ -11902,8 +11903,7 @@ var CoreOptionsSchemaInput = import_zod12.z.intersection(
      (If there are assets but we're not using vitest, the miniflare entry worker can point directly to
      Router Worker)
      */
-    hasAssetsAndIsVitest: import_zod12.z.boolean().optional(),
-    unsafeEnableAssetsRpc: import_zod12.z.boolean().optional()
+    hasAssetsAndIsVitest: import_zod12.z.boolean().optional()
   })
 );
 var CoreOptionsSchema = CoreOptionsSchemaInput.transform((value) => {
@@ -11916,7 +11916,7 @@ var CoreOptionsSchema = CoreOptionsSchemaInput.transform((value) => {
       );
     }
     value.fetchMock = void 0;
-    value.outboundService = (req) => fetch3(req, { dispatcher: fetchMock });
+    value.outboundService = (req) => fetch4(req, { dispatcher: fetchMock });
   }
   return value;
 });
@@ -11943,8 +11943,7 @@ var CoreSharedOptionsSchema = import_zod12.z.object({
   unsafeProxySharedSecret: import_zod12.z.string().optional(),
   unsafeModuleFallbackService: ServiceFetchSchema.optional(),
   // Keep blobs when deleting/overwriting keys, required for stacked storage
-  unsafeStickyBlobs: import_zod12.z.boolean().optional(),
-  unsafeEnableAssetsRpc: import_zod12.z.boolean().optional()
+  unsafeStickyBlobs: import_zod12.z.boolean().optional()
 });
 var CORE_PLUGIN_NAME2 = "core";
 var LIVE_RELOAD_SCRIPT_TEMPLATE = (port) => `<script defer type="application/javascript">
@@ -11970,7 +11969,7 @@ var SCRIPT_CUSTOM_SERVICE = `addEventListener("fetch", (event) => {
   request.headers.set("${CoreHeaders.ORIGINAL_URL}", request.url);
   event.respondWith(${CoreBindings.SERVICE_LOOPBACK}.fetch(request));
 })`;
-function getCustomServiceDesignator(refererName, workerIndex, kind, name, service, hasAssetsAndIsVitest = false, unsafeEnableAssetsRpc = false) {
+function getCustomServiceDesignator(refererName, workerIndex, kind, name, service, hasAssetsAndIsVitest = false) {
   let serviceName;
   let entrypoint;
   if (typeof service === "function") {
@@ -11987,7 +11986,7 @@ function getCustomServiceDesignator(refererName, workerIndex, kind, name, servic
       serviceName = getBuiltinServiceName(workerIndex, kind, name);
     }
   } else if (service === kCurrentWorker) {
-    serviceName = hasAssetsAndIsVitest ? unsafeEnableAssetsRpc ? `${RPC_PROXY_SERVICE_NAME}:${refererName}` : `${ROUTER_SERVICE_NAME}:${refererName}` : getUserServiceName(refererName);
+    serviceName = hasAssetsAndIsVitest ? `${RPC_PROXY_SERVICE_NAME}:${refererName}` : getUserServiceName(refererName);
   } else {
     serviceName = getUserServiceName(service);
   }
@@ -12108,8 +12107,7 @@ var CORE_PLUGIN = {
               "#" /* UNKNOWN */,
               name,
               service,
-              options.hasAssetsAndIsVitest,
-              options.unsafeEnableAssetsRpc
+              options.hasAssetsAndIsVitest
             )
           };
         })
@@ -12297,7 +12295,10 @@ Ensure ${stringName} doesn't include unbundled \`import\`s.`
         worker: {
           ...workerScript,
           compatibilityDate,
-          compatibilityFlags: options.compatibilityFlags,
+          compatibilityFlags: options.compatibilityFlags?.filter(
+            // This can be removed once https://github.com/cloudflare/workerd/pull/3745 lands.
+            (flag) => !flag.startsWith("assets_")
+          ),
           bindings: workerBindings,
           durableObjectNamespaces: classNamesEntries.map(
             ([
@@ -12332,8 +12333,7 @@ Ensure ${stringName} doesn't include unbundled \`import\`s.`
             "$" /* KNOWN */,
             CUSTOM_SERVICE_KNOWN_OUTBOUND,
             options.outboundService,
-            options.hasAssetsAndIsVitest,
-            options.unsafeEnableAssetsRpc
+            options.hasAssetsAndIsVitest
           ),
           cacheApiOutbound: { name: getCacheServiceName(workerIndex) },
           moduleFallback: options.unsafeUseModuleFallbackService && sharedOptions.unsafeModuleFallbackService !== void 0 ? `localhost:${loopbackPort}` : void 0
@@ -12515,8 +12515,13 @@ var AssetsOptionsSchema = import_zod13.z.object({
     directory: PathSchema,
     binding: import_zod13.z.string().optional(),
     routerConfig: RouterConfigSchema.optional(),
-    assetConfig: AssetConfigSchema.optional()
-  }).optional()
+    assetConfig: AssetConfigSchema.omit({
+      compatibility_date: true,
+      compatibility_flags: true
+    }).optional()
+  }).optional(),
+  compatibilityDate: import_zod13.z.string().optional(),
+  compatibilityFlags: import_zod13.z.string().array().optional()
 });
 
 // src/plugins/assets/index.ts
@@ -12544,7 +12549,7 @@ var ASSETS_PLUGIN = {
       [options.assets.binding]: new ProxyNodeBinding()
     };
   },
-  async getServices({ options, unsafeEnableAssetsRpc }) {
+  async getServices({ options }) {
     if (!options.assets) {
       return [];
     }
@@ -12591,6 +12596,8 @@ var ASSETS_PLUGIN = {
       );
     }
     const assetConfig = {
+      compatibility_date: options.compatibilityDate,
+      compatibility_flags: options.compatibilityFlags,
       ...options.assets.assetConfig,
       redirects: parsedRedirects,
       headers: parsedHeaders
@@ -12679,36 +12686,39 @@ var ASSETS_PLUGIN = {
         ]
       }
     };
-    const services = [
+    const assetsProxyService = {
+      name: `${RPC_PROXY_SERVICE_NAME}:${id}`,
+      worker: {
+        compatibilityDate: "2024-08-01",
+        modules: [
+          {
+            name: "assets-proxy-worker.mjs",
+            esModule: rpc_proxy_worker_default()
+          }
+        ],
+        bindings: [
+          {
+            name: "ROUTER_WORKER",
+            service: {
+              name: `${ROUTER_SERVICE_NAME}:${id}`
+            }
+          },
+          {
+            name: "USER_WORKER",
+            service: {
+              name: getUserServiceName(id)
+            }
+          }
+        ]
+      }
+    };
+    return [
       storageService,
       namespaceService,
       assetService,
-      routerService
+      routerService,
+      assetsProxyService
     ];
-    if (unsafeEnableAssetsRpc) {
-      const assetsProxyService = {
-        name: `${RPC_PROXY_SERVICE_NAME}:${id}`,
-        worker: {
-          compatibilityDate: "2024-08-01",
-          modules: [
-            {
-              name: "assets-proxy-worker.mjs",
-              esModule: rpc_proxy_worker_default()
-            }
-          ],
-          bindings: [
-            {
-              name: "ROUTER_WORKER",
-              service: {
-                name: `${ROUTER_SERVICE_NAME}:${id}`
-              }
-            }
-          ]
-        }
-      };
-      services.push(assetsProxyService);
-    }
-    return services;
   }
 };
 var buildAssetManifest = async (dir) => {
@@ -12962,9 +12972,13 @@ var HYPERDRIVE_PLUGIN_NAME = "hyperdrive";
 function hasPostgresProtocol(url20) {
   return url20.protocol === "postgresql:" || url20.protocol === "postgres:";
 }
+function hasMysqlProtocol(url20) {
+  return url20.protocol === "mysql:";
+}
 function getPort(url20) {
   if (url20.port !== "") return url20.port;
   if (hasPostgresProtocol(url20)) return "5432";
+  if (hasMysqlProtocol(url20)) return "3306";
   import_node_assert3.default.fail(`Expected known protocol, got ${url20.protocol}`);
 }
 var HyperdriveSchema = import_zod15.z.union([import_zod15.z.string().url(), import_zod15.z.instanceof(URL)]).transform((url20, ctx) => {
@@ -12972,12 +12986,12 @@ var HyperdriveSchema = import_zod15.z.union([import_zod15.z.string().url(), impo
   if (url20.protocol === "") {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
-      message: "You must specify the database protocol - e.g. 'postgresql'."
+      message: "You must specify the database protocol - e.g. 'postgresql'/'mysql'."
     });
-  } else if (!hasPostgresProtocol(url20)) {
+  } else if (!hasPostgresProtocol(url20) && !hasMysqlProtocol(url20)) {
     ctx.addIssue({
       code: import_zod15.z.ZodIssueCode.custom,
-      message: "Only PostgreSQL or PostgreSQL compatible databases are currently supported."
+      message: "Only PostgreSQL-compatible or MySQL-compatible databases are currently supported."
     });
   }
   if (url20.host === "") {
@@ -13850,6 +13864,415 @@ var PLUGINS = {
 };
 var PLUGIN_ENTRIES = Object.entries(PLUGINS);
 
+// src/plugins/core/inspector-proxy/inspector-proxy-controller.ts
+var import_node_crypto2 = __toESM(require("node:crypto"));
+var import_node_http = require("node:http");
+
+// ../../node_modules/.pnpm/get-port@7.1.0/node_modules/get-port/index.js
+var import_node_net = __toESM(require("node:net"), 1);
+var import_node_os = __toESM(require("node:os"), 1);
+var Locked = class extends Error {
+  constructor(port) {
+    super(`${port} is locked`);
+  }
+};
+var lockedPorts = {
+  old: /* @__PURE__ */ new Set(),
+  young: /* @__PURE__ */ new Set()
+};
+var releaseOldLockedPortsIntervalMs = 1e3 * 15;
+var timeout;
+var getLocalHosts = () => {
+  const interfaces = import_node_os.default.networkInterfaces();
+  const results = /* @__PURE__ */ new Set([void 0, "0.0.0.0"]);
+  for (const _interface of Object.values(interfaces)) {
+    for (const config of _interface) {
+      results.add(config.address);
+    }
+  }
+  return results;
+};
+var checkAvailablePort = (options) => new Promise((resolve2, reject) => {
+  const server = import_node_net.default.createServer();
+  server.unref();
+  server.on("error", reject);
+  server.listen(options, () => {
+    const { port } = server.address();
+    server.close(() => {
+      resolve2(port);
+    });
+  });
+});
+var getAvailablePort = async (options, hosts) => {
+  if (options.host || options.port === 0) {
+    return checkAvailablePort(options);
+  }
+  for (const host of hosts) {
+    try {
+      await checkAvailablePort({ port: options.port, host });
+    } catch (error) {
+      if (!["EADDRNOTAVAIL", "EINVAL"].includes(error.code)) {
+        throw error;
+      }
+    }
+  }
+  return options.port;
+};
+var portCheckSequence = function* (ports) {
+  if (ports) {
+    yield* ports;
+  }
+  yield 0;
+};
+async function getPorts(options) {
+  let ports;
+  let exclude = /* @__PURE__ */ new Set();
+  if (options) {
+    if (options.port) {
+      ports = typeof options.port === "number" ? [options.port] : options.port;
+    }
+    if (options.exclude) {
+      const excludeIterable = options.exclude;
+      if (typeof excludeIterable[Symbol.iterator] !== "function") {
+        throw new TypeError("The `exclude` option must be an iterable.");
+      }
+      for (const element of excludeIterable) {
+        if (typeof element !== "number") {
+          throw new TypeError("Each item in the `exclude` option must be a number corresponding to the port you want excluded.");
+        }
+        if (!Number.isSafeInteger(element)) {
+          throw new TypeError(`Number ${element} in the exclude option is not a safe integer and can't be used`);
+        }
+      }
+      exclude = new Set(excludeIterable);
+    }
+  }
+  if (timeout === void 0) {
+    timeout = setTimeout(() => {
+      timeout = void 0;
+      lockedPorts.old = lockedPorts.young;
+      lockedPorts.young = /* @__PURE__ */ new Set();
+    }, releaseOldLockedPortsIntervalMs);
+    if (timeout.unref) {
+      timeout.unref();
+    }
+  }
+  const hosts = getLocalHosts();
+  for (const port of portCheckSequence(ports)) {
+    try {
+      if (exclude.has(port)) {
+        continue;
+      }
+      let availablePort = await getAvailablePort({ ...options, port }, hosts);
+      while (lockedPorts.old.has(availablePort) || lockedPorts.young.has(availablePort)) {
+        if (port !== 0) {
+          throw new Locked(port);
+        }
+        availablePort = await getAvailablePort({ ...options, port }, hosts);
+      }
+      lockedPorts.young.add(availablePort);
+      return availablePort;
+    } catch (error) {
+      if (!["EADDRINUSE", "EACCES"].includes(error.code) && !(error instanceof Locked)) {
+        throw error;
+      }
+    }
+  }
+  throw new Error("No available ports found");
+}
+
+// src/plugins/core/inspector-proxy/inspector-proxy-controller.ts
+var import_ws4 = __toESM(require("ws"));
+
+// package.json
+var version = "0.0.0-e5dbedd78";
+
+// src/plugins/core/inspector-proxy/inspector-proxy.ts
+var import_node_assert4 = __toESM(require("node:assert"));
+var import_ws3 = __toESM(require("ws"));
+
+// src/plugins/core/inspector-proxy/devtools.ts
+function isDevToolsEvent(event, name) {
+  return typeof event === "object" && event !== null && "method" in event && event.method === name;
+}
+
+// src/plugins/core/inspector-proxy/inspector-proxy.ts
+var InspectorProxy = class {
+  #workerName;
+  #runtimeWs;
+  #devtoolsWs;
+  #devtoolsHaveFileSystemAccess = false;
+  constructor(workerName, runtimeWs) {
+    this.#workerName = workerName;
+    this.#runtimeWs = runtimeWs;
+    this.#runtimeWs.once("open", () => this.#handleRuntimeWebSocketOpen());
+  }
+  get workerName() {
+    return this.#workerName;
+  }
+  get path() {
+    return `/${this.#workerName}`;
+  }
+  onDevtoolsConnected(devtoolsWs, devtoolsHaveFileSystemAccess) {
+    if (this.#devtoolsWs) {
+      devtoolsWs.close(
+        1013,
+        "Too many clients; only one can be connected at a time"
+      );
+      return;
+    }
+    this.#devtoolsWs = devtoolsWs;
+    this.#devtoolsHaveFileSystemAccess = devtoolsHaveFileSystemAccess;
+    (0, import_node_assert4.default)(this.#devtoolsWs?.readyState === import_ws3.default.OPEN);
+    this.#devtoolsWs.on("error", console.error);
+    this.#devtoolsWs.once("close", () => {
+      if (this.#runtimeWs?.OPEN) {
+        this.#sendMessageToRuntime({
+          method: "Debugger.disable",
+          id: this.#nextCounter()
+        });
+      }
+      this.#devtoolsWs = void 0;
+    });
+    this.#devtoolsWs.on("message", (data) => {
+      const message = JSON.parse(data.toString());
+      (0, import_node_assert4.default)(this.#runtimeWs?.OPEN);
+      this.#sendMessageToRuntime(message);
+    });
+  }
+  #runtimeMessageCounter = 1e8;
+  #nextCounter() {
+    return ++this.#runtimeMessageCounter;
+  }
+  #runtimeKeepAliveInterval;
+  #handleRuntimeWebSocketOpen() {
+    (0, import_node_assert4.default)(this.#runtimeWs?.OPEN);
+    this.#runtimeWs.on("message", (data) => {
+      const message = JSON.parse(data.toString());
+      if (!this.#devtoolsWs) {
+        return;
+      }
+      if (isDevToolsEvent(message, "Debugger.scriptParsed")) {
+        return this.#handleRuntimeScriptParsed(message);
+      }
+      return this.#sendMessageToDevtools(message);
+    });
+    clearInterval(this.#runtimeKeepAliveInterval);
+    this.#runtimeKeepAliveInterval = setInterval(() => {
+      if (this.#runtimeWs?.OPEN) {
+        this.#sendMessageToRuntime({
+          method: "Runtime.getIsolateId",
+          id: this.#nextCounter()
+        });
+      }
+    }, 1e4);
+  }
+  #handleRuntimeScriptParsed(message) {
+    if (!this.#devtoolsHaveFileSystemAccess && message.params.sourceMapURL !== void 0 && // Don't try to find a sourcemap for e.g. node-internal: scripts
+    message.params.url.startsWith("file:")) {
+      const url20 = new URL(message.params.sourceMapURL, message.params.url);
+      if (url20.protocol === "file:") {
+        message.params.sourceMapURL = url20.href.replace(
+          "file:",
+          "wrangler-file:"
+        );
+      }
+    }
+    return this.#sendMessageToDevtools(message);
+  }
+  #sendMessageToDevtools(message) {
+    (0, import_node_assert4.default)(this.#devtoolsWs);
+    if (!this.#devtoolsWs.OPEN) {
+      this.#devtoolsWs.once(
+        "open",
+        () => this.#devtoolsWs?.send(JSON.stringify(message))
+      );
+      return;
+    }
+    this.#devtoolsWs.send(JSON.stringify(message));
+  }
+  #sendMessageToRuntime(message) {
+    (0, import_node_assert4.default)(this.#runtimeWs?.OPEN);
+    this.#runtimeWs.send(JSON.stringify(message));
+  }
+  async dispose() {
+    clearInterval(this.#runtimeKeepAliveInterval);
+    this.#devtoolsWs?.close();
+  }
+};
+
+// src/plugins/core/inspector-proxy/inspector-proxy-controller.ts
+var InspectorProxyController = class {
+  constructor(userInspectorPort, log, workerNamesToProxy) {
+    this.log = log;
+    this.workerNamesToProxy = workerNamesToProxy;
+    this.#inspectorPort = userInspectorPort !== 0 ? userInspectorPort : getPorts();
+    this.#server = this.#initializeServer();
+    this.#runtimeConnectionEstablished = new DeferredPromise();
+  }
+  #runtimeConnectionEstablished;
+  #proxies = [];
+  #server;
+  #inspectorPort;
+  async #initializeServer() {
+    const server = (0, import_node_http.createServer)(async (req, res) => {
+      const maybeJson = await this.#handleDevToolsJsonRequest(
+        req.headers.host ?? "localhost",
+        req.url ?? "/"
+      );
+      if (maybeJson !== null) {
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify(maybeJson));
+        return;
+      }
+      res.statusCode = 404;
+      res.end(null);
+    });
+    this.#initializeWebSocketServer(server);
+    server.listen(await this.#inspectorPort);
+    return server;
+  }
+  #initializeWebSocketServer(server) {
+    const devtoolsWebSocketServer = new import_ws4.WebSocketServer({ server });
+    devtoolsWebSocketServer.on("connection", (devtoolsWs, upgradeRequest) => {
+      const validationError = this.#validateDevToolsWebSocketUpgradeRequest(upgradeRequest);
+      if (validationError !== null) {
+        devtoolsWs.close();
+        return;
+      }
+      const proxy = this.#proxies.find(
+        ({ path: path30 }) => upgradeRequest.url === path30
+      );
+      if (!proxy) {
+        this.log.warn(
+          `Warning: An inspector connection was requested for the ${upgradeRequest.url} path but no such inspector exists`
+        );
+        devtoolsWs.close();
+        return;
+      }
+      proxy.onDevtoolsConnected(
+        devtoolsWs,
+        this.#checkIfDevtoolsHaveFileSystemAccess(upgradeRequest)
+      );
+    });
+  }
+  #validateDevToolsWebSocketUpgradeRequest(req) {
+    const hostHeader = req.headers.host;
+    if (hostHeader == null) return { statusText: null, status: 400 };
+    try {
+      const host = new URL(`http://${hostHeader}`);
+      if (!ALLOWED_HOST_HOSTNAMES.includes(host.hostname)) {
+        return { statusText: "Disallowed `Host` header", status: 401 };
+      }
+    } catch {
+      return { statusText: "Expected `Host` header", status: 400 };
+    }
+    let originHeader = req.headers.origin;
+    if (!originHeader && !req.headers["user-agent"]) {
+      originHeader = "http://localhost";
+    }
+    if (!originHeader) {
+      return { statusText: "Expected `Origin` header", status: 400 };
+    }
+    try {
+      const origin = new URL(originHeader);
+      const allowed = ALLOWED_ORIGIN_HOSTNAMES.some((rule) => {
+        if (typeof rule === "string") return origin.hostname === rule;
+        else return rule.test(origin.hostname);
+      });
+      if (!allowed) {
+        return { statusText: "Disallowed `Origin` header", status: 401 };
+      }
+    } catch {
+      return { statusText: "Expected `Origin` header", status: 400 };
+    }
+    return null;
+  }
+  #checkIfDevtoolsHaveFileSystemAccess(req) {
+    const userAgent = req.headers["user-agent"] ?? "";
+    const hasFileSystemAccess = !/mozilla/i.test(userAgent);
+    return hasFileSystemAccess;
+  }
+  #inspectorId = import_node_crypto2.default.randomUUID();
+  async #handleDevToolsJsonRequest(host, path30) {
+    if (path30 === "/json/version") {
+      return {
+        Browser: `miniflare/v${version}`,
+        // TODO: (someday): The DevTools protocol should match that of workerd.
+        // This could be exposed by the preview API.
+        "Protocol-Version": "1.3"
+      };
+    }
+    if (path30 === "/json" || path30 === "/json/list") {
+      return this.#proxies.map(({ workerName }) => {
+        const localHost = `${host}/${workerName}`;
+        const devtoolsFrontendUrl = `https://devtools.devprod.cloudflare.dev/js_app?theme=systemPreferred&debugger=true&ws=${localHost}`;
+        return {
+          id: `${this.#inspectorId}-${workerName}`,
+          type: "node",
+          // TODO: can we specify different type?
+          description: "workers",
+          webSocketDebuggerUrl: `ws://${localHost}`,
+          devtoolsFrontendUrl,
+          devtoolsFrontendUrlCompat: devtoolsFrontendUrl,
+          // Below are fields that are visible in the DevTools UI.
+          title: workerName.length === 0 || this.#proxies.length === 1 ? `Cloudflare Worker` : `Cloudflare Worker: ${workerName}`,
+          faviconUrl: "https://workers.cloudflare.com/favicon.ico"
+          // url: "http://" + localHost, // looks unnecessary
+        };
+      });
+    }
+    return null;
+  }
+  async getInspectorURL() {
+    return getWebsocketURL(await this.#inspectorPort);
+  }
+  async updateConnection(runtimeInspectorPort) {
+    const workerdInspectorJson = await fetch(
+      `http://127.0.0.1:${runtimeInspectorPort}/json`
+    ).then((resp) => resp.json());
+    this.#proxies = workerdInspectorJson.map(({ id }) => {
+      if (!id.startsWith("core:user:")) {
+        return;
+      }
+      const workerName = id.replace(/^core:user:/, "");
+      if (!this.workerNamesToProxy.has(workerName)) {
+        return;
+      }
+      return new InspectorProxy(
+        workerName,
+        new import_ws4.default(`ws://127.0.0.1:${runtimeInspectorPort}/${id}`)
+      );
+    }).filter(Boolean);
+    this.#runtimeConnectionEstablished.resolve();
+  }
+  async #waitForReady() {
+    await this.#runtimeConnectionEstablished;
+  }
+  get ready() {
+    return this.#waitForReady();
+  }
+  async dispose() {
+    await Promise.all(this.#proxies.map((proxy) => proxy.dispose()));
+    const server = await this.#server;
+    return new Promise((resolve2, reject) => {
+      server.close((err) => err ? reject(err) : resolve2());
+    });
+  }
+};
+function getWebsocketURL(port) {
+  return new URL(`ws://127.0.0.1:${port}`);
+}
+var ALLOWED_HOST_HOSTNAMES = ["127.0.0.1", "[::1]", "localhost"];
+var ALLOWED_ORIGIN_HOSTNAMES = [
+  "devtools.devprod.cloudflare.dev",
+  "cloudflare-devtools.pages.dev",
+  /^[a-z0-9]+\.cloudflare-devtools\.pages\.dev$/,
+  "127.0.0.1",
+  "[::1]",
+  "localhost"
+];
+
 // src/shared/mime-types.ts
 var compressedByCloudflareFL = /* @__PURE__ */ new Set([
   // list copied from https://developers.cloudflare.com/speed/optimization/content/brotli/content-compression/#:~:text=If%20supported%20by%20visitors%E2%80%99%20web%20browsers%2C%20Cloudflare%20will%20return%20Gzip%20or%20Brotli%2Dencoded%20responses%20for%20the%20following%20content%20types%3A
@@ -14589,18 +15012,45 @@ var Miniflare2 = class _Miniflare {
   #liveReloadServer;
   #webSocketServer;
   #webSocketExtraHeaders;
+  #maybeInspectorProxyController;
+  #previousRuntimeInspectorPort;
   constructor(opts) {
     const [sharedOpts, workerOpts] = validateOptions(opts);
     this.#sharedOpts = sharedOpts;
     this.#workerOpts = workerOpts;
+    const workerNamesToProxy = new Set(
+      this.#workerOpts.filter(({ core: { unsafeInspectorProxy } }) => !!unsafeInspectorProxy).map((w) => w.core.name ?? "")
+    );
+    const enableInspectorProxy = workerNamesToProxy.size > 0;
+    if (enableInspectorProxy) {
+      if (this.#sharedOpts.core.inspectorPort === void 0) {
+        throw new MiniflareCoreError(
+          "ERR_MISSING_INSPECTOR_PROXY_PORT",
+          "inspector proxy requested but without an inspectorPort specified"
+        );
+      }
+    }
     if (maybeInstanceRegistry !== void 0) {
       const object = { name: "Miniflare", stack: "" };
       Error.captureStackTrace(object, _Miniflare);
       maybeInstanceRegistry.set(this, object.stack);
     }
     this.#log = this.#sharedOpts.core.log ?? new NoOpLog();
-    this.#liveReloadServer = new import_ws3.WebSocketServer({ noServer: true });
-    this.#webSocketServer = new import_ws3.WebSocketServer({
+    if (enableInspectorProxy) {
+      if (this.#sharedOpts.core.inspectorPort === void 0) {
+        throw new MiniflareCoreError(
+          "ERR_MISSING_INSPECTOR_PROXY_PORT",
+          "inspector proxy requested but without an inspectorPort specified"
+        );
+      }
+      this.#maybeInspectorProxyController = new InspectorProxyController(
+        this.#sharedOpts.core.inspectorPort,
+        this.#log,
+        workerNamesToProxy
+      );
+    }
+    this.#liveReloadServer = new import_ws5.WebSocketServer({ noServer: true });
+    this.#webSocketServer = new import_ws5.WebSocketServer({
       noServer: true,
       // Disable automatic handling of `Sec-WebSocket-Protocol` header,
       // Cloudflare Workers require users to include this header themselves in
@@ -14911,14 +15361,13 @@ var Miniflare2 = class _Miniflare {
               );
               if (maybeAssetTargetService && !binding.service?.entrypoint) {
                 (0, import_assert12.default)(binding.service?.name);
-                binding.service.name = this.#sharedOpts.core.unsafeEnableAssetsRpc ? `${RPC_PROXY_SERVICE_NAME}:${targetWorkerName}` : `${ROUTER_SERVICE_NAME}:${targetWorkerName}`;
+                binding.service.name = `${RPC_PROXY_SERVICE_NAME}:${targetWorkerName}`;
               }
             }
           }
         }
       }
       const unsafeStickyBlobs = sharedOpts.core.unsafeStickyBlobs ?? false;
-      const unsafeEnableAssetsRpc = sharedOpts.core.unsafeEnableAssetsRpc ?? false;
       const unsafeEphemeralDurableObjects = workerOpts.core.unsafeEphemeralDurableObjects ?? false;
       const pluginServicesOptionsBase = {
         log: this.#log,
@@ -14933,8 +15382,7 @@ var Miniflare2 = class _Miniflare {
         durableObjectClassNames,
         unsafeEphemeralDurableObjects,
         queueProducers,
-        queueConsumers,
-        unsafeEnableAssetsRpc
+        queueConsumers
       };
       for (const [key, plugin] of PLUGIN_ENTRIES) {
         const pluginServicesExtensions = await plugin.getServices({
@@ -14982,13 +15430,16 @@ var Miniflare2 = class _Miniflare {
           directSocket.host,
           directSocket.port
         );
+        const service = workerOpts.assets.assets && entrypoint === "default" ? {
+          name: `${RPC_PROXY_SERVICE_NAME}:${workerOpts.core.name}`
+        } : {
+          name: getUserServiceName(workerName),
+          entrypoint: entrypoint === "default" ? void 0 : entrypoint
+        };
         sockets.push({
           name,
           address,
-          service: {
-            name: getUserServiceName(workerName),
-            entrypoint: entrypoint === "default" ? void 0 : entrypoint
-          },
+          service,
           http: {
             style: directSocket.proxy ? HttpOptions_Style.PROXY : void 0,
             cfBlobHeader: CoreHeaders.CF_BLOB,
@@ -15001,15 +15452,15 @@ var Miniflare2 = class _Miniflare {
       sharedOptions: sharedOpts.core,
       allWorkerRoutes,
       /*
-       * - if Workers + Assets project but NOT Vitest, point to Router Worker or
-       *   Proxy Worker depending on whether experimental flag `unsafeEnableAssetsRpc`
-       *   was set
-       * - if Vitest with assets, the self binding on the test runner will point to
-       *   Router Worker
+       * - if Workers + Assets project but NOT Vitest, the fallback Worker (see
+       *   `MINIFLARE_USER_FALLBACK`) should point to the (assets) RPC Proxy Worker
+       * - if Vitest with assets, the fallback Worker should point to the Vitest
+       *   runner Worker, while the SELF binding on the test runner will point to
+       *   the (assets) RPC Proxy Worker
        */
       fallbackWorkerName: this.#workerOpts[0].assets.assets && !this.#workerOpts[0].core.name?.startsWith(
         "vitest-pool-workers-runner-"
-      ) ? this.#sharedOpts.core.unsafeEnableAssetsRpc ? `${RPC_PROXY_SERVICE_NAME}:${this.#workerOpts[0].core.name}` : `${ROUTER_SERVICE_NAME}:${this.#workerOpts[0].core.name}` : getUserServiceName(this.#workerOpts[0].core.name),
+      ) ? `${RPC_PROXY_SERVICE_NAME}:${this.#workerOpts[0].core.name}` : getUserServiceName(this.#workerOpts[0].core.name),
       loopbackPort,
       log: this.#log,
       proxyBindings
@@ -15060,14 +15511,19 @@ var Miniflare2 = class _Miniflare {
       configuredHost,
       this.#sharedOpts.core.port
     );
-    let inspectorAddress;
+    let runtimeInspectorAddress;
     if (this.#sharedOpts.core.inspectorPort !== void 0) {
-      inspectorAddress = this.#getSocketAddress(
+      let runtimeInspectorPort = this.#sharedOpts.core.inspectorPort;
+      if (this.#maybeInspectorProxyController !== void 0) {
+        runtimeInspectorPort = 0;
+      }
+      runtimeInspectorAddress = this.#getSocketAddress(
         kInspectorSocket,
-        this.#previousSharedOpts?.core.inspectorPort,
+        this.#previousRuntimeInspectorPort,
         "localhost",
-        this.#sharedOpts.core.inspectorPort
+        runtimeInspectorPort
       );
+      this.#previousRuntimeInspectorPort = runtimeInspectorPort;
     }
     const loopbackAddress = `${maybeGetLocallyAccessibleHost(configuredHost) ?? getURLSafeHost(configuredHost)}:${loopbackPort}`;
     const runtimeOpts = {
@@ -15075,7 +15531,7 @@ var Miniflare2 = class _Miniflare {
       entryAddress,
       loopbackAddress,
       requiredSockets,
-      inspectorAddress,
+      inspectorAddress: runtimeInspectorAddress,
       verbose: this.#sharedOpts.core.verbose,
       handleRuntimeStdio: this.#sharedOpts.core.handleRuntimeStdio
     };
@@ -15091,6 +15547,17 @@ var Miniflare2 = class _Miniflare {
       );
     }
     this.#socketPorts = maybeSocketPorts;
+    if (this.#maybeInspectorProxyController !== void 0) {
+      const maybePort = this.#socketPorts.get(kInspectorSocket);
+      if (maybePort === void 0) {
+        throw new MiniflareCoreError(
+          "ERR_RUNTIME_FAILURE",
+          "Unable to access the runtime inspector socket."
+        );
+      } else {
+        this.#maybeInspectorProxyController.updateConnection(maybePort);
+      }
+    }
     const entrySocket = config.sockets?.[0];
     const secure = entrySocket !== void 0 && "https" in entrySocket;
     const previousEntryURL = this.#runtimeEntryURL;
@@ -15145,6 +15612,7 @@ var Miniflare2 = class _Miniflare {
     await this.#initPromise;
     await this.#runtimeMutex.drained();
     if (disposing) return new URL("http://[100::]/");
+    await this.#maybeInspectorProxyController?.ready;
     this.#checkDisposed();
     (0, import_assert12.default)(this.#runtimeEntryURL !== void 0);
     return new URL(this.#runtimeEntryURL.toString());
@@ -15160,6 +15628,9 @@ var Miniflare2 = class _Miniflare {
   async getInspectorURL() {
     this.#checkDisposed();
     await this.ready;
+    if (this.#maybeInspectorProxyController !== void 0) {
+      return this.#maybeInspectorProxyController.getInspectorURL();
+    }
     (0, import_assert12.default)(this.#socketPorts !== void 0);
     const maybePort = this.#socketPorts.get(kInspectorSocket);
     if (maybePort === void 0) {
@@ -15238,7 +15709,7 @@ var Miniflare2 = class _Miniflare {
     );
     const forwardInit = forward;
     forwardInit.dispatcher = dispatcher;
-    const response = await fetch3(url20, forwardInit);
+    const response = await fetch4(url20, forwardInit);
     const stack = response.headers.get(CoreHeaders.ERROR_STACK);
     if (response.status === 500 && stack !== null) {
       const caught = JsonErrorSchema.parse(await response.json());
@@ -15387,6 +15858,7 @@ var Miniflare2 = class _Miniflare {
       await this.#runtime?.dispose();
       await this.#stopLoopbackServer();
       await import_fs24.default.promises.rm(this.#tmpPath, { force: true, recursive: true });
+      await this.#maybeInspectorProxyController?.dispose();
       maybeInstanceRegistry?.delete(this);
     }
   }