herdr-remote 0.2.16 → 0.2.18

package/dist/tui.mjs

@@ -415,6 +415,9 @@ var require_updater = __commonJS({
       }
       return "npm";
     }
+    function updateChecksEnabled2(env = process.env) {
+      return env.HERDR_REMOTE_UPDATE_CHECK !== "0";
+    }
     function canSelfUpdate2() {
       return installKind2() === "npm";
     }
@@ -466,92 +469,173 @@ var require_updater = __commonJS({
       }
       return 0;
     }
-    async function askRegistry(registry, { timeoutMs, fetchImpl }) {
+    async function fetchJson(url, { timeoutMs, fetchImpl }) {
       const controller = new AbortController();
       const timer = setTimeout(() => controller.abort(), timeoutMs);
       try {
-        const response = await fetchImpl(`${registry}/${PACKAGE_NAME}/latest`, {
+        const response = await fetchImpl(url, {
           signal: controller.signal,
-          headers: { Accept: "application/vnd.npm.install-v1+json" }
+          headers: { Accept: "application/json", "Cache-Control": "no-cache" }
         });
         if (!response.ok) return { ok: false, message: `HTTP ${response.status ?? "?"}` };
-        const body = await response.json();
-        const latest = typeof body?.version === "string" ? body.version : null;
-        if (!latest) return { ok: false, message: "registry answered without a version" };
-        return { ok: true, latest };
+        return { ok: true, body: await response.json() };
       } catch (error) {
         return { ok: false, message: error?.name === "AbortError" ? "timed out" : String(error?.message || error) };
       } finally {
         clearTimeout(timer);
       }
     }
+    async function askRegistry(registry, { timeoutMs, fetchImpl }) {
+      const endpoints = [
+        { url: `${registry}/-/package/${PACKAGE_NAME}/dist-tags`, read: (body) => body?.latest },
+        { url: `${registry}/${PACKAGE_NAME}/latest`, read: (body) => body?.version }
+      ];
+      let message = null;
+      for (const endpoint of endpoints) {
+        const attempt = await fetchJson(endpoint.url, { timeoutMs, fetchImpl });
+        if (!attempt.ok) {
+          message = attempt.message;
+          continue;
+        }
+        const latest = endpoint.read(attempt.body);
+        if (typeof latest === "string" && latest) return { ok: true, latest };
+        message = "registry answered without a version";
+      }
+      return { ok: false, message };
+    }
     async function checkForUpdate2({
       timeoutMs = 6e3,
       fetchImpl = globalThis.fetch,
       registries = registryCandidates()
     } = {}) {
       const current = currentVersion();
-      const failures = [];
-      for (const registry of registries) {
-        const attempt = await askRegistry(registry, { timeoutMs, fetchImpl });
-        if (attempt.ok) {
-          return {
-            ok: true,
-            current,
-            latest: attempt.latest,
-            registry,
-            updateAvailable: compareVersions(attempt.latest, current) > 0
-          };
-        }
-        failures.push(`${registry}: ${attempt.message}`);
+      const attempts = await Promise.all(registries.map(async (registry) => ({
+        registry,
+        ...await askRegistry(registry, { timeoutMs, fetchImpl })
+      })));
+      const answers = attempts.filter((attempt) => attempt.ok);
+      if (answers.length === 0) {
+        return {
+          ok: false,
+          current,
+          errorKey: "update.errorNetwork",
+          message: attempts.map((attempt) => `${attempt.registry}: ${attempt.message}`).join("; "),
+          triedRegistries: registries
+        };
       }
+      const latest = answers.map((answer) => answer.latest).reduce((best, version) => compareVersions(version, best) > 0 ? version : best);
+      const sources = answers.filter((answer) => compareVersions(answer.latest, latest) === 0).map((answer) => answer.registry);
+      const behind = answers.filter((answer) => compareVersions(answer.latest, latest) < 0).map((answer) => ({ registry: answer.registry, version: answer.latest }));
       return {
-        ok: false,
+        ok: true,
         current,
-        errorKey: "update.errorNetwork",
-        message: failures.join("; "),
-        triedRegistries: registries
+        latest,
+        registry: sources[0],
+        sources,
+        behind,
+        updateAvailable: compareVersions(latest, current) > 0
       };
     }
-    function performUpdate2({
-      spawnImpl = spawn,
-      timeoutMs = 18e4,
-      // Seam for tests: the suite runs from a checkout, where the guard below is
-      // correctly the only reachable outcome.
-      installKindImpl = installKind2,
-      // The registry that just answered the version check. Installing from
-      // somewhere the machine has been shown to reach beats installing from a
-      // default it may have no route to. Empty means "whatever npm is configured
-      // with", which is the right answer when no check has run.
-      registry = ""
-    } = {}) {
+    function npmErrorSummary(output) {
+      const lines = String(output || "").split(/\r?\n/).map((line) => line.trim()).filter((line) => /^npm (error|ERR!)/.test(line) && !/complete log of this run/i.test(line)).map((line) => line.replace(/^npm (error|ERR!)\s*/, "")).filter(Boolean);
+      return (lines.length > 0 ? lines.slice(0, 3) : String(output || "").trim().split(/\r?\n/).slice(-3)).join(" ");
+    }
+    function isNotYetPublished(output) {
+      return /\bETARGET\b|notarget|No matching version found/i.test(String(output || ""));
+    }
+    function installedVersionOnDisk() {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8")).version;
+      } catch {
+        return null;
+      }
+    }
+    function runNpm(spawnImpl, args, timeoutMs) {
       return new Promise((resolve) => {
-        const kind = installKindImpl();
-        if (kind !== "npm") {
-          resolve({ ok: false, errorKey: `update.cannot.${kind}` });
+        let child;
+        try {
+          child = spawnImpl("npm", args, { timeout: timeoutMs });
+        } catch (error) {
+          resolve({ ok: false, spawnFailed: true, output: String(error?.message || error) });
           return;
         }
-        const args = ["install", "-g", `${PACKAGE_NAME}@latest`];
-        const normalizedRegistry = normalizeRegistry(registry);
-        if (normalizedRegistry) args.push("--registry", normalizedRegistry);
-        const child = spawnImpl("npm", args, {
-          encoding: "utf8",
-          timeout: timeoutMs
-        });
         let output = "";
+        let settled = false;
+        const finish = (result) => {
+          if (!settled) {
+            settled = true;
+            resolve(result);
+          }
+        };
         const collect = (chunk) => {
           output += String(chunk);
         };
         child.stdout?.on("data", collect);
         child.stderr?.on("data", collect);
-        child.on("error", (error) => {
-          resolve({ ok: false, errorKey: "update.errorFailed", output: error.message });
-        });
-        child.on("close", (code) => {
-          resolve({ ok: code === 0, output: output.trim().slice(-2e3) });
-        });
+        child.on("error", (error) => finish({ ok: false, spawnFailed: true, output: error.message }));
+        child.on("close", (code) => finish({ ok: code === 0, output: output.trim() }));
       });
     }
+    var VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+    async function performUpdate2({
+      spawnImpl = spawn,
+      timeoutMs = 18e4,
+      // Seam for tests: the suite runs from a checkout, where the guard below is
+      // correctly the only reachable outcome.
+      installKindImpl = installKind2,
+      // The registries that reported `version`, preferred first. Empty means
+      // "whatever npm is configured with", which is right when no check has run.
+      registry = "",
+      sources = [],
+      version = null,
+      attempts = 3,
+      retryDelayMs = 15e3,
+      sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+      readInstalledVersion = installedVersionOnDisk,
+      onAttempt = () => {
+      }
+    } = {}) {
+      const kind = installKindImpl();
+      if (kind !== "npm") return { ok: false, errorKey: `update.cannot.${kind}` };
+      const target = typeof version === "string" && VERSION_PATTERN.test(version) ? version : null;
+      const spec = `${PACKAGE_NAME}@${target || "latest"}`;
+      const registries = [];
+      for (const candidate of [registry, ...sources]) {
+        const normalized = normalizeRegistry(candidate);
+        if (normalized && !registries.includes(normalized)) registries.push(normalized);
+      }
+      if (registries.length === 0) registries.push("");
+      let last = { output: "" };
+      let notYetPublished = false;
+      for (const source of registries) {
+        for (let attempt = 1; attempt <= attempts; attempt += 1) {
+          onAttempt({ registry: source, attempt });
+          const args = ["install", "-g", spec, "--prefer-online"];
+          if (source) args.push("--registry", source);
+          const result = await runNpm(spawnImpl, args, timeoutMs);
+          if (result.ok) {
+            const installed = readInstalledVersion();
+            if (target && installed && compareVersions(installed, target) < 0) {
+              return { ok: false, errorKey: "update.errorNotApplied", installed, output: result.output.slice(-2e3) };
+            }
+            return { ok: true, installed, output: result.output.slice(-2e3) };
+          }
+          last = result;
+          if (result.spawnFailed) {
+            return { ok: false, errorKey: "update.errorFailed", output: result.output, summary: result.output };
+          }
+          notYetPublished = isNotYetPublished(result.output);
+          if (!notYetPublished) break;
+          if (attempt < attempts) await sleep(retryDelayMs);
+        }
+      }
+      return {
+        ok: false,
+        errorKey: notYetPublished ? "update.errorNotYetPublished" : "update.errorFailed",
+        output: String(last.output || "").slice(-2e3),
+        summary: npmErrorSummary(last.output)
+      };
+    }
     module.exports = {
       PACKAGE_NAME,
       DEFAULT_REGISTRY,
@@ -561,8 +645,11 @@ var require_updater = __commonJS({
       compareVersions,
       currentVersion,
       installKind: installKind2,
+      installedVersionOnDisk,
+      npmErrorSummary,
       performUpdate: performUpdate2,
-      registryCandidates
+      registryCandidates,
+      updateChecksEnabled: updateChecksEnabled2
     };
   }
 });
@@ -910,16 +997,22 @@ var require_en = __commonJS({
       "hint.save": "s save",
       "hint.editing": "\u21B5 confirm \xB7 esc cancel",
       "update.title": "Updates",
+      "update.banner": "herdr-remote {latest} is out (running {current}). Press 7 and Enter on the update row to install.",
       "update.check": "Check for updates",
       "update.checking": "Checking npm\u2026",
       "update.upToDate": "Up to date ({version})",
       "update.available": "Update {version} available (press Enter to install)",
       "update.updating": "Installing {version}\u2026",
+      "update.updatingRetry": "Installing {version}\u2026 (npm has not caught up yet, attempt {attempt})",
       "update.done": "Updated to {version}",
       "update.restartHint": "Update installed. Restart herdr-remote to apply.",
       "update.errorNetwork": "Could not reach any npm registry",
       "update.errorNetworkDetail": "No registry answered: {message}",
-      "update.errorFailed": "Update failed. Run: npm install -g herdr-remote@latest",
+      "update.errorFailed": "Update failed. Run: npm install -g herdr-remote@{version} --prefer-online",
+      "update.errorFailedDetail": "npm: {message}",
+      "update.errorNotYetPublished": "npm has not caught up with {version} yet (common in the first minutes after a release). Press Enter to try again shortly.",
+      "update.errorNotApplied": "npm reported success, but {installed} is still installed",
+      "update.mirrorBehind": "{registries} still has an older version; installing from {source}",
       "update.cannot.source": "Source checkout \u2014 update with git",
       "update.cannot.linked": "Linked package \u2014 managed by npm link"
     };
@@ -1131,16 +1224,22 @@ var require_zh = __commonJS({
       "hint.save": "s \u4FDD\u5B58",
       "hint.editing": "\u21B5 \u786E\u8BA4 \xB7 esc \u53D6\u6D88",
       "update.title": "\u66F4\u65B0",
+      "update.banner": "herdr-remote {latest} \u5DF2\u53D1\u5E03\uFF08\u5F53\u524D {current}\uFF09\uFF0C\u6309 7 \u8FDB\u5165\u300C\u8BED\u8A00\u4E0E\u5173\u4E8E\u300D\uFF0C\u5728\u66F4\u65B0\u4E00\u884C\u6309 Enter \u5B89\u88C5\u3002",
       "update.check": "\u68C0\u67E5\u66F4\u65B0",
       "update.checking": "\u67E5\u8BE2 npm \u4E2D\u2026",
       "update.upToDate": "\u5DF2\u662F\u6700\u65B0\uFF08{version}\uFF09",
       "update.available": "\u65B0\u7248\u672C {version} \u53EF\u7528\uFF08\u6309 Enter \u5B89\u88C5\uFF09",
       "update.updating": "\u5B89\u88C5 {version} \u4E2D\u2026",
+      "update.updatingRetry": "\u5B89\u88C5 {version} \u4E2D\u2026\uFF08npm \u5C1A\u672A\u540C\u6B65\uFF0C\u7B2C {attempt} \u6B21\u5C1D\u8BD5\uFF09",
       "update.done": "\u5DF2\u66F4\u65B0\u81F3 {version}",
       "update.restartHint": "\u66F4\u65B0\u5DF2\u5B89\u88C5\uFF0C\u91CD\u542F herdr-remote \u751F\u6548\u3002",
       "update.errorNetwork": "\u6240\u6709 npm registry \u5747\u65E0\u6CD5\u8FDE\u63A5",
       "update.errorNetworkDetail": "\u65E0 registry \u5E94\u7B54\uFF1A{message}",
-      "update.errorFailed": "\u66F4\u65B0\u5931\u8D25\uFF0C\u53EF\u624B\u52A8\u6267\u884C\uFF1Anpm install -g herdr-remote@latest",
+      "update.errorFailed": "\u66F4\u65B0\u5931\u8D25\uFF0C\u53EF\u624B\u52A8\u6267\u884C\uFF1Anpm install -g herdr-remote@{version} --prefer-online",
+      "update.errorFailedDetail": "npm\uFF1A{message}",
+      "update.errorNotYetPublished": "npm \u8FD8\u6CA1\u540C\u6B65\u5230 {version}\uFF08\u521A\u53D1\u5E03\u7684\u51E0\u5206\u949F\u5185\u5E38\u89C1\uFF09\uFF0C\u7A0D\u540E\u6309 Enter \u91CD\u8BD5\u3002",
+      "update.errorNotApplied": "npm \u62A5\u544A\u6210\u529F\uFF0C\u4F46\u5B89\u88C5\u7684\u4ECD\u662F {installed}",
+      "update.mirrorBehind": "{registries} \u4ECD\u662F\u65E7\u7248\u672C\uFF0C\u5C06\u4ECE {source} \u5B89\u88C5",
       "update.cannot.source": "\u6E90\u7801\u76EE\u5F55\u8FD0\u884C\uFF0C\u8BF7\u4F7F\u7528 git \u66F4\u65B0",
       "update.cannot.linked": "npm link \u5DE5\u4F5C\u526F\u672C\uFF0C\u7531 npm link \u7BA1\u7406"
     };
@@ -1728,6 +1827,1161 @@ var require_terminal_palette = __commonJS({
   }
 });
 
+// src/binary-plist.js
+var require_binary_plist = __commonJS({
+  "src/binary-plist.js"(exports, module) {
+    "use strict";
+    var Uid = class {
+      constructor(value) {
+        this.value = value;
+      }
+    };
+    function readSizedInt(buffer, offset, size) {
+      let value = 0;
+      for (let i = 0; i < size; i += 1) value = value * 256 + buffer[offset + i];
+      return value;
+    }
+    function parseBinaryPlist(buffer) {
+      if (!Buffer.isBuffer(buffer) || buffer.length < 40 || buffer.toString("latin1", 0, 8) !== "bplist00") {
+        throw new Error("not a binary plist");
+      }
+      const trailer = buffer.length - 32;
+      const offsetSize = buffer[trailer + 6];
+      const refSize = buffer[trailer + 7];
+      const count = readSizedInt(buffer, trailer + 8, 8);
+      const top = readSizedInt(buffer, trailer + 16, 8);
+      const tableOffset = readSizedInt(buffer, trailer + 24, 8);
+      if (!offsetSize || !refSize || count > 1e6 || tableOffset + count * offsetSize > trailer) {
+        throw new Error("corrupt binary plist trailer");
+      }
+      const offsets = [];
+      for (let i = 0; i < count; i += 1) offsets.push(readSizedInt(buffer, tableOffset + i * offsetSize, offsetSize));
+      const parsing = /* @__PURE__ */ new Set();
+      const parse = (index) => {
+        if (index >= count || parsing.has(index)) throw new Error("corrupt binary plist reference");
+        parsing.add(index);
+        try {
+          return parseObject(offsets[index]);
+        } finally {
+          parsing.delete(index);
+        }
+      };
+      const lengthAt = (offset) => {
+        const low = buffer[offset] & 15;
+        if (low !== 15) return { length: low, start: offset + 1 };
+        const marker = buffer[offset + 1];
+        if ((marker & 240) !== 16) throw new Error("corrupt binary plist length");
+        const size = 1 << (marker & 15);
+        return { length: readSizedInt(buffer, offset + 2, size), start: offset + 2 + size };
+      };
+      const parseObject = (offset) => {
+        const marker = buffer[offset];
+        const type = marker >> 4;
+        const low = marker & 15;
+        switch (type) {
+          case 0:
+            if (marker === 8) return false;
+            if (marker === 9) return true;
+            return null;
+          case 1: {
+            const size = 1 << low;
+            if (size === 8) return Number(buffer.readBigInt64BE(offset + 1));
+            return readSizedInt(buffer, offset + 1, size);
+          }
+          case 2:
+            return low === 2 ? buffer.readFloatBE(offset + 1) : buffer.readDoubleBE(offset + 1);
+          case 3:
+            return new Date(Date.UTC(2001, 0, 1) + buffer.readDoubleBE(offset + 1) * 1e3);
+          case 4: {
+            const { length, start } = lengthAt(offset);
+            return buffer.subarray(start, start + length);
+          }
+          case 5: {
+            const { length, start } = lengthAt(offset);
+            return buffer.toString("latin1", start, start + length);
+          }
+          case 6: {
+            const { length, start } = lengthAt(offset);
+            return Buffer.from(buffer.subarray(start, start + length * 2)).swap16().toString("utf16le");
+          }
+          case 8:
+            return new Uid(readSizedInt(buffer, offset + 1, low + 1));
+          case 10:
+          case 12: {
+            const { length, start } = lengthAt(offset);
+            const items = [];
+            for (let i = 0; i < length; i += 1) items.push(parse(readSizedInt(buffer, start + i * refSize, refSize)));
+            return items;
+          }
+          case 13: {
+            const { length, start } = lengthAt(offset);
+            const result = {};
+            for (let i = 0; i < length; i += 1) {
+              const key = parse(readSizedInt(buffer, start + i * refSize, refSize));
+              result[String(key)] = parse(readSizedInt(buffer, start + (length + i) * refSize, refSize));
+            }
+            return result;
+          }
+          default:
+            throw new Error(`unsupported binary plist object 0x${marker.toString(16)}`);
+        }
+      };
+      return parse(top);
+    }
+    function unarchiveKeyed(archive, depth = 6) {
+      const objects = archive?.$objects;
+      const rootRef = archive?.$top?.root;
+      if (!Array.isArray(objects) || !(rootRef instanceof Uid)) throw new Error("not a keyed archive");
+      const resolve = (value, level2) => {
+        if (value instanceof Uid) return level2 > depth ? null : resolve(objects[value.value], level2 + 1);
+        if (Array.isArray(value)) return value.map((item) => resolve(item, level2));
+        if (value && typeof value === "object" && !Buffer.isBuffer(value) && !(value instanceof Date)) {
+          const result = {};
+          for (const [key, item] of Object.entries(value)) result[key] = resolve(item, level2);
+          return result;
+        }
+        return value === "$null" ? null : value;
+      };
+      return resolve(rootRef, 0);
+    }
+    module.exports = { Uid, parseBinaryPlist, unarchiveKeyed };
+  }
+});
+
+// src/terminal-font.js
+var require_terminal_font = __commonJS({
+  "src/terminal-font.js"(exports, module) {
+    "use strict";
+    var crypto = __require("node:crypto");
+    var fs = __require("node:fs");
+    var os = __require("node:os");
+    var path = __require("node:path");
+    var { spawnSync } = __require("node:child_process");
+    var {
+      MAX_TERMINAL_FONT_BYTES,
+      TERMINAL_FONT_CHUNK_BYTES,
+      TERMINAL_FONT_STYLES,
+      sanitizeTerminalFont
+    } = __require("herdr-remote-relay/protocol");
+    var { runtimeStatePath, stateDir: stateDir2 } = require_config();
+    var { ensureDir, readJson, writeJsonAtomic } = require_state();
+    var { parseBinaryPlist, unarchiveKeyed } = require_binary_plist();
+    var PX_PER_PT = 96 / 72;
+    var COMMAND_TIMEOUT_MS = 3e3;
+    var GENERIC_FAMILIES = /* @__PURE__ */ new Set(["monospace", "mono", "sans", "sans-serif", "serif", "system-ui", "ui-monospace"]);
+    function defaultRun(command, args) {
+      try {
+        const result = spawnSync(command, args, { encoding: "utf8", timeout: COMMAND_TIMEOUT_MS });
+        return { status: result.status, stdout: result.stdout || "" };
+      } catch {
+        return { status: null, stdout: "" };
+      }
+    }
+    function defaultReadFile(filePath) {
+      try {
+        return fs.readFileSync(filePath, "utf8");
+      } catch {
+        return null;
+      }
+    }
+    function defaultReadBuffer(filePath) {
+      try {
+        return fs.readFileSync(filePath);
+      } catch {
+        return null;
+      }
+    }
+    function withDefaults(deps = {}) {
+      const env = deps.env || process.env;
+      return {
+        env,
+        platform: deps.platform || process.platform,
+        home: deps.home || env.HOME || os.homedir(),
+        run: deps.run || defaultRun,
+        readFile: deps.readFile || defaultReadFile,
+        readBuffer: deps.readBuffer || defaultReadBuffer,
+        terminalArgs: deps.terminalArgs || []
+      };
+    }
+    function configHome(deps) {
+      return deps.env.XDG_CONFIG_HOME || path.join(deps.home, ".config");
+    }
+    function dataHome(deps) {
+      return deps.env.XDG_DATA_HOME || path.join(deps.home, ".local", "share");
+    }
+    function expandHome(filePath, deps) {
+      return filePath.startsWith("~/") ? path.join(deps.home, filePath.slice(2)) : filePath;
+    }
+    function pointsToPx(points) {
+      const value = Number(points);
+      return Number.isFinite(value) && value > 0 ? Math.round(value * PX_PER_PT * 10) / 10 : void 0;
+    }
+    function positiveNumber(value) {
+      const number = Number(value);
+      return Number.isFinite(number) && number > 0 ? number : void 0;
+    }
+    function parseIni(text) {
+      const sections = { "": {} };
+      let current = sections[""];
+      for (const rawLine of String(text || "").split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+        const header = /^\[(.+)\]$/.exec(line);
+        if (header) {
+          current = sections[header[1].trim()] ||= {};
+          continue;
+        }
+        const equals = line.indexOf("=");
+        if (equals === -1) continue;
+        current[line.slice(0, equals).trim()] = line.slice(equals + 1).trim();
+      }
+      return sections;
+    }
+    function parseGVariantString(output) {
+      const text = String(output || "").trim();
+      const quoted = /^'((?:[^'\\]|\\.)*)'$/.exec(text) || /^"((?:[^"\\]|\\.)*)"$/.exec(text);
+      if (!quoted) return null;
+      return quoted[1].replace(/\\(.)/g, "$1");
+    }
+    function gsettingsGet(deps, schema, key) {
+      const result = deps.run("gsettings", ["get", schema, key]);
+      if (result.status !== 0) return null;
+      return result.stdout.trim();
+    }
+    var PANGO_STYLE_WORDS = /* @__PURE__ */ new Set([
+      "normal",
+      "roman",
+      "oblique",
+      "italic",
+      "small-caps",
+      "all-small-caps",
+      "petite-caps",
+      "all-petite-caps",
+      "unicase",
+      "title-caps",
+      "ultra-condensed",
+      "extra-condensed",
+      "condensed",
+      "semi-condensed",
+      "semi-expanded",
+      "expanded",
+      "extra-expanded",
+      "ultra-expanded",
+      "thin",
+      "ultra-light",
+      "extra-light",
+      "light",
+      "semi-light",
+      "demi-light",
+      "book",
+      "regular",
+      "medium",
+      "semi-bold",
+      "demi-bold",
+      "bold",
+      "ultra-bold",
+      "extra-bold",
+      "heavy",
+      "black",
+      "ultra-black",
+      "extra-black",
+      "ultra-heavy",
+      "extra-heavy",
+      "not-rotated",
+      "south",
+      "upside-down",
+      "north",
+      "rotated-left",
+      "east",
+      "rotated-right",
+      "west"
+    ]);
+    function parsePangoFontDescription(description) {
+      if (typeof description !== "string") return null;
+      const words = description.trim().split(/\s+/).filter(Boolean);
+      while (words.length && words[words.length - 1].startsWith("@")) words.pop();
+      let sizePx;
+      const size = /^(\d+(?:\.\d+)?)(px)?$/i.exec(words[words.length - 1] || "");
+      if (size && words.length > 1) {
+        words.pop();
+        sizePx = size[2] ? positiveNumber(size[1]) : pointsToPx(size[1]);
+      }
+      while (words.length > 1) {
+        const last = words[words.length - 1].toLowerCase();
+        if (!PANGO_STYLE_WORDS.has(last) && !/^weight=\d+$/.test(last)) break;
+        words.pop();
+      }
+      const family = words.join(" ").split(",")[0].trim();
+      return family ? { family, sizePx } : null;
+    }
+    function parseQtFontString(value) {
+      if (typeof value !== "string") return null;
+      const parts = value.split(",");
+      const family = (parts[0] || "").trim();
+      if (!family) return null;
+      const points = Number(parts[1]);
+      const pixels = Number(parts[2]);
+      const sizePx = points > 0 ? pointsToPx(points) : pixels > 0 ? pixels : void 0;
+      return { family, sizePx };
+    }
+    function parseFontconfigPattern(value) {
+      if (typeof value !== "string") return null;
+      const first = value.split(/(?<!\\),/)[0];
+      const [rawFamily, ...properties] = first.split(/(?<!\\):/);
+      const family = rawFamily.replace(/\\(.)/g, "$1").trim();
+      if (!family) return null;
+      let sizePx;
+      for (const property of properties) {
+        const [key, raw] = property.split("=");
+        if (key === "size") sizePx = pointsToPx(raw);
+        else if (key === "pixelsize") sizePx = positiveNumber(raw);
+      }
+      return { family, sizePx };
+    }
+    function firstCssFamily(value) {
+      if (typeof value !== "string") return null;
+      const first = value.split(",")[0].trim().replace(/^(['"])(.*)\1$/, "$2").trim();
+      return first || null;
+    }
+    function parseJsonc(text) {
+      if (typeof text !== "string") return null;
+      let out = "";
+      let inString = false;
+      for (let i = 0; i < text.length; i += 1) {
+        const char = text[i];
+        if (inString) {
+          out += char;
+          if (char === "\\") {
+            out += text[i + 1] || "";
+            i += 1;
+          } else if (char === '"') inString = false;
+          continue;
+        }
+        if (char === '"') {
+          inString = true;
+          out += char;
+          continue;
+        }
+        if (char === "/" && text[i + 1] === "/") {
+          while (i < text.length && text[i] !== "\n") i += 1;
+          out += "\n";
+          continue;
+        }
+        if (char === "/" && text[i + 1] === "*") {
+          i += 2;
+          while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i += 1;
+          i += 1;
+          continue;
+        }
+        out += char;
+      }
+      try {
+        return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+      } catch {
+        return null;
+      }
+    }
+    function parseTomlSubset(text) {
+      const values = {};
+      const lines = String(text || "").split(/\r?\n/);
+      let table = "";
+      const unquote = (raw) => {
+        const value = raw.trim();
+        const basic = /^"((?:[^"\\]|\\.)*)"/.exec(value);
+        if (basic) return basic[1].replace(/\\(.)/g, "$1");
+        const literal = /^'([^']*)'/.exec(value);
+        if (literal) return literal[1];
+        const number = Number(value.replace(/#.*$/, "").trim());
+        return Number.isFinite(number) ? number : void 0;
+      };
+      const keyPath = (raw) => raw.split(".").map((part) => part.trim().replace(/^(['"])(.*)\1$/, "$2"));
+      const assign = (prefix, rawKey, rawValue) => {
+        const key = [...prefix ? [prefix] : [], ...keyPath(rawKey)].join(".");
+        const value = rawValue.trim();
+        if (value.startsWith("{")) {
+          const body = value.slice(1, value.lastIndexOf("}"));
+          for (const pair2 of body.split(/,(?=(?:[^"']|"[^"]*"|'[^']*')*$)/)) {
+            const equals = pair2.indexOf("=");
+            if (equals !== -1) assign(key, pair2.slice(0, equals), pair2.slice(equals + 1));
+          }
+          return;
+        }
+        if (value.startsWith("[")) {
+          values[key] = [...value.matchAll(/"((?:[^"\\]|\\.)*)"|'([^']*)'/g)].map((m) => m[1] ?? m[2]);
+          return;
+        }
+        const parsed = unquote(value);
+        if (parsed !== void 0) values[key] = parsed;
+      };
+      for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index].trim();
+        if (!line || line.startsWith("#")) continue;
+        const header = /^\[([^[\]]+)\]/.exec(line);
+        if (header) {
+          table = keyPath(header[1]).join(".");
+          continue;
+        }
+        if (line.startsWith("[[")) {
+          table = "\0";
+          continue;
+        }
+        if (table === "\0") continue;
+        const equals = line.indexOf("=");
+        if (equals === -1) continue;
+        let rawValue = line.slice(equals + 1);
+        if (rawValue.trim().startsWith("[") && !rawValue.includes("]")) {
+          while (index + 1 < lines.length && !rawValue.includes("]")) {
+            index += 1;
+            rawValue += ` ${lines[index].trim()}`;
+          }
+        }
+        assign(table, line.slice(0, equals), rawValue);
+      }
+      return values;
+    }
+    var TERMINAL_PROCESSES = [
+      [/^gnome-terminal/, "gnome-terminal"],
+      [/^ptyxis/, "ptyxis"],
+      [/^tilix$/, "tilix"],
+      [/^konsole$/, "konsole"],
+      [/^xfce4-terminal$/, "xfce4-terminal"],
+      [/^kitty$/, "kitty"],
+      [/^alacritty$/i, "alacritty"],
+      [/^ghostty$/i, "ghostty"],
+      [/^wezterm-gui$/, "wezterm"],
+      [/^foot(client)?$/, "foot"],
+      [/^iTerm2$/, "iterm2"],
+      [/^Terminal$/, "apple-terminal"],
+      [/^xterm$/, "xterm"],
+      [/^(urxvt|urxvtd|rxvt)$/, "urxvt"]
+    ];
+    function identifyTerminal({ env = process.env, ancestry = [] } = {}) {
+      for (const name of ancestry) {
+        const base = path.basename(String(name || ""));
+        for (const [pattern, id] of TERMINAL_PROCESSES) {
+          if (pattern.test(base)) return id;
+        }
+      }
+      const program = env.TERM_PROGRAM || "";
+      if (program === "vscode") return "vscode";
+      if (program === "iTerm.app" || env.ITERM_SESSION_ID) return "iterm2";
+      if (program === "Apple_Terminal") return "apple-terminal";
+      if (program === "WezTerm" || env.WEZTERM_EXECUTABLE) return "wezterm";
+      if (program === "ghostty" || env.GHOSTTY_RESOURCES_DIR) return "ghostty";
+      if (env.KITTY_WINDOW_ID || env.TERM === "xterm-kitty") return "kitty";
+      if (env.ALACRITTY_SOCKET || env.ALACRITTY_WINDOW_ID || env.ALACRITTY_LOG) return "alacritty";
+      if (/^foot/.test(env.TERM || "")) return "foot";
+      if (env.KONSOLE_VERSION || env.KONSOLE_DBUS_SESSION) return "konsole";
+      if (env.PTYXIS_VERSION) return "ptyxis";
+      if (env.TILIX_ID) return "tilix";
+      if (env.GNOME_TERMINAL_SCREEN || env.GNOME_TERMINAL_SERVICE) return "gnome-terminal";
+      if (/^rxvt-unicode/.test(env.TERM || "")) return "urxvt";
+      if (env.XTERM_VERSION) return "xterm";
+      return null;
+    }
+    function processLineage({ platform = process.platform, pid = process.ppid, run = defaultRun } = {}) {
+      const lineage = [];
+      if (platform === "linux") {
+        let current = pid;
+        for (let depth = 0; depth < 32 && current > 1; depth += 1) {
+          let stat;
+          try {
+            stat = fs.readFileSync(`/proc/${current}/stat`, "utf8");
+          } catch {
+            break;
+          }
+          const open = stat.indexOf("(");
+          const close = stat.lastIndexOf(")");
+          if (open === -1 || close === -1) break;
+          lineage.push({ pid: current, name: stat.slice(open + 1, close) });
+          current = Number(stat.slice(close + 2).split(" ")[1]);
+        }
+        return lineage;
+      }
+      if (platform === "darwin") {
+        const result = run("ps", ["-axo", "pid=,ppid=,comm="]);
+        if (result.status !== 0) return lineage;
+        const table = /* @__PURE__ */ new Map();
+        for (const line of result.stdout.split("\n")) {
+          const match = /^\s*(\d+)\s+(\d+)\s+(.+)$/.exec(line);
+          if (match) table.set(Number(match[1]), { ppid: Number(match[2]), comm: match[3].trim() });
+        }
+        let current = pid;
+        for (let depth = 0; depth < 32 && table.has(current) && current > 1; depth += 1) {
+          const entry = table.get(current);
+          lineage.push({ pid: current, name: entry.comm });
+          current = entry.ppid;
+        }
+      }
+      return lineage;
+    }
+    function processAncestry(options = {}) {
+      return processLineage(options).map((entry) => entry.name);
+    }
+    function processArguments(pid, { platform = process.platform } = {}) {
+      if (platform !== "linux") return [];
+      try {
+        return fs.readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean);
+      } catch {
+        return [];
+      }
+    }
+    function terminalProcess(source, lineage) {
+      return lineage.find((entry) => TERMINAL_PROCESSES.some(([pattern, id]) => id === source && pattern.test(path.basename(String(entry.name || ""))))) || null;
+    }
+    function readGSettingsProfileFont(deps, { schema, path: profilePath, fontKey = "font" }) {
+      const useSystem = gsettingsGet(deps, `${schema}:${profilePath}`, "use-system-font");
+      if (useSystem === null) return null;
+      if (useSystem === "false") {
+        const font = parsePangoFontDescription(parseGVariantString(gsettingsGet(deps, `${schema}:${profilePath}`, fontKey)));
+        if (font) return font;
+      }
+      return systemMonospaceFont(deps);
+    }
+    function systemMonospaceFont(deps) {
+      return parsePangoFontDescription(parseGVariantString(
+        gsettingsGet(deps, "org.gnome.desktop.interface", "monospace-font-name")
+      ));
+    }
+    var READERS = {
+      "gnome-terminal": (deps) => {
+        const id = parseGVariantString(gsettingsGet(deps, "org.gnome.Terminal.ProfilesList", "default"));
+        if (!id) return null;
+        return readGSettingsProfileFont(deps, {
+          schema: "org.gnome.Terminal.Legacy.Profile",
+          path: `/org/gnome/terminal/legacy/profiles:/:${id}/`
+        });
+      },
+      tilix: (deps) => {
+        const id = parseGVariantString(gsettingsGet(deps, "com.gexperts.Tilix.ProfilesList", "default"));
+        if (!id) return null;
+        return readGSettingsProfileFont(deps, {
+          schema: "com.gexperts.Tilix.Profile",
+          path: `/com/gexperts/Tilix/profiles/${id}/`
+        });
+      },
+      ptyxis: (deps) => {
+        const useSystem = gsettingsGet(deps, "org.gnome.Ptyxis", "use-system-font");
+        if (useSystem === "false") {
+          const font = parsePangoFontDescription(parseGVariantString(gsettingsGet(deps, "org.gnome.Ptyxis", "font-name")));
+          if (font) return font;
+        }
+        return useSystem === null ? null : systemMonospaceFont(deps);
+      },
+      konsole: (deps) => {
+        const rc = parseIni(deps.readFile(path.join(configHome(deps), "konsolerc")));
+        const profileName = rc["Desktop Entry"]?.DefaultProfile;
+        if (profileName) {
+          const profile = parseIni(deps.readFile(path.join(dataHome(deps), "konsole", profileName)));
+          const font = parseQtFontString(profile.Appearance?.Font);
+          if (font) return font;
+        }
+        const globals = parseIni(deps.readFile(path.join(configHome(deps), "kdeglobals")));
+        return parseQtFontString(globals.General?.fixed) || { family: "Hack", sizePx: pointsToPx(10) };
+      },
+      "xfce4-terminal": (deps) => {
+        const query = (property) => {
+          const result2 = deps.run("xfconf-query", ["-c", "xfce4-terminal", "-p", property]);
+          return result2.status === 0 ? result2.stdout.trim() : null;
+        };
+        const rc = parseIni(deps.readFile(path.join(configHome(deps), "xfce4", "terminal", "terminalrc"))).Configuration || {};
+        const useSystem = (query("/font-use-system") ?? rc.FontUseSystem ?? "false").toLowerCase() === "true";
+        if (!useSystem) {
+          const font = parsePangoFontDescription(query("/font-name") ?? rc.FontName ?? "Monospace 12");
+          if (font) return font;
+        }
+        const result = deps.run("xfconf-query", ["-c", "xsettings", "-p", "/Gtk/MonospaceFontName"]);
+        return parsePangoFontDescription(result.status === 0 ? result.stdout.trim() : "Monospace 10");
+      },
+      kitty: (deps) => {
+        const directory = deps.env.KITTY_CONFIG_DIRECTORY || path.join(configHome(deps), "kitty");
+        const settings = {};
+        const visit = (file, depth) => {
+          const text = deps.readFile(file);
+          if (text === null || depth > 4) return;
+          for (const rawLine of text.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line || line.startsWith("#")) continue;
+            const [key, ...rest] = line.split(/\s+/);
+            const value = rest.join(" ");
+            if (key === "include") visit(path.resolve(directory, expandHome(value, deps)), depth + 1);
+            else if (key === "font_family" || key === "font_size") settings[key] = value;
+          }
+        };
+        visit(path.join(directory, "kitty.conf"), 0);
+        const raw = settings.font_family || "monospace";
+        const quoted = /family\s*=\s*(?:"([^"]+)"|'([^']+)'|(\S+))/.exec(raw);
+        const family = quoted ? quoted[1] || quoted[2] || quoted[3] : raw;
+        return { family, sizePx: pointsToPx(settings.font_size || 11) };
+      },
+      alacritty: (deps) => {
+        const candidates = [
+          path.join(configHome(deps), "alacritty", "alacritty.toml"),
+          path.join(configHome(deps), "alacritty.toml"),
+          path.join(deps.home, ".alacritty.toml")
+        ];
+        const merged = {};
+        const visit = (file, depth) => {
+          const text = deps.readFile(file);
+          if (text === null || depth > 4) return false;
+          const values = parseTomlSubset(text);
+          for (const imported of [...values.import || [], ...values["general.import"] || []]) {
+            visit(path.resolve(path.dirname(file), expandHome(String(imported), deps)), depth + 1);
+          }
+          Object.assign(merged, values);
+          return true;
+        };
+        candidates.some((file) => visit(file, 0));
+        const fallbackFamily = deps.platform === "darwin" ? "Menlo" : "monospace";
+        return {
+          family: String(merged["font.normal.family"] || fallbackFamily),
+          sizePx: pointsToPx(merged["font.size"] || 11.25)
+        };
+      },
+      ghostty: (deps) => {
+        const settings = { families: [], size: void 0 };
+        const visit = (file, depth) => {
+          const text = deps.readFile(file);
+          if (text === null || depth > 4) return;
+          for (const rawLine of text.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line || line.startsWith("#")) continue;
+            const equals = line.indexOf("=");
+            if (equals === -1) continue;
+            const key = line.slice(0, equals).trim();
+            const value = line.slice(equals + 1).trim().replace(/^"(.*)"$/, "$1");
+            if (key === "font-family") {
+              if (value) settings.families.push(value);
+              else settings.families = [];
+            } else if (key === "font-size") {
+              settings.size = value;
+            } else if (key === "config-file") {
+              const target = expandHome(value.replace(/^\?/, ""), deps);
+              visit(path.resolve(path.dirname(file), target), depth + 1);
+            }
+          }
+        };
+        visit(path.join(configHome(deps), "ghostty", "config"), 0);
+        if (deps.platform === "darwin") {
+          visit(path.join(deps.home, "Library", "Application Support", "com.mitchellh.ghostty", "config"), 0);
+        }
+        return {
+          family: settings.families[0] || "JetBrains Mono",
+          sizePx: pointsToPx(settings.size || (deps.platform === "darwin" ? 13 : 12))
+        };
+      },
+      wezterm: (deps) => {
+        const result = deps.run("wezterm", ["ls-fonts"]);
+        const listing = result.status === 0 ? result.stdout : "";
+        const match = /family\s*=\s*"([^"]+)"/.exec(listing) || /font_with_fallback\(\{[\s\S]*?"([^"]+)"/.exec(listing);
+        let sizePt = 12;
+        for (const file of [path.join(deps.home, ".wezterm.lua"), path.join(configHome(deps), "wezterm", "wezterm.lua")]) {
+          const size = /font_size\s*=\s*(\d+(?:\.\d+)?)/.exec(deps.readFile(file) || "");
+          if (size) {
+            sizePt = Number(size[1]);
+            break;
+          }
+        }
+        return { family: match ? match[1] : "JetBrains Mono", sizePx: pointsToPx(sizePt) };
+      },
+      foot: (deps) => {
+        const ini = parseIni(deps.readFile(path.join(configHome(deps), "foot", "foot.ini")));
+        const value = ini.main?.font || ini[""]?.font || "monospace:size=8";
+        return parseFontconfigPattern(value);
+      },
+      vscode: (deps) => {
+        const base = deps.platform === "darwin" ? path.join(deps.home, "Library", "Application Support") : configHome(deps);
+        for (const product of ["Code", "Cursor", "Code - Insiders", "VSCodium", "Windsurf"]) {
+          const settings = parseJsonc(deps.readFile(path.join(base, product, "User", "settings.json")));
+          if (!settings) continue;
+          const family = firstCssFamily(settings["terminal.integrated.fontFamily"]) || firstCssFamily(settings["editor.fontFamily"]);
+          const sizePx = positiveNumber(settings["terminal.integrated.fontSize"]) || positiveNumber(settings["editor.fontSize"]) || 14;
+          if (family) return { family, sizePx };
+        }
+        return { family: deps.platform === "darwin" ? "Menlo" : "Droid Sans Mono", sizePx: 14 };
+      },
+      iterm2: (deps) => {
+        const prefs = readPreferences("com.googlecode.iterm2", deps);
+        const profiles = Array.isArray(prefs?.["New Bookmarks"]) ? prefs["New Bookmarks"] : [];
+        const profile = profiles.find((candidate) => candidate?.Guid === prefs["Default Bookmark Guid"]) || profiles[0];
+        const match = /^(.+?)\s+(\d+(?:\.\d+)?)$/.exec(String(profile?.["Normal Font"] || "").trim());
+        if (!match) return null;
+        const family = familyForPostScriptName(match[1], deps);
+        return family ? { family, sizePx: pointsToPx(match[2]) } : null;
+      },
+      "apple-terminal": (deps) => {
+        const prefs = readPreferences("com.apple.Terminal", deps);
+        if (!prefs) return null;
+        const name = prefs["Default Window Settings"] || prefs["Startup Window Settings"] || "Basic";
+        const profile = prefs["Window Settings"]?.[name];
+        let postscript = "SFMono-Regular";
+        let points = 11;
+        if (Buffer.isBuffer(profile?.Font)) {
+          const font = unarchiveKeyed(parseBinaryPlist(profile.Font));
+          if (typeof font?.NSName === "string" && font.NSName) postscript = font.NSName;
+          if (Number(font?.NSSize) > 0) points = Number(font.NSSize);
+        }
+        const family = familyForPostScriptName(postscript, deps);
+        return family ? { family, sizePx: pointsToPx(points) } : null;
+      },
+      xterm: (deps) => {
+        const classes = ["XTerm", "xterm", "UXTerm", "uxterm"];
+        const args = deps.terminalArgs || [];
+        const resources = [...xResources(deps), ...xrmResources(args)];
+        const face = optionValue(args, ["-fa", "-faceName"]) || xResource(resources, classes, "faceName");
+        if (!face) return null;
+        const font = parseXFontName(face, { bareIsPattern: true });
+        if (!font) return null;
+        const size = Number(optionValue(args, ["-fs", "-faceSize"]) || xResource(resources, classes, "faceSize"));
+        return size > 0 ? { ...font, sizePx: pointsToPx(size) } : font;
+      },
+      urxvt: (deps) => {
+        const args = deps.terminalArgs || [];
+        const resources = [...xResources(deps), ...xrmResources(args)];
+        const font = optionValue(args, ["-fn"]) || xResource(resources, ["URxvt", "urxvt", "Rxvt", "rxvt"], "font");
+        return font ? parseXFontName(font) : null;
+      }
+    };
+    function readPreferences(domain, deps) {
+      const data = deps.readBuffer(path.join(deps.home, "Library", "Preferences", `${domain}.plist`));
+      if (!data) return null;
+      try {
+        return parseBinaryPlist(data);
+      } catch {
+        return null;
+      }
+    }
+    function optionValue(args, names) {
+      let value = null;
+      for (let i = 0; i < args.length - 1; i += 1) {
+        if (names.includes(args[i])) value = args[i + 1];
+      }
+      return value;
+    }
+    function xrmResources(args) {
+      const entries = [];
+      for (let i = 0; i < args.length - 1; i += 1) {
+        if (args[i] !== "-xrm") continue;
+        const colon = args[i + 1].indexOf(":");
+        if (colon !== -1) entries.push([args[i + 1].slice(0, colon).trim(), args[i + 1].slice(colon + 1).trim()]);
+      }
+      return entries;
+    }
+    function xResources(deps) {
+      const result = deps.run("xrdb", ["-query"]);
+      if (result.status !== 0) return [];
+      return result.stdout.split("\n").map((line) => {
+        const colon = line.indexOf(":");
+        return colon === -1 ? null : [line.slice(0, colon).trim(), line.slice(colon + 1).trim()];
+      }).filter(Boolean);
+    }
+    function xResource(resources, classes, resource) {
+      let named = null;
+      let wildcard = null;
+      for (const [name, value] of resources) {
+        const parts = name.split(/[.*]/).filter(Boolean);
+        if (parts[parts.length - 1] !== resource || !value) continue;
+        if (parts.length === 1) wildcard = value;
+        else if (classes.includes(parts[0])) named = value;
+      }
+      return named ?? wildcard;
+    }
+    function parseXFontName(value, { bareIsPattern = false } = {}) {
+      const first = String(value || "").split(/,(?=\s*(?:xft:|-))/)[0].trim();
+      if (/^xft:/i.test(first)) return parseFontconfigPattern(first.slice(4));
+      if (first.startsWith("-")) {
+        const fields = first.split("-");
+        const family = (fields[2] || "").trim();
+        if (!family || family === "*" || /^(fixed|misc)$/i.test(family)) return null;
+        const pixels = Number(fields[7]);
+        const decipoints = Number(fields[8]);
+        return { family, sizePx: pixels > 0 ? pixels : decipoints > 0 ? pointsToPx(decipoints / 10) : void 0 };
+      }
+      if (!first) return null;
+      return bareIsPattern || first.includes(":") ? parseFontconfigPattern(first) : null;
+    }
+    var FACE_PATTERNS = {
+      regular: ":weight=regular:slant=roman",
+      bold: ":weight=bold:slant=roman",
+      italic: ":weight=regular:slant=italic",
+      boldItalic: ":weight=bold:slant=italic"
+    };
+    function escapeFontconfig(value) {
+      return value.replace(/([\\\-:,])/g, "\\$1");
+    }
+    function sfntFormat(header) {
+      if (!header || header.length < 4) return null;
+      const tag = header.subarray(0, 4).toString("latin1");
+      if (tag === "\0
\0\0" || tag === "true") return "truetype";
+      if (tag === "OTTO") return "opentype";
+      return null;
+    }
+    function readHeader(filePath, length) {
+      let fd;
+      try {
+        fd = fs.openSync(filePath, "r");
+        const buffer = Buffer.alloc(length);
+        const read = fs.readSync(fd, buffer, 0, length, 0);
+        return buffer.subarray(0, read);
+      } catch {
+        return null;
+      } finally {
+        if (fd !== void 0) try {
+          fs.closeSync(fd);
+        } catch {
+        }
+      }
+    }
+    function readSfntNames(filePath) {
+      let fd;
+      try {
+        fd = fs.openSync(filePath, "r");
+        const head = Buffer.alloc(12);
+        fs.readSync(fd, head, 0, 12, 0);
+        if (!sfntFormat(head)) return null;
+        const tables = head.readUInt16BE(4);
+        const directory = Buffer.alloc(tables * 16);
+        fs.readSync(fd, directory, 0, directory.length, 12);
+        let offset = -1;
+        let length = 0;
+        for (let i = 0; i < tables; i += 1) {
+          if (directory.toString("latin1", i * 16, i * 16 + 4) === "name") {
+            offset = directory.readUInt32BE(i * 16 + 8);
+            length = directory.readUInt32BE(i * 16 + 12);
+          }
+        }
+        if (offset < 0 || length > 1024 * 1024) return null;
+        const table = Buffer.alloc(length);
+        fs.readSync(fd, table, 0, length, offset);
+        const count = table.readUInt16BE(2);
+        const strings = table.readUInt16BE(4);
+        const names = {};
+        for (let i = 0; i < count; i += 1) {
+          const record = 6 + i * 12;
+          const platformId = table.readUInt16BE(record);
+          const languageId = table.readUInt16BE(record + 4);
+          const nameId = table.readUInt16BE(record + 6);
+          const size = table.readUInt16BE(record + 8);
+          const start = strings + table.readUInt16BE(record + 10);
+          if (![1, 2, 6, 16, 17].includes(nameId) || start + size > table.length) continue;
+          let text;
+          if ((platformId === 3 || platformId === 0) && size % 2 === 0) {
+            if (platformId === 3 && languageId !== 1033 && names[nameId]) continue;
+            const utf16 = Buffer.from(table.subarray(start, start + size));
+            text = utf16.swap16().toString("utf16le");
+          } else if (platformId === 1 && !names[nameId]) {
+            text = table.toString("latin1", start, start + size);
+          }
+          if (text) names[nameId] = text;
+        }
+        return {
+          family: names[16] || names[1] || null,
+          subfamily: names[17] || names[2] || "",
+          postscript: names[6] || null
+        };
+      } catch {
+        return null;
+      } finally {
+        if (fd !== void 0) try {
+          fs.closeSync(fd);
+        } catch {
+        }
+      }
+    }
+    function macFontFiles(deps) {
+      const roots = [
+        path.join(deps.home, "Library", "Fonts"),
+        "/Library/Fonts",
+        "/System/Library/Fonts"
+      ];
+      const files = [];
+      const walk = (directory, depth) => {
+        let entries;
+        try {
+          entries = fs.readdirSync(directory, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        for (const entry of entries) {
+          const full = path.join(directory, entry.name);
+          if (entry.isDirectory() && depth < 2) walk(full, depth + 1);
+          else if (/\.(ttf|otf)$/i.test(entry.name)) files.push(full);
+        }
+      };
+      for (const root of roots) walk(root, 0);
+      return files;
+    }
+    var APPLE_POSTSCRIPT_FAMILIES = [
+      [/^\.?SF(NS)?Mono/, "SF Mono"],
+      [/^Menlo-/, "Menlo"],
+      [/^Monaco$/, "Monaco"],
+      [/^Courier(New)?/, "Courier New"],
+      [/^AndaleMono$/, "Andale Mono"]
+    ];
+    function familyForPostScriptName(postscript, deps) {
+      const apple = APPLE_POSTSCRIPT_FAMILIES.find(([pattern]) => pattern.test(postscript));
+      if (apple && deps.platform === "darwin") return apple[1];
+      const listed = deps.run("fc-list", [`:postscriptname=${escapeFontconfig(postscript)}`, "family"]);
+      if (listed.status === 0 && listed.stdout.trim()) return listed.stdout.trim().split("\n")[0].split(",")[0].trim();
+      if (deps.platform !== "darwin") return null;
+      for (const file of macFontFiles(deps)) {
+        const names = readSfntNames(file);
+        if (names?.postscript === postscript) return names.family;
+      }
+      return null;
+    }
+    function styleOfSubfamily(subfamily) {
+      const text = String(subfamily || "").toLowerCase();
+      const bold = /\bbold\b/.test(text) && !/(semi|demi|extra|ultra)\s*bold/.test(text);
+      const italic = /italic|oblique/.test(text);
+      if (bold && italic) return "boldItalic";
+      if (bold) return "bold";
+      if (italic) return "italic";
+      return /^(regular|normal|book|roman)$/.test(text.trim()) ? "regular" : null;
+    }
+    function locateFaceFiles(family, deps) {
+      const located = {};
+      let fontconfig = false;
+      for (const style of TERMINAL_FONT_STYLES) {
+        const result = deps.run("fc-match", ["-f", "%{file}\n%{family}\n%{index}\n", `${escapeFontconfig(family)}${FACE_PATTERNS[style]}`]);
+        if (result.status !== 0) continue;
+        fontconfig = true;
+        const [file, families = "", index = "0"] = result.stdout.split("\n");
+        const names = families.split(",").map((name) => name.trim().toLowerCase());
+        if (!file || !names.includes(family.toLowerCase()) || Number(index) !== 0) continue;
+        located[style] = file;
+      }
+      if (fontconfig || deps.platform !== "darwin") return located;
+      for (const file of macFontFiles(deps)) {
+        const names = readSfntNames(file);
+        if (!names || names.family?.toLowerCase() !== family.toLowerCase()) continue;
+        const style = styleOfSubfamily(names.subfamily);
+        if (style && !located[style]) located[style] = file;
+      }
+      return located;
+    }
+    function hashFile(filePath) {
+      return crypto.createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+    }
+    function resolveFontFaces(family, deps = {}) {
+      const resolved = withDefaults(deps);
+      if (!family || GENERIC_FAMILIES.has(family.toLowerCase())) return [];
+      const located = locateFaceFiles(family, resolved);
+      const faces = [];
+      const usedFiles = /* @__PURE__ */ new Set();
+      for (const style of TERMINAL_FONT_STYLES) {
+        const file = located[style];
+        if (!file || usedFiles.has(file)) continue;
+        if (/^\/System\//.test(file) || /\.app\/Contents\//.test(file)) continue;
+        if (style !== "regular" && !faces.length) continue;
+        let stat;
+        try {
+          stat = fs.statSync(file);
+        } catch {
+          continue;
+        }
+        if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_TERMINAL_FONT_BYTES) continue;
+        const format = sfntFormat(readHeader(file, 4));
+        if (!format) continue;
+        usedFiles.add(file);
+        faces.push({ style, format, bytes: stat.size, sha256: hashFile(file), path: file, mtimeMs: stat.mtimeMs });
+      }
+      return faces;
+    }
+    var MAX_SUBSET_SOURCE_BYTES = 64 * 1024 * 1024;
+    function locateFont(pattern, deps) {
+      const result = deps.run("fc-match", ["-f", "%{file}\n%{family}\n%{index}\n", pattern]);
+      if (result.status !== 0) return null;
+      const [file, families = "", index = "0"] = result.stdout.split("\n");
+      if (!file) return null;
+      return { file, families: families.split(",").map((name) => name.trim()).filter(Boolean), index: Number(index) || 0 };
+    }
+    function resolveSubsetSources(family, faces, deps = {}) {
+      const resolved = withDefaults(deps);
+      if (!family || GENERIC_FAMILIES.has(family.toLowerCase())) return [];
+      const wanted = family.toLowerCase();
+      const sources = [];
+      const add = (located, scope, name) => {
+        if (!located || /^\/System\//.test(located.file) || /\.app\/Contents\//.test(located.file)) return;
+        let stat;
+        try {
+          stat = fs.statSync(located.file);
+        } catch {
+          return;
+        }
+        if (!stat.isFile() || stat.size > MAX_SUBSET_SOURCE_BYTES) return;
+        const header = readHeader(located.file, 4);
+        if (!sfntFormat(header) && header?.toString("latin1") !== "ttcf") return;
+        const sha256 = crypto.createHash("sha256").update(`${located.file}\0${located.index}\0${stat.size}\0${stat.mtimeMs}`).digest("hex");
+        sources.push({
+          family: name,
+          style: "regular",
+          scope,
+          sha256,
+          path: located.file,
+          index: located.index,
+          bytes: stat.size,
+          mtimeMs: stat.mtimeMs
+        });
+      };
+      const self = locateFont(`${escapeFontconfig(family)}${FACE_PATTERNS.regular}`, resolved);
+      const selfInstalled = self && self.families.some((name) => name.toLowerCase() === wanted);
+      if (selfInstalled && !faces.some((face) => face.style === "regular")) add(self, "all", family);
+      const cjk = locateFont(`${escapeFontconfig(family)}:charset=4e00${FACE_PATTERNS.regular}`, resolved);
+      const coveredBySelf = cjk && cjk.families.some((name) => name.toLowerCase() === wanted);
+      if (cjk && !coveredBySelf && cjk.families[0]) add(cjk, "cjk", cjk.families[0]);
+      return sources;
+    }
+    function concreteFamily(family, deps) {
+      if (!GENERIC_FAMILIES.has(String(family).toLowerCase())) return family;
+      const result = deps.run("fc-match", ["-f", "%{family[0]}", family]);
+      const matched = result.status === 0 ? result.stdout.trim() : "";
+      return matched || null;
+    }
+    function readTerminalFont(source, deps = {}) {
+      const resolved = withDefaults(deps);
+      const reader = READERS[source];
+      if (!reader) return null;
+      let font;
+      try {
+        font = reader(resolved);
+      } catch {
+        return null;
+      }
+      if (!font?.family) return null;
+      const family = concreteFamily(font.family, resolved);
+      if (!family) return null;
+      return sanitizeDetected({ source, family, sizePx: font.sizePx });
+    }
+    function detectTerminalFont({ env = process.env, ancestry, lineage, deps = {} } = {}) {
+      const processes = lineage || (ancestry ? ancestry.map((name) => ({ pid: 0, name })) : processLineage({ run: deps.run }));
+      const source = identifyTerminal({ env, ancestry: processes.map((entry) => entry.name) });
+      if (!source) return null;
+      const emulator = terminalProcess(source, processes);
+      const terminalArgs = deps.terminalArgs || (emulator?.pid ? processArguments(emulator.pid) : []);
+      return readTerminalFont(source, { ...deps, env, terminalArgs });
+    }
+    function sanitizeDetected(value) {
+      const clean = sanitizeTerminalFont(value);
+      if (!clean) return null;
+      const detected = { source: clean.source || null, family: clean.family };
+      if (clean.sizePx) detected.sizePx = clean.sizePx;
+      return detected;
+    }
+    function describeTerminalFont(detected, deps = {}) {
+      if (!detected?.family) return null;
+      const faces = resolveFontFaces(detected.family, deps);
+      return { ...detected, faces, subsets: resolveSubsetSources(detected.family, faces, deps) };
+    }
+    function publicTerminalFont(record) {
+      return record ? sanitizeTerminalFont(record) : null;
+    }
+    function readFontChunk(record, sha256, index) {
+      const face = record?.faces?.find((candidate) => candidate.sha256 === sha256);
+      if (!face) return null;
+      const total = Math.ceil(face.bytes / TERMINAL_FONT_CHUNK_BYTES);
+      if (!Number.isInteger(index) || index < 0 || index >= total) return null;
+      let fd;
+      try {
+        const stat = fs.statSync(face.path);
+        if (stat.size !== face.bytes || stat.mtimeMs !== face.mtimeMs) return null;
+        fd = fs.openSync(face.path, "r");
+        const start = index * TERMINAL_FONT_CHUNK_BYTES;
+        const length = Math.min(TERMINAL_FONT_CHUNK_BYTES, face.bytes - start);
+        const buffer = Buffer.alloc(length);
+        const read = fs.readSync(fd, buffer, 0, length, start);
+        if (read !== length) return null;
+        return { data: buffer, total };
+      } catch {
+        return null;
+      } finally {
+        if (fd !== void 0) try {
+          fs.closeSync(fd);
+        } catch {
+        }
+      }
+    }
+    function fontFromEnvironment(env = process.env) {
+      const raw = env.HERDR_TERM_FONT_JSON;
+      if (!raw) return null;
+      try {
+        return sanitizeDetected(JSON.parse(raw));
+      } catch {
+        return null;
+      }
+    }
+    function rememberTerminalFont(detected) {
+      const clean = sanitizeDetected(detected);
+      if (!clean) return null;
+      try {
+        ensureDir(stateDir2());
+        const state = readJson(runtimeStatePath(), {});
+        const previous = state.terminalFont;
+        if (!previous || JSON.stringify(previous) !== JSON.stringify(clean)) {
+          writeJsonAtomic(runtimeStatePath(), { ...state, terminalFont: clean });
+        }
+      } catch {
+      }
+      return clean;
+    }
+    function rememberedTerminalFont() {
+      try {
+        return sanitizeDetected(readJson(runtimeStatePath(), {}).terminalFont);
+      } catch {
+        return null;
+      }
+    }
+    function captureTerminalFont({ env = process.env, detect = detectTerminalFont } = {}) {
+      if (env.HERDR_TERM_FONT_JSON) return fontFromEnvironment(env);
+      const detected = detect({ env });
+      if (!detected) return null;
+      env.HERDR_TERM_FONT_JSON = JSON.stringify(detected);
+      rememberTerminalFont(detected);
+      return detected;
+    }
+    function resolveHostFont({ env = process.env } = {}) {
+      return fontFromEnvironment(env) || rememberedTerminalFont();
+    }
+    function loadHostTerminalFont({ env = process.env, refresh = false, deps = {} } = {}) {
+      const known = resolveHostFont({ env });
+      let current = known?.source ? readTerminalFont(known.source, { ...deps, env }) : null;
+      if (!current && refresh && !known) current = detectTerminalFont({ env, deps });
+      if (current && JSON.stringify(current) !== JSON.stringify(known)) rememberTerminalFont(current);
+      return describeTerminalFont(current || known, deps);
+    }
+    module.exports = {
+      PX_PER_PT,
+      parsePangoFontDescription,
+      parseQtFontString,
+      parseFontconfigPattern,
+      parseGVariantString,
+      parseTomlSubset,
+      parseJsonc,
+      parseXFontName,
+      xResource,
+      firstCssFamily,
+      identifyTerminal,
+      processAncestry,
+      processLineage,
+      readTerminalFont,
+      detectTerminalFont,
+      resolveFontFaces,
+      resolveSubsetSources,
+      readSfntNames,
+      sfntFormat,
+      describeTerminalFont,
+      publicTerminalFont,
+      readFontChunk,
+      fontFromEnvironment,
+      rememberTerminalFont,
+      rememberedTerminalFont,
+      captureTerminalFont,
+      resolveHostFont,
+      loadHostTerminalFont
+    };
+  }
+});
+
 // src/socket-discovery.js
 var require_socket_discovery = __commonJS({
   "src/socket-discovery.js"(exports, module) {
@@ -1816,6 +3070,7 @@ var require_service = __commonJS({
       rememberTerminalPalette,
       rememberedTerminalPalette
     } = require_terminal_palette();
+    var { resolveHostFont } = require_terminal_font();
     var { resolveSocketPath } = require_socket_discovery();
     var { preferredLanAddress: preferredLanAddress2 } = require_net_interfaces();
     var { MIN_HERDR_VERSION: MIN_HERDR_VERSION2, findHerdrCommand, herdrVersion: herdrVersion2, resolveHerdrCommand } = require_herdr_command();
@@ -1872,6 +3127,9 @@ var require_service = __commonJS({
       cachedTerminalPalette = rememberedTerminalPalette();
       return cachedTerminalPalette;
     }
+    function hostTerminalFont() {
+      return resolveHostFont();
+    }
     function logPath(name) {
       return path.join(stateDir2(), `${name}.log`);
     }
@@ -1913,6 +3171,7 @@ var require_service = __commonJS({
         });
       }
       const terminalPalette = hostTerminalPalette();
+      const terminalFont = hostTerminalFont();
       specs.push({
         name: "host",
         command: process.execPath,
@@ -1921,6 +3180,7 @@ var require_service = __commonJS({
           // Captured here, where a terminal may still be attached, because the
           // connector itself usually runs detached with no terminal to ask.
           ...terminalPalette ? { HERDR_TERM_PALETTE_JSON: JSON.stringify(terminalPalette) } : {},
+          ...terminalFont ? { HERDR_TERM_FONT_JSON: JSON.stringify(terminalFont) } : {},
           RELAY_URL: resolveHostRelayUrl(config),
           RELAY_HOST_ID: state.hostId,
           RELAY_HOST_TOKEN: state.hostToken,
@@ -2198,6 +3458,7 @@ var require_service = __commonJS({
       serviceSpecs,
       baseEnvironment,
       hostTerminalPalette,
+      hostTerminalFont,
       startServices,
       stopServices,
       restartServices,
@@ -2625,7 +3886,7 @@ var require_lifecycle = __commonJS({
 import { render } from "ink";
 
 // tui/src/App.tsx
-import { useCallback as useCallback2, useEffect as useEffect6, useMemo as useMemo4, useRef as useRef3, useState as useState10 } from "react";
+import { useCallback as useCallback2, useEffect as useEffect7, useMemo as useMemo4, useRef as useRef3, useState as useState10 } from "react";
 import { Box as Box11, Text as Text11, useApp, useInput as useInput9 } from "ink";
 
 // tui/src/mouse/index.tsx
@@ -3819,14 +5080,16 @@ function HerdrScreen({ ctx }) {
 }
 
 // tui/src/screens/About.tsx
-import { useState as useState8 } from "react";
+import { useEffect as useEffect6, useState as useState8 } from "react";
 import { Box as Box9, Text as Text9, useInput as useInput7 } from "ink";
 import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var registryHost = (registry) => registry.replace(/^https?:\/\//, "");
 function About({ ctx }) {
   const { t, draft } = ctx;
   const [selected, setSelected] = useState8("auto");
   const [update, setUpdate] = useState8({ phase: "idle" });
-  const registryRef = useState8(() => ({ current: "" }))[0];
+  const [sourceNote, setSourceNote] = useState8(null);
+  const checkRef = useState8(() => ({ current: { registry: "", sources: [] } }))[0];
   const detected = detectLocale({ preference: "auto" });
   const languageOptions = [
     { id: "auto", label: t("about.languageAuto", { detected }) },
@@ -3843,36 +5106,57 @@ function About({ ctx }) {
       case "available":
         return t("update.available", { version: update.latest });
       case "updating":
-        return t("update.updating", { version: update.latest });
+        return update.attempt > 1 ? t("update.updatingRetry", { version: update.latest, attempt: update.attempt }) : t("update.updating", { version: update.latest });
       case "done":
         return t("update.done", { version: update.latest });
       case "error":
-        return t(update.messageKey);
+        return t(update.messageKey, update.params);
       default:
         return t("update.check");
     }
   })();
   const options = [...languageOptions, { id: "update", label: updateLabel }];
+  const applyCheck = (result) => {
+    checkRef.current = { registry: result.registry ?? "", sources: result.sources ?? [] };
+    const behind = result.behind ?? [];
+    setSourceNote(result.updateAvailable && behind.length > 0 && result.registry ? t("update.mirrorBehind", {
+      registries: behind.map((entry) => `${registryHost(entry.registry)} ${entry.version ?? ""}`.trim()).join(", "),
+      source: registryHost(result.registry)
+    }) : null);
+    setUpdate(result.updateAvailable ? { phase: "available", latest: result.latest } : { phase: "current", latest: result.latest });
+  };
+  useEffect6(() => {
+    if (ctx.updateCheck?.ok && update.phase === "idle") applyCheck(ctx.updateCheck);
+  }, [ctx.updateCheck]);
   const runCheck = async () => {
     setUpdate({ phase: "checking" });
+    setSourceNote(null);
     const result = await (0, import_updater.checkForUpdate)();
     if (!result.ok) {
       setUpdate({ phase: "error", messageKey: result.errorKey ?? "update.errorNetwork" });
       if (result.message) ctx.notify(t("update.errorNetworkDetail", { message: result.message }), "error");
       return;
     }
-    registryRef.current = result.registry ?? "";
-    setUpdate(result.updateAvailable ? { phase: "available", latest: result.latest } : { phase: "current", latest: result.latest });
+    ctx.setUpdateCheck(result);
+    applyCheck(result);
   };
   const runUpdate = async (latest) => {
-    setUpdate({ phase: "updating", latest });
-    const result = await (0, import_updater.performUpdate)({ registry: registryRef.current });
+    setUpdate({ phase: "updating", latest, attempt: 1 });
+    const result = await (0, import_updater.performUpdate)({
+      registry: checkRef.current.registry,
+      sources: checkRef.current.sources,
+      version: latest,
+      onAttempt: ({ attempt }) => setUpdate({ phase: "updating", latest, attempt })
+    });
     if (!result.ok) {
-      setUpdate({ phase: "error", messageKey: result.errorKey ?? "update.errorFailed" });
-      ctx.notify(t("update.errorFailed"), "error");
+      const params = { version: latest, installed: result.installed ?? "" };
+      setUpdate({ phase: "error", messageKey: result.errorKey ?? "update.errorFailed", params });
+      ctx.notify(result.summary ? t("update.errorFailedDetail", { message: result.summary }) : t(result.errorKey ?? "update.errorFailed", params), "error");
       return;
     }
     setUpdate({ phase: "done", latest });
+    setSourceNote(null);
+    ctx.setUpdateCheck(null);
     ctx.notify(t("update.restartHint"), "success");
   };
   const activateUpdate = () => {
@@ -3931,19 +5215,22 @@ function About({ ctx }) {
       option.id
     )) }),
     /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: t("update.title") }),
-    /* @__PURE__ */ jsx10(Box9, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx10(
-      Selectable,
-      {
-        selected: selected === "update",
-        onSelect: () => {
-          setSelected("update");
-          activateUpdate();
-        },
-        onHover: () => setSelected("update"),
-        children: updateLabel
-      }
-    ) }),
-    /* @__PURE__ */ jsx10(Row, { label: t("about.version"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: "0.2.16" }) }),
+    /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", marginTop: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx10(
+        Selectable,
+        {
+          selected: selected === "update",
+          onSelect: () => {
+            setSelected("update");
+            activateUpdate();
+          },
+          onHover: () => setSelected("update"),
+          children: updateLabel
+        }
+      ),
+      sourceNote ? /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: `  ${sourceNote}` }) : null
+    ] }),
+    /* @__PURE__ */ jsx10(Row, { label: t("about.version"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: "0.2.18" }) }),
     /* @__PURE__ */ jsx10(Row, { label: t("about.configPath"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: (0, import_config.configPath)() }) }),
     /* @__PURE__ */ jsx10(Row, { label: t("about.statePath"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: (0, import_config.stateDir)() }) }),
     /* @__PURE__ */ jsx10(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: t("about.docs") }) }),
@@ -4260,7 +5547,11 @@ function Tab({ label, active, onSelect }) {
 function Footer({ hints }) {
   return /* @__PURE__ */ jsx12(Box11, { marginTop: 1, paddingX: 1, children: /* @__PURE__ */ jsx12(Text11, { color: theme.muted, children: hints.join("  \xB7  ") }) });
 }
-function App({ initialLanguage, needsWizard }) {
+function App({
+  initialLanguage,
+  needsWizard,
+  updateChecker = (0, import_updater.updateChecksEnabled)() ? import_updater.checkForUpdate : null
+}) {
   const { exit } = useApp();
   const mouse = useMouse();
   const [config, setConfig] = useState10(() => (0, import_config.loadConfig)());
@@ -4272,6 +5563,18 @@ function App({ initialLanguage, needsWizard }) {
   const [busy, setBusy] = useState10(false);
   const [editingId, setEditingId] = useState10(null);
   const [wizardDone, setWizardDone] = useState10(!needsWizard);
+  const [updateCheck, setUpdateCheck] = useState10(null);
+  useEffect7(() => {
+    if (!updateChecker) return void 0;
+    let cancelled = false;
+    updateChecker().then((result) => {
+      if (!cancelled && result?.ok) setUpdateCheck(result);
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [updateChecker]);
   const locale = useMemo4(
     () => detectLocale({ preference: initialLanguage ?? draft.ui.language }),
     [initialLanguage, draft.ui.language]
@@ -4298,7 +5601,7 @@ function App({ initialLanguage, needsWizard }) {
       refresh();
     });
   }, [notify, refresh]);
-  useEffect6(() => {
+  useEffect7(() => {
     if (!wizardDone) return void 0;
     refresh();
     const timer = setInterval(() => {
@@ -4307,7 +5610,7 @@ function App({ initialLanguage, needsWizard }) {
     return () => clearInterval(timer);
   }, [wizardDone, refresh, editingId]);
   const mouseChoice = useRef3(null);
-  useEffect6(() => {
+  useEffect7(() => {
     if (mouseChoice.current !== null) return;
     if (mouse.supported && !mouse.enabled) mouse.enable();
   }, [mouse.supported, mouse.enabled, mouse]);
@@ -4327,7 +5630,9 @@ function App({ initialLanguage, needsWizard }) {
     notify,
     run,
     refresh,
-    message
+    message,
+    updateCheck,
+    setUpdateCheck
   };
   useInput9((input, key) => {
     if (key.ctrl && input === "c") {
@@ -4387,9 +5692,12 @@ function App({ initialLanguage, needsWizard }) {
     t("hint.quit")
   ].filter(Boolean);
   return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
-    /* @__PURE__ */ jsxs11(Box11, { marginBottom: 1, children: [
-      /* @__PURE__ */ jsx12(Text11, { bold: true, children: t("app.name") }),
-      /* @__PURE__ */ jsx12(Text11, { color: theme.muted, children: `  ${t("app.tagline")}` })
+    /* @__PURE__ */ jsxs11(Box11, { marginBottom: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs11(Box11, { children: [
+        /* @__PURE__ */ jsx12(Text11, { bold: true, children: t("app.name") }),
+        /* @__PURE__ */ jsx12(Text11, { color: theme.muted, children: `  ${t("app.tagline")}` })
+      ] }),
+      updateCheck?.updateAvailable ? /* @__PURE__ */ jsx12(Text11, { color: theme.warn, children: t("update.banner", { latest: updateCheck.latest ?? "", current: updateCheck.current }) }) : null
     ] }),
     /* @__PURE__ */ jsx12(Box11, { marginBottom: 1, children: TABS.map((entry, entryIndex) => /* @__PURE__ */ jsx12(
       Tab,