@hardikg/mdview 0.10.0 → 0.11.0

package/bin/mdview.mjs

@@ -1,159 +1,32 @@
 #!/usr/bin/env node
+import {
+  DEFAULT_IGNORED_DIRS,
+  deriveRootId,
+  globalConfigPath,
+  isValidRootId,
+  loadGlobalConfig
+} from "./chunk-WWM6JNAS.mjs";
+import {
+  PALETTES
+} from "./chunk-XFRQFZZ4.mjs";
 
 // src/cli.ts
 import dns from "dns/promises";
-import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync, statSync as statSync4 } from "fs";
-import path14 from "path";
-import { fileURLToPath } from "url";
-import chokidar3 from "chokidar";
-import openBrowser from "open";
+import { existsSync as existsSync2, realpathSync as realpathSync2, statSync as statSync5 } from "fs";
+import path6 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
-// src/server/config.ts
-import { readFile } from "fs/promises";
-import os from "os";
+// src/server/config-write.ts
+import { chmod, mkdir, readFile, writeFile } from "fs/promises";
 import path from "path";
-
-// src/shared/types.ts
-var DEFAULT_PALETTE = "flexoki";
-var PALETTES = [
-  "flexoki",
-  "paper",
-  "solarized",
-  "everforest",
-  "rose-pine",
-  "kanagawa",
-  "catppuccin",
-  "high-contrast"
-];
-
-// src/server/config.ts
-var CONFIG_FILENAME = ".mdview.json";
-var GLOBAL_CONFIG_FILENAME = "config.json";
-var FONT_FAMILIES = ["serif", "sans", "mono"];
 var IGNORE_ENTRY_PATTERN = /^[A-Za-z0-9_.\-+]{1,64}$/;
-function isObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function globalConfigPath() {
-  const xdg = process.env.XDG_CONFIG_HOME;
-  const base = xdg && xdg.length > 0 ? xdg : path.join(os.homedir(), ".config");
-  return path.join(base, "mdview", GLOBAL_CONFIG_FILENAME);
-}
-function validateConfig(raw, source = CONFIG_FILENAME) {
-  if (!isObject(raw)) return null;
-  const out = {};
-  if ("palette" in raw) {
-    const p = raw.palette;
-    if (typeof p === "string" && PALETTES.includes(p)) {
-      out.palette = p;
-    } else {
-      console.warn(`[mdview] ${source}: ignoring invalid palette: ${String(p)}`);
-    }
-  }
-  if ("fontFamily" in raw) {
-    const f = raw.fontFamily;
-    if (typeof f === "string" && FONT_FAMILIES.includes(f)) {
-      out.fontFamily = f;
-    } else {
-      console.warn(`[mdview] ${source}: ignoring invalid fontFamily: ${String(f)}`);
-    }
-  }
-  if ("lineWidth" in raw) {
-    const w = raw.lineWidth;
-    if (typeof w === "string" && w.length > 0 && w.length <= 32 && /^[\w%.-]+$/.test(w)) {
-      out.lineWidth = w;
-    } else {
-      console.warn(`[mdview] ${source}: ignoring invalid lineWidth: ${String(w)}`);
-    }
-  }
-  if ("defaultCollapsed" in raw && isObject(raw.defaultCollapsed)) {
-    const dc = raw.defaultCollapsed;
-    const collapsed = {};
-    if (typeof dc.tree === "boolean") collapsed.tree = dc.tree;
-    if (typeof dc.outline === "boolean") collapsed.outline = dc.outline;
-    if (collapsed.tree !== void 0 || collapsed.outline !== void 0) {
-      out.defaultCollapsed = collapsed;
-    }
-  }
-  if ("ignore" in raw) {
-    const ig = raw.ignore;
-    if (Array.isArray(ig)) {
-      const cleaned = [];
-      for (const entry of ig) {
-        if (typeof entry === "string" && entry !== "." && entry !== ".." && IGNORE_ENTRY_PATTERN.test(entry)) {
-          cleaned.push(entry);
-        } else {
-          console.warn(`[mdview] ${source}: ignoring invalid ignore entry: ${String(entry)}`);
-        }
-      }
-      if (cleaned.length > 0) out.ignore = cleaned;
-    } else {
-      console.warn(`[mdview] ${source}: ignoring invalid ignore (expected array of strings)`);
-    }
-  }
-  return out;
-}
-async function loadConfigFromPath(filePath, source) {
-  let raw;
-  try {
-    raw = await readFile(filePath, "utf8");
-  } catch (err) {
-    if (err.code === "ENOENT") return null;
-    console.warn(`[mdview] failed to read ${source}: ${err.message}`);
-    return null;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    console.warn(`[mdview] ${source} is not valid JSON: ${err.message}`);
-    return null;
-  }
-  return validateConfig(parsed, source);
-}
-async function loadProjectConfig(rootAbsPath) {
-  return loadConfigFromPath(path.join(rootAbsPath, CONFIG_FILENAME), CONFIG_FILENAME);
-}
-async function loadGlobalConfig() {
-  return loadConfigFromPath(globalConfigPath(), `~/.config/mdview/${GLOBAL_CONFIG_FILENAME}`);
-}
-function mergeConfigs(global, project) {
-  if (!global && !project) return null;
-  const out = {};
-  if (global?.palette !== void 0) out.palette = global.palette;
-  if (project?.palette !== void 0) out.palette = project.palette;
-  if (global?.fontFamily !== void 0) out.fontFamily = global.fontFamily;
-  if (project?.fontFamily !== void 0) out.fontFamily = project.fontFamily;
-  if (global?.lineWidth !== void 0) out.lineWidth = global.lineWidth;
-  if (project?.lineWidth !== void 0) out.lineWidth = project.lineWidth;
-  if (global?.defaultCollapsed || project?.defaultCollapsed) {
-    out.defaultCollapsed = { ...global?.defaultCollapsed, ...project?.defaultCollapsed };
-  }
-  const ig = [...global?.ignore ?? [], ...project?.ignore ?? []];
-  if (ig.length > 0) {
-    out.ignore = Array.from(new Set(ig));
-  }
-  return out;
-}
-async function loadEffectiveConfig(rootAbsPath) {
-  const [global, project] = await Promise.all([
-    loadGlobalConfig(),
-    loadProjectConfig(rootAbsPath)
-  ]);
-  return mergeConfigs(global, project);
-}
-
-// src/server/config-write.ts
-import { mkdir, readFile as readFile2, writeFile } from "fs/promises";
-import path2 from "path";
-var IGNORE_ENTRY_PATTERN2 = /^[A-Za-z0-9_.\-+]{1,64}$/;
 function isValidIgnoreEntry(s) {
-  return s !== "." && s !== ".." && IGNORE_ENTRY_PATTERN2.test(s);
+  return s !== "." && s !== ".." && IGNORE_ENTRY_PATTERN.test(s);
 }
 async function readGlobalRaw(filePath) {
   let raw;
   try {
-    raw = await readFile2(filePath, "utf8");
+    raw = await readFile(filePath, "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return {};
     throw err;
@@ -170,9 +43,12 @@ async function readGlobalRaw(filePath) {
   return parsed;
 }
 async function writeGlobalRaw(filePath, data) {
-  await mkdir(path2.dirname(filePath), { recursive: true });
+  const dir = path.dirname(filePath);
+  await mkdir(dir, { recursive: true, mode: 448 });
+  await chmod(dir, 448);
   const json = JSON.stringify(data, null, 2) + "\n";
-  await writeFile(filePath, json, "utf8");
+  await writeFile(filePath, json, { encoding: "utf8", mode: 384 });
+  await chmod(filePath, 384);
 }
 function readIgnoreArray(cfg) {
   const v = cfg.ignore;
@@ -213,22 +89,18 @@ async function listUserIgnoreEntries(filePath = globalConfigPath()) {
   const cfg = await readGlobalRaw(filePath);
   return readIgnoreArray(cfg);
 }
-
-// src/shared/ignore.ts
-var DEFAULT_IGNORED_DIRS = [
-  "node_modules",
-  "dist",
-  "build",
-  "out",
-  "target",
-  "coverage",
-  "vendor",
-  "__pycache__",
-  "venv",
-  "Pods",
-  "DerivedData",
-  "_build"
-];
+async function readUpdateCheck(filePath = globalConfigPath()) {
+  const cfg = await readGlobalRaw(filePath);
+  return cfg.updateCheck === true;
+}
+async function setUpdateCheck(enabled, filePath = globalConfigPath()) {
+  const cfg = await readGlobalRaw(filePath);
+  const before = cfg.updateCheck === true;
+  if (enabled) cfg.updateCheck = true;
+  else delete cfg.updateCheck;
+  await writeGlobalRaw(filePath, cfg);
+  return { before, after: enabled, path: filePath };
+}
 
 // src/cli-config.ts
 function printConfigUsage() {
@@ -241,12 +113,18 @@ Subcommands:
   ignore list                Show the built-in skips plus user-added ones
   ignore add <name\u2026>         Append basename(s) to the ignore list
   ignore rm  <name\u2026>         Remove basename(s) from the ignore list
+  update-check [on|off]      Show, or turn on/off, the daily check for a newer release
 
 Examples:
   mdview config path
   mdview config ignore add deps _site
   mdview config ignore list
 
+The update check is off by default. When on, the background server asks
+registry.npmjs.org once a day for the latest version and sends nothing that
+identifies you. It only ever prints a one-line notice; 'mdview update' shows
+the install command.
+
 After editing the ignore list, restart any running mdview instance \u2014 the file
 watcher caches its skip set at startup.
 `.trim()
@@ -267,6 +145,8 @@ async function runConfigSubcommand(argv) {
       return 0;
     case "ignore":
       return runIgnoreSubcommand(rest);
+    case "update-check":
+      return runUpdateCheckSubcommand(rest);
     default:
       console.error(`Unknown subcommand: config ${sub}`);
       printConfigUsage();
@@ -340,31 +220,293 @@ async function runIgnoreSubcommand(argv) {
       return 2;
   }
 }
+async function runUpdateCheckSubcommand(argv) {
+  const [action, ...extra] = argv;
+  if (extra.length > 0 || action !== void 0 && action !== "on" && action !== "off") {
+    console.error("Usage: mdview config update-check [on|off]");
+    return 2;
+  }
+  try {
+    if (action === void 0) {
+      console.log(`update-check: ${await readUpdateCheck() ? "on" : "off"}`);
+      return 0;
+    }
+    const result = await setUpdateCheck(action === "on");
+    if (result.before === result.after) {
+      console.log(`update-check is already ${action}.`);
+    } else if (result.after) {
+      console.log(`update-check on (${result.path}).`);
+      console.log(
+        "The background server checks registry.npmjs.org about once a day; a running one notices this within an hour."
+      );
+    } else {
+      console.log(`update-check off (${result.path}).`);
+    }
+    return 0;
+  } catch (err) {
+    console.error(err.message);
+    return 2;
+  }
+}
+
+// src/cli-update.ts
+import { statSync } from "fs";
+import path3 from "path";
+
+// src/update/semver.ts
+var PRERELEASE_ID = "(?:0|[1-9]\\d*|\\d*[A-Za-z-][0-9A-Za-z-]*)";
+var SEMVER_PATTERN = new RegExp(
+  `^(0|[1-9]\\d{0,8})\\.(0|[1-9]\\d{0,8})\\.(0|[1-9]\\d{0,8})(?:-(${PRERELEASE_ID}(?:\\.${PRERELEASE_ID})*))?$`
+);
+var MAX_VERSION_LENGTH = 48;
+function parseVersion(v) {
+  if (typeof v !== "string" || v.length > MAX_VERSION_LENGTH) return null;
+  const m = SEMVER_PATTERN.exec(v);
+  if (!m) return null;
+  return {
+    core: [Number(m[1]), Number(m[2]), Number(m[3])],
+    pre: m[4] === void 0 ? [] : m[4].split(".")
+  };
+}
+function isValidVersion(v) {
+  return parseVersion(v) !== null;
+}
+var NUMERIC = /^\d+$/;
+function comparePreId(a, b) {
+  const an = NUMERIC.test(a);
+  const bn = NUMERIC.test(b);
+  if (an && bn) return a.length - b.length || (a < b ? -1 : a > b ? 1 : 0);
+  if (an) return -1;
+  if (bn) return 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareVersions(a, b) {
+  for (let i = 0; i < 3; i++) {
+    const d = a.core[i] - b.core[i];
+    if (d !== 0) return d;
+  }
+  if (a.pre.length === 0 && b.pre.length === 0) return 0;
+  if (a.pre.length === 0) return 1;
+  if (b.pre.length === 0) return -1;
+  const n = Math.min(a.pre.length, b.pre.length);
+  for (let i = 0; i < n; i++) {
+    const d = comparePreId(a.pre[i], b.pre[i]);
+    if (d !== 0) return d;
+  }
+  return a.pre.length - b.pre.length;
+}
+function isNewerVersion(candidate, current) {
+  const c = parseVersion(candidate);
+  const k = parseVersion(current);
+  return c !== null && k !== null && compareVersions(c, k) > 0;
+}
+
+// src/update/latest.ts
+var DIST_TAGS_URL = "https://registry.npmjs.org/-/package/@hardikg%2fmdview/dist-tags";
+var TIMEOUT_MS = 5e3;
+var MAX_BODY_BYTES = 64 * 1024;
+var UpdateCheckError = class extends Error {
+};
+async function readCapped(res, maxBytes, abort) {
+  const declared = Number(res.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    abort.abort();
+    throw new UpdateCheckError("the registry answer was too large");
+  }
+  if (!res.body) throw new UpdateCheckError("the registry answer was empty");
+  const reader = res.body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      abort.abort();
+      await reader.cancel().catch(() => void 0);
+      throw new UpdateCheckError("the registry answer was too large");
+    }
+    chunks.push(value);
+  }
+  return new TextDecoder().decode(Buffer.concat(chunks));
+}
+async function fetchLatestVersion(options = {}) {
+  const fetchFn = options.fetchFn ?? fetch;
+  const abort = new AbortController();
+  const timeout = AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS);
+  const signal = AbortSignal.any([abort.signal, timeout]);
+  let body;
+  try {
+    const res = await fetchFn(DIST_TAGS_URL, { redirect: "error", signal });
+    if (!res.ok) throw new UpdateCheckError(`the registry answered HTTP ${res.status}`);
+    body = await readCapped(res, options.maxBytes ?? MAX_BODY_BYTES, abort);
+  } catch (err) {
+    if (err instanceof UpdateCheckError) throw err;
+    if (timeout.aborted) throw new UpdateCheckError("the registry did not answer in time", { cause: err });
+    throw new UpdateCheckError("could not reach the registry", { cause: err });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    throw new UpdateCheckError("the registry answer was not valid JSON");
+  }
+  const latest = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed.latest : void 0;
+  if (!isValidVersion(latest)) {
+    throw new UpdateCheckError("the registry answer did not hold a valid version");
+  }
+  return latest;
+}
+
+// src/version.ts
+import { readFileSync } from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+function readVersion() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path2.resolve(here, "../package.json"),
+    path2.resolve(here, "../../package.json")
+  ];
+  for (const p of candidates) {
+    try {
+      const raw = readFileSync(p, "utf8");
+      const v = JSON.parse(raw).version;
+      if (typeof v === "string") return v;
+    } catch {
+    }
+  }
+  return "unknown";
+}
+
+// src/cli-update.ts
+var POSIX_SAFE = /^[A-Za-z0-9_@%+=:,./-]+$/;
+var WINDOWS_UNSAFE = /["%^&|<>!]/;
+function hasControlCharacter(s) {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 32 || c === 127) return true;
+  }
+  return false;
+}
+function isFileOnDisk(file) {
+  try {
+    return statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+function npmInstallCommand(version, env) {
+  const windows = env.platform === "win32";
+  const p = windows ? path3.win32 : path3.posix;
+  const npm = p.join(p.dirname(env.execPath), windows ? "npm.cmd" : "npm");
+  const args = `install -g @hardikg/mdview@${version}`;
+  if (!env.isFile(npm) || hasControlCharacter(npm)) return `npm ${args}`;
+  if (windows) {
+    if (WINDOWS_UNSAFE.test(npm)) return `npm ${args}`;
+    return /^[A-Za-z0-9_@+=:,.\\/-]+$/.test(npm) ? `${npm} ${args}` : `"${npm}" ${args}`;
+  }
+  const quoted = POSIX_SAFE.test(npm) ? npm : `'${npm.replace(/'/g, `'\\''`)}'`;
+  return `${quoted} ${args}`;
+}
+async function runUpdateCommand(deps = {}) {
+  const log = deps.log ?? ((line) => console.log(line));
+  const logError = deps.logError ?? ((line) => console.error(line));
+  const current = deps.currentVersion ?? readVersion();
+  const currentParsed = parseVersion(current);
+  if (!currentParsed) {
+    logError("mdview: could not read the version of this install, so it cannot compare.");
+    return 1;
+  }
+  let latest;
+  try {
+    latest = await fetchLatestVersion({
+      ...deps.fetchFn ? { fetchFn: deps.fetchFn } : {},
+      ...deps.timeoutMs === void 0 ? {} : { timeoutMs: deps.timeoutMs }
+    });
+  } catch (err) {
+    if (err instanceof UpdateCheckError) {
+      logError(`mdview: could not check for updates: ${err.message}.`);
+      if (process.env.MDVIEW_DEBUG === "1" && err.cause instanceof Error && err.cause.stack) {
+        logError(err.cause.stack);
+      }
+      return 1;
+    }
+    throw err;
+  }
+  const order = compareVersions(parseVersion(latest), currentParsed);
+  if (order > 0) {
+    const command = npmInstallCommand(latest, {
+      execPath: deps.install?.execPath ?? process.execPath,
+      platform: deps.install?.platform ?? process.platform,
+      isFile: deps.install?.isFile ?? isFileOnDisk
+    });
+    log(`mdview ${current} \u2192 ${latest} is available.`);
+    log("Install it with:");
+    log("");
+    log(`  ${command}`);
+    log("");
+    log("The background server restarts itself on the next `mdview` run.");
+  } else if (order === 0) {
+    log(`mdview ${current} is up to date.`);
+  } else {
+    log(`mdview ${current} is newer than the latest release (${latest}).`);
+  }
+  return 0;
+}
 
 // src/daemon/client.ts
 import { spawn } from "child_process";
-import { closeSync, openSync as openSync2, statSync as statSync2, truncateSync } from "fs";
+import { closeSync as closeSync2, statSync as statSync3, truncateSync } from "fs";
 
 // src/daemon/state.ts
-import { mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
-import path3 from "path";
+import {
+  chmodSync,
+  closeSync,
+  fchmodSync,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmSync,
+  statSync as statSync2,
+  writeFileSync
+} from "fs";
+import path4 from "path";
 function stateDir() {
-  return path3.dirname(globalConfigPath());
+  return path4.dirname(globalConfigPath());
 }
 function daemonStatePath() {
-  return path3.join(stateDir(), "daemon.json");
+  return path4.join(stateDir(), "daemon.json");
 }
 function workspaceFilePath() {
-  return path3.join(stateDir(), "workspace.json");
+  return path4.join(stateDir(), "workspace.json");
 }
 function daemonLogPath() {
-  return path3.join(stateDir(), "daemon.log");
+  return path4.join(stateDir(), "daemon.log");
 }
 function daemonLockPath() {
-  return path3.join(stateDir(), "daemon.lock");
+  return path4.join(stateDir(), "daemon.lock");
+}
+function updateCheckPath() {
+  return path4.join(stateDir(), "update-check.json");
+}
+function ensurePrivateDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  chmodSync(dir, 448);
+}
+function openPrivateAppend(file) {
+  const fd = openSync(file, "a", 384);
+  try {
+    fchmodSync(fd, 384);
+  } catch (err) {
+    closeSync(fd);
+    throw err;
+  }
+  return fd;
 }
 function writeJsonAtomic(file, value) {
-  mkdirSync(path3.dirname(file), { recursive: true, mode: 448 });
+  ensurePrivateDir(path4.dirname(file));
   const tmp = `${file}.${process.pid}.tmp`;
   writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
@@ -372,7 +514,7 @@ function writeJsonAtomic(file, value) {
 }
 function readJsonSafe(file) {
   try {
-    return JSON.parse(readFileSync(file, "utf8"));
+    return JSON.parse(readFileSync2(file, "utf8"));
   } catch {
     return null;
   }
@@ -395,18 +537,18 @@ function clearDaemonState() {
   rmSync(daemonStatePath(), { force: true });
 }
 function tryTakeSpawnLock(staleAfterMs = 1e4) {
-  mkdirSync(stateDir(), { recursive: true, mode: 448 });
+  ensurePrivateDir(stateDir());
   const file = daemonLockPath();
   try {
-    openSync(file, "wx");
+    closeSync(openSync(file, "wx", 384));
     return true;
   } catch (err) {
     if (err.code !== "EEXIST") throw err;
   }
   try {
-    if (Date.now() - statSync(file).mtimeMs < staleAfterMs) return false;
+    if (Date.now() - statSync2(file).mtimeMs < staleAfterMs) return false;
     rmSync(file, { force: true });
-    openSync(file, "wx");
+    closeSync(openSync(file, "wx", 384));
     return true;
   } catch {
     return false;
@@ -435,6 +577,8 @@ async function probeHealth(port) {
     return {
       pid: body.pid,
       startedAt: body.startedAt,
+      // Validated because it is printed to the terminal when it differs.
+      ...isValidVersion(body.version) ? { version: body.version } : {},
       roots: Array.isArray(body.roots) ? body.roots.filter((r) => typeof r === "string") : []
     };
   } catch {
@@ -451,12 +595,12 @@ async function findLiveDaemon() {
 }
 function spawnDaemon(cliEntry) {
   try {
-    if (statSync2(daemonLogPath()).size > LOG_TRUNCATE_BYTES) {
+    if (statSync3(daemonLogPath()).size > LOG_TRUNCATE_BYTES) {
       truncateSync(daemonLogPath(), 0);
     }
   } catch {
   }
-  const log = openSync2(daemonLogPath(), "a");
+  const log = openPrivateAppend(daemonLogPath());
   try {
     const child = spawn(process.execPath, [cliEntry, "--daemon"], {
       detached: true,
@@ -465,28 +609,47 @@ function spawnDaemon(cliEntry) {
       stdio: ["ignore", log, log]
     });
     child.unref();
-    return child;
   } finally {
-    closeSync(log);
+    closeSync2(log);
   }
 }
-async function ensureDaemon(cliEntry) {
+function runsOtherVersion(live, version) {
+  return isValidVersion(version) && live.health.version !== version;
+}
+function sameDaemon(a, b) {
+  return a.state.pid === b.state.pid && a.state.startedAt === b.state.startedAt;
+}
+async function ensureDaemon(cliEntry, options = {}) {
+  const version = options.version ?? readVersion();
+  const timeoutMs = options.startTimeoutMs ?? START_TIMEOUT_MS;
+  const spawnFn = options.spawnFn ?? spawnDaemon;
   const existing = await findLiveDaemon();
-  if (existing) return existing.state;
+  if (existing && !runsOtherVersion(existing, version)) return existing.state;
   if (!tryTakeSpawnLock()) {
-    const found = await waitFor(() => findLiveDaemon(), START_TIMEOUT_MS);
+    const found = await waitFor(async () => {
+      const live = await findLiveDaemon();
+      if (!live) return null;
+      if (!existing || !sameDaemon(live, existing)) return live;
+      return runsOtherVersion(live, version) ? null : live;
+    }, timeoutMs);
     if (found) return found.state;
+    const fallback = await findLiveDaemon();
+    if (fallback) return fallback.state;
     throw new Error("Timed out waiting for the mdview background server to start.");
   }
   try {
+    const current = await findLiveDaemon();
+    if (current && !runsOtherVersion(current, version)) return current.state;
+    if (current) await stopDaemon();
     clearDaemonState();
-    spawnDaemon(cliEntry);
-    const found = await waitFor(() => findLiveDaemon(), START_TIMEOUT_MS);
+    spawnFn(cliEntry);
+    const found = await waitFor(() => findLiveDaemon(), timeoutMs);
     if (!found) {
       throw new Error(
         `The mdview background server did not start. See ${daemonLogPath()} for why.`
       );
     }
+    if (current) options.onRestart?.(current.health.version ?? "unknown", version);
     return found.state;
   } finally {
     releaseSpawnLock();
@@ -532,51 +695,8 @@ async function stopDaemon() {
 }
 
 // src/daemon/workspace-file.ts
-import { existsSync, statSync as statSync3 } from "fs";
+import { existsSync, lstatSync, realpathSync, statSync as statSync4 } from "fs";
 import path5 from "path";
-
-// src/server/workspace.ts
-import path4 from "path";
-var ROOT_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/;
-function isValidRootId(id) {
-  return id !== "." && id !== ".." && ROOT_ID_PATTERN.test(id);
-}
-function deriveRootId(absPath, taken) {
-  const slug = path4.basename(absPath).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^[^a-z0-9]+/, "").replace(/[-.]+$/, "").slice(0, 64);
-  const stem = isValidRootId(slug) ? slug : "root";
-  if (!taken.has(stem)) return stem;
-  for (let n = 2; ; n++) {
-    const candidate = `${stem.slice(0, 60)}-${n}`;
-    if (!taken.has(candidate)) return candidate;
-  }
-}
-function resolveRootId(spec, taken) {
-  if (spec.id && isValidRootId(spec.id) && !taken.has(spec.id)) return spec.id;
-  return deriveRootId(spec.absPath, taken);
-}
-function describeRoot(spec, id) {
-  return {
-    id,
-    name: spec.name ?? path4.basename(spec.absPath),
-    kind: spec.kind,
-    filePath: spec.kind === "file" ? spec.filePath ?? "" : ""
-  };
-}
-function parseWorkspacePath(roots, wsPath) {
-  const primary = roots[0];
-  if (!primary) return null;
-  const trimmed = wsPath.replace(/^\/+/, "");
-  const slash = trimmed.indexOf("/");
-  const head = slash === -1 ? trimmed : trimmed.slice(0, slash);
-  const match = roots.find((r) => r.root.id === head);
-  if (!match) return { state: primary, rel: trimmed };
-  return { state: match, rel: slash === -1 ? "" : trimmed.slice(slash + 1) };
-}
-function toWorkspacePath(rootId, rel) {
-  return rel ? `${rootId}/${rel}` : rootId;
-}
-
-// src/daemon/workspace-file.ts
 var MAX_ROOTS = 8;
 function validateRecord(raw) {
   if (!raw || typeof raw !== "object") return null;
@@ -623,13 +743,19 @@ function toRootSpecs(record) {
 function resolveTarget(target) {
   const abs = path5.resolve(target);
   if (!existsSync(abs)) throw new Error(`Path does not exist: ${abs}`);
-  const st = statSync3(abs);
+  const st = statSync4(abs);
   if (st.isDirectory()) {
     return { absPath: abs, kind: "dir", filePath: "", name: path5.basename(abs) };
   }
   if (st.isFile()) {
-    const dir = path5.dirname(abs);
-    return { absPath: dir, kind: "file", filePath: path5.basename(abs), name: path5.basename(abs) };
+    const onDisk = realpathSync.native(abs);
+    const real = lstatSync(abs).isSymbolicLink() ? onDisk : path5.join(path5.dirname(abs), path5.basename(onDisk));
+    return {
+      absPath: path5.dirname(real),
+      kind: "file",
+      filePath: path5.basename(real),
+      name: path5.basename(abs)
+    };
   }
   throw new Error(`Unsupported path type: ${abs}`);
 }
@@ -718,6 +844,12 @@ Workspace is full (${MAX_ROOTS}). Remove one with \`mdview rm <name>\`.`);
   if (live) {
     console.log(`server:  http://mdview.localhost:${live.state.port}/  (pid ${live.state.pid})`);
     console.log(`logs:    ${daemonLogPath()}`);
+    const own = readVersion();
+    if (isValidVersion(own) && live.health.version !== own) {
+      console.log(
+        `note:    it runs ${live.health.version ?? "a version that reports none"}, this is ${own}; the next \`mdview <path>\` restarts it`
+      );
+    }
   } else {
     console.log("server:  not running \u2014 the next `mdview <path>` will start it");
   }
@@ -758,1086 +890,100 @@ async function runStopCommand() {
   }
 }
 
-// src/server/index.ts
-import path13 from "path";
-import chokidar2 from "chokidar";
-import Fastify from "fastify";
-
-// src/server/fs/ignore.ts
-import path6 from "path";
-var DEFAULT_IGNORED_DIRS2 = new Set(DEFAULT_IGNORED_DIRS);
-function buildIgnoreSet(extra = []) {
-  return /* @__PURE__ */ new Set([...DEFAULT_IGNORED_DIRS2, ...extra]);
-}
-function isDirIgnored(name, set) {
-  return name.startsWith(".") || set.has(name);
-}
-function isPathIgnored(abs, root, set) {
-  const rel = path6.relative(root, abs);
-  if (rel === "" || rel.startsWith("..")) return false;
-  for (const seg of rel.split(path6.sep)) {
-    if (!seg) continue;
-    if (seg.startsWith(".")) return true;
-    if (set.has(seg)) return true;
-  }
-  return false;
-}
-
-// src/server/hosts.ts
-var LOOPBACK_NAMES = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
-var MAX_HOST_LEN = 253;
-function hostOnly(value) {
-  const h = value.trim().toLowerCase();
-  if (h.startsWith("[")) {
-    const end = h.indexOf("]");
-    return end === -1 ? h : h.slice(0, end + 1);
-  }
-  if (h.indexOf(":") !== h.lastIndexOf(":")) return h;
-  const colon = h.indexOf(":");
-  return colon === -1 ? h : h.slice(0, colon);
-}
-function isAllowedHost(value) {
-  if (!value || value.length > MAX_HOST_LEN) return false;
-  if (!/^[\x21-\x7e]+$/.test(value)) return false;
-  const host = hostOnly(value);
-  return LOOPBACK_NAMES.has(host) || /^[a-z0-9][a-z0-9.-]*\.localhost$/.test(host);
-}
-
-// src/server/routes/api-asset.ts
-import { createReadStream } from "fs";
-import { stat } from "fs/promises";
-import path8 from "path";
-
-// src/server/fs/resolve.ts
-import path7 from "path";
-function resolveSafePath(root, relPath) {
-  if (path7.isAbsolute(relPath)) {
-    throw new Error(`Refusing absolute path: ${relPath}`);
-  }
-  const absRoot = path7.resolve(root);
-  const candidate = path7.resolve(absRoot, relPath);
-  const rel = path7.relative(absRoot, candidate);
-  if (rel.startsWith("..") || path7.isAbsolute(rel)) {
-    throw new Error(`Path resolves outside root: ${relPath}`);
-  }
-  return candidate;
-}
-
-// src/server/routes/api-asset.ts
-var MIME = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".svg": "image/svg+xml",
-  ".avif": "image/avif",
-  ".bmp": "image/bmp",
-  ".ico": "image/x-icon",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mov": "video/quicktime",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
-  ".pdf": "application/pdf",
-  ".txt": "text/plain; charset=utf-8"
-};
-function registerApiAsset(app, roots) {
-  app.get("/__asset/*", async (req, reply) => {
-    const wsPath = (req.params["*"] ?? "").replace(/^\/+/, "");
-    const resolved = parseWorkspacePath(roots, wsPath);
-    if (!resolved) {
-      return reply.code(404).send({ error: "Asset not found" });
-    }
-    let abs;
-    try {
-      abs = resolveSafePath(resolved.state.absPath, resolved.rel);
-    } catch (err) {
-      return reply.code(400).send({ error: err.message });
-    }
-    let st;
-    try {
-      st = await stat(abs);
-    } catch {
-      return reply.code(404).send({ error: "Asset not found" });
-    }
-    if (!st.isFile()) {
-      return reply.code(404).send({ error: "Not a file" });
-    }
-    const ext = path8.extname(abs).toLowerCase();
-    const mime = MIME[ext];
-    if (!mime) {
-      return reply.code(404).send({ error: "Asset type not allowed" });
-    }
-    reply.header("content-type", mime);
-    reply.header("content-length", st.size);
-    reply.header("cache-control", "no-cache");
-    return reply.send(createReadStream(abs));
-  });
-}
-
-// src/server/routes/api-file.ts
-import { readFile as readFile3, stat as stat2 } from "fs/promises";
-
-// src/render/frontmatter.ts
-import { load } from "js-yaml";
-var MAX_NODES = 1e4;
-function unparsed(raw) {
-  return { data: null, body: raw, bodyStartLine: 0 };
-}
-function parseFrontmatter(raw) {
-  const block = locateBlock(raw);
-  if (!block) return unparsed(raw);
-  let loaded;
-  try {
-    loaded = load(block.yaml);
-  } catch {
-    return unparsed(raw);
-  }
-  if (!withinBudget(loaded)) return unparsed(raw);
-  return {
-    // An empty or comment-only block loads as `undefined`; it is still a
-    // front matter block with no keys.
-    data: loaded === void 0 ? {} : isPlainObject(loaded) ? loaded : null,
-    // CRLF-safe strip so the body and the bodyStartLine offset stay aligned for
-    // both LF- and CRLF-authored sources.
-    body: block.body.replace(/^(?:\r?\n)+/, ""),
-    bodyStartLine: block.bodyStartLine
-  };
-}
-function locateBlock(raw) {
-  const parts = raw.split(/(\r?\n)/);
-  const lineAt = (i) => parts[i * 2];
-  const lineCount = Math.ceil(parts.length / 2);
-  if (lineAt(0) !== "---") return null;
-  let closingIdx = -1;
-  for (let i = 1; i < lineCount; i++) {
-    if (lineAt(i) === "---") {
-      closingIdx = i;
-      break;
-    }
-  }
-  if (closingIdx < 0) return null;
-  let bodyStartLine = closingIdx + 1;
-  while (bodyStartLine < lineCount && lineAt(bodyStartLine) === "") {
-    bodyStartLine++;
-  }
-  const yaml = [];
-  for (let i = 1; i < closingIdx; i++) yaml.push(lineAt(i) ?? "");
-  return {
-    yaml: yaml.join("\n"),
-    body: parts.slice((closingIdx + 1) * 2).join(""),
-    bodyStartLine
-  };
-}
-function withinBudget(root) {
-  const stack = [root];
-  let visited = 0;
-  while (stack.length > 0) {
-    const node = stack.pop();
-    if (++visited > MAX_NODES) return false;
-    if (Array.isArray(node)) {
-      for (const child of node) stack.push(child);
-    } else if (isPlainObject(node)) {
-      for (const child of Object.values(node)) stack.push(child);
-    }
-  }
-  return true;
-}
-function isPlainObject(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-
-// src/render/links.ts
-import path9 from "path/posix";
-var MD_EXT_RE = /\.(md|markdown|mdx)$/i;
-var HREF_RE = /<a\s+([^>]*?)href="([^"#?]*)(\?[^"#]*)?(#[^"]*)?"([^>]*)>/gi;
-var IMG_SRC_RE = /<img\s+([^>]*?)src="([^"]+)"([^>]*)>/gi;
-function tagInternalLinks(html, currentRelPath) {
-  const currentDir = path9.dirname(currentRelPath);
-  return html.replace(HREF_RE, (full, pre, target, query, hash, post) => {
-    if (!target || /^https?:\/\//i.test(target) || target.startsWith("mailto:")) {
-      return full;
-    }
-    if (!MD_EXT_RE.test(target)) return full;
-    const resolved = path9.normalize(path9.join(currentDir, target));
-    let decoded;
-    try {
-      decoded = decodeURIComponent(resolved);
-    } catch {
-      decoded = resolved;
-    }
-    const href = `?file=${encodeURIComponent(decoded)}${hash ?? ""}`;
-    const internal = `${decoded}${query ?? ""}${hash ?? ""}`;
-    return `<a ${pre}href="${href}" data-internal-link="${internal}"${post}>`;
-  });
-}
-function rewriteImageSrc(html, currentRelPath) {
-  const currentDir = path9.dirname(currentRelPath);
-  return html.replace(IMG_SRC_RE, (full, pre, src, post) => {
-    if (!src) return full;
-    if (/^(https?:\/\/|data:|\/__asset\/)/i.test(src)) return full;
-    const trimmed = src.replace(/^\/+/, "");
-    const resolved = path9.normalize(path9.join(currentDir, trimmed));
-    if (resolved.startsWith("..")) return full;
-    return `<img ${pre}src="/__asset/${resolved}"${post}>`;
-  });
+// src/update/cache.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function isTimestamp(v) {
+  return typeof v === "number" && Number.isInteger(v) && v > 0;
 }
-
-// src/render/markdown.ts
-import MarkdownIt from "markdown-it";
-import anchor from "markdown-it-anchor";
-import taskLists from "markdown-it-task-lists";
-
-// src/render/math.ts
-var BLOCK_RE = /^\$\$([\s\S]+?)\$\$$/;
-var INLINE_RE = /\$(?!\s)([^$\n]+?)(?<!\s)\$/g;
-function blockMathHtml(latex) {
-  const encoded = encodeURIComponent(latex.trim());
-  return `<div class="math-block" data-source="${encoded}"></div>
-`;
-}
-function inlineMathHtml(latex) {
-  const encoded = encodeURIComponent(latex);
-  return `<span class="math-inline" data-source="${encoded}"></span>`;
-}
-function convertBlockMath(tokens) {
-  for (let i = 0; i < tokens.length - 2; i++) {
-    if (tokens[i].type === "paragraph_open" && tokens[i + 1].type === "inline" && tokens[i + 2].type === "paragraph_close") {
-      const inline = tokens[i + 1];
-      const trimmed = inline.content.trim();
-      const m = trimmed.match(BLOCK_RE);
-      if (m) {
-        const replacement = new tokens[i].constructor(
-          "html_block",
-          "",
-          0
-        );
-        replacement.content = blockMathHtml(m[1]);
-        tokens.splice(i, 3, replacement);
-      }
-    }
+function readUpdateCache(file = updateCheckPath()) {
+  const raw = readJsonSafe(file);
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const r = raw;
+  if (!isTimestamp(r.checkedAt) || !isValidVersion(r.latest)) return null;
+  const cache = { checkedAt: r.checkedAt, latest: r.latest };
+  if (isValidVersion(r.notifiedFor) && isTimestamp(r.notifiedAt)) {
+    cache.notifiedFor = r.notifiedFor;
+    cache.notifiedAt = r.notifiedAt;
   }
+  return cache;
 }
-function convertInlineMath(tokens) {
-  const TokenCtor = tokens[0]?.constructor;
-  if (!TokenCtor) return;
-  for (const top of tokens) {
-    if (top.type !== "inline" || !top.children) continue;
-    const out = [];
-    for (const child of top.children) {
-      if (child.type !== "text") {
-        out.push(child);
-        continue;
-      }
-      const text = child.content;
-      INLINE_RE.lastIndex = 0;
-      let last = 0;
-      let m;
-      let found = false;
-      while ((m = INLINE_RE.exec(text)) !== null) {
-        found = true;
-        if (m.index > last) {
-          const t = new TokenCtor("text", "", 0);
-          t.content = text.slice(last, m.index);
-          out.push(t);
-        }
-        const mathTok = new TokenCtor("html_inline", "", 0);
-        mathTok.content = inlineMathHtml(m[1]);
-        out.push(mathTok);
-        last = m.index + m[0].length;
-      }
-      if (!found) {
-        out.push(child);
-      } else if (last < text.length) {
-        const t = new TokenCtor("text", "", 0);
-        t.content = text.slice(last);
-        out.push(t);
-      }
-    }
-    top.children = out;
+function recordCheck(latest, now, file = updateCheckPath()) {
+  const previous = readUpdateCache(file);
+  const next = { checkedAt: now, latest };
+  if (previous?.notifiedFor !== void 0 && previous.notifiedAt !== void 0) {
+    next.notifiedFor = previous.notifiedFor;
+    next.notifiedAt = previous.notifiedAt;
   }
+  writeJsonAtomic(file, next);
 }
-function mathPlugin(md2) {
-  md2.core.ruler.after("inline", "mdview-math", (state) => {
-    convertBlockMath(state.tokens);
-    convertInlineMath(state.tokens);
-  });
+function recordNotified(version, now, file = updateCheckPath()) {
+  const current = readUpdateCache(file);
+  if (!current) return;
+  writeJsonAtomic(file, { ...current, notifiedFor: version, notifiedAt: now });
 }
-
-// src/render/shiki.ts
-import { createHighlighter } from "shiki";
-var COMMON_LANGUAGES = [
-  "ts",
-  "tsx",
-  "js",
-  "jsx",
-  "python",
-  "go",
-  "rust",
-  "java",
-  "kotlin",
-  "css",
-  "scss",
-  "html",
-  "json",
-  "yaml",
-  "toml",
-  "bash",
-  "shell",
-  "sql",
-  "md",
-  "diff",
-  "dockerfile"
-];
-var PALETTE_THEMES = {
-  // Flexoki has no upstream TextMate theme. `min-light` and `vesper` are the
-  // closest bundled stand-ins: both are deliberately low-chroma, which is the
-  // one property of Flexoki that a louder theme would contradict.
-  flexoki: { light: "min-light", dark: "vesper" },
-  paper: { light: "min-light", dark: "vitesse-dark" },
-  solarized: { light: "solarized-light", dark: "solarized-dark" },
-  everforest: { light: "everforest-light", dark: "everforest-dark" },
-  "rose-pine": { light: "rose-pine-dawn", dark: "rose-pine" },
-  kanagawa: { light: "kanagawa-lotus", dark: "kanagawa-wave" },
-  catppuccin: { light: "catppuccin-latte", dark: "catppuccin-mocha" },
-  "high-contrast": { light: "github-light-high-contrast", dark: "github-dark-high-contrast" }
-};
-var UNDERLYING_THEMES = Array.from(
-  new Set(Object.values(PALETTE_THEMES).flatMap((t) => [t.light, t.dark]))
-);
-var highlighterPromise = null;
-function getHighlighter() {
-  if (!highlighterPromise) {
-    highlighterPromise = createHighlighter({
-      themes: UNDERLYING_THEMES,
-      langs: COMMON_LANGUAGES
-    });
-  }
-  return highlighterPromise;
+function isCheckDue(cache, now) {
+  if (!cache) return true;
+  return cache.checkedAt > now || now - cache.checkedAt >= DAY_MS;
 }
-function escapeHtml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-async function highlightCode(code, lang, palette = DEFAULT_PALETTE) {
-  const highlighter = await getHighlighter();
-  const loaded = highlighter.getLoadedLanguages();
-  let effectiveLang = lang;
-  if (lang && !loaded.includes(lang) && !["text", "plain", ""].includes(lang)) {
-    try {
-      await highlighter.loadLanguage(lang);
-    } catch {
-      effectiveLang = "text";
-    }
-  }
-  try {
-    return highlighter.codeToHtml(code, {
-      lang: effectiveLang || "text",
-      themes: PALETTE_THEMES[palette],
-      defaultColor: false
-    });
-  } catch {
-    return `<pre class="shiki shiki-fallback"><code>${escapeHtml(code)}</code></pre>`;
-  }
+function wasRecentlyNotified(cache, now) {
+  if (cache.notifiedFor !== cache.latest || cache.notifiedAt === void 0) return false;
+  return cache.notifiedAt <= now && now - cache.notifiedAt < DAY_MS;
 }
 
-// src/render/markdown.ts
-var md = new MarkdownIt({
-  html: true,
-  linkify: true,
-  typographer: false,
-  breaks: false,
-  highlight: () => ""
-});
-md.use(anchor, {
-  permalink: false,
-  slugify: (s) => s.toLowerCase().trim().replace(/[^\wÀ-ɏ\s-]/g, "").replace(/\s+/g, "-")
-});
-md.use(taskLists, { enabled: false, label: false });
-md.use(mathPlugin);
-async function renderMarkdown(source, bodyStartLine = 0, palette = DEFAULT_PALETTE) {
-  const tokens = md.parse(source, {});
-  for (const token of tokens) {
-    if (token.type === "heading_open" && token.map) {
-      token.attrSet("data-source-line", String(token.map[0] + bodyStartLine));
-    }
-    if (token.type === "fence") {
-      const lang = token.info.trim().split(/\s+/)[0] || "text";
-      if (lang === "mermaid") {
-        token.type = "html_block";
-        token.content = `<div class="mermaid-block" data-source="${encodeURIComponent(token.content)}"></div>
-`;
-      } else {
-        const highlighted = await highlightCode(token.content, lang, palette);
-        token.type = "html_block";
-        token.content = highlighted + "\n";
-      }
-    }
-  }
-  const html = md.renderer.render(tokens, md.options, {});
-  return { html, tokens };
-}
-
-// src/render/outline.ts
-function extractOutline(tokens) {
-  const flat = [];
-  for (let i = 0; i < tokens.length; i++) {
-    const t = tokens[i];
-    if (t.type !== "heading_open") continue;
-    const level = Number(t.tag.slice(1));
-    const inline = tokens[i + 1];
-    const id = (t.attrGet("id") ?? "").toString();
-    const text = inline?.content?.trim() ?? "";
-    if (!id || !text) continue;
-    flat.push({ id, text, level, children: [] });
-  }
-  return nest(flat);
-}
-function nest(flat) {
-  const root = [];
-  const stack = [];
-  for (const node of flat) {
-    while (stack.length && stack[stack.length - 1].level >= node.level) {
-      stack.pop();
-    }
-    if (stack.length === 0) {
-      root.push(node);
-    } else {
-      stack[stack.length - 1].children.push(node);
-    }
-    stack.push(node);
-  }
-  return root;
-}
-
-// src/server/routes/api-file.ts
-function registerApiFile(app, roots) {
-  app.get(
-    "/api/file",
-    async (req, reply) => {
-      const requested = req.query.path?.trim() ?? "";
-      const rawPalette = req.query.palette?.trim() ?? "";
-      const palette = PALETTES.includes(rawPalette) ? rawPalette : DEFAULT_PALETTE;
-      const primary = roots[0];
-      if (!primary) {
-        return reply.code(404).send({ error: "No folders are open" });
-      }
-      let wsPath = requested;
-      if (!wsPath) {
-        if (primary.root.kind !== "file") {
-          return reply.code(400).send({ error: "Missing ?path" });
-        }
-        wsPath = toWorkspacePath(primary.root.id, primary.root.filePath);
-      }
-      const resolved = parseWorkspacePath(roots, wsPath);
-      if (!resolved) {
-        return reply.code(404).send({ error: "File not found" });
-      }
-      const { state, rel } = resolved;
-      if (state.root.kind === "file" && rel !== state.root.filePath) {
-        return reply.code(404).send({ error: "File not found in single-file mode" });
-      }
-      if (!/\.(md|markdown|mdx)$/i.test(rel)) {
-        return reply.code(400).send({ error: "Only markdown files are supported" });
-      }
-      let absPath;
-      try {
-        absPath = resolveSafePath(state.absPath, rel);
-      } catch (err) {
-        return reply.code(400).send({ error: err.message });
-      }
-      let raw;
-      let mtimeMs;
-      try {
-        const [content, st] = await Promise.all([
-          readFile3(absPath, "utf8"),
-          stat2(absPath)
-        ]);
-        raw = content;
-        mtimeMs = st.mtimeMs;
-      } catch {
-        return reply.code(404).send({ error: "File not found" });
-      }
-      const { data, body, bodyStartLine } = parseFrontmatter(raw);
-      const { html: rawHtml, tokens } = await renderMarkdown(body, bodyStartLine, palette);
-      const wsRel = toWorkspacePath(state.root.id, rel);
-      const html = rewriteImageSrc(tagInternalLinks(rawHtml, wsRel), wsRel);
-      const outline = extractOutline(tokens);
-      const title = (typeof data?.title === "string" ? data.title : null) ?? outline[0]?.text ?? null;
-      const result = {
-        relPath: wsRel,
-        html,
-        outline,
-        frontmatter: data,
-        title,
-        lastModified: mtimeMs
-      };
-      return reply.send(result);
-    }
-  );
-}
-
-// src/server/fs/grep.ts
-import { readFile as readFile4 } from "fs/promises";
-
-// src/shared/search-pattern.ts
-function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function compilePattern(query, opts) {
-  if (!query) {
-    return {
-      test: () => null,
-      matchAll: () => [],
-      matchAllWithBudget: () => ({ matches: [], truncated: false }),
-      query,
-      valid: true
-    };
-  }
-  let re;
-  if (opts.regex) {
+// src/daemon/update-check.ts
+var POLL_MS = 60 * 60 * 1e3;
+function createUpdateChecker(deps) {
+  let running = false;
+  const tick = async () => {
+    if (running) return "busy";
+    running = true;
     try {
-      re = new RegExp(query, opts.caseSensitive ? "g" : "gi");
-    } catch {
-      return {
-        test: () => null,
-        matchAll: () => [],
-        matchAllWithBudget: () => ({ matches: [], truncated: false }),
-        query,
-        valid: false
-      };
-    }
-  } else {
-    let pat = escapeRegex(query);
-    if (opts.wholeWord) pat = `\\b${pat}\\b`;
-    re = new RegExp(pat, opts.caseSensitive ? "g" : "gi");
-  }
-  return {
-    query,
-    valid: true,
-    test(text) {
-      re.lastIndex = 0;
-      return re.exec(text);
-    },
-    matchAll(text) {
-      re.lastIndex = 0;
-      const out = [];
-      let m;
-      while ((m = re.exec(text)) !== null) {
-        if (m[0].length === 0) {
-          re.lastIndex++;
-          continue;
-        }
-        out.push({ index: m.index, length: m[0].length });
-      }
-      return out;
-    },
-    matchAllWithBudget(text, budgetMs) {
-      re.lastIndex = 0;
-      const matches = [];
-      const deadline = performance.now() + budgetMs;
-      let m;
-      while ((m = re.exec(text)) !== null) {
-        if (m[0].length === 0) {
-          re.lastIndex++;
-          continue;
-        }
-        matches.push({ index: m.index, length: m[0].length });
-        if (performance.now() > deadline) {
-          return { matches, truncated: true };
-        }
-      }
-      return { matches, truncated: false };
+      if (!await deps.isEnabled()) return "disabled";
+      const now = deps.now();
+      if (!isCheckDue(readUpdateCache(deps.cacheFile), now)) return "fresh";
+      const latest = await deps.fetchLatest();
+      recordCheck(latest, now, deps.cacheFile);
+      return "checked";
+    } catch (err) {
+      deps.log(
+        `update check failed: ${err instanceof UpdateCheckError ? err.message : "unexpected error"}`
+      );
+      return "failed";
+    } finally {
+      running = false;
     }
   };
-}
-
-// src/shared/tree-utils.ts
-var MD_EXT = /* @__PURE__ */ new Set([".md", ".markdown", ".mdx"]);
-function flattenMdRelPaths(nodes, out = []) {
-  for (const n of nodes) {
-    if (n.type === "file" && n.isMarkdown) out.push(n.relPath);
-    else if (n.type === "dir" && n.children) flattenMdRelPaths(n.children, out);
-  }
-  return out;
-}
-
-// src/server/fs/tree.ts
-import { readdir } from "fs/promises";
-import path10 from "path";
-async function walkFolder(root, opts = {}) {
-  const ignore = opts.ignore ?? DEFAULT_IGNORED_DIRS2;
-  return walkInner(root, opts.relBase ?? "", ignore);
-}
-async function walkInner(absDir, relBase, ignore) {
-  const entries = await readdir(absDir, { withFileTypes: true });
-  const out = [];
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (isDirIgnored(entry.name, ignore)) continue;
-    } else if (entry.name.startsWith(".")) {
-      continue;
-    }
-    const childRel = relBase ? `${relBase}/${entry.name}` : entry.name;
-    if (entry.isDirectory()) {
-      const children = await walkInner(path10.join(absDir, entry.name), childRel, ignore);
-      out.push({
-        name: entry.name,
-        relPath: childRel,
-        type: "dir",
-        children
-      });
-    } else if (entry.isFile()) {
-      const ext = path10.extname(entry.name).toLowerCase();
-      out.push({
-        name: entry.name,
-        relPath: childRel,
-        type: "file",
-        isMarkdown: MD_EXT.has(ext)
-      });
-    }
-  }
-  out.sort((a, b) => {
-    if (a.type !== b.type) return a.type === "dir" ? -1 : 1;
-    return a.name.localeCompare(b.name);
-  });
-  return out;
-}
-
-// src/server/fs/grep.ts
-function buildSnippet(line, start, end, radius) {
-  const from = Math.max(0, start - radius);
-  const to = Math.min(line.length, end + radius);
-  const prefix = from > 0 ? "\u2026" : "";
-  const suffix = to < line.length ? "\u2026" : "";
-  const sliced = line.slice(from, to);
-  const hlStart = prefix.length + (start - from);
-  const hlEnd = hlStart + (end - start);
+  let timer;
   return {
-    snippet: prefix + sliced + suffix,
-    highlight: [hlStart, hlEnd]
-  };
-}
-async function grepFiles(roots, query, opts = {}) {
-  const perFileCap = opts.perFileCap ?? 20;
-  const globalCap = opts.globalCap ?? 200;
-  const snippetRadius = opts.snippetRadius ?? 60;
-  const perLineBudgetMs = opts.perLineBudgetMs ?? 5;
-  const maxLineLenForRegex = opts.maxLineLenForRegex ?? 1e4;
-  const regexMode = opts.regex ?? false;
-  if (!query || query.length === 0) {
-    return { query, results: [], truncated: false };
-  }
-  const pattern = compilePattern(query, {
-    caseSensitive: opts.caseSensitive ?? false,
-    wholeWord: opts.wholeWord ?? false,
-    regex: opts.regex ?? false
-  });
-  if (!pattern.valid) return { query, results: [], truncated: false };
-  const results = [];
-  let totalHits = 0;
-  let truncated = false;
-  for (const root of roots) {
-    if (totalHits >= globalCap) {
-      truncated = true;
-      break;
-    }
-    const tree = await walkFolder(root.absPath, { ignore: root.ignore ?? opts.ignore });
-    const files = flattenMdRelPaths(tree);
-    for (const relPath of files) {
-      if (totalHits >= globalCap) {
-        truncated = true;
-        break;
-      }
-      let absPath;
-      try {
-        absPath = resolveSafePath(root.absPath, relPath);
-      } catch {
-        continue;
-      }
-      let raw;
-      try {
-        raw = await readFile4(absPath, "utf8");
-      } catch {
-        continue;
-      }
-      const { body } = parseFrontmatter(raw);
-      const lines = body.split(/\r?\n/);
-      const fileHits = [];
-      let fileTotal = 0;
-      let fileTruncated = false;
-      for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        if (regexMode && line.length > maxLineLenForRegex) {
-          fileTruncated = true;
-          continue;
-        }
-        const { matches, truncated: lineTruncated } = regexMode ? pattern.matchAllWithBudget(line, perLineBudgetMs) : { matches: pattern.matchAll(line), truncated: false };
-        if (lineTruncated) fileTruncated = true;
-        for (const m of matches) {
-          fileTotal++;
-          if (fileHits.length < perFileCap) {
-            const { snippet, highlight } = buildSnippet(
-              line,
-              m.index,
-              m.index + m.length,
-              snippetRadius
-            );
-            fileHits.push({ line: i + 1, col: m.index, snippet, highlight });
-            totalHits++;
-          } else {
-            fileTruncated = true;
-          }
-          if (totalHits >= globalCap) {
-            truncated = true;
-            break;
-          }
-        }
-        if (totalHits >= globalCap) break;
-      }
-      if (fileHits.length > 0) {
-        results.push({
-          relPath: `${root.id}/${relPath}`,
-          hits: fileHits,
-          total: fileTotal,
-          truncated: fileTruncated
-        });
-      }
-    }
-  }
-  return { query, results, truncated };
-}
-
-// src/server/routes/api-search.ts
-var MAX_QUERY_LEN = 200;
-function isTrue(v) {
-  return v === "1" || v === "true";
-}
-function registerApiSearch(app, roots) {
-  app.get("/api/search", async (req, reply) => {
-    const q = (req.query.q ?? "").trim();
-    if (q.length === 0) {
-      return reply.send({ query: "", results: [], truncated: false });
-    }
-    if (q.length > MAX_QUERY_LEN) {
-      return reply.code(400).send({ error: "Query too long" });
-    }
-    const searchable = roots.filter((r) => r.root.kind === "dir").map((r) => ({ absPath: r.absPath, id: r.root.id, ignore: r.ignoreSet }));
-    const out = await grepFiles(searchable, q, {
-      caseSensitive: isTrue(req.query.case),
-      wholeWord: isTrue(req.query.word),
-      regex: isTrue(req.query.regex)
-    });
-    return reply.send(out);
-  });
-}
-
-// src/server/routes/api-tree.ts
-import path11 from "path";
-function applyOverrides(config, paletteOverride) {
-  if (!paletteOverride) return config;
-  return { ...config ?? {}, palette: paletteOverride };
-}
-async function rootChildren(state) {
-  const { id, kind, filePath } = state.root;
-  if (kind === "file") {
-    return [
-      {
-        name: path11.basename(filePath),
-        relPath: toWorkspacePath(id, filePath),
-        type: "file",
-        isMarkdown: true
-      }
-    ];
-  }
-  return walkFolder(state.absPath, { ignore: state.ignoreSet, relBase: id });
-}
-function registerApiTree(app, roots, paletteOverride) {
-  app.get("/api/tree", async (_req, reply) => {
-    const config = applyOverrides(roots[0]?.config ?? null, paletteOverride);
-    if (roots.length === 1) {
-      const only = roots[0];
-      return reply.send({
-        roots: [only.root],
-        tree: await rootChildren(only),
-        config
-      });
-    }
-    const tree = [];
-    for (const state of roots) {
-      tree.push({
-        name: state.root.name,
-        relPath: state.root.id,
-        type: "dir",
-        children: await rootChildren(state)
-      });
-    }
-    return reply.send({ roots: roots.map((r) => r.root), tree, config });
-  });
-}
-
-// src/server/routes/health.ts
-function registerHealth(app, identity, roots) {
-  app.get(
-    "/api/health",
-    async (_req, reply) => reply.send({
-      ok: true,
-      pid: identity.pid,
-      startedAt: identity.startedAt,
-      roots: roots.map((r) => r.root.id)
-    })
-  );
-}
-
-// src/server/routes/sse.ts
-function registerSse(app, hub, hooks = {}) {
-  let clients = 0;
-  app.get("/api/watch", (req, reply) => {
-    reply.raw.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache, no-transform",
-      Connection: "keep-alive",
-      "X-Accel-Buffering": "no"
-    });
-    reply.raw.write(": connected\n\n");
-    let closed = false;
-    clients++;
-    hooks.onClientsChanged?.(clients);
-    const cleanup = () => {
-      if (closed) return;
-      closed = true;
-      clearInterval(heartbeat);
-      hub.off("event", send);
-      clients--;
-      hooks.onClientsChanged?.(clients);
-      try {
-        reply.raw.end();
-      } catch {
-      }
-    };
-    const send = (e) => {
-      if (closed) return;
-      try {
-        reply.raw.write(`event: ${e.kind}
-`);
-        reply.raw.write(`data: ${JSON.stringify(e)}
-
-`);
-      } catch {
-        cleanup();
-      }
-    };
-    const heartbeat = setInterval(() => {
-      if (closed) return;
-      try {
-        reply.raw.write(": hb\n\n");
-      } catch {
-        cleanup();
-      }
-    }, 15e3);
-    hub.on("event", send);
-    req.raw.on("close", cleanup);
-    req.raw.on("error", cleanup);
-    reply.raw.on("error", cleanup);
-    reply.raw.on("close", cleanup);
-  });
-}
-
-// src/server/watcher.ts
-import { EventEmitter } from "events";
-import path12 from "path";
-import chokidar from "chokidar";
-function createEventHub() {
-  const emitter = new EventEmitter();
-  emitter.setMaxListeners(0);
-  return {
-    on: (event, listener) => emitter.on(event, listener),
-    off: (event, listener) => emitter.off(event, listener),
-    emitSynthetic: (e) => emitter.emit("event", e),
-    close: async () => {
-      emitter.removeAllListeners();
-    }
-  };
-}
-function createWatcher(rootAbsPath, opts = {}) {
-  const emitter = new EventEmitter();
-  emitter.setMaxListeners(0);
-  const ignore = opts.ignore ?? DEFAULT_IGNORED_DIRS2;
-  const prefix = opts.prefix ?? "";
-  const watcher = chokidar.watch(rootAbsPath, {
-    ignoreInitial: true,
-    ignored: (p) => isPathIgnored(p, rootAbsPath, ignore),
-    persistent: true,
-    awaitWriteFinish: { stabilityThreshold: 60, pollInterval: 30 }
-  });
-  watcher.on("error", (err) => {
-    const e = err;
-    if (e?.code === "EMFILE" || e?.code === "ENOSPC") {
-      console.error(
-        `[mdview] file watcher hit ${e.code} while watching ${rootAbsPath}
-  Path: ${e.path ?? "(unknown)"}
-  Likely cause: a heavy directory (build output, deps) wasn't ignored.
-  Fix: add the directory name to "ignore" in ~/.config/mdview/config.json, e.g.
-    { "ignore": ["deps", "_site"] }
-  Built-in skips already cover ${[...DEFAULT_IGNORED_DIRS2].join(", ")}.`
-      );
-    } else {
-      console.error(`[mdview] watcher error: ${e?.message ?? String(err)}`);
+    tick,
+    start: () => {
+      if (timer) return;
+      void tick();
+      timer = setInterval(() => void tick(), deps.pollMs ?? POLL_MS);
+      timer.unref();
+    },
+    stop: () => {
+      if (timer) clearInterval(timer);
+      timer = void 0;
     }
-  });
-  function emit(kind, abs) {
-    const rel = path12.relative(rootAbsPath, abs).split(path12.sep).join("/");
-    if (!rel) return;
-    const relPath = prefix ? `${prefix}/${rel}` : rel;
-    emitter.emit("event", { kind, relPath });
-  }
-  watcher.on("change", (p) => emit("change", p));
-  watcher.on("add", (p) => emit("add", p));
-  watcher.on("unlink", (p) => emit("unlink", p));
-  return {
-    on: (event, listener) => emitter.on(event, listener),
-    off: (event, listener) => emitter.off(event, listener),
-    emitSynthetic: (e) => emitter.emit("event", e),
-    close: () => watcher.close()
   };
 }
 
-// src/server/index.ts
-function buildCspHtml(embedMode) {
-  const directives = [
-    "default-src 'self'",
-    "script-src 'self'",
-    // KaTeX and the diagram renderer set inline style attributes on their
-    // output; the rest of the policy is strict.
-    "style-src 'self' 'unsafe-inline'",
-    "img-src 'self' data:",
-    "font-src 'self' data:",
-    "connect-src 'self'",
-    "base-uri 'none'",
-    "form-action 'none'"
-  ];
-  if (!embedMode) directives.push("frame-ancestors 'none'");
-  return directives.join("; ");
-}
-async function createServer(opts) {
-  const app = Fastify({ logger: false });
-  const cspHtml = buildCspHtml(opts.embedMode ?? false);
-  app.addHook("onRequest", async (req, reply) => {
-    if (isAllowedHost(req.headers.host)) return;
-    return reply.code(403).type("text/plain; charset=utf-8").send("Forbidden");
-  });
-  app.addHook("onSend", async (_req, reply, payload) => {
-    const ct = String(reply.getHeader("content-type") ?? "");
-    if (ct.startsWith("text/html")) {
-      reply.header("content-security-policy", cspHtml);
-      reply.header("x-content-type-options", "nosniff");
-      reply.header("referrer-policy", "no-referrer");
-    }
-    return payload;
-  });
-  const roots = [];
-  const configWatchers = /* @__PURE__ */ new Map();
-  const hub = createEventHub();
-  async function openRoot(spec, id) {
-    const config = await loadEffectiveConfig(spec.absPath);
-    const ignoreSet = buildIgnoreSet(config?.ignore ?? []);
-    const state = {
-      root: describeRoot(spec, id),
-      absPath: spec.absPath,
-      ignoreSet,
-      config,
-      watcher: createWatcher(spec.absPath, { ignore: ignoreSet, prefix: id })
-    };
-    state.watcher.on("event", (e) => hub.emitSynthetic(e));
-    const configWatcher = chokidar2.watch(path13.join(spec.absPath, CONFIG_FILENAME), {
-      ignoreInitial: true,
-      persistent: true,
-      awaitWriteFinish: { stabilityThreshold: 60, pollInterval: 30 }
-    });
-    const reloadConfig = async () => {
-      state.config = await loadEffectiveConfig(spec.absPath);
-      const event = { kind: "config", relPath: `${id}/${CONFIG_FILENAME}` };
-      hub.emitSynthetic(event);
-    };
-    configWatcher.on("add", () => void reloadConfig());
-    configWatcher.on("change", () => void reloadConfig());
-    configWatcher.on("unlink", () => void reloadConfig());
-    configWatchers.set(id, configWatcher);
-    return state;
-  }
-  async function closeRoot(state) {
-    const cw = configWatchers.get(state.root.id);
-    configWatchers.delete(state.root.id);
-    await Promise.all([state.watcher.close(), cw?.close()]);
-  }
-  async function setRoots(specs) {
-    const taken = /* @__PURE__ */ new Set();
-    const wanted = specs.map((spec) => {
-      const id = resolveRootId(spec, taken);
-      taken.add(id);
-      return { id, spec };
-    });
-    const keep = new Map(
-      roots.filter((r) => wanted.some((w) => w.id === r.root.id && w.spec.absPath === r.absPath)).map((r) => [r.root.id, r])
+// src/update/notice.ts
+async function printUpdateNotice(deps) {
+  try {
+    if (!deps.interactive()) return;
+    if (!await deps.isEnabled()) return;
+    const cache = readUpdateCache(deps.cacheFile);
+    if (!cache || !isNewerVersion(cache.latest, deps.version)) return;
+    const now = deps.now();
+    if (wasRecentlyNotified(cache, now)) return;
+    deps.print(
+      `mdview ${cache.latest} is available \u2014 run \`mdview update\` for the install command.`
     );
-    const dropped = roots.filter((r) => !keep.has(r.root.id));
-    const next = [];
-    for (const { id, spec } of wanted) {
-      const existing = keep.get(id);
-      next.push(existing ?? await openRoot(spec, id));
-    }
-    roots.length = 0;
-    roots.push(...next);
-    await Promise.all(dropped.map(closeRoot));
-    hub.emitSynthetic({ kind: "workspace" });
-  }
-  {
-    const taken = /* @__PURE__ */ new Set();
-    for (const spec of opts.roots) {
-      const id = resolveRootId(spec, taken);
-      taken.add(id);
-      roots.push(await openRoot(spec, id));
-    }
+    recordNotified(cache.latest, now, deps.cacheFile);
+  } catch {
   }
-  registerApiFile(app, roots);
-  registerApiTree(app, roots, opts.paletteOverride);
-  registerApiAsset(app, roots);
-  registerApiSearch(app, roots);
-  registerSse(app, hub, { ...opts.onSseClientsChanged ? { onClientsChanged: opts.onSseClientsChanged } : {} });
-  if (opts.identity) registerHealth(app, opts.identity, roots);
-  await app.register(import("@fastify/static"), {
-    root: opts.clientDir,
-    prefix: "/"
-  });
-  app.setNotFoundHandler(async (req, reply) => {
-    if (req.url.startsWith("/api/") || req.url.startsWith("/__asset/")) {
-      reply.code(404).send({ error: "Not found" });
-      return;
-    }
-    const qIndex = req.url.indexOf("?");
-    const rawPath = qIndex >= 0 ? req.url.slice(0, qIndex) : req.url;
-    if (/[\r\n]/.test(rawPath)) {
-      reply.code(404).send({ error: "Not found" });
-      return;
-    }
-    if (/\.(md|markdown|mdx)$/i.test(rawPath)) {
-      const relPath = rawPath.replace(/^\/+/, "");
-      const location = `/?file=${encodeURIComponent(relPath)}`;
-      reply.code(302).header("Location", location).send();
-      return;
-    }
-    return reply.sendFile("index.html");
-  });
-  app.addHook("onClose", async () => {
-    await Promise.all([
-      ...roots.map((r) => r.watcher.close()),
-      ...[...configWatchers.values()].map((w) => w.close())
-    ]);
-    await hub.close();
-  });
-  return { app, setRoots };
 }
 
 // src/cli.ts
@@ -1850,6 +996,7 @@ Usage:
   mdview ls                List open folders and the background server
   mdview rm <name|path>\u2026   Stop serving a folder
   mdview stop              Stop the background server
+  mdview update            Check for a newer release and print the install command
   mdview config <\u2026>        Read or edit the global config (run 'mdview config -h')
 
 One background server serves every folder you open, so 'mdview .' in a second
@@ -1877,24 +1024,9 @@ Examples:
   mdview --port 9000 ./docs              One-off server on a specific port
   mdview config ignore add deps _site    Hide extra build dirs globally
   mdview config path                     Print global config path
+  mdview update                          Is there a newer mdview?
 `.trim());
 }
-function readVersion() {
-  const here = path14.dirname(fileURLToPath(import.meta.url));
-  const candidates = [
-    path14.resolve(here, "../package.json"),
-    path14.resolve(here, "../../package.json")
-  ];
-  for (const p of candidates) {
-    try {
-      const raw = readFileSync2(p, "utf8");
-      const v = JSON.parse(raw).version;
-      if (typeof v === "string") return v;
-    } catch {
-    }
-  }
-  return "unknown";
-}
 var DEFAULT_PORT = 7331;
 var FRIENDLY_HOST = "mdview.localhost";
 function isLoopbackAddress(addr) {
@@ -1975,24 +1107,38 @@ function parseArgs(argv, defaultPort = DEFAULT_PORT) {
   return { kind: "run", args };
 }
 function detectRoot(target) {
-  const abs = path14.resolve(target);
+  const abs = path6.resolve(target);
   if (!existsSync2(abs)) throw new Error(`Path does not exist: ${abs}`);
-  const st = statSync4(abs);
+  const st = statSync5(abs);
   if (st.isDirectory()) {
     return { absPath: abs, id: deriveRootId(abs, /* @__PURE__ */ new Set()), kind: "dir" };
   }
   if (st.isFile()) {
-    const dir = path14.dirname(abs);
+    const target2 = realpathSync2.native(abs);
+    const linked = path6.dirname(target2) !== realpathSync2.native(path6.dirname(abs));
+    const dir = linked ? path6.dirname(target2) : path6.dirname(abs);
     return {
       absPath: dir,
       id: deriveRootId(dir, /* @__PURE__ */ new Set()),
-      name: path14.basename(abs),
+      name: path6.basename(abs),
       kind: "file",
-      filePath: path14.basename(abs)
+      filePath: path6.basename(target2)
     };
   }
   throw new Error(`Unsupported path type: ${abs}`);
 }
+var EMBED_TOKEN_ENV = "MDVIEW_EMBED_TOKEN";
+var EMBED_TOKEN_PATTERN = /^[A-Za-z0-9_-]{32,256}$/;
+function takeEmbedToken() {
+  const token = process.env[EMBED_TOKEN_ENV];
+  delete process.env[EMBED_TOKEN_ENV];
+  if (token === void 0 || !EMBED_TOKEN_PATTERN.test(token)) {
+    throw new Error(
+      `Embed mode (--vscode) needs ${EMBED_TOKEN_ENV} set to a random base64url token of at least 32 characters. --vscode is meant to be started by the mdview VS Code extension; use --foreground to run a server yourself.`
+    );
+  }
+  return token;
+}
 function portFinderHint(port) {
   switch (process.platform) {
     case "darwin":
@@ -2038,10 +1184,10 @@ Find the process with: ${portFinderHint(port)}`
   throw new Error("Could not bind a port (tried 10 in a row).");
 }
 function requireClientDir() {
-  const here = path14.dirname(fileURLToPath(import.meta.url));
+  const here = path6.dirname(fileURLToPath2(import.meta.url));
   const candidates = [
-    path14.resolve(here, "../dist/client"),
-    path14.resolve(here, "../../dist/client")
+    path6.resolve(here, "../dist/client"),
+    path6.resolve(here, "../../dist/client")
   ];
   const dir = candidates.find(existsSync2);
   if (!dir) throw new Error("Client bundle not found. Run `npm run build:client` first.");
@@ -2054,14 +1200,29 @@ function idleTimeoutMs() {
   if (!Number.isFinite(n) || n < 0) return 0;
   return Math.round(n * 6e4);
 }
+function loadServer() {
+  return import("./server-KALIU7HM.mjs");
+}
+async function openBrowser(url) {
+  const { default: open } = await import("open");
+  await open(url);
+}
+var WARM_UP_DELAY_MS = 100;
+function warmHighlighterInBackground() {
+  setTimeout(() => {
+    void import("./shiki-5SFVA32N.mjs").then((m) => m.warmHighlighter()).catch(() => void 0);
+  }, WARM_UP_DELAY_MS).unref();
+}
 async function runForeground(args) {
+  const embedToken = args.embedMode ? takeEmbedToken() : void 0;
   const root = detectRoot(args.target);
   const clientDir = requireClientDir();
+  const { createServer } = await loadServer();
   const { app } = await createServer({
     roots: [root],
     clientDir,
     ...args.palette === void 0 ? {} : { paletteOverride: args.palette },
-    embedMode: args.embedMode
+    ...embedToken === void 0 ? {} : { embedToken }
   });
   const boundPort = await listen(app, args.port, args.portExplicit);
   const host = args.embedMode ? "127.0.0.1" : await resolveDisplayHost();
@@ -2071,8 +1232,11 @@ async function runForeground(args) {
 `);
   } else {
     console.log(`mdview \u2192 ${url}`);
-    console.log(`watching: ${root.absPath}`);
+    console.log(
+      `watching: ${root.kind === "file" ? path6.join(root.absPath, root.filePath ?? "") : root.absPath}`
+    );
   }
+  warmHighlighterInBackground();
   if (args.open) await openBrowser(url);
   let shuttingDown = false;
   const shutdown = async () => {
@@ -2105,10 +1269,11 @@ async function runDaemon(args) {
   const clientDir = requireClientDir();
   const startedAt = Date.now();
   let idleTimer;
+  const { createServer } = await loadServer();
   const server = await createServer({
     roots: toRootSpecs(readWorkspace()),
     clientDir,
-    identity: { pid: process.pid, startedAt },
+    identity: { pid: process.pid, startedAt, version: readVersion() },
     onSseClientsChanged: (count) => {
       if (count > 0) {
         if (idleTimer) clearTimeout(idleTimer);
@@ -2121,9 +1286,19 @@ async function runDaemon(args) {
   const boundPort = await listen(server.app, args.port, args.portExplicit);
   writeDaemonState({ pid: process.pid, port: boundPort, startedAt });
   console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] mdview daemon pid ${process.pid} on port ${boundPort}`);
-  const wsWatcher = chokidar3.watch(workspaceFilePath(), {
+  const updateChecker = createUpdateChecker({
+    isEnabled: async () => (await loadGlobalConfig())?.updateCheck === true,
+    fetchLatest: () => fetchLatestVersion(),
+    now: Date.now,
+    log: (message) => console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}`)
+  });
+  const { default: chokidar } = await import("chokidar");
+  const wsWatcher = chokidar.watch(workspaceFilePath(), {
     ignoreInitial: true,
     persistent: true,
+    // A workspace.json replaced by a link to a directory would otherwise be
+    // walked and watched recursively.
+    followSymlinks: false,
     awaitWriteFinish: { stabilityThreshold: 60, pollInterval: 30 }
   });
   const reload = () => {
@@ -2140,6 +1315,7 @@ async function runDaemon(args) {
     shuttingDown = true;
     console.log(`[${(/* @__PURE__ */ new Date()).toISOString()}] mdview daemon stopping (${why})`);
     clearDaemonState();
+    updateChecker.stop();
     const timeout = new Promise((resolve) => setTimeout(resolve, 1500));
     await Promise.race([
       Promise.all([server.app.close().catch(() => void 0), wsWatcher.close()]).then(
@@ -2159,16 +1335,29 @@ async function runDaemon(args) {
   process.on("SIGTERM", () => void shutdown("SIGTERM"));
   if (process.platform !== "win32") process.on("SIGHUP", () => void shutdown("SIGHUP"));
   armIdle();
+  warmHighlighterInBackground();
+  updateChecker.start();
 }
 async function runAttach(args) {
   const added = addRoot(args.target);
-  const state = await ensureDaemon(fileURLToPath(import.meta.url));
+  const state = await ensureDaemon(fileURLToPath2(import.meta.url), {
+    onRestart: (from, to) => console.error(`mdview: restarted the background server (${from} \u2192 ${to})`)
+  });
   await waitForRoot(state.port, added.root.id);
   const host = await resolveDisplayHost();
   const base = `http://${host}:${state.port}/`;
   const url = added.filePath ? `${base}?file=${encodeURIComponent(added.filePath)}` : `${base}?root=${encodeURIComponent(added.focusPath)}`;
   console.log(`mdview \u2192 ${url}`);
   console.log(`${added.changed ? "added" : "open"}: ${added.root.path} (${added.root.id})`);
+  await printUpdateNotice({
+    version: readVersion(),
+    now: Date.now,
+    interactive: () => Boolean(process.stdout.isTTY && process.stderr.isTTY),
+    // The raw key, not loadGlobalConfig: this short command must not start
+    // warning about unrelated fields in a config it never read before.
+    isEnabled: () => readUpdateCheck(),
+    print: (line) => console.error(line)
+  });
   if (args.open) await openBrowser(url);
 }
 async function main() {
@@ -2178,6 +1367,13 @@ async function main() {
   if (sub === "ls" || sub === "status") process.exit(await runListCommand());
   if (sub === "rm") process.exit(await runRemoveCommand(argv.slice(1)));
   if (sub === "stop") process.exit(await runStopCommand());
+  if (sub === "update") {
+    if (argv.length > 1) {
+      console.error("Usage: mdview update");
+      process.exit(2);
+    }
+    process.exit(await runUpdateCommand());
+  }
   let parsed;
   try {
     parsed = parseArgs(argv, envPort() ?? DEFAULT_PORT);
@@ -2216,6 +1412,7 @@ function formatError(err) {
     "Unsupported path type",
     "Could not bind a port",
     "Unexpected argument",
+    "Embed mode",
     "Workspace is full",
     "Timed out waiting for the mdview background server",
     "The mdview background server did not start"
@@ -2229,7 +1426,7 @@ var isEntryPoint = (() => {
   const argv1 = process.argv[1];
   if (!argv1) return false;
   try {
-    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(argv1);
+    return realpathSync2(fileURLToPath2(import.meta.url)) === realpathSync2(argv1);
   } catch {
     return false;
   }
@@ -2253,6 +1450,7 @@ if (isEntryPoint) {
 }
 export {
   DEFAULT_PORT,
+  detectRoot,
   idleTimeoutMs,
   parseArgs
 };