clawdex-mobile 5.0.8 → 5.1.2

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 All notable changes to this project are documented in this file.
 
+## 5.1.2 - 2026-04-07
+
+### Added
+- Local preview browser workflow with desktop and overview shells for mobile web inspection.
+- App-wide font preference support in the mobile client.
+
+### Improved
+- Chat transcript tool-call UX now supports grouped tool-call inspection, per-call output expansion, and file-change labels that include changed filenames.
+- Drawer, sheet, and chat header interactions feel smoother and more consistent across open/close, reconnect, and navigation flows.
+- Composer and transcript responsiveness were tightened with lower rerender churn, more stable activity indicators, and cleaner compaction presentation.
+- Browser preview controls, address handling, and preview session stability were refined for everyday use.
+- Manual npm release runs can now build every packaged bridge target without publishing to npm.
+
+### Fixed
+- Bridge restart cleanup and maintenance behavior are more reliable during repeated local development cycles.
+- Queued thread messages now use guaranteed-unique bridge queue item IDs during blocked-turn queuing.
+- Bridge self-update now reports shutdown failures cleanly while still preserving status updates and `.env.secure` backup cleanup.
+- Browser preview and mobile UI regressions caught during review and CI were resolved before release.
+
 ## 1.1.0 - 2026-02-23
 
 ### Added

package/docs/setup-and-operations.md

@@ -80,16 +80,20 @@ When both CLIs are selected, the bridge starts both backends and merges chat lis
 
 Open the installed mobile app on your phone, then scan the bridge QR. If needed, enter the bridge URL manually (for example `http://100.x.y.z:8787` or `http://192.168.x.y:8787`). The chosen bridge URL is stored on-device and can be changed later in Settings.
 
-### In-app Bridge Update
+### In-app Bridge Maintenance
 
-For published `clawdex-mobile` CLI installs, the mobile Settings screen can start a bridge update safely.
+For secure-launcher installs, the mobile Settings screen can trigger bridge maintenance safely.
 
 - Open `Settings > Bridge Maintenance`
-- Tap `Update bridge`
-- The app will disconnect briefly while a detached helper job stops the current bridge, runs `npm install -g clawdex-mobile@latest`, and starts the bridge again
+- Tap `Restart bridge safely` to stop the current bridge and relaunch it through `scripts/start-bridge-secure.js`
+- The app will disconnect briefly while the detached helper waits for bridge health to recover
+
+Published `clawdex-mobile` CLI installs also expose `Update bridge`.
+
+- `Update bridge` stops the current bridge, runs `npm install -g clawdex-mobile@latest`, and starts the bridge again
 - If the upgrade step fails, the helper attempts to restart the previous bridge automatically
 
-Source checkouts do not expose this button because they need repo-specific update logic that is not safe to automate generically from mobile.
+Source checkouts expose only the restart action because repo-specific update logic is not safe to automate generically from mobile.
 
 ## Local Mobile Development Only
 
@@ -110,6 +114,39 @@ Optional environment variables:
 - `EXPO_AUTO_REPAIR=true` — auto-repair React Native runtime on `npm run mobile`
 - `EXPO_CLEAR_CACHE=true` — force `expo start --clear` via `npm run mobile`
 
