@hardikg/mdview 0.6.2

package/bin/mdview.mjs

@@ -0,0 +1,1418 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import path11 from "path";
+import { fileURLToPath } from "url";
+import openBrowser from "open";
+
+// src/server/config.ts
+import { readFile } from "fs/promises";
+import os from "os";
+import path from "path";
+
+// src/shared/types.ts
+var PALETTES = ["classic", "paper", "nord", "solarized", "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);
+}
+async function readGlobalRaw(filePath) {
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Existing config at ${filePath} is not valid JSON \u2014 fix or remove it before editing via CLI.`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Existing config at ${filePath} is not a JSON object \u2014 fix or remove it before editing via CLI.`);
+  }
+  return parsed;
+}
+async function writeGlobalRaw(filePath, data) {
+  await mkdir(path2.dirname(filePath), { recursive: true });
+  const json = JSON.stringify(data, null, 2) + "\n";
+  await writeFile(filePath, json, "utf8");
+}
+function readIgnoreArray(cfg) {
+  const v = cfg.ignore;
+  if (!Array.isArray(v)) return [];
+  return v.filter((x) => typeof x === "string");
+}
+async function addIgnoreEntries(names, filePath = globalConfigPath()) {
+  for (const n of names) {
+    if (!isValidIgnoreEntry(n)) {
+      throw new Error(
+        `Invalid ignore entry: ${JSON.stringify(n)}
+  Must match /^[A-Za-z0-9_.\\-+]{1,64}$/ and not be '.' or '..'.`
+      );
+    }
+  }
+  const cfg = await readGlobalRaw(filePath);
+  const before = readIgnoreArray(cfg);
+  const merged = Array.from(/* @__PURE__ */ new Set([...before, ...names])).sort();
+  cfg.ignore = merged;
+  await writeGlobalRaw(filePath, cfg);
+  return { before, after: merged, path: filePath };
+}
+async function removeIgnoreEntries(names, filePath = globalConfigPath()) {
+  const cfg = await readGlobalRaw(filePath);
+  const before = readIgnoreArray(cfg);
+  const set = new Set(before);
+  for (const n of names) set.delete(n);
+  const after = Array.from(set).sort();
+  if (after.length === 0) {
+    delete cfg.ignore;
+  } else {
+    cfg.ignore = after;
+  }
+  await writeGlobalRaw(filePath, cfg);
+  return { before, after, path: filePath };
+}
+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"
+];
+
+// src/cli-config.ts
+function printConfigUsage() {
+  console.error(
+    `
+mdview config \u2014 read or edit the global config (${globalConfigPath()})
+
+Subcommands:
+  path                       Print the global config file path
+  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
+
+Examples:
+  mdview config path
+  mdview config ignore add deps _site
+  mdview config ignore list
+
+After editing the ignore list, restart any running mdview instance \u2014 the file
+watcher caches its skip set at startup.
+`.trim()
+  );
+}
+function printIgnoreUsage() {
+  console.error("Usage: mdview config ignore (list|add|rm) [names\u2026]");
+}
+async function runConfigSubcommand(argv) {
+  const [sub, ...rest] = argv;
+  if (!sub || sub === "-h" || sub === "--help") {
+    printConfigUsage();
+    return sub ? 0 : 2;
+  }
+  switch (sub) {
+    case "path":
+      console.log(globalConfigPath());
+      return 0;
+    case "ignore":
+      return runIgnoreSubcommand(rest);
+    default:
+      console.error(`Unknown subcommand: config ${sub}`);
+      printConfigUsage();
+      return 2;
+  }
+}
+async function runIgnoreSubcommand(argv) {
+  const [action, ...names] = argv;
+  if (!action) {
+    printIgnoreUsage();
+    return 2;
+  }
+  switch (action) {
+    case "list": {
+      const userList = await listUserIgnoreEntries();
+      console.log("Built-in (always skipped):");
+      for (const n of DEFAULT_IGNORED_DIRS) console.log(`  ${n}`);
+      console.log("Dotfiles / dotdirs are always skipped too (.git, .next, .venv, \u2026).");
+      console.log("");
+      console.log(`User (${globalConfigPath()}):`);
+      if (userList.length === 0) {
+        console.log("  (none \u2014 run `mdview config ignore add <name>` to add one)");
+      } else {
+        for (const n of userList) console.log(`  ${n}`);
+      }
+      return 0;
+    }
+    case "add": {
+      if (names.length === 0) {
+        console.error("mdview config ignore add: expected at least one name");
+        return 2;
+      }
+      try {
+        const result = await addIgnoreEntries(names);
+        const added = result.after.filter((n) => !result.before.includes(n));
+        if (added.length === 0) {
+          console.log("Nothing changed \u2014 all entries were already in the list.");
+        } else {
+          console.log(`Added to ${result.path}: ${added.join(", ")}`);
+          console.log("Restart mdview for the watcher to pick up the change.");
+        }
+        return 0;
+      } catch (err) {
+        console.error(err.message);
+        return 2;
+      }
+    }
+    case "rm":
+    case "remove": {
+      if (names.length === 0) {
+        console.error("mdview config ignore rm: expected at least one name");
+        return 2;
+      }
+      try {
+        const result = await removeIgnoreEntries(names);
+        const removed = result.before.filter((n) => !result.after.includes(n));
+        if (removed.length === 0) {
+          console.log("Nothing changed \u2014 none of those names were in the list.");
+        } else {
+          console.log(`Removed from ${result.path}: ${removed.join(", ")}`);
+          console.log("Restart mdview for the watcher to pick up the change.");
+        }
+        return 0;
+      } catch (err) {
+        console.error(err.message);
+        return 2;
+      }
+    }
+    default:
+      printIgnoreUsage();
+      return 2;
+  }
+}
+
+// src/server/index.ts
+import path10 from "path";
+import chokidar2 from "chokidar";
+import Fastify from "fastify";
+
+// src/server/fs/ignore.ts
+import path3 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 = path3.relative(root, abs);
+  if (rel === "" || rel.startsWith("..")) return false;
+  for (const seg of rel.split(path3.sep)) {
+    if (!seg) continue;
+    if (seg.startsWith(".")) return true;
+    if (set.has(seg)) return true;
+  }
+  return false;
+}
+
+// src/server/routes/api-asset.ts
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
+import path5 from "path";
+
+// src/server/fs/resolve.ts
+import path4 from "path";
+function resolveSafePath(root, relPath) {
+  if (path4.isAbsolute(relPath)) {
+    throw new Error(`Refusing absolute path: ${relPath}`);
+  }
+  const absRoot = path4.resolve(root);
+  const candidate = path4.resolve(absRoot, relPath);
+  const rel = path4.relative(absRoot, candidate);
+  if (rel.startsWith("..") || path4.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, rootAbsPath) {
+  app.get("/__asset/*", async (req, reply) => {
+    const rel = (req.params["*"] ?? "").replace(/^\/+/, "");
+    let abs;
+    try {
+      abs = resolveSafePath(rootAbsPath, 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 = path5.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 matter from "gray-matter";
+function parseFrontmatter(raw) {
+  if (!raw.startsWith("---")) {
+    return { data: null, body: raw };
+  }
+  try {
+    const parsed = matter(raw);
+    return {
+      data: parsed.data ?? null,
+      body: parsed.content.replace(/^\n+/, "")
+    };
+  } catch {
+    return { data: null, body: raw };
+  }
+}
+
+// src/render/links.ts
+import path6 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 = path6.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 = path6.normalize(path6.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 = path6.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 = path6.normalize(path6.join(currentDir, trimmed));
+    if (resolved.startsWith("..")) return full;
+    return `<img ${pre}src="/__asset/${resolved}"${post}>`;
+  });
+}
+
+// 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 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 mathPlugin(md2) {
+  md2.core.ruler.after("inline", "mdview-math", (state) => {
+    convertBlockMath(state.tokens);
+    convertInlineMath(state.tokens);
+  });
+}
+
+// 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_THEME_MAP = {
+  "classic-light": "github-light",
+  "classic-dark": "github-dark",
+  "paper-light": "min-light",
+  "paper-dark": "vitesse-dark",
+  "nord-light": "min-light",
+  "nord-dark": "nord",
+  "solarized-light": "solarized-light",
+  "solarized-dark": "solarized-dark",
+  "high-contrast-light": "github-light-high-contrast",
+  "high-contrast-dark": "github-dark-high-contrast"
+};
+var UNDERLYING_THEMES = Array.from(
+  new Set(Object.values(PALETTE_THEME_MAP))
+);
+var highlighterPromise = null;
+function getHighlighter() {
+  if (!highlighterPromise) {
+    highlighterPromise = createHighlighter({
+      themes: UNDERLYING_THEMES,
+      langs: COMMON_LANGUAGES
+    });
+  }
+  return highlighterPromise;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+async function highlightCode(code, lang) {
+  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_THEME_MAP,
+      defaultColor: false
+    });
+  } catch {
+    return `<pre class="shiki shiki-fallback"><code>${escapeHtml(code)}</code></pre>`;
+  }
+}
+
+// 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) {
+  const tokens = md.parse(source, {});
+  for (const token of tokens) {
+    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);
+        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, rootAbsPath, rootInfo) {
+  app.get("/api/file", async (req, reply) => {
+    const requested = req.query.path?.trim() ?? "";
+    let relPath;
+    if (rootInfo.rootKind === "file") {
+      if (requested && requested !== rootInfo.rootRelPath) {
+        return reply.code(404).send({ error: "File not found in single-file mode" });
+      }
+      relPath = rootInfo.rootRelPath;
+    } else {
+      if (!requested) {
+        return reply.code(400).send({ error: "Missing ?path" });
+      }
+      relPath = requested;
+    }
+    if (!/\.(md|markdown|mdx)$/i.test(relPath)) {
+      return reply.code(400).send({ error: "Only markdown files are supported" });
+    }
+    let absPath;
+    try {
+      absPath = resolveSafePath(rootAbsPath, relPath);
+    } 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 } = parseFrontmatter(raw);
+    const { html: rawHtml, tokens } = await renderMarkdown(body);
+    const html = rewriteImageSrc(tagInternalLinks(rawHtml, relPath), relPath);
+    const outline = extractOutline(tokens);
+    const title = (typeof data?.title === "string" ? data.title : null) ?? outline[0]?.text ?? null;
+    const result = {
+      relPath,
+      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) {
+    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 };
+    }
+  };
+}
+
+// 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 path7 from "path";
+async function walkFolder(root, opts = {}) {
+  const ignore = opts.ignore ?? DEFAULT_IGNORED_DIRS2;
+  return walkInner(root, "", ignore);
+}
+async function walkInner(root, relBase, ignore) {
+  const absDir = path7.join(root, relBase);
+  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(root, childRel, ignore);
+      out.push({
+        name: entry.name,
+        relPath: childRel,
+        type: "dir",
+        children
+      });
+    } else if (entry.isFile()) {
+      const ext = path7.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);
+  return {
+    snippet: prefix + sliced + suffix,
+    highlight: [hlStart, hlEnd]
+  };
+}
+async function grepFiles(rootAbsPath, 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 tree = await walkFolder(rootAbsPath, { ignore: opts.ignore });
+  const files = flattenMdRelPaths(tree);
+  const results = [];
+  let totalHits = 0;
+  let truncated = false;
+  for (const relPath of files) {
+    if (totalHits >= globalCap) {
+      truncated = true;
+      break;
+    }
+    let absPath;
+    try {
+      absPath = resolveSafePath(rootAbsPath, 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, 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, rootAbsPath, rootInfo, configState) {
+  app.get("/api/search", async (req, reply) => {
+    if (rootInfo.rootKind === "file") {
+      return reply.send({ query: req.query.q ?? "", results: [], truncated: false });
+    }
+    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 out = await grepFiles(rootAbsPath, q, {
+      caseSensitive: isTrue(req.query.case),
+      wholeWord: isTrue(req.query.word),
+      regex: isTrue(req.query.regex),
+      ignore: configState.ignoreSet
+    });
+    return reply.send(out);
+  });
+}
+
+// src/server/routes/api-tree.ts
+import path8 from "path";
+function registerApiTree(app, rootAbsPath, rootInfo, configState) {
+  app.get("/api/tree", async (_req, reply) => {
+    const config = configState.current;
+    if (rootInfo.rootKind === "file") {
+      const single = [
+        {
+          name: path8.basename(rootInfo.rootRelPath),
+          relPath: rootInfo.rootRelPath,
+          type: "file",
+          isMarkdown: true
+        }
+      ];
+      return reply.send({ root: rootInfo, tree: single, config });
+    }
+    const tree = await walkFolder(rootAbsPath, { ignore: configState.ignoreSet });
+    return reply.send({ root: rootInfo, tree, config });
+  });
+}
+
+// src/server/routes/sse.ts
+function registerSse(app, watcher) {
+  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;
+    const cleanup = () => {
+      if (closed) return;
+      closed = true;
+      clearInterval(heartbeat);
+      watcher.off("event", send);
+      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);
+    watcher.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 path9 from "path";
+import chokidar from "chokidar";
+function createWatcher(rootAbsPath, opts = {}) {
+  const emitter = new EventEmitter();
+  emitter.setMaxListeners(0);
+  const ignore = opts.ignore ?? DEFAULT_IGNORED_DIRS2;
+  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)}`);
+    }
+  });
+  function emit(kind, abs) {
+    const rel = path9.relative(rootAbsPath, abs).split(path9.sep).join("/");
+    if (!rel) return;
+    emitter.emit("event", { kind, relPath: rel });
+  }
+  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
+var CSP_HTML = [
+  "default-src 'self'",
+  "script-src 'self'",
+  // KaTeX + mermaid inject inline styles into rendered output; the rest of
+  // the policy is strict.
+  "style-src 'self' 'unsafe-inline'",
+  "img-src 'self' data: blob:",
+  "font-src 'self' data:",
+  "connect-src 'self'",
+  "frame-ancestors 'none'",
+  "base-uri 'none'",
+  "form-action 'none'"
+].join("; ");
+async function createServer(opts) {
+  const app = Fastify({ logger: false });
+  app.addHook("onSend", async (_req, reply, payload) => {
+    const ct = String(reply.getHeader("content-type") ?? "");
+    if (ct.startsWith("text/html")) {
+      reply.header("content-security-policy", CSP_HTML);
+      reply.header("x-content-type-options", "nosniff");
+      reply.header("referrer-policy", "no-referrer");
+    }
+    return payload;
+  });
+  const initialConfig = await loadEffectiveConfig(opts.rootAbsPath);
+  const ignoreSet = buildIgnoreSet(initialConfig?.ignore ?? []);
+  const configState = { current: initialConfig, ignoreSet };
+  const watcher = createWatcher(opts.rootAbsPath, { ignore: ignoreSet });
+  const configPath = path10.join(opts.rootAbsPath, CONFIG_FILENAME);
+  const configWatcher = chokidar2.watch(configPath, {
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 60, pollInterval: 30 }
+  });
+  const reloadConfig = async () => {
+    configState.current = await loadEffectiveConfig(opts.rootAbsPath);
+    const event = { kind: "config", relPath: CONFIG_FILENAME };
+    watcher.emitSynthetic?.(event);
+  };
+  configWatcher.on("add", () => void reloadConfig());
+  configWatcher.on("change", () => void reloadConfig());
+  configWatcher.on("unlink", () => void reloadConfig());
+  registerApiFile(app, opts.rootAbsPath, opts.rootInfo);
+  registerApiTree(app, opts.rootAbsPath, opts.rootInfo, configState);
+  registerApiAsset(app, opts.rootAbsPath);
+  registerApiSearch(app, opts.rootAbsPath, opts.rootInfo, configState);
+  registerSse(app, watcher);
+  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 watcher.close();
+    await configWatcher.close();
+  });
+  return app;
+}
+
+// src/cli.ts
+function printUsage() {
+  console.error(`
+mdview \u2014 local markdown viewer
+
+Usage:
+  mdview [path]            View file or folder (default: cwd)
+  mdview config <\u2026>        Read or edit the global config (run 'mdview config -h')
+
+Options:
+  --port <n>               Port to listen on (default: 7331; auto-fallback)
+  --no-open                Don't auto-launch the browser
+  --version, -v            Print version and exit
+  --help, -h               Show this help
+
+Examples:
+  mdview ./docs                          Browse a folder
+  mdview README.md                       View a single file
+  mdview --port 9000                     Use a specific port
+  mdview config ignore add deps _site    Hide extra build dirs globally
+  mdview config path                     Print global config path
+`.trim());
+}
+function readVersion() {
+  const here = path11.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path11.resolve(here, "../package.json"),
+    path11.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";
+}
+function parseArgs(argv) {
+  const args = { target: ".", port: 7331, portExplicit: false, open: true };
+  let targetSet = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") return { kind: "help" };
+    if (a === "-v" || a === "--version") return { kind: "version" };
+    if (a === "--no-open") {
+      args.open = false;
+      continue;
+    }
+    if (a === "--port") {
+      const v = argv[++i];
+      if (!v) throw new Error("--port requires a number");
+      args.port = Number(v);
+      if (!Number.isInteger(args.port) || args.port <= 0) throw new Error("Invalid --port");
+      args.portExplicit = true;
+      continue;
+    }
+    if (a.startsWith("-")) throw new Error(`Unknown flag: ${a}`);
+    if (targetSet) throw new Error(`Unexpected argument: ${a}`);
+    args.target = a;
+    targetSet = true;
+  }
+  return { kind: "run", args };
+}
+function detectRoot(target) {
+  const abs = path11.resolve(target);
+  if (!existsSync(abs)) throw new Error(`Path does not exist: ${abs}`);
+  const st = statSync(abs);
+  if (st.isDirectory()) {
+    return {
+      rootAbsPath: abs,
+      rootInfo: { rootKind: "dir", rootRelPath: "", rootName: path11.basename(abs) }
+    };
+  }
+  if (st.isFile()) {
+    return {
+      rootAbsPath: path11.dirname(abs),
+      rootInfo: {
+        rootKind: "file",
+        rootRelPath: path11.basename(abs),
+        rootName: path11.basename(abs)
+      }
+    };
+  }
+  throw new Error(`Unsupported path type: ${abs}`);
+}
+function portFinderHint(port) {
+  switch (process.platform) {
+    case "darwin":
+      return `lsof -nP -iTCP:${port} -sTCP:LISTEN`;
+    case "linux":
+      return `ss -ltnp 'sport = :${port}'  (or: lsof -nP -iTCP:${port} -sTCP:LISTEN)`;
+    case "win32":
+      return `netstat -ano | findstr :${port}  (then: tasklist /FI "PID eq <pid>")`;
+    default:
+      return `lsof -nP -iTCP:${port} -sTCP:LISTEN`;
+  }
+}
+async function listen(app, port, explicit) {
+  if (explicit) {
+    try {
+      await app.listen({ host: "127.0.0.1", port });
+      return port;
+    } catch (err) {
+      if (err.code === "EADDRINUSE") {
+        throw new Error(
+          `Port ${port} is already in use.
+Try a different port (e.g. --port ${port + 1}) or stop whatever is bound to ${port}.
+Find the process with: ${portFinderHint(port)}`
+        );
+      }
+      throw err;
+    }
+  }
+  for (let attempt = 0; attempt < 10; attempt++) {
+    const tryPort = port + attempt;
+    try {
+      await app.listen({ host: "127.0.0.1", port: tryPort });
+      if (attempt > 0) {
+        console.log(`port ${port} in use, using ${tryPort} instead`);
+      }
+      return tryPort;
+    } catch (err) {
+      if (err.code !== "EADDRINUSE") throw err;
+    }
+  }
+  throw new Error("Could not bind a port (tried 10 in a row).");
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "config") {
+    const code = await runConfigSubcommand(argv.slice(1));
+    process.exit(code);
+  }
+  let parsed;
+  try {
+    parsed = parseArgs(argv);
+  } catch (err) {
+    console.error(err.message);
+    printUsage();
+    process.exit(2);
+  }
+  if (parsed.kind === "help") {
+    printUsage();
+    process.exit(0);
+  }
+  if (parsed.kind === "version") {
+    console.log(readVersion());
+    process.exit(0);
+  }
+  const args = parsed.args;
+  const { rootAbsPath, rootInfo } = detectRoot(args.target);
+  const here = path11.dirname(fileURLToPath(import.meta.url));
+  const clientDirCandidates = [
+    path11.resolve(here, "../dist/client"),
+    path11.resolve(here, "../../dist/client")
+  ];
+  const clientDir = clientDirCandidates.find(existsSync);
+  if (!clientDir) {
+    console.error("Client bundle not found. Run `npm run build:client` first.");
+    process.exit(1);
+  }
+  const app = await createServer({ rootAbsPath, rootInfo, clientDir });
+  const boundPort = await listen(app, args.port, args.portExplicit);
+  const url = rootInfo.rootKind === "file" ? `http://127.0.0.1:${boundPort}/?file=${encodeURIComponent(rootInfo.rootRelPath)}` : `http://127.0.0.1:${boundPort}/`;
+  console.log(`mdview \u2192 ${url}`);
+  console.log(`watching: ${rootAbsPath}`);
+  if (args.open) await openBrowser(url);
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) {
+      process.exit(130);
+    }
+    shuttingDown = true;
+    console.log("mdview: shutting down...");
+    const timeout = new Promise((resolve) => setTimeout(resolve, 1500));
+    try {
+      await Promise.race([app.close().catch(() => void 0), timeout]);
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  if (process.platform !== "win32") process.on("SIGHUP", shutdown);
+}
+function formatError(err) {
+  if (!(err instanceof Error)) return null;
+  const errno = err;
+  if (errno.code === "ENOENT") {
+    return { message: `mdview: path not found${errno.path ? `: ${errno.path}` : ""}`, code: 1 };
+  }
+  if (errno.code === "EACCES") {
+    return { message: `mdview: permission denied${errno.path ? `: ${errno.path}` : ""}`, code: 1 };
+  }
+  const msg = err.message;
+  if (msg.startsWith("Port ")) return { message: msg, code: 1 };
+  if (msg.startsWith("Client bundle not found")) return { message: `mdview: ${msg}`, code: 1 };
+  if (msg.startsWith("Path does not exist") || msg.startsWith("Unsupported path type") || msg.startsWith("Could not bind a port") || msg.startsWith("Unexpected argument")) {
+    return { message: `mdview: ${msg}`, code: 1 };
+  }
+  return null;
+}
+main().catch((err) => {
+  const known = formatError(err);
+  if (known) {
+    console.error(known.message);
+    process.exit(known.code);
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`mdview: unexpected error: ${message}`);
+  if (process.env.MDVIEW_DEBUG === "1" && err instanceof Error && err.stack) {
+    console.error(err.stack);
+  } else {
+    console.error("(set MDVIEW_DEBUG=1 for full stack)");
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=mdview.mjs.map