mosage 0.1.0

package/dist/cli.js

@@ -0,0 +1,4545 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/config.ts
+function defaultExport(type) {
+  return structuredClone(type === "thesis" ? THESIS_EXPORT : BOOK_EXPORT);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value, fallback) {
+  return typeof value === "string" ? value : typeof value === "number" ? String(value) : fallback;
+}
+function num(value, fallback) {
+  const n = typeof value === "string" ? Number(value) : value;
+  return typeof n === "number" && Number.isFinite(n) ? n : fallback;
+}
+function bool(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function oneOf(value, options, fallback) {
+  return typeof value === "string" && options.includes(value) ? value : fallback;
+}
+function resolvePageSize(value, fallback) {
+  if (typeof value === "string") {
+    const name = Object.keys(PAGE_SIZES).find((k) => k.toLowerCase() === value.toLowerCase());
+    if (name) return name;
+  }
+  if (isObject(value)) {
+    const width = num(value.width, 0);
+    const height = num(value.height, 0);
+    if (width > 0 && height > 0) return { width, height };
+  }
+  return fallback;
+}
+function mergeConfig(base, override) {
+  const out = isObject(base) ? { ...base } : {};
+  if (!isObject(override)) return out;
+  for (const [key, value] of Object.entries(override)) {
+    if (value === null || value === void 0 || value === "") continue;
+    out[key] = isObject(value) && isObject(out[key]) ? mergeConfig(out[key], value) : value;
+  }
+  return out;
+}
+function resolveConfig(raw) {
+  const r = isObject(raw) ? raw : {};
+  const type = oneOf(r.type, ["book", "thesis", "other"], "book");
+  const title = str(r.title, "").trim();
+  const d = defaultExport(type);
+  const e = isObject(r.export) ? r.export : {};
+  const margins = isObject(e.margins) ? e.margins : {};
+  const fonts = isObject(e.fonts) ? e.fonts : {};
+  const ai = isObject(r.ai) ? r.ai : {};
+  return {
+    type,
+    stage: oneOf(r.stage, STAGES, "kickoff"),
+    title,
+    subtitle: str(r.subtitle, ""),
+    author: str(r.author, ""),
+    language: str(r.language, "zh-TW"),
+    targetWords: Math.max(0, num(r.targetWords, 0)),
+    chapters: Array.isArray(r.chapters) ? r.chapters.filter((c) => typeof c === "string" && c.trim() !== "") : [],
+    ai: { editMode: oneOf(ai.editMode, ["suggest", "direct"], "suggest") },
+    export: {
+      fileName: str(e.fileName, "") || title || "manuscript",
+      pageSize: resolvePageSize(e.pageSize, d.pageSize),
+      margins: {
+        top: num(margins.top, d.margins.top),
+        bottom: num(margins.bottom, d.margins.bottom),
+        left: num(margins.left, d.margins.left),
+        right: num(margins.right, d.margins.right)
+      },
+      fonts: {
+        body: str(fonts.body, d.fonts.body),
+        latin: str(fonts.latin, d.fonts.latin),
+        heading: str(fonts.heading, d.fonts.heading),
+        code: str(fonts.code, d.fonts.code)
+      },
+      fontSize: num(e.fontSize, d.fontSize),
+      lineSpacing: num(e.lineSpacing, d.lineSpacing),
+      firstLineIndent: num(e.firstLineIndent, d.firstLineIndent),
+      paragraphSpacing: num(e.paragraphSpacing, d.paragraphSpacing),
+      titlePage: bool(e.titlePage, d.titlePage),
+      toc: bool(e.toc, d.toc),
+      chapterPageBreak: bool(e.chapterPageBreak, d.chapterPageBreak),
+      pageNumbers: bool(e.pageNumbers, d.pageNumbers),
+      header: oneOf(e.header, ["none", "title", "chapter"], d.header),
+      sceneBreak: str(e.sceneBreak, d.sceneBreak)
+    }
+  };
+}
+function pageSizeMm(size) {
+  return typeof size === "string" ? PAGE_SIZES[size] : size;
+}
+var STAGES, CHAPTER_STATUSES, PAGE_SIZES, BOOK_EXPORT, THESIS_EXPORT;
+var init_config = __esm({
+  "src/shared/config.ts"() {
+    "use strict";
+    STAGES = ["kickoff", "outline", "writing", "revising", "done"];
+    CHAPTER_STATUSES = ["idea", "draft", "revising", "done"];
+    PAGE_SIZES = {
+      A4: { width: 210, height: 297 },
+      A5: { width: 148, height: 210 },
+      // JIS B5, the size Taiwanese and Japanese printers mean by "B5".
+      B5: { width: 182, height: 257 },
+      Letter: { width: 216, height: 279 }
+    };
+    BOOK_EXPORT = {
+      fileName: "",
+      pageSize: "A4",
+      margins: { top: 25, bottom: 25, left: 25, right: 25 },
+      fonts: {
+        body: "\u65B0\u7D30\u660E\u9AD4",
+        latin: "Times New Roman",
+        heading: "\u5FAE\u8EDF\u6B63\u9ED1\u9AD4",
+        code: "Consolas"
+      },
+      fontSize: 12,
+      lineSpacing: 1.5,
+      firstLineIndent: 2,
+      paragraphSpacing: 6,
+      titlePage: true,
+      toc: true,
+      chapterPageBreak: true,
+      pageNumbers: true,
+      header: "title",
+      sceneBreak: "\uFF0A\u3000\uFF0A\u3000\uFF0A"
+    };
+    THESIS_EXPORT = {
+      ...BOOK_EXPORT,
+      margins: { top: 25, bottom: 25, left: 30, right: 25 },
+      fonts: {
+        body: "\u6A19\u6977\u9AD4",
+        latin: "Times New Roman",
+        heading: "\u6A19\u6977\u9AD4",
+        code: "Consolas"
+      },
+      paragraphSpacing: 0,
+      header: "none"
+    };
+  }
+});
+
+// src/shared/annotations.ts
+function isMarker(html) {
+  return MARKER_RE.test(html.trim());
+}
+function unquote(value) {
+  if (!value.startsWith('"')) return value;
+  return value.slice(1, -1).replace(/\\(.)/g, (_, ch) => ch === "n" ? "\n" : ch);
+}
+function parseMarker(html) {
+  const match = MARKER_RE.exec(html.trim());
+  if (!match) return null;
+  const kind = match[1];
+  const rest = match[2];
+  const newline = rest.indexOf("\n");
+  let header = newline === -1 ? rest : rest.slice(0, newline);
+  const tail = newline === -1 ? "" : rest.slice(newline + 1);
+  const attrs = {};
+  for (; ; ) {
+    const attr = ATTR_RE.exec(header);
+    if (!attr) break;
+    attrs[attr[1]] = unquote(attr[2]);
+    header = header.slice(attr[0].length);
+  }
+  const body = [header.trim(), tail].filter((s) => s.trim() !== "").join("\n");
+  return { kind, attrs, body: body.replace(/^\s*\n/, "").replace(/\s+$/, "") };
+}
+function quoteAttr(value) {
+  if (value !== "" && /^[^\s"=<>`'\\]+$/.test(value) && !value.includes("--")) return value;
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/--/g, "-\\-")}"`;
+}
+function formatMarker(kind, attrs, body) {
+  const head = Object.entries(attrs).filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => `${k}=${quoteAttr(v)}`).join(" ");
+  const safeBody = body.replace(/-->/g, "-- >").trim();
+  return `<!-- mosage:${kind}${head ? ` ${head}` : ""}
+${safeBody}
+-->`;
+}
+function hash(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function newAnnotationId(kind) {
+  const random = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID().replace(/-/g, "") : Math.random().toString(16).slice(2) + Date.now().toString(16);
+  return `${kind === "comment" ? "c" : "s"}-${random.slice(0, 8)}`;
+}
+function toAnnotation(data, position, seen) {
+  let id = data.attrs.id;
+  if (!id) {
+    const base = `${data.kind === "comment" ? "c" : "s"}-${hash(`${data.kind}
+${data.attrs.quote ?? ""}
+${data.body}`)}`;
+    id = base;
+    for (let n = 2; seen.has(id); n++) id = `${base}-${n}`;
+  }
+  seen.add(id);
+  const span = Number.parseInt(data.attrs.span ?? "", 10);
+  return {
+    ...data,
+    id,
+    by: (data.attrs.by ?? (data.kind === "suggest" ? "ai" : "human")).toLowerCase(),
+    at: data.attrs.at,
+    quote: data.attrs.quote,
+    note: data.attrs.note,
+    span: Number.isFinite(span) && span >= 0 ? span : 1,
+    ...position
+  };
+}
+var MARKER_RE, ATTR_RE;
+var init_annotations = __esm({
+  "src/shared/annotations.ts"() {
+    "use strict";
+    MARKER_RE = /^<!--[ \t]*mosage:(comment|suggest)\b([\s\S]*?)-->[ \t]*$/;
+    ATTR_RE = /^[ \t]*([A-Za-z][\w-]*)=("(?:[^"\\\n]|\\.)*"|[^\s"]+)/;
+  }
+});
+
+// src/shared/wordcount.ts
+function countWords(text) {
+  let count = 0;
+  for (const _ of text.matchAll(TOKEN)) count++;
+  return count;
+}
+function formatCount(n, locale = "zh-TW") {
+  return new Intl.NumberFormat(locale).format(n);
+}
+var CJK, LATIN, TOKEN;
+var init_wordcount = __esm({
+  "src/shared/wordcount.ts"() {
+    "use strict";
+    CJK = "\\p{Script=Han}\\p{Script=Hiragana}\\p{Script=Katakana}\\p{Script=Hangul}";
+    LATIN = `(?:(?![${CJK}])[\\p{L}\\p{N}])+`;
+    TOKEN = new RegExp(`[${CJK}]|${LATIN}(?:['\u2019.-]${LATIN})*`, "gu");
+  }
+});
+
+// src/shared/markdown.ts
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import { parse as parseYaml } from "yaml";
+function parseMarkdown(source) {
+  return processor.parse(source);
+}
+function textOf(node) {
+  if (!node || typeof node !== "object") return "";
+  const n = node;
+  if (n.type === "html" || n.type === "yaml" || n.type === "footnoteDefinition") return "";
+  if (n.type === "break") return "\n";
+  if (typeof n.value === "string") return n.value;
+  if (n.type === "image") return n.alt ?? "";
+  if (Array.isArray(n.children)) return n.children.map(textOf).join("");
+  return "";
+}
+function isPageBreak(node) {
+  return node.type === "html" && /^<!--\s*(pagebreak|page-break|分頁)\s*-->$/i.test(node.value.trim());
+}
+function lineAt(source, offset) {
+  let line = 1;
+  for (let i = 0; i < offset && i < source.length; i++) if (source.charCodeAt(i) === 10) line++;
+  return line;
+}
+function readFrontmatter(value) {
+  try {
+    const data = parseYaml(value);
+    return data && typeof data === "object" && !Array.isArray(data) ? data : {};
+  } catch {
+    return {};
+  }
+}
+function wordsOf(tree) {
+  let total = 0;
+  const walk2 = (node) => {
+    const n = node;
+    if (!n || n.type === "html" || n.type === "yaml" || n.type === "code") return;
+    if (typeof n.value === "string") total += countWords(n.value);
+    if (Array.isArray(n.children)) n.children.forEach(walk2);
+  };
+  walk2(tree);
+  return total;
+}
+function parseChapter(source) {
+  const tree = parseMarkdown(source);
+  let frontmatter = {};
+  let frontmatterRange = null;
+  const blocks = [];
+  const annotations = [];
+  const seen = /* @__PURE__ */ new Set();
+  let pending = [];
+  for (const node of tree.children) {
+    const start = node.position?.start.offset ?? 0;
+    const end = node.position?.end.offset ?? start;
+    if (node.type === "yaml") {
+      frontmatter = readFrontmatter(node.value);
+      frontmatterRange = [start, end];
+      continue;
+    }
+    if (node.type === "html") {
+      const marker = parseMarker(node.value);
+      if (marker) {
+        const annotation = toAnnotation(marker, { start, end, blockIndex: null }, seen);
+        pending.push(annotation);
+        annotations.push(annotation);
+        continue;
+      }
+    }
+    const index = blocks.length;
+    for (const a of pending) a.blockIndex = index;
+    blocks.push({ index, node, start, end, annotations: pending });
+    pending = [];
+  }
+  const headings = [];
+  for (const block of blocks) {
+    if (block.node.type !== "heading") continue;
+    headings.push({
+      depth: block.node.depth,
+      text: textOf(block.node).trim(),
+      blockIndex: block.index,
+      line: lineAt(source, block.start)
+    });
+  }
+  const h1 = headings.find((h) => h.depth === 1);
+  return {
+    source,
+    tree,
+    frontmatter,
+    frontmatterRange,
+    title: h1 ? h1.text : null,
+    blocks,
+    annotations,
+    headings,
+    words: wordsOf(tree)
+  };
+}
+function stripMarkers(source) {
+  const { annotations } = parseChapter(source);
+  let out = source;
+  for (const a of [...annotations].reverse()) {
+    let end = a.end;
+    if (out[end] === "\n") end++;
+    out = out.slice(0, a.start) + out.slice(end);
+  }
+  return out;
+}
+var processor;
+var init_markdown = __esm({
+  "src/shared/markdown.ts"() {
+    "use strict";
+    init_annotations();
+    init_wordcount();
+    processor = unified().use(remarkParse).use(remarkGfm).use(remarkFrontmatter, ["yaml"]);
+  }
+});
+
+// src/node/export/common.ts
+import { existsSync as existsSync4, statSync } from "fs";
+import { readFile as readFile4 } from "fs/promises";
+import { basename, extname as extname2, isAbsolute, join as join4 } from "path";
+import { fileURLToPath } from "url";
+import { imageSize } from "image-size";
+function isEnglish(language) {
+  return /^en\b/i.test(language.trim());
+}
+function isCjkLanguage(language) {
+  return /^(zh|ja|ko)\b/i.test(language.trim());
+}
+function labelsFor(language) {
+  return isEnglish(language) ? EN : ZH;
+}
+function imagePlaceholder(alt, labels) {
+  const text = alt.trim();
+  if (!text) return `[${labels.image}]`;
+  return labels === EN ? `[${labels.image}: ${text}]` : `[${labels.image}\uFF1A${text}]`;
+}
+function walk(node, visit) {
+  if (!("children" in node)) return;
+  const parent = node;
+  for (let i = 0; i < parent.children.length; i++) {
+    const child = parent.children[i];
+    visit(child, parent, i);
+    walk(child, visit);
+  }
+}
+function prepareChapter(source) {
+  const tree = parseMarkdown(stripMarkers(source));
+  const prune = (node) => {
+    node.children = node.children.filter(
+      (child) => !(child.type === "yaml" || child.type === "html" && isMarker(child.value))
+    );
+    for (const child of node.children) if ("children" in child) prune(child);
+  };
+  prune(tree);
+  return tree;
+}
+function collectDefinitions(tree) {
+  const map = /* @__PURE__ */ new Map();
+  walk(tree, (node) => {
+    if (node.type === "definition" && !map.has(node.identifier)) map.set(node.identifier, node);
+  });
+  return map;
+}
+function collectFootnotes(tree) {
+  const map = /* @__PURE__ */ new Map();
+  walk(tree, (node) => {
+    if (node.type === "footnoteDefinition" && !map.has(node.identifier)) {
+      map.set(node.identifier, node);
+    }
+  });
+  return map;
+}
+function readAlert(node) {
+  const first = node.children[0];
+  if (first?.type !== "paragraph") return null;
+  const head = first.children[0];
+  if (head?.type !== "text") return null;
+  const match = ALERT_RE.exec(head.value);
+  if (!match) return null;
+  const rest = head.value.slice(match[0].length);
+  const inline = [...first.children.slice(1)];
+  if (rest) inline.unshift({ ...head, value: rest });
+  else if (inline[0]?.type === "break") inline.shift();
+  const paragraph = { ...first, children: inline };
+  const hasText = inline.some((c) => c.type !== "text" || c.value.trim() !== "");
+  return {
+    type: match[1].toLowerCase(),
+    children: hasText ? [paragraph, ...node.children.slice(1)] : node.children.slice(1)
+  };
+}
+function charBefore(s, i) {
+  const code = s.charCodeAt(i - 1);
+  return code >= 56320 && code <= 57343 && i >= 2 ? s.slice(i - 2, i) : s.charAt(i - 1);
+}
+function charAt(s, i) {
+  const cp3 = s.codePointAt(i);
+  return cp3 === void 0 ? "" : String.fromCodePoint(cp3);
+}
+function joinSoftBreaks(text) {
+  if (!text.includes("\n")) return text;
+  return text.replace(/[ \t]*\r?\n[ \t]*/g, (match, offset, s) => {
+    const before = charBefore(s, offset);
+    const after = charAt(s, offset + match.length);
+    return CJK_RE.test(before) && CJK_RE.test(after) ? "" : " ";
+  });
+}
+function sanitizeFileName(name) {
+  const clean = name.replace(/[/\\:*?"<>|]/g, "").replace(/[\u0000-\u001f\u007f]/g, "").replace(/\s+/g, " ").trim().replace(/^\.+/, "").replace(/[. ]+$/, "").slice(0, 120).trim();
+  return clean || "manuscript";
+}
+function isExternalUrl(url) {
+  return SCHEME_RE.test(url) && !WINDOWS_PATH_RE.test(url) && !/^file:/i.test(url);
+}
+function safeDecode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function imageCandidates(url, root) {
+  let path = url.trim();
+  if (!path || isExternalUrl(path)) return [];
+  if (/^file:/i.test(path)) {
+    try {
+      return [fileURLToPath(path)];
+    } catch {
+      return [];
+    }
+  }
+  path = path.replace(/[?#].*$/, "");
+  const decoded = safeDecode(path);
+  const variants = decoded === path ? [path] : [decoded, path];
+  const out = [];
+  for (const p of variants) {
+    if (isAbsolute(p) || WINDOWS_PATH_RE.test(p)) {
+      out.push(p, join4(root, p));
+    } else {
+      out.push(join4(root, "chapters", p), join4(root, p));
+    }
+  }
+  return [...new Set(out)];
+}
+function isFile(path) {
+  try {
+    return existsSync4(path) && statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function resolveLocalFile(url, root) {
+  return imageCandidates(url, root).find(isFile) ?? null;
+}
+function describe(data, name) {
+  let type = EXT_TYPE[extname2(name).toLowerCase()] ?? "";
+  let width = 0;
+  let height = 0;
+  try {
+    const size = imageSize(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+    width = size.width ?? 0;
+    height = size.height ?? 0;
+    if (size.type) type = size.type === "jpeg" ? "jpg" : size.type;
+  } catch {
+    if (type !== "svg") return null;
+  }
+  if (!type) return null;
+  return { data, type, mime: MIME[type] ?? `image/${type}`, width, height, name };
+}
+async function loadImage(url, root) {
+  const dataUri = /^data:([^;,]*)((?:;[^;,]*)*?)(;base64)?,(.*)$/is.exec(url.trim());
+  if (dataUri) {
+    try {
+      const payload = dataUri[3] ? Buffer.from(dataUri[4], "base64") : Buffer.from(safeDecode(dataUri[4]), "utf8");
+      const ext = Object.entries(MIME).find(([, m]) => m === dataUri[1].toLowerCase())?.[0];
+      return describe(payload, `image.${ext ?? "bin"}`);
+    } catch {
+      return null;
+    }
+  }
+  const file = resolveLocalFile(url, root);
+  if (!file) return null;
+  try {
+    return describe(await readFile4(file), basename(file));
+  } catch {
+    return null;
+  }
+}
+async function loadImages(urls, root) {
+  const unique = [...new Set(urls)];
+  const loaded = await Promise.all(unique.map((url) => loadImage(url, root)));
+  return new Map(unique.map((url, i) => [url, loaded[i]]));
+}
+function imageUrls(tree) {
+  const definitions = collectDefinitions(tree);
+  const urls = [];
+  walk(tree, (node) => {
+    if (node.type === "image") urls.push(node.url);
+    else if (node.type === "imageReference") {
+      const def = definitions.get(node.identifier);
+      if (def) urls.push(def.url);
+    }
+  });
+  return urls;
+}
+function applyEdits(source, edits) {
+  const sorted = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+  let out = "";
+  let pos = 0;
+  for (const edit of sorted) {
+    if (edit.start < pos) continue;
+    out += source.slice(pos, edit.start) + edit.text;
+    pos = edit.end;
+  }
+  return out + source.slice(pos);
+}
+function markdownUrl(url) {
+  return /[\s()<>]/.test(url) ? `<${url.replace(/</g, "%3C").replace(/>/g, "%3E")}>` : url;
+}
+function markdownTitle(title) {
+  return title ? ` "${title.replace(/["\\]/g, "\\$&")}"` : "";
+}
+function markdownAlt(alt) {
+  return alt.replace(/[\\[\]]/g, "\\$&").replace(/\s*\n\s*/g, " ");
+}
+var ALERT_TYPES, ALERT_COLORS, ZH, EN, ALERT_RE, CJK_RE, MIME, EXT_TYPE, SCHEME_RE, WINDOWS_PATH_RE;
+var init_common = __esm({
+  "src/node/export/common.ts"() {
+    "use strict";
+    init_annotations();
+    init_markdown();
+    ALERT_TYPES = ["note", "tip", "important", "warning", "caution"];
+    ALERT_COLORS = {
+      note: "0969DA",
+      tip: "1A7F37",
+      important: "8250DF",
+      warning: "9A6700",
+      caution: "CF222E"
+    };
+    ZH = {
+      contents: "\u76EE\u9304",
+      untitled: "\u672A\u547D\u540D",
+      image: "\u5716",
+      footnotes: "\u8A3B\u91CB",
+      backToText: "\u56DE\u5230\u5167\u6587",
+      frontMatter: "\u524D\u8A00\u7D20\u6750",
+      alerts: { note: "\u6CE8\u610F", tip: "\u63D0\u793A", important: "\u91CD\u8981", warning: "\u8B66\u544A", caution: "\u5C0F\u5FC3" }
+    };
+    EN = {
+      contents: "Contents",
+      untitled: "Untitled",
+      image: "Image",
+      footnotes: "Notes",
+      backToText: "Back to text",
+      frontMatter: "Front matter",
+      alerts: {
+        note: "Note",
+        tip: "Tip",
+        important: "Important",
+        warning: "Warning",
+        caution: "Caution"
+      }
+    };
+    ALERT_RE = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\][ \t]*(?:\r?\n[ \t]*|$)/i;
+    CJK_RE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}　-〿＀-￯⺀-⿟]/u;
+    MIME = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      gif: "image/gif",
+      bmp: "image/bmp",
+      svg: "image/svg+xml",
+      webp: "image/webp",
+      avif: "image/avif",
+      ico: "image/x-icon",
+      tiff: "image/tiff"
+    };
+    EXT_TYPE = {
+      ".png": "png",
+      ".jpg": "jpg",
+      ".jpeg": "jpg",
+      ".gif": "gif",
+      ".bmp": "bmp",
+      ".svg": "svg",
+      ".webp": "webp",
+      ".avif": "avif",
+      ".ico": "ico",
+      ".tif": "tiff",
+      ".tiff": "tiff"
+    };
+    SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+    WINDOWS_PATH_RE = /^[a-z]:[\\/]/i;
+  }
+});
+
+// src/node/export/docx.ts
+import {
+  AlignmentType,
+  Bookmark,
+  BookmarkEnd,
+  BookmarkStart,
+  BorderStyle,
+  Document,
+  DocumentDefaults,
+  ExternalHyperlink,
+  Footer,
+  FootnoteReferenceRun,
+  Header,
+  ImageRun,
+  InternalHyperlink,
+  LevelFormat,
+  LineRuleType,
+  NumberFormat,
+  Packer,
+  PageNumber,
+  PageOrientation,
+  Paragraph,
+  SectionType,
+  ShadingType,
+  StyleForCharacter,
+  StyleForParagraph,
+  Table,
+  TableCell,
+  TableLayoutType,
+  TableOfContents,
+  TableRow,
+  TextRun,
+  VerticalAlignTable,
+  WidthType,
+  XmlAttributeComponent
+} from "docx";
+function xmlText(text) {
+  return text.replace(INVALID_XML_RE, "");
+}
+function bookmark(name, id, children) {
+  const mark = new Bookmark({ id: name, children });
+  Object.assign(mark, { start: new BookmarkStart(name, id), end: new BookmarkEnd(id) });
+  return mark;
+}
+function columnWidths(table, cols, available) {
+  const weights = Array.from({ length: cols }, () => 4);
+  for (const row of table.children) {
+    row.children.forEach((cell, c) => {
+      let width = 0;
+      for (const char of textOf(cell)) width += char.charCodeAt(0) > 11903 ? 2 : 1;
+      weights[c] = Math.max(weights[c], Math.min(width, 40));
+    });
+  }
+  const total = weights.reduce((a, b) => a + b, 0);
+  const minimum = available / cols / 3;
+  const raw = weights.map((w) => Math.max(minimum, available * w / total));
+  const scale = available / raw.reduce((a, b) => a + b, 0);
+  const widths = raw.map((w) => Math.floor(w * scale));
+  widths[cols - 1] += available - widths.reduce((a, b) => a + b, 0);
+  return widths;
+}
+async function buildDocx(input) {
+  return new DocxBuilder(input).build();
+}
+var TWIPS_PER_MM, PX_PER_MM, TWIPS_PER_PX, DOCX_IMAGE_TYPES, BULLETS, ORDERED_FORMATS, NO_SPACE_BEFORE, twips, halfPoints, INVALID_XML_RE, DefaultStyleAttributes, DefaultParagraphStyle, HTML_FORMAT, DocxBuilder;
+var init_docx = __esm({
+  "src/node/export/docx.ts"() {
+    "use strict";
+    init_config();
+    init_markdown();
+    init_common();
+    TWIPS_PER_MM = 1440 / 25.4;
+    PX_PER_MM = 96 / 25.4;
+    TWIPS_PER_PX = 15;
+    DOCX_IMAGE_TYPES = /* @__PURE__ */ new Set(["png", "jpg", "gif", "bmp"]);
+    BULLETS = ["\u2022", "\u25E6", "\u25AA"];
+    ORDERED_FORMATS = [LevelFormat.DECIMAL, LevelFormat.LOWER_LETTER, LevelFormat.LOWER_ROMAN];
+    NO_SPACE_BEFORE = /* @__PURE__ */ new Set(["BodyText", "ListParagraph", "ListContinue", "Quote", "Callout"]);
+    twips = (mm) => Math.round(mm * TWIPS_PER_MM);
+    halfPoints = (pt) => Math.max(2, Math.round(pt * 2));
+    INVALID_XML_RE = // biome-ignore lint/suspicious/noControlCharactersInRegex: these are exactly the characters to drop
+    /[\u0000-\u0008\u000B\u000C\u000E-\u001F￾￿]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+    DefaultStyleAttributes = class extends XmlAttributeComponent {
+      xmlKeys = { type: "w:type", styleId: "w:styleId", default: "w:default" };
+    };
+    DefaultParagraphStyle = class extends StyleForParagraph {
+      constructor(options) {
+        super(options);
+        this.root[0] = new DefaultStyleAttributes({
+          type: "paragraph",
+          styleId: options.id,
+          default: true
+        });
+      }
+    };
+    HTML_FORMAT = {
+      b: "bold",
+      strong: "bold",
+      i: "italics",
+      em: "italics",
+      u: "underline",
+      ins: "underline",
+      s: "strike",
+      del: "strike",
+      strike: "strike",
+      sup: "superScript",
+      sub: "subScript",
+      mark: "highlight",
+      code: "code",
+      kbd: "code"
+    };
+    DocxBuilder = class {
+      constructor(input) {
+        this.input = input;
+        const config = input.config;
+        this.e = config.export;
+        this.labels = labelsFor(config.language);
+        const size = pageSizeMm(this.e.pageSize);
+        const m = this.e.margins;
+        const widthMm = Math.max(20, size.width - m.left - m.right);
+        const heightMm = Math.max(20, size.height - m.top - m.bottom);
+        this.charTwips = Math.round(this.e.fontSize * 20);
+        this.contentWidth = twips(widthMm);
+        this.contentHeight = twips(heightMm);
+        this.contentWidthPx = widthMm * PX_PER_MM;
+        this.contentHeightPx = heightMm * PX_PER_MM;
+        this.quoteIndent = this.charTwips * 2;
+        this.calloutIndent = Math.round(this.charTwips / 2);
+      }
+      input;
+      e;
+      labels;
+      charTwips;
+      contentWidth;
+      contentHeight;
+      contentWidthPx;
+      contentHeightPx;
+      quoteIndent;
+      calloutIndent;
+      images = /* @__PURE__ */ new Map();
+      definitions = /* @__PURE__ */ new Map();
+      footnoteDefs = /* @__PURE__ */ new Map();
+      footnotes = {};
+      footnoteCount = 0;
+      orderedLists = [];
+      toc = [];
+      bookmarkCount = 0;
+      /** A page break is due before the next body paragraph. */
+      breakNext = false;
+      /** The last body block was a table: the next paragraph needs air above it. */
+      afterTable = false;
+      get config() {
+        return this.input.config;
+      }
+      async build() {
+        const trees = this.input.chapters.map((c) => prepareChapter(c.source));
+        this.images = await loadImages(
+          trees.flatMap((t) => imageUrls(t)),
+          this.input.root
+        );
+        const perChapter = this.e.header === "chapter";
+        const bodyCtx = {
+          style: "BodyText",
+          indent: 0,
+          listLevel: 0,
+          body: true,
+          inFootnote: false
+        };
+        const chapters = [];
+        trees.forEach((tree, i) => {
+          this.definitions = collectDefinitions(tree);
+          this.footnoteDefs = collectFootnotes(tree);
+          if (i > 0 && this.e.chapterPageBreak) this.breakNext = !perChapter;
+          chapters.push({
+            title: this.chapterTitle(tree, this.input.chapters[i].id),
+            children: this.blocks(tree.children, bodyCtx)
+          });
+        });
+        this.breakNext = false;
+        const doc = new Document({
+          title: this.config.title || void 0,
+          subject: this.config.subtitle || void 0,
+          creator: this.config.author || "MoSage",
+          lastModifiedBy: "MoSage",
+          description: "Exported by MoSage",
+          features: this.e.toc ? { updateFields: true } : void 0,
+          // A justified line that ends in a manual line break is not stretched.
+          compatibility: { doNotExpandShiftReturn: true },
+          styles: { importedStyles: this.styles() },
+          numbering: { config: this.numbering() },
+          footnotes: this.footnotes,
+          sections: this.sections(chapters)
+        });
+        return Packer.toBuffer(doc);
+      }
+      // -------------------------------------------------------------------------
+      // Sections
+      sections(chapters) {
+        const size = pageSizeMm(this.e.pageSize);
+        const m = this.e.margins;
+        const page = {
+          size: {
+            width: twips(size.width),
+            height: twips(size.height),
+            orientation: PageOrientation.PORTRAIT
+          },
+          margin: {
+            top: twips(m.top),
+            bottom: twips(m.bottom),
+            left: twips(m.left),
+            right: twips(m.right),
+            header: twips(Math.min(12.5, m.top / 2)),
+            footer: twips(Math.min(12.5, m.bottom / 2))
+          }
+        };
+        const sections = [];
+        if (this.e.titlePage) {
+          sections.push({
+            properties: { page },
+            children: this.titlePage()
+          });
+        }
+        if (this.e.toc) {
+          sections.push({
+            properties: { page, type: SectionType.NEXT_PAGE },
+            children: this.tableOfContents()
+          });
+        }
+        const footers = this.e.pageNumbers ? {
+          default: new Footer({
+            children: [
+              new Paragraph({
+                style: "Footer",
+                children: [new TextRun({ children: [PageNumber.CURRENT] })]
+              })
+            ]
+          })
+        } : void 0;
+        const header = (text) => text.trim() ? {
+          default: new Header({
+            children: [
+              new Paragraph({ style: "Header", children: [new TextRun(xmlText(text))] })
+            ]
+          })
+        } : void 0;
+        const firstPage = { ...page, pageNumbers: { start: 1, formatType: NumberFormat.DECIMAL } };
+        const nonEmpty = (children) => children.length ? children : [new Paragraph({})];
+        if (this.e.header === "chapter") {
+          chapters.forEach((chapter, i) => {
+            sections.push({
+              properties: {
+                page: i === 0 ? firstPage : page,
+                type: i === 0 || this.e.chapterPageBreak ? SectionType.NEXT_PAGE : SectionType.CONTINUOUS
+              },
+              headers: header(chapter.title),
+              footers,
+              children: nonEmpty(chapter.children)
+            });
+          });
+        } else if (chapters.length || !sections.length) {
+          sections.push({
+            properties: { page: firstPage, type: SectionType.NEXT_PAGE },
+            headers: this.e.header === "title" ? header(this.config.title) : void 0,
+            footers,
+            children: nonEmpty(chapters.flatMap((c) => c.children))
+          });
+        }
+        return sections;
+      }
+      titlePage() {
+        const c = this.config;
+        const out = [
+          new Paragraph({
+            style: "Title",
+            children: [new TextRun(xmlText(c.title || this.labels.untitled))]
+          })
+        ];
+        if (c.subtitle.trim()) {
+          out.push(new Paragraph({ style: "Subtitle", children: [new TextRun(xmlText(c.subtitle))] }));
+        }
+        if (c.author.trim()) {
+          out.push(new Paragraph({ style: "Author", children: [new TextRun(xmlText(c.author))] }));
+        }
+        return out;
+      }
+      tableOfContents() {
+        const entries = this.toc.map(
+          (entry) => new Paragraph({
+            style: `TOC${entry.level}`,
+            children: [
+              new InternalHyperlink({
+                anchor: entry.anchor,
+                children: [new TextRun(xmlText(entry.title))]
+              })
+            ]
+          })
+        );
+        return [
+          new Paragraph({ style: "TOCHeading", children: [new TextRun(this.labels.contents)] }),
+          new TableOfContents(this.labels.contents, {
+            hyperlink: true,
+            headingStyleRange: "1-3",
+            hideTabAndPageNumbersInWebView: true,
+            useAppliedParagraphOutlineLevel: true,
+            contentChildren: entries
+          })
+        ];
+      }
+      chapterTitle(tree, id) {
+        const h1 = tree.children.find((n) => n.type === "heading" && n.depth === 1);
+        const title = h1 ? joinSoftBreaks(textOf(h1)).trim() : "";
+        return title || id.replace(/\.md$/i, "");
+      }
+      // -------------------------------------------------------------------------
+      // Blocks
+      paragraph(ctx, options) {
+        let extra = {};
+        if (ctx.body && this.breakNext) {
+          extra = { ...extra, pageBreakBefore: true };
+          this.breakNext = false;
+        }
+        if (ctx.body && this.afterTable) {
+          this.afterTable = false;
+          if (!options.spacing && NO_SPACE_BEFORE.has(options.style)) {
+            extra = { ...extra, spacing: { before: Math.round(this.charTwips * 0.75) } };
+          }
+        }
+        if (!options.numbering && !options.indent && ctx.indent > 0) {
+          extra = { ...extra, indent: { left: ctx.indent + this.styleIndent(options.style) } };
+        }
+        if (!options.numbering && ctx.border && options.style === "Callout") {
+          extra = { ...extra, border: { left: ctx.border } };
+        }
+        return new Paragraph({ ...options, ...extra });
+      }
+      styleIndent(style) {
+        if (style === "Quote") return this.quoteIndent;
+        if (style === "Callout") return this.calloutIndent;
+        return 0;
+      }
+      blocks(nodes, ctx) {
+        const out = [];
+        for (const node of nodes) {
+          for (const child of this.block(node, ctx)) {
+            if (child instanceof Table && out.at(-1) instanceof Table) {
+              out.push(new Paragraph({ style: ctx.style }));
+            }
+            out.push(child);
+          }
+        }
+        return out;
+      }
+      block(node, ctx) {
+        switch (node.type) {
+          case "paragraph":
+            return this.paragraphBlock(node, ctx);
+          case "heading":
+            return [this.heading(node, ctx)];
+          case "thematicBreak":
+            return [
+              this.paragraph(ctx, {
+                style: ctx.body ? "SceneBreak" : ctx.style,
+                alignment: ctx.body ? void 0 : AlignmentType.CENTER,
+                children: [this.textRun(this.e.sceneBreak, {})]
+              })
+            ];
+          case "blockquote": {
+            const alert = readAlert(node);
+            if (alert) return this.callout(alert.type, alert.children, ctx);
+            if (!ctx.body) return this.blocks(node.children, ctx);
+            const quoteCtx = ctx.style === "Quote" ? { ...ctx, indent: ctx.indent + this.quoteIndent } : { ...ctx, style: "Quote", border: void 0 };
+            return this.blocks(node.children, quoteCtx);
+          }
+          case "list":
+            return this.list(node, ctx);
+          case "code":
+            return [this.codeBlock(node, ctx)];
+          case "table":
+            return this.table(node, ctx);
+          case "html":
+            if (ctx.body && isPageBreak(node)) this.breakNext = true;
+            return [];
+          case "definition":
+          case "footnoteDefinition":
+          case "yaml":
+            return [];
+          default: {
+            const text = joinSoftBreaks(textOf(node)).trim();
+            return text ? [this.paragraph(ctx, { style: ctx.style, children: [this.textRun(text, {})] })] : [];
+          }
+        }
+      }
+      paragraphBlock(node, ctx) {
+        const figure = this.figureOf(node);
+        if (figure && ctx.body) return this.figure(figure, ctx);
+        return [
+          this.paragraph(ctx, { style: ctx.style, children: this.inlines(node.children, {}, ctx) })
+        ];
+      }
+      /** The image of a paragraph that holds nothing else. */
+      figureOf(node) {
+        const content = node.children.filter((c) => !(c.type === "text" && !c.value.trim()));
+        if (content.length !== 1) return null;
+        const only = content[0];
+        if (only.type === "image") {
+          return { url: only.url, alt: only.alt ?? "", title: only.title ?? void 0 };
+        }
+        if (only.type === "imageReference") {
+          const def = this.definitions.get(only.identifier);
+          if (def) return { url: def.url, alt: only.alt ?? "", title: def.title ?? void 0 };
+        }
+        return null;
+      }
+      figure(img, ctx) {
+        const alt = joinSoftBreaks(img.alt).trim();
+        const run2 = this.imageRun(img.url, alt, img.title, ctx);
+        if (!run2) {
+          return [
+            this.paragraph(ctx, {
+              style: "Figure",
+              children: [this.textRun(imagePlaceholder(alt, this.labels), {})]
+            })
+          ];
+        }
+        const out = [
+          this.paragraph(ctx, { style: "Figure", keepNext: alt ? true : void 0, children: [run2] })
+        ];
+        if (alt) out.push(this.paragraph(ctx, { style: "Caption", children: [this.textRun(alt, {})] }));
+        return out;
+      }
+      heading(node, ctx) {
+        if (!ctx.body) {
+          return this.paragraph(ctx, {
+            style: ctx.style,
+            children: this.inlines(node.children, { bold: true }, ctx)
+          });
+        }
+        let children = this.inlines(node.children, {}, ctx);
+        const title = joinSoftBreaks(textOf(node)).trim();
+        if (node.depth <= 3 && title) {
+          const id = ++this.bookmarkCount;
+          const anchor = `_Toc${String(id).padStart(8, "0")}`;
+          this.toc.push({ level: node.depth, title, anchor });
+          children = [bookmark(anchor, id, children)];
+        }
+        return this.paragraph(
+          { ...ctx, border: void 0 },
+          { style: `Heading${Math.min(node.depth, 4)}`, children }
+        );
+      }
+      callout(type, children, ctx) {
+        if (!ctx.body) {
+          return [
+            this.paragraph(ctx, {
+              style: ctx.style,
+              children: [this.textRun(this.labels.alerts[type], { bold: true })]
+            }),
+            ...this.blocks(children, ctx)
+          ];
+        }
+        const border = {
+          style: BorderStyle.SINGLE,
+          size: 24,
+          color: ALERT_COLORS[type],
+          space: 8
+        };
+        const inner = { ...ctx, style: "Callout", border };
+        return [
+          this.paragraph(inner, {
+            style: "Callout",
+            keepNext: true,
+            children: [this.textRun(this.labels.alerts[type], { bold: true })]
+          }),
+          ...this.blocks(children, inner)
+        ];
+      }
+      codeBlock(node, ctx) {
+        const lines = node.value.replace(/\t/g, "    ").split(/\r?\n/);
+        const code = !ctx.body;
+        const children = lines.map(
+          (line, i) => new TextRun({
+            text: xmlText(line),
+            break: i > 0 ? 1 : void 0,
+            style: code ? "InlineCode" : void 0
+          })
+        );
+        return this.paragraph(ctx, { style: ctx.body ? "Code" : ctx.style, children });
+      }
+      listLeft(level) {
+        return this.charTwips * 2 * (level + 1);
+      }
+      get hanging() {
+        return Math.round(this.charTwips * 1.5);
+      }
+      list(node, ctx) {
+        const level = Math.min(ctx.listLevel, 8);
+        let reference = "bullet";
+        if (node.ordered) {
+          reference = `ordered-${this.orderedLists.length + 1}`;
+          this.orderedLists.push({ reference, level, start: node.start ?? 1 });
+        }
+        const style = ctx.body ? "ListParagraph" : ctx.style;
+        const itemCtx = {
+          ...ctx,
+          // Later paragraphs of an item: no bullet, aligned with the item's text.
+          style: ctx.body ? "ListContinue" : ctx.style,
+          listLevel: level + 1,
+          indent: this.listLeft(level),
+          border: void 0
+        };
+        const numbering = { reference, level };
+        const out = [];
+        for (const item of node.children) {
+          const box = item.checked === true ? "\u2611 " : item.checked === false ? "\u2610 " : "";
+          const lead = box ? [this.textRun(box, {})] : [];
+          let numbered = false;
+          for (const child of item.children) {
+            if (!numbered) {
+              numbered = true;
+              if (child.type === "paragraph") {
+                out.push(
+                  this.paragraph(ctx, {
+                    style,
+                    numbering,
+                    children: [...lead, ...this.inlines(child.children, {}, itemCtx)]
+                  })
+                );
+                continue;
+              }
+              out.push(this.paragraph(ctx, { style, numbering, children: lead }));
+            }
+            out.push(...this.blocks([child], itemCtx));
+          }
+          if (!numbered) out.push(this.paragraph(ctx, { style, numbering, children: lead }));
+        }
+        return out;
+      }
+      table(node, ctx) {
+        const rows = node.children;
+        if (!rows.length) return [];
+        const out = [];
+        if (ctx.body && this.breakNext) out.push(this.paragraph(ctx, { style: ctx.style }));
+        const cols = Math.max(1, ...rows.map((r) => r.children.length));
+        const available = Math.max(this.contentWidth - ctx.indent, 1440);
+        const widths = columnWidths(node, cols, available);
+        const cellCtx = {
+          style: "TableText",
+          indent: 0,
+          listLevel: 0,
+          body: false,
+          inFootnote: ctx.inFootnote,
+          maxImagePx: available / TWIPS_PER_PX / cols * 0.9
+        };
+        const thin = { style: BorderStyle.SINGLE, size: 4, color: "808080" };
+        const tableRows = rows.map(
+          (row, r) => new TableRow({
+            tableHeader: r === 0 ? true : void 0,
+            children: Array.from({ length: cols }, (_, c) => {
+              const cell = row.children[c];
+              const align = node.align?.[c];
+              return new TableCell({
+                width: { size: widths[c], type: WidthType.DXA },
+                verticalAlign: VerticalAlignTable.CENTER,
+                shading: r === 0 ? { type: ShadingType.CLEAR, color: "auto", fill: "F2F2F2" } : void 0,
+                children: [
+                  new Paragraph({
+                    style: "TableText",
+                    alignment: align === "center" ? AlignmentType.CENTER : align === "right" ? AlignmentType.RIGHT : align === "left" ? AlignmentType.LEFT : void 0,
+                    children: cell ? this.inlines(cell.children, r === 0 ? { bold: true } : {}, cellCtx) : []
+                  })
+                ]
+              });
+            })
+          })
+        );
+        out.push(
+          new Table({
+            rows: tableRows,
+            width: { size: widths.reduce((a, b) => a + b, 0), type: WidthType.DXA },
+            columnWidths: widths,
+            layout: TableLayoutType.FIXED,
+            indent: ctx.indent > 0 ? { size: ctx.indent, type: WidthType.DXA } : void 0,
+            margins: { top: 40, bottom: 40, left: 100, right: 100 },
+            borders: {
+              top: thin,
+              bottom: thin,
+              left: thin,
+              right: thin,
+              insideHorizontal: thin,
+              insideVertical: thin
+            }
+          })
+        );
+        if (ctx.body) this.afterTable = true;
+        return out;
+      }
+      // -------------------------------------------------------------------------
+      // Inline content
+      textRun(text, fmt) {
+        return new TextRun({
+          text: xmlText(text),
+          bold: fmt.bold || void 0,
+          italics: fmt.italics || void 0,
+          strike: fmt.strike || void 0,
+          superScript: fmt.superScript || void 0,
+          subScript: fmt.subScript || void 0,
+          underline: fmt.underline ? {} : void 0,
+          highlight: fmt.highlight ? "yellow" : void 0,
+          style: fmt.code ? "InlineCode" : fmt.link ? "Hyperlink" : void 0
+        });
+      }
+      inlines(nodes, fmt, ctx) {
+        const out = [];
+        let local = { ...fmt };
+        for (const node of nodes) {
+          switch (node.type) {
+            case "text": {
+              const text = joinSoftBreaks(node.value);
+              if (text) out.push(this.textRun(text, local));
+              break;
+            }
+            case "emphasis":
+              out.push(...this.inlines(node.children, { ...local, italics: true }, ctx));
+              break;
+            case "strong":
+              out.push(...this.inlines(node.children, { ...local, bold: true }, ctx));
+              break;
+            case "delete":
+              out.push(...this.inlines(node.children, { ...local, strike: true }, ctx));
+              break;
+            case "inlineCode":
+              out.push(this.textRun(node.value, { ...local, code: true }));
+              break;
+            case "break":
+              out.push(new TextRun({ break: 1 }));
+              break;
+            case "link":
+              out.push(...this.link(node.url, node.children, local, ctx));
+              break;
+            case "linkReference": {
+              const def = this.definitions.get(node.identifier);
+              if (def) out.push(...this.link(def.url, node.children, local, ctx));
+              else out.push(...this.inlines(node.children, local, ctx));
+              break;
+            }
+            case "image":
+              out.push(this.inlineImage(node.url, node.alt ?? "", node.title ?? void 0, local, ctx));
+              break;
+            case "imageReference": {
+              const def = this.definitions.get(node.identifier);
+              if (def) {
+                out.push(this.inlineImage(def.url, node.alt ?? "", def.title ?? void 0, local, ctx));
+              } else if (node.alt) {
+                out.push(this.textRun(node.alt, local));
+              }
+              break;
+            }
+            case "footnoteReference":
+              out.push(this.footnoteRef(node, ctx));
+              break;
+            case "html":
+              local = this.inlineHtml(node.value, local, fmt, out);
+              break;
+            default: {
+              const text = joinSoftBreaks(textOf(node));
+              if (text) out.push(this.textRun(text, local));
+            }
+          }
+        }
+        return out;
+      }
+      /** `<br>` becomes a line break; `<sup>`, `<u>`, `<mark>`… toggle formatting; other tags vanish. */
+      inlineHtml(value, local, parent, out) {
+        const tag = /^<\s*(\/)?\s*([a-z][a-z0-9]*)\b[^>]*>$/i.exec(value.trim());
+        if (!tag) return local;
+        const name = tag[2].toLowerCase();
+        if (name === "br") {
+          out.push(new TextRun({ break: 1 }));
+          return local;
+        }
+        const key = HTML_FORMAT[name];
+        if (!key) return local;
+        return { ...local, [key]: tag[1] ? parent[key] : true };
+      }
+      link(url, children, fmt, ctx) {
+        const href = url.trim();
+        if (!/^https?:\/\//i.test(href)) return this.inlines(children, fmt, ctx);
+        const inner = this.inlines(children, { ...fmt, link: true }, ctx);
+        return [
+          new ExternalHyperlink({
+            link: href,
+            children: inner.length ? inner : [this.textRun(href, { ...fmt, link: true })]
+          })
+        ];
+      }
+      inlineImage(url, alt, title, fmt, ctx) {
+        const text = joinSoftBreaks(alt).trim();
+        return this.imageRun(url, text, title, ctx) ?? this.textRun(imagePlaceholder(text, this.labels), fmt);
+      }
+      imageRun(url, alt, title, ctx) {
+        const image = this.images.get(url);
+        if (!image || !DOCX_IMAGE_TYPES.has(image.type) || !image.width || !image.height) return null;
+        const maxWidth = Math.max(
+          24,
+          Math.min(
+            ctx.maxImagePx ?? Number.POSITIVE_INFINITY,
+            this.contentWidthPx - ctx.indent / TWIPS_PER_PX
+          )
+        );
+        const maxHeight = this.contentHeightPx * 0.8;
+        const scale = Math.min(1, maxWidth / image.width, maxHeight / image.height);
+        return new ImageRun({
+          type: image.type,
+          data: image.data,
+          transformation: {
+            width: Math.max(1, Math.round(image.width * scale)),
+            height: Math.max(1, Math.round(image.height * scale))
+          },
+          altText: {
+            name: xmlText(image.name),
+            description: xmlText(alt),
+            title: xmlText(title ?? alt)
+          }
+        });
+      }
+      footnoteRef(node, ctx) {
+        const def = this.footnoteDefs.get(node.identifier);
+        if (!def || ctx.inFootnote) {
+          return this.textRun(
+            def ? node.label ?? node.identifier : `[^${node.label ?? node.identifier}]`,
+            {
+              superScript: Boolean(def)
+            }
+          );
+        }
+        const id = ++this.footnoteCount;
+        const noteCtx = {
+          style: "FootnoteText",
+          indent: 0,
+          listLevel: 0,
+          body: false,
+          inFootnote: true
+        };
+        const paragraphs = this.blocks(def.children, noteCtx).filter(
+          (b) => b instanceof Paragraph
+        );
+        if (!paragraphs.length) paragraphs.push(new Paragraph({ style: "FootnoteText" }));
+        paragraphs[0].addRunToFront(new TextRun(" "));
+        this.footnotes[id] = { children: paragraphs };
+        return new FootnoteReferenceRun(id);
+      }
+      // -------------------------------------------------------------------------
+      // Styles and numbering
+      numbering() {
+        const indent = (level) => ({
+          paragraph: { indent: { left: this.listLeft(level), hanging: this.hanging } }
+        });
+        const levels = Array.from({ length: 9 }, (_, level) => level);
+        return [
+          {
+            reference: "bullet",
+            levels: levels.map((level) => ({
+              level,
+              format: LevelFormat.BULLET,
+              text: BULLETS[level % BULLETS.length],
+              alignment: AlignmentType.LEFT,
+              style: indent(level)
+            }))
+          },
+          ...this.orderedLists.map((list) => ({
+            reference: list.reference,
+            levels: levels.map((level) => ({
+              level,
+              format: ORDERED_FORMATS[level % ORDERED_FORMATS.length],
+              text: `%${level + 1}.`,
+              start: level === list.level ? list.start : 1,
+              alignment: AlignmentType.LEFT,
+              style: indent(level)
+            }))
+          }))
+        ];
+      }
+      styles() {
+        const e = this.e;
+        const ch = this.charTwips;
+        const size = halfPoints(e.fontSize);
+        const after = Math.round(e.paragraphSpacing * 20);
+        const cjk = isCjkLanguage(this.config.language);
+        const hint = cjk ? "eastAsia" : void 0;
+        const font = (eastAsia, latin = e.fonts.latin) => ({
+          ascii: latin,
+          hAnsi: latin,
+          cs: latin,
+          eastAsia,
+          hint
+        });
+        const bodyFont = font(e.fonts.body);
+        const headingFont = font(e.fonts.heading);
+        const codeFont = font(e.fonts.body, e.fonts.code);
+        const language = cjk ? { value: "en-US", eastAsia: this.config.language } : { value: this.config.language || "en-US", eastAsia: "zh-TW" };
+        const single = { line: 240, lineRule: LineRuleType.AUTO };
+        const headingLine = { line: 288, lineRule: LineRuleType.AUTO };
+        const style = (id, name, options) => new StyleForParagraph({ id, name, basedOn: "Normal", quickFormat: true, ...options });
+        const heading = (level, factor, before, afterSpace) => style(`Heading${level}`, `heading ${level}`, {
+          next: "BodyText",
+          run: { font: headingFont, size: halfPoints(e.fontSize * factor), bold: true },
+          paragraph: {
+            keepNext: true,
+            keepLines: true,
+            outlineLevel: level - 1,
+            alignment: level === 1 ? AlignmentType.CENTER : AlignmentType.LEFT,
+            spacing: { ...headingLine, before: Math.round(before), after: Math.round(afterSpace) }
+          }
+        });
+        const toc = (level) => style(`TOC${level}`, `toc ${level}`, {
+          next: "Normal",
+          quickFormat: false,
+          paragraph: {
+            indent: { left: ch * 2 * (level - 1) },
+            spacing: { before: level === 1 ? Math.round(ch / 2) : 0, after: 0 }
+          }
+        });
+        return [
+          new DocumentDefaults({
+            run: { font: bodyFont, size, sizeComplexScript: size, language },
+            paragraph: {
+              spacing: { line: Math.round(240 * e.lineSpacing), lineRule: LineRuleType.AUTO }
+            }
+          }),
+          new DefaultParagraphStyle({
+            id: "Normal",
+            name: "Normal",
+            quickFormat: true,
+            run: { font: bodyFont, size, sizeComplexScript: size, language },
+            paragraph: {
+              spacing: {
+                line: Math.round(240 * e.lineSpacing),
+                lineRule: LineRuleType.AUTO,
+                before: 0,
+                after: 0
+              }
+            }
+          }),
+          style("BodyText", "Body Text", {
+            next: "BodyText",
+            paragraph: {
+              alignment: AlignmentType.BOTH,
+              indent: { firstLine: Math.round(e.firstLineIndent * ch) },
+              spacing: { after }
+            }
+          }),
+          heading(1, 1.75, ch * 2, ch * 1.5),
+          heading(2, 1.4, ch * 1.5, ch * 0.5),
+          heading(3, 1.2, ch, ch * 0.5),
+          heading(4, 1.05, ch * 0.75, ch * 0.25),
+          style("Title", "Title", {
+            next: "Subtitle",
+            run: { font: headingFont, size: halfPoints(e.fontSize * 2.4), bold: true },
+            paragraph: {
+              alignment: AlignmentType.CENTER,
+              // About a quarter down the page; section vAlign is ignored by LibreOffice.
+              spacing: { ...headingLine, before: Math.round(this.contentHeight * 0.25), after: ch * 2 }
+            }
+          }),
+          style("Subtitle", "Subtitle", {
+            next: "Author",
+            run: { font: headingFont, size: halfPoints(e.fontSize * 1.5) },
+            paragraph: { alignment: AlignmentType.CENTER, spacing: { ...headingLine, after: ch } }
+          }),
+          style("Author", "Author", {
+            run: { size: halfPoints(e.fontSize * 1.25) },
+            paragraph: { alignment: AlignmentType.CENTER, spacing: { before: ch * 4, after: ch } }
+          }),
+          style("TOCHeading", "TOC Heading", {
+            next: "Normal",
+            run: { font: headingFont, size: halfPoints(e.fontSize * 1.75), bold: true },
+            paragraph: {
+              alignment: AlignmentType.CENTER,
+              keepNext: true,
+              spacing: { ...headingLine, before: ch * 2, after: ch * 1.5 }
+            }
+          }),
+          toc(1),
+          toc(2),
+          toc(3),
+          style("ListParagraph", "List Paragraph", {
+            paragraph: { alignment: AlignmentType.BOTH, contextualSpacing: true, spacing: { after } }
+          }),
+          style("ListContinue", "List Continue", {
+            paragraph: {
+              alignment: AlignmentType.BOTH,
+              indent: { left: this.listLeft(0) },
+              spacing: { after }
+            }
+          }),
+          style("Quote", "Quote", {
+            next: "BodyText",
+            run: { color: "404040" },
+            paragraph: {
+              alignment: AlignmentType.BOTH,
+              indent: { left: this.quoteIndent, right: this.quoteIndent },
+              spacing: { after: Math.max(after, 120) },
+              border: { left: { style: BorderStyle.SINGLE, size: 12, color: "A6A6A6", space: 8 } }
+            }
+          }),
+          style("Callout", "Callout", {
+            next: "BodyText",
+            paragraph: {
+              alignment: AlignmentType.BOTH,
+              contextualSpacing: true,
+              indent: { left: this.calloutIndent, right: this.calloutIndent },
+              spacing: { after: Math.max(after, 120) },
+              shading: { type: ShadingType.CLEAR, color: "auto", fill: "F3F5F8" },
+              border: { left: { style: BorderStyle.SINGLE, size: 24, color: "7F8C9A", space: 8 } }
+            }
+          }),
+          style("Code", "Code", {
+            next: "BodyText",
+            run: { font: codeFont, size: halfPoints(e.fontSize * 0.85), noProof: true },
+            paragraph: {
+              alignment: AlignmentType.LEFT,
+              spacing: { ...single, before: 60, after: Math.max(after, 120) },
+              shading: { type: ShadingType.CLEAR, color: "auto", fill: "F2F2F2" }
+            }
+          }),
+          style("Figure", "Figure", {
+            next: "Caption",
+            paragraph: {
+              alignment: AlignmentType.CENTER,
+              spacing: { before: 120, after: 60 }
+            }
+          }),
+          style("Caption", "caption", {
+            next: "BodyText",
+            run: { size: halfPoints(e.fontSize * 0.85), color: "404040" },
+            paragraph: {
+              alignment: AlignmentType.CENTER,
+              keepLines: true,
+              spacing: { ...single, after: Math.max(after, 120) }
+            }
+          }),
+          style("SceneBreak", "Scene Break", {
+            next: "BodyText",
+            paragraph: {
+              alignment: AlignmentType.CENTER,
+              spacing: { before: ch, after: ch + after }
+            }
+          }),
+          style("TableText", "Table Text", {
+            quickFormat: false,
+            paragraph: { spacing: { ...single, before: 40, after: 40 } }
+          }),
+          style("FootnoteText", "footnote text", {
+            quickFormat: false,
+            run: { size: halfPoints(Math.max(8, e.fontSize - 2)) },
+            paragraph: { alignment: AlignmentType.BOTH, spacing: { ...single, after: 0 } }
+          }),
+          style("Header", "header", {
+            quickFormat: false,
+            run: { size: halfPoints(e.fontSize * 0.75), color: "595959" },
+            paragraph: { alignment: AlignmentType.CENTER, spacing: { ...single, after: 0 } }
+          }),
+          style("Footer", "footer", {
+            quickFormat: false,
+            run: { size: halfPoints(e.fontSize * 0.75) },
+            paragraph: { alignment: AlignmentType.CENTER, spacing: { ...single, after: 0 } }
+          }),
+          new StyleForCharacter({
+            id: "Hyperlink",
+            name: "Hyperlink",
+            basedOn: "DefaultParagraphFont",
+            run: { color: "0563C1", underline: {} }
+          }),
+          new StyleForCharacter({
+            id: "FootnoteReference",
+            name: "footnote reference",
+            basedOn: "DefaultParagraphFont",
+            run: { superScript: true }
+          }),
+          new StyleForCharacter({
+            id: "InlineCode",
+            name: "Inline Code",
+            basedOn: "DefaultParagraphFont",
+            run: {
+              font: codeFont,
+              size: halfPoints(e.fontSize * 0.9),
+              noProof: true,
+              shading: { type: ShadingType.CLEAR, color: "auto", fill: "F2F2F2" }
+            }
+          })
+        ];
+      }
+    };
+  }
+});
+
+// src/node/export/html.ts
+import rehypeStringify from "rehype-stringify";
+import remarkRehype from "remark-rehype";
+import { unified as unified2 } from "unified";
+function escapeHtml(text) {
+  return text.replace(/[&<>"']/g, (ch) => HTML_ESCAPES[ch]);
+}
+function cssString(text) {
+  return `"${text.replace(/[\r\n\f]/g, " ").replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/</g, "\\3c ")}"`;
+}
+function wrapInlineHtml(parent) {
+  const kids = parent.children;
+  for (let i = 0; i < kids.length; i++) {
+    const node = kids[i];
+    if (node.type !== "html") continue;
+    const open = /^<([a-z]+)(?:\s[^<>]*)?>$/i.exec(node.value.trim());
+    const tag = open?.[1].toLowerCase();
+    if (!tag || !INLINE_TAGS.has(tag)) continue;
+    const closing = new RegExp(`^</${tag}\\s*>$`, "i");
+    const close = kids.findIndex(
+      (n, j) => j > i && n.type === "html" && closing.test(n.value.trim())
+    );
+    if (close === -1) continue;
+    const wrapped = {
+      type: "emphasis",
+      data: { hName: tag },
+      children: kids.slice(i + 1, close)
+    };
+    kids.splice(i, close - i + 1, wrapped);
+  }
+}
+function prefixFootnoteLabel(node, prefix) {
+  if (node.type === "element") {
+    const props = node.properties;
+    if (props.id === "footnote-label") props.id = `${prefix}footnote-label`;
+    if (Array.isArray(props.ariaDescribedBy)) {
+      props.ariaDescribedBy = props.ariaDescribedBy.map(
+        (v) => v === "footnote-label" ? `${prefix}footnote-label` : v
+      );
+    }
+  }
+  if ("children" in node) for (const child of node.children) prefixFootnoteLabel(child, prefix);
+}
+function element(tagName, className, children) {
+  return {
+    type: "element",
+    tagName,
+    properties: className ? { className: [className] } : {},
+    children
+  };
+}
+async function buildHtml(input) {
+  return new HtmlBuilder(input).build();
+}
+var HTML_ESCAPES, round, INLINE_TAGS, HtmlBuilder;
+var init_html = __esm({
+  "src/node/export/html.ts"() {
+    "use strict";
+    init_config();
+    init_markdown();
+    init_common();
+    HTML_ESCAPES = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;"
+    };
+    round = (n) => Math.round(n * 100) / 100;
+    INLINE_TAGS = /* @__PURE__ */ new Set([
+      "sup",
+      "sub",
+      "u",
+      "ins",
+      "mark",
+      "s",
+      "del",
+      "b",
+      "strong",
+      "i",
+      "em",
+      "kbd",
+      "small"
+    ]);
+    HtmlBuilder = class {
+      constructor(input) {
+        this.input = input;
+        this.labels = labelsFor(input.config.language);
+      }
+      input;
+      labels;
+      images = /* @__PURE__ */ new Map();
+      toc = [];
+      async build() {
+        const trees = this.input.chapters.map((c) => prepareChapter(c.source));
+        this.images = await loadImages(
+          trees.flatMap((t) => imageUrls(t)),
+          this.input.root
+        );
+        const sections = [];
+        for (const [i, tree] of trees.entries()) {
+          const prefix = `ch${i + 1}-`;
+          this.transform(tree, prefix);
+          const processor2 = unified2().use(remarkRehype, {
+            allowDangerousHtml: false,
+            clobberPrefix: prefix,
+            footnoteLabel: this.labels.footnotes,
+            footnoteLabelTagName: "h2",
+            footnoteLabelProperties: { className: ["footnotes-title"] },
+            footnoteBackLabel: (n) => `${this.labels.backToText} ${n + 1}`
+          }).use(rehypeStringify);
+          const hast = await processor2.run(tree);
+          prefixFootnoteLabel(hast, prefix);
+          const body = processor2.stringify(hast);
+          sections.push(
+            `<section class="chapter" id="${prefix}start" data-chapter="${escapeHtml(this.input.chapters[i].id)}">
+${body}
+</section>`
+          );
+        }
+        const { config } = this.input;
+        const title = config.title || this.labels.untitled;
+        return [
+          "<!DOCTYPE html>",
+          `<html lang="${escapeHtml(config.language || "zh-TW")}">`,
+          "<head>",
+          '<meta charset="utf-8">',
+          '<meta name="viewport" content="width=device-width, initial-scale=1">',
+          '<meta name="generator" content="MoSage">',
+          config.author ? `<meta name="author" content="${escapeHtml(config.author)}">` : "",
+          `<title>${escapeHtml(title)}</title>`,
+          `<style>
+${this.css()}
+</style>`,
+          "</head>",
+          "<body>",
+          config.export.titlePage ? this.titlePage() : "",
+          config.export.toc ? this.contents() : "",
+          "<main>",
+          sections.join("\n"),
+          "</main>",
+          "</body>",
+          "</html>",
+          ""
+        ].filter((line) => line !== "").join("\n");
+      }
+      titlePage() {
+        const c = this.input.config;
+        return [
+          '<header class="title-page">',
+          `<h1 class="book-title">${escapeHtml(c.title || this.labels.untitled)}</h1>`,
+          c.subtitle ? `<p class="book-subtitle">${escapeHtml(c.subtitle)}</p>` : "",
+          c.author ? `<p class="book-author">${escapeHtml(c.author)}</p>` : "",
+          "</header>"
+        ].filter(Boolean).join("\n");
+      }
+      contents() {
+        const items = this.toc.map(
+          (e) => `<li class="toc-${e.level}"><a href="#${escapeHtml(e.id)}">${escapeHtml(e.text)}</a></li>`
+        ).join("\n");
+        return `<nav class="toc" aria-labelledby="toc-title">
+<h2 id="toc-title" class="toc-title">${escapeHtml(this.labels.contents)}</h2>
+<ol class="toc-list">
+${items}
+</ol>
+</nav>`;
+      }
+      /** Rewrite the mdast in place: ids, alerts, scene and page breaks, images, soft breaks. */
+      transform(tree, prefix) {
+        const definitions = collectDefinitions(tree);
+        let headings = 0;
+        const visit = (parent) => {
+          wrapInlineHtml(parent);
+          const children = parent.children;
+          for (let i = 0; i < children.length; i++) {
+            const node = children[i];
+            switch (node.type) {
+              case "heading": {
+                const id = `${prefix}h${++headings}`;
+                node.data = { ...node.data, hProperties: { ...node.data?.hProperties, id } };
+                const text = joinSoftBreaks(textOf(node)).trim();
+                if (node.depth <= 3 && text && parent.type === "root") {
+                  this.toc.push({ level: node.depth, text, id });
+                }
+                break;
+              }
+              case "blockquote": {
+                const alert = readAlert(node);
+                if (alert) {
+                  node.children = [
+                    {
+                      type: "paragraph",
+                      data: { hProperties: { className: ["callout-title"] } },
+                      children: [{ type: "text", value: this.labels.alerts[alert.type] }]
+                    },
+                    ...alert.children
+                  ];
+                  node.data = {
+                    ...node.data,
+                    hName: "aside",
+                    hProperties: { className: ["callout", `callout-${alert.type}`] }
+                  };
+                }
+                break;
+              }
+              case "thematicBreak":
+                children[i] = {
+                  type: "paragraph",
+                  data: { hProperties: { className: ["scene-break"] } },
+                  children: [{ type: "text", value: this.input.config.export.sceneBreak }]
+                };
+                continue;
+              case "html":
+                if (isPageBreak(node)) {
+                  children[i] = {
+                    type: "paragraph",
+                    data: { hName: "div", hProperties: { className: ["page-break"] } },
+                    children: []
+                  };
+                } else if (/^<br\s*\/?>$/i.test(node.value.trim())) {
+                  children[i] = { type: "break" };
+                }
+                continue;
+              case "text":
+                node.value = joinSoftBreaks(node.value);
+                continue;
+              case "paragraph": {
+                const figure = this.figureOf(node.children, definitions);
+                if (figure) {
+                  node.data = { ...node.data, hName: "figure", hChildren: this.figure(figure) };
+                  continue;
+                }
+                break;
+              }
+              case "image":
+              case "imageReference": {
+                const def = node.type === "imageReference" ? definitions.get(node.identifier) : null;
+                const url = node.type === "image" ? node.url : def?.url;
+                const src = url === void 0 ? null : this.source(url);
+                if (src === null) {
+                  children[i] = {
+                    type: "text",
+                    value: imagePlaceholder(joinSoftBreaks(node.alt ?? ""), this.labels)
+                  };
+                } else if (node.type === "image") {
+                  node.url = src;
+                } else if (def) {
+                  children[i] = { type: "image", url: src, alt: node.alt, title: def.title };
+                }
+                continue;
+              }
+            }
+            if ("children" in node) visit(node);
+          }
+        };
+        visit(tree);
+      }
+      /** Data URI of a local image, the URL itself for a remote one, null when it cannot be shown. */
+      source(url) {
+        if (/^https?:\/\//i.test(url.trim())) return url.trim();
+        const image = this.images.get(url);
+        return image ? `data:${image.mime};base64,${image.data.toString("base64")}` : null;
+      }
+      figureOf(children, definitions) {
+        const content = children.filter((c) => !(c.type === "text" && !c.value.trim()));
+        if (content.length !== 1) return null;
+        const only = content[0];
+        let url;
+        let title;
+        if (only.type === "image") {
+          url = only.url;
+          title = only.title ?? void 0;
+        } else if (only.type === "imageReference") {
+          const def = definitions.get(only.identifier);
+          url = def?.url;
+          title = def?.title ?? void 0;
+        }
+        if (url === void 0 || only.type !== "image" && only.type !== "imageReference") return null;
+        const alt = joinSoftBreaks(only.alt ?? "").trim();
+        return { src: this.source(url), alt, title };
+      }
+      figure(figure) {
+        if (figure.src === null) {
+          return [
+            element("p", "image-missing", [
+              { type: "text", value: imagePlaceholder(figure.alt, this.labels) }
+            ])
+          ];
+        }
+        const img = {
+          type: "element",
+          tagName: "img",
+          properties: {
+            src: figure.src,
+            alt: figure.alt,
+            ...figure.title ? { title: figure.title } : {}
+          },
+          children: []
+        };
+        if (!figure.alt) return [img];
+        return [img, element("figcaption", null, [{ type: "text", value: figure.alt }])];
+      }
+      css() {
+        const { config } = this.input;
+        const e = config.export;
+        const size = pageSizeMm(e.pageSize);
+        const m = e.margins;
+        const contentHeight = Math.max(20, size.height - m.top - m.bottom);
+        const bodyFonts = `${cssString(e.fonts.latin)}, ${cssString(e.fonts.body)}, serif`;
+        const headingFonts = `${cssString(e.fonts.latin)}, ${cssString(e.fonts.heading)}, serif`;
+        const codeFonts = `${cssString(e.fonts.code)}, ${cssString(e.fonts.body)}, monospace`;
+        const lineHeight = round(Math.max(1, e.lineSpacing) * 1.2);
+        const pageBox = [];
+        if (e.pageNumbers) pageBox.push("  @bottom-center { content: counter(page); font-size: 9pt; }");
+        if (e.header === "title" && config.title) {
+          pageBox.push(
+            `  @top-center { content: ${cssString(config.title)}; font-size: 9pt; color: #595959; }`
+          );
+        }
+        const alerts = ALERT_TYPES.map(
+          (type) => `.callout-${type} { border-left-color: #${ALERT_COLORS[type]}; }
+.callout-${type} .callout-title { color: #${ALERT_COLORS[type]}; }`
+        ).join("\n");
+        return `@page {
+  size: ${size.width}mm ${size.height}mm;
+  margin: ${m.top}mm ${m.right}mm ${m.bottom}mm ${m.left}mm;
+${pageBox.join("\n")}
+}
+@page front {
+  @top-center { content: none; }
+  @bottom-center { content: none; }
+}
+:root { color-scheme: light; }
+html { background: #fff; color: #000; }
+body {
+  font-family: ${bodyFonts};
+  font-size: ${e.fontSize}pt;
+  line-height: ${lineHeight};
+  margin: 0;
+  text-rendering: optimizeLegibility;
+  font-kerning: normal;
+}
+@media screen {
+  body { max-width: ${round(size.width - m.left - m.right)}mm; margin: 2em auto 6em; padding: 0 1.5em; }
+  .title-page, .toc, .chapter { border-bottom: 1px dashed #ccc; padding-bottom: 2em; margin-bottom: 2em; }
+}
+h1, h2, h3, h4, h5, h6 {
+  font-family: ${headingFonts};
+  font-weight: bold;
+  line-height: 1.3;
+  break-after: avoid;
+  page-break-after: avoid;
+}
+.chapter h1 { font-size: 1.75em; text-align: center; margin: 2em 0 1.5em; }
+.chapter h2 { font-size: 1.4em; margin: 1.5em 0 0.5em; }
+.chapter h3 { font-size: 1.2em; margin: 1em 0 0.5em; }
+.chapter h4, .chapter h5, .chapter h6 { font-size: 1.05em; margin: 0.75em 0 0.25em; }
+p { margin: 0 0 ${e.paragraphSpacing}pt; text-align: justify; orphans: 2; widows: 2; }
+.chapter p { text-indent: ${e.firstLineIndent}em; }
+.chapter li p, .chapter blockquote p, .chapter td p, .chapter th p, .chapter .footnotes p,
+.chapter figure p, .chapter p.scene-break, .chapter p.callout-title { text-indent: 0; }
+.title-page {
+  page: front;
+  break-after: page;
+  page-break-after: always;
+  min-height: calc(${contentHeight}mm - 2mm);
+  display: flex;
+  flex-direction: column;
+  justify-content: center;
+  text-align: center;
+}
+.book-title { font-size: 2.4em; margin: 0 0 1em; }
+.book-subtitle { font-size: 1.5em; margin: 0 0 1em; text-indent: 0; text-align: center; }
+.book-author { font-size: 1.25em; margin: 3em 0 0; text-indent: 0; text-align: center; }
+.toc { page: front; break-after: page; page-break-after: always; }
+.toc-title { text-align: center; font-size: 1.75em; margin: 2em 0 1.5em; }
+.toc-list { list-style: none; margin: 0; padding: 0; }
+.toc-list a { color: inherit; text-decoration: none; }
+.toc-1 { margin-top: 0.5em; }
+.toc-2 { padding-left: 2em; }
+.toc-3 { padding-left: 4em; }
+${e.chapterPageBreak ? ".chapter { break-before: page; page-break-before: always; }" : ".chapter + .chapter { margin-top: 3em; }"}
+.page-break { break-after: page; page-break-after: always; height: 0; }
+.scene-break { text-align: center; margin: 1em 0; }
+blockquote {
+  margin: 0 2em ${Math.max(e.paragraphSpacing, 6)}pt;
+  padding-left: 0.8em;
+  border-left: 2px solid #a6a6a6;
+  color: #404040;
+}
+.callout {
+  margin: 1em 0.5em;
+  padding: 0.5em 1em;
+  background: #f3f5f8;
+  border-left: 4px solid #7f8c9a;
+  break-inside: avoid;
+}
+.callout > :last-child { margin-bottom: 0; }
+.callout-title { font-weight: bold; margin-bottom: 0.25em; }
+${alerts}
+pre {
+  font-family: ${codeFonts};
+  font-size: 0.85em;
+  line-height: 1.35;
+  background: #f2f2f2;
+  padding: 0.6em 0.8em;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  margin: 0.25em 0 1em;
+}
+code { font-family: ${codeFonts}; font-size: 0.9em; }
+:not(pre) > code { background: #f2f2f2; padding: 0 0.2em; border-radius: 2px; }
+ul, ol { margin: 0 0 ${e.paragraphSpacing}pt; padding-left: 2em; }
+li > p { margin: 0; }
+table { border-collapse: collapse; width: 100%; margin: 0.5em 0 1em; font-size: 0.95em; line-height: 1.4; }
+th, td { border: 1px solid #808080; padding: 0.25em 0.5em; vertical-align: middle; }
+th { background: #f2f2f2; font-weight: bold; }
+thead { display: table-header-group; }
+tr { break-inside: avoid; }
+figure { margin: 1em 0; text-align: center; break-inside: avoid; }
+figure img { max-width: 100%; max-height: ${round(contentHeight * 0.8)}mm; }
+figcaption { font-size: 0.85em; color: #404040; margin-top: 0.3em; text-indent: 0; }
+img { max-width: 100%; }
+a { color: #0563c1; }
+.footnotes { margin-top: 2em; border-top: 1px solid #999; font-size: 0.85em; }
+.footnotes-title { font-size: 1em; margin: 0.5em 0; }
+.footnotes ol { padding-left: 1.5em; }
+sup a[data-footnote-ref] { text-decoration: none; }
+@media print {
+  a { color: inherit; text-decoration: none; }
+  a[data-footnote-backref] { display: none; }
+}`;
+      }
+    };
+  }
+});
+
+// src/node/export/markdown.ts
+import { isAbsolute as isAbsolute2, join as join5, relative as relative3, sep as sep3 } from "path";
+function rewriteUrl(url, root, outputDir) {
+  const trimmed = url.trim();
+  if (!trimmed || trimmed.startsWith("#") || isExternalUrl(trimmed) || isAbsolute2(trimmed)) {
+    return url;
+  }
+  const file = resolveLocalFile(trimmed, root) ?? imageCandidates(trimmed, root)[0];
+  if (!file) return url;
+  return relative3(outputDir, file).split(sep3).join("/");
+}
+function chapterMarkdown(source, index, root, outputDir) {
+  const clean = stripMarkers(source);
+  const tree = parseMarkdown(clean);
+  const prefix = `ch${index + 1}-`;
+  const imageRefs = /* @__PURE__ */ new Set();
+  walk(tree, (node) => {
+    if (node.type === "imageReference") imageRefs.add(node.identifier);
+  });
+  const edits = [];
+  const visit = (node) => {
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (start === void 0 || end === void 0) return;
+    switch (node.type) {
+      case "yaml":
+        edits.push({ start, end, text: "" });
+        return;
+      case "html":
+        if (isMarker(node.value)) {
+          edits.push({ start, end: clean[end] === "\n" ? end + 1 : end, text: "" });
+        }
+        return;
+      case "footnoteReference":
+        edits.push({ start, end, text: `[^${prefix}${node.label ?? node.identifier}]` });
+        return;
+      case "footnoteDefinition": {
+        const label = /^\[\^([^\]]+)\]:/.exec(clean.slice(start, end));
+        if (label) {
+          edits.push({ start, end: start + label[0].length, text: `[^${prefix}${label[1]}]:` });
+        }
+        break;
+      }
+      case "image": {
+        const url = rewriteUrl(node.url, root, outputDir);
+        if (url !== node.url) {
+          edits.push({
+            start,
+            end,
+            text: `![${markdownAlt(node.alt ?? "")}](${markdownUrl(url)}${markdownTitle(node.title)})`
+          });
+        }
+        return;
+      }
+      case "definition": {
+        if (!imageRefs.has(node.identifier)) return;
+        const url = rewriteUrl(node.url, root, outputDir);
+        if (url !== node.url) {
+          edits.push({
+            start,
+            end,
+            text: `[${node.label ?? node.identifier}]: ${markdownUrl(url)}${markdownTitle(node.title)}`
+          });
+        }
+        return;
+      }
+    }
+    if ("children" in node) for (const child of node.children) visit(child);
+  };
+  visit(tree);
+  return applyEdits(clean, edits).trim();
+}
+function buildMarkdown(input) {
+  const outputDir = input.outputDir ?? join5(input.root, "output");
+  const parts = input.chapters.map((c, i) => chapterMarkdown(c.source, i, input.root, outputDir)).filter((part) => part !== "");
+  return parts.length ? `${parts.join("\n\n")}
+` : "";
+}
+var init_markdown2 = __esm({
+  "src/node/export/markdown.ts"() {
+    "use strict";
+    init_annotations();
+    init_markdown();
+    init_common();
+  }
+});
+
+// src/node/export/index.ts
+var export_exports = {};
+__export(export_exports, {
+  EXPORT_FORMATS: () => EXPORT_FORMATS,
+  buildDocx: () => buildDocx,
+  buildHtml: () => buildHtml,
+  buildMarkdown: () => buildMarkdown,
+  exportManuscript: () => exportManuscript,
+  renderManuscript: () => renderManuscript
+});
+import { mkdir as mkdir4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname3, join as join6, resolve as resolve2 } from "path";
+async function render(book, format, outputDir) {
+  if (!EXPORT_FORMATS.includes(format)) throw new Error(`\u4E0D\u652F\u63F4\u7684\u532F\u51FA\u683C\u5F0F\uFF1A${format}`);
+  const { config, chapters } = await book.loadManuscript();
+  const input = { config, chapters, root: book.root, outputDir };
+  let data;
+  if (format === "docx") data = await buildDocx(input);
+  else if (format === "html") data = Buffer.from(await buildHtml(input), "utf8");
+  else data = Buffer.from(buildMarkdown(input), "utf8");
+  return {
+    data,
+    fileName: `${sanitizeFileName(config.export.fileName || config.title)}.${format}`,
+    contentType: CONTENT_TYPES[format]
+  };
+}
+async function renderManuscript(book, format) {
+  return render(book, format, book.outputDir);
+}
+async function exportManuscript(book, format, outFile) {
+  const target = outFile ? resolve2(outFile) : null;
+  const file = await render(book, format, target ? dirname3(target) : book.outputDir);
+  const path = target ?? join6(book.outputDir, file.fileName);
+  await mkdir4(dirname3(path), { recursive: true });
+  await writeFile4(path, file.data);
+  return { path, bytes: file.data.length };
+}
+var EXPORT_FORMATS, CONTENT_TYPES;
+var init_export = __esm({
+  "src/node/export/index.ts"() {
+    "use strict";
+    init_common();
+    init_docx();
+    init_html();
+    init_markdown2();
+    EXPORT_FORMATS = ["docx", "html", "md"];
+    CONTENT_TYPES = {
+      docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      html: "text/html; charset=utf-8",
+      md: "text/markdown; charset=utf-8"
+    };
+  }
+});
+
+// src/node/import/markdown.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync9, statSync as statSync2 } from "fs";
+import { copyFile, mkdir as mkdir6, readFile as readFile7 } from "fs/promises";
+import { basename as basename4, dirname as dirname6, extname as extname4, isAbsolute as isAbsolute3, join as join10, relative as relative6, resolve as resolve6, sep as sep5 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function posix(path) {
+  return path.split(sep5).join("/");
+}
+function safeName(name) {
+  return name.normalize("NFC").replace(/[\s()[\]<>{}#%?*:|"'\\/]+/g, "-").replace(/-+/g, "-").replace(/^[-.]+|-+$/g, "").slice(0, 60) || "image";
+}
+async function sameContent(a, b) {
+  if (statSync2(a).size !== statSync2(b).size) return false;
+  const hash2 = async (p) => createHash2("sha1").update(await readFile7(p)).digest("hex");
+  return await hash2(a) === await hash2(b);
+}
+async function copyInto(file, dir) {
+  await mkdir6(dir, { recursive: true });
+  const ext = extname4(file).toLowerCase();
+  const stem = safeName(basename4(file, extname4(file)));
+  for (let n = 1; ; n++) {
+    const dest = join10(dir, `${stem}${n > 1 ? `-${n}` : ""}${ext}`);
+    if (!existsSync9(dest)) {
+      await copyFile(file, dest);
+      return { path: dest, copied: true };
+    }
+    if (await sameContent(file, dest)) return { path: dest, copied: false };
+  }
+}
+function localPath(url, baseDir) {
+  const trimmed = url.trim();
+  if (!trimmed || trimmed.startsWith("#")) return null;
+  if (/^file:/i.test(trimmed)) {
+    try {
+      return fileURLToPath4(trimmed);
+    } catch {
+      return null;
+    }
+  }
+  if (isExternalUrl(trimmed)) return null;
+  let path = trimmed.replace(/[?#].*$/, "");
+  try {
+    path = decodeURIComponent(path);
+  } catch {
+  }
+  return isAbsolute3(path) ? path : resolve6(baseDir, path);
+}
+async function readMarkdownFile(file, target, log) {
+  const source = (await readFile7(file, "utf8")).replace(/^/, "").replace(/\r\n?/g, "\n");
+  const tree = parseMarkdown(source);
+  const baseDir = dirname6(file);
+  const assetsDir = join10(target.root, "assets", "imported");
+  const imageRefs = /* @__PURE__ */ new Set();
+  walk(tree, (node) => {
+    if (node.type === "imageReference") imageRefs.add(node.identifier);
+  });
+  const copies = /* @__PURE__ */ new Map();
+  const relink = async (url) => {
+    const path = localPath(url, baseDir);
+    if (!path) return null;
+    if (copies.has(path)) return copies.get(path) ?? null;
+    let link = null;
+    if (existsSync9(path) && statSync2(path).isFile()) {
+      const { path: dest, copied } = await copyInto(path, assetsDir);
+      if (copied) log.assets.push(posix(relative6(target.root, dest)));
+      link = posix(relative6(target.chaptersDir, dest));
+    } else {
+      log.warnings.push(`\u627E\u4E0D\u5230\u5716\u7247\uFF1A${url}\uFF08\u9023\u7D50\u4FDD\u6301\u539F\u6A23\uFF09`);
+    }
+    copies.set(path, link);
+    return link;
+  };
+  const edits = [];
+  const links = [];
+  const visit = (node) => {
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (start === void 0 || end === void 0) return;
+    if (node.type === "yaml") {
+      edits.push({ start, end, text: "" });
+    } else if (node.type === "image") {
+      links.push({
+        url: node.url,
+        edit: (url) => ({
+          start,
+          end,
+          text: `![${markdownAlt(node.alt ?? "")}](${markdownUrl(url)}${markdownTitle(node.title)})`
+        })
+      });
+    } else if (node.type === "definition") {
+      if (!imageRefs.has(node.identifier)) return;
+      links.push({
+        url: node.url,
+        edit: (url) => ({
+          start,
+          end,
+          text: `[${node.label ?? node.identifier}]: ${markdownUrl(url)}${markdownTitle(node.title)}`
+        })
+      });
+    } else if ("children" in node) {
+      for (const child of node.children) visit(child);
+    }
+  };
+  visit(tree);
+  for (const link of links) {
+    const url = await relink(link.url);
+    if (url !== null) edits.push(link.edit(url));
+  }
+  return applyEdits(source, edits);
+}
+var init_markdown3 = __esm({
+  "src/node/import/markdown.ts"() {
+    "use strict";
+    init_markdown();
+    init_common();
+  }
+});
+
+// src/node/import/docx.ts
+import { existsSync as existsSync10 } from "fs";
+import { mkdir as mkdir7, writeFile as writeFile7 } from "fs/promises";
+import { basename as basename5, extname as extname5, join as join11, relative as relative7, sep as sep6 } from "path";
+import mammoth from "mammoth";
+import TurndownService from "turndown";
+import { gfm } from "turndown-plugin-gfm";
+function noteLabel(kind, n) {
+  return kind === "endnote" ? `e${n}` : n;
+}
+function closest(node, name) {
+  let current = node.parentNode;
+  while (current && current.nodeName !== name) current = current.parentNode;
+  return current;
+}
+function preText(node) {
+  let out = "";
+  for (const child of Array.from(node.childNodes)) {
+    if (child.nodeType === 3) out += child.nodeValue ?? "";
+    else if (child.nodeName === "BR") out += "\n";
+    else out += preText(child);
+  }
+  return out;
+}
+function tableCell(content, node) {
+  let text = content.trim().replace(/\s*\n+\s*/g, " ").replace(/\|/g, "\\|");
+  if (node.nodeName === "TH") text = text.replace(/^\*\*(.*)\*\*$/, "$1");
+  const span = Number(node.getAttribute("colspan") ?? "1");
+  const cell = ` ${text} |`;
+  return cell + " |".repeat(Number.isFinite(span) && span > 1 ? Math.min(span, 50) - 1 : 0);
+}
+function htmlToMarkdown(html) {
+  const service = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "-",
+    emDelimiter: "*",
+    strongDelimiter: "**",
+    hr: "---",
+    fence: "```"
+  });
+  service.use(gfm);
+  service.addRule("strikethrough", {
+    filter: ["del", "s", "strike"],
+    replacement: (content) => content.trim() ? `~~${content}~~` : content
+  });
+  service.addRule("listItem", {
+    filter: "li",
+    replacement: (content, node, options) => {
+      const li = node;
+      const parent = li.parentNode;
+      let prefix = `${options.bulletListMarker} `;
+      if (parent?.nodeName === "OL") {
+        const start = Number(parent.getAttribute("start") ?? "1");
+        const index = Array.from(parent.children).indexOf(li);
+        prefix = `${(Number.isFinite(start) ? start : 1) + index}. `;
+      }
+      const body = content.replace(/^\n+/, "").replace(/\n+$/, "\n").replace(/\n(?!$)/gm, `
+${" ".repeat(prefix.length)}`);
+      return prefix + body + (li.nextSibling && !/\n$/.test(body) ? "\n" : "");
+    }
+  });
+  service.addRule("preformatted", {
+    filter: (node) => node.nodeName === "PRE" && node.firstChild?.nodeName !== "CODE",
+    replacement: (_content, node) => {
+      const text = preText(node).replace(/\n+$/, "");
+      const longest = Math.max(2, ...(text.match(/`+/g) ?? []).map((m) => m.length));
+      const fence = "`".repeat(longest + 1);
+      return `
+
+${fence}
+${text}
+${fence}
+
+`;
+    }
+  });
+  service.addRule("sceneBreak", {
+    filter: (node) => node.nodeName === "P" && /\bscene-break\b/.test(node.getAttribute("class") ?? ""),
+    replacement: () => "\n\n---\n\n"
+  });
+  service.addRule("supSub", {
+    filter: ["sup", "sub"],
+    replacement: (content, node) => {
+      const el = node;
+      const only = Array.from(el.children);
+      if (only.length === 1 && only[0].nodeName === "A" && FOOTNOTE_REF_RE.test(only[0].getAttribute("href") ?? "")) {
+        return content;
+      }
+      if (!content.trim()) return content;
+      const tag = el.nodeName.toLowerCase();
+      return `<${tag}>${content}</${tag}>`;
+    }
+  });
+  service.addRule("tableCell", {
+    filter: ["th", "td"],
+    replacement: (content, node) => {
+      const el = node;
+      const first = el.parentNode ? Array.from(el.parentNode.children).indexOf(el) === 0 : true;
+      return (first ? "|" : "") + tableCell(content, el);
+    }
+  });
+  service.addRule("tableRow", {
+    filter: "tr",
+    replacement: (content, node) => {
+      const tr = node;
+      const table = closest(tr, "TABLE");
+      const isFirst = table?.rows ? table.rows[0] === tr : false;
+      if (!isFirst) return `
+${content}`;
+      let cols = 0;
+      for (const cell of Array.from(tr.children)) {
+        const span = Number(cell.getAttribute("colspan") ?? "1");
+        cols += Number.isFinite(span) && span > 1 ? Math.min(span, 50) : 1;
+      }
+      return `
+${content}
+|${" --- |".repeat(Math.max(1, cols))}`;
+    }
+  });
+  service.addRule("tableSection", {
+    filter: ["thead", "tbody", "tfoot"],
+    replacement: (content) => content
+  });
+  service.addRule("table", {
+    filter: "table",
+    replacement: (content) => `
+
+${content.replace(/\n+/g, "\n").trim()}
+
+`
+  });
+  service.addRule("internalLink", {
+    filter: (node) => node.nodeName === "A" && (node.getAttribute("href") ?? "").startsWith("#"),
+    replacement: (content) => content
+  });
+  service.addRule("autolink", {
+    filter: (node) => {
+      const href = node.getAttribute("href") ?? "";
+      return node.nodeName === "A" && /^https?:\/\//i.test(href) && node.textContent?.trim() === href;
+    },
+    replacement: (_content, node) => `<${node.getAttribute("href")}>`
+  });
+  service.addRule("footnoteReference", {
+    filter: (node) => node.nodeName === "A" && FOOTNOTE_REF_RE.test(node.getAttribute("href") ?? ""),
+    replacement: (_content, node) => {
+      const [, kind, n] = FOOTNOTE_REF_RE.exec(node.getAttribute("href") ?? "") ?? [];
+      return `[^${noteLabel(kind, n)}]`;
+    }
+  });
+  service.addRule("footnoteBackLink", {
+    filter: (node) => node.nodeName === "A" && FOOTNOTE_BACK_RE.test(node.getAttribute("href") ?? ""),
+    replacement: () => ""
+  });
+  service.addRule("footnoteItem", {
+    filter: (node) => node.nodeName === "LI" && FOOTNOTE_ITEM_RE.test(node.getAttribute("id") ?? ""),
+    replacement: (content, node) => {
+      const [, kind, n] = FOOTNOTE_ITEM_RE.exec(node.getAttribute("id") ?? "") ?? [];
+      const text = content.trim().split("\n").map((line, i) => i === 0 || !line.trim() ? line.trimEnd() : `    ${line}`).join("\n");
+      return `
+
+[^${noteLabel(kind, n)}]: ${text}
+
+`;
+    }
+  });
+  service.addRule("footnoteList", {
+    filter: (node) => {
+      if (node.nodeName !== "OL") return false;
+      const items = Array.from(node.children);
+      return items.length > 0 && items.every((li) => FOOTNOTE_ITEM_RE.test(li.getAttribute("id") ?? ""));
+    },
+    replacement: (content) => `
+
+${content.trim()}
+
+`
+  });
+  let markdown = service.turndown(html);
+  markdown = markdown.replace(
+    /^> \*\*([^*\n]+)\*\*[ \t]*\n>[ \t]*\n/gm,
+    (match, label) => {
+      const type = ALERT_LABELS[label.trim().toLowerCase()] ?? ALERT_LABELS[label.trim()];
+      return type ? `> [!${type}]
+` : match;
+    }
+  );
+  markdown = markdown.replace(
+    /^(!\[([^\]\n]+)\]\([^)\n]*\))\n\n([^\n]+)\n(?=\n|$)/gm,
+    (match, image, alt, caption) => caption.replace(/\\(.)/g, "$1").trim() === alt.trim() ? `${image}
+` : match
+  );
+  return `${markdown.replace(/\n{3,}/g, "\n\n").trim()}
+`;
+}
+function translateMessage(message) {
+  const style = /^Unrecognised (paragraph|run) style: '(.*)' \(Style ID: (.*)\)$/.exec(message);
+  if (style) {
+    return `Word \u6A23\u5F0F\u300C${style[2]}\u300D\u6C92\u6709\u5C0D\u61C9\u7684 Markdown \u683C\u5F0F\uFF0C\u5DF2\u7576\u6210\u4E00\u822C${style[1] === "run" ? "\u6587\u5B57" : "\u6BB5\u843D"}\u532F\u5165\u3002`;
+  }
+  return `Word \u8F49\u63DB\uFF1A${message}`;
+}
+async function readDocxFile(file, target, log) {
+  const stem = safeName(basename5(file, extname5(file)));
+  const dir = join11(target.root, "assets", "imported");
+  let count = 0;
+  let metafiles = 0;
+  const convertImage = mammoth.images.imgElement(async (image) => {
+    const ext = IMAGE_EXT[image.contentType?.toLowerCase() ?? ""] ?? "bin";
+    let dest;
+    do {
+      count++;
+      dest = join11(dir, `${stem}-${count}.${ext}`);
+    } while (existsSync10(dest));
+    const data = await image.readAsBuffer();
+    await mkdir7(dir, { recursive: true });
+    await writeFile7(dest, data);
+    log.assets.push(relative7(target.root, dest).split(sep6).join("/"));
+    if (ext === "emf" || ext === "wmf") metafiles++;
+    return { src: relative7(target.chaptersDir, dest).split(sep6).join("/") };
+  });
+  const result = await mammoth.convertToHtml({ path: file }, { styleMap: STYLE_MAP, convertImage });
+  const seen = /* @__PURE__ */ new Set();
+  for (const message of result.messages) {
+    const text = translateMessage(message.message);
+    if (!seen.has(text)) {
+      seen.add(text);
+      log.warnings.push(text);
+    }
+  }
+  if (metafiles) {
+    log.warnings.push(
+      `\u6709 ${metafiles} \u5F35\u5716\u7247\u662F Windows \u5716\u5143\u6A94\uFF08EMF/WMF\uFF09\uFF0C\u700F\u89BD\u5668\u548C\u532F\u51FA\u90FD\u7121\u6CD5\u986F\u793A\uFF0C\u5EFA\u8B70\u5728 Word \u88E1\u53E6\u5B58\u6210 PNG \u5F8C\u66FF\u63DB\u3002`
+    );
+  }
+  return htmlToMarkdown(result.value);
+}
+var STYLE_MAP, IMAGE_EXT, ALERT_LABELS, FOOTNOTE_REF_RE, FOOTNOTE_BACK_RE, FOOTNOTE_ITEM_RE;
+var init_docx2 = __esm({
+  "src/node/import/docx.ts"() {
+    "use strict";
+    init_markdown3();
+    STYLE_MAP = [
+      // The table of contents is rebuilt on export; its entries are just noise here.
+      "p[style-name='TOC Heading'] => !",
+      ...Array.from({ length: 9 }, (_, i) => `p[style-name='toc ${i + 1}'] => !`),
+      "p[style-name='Title'] => p:fresh",
+      "p[style-name='Subtitle'] => p:fresh",
+      "p[style-name='Author'] => p:fresh",
+      "p[style-name='Body Text'] => p:fresh",
+      "p[style-name='Body Text Indent'] => p:fresh",
+      "p[style-name='Body Text First Indent'] => p:fresh",
+      "p[style-name='First Paragraph'] => p:fresh",
+      "p[style-name='Compact'] => p:fresh",
+      "p[style-name='Figure'] => p:fresh",
+      "p[style-name='Captioned Figure'] => p:fresh",
+      "p[style-name='caption'] => p:fresh",
+      "p[style-name='Caption'] => p:fresh",
+      "p[style-name='Image Caption'] => p:fresh",
+      "p[style-name='Table Text'] => p:fresh",
+      "p[style-name='List Continue'] => p:fresh",
+      "p[style-name='Quote'] => blockquote > p:fresh",
+      "p[style-name='Intense Quote'] => blockquote > p:fresh",
+      "p[style-name='Block Text'] => blockquote > p:fresh",
+      "p[style-name='Callout'] => blockquote.callout > p:fresh",
+      "p[style-name='Code'] => pre:separator('\\n')",
+      "p[style-name='Source Code'] => pre:separator('\\n')",
+      "p[style-name='HTML Preformatted'] => pre:separator('\\n')",
+      "p[style-name='Scene Break'] => p.scene-break:fresh",
+      "r[style-name='Inline Code'] => code",
+      "r[style-name='Verbatim Char'] => code",
+      "r[style-name='HTML Code'] => code"
+    ];
+    IMAGE_EXT = {
+      "image/png": "png",
+      "image/jpeg": "jpg",
+      "image/jpg": "jpg",
+      "image/gif": "gif",
+      "image/bmp": "bmp",
+      "image/tiff": "tiff",
+      "image/svg+xml": "svg",
+      "image/webp": "webp",
+      "image/x-emf": "emf",
+      "image/emf": "emf",
+      "image/x-wmf": "wmf",
+      "image/wmf": "wmf"
+    };
+    ALERT_LABELS = {
+      \u6CE8\u610F: "NOTE",
+      \u63D0\u793A: "TIP",
+      \u91CD\u8981: "IMPORTANT",
+      \u8B66\u544A: "WARNING",
+      \u5C0F\u5FC3: "CAUTION",
+      note: "NOTE",
+      tip: "TIP",
+      important: "IMPORTANT",
+      warning: "WARNING",
+      caution: "CAUTION"
+    };
+    FOOTNOTE_REF_RE = /^#(footnote|endnote)-(\d+)$/;
+    FOOTNOTE_BACK_RE = /^#(footnote|endnote)-ref-\d+$/;
+    FOOTNOTE_ITEM_RE = /^(footnote|endnote)-(\d+)$/;
+  }
+});
+
+// src/node/import/split.ts
+function oneLine(text) {
+  return text.replace(/[ \t\r\n]+/g, " ").replace(/^[ \t]+|[ \t]+$/g, "");
+}
+function reheading(source, node, depth) {
+  const first = node.children[0];
+  const last = node.children.at(-1);
+  const inline = first && last ? oneLine(source.slice(off(first, "start"), off(last, "end"))) : "";
+  const hashes = "#".repeat(Math.min(6, Math.max(1, depth)));
+  return {
+    start: off(node, "start"),
+    end: off(node, "end"),
+    text: inline ? `${hashes} ${inline}` : hashes
+  };
+}
+function splitManuscript(source, opts) {
+  const tree = parseMarkdown(source);
+  const cuts = [];
+  const defs = [];
+  const refs = [];
+  for (const node of tree.children) {
+    if (node.type === "yaml") {
+      cuts.push({ start: off(node, "start"), end: off(node, "end"), text: "" });
+    } else if (node.type === "footnoteDefinition" || node.type === "definition") {
+      const start = off(node, "start");
+      let end = off(node, "end");
+      while (source[end] === "\n" || source[end] === "\r") end++;
+      const kind = node.type === "footnoteDefinition" ? "footnote" : "link";
+      defs.push({
+        key: `${kind}:${node.identifier}`,
+        start,
+        end,
+        text: source.slice(start, off(node, "end")).trim()
+      });
+      cuts.push({ start, end, text: "" });
+    }
+  }
+  const headings = [];
+  walk(tree, (node) => {
+    if (node.type === "heading") headings.push(node);
+    else if (node.type === "footnoteReference") {
+      refs.push({ key: `footnote:${node.identifier}`, offset: off(node, "start") });
+    } else if (node.type === "linkReference" || node.type === "imageReference") {
+      refs.push({ key: `link:${node.identifier}`, offset: off(node, "start") });
+    }
+  });
+  const referenced = new Set(refs.map((r) => r.key));
+  const orphansIn = (start, end) => defs.filter((d) => d.start >= start && d.start < end && !referenced.has(d.key));
+  const body = (start, end, shift2, extra) => {
+    const edits = [];
+    for (const c of cuts) {
+      if (c.start >= start && c.start < end) {
+        edits.push({ start: c.start - start, end: Math.min(c.end, end) - start, text: "" });
+      }
+    }
+    if (shift2 !== 0) {
+      for (const h of headings) {
+        const depth = h.depth + shift2;
+        if (off(h, "start") < start || off(h, "end") > end || depth < 2) continue;
+        const edit = reheading(source, h, depth);
+        edits.push({ ...edit, start: edit.start - start, end: edit.end - start });
+      }
+    }
+    const text = applyEdits(source.slice(start, end), edits).trim();
+    const used = [];
+    for (const ref of refs) {
+      if (ref.offset < start || ref.offset >= end) continue;
+      const def = defs.find((d) => d.key === ref.key);
+      if (def && !used.includes(def)) used.push(def);
+    }
+    for (const def of extra) if (!used.includes(def)) used.push(def);
+    return [text, ...used.map((d) => d.text)].filter(Boolean).join("\n\n");
+  };
+  const topLevel = tree.children.filter((n) => n.type === "heading");
+  const level = topLevel.length ? Math.min(...topLevel.map((h) => h.depth)) : 0;
+  const unreferenced = defs.filter((d) => !referenced.has(d.key));
+  if (!opts.split || level === 0) {
+    const h1s = headings.filter((h) => h.depth === 1);
+    const first = tree.children.find((n) => n.type !== "yaml");
+    if (h1s.length === 1 && first === h1s[0]) {
+      return {
+        chapters: [
+          {
+            title: oneLine(textOf(h1s[0])) || opts.fallbackTitle,
+            body: body(off(h1s[0], "end"), source.length, 0, unreferenced)
+          }
+        ],
+        noHeadings: false
+      };
+    }
+    return {
+      chapters: [
+        {
+          title: opts.fallbackTitle,
+          body: body(0, source.length, h1s.length ? 1 : 0, unreferenced)
+        }
+      ],
+      noHeadings: headings.length === 0
+    };
+  }
+  const splits = topLevel.filter((h) => h.depth === level);
+  const shift = 1 - level;
+  const chapters = [];
+  const firstStart = off(splits[0], "start");
+  const leadingOrphans = orphansIn(0, firstStart);
+  const hasLeading = body(0, firstStart, shift, []).trim() !== "";
+  if (hasLeading) {
+    chapters.push({
+      title: opts.frontMatterTitle,
+      body: body(0, firstStart, shift, leadingOrphans)
+    });
+  }
+  splits.forEach((heading, i) => {
+    const next = splits[i + 1];
+    const end = next ? off(next, "start") : source.length;
+    const extra = orphansIn(off(heading, "start"), end);
+    if (i === 0 && !hasLeading) extra.unshift(...leadingOrphans);
+    chapters.push({
+      title: oneLine(textOf(heading)) || opts.fallbackTitle,
+      body: body(off(heading, "end"), end, shift, extra)
+    });
+  });
+  return { chapters, noHeadings: false };
+}
+var off;
+var init_split = __esm({
+  "src/node/import/split.ts"() {
+    "use strict";
+    init_markdown();
+    init_common();
+    off = (node, edge) => node.position?.[edge].offset ?? 0;
+  }
+});
+
+// src/node/import/index.ts
+var import_exports = {};
+__export(import_exports, {
+  htmlToMarkdown: () => htmlToMarkdown,
+  importFile: () => importFile,
+  splitManuscript: () => splitManuscript
+});
+import { existsSync as existsSync11, statSync as statSync3 } from "fs";
+import { basename as basename6, extname as extname6, resolve as resolve7 } from "path";
+async function importFile(book, file, opts = {}) {
+  const path = resolve7(file);
+  if (!existsSync11(path) || !statSync3(path).isFile()) throw new Error(`\u627E\u4E0D\u5230\u6A94\u6848\uFF1A${file}`);
+  const ext = extname6(path).toLowerCase();
+  if (ext !== ".docx" && !MARKDOWN_EXTENSIONS.has(ext)) {
+    throw new Error(
+      `\u4E0D\u652F\u63F4\u7684\u6A94\u6848\u683C\u5F0F\uFF1A${ext || "\uFF08\u6C92\u6709\u526F\u6A94\u540D\uFF09"}\u3002\u53EF\u4EE5\u532F\u5165 .docx\u3001.md\u3001.markdown \u6216 .txt\uFF1B.doc \u8ACB\u5148\u5728 Word \u53E6\u5B58\u6210 .docx\u3002`
+    );
+  }
+  const config = await book.loadConfig();
+  const log = { assets: [], warnings: [] };
+  const markdown = ext === ".docx" ? await readDocxFile(path, book, log) : await readMarkdownFile(path, book, log);
+  if (!markdown.trim()) {
+    log.warnings.push(`\u300C${basename6(path)}\u300D\u6C92\u6709\u5167\u5BB9\uFF0C\u6C92\u6709\u5EFA\u7ACB\u4EFB\u4F55\u7AE0\u7BC0\u3002`);
+    return { created: [], assets: log.assets, warnings: log.warnings };
+  }
+  const split = opts.split !== false;
+  const name = basename6(path, extname6(path)).trim() || "\u532F\u5165\u7684\u7A3F\u4EF6";
+  const { chapters, noHeadings } = splitManuscript(markdown, {
+    split,
+    fallbackTitle: name,
+    frontMatterTitle: isEnglish(config.language) ? "Front matter" : "\u524D\u8A00\u7D20\u6750"
+  });
+  if (noHeadings) {
+    log.warnings.push(
+      `\u300C${basename6(path)}\u300D\u88E1\u6C92\u6709\u5075\u6E2C\u5230\u6A19\u984C\u6A23\u5F0F\uFF08Word \u7684\u300C\u6A19\u984C 1\uFF0F\u6A19\u984C 2\u300D\u6216 Markdown \u7684 # \u6A19\u984C\uFF09\uFF0C\u6240\u4EE5\u6574\u4EFD\u532F\u5165\u6210\u4E00\u7AE0\u300C${name}\u300D\u3002\u53EF\u4EE5\u8ACB AI \u4F9D\u5167\u5BB9\u5E6B\u4F60\u5207\u5206\u6210\u7AE0\u7BC0\u3002`
+    );
+  }
+  const created = [];
+  for (const chapter of chapters) {
+    created.push(
+      await book.createChapter(chapter.title.slice(0, 200), {
+        body: chapter.body,
+        status: "draft",
+        listed: opts.listed !== false
+      })
+    );
+  }
+  return { created, assets: log.assets, warnings: log.warnings };
+}
+var MARKDOWN_EXTENSIONS;
+var init_import = __esm({
+  "src/node/import/index.ts"() {
+    "use strict";
+    init_common();
+    init_docx2();
+    init_markdown3();
+    init_split();
+    init_docx2();
+    init_split();
+    MARKDOWN_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown", ".txt"]);
+  }
+});
+
+// src/cli/index.ts
+import { spawn as spawn2 } from "child_process";
+import { basename as basename7, extname as extname7 } from "path";
+import { createInterface } from "readline/promises";
+import { parseArgs } from "util";
+
+// src/node/project.ts
+import { existsSync as existsSync3 } from "fs";
+import { cp, mkdir as mkdir3, readdir as readdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join3, relative as relative2, resolve, sep as sep2 } from "path";
+import { isMap as isMap2, parseDocument as parseDocument2 } from "yaml";
+
+// src/node/book.ts
+init_config();
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { mkdir, readdir, readFile, rename, stat, writeFile } from "fs/promises";
+import { dirname, extname, join, relative, sep } from "path";
+import { isMap, parseDocument } from "yaml";
+
+// src/shared/edits.ts
+init_annotations();
+init_markdown();
+import { stringify as stringifyYaml } from "yaml";
+var EditConflict = class extends Error {
+  constructor(message = "The chapter changed since it was loaded.") {
+    super(message);
+    this.name = "EditConflict";
+  }
+};
+function replaceRange(source, start, end, expected, text) {
+  if (source.slice(start, end) !== expected) throw new EditConflict();
+  return source.slice(0, start) + text + source.slice(end);
+}
+function locateBlock(source, blockStart, expected) {
+  const { blocks } = parseChapter(source);
+  const exact = blocks.find(
+    (b) => b.start === blockStart && source.slice(b.start, b.end) === expected
+  );
+  if (exact) return exact;
+  const byText = blocks.filter((b) => source.slice(b.start, b.end) === expected);
+  if (byText.length === 1) return byText[0];
+  throw new EditConflict();
+}
+function insertComment(source, c) {
+  const block = locateBlock(source, c.blockStart, c.blockText);
+  const id = newAnnotationId("comment");
+  const marker = formatMarker(
+    "comment",
+    {
+      id,
+      by: c.by ?? "human",
+      at: (c.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z"),
+      quote: c.quote?.trim().slice(0, 200) ?? ""
+    },
+    c.body.trim()
+  );
+  const at = block.start;
+  return { source: `${source.slice(0, at)}${marker}
+${source.slice(at)}`, id };
+}
+function removeAnnotation(source, id) {
+  const { annotations } = parseChapter(source);
+  const a = annotations.find((x) => x.id === id);
+  if (!a) throw new EditConflict("The note no longer exists.");
+  return cutMarker(source, a.start, a.end);
+}
+function cutMarker(source, start, end) {
+  let cutEnd = end;
+  if (source[cutEnd] === "\n") cutEnd++;
+  const before = source.slice(0, start);
+  if (source[cutEnd] === "\n" && (before.endsWith("\n\n") || before === "")) cutEnd++;
+  return before + source.slice(cutEnd);
+}
+function acceptSuggestion(source, id) {
+  const parsed = parseChapter(source);
+  const s = parsed.annotations.find((x) => x.id === id);
+  if (s?.kind !== "suggest") throw new EditConflict("The suggestion no longer exists.");
+  const replacement = s.body.replace(/^\n+|\s+$/g, "");
+  if (s.blockIndex === null || s.span === 0) {
+    let end = s.end;
+    if (source[end] === "\n") end++;
+    const tail = source.slice(end);
+    const sep7 = tail === "" ? "\n" : tail.startsWith("\n") ? "\n" : "\n\n";
+    return source.slice(0, s.start) + replacement + sep7 + tail;
+  }
+  const first = parsed.blocks[s.blockIndex];
+  const last = parsed.blocks[Math.min(parsed.blocks.length - 1, s.blockIndex + s.span - 1)];
+  const kept = parsed.annotations.filter((a) => a.id !== s.id && a.start >= s.start && a.end <= last.end).map((a) => source.slice(a.start, a.end));
+  const prefix = kept.length ? `${kept.join("\n")}
+` : "";
+  const start = Math.min(s.start, first.start);
+  return source.slice(0, start) + prefix + replacement + source.slice(last.end);
+}
+function setFrontmatter(source, key, value) {
+  const { frontmatter, frontmatterRange } = parseChapter(source);
+  const next = { ...frontmatter };
+  if (value === void 0 || value === "") delete next[key];
+  else next[key] = value;
+  const body = frontmatterRange ? source.slice(frontmatterRange[1]).replace(/^\n+/, "") : source;
+  if (Object.keys(next).length === 0) return body;
+  const yaml = stringifyYaml(next, { lineWidth: 0 }).trimEnd();
+  return `---
+${yaml}
+---
+
+${body}`;
+}
+function setTitle(source, title) {
+  const parsed = parseChapter(source);
+  const clean = title.replace(/[ \t\r\n]+/g, " ").trim();
+  const h1 = parsed.blocks.find((b) => b.node.type === "heading" && b.node.depth === 1);
+  if (h1) return `${source.slice(0, h1.start)}# ${clean}${source.slice(h1.end)}`;
+  const at = parsed.frontmatterRange ? parsed.frontmatterRange[1] : 0;
+  const head = source.slice(0, at);
+  const rest = source.slice(at).replace(/^\n+/, "");
+  return `${head}${head ? "\n\n" : ""}# ${clean}
+
+${rest}`;
+}
+
+// src/node/book.ts
+init_markdown();
+var BOOK_FILE = "book.yaml";
+var ProjectError = class extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+    this.name = "ProjectError";
+  }
+  status;
+};
+function versionOf(source) {
+  return createHash("sha1").update(source).digest("hex").slice(0, 12);
+}
+function isChapterId(id) {
+  return /^[^/\\]+\.md$/i.test(id) && !id.startsWith(".") && !id.includes("..");
+}
+function statusOf(value) {
+  return CHAPTER_STATUSES.includes(value) ? value : "draft";
+}
+function summarizeChapter(id, source, listed, updatedAt) {
+  const parsed = parseChapter(source);
+  let comments = 0;
+  let aiNotes = 0;
+  let suggestions = 0;
+  for (const a of parsed.annotations) {
+    if (a.kind === "suggest") suggestions++;
+    else if (a.by === "ai") aiNotes++;
+    else comments++;
+  }
+  const fm = parsed.frontmatter;
+  return {
+    id,
+    title: parsed.title || (typeof fm.title === "string" ? fm.title : "") || id.replace(/\.md$/i, ""),
+    status: statusOf(fm.status),
+    summary: typeof fm.summary === "string" ? fm.summary : "",
+    words: parsed.words,
+    sections: parsed.headings.filter((h) => h.depth === 2).map((h) => h.text),
+    comments,
+    aiNotes,
+    suggestions,
+    listed,
+    version: versionOf(source),
+    updatedAt: updatedAt.toISOString()
+  };
+}
+function slugify(title) {
+  return title.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+}
+var BRIEF_PLACEHOLDER = "\uFF08\u5C1A\u672A\u9032\u884C\u7ACB\u9805\u8A2A\u8AC7\uFF09";
+function safeFileName(name) {
+  const base = name.split(/[/\\]/).pop() ?? "";
+  const clean = [...base.normalize("NFC")].filter((ch) => ch.charCodeAt(0) >= 32).join("").replace(/[<>:"|?*]/g, "").replace(/\s+/g, "-").replace(/^\.+/, "").slice(0, 120);
+  return clean || "file";
+}
+var Book = class {
+  constructor(project, id) {
+    this.project = project;
+    this.id = id;
+  }
+  project;
+  id;
+  get root() {
+    return join(this.project.booksDir, this.id);
+  }
+  get configPath() {
+    return join(this.root, BOOK_FILE);
+  }
+  get chaptersDir() {
+    return join(this.root, "chapters");
+  }
+  get outputDir() {
+    return join(this.project.root, "output", this.id);
+  }
+  get history() {
+    return this.project.historyFor(this.id);
+  }
+  exists() {
+    return existsSync(this.configPath);
+  }
+  chapterPath(id) {
+    if (!isChapterId(id)) throw new ProjectError(`\u4E0D\u5408\u6CD5\u7684\u7AE0\u7BC0\u6A94\u540D\uFF1A${id}`);
+    return join(this.chaptersDir, id);
+  }
+  async readConfigDocument() {
+    const text = existsSync(this.configPath) ? await readFile(this.configPath, "utf8") : "";
+    return parseDocument(text);
+  }
+  async loadConfig() {
+    const [defaults, own] = await Promise.all([
+      this.project.loadDefaults(),
+      this.readConfigDocument()
+    ]);
+    return resolveConfig(mergeConfig(defaults, own.toJS()));
+  }
+  /** Edit book.yaml in place, keeping the author's comments and layout. */
+  async updateConfig(mutate) {
+    const doc = await this.readConfigDocument();
+    if (!isMap(doc.contents)) doc.contents = doc.createNode({});
+    mutate(doc);
+    await writeFile(this.configPath, doc.toString({ lineWidth: 0 }));
+  }
+  async listChapterFiles() {
+    if (!existsSync(this.chaptersDir)) return [];
+    const entries = await readdir(this.chaptersDir, { withFileTypes: true });
+    return entries.filter((e) => e.isFile() && isChapterId(e.name)).map((e) => e.name).sort((a, b) => a.localeCompare(b, "en", { numeric: true }));
+  }
+  async readChapter(id) {
+    const path = this.chapterPath(id);
+    if (!existsSync(path)) throw new ProjectError(`\u627E\u4E0D\u5230\u7AE0\u7BC0\uFF1A${id}`, 404);
+    const source = await readFile(path, "utf8");
+    return { id, source, version: versionOf(source) };
+  }
+  /**
+   * Write a chapter. With `baseVersion`, refuse when the file changed since
+   * the caller read it. The previous content goes to history first.
+   */
+  async writeChapter(id, source, baseVersion) {
+    const path = this.chapterPath(id);
+    const previous = existsSync(path) ? await readFile(path, "utf8") : null;
+    if (baseVersion && previous !== null && versionOf(previous) !== baseVersion) {
+      throw new ProjectError(
+        "\u9019\u4E00\u7AE0\u5728\u4F60\u8F09\u5165\u5F8C\u88AB\u4FEE\u6539\u904E\u4E86\uFF08\u53EF\u80FD\u662F AI \u6B63\u5728\u6539\uFF09\u3002\u8ACB\u91CD\u65B0\u6574\u7406\u5F8C\u518D\u8A66\u3002",
+        409
+      );
+    }
+    if (previous === source) return versionOf(source);
+    if (previous !== null) await this.history.snapshot(id, previous);
+    await mkdir(dirname(path), { recursive: true });
+    const tmp = `${path}.mosage-tmp`;
+    await writeFile(tmp, source);
+    await rename(tmp, path);
+    this.history.remember(id, source);
+    return versionOf(source);
+  }
+  /** Read–transform–write with a version check against what the client saw. */
+  async transformChapter(id, transform, baseVersion) {
+    const { source, version } = await this.readChapter(id);
+    if (baseVersion && baseVersion !== version) {
+      throw new ProjectError(
+        "\u9019\u4E00\u7AE0\u5728\u4F60\u8F09\u5165\u5F8C\u88AB\u4FEE\u6539\u904E\u4E86\uFF08\u53EF\u80FD\u662F AI \u6B63\u5728\u6539\uFF09\u3002\u8ACB\u91CD\u65B0\u6574\u7406\u5F8C\u518D\u8A66\u3002",
+        409
+      );
+    }
+    return this.writeChapter(id, transform(source), version);
+  }
+  async hasBrief() {
+    const path = join(this.root, "brief.md");
+    if (!existsSync(path)) return false;
+    return !(await readFile(path, "utf8")).includes(BRIEF_PLACEHOLDER);
+  }
+  async summarize() {
+    const config = await this.loadConfig();
+    const files = await this.listChapterFiles();
+    const fileSet = new Set(files);
+    const listedSet = new Set(config.chapters);
+    const summaries = /* @__PURE__ */ new Map();
+    let updated = existsSync(this.configPath) ? (await stat(this.configPath)).mtime : /* @__PURE__ */ new Date(0);
+    await Promise.all(
+      files.map(async (id) => {
+        const path = this.chapterPath(id);
+        const [source, info] = await Promise.all([readFile(path, "utf8"), stat(path)]);
+        if (info.mtime > updated) updated = info.mtime;
+        summaries.set(id, summarizeChapter(id, source, listedSet.has(id), info.mtime));
+      })
+    );
+    const chapters = config.chapters.filter((id) => fileSet.has(id)).map((id) => summaries.get(id));
+    const drafts = files.filter((id) => !listedSet.has(id)).map((id) => summaries.get(id));
+    const totals = { words: 0, comments: 0, aiNotes: 0, suggestions: 0 };
+    for (const c of [...chapters, ...drafts]) {
+      totals.words += c.listed ? c.words : 0;
+      totals.comments += c.comments;
+      totals.aiNotes += c.aiNotes;
+      totals.suggestions += c.suggestions;
+    }
+    return {
+      id: this.id,
+      config,
+      chapters,
+      drafts,
+      missing: config.chapters.filter((id) => !fileSet.has(id)),
+      totals,
+      hasBrief: await this.hasBrief(),
+      updatedAt: updated.toISOString()
+    };
+  }
+  /** The listed chapters with their sources, in reading order — export input. */
+  async loadManuscript() {
+    const config = await this.loadConfig();
+    const files = new Set(await this.listChapterFiles());
+    const ids = config.chapters.filter((id) => files.has(id));
+    const chapters = await Promise.all(
+      ids.map(async (id) => ({ id, source: await readFile(this.chapterPath(id), "utf8") }))
+    );
+    return { config, chapters };
+  }
+  async setChapterOrder(ids) {
+    for (const id of ids) if (!isChapterId(id)) throw new ProjectError(`\u4E0D\u5408\u6CD5\u7684\u7AE0\u7BC0\u6A94\u540D\uFF1A${id}`);
+    const unique = [...new Set(ids)];
+    await this.updateConfig((doc) => {
+      doc.set("chapters", doc.createNode(unique));
+    });
+  }
+  async addToOrder(id, position) {
+    const config = await this.loadConfig();
+    const order = config.chapters.filter((c) => c !== id);
+    order.splice(position ?? order.length, 0, id);
+    await this.setChapterOrder(order);
+  }
+  async removeFromOrder(id) {
+    const config = await this.loadConfig();
+    await this.setChapterOrder(config.chapters.filter((c) => c !== id));
+  }
+  /** Create `chapters/NN-slug.md` and append it to the chapter order. */
+  async createChapter(title, opts = {}) {
+    const files = await this.listChapterFiles();
+    const numbers = files.map((f) => Number.parseInt(f, 10)).filter(Number.isFinite);
+    const next = String(numbers.length ? Math.max(...numbers) + 1 : 1).padStart(2, "0");
+    const slug = slugify(title) || "chapter";
+    let id = `${next}-${slug}.md`;
+    for (let n = 2; files.includes(id); n++) id = `${next}-${slug}-${n}.md`;
+    const body = opts.body?.trim() ? `${opts.body.trim()}
+` : "";
+    let source = `# ${title.trim() || "\u672A\u547D\u540D\u7AE0\u7BC0"}
+
+${body}`;
+    source = setFrontmatter(source, "status", opts.status ?? "idea");
+    if (opts.summary) source = setFrontmatter(source, "summary", opts.summary);
+    await this.writeChapter(id, source);
+    if (opts.listed !== false) await this.addToOrder(id);
+    return id;
+  }
+  folderPath(folder) {
+    if (folder !== "assets" && folder !== "notes")
+      throw new ProjectError(`\u4E0D\u5408\u6CD5\u7684\u8CC7\u6599\u593E\uFF1A${folder}`);
+    return join(this.root, folder);
+  }
+  /** Everything under assets/ and notes/ — images and reference material. */
+  async listFiles() {
+    const chapterSources = await Promise.all(
+      (await this.listChapterFiles()).map((id) => readFile(this.chapterPath(id), "utf8"))
+    );
+    const everything = chapterSources.join("\n");
+    const walk2 = async (folder) => {
+      const base = this.folderPath(folder);
+      if (!existsSync(base)) return [];
+      const entries = await readdir(base, { recursive: true, withFileTypes: true });
+      const files = [];
+      for (const e of entries) {
+        if (!e.isFile() || e.name.startsWith(".")) continue;
+        const full = join(e.parentPath, e.name);
+        const name = relative(base, full).split(sep).join("/");
+        if (name.split("/").some((seg) => seg.startsWith("."))) continue;
+        const info = await stat(full);
+        files.push({
+          name,
+          path: `${folder}/${name}`,
+          size: info.size,
+          updatedAt: info.mtime.toISOString(),
+          used: folder === "assets" ? everything.includes(name) || everything.includes(encodeURI(name)) : void 0
+        });
+      }
+      return files.sort((a, b) => a.name.localeCompare(b.name, "zh-Hant"));
+    };
+    return { assets: await walk2("assets"), notes: await walk2("notes") };
+  }
+  /** Copy a file into assets/ or notes/, never overwriting. Returns its name. */
+  async saveFile(folder, name, data) {
+    const dir = this.folderPath(folder);
+    await mkdir(dir, { recursive: true });
+    const clean = safeFileName(name);
+    const ext = extname(clean);
+    const stem = clean.slice(0, clean.length - ext.length);
+    let final = clean;
+    for (let n = 2; existsSync(join(dir, final)); n++) final = `${stem}-${n}${ext}`;
+    await writeFile(join(dir, final), data);
+    return final;
+  }
+  /** Move a file to .mosage/trash instead of deleting it. */
+  async trashFile(folder, name) {
+    const base = this.folderPath(folder);
+    const path = join(base, ...name.split("/"));
+    const inside = relative(base, path);
+    if (!inside || inside.startsWith("..") || !existsSync(path)) {
+      throw new ProjectError(`\u627E\u4E0D\u5230\u6A94\u6848\uFF1A${folder}/${name}`, 404);
+    }
+    const trash = join(this.project.stateDir, "trash", this.id, folder);
+    await mkdir(trash, { recursive: true });
+    const stamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    await rename(path, join(trash, `${stamp2}-${safeFileName(name)}`));
+  }
+  async setChapterStatus(id, status, baseVersion) {
+    if (!CHAPTER_STATUSES.includes(status)) throw new ProjectError(`\u4E0D\u5408\u6CD5\u7684\u72C0\u614B\uFF1A${status}`);
+    return this.transformChapter(id, (s) => setFrontmatter(s, "status", status), baseVersion);
+  }
+  async setChapterSummary(id, summary, baseVersion) {
+    return this.transformChapter(
+      id,
+      (s) => setFrontmatter(s, "summary", summary.trim()),
+      baseVersion
+    );
+  }
+  async setChapterTitle(id, title, baseVersion) {
+    if (!title.trim()) throw new ProjectError("\u7AE0\u7BC0\u6A19\u984C\u4E0D\u80FD\u662F\u7A7A\u7684");
+    return this.transformChapter(id, (s) => setTitle(s, title), baseVersion);
+  }
+};
+
+// src/node/history.ts
+init_wordcount();
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, readdir as readdir2, readFile as readFile2, rm, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
+var QUIET_MS = 9e4;
+var KEEP = 100;
+function stamp(date) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+function parseStamp(name) {
+  const m = /^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z/.exec(name);
+  return m ? `${m[1]}T${m[2]}:${m[3]}:${m[4]}.${m[5]}Z` : name;
+}
+var History = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  known = /* @__PURE__ */ new Map();
+  lastSnapshot = /* @__PURE__ */ new Map();
+  chapterDir(id) {
+    return join2(this.dir, id.replace(/\.md$/i, ""));
+  }
+  /** Record the content we last saw on disk, without snapshotting. */
+  remember(id, content) {
+    this.known.set(id, content);
+  }
+  /** A watcher saw the file change: snapshot what it was before. */
+  async observe(id, content) {
+    const before = this.known.get(id);
+    this.known.set(id, content);
+    if (before === void 0 || before === content) return false;
+    await this.snapshot(id, before);
+    return true;
+  }
+  async snapshot(id, content, force = false) {
+    const now = Date.now();
+    if (!force && now - (this.lastSnapshot.get(id) ?? 0) < QUIET_MS) return;
+    this.lastSnapshot.set(id, now);
+    const dir = this.chapterDir(id);
+    await mkdir2(dir, { recursive: true });
+    const names = (await readdir2(dir)).filter((n) => n.endsWith(".md")).sort();
+    const latest = names.at(-1);
+    if (latest && await readFile2(join2(dir, latest), "utf8") === content) return;
+    await writeFile2(join2(dir, `${stamp(new Date(now))}.md`), content);
+    for (const old of names.slice(0, Math.max(0, names.length + 1 - KEEP))) {
+      await rm(join2(dir, old), { force: true });
+    }
+  }
+  async list(id) {
+    const dir = this.chapterDir(id);
+    if (!existsSync2(dir)) return [];
+    const names = (await readdir2(dir)).filter((n) => n.endsWith(".md")).sort().reverse();
+    return Promise.all(
+      names.map(async (name) => {
+        const content = await readFile2(join2(dir, name), "utf8");
+        return {
+          id: name.replace(/\.md$/, ""),
+          at: parseStamp(name),
+          words: countWords(content),
+          size: content.length
+        };
+      })
+    );
+  }
+  async read(id, snapshotId) {
+    if (!/^[\w-]+$/.test(snapshotId)) throw new Error("invalid snapshot id");
+    return readFile2(join2(this.chapterDir(id), `${snapshotId}.md`), "utf8");
+  }
+};
+
+// src/node/project.ts
+var PROJECT_FILE = "mosage.yaml";
+function isBookId(id) {
+  return /^[\p{L}\p{N}][\p{L}\p{N}_-]*$/u.test(id) && id.length <= 80;
+}
+function bookIdFrom(title) {
+  return slugify(title) || "book";
+}
+var Project = class _Project {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  histories = /* @__PURE__ */ new Map();
+  /** Walk up from `start` to the folder holding mosage.yaml. */
+  static find(start = process.cwd()) {
+    let dir = resolve(start);
+    for (; ; ) {
+      if (existsSync3(join3(dir, PROJECT_FILE))) return new _Project(dir);
+      const parent = dirname2(dir);
+      if (parent === dir) {
+        throw new ProjectError(
+          `\u627E\u4E0D\u5230 ${PROJECT_FILE}\u3002\u8ACB\u5728 MoSage \u5C08\u6848\u8CC7\u6599\u593E\u88E1\u57F7\u884C\uFF0C\u6216\u5148\u7528 \`npx mosage init <\u8CC7\u6599\u593E>\` \u5EFA\u7ACB\u5C08\u6848\u3002`,
+          404
+        );
+      }
+      dir = parent;
+    }
+  }
+  get configPath() {
+    return join3(this.root, PROJECT_FILE);
+  }
+  get booksDir() {
+    return join3(this.root, "books");
+  }
+  get stateDir() {
+    return join3(this.root, ".mosage");
+  }
+  historyFor(bookId) {
+    let history = this.histories.get(bookId);
+    if (!history) {
+      history = new History(join3(this.stateDir, "history", bookId));
+      this.histories.set(bookId, history);
+    }
+    return history;
+  }
+  async readConfigDocument() {
+    const text = existsSync3(this.configPath) ? await readFile3(this.configPath, "utf8") : "";
+    return parseDocument2(text);
+  }
+  /** mosage.yaml as plain data — the defaults every book inherits. */
+  async loadDefaults() {
+    const data = (await this.readConfigDocument()).toJS();
+    return data && typeof data === "object" && !Array.isArray(data) ? data : {};
+  }
+  async updateConfig(mutate) {
+    const doc = await this.readConfigDocument();
+    if (!isMap2(doc.contents)) doc.contents = doc.createNode({});
+    mutate(doc);
+    await writeFile3(this.configPath, doc.toString({ lineWidth: 0 }));
+  }
+  book(id) {
+    if (!isBookId(id)) throw new ProjectError(`\u4E0D\u5408\u6CD5\u7684\u66F8\u7C4D\u4EE3\u865F\uFF1A${id}`);
+    const book = new Book(this, id);
+    if (!book.exists()) throw new ProjectError(`\u627E\u4E0D\u5230\u9019\u672C\u66F8\uFF1Abooks/${id}/${BOOK_FILE}`, 404);
+    return book;
+  }
+  /** Book folders, in the order of `books:` in mosage.yaml, then by name. */
+  async listBookIds() {
+    if (!existsSync3(this.booksDir)) return [];
+    const entries = await readdir3(this.booksDir, { withFileTypes: true });
+    const ids = entries.filter((e) => e.isDirectory() && isBookId(e.name)).filter((e) => existsSync3(join3(this.booksDir, e.name, BOOK_FILE))).map((e) => e.name);
+    const defaults = await this.loadDefaults();
+    const order = Array.isArray(defaults.books) ? defaults.books.map(String) : [];
+    const rank = (id) => {
+      const i = order.indexOf(id);
+      return i === -1 ? Number.MAX_SAFE_INTEGER : i;
+    };
+    return ids.sort((a, b) => rank(a) - rank(b) || a.localeCompare(b, "en", { numeric: true }));
+  }
+  async listBooks() {
+    const ids = await this.listBookIds();
+    return Promise.all(ids.map((id) => new Book(this, id).summarize()));
+  }
+  async setBookOrder(ids) {
+    for (const id of ids) if (!isBookId(id)) throw new ProjectError(`\u4E0D\u5408\u6CD5\u7684\u66F8\u7C4D\u4EE3\u865F\uFF1A${id}`);
+    await this.updateConfig((doc) => doc.set("books", doc.createNode([...new Set(ids)])));
+  }
+  /**
+   * Resolve which book a command means: an explicit id, the book folder the
+   * shell is in, or the only book there is.
+   */
+  async resolveBook(explicit, cwd = process.cwd()) {
+    if (explicit) return this.book(explicit);
+    const rel = relative2(this.booksDir, resolve(cwd));
+    if (rel && !rel.startsWith("..")) return this.book(rel.split(sep2)[0]);
+    const ids = await this.listBookIds();
+    if (ids.length === 1) return this.book(ids[0]);
+    if (ids.length === 0) {
+      throw new ProjectError(
+        "\u9019\u500B\u5C08\u6848\u9084\u6C92\u6709\u4EFB\u4F55\u66F8\u3002\u7528 `npx mosage new <\u4EE3\u865F>` \u5EFA\u7ACB\uFF0C\u6216\u8ACB AI \u5E36\u4F60\u7ACB\u9805\u3002"
+      );
+    }
+    throw new ProjectError(`\u6709 ${ids.length} \u672C\u66F8\uFF0C\u8ACB\u6307\u5B9A\u662F\u54EA\u4E00\u672C\uFF1A${ids.join("\u3001")}`);
+  }
+  /** Scaffold books/<id>/ from the bundled template. */
+  async createBook(templateDir, opts = {}) {
+    let id = opts.id?.trim() || bookIdFrom(opts.title ?? "");
+    if (!isBookId(id)) throw new ProjectError(`\u4E0D\u5408\u6CD5\u7684\u66F8\u7C4D\u4EE3\u865F\uFF1A${id}\uFF08\u8ACB\u7528\u82F1\u6587\u3001\u6578\u5B57\u8207 -\uFF09`);
+    const base = id;
+    for (let n = 2; existsSync3(join3(this.booksDir, id)); n++) {
+      if (opts.id) throw new ProjectError(`books/${id} \u5DF2\u7D93\u5B58\u5728`);
+      id = `${base}-${n}`;
+    }
+    const book = new Book(this, id);
+    await mkdir3(this.booksDir, { recursive: true });
+    await cp(templateDir, book.root, { recursive: true });
+    await book.updateConfig((doc) => {
+      if (opts.type) doc.set("type", opts.type);
+      if (opts.title) doc.set("title", opts.title.trim());
+      if (opts.author) doc.set("author", opts.author.trim());
+    });
+    const ids = await this.listBookIds();
+    await this.setBookOrder(ids.includes(id) ? ids : [...ids, id]);
+    return book;
+  }
+  /** Where the author is reading — for the `current-position` skill. */
+  async writeCurrent(position) {
+    await mkdir3(this.stateDir, { recursive: true });
+    await writeFile3(
+      join3(this.stateDir, "current.json"),
+      `${JSON.stringify({ ...position, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
+`
+    );
+  }
+};
+
+// src/node/server.ts
+init_config();
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile5, stat as stat2, writeFile as writeFile5 } from "fs/promises";
+import { createServer } from "http";
+import { basename as basename2, extname as extname3, join as join7, normalize, relative as relative4, resolve as resolve3, sep as sep4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import chokidar from "chokidar";
+var MIME2 = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".md": "text/markdown; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".pdf": "application/pdf"
+};
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+function defaultWebDir() {
+  return fileURLToPath2(new URL("./web/", import.meta.url));
+}
+function send(res, status, body) {
+  const text = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store"
+  });
+  res.end(text);
+}
+function reply(res, status, body) {
+  send(res, status, body);
+  return true;
+}
+async function readJson(req) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > 60 * 1024 * 1024) throw new HttpError(413, "request too large");
+    chunks.push(chunk);
+  }
+  if (chunks.length === 0) return {};
+  try {
+    const data = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (data && typeof data === "object" && !Array.isArray(data)) return data;
+  } catch {
+  }
+  throw new HttpError(400, "invalid JSON body");
+}
+function hostnameOf(host) {
+  if (!host) return "";
+  if (host.startsWith("[")) return host.slice(0, host.indexOf("]") + 1);
+  return host.split(":")[0];
+}
+function guard(req, allowAnyHost) {
+  if (!allowAnyHost && !LOCAL_HOSTS.has(hostnameOf(req.headers.host).toLowerCase())) {
+    throw new HttpError(403, "unexpected host");
+  }
+  if (req.method === "GET" || req.method === "HEAD") return;
+  if (req.headers["sec-fetch-site"] === "cross-site") {
+    throw new HttpError(403, "cross-site request blocked");
+  }
+  const origin = req.headers.origin;
+  if (origin) {
+    let originHost = "";
+    try {
+      originHost = new URL(origin).host;
+    } catch {
+    }
+    if (originHost !== req.headers.host) throw new HttpError(403, "origin mismatch");
+  }
+  if (req.method !== "DELETE") {
+    const type = req.headers["content-type"] ?? "";
+    if (!type.startsWith("application/json")) {
+      throw new HttpError(415, "content-type must be application/json");
+    }
+  }
+}
+function str2(value, name) {
+  if (typeof value !== "string") throw new HttpError(400, `${name} must be a string`);
+  return value;
+}
+function int(value, name) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new HttpError(400, `${name} must be a non-negative integer`);
+  }
+  return value;
+}
+function optionalStr(value) {
+  return typeof value === "string" ? value : void 0;
+}
+async function startServer(project, opts = {}) {
+  const host = opts.host ?? "127.0.0.1";
+  const allowAnyHost = !["127.0.0.1", "localhost", "::1"].includes(host);
+  const webDir = opts.webDir ?? defaultWebDir();
+  const templateDir = opts.bookTemplateDir;
+  const clients = /* @__PURE__ */ new Set();
+  const broadcast = (event) => {
+    const data = `data: ${JSON.stringify(event)}
+
+`;
+    for (const res of clients) res.write(data);
+  };
+  for (const bookId of await project.listBookIds()) {
+    const book = project.book(bookId);
+    for (const id of await book.listChapterFiles()) {
+      try {
+        book.history.remember(id, (await book.readChapter(id)).source);
+      } catch {
+      }
+    }
+  }
+  const watcher = chokidar.watch([project.booksDir, project.configPath], {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 120, pollInterval: 40 },
+    ignored: (path) => path.endsWith(".mosage-tmp") || path.includes(`${sep4}node_modules${sep4}`)
+  });
+  const pending = /* @__PURE__ */ new Map();
+  watcher.on("all", (_event, path) => {
+    clearTimeout(pending.get(path));
+    pending.set(
+      path,
+      setTimeout(async () => {
+        pending.delete(path);
+        const [bookId, folder, file, extra] = relative4(project.booksDir, path).split(sep4);
+        if (bookId && !bookId.startsWith("..")) {
+          if (folder === "chapters" && file && !extra && isChapterId(file)) {
+            try {
+              const book = project.book(bookId);
+              await book.history.observe(file, (await book.readChapter(file)).source);
+            } catch {
+            }
+            broadcast({ type: "chapter", book: bookId, id: file });
+          } else if (folder === "assets") {
+            broadcast({ type: "assets", book: bookId });
+          }
+          broadcast({ type: "book", book: bookId });
+        }
+        broadcast({ type: "library" });
+      }, 80)
+    );
+  });
+  const libraryRoutes = async (req, res, route) => {
+    switch (route) {
+      case "GET /library": {
+        const defaults = await project.loadDefaults();
+        return reply(res, 200, {
+          name: basename2(project.root),
+          author: typeof defaults.author === "string" ? defaults.author : "",
+          books: await project.listBooks()
+        });
+      }
+      case "POST /books": {
+        if (!templateDir) throw new HttpError(500, "book template missing");
+        const body = await readJson(req);
+        const type = optionalStr(body.type);
+        if (type && !["book", "thesis", "other"].includes(type)) {
+          throw new HttpError(400, "invalid type");
+        }
+        const book = await project.createBook(templateDir, {
+          id: optionalStr(body.id),
+          title: optionalStr(body.title),
+          type
+        });
+        return reply(res, 201, { id: book.id });
+      }
+      case "POST /books/order": {
+        const body = await readJson(req);
+        if (!Array.isArray(body.books)) throw new HttpError(400, "books must be an array");
+        await project.setBookOrder(body.books.map((b) => str2(b, "book")));
+        return reply(res, 200, { ok: true });
+      }
+      case "POST /current": {
+        const body = await readJson(req);
+        await project.writeCurrent(body);
+        return reply(res, 200, { ok: true });
+      }
+      case "GET /events": {
+        res.writeHead(200, {
+          "content-type": "text/event-stream; charset=utf-8",
+          "cache-control": "no-store",
+          connection: "keep-alive"
+        });
+        res.write("retry: 1500\n\n");
+        clients.add(res);
+        req.on("close", () => clients.delete(res));
+        return true;
+      }
+    }
+    return false;
+  };
+  const bookRoutes = async (req, res, book, parts, url) => {
+    const route = routeKey(req.method ?? "GET", parts);
+    const id = parts[1];
+    switch (route) {
+      case "GET /":
+        return reply(res, 200, await book.summarize());
+      case "POST /config": {
+        const body = await readJson(req);
+        await book.updateConfig((doc) => {
+          for (const key of ["title", "subtitle", "author"]) {
+            if (typeof body[key] === "string") doc.set(key, body[key].trim());
+          }
+          if (typeof body.stage === "string") {
+            if (!STAGES.includes(body.stage)) throw new HttpError(400, "invalid stage");
+            doc.set("stage", body.stage);
+          }
+          if (typeof body.targetWords === "number" && body.targetWords >= 0) {
+            doc.set("targetWords", Math.round(body.targetWords));
+          }
+        });
+        return reply(res, 200, await book.summarize());
+      }
+      case "POST /order": {
+        const body = await readJson(req);
+        if (!Array.isArray(body.chapters)) throw new HttpError(400, "chapters must be an array");
+        await book.setChapterOrder(body.chapters.map((c) => str2(c, "chapter")));
+        return reply(res, 200, await book.summarize());
+      }
+      case "POST /chapters": {
+        const body = await readJson(req);
+        const newId = await book.createChapter(str2(body.title, "title"), {
+          summary: optionalStr(body.summary)
+        });
+        return reply(res, 201, { id: newId });
+      }
+      case "GET /chapters/:id":
+        return reply(res, 200, await book.readChapter(id));
+      case "PUT /chapters/:id": {
+        const body = await readJson(req);
+        const version = await book.writeChapter(
+          id,
+          str2(body.source, "source"),
+          optionalStr(body.baseVersion)
+        );
+        return reply(res, 200, { version });
+      }
+      case "PATCH /chapters/:id": {
+        const body = await readJson(req);
+        let base = optionalStr(body.baseVersion);
+        if (typeof body.title === "string") base = await book.setChapterTitle(id, body.title, base);
+        if (typeof body.summary === "string") {
+          base = await book.setChapterSummary(id, body.summary, base);
+        }
+        if (typeof body.status === "string") {
+          base = await book.setChapterStatus(id, body.status, base);
+        }
+        return reply(res, 200, { version: base });
+      }
+      case "POST /chapters/:id/list": {
+        const body = await readJson(req);
+        await book.addToOrder(id, typeof body.position === "number" ? body.position : void 0);
+        return reply(res, 200, await book.summarize());
+      }
+      case "POST /chapters/:id/unlist":
+        await book.removeFromOrder(id);
+        return reply(res, 200, await book.summarize());
+      case "POST /chapters/:id/replace": {
+        const body = await readJson(req);
+        const start = int(body.start, "start");
+        const end = int(body.end, "end");
+        const expected = str2(body.expected, "expected");
+        const text = str2(body.text, "text");
+        const version = await book.transformChapter(
+          id,
+          (s) => replaceRange(s, start, end, expected, text)
+        );
+        return reply(res, 200, { version });
+      }
+      case "POST /chapters/:id/comments": {
+        const body = await readJson(req);
+        let newId = "";
+        const version = await book.transformChapter(id, (s) => {
+          const out = insertComment(s, {
+            blockStart: int(body.blockStart, "blockStart"),
+            blockText: str2(body.blockText, "blockText"),
+            body: str2(body.body, "body"),
+            quote: optionalStr(body.quote)
+          });
+          newId = out.id;
+          return out.source;
+        });
+        return reply(res, 201, { id: newId, version });
+      }
+      case "DELETE /chapters/:id/annotations/:ann": {
+        const version = await book.transformChapter(id, (s) => removeAnnotation(s, parts[3]));
+        return reply(res, 200, { version });
+      }
+      case "POST /chapters/:id/annotations/:ann/accept": {
+        const version = await book.transformChapter(id, (s) => acceptSuggestion(s, parts[3]));
+        return reply(res, 200, { version });
+      }
+      case "GET /chapters/:id/history":
+        book.chapterPath(id);
+        return reply(res, 200, { snapshots: await book.history.list(id) });
+      case "GET /chapters/:id/history/:snap":
+        book.chapterPath(id);
+        return reply(res, 200, { source: await book.history.read(id, parts[3]) });
+      case "POST /chapters/:id/history/:snap/restore": {
+        const snapshot = await book.history.read(id, parts[3]);
+        const current = await book.readChapter(id);
+        await book.history.snapshot(id, current.source, true);
+        const version = await book.writeChapter(id, snapshot);
+        return reply(res, 200, { version });
+      }
+      case "GET /doc/brief":
+      case "GET /doc/style": {
+        const file = join7(book.root, parts[1] === "brief" ? "brief.md" : "STYLE.md");
+        const source = existsSync5(file) ? await readFile5(file, "utf8") : "";
+        return reply(res, 200, { source });
+      }
+      case "PUT /doc/brief":
+      case "PUT /doc/style": {
+        const body = await readJson(req);
+        const file = join7(book.root, parts[1] === "brief" ? "brief.md" : "STYLE.md");
+        await writeFile5(file, str2(body.source, "source"));
+        return reply(res, 200, { ok: true });
+      }
+      case "GET /files":
+        return reply(res, 200, await book.listFiles());
+      case "POST /files": {
+        const body = await readJson(req);
+        const folder = str2(body.folder, "folder");
+        const data = Buffer.from(str2(body.data, "data"), "base64");
+        const name = await book.saveFile(folder, str2(body.name, "name"), data);
+        return reply(res, 201, { name, path: `${folder}/${name}` });
+      }
+      case "DELETE /files": {
+        const folder = url.searchParams.get("folder") ?? "";
+        const name = url.searchParams.get("name") ?? "";
+        await book.trashFile(folder, name);
+        return reply(res, 200, { ok: true });
+      }
+      case "GET /export/docx":
+      case "GET /export/html":
+      case "GET /export/md": {
+        const format = parts[1];
+        const { renderManuscript: renderManuscript2 } = await Promise.resolve().then(() => (init_export(), export_exports));
+        const file = await renderManuscript2(book, format);
+        res.writeHead(200, {
+          "content-type": file.contentType,
+          "content-length": file.data.length,
+          "content-disposition": `attachment; filename="${book.id}.${format}"; filename*=UTF-8''${encodeURIComponent(file.fileName)}`,
+          "cache-control": "no-store"
+        });
+        res.end(file.data);
+        return true;
+      }
+    }
+    return false;
+  };
+  const api = async (req, res, url) => {
+    const parts = url.pathname.split("/").filter(Boolean).slice(1).map(decodeURIComponent);
+    const method = req.method ?? "GET";
+    if (await libraryRoutes(req, res, `${method} /${parts.join("/")}`)) return;
+    if (parts[0] === "books" && parts[1] && parts[1] !== "order") {
+      if (await bookRoutes(req, res, project.book(parts[1]), parts.slice(2), url)) return;
+    }
+    throw new HttpError(404, `no route for ${method} ${url.pathname}`);
+  };
+  const serveProjectFile = async (res, rel) => {
+    const path = resolve3(project.root, normalize(rel).replace(/^([/\\])+/, ""));
+    const inside = relative4(project.root, path);
+    if (inside.startsWith("..") || inside.split(sep4).some((seg) => seg.startsWith(".")) || !existsSync5(path) || !(await stat2(path)).isFile()) {
+      throw new HttpError(404, "not found");
+    }
+    res.writeHead(200, {
+      "content-type": MIME2[extname3(path).toLowerCase()] ?? "application/octet-stream",
+      "cache-control": "no-cache"
+    });
+    res.end(await readFile5(path));
+  };
+  const serveWeb = async (res, pathname) => {
+    const file = resolve3(webDir, `.${pathname === "/" ? "/index.html" : pathname}`);
+    const target = file.startsWith(resolve3(webDir)) && existsSync5(file) && (await stat2(file)).isFile() ? file : join7(webDir, "index.html");
+    if (!existsSync5(target)) {
+      res.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+      res.end("MoSage web UI is not built. Run `npm run build:web` in the mosage package.");
+      return;
+    }
+    res.writeHead(200, {
+      "content-type": MIME2[extname3(target)] ?? "application/octet-stream",
+      "cache-control": target.includes(`${sep4}assets${sep4}`) ? "max-age=31536000, immutable" : "no-cache"
+    });
+    res.end(await readFile5(target));
+  };
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", "http://localhost");
+    try {
+      guard(req, allowAnyHost);
+      if (url.pathname.startsWith("/api/")) return await api(req, res, url);
+      if (url.pathname.startsWith("/files/")) {
+        return await serveProjectFile(
+          res,
+          decodeURIComponent(url.pathname.slice("/files/".length))
+        );
+      }
+      return await serveWeb(res, url.pathname);
+    } catch (err) {
+      const status = err instanceof HttpError || err instanceof ProjectError ? err.status : err instanceof EditConflict ? 409 : err?.code === "ENOENT" ? 404 : 500;
+      if (status === 500) console.error(err);
+      if (!res.headersSent) send(res, status, { error: err.message ?? String(err) });
+      else res.end();
+    }
+  });
+  const heartbeat = setInterval(() => {
+    for (const res of clients) res.write(": ping\n\n");
+  }, 25e3);
+  const port = await listen(server, host, opts.port ?? 5280);
+  const shownHost = host === "0.0.0.0" || host === "::" ? "localhost" : host;
+  return {
+    url: `http://${shownHost.includes(":") ? `[${shownHost}]` : shownHost}:${port}`,
+    server,
+    async close() {
+      clearInterval(heartbeat);
+      for (const res of clients) res.end();
+      await watcher.close();
+      await new Promise((done) => server.close(() => done()));
+    }
+  };
+}
+function routeKey(method, parts) {
+  if (parts.length === 0) return `${method} /`;
+  const shape = parts.map((part, i) => {
+    if (parts[0] !== "chapters") return part;
+    if (i === 1) return ":id";
+    if (i === 3 && parts[2] === "annotations") return ":ann";
+    if (i === 3 && parts[2] === "history") return ":snap";
+    return part;
+  });
+  return `${method} /${shape.join("/")}`;
+}
+async function listen(server, host, port) {
+  for (let attempt = 0; attempt < 20; attempt++) {
+    try {
+      await new Promise((ok, fail) => {
+        server.once("error", fail);
+        server.listen(port + attempt, host, () => {
+          server.off("error", fail);
+          ok();
+        });
+      });
+      return server.address().port;
+    } catch (err) {
+      if (err.code !== "EADDRINUSE" || port === 0) throw err;
+    }
+  }
+  throw new Error(`No free port found from ${port}`);
+}
+
+// src/cli/init.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { cp as cp2, mkdir as mkdir5, readdir as readdir4, readFile as readFile6, rm as rm2, symlink, writeFile as writeFile6 } from "fs/promises";
+import { basename as basename3, join as join9, relative as relative5, resolve as resolve4 } from "path";
+import { parseDocument as parseDocument3 } from "yaml";
+
+// src/cli/paths.ts
+import { existsSync as existsSync6, readFileSync } from "fs";
+import { dirname as dirname4, join as join8 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var PACKAGE_ROOT = (() => {
+  let dir = dirname4(fileURLToPath3(import.meta.url));
+  for (; ; ) {
+    const pkg = join8(dir, "package.json");
+    if (existsSync6(pkg)) {
+      try {
+        if (JSON.parse(readFileSync(pkg, "utf8")).name === "mosage") return dir;
+      } catch {
+      }
+    }
+    const parent = dirname4(dir);
+    if (parent === dir) throw new Error("Cannot locate the mosage package root.");
+    dir = parent;
+  }
+})();
+var VERSION = true ? "0.1.0" : JSON.parse(readFileSync(join8(PACKAGE_ROOT, "package.json"), "utf8")).version;
+var PROJECT_TEMPLATE_DIR = join8(PACKAGE_ROOT, "template", "project");
+var BOOK_TEMPLATE_DIR = join8(PACKAGE_ROOT, "template", "book");
+var SKILLS_DIR = join8(PACKAGE_ROOT, "skills");
+var WEB_DIR = join8(PACKAGE_ROOT, "dist", "web");
+
+// src/cli/style.ts
+var enabled = process.stdout.isTTY && !process.env.NO_COLOR;
+var wrap = (open, close) => (text) => enabled ? `\x1B[${open}m${text}\x1B[${close}m` : text;
+var bold = wrap(1, 22);
+var dim = wrap(2, 22);
+var red = wrap(31, 39);
+var green = wrap(32, 39);
+var yellow = wrap(33, 39);
+var cyan = wrap(36, 39);
+var magenta = wrap(35, 39);
+
+// src/cli/init.ts
+function detectPackageManager() {
+  const agent = process.env.npm_config_user_agent ?? "";
+  if (agent.startsWith("pnpm")) return "pnpm";
+  if (agent.startsWith("yarn")) return "yarn";
+  if (agent.startsWith("bun")) return "bun";
+  return "npm";
+}
+async function isNonEmpty(dir) {
+  if (!existsSync7(dir)) return false;
+  return (await readdir4(dir)).some((name) => !name.startsWith("."));
+}
+function run(cmd, args, cwd, quiet = false) {
+  return new Promise((ok, fail) => {
+    const child = spawn(cmd, args, {
+      cwd,
+      stdio: quiet ? "ignore" : "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", fail);
+    child.on(
+      "close",
+      (code) => code === 0 ? ok() : fail(new Error(`${cmd} exited with ${code}`))
+    );
+  });
+}
+async function installSkills(target) {
+  const agentsDir = join9(target, ".agents", "skills");
+  const claudeDir = join9(target, ".claude", "skills");
+  await mkdir5(agentsDir, { recursive: true });
+  await mkdir5(claudeDir, { recursive: true });
+  const names = (await readdir4(SKILLS_DIR, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  for (const name of names) {
+    const src = join9(agentsDir, name);
+    await rm2(src, { recursive: true, force: true });
+    await cp2(join9(SKILLS_DIR, name), src, { recursive: true });
+    const link = join9(claudeDir, name);
+    await rm2(link, { recursive: true, force: true });
+    if (process.platform === "win32") {
+      await cp2(src, link, { recursive: true });
+    } else {
+      await symlink(relative5(claudeDir, src), link);
+    }
+  }
+  return names;
+}
+async function init(opts) {
+  const target = resolve4(process.cwd(), opts.dir);
+  if (await isNonEmpty(target) && !opts.force) {
+    throw new Error(`${target} \u4E0D\u662F\u7A7A\u8CC7\u6599\u593E\u3002\u63DB\u4E00\u500B\u540D\u7A31\uFF0C\u6216\u52A0\u4E0A --force \u5F37\u5236\u5EFA\u7ACB\u3002`);
+  }
+  await mkdir5(target, { recursive: true });
+  await cp2(PROJECT_TEMPLATE_DIR, target, { recursive: true, force: opts.force });
+  if (existsSync7(join9(target, "gitignore"))) {
+    await cp2(join9(target, "gitignore"), join9(target, ".gitignore"));
+    await rm2(join9(target, "gitignore"));
+  }
+  const name = basename3(target);
+  const pkgPath = join9(target, "package.json");
+  const pkg = JSON.parse(await readFile6(pkgPath, "utf8"));
+  pkg.name = name.toLowerCase().replace(/[^a-z0-9-_.]+/g, "-").replace(/^[-.]+|-+$/g, "") || "my-writing";
+  pkg.devDependencies = { ...pkg.devDependencies, mosage: `^${VERSION}` };
+  await writeFile6(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`);
+  const configPath = join9(target, "mosage.yaml");
+  if (opts.author) {
+    const doc = parseDocument3(await readFile6(configPath, "utf8"));
+    doc.set("author", opts.author);
+    await writeFile6(configPath, doc.toString({ lineWidth: 0 }));
+  }
+  const skills = await installSkills(target);
+  const out = process.stdout;
+  out.write(`
+${green("\u2714")} ${bold("\u5DF2\u5EFA\u7ACB\u5BEB\u4F5C\u5C08\u6848")} ${dim(target)}
+`);
+  out.write(dim(`  \u5DF2\u5B89\u88DD ${skills.length} \u500B AI skills\uFF1A${skills.join("\u3001")}
+`));
+  const pm = detectPackageManager();
+  let installed = false;
+  if (opts.install) {
+    out.write(`
+${bold(`\u6B63\u5728\u7528 ${pm} \u5B89\u88DD\u76F8\u4F9D\u5957\u4EF6\u2026`)}
+
+`);
+    try {
+      await run(pm, ["install"], target);
+      installed = true;
+    } catch (err) {
+      out.write(
+        `
+${yellow("!")} \u5B89\u88DD\u5931\u6557\uFF1A${dim(err.message)}\uFF0C\u7A0D\u5F8C\u53EF\u624B\u52D5\u57F7\u884C ${cyan(`${pm} install`)}
+`
+      );
+    }
+  }
+  if (opts.git) {
+    try {
+      await run("git", ["init", "-q"], target, true);
+      await run("git", ["add", "-A"], target, true);
+      await run(
+        "git",
+        [
+          "-c",
+          "user.name=MoSage",
+          "-c",
+          "user.email=mosage@localhost",
+          "commit",
+          "-qm",
+          "\u5EFA\u7ACB\u5BEB\u4F5C\u5C08\u6848"
+        ],
+        target,
+        true
+      );
+      out.write(`${green("\u2714")} \u5DF2\u5EFA\u7ACB git \u7248\u672C\u5EAB\uFF08AI \u7684\u6BCF\u4E00\u6B21\u4FEE\u6539\u90FD\u80FD\u56DE\u6EAF\uFF09
+`);
+    } catch {
+      out.write(`${yellow("!")} \u7565\u904E git \u521D\u59CB\u5316\uFF08\u627E\u4E0D\u5230 git \u6216\u521D\u59CB\u5316\u5931\u6557\uFF09
+`);
+    }
+  }
+  const cd = relative5(process.cwd(), target) || ".";
+  const devCmd = pm === "npm" ? "npm run dev" : `${pm} dev`;
+  out.write(`
+${bold("\u63A5\u4E0B\u4F86\uFF1A")}
+
+`);
+  out.write(`  ${dim("1.")} \u958B\u555F\u5BEB\u4F5C\u4ECB\u9762
+`);
+  if (cd !== ".") out.write(`     ${cyan(`cd ${cd}`)}
+`);
+  if (!installed) out.write(`     ${cyan(`${pm} install`)}
+`);
+  out.write(`     ${cyan(devCmd)}      ${dim("# \u700F\u89BD\u5668\u958B\u555F http://localhost:5280")}
+
+`);
+  out.write(`  ${dim("2.")} \u5728\u540C\u4E00\u500B\u8CC7\u6599\u593E\u958B\u555F AI \u5DE5\u5177
+`);
+  out.write(`     ${cyan("claude")}   ${dim("# Claude Code\uFF0C\u6216")}  ${cyan("codex")}
+
+`);
+  out.write(`  ${dim("3.")} \u5C0D AI \u8AAA\u300C${bold("\u958B\u59CB")}\u300D\uFF08\u6216\u8F38\u5165 ${cyan("/kickoff")}\uFF09
+`);
+  out.write(
+    dim(
+      "     AI \u6703\u5148\u4E86\u89E3\u4F60\u7684\u5BEB\u4F5C\u76EE\u7684\u3001\u8B80\u8005\u8207\u98A8\u683C\uFF0C\u518D\u548C\u4F60\u4E00\u8D77\u8A02\u66F8\u540D\u8207\u5927\u7DB1\uFF0C\n     \u5728\u700F\u89BD\u5668\u88E1\u7DE8\u6392\u597D\u7AE0\u7BC0\u5F8C\uFF0C\u5C31\u53EF\u4EE5\u958B\u59CB\u4E00\u7AE0\u4E00\u7AE0\u5BEB\u3002\n     \u4E00\u500B\u5C08\u6848\u53EF\u4EE5\u653E\u5F88\u591A\u672C\u66F8 \u2014\u2014 \u60F3\u5BEB\u4E0B\u4E00\u672C\u6642\uFF0C\u8DDF AI \u8AAA\u300C\u6211\u60F3\u5BEB\u4E00\u672C\u65B0\u66F8\u300D\u3002\n\n"
+    )
+  );
+}
+
+// src/cli/status.ts
+init_markdown();
+init_wordcount();
+import { existsSync as existsSync8 } from "fs";
+import { dirname as dirname5, resolve as resolve5 } from "path";
+var STAGE_LABEL = {
+  kickoff: "\u7ACB\u9805\uFF08\u8A2A\u8AC7\u5BEB\u4F5C\u76EE\u7684\uFF09",
+  outline: "\u5927\u7DB1\uFF08\u8A02\u66F8\u540D\u8207\u7AE0\u7BC0\uFF09",
+  writing: "\u64B0\u5BEB",
+  revising: "\u4FEE\u8A02",
+  done: "\u5B8C\u7A3F"
+};
+var STATUS_LABEL = {
+  idea: "\u69CB\u60F3",
+  draft: "\u8349\u7A3F",
+  revising: "\u4FEE\u8A02\u4E2D",
+  done: "\u5B8C\u6210"
+};
+async function collectStatus(target) {
+  const book = await target.summarize();
+  const notes = [];
+  const brokenImages = [];
+  for (const chapter of [...book.chapters, ...book.drafts]) {
+    const { source } = await target.readChapter(chapter.id);
+    const parsed = parseChapter(source);
+    for (const a of parsed.annotations) {
+      notes.push({
+        chapter: chapter.id,
+        id: a.id,
+        kind: a.kind,
+        by: a.by,
+        line: lineAt(source, a.start),
+        quote: a.quote,
+        body: a.body
+      });
+    }
+    const visit = (node) => {
+      const n = node;
+      if (n.type === "image") {
+        const img = node;
+        const url = decodeURI(img.url.split(/[?#]/)[0]);
+        if (!/^[a-z]+:/i.test(url) && url) {
+          const fromChapter = resolve5(dirname5(target.chapterPath(chapter.id)), url);
+          const fromRoot = resolve5(target.root, url);
+          if (!existsSync8(fromChapter) && !existsSync8(fromRoot)) {
+            brokenImages.push({
+              chapter: chapter.id,
+              line: img.position?.start.line ?? 0,
+              url: img.url
+            });
+          }
+        }
+      }
+      n.children?.forEach(visit);
+    };
+    visit(parsed.tree);
+  }
+  return { ...book, notes, brokenImages };
+}
+async function printStatus(target, json) {
+  const s = await collectStatus(target);
+  if (json) {
+    process.stdout.write(`${JSON.stringify(s, null, 2)}
+`);
+    return;
+  }
+  const { config } = s;
+  const out = (line = "") => process.stdout.write(`${line}
+`);
+  const kind = config.type === "thesis" ? "\u8AD6\u6587" : config.type === "book" ? "\u66F8" : "\u5BEB\u4F5C\u5C08\u6848";
+  out();
+  out(
+    `${bold(config.title || "\uFF08\u5C1A\u672A\u547D\u540D\uFF09")}${config.subtitle ? `  ${dim(config.subtitle)}` : ""}`
+  );
+  out(
+    dim(
+      `${kind}${config.author ? ` \xB7 ${config.author}` : ""} \xB7 \u968E\u6BB5\uFF1A${STAGE_LABEL[config.stage]}`
+    )
+  );
+  const goal = config.targetWords ? ` / \u76EE\u6A19 ${formatCount(config.targetWords)}` : "";
+  const pct = config.targetWords ? `\uFF08${Math.round(s.totals.words / config.targetWords * 100)}%\uFF09` : "";
+  out(dim(`\u5B57\u6578 ${formatCount(s.totals.words)}${goal}${pct}`));
+  out();
+  out(dim(`books/${s.id}/`));
+  out();
+  if (!s.hasBrief) {
+    out(`${yellow("\u9084\u6C92\u6709\u5BEB\u4F5C\u4F01\u5283\uFF08brief.md\uFF09\u3002")}\u5C0D AI \u8AAA\u300C\u958B\u59CB\u300D\u9032\u884C\u7ACB\u9805\u8A2A\u8AC7\u3002`);
+    out();
+  }
+  if (s.chapters.length) {
+    out(bold("\u7AE0\u7BC0"));
+    s.chapters.forEach((c, i) => {
+      const flags = [
+        c.comments ? yellow(`${c.comments} \u5247\u7559\u8A00\u5F85 AI \u8655\u7406`) : "",
+        c.suggestions ? magenta(`${c.suggestions} \u500B AI \u4FEE\u6539\u5EFA\u8B70`) : "",
+        c.aiNotes ? cyan(`${c.aiNotes} \u5247 AI \u7559\u8A00`) : ""
+      ].filter(Boolean);
+      out(
+        `  ${dim(String(i + 1).padStart(2))}  ${c.title}  ${dim(`${STATUS_LABEL[c.status]} \xB7 ${formatCount(c.words)} \u5B57 \xB7 ${c.id}`)}${flags.length ? `  ${flags.join("  ")}` : ""}`
+      );
+    });
+    out();
+  }
+  if (s.drafts.length) {
+    out(bold("\u672A\u6392\u5165\u76EE\u9304\u7684\u8349\u7A3F"));
+    for (const c of s.drafts) out(`  \xB7  ${c.title}  ${dim(c.id)}`);
+    out();
+  }
+  if (s.missing.length) {
+    out(red(`mosage.yaml \u5217\u51FA\u4F46\u627E\u4E0D\u5230\u7684\u6A94\u6848\uFF1A${s.missing.join("\u3001")}`));
+    out();
+  }
+  if (s.brokenImages.length) {
+    out(red("\u627E\u4E0D\u5230\u7684\u5716\u7247"));
+    for (const b of s.brokenImages)
+      out(`  books/${s.id}/chapters/${b.chapter}:${b.line}  ${b.url}`);
+    out();
+  }
+  if (s.notes.length) {
+    out(bold("\u5F85\u8655\u7406\u7684\u6A19\u8A18"));
+    for (const n of s.notes) {
+      const label = n.kind === "suggest" ? magenta("AI \u5EFA\u8B70") : n.by === "ai" ? cyan("AI \u7559\u8A00") : yellow("\u7D66 AI \u7684\u7559\u8A00");
+      const text = n.body.replace(/\s+/g, " ").slice(0, 60);
+      out(`  ${label}  ${dim(`books/${s.id}/chapters/${n.chapter}:${n.line}`)}  ${text}`);
+    }
+    out();
+  } else if (s.chapters.length) {
+    out(green("\u6C92\u6709\u5F85\u8655\u7406\u7684\u7559\u8A00\u6216\u5EFA\u8B70\u3002"));
+    out();
+  }
+}
+async function printLibrary(project, json) {
+  const books = await project.listBooks();
+  if (json) {
+    process.stdout.write(`${JSON.stringify({ root: project.root, books }, null, 2)}
+`);
+    return;
+  }
+  const out = (line = "") => process.stdout.write(`${line}
+`);
+  out();
+  if (books.length === 0) {
+    out(`${yellow("\u9019\u500B\u5C08\u6848\u9084\u6C92\u6709\u4EFB\u4F55\u66F8\u3002")}`);
+    out(
+      "\u7528 Claude Code \u6216 Codex \u958B\u555F\u9019\u500B\u8CC7\u6599\u593E\uFF0C\u8AAA\u300C\u958B\u59CB\u300D\u2014\u2014 AI \u6703\u5E36\u4F60\u5B8C\u6210\u7ACB\u9805\u8A2A\u8AC7\u4E26\u5EFA\u7ACB\u7B2C\u4E00\u672C\u66F8\u3002"
+    );
+    out();
+    return;
+  }
+  out(bold(`\u66F8\u67B6\uFF08${books.length} \u672C\uFF09`));
+  for (const b of books) {
+    const c = b.config;
+    const kind = c.type === "thesis" ? "\u8AD6\u6587" : c.type === "book" ? "\u66F8" : "\u9577\u6587";
+    const progress = c.targetWords ? `${formatCount(b.totals.words)} / ${formatCount(c.targetWords)} \u5B57` : `${formatCount(b.totals.words)} \u5B57`;
+    const flags = [
+      b.totals.comments ? yellow(`${b.totals.comments} \u5247\u7559\u8A00\u5F85\u8655\u7406`) : "",
+      b.totals.suggestions ? magenta(`${b.totals.suggestions} \u500B AI \u5EFA\u8B70`) : ""
+    ].filter(Boolean);
+    out(
+      `  ${bold(c.title || "\uFF08\u672A\u547D\u540D\uFF09")}  ${dim(`${kind} \xB7 ${STAGE_LABEL[c.stage]} \xB7 ${b.chapters.length} \u7AE0 \xB7 ${progress} \xB7 books/${b.id}/`)}${flags.length ? `  ${flags.join("  ")}` : ""}`
+    );
+  }
+  out();
+  out(dim("\u67E5\u770B\u55AE\u672C\uFF1Amosage status <\u4EE3\u865F>"));
+  out();
+}
+
+// src/cli/index.ts
+var HELP = `
+${bold("MoSage")} ${dim(`v${VERSION}`)} \u2014 \u548C AI \u4E00\u8D77\u5BEB\u66F8\u3001\u5BEB\u8AD6\u6587
+
+${bold("\u5EFA\u7ACB\u5C08\u6848")}\uFF08\u4E00\u500B\u5C08\u6848\u53EF\u4EE5\u653E\u5F88\u591A\u672C\u66F8\uFF09
+  ${cyan("npx mosage init <\u8CC7\u6599\u593E>")}          \u5EFA\u7ACB\u5BEB\u4F5C\u5C08\u6848
+      --author <\u4F5C\u8005>  --no-install  --no-git  --force
+
+${bold("\u5728\u5C08\u6848\u8CC7\u6599\u593E\u88E1")}
+  ${cyan("mosage dev")}                         \u958B\u555F\u5BEB\u4F5C\u4ECB\u9762\uFF08\u9810\u8A2D http://localhost:5280\uFF09
+      --port <\u57E0\u865F>  --host <\u4F4D\u5740>  --no-open
+  ${cyan("mosage new <\u4EE3\u865F>")}                  \u65B0\u589E\u4E00\u672C\u66F8\uFF08\u901A\u5E38\u7531 AI \u5728\u7ACB\u9805\u6642\u57F7\u884C\uFF09
+      --title <\u66F8\u540D>  --type book|thesis|other
+  ${cyan("mosage status [\u66F8]")}                 \u66F8\u67B6\u7E3D\u89BD\uFF0F\u55AE\u672C\u66F8\u7684\u7AE0\u7BC0\u3001\u5B57\u6578\u3001\u5F85\u8655\u7406\u6A19\u8A18
+      --json
+  ${cyan("mosage export [\u66F8] [docx|html|md]")}  \u532F\u51FA\uFF08\u9810\u8A2D Word\uFF09\u5230 output/<\u66F8>/
+      --out <\u6A94\u6848\u8DEF\u5F91>
+  ${cyan("mosage import <\u6A94\u6848.docx|.md>")}      \u532F\u5165\u65E2\u6709\u7A3F\u4EF6\uFF0C\u4F9D\u6A19\u984C\u5207\u6210\u7AE0\u7BC0\uFF08\u9810\u8A2D\u5EFA\u7ACB\u65B0\u66F8\uFF09
+      --book <\u4EE3\u865F>  --title <\u66F8\u540D>  --no-split  --unlisted
+  ${cyan("mosage sync-skills")}                 \u5347\u7D1A mosage \u5F8C\uFF0C\u66F4\u65B0\u5C08\u6848\u88E1\u7684 AI skills
+
+  [\u66F8] \u53EF\u7701\u7565\uFF1A\u5728\u66F8\u7684\u8CC7\u6599\u593E\u88E1\u57F7\u884C\u3001\u6216\u5C08\u6848\u53EA\u6709\u4E00\u672C\u66F8\u6642\u6703\u81EA\u52D5\u5224\u65B7\u3002
+`;
+var FORMATS = /* @__PURE__ */ new Set(["docx", "html", "md"]);
+function openBrowser(url) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", '""', url]] : ["xdg-open", [url]];
+  try {
+    const child = spawn2(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+async function ask(question, fallback) {
+  if (!process.stdin.isTTY) return fallback;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`${question} ${dim(`(${fallback})`)} `)).trim();
+    return answer || fallback;
+  } finally {
+    rl.close();
+  }
+}
+function projectType(value) {
+  if (value === void 0) return void 0;
+  if (value === "book" || value === "thesis" || value === "other") return value;
+  throw new Error("--type \u53EA\u80FD\u662F book\u3001thesis \u6216 other");
+}
+async function main(argv) {
+  if (argv.length === 0) {
+    try {
+      Project.find();
+    } catch {
+      process.stdout.write(HELP);
+      return;
+    }
+  }
+  const [command = "dev", ...rest] = argv;
+  const { values, positionals } = parseArgs({
+    args: rest,
+    allowPositionals: true,
+    strict: false,
+    options: {
+      port: { type: "string" },
+      host: { type: "string" },
+      "no-open": { type: "boolean" },
+      out: { type: "string" },
+      json: { type: "boolean" },
+      type: { type: "string" },
+      title: { type: "string" },
+      author: { type: "string" },
+      book: { type: "string" },
+      "no-install": { type: "boolean" },
+      "no-git": { type: "boolean" },
+      force: { type: "boolean" },
+      "no-split": { type: "boolean" },
+      unlisted: { type: "boolean" }
+    }
+  });
+  const opt = (name) => typeof values[name] === "string" ? values[name] : void 0;
+  switch (command) {
+    case "help":
+    case "--help":
+    case "-h":
+      process.stdout.write(HELP);
+      return;
+    case "version":
+    case "--version":
+    case "-v":
+      process.stdout.write(`${VERSION}
+`);
+      return;
+    case "init":
+    case "create": {
+      const dir = positionals[0] ?? await ask("\u5C08\u6848\u8CC7\u6599\u593E\u540D\u7A31\uFF1F", "my-writing");
+      await init({
+        dir,
+        author: opt("author"),
+        install: !values["no-install"],
+        git: !values["no-git"],
+        force: Boolean(values.force)
+      });
+      return;
+    }
+    case "dev":
+    case "start":
+    case "open": {
+      const project = Project.find();
+      const host = opt("host") ?? "127.0.0.1";
+      const running = await startServer(project, {
+        port: opt("port") ? Number(opt("port")) : 5280,
+        host,
+        webDir: WEB_DIR,
+        bookTemplateDir: BOOK_TEMPLATE_DIR
+      });
+      process.stdout.write(
+        `
+${green("\u25CF")} ${bold("MoSage \u5BEB\u4F5C\u4ECB\u9762")}  ${cyan(running.url)}
+${dim(`  \u5C08\u6848\uFF1A${project.root}`)}
+`
+      );
+      if (host !== "127.0.0.1" && host !== "localhost") {
+        process.stdout.write(
+          `${yellow("!")} \u4F3A\u670D\u5668\u5C0D ${host} \u958B\u653E \u2014\u2014 \u540C\u4E00\u500B\u7DB2\u8DEF\u4E0A\u7684\u4EFB\u4F55\u4EBA\u90FD\u80FD\u8B80\u5BEB\u4F60\u7684\u7A3F\u4EF6\u3002
+`
+        );
+      }
+      process.stdout.write(dim("  \u6309 Ctrl+C \u7D50\u675F\n\n"));
+      if (!values["no-open"]) openBrowser(running.url);
+      const stop = async () => {
+        await running.close();
+        process.exit(0);
+      };
+      process.on("SIGINT", stop);
+      process.on("SIGTERM", stop);
+      return;
+    }
+    case "new": {
+      const project = Project.find();
+      const book = await project.createBook(BOOK_TEMPLATE_DIR, {
+        id: positionals[0],
+        title: opt("title"),
+        type: projectType(opt("type"))
+      });
+      process.stdout.write(
+        `${green("\u2714")} \u5DF2\u5EFA\u7ACB ${bold(`books/${book.id}/`)}\uFF08book.yaml\u3001brief.md\u3001STYLE.md\u3001chapters/\u3001assets/\u3001notes/\uFF09
+`
+      );
+      return;
+    }
+    case "status": {
+      const project = Project.find();
+      const json = Boolean(values.json);
+      const explicit = positionals[0];
+      let book = null;
+      if (explicit) book = project.book(explicit);
+      else {
+        try {
+          book = await project.resolveBook();
+        } catch {
+          book = null;
+        }
+      }
+      if (book) await printStatus(book, json);
+      else await printLibrary(project, json);
+      return;
+    }
+    case "export": {
+      const project = Project.find();
+      const format = positionals.find((p) => FORMATS.has(p.replace(/^\./, "")))?.replace(/^\./, "");
+      const bookId = positionals.find((p) => !FORMATS.has(p.replace(/^\./, "")));
+      const book = await project.resolveBook(bookId);
+      const { exportManuscript: exportManuscript2 } = await Promise.resolve().then(() => (init_export(), export_exports));
+      const result = await exportManuscript2(book, format ?? "docx", opt("out"));
+      process.stdout.write(
+        `${green("\u2714")} \u5DF2\u532F\u51FA ${bold(result.path)} ${dim(`(${Math.max(1, Math.round(result.bytes / 1024))} KB)`)}
+`
+      );
+      return;
+    }
+    case "import": {
+      const file = positionals[0];
+      if (!file) throw new Error("\u8ACB\u6307\u5B9A\u8981\u532F\u5165\u7684\u6A94\u6848\uFF0C\u4F8B\u5982\uFF1Amosage import \u66F8\u7A3F.docx");
+      const project = Project.find();
+      const target = opt("book");
+      let book;
+      let created = false;
+      const existing = target ? await project.listBookIds() : [];
+      if (target && existing.includes(target)) {
+        book = project.book(target);
+      } else {
+        const title = opt("title") ?? basename7(file, extname7(file));
+        book = await project.createBook(BOOK_TEMPLATE_DIR, { id: target, title });
+        await book.updateConfig((doc) => doc.set("stage", "writing"));
+        created = true;
+      }
+      const { importFile: importFile2 } = await Promise.resolve().then(() => (init_import(), import_exports));
+      const result = await importFile2(book, file, {
+        split: !values["no-split"],
+        listed: !values.unlisted
+      });
+      if (created) process.stdout.write(`${green("\u2714")} \u5EFA\u7ACB\u65B0\u66F8 ${bold(`books/${book.id}/`)}
+`);
+      process.stdout.write(`${green("\u2714")} \u532F\u5165 ${result.created.length} \u500B\u7AE0\u7BC0
+`);
+      for (const id of result.created) process.stdout.write(dim(`   chapters/${id}
+`));
+      if (result.assets.length) {
+        process.stdout.write(dim(`   \u53E6\u5B58\u4E86 ${result.assets.length} \u5F35\u5716\u7247\u5230 assets/imported/
+`));
+      }
+      for (const w of result.warnings) process.stdout.write(`${yellow("!")} ${w}
+`);
+      if (created) {
+        process.stdout.write(
+          dim(
+            "\n  \u5EFA\u8B70\u63A5\u8457\u8ACB AI \u8B80\u904E\u7A3F\u5B50\u3001\u88DC\u9F4A brief.md \u8207 STYLE.md\uFF08\u5C0D AI \u8AAA\u300C\u5E6B\u6211\u6574\u7406\u9019\u672C\u532F\u5165\u7684\u66F8\u300D\uFF09\u3002\n"
+          )
+        );
+      }
+      return;
+    }
+    case "sync-skills": {
+      const project = Project.find();
+      const names = await installSkills(project.root);
+      process.stdout.write(`${green("\u2714")} \u5DF2\u66F4\u65B0 ${names.length} \u500B skills\uFF1A${names.join("\u3001")}
+`);
+      return;
+    }
+    default:
+      process.stdout.write(`${red(`\u4E0D\u8A8D\u5F97\u7684\u6307\u4EE4\uFF1A${command}`)}
+${HELP}`);
+      process.exitCode = 1;
+  }
+}
+main(process.argv.slice(2)).catch((err) => {
+  process.stderr.write(`${red("\u2716")} ${err.message ?? err}
+`);
+  process.exit(1);
+});