+## Local Browser Preview
+
+The mobile app includes a `Browser` screen that can open loopback-only web apps from the bridge
+machine inside the app itself.
+
+Typical examples:
+
+- `localhost:3000`
+- `127.0.0.1:5173`
+- `3000`
+
+How it works:
+
+- The app creates a short-lived preview session through the bridge RPC API
+- The bridge serves a dedicated preview origin on a separate port
+- HTTP requests, subresources, cookies, and WebSocket/HMR traffic are proxied from the phone to
+  the bridge host's loopback target
+- Browser runtime calls to other loopback origins on the host are also rewritten through the
+  preview origin for `fetch`, XHR, `EventSource`, `WebSocket`, and form submissions
+
+Current scope:
+
+- Supports `http://` and `https://` loopback targets only
+- Intended for local web dev servers such as Next.js, Vite, CRA, or simple static servers
+- Separate local frontend/backend ports can work together inside the preview as long as the app
+  reaches the backend through normal browser APIs or form posts
+- Hard-coded absolute localhost asset URLs outside those browser APIs may still need a same-origin
+  dev proxy in the app itself
+- Does not preview native React Native simulator/device UI directly
+
+For a concise list of supported cases and known limitations, see
+`docs/browser-preview-limitations.md`.
+
 ## Teardown / Cleanup
 
 ```bash
@@ -138,6 +175,7 @@ npm run teardown -- --yes
 |---|---|
 | `BRIDGE_HOST` | bind host for rust bridge |
 | `BRIDGE_PORT` | bridge port (default `8787`) |
+| `BRIDGE_PREVIEW_PORT` | browser preview port for proxied localhost web apps (default `BRIDGE_PORT + 1`) |
 | `BRIDGE_AUTH_TOKEN` | required auth token |
 | `BRIDGE_ALLOW_QUERY_TOKEN_AUTH` | query-token auth fallback |
 | `CODEX_CLI_BIN` | codex executable |
@@ -207,6 +245,7 @@ Expected response contains `"status":"ok"`.
 6. Open Git from header and verify status/diff/commit/push behavior
 7. Test attachment menu (`+`) with workspace path + phone file/image
 8. Run long task and verify stop button interrupts run and transcript logs stop
+9. Open `Browser`, enter `localhost:3000` or another active loopback dev port, and verify the page loads inside the app
 
 ## Chat Controls (Workspace, Model, Mode, Approvals)
 

package/docs/troubleshooting.md

@@ -36,8 +36,20 @@ npm run stop:services
 - For the shipped mobile app, rescan the bridge QR or update the stored token in Settings.
 - For a local dev build, also ensure `BRIDGE_AUTH_TOKEN` in `.env.secure` matches `EXPO_PUBLIC_HOST_BRIDGE_TOKEN` in `apps/mobile/.env`.
 - Restart the bridge after token changes.
+- On secure-launcher installs, `Settings > Bridge Maintenance > Restart bridge safely` can do that from the phone.
 - If an in-app bridge update fails, inspect `.bridge-updater.log` and `.bridge-update-status.json` in the bridge install root.
 
+## Local browser preview does not open
+
+- The in-app browser only supports loopback targets from the bridge host: `localhost`, `127.0.0.1`, or `::1`.
+- Use entries like `localhost:3000`, `127.0.0.1:5173`, or just a port number.
+- If a separate local API runs on another port, make sure the app reaches it through `fetch`, XHR, `EventSource`, `WebSocket`, or a normal form post so the preview runtime can rewrite it through the bridge.
+- See `docs/browser-preview-limitations.md` for the current support boundaries and known caveats.
+- If Browser reports preview is unavailable, check whether `BRIDGE_PREVIEW_PORT` is already in use on the host.
+- By default the preview server binds to `BRIDGE_PORT + 1`.
+- Restart the bridge after changing `BRIDGE_PREVIEW_PORT`.
+- If the page shell loads but live reload does not, verify the target dev server is still serving its WebSocket/HMR endpoint locally.
+
 ## Tailscale issues
 
 - Verify host and phone are on the same Tailscale network

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawdex-mobile",
-  "version": "5.0.8",
+  "version": "5.1.2",
   "description": "Private-network mobile bridge and CLI for Codex and OpenCode",
   "keywords": [
     "codex",

package/scripts/bridge-self-update.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 
-const { spawn } = require("node:child_process");
+const { spawn, spawnSync } = require("node:child_process");
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
@@ -10,6 +10,7 @@ const https = require("node:https");
 
 function parseArgs(argv) {
   const parsed = {
+    action: "update",
     jobId: "",
     bridgePid: 0,
     version: "latest",
@@ -26,6 +27,9 @@ function parseArgs(argv) {
     }
 
     switch (flag) {
+      case "--action":
+        parsed.action = value;
+        break;
       case "--job-id":
         parsed.jobId = value;
         break;
@@ -53,6 +57,10 @@ function parseArgs(argv) {
     throw new Error("missing updater arguments");
   }
 
+  if (parsed.action !== "update" && parsed.action !== "restart") {
+    throw new Error(`unsupported bridge maintenance action: ${parsed.action}`);
+  }
+
   return parsed;
 }
 
@@ -94,6 +102,18 @@ function writeStatus(statusPath, payload) {
   fs.writeFileSync(statusPath, `${JSON.stringify(nextPayload, null, 2)}\n`);
 }
 
+function readNonEmptyEnv(env, key) {
+  const value = env?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+
+function formatHostForUrl(host) {
+  if (host.includes(":") && !host.startsWith("[")) {
+    return `[${host}]`;
+  }
+  return host;
+}
+
 function backupSecureEnv(packageRoot, jobId) {
   const secureEnvPath = path.join(packageRoot, ".env.secure");
   if (!fs.existsSync(secureEnvPath)) {
@@ -166,23 +186,135 @@ function killBridgeProcess(pid) {
   }
 }
 
-async function waitForBridgeExit(pid) {
-  for (let attempt = 0; attempt < 40; attempt += 1) {
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function forceKillBridgeProcess(pid) {
+  if (process.platform === "win32") {
+    const result = spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], {
+      stdio: "ignore",
+    });
+    if (result.error && result.error.code !== "ENOENT") {
+      throw result.error;
+    }
+    return;
+  }
+
+  process.kill(pid, "SIGKILL");
+}
+
+function listMatchingPids(pattern) {
+  const result = spawnSync("ps", ["-ax", "-o", "pid=", "-o", "command="], {
+    encoding: "utf8",
+  });
+  if (result.error || result.status !== 0) {
+    return [];
+  }
+
+  return result.stdout
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const match = line.match(/^(\d+)\s+(.*)$/);
+      if (!match) {
+        return null;
+      }
+      return {
+        pid: Number.parseInt(match[1], 10),
+        command: match[2],
+      };
+    })
+    .filter((entry) => entry && Number.isFinite(entry.pid) && pattern.test(entry.command))
+    .map((entry) => entry.pid);
+}
+
+function isOpencodeEnabled(env) {
+  const activeEngine = readNonEmptyEnv(env, "BRIDGE_ACTIVE_ENGINE");
+  const enabledEngines = readNonEmptyEnv(env, "BRIDGE_ENABLED_ENGINES");
+  return [activeEngine, enabledEngines].some((value) =>
+    value
+      .split(",")
+      .map((entry) => entry.trim())
+      .filter(Boolean)
+      .includes("opencode")
+  );
+}
+
+function buildOpencodeServePattern(port) {
+  const normalizedPort = String(port).trim().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\bopencode(?:\\.cmd|\\.exe)?\\b.*\\bserve\\b.*--port\\s+${normalizedPort}\\b`);
+}
+
+async function stopLingeringOpencodeServer(packageRoot) {
+  const secureEnvPath = path.join(packageRoot, ".env.secure");
+  if (!fs.existsSync(secureEnvPath)) {
+    return;
+  }
+
+  const secureEnv = readEnvFile(secureEnvPath);
+  if (!isOpencodeEnabled(secureEnv)) {
+    return;
+  }
+
+  const opencodePort = readNonEmptyEnv(secureEnv, "BRIDGE_OPENCODE_PORT") || "4090";
+  const pids = listMatchingPids(buildOpencodeServePattern(opencodePort));
+  if (pids.length === 0) {
+    return;
+  }
+
+  for (const pid of pids) {
     try {
-      process.kill(pid, 0);
-    } catch {
+      process.kill(pid, "SIGTERM");
+    } catch {}
+  }
+
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    const stillRunning = pids.filter((pid) => isProcessAlive(pid));
+    if (stillRunning.length === 0) {
       return;
     }
     await sleep(250);
   }
 
-  if (process.platform !== "win32") {
+  for (const pid of pids) {
+    if (!isProcessAlive(pid)) {
+      continue;
+    }
     try {
-      process.kill(pid, "SIGKILL");
-    } catch {
+      forceKillBridgeProcess(pid);
+    } catch {}
+  }
+}
+
+async function waitForBridgeExit(pid) {
+  for (let attempt = 0; attempt < 40; attempt += 1) {
+    if (!isProcessAlive(pid)) {
+      return;
+    }
+    await sleep(250);
+  }
+
+  try {
+    forceKillBridgeProcess(pid);
+  } catch {
+    return;
+  }
+
+  for (let attempt = 0; attempt < 20; attempt += 1) {
+    if (!isProcessAlive(pid)) {
       return;
     }
+    await sleep(250);
   }
+
+  throw new Error("bridge process did not exit in time");
 }
 
 function startBridge(packageRoot, logPath) {
@@ -209,7 +341,7 @@ async function waitForHealth(envFilePath, timeoutMs) {
   const secureEnv = readEnvFile(envFilePath);
   const host = secureEnv.BRIDGE_HOST || "127.0.0.1";
   const port = secureEnv.BRIDGE_PORT || "8787";
-  const url = new URL(`http://${host}:${port}/health`);
+  const url = new URL(`http://${formatHostForUrl(host)}:${port}/health`);
   const client = url.protocol === "https:" ? https : http;
   const startedAt = Date.now();
 
@@ -242,6 +374,7 @@ async function waitForHealth(envFilePath, timeoutMs) {
 }
 
 async function restartBridge(packageRoot, statusPath, payload, message) {
+  await stopLingeringOpencodeServer(packageRoot);
   writeStatus(statusPath, {
     ...payload,
     state: "starting",
@@ -256,13 +389,23 @@ async function restartBridge(packageRoot, statusPath, payload, message) {
   await waitForHealth(path.join(packageRoot, ".env.secure"), 45_000);
 }
 
+async function stopCurrentBridge(statusPath, payload, bridgePid) {
+  writeStatus(statusPath, {
+    ...payload,
+    state: "stopping",
+    message: "Stopping the current bridge process.",
+  });
+  killBridgeProcess(bridgePid);
+  await waitForBridgeExit(bridgePid);
+}
+
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const packageRoot = path.resolve(__dirname, "..");
   const secureEnvBackup = backupSecureEnv(packageRoot, args.jobId);
   const baseStatus = {
     jobId: args.jobId,
-    targetVersion: args.version,
+    targetVersion: args.action === "restart" ? args.version || "current" : args.version,
     startedAt: args.startedAt,
     logPath: args.logPath || null,
   };
@@ -270,75 +413,113 @@ async function main() {
   writeStatus(args.statusPath, {
     ...baseStatus,
     state: "scheduled",
-    message: `Bridge update scheduled for ${args.version}.`,
+    message:
+      args.action === "restart"
+        ? "Bridge restart scheduled."
+        : `Bridge update scheduled for ${args.version}.`,
   });
-  await sleep(800);
-
-  writeStatus(args.statusPath, {
-    ...baseStatus,
-    state: "stopping",
-    message: "Stopping the current bridge process.",
-  });
-  killBridgeProcess(args.bridgePid);
-  await waitForBridgeExit(args.bridgePid);
-
-  let upgraded = false;
   try {
-    writeStatus(args.statusPath, {
-      ...baseStatus,
-      state: "upgrading",
-      message: `Installing clawdex-mobile@${args.version}.`,
-    });
-    await runCommand(npmCommand(), ["install", "-g", `clawdex-mobile@${args.version}`], {
-      cwd: packageRoot,
-      env: process.env,
-    });
-    restoreSecureEnv(secureEnvBackup);
-    upgraded = true;
-    await restartBridge(
-      packageRoot,
-      args.statusPath,
-      baseStatus,
-      "Starting the updated bridge process."
-    );
-    writeStatus(args.statusPath, {
-      ...baseStatus,
-      state: "completed",
-      message: `Bridge updated to ${args.version} and restarted successfully.`,
-      completedAt: new Date().toISOString(),
-    });
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
+    await sleep(800);
+    await stopCurrentBridge(args.statusPath, baseStatus, args.bridgePid);
+
+    if (args.action === "restart") {
+      try {
+        await restartBridge(
+          packageRoot,
+          args.statusPath,
+          baseStatus,
+          "Starting the bridge process."
+        );
+        writeStatus(args.statusPath, {
+          ...baseStatus,
+          state: "completed",
+          message: "Bridge restarted successfully.",
+          completedAt: new Date().toISOString(),
+        });
+      } catch (error) {
+        writeStatus(args.statusPath, {
+          ...baseStatus,
+          state: "failed",
+          message:
+            error instanceof Error
+              ? error.message
+              : "Bridge restart failed and the bridge did not recover automatically.",
+          completedAt: new Date().toISOString(),
+        });
+        process.exitCode = 1;
+      }
+      return;
+    }
+
+    let upgraded = false;
     try {
+      writeStatus(args.statusPath, {
+        ...baseStatus,
+        state: "upgrading",
+        message: `Installing clawdex-mobile@${args.version}.`,
+      });
+      await runCommand(npmCommand(), ["install", "-g", `clawdex-mobile@${args.version}`], {
+        cwd: packageRoot,
+        env: process.env,
+      });
       restoreSecureEnv(secureEnvBackup);
+      upgraded = true;
       await restartBridge(
         packageRoot,
         args.statusPath,
         baseStatus,
-        upgraded
-          ? "Updated bridge failed to come up; restarting the previous bridge."
-          : "Upgrade failed; restarting the previous bridge."
+        "Starting the updated bridge process."
       );
       writeStatus(args.statusPath, {
         ...baseStatus,
-        state: "recovered",
-        message: upgraded
-          ? "Bridge update failed after install. The previous bridge was restarted."
-          : "Bridge upgrade failed. The previous bridge was restarted.",
-        completedAt: new Date().toISOString(),
-      });
-    } catch (restartError) {
-      writeStatus(args.statusPath, {
-        ...baseStatus,
-        state: "failed",
-        message:
-          restartError instanceof Error
-            ? restartError.message
-            : "Bridge update failed and automatic recovery did not complete.",
+        state: "completed",
+        message: `Bridge updated to ${args.version} and restarted successfully.`,
         completedAt: new Date().toISOString(),
       });
-      process.exitCode = 1;
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      try {
+        restoreSecureEnv(secureEnvBackup);
+        await restartBridge(
+          packageRoot,
+          args.statusPath,
+          baseStatus,
+          upgraded
+            ? "Updated bridge failed to come up; restarting the previous bridge."
+            : "Upgrade failed; restarting the previous bridge."
+        );
+        writeStatus(args.statusPath, {
+          ...baseStatus,
+          state: "recovered",
+          message: upgraded
+            ? "Bridge update failed after install. The previous bridge was restarted."
+            : "Bridge upgrade failed. The previous bridge was restarted.",
+          completedAt: new Date().toISOString(),
+        });
+      } catch (restartError) {
+        writeStatus(args.statusPath, {
+          ...baseStatus,
+          state: "failed",
+          message:
+            restartError instanceof Error
+              ? restartError.message
+              : "Bridge update failed and automatic recovery did not complete.",
+          completedAt: new Date().toISOString(),
+        });
+        process.exitCode = 1;
+      }
     }
+  } catch (error) {
+    writeStatus(args.statusPath, {
+      ...baseStatus,
+      state: "failed",
+      message:
+        error instanceof Error
+          ? error.message
+          : "Bridge maintenance failed before restart or recovery could begin.",
+      completedAt: new Date().toISOString(),
+    });
+    process.exitCode = 1;
   } finally {
     cleanupSecureEnvBackup(secureEnvBackup);
   }

package/scripts/start-bridge-secure.js

@@ -579,6 +579,9 @@ async function start() {
   const fileEnv = readEnvFile(secureEnvFile);
   const env = { ...fileEnv, ...process.env };
   const devMode = process.argv.includes("--dev") || env.BRIDGE_RUN_MODE === "dev";
+  if (devMode) {
+    env.BRIDGE_RUN_MODE = "dev";
+  }
   const backgroundMode = process.argv.includes("--background");
   const forceSourceBuild = env.CLAWDEX_BRIDGE_FORCE_SOURCE_BUILD === "true";
   const launch = resolveLaunch(rootDir, env, { devMode, forceSourceBuild });

package/services/rust-bridge/Cargo.lock

@@ -149,7 +149,7 @@ dependencies = [
 
 [[package]]
 name = "codex-rust-bridge"
-version = "5.0.8"
+version = "5.1.2"
 dependencies = [
  "axum",
  "base64",
@@ -162,6 +162,7 @@ dependencies = [
  "serde_json",
  "shlex",
  "tokio",
+ "tokio-tungstenite",
 ]
 
 [[package]]
@@ -278,6 +279,12 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
 
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
 [[package]]
 name = "futures-macro"
 version = "0.3.32"
@@ -308,9 +315,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
 dependencies = [
  "futures-core",
+ "futures-io",
  "futures-macro",
  "futures-sink",
  "futures-task",
+ "memchr",
  "pin-project-lite",
  "slab",
 ]
@@ -433,7 +442,7 @@ dependencies = [
  "tokio",
  "tokio-rustls",
  "tower-service",
- "webpki-roots",
+ "webpki-roots 1.0.6",
 ]
 
 [[package]]
@@ -932,14 +941,16 @@ dependencies = [
  "sync_wrapper",
  "tokio",
  "tokio-rustls",
+ "tokio-util",
  "tower",
  "tower-http",
  "tower-service",
  "url",
  "wasm-bindgen",
  "wasm-bindgen-futures",
+ "wasm-streams",
  "web-sys",
- "webpki-roots",
+ "webpki-roots 1.0.6",
 ]
 
 [[package]]
@@ -1277,8 +1288,25 @@ checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
 dependencies = [
  "futures-util",
  "log",
+ "rustls",
+ "rustls-pki-types",
  "tokio",
+ "tokio-rustls",
  "tungstenite",
+ "webpki-roots 0.26.11",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
 ]
 
 [[package]]
@@ -1365,6 +1393,8 @@ dependencies = [
  "httparse",
  "log",
  "rand",
+ "rustls",
+ "rustls-pki-types",
  "sha1",
  "thiserror",
  "utf-8",
@@ -1507,6 +1537,19 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "wasm-streams"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.91"
@@ -1527,6 +1570,15 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.6",
+]
+
 [[package]]
 name = "webpki-roots"
 version = "1.0.6"