@codexhost/cli-darwin-x64 0.16.0 → 0.17.0

package/app/desktop-controller.mjs

@@ -227,13 +227,32 @@ var CdpClient = class _CdpClient {
       returnByValue: true
     });
     if (!isRecord(response)) throw new Error("Runtime.evaluate returned an invalid result");
-    if (isRecord(response.exceptionDetails)) {
-      throw new Error(cdpExceptionMessage(response.exceptionDetails, "Renderer evaluation failed"));
-    }
-    if (!isRecord(response.result) || !("value" in response.result)) {
-      throw new Error("Runtime.evaluate did not return a value");
+    try {
+      if (isRecord(response.exceptionDetails)) {
+        throw new Error(
+          cdpExceptionMessage(response.exceptionDetails, "Renderer evaluation failed")
+        );
+      }
+      if (!isRecord(response.result) || !("value" in response.result)) {
+        throw new Error("Runtime.evaluate did not return a value");
+      }
+      return response.result.value;
+    } finally {
+      const objects = [
+        response.result,
+        isRecord(response.exceptionDetails) ? response.exceptionDetails.exception : void 0
+      ];
+      const ids = new Set(
+        objects.flatMap(
+          (object2) => isRecord(object2) && typeof object2.objectId === "string" ? [object2.objectId] : []
+        )
+      );
+      await Promise.all(
+        [...ids].map(
+          (objectId) => this.command("Runtime.releaseObject", { objectId }).catch(() => void 0)
+        )
+      );
     }
-    return response.result.value;
   }
   close() {
     if (this.#closed) return;
@@ -15840,7 +15859,10 @@ var harnessPluginRouteSchema = external_exports.object({
   harnessId: harnessPluginIdSchema,
   model: harnessModelRefSchema.optional(),
   thinkingOptionId: harnessThinkingOptionIdSchema.optional(),
-  permissionModeId: harnessPermissionModeIdSchema.optional()
+  permissionModeId: harnessPermissionModeIdSchema.optional(),
+  /** A draft prewarm create: stays unsubmitted until the user's first Turn.
+   * Desktop forwards only the Model of a main-process prewarm to thread/start. */
+  prewarm: external_exports.literal(true).optional()
 }).strict();
 
 // packages/shared-contracts/dist/harness-launch-settings.js
@@ -16706,20 +16728,20 @@ function retainRendererHostResponses(client, hostId2, target) {
 
 // packages/desktop-control/src/renderer-prewarm-consumption.ts
 function isolateRendererPrewarmConsumption(manager, discardExternal) {
-  const record2 = (value) => value !== null && typeof value === "object";
-  if (!record2(manager) || !record2(manager.threadCreation)) return null;
+  const record3 = (value) => value !== null && typeof value === "object";
+  if (!record3(manager) || !record3(manager.threadCreation)) return null;
   const creation = manager.threadCreation;
   const originalStart = manager.startConversation;
   const original = creation.createConversation;
   const params = creation.params;
-  if (typeof originalStart !== "function" || typeof original !== "function" || !record2(params))
+  if (typeof originalStart !== "function" || typeof original !== "function" || !record3(params))
     return null;
   const prototype = Object.getPrototypeOf(creation);
-  if (!record2(prototype) || typeof prototype.constructor !== "function") return null;
+  if (!record3(prototype) || typeof prototype.constructor !== "function") return null;
   if (Object.keys(creation).some((key) => key !== "params" && typeof creation[key] !== "function") || /#[A-Za-z_$]/u.test(Function.prototype.toString.call(prototype.constructor)))
     return null;
   const pool = params.prewarmedThreadManager;
-  if (!record2(pool) || typeof pool.hasPrewarmedThread !== "function" || typeof pool.consumePrewarmedThread !== "function" || typeof pool.deletePrewarmedThread !== "function")
+  if (!record3(pool) || typeof pool.hasPrewarmedThread !== "function" || typeof pool.consumePrewarmedThread !== "function" || typeof pool.deletePrewarmedThread !== "function")
     return null;
   const consume = pool.consumePrewarmedThread;
   const hasPrewarm = pool.hasPrewarmedThread;
@@ -16727,14 +16749,14 @@ function isolateRendererPrewarmConsumption(manager, discardExternal) {
   const draftIdentity = /* @__PURE__ */ Symbol("codexhost draft creation");
   const external = (model2) => typeof model2 === "string" && model2.startsWith("codexhost/");
   const routedStart = function(input, options, ...args) {
-    const draftId = record2(options) ? options.clientThreadId : null;
-    const mode = record2(input) && record2(input.collaborationMode) ? input.collaborationMode : null;
+    const draftId = record3(options) ? options.clientThreadId : null;
+    const mode = record3(input) && record3(input.collaborationMode) ? input.collaborationMode : null;
     const origin = mode ? Reflect.get(mode, draftIdentity) : void 0;
-    if (mode && record2(mode.settings) && external(mode.settings.model))
+    if (mode && record3(mode.settings) && external(mode.settings.model))
       return originalStart.call(this, input, options, ...args);
     const model2 = (typeof draftId === "string" ? draftModels.get(draftId) : void 0) ?? (typeof origin === "string" ? draftModels.get(origin) : void 0);
     if (!model2) return originalStart.call(this, input, options, ...args);
-    if (!record2(input) || !record2(input.collaborationMode) || !record2(input.collaborationMode.settings))
+    if (!record3(input) || !record3(input.collaborationMode) || !record3(input.collaborationMode.settings))
       throw new Error("External draft creation is missing its native Model settings");
     const routed = {
       ...input,
@@ -16746,17 +16768,17 @@ function isolateRendererPrewarmConsumption(manager, discardExternal) {
     return originalStart.call(this, routed, options, ...args);
   };
   const wrapped = function(input, ...args) {
-    const mode = record2(input) && record2(input.collaborationMode) ? input.collaborationMode : null;
-    const expected = mode && record2(mode.settings) ? mode.settings.model : null;
+    const mode = record3(input) && record3(input.collaborationMode) ? input.collaborationMode : null;
+    const expected = mode && record3(mode.settings) ? mode.settings.model : null;
     const scopedPool = Object.create(pool);
     scopedPool.hasPrewarmedThread = (...parameters) => hasPrewarm.apply(pool, parameters);
     scopedPool.consumePrewarmedThread = async (...consumeArgs) => {
       const warmed = await consume.apply(pool, consumeArgs);
-      if (!record2(warmed) || !record2(warmed.response)) return warmed;
+      if (!record3(warmed) || !record3(warmed.response)) return warmed;
       const response = warmed.response;
       if (!external(expected) && !external(response.model)) return warmed;
       if (external(expected) && expected === response.model) return warmed;
-      if (record2(response.thread) && typeof response.thread.id === "string") {
+      if (record3(response.thread) && typeof response.thread.id === "string") {
         const threadId = response.thread.id;
         if (external(response.model)) discardExternal(threadId);
         else
@@ -17361,14 +17383,14 @@ function createDraftPrewarmPolicyBridge(manager, bridge, hostId2, target, prewar
 
 // packages/desktop-control/src/renderer-host-discovery.ts
 function requestManagerFromHookState(value, hostId2) {
-  const record2 = (candidate) => typeof candidate === "object" && candidate !== null;
+  const record3 = (candidate) => typeof candidate === "object" && candidate !== null;
   const manager = (candidate) => {
-    if (!record2(candidate) || !record2(candidate.requestClient) || !record2(candidate.prewarmedThreadManager))
+    if (!record3(candidate) || !record3(candidate.requestClient) || !record3(candidate.prewarmedThreadManager))
       return null;
     const bridge = candidate.requestClient;
     return typeof candidate.sendRequest === "function" && typeof bridge.sendRequest === "function" && typeof bridge.prewarmThreadStart === "function" && typeof bridge.enqueueRequest === "function" && typeof candidate.prewarmedThreadManager.discardAllPrewarmedThreads === "function" ? candidate : null;
   };
-  if (!record2(value)) return null;
+  if (!record3(value)) return null;
   const direct = manager(value) ?? manager(value.manager);
   if (direct) return direct;
   if (!hostId2 || typeof value.addManager !== "function" || typeof value.getForHostId !== "function")
@@ -17578,6 +17600,339 @@ function installRendererHostRouting(root, target, discover, resolve, createPolic
   return routing;
 }
 
+// packages/desktop-control/src/renderer-host-rpc-discovery.ts
+function findRendererAppScopeStore(root) {
+  const MAX_VISITED_FIBERS = 5e4;
+  const record3 = (value) => typeof value === "object" && value !== null;
+  const container = root.getElementById?.("root");
+  if (!record3(container)) return null;
+  const key = Object.getOwnPropertyNames(container).find(
+    (name) => name.startsWith("__reactContainer$")
+  );
+  const first = key ? container[key] : null;
+  if (!record3(first)) return null;
+  const isScopeHandle = (value) => record3(value) && record3(value.node) && "chain" in value && "scope" in value && typeof value.get === "function" && typeof value.set === "function" && typeof value.watch === "function";
+  const stack = [first];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length && seen.size < MAX_VISITED_FIBERS) {
+    const fiber = stack.pop();
+    if (seen.has(fiber)) continue;
+    seen.add(fiber);
+    let hook = fiber.memoizedState;
+    for (let index = 0; record3(hook) && "next" in hook && index < 150; index += 1) {
+      const state = hook.memoizedState;
+      const handle = record3(state) ? state.current : null;
+      if (isScopeHandle(handle)) {
+        let node = handle.node;
+        const nodes = /* @__PURE__ */ new Set();
+        while (record3(node.parent) && !nodes.has(node.parent)) {
+          nodes.add(node);
+          node = node.parent;
+        }
+        const bindings = node.familyBindings;
+        return record3(bindings) && typeof bindings.get === "function" && typeof bindings.entries === "function" ? node : null;
+      }
+      hook = hook.next;
+    }
+    if (record3(fiber.sibling)) stack.push(fiber.sibling);
+    if (record3(fiber.child)) stack.push(fiber.child);
+  }
+  return null;
+}
+function findRendererHostRpcFamily(store) {
+  const record3 = (value) => typeof value === "object" && value !== null;
+  const families = /* @__PURE__ */ new Set();
+  for (const [definition, members] of store.familyBindings) {
+    if (!record3(definition) || definition.kind !== "signal-family") continue;
+    if (!record3(members) || typeof members.get !== "function") continue;
+    for (const [hostId2, member] of members) {
+      if (typeof hostId2 !== "string" || !record3(member)) continue;
+      const signal = member.value;
+      if (!record3(signal) || typeof signal.get !== "function") continue;
+      let value;
+      try {
+        value = signal.get();
+      } catch {
+        continue;
+      }
+      if (record3(value) && Object.keys(value).length === 2 && typeof value.status === "string" && record3(value.client) && value.client.hostId === hostId2 && "rpc" in value.client) {
+        families.add(members);
+        break;
+      }
+    }
+  }
+  if (families.size !== 1) return null;
+  return { store, family: families.values().next().value };
+}
+function resolveRendererHostRpc(discovery, hostId2) {
+  const record3 = (value2) => typeof value2 === "object" && value2 !== null;
+  const signal = discovery.family.get(hostId2)?.value;
+  if (!record3(signal) || typeof signal.get !== "function") return null;
+  let value;
+  try {
+    value = signal.get();
+  } catch {
+    return null;
+  }
+  if (!record3(value) || value.status !== "ready" || !record3(value.client) || value.client.hostId !== hostId2)
+    return null;
+  const rpc = value.client.rpc;
+  return typeof rpc === "function" || record3(rpc) ? rpc : null;
+}
+function rendererHostRpcHostIds(discovery) {
+  return [...discovery.family.keys()].filter(
+    (hostId2) => typeof hostId2 === "string"
+  );
+}
+
+// packages/desktop-control/src/renderer-host-rpc-routing.ts
+function installRendererHostRpcRouting(root, target, dependencies) {
+  const existing = target.__codexhostHostRoutingV1;
+  if (existing) return existing;
+  let disposed = false;
+  let discovery = null;
+  const routes = /* @__PURE__ */ new Map();
+  const read = () => {
+    if (disposed) return null;
+    if (!discovery) {
+      const store = dependencies.findStore(root);
+      discovery = store ? dependencies.findFamily(store) : null;
+    }
+    return discovery;
+  };
+  if (!read()) return null;
+  const isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  const externalDrafts = /* @__PURE__ */ new Map();
+  const selectedModels = /* @__PURE__ */ new Map();
+  const prewarmCarrier = (carrier) => {
+    const prefix = "codexhost/plugin-v1@";
+    if (!carrier.startsWith(prefix)) return null;
+    try {
+      const json2 = carrier.slice(prefix.length).replace(/[a-f0-9]{2}/gu, (byte) => String.fromCharCode(Number.parseInt(byte, 16)));
+      const route = JSON.parse(json2);
+      if (!isRecord3(route)) return null;
+      const payload = [...JSON.stringify({ ...route, prewarm: true })].map((character) => character.charCodeAt(0).toString(16).padStart(2, "0")).join("");
+      return `${prefix}${payload}`;
+    } catch {
+      return null;
+    }
+  };
+  const publishDraftWorkspace = (hostId2, cwd) => {
+    if (typeof cwd !== "string" || cwd.length === 0) return;
+    const drafts = isRecord3(target.__codexhostDraftWorkspacesV1) ? target.__codexhostDraftWorkspacesV1 : {};
+    if (drafts[hostId2] === cwd) return;
+    drafts[hostId2] = cwd;
+    Object.defineProperty(target, "__codexhostDraftWorkspacesV1", {
+      configurable: true,
+      value: drafts
+    });
+    if (typeof target.dispatchEvent === "function" && typeof CustomEvent === "function") {
+      target.dispatchEvent(
+        new CustomEvent("codexhost:draft-workspace", { detail: { hostId: hostId2, cwd } })
+      );
+    }
+  };
+  const routeCreationCall = (message) => {
+    if (!Array.isArray(message) || message.length !== 2 || message[0] !== "push") return message;
+    const expression = message[1];
+    if (!Array.isArray(expression) || expression.length !== 4 || expression[0] !== "pipeline")
+      return message;
+    const [, importId, path3, args] = expression;
+    if (!Array.isArray(path3) || path3.length !== 1 || !Array.isArray(args)) return message;
+    const [input, options] = args;
+    if (!isRecord3(input) || !isRecord3(input.collaborationMode)) return message;
+    const settings = input.collaborationMode.settings;
+    if (!isRecord3(settings)) return message;
+    const nativeModel = typeof settings.model === "string" ? settings.model : null;
+    let model2 = null;
+    if (path3[0] === "startConversation") {
+      const draftId = isRecord3(options) ? options.clientThreadId : null;
+      model2 = typeof draftId === "string" ? externalDrafts.get(draftId)?.model ?? null : null;
+    } else if (path3[0] === "prewarmConversation") {
+      if (input.ephemeral !== true) publishDraftWorkspace("local", input.cwd);
+      const selected = selectedModels.get("local") ?? null;
+      const carrier = nativeModel?.startsWith("codexhost/") ? nativeModel : selected;
+      model2 = carrier ? prewarmCarrier(carrier) : null;
+    }
+    if (!model2) return message;
+    if (path3[0] === "startConversation" && nativeModel?.startsWith("codexhost/") && nativeModel !== model2)
+      return message;
+    return [
+      "push",
+      [
+        "pipeline",
+        importId,
+        path3,
+        [
+          {
+            ...input,
+            collaborationMode: { ...input.collaborationMode, settings: { ...settings, model: model2 } }
+          },
+          ...args.slice(1)
+        ]
+      ]
+    ];
+  };
+  const port = dependencies.portPrototype;
+  const originalPostMessage = port.postMessage;
+  const postMessage = function(message, ...rest) {
+    let routed = message;
+    try {
+      routed = disposed ? message : routeCreationCall(message);
+    } catch {
+      routed = message;
+    }
+    return originalPostMessage.call(this, routed, ...rest);
+  };
+  port.postMessage = postMessage;
+  const createRoute = (hostId2, rpc) => {
+    let retired = false;
+    const isCurrent = () => !retired && !disposed && routes.get(hostId2)?.rpc === rpc;
+    const manager = Object.freeze({
+      kind: "main-process-rpc",
+      getHostId: () => hostId2,
+      sendRequest(method, params, options) {
+        if (!isCurrent())
+          return Promise.reject(new Error(`Renderer request manager is retired for ${hostId2}`));
+        return options === void 0 ? rpc.sendRequest(method, params) : rpc.sendRequest(method, params, options);
+      },
+      // The main process broadcasts every app-server notification to its windows,
+      // including codexhost methods Desktop's own notification table drops.
+      addNotificationCallback(methods, listener) {
+        const accepted = new Set(typeof methods === "string" ? [methods] : methods);
+        const onMessage = (event) => {
+          const { source, data } = event;
+          if (source != null && source !== target) return;
+          if (!isRecord3(data) || data.type !== "mcp-notification" || data.hostId !== hostId2 || typeof data.method !== "string" || !accepted.has(data.method) || !isCurrent())
+            return;
+          listener({ method: data.method, params: data.params });
+        };
+        target.addEventListener?.("message", onMessage);
+        return () => target.removeEventListener?.("message", onMessage);
+      }
+    });
+    const clearDrafts = () => {
+      for (const [draftId, draft] of externalDrafts) {
+        if (draft.owner === policy) externalDrafts.delete(draftId);
+      }
+    };
+    const clear = () => isCurrent() ? Promise.resolve(rpc.clearPrewarmedThreads()).then(() => void 0) : Promise.reject(new Error("Renderer request manager is retired"));
+    const policy = Object.freeze({
+      state: "ready",
+      hostId: hostId2,
+      scopedCreation: true,
+      requestTarget: () => {
+        if (!isCurrent()) throw new Error("Renderer request manager is retired");
+        return manager;
+      },
+      select(model2, draftId) {
+        if (!isCurrent()) throw new Error("Renderer request manager is retired");
+        if (model2 !== null && (typeof model2 !== "string" || !model2.startsWith("codexhost/"))) {
+          throw new Error("Draft route Model must be a codexhost transport carrier");
+        }
+        if (draftId === void 0) {
+          if (model2 === null) clearDrafts();
+        } else if (model2 === null) {
+          if (externalDrafts.get(draftId)?.owner === policy) externalDrafts.delete(draftId);
+        } else {
+          if (!draftId.startsWith("client-new-thread:"))
+            throw new Error("External draft route is missing its client Thread identity");
+          externalDrafts.set(draftId, { model: model2, owner: policy });
+        }
+        if ((selectedModels.get(hostId2) ?? null) === model2) return false;
+        if (model2 === null) selectedModels.delete(hostId2);
+        else selectedModels.set(hostId2, model2);
+        void clear().catch(() => void 0);
+        return true;
+      },
+      clear,
+      dispose() {
+        if (retired) return;
+        retired = true;
+        clearDrafts();
+        selectedModels.delete(hostId2);
+      }
+    });
+    return { hostId: hostId2, manager, policy };
+  };
+  const retire = (hostId2) => {
+    const entry = routes.get(hostId2);
+    routes.delete(hostId2);
+    entry?.route.policy.dispose();
+  };
+  const routeFor = (hostId2) => {
+    const current = read();
+    const rpc = current ? dependencies.resolve(current, hostId2) : null;
+    const previous = routes.get(hostId2);
+    if (rpc && previous?.rpc === rpc) return previous.route;
+    retire(hostId2);
+    if (!rpc) return null;
+    const route = createRoute(hostId2, rpc);
+    routes.set(hostId2, { route, rpc });
+    return route;
+  };
+  const publish = (route) => {
+    const policy = route?.policy;
+    if (target.__codexhostDraftPrewarmPolicyV1 === policy) return;
+    Object.defineProperty(target, "__codexhostDraftPrewarmPolicyV1", {
+      configurable: true,
+      value: policy
+    });
+    if (typeof target.dispatchEvent === "function" && typeof CustomEvent === "function") {
+      target.dispatchEvent(new CustomEvent("codexhost:draft-prewarm-policy-changed"));
+    }
+  };
+  const composerHostId = (composer) => {
+    const hostIds = new Set(dependencies.composerHostIds(composer).hostIds);
+    const hostId2 = hostIds.size === 1 ? hostIds.values().next().value : null;
+    return typeof hostId2 === "string" && hostId2 ? hostId2 : null;
+  };
+  const routing = {
+    knownHostIds() {
+      const current = read();
+      return current ? dependencies.hostIds(current) : [];
+    },
+    forHost(hostId2) {
+      return hostId2 && !disposed ? routeFor(hostId2) : null;
+    },
+    hostIdForComposer(composer) {
+      if (disposed) return null;
+      try {
+        return composerHostId(composer);
+      } catch {
+        return null;
+      }
+    },
+    forComposer(composer) {
+      if (disposed) return null;
+      let hostId2;
+      try {
+        hostId2 = composerHostId(composer);
+      } catch {
+        hostId2 = null;
+      }
+      const route = hostId2 ? routeFor(hostId2) : null;
+      if (!composer) publish(route);
+      return route;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const hostId2 of [...routes.keys()]) retire(hostId2);
+      discovery = null;
+      externalDrafts.clear();
+      selectedModels.clear();
+      if (port.postMessage === postMessage) port.postMessage = originalPostMessage;
+      if (target.__codexhostHostRoutingV1 === routing) {
+        delete target.__codexhostHostRoutingV1;
+        publish(null);
+      }
+    }
+  };
+  Object.defineProperty(target, "__codexhostHostRoutingV1", { configurable: true, value: routing });
+  return routing;
+}
+
 // packages/desktop-control/src/renderer-draft-prewarm-policy.ts
 var REQUEST_MANAGER_WAIT_TIMEOUT_MS = 6e4;
 var REQUEST_MANAGER_POLL_INTERVAL_MS = 25;
@@ -17590,21 +17945,52 @@ function directRendererInstaller() {
     const retainRendererHostResponses = ${retainRendererHostResponses.toString()};
     const createDraftPrewarmPolicyBridge = ${createDraftPrewarmPolicyBridge.toString()};
     const isolateRendererPrewarmConsumption = ${isolateRendererPrewarmConsumption.toString()};
-    const routing = (${installRendererHostRouting.toString()})(
-      document, window,
-      (root) => discoverRendererHosts(root, committedReactAncestors, requestManagerFromHookState),
+    const discover = (root) =>
+      discoverRendererHosts(root, committedReactAncestors, requestManagerFromHookState);
+    const installNative = () => (${installRendererHostRouting.toString()})(
+      document, window, discover,
       (discovery, hostId) => resolveRendererHostManager(discovery, hostId, requestManagerFromHookState),
       (manager, bridge, hostId, target, prewarmed, isCurrent) => createDraftPrewarmPolicyBridge(
         manager, bridge, hostId, target, prewarmed, isCurrent, retainRendererHostResponses,
         isolateRendererPrewarmConsumption,
       ),
     );
+    const installRpc = () => typeof MessagePort !== 'function' ? null : (${installRendererHostRpcRouting.toString()})(document, window, {
+      findStore: ${findRendererAppScopeStore.toString()},
+      findFamily: ${findRendererHostRpcFamily.toString()},
+      resolve: ${resolveRendererHostRpc.toString()},
+      hostIds: ${rendererHostRpcHostIds.toString()},
+      composerHostIds: (composer) => {
+        const source = composer?.matches?.('[data-codex-composer], [contenteditable="true"][role="textbox"]')
+          ? { querySelectorAll: () => [composer] }
+          : (composer ?? document);
+        return discover(source);
+      },
+      portPrototype: MessagePort.prototype,
+    });
+    const connected = (routing) => routing.forComposer() !== null ||
+      ['local', ...(routing.knownHostIds?.() ?? [])].some((hostId) => routing.forHost(hostId) !== null);
+    let nativeReady = false;
+    // A legacy registry can remain mounted without a usable native manager.
+    // Prefer a ready native route, then try the identified main-process RPC store.
+    const routing = (() => {
+      if (window.__codexhostHostRoutingV1) return window.__codexhostHostRoutingV1;
+      const native = discover(document);
+      if (native.managers.length || native.registries.length) {
+        const routing = installNative();
+        if (connected(routing)) {
+          nativeReady = true;
+          return routing;
+        }
+        routing.dispose();
+      }
+      const rpc = installRpc();
+      if (rpc) return rpc;
+      throw new Error('Renderer Host request manager is unavailable');
+    })();
     // Publish a default draft policy only when its Host is unambiguous. Host
     // connections can be ready even when multiple Composers coexist.
-    const composerRoute = routing.forComposer();
-    const connected = composerRoute !== null ||
-      ['local', ...(routing.knownHostIds?.() ?? [])].some((hostId) => routing.forHost(hostId) !== null);
-    if (!connected) throw new Error('Renderer Host request manager is unavailable');
+    if (!nativeReady && !connected(routing)) throw new Error('Renderer Host request manager is unavailable');
     return { state: 'ready', reason: 'owned-request-bridge' };
   })()`;
 }
@@ -17635,6 +18021,130 @@ function installRendererDraftPrewarmPolicyDirect(renderer) {
   );
 }
 
+// packages/desktop-control/src/renderer-loaded-modules.ts
+var record2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var MAX_MODULES = 4096;
+var STALE_CONTEXT_ERROR = /uniqueContextId not found|Cannot find context with specified id|Execution context was destroyed|Cannot find default execution context/i;
+function isStaleContextError(error51) {
+  return error51 instanceof Error && STALE_CONTEXT_ERROR.test(error51.message);
+}
+function nativeModuleCatalogExpression(urls, complete, owner) {
+  return `Object.defineProperty(globalThis, '__codexhostLoadedModulesV1', {
+    configurable: true,
+    value: Object.freeze({ owner: ${JSON.stringify(owner)}, documentUrl: location.href, complete: ${complete}, urls: Object.freeze(${JSON.stringify(urls)}) })
+  }); void 0`;
+}
+async function installRendererLoadedModules(renderer) {
+  const owner = crypto.randomUUID();
+  const contexts = /* @__PURE__ */ new Map();
+  const contextIds = /* @__PURE__ */ new Map();
+  const dirty = /* @__PURE__ */ new Set();
+  let ready = false;
+  let disposed = false;
+  let timer;
+  let publishing = Promise.resolve();
+  const flush = () => {
+    clearTimeout(timer);
+    timer = void 0;
+    const pending = [...dirty];
+    dirty.clear();
+    publishing = publishing.catch(() => void 0).then(async () => {
+      let failure;
+      for (const uniqueId of pending) {
+        const context = contexts.get(uniqueId);
+        if (!context || disposed) continue;
+        try {
+          const response = await renderer.command("Runtime.evaluate", {
+            expression: nativeModuleCatalogExpression([...context.urls], context.complete, owner),
+            uniqueContextId: uniqueId
+          });
+          if (record2(response) && record2(response.exceptionDetails))
+            throw new Error("Loaded Renderer module catalog publication failed");
+        } catch (error51) {
+          if (contexts.get(uniqueId) !== context) continue;
+          if (isStaleContextError(error51)) {
+            forget(uniqueId);
+            continue;
+          }
+          failure ??= error51;
+        }
+      }
+      if (failure !== void 0) throw failure;
+    });
+    return publishing;
+  };
+  const schedule = (uniqueId) => {
+    dirty.add(uniqueId);
+    if (ready && timer === void 0)
+      timer = setTimeout(() => {
+        void flush().catch((error51) => {
+          console.error("Could not publish loaded Renderer modules", error51);
+        });
+      }, 10);
+  };
+  const forget = (uniqueId) => {
+    contexts.delete(uniqueId);
+    dirty.delete(uniqueId);
+    for (const [id, value] of contextIds) if (value === uniqueId) contextIds.delete(id);
+  };
+  const remove = (params) => {
+    const byId = typeof params.executionContextId === "number" ? contextIds.get(params.executionContextId) : void 0;
+    const uniqueId = typeof params.executionContextUniqueId === "string" ? params.executionContextUniqueId : byId;
+    if (uniqueId) forget(uniqueId);
+  };
+  const listeners = [
+    renderer.on("Runtime.executionContextCreated", (params) => {
+      const context = record2(params) ? params.context : null;
+      if (!record2(context) || typeof context.id !== "number" || typeof context.uniqueId !== "string" || !record2(context.auxData) || context.auxData.isDefault !== true)
+        return;
+      contextIds.set(context.id, context.uniqueId);
+      contexts.set(context.uniqueId, { urls: /* @__PURE__ */ new Set(), complete: true });
+      schedule(context.uniqueId);
+    }),
+    renderer.on("Runtime.executionContextDestroyed", (params) => {
+      if (record2(params)) remove(params);
+    }),
+    renderer.on("Runtime.executionContextsCleared", () => {
+      contextIds.clear();
+      contexts.clear();
+      dirty.clear();
+    }),
+    renderer.on("Debugger.scriptParsed", (params) => {
+      if (!record2(params) || params.isModule !== true || params.hasSourceURL === true || typeof params.url !== "string" || typeof params.executionContextId !== "number")
+        return;
+      const uniqueId = contextIds.get(params.executionContextId);
+      const context = uniqueId ? contexts.get(uniqueId) : null;
+      if (!context || !uniqueId || context.urls.has(params.url)) return;
+      if (context.urls.size >= MAX_MODULES) context.complete = false;
+      else context.urls.add(params.url);
+      schedule(uniqueId);
+    })
+  ];
+  const dispose = () => {
+    disposed = true;
+    clearTimeout(timer);
+    for (const unsubscribe of listeners) unsubscribe();
+    for (const uniqueId of contexts.keys())
+      void renderer.command("Runtime.evaluate", {
+        expression: `if (globalThis.__codexhostLoadedModulesV1 === undefined || globalThis.__codexhostLoadedModulesV1?.owner === ${JSON.stringify(owner)}) { ${nativeModuleCatalogExpression([], false, owner)} }`,
+        uniqueContextId: uniqueId
+      }).catch(() => void 0);
+    contexts.clear();
+    contextIds.clear();
+    dirty.clear();
+  };
+  try {
+    await renderer.command("Runtime.enable");
+    await renderer.command("Debugger.enable");
+    ready = true;
+    await flush();
+    return dispose;
+  } catch (error51) {
+    dispose();
+    throw error51;
+  }
+}
+
 // packages/desktop-control/src/renderer-cdp-control-session.ts
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -17779,21 +18289,23 @@ async function waitForBinding(renderer, enabledAgents, timeoutMs, pollIntervalMs
 }
 async function installTarget(target, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations) {
   const renderer = await operations.connect(target.webSocketDebuggerUrl);
+  let disposeModules;
   try {
-    await renderer.command("Runtime.enable");
+    disposeModules = await installRendererLoadedModules(renderer);
     await renderer.command("Page.enable");
     await renderer.command("Page.addScriptToEvaluateOnNewDocument", { source: rendererSource });
     await evaluateSource(renderer, rendererSource);
     const draftPrewarmPolicy = await operations.installDraftPrewarmPolicy(renderer);
     const binding = await waitForBinding(renderer, enabledAgents, timeoutMs, pollIntervalMs);
-    return { renderer, snapshot: { target, draftPrewarmPolicy, binding } };
+    return { renderer, snapshot: { target, draftPrewarmPolicy, binding }, disposeModules };
   } catch (error51) {
+    disposeModules?.();
     renderer.close();
     throw error51;
   }
 }
 var InstalledRendererCdpControlSession = class {
-  constructor(renderer, rendererCdpEndpoint2, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, currentSnapshot) {
+  constructor(renderer, rendererCdpEndpoint2, rendererSource, enabledAgents, timeoutMs, pollIntervalMs, operations, currentSnapshot, disposeModules) {
     this.renderer = renderer;
     this.rendererCdpEndpoint = rendererCdpEndpoint2;
     this.rendererSource = rendererSource;
@@ -17802,6 +18314,7 @@ var InstalledRendererCdpControlSession = class {
     this.pollIntervalMs = pollIntervalMs;
     this.operations = operations;
     this.currentSnapshot = currentSnapshot;
+    this.disposeModules = disposeModules;
   }
   renderer;
   rendererCdpEndpoint;
@@ -17811,6 +18324,7 @@ var InstalledRendererCdpControlSession = class {
   pollIntervalMs;
   operations;
   currentSnapshot;
+  disposeModules;
   #closed = false;
   get snapshot() {
     return this.currentSnapshot;
@@ -17833,8 +18347,10 @@ var InstalledRendererCdpControlSession = class {
         this.pollIntervalMs,
         this.operations
       );
+      this.disposeModules();
       this.renderer.close();
       this.renderer = replacement.renderer;
+      this.disposeModules = replacement.disposeModules;
       this.currentSnapshot = replacement.snapshot;
       return this.currentSnapshot;
     }
@@ -17859,8 +18375,10 @@ var InstalledRendererCdpControlSession = class {
         this.pollIntervalMs,
         this.operations
       );
+      this.disposeModules();
       this.renderer.close();
       this.renderer = replacement.renderer;
+      this.disposeModules = replacement.disposeModules;
       this.currentSnapshot = replacement.snapshot;
       return this.currentSnapshot;
     }
@@ -17877,6 +18395,7 @@ var InstalledRendererCdpControlSession = class {
   close() {
     if (this.#closed) return;
     this.#closed = true;
+    this.disposeModules();
     this.renderer.close();
   }
 };
@@ -17914,7 +18433,8 @@ async function createRendererCdpControlSession(options) {
     timeoutMs,
     pollIntervalMs,
     operations,
-    installed.snapshot
+    installed.snapshot,
+    installed.disposeModules
   );
 }
 function installRendererCdpControlSession(options) {