@cortexkit/aft-opencode 0.12.1 → 0.12.2

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8BxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwC1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AA8HxD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAwBjE"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8BxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwC1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAmIxD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAwBjE"}

package/dist/index.js

@@ -7805,12 +7805,13 @@ var require_src2 = __commonJS((exports, module) => {
 // src/index.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 import { join as join13 } from "path";
 
 // src/config.ts
 var import_comment_json = __toESM(require_src2(), 1);
 import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
 import { join as join2 } from "path";
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
@@ -21514,7 +21515,11 @@ function mergeConfigs(base, override) {
   };
 }
 function getOpenCodeConfigDir() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join2(process.env.HOME || "~", ".config");
+  const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  if (envDir) {
+    return envDir;
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join2(homedir(), ".config");
   return join2(xdgConfig, "opencode");
 }
 function loadAftConfig(projectDirectory) {
@@ -21535,7 +21540,7 @@ function loadAftConfig(projectDirectory) {
 
 // src/downloader.ts
 import { chmodSync, existsSync as existsSync2, mkdirSync, unlinkSync } from "fs";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
 
 // src/platform.ts
@@ -21557,10 +21562,10 @@ var REPO = "cortexkit/aft";
 function getCacheDir() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join3(homedir(), "AppData", "Local");
+    const base2 = localAppData || join3(homedir2(), "AppData", "Local");
     return join3(base2, "aft", "bin");
   }
-  const base = process.env.XDG_CACHE_HOME || join3(homedir(), ".cache");
+  const base = process.env.XDG_CACHE_HOME || join3(homedir2(), ".cache");
   return join3(base, "aft", "bin");
 }
 function getBinaryName() {
@@ -21755,7 +21760,7 @@ function normalizeToolMap(tools) {
 
 // src/notifications.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { homedir as homedir2, platform } from "os";
+import { homedir as homedir3, platform } from "os";
 import { join as join4 } from "path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
@@ -21777,7 +21782,7 @@ var WARNING_MARKER = `${AFT_MARKER} \u26A0\uFE0F`;
 var STATUS_MARKER = `${AFT_MARKER} \u2705`;
 function getDesktopStatePath() {
   const os2 = platform();
-  const home = homedir2();
+  const home = homedir3();
   if (os2 === "darwin") {
     return join4(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
@@ -22059,8 +22064,7 @@ async function downloadOnnxRuntime(info, targetDir) {
       const { execSync } = await import("child_process");
       execSync(`tar xzf "${archivePath}" -C "${tmpDir}"`, { stdio: "pipe" });
     } else {
-      const { execSync } = await import("child_process");
-      execSync(`unzip -q "${archivePath}" -d "${tmpDir}"`, { stdio: "pipe" });
+      await extractZipArchive(archivePath, tmpDir);
     }
     const extractedDir = join5(tmpDir, info.assetName, "lib");
     if (!existsSync4(extractedDir)) {
@@ -22118,10 +22122,42 @@ async function downloadOnnxRuntime(info, targetDir) {
     return null;
   }
 }
+async function extractZipArchive(archivePath, destinationDir) {
+  const { execFileSync } = await import("child_process");
+  if (process.platform === "win32") {
+    let powershellError;
+    try {
+      execFileSync("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-Command",
+        "& { Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force }",
+        archivePath,
+        destinationDir
+      ], { stdio: "pipe", timeout: 120000 });
+      return;
+    } catch (err) {
+      powershellError = err;
+      warn(`PowerShell Expand-Archive failed, falling back to cmd/tar: ${String(err)}`);
+    }
+    try {
+      execFileSync("cmd.exe", ["/d", "/s", "/c", `tar -xf "${archivePath}" -C "${destinationDir}"`], { stdio: "pipe", timeout: 120000 });
+      return;
+    } catch (cmdError) {
+      throw new Error(`ZIP extraction failed via PowerShell and cmd/tar. PowerShell: ${String(powershellError)} | cmd/tar: ${String(cmdError)}`);
+    }
+  }
+  execFileSync("unzip", ["-q", archivePath, "-d", destinationDir], {
+    stdio: "pipe",
+    timeout: 120000
+  });
+}
 
 // src/bridge.ts
 import { spawn } from "child_process";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { join as join6 } from "path";
 function compareSemver(a, b) {
   const pa = a.split(".").map(Number);
@@ -22279,7 +22315,7 @@ class BinaryBridge {
       stdio: ["pipe", "pipe", "pipe"],
       env: {
         ...process.env,
-        FASTEMBED_CACHE_DIR: process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join6(this.configOverrides.storage_dir, "semantic", "models") : join6(homedir3() || "", ".cache", "fastembed")),
+        FASTEMBED_CACHE_DIR: process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join6(this.configOverrides.storage_dir, "semantic", "models") : join6(homedir4() || "", ".cache", "fastembed")),
         ...typeof this.configOverrides._ort_dylib_dir === "string" && {
           ORT_DYLIB_PATH: join6(this.configOverrides._ort_dylib_dir, process.platform === "win32" ? "onnxruntime.dll" : process.platform === "darwin" ? "libonnxruntime.dylib" : "libonnxruntime.so")
         }
@@ -22493,7 +22529,7 @@ class BridgePool {
 import { execSync, spawnSync } from "child_process";
 import { chmodSync as chmodSync3, copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync4 } from "fs";
 import { createRequire } from "module";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { join as join7 } from "path";
 function copyToVersionedCache(npmBinaryPath) {
   try {
@@ -22573,7 +22609,7 @@ function findBinarySync() {
     if (result)
       return result;
   } catch {}
-  const cargoPath = join7(homedir4(), ".cargo", "bin", `aft${ext}`);
+  const cargoPath = join7(homedir5(), ".cargo", "bin", `aft${ext}`);
   if (existsSync5(cargoPath))
     return cargoPath;
   return null;
@@ -22856,7 +22892,7 @@ import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as rea
 import { dirname as dirname2, join as join10 } from "path";
 
 // src/shared/opencode-config-dir.ts
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 import { join as join9, resolve } from "path";
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
@@ -22864,9 +22900,9 @@ function getCliConfigDir() {
     return resolve(envConfigDir);
   }
   if (process.platform === "win32") {
-    return join9(homedir5(), ".config", "opencode");
+    return join9(homedir6(), ".config", "opencode");
   }
-  return join9(process.env.XDG_CONFIG_HOME || join9(homedir5(), ".config"), "opencode");
+  return join9(process.env.XDG_CONFIG_HOME || join9(homedir6(), ".config"), "opencode");
 }
 function getOpenCodeConfigDir2(_options) {
   return getCliConfigDir();
@@ -25234,7 +25270,7 @@ var plugin = async (input) => {
     configOverrides.experimental_search_index = aftConfig.experimental_search_index;
   if (aftConfig.experimental_semantic_search !== undefined)
     configOverrides.experimental_semantic_search = aftConfig.experimental_semantic_search;
-  const dataHome = process.env.XDG_DATA_HOME || join13(homedir6(), ".local", "share");
+  const dataHome = process.env.XDG_DATA_HOME || join13(homedir7(), ".local", "share");
   configOverrides.storage_dir = join13(dataHome, "opencode", "storage", "plugin", "aft");
   if (aftConfig.experimental_semantic_search) {
     const storageDir2 = configOverrides.storage_dir;

package/dist/onnx-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onnx-runtime.d.ts","sourceRoot":"","sources":["../src/onnx-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA0DH,4DAA4D;AAC5D,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,IAAI,MAAM,CAQ7C;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA4BlF;AAgJD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAU3D"}
+{"version":3,"file":"onnx-runtime.d.ts","sourceRoot":"","sources":["../src/onnx-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA0DH,4DAA4D;AAC5D,wBAAgB,0BAA0B,IAAI,OAAO,CAEpD;AAED,6EAA6E;AAC7E,wBAAgB,oBAAoB,IAAI,MAAM,CAQ7C;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA4BlF;AA8LD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAU3D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/aft-opencode",
-  "version": "0.12.1",
+  "version": "0.12.2",
   "type": "module",
   "description": "OpenCode plugin for Agent File Tools (AFT) — tree-sitter and lsp powered code analysis",
   "main": "dist/index.js",
@@ -15,6 +15,8 @@
   },
   "files": [
     "dist",
+    "src/tui",
+    "src/shared",
     "README.md"
   ],
   "scripts": {
@@ -33,11 +35,11 @@
     "zod": "^4.1.8"
   },
   "optionalDependencies": {
-    "@cortexkit/aft-darwin-arm64": "0.12.1",
-    "@cortexkit/aft-darwin-x64": "0.12.1",
-    "@cortexkit/aft-linux-arm64": "0.12.1",
-    "@cortexkit/aft-linux-x64": "0.12.1",
-    "@cortexkit/aft-win32-x64": "0.12.1"
+    "@cortexkit/aft-darwin-arm64": "0.12.2",
+    "@cortexkit/aft-darwin-x64": "0.12.2",
+    "@cortexkit/aft-linux-arm64": "0.12.2",
+    "@cortexkit/aft-linux-x64": "0.12.2",
+    "@cortexkit/aft-win32-x64": "0.12.2"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -50,7 +52,7 @@
     },
     "./tui": {
       "types": "./src/tui/index.tsx",
-      "import": "./dist/tui.js"
+      "import": "./src/tui/index.tsx"
     }
   },
   "oc-plugin": [

package/src/shared/opencode-config-dir.ts

@@ -0,0 +1,46 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+export type OpenCodeBinaryType = "opencode" | "opencode-desktop";
+
+export interface OpenCodeConfigDirOptions {
+  binary: OpenCodeBinaryType;
+  version?: string | null;
+  checkExisting?: boolean;
+}
+
+export interface OpenCodeConfigPaths {
+  configDir: string;
+  configJson: string;
+  configJsonc: string;
+  packageJson: string;
+  omoConfig: string;
+}
+
+function getCliConfigDir(): string {
+  const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  if (envConfigDir) {
+    return resolve(envConfigDir);
+  }
+
+  if (process.platform === "win32") {
+    return join(homedir(), ".config", "opencode");
+  }
+
+  return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+}
+
+export function getOpenCodeConfigDir(_options: OpenCodeConfigDirOptions): string {
+  return getCliConfigDir();
+}
+
+export function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths {
+  const configDir = getOpenCodeConfigDir(options);
+  return {
+    configDir,
+    configJson: join(configDir, "opencode.json"),
+    configJsonc: join(configDir, "opencode.jsonc"),
+    packageJson: join(configDir, "package.json"),
+    omoConfig: join(configDir, "magic-context.jsonc"),
+  };
+}

package/src/shared/rpc-client.ts

@@ -0,0 +1,123 @@
+import { readFileSync } from "node:fs";
+import { rpcPortFilePath } from "./rpc-utils";
+
+const MAX_RETRIES = 10;
+const RETRY_DELAY_MS = 500;
+const REQUEST_TIMEOUT_MS = 5000;
+
+export class AftRpcClient {
+  private port: number | null = null;
+  private portFilePath: string;
+  private healthChecked = false;
+
+  constructor(storageDir: string, directory: string) {
+    this.portFilePath = rpcPortFilePath(storageDir, directory);
+  }
+
+  /** Call an RPC method. Retries port resolution if the server isn't ready yet. */
+  async call<T = Record<string, unknown>>(
+    method: string,
+    params: Record<string, unknown> = {},
+  ): Promise<T> {
+    const port = await this.resolvePort();
+    if (!port) {
+      throw new Error("AFT RPC server not available");
+    }
+
+    const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/rpc/${method}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(params),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`RPC ${method} failed (${response.status}): ${text}`);
+    }
+
+    return (await response.json()) as T;
+  }
+
+  /** Check if the RPC server is reachable. */
+  async isAvailable(): Promise<boolean> {
+    try {
+      const port = await this.resolvePort();
+      return port !== null;
+    } catch {
+      return false;
+    }
+  }
+
+  private async resolvePort(): Promise<number | null> {
+    if (this.port && this.healthChecked) {
+      return this.port;
+    }
+
+    if (this.port) {
+      const alive = await this.healthCheck(this.port);
+      if (alive) {
+        this.healthChecked = true;
+        return this.port;
+      }
+      this.port = null;
+      this.healthChecked = false;
+    }
+
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      const port = this.readPortFile();
+      if (port) {
+        const alive = await this.healthCheck(port);
+        if (alive) {
+          this.port = port;
+          this.healthChecked = true;
+          return port;
+        }
+      }
+
+      if (attempt < MAX_RETRIES - 1) {
+        await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+      }
+    }
+
+    return null;
+  }
+
+  private readPortFile(): number | null {
+    try {
+      const content = readFileSync(this.portFilePath, "utf-8").trim();
+      const port = Number.parseInt(content, 10);
+      if (Number.isNaN(port) || port <= 0 || port > 65535) {
+        return null;
+      }
+      return port;
+    } catch {
+      return null;
+    }
+  }
+
+  private async healthCheck(port: number): Promise<boolean> {
+    try {
+      const response = await this.fetchWithTimeout(`http://127.0.0.1:${port}/health`, {
+        method: "GET",
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  private async fetchWithTimeout(url: string, options: RequestInit): Promise<Response> {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+      return await fetch(url, { ...options, signal: controller.signal });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  reset(): void {
+    this.port = null;
+    this.healthChecked = false;
+  }
+}

package/src/shared/rpc-server.ts

@@ -0,0 +1,135 @@
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { dirname } from "node:path";
+import { log, warn } from "../logger";
+import { rpcPortFilePath } from "./rpc-utils";
+
+type RpcHandler = (params: Record<string, unknown>) => Promise<Record<string, unknown>>;
+
+export class AftRpcServer {
+  private server: Server | null = null;
+  private port = 0;
+  private handlers = new Map<string, RpcHandler>();
+  private portFilePath: string;
+
+  constructor(storageDir: string, directory: string) {
+    this.portFilePath = rpcPortFilePath(storageDir, directory);
+  }
+
+  /** Register an RPC method handler. */
+  handle(method: string, handler: RpcHandler): void {
+    this.handlers.set(method, handler);
+  }
+
+  /** Start the server on a random port, write port to disk. */
+  async start(): Promise<number> {
+    return new Promise((resolve, reject) => {
+      const server = createServer((req, res) => this.dispatch(req, res));
+
+      server.on("error", (err) => {
+        warn(`RPC server error: ${err.message}`);
+        reject(err);
+      });
+
+      server.listen(0, "127.0.0.1", () => {
+        const addr = server.address();
+        if (!addr || typeof addr === "string") {
+          reject(new Error("Failed to get server address"));
+          return;
+        }
+        this.port = addr.port;
+        this.server = server;
+
+        // Write port file atomically
+        try {
+          const dir = dirname(this.portFilePath);
+          mkdirSync(dir, { recursive: true });
+          const tmpPath = `${this.portFilePath}.tmp`;
+          writeFileSync(tmpPath, String(this.port), "utf-8");
+          renameSync(tmpPath, this.portFilePath);
+          log(`RPC server listening on 127.0.0.1:${this.port}`);
+        } catch (err) {
+          warn(`Failed to write RPC port file: ${err}`);
+        }
+
+        resolve(this.port);
+      });
+
+      // Don't keep the process alive just for the RPC server
+      server.unref();
+    });
+  }
+
+  /** Stop the server and clean up port file. */
+  stop(): void {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+    try {
+      unlinkSync(this.portFilePath);
+    } catch {
+      // ignore
+    }
+  }
+
+  private dispatch(req: IncomingMessage, res: ServerResponse): void {
+    const url = req.url ?? "";
+
+    if (req.method === "GET" && url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true, pid: process.pid }));
+      return;
+    }
+
+    if (req.method !== "POST" || !url.startsWith("/rpc/")) {
+      res.writeHead(404);
+      res.end("Not Found");
+      return;
+    }
+
+    const method = url.slice(5);
+    const handler = this.handlers.get(method);
+    if (!handler) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: `Unknown method: ${method}` }));
+      return;
+    }
+
+    let body = "";
+    req.on("data", (chunk: Buffer) => {
+      body += chunk.toString();
+      if (body.length > 1_048_576) {
+        res.writeHead(413);
+        res.end("Request too large");
+        req.destroy();
+      }
+    });
+
+    req.on("end", () => {
+      let params: Record<string, unknown> = {};
+      try {
+        if (body.length > 0) {
+          params = JSON.parse(body);
+        }
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid JSON" }));
+        return;
+      }
+
+      log(`RPC call: ${method} params=${JSON.stringify(params).slice(0, 200)}`);
+      handler(params)
+        .then((result) => {
+          log(`RPC result: ${method} => ${JSON.stringify(result).slice(0, 200)}`);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(result));
+        })
+        .catch((err) => {
+          log(`RPC error: ${method} => ${err}`);
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: String(err) }));
+        });
+    });
+  }
+}

package/src/shared/rpc-utils.ts

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+
+/**
+ * Compute a stable hash for a project directory.
+ * Used to scope RPC port files per-project so multiple
+ * OpenCode Desktop instances don't overwrite each other.
+ */
+export function projectHash(directory: string): string {
+  // Normalize: strip trailing slashes
+  const normalized = directory.replace(/\/+$/, "");
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+
+/**
+ * Get the per-project RPC port file path.
+ */
+export function rpcPortFilePath(storageDir: string, directory: string): string {
+  const hash = projectHash(directory);
+  return join(storageDir, "rpc", hash, "port");
+}

package/src/shared/runtime.ts

@@ -0,0 +1,26 @@
+type BridgeLike = {
+  getBridge: (
+    directory: string,
+    sessionID: string,
+  ) => {
+    send: (command: string, params?: Record<string, unknown>) => Promise<Record<string, unknown>>;
+  };
+};
+
+const GLOBAL_KEY = "__AFT_SHARED_BRIDGE_POOL__";
+
+function getGlobalState(): { [GLOBAL_KEY]?: BridgeLike | null } {
+  return globalThis as { [GLOBAL_KEY]?: BridgeLike | null };
+}
+
+export function setSharedBridgePool(pool: BridgeLike): void {
+  getGlobalState()[GLOBAL_KEY] = pool;
+}
+
+export function getSharedBridgePool(): BridgeLike | null {
+  return getGlobalState()[GLOBAL_KEY] ?? null;
+}
+
+export function clearSharedBridgePool(): void {
+  getGlobalState()[GLOBAL_KEY] = null;
+}