@peaske7/readit 0.3.0-rc.0 → 0.3.0-rc.2

package/dist/index.js

@@ -0,0 +1,2625 @@
+#!/usr/bin/env bun
+// @bun
+var __require = import.meta.require;
+
+// src/cli.ts
+import {
+  existsSync,
+  lstatSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync
+} from "fs";
+import * as fs2 from "fs/promises";
+import * as os3 from "os";
+import { join as join4, resolve as resolve3 } from "path";
+import { Command } from "commander";
+import open2 from "open";
+
+// src/lib/comment-storage.ts
+import * as crypto from "crypto";
+import * as os from "os";
+import * as path from "path";
+var FORMAT_VERSION = 1;
+var HASH_LENGTH = 16;
+var MAX_SELECTION_LENGTH = 1000;
+var TRUNCATION_MARKER = `
+...
+`;
+var ANCHOR_PREFIX_LENGTH = 200;
+function truncateSelection(text) {
+  if (text.length <= MAX_SELECTION_LENGTH) {
+    return text;
+  }
+  const half = Math.floor((MAX_SELECTION_LENGTH - TRUNCATION_MARKER.length) / 2);
+  return text.slice(0, half) + TRUNCATION_MARKER + text.slice(-half);
+}
+function getCommentPath(sourcePath) {
+  const absolute = path.resolve(sourcePath);
+  const normalized = absolute.replace(/^\//, "").replace(/^[A-Z]:[\\/]/, "");
+  const ext = path.extname(normalized);
+  const withoutExt = normalized.slice(0, -ext.length || undefined);
+  return path.join(os.homedir(), ".readit", "comments", `${withoutExt}.comments.md`);
+}
+function computeHash(content) {
+  return crypto.createHash("sha256").update(content).digest("hex").slice(0, HASH_LENGTH);
+}
+function getLineNumber(content, offset) {
+  if (offset <= 0 || content.length === 0)
+    return 1;
+  const clampedOffset = Math.min(offset, content.length);
+  return content.slice(0, clampedOffset).split(`
+`).length;
+}
+function getLineHint(content, startOffset, endOffset) {
+  const startLine = getLineNumber(content, startOffset);
+  const endLine = getLineNumber(content, endOffset);
+  return startLine === endLine ? `L${startLine}` : `L${startLine}-L${endLine}`;
+}
+function parseCommentFile(content) {
+  const result = {
+    source: "",
+    hash: "",
+    version: FORMAT_VERSION,
+    comments: []
+  };
+  if (!content.trim()) {
+    return result;
+  }
+  const frontMatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (frontMatterMatch) {
+    const frontMatter = frontMatterMatch[1];
+    const sourceMatch = frontMatter.match(/^source:\s*(.+)$/m);
+    const hashMatch = frontMatter.match(/^hash:\s*(.+)$/m);
+    const versionMatch = frontMatter.match(/^version:\s*(\d+)$/m);
+    if (sourceMatch)
+      result.source = sourceMatch[1].trim();
+    if (hashMatch)
+      result.hash = hashMatch[1].trim();
+    if (versionMatch)
+      result.version = Number.parseInt(versionMatch[1], 10);
+    if (result.version > FORMAT_VERSION) {
+      throw new Error(`Comment file requires readit v${result.version} or higher. ` + `Current version supports format v${FORMAT_VERSION}.`);
+    }
+  }
+  const bodyContent = content.replace(/^---\n[\s\S]*?\n---\n*/, "");
+  const markerRe = /<!--\s*c:[^|]+\|[^|>\s]+(?:\|[^>]*)?\s*-->/g;
+  const markerStarts = [];
+  for (const m of bodyContent.matchAll(markerRe)) {
+    if (m.index !== undefined)
+      markerStarts.push(m.index);
+  }
+  for (let i = 0;i < markerStarts.length; i++) {
+    const start = markerStarts[i];
+    const end = i + 1 < markerStarts.length ? markerStarts[i + 1] : bodyContent.length;
+    const block = bodyContent.slice(start, end).replace(/\n+---\s*$/, "").trim();
+    if (!block)
+      continue;
+    const comment = parseCommentBlock(block);
+    if (comment) {
+      result.comments.push(comment);
+    }
+  }
+  return result;
+}
+function parseCommentBlock(block) {
+  const metadataMatch = block.match(/<!--\s*c:([^|]+)\|([^|>\s]+)(?:\|([^>]*))?\s*-->/);
+  if (!metadataMatch) {
+    return;
+  }
+  const [, id, lineHint, createdAtRaw] = metadataMatch;
+  const createdAt = createdAtRaw?.trim() || undefined;
+  const anchorMatch = block.match(/<!--\s*anchor:(.+?)\s*-->/);
+  const anchorPrefix = anchorMatch ? anchorMatch[1] : undefined;
+  const blockquoteMatch = block.match(/^>\s*(.+(?:\n>\s*.+)*)$/m);
+  if (!blockquoteMatch) {
+    return;
+  }
+  const selectedText = blockquoteMatch[1].split(`
+`).map((line) => line.replace(/^>\s*/, "")).join(`
+`);
+  const afterBlockquote = block.slice(block.indexOf(blockquoteMatch[0]) + blockquoteMatch[0].length);
+  const commentBody = afterBlockquote.trim();
+  return {
+    id,
+    selectedText,
+    comment: commentBody,
+    lineHint,
+    createdAt,
+    anchorPrefix,
+    startOffset: 0,
+    endOffset: 0
+  };
+}
+function serializeComments(file) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`source: ${file.source}`);
+  lines.push(`hash: ${file.hash}`);
+  lines.push(`version: ${file.version}`);
+  lines.push("---");
+  lines.push("");
+  for (const comment of file.comments) {
+    lines.push(serializeComment(comment));
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function serializeComment(comment) {
+  const lines = [];
+  const lineHint = comment.lineHint || "L0";
+  const createdAt = comment.createdAt || new Date().toISOString();
+  lines.push(`<!-- c:${comment.id}|${lineHint}|${createdAt} -->`);
+  if (comment.anchorPrefix) {
+    lines.push(`<!-- anchor:${comment.anchorPrefix} -->`);
+  }
+  const quotedLines = comment.selectedText.split(`
+`).map((line) => `> ${line}`);
+  lines.push(...quotedLines);
+  if (comment.comment) {
+    lines.push("");
+    lines.push(comment.comment);
+  }
+  return lines.join(`
+`);
+}
+function createComment(selectedText, commentText, startOffset, endOffset, sourceContent) {
+  const id = crypto.randomUUID().slice(0, 8);
+  const lineHint = getLineHint(sourceContent, startOffset, endOffset);
+  const needsTruncation = selectedText.length > MAX_SELECTION_LENGTH;
+  return {
+    id,
+    selectedText: truncateSelection(selectedText),
+    comment: commentText,
+    startOffset,
+    endOffset,
+    lineHint,
+    createdAt: new Date().toISOString(),
+    anchorPrefix: needsTruncation ? selectedText.slice(0, ANCHOR_PREFIX_LENGTH) : undefined
+  };
+}
+
+// src/lib/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function isMarkdownFile(filePath) {
+  return filePath.endsWith(".md") || filePath.endsWith(".markdown");
+}
+
+// src/server.ts
+import { watch } from "fs";
+import * as fs from "fs/promises";
+import * as os2 from "os";
+import * as path2 from "path";
+import { basename, dirname as dirname2, join as join3 } from "path";
+
+// src/schema.ts
+var AnchorConfidences = {
+  EXACT: "exact",
+  NORMALIZED: "normalized",
+  FUZZY: "fuzzy",
+  UNRESOLVED: "unresolved"
+};
+var FontFamilies = {
+  SERIF: "serif",
+  SANS_SERIF: "sans-serif"
+};
+
+// src/lib/anchor.ts
+var DEFAULT_SEARCH_WINDOW = 500;
+var DEFAULT_FUZZY_THRESHOLD = 5;
+var MAX_FUZZY_TEXT_LENGTH = 200;
+var FUZZY_SEARCH_WINDOW = 2000;
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function levenshteinDistance(a, b, maxDistance) {
+  if (a.length > b.length) {
+    [a, b] = [b, a];
+  }
+  const m = a.length;
+  const n = b.length;
+  if (m === 0)
+    return n;
+  if (n === 0)
+    return m;
+  if (maxDistance !== undefined && Math.abs(m - n) > maxDistance) {
+    return Number.POSITIVE_INFINITY;
+  }
+  let prevRow = new Array(m + 1);
+  let currRow = new Array(m + 1);
+  for (let i = 0;i <= m; i++) {
+    prevRow[i] = i;
+  }
+  for (let j = 1;j <= n; j++) {
+    currRow[0] = j;
+    let rowMin = currRow[0];
+    for (let i = 1;i <= m; i++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      currRow[i] = Math.min(prevRow[i] + 1, currRow[i - 1] + 1, prevRow[i - 1] + cost);
+      rowMin = Math.min(rowMin, currRow[i]);
+    }
+    if (maxDistance !== undefined && rowMin > maxDistance) {
+      return Number.POSITIVE_INFINITY;
+    }
+    [prevRow, currRow] = [currRow, prevRow];
+  }
+  return prevRow[m];
+}
+function getLineOffset(content, lineNumber) {
+  if (lineNumber <= 1)
+    return 0;
+  let currentLine = 1;
+  for (let i = 0;i < content.length; i++) {
+    if (content[i] === `
+`) {
+      currentLine++;
+      if (currentLine === lineNumber) {
+        return i + 1;
+      }
+    }
+  }
+  return content.length;
+}
+function parseLineHint(lineHint) {
+  const match = lineHint.match(/^L(\d+)(?:-L?(\d+))?$/);
+  if (!match) {
+    return { start: 1, end: 1 };
+  }
+  const start = Number.parseInt(match[1], 10);
+  const end = match[2] ? Number.parseInt(match[2], 10) : start;
+  return { start, end };
+}
+function findAnchor({
+  source,
+  selectedText,
+  lineHint,
+  searchWindow = DEFAULT_SEARCH_WINDOW
+}) {
+  if (!selectedText || !source) {
+    return;
+  }
+  const { start: hintLine } = parseLineHint(lineHint);
+  const lineOffset = getLineOffset(source, hintLine);
+  const windowStart = Math.max(0, lineOffset - searchWindow);
+  const windowEnd = Math.min(source.length, lineOffset + searchWindow);
+  const window = source.slice(windowStart, windowEnd);
+  const localIndex = window.indexOf(selectedText);
+  if (localIndex !== -1) {
+    const start = windowStart + localIndex;
+    const end = start + selectedText.length;
+    return {
+      start,
+      end,
+      line: getLineNumber(source, start),
+      confidence: AnchorConfidences.EXACT
+    };
+  }
+  const globalIndex = source.indexOf(selectedText);
+  if (globalIndex !== -1) {
+    return {
+      start: globalIndex,
+      end: globalIndex + selectedText.length,
+      line: getLineNumber(source, globalIndex),
+      confidence: AnchorConfidences.EXACT
+    };
+  }
+  return;
+}
+function buildNormalizedPositionMap(text) {
+  const toOriginal = [];
+  let normalized = "";
+  let inWhitespace = false;
+  for (let i = 0;i < text.length; i++) {
+    const char = text[i];
+    const isSpace = /\s/.test(char);
+    if (isSpace) {
+      if (!inWhitespace && normalized.length > 0) {
+        normalized += " ";
+        toOriginal.push(i);
+      }
+      inWhitespace = true;
+    } else {
+      normalized += char;
+      toOriginal.push(i);
+      inWhitespace = false;
+    }
+  }
+  if (normalized.endsWith(" ")) {
+    normalized = normalized.slice(0, -1);
+    toOriginal.pop();
+  }
+  return { normalized, toOriginal };
+}
+function findAnchorNormalized({
+  source,
+  selectedText,
+  lineHint,
+  searchWindow = FUZZY_SEARCH_WINDOW
+}) {
+  if (!selectedText || !source) {
+    return;
+  }
+  const normalizedText = normalizeWhitespace(selectedText);
+  if (!normalizedText) {
+    return;
+  }
+  if (normalizedText === selectedText) {
+    return;
+  }
+  const { start: hintLine } = parseLineHint(lineHint);
+  const lineOffset = getLineOffset(source, hintLine);
+  const windowStart = Math.max(0, lineOffset - searchWindow);
+  const windowEnd = Math.min(source.length, lineOffset + searchWindow);
+  const window = source.slice(windowStart, windowEnd);
+  const { normalized: normalizedWindow, toOriginal } = buildNormalizedPositionMap(window);
+  const normalizedIndex = normalizedWindow.indexOf(normalizedText);
+  if (normalizedIndex !== -1) {
+    const originalStart = windowStart + toOriginal[normalizedIndex];
+    const endNormIndex = normalizedIndex + normalizedText.length - 1;
+    let originalEnd = windowStart + toOriginal[endNormIndex] + 1;
+    while (originalEnd < source.length && /\s/.test(source[originalEnd])) {
+      originalEnd++;
+    }
+    return {
+      start: originalStart,
+      end: originalEnd,
+      line: getLineNumber(source, originalStart),
+      confidence: AnchorConfidences.NORMALIZED
+    };
+  }
+  const { normalized: fullNormalized, toOriginal: fullToOriginal } = buildNormalizedPositionMap(source);
+  const globalIndex = fullNormalized.indexOf(normalizedText);
+  if (globalIndex !== -1) {
+    const originalStart = fullToOriginal[globalIndex];
+    const endNormIndex = globalIndex + normalizedText.length - 1;
+    let originalEnd = fullToOriginal[endNormIndex] + 1;
+    while (originalEnd < source.length && /\s/.test(source[originalEnd])) {
+      originalEnd++;
+    }
+    return {
+      start: originalStart,
+      end: originalEnd,
+      line: getLineNumber(source, originalStart),
+      confidence: AnchorConfidences.NORMALIZED
+    };
+  }
+  return;
+}
+function findAnchorFuzzy({
+  source,
+  selectedText,
+  lineHint,
+  threshold = DEFAULT_FUZZY_THRESHOLD
+}) {
+  if (!selectedText || !source) {
+    return;
+  }
+  const textLen = selectedText.length;
+  if (textLen > MAX_FUZZY_TEXT_LENGTH) {
+    return;
+  }
+  let bestMatch;
+  let bestDistance = threshold + 1;
+  let searchStart = 0;
+  let searchEnd = source.length;
+  if (lineHint) {
+    const { start: hintLine } = parseLineHint(lineHint);
+    const lineOffset = getLineOffset(source, hintLine);
+    searchStart = Math.max(0, lineOffset - FUZZY_SEARCH_WINDOW);
+    searchEnd = Math.min(source.length, lineOffset + FUZZY_SEARCH_WINDOW);
+  }
+  const minLen = Math.max(1, textLen - threshold);
+  const maxLen = textLen + threshold;
+  for (let len = minLen;len <= maxLen; len++) {
+    for (let i = searchStart;i <= searchEnd - len; i++) {
+      const candidate = source.slice(i, i + len);
+      const distance = levenshteinDistance(selectedText, candidate, bestDistance - 1);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        bestMatch = {
+          start: i,
+          end: i + len,
+          line: getLineNumber(source, i),
+          confidence: AnchorConfidences.FUZZY,
+          distance
+        };
+        if (distance === 0) {
+          return bestMatch;
+        }
+      }
+    }
+  }
+  return bestMatch;
+}
+function findAnchorWithFallback({
+  source,
+  selectedText,
+  lineHint,
+  fuzzyThreshold
+}) {
+  const exactMatch = findAnchor({ source, selectedText, lineHint });
+  if (exactMatch) {
+    return exactMatch;
+  }
+  const normalizedMatch = findAnchorNormalized({
+    source,
+    selectedText,
+    lineHint
+  });
+  if (normalizedMatch) {
+    return normalizedMatch;
+  }
+  return findAnchorFuzzy({
+    source,
+    selectedText,
+    lineHint,
+    threshold: fuzzyThreshold
+  });
+}
+
+// src/lib/highlight/resolver.ts
+function findTextPosition(textContent, selectedText, hintOffset) {
+  if (!selectedText || !textContent)
+    return;
+  const occurrences = [];
+  let idx = 0;
+  for (;; ) {
+    idx = textContent.indexOf(selectedText, idx);
+    if (idx === -1)
+      break;
+    occurrences.push(idx);
+    idx += 1;
+  }
+  if (occurrences.length === 0)
+    return;
+  if (occurrences.length === 1) {
+    return {
+      start: occurrences[0],
+      end: occurrences[0] + selectedText.length
+    };
+  }
+  const target = hintOffset ?? 0;
+  let closest = occurrences[0];
+  let minDist = Math.abs(closest - target);
+  for (const occ of occurrences) {
+    const dist = Math.abs(occ - target);
+    if (dist < minDist) {
+      minDist = dist;
+      closest = occ;
+    }
+  }
+  return { start: closest, end: closest + selectedText.length };
+}
+
+// src/lib/html-text.ts
+var BLOCK_ELEMENTS = new Set([
+  "p",
+  "div",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "pre",
+  "blockquote",
+  "li",
+  "tr",
+  "br"
+]);
+function extractTextFromHtml(html) {
+  const textNodes = collectTextNodesFromHtml(html);
+  if (textNodes.length === 0)
+    return "";
+  let result = "";
+  let lastBlockPath = null;
+  for (const node of textNodes) {
+    if (lastBlockPath) {
+      const lastBlock = lastBlockPath;
+      const currBlock = node.blockAncestorPath;
+      if (lastBlock.length > 0 && currBlock.length > 0 && !isNested(lastBlock, currBlock)) {
+        if (lastBlock[lastBlock.length - 1] !== currBlock[currBlock.length - 1]) {
+          result += `
+`;
+        }
+      }
+    }
+    result += node.text;
+    lastBlockPath = node.blockAncestorPath;
+  }
+  return result;
+}
+function isNested(pathA, pathB) {
+  const blockA = pathA[pathA.length - 1];
+  const blockB = pathB[pathB.length - 1];
+  if (pathB.includes(blockA))
+    return true;
+  if (pathA.includes(blockB))
+    return true;
+  return false;
+}
+function collectTextNodesFromHtml(html) {
+  const nodes = [];
+  const stack = [];
+  let idCounter = 0;
+  const tagPattern = /<\/?([a-zA-Z][a-zA-Z0-9]*)[^>]*\/?>/g;
+  let lastIndex = 0;
+  let match;
+  match = tagPattern.exec(html);
+  while (match !== null) {
+    if (match.index > lastIndex) {
+      const text = decodeEntities(html.slice(lastIndex, match.index));
+      if (text) {
+        nodes.push({
+          text,
+          blockAncestorPath: getBlockAncestorPath(stack)
+        });
+      }
+    }
+    const fullTag = match[0];
+    const tagName = match[1].toLowerCase();
+    const isClosing = fullTag.startsWith("</");
+    const isSelfClosing = fullTag.endsWith("/>") || isVoidElement(tagName);
+    if (isClosing) {
+      for (let i = stack.length - 1;i >= 0; i--) {
+        if (stack[i].tag === tagName) {
+          stack.splice(i);
+          break;
+        }
+      }
+    } else if (!isSelfClosing) {
+      stack.push({ tag: tagName, id: `e${idCounter++}` });
+    }
+    lastIndex = match.index + fullTag.length;
+    match = tagPattern.exec(html);
+  }
+  if (lastIndex < html.length) {
+    const text = decodeEntities(html.slice(lastIndex));
+    if (text) {
+      nodes.push({
+        text,
+        blockAncestorPath: getBlockAncestorPath(stack)
+      });
+    }
+  }
+  return nodes;
+}
+function getBlockAncestorPath(stack) {
+  const path2 = [];
+  for (const entry of stack) {
+    if (BLOCK_ELEMENTS.has(entry.tag)) {
+      path2.push(entry.id);
+    }
+  }
+  return path2;
+}
+var VOID_ELEMENTS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function isVoidElement(tag) {
+  return VOID_ELEMENTS.has(tag);
+}
+function decodeEntities(text) {
+  return text.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x27;/g, "'").replace(/&nbsp;/g, "\xA0").replace(/&#(\d+);/g, (_, code) => String.fromCharCode(Number(code))).replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+}
+
+// src/lib/key-lock.ts
+var locks = new Map;
+function namespace(name) {
+  let n = locks.get(name);
+  if (!n) {
+    n = new Map;
+    locks.set(name, n);
+  }
+  return n;
+}
+function createKeyLock(name) {
+  const map = namespace(name);
+  return function withLock(key, fn) {
+    const prev = map.get(key) ?? Promise.resolve();
+    const next = prev.catch(() => {}).then(fn);
+    map.set(key, next.catch(() => {}));
+    return next;
+  };
+}
+
+// src/lib/markdown-renderer.ts
+import MarkdownIt from "markdown-it";
+
+// src/lib/headings.ts
+function slugify(text) {
+  return text.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+function stripCodeBlocks(content) {
+  let result = content.replace(/^(`{3,}|~{3,}).*$[\s\S]*?^\1\s*$/gm, "");
+  result = result.replace(/(?:^|\n\n)((?:(?:[ ]{4}|\t).+\n?)+)/g, `
+
+`);
+  return result;
+}
+function parseMarkdownHeadings(content) {
+  const headings = [];
+  const seenIds = new Map;
+  const contentWithoutCode = stripCodeBlocks(content);
+  const regex = /^(#{1,6})\s+(.+)$/gm;
+  let match = regex.exec(contentWithoutCode);
+  while (match !== null) {
+    const level = match[1].length;
+    const text = match[2].trim();
+    const baseId = slugify(text);
+    const count = seenIds.get(baseId) ?? 0;
+    const id = count > 0 ? `${baseId}-${count}` : baseId;
+    seenIds.set(baseId, count + 1);
+    headings.push({ id, text, level });
+    match = regex.exec(contentWithoutCode);
+  }
+  return headings;
+}
+
+// src/lib/mermaid-renderer.ts
+var RENDER_TIMEOUT_MS = 15000;
+var MAX_CONSECUTIVE_ERRORS = 3;
+var worker = null;
+var workerReady = null;
+var pendingRequests = new Map;
+var requestCounter = 0;
+var consecutiveErrors = 0;
+function resetWorker(reason, currentWorker = worker) {
+  if (currentWorker)
+    currentWorker.terminate();
+  if (worker === currentWorker) {
+    worker = null;
+    workerReady = null;
+  }
+  for (const [, pending] of pendingRequests) {
+    clearTimeout(pending.timer);
+    pending.reject(reason);
+  }
+  pendingRequests.clear();
+}
+function createWorker() {
+  const w = new Worker(new URL("./mermaid-worker.ts", import.meta.url).href, {
+    type: "module"
+  });
+  const ready = new Promise((resolve2, reject) => {
+    const timeout = setTimeout(() => {
+      w.removeEventListener("message", onReady);
+      w.removeEventListener("error", onStartupError);
+      w.terminate();
+      if (worker === w) {
+        worker = null;
+        workerReady = null;
+      }
+      reject(new Error("Mermaid worker failed to start within 30s"));
+    }, 30000);
+    function onStartupError(event) {
+      clearTimeout(timeout);
+      w.removeEventListener("message", onReady);
+      w.removeEventListener("error", onStartupError);
+      w.terminate();
+      if (worker === w) {
+        worker = null;
+        workerReady = null;
+      }
+      reject(new Error(`Mermaid worker failed to start: ${event.message}`));
+    }
+    function onReady(event) {
+      if (event.data?.type === "ready") {
+        clearTimeout(timeout);
+        w.removeEventListener("message", onReady);
+        w.removeEventListener("error", onStartupError);
+        resolve2();
+      }
+    }
+    w.addEventListener("message", onReady);
+    w.addEventListener("error", onStartupError);
+  });
+  w.addEventListener("message", (event) => {
+    const { id, svg, error } = event.data;
+    if (!id)
+      return;
+    const pending = pendingRequests.get(id);
+    if (!pending)
+      return;
+    clearTimeout(pending.timer);
+    pendingRequests.delete(id);
+    if (error) {
+      consecutiveErrors++;
+      pending.reject(new Error(error));
+    } else {
+      consecutiveErrors = 0;
+      pending.resolve(svg);
+    }
+  });
+  w.addEventListener("error", (event) => {
+    resetWorker(new Error(`Worker error: ${event.message}`), w);
+  });
+  return { worker: w, ready };
+}
+async function ensureWorker() {
+  if (worker && workerReady) {
+    await workerReady;
+    if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+      resetWorker(new Error("Mermaid worker restarted after repeated render failures"));
+      consecutiveErrors = 0;
+    }
+  }
+  if (!worker) {
+    const result = createWorker();
+    worker = result.worker;
+    workerReady = result.ready;
+    await workerReady;
+  }
+  return worker;
+}
+async function renderMermaidSvg(code) {
+  const w = await ensureWorker();
+  const id = `req-${++requestCounter}`;
+  const diagramId = `mermaid-ssr-${requestCounter}`;
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      pendingRequests.delete(id);
+      resetWorker(new Error(`Mermaid render timed out after ${RENDER_TIMEOUT_MS}ms`), w);
+      reject(new Error(`Mermaid render timed out after ${RENDER_TIMEOUT_MS}ms`));
+    }, RENDER_TIMEOUT_MS);
+    pendingRequests.set(id, { resolve: resolve2, reject, timer });
+    w.postMessage({ id, code, diagramId });
+  });
+}
+async function renderMermaidBlocks(blocks) {
+  const results = [];
+  for (const code of blocks) {
+    try {
+      const svg = await renderMermaidSvg(code);
+      results.push(svg);
+    } catch {
+      results.push(null);
+    }
+  }
+  return results;
+}
+function disposeMermaidWorker() {
+  resetWorker(new Error("Mermaid worker disposed"));
+}
+
+// src/lib/markdown-renderer.ts
+var SHIKI_LANGUAGES = [
+  "bash",
+  "css",
+  "diff",
+  "go",
+  "graphql",
+  "javascript",
+  "json",
+  "jsx",
+  "markdown",
+  "python",
+  "rust",
+  "sql",
+  "tsx",
+  "typescript",
+  "yaml"
+];
+var SHIKI_THEME = "one-dark-pro";
+var shikiInstance = null;
+var shikiPromise = null;
+async function getShiki() {
+  if (shikiInstance)
+    return shikiInstance;
+  if (shikiPromise)
+    return shikiPromise;
+  shikiPromise = import("shiki").then(async ({ createHighlighter }) => {
+    const highlighter = await createHighlighter({
+      themes: [SHIKI_THEME],
+      langs: SHIKI_LANGUAGES
+    });
+    shikiInstance = highlighter;
+    return highlighter;
+  });
+  return shikiPromise;
+}
+function createMarkdownRenderer(shiki) {
+  const md = new MarkdownIt({
+    html: true,
+    linkify: true,
+    typographer: false,
+    highlight(code, lang) {
+      if (lang === "mermaid") {
+        return `<pre><code class="language-mermaid">${md.utils.escapeHtml(code)}</code></pre>`;
+      }
+      const language = normalizeLanguage(lang);
+      if (language && shiki.getLoadedLanguages().includes(language)) {
+        return shiki.codeToHtml(code, {
+          lang: language,
+          theme: SHIKI_THEME
+        });
+      }
+      return `<pre class="shiki"><code>${md.utils.escapeHtml(code)}</code></pre>`;
+    }
+  });
+  return md;
+}
+function normalizeLanguage(lang) {
+  const aliases = {
+    sh: "bash",
+    shell: "bash",
+    js: "javascript",
+    ts: "typescript",
+    py: "python",
+    rs: "rust",
+    yml: "yaml",
+    md: "markdown"
+  };
+  const normalized = lang.toLowerCase().trim();
+  if (SHIKI_LANGUAGES.includes(normalized)) {
+    return normalized;
+  }
+  return aliases[normalized];
+}
+function injectHeadingIds(html, headings) {
+  let headingIdx = 0;
+  return html.replace(/<(h[1-6])([^>]*)>([\s\S]*?)<\/\1>/gi, (match, tag, attrs, content) => {
+    if (headingIdx >= headings.length)
+      return match;
+    const heading = headings[headingIdx];
+    headingIdx++;
+    if (/\bid\s*=/.test(attrs))
+      return match;
+    return `<${tag} id="${heading.id}"${attrs}>${content}</${tag}>`;
+  });
+}
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function extractFrontmatter(src) {
+  const match = src.match(FRONTMATTER_RE);
+  if (!match)
+    return { rest: src, frontmatter: "" };
+  return { rest: src.slice(match[0].length), frontmatter: match[1].trim() };
+}
+function renderFrontmatterBlock(yaml, md, shiki) {
+  const highlighted = shiki.getLoadedLanguages().includes("yaml") ? shiki.codeToHtml(yaml, { lang: "yaml", theme: SHIKI_THEME }) : `<pre><code class="language-yaml">${md.utils.escapeHtml(yaml)}</code></pre>`;
+  return `<details class="frontmatter"><summary>Properties</summary>${highlighted}</details>`;
+}
+var TASK_ITEM_RE = /<li>(\s*(?:<p>)?)\[([ xX])\]\s/g;
+function transformTaskLists(html) {
+  let idx = 0;
+  return html.replace(TASK_ITEM_RE, (_match, prefix, mark) => {
+    const checked = mark === " " ? "false" : "true";
+    const span = `<span class="task-checkbox" data-checked="${checked}" data-task-index="${idx}" role="checkbox" aria-checked="${checked}" tabindex="0"></span>`;
+    idx++;
+    return `<li>${prefix}${span}`;
+  });
+}
+var TS_TASK_ITEM_RE = /^(\s*[-*+]\s+)\[([ xX])\](\s)/gm;
+var TS_FENCED_CODE_RE = /^(?:```|~~~)[^\n]*\n[\s\S]*?\n(?:```|~~~)[ \t]*$/gm;
+function maskCodeBlocks(src) {
+  return src.replace(TS_FENCED_CODE_RE, (m) => m.replace(/[^\n]/g, "X"));
+}
+function toggleTaskInSource(src, index, checked) {
+  const { rest } = extractFrontmatter(src);
+  const prefixLen = src.length - rest.length;
+  const masked = maskCodeBlocks(rest);
+  const matches = [];
+  TS_TASK_ITEM_RE.lastIndex = 0;
+  let m = TS_TASK_ITEM_RE.exec(masked);
+  while (m !== null) {
+    const markIndex = m.index + m[1].length + 1;
+    matches.push({ markIndex });
+    m = TS_TASK_ITEM_RE.exec(masked);
+  }
+  if (index < 0 || index >= matches.length)
+    return null;
+  const markPos = prefixLen + matches[index].markIndex;
+  const newMark = checked ? "x" : " ";
+  return src.slice(0, markPos) + newMark + src.slice(markPos + 1);
+}
+var MERMAID_BLOCK_RE = /<pre><code class="language-mermaid">([\s\S]*?)<\/code><\/pre>/g;
+function unescapeHtml(str) {
+  return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"');
+}
+async function replaceMermaidBlocks(html) {
+  MERMAID_BLOCK_RE.lastIndex = 0;
+  const matches = [];
+  let match = MERMAID_BLOCK_RE.exec(html);
+  while (match !== null) {
+    matches.push({
+      fullMatch: match[0],
+      code: unescapeHtml(match[1]),
+      index: match.index
+    });
+    match = MERMAID_BLOCK_RE.exec(html);
+  }
+  if (matches.length === 0)
+    return html;
+  const codes = matches.map((m) => m.code);
+  const svgs = await renderMermaidBlocks(codes);
+  for (let i = matches.length - 1;i >= 0; i--) {
+    const svg = svgs[i];
+    if (svg !== null) {
+      const { fullMatch, index, code } = matches[i];
+      const encodedSource = encodeURIComponent(code);
+      const replacement = `<div class="mermaid-container" data-mermaid-source="${encodedSource}">${svg}</div>`;
+      html = html.slice(0, index) + replacement + html.slice(index + fullMatch.length);
+    }
+  }
+  return html;
+}
+async function renderMarkdown(content) {
+  const shiki = await getShiki();
+  const md = createMarkdownRenderer(shiki);
+  const { rest, frontmatter } = extractFrontmatter(content);
+  const headings = parseMarkdownHeadings(rest);
+  let html = md.render(rest);
+  html = injectHeadingIds(html, headings);
+  html = await replaceMermaidBlocks(html);
+  html = transformTaskLists(html);
+  if (frontmatter) {
+    html = renderFrontmatterBlock(frontmatter, md, shiki) + html;
+  }
+  return { html, headings };
+}
+
+// src/template.ts
+function safeJsonStringify(data) {
+  return JSON.stringify(data).replace(/</g, "\\u003c");
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeAttr(str) {
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function sanitizeHtml(html) {
+  let sanitized = html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "");
+  sanitized = sanitized.replace(/\s+on\w+\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+)/gi, "");
+  sanitized = sanitized.replace(/\bhref\s*=\s*(?:"javascript:[^"]*"|'javascript:[^']*')/gi, "");
+  sanitized = sanitized.replace(/\bsrc\s*=\s*(?:"javascript:[^"]*"|'javascript:[^']*')/gi, "");
+  return sanitized;
+}
+function renderTemplate(options) {
+  const {
+    title,
+    cssPath,
+    jsPath,
+    documentHtml,
+    inlineData,
+    isDev,
+    fontFamily
+  } = options;
+  const viteClient = isDev ? '<script type="module" src="http://127.0.0.1:24678/@vite/client"></script>' : "";
+  const cssLink = cssPath ? `<link rel="stylesheet" href="${escapeAttr(cssPath)}">` : "";
+  const proseClass = fontFamily === "sans-serif" ? "prose-sans" : "prose-serif";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>readit \u2014 ${escapeHtml(title)}</title>
+  <link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>\uD83D\uDCD6</text></svg>">
+  <script>
+    (() => {
+      var t = localStorage.getItem("readit:theme");
+      var d = t === "dark" || (t !== "light" && matchMedia("(prefers-color-scheme: dark)").matches);
+      if (d) document.documentElement.classList.add("dark");
+    })();
+  </script>
+  ${viteClient}
+  ${cssLink}
+</head>
+<body class="min-h-screen">
+  <article id="document-content" class="prose ${proseClass}">${sanitizeHtml(documentHtml)}</article>
+  <div id="app"></div>
+  <script type="application/json" id="__readit">${safeJsonStringify(inlineData)}</script>
+  <script type="module" src="${escapeAttr(jsPath)}" defer></script>
+</body>
+</html>`;
+}
+
+// src/server.ts
+function isErrnoException(err) {
+  return err instanceof Error && "code" in err;
+}
+var resolvedCommentsCache = new Map;
+function invalidateResolvedComments(filePath) {
+  resolvedCommentsCache.delete(filePath);
+}
+var withCommentLock = createKeyLock("comments");
+var withSourceLock = createKeyLock("source");
+async function canonicalPath(filePath) {
+  return fs.realpath(path2.resolve(filePath));
+}
+async function readCommentsFromFile(filePath, sourceContent, renderedHtml) {
+  const commentPath = getCommentPath(filePath);
+  const sourceHash = computeHash(sourceContent);
+  try {
+    const stats = await fs.stat(commentPath);
+    const cached = resolvedCommentsCache.get(filePath);
+    if (cached && cached.sourceHash === sourceHash && cached.commentMtimeMs === stats.mtimeMs) {
+      return cached.comments;
+    }
+    const content = await fs.readFile(commentPath, "utf-8");
+    const file = parseCommentFile(content);
+    const domText = renderedHtml ? extractTextFromHtml(renderedHtml) : null;
+    const resolvedComments = file.comments.map((comment) => {
+      const textForMatching = comment.anchorPrefix || comment.selectedText;
+      const anchor = findAnchorWithFallback({
+        source: sourceContent,
+        selectedText: textForMatching,
+        lineHint: comment.lineHint || "L1"
+      });
+      if (!anchor) {
+        return {
+          ...comment,
+          anchorConfidence: AnchorConfidences.UNRESOLVED
+        };
+      }
+      let startOffset = anchor.start;
+      let endOffset = anchor.end;
+      if (domText) {
+        const domPos = findTextPosition(domText, comment.selectedText, anchor.start);
+        if (domPos) {
+          startOffset = domPos.start;
+          endOffset = domPos.end;
+        }
+      }
+      return {
+        ...comment,
+        startOffset,
+        endOffset,
+        lineHint: `L${anchor.line}`,
+        anchorConfidence: anchor.confidence
+      };
+    });
+    resolvedCommentsCache.set(filePath, {
+      sourceHash,
+      commentMtimeMs: stats.mtimeMs,
+      comments: resolvedComments
+    });
+    return resolvedComments;
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") {
+      invalidateResolvedComments(filePath);
+      return [];
+    }
+    throw err;
+  }
+}
+async function writeCommentsToFile(filePath, sourceContent, comments) {
+  const commentPath = getCommentPath(filePath);
+  const commentDir = dirname2(commentPath);
+  await fs.mkdir(commentDir, { recursive: true });
+  const file = {
+    source: filePath,
+    hash: computeHash(sourceContent),
+    version: 1,
+    comments
+  };
+  const content = serializeComments(file);
+  const tempPath = `${commentPath}.tmp`;
+  await fs.writeFile(tempPath, content, "utf-8");
+  await fs.rename(tempPath, commentPath);
+  invalidateResolvedComments(filePath);
+}
+async function deleteCommentFile(filePath) {
+  const commentPath = getCommentPath(filePath);
+  try {
+    await fs.unlink(commentPath);
+  } catch (err) {
+    if (!isErrnoException(err) || err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  invalidateResolvedComments(filePath);
+}
+var SETTINGS_PATH = path2.join(os2.homedir(), ".readit", "settings.json");
+var DEFAULT_SETTINGS = {
+  version: 1,
+  fontFamily: FontFamilies.SERIF
+};
+async function readSettings() {
+  try {
+    const content = await fs.readFile(SETTINGS_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") {
+      return DEFAULT_SETTINGS;
+    }
+    throw err;
+  }
+}
+async function writeSettings(settings) {
+  const settingsDir = dirname2(SETTINGS_PATH);
+  await fs.mkdir(settingsDir, { recursive: true });
+  const tempPath = `${SETTINGS_PATH}.tmp`;
+  await fs.writeFile(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  await fs.rename(tempPath, SETTINGS_PATH);
+}
+function isValidFontFamily(value) {
+  return value === FontFamilies.SERIF || value === FontFamilies.SANS_SERIF;
+}
+var SERVER_INFO_PATH = path2.join(os2.homedir(), ".readit", "server.json");
+async function writeServerInfo(port) {
+  await fs.mkdir(path2.dirname(SERVER_INFO_PATH), { recursive: true });
+  await fs.writeFile(SERVER_INFO_PATH, JSON.stringify({ port, pid: process.pid }), "utf-8");
+}
+async function removeServerInfo() {
+  try {
+    await fs.unlink(SERVER_INFO_PATH);
+  } catch (err) {
+    if (!isErrnoException(err) || err.code !== "ENOENT") {
+      console.error("Failed to remove server info:", err);
+    }
+  }
+}
+function json(data, status = 200) {
+  return Response.json(data, { status });
+}
+function errorResponse(message, status) {
+  return Response.json({ error: message }, { status });
+}
+function errorWithDetail(message, err, status = 500) {
+  const detail = err instanceof Error ? err.message : String(err);
+  return errorResponse(`${message}: ${detail}`, status);
+}
+async function getComments(ctx, renderedHtml) {
+  try {
+    const currentContent = await ctx.getCurrentContent();
+    const comments = await readCommentsFromFile(ctx.filePath, currentContent, renderedHtml);
+    return json({ comments });
+  } catch (err) {
+    console.error("Failed to read comments:", err);
+    return errorResponse("Failed to read comments", 500);
+  }
+}
+async function addComment(ctx, req) {
+  try {
+    const {
+      selectedText,
+      comment: commentText,
+      startOffset,
+      endOffset
+    } = await req.json();
+    if (!selectedText || typeof commentText !== "string" || startOffset === undefined || endOffset === undefined) {
+      return errorResponse("Missing required fields", 400);
+    }
+    const currentContent = await ctx.getCurrentContent();
+    const newComment = createComment(selectedText, commentText, startOffset, endOffset, currentContent);
+    await withCommentLock(ctx.filePath, async () => {
+      const existingComments = await readCommentsFromFile(ctx.filePath, currentContent);
+      const allComments = [...existingComments, newComment];
+      await writeCommentsToFile(ctx.filePath, currentContent, allComments);
+    });
+    return json({ comment: newComment }, 201);
+  } catch (err) {
+    console.error("Failed to add comment:", err);
+    return errorWithDetail("Failed to add comment", err);
+  }
+}
+async function updateComment(ctx, req, id) {
+  try {
+    const { comment: commentText } = await req.json();
+    if (typeof commentText !== "string") {
+      return errorResponse("Missing comment text", 400);
+    }
+    const currentContent = await ctx.getCurrentContent();
+    const result = await withCommentLock(ctx.filePath, async () => {
+      const existingComments = await readCommentsFromFile(ctx.filePath, currentContent);
+      const commentIndex = existingComments.findIndex((c) => c.id === id);
+      if (commentIndex === -1)
+        return null;
+      const updatedComments = existingComments.map((c, i) => i === commentIndex ? { ...c, comment: commentText.trim() } : c);
+      await writeCommentsToFile(ctx.filePath, currentContent, updatedComments);
+      return updatedComments[commentIndex];
+    });
+    if (!result)
+      return errorResponse("Comment not found", 404);
+    return json({ comment: result });
+  } catch (err) {
+    console.error("Failed to update comment:", err);
+    return errorWithDetail("Failed to update comment", err);
+  }
+}
+async function deleteComment(ctx, id) {
+  try {
+    const currentContent = await ctx.getCurrentContent();
+    const found = await withCommentLock(ctx.filePath, async () => {
+      const existingComments = await readCommentsFromFile(ctx.filePath, currentContent);
+      const filteredComments = existingComments.filter((c) => c.id !== id);
+      if (filteredComments.length === existingComments.length)
+        return false;
+      if (filteredComments.length === 0) {
+        await deleteCommentFile(ctx.filePath);
+      } else {
+        await writeCommentsToFile(ctx.filePath, currentContent, filteredComments);
+      }
+      return true;
+    });
+    if (!found)
+      return errorResponse("Comment not found", 404);
+    return json({ success: true });
+  } catch (err) {
+    console.error("Failed to delete comment:", err);
+    return errorWithDetail("Failed to delete comment", err);
+  }
+}
+async function clearComments(ctx) {
+  try {
+    await withCommentLock(ctx.filePath, () => deleteCommentFile(ctx.filePath));
+    return json({ success: true });
+  } catch (err) {
+    console.error("Failed to clear comments:", err);
+    return errorWithDetail("Failed to clear comments", err);
+  }
+}
+async function getRawComments(ctx) {
+  const commentPath = getCommentPath(ctx.filePath);
+  try {
+    const content = await fs.readFile(commentPath, "utf-8");
+    return json({ content, path: commentPath });
+  } catch (err) {
+    if (isErrnoException(err) && err.code === "ENOENT") {
+      return json({ content: null, path: commentPath });
+    }
+    console.error("Failed to read raw comments:", err);
+    return errorResponse("Failed to read raw comments", 500);
+  }
+}
+async function reanchorComment(ctx, req, id) {
+  try {
+    const { selectedText, startOffset, endOffset } = await req.json();
+    if (!selectedText || startOffset === undefined || endOffset === undefined) {
+      return errorResponse("Missing required fields", 400);
+    }
+    const currentContent = await ctx.getCurrentContent();
+    const result = await withCommentLock(ctx.filePath, async () => {
+      const existingComments = await readCommentsFromFile(ctx.filePath, currentContent);
+      const commentIndex = existingComments.findIndex((c) => c.id === id);
+      if (commentIndex === -1)
+        return null;
+      const lineHint = getLineHint(currentContent, startOffset, endOffset);
+      const truncatedText = truncateSelection(selectedText);
+      const updatedComment = {
+        ...existingComments[commentIndex],
+        selectedText: truncatedText,
+        startOffset,
+        endOffset,
+        lineHint,
+        anchorConfidence: AnchorConfidences.EXACT,
+        anchorPrefix: selectedText.length > 1000 ? selectedText.slice(0, 200) : undefined
+      };
+      const updatedComments = existingComments.map((c, i) => i === commentIndex ? updatedComment : c);
+      await writeCommentsToFile(ctx.filePath, currentContent, updatedComments);
+      return updatedComment;
+    });
+    if (!result)
+      return errorResponse("Comment not found", 404);
+    return json({ comment: result });
+  } catch (err) {
+    console.error("Failed to re-anchor comment:", err);
+    return errorWithDetail("Failed to re-anchor comment", err);
+  }
+}
+async function getSettingsRoute() {
+  try {
+    const settings = await readSettings();
+    return json(settings);
+  } catch (err) {
+    console.error("Failed to read settings:", err);
+    return errorResponse("Failed to read settings", 500);
+  }
+}
+async function updateSettingsRoute(req) {
+  try {
+    const body = await req.json();
+    const { fontFamily } = body;
+    if (fontFamily !== undefined && !isValidFontFamily(fontFamily)) {
+      return errorResponse("Invalid font family", 400);
+    }
+    const current = await readSettings();
+    const settings = {
+      ...current,
+      ...fontFamily !== undefined && { fontFamily }
+    };
+    await writeSettings(settings);
+    return json(settings);
+  } catch (err) {
+    console.error("Failed to save settings:", err);
+    return errorResponse("Failed to save settings", 500);
+  }
+}
+function createDocumentStream(sseClients) {
+  let pingInterval;
+  let captured;
+  const stream = new ReadableStream({
+    start(controller) {
+      captured = controller;
+      controller.enqueue(`data: connected
+
+`);
+      sseClients.add(controller);
+      pingInterval = setInterval(() => {
+        try {
+          controller.enqueue(`data: ping
+
+`);
+        } catch {
+          clearInterval(pingInterval);
+          sseClients.delete(controller);
+        }
+      }, 5000);
+    },
+    cancel() {
+      clearInterval(pingInterval);
+      sseClients.delete(captured);
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+function createHeartbeat(onOpen, onClose) {
+  let interval;
+  let captured;
+  const stream = new ReadableStream({
+    start(controller) {
+      captured = controller;
+      controller.enqueue(`data: connected
+
+`);
+      onOpen(controller);
+      interval = setInterval(() => {
+        try {
+          controller.enqueue(`data: ping
+
+`);
+        } catch {
+          clearInterval(interval);
+          onClose(controller);
+        }
+      }, 5000);
+    },
+    cancel() {
+      clearInterval(interval);
+      onClose(captured);
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    }
+  });
+}
+async function serveStaticFile(distPath, pathname) {
+  const filePath = join3(distPath, pathname);
+  const file = Bun.file(filePath);
+  if (await file.exists()) {
+    const isHashed = pathname.startsWith("/assets/");
+    const headers = isHashed ? { "Cache-Control": "public, max-age=31536000, immutable" } : {};
+    return new Response(file, { headers });
+  }
+  const indexFile = Bun.file(join3(distPath, "index.html"));
+  if (await indexFile.exists()) {
+    return new Response(indexFile);
+  }
+  return new Response("Not Found", { status: 404 });
+}
+var VITE_DEV_PORT = 24678;
+var VITE_DEV_ORIGIN = `http://127.0.0.1:${VITE_DEV_PORT}`;
+async function proxyToVite(req, pathname, search) {
+  const target = `${VITE_DEV_ORIGIN}${pathname}${search}`;
+  try {
+    return await fetch(new Request(target, {
+      method: req.method,
+      headers: req.headers,
+      body: req.body,
+      redirect: "manual"
+    }));
+  } catch {
+    return new Response("Vite dev server not available", { status: 502 });
+  }
+}
+function extractCommentId(pathname) {
+  const match = pathname.match(/^\/api\/comments\/([^/]+)/);
+  return match?.[1];
+}
+function createServer(options) {
+  const fileMap = new Map;
+  const fileOrder = [];
+  for (const entry of options.files) {
+    fileMap.set(entry.filePath, {
+      content: entry.content ?? null,
+      renderedHtml: null,
+      headings: null,
+      isLoaded: entry.content !== undefined,
+      debounceTimer: null
+    });
+    fileOrder.push(entry.filePath);
+    if (options.clean) {
+      const commentPath = getCommentPath(entry.filePath);
+      fs.unlink(commentPath).catch(() => {});
+      invalidateResolvedComments(entry.filePath);
+    }
+  }
+  const defaultPath = fileOrder[0];
+  const sseClients = new Set;
+  const heartbeatClients = new Set;
+  let shutdownTimer = null;
+  function sendEvent(event) {
+    const message = `data: ${JSON.stringify(event)}
+
+`;
+    for (const controller of sseClients) {
+      try {
+        controller.enqueue(message);
+      } catch {
+        sseClients.delete(controller);
+      }
+    }
+  }
+  function clearShutdownTimer() {
+    if (!shutdownTimer)
+      return;
+    clearTimeout(shutdownTimer);
+    shutdownTimer = null;
+  }
+  function onHeartbeatOpen(controller) {
+    heartbeatClients.add(controller);
+    clearShutdownTimer();
+  }
+  function onHeartbeatClose(controller) {
+    heartbeatClients.delete(controller);
+    if (isDev || heartbeatClients.size > 0 || shutdownTimer)
+      return;
+    shutdownTimer = setTimeout(() => {
+      if (heartbeatClients.size > 0) {
+        clearShutdownTimer();
+        return;
+      }
+      console.log(`
+Browser disconnected, shutting down...`);
+      process.exit(0);
+    }, 1500);
+  }
+  async function ensureFileContent(filePath) {
+    const state = fileMap.get(filePath);
+    if (!state) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    if (state.isLoaded && state.content !== null) {
+      return state.content;
+    }
+    const content = await fs.readFile(filePath, "utf-8");
+    state.content = content;
+    state.isLoaded = true;
+    return content;
+  }
+  async function ensureRenderedHtml(filePath) {
+    const state = fileMap.get(filePath);
+    if (!state)
+      throw new Error(`File not found: ${filePath}`);
+    if (state.renderedHtml !== null && state.headings !== null) {
+      return { html: state.renderedHtml, headings: state.headings };
+    }
+    const content = await ensureFileContent(filePath);
+    const result = await renderMarkdown(content);
+    state.renderedHtml = result.html;
+    state.headings = result.headings;
+    return result;
+  }
+  function resolveContext(url) {
+    const requestedPath = url.searchParams.get("path") ?? defaultPath;
+    const state = fileMap.get(requestedPath);
+    if (!state)
+      return null;
+    return {
+      filePath: requestedPath,
+      getCurrentContent: () => ensureFileContent(requestedPath)
+    };
+  }
+  function requireContext(url) {
+    const ctx = resolveContext(url);
+    if (!ctx) {
+      return errorResponse("File not found", 404);
+    }
+    return ctx;
+  }
+  const isDev = false;
+  const distPath = import.meta.dir;
+  let manifestCache = null;
+  async function getManifest() {
+    if (manifestCache)
+      return manifestCache;
+    try {
+      const manifestPath = join3(distPath, ".vite", "manifest.json");
+      const content = await fs.readFile(manifestPath, "utf-8");
+      manifestCache = JSON.parse(content);
+      return manifestCache;
+    } catch {
+      return null;
+    }
+  }
+  let pageCache = null;
+  let pageCacheGz = null;
+  function invalidatePageCache() {
+    pageCache = null;
+    pageCacheGz = null;
+  }
+  async function serveAppPage(req) {
+    const acceptGzip = req.headers.get("accept-encoding")?.includes("gzip") ?? false;
+    try {
+      if (pageCache) {
+        if (acceptGzip && pageCacheGz) {
+          return new Response(pageCacheGz, {
+            headers: {
+              "Content-Type": "text/html; charset=utf-8",
+              "Content-Encoding": "gzip"
+            }
+          });
+        }
+        return new Response(pageCache, {
+          headers: { "Content-Type": "text/html; charset=utf-8" }
+        });
+      }
+      const { html, headings } = await ensureRenderedHtml(defaultPath);
+      const content = await ensureFileContent(defaultPath);
+      const comments = await readCommentsFromFile(defaultPath, content, html);
+      const settings = await readSettings();
+      const files = fileOrder.map((fp) => ({
+        path: fp,
+        fileName: basename(fp)
+      }));
+      const inlineData = {
+        files,
+        activeFile: defaultPath,
+        settings,
+        documents: {
+          [defaultPath]: {
+            headings,
+            comments
+          }
+        },
+        clean: options.clean || false,
+        workingDirectory: process.cwd()
+      };
+      let cssPath = "";
+      let jsPath;
+      if (isDev) {
+        jsPath = `http://127.0.0.1:${VITE_DEV_PORT}/src/main.ts`;
+      } else {
+        const manifest = await getManifest();
+        const entry = manifest?.["index.html"];
+        jsPath = entry ? `/${entry.file}` : "/assets/index.js";
+        if (entry?.css?.[0]) {
+          cssPath = `/${entry.css[0]}`;
+        }
+      }
+      const body = renderTemplate({
+        title: basename(defaultPath),
+        cssPath,
+        jsPath,
+        documentHtml: html,
+        inlineData,
+        isDev,
+        fontFamily: settings.fontFamily
+      });
+      if (!isDev) {
+        pageCache = body;
+        pageCacheGz = Bun.gzipSync(new TextEncoder().encode(body));
+      }
+      if (acceptGzip) {
+        const gz = pageCacheGz ?? Bun.gzipSync(new TextEncoder().encode(body));
+        return new Response(gz, {
+          headers: {
+            "Content-Type": "text/html; charset=utf-8",
+            "Content-Encoding": "gzip"
+          }
+        });
+      }
+      return new Response(body, {
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    } catch (err) {
+      console.error("Failed to serve app page:", err);
+      return new Response("Internal Server Error", { status: 500 });
+    }
+  }
+  function watchFile(targetPath) {
+    try {
+      const watcher = watch(targetPath, async (eventType) => {
+        if (eventType !== "change" && eventType !== "rename")
+          return;
+        const state = fileMap.get(targetPath);
+        if (!state)
+          return;
+        if (state.debounceTimer)
+          clearTimeout(state.debounceTimer);
+        state.debounceTimer = setTimeout(async () => {
+          try {
+            const newContent = await fs.readFile(targetPath, "utf-8");
+            if (!state.isLoaded || newContent !== state.content) {
+              state.content = newContent;
+              state.renderedHtml = null;
+              state.headings = null;
+              state.isLoaded = true;
+              invalidateResolvedComments(targetPath);
+              invalidatePageCache();
+              console.log(`File changed: ${basename(targetPath)}`);
+              sendEvent({ type: "document-updated", path: targetPath });
+            }
+          } catch (err) {
+            if (isErrnoException(err) && err.code === "ENOENT") {
+              await rewatch(targetPath);
+            } else {
+              console.error(`Failed to read updated file ${targetPath}:`, err);
+            }
+          }
+        }, 100);
+      });
+      async function rewatch(filePath) {
+        const maxRetries = 10;
+        const retryInterval = 200;
+        for (let i = 0;i < maxRetries; i++) {
+          await new Promise((r) => setTimeout(r, retryInterval));
+          try {
+            await fs.access(filePath);
+            try {
+              watcher.close();
+            } catch {}
+            const idx = watchers.indexOf(watcher);
+            const newWatcher = watchFile(filePath);
+            if (newWatcher) {
+              if (idx >= 0)
+                watchers[idx] = newWatcher;
+              else
+                watchers.push(newWatcher);
+            }
+            const state = fileMap.get(filePath);
+            if (state) {
+              const newContent = await fs.readFile(filePath, "utf-8");
+              if (!state.isLoaded || newContent !== state.content) {
+                state.content = newContent;
+                state.renderedHtml = null;
+                state.headings = null;
+                state.isLoaded = true;
+                invalidateResolvedComments(filePath);
+                invalidatePageCache();
+                console.log(`File changed: ${basename(filePath)}`);
+                sendEvent({ type: "document-updated", path: filePath });
+              }
+            }
+            return;
+          } catch {}
+        }
+        console.warn(`File did not reappear after rename: ${filePath}`);
+      }
+      return watcher;
+    } catch (err) {
+      console.warn(`File watching not available for ${targetPath}:`, err);
+      return null;
+    }
+  }
+  const watchers = [];
+  const server = Bun.serve({
+    port: options.port,
+    hostname: options.host,
+    idleTimeout: 255,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const { pathname } = url;
+      const method = req.method;
+      if (pathname === "/api/documents" && method === "GET") {
+        const files = fileOrder.map((fp) => ({
+          path: fp,
+          fileName: basename(fp)
+        }));
+        return json({
+          files,
+          clean: options.clean || false,
+          workingDirectory: process.cwd()
+        });
+      }
+      if (pathname === "/api/documents" && method === "POST") {
+        try {
+          const { path: requestedPath } = await req.json();
+          if (!requestedPath || typeof requestedPath !== "string") {
+            return errorResponse("Missing 'path' field", 400);
+          }
+          let filePath;
+          try {
+            filePath = await canonicalPath(requestedPath);
+          } catch (err) {
+            if (isErrnoException(err) && err.code === "ENOENT") {
+              return errorResponse(`File not found: ${requestedPath}`, 404);
+            }
+            throw err;
+          }
+          if (!isMarkdownFile(filePath)) {
+            return errorResponse(`Unsupported file type: ${filePath} (expected .md or .markdown)`, 400);
+          }
+          const existingState = fileMap.get(filePath);
+          if (existingState) {
+            return json({
+              path: filePath,
+              fileName: basename(filePath),
+              status: "present"
+            });
+          } else {
+            fileMap.set(filePath, {
+              content: null,
+              renderedHtml: null,
+              headings: null,
+              isLoaded: false,
+              debounceTimer: null
+            });
+            fileOrder.push(filePath);
+            const watcher = watchFile(filePath);
+            if (watcher)
+              watchers.push(watcher);
+            sendEvent({
+              type: "document-added",
+              path: filePath,
+              fileName: basename(filePath)
+            });
+          }
+          return json({
+            path: filePath,
+            fileName: basename(filePath),
+            status: "added"
+          });
+        } catch (err) {
+          console.error("Failed to add document:", err);
+          return errorResponse("Failed to add document", 500);
+        }
+      }
+      if (pathname === "/api/document/task" && method === "PATCH") {
+        try {
+          const body = await req.json();
+          if (!body?.path || typeof body.index !== "number" || typeof body.checked !== "boolean") {
+            return errorResponse("path, index, checked required", 400);
+          }
+          let filePath;
+          try {
+            filePath = await canonicalPath(body.path);
+          } catch {
+            return errorResponse("file not loaded", 404);
+          }
+          if (!fileMap.has(filePath)) {
+            return errorResponse("file not loaded", 404);
+          }
+          const result = await withSourceLock(filePath, async () => {
+            const current = await fs.readFile(filePath, "utf-8");
+            const updated = toggleTaskInSource(current, body.index, body.checked);
+            if (updated === null)
+              return { status: 400 };
+            if (updated === current)
+              return { status: 200, body: { status: "unchanged" } };
+            const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+            await fs.writeFile(tmpPath, updated, "utf-8");
+            await fs.rename(tmpPath, filePath);
+            return { status: 200, body: { status: "ok" } };
+          });
+          if (result.status === 400) {
+            return errorResponse("task index out of range", 400);
+          }
+          return json(result.body);
+        } catch (err) {
+          console.error("Failed to toggle task:", err);
+          return errorResponse("toggle failed", 500);
+        }
+      }
+      if (pathname === "/api/document" && method === "GET") {
+        const ctxOrRes = requireContext(url);
+        if (ctxOrRes instanceof Response)
+          return ctxOrRes;
+        const { html, headings } = await ensureRenderedHtml(ctxOrRes.filePath);
+        return json({
+          html,
+          headings,
+          filePath: ctxOrRes.filePath,
+          fileName: basename(ctxOrRes.filePath),
+          clean: options.clean || false
+        });
+      }
+      if (pathname === "/api/document/stream" && method === "GET") {
+        return createDocumentStream(sseClients);
+      }
+      if (pathname === "/api/health" && method === "GET") {
+        return json({ status: "ok" });
+      }
+      if (pathname === "/api/heartbeat" && method === "GET") {
+        return createHeartbeat(onHeartbeatOpen, onHeartbeatClose);
+      }
+      if (pathname === "/api/comments" && method === "GET") {
+        const ctxOrRes = requireContext(url);
+        if (ctxOrRes instanceof Response)
+          return ctxOrRes;
+        const rendered = await ensureRenderedHtml(ctxOrRes.filePath);
+        return getComments(ctxOrRes, rendered.html);
+      }
+      if (pathname === "/api/comments/raw" && method === "GET") {
+        const ctxOrRes = requireContext(url);
+        if (ctxOrRes instanceof Response)
+          return ctxOrRes;
+        return getRawComments(ctxOrRes);
+      }
+      if (pathname === "/api/comments" && method === "POST") {
+        const ctxOrRes = requireContext(url);
+        if (ctxOrRes instanceof Response)
+          return ctxOrRes;
+        invalidatePageCache();
+        return addComment(ctxOrRes, req);
+      }
+      if (pathname === "/api/comments" && method === "DELETE") {
+        const ctxOrRes = requireContext(url);
+        if (ctxOrRes instanceof Response)
+          return ctxOrRes;
+        invalidatePageCache();
+        return clearComments(ctxOrRes);
+      }
+      const commentId = extractCommentId(pathname);
+      if (commentId) {
+        const ctxOrRes = requireContext(url);
+        if (ctxOrRes instanceof Response)
+          return ctxOrRes;
+        invalidatePageCache();
+        if (pathname.endsWith("/reanchor") && method === "PUT") {
+          return reanchorComment(ctxOrRes, req, commentId);
+        }
+        if (method === "PUT") {
+          return updateComment(ctxOrRes, req, commentId);
+        }
+        if (method === "DELETE") {
+          return deleteComment(ctxOrRes, commentId);
+        }
+      }
+      if (pathname === "/api/settings" && method === "GET") {
+        return getSettingsRoute();
+      }
+      if (pathname === "/api/settings" && method === "PUT") {
+        return updateSettingsRoute(req);
+      }
+      if (pathname === "/") {
+        return serveAppPage(req);
+      }
+      if (isDev) {
+        return proxyToVite(req, pathname, url.search);
+      }
+      return serveStaticFile(distPath, pathname);
+    }
+  });
+  for (const fp of fileOrder) {
+    const watcher = watchFile(fp);
+    if (watcher)
+      watchers.push(watcher);
+  }
+  return { server, watchers };
+}
+async function startServer(options) {
+  getShiki();
+  const MAX_PORT = 65535;
+  for (let port = options.port;port <= MAX_PORT; port++) {
+    try {
+      const { server, watchers } = createServer({ ...options, port });
+      const displayHost = options.host === "0.0.0.0" ? "localhost" : options.host;
+      let stopVite;
+      if (false) {}
+      const originalStop = server.stop.bind(server);
+      const wrappedServer = {
+        stop() {
+          disposeMermaidWorker();
+          stopVite?.();
+          for (const w of watchers)
+            w.close();
+          originalStop();
+        }
+      };
+      const actualPort = server.port ?? port;
+      await writeServerInfo(actualPort);
+      return {
+        port: actualPort,
+        url: `http://${displayHost}:${actualPort}`,
+        server: wrappedServer
+      };
+    } catch (err) {
+      if (isErrnoException(err) && (err.code === "EADDRINUSE" || err.code === "EACCES")) {
+        console.log(`Port ${port} is busy, trying ${port + 1}...`);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`No available port found starting from ${options.port}`);
+}
+
+// src/cli.ts
+var program = new Command;
+function isPermissionError(err) {
+  return err instanceof Error && "code" in err && err.code === "EACCES";
+}
+var READIT_DIR = join4(os3.homedir(), ".readit");
+var SERVER_INFO_PATH2 = join4(READIT_DIR, "server.json");
+var SERVER_LOCK_PATH = join4(READIT_DIR, "server.lock");
+var SERVER_LOCK_MAX_AGE_MS = 30000;
+var SERVER_LOCK_TIMEOUT_MS = 1e4;
+var SERVER_LOCK_WAIT_MS = 100;
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getErrnoCode(err) {
+  return err instanceof Error && "code" in err ? err.code : undefined;
+}
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+async function clearStaleServerLock() {
+  try {
+    const [stats, content] = await Promise.all([
+      fs2.stat(SERVER_LOCK_PATH),
+      fs2.readFile(SERVER_LOCK_PATH, "utf-8").catch(() => "")
+    ]);
+    const age = Date.now() - stats.mtimeMs;
+    let pid;
+    if (content) {
+      try {
+        const lock = JSON.parse(content);
+        pid = lock.pid;
+      } catch {}
+    }
+    if (age > SERVER_LOCK_MAX_AGE_MS || pid !== undefined && !isAlive(pid)) {
+      await fs2.unlink(SERVER_LOCK_PATH).catch(() => {});
+    }
+  } catch (err) {
+    if (getErrnoCode(err) !== "ENOENT")
+      throw err;
+  }
+}
+async function withServerLock(run) {
+  await fs2.mkdir(READIT_DIR, { recursive: true });
+  const start = Date.now();
+  while (true) {
+    let handle;
+    try {
+      handle = await fs2.open(SERVER_LOCK_PATH, "wx");
+      await handle.writeFile(JSON.stringify({ pid: process.pid, createdAt: Date.now() }), "utf-8");
+      try {
+        return await run();
+      } finally {
+        await handle.close().catch(() => {});
+        await fs2.unlink(SERVER_LOCK_PATH).catch(() => {});
+      }
+    } catch (err) {
+      if (handle) {
+        await handle.close().catch(() => {});
+      }
+      if (getErrnoCode(err) !== "EEXIST") {
+        throw err;
+      }
+      await clearStaleServerLock();
+      if (Date.now() - start >= SERVER_LOCK_TIMEOUT_MS) {
+        throw new Error("Timed out waiting for readit server lock");
+      }
+      await sleep(SERVER_LOCK_WAIT_MS);
+    }
+  }
+}
+async function discoverServer() {
+  try {
+    const content = readFileSync(SERVER_INFO_PATH2, "utf-8");
+    const info = JSON.parse(content);
+    if (!isAlive(info.pid)) {
+      return null;
+    }
+    try {
+      const res = await fetch(`http://127.0.0.1:${info.port}/api/health`);
+      if (!res.ok)
+        return null;
+    } catch {
+      return null;
+    }
+    return info;
+  } catch {
+    return null;
+  }
+}
+async function attachFiles(server, files) {
+  for (const file of files) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${server.port}/api/documents`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ path: file.path })
+      });
+      if (!res.ok) {
+        const data2 = await res.json();
+        console.error(`error: failed to add ${file.path}: ${data2.error}`);
+        process.exit(1);
+      }
+      const data = await res.json();
+      if (data.status === "added") {
+        console.log(`Added: ${data.fileName}`);
+      } else {
+        console.log(`Present: ${data.fileName}`);
+      }
+    } catch (err) {
+      console.error("error: failed to connect to server:", err instanceof Error ? err.message : err);
+      process.exit(1);
+    }
+  }
+}
+async function getServerTarget(files, port, host) {
+  return withServerLock(async () => {
+    const server = await discoverServer();
+    if (server) {
+      return {
+        kind: "existing",
+        port: server.port,
+        url: `http://127.0.0.1:${server.port}`
+      };
+    }
+    const started = await startServer({ files, port, host });
+    return {
+      kind: "started",
+      port: started.port,
+      url: started.url,
+      server: started.server
+    };
+  });
+}
+function findCommentFiles(dir) {
+  const results = [];
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = join4(dir, entry);
+      try {
+        const lstat = lstatSync(fullPath);
+        if (lstat.isSymbolicLink())
+          continue;
+        if (lstat.isDirectory()) {
+          results.push(...findCommentFiles(fullPath));
+        } else if (entry.endsWith(".comments.md")) {
+          results.push(fullPath);
+        }
+      } catch (err) {
+        if (isPermissionError(err)) {
+          console.warn(`Warning: Permission denied: ${fullPath}`);
+        }
+      }
+    }
+  } catch (err) {
+    if (isPermissionError(err)) {
+      console.warn(`Warning: Permission denied: ${dir}`);
+    }
+  }
+  return results;
+}
+function findReviewableFiles(dir) {
+  const results = [];
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "node_modules")
+        continue;
+      const fullPath = join4(dir, entry);
+      try {
+        const lstat = lstatSync(fullPath);
+        if (lstat.isSymbolicLink())
+          continue;
+        if (lstat.isDirectory()) {
+          results.push(...findReviewableFiles(fullPath));
+        } else if (isMarkdownFile(entry)) {
+          results.push({ filePath: fullPath });
+        }
+      } catch (err) {
+        if (isPermissionError(err)) {
+          console.warn(`Warning: Permission denied: ${fullPath}`);
+        }
+      }
+    }
+  } catch (err) {
+    if (isPermissionError(err)) {
+      console.warn(`Warning: Permission denied: ${dir}`);
+    }
+  }
+  return results;
+}
+function resolveFiles(args) {
+  const seen = new Set;
+  const files = [];
+  for (const arg of args) {
+    const inputPath = resolve3(process.cwd(), arg);
+    if (!existsSync(inputPath)) {
+      console.error(`error: not found: ${inputPath}`);
+      process.exit(1);
+    }
+    const filePath = realpathSync(inputPath);
+    const stat3 = statSync(filePath);
+    if (stat3.isDirectory()) {
+      const found = findReviewableFiles(filePath);
+      for (const entry of found) {
+        if (!seen.has(entry.filePath)) {
+          seen.add(entry.filePath);
+          files.push(entry);
+        }
+      }
+    } else {
+      if (seen.has(filePath))
+        continue;
+      if (!isMarkdownFile(filePath)) {
+        console.error(`error: unsupported file type: ${arg} (expected .md or .markdown)`);
+        process.exit(1);
+      }
+      seen.add(filePath);
+      files.push({ filePath });
+    }
+  }
+  return files;
+}
+var SETTINGS_PATH2 = join4(os3.homedir(), ".readit", "settings.json");
+function isOnboarded() {
+  try {
+    const content = readFileSync(SETTINGS_PATH2, "utf-8");
+    const settings = JSON.parse(content);
+    return settings.onboarded === true;
+  } catch {
+    return false;
+  }
+}
+async function markOnboarded() {
+  let settings = {};
+  try {
+    const content = readFileSync(SETTINGS_PATH2, "utf-8");
+    settings = JSON.parse(content);
+  } catch {}
+  settings.onboarded = true;
+  const dir = join4(os3.homedir(), ".readit");
+  await fs2.mkdir(dir, { recursive: true });
+  await fs2.writeFile(SETTINGS_PATH2, JSON.stringify(settings, null, 2), "utf-8");
+}
+var WELCOME_CONTENT = `# Welcome to readit
+
+A simple tool for reviewing markdown with inline comments.
+
+---
+
+## How It Works
+
+readit follows a simple loop: **read \u2192 comment \u2192 extract**.
+
+### 1. Read
+
+You're already doing this. Open any markdown file with \`readit <file.md>\` and it renders in your browser with a clean reading experience.
+
+### 2. Comment
+
+Select any text to add a comment. Try it now \u2014 **select this sentence** and type your first comment.
+
+Your comments appear as margin notes next to the highlighted text, just like reviewing a document in Google Docs. Add as many as you need.
+
+### 3. Extract
+
+When you're done reviewing, click the menu in the top-right and choose **Copy as Prompt**. This exports all your comments in a format ready for Claude, ChatGPT, or any AI assistant.
+
+You can also export as JSON if you prefer structured data.
+
+---
+
+## Everything is Plain Markdown
+
+Your comments are saved as \`.comments.md\` files in \`~/.readit/comments/\`. No database, no lock-in \u2014 just readable markdown files you can version control, search, or edit by hand.
+
+Each comment file looks something like this:
+
+\`\`\`markdown
+## Comment 1
+**Selected:** "select this sentence"
+**Comment:** This is my first comment!
+**Created:** 2024-01-15T10:30:00Z
+\`\`\`
+
+---
+
+## Navigating Comments
+
+Once you have multiple comments, use the navigation bar at the bottom of the screen to jump between them. You can also use keyboard shortcuts:
+
+| Shortcut | Action |
+|----------|--------|
+| \`Alt + \u2191\` | Previous comment |
+| \`Alt + \u2193\` | Next comment |
+| \`\u2318 + C\` | Copy selected text (raw) |
+| \`\u2318 + Shift + C\` | Copy selected text with context (for AI) |
+
+---
+
+## Quick Start
+
+\`\`\`bash
+# Review a markdown file
+readit document.md
+
+# Use a custom port
+readit document.md --port 3000
+
+# Start fresh (clear existing comments)
+readit document.md --clean
+\`\`\`
+
+---
+
+## Try It Now
+
+Go ahead and add a few comments to this document. When you're done, export them and see the output. That's the entire workflow \u2014 simple, transparent, and designed for reviewing AI-generated content.
+`;
+var WELCOME_PATH = join4(os3.homedir(), ".readit", "welcome.md");
+program.name("readit").description("Review Markdown documents with inline comments").version("0.2.0");
+program.command("list").description("List all files with comments").action(async () => {
+  const readitDir = join4(os3.homedir(), ".readit", "comments");
+  if (!existsSync(readitDir)) {
+    console.log("No comments found.");
+    return;
+  }
+  const commentFiles = findCommentFiles(readitDir);
+  if (commentFiles.length === 0) {
+    console.log("No comments found.");
+    return;
+  }
+  console.log(`
+Found ${commentFiles.length} file(s) with comments:
+`);
+  for (const file of commentFiles) {
+    try {
+      const content = readFileSync(file, "utf-8");
+      const parsed = parseCommentFile(content);
+      const commentCount = parsed.comments.length;
+      const sourcePath = parsed.source || "(unknown source)";
+      console.log(`  ${sourcePath}`);
+      console.log(`    ${commentCount} comment${commentCount !== 1 ? "s" : ""}`);
+      console.log();
+    } catch {}
+  }
+});
+program.command("show <file>").description("Show comments for a file").action(async (file) => {
+  const filePath = resolve3(process.cwd(), file);
+  const commentPath = getCommentPath(filePath);
+  if (!existsSync(commentPath)) {
+    console.log(`No comments found for: ${filePath}`);
+    return;
+  }
+  try {
+    const content = await fs2.readFile(commentPath, "utf-8");
+    const parsed = parseCommentFile(content);
+    if (parsed.comments.length === 0) {
+      console.log(`No comments found for: ${filePath}`);
+      return;
+    }
+    console.log(`
+Comments for: ${filePath}`);
+    console.log(`${"\u2500".repeat(60)}
+`);
+    for (let i = 0;i < parsed.comments.length; i++) {
+      const comment = parsed.comments[i];
+      console.log(`[${i + 1}] ${comment.lineHint || "L?"}`);
+      console.log(`Selected: "${comment.selectedText.slice(0, 80)}${comment.selectedText.length > 80 ? "..." : ""}"`);
+      console.log(`Comment: ${comment.comment}`);
+      console.log();
+    }
+  } catch (err) {
+    console.error("error: failed to read comments:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.argument("[files...]", "Markdown files/directories to review").option("-p, --port <number>", "Port to run server on", "4567").option("--host <address>", "Host address to bind to", "127.0.0.1").option("--no-open", "Don't automatically open browser").option("--clean", "Clear all existing comments on startup").action(async (fileArgs, options) => {
+  let files;
+  if (fileArgs.length === 0) {
+    if (isOnboarded()) {
+      files = [];
+    } else {
+      files = [
+        {
+          content: WELCOME_CONTENT,
+          filePath: WELCOME_PATH
+        }
+      ];
+    }
+  } else {
+    files = resolveFiles(fileArgs);
+    if (files.length === 0) {
+      console.error("error: no reviewable files found");
+      process.exit(1);
+    }
+  }
+  const preferredPort = Number.parseInt(options.port, 10);
+  if (Number.isNaN(preferredPort) || preferredPort < 1 || preferredPort > 65535) {
+    console.error(`error: invalid port number: ${options.port}`);
+    process.exit(1);
+  }
+  let previousPort;
+  try {
+    const info = JSON.parse(readFileSync(SERVER_INFO_PATH2, "utf-8"));
+    if (!isAlive(info.pid)) {
+      previousPort = info.port;
+    }
+  } catch {}
+  try {
+    const { url, server } = await startServer({
+      files,
+      port: preferredPort,
+      host: options.host,
+      clean: options.clean
+    });
+    if (files.length === 0) {
+      console.log(`
+readit - Document Review Tool
+
+  URL:  ${url}
+
+  No files specified. Add files with:
+    readit open <file.md>
+
+  Server running. Press Ctrl+C to stop.
+`);
+    } else {
+      const fileList = files.map((f) => `  ${f.filePath}`);
+      console.log(`
+readit - Document Review Tool
+
+  ${files.length === 1 ? "File:" : "Files:"}
+${fileList.join(`
+`)}
+  URL:  ${url}
+
+  Server running. Close browser tab to stop.
+  Press Ctrl+C to force stop.
+`);
+    }
+    const browserLikelyOpen = previousPort === preferredPort || false;
+    if (options.open && !browserLikelyOpen) {
+      open2(url);
+    }
+    if (fileArgs.length === 0) {
+      await markOnboarded();
+    }
+    process.on("SIGINT", async () => {
+      console.log(`
+
+Shutting down...`);
+      server.stop();
+      await removeServerInfo();
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("error: failed to start server:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("open").argument("<files...>", "Markdown files to add to running server").description("Add files to a running readit server, or start a new one").option("-p, --port <number>", "Port for new server (if starting)", "4567").option("--host <address>", "Host for new server (if starting)", "127.0.0.1").action(async (fileArgs, options) => {
+  const resolvedFiles = [];
+  for (const arg of fileArgs) {
+    const inputPath = resolve3(process.cwd(), arg);
+    if (!existsSync(inputPath)) {
+      console.error(`error: not found: ${inputPath}`);
+      process.exit(1);
+    }
+    const filePath = realpathSync(inputPath);
+    if (!isMarkdownFile(filePath)) {
+      console.error(`error: unsupported file type: ${arg} (expected .md or .markdown)`);
+      process.exit(1);
+    }
+    resolvedFiles.push({ path: filePath });
+  }
+  const files = resolvedFiles.map((f) => ({
+    filePath: f.path
+  }));
+  const preferredPort = Number.parseInt(options.port, 10);
+  try {
+    const target = await getServerTarget(files, preferredPort, options.host);
+    if (target.kind === "existing") {
+      await attachFiles({ port: target.port, pid: process.pid }, resolvedFiles);
+      console.log(`
+Server: ${target.url}`);
+      return;
+    }
+    const fileList = files.map((f) => `  ${f.filePath}`);
+    console.log(`
+readit - Document Review Tool
+
+  ${files.length === 1 ? "File:" : "Files:"}
+${fileList.join(`
+`)}
+  URL:  ${target.url}
+
+  Server running. Close browser tab to stop.
+  Press Ctrl+C to force stop.
+`);
+    open2(target.url);
+    process.on("SIGINT", async () => {
+      console.log(`
+
+Shutting down...`);
+      target.server?.stop();
+      await removeServerInfo();
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("error: failed to start server:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("completion").argument("[shell]", "Shell type (zsh, bash, fish)", "zsh").description("Output shell completion and integration script").action((shell) => {
+  const shellDir = join4(import.meta.dir, "..", "shell");
+  switch (shell) {
+    case "zsh": {
+      const widgetPath = join4(shellDir, "readit.zsh");
+      const compPath = join4(shellDir, "_readit");
+      if (!existsSync(widgetPath) || !existsSync(compPath)) {
+        console.log(generateInlineZshCompletion());
+        return;
+      }
+      const compdefContent = readFileSync(compPath, "utf-8");
+      const widgetContent = readFileSync(widgetPath, "utf-8");
+      const lines = [];
+      lines.push("# readit shell integration for zsh");
+      lines.push('# Add to your .zshrc: eval "$(readit completion zsh)"');
+      lines.push("");
+      lines.push("# \u2500\u2500 _readit compdef (autoloaded) \u2500\u2500");
+      lines.push("# This handles: subcommand/option completion + @ file autocomplete");
+      lines.push("# Renders [file.md] in a native multi-column grid via compadd");
+      lines.push("");
+      lines.push(compdefContent.replace(/^#compdef readit\n/, `autoload -Uz _readit
+_readit() {
+`).replace(/\n_readit "\$@"\n?$/, `
+}
+`));
+      lines.push("");
+      lines.push("# \u2500\u2500 readit.zsh (sourced) \u2500\u2500");
+      lines.push("# This handles: @[...] bracket stripping on Enter + syntax highlighting");
+      lines.push("");
+      lines.push(widgetContent.replace(/^#!/, "#").replace(/\n\(\( \$\+ functions\[_readit_plugin_loaded\] \)\)/, ""));
+      console.log(lines.join(`
+`));
+      break;
+    }
+    case "bash":
+      console.log(generateBashCompletion());
+      break;
+    case "fish":
+      console.log(generateFishCompletion());
+      break;
+    default:
+      console.error(`error: unsupported shell: ${shell}`);
+      console.error("Supported shells: zsh, bash, fish");
+      process.exit(1);
+  }
+});
+program.parse();
+function generateInlineZshCompletion() {
+  return `
+#compdef readit
+
+_readit_markdown_files() {
+  local -a files
+  files=( \${(f)"$(find . -type f \\( -name '*.md' -o -name '*.markdown' \\) -not -path '*/\\.*' -not -path '*/node_modules/*' 2>/dev/null | sed 's|^\\./||')"} )
+  _describe -t files 'markdown files' files
+}
+
+_readit() {
+  local context state state_descr line
+  typeset -A opt_args
+  _arguments -C '1:command:->cmd_or_files' '*::arg:->args'
+  case "$state" in
+    cmd_or_files)
+      local -a commands=(
+        'open:Add files to running server'
+        'list:List files with comments'
+        'show:Show comments for a file'
+        'completion:Output shell completion script'
+      )
+      _alternative 'commands:command:compadd -a commands' 'files:markdown file:_readit_markdown_files'
+      ;;
+    args)
+      case "\${line[1]}" in
+        open) _arguments '*:file:_readit_markdown_files' ;;
+        show) _arguments '1:file:_files -g "*.md *.markdown"' ;;
+        *) _arguments '*:file:_readit_markdown_files' ;;
+      esac
+      ;;
+  esac
+}
+_readit "$@"
+`.trim();
+}
+function generateBashCompletion() {
+  return `
+# readit bash completion
+# Add to .bashrc: eval "$(readit completion bash)"
+
+_readit_completions() {
+  local cur prev commands
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  commands="open list show completion"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "\${commands}" -- "\${cur}") )
+    # Also complete markdown files
+    local files=$(find . -type f \\( -name '*.md' -o -name '*.markdown' \\) \\
+      -not -path '*/.*' -not -path '*/node_modules/*' 2>/dev/null | sed 's|^\\./||')
+    COMPREPLY+=( $(compgen -W "\${files}" -- "\${cur}") )
+    return 0
+  fi
+
+  case "\${COMP_WORDS[1]}" in
+    open|show)
+      local files=$(find . -type f \\( -name '*.md' -o -name '*.markdown' \\) \\
+        -not -path '*/.*' -not -path '*/node_modules/*' 2>/dev/null | sed 's|^\\./||')
+      COMPREPLY=( $(compgen -W "\${files}" -- "\${cur}") )
+      ;;
+    completion)
+      COMPREPLY=( $(compgen -W "zsh bash fish" -- "\${cur}") )
+      ;;
+  esac
+  return 0
+}
+
+complete -F _readit_completions readit
+`.trim();
+}
+function generateFishCompletion() {
+  return `
+# readit fish completion
+# Add to config.fish: readit completion fish | source
+
+# Disable file completions by default
+complete -c readit -f
+
+# Subcommands
+complete -c readit -n '__fish_use_subcommand' -a 'open' -d 'Add files to running server'
+complete -c readit -n '__fish_use_subcommand' -a 'list' -d 'List files with comments'
+complete -c readit -n '__fish_use_subcommand' -a 'show' -d 'Show comments for a file'
+complete -c readit -n '__fish_use_subcommand' -a 'completion' -d 'Output shell completion script'
+
+# Options
+complete -c readit -s p -l port -d 'Port to run server on'
+complete -c readit -l host -d 'Host address to bind to'
+complete -c readit -l no-open -d "Don't automatically open browser"
+complete -c readit -l clean -d 'Clear existing comments'
+
+# File arguments for default command and open
+complete -c readit -n '__fish_use_subcommand' -F -a '(find . -type f \\( -name "*.md" -o -name "*.markdown" \\) -not -path "*/.*" -not -path "*/node_modules/*" 2>/dev/null | sed "s|^\\./||")'
+complete -c readit -n '__fish_seen_subcommand_from open' -F -a '(find . -type f \\( -name "*.md" -o -name "*.markdown" \\) -not -path "*/.*" -not -path "*/node_modules/*" 2>/dev/null | sed "s|^\\./||")'
+complete -c readit -n '__fish_seen_subcommand_from show' -F -a '(find . -type f \\( -name "*.md" -o -name "*.markdown" \\) -not -path "*/.*" -not -path "*/node_modules/*" 2>/dev/null | sed "s|^\\./||")'
+
+# Shell completions for completion subcommand
+complete -c readit -n '__fish_seen_subcommand_from completion' -a 'zsh bash fish'
+`.trim();
+}