@huoweifang/dsh-mindmap 0.1.0 → 0.2.0

package/lib/index.js

@@ -6,6 +6,9 @@ import { join as join2, resolve } from "node:path";
 var ROUTE_PREFIX = "/dsh-mindmap/api";
 
 // src/shared/markdown.ts
+function needsEscape(t) {
+  return LIST_RE.test(t) || HEADING_RE.test(t) || t.startsWith("\\") || t.startsWith(">") || FENCE_RE.test(t);
+}
 function unescapeFirst(text) {
   const m = /^(?: )+/.exec(text);
   if (m !== null) return " ".repeat(m[0].length / 5) + text.slice(m[0].length);
@@ -15,40 +18,85 @@ function unescapeRest(line) {
   const t = line.trimStart();
   if (!t.startsWith("\\")) return line;
   const u = t.slice(1);
-  return LIST_RE.test(u) || HEADING_RE.test(u) || u.startsWith("\\") ? line.slice(0, line.length - t.length) + u : line;
+  return needsEscape(u) ? line.slice(0, line.length - t.length) + u : line;
 }
 var LIST_RE = /^(\s*)([-*+]|\d{1,9}[.)])(\s+|$)(.*)$/;
 var HEADING_RE = /^(#{1,6})\s+(.*?)\s*#*\s*$/;
 var CHECK_RE = /^\[( |x|X)\](?:\s+|$)([\s\S]*)$/;
+var FENCE_RE = /^(```+|~~~+)/;
+var QUOTE_RE = /^>\s?(.*)$/;
 function indentOf(line) {
   return line.length - line.trimStart().length;
 }
+function addNote(item, text, blanks) {
+  item.note = item.note === void 0 ? text : item.note + "\n".repeat(blanks > 0 ? 2 : 1) + text;
+}
 function parseMarkdown(src, options = {}) {
   const detectTitle = options.detectTitle ?? true;
   const lines = src.replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n").split("\n").map((l) => l.replace(/\t/g, "    "));
-  const h1Count = lines.filter((l) => /^#\s+\S/.test(l)).length;
+  let h1Count = 0;
+  {
+    let fence = null;
+    for (const l of lines) {
+      const fm = FENCE_RE.exec(l.trimStart());
+      if (fence !== null) {
+        if (fm !== null && fm[1].startsWith(fence)) fence = null;
+        continue;
+      }
+      if (fm !== null) {
+        fence = fm[1];
+        continue;
+      }
+      if (/^#\s+\S/.test(l)) h1Count++;
+    }
+  }
   const root = [];
   const headings = [];
   let list = [];
   let last = null;
+  let freshHeading = null;
   let blanks = 0;
   let title;
   const container = () => headings.length > 0 ? headings[headings.length - 1].item.children : root;
-  for (const line of lines) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
     if (line.trim().length === 0) {
       blanks++;
       continue;
     }
+    const ind = indentOf(line);
+    const trimmed = line.slice(ind);
+    const fm = FENCE_RE.exec(trimmed);
+    if (fm !== null) {
+      const block = [trimmed];
+      let j = i + 1;
+      for (; j < lines.length; j++) {
+        const l = lines[j];
+        const body = l.slice(Math.min(ind, indentOf(l)));
+        block.push(body);
+        const close = FENCE_RE.exec(l.trimStart());
+        if (close !== null && close[1].startsWith(fm[1]) && l.trimStart().slice(close[1].length).trim().length === 0) break;
+      }
+      i = j;
+      const text = block.join("\n");
+      const owner = last !== null && ind > last.marker ? last.item : freshHeading ?? last?.item ?? null;
+      if (owner !== null) addNote(owner, text, blanks);
+      else container().push({ text, children: [] });
+      blanks = 0;
+      continue;
+    }
     const hm = HEADING_RE.exec(line);
     if (hm !== null) {
       const level = hm[1].length;
       if (detectTitle && title === void 0 && level === 1 && h1Count === 1 && root.length === 0) {
         title = hm[2];
+        freshHeading = null;
       } else {
         while (headings.length > 0 && headings[headings.length - 1].level >= level) headings.pop();
         const item = { text: hm[2], children: [] };
         container().push(item);
         headings.push({ level, item });
+        freshHeading = item;
       }
       list = [];
       last = null;
@@ -72,16 +120,24 @@ function parseMarkdown(src, options = {}) {
       (list.length > 0 ? list[list.length - 1].item.children : container()).push(item);
       list.push({ indent, item });
       last = { marker: indent, content: indent + lm[2].length + Math.max(1, lm[3].length), item };
+      freshHeading = null;
       blanks = 0;
       continue;
     }
-    const ind = indentOf(line);
+    const qm = QUOTE_RE.exec(trimmed);
     if (last !== null && ind > last.marker) {
-      last.item.text += "\n".repeat(blanks + 1) + unescapeRest(line.slice(Math.min(ind, last.content)));
+      if (qm !== null) addNote(last.item, qm[1], 0);
+      else last.item.text += "\n".repeat(blanks + 1) + unescapeRest(line.slice(Math.min(ind, last.content)));
       blanks = 0;
       continue;
     }
-    container().push({ text: line.trim(), children: [] });
+    const para = qm !== null ? qm[1] : trimmed;
+    if (freshHeading !== null) {
+      addNote(freshHeading, para, blanks);
+      blanks = 0;
+      continue;
+    }
+    container().push({ text: para, children: [] });
     list = [];
     last = null;
     blanks = 0;
@@ -108,7 +164,7 @@ function parseOpml(xml) {
   const body = bodyAt >= 0 ? xml.slice(bodyAt) : xml;
   const root = [];
   const stack = [];
-  const tokens = /<outline\b([^>]*?)(\/?)>|<\/outline\s*>/gi;
+  const tokens = /<outline\b((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>|<\/outline\s*>/gi;
   let m;
   while ((m = tokens.exec(body)) !== null) {
     if (m[0].startsWith("</")) {
@@ -123,6 +179,8 @@ function parseOpml(xml) {
     const flag = attrs._checked ?? attrs._complete;
     if (flag === "true") item.checked = true;
     else if (attrs._checked === "false") item.checked = false;
+    const note = (attrs._note ?? "").replace(/\r/g, "");
+    if (note.trim().length > 0) item.note = note;
     (stack.length > 0 ? stack[stack.length - 1].children : root).push(item);
     if (m[2] !== "/") stack.push(item);
   }
@@ -130,11 +188,20 @@ function parseOpml(xml) {
   return title !== void 0 && title.length > 0 ? { title, items: root } : { items: root };
 }
 
-// src/host/storage.ts
-import { mkdir, open, readFile, readdir, rename, rm, stat } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
 // src/shared/model.ts
+var MAX_IMPORT_DEPTH = 200;
+function itemsDepth(items) {
+  let max = 0;
+  const stack = [[items, 1]];
+  while (stack.length > 0) {
+    const [list, depth] = stack.pop();
+    for (const it of list) {
+      if (depth > max) max = depth;
+      if (it.children.length > 0) stack.push([it.children, depth + 1]);
+    }
+  }
+  return max;
+}
 var ID_RE = /^[a-z0-9-]{6,64}$/;
 var MAX_TITLE = 200;
 var counter = 0;
@@ -150,18 +217,32 @@ function normalizeTitle(raw, fallback = "\u672A\u547D\u540D\u6587\u6863") {
 function createDoc(title, now, items = [], id = newId()) {
   const rootId = newId();
   const nodes = {};
-  const build = (item) => {
-    const nid = newId();
-    const node = { id: nid, text: item.text, children: [] };
-    if (typeof item.checked === "boolean") node.checked = item.checked;
-    nodes[nid] = node;
-    node.children = item.children.map(build);
-    return nid;
-  };
-  const top = (items.length > 0 ? items : [{ text: "", children: [] }]).map(build);
-  nodes[rootId] = { id: rootId, text: "", children: top };
+  nodes[rootId] = { id: rootId, text: "", children: [] };
+  buildItems(nodes, rootId, items.length > 0 ? items : [{ text: "", children: [] }]);
   return { schema: 1, id, title: normalizeTitle(title), rootId, nodes, revision: 0, createdAt: now, updatedAt: now };
 }
+function nodeFromItem(item) {
+  const node = { id: newId(), text: item.text, children: [] };
+  if (typeof item.checked === "boolean") node.checked = item.checked;
+  if (typeof item.note === "string" && item.note.length > 0) node.note = item.note;
+  return node;
+}
+function buildItems(nodes, parentId, items) {
+  const top = [];
+  const stack = [];
+  for (let i = items.length - 1; i >= 0; i--) stack.push([items[i], top]);
+  const order = [];
+  while (stack.length > 0) {
+    const [item, into] = stack.pop();
+    const node = nodeFromItem(item);
+    nodes[node.id] = node;
+    order.push([node.id, into]);
+    for (let i = item.children.length - 1; i >= 0; i--) stack.push([item.children[i], node.children]);
+  }
+  for (const [id, into] of order) into.push(id);
+  if (parentId !== null) nodes[parentId].children.push(...top);
+  return top;
+}
 function validateDoc(value) {
   if (typeof value !== "object" || value === null) return "document is not an object";
   const doc = value;
@@ -170,6 +251,7 @@ function validateDoc(value) {
   if (typeof doc.title !== "string") return "invalid title";
   if (typeof doc.revision !== "number" || !Number.isInteger(doc.revision) || doc.revision < 0) return "invalid revision";
   if (typeof doc.nodes !== "object" || doc.nodes === null) return "invalid nodes";
+  if (doc.view !== void 0 && (typeof doc.view !== "object" || doc.view === null)) return "invalid view";
   const root = doc.nodes[doc.rootId];
   if (root === void 0) return "root node missing";
   const seen = /* @__PURE__ */ new Set();
@@ -182,6 +264,7 @@ function validateDoc(value) {
     if (node === void 0) return `dangling child reference ${id}`;
     if (node.id !== id) return `node key mismatch ${id}`;
     if (typeof node.text !== "string") return `node ${id} has no text`;
+    if (node.note !== void 0 && typeof node.note !== "string") return `node ${id} has an invalid note`;
     if (!Array.isArray(node.children)) return `node ${id} has no children array`;
     for (const child of node.children) {
       if (typeof child !== "string") return `node ${id} has a non-string child`;
@@ -192,6 +275,26 @@ function validateDoc(value) {
   if (seen.size !== total) return `${total - seen.size} orphan node(s)`;
   return null;
 }
+function toItems(doc, ids) {
+  const out = [];
+  const stack = [];
+  for (let i = ids.length - 1; i >= 0; i--) stack.push([ids[i], out]);
+  while (stack.length > 0) {
+    const [id, into] = stack.pop();
+    const node = doc.nodes[id];
+    if (node === void 0) continue;
+    const item = { text: node.text, children: [] };
+    if (typeof node.checked === "boolean") item.checked = node.checked;
+    if (typeof node.note === "string" && node.note.length > 0) item.note = node.note;
+    into.push(item);
+    for (let i = node.children.length - 1; i >= 0; i--) stack.push([node.children[i], item.children]);
+  }
+  return out;
+}
+
+// src/host/storage.ts
+import { mkdir, open, readFile, readdir, rename, rm, stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
 
 // src/shared/search.ts
 function snippetOf(text, at, len) {
@@ -200,29 +303,48 @@ function snippetOf(text, at, len) {
   const end = Math.min(flat.length, at + len + 40);
   return (start > 0 ? "\u2026" : "") + flat.slice(start, end) + (end < flat.length ? "\u2026" : "");
 }
-function searchDoc(doc, title, query, limit = 20) {
-  const q = query.trim().toLowerCase();
-  if (q.length === 0) return [];
+function indexDoc(doc) {
+  const entries = [];
+  const stack = (doc.nodes[doc.rootId]?.children ?? []).slice().reverse();
+  while (stack.length > 0) {
+    const id = stack.pop();
+    const n = doc.nodes[id];
+    if (n === void 0) continue;
+    entries.push([id, n.text, n.note ?? ""]);
+    for (let i = n.children.length - 1; i >= 0; i--) stack.push(n.children[i]);
+  }
+  return { docId: doc.id, revision: doc.revision, entries };
+}
+function searchIndex(index, title, query, limit = 20) {
+  const q = query.trim().toLowerCase().replace(/\s+/g, " ");
+  if (q.length === 0 || limit <= 0) return [];
   const hits = [];
   const ti = title.toLowerCase().indexOf(q);
-  if (ti >= 0) hits.push({ docId: doc.id, title, nodeId: null, snippet: snippetOf(title, ti, q.length) });
-  const walk = (ids) => {
-    for (const id of ids) {
-      if (hits.length >= limit) return;
-      const n = doc.nodes[id];
-      if (n === void 0) continue;
-      const at = n.text.toLowerCase().replace(/\s/g, " ").indexOf(q);
-      if (at >= 0) hits.push({ docId: doc.id, title, nodeId: id, snippet: snippetOf(n.text, at, q.length) });
-      walk(n.children);
+  if (ti >= 0) hits.push({ docId: index.docId, title, nodeId: null, snippet: snippetOf(title, ti, q.length) });
+  for (const [id, text, note] of index.entries) {
+    if (hits.length >= limit) break;
+    const at = text.toLowerCase().replace(/\s/g, " ").indexOf(q);
+    if (at >= 0) {
+      hits.push({ docId: index.docId, title, nodeId: id, snippet: snippetOf(text, at, q.length) });
+      continue;
     }
-  };
-  walk(doc.nodes[doc.rootId]?.children ?? []);
+    const nt = note.length > 0 ? note.toLowerCase().replace(/\s/g, " ").indexOf(q) : -1;
+    if (nt >= 0) hits.push({ docId: index.docId, title, nodeId: id, snippet: snippetOf(note, nt, q.length) });
+  }
   return hits;
 }
 
 // src/host/storage.ts
-var MAX_BACKUPS = 30;
-var BACKUP_RE = /^mindmap-\d{8}(?:-\d{6})?(?:-pre-restore)?\.json$/;
+var BACKUP_KEEP = { daily: 14, manual: 10, "pre-restore": 5, purge: 5 };
+var BACKUP_RE = /^mindmap-\d{8}(?:-\d{6})?(?:-(?:pre-restore|purge))?\.json$/;
+var TRASH_RETENTION_MS = 30 * 24 * 3600 * 1e3;
+var DOC_CACHE_LIMIT = 50;
+var PURGE_BACKUP_DEDUPE_MS = 60 * 1e3;
+function backupKind(name2) {
+  if (name2.endsWith("-pre-restore.json")) return "pre-restore";
+  if (name2.endsWith("-purge.json")) return "purge";
+  return /^mindmap-\d{8}\.json$/.test(name2) ? "daily" : "manual";
+}
 var StorageError = class extends Error {
   code;
   current;
@@ -267,6 +389,26 @@ async function atomicWrite(file, contents) {
 function isEnoent(error) {
   return error?.code === "ENOENT";
 }
+async function renameRetry(from, to) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await rename(from, to);
+      return;
+    } catch (error) {
+      const code = error.code;
+      if (attempt >= 8 || code !== "EPERM" && code !== "EBUSY" && code !== "EACCES") throw error;
+      await sleep(50 * (attempt + 1));
+    }
+  }
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function sanitizeMeta(raw) {
   if (typeof raw !== "object" || raw === null) return null;
   const m = raw;
@@ -282,17 +424,31 @@ function sanitizeMeta(raw) {
   if (typeof m.trashedAt === "number") meta.trashedAt = m.trashedAt;
   return meta;
 }
+function wouldCycle(folders, id, parentId) {
+  const byId = new Map(folders.map((f) => [f.id, f]));
+  let cur = parentId;
+  for (let guard = 0; cur !== null && guard <= folders.length; guard++) {
+    if (cur === id) return true;
+    cur = byId.get(cur)?.parentId ?? null;
+  }
+  return cur !== null;
+}
 function sanitizeLibrary(raw) {
   if (typeof raw !== "object" || raw === null) return null;
   const l = raw;
   if (!Array.isArray(l.docs) || !Array.isArray(l.folders)) return null;
   const folders = [];
+  const seenFolders = /* @__PURE__ */ new Set();
   for (const f of l.folders) {
-    if (typeof f === "object" && f !== null && typeof f.id === "string" && ID_RE.test(f.id) && typeof f.name === "string") {
-      folders.push({ id: f.id, name: normalizeTitle(f.name, "\u65B0\u5EFA\u6587\u4EF6\u5939"), createdAt: Number(f.createdAt) || 0 });
-    }
+    if (typeof f !== "object" || f === null) continue;
+    const r = f;
+    if (typeof r.id !== "string" || !ID_RE.test(r.id) || typeof r.name !== "string" || seenFolders.has(r.id)) continue;
+    seenFolders.add(r.id);
+    folders.push({ id: r.id, name: normalizeTitle(r.name, "\u65B0\u5EFA\u6587\u4EF6\u5939"), createdAt: Number(r.createdAt) || 0, parentId: typeof r.parentId === "string" ? r.parentId : null });
   }
   const ids = new Set(folders.map((f) => f.id));
+  for (const f of folders) if (f.parentId !== null && f.parentId !== void 0 && !ids.has(f.parentId)) f.parentId = null;
+  for (const f of folders) if (f.parentId !== null && f.parentId !== void 0 && wouldCycle(folders, f.id, f.parentId)) f.parentId = null;
   const docs = [];
   const seen = /* @__PURE__ */ new Set();
   for (const d of l.docs) {
@@ -308,11 +464,14 @@ var MindmapStorage = class {
   dir;
   now;
   library = { schema: 1, folders: [], docs: [] };
+  /** LRU cache of whole documents (Map keeps insertion order). */
   docs = /* @__PURE__ */ new Map();
+  /** Compact text index of every readable document, for search. */
+  index = /* @__PURE__ */ new Map();
   queue = Promise.resolve();
   loading;
-  /** Problems found while loading (quarantined files etc.). */
-  warnings = [];
+  pendingWarnings = [];
+  lastPurgeBackup = null;
   constructor(dir, now = () => Date.now()) {
     this.dir = dir;
     this.now = now;
@@ -323,12 +482,32 @@ var MindmapStorage = class {
   get docsDir() {
     return join(this.dir, "docs");
   }
+  get stagingDir() {
+    return join(this.dir, "docs.new");
+  }
+  get retiredDir() {
+    return join(this.dir, "docs.old");
+  }
+  get restoreMarker() {
+    return join(this.dir, "restore.pending.json");
+  }
   get backupsDir() {
     return join(this.dir, "backups");
   }
   docFile(id) {
     return join(this.docsDir, `${id}.json`);
   }
+  /** Problems found while loading that have not been reported yet. */
+  get warnings() {
+    return this.pendingWarnings;
+  }
+  /** Return the unreported warnings and forget them (each is reported once). */
+  async takeWarnings() {
+    await this.ready();
+    const out = this.pendingWarnings;
+    this.pendingWarnings = [];
+    return out;
+  }
   /** Serialize every mutation (and the initial load) through one queue. */
   serial(fn) {
     const run = this.queue.then(() => this.ready()).then(fn);
@@ -344,10 +523,35 @@ var MindmapStorage = class {
     const target = file.replace(/\.json$/, `.corrupt-${stamp(this.now(), true)}.json`);
     await rename(file, target).catch(() => {
     });
-    this.warnings.push(`${why}: \u5DF2\u9694\u79BB\u4E3A ${target}`);
+    this.pendingWarnings.push(`${why}\uFF1A\u5DF2\u9694\u79BB\u4E3A ${target}`);
     console.warn(`[dsh-mindmap] ${why}; quarantined as ${target}`);
   }
+  /**
+   * Finish or roll back a restore interrupted by a crash. The marker holds the
+   * library to install; docs.new present means the directory swap never
+   * completed, so the old documents are put back.
+   */
+  async recoverRestore() {
+    const marker = await readFile(this.restoreMarker, "utf8").catch(() => null);
+    if (marker === null) {
+      await rm(this.stagingDir, { recursive: true, force: true });
+      await rm(this.retiredDir, { recursive: true, force: true });
+      return;
+    }
+    if (await exists(this.stagingDir)) {
+      if (!await exists(this.docsDir) && await exists(this.retiredDir)) await renameRetry(this.retiredDir, this.docsDir);
+      await rm(this.stagingDir, { recursive: true, force: true });
+      this.pendingWarnings.push("\u4E0A\u6B21\u6062\u590D\u5907\u4EFD\u672A\u5B8C\u6210\uFF0C\u5DF2\u56DE\u6EDA\u5230\u6062\u590D\u524D\u7684\u72B6\u6001");
+    } else {
+      await atomicWrite(this.libraryFile, marker);
+      await rm(this.retiredDir, { recursive: true, force: true });
+      this.pendingWarnings.push("\u4E0A\u6B21\u6062\u590D\u5907\u4EFD\u5728\u4E2D\u9014\u4E2D\u65AD\uFF0C\u5DF2\u5B8C\u6210\u6062\u590D");
+    }
+    await rm(this.restoreMarker, { force: true });
+  }
   async load() {
+    await mkdir(this.dir, { recursive: true });
+    await this.recoverRestore();
     await mkdir(this.docsDir, { recursive: true });
     await mkdir(this.backupsDir, { recursive: true });
     let library = null;
@@ -376,6 +580,15 @@ var MindmapStorage = class {
     if (adopted || library === null || lib.docs.length !== before) {
       if (lib.docs.length > 0 || library !== null) await this.writeLibrary();
     }
+    const cutoff = this.now() - TRASH_RETENTION_MS;
+    const expired = lib.docs.filter((d) => d.trashedAt !== void 0 && d.trashedAt < cutoff).map((d) => d.id);
+    if (expired.length > 0) {
+      try {
+        await this.purgeIds(expired);
+      } catch (error) {
+        console.warn("[dsh-mindmap] trash auto-purge failed:", error);
+      }
+    }
   }
   async readDocFile(id) {
     const file = this.docFile(id);
@@ -397,11 +610,17 @@ var MindmapStorage = class {
   async writeLibrary() {
     await atomicWrite(this.libraryFile, JSON.stringify(this.library, null, 1));
   }
+  remember(doc) {
+    this.docs.delete(doc.id);
+    this.docs.set(doc.id, doc);
+    while (this.docs.size > DOC_CACHE_LIMIT) this.docs.delete(this.docs.keys().next().value);
+    this.index.set(doc.id, indexDoc(doc));
+  }
   async writeDoc(doc) {
     const problem = validateDoc(doc);
     if (problem !== null) throw new StorageError("invalid_input", `\u6587\u6863\u7ED3\u6784\u65E0\u6548\uFF1A${problem}`);
     await atomicWrite(this.docFile(doc.id), JSON.stringify(doc));
-    this.docs.set(doc.id, doc);
+    this.remember(doc);
   }
   meta(id) {
     if (!ID_RE.test(id)) throw new StorageError("invalid_input", "\u65E0\u6548\u7684\u6587\u6863 id");
@@ -412,9 +631,13 @@ var MindmapStorage = class {
   async loadDoc(id) {
     this.meta(id);
     const cached = this.docs.get(id);
-    if (cached !== void 0) return cached;
+    if (cached !== void 0) {
+      this.docs.delete(id);
+      this.docs.set(id, cached);
+      return cached;
+    }
     const doc = await this.readDocFile(id);
-    this.docs.set(id, doc);
+    this.remember(doc);
     return doc;
   }
   checkFolder(folderId) {
@@ -434,13 +657,15 @@ var MindmapStorage = class {
   createDoc(input) {
     return this.serial(async () => {
       const folderId = this.checkFolder(input.folderId);
+      const items = input.items ?? [];
+      if (itemsDepth(items) > MAX_IMPORT_DEPTH) throw new StorageError("invalid_input", `\u5C42\u7EA7\u8D85\u8FC7 ${MAX_IMPORT_DEPTH} \u7EA7\uFF0C\u65E0\u6CD5\u5BFC\u5165`);
+      await this.dailyBackup();
       const now = this.now();
-      const doc = createDoc(normalizeTitle(input.title), now, input.items ?? []);
+      const doc = createDoc(normalizeTitle(input.title), now, items);
       await this.writeDoc(doc);
       const meta = { id: doc.id, title: doc.title, folderId, favorite: false, createdAt: now, updatedAt: now };
       this.library.docs.push(meta);
       await this.writeLibrary();
-      await this.dailyBackup();
       return { meta: { ...meta }, doc };
     });
   }
@@ -456,13 +681,13 @@ var MindmapStorage = class {
       if (problem !== null) throw new StorageError("invalid_input", `\u6587\u6863\u7ED3\u6784\u65E0\u6548\uFF1A${problem}`);
       const doc = incoming;
       if (doc.id !== id) throw new StorageError("invalid_input", "\u6587\u6863 id \u4E0D\u5339\u914D");
+      await this.dailyBackup();
       const now = this.now();
       const next = { ...doc, title: normalizeTitle(doc.title), revision: current.revision + 1, createdAt: current.createdAt, updatedAt: now };
       await this.writeDoc(next);
       meta.title = next.title;
       meta.updatedAt = now;
       await this.writeLibrary();
-      await this.dailyBackup();
       return next;
     });
   }
@@ -477,6 +702,7 @@ var MindmapStorage = class {
         const title = normalizeTitle(body.title);
         const current = await this.loadDoc(id);
         if (current.title !== title) {
+          await this.dailyBackup();
           const now = this.now();
           doc = { ...current, title, revision: current.revision + 1, updatedAt: now };
           await this.writeDoc(doc);
@@ -505,21 +731,42 @@ var MindmapStorage = class {
       return { ...meta };
     });
   }
+  /** Remove documents for good, after one (coalesced) purge backup. Caller holds the queue. */
+  async purgeIds(ids) {
+    if (ids.length === 0) return;
+    const last = this.lastPurgeBackup;
+    if (last === null || this.now() - last.at > PURGE_BACKUP_DEDUPE_MS) {
+      this.lastPurgeBackup = { at: this.now(), info: await this.backupInternal("purge") };
+    }
+    const gone = new Set(ids);
+    this.library.docs = this.library.docs.filter((d) => !gone.has(d.id));
+    await this.writeLibrary();
+    for (const id of gone) {
+      this.docs.delete(id);
+      this.index.delete(id);
+      await rm(this.docFile(id), { force: true });
+    }
+  }
   /** Permanent delete; only trashed documents. */
   purgeDoc(id) {
     return this.serial(async () => {
       const meta = this.meta(id);
       if (meta.trashedAt === void 0) throw new StorageError("invalid_input", "\u53EA\u80FD\u6C38\u4E45\u5220\u9664\u56DE\u6536\u7AD9\u4E2D\u7684\u6587\u6863");
-      await this.backupInternal("manual");
-      this.library.docs = this.library.docs.filter((d) => d.id !== id);
-      await this.writeLibrary();
-      this.docs.delete(id);
-      await rm(this.docFile(id), { force: true });
+      await this.purgeIds([id]);
     });
   }
-  createFolder(name2) {
+  /** Permanently delete everything in the trash; returns how many documents went. */
+  emptyTrash() {
     return this.serial(async () => {
-      const folder = { id: newId(), name: normalizeTitle(name2, "\u65B0\u5EFA\u6587\u4EF6\u5939"), createdAt: this.now() };
+      const ids = this.library.docs.filter((d) => d.trashedAt !== void 0).map((d) => d.id);
+      await this.purgeIds(ids);
+      return { purged: ids.length };
+    });
+  }
+  createFolder(name2, parentId = null) {
+    return this.serial(async () => {
+      const parent = this.checkFolder(parentId);
+      const folder = { id: newId(), name: normalizeTitle(name2, "\u65B0\u5EFA\u6587\u4EF6\u5939"), createdAt: this.now(), parentId: parent };
       this.library.folders.push(folder);
       await this.writeLibrary();
       return { ...folder };
@@ -534,36 +781,71 @@ var MindmapStorage = class {
       return { ...folder };
     });
   }
-  /** Delete a folder; its documents move back to the top level (never deleted). */
+  /** Move a folder under another folder (null = top level); cycles are refused. */
+  moveFolder(id, parentId) {
+    return this.serial(async () => {
+      const folder = this.library.folders.find((f) => f.id === id);
+      if (folder === void 0) throw new StorageError("not_found", "\u6587\u4EF6\u5939\u4E0D\u5B58\u5728");
+      const parent = this.checkFolder(parentId);
+      if (parent !== null && wouldCycle(this.library.folders, id, parent)) throw new StorageError("invalid_input", "\u4E0D\u80FD\u628A\u6587\u4EF6\u5939\u79FB\u5230\u5B83\u81EA\u5DF1\u7684\u5B50\u6587\u4EF6\u5939\u91CC");
+      folder.parentId = parent;
+      await this.writeLibrary();
+      return { ...folder };
+    });
+  }
+  /** Delete a folder; its documents and sub-folders move up one level (never deleted). */
   deleteFolder(id) {
     return this.serial(async () => {
-      if (!this.library.folders.some((f) => f.id === id)) throw new StorageError("not_found", "\u6587\u4EF6\u5939\u4E0D\u5B58\u5728");
+      const folder = this.library.folders.find((f) => f.id === id);
+      if (folder === void 0) throw new StorageError("not_found", "\u6587\u4EF6\u5939\u4E0D\u5B58\u5728");
+      const up = folder.parentId ?? null;
       this.library.folders = this.library.folders.filter((f) => f.id !== id);
-      for (const d of this.library.docs) if (d.folderId === id) d.folderId = null;
+      for (const f of this.library.folders) if (f.parentId === id) f.parentId = up;
+      for (const d of this.library.docs) if (d.folderId === id) d.folderId = up;
       await this.writeLibrary();
     });
   }
-  /** Title + node text search over non-trashed documents. */
-  async search(query, limit = 100) {
+  /** Title + node text + note search over non-trashed documents (uses the text index). */
+  search(query, limit = 100) {
+    return this.serial(async () => {
+      const hits = [];
+      if (query.trim().length === 0) return hits;
+      for (const meta of this.library.docs) {
+        if (meta.trashedAt !== void 0) continue;
+        if (hits.length >= limit) break;
+        let idx = this.index.get(meta.id);
+        if (idx === void 0) {
+          try {
+            idx = indexDoc(await this.readDocFile(meta.id));
+            this.index.set(meta.id, idx);
+          } catch {
+            continue;
+          }
+        }
+        hits.push(...searchIndex(idx, meta.title, query, limit - hits.length));
+      }
+      return hits;
+    });
+  }
+  /** Quarantined (corrupt) files, newest first; paths relative to the data directory. */
+  async listQuarantine() {
     await this.ready();
-    const hits = [];
-    for (const meta of this.library.docs) {
-      if (meta.trashedAt !== void 0) continue;
-      if (hits.length >= limit) break;
-      try {
-        const doc = await this.serial(() => this.loadDoc(meta.id));
-        hits.push(...searchDoc(doc, meta.title, query, limit - hits.length));
-      } catch {
+    const out = [];
+    for (const [sub, dir] of [["", this.dir], ["docs/", this.docsDir]]) {
+      for (const name2 of await readdir(dir).catch(() => [])) {
+        if (!/\.corrupt-\d{8}-\d{6}\.json$/.test(name2)) continue;
+        const s = await stat(join(dir, name2)).catch(() => null);
+        if (s !== null && s.isFile()) out.push({ name: sub + name2, size: s.size, createdAt: s.mtimeMs });
       }
     }
-    return hits;
+    return out.sort((a, b) => b.createdAt - a.createdAt);
   }
   // -------------------------------------------------------------- backups
   async snapshot() {
     const docs = [];
     for (const meta of this.library.docs) {
       try {
-        docs.push(await this.loadDoc(meta.id));
+        docs.push(this.docs.get(meta.id) ?? await this.readDocFile(meta.id));
       } catch {
       }
     }
@@ -571,34 +853,44 @@ var MindmapStorage = class {
   }
   async backupInternal(kind) {
     const now = this.now();
-    const name2 = kind === "daily" ? `mindmap-${stamp(now, false)}.json` : `mindmap-${stamp(now, true)}${kind === "pre-restore" ? "-pre-restore" : ""}.json`;
+    const suffix = kind === "pre-restore" ? "-pre-restore" : kind === "purge" ? "-purge" : "";
+    let name2 = kind === "daily" ? `mindmap-${stamp(now, false)}.json` : `mindmap-${stamp(now, true)}${suffix}.json`;
+    for (let bump = 1; kind !== "daily" && await exists(join(this.backupsDir, name2)) && bump < 60; bump++) {
+      name2 = `mindmap-${stamp(now + bump * 1e3, true)}${suffix}.json`;
+    }
     const contents = JSON.stringify(await this.snapshot());
     await atomicWrite(join(this.backupsDir, name2), contents);
     await this.prune();
-    return { name: name2, size: Buffer.byteLength(contents), createdAt: now };
+    return { name: name2, size: Buffer.byteLength(contents), createdAt: now, kind };
   }
-  /** First write of a local day snapshots the whole library. */
+  /**
+   * The first write of a local day snapshots the library as it was BEFORE that
+   * write, so the day's starting state is always recoverable. Empty libraries
+   * are not backed up.
+   */
   async dailyBackup() {
+    if (this.library.docs.length === 0) return;
     const name2 = `mindmap-${stamp(this.now(), false)}.json`;
-    try {
-      await stat(join(this.backupsDir, name2));
-    } catch (error) {
-      if (!isEnoent(error)) return;
-      await this.backupInternal("daily").catch((e) => console.warn("[dsh-mindmap] daily backup failed:", e));
-    }
+    if (await exists(join(this.backupsDir, name2))) return;
+    await this.backupInternal("daily").catch((e) => console.warn("[dsh-mindmap] daily backup failed:", e));
   }
+  /** Keep the newest BACKUP_KEEP[kind] files of each kind. */
   async prune() {
-    const list = await this.listBackupsRaw();
-    for (const old of list.slice(MAX_BACKUPS)) await rm(join(this.backupsDir, old.name), { force: true });
+    const seen = { daily: 0, manual: 0, "pre-restore": 0, purge: 0 };
+    for (const b of await this.listBackupsRaw()) {
+      const kind = b.kind ?? "manual";
+      seen[kind]++;
+      if (seen[kind] > BACKUP_KEEP[kind]) await rm(join(this.backupsDir, b.name), { force: true });
+    }
   }
   async listBackupsRaw() {
     const out = [];
     for (const name2 of await readdir(this.backupsDir).catch(() => [])) {
       if (!BACKUP_RE.test(name2)) continue;
       const s = await stat(join(this.backupsDir, name2)).catch(() => null);
-      if (s !== null) out.push({ name: name2, size: s.size, createdAt: s.mtimeMs });
+      if (s !== null) out.push({ name: name2, size: s.size, createdAt: s.mtimeMs, kind: backupKind(name2) });
     }
-    return out.sort((a, b) => b.createdAt - a.createdAt);
+    return out.sort((a, b) => b.createdAt - a.createdAt || (a.name < b.name ? 1 : -1));
   }
   async listBackups() {
     await this.ready();
@@ -619,13 +911,21 @@ var MindmapStorage = class {
   }
   /**
    * Replace everything with a backup. The current state is first saved as a
-   * "-pre-restore" backup, so a restore is itself reversible.
+   * "-pre-restore" backup, so a restore is itself reversible. The new documents
+   * are staged in docs.new/ and swapped in with directory renames; a crash at
+   * any point is finished or rolled back on the next start (recoverRestore).
    */
   restore(source) {
     return this.serial(async () => {
       let raw;
-      if ("name" in source) raw = JSON.parse(await this.readBackup(source.name));
-      else raw = source.data;
+      if ("name" in source) {
+        const text = await this.readBackup(source.name);
+        try {
+          raw = JSON.parse(text);
+        } catch {
+          throw new StorageError("invalid_input", "\u5907\u4EFD\u6587\u4EF6\u4E0D\u662F\u6709\u6548 JSON");
+        }
+      } else raw = source.data;
       const file = raw;
       if (typeof file !== "object" || file === null || file.kind !== "dsh-mindmap-backup" || !Array.isArray(file.docs)) {
         throw new StorageError("invalid_input", "\u4E0D\u662F\u6709\u6548\u7684\u601D\u7EF4\u5BFC\u56FE\u5907\u4EFD\u6587\u4EF6");
@@ -639,28 +939,34 @@ var MindmapStorage = class {
       const byId = new Map(file.docs.map((d) => [d.id, d]));
       library.docs = library.docs.filter((d) => byId.has(d.id));
       const pre = await this.backupInternal("pre-restore");
-      for (const meta of library.docs) await this.writeDoc(byId.get(meta.id));
-      const keep = new Set(library.docs.map((d) => d.id));
-      for (const f of await readdir(this.docsDir)) {
-        const m = /^([a-z0-9-]{6,64})\.json$/.exec(f);
-        if (m !== null && !keep.has(m[1])) await rm(join(this.docsDir, f), { force: true });
-      }
+      await rm(this.stagingDir, { recursive: true, force: true });
+      await rm(this.retiredDir, { recursive: true, force: true });
+      await mkdir(this.stagingDir, { recursive: true });
+      for (const meta of library.docs) await atomicWrite(join(this.stagingDir, `${meta.id}.json`), JSON.stringify(byId.get(meta.id)));
+      const libText = JSON.stringify(library, null, 1);
+      await atomicWrite(this.restoreMarker, libText);
+      await renameRetry(this.docsDir, this.retiredDir);
+      await renameRetry(this.stagingDir, this.docsDir);
+      await atomicWrite(this.libraryFile, libText);
+      await rm(this.restoreMarker, { force: true });
+      await rm(this.retiredDir, { recursive: true, force: true });
       this.docs.clear();
+      this.index.clear();
       this.library = library;
-      await this.writeLibrary();
       return { docs: library.docs.length, preRestore: pre.name };
     });
   }
 };
 
 // src/host/routes.ts
-var MAX_BODY_BYTES = 8 * 1024 * 1024;
+var BODY_LIMITS = { save: 32 * 1024 * 1024, restore: 64 * 1024 * 1024, other: 1024 * 1024 };
 var STATUS = { invalid_input: 400, not_found: 404, conflict: 409, too_large: 413, internal: 500 };
 var ID = "([a-z0-9-]{6,64})";
-var DOC_RE = new RegExp(`^/docs/${ID}$`);
-var DOC_ACTION_RE = new RegExp(`^/docs/${ID}/(save|meta|trash|restore|purge)$`);
-var FOLDER_ACTION_RE = new RegExp(`^/folders/${ID}/(rename|delete)$`);
-var BACKUP_RE2 = /^\/backups\/(mindmap-\d{8}(?:-\d{6})?(?:-pre-restore)?\.json)(\/restore)?$/;
+var DOC_RE = new RegExp("^/docs/" + ID + "$");
+var DOC_ACTION_RE = new RegExp("^/docs/" + ID + "/(save|meta|trash|restore|purge)$");
+var FOLDER_ACTION_RE = new RegExp("^/folders/" + ID + "/(rename|delete|move)$");
+var BACKUP_RE2 = /^\/backups\/(mindmap-\d{8}(?:-\d{6})?(?:-(?:pre-restore|purge))?\.json)(\/restore)?$/;
+var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
 function send(res, status, body) {
   const text = JSON.stringify(body);
   res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
@@ -672,14 +978,33 @@ function ok(res, value) {
 function fail(res, code, message, extra = {}) {
   send(res, STATUS[code], { ok: false, error: { code, message, ...extra } });
 }
-async function readBody(req) {
+function hostName(value) {
+  const v = value.trim().toLowerCase();
+  if (v.startsWith("[")) return v.slice(0, v.indexOf("]") + 1);
+  const i = v.lastIndexOf(":");
+  return i >= 0 ? v.slice(0, i) : v;
+}
+function checkOrigin(req) {
+  const host = String(req.headers.host ?? "");
+  if (host === "" || !LOOPBACK.has(hostName(host))) return false;
+  const origin = req.headers.origin;
+  if (origin === void 0) return true;
+  try {
+    return new URL(String(origin)).host.toLowerCase() === host.trim().toLowerCase();
+  } catch {
+    return false;
+  }
+}
+async function readBody(req, limit) {
   const type = String(req.headers["content-type"] ?? "");
   if (!type.toLowerCase().startsWith("application/json")) throw new StorageError("invalid_input", "\u8BF7\u6C42\u5FC5\u987B\u662F application/json");
+  const declared = Number(req.headers["content-length"]);
+  if (Number.isFinite(declared) && declared > limit) throw new StorageError("too_large", "\u8BF7\u6C42\u4F53\u8FC7\u5927");
   const chunks = [];
   let size = 0;
   for await (const chunk of req) {
     size += chunk.length;
-    if (size > MAX_BODY_BYTES) throw new StorageError("too_large", "\u8BF7\u6C42\u4F53\u8FC7\u5927");
+    if (size > limit) throw new StorageError("too_large", "\u8BF7\u6C42\u4F53\u8FC7\u5927");
     chunks.push(chunk);
   }
   const raw = Buffer.concat(chunks).toString("utf8");
@@ -693,9 +1018,18 @@ async function readBody(req) {
 function obj(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
+function limitFor(path) {
+  if (path === "/restore") return BODY_LIMITS.restore;
+  if (path === "/docs" || path.endsWith("/save")) return BODY_LIMITS.save;
+  return BODY_LIMITS.other;
+}
 function createHandler(storage) {
   return async (req, res) => {
     try {
+      if (!checkOrigin(req)) {
+        send(res, 403, { ok: false, error: { code: "invalid_input", message: "\u62D2\u7EDD\u8BBF\u95EE" } });
+        return;
+      }
       const url = new URL(req.url ?? "/", "http://localhost");
       if (!url.pathname.startsWith(ROUTE_PREFIX)) {
         fail(res, "not_found", "\u672A\u77E5\u8DEF\u5F84");
@@ -705,7 +1039,8 @@ function createHandler(storage) {
       const method = req.method ?? "GET";
       if (method === "GET") {
         if (path === "/library") {
-          ok(res, { library: await storage.getLibrary(), warnings: storage.warnings });
+          const library = await storage.getLibrary();
+          ok(res, { library, warnings: await storage.takeWarnings() });
           return;
         }
         const doc = DOC_RE.exec(path);
@@ -721,10 +1056,14 @@ function createHandler(storage) {
           ok(res, await storage.listBackups());
           return;
         }
+        if (path === "/health/quarantine") {
+          ok(res, await storage.listQuarantine());
+          return;
+        }
         const backup2 = BACKUP_RE2.exec(path);
         if (backup2 !== null && backup2[2] === void 0) {
           const text = await storage.readBackup(backup2[1]);
-          res.writeHead(200, { "content-type": "application/json; charset=utf-8", "content-disposition": `attachment; filename="${backup2[1]}"`, "cache-control": "no-store" });
+          res.writeHead(200, { "content-type": "application/json; charset=utf-8", "content-disposition": 'attachment; filename="' + backup2[1] + '"', "cache-control": "no-store" });
           res.end(text);
           return;
         }
@@ -735,11 +1074,17 @@ function createHandler(storage) {
         fail(res, "not_found", "\u4E0D\u652F\u6301\u7684\u65B9\u6CD5");
         return;
       }
-      const body = obj(await readBody(req));
+      const body = obj(await readBody(req, limitFor(path)));
       if (path === "/docs") {
         let items = [];
         let title = body.title;
-        if (typeof body.markdown === "string") {
+        if (body.copy !== void 0) {
+          const problem = validateDoc(body.copy);
+          if (problem !== null) throw new StorageError("invalid_input", "\u6587\u6863\u7ED3\u6784\u65E0\u6548\uFF1A" + problem);
+          const copy = body.copy;
+          items = toItems(copy, copy.nodes[copy.rootId].children);
+          if (title === void 0 || title === "") title = copy.title;
+        } else if (typeof body.markdown === "string") {
           const parsed = parseMarkdown(body.markdown);
           items = parsed.items;
           if (title === void 0 || title === "") title = parsed.title;
@@ -778,13 +1123,18 @@ function createHandler(storage) {
             return;
         }
       }
+      if (path === "/trash/empty") {
+        ok(res, await storage.emptyTrash());
+        return;
+      }
       if (path === "/folders") {
-        ok(res, await storage.createFolder(body.name));
+        ok(res, await storage.createFolder(body.name, body.parentId ?? null));
         return;
       }
       const folder = FOLDER_ACTION_RE.exec(path);
       if (folder !== null) {
         if (folder[2] === "rename") ok(res, await storage.renameFolder(folder[1], body.name));
+        else if (folder[2] === "move") ok(res, await storage.moveFolder(folder[1], body.parentId ?? null));
         else {
           await storage.deleteFolder(folder[1]);
           ok(res, null);
@@ -811,7 +1161,7 @@ function createHandler(storage) {
         return;
       }
       console.error("[dsh-mindmap] route failed:", error);
-      fail(res, "internal", error instanceof Error ? error.message : String(error));
+      fail(res, "internal", "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
     }
   };
 }