@tnotesjs/core 0.6.1 → 0.8.0

package/dist/chunk-ZEQS64PE.js

@@ -0,0 +1,1746 @@
+import {
+  formatTNotesNote
+} from "./chunk-GWG75A5M.js";
+
+// workspace/workspace.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import fs3 from "fs/promises";
+import path4 from "path";
+
+// workspace/atomic.ts
+import { randomUUID } from "crypto";
+import { constants as fsConstants } from "fs";
+import fs from "fs/promises";
+import path from "path";
+
+// workspace/errors.ts
+var WorkspaceError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.name = "WorkspaceError";
+    this.code = code;
+    this.details = details;
+  }
+};
+
+// workspace/atomic.ts
+async function pathExists(filePath) {
+  try {
+    await fs.access(filePath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stageWrite(write) {
+  await fs.mkdir(path.dirname(write.path), { recursive: true });
+  const temporaryPath = path.join(
+    path.dirname(write.path),
+    `.${path.basename(write.path)}.${randomUUID()}.tmp`
+  );
+  const handle = await fs.open(temporaryPath, "wx");
+  try {
+    await handle.writeFile(write.data);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  return temporaryPath;
+}
+async function restoreOriginals(originals) {
+  for (const original of originals) {
+    if (original.existed && original.data) {
+      const restorePath = await stageWrite({
+        path: original.path,
+        data: original.data
+      });
+      await fs.rename(restorePath, original.path);
+    } else {
+      await fs.rm(original.path, { force: true });
+    }
+  }
+}
+async function writeFilesAtomically(writes) {
+  const uniqueWrites = /* @__PURE__ */ new Map();
+  for (const write of writes) uniqueWrites.set(write.path, write);
+  const normalizedWrites = [...uniqueWrites.values()];
+  const originals = [];
+  const staged = [];
+  try {
+    for (const write of normalizedWrites) {
+      const existed = await pathExists(write.path);
+      originals.push({
+        path: write.path,
+        existed,
+        data: existed ? await fs.readFile(write.path) : void 0
+      });
+      staged.push({
+        target: write.path,
+        temporary: await stageWrite(write)
+      });
+    }
+    for (const item of staged) {
+      await fs.rename(item.temporary, item.target);
+    }
+  } catch (error) {
+    await Promise.allSettled(
+      staged.map((item) => fs.rm(item.temporary, { force: true }))
+    );
+    try {
+      await restoreOriginals(originals);
+    } catch (restoreError) {
+      throw new WorkspaceError(
+        "FILESYSTEM_ERROR",
+        "\u5199\u5165\u5931\u8D25\uFF0C\u5E76\u4E14\u65E0\u6CD5\u5B8C\u6574\u6062\u590D\u539F\u6587\u4EF6",
+        {
+          cause: error instanceof Error ? error.message : String(error),
+          restoreCause: restoreError instanceof Error ? restoreError.message : String(restoreError)
+        }
+      );
+    }
+    throw new WorkspaceError("FILESYSTEM_ERROR", "\u65E0\u6CD5\u539F\u5B50\u5199\u5165\u77E5\u8BC6\u5E93\u6587\u4EF6", {
+      cause: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+
+// workspace/mutationQueue.ts
+var MutationQueue = class {
+  constructor() {
+    this.tail = Promise.resolve();
+    this.disposed = false;
+  }
+  async run(operation) {
+    if (this.disposed) {
+      throw new Error("Mutation queue has been disposed");
+    }
+    const previous = this.tail;
+    let release;
+    this.tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+  async dispose() {
+    this.disposed = true;
+    await this.tail;
+  }
+};
+
+// workspace/paths.ts
+import path2 from "path";
+function createWorkspacePaths(rootPath) {
+  if (!rootPath || !path2.isAbsolute(rootPath)) {
+    throw new WorkspaceError(
+      "INVALID_PATH",
+      "\u77E5\u8BC6\u5E93\u8DEF\u5F84\u5FC5\u987B\u662F\u975E\u7A7A\u7684\u7EDD\u5BF9\u8DEF\u5F84",
+      { rootPath }
+    );
+  }
+  const root = path2.normalize(path2.resolve(rootPath));
+  return {
+    root,
+    config: path2.join(root, ".tnotes.json"),
+    toc: path2.join(root, "TOC.md"),
+    notes: path2.join(root, "notes"),
+    sidebar: path2.join(root, "sidebar.json"),
+    packageJson: path2.join(root, "package.json")
+  };
+}
+function assertPathInside(parent, target) {
+  const relative = path2.relative(parent, target);
+  if (relative === "" || !relative.startsWith(`..${path2.sep}`) && relative !== ".." && !path2.isAbsolute(relative)) {
+    return;
+  }
+  throw new WorkspaceError("INVALID_PATH", "\u76EE\u6807\u8DEF\u5F84\u8D85\u51FA\u5141\u8BB8\u8303\u56F4", {
+    parent,
+    target
+  });
+}
+function sanitizeFileName(fileName) {
+  const value = fileName.trim();
+  if (!value || value === "." || value === ".." || value.includes("/") || value.includes("\\") || value.includes("\0")) {
+    throw new WorkspaceError("INVALID_PATH", "\u9644\u4EF6\u6587\u4EF6\u540D\u4E0D\u5408\u6CD5", {
+      fileName
+    });
+  }
+  return value;
+}
+
+// workspace/reconcile.ts
+var NOTE_CONFIG_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
+  "NOTE_CONFIG_MISSING",
+  "NOTE_CONFIG_INVALID"
+]);
+function dirFromConfigDiagnostic(path5) {
+  if (!path5) return null;
+  const match = path5.replace(/\\/g, "/").match(/(?:^|\/)notes\/([^/]+)\/\.tnotes\.json$/);
+  return match ? match[1] : null;
+}
+function planReconcile(snapshot) {
+  const seen = /* @__PURE__ */ new Set();
+  const trashDirs = [];
+  for (const diagnostic of snapshot.health.diagnostics) {
+    if (!NOTE_CONFIG_DIAGNOSTIC_CODES.has(diagnostic.code)) continue;
+    const dir = dirFromConfigDiagnostic(diagnostic.path);
+    if (dir && !seen.has(dir)) {
+      seen.add(dir);
+      trashDirs.push(dir);
+    }
+  }
+  trashDirs.sort((a, b) => a.localeCompare(b));
+  const validIndexes = new Set(snapshot.notes.map((note) => note.index));
+  const clean = (nodes) => {
+    const next = [];
+    for (const node of nodes) {
+      if (node.kind === "folder") {
+        next.push({ ...node, children: clean(node.children) });
+        continue;
+      }
+      if (validIndexes.has(node.noteIndex)) {
+        next.push({ ...node, children: clean(node.children) });
+      }
+    }
+    return next;
+  };
+  const present = /* @__PURE__ */ new Set();
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.kind === "note") present.add(node.noteIndex);
+      walk(node.children);
+    }
+  };
+  walk(snapshot.toc);
+  const missing = snapshot.notes.filter((note) => !present.has(note.index)).sort((left, right) => left.index.localeCompare(right.index));
+  const tree = [
+    ...clean(snapshot.toc),
+    ...missing.map((note) => ({
+      kind: "note",
+      noteIndex: note.index,
+      indent: 0,
+      tocLineIndex: 0,
+      children: []
+    }))
+  ];
+  return { trashDirs, tree };
+}
+
+// workspace/scanner.ts
+import { createHash } from "crypto";
+import fs2 from "fs/promises";
+import path3 from "path";
+
+// utils/tocNodeId.ts
+function extractNoteIndexFromLink(link) {
+  if (!link) return null;
+  const match = link.match(/\/notes\/(\d{4})\./);
+  return match ? match[1] : null;
+}
+function nodeIdForNote(noteIndex) {
+  return `note:${noteIndex}`;
+}
+function nodeIdForFolder(folderPath) {
+  return `folder:${folderPath.join("/")}`;
+}
+function nodeIdForLine(tocLineIndex) {
+  return `line:${tocLineIndex}`;
+}
+function computeSidebarNodeId(item) {
+  if (item.nodeId) return item.nodeId;
+  const noteIndex = extractNoteIndexFromLink(item.link);
+  if (noteIndex) return nodeIdForNote(noteIndex);
+  if (item.tocLineIndex !== void 0 && !item.link) {
+    return nodeIdForLine(item.tocLineIndex);
+  }
+  if (item.folderPath?.length) {
+    return nodeIdForFolder(item.folderPath);
+  }
+  if (item.tocLineIndex !== void 0) {
+    return nodeIdForLine(item.tocLineIndex);
+  }
+  return `text:${item.text}`;
+}
+
+// utils/tocHelpers.ts
+var TOC_INDENT_SPACES = 2;
+var TOC_LEGACY_FULL_REGEX = /^( *)(-\s+\[(x| )\])\s+\[(\d{4}\.[^\]]+)\]\(([^)]+)\)/;
+var TOC_NOTE_LINE_REGEX = /^( *)(-\s+\[(x| )\])\s+(\d{4})(?:\.\s*(.*))?\s*$/;
+var TOC_FOLDER_LINE_REGEX = /^( *)(-\s+(?!\[(?:x| )\]).+?)\s*$/;
+function extractNoteIndexFromTitle(text) {
+  const match = text.match(/^(\d{4})\./);
+  return match ? match[1] : null;
+}
+function parseIndent(spaces) {
+  return Math.floor((spaces?.length ?? 0) / TOC_INDENT_SPACES);
+}
+function parseTocLine(line) {
+  const rawLine = line ?? "";
+  const empty = {
+    kind: "unknown",
+    isMatch: false,
+    indentLevel: 0,
+    noteIndex: null,
+    folderTitle: null,
+    completed: false,
+    rawLine
+  };
+  if (line == null) return empty;
+  const legacyMatch = line.match(TOC_LEGACY_FULL_REGEX);
+  if (legacyMatch) {
+    const [, spaces, , statusChar, titleText] = legacyMatch;
+    const noteIndex = extractNoteIndexFromTitle(titleText);
+    if (!noteIndex) return empty;
+    return {
+      kind: "note",
+      isMatch: true,
+      indentLevel: parseIndent(spaces),
+      noteIndex,
+      folderTitle: null,
+      completed: statusChar === "x",
+      rawLine
+    };
+  }
+  const noteMatch = line.match(TOC_NOTE_LINE_REGEX);
+  if (noteMatch) {
+    const [, spaces, , statusChar, noteIndex] = noteMatch;
+    return {
+      kind: "note",
+      isMatch: true,
+      indentLevel: parseIndent(spaces),
+      noteIndex,
+      folderTitle: null,
+      completed: statusChar === "x",
+      rawLine
+    };
+  }
+  const folderMatch = line.match(TOC_FOLDER_LINE_REGEX);
+  if (folderMatch) {
+    const [, spaces, titlePart] = folderMatch;
+    const title = titlePart.replace(/^-\s+/, "").trim();
+    if (!title) return empty;
+    return {
+      kind: "folder",
+      isMatch: true,
+      indentLevel: parseIndent(spaces),
+      noteIndex: null,
+      folderTitle: title,
+      completed: false,
+      rawLine
+    };
+  }
+  return empty;
+}
+function isTocContentLine(line) {
+  return parseTocLine(line).isMatch;
+}
+function resolveNoteFromIndex(index, notes) {
+  return notes.find((n) => n.index === index);
+}
+function getTocLineCompleted(note, configOverride) {
+  const config = configOverride ? { ...note.config, ...configOverride } : note.config;
+  return config?.done ?? false;
+}
+function buildFolderTocLine(title, indentLevel) {
+  const indent = " ".repeat(indentLevel * TOC_INDENT_SPACES);
+  return `${indent}- ${title}`;
+}
+function buildTocLine(note, indentLevel, completed) {
+  const indent = " ".repeat(indentLevel * TOC_INDENT_SPACES);
+  const status = completed ?? getTocLineCompleted(note) ? "x" : " ";
+  return `${indent}- [${status}] ${note.dirName}`;
+}
+function mutableToTreeNode(node) {
+  if (node.kind === "folder") {
+    return {
+      kind: "folder",
+      title: node.title,
+      indent: node.indent,
+      tocLineIndex: node.tocLineIndex,
+      children: node.children.map(mutableToTreeNode)
+    };
+  }
+  return {
+    kind: "note",
+    noteIndex: node.noteIndex,
+    indent: node.indent,
+    tocLineIndex: node.tocLineIndex,
+    children: node.children.map(mutableToTreeNode)
+  };
+}
+function buildMutableTreeFromFlat(flatNodes) {
+  const roots = [];
+  const stack = [];
+  for (const item of flatNodes) {
+    while (stack.length > 0 && stack[stack.length - 1].indent >= item.indent) {
+      stack.pop();
+    }
+    const node = {
+      kind: item.kind,
+      title: item.title,
+      noteIndex: item.noteIndex,
+      indent: item.indent,
+      tocLineIndex: item.tocLineIndex,
+      children: []
+    };
+    if (stack.length === 0) {
+      roots.push(node);
+    } else {
+      stack[stack.length - 1].children.push(node);
+    }
+    stack.push(node);
+  }
+  return roots;
+}
+function parseTocToMutableTree(lines, notes) {
+  const flatNodes = [];
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex];
+    const parsed = parseTocLine(line);
+    if (!parsed.isMatch) continue;
+    if (parsed.kind === "folder") {
+      flatNodes.push({
+        kind: "folder",
+        title: parsed.folderTitle,
+        indent: parsed.indentLevel,
+        tocLineIndex: lineIndex
+      });
+      continue;
+    }
+    if (!parsed.noteIndex) continue;
+    if (!resolveNoteFromIndex(parsed.noteIndex, notes)) continue;
+    flatNodes.push({
+      kind: "note",
+      noteIndex: parsed.noteIndex,
+      indent: parsed.indentLevel,
+      tocLineIndex: lineIndex
+    });
+  }
+  return buildMutableTreeFromFlat(flatNodes);
+}
+function parseTocToTree(lines, notes) {
+  return parseTocToMutableTree(lines, notes).map(mutableToTreeNode);
+}
+function serializeTocTree(tree, notes, configByIndex) {
+  const lines = [];
+  function walk(nodes) {
+    for (const node of nodes) {
+      if (node.kind === "folder") {
+        lines.push(buildFolderTocLine(node.title, node.indent));
+        walk(node.children);
+        continue;
+      }
+      const note = resolveNoteFromIndex(node.noteIndex, notes);
+      if (!note) continue;
+      const override = configByIndex?.get(node.noteIndex);
+      const completed = override !== void 0 ? getTocLineCompleted(note, override) : getTocLineCompleted(note);
+      lines.push(buildTocLine(note, node.indent, completed));
+      walk(node.children);
+    }
+  }
+  walk(tree);
+  return lines;
+}
+function adjustTocLineIndexAfterSubtreeRemoval(lineIndex, removedStart, removedEnd) {
+  if (lineIndex >= removedEnd) {
+    return lineIndex - (removedEnd - removedStart);
+  }
+  return lineIndex;
+}
+function getTocEntrySubtreeRange(lines, lineIndex) {
+  const parsed = parseTocLine(lines[lineIndex]);
+  if (!parsed.isMatch) {
+    return { start: lineIndex, end: lineIndex + 1 };
+  }
+  const baseIndent = parsed.indentLevel;
+  let end = lineIndex + 1;
+  for (let i = lineIndex + 1; i < lines.length; i++) {
+    const next = parseTocLine(lines[i]);
+    if (next.isMatch && next.indentLevel <= baseIndent) break;
+    end = i + 1;
+  }
+  return { start: lineIndex, end };
+}
+function collectNoteIndexesInSubtree(lines, lineIndex) {
+  const { start, end } = getTocEntrySubtreeRange(lines, lineIndex);
+  const indexes = [];
+  for (let i = start; i < end; i++) {
+    const parsed = parseTocLine(lines[i]);
+    if (parsed.noteIndex) {
+      indexes.push(parsed.noteIndex);
+    }
+  }
+  return indexes;
+}
+function renameFolderLine(lines, lineIndex, newTitle) {
+  const parsed = parseTocLine(lines[lineIndex]);
+  if (parsed.kind !== "folder") {
+    throw new Error(`TOC \u884C ${lineIndex} \u4E0D\u662F\u76EE\u5F55\u884C`);
+  }
+  const trimmed = newTitle.trim();
+  if (!trimmed) {
+    throw new Error("\u76EE\u5F55\u6807\u9898\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const result = [...lines];
+  result[lineIndex] = buildFolderTocLine(trimmed, parsed.indentLevel);
+  return result;
+}
+function findFolderLineIndex(lines, folderPath) {
+  const target = folderPath.join("/");
+  const stack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const parsed = parseTocLine(lines[i]);
+    if (!parsed.isMatch) continue;
+    while (stack.length > 0 && stack[stack.length - 1].indent >= parsed.indentLevel) {
+      stack.pop();
+    }
+    if (parsed.kind === "folder") {
+      const path5 = [...stack.map((s) => s.title), parsed.folderTitle].join("/");
+      if (path5 === target) return i;
+      stack.push({ title: parsed.folderTitle, indent: parsed.indentLevel });
+    }
+  }
+  throw new Error(`TOC.md \u4E2D\u672A\u627E\u5230\u76EE\u5F55: ${folderPath.join(" > ")}`);
+}
+function findTocLineIndex(lines, noteIndex) {
+  for (let i = 0; i < lines.length; i++) {
+    const parsed = parseTocLine(lines[i]);
+    if (parsed.noteIndex === noteIndex) return i;
+  }
+  throw new Error(`TOC.md \u4E2D\u672A\u627E\u5230\u7B14\u8BB0: ${noteIndex}`);
+}
+function processTocEmptyLines(lines) {
+  const result = [];
+  let previousEmpty = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === "") {
+      const prev = i > 0 ? lines[i - 1] : null;
+      const next = i < lines.length - 1 ? lines[i + 1] : null;
+      if (prev && next && isTocContentLine(prev) && isTocContentLine(next)) {
+        continue;
+      }
+      if (!previousEmpty) {
+        result.push(line);
+        previousEmpty = true;
+      }
+    } else {
+      result.push(line);
+      previousEmpty = false;
+    }
+  }
+  return result;
+}
+function parseTocCompletedNotes(content) {
+  const lines = content.split("\n");
+  const noteMap = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const parsed = parseTocLine(line);
+    if (parsed.kind !== "note" || !parsed.noteIndex) continue;
+    const noteIndex = parsed.noteIndex;
+    const completed = parsed.completed;
+    if (noteMap.has(noteIndex)) {
+      const existing = noteMap.get(noteIndex);
+      if (existing.completed !== completed) {
+        throw new Error(
+          `\u53D1\u73B0\u76F8\u540C\u7F16\u53F7 ${noteIndex} \u7684\u7B14\u8BB0\u6709\u4E0D\u540C\u7684\u5B8C\u6210\u72B6\u6001:
+  \u7B2C\u4E00\u6B21\u51FA\u73B0: ${existing.line}
+  \u7B2C\u4E8C\u6B21\u51FA\u73B0: ${line.trim()}`
+        );
+      }
+      continue;
+    }
+    noteMap.set(noteIndex, {
+      noteIndex,
+      completed,
+      line: line.trim()
+    });
+  }
+  const notes = Array.from(noteMap.values());
+  return {
+    completedCount: notes.filter((n) => n.completed).length,
+    totalCount: notes.length,
+    notes
+  };
+}
+function buildSidebarFromTocTree(tree, notes, options, parentFolderPath = []) {
+  const collapsed = options.sidebarIsCollapsed ?? true;
+  function mapNote(node, currentFolderPath) {
+    const note = resolveNoteFromIndex(node.noteIndex, notes);
+    if (!note) return null;
+    let statusEmoji = "\u23F0 ";
+    if (note.config?.done) {
+      statusEmoji = "\u2705 ";
+    }
+    let displayText = note.dirName;
+    if (!options.sidebarShowNoteId) {
+      displayText = note.dirName.replace(/^\d{4}\.\s/, "");
+    }
+    const childItems = node.children.map((child) => mapNode(child, currentFolderPath)).filter((item2) => item2 !== null);
+    if (childItems.length > 0) {
+      const item2 = {
+        text: statusEmoji + displayText,
+        link: `/notes/${note.dirName}/README`,
+        collapsed,
+        items: childItems,
+        tocLineIndex: node.tocLineIndex
+      };
+      item2.nodeId = computeSidebarNodeId(item2);
+      return item2;
+    }
+    const item = {
+      text: statusEmoji + displayText,
+      link: `/notes/${note.dirName}/README`,
+      tocLineIndex: node.tocLineIndex
+    };
+    item.nodeId = computeSidebarNodeId(item);
+    return item;
+  }
+  function mapFolder(node, folderPath) {
+    const childItems = node.children.map((child) => mapNode(child, folderPath)).filter((item2) => item2 !== null);
+    if (childItems.length === 0) {
+      const item2 = {
+        text: node.title,
+        collapsed,
+        items: [],
+        folderPath,
+        tocLineIndex: node.tocLineIndex
+      };
+      item2.nodeId = computeSidebarNodeId(item2);
+      return item2;
+    }
+    const item = {
+      text: node.title,
+      collapsed,
+      items: childItems,
+      folderPath,
+      tocLineIndex: node.tocLineIndex
+    };
+    item.nodeId = computeSidebarNodeId(item);
+    return item;
+  }
+  function mapNode(node, currentFolderPath) {
+    if (node.kind === "folder") {
+      const folderPath = [...currentFolderPath, node.title];
+      return mapFolder(node, folderPath);
+    }
+    return mapNote(node, currentFolderPath);
+  }
+  return tree.map((node) => mapNode(node, parentFolderPath)).filter((item) => item !== null);
+}
+
+// workspace/scanner.ts
+var NOTE_DIRECTORY_PATTERN = /^(\d{4})\.\s*(.+)$/;
+var CURRENT_SCHEMA_VERSION = 1;
+function digest(...values) {
+  const hash = createHash("sha256");
+  for (const value of values) {
+    hash.update(value);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+async function readText(filePath) {
+  try {
+    return await fs2.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function parseJsonObject(content) {
+  try {
+    const value = JSON.parse(content);
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function noteInfoFromSummary(note) {
+  return {
+    index: note.index,
+    path: note.directoryPath,
+    dirName: note.dirName,
+    readmePath: note.readmePath,
+    configPath: note.configPath,
+    config: note.config
+  };
+}
+async function scanWorkspace(paths) {
+  const diagnostics = [];
+  let rootIsDirectory = false;
+  try {
+    rootIsDirectory = (await fs2.stat(paths.root)).isDirectory();
+  } catch {
+  }
+  if (!rootIsDirectory) {
+    diagnostics.push({
+      code: "ROOT_NOT_DIRECTORY",
+      message: "\u77E5\u8BC6\u5E93\u6839\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u76EE\u5F55",
+      severity: "error",
+      path: paths.root
+    });
+  }
+  const configText = await readText(paths.config);
+  let config = null;
+  if (configText === null) {
+    diagnostics.push({
+      code: "CONFIG_MISSING",
+      message: "\u7F3A\u5C11\u77E5\u8BC6\u5E93\u914D\u7F6E .tnotes.json",
+      severity: "error",
+      path: paths.config
+    });
+  } else {
+    config = parseJsonObject(configText);
+    if (!config) {
+      diagnostics.push({
+        code: "CONFIG_INVALID_JSON",
+        message: "\u77E5\u8BC6\u5E93\u914D\u7F6E\u4E0D\u662F\u6709\u6548\u7684 JSON \u5BF9\u8C61",
+        severity: "error",
+        path: paths.config
+      });
+    } else {
+      if (typeof config.id !== "string" || !config.id.trim()) {
+        diagnostics.push({
+          code: "CONFIG_ID_MISSING",
+          message: "\u77E5\u8BC6\u5E93\u914D\u7F6E\u7F3A\u5C11\u7A33\u5B9A\u7684 id",
+          severity: "error",
+          path: paths.config
+        });
+      }
+      if (typeof config.repoName !== "string" || !config.repoName.trim()) {
+        diagnostics.push({
+          code: "CONFIG_REPO_NAME_MISSING",
+          message: "\u77E5\u8BC6\u5E93\u914D\u7F6E\u7F3A\u5C11 repoName",
+          severity: "error",
+          path: paths.config
+        });
+      }
+    }
+  }
+  let notesDirectoryExists = false;
+  try {
+    notesDirectoryExists = (await fs2.stat(paths.notes)).isDirectory();
+  } catch {
+  }
+  if (!notesDirectoryExists) {
+    diagnostics.push({
+      code: "NOTES_DIRECTORY_MISSING",
+      message: "\u7F3A\u5C11 notes \u76EE\u5F55",
+      severity: "error",
+      path: paths.notes
+    });
+  }
+  const tocText = await readText(paths.toc);
+  if (tocText === null) {
+    diagnostics.push({
+      code: "TOC_MISSING",
+      message: "\u7F3A\u5C11\u76EE\u5F55\u771F\u76F8\u6E90 TOC.md",
+      severity: "error",
+      path: paths.toc
+    });
+  }
+  const notes = [];
+  const usedIndexes = /* @__PURE__ */ new Map();
+  const usedIds = /* @__PURE__ */ new Map();
+  if (notesDirectoryExists) {
+    const entries = await fs2.readdir(paths.notes, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const match = NOTE_DIRECTORY_PATTERN.exec(entry.name);
+      if (!match) continue;
+      const [, index, rawTitle] = match;
+      const title = rawTitle.trim();
+      const directoryPath = path3.join(paths.notes, entry.name);
+      const readmePath = path3.join(directoryPath, "README.md");
+      const configPath = path3.join(directoryPath, ".tnotes.json");
+      const readme = await readText(readmePath);
+      const noteConfigText = await readText(configPath);
+      if (readme === null) {
+        diagnostics.push({
+          code: "NOTE_README_MISSING",
+          message: `\u7B14\u8BB0 ${entry.name} \u7F3A\u5C11 README.md`,
+          severity: "error",
+          path: readmePath
+        });
+        continue;
+      }
+      if (noteConfigText === null) {
+        diagnostics.push({
+          code: "NOTE_CONFIG_MISSING",
+          message: `\u7B14\u8BB0 ${entry.name} \u7F3A\u5C11 .tnotes.json`,
+          severity: "error",
+          path: configPath
+        });
+        continue;
+      }
+      const noteConfig = parseJsonObject(noteConfigText);
+      if (!noteConfig || typeof noteConfig.id !== "string" || !noteConfig.id) {
+        diagnostics.push({
+          code: "NOTE_CONFIG_INVALID",
+          message: `\u7B14\u8BB0 ${entry.name} \u7684\u914D\u7F6E\u65E0\u6CD5\u89E3\u6790\u6216\u7F3A\u5C11 id`,
+          severity: "error",
+          path: configPath
+        });
+        continue;
+      }
+      const existingIndex = usedIndexes.get(index);
+      if (existingIndex) {
+        diagnostics.push({
+          code: "NOTE_INDEX_DUPLICATE",
+          message: `\u7B14\u8BB0\u7F16\u53F7 ${index} \u91CD\u590D\uFF1A${existingIndex}\u3001${entry.name}`,
+          severity: "error",
+          path: directoryPath
+        });
+      } else {
+        usedIndexes.set(index, entry.name);
+      }
+      const existingId = usedIds.get(noteConfig.id);
+      if (existingId) {
+        diagnostics.push({
+          code: "NOTE_ID_DUPLICATE",
+          message: `\u7B14\u8BB0 id ${noteConfig.id} \u91CD\u590D\uFF1A${existingId}\u3001${entry.name}`,
+          severity: "error",
+          path: configPath
+        });
+      } else {
+        usedIds.set(noteConfig.id, entry.name);
+      }
+      notes.push({
+        uuid: noteConfig.id,
+        index,
+        title,
+        dirName: entry.name,
+        directoryPath,
+        readmePath,
+        configPath,
+        config: noteConfig,
+        revision: digest(entry.name, readme, noteConfigText)
+      });
+    }
+  }
+  const noteInfos = notes.map(noteInfoFromSummary);
+  const toc = tocText ? parseTocToTree(tocText.split("\n"), noteInfos) : [];
+  const sidebar = buildSidebarFromTocTree(toc, noteInfos, {
+    sidebarShowNoteId: config?.sidebarShowNoteId ?? true,
+    sidebarIsCollapsed: true
+  });
+  const schemaVersion = config?.schemaVersion;
+  const futureSchema = typeof schemaVersion === "number" && schemaVersion > CURRENT_SCHEMA_VERSION;
+  if (futureSchema) {
+    diagnostics.push({
+      code: "FUTURE_SCHEMA",
+      message: `\u77E5\u8BC6\u5E93 schemaVersion ${schemaVersion} \u9AD8\u4E8E\u5F53\u524D\u652F\u6301\u7248\u672C ${CURRENT_SCHEMA_VERSION}`,
+      severity: "error",
+      path: paths.config
+    });
+  }
+  const health = futureSchema ? { status: "future-schema", diagnostics } : diagnostics.some((diagnostic) => diagnostic.severity === "error") ? { status: "invalid", diagnostics } : { status: "ready", diagnostics };
+  const id = config && typeof config.id === "string" && config.id.trim() ? config.id : `path-${digest(paths.root).slice(0, 24)}`;
+  const revision = digest(
+    paths.root,
+    configText ?? "",
+    tocText ?? "",
+    ...notes.map((note) => `${note.uuid}:${note.revision}`)
+  );
+  return {
+    snapshot: {
+      id,
+      rootPath: paths.root,
+      config,
+      health,
+      toc,
+      sidebar,
+      notes,
+      revision
+    },
+    configText,
+    tocText
+  };
+}
+function toNoteInfo(note) {
+  return noteInfoFromSummary(note);
+}
+
+// config/templates.ts
+var NEW_NOTES_README_MD_TEMPLATE = `
+<!-- region:toc -->
+
+- [1. \u672C\u8282\u5185\u5BB9](#1-\u672C\u8282\u5185\u5BB9)
+
+<!-- endregion:toc -->
+
+## 1. \u672C\u8282\u5185\u5BB9
+
+- todo
+`;
+function getNewNoteReadmeBody() {
+  return NEW_NOTES_README_MD_TEMPLATE;
+}
+function generateNoteTitle(noteIndex, title, repoUrl) {
+  const dirName = `${noteIndex}. ${title}`;
+  const encodedDirName = encodeURIComponent(dirName);
+  return `# [${dirName}](${repoUrl}/${encodedDirName})`;
+}
+
+// workspace/workspace.ts
+var NOTE_CONFIG_FIELD_ORDER = [
+  "bilibili",
+  "tnotes",
+  "yuque",
+  "done",
+  "category",
+  "enableDiscussions",
+  "description",
+  "id"
+];
+function validateTitle(title) {
+  const value = title.trim();
+  if (!value || /[\\/\0\r\n]/.test(value) || /[. ]$/.test(value) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(value)) {
+    throw new WorkspaceError("INVALID_TITLE", "\u7B14\u8BB0\u6216\u5206\u7EC4\u6807\u9898\u4E0D\u5408\u6CD5", {
+      title
+    });
+  }
+  return value;
+}
+function serializeNoteConfig(config) {
+  const record = config;
+  const sorted = {};
+  for (const field of NOTE_CONFIG_FIELD_ORDER) {
+    if (field in record) sorted[field] = record[field];
+  }
+  for (const [key, value] of Object.entries(record)) {
+    if (!(key in sorted)) sorted[key] = value;
+  }
+  return `${JSON.stringify(sorted, null, 2)}
+`;
+}
+function normalizeTocContent(lines) {
+  const content = processTocEmptyLines(lines).join("\n");
+  return content.endsWith("\n") ? content : `${content}
+`;
+}
+function toNoteInfos(notes) {
+  return notes.map(toNoteInfo);
+}
+function sidebarContent(tocLines, notes, config) {
+  const noteInfos = toNoteInfos(notes);
+  const tree = parseTocToTree(tocLines, noteInfos);
+  return JSON.stringify(
+    buildSidebarFromTocTree(tree, noteInfos, {
+      sidebarShowNoteId: config.sidebarShowNoteId ?? true,
+      sidebarIsCollapsed: true
+    }),
+    null,
+    2
+  );
+}
+function requireConfig(snapshot) {
+  if (snapshot.health.status === "future-schema") {
+    throw new WorkspaceError(
+      "WORKSPACE_READ_ONLY",
+      "\u77E5\u8BC6\u5E93\u7531\u66F4\u65B0\u7248\u672C\u7684 Core \u521B\u5EFA\uFF0C\u5F53\u524D\u7248\u672C\u53EA\u5141\u8BB8\u8BFB\u53D6"
+    );
+  }
+  if (snapshot.health.status !== "ready" || !snapshot.config) {
+    throw new WorkspaceError("WORKSPACE_INVALID", "\u77E5\u8BC6\u5E93\u914D\u7F6E\u5F02\u5E38\uFF0C\u7981\u6B62\u4FEE\u6539", {
+      diagnostics: snapshot.health.diagnostics
+    });
+  }
+  return snapshot.config;
+}
+function findNote(snapshot, noteUuid) {
+  const note = snapshot.notes.find((item) => item.uuid === noteUuid);
+  if (!note) {
+    throw new WorkspaceError("NOTE_NOT_FOUND", `\u672A\u627E\u5230\u7B14\u8BB0\uFF1A${noteUuid}`, {
+      noteUuid
+    });
+  }
+  return note;
+}
+function assertRevision(actual, expected, subject) {
+  if (actual !== expected) {
+    throw new WorkspaceError(
+      "REVISION_CONFLICT",
+      `${subject} \u5DF2\u88AB\u5176\u4ED6\u7A0B\u5E8F\u4FEE\u6539\uFF0C\u8BF7\u5148\u5904\u7406\u5916\u90E8\u53D8\u66F4`,
+      { actual, expected }
+    );
+  }
+}
+function allocateNoteIndex(notes) {
+  const used = new Set(
+    notes.map((note) => Number.parseInt(note.index, 10)).filter((value) => Number.isInteger(value) && value >= 1 && value <= 9999)
+  );
+  for (let index = 1; index <= 9999; index++) {
+    if (!used.has(index)) return String(index).padStart(4, "0");
+  }
+  throw new WorkspaceError(
+    "NOTE_INDEX_EXHAUSTED",
+    "\u6240\u6709\u7B14\u8BB0\u7F16\u53F7\uFF080001-9999\uFF09\u5747\u5DF2\u4F7F\u7528"
+  );
+}
+function resolveEntryLine(lines, snapshot, entry) {
+  if (entry.type === "line") {
+    if (entry.tocLineIndex < 0 || entry.tocLineIndex >= lines.length) {
+      throw new WorkspaceError("INVALID_TOC_ENTRY", "TOC \u884C\u7D22\u5F15\u65E0\u6548", {
+        tocLineIndex: entry.tocLineIndex
+      });
+    }
+    return entry.tocLineIndex;
+  }
+  if (entry.type === "folder") {
+    try {
+      return findFolderLineIndex(lines, entry.folderPath);
+    } catch (error) {
+      throw new WorkspaceError("INVALID_TOC_ENTRY", "\u672A\u627E\u5230 TOC \u5206\u7EC4", {
+        folderPath: entry.folderPath,
+        cause: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const note = findNote(snapshot, entry.noteUuid);
+  try {
+    return findTocLineIndex(lines, note.index);
+  } catch (error) {
+    throw new WorkspaceError("INVALID_TOC_ENTRY", "\u672A\u5728 TOC \u4E2D\u627E\u5230\u7B14\u8BB0", {
+      noteUuid: entry.noteUuid,
+      cause: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function placementTargetLine(lines, snapshot, placement) {
+  if (placement.type === "note") {
+    return resolveEntryLine(lines, snapshot, {
+      type: "note",
+      noteUuid: placement.targetNoteUuid
+    });
+  }
+  return resolveEntryLine(lines, snapshot, {
+    type: "folder",
+    folderPath: placement.folderPath
+  });
+}
+function insertLineAtPlacement(lines, snapshot, placement, buildLine) {
+  const resolvedPlacement = placement ?? { type: "root", placement: "end" };
+  if (resolvedPlacement.type === "root") {
+    if (resolvedPlacement.placement === "start") {
+      const firstContent = lines.findIndex((line) => parseTocLine(line).isMatch);
+      lines.splice(firstContent >= 0 ? firstContent : lines.length, 0, buildLine(0));
+    } else {
+      let insertAt = lines.length;
+      while (insertAt > 0 && lines[insertAt - 1] === "") insertAt--;
+      lines.splice(insertAt, 0, buildLine(0));
+    }
+    return;
+  }
+  const targetLine = placementTargetLine(lines, snapshot, resolvedPlacement);
+  const target = parseTocLine(lines[targetLine]);
+  if (!target.isMatch) {
+    throw new WorkspaceError("INVALID_TOC_ENTRY", "\u76EE\u6807 TOC \u6761\u76EE\u65E0\u6548");
+  }
+  if (resolvedPlacement.placement === "inside") {
+    const range = getTocEntrySubtreeRange(lines, targetLine);
+    lines.splice(range.end, 0, buildLine(target.indentLevel + 1));
+  } else if (resolvedPlacement.placement === "before") {
+    lines.splice(targetLine, 0, buildLine(target.indentLevel));
+  } else {
+    const range = getTocEntrySubtreeRange(lines, targetLine);
+    lines.splice(range.end, 0, buildLine(target.indentLevel));
+  }
+}
+function adjustIndent(lines, delta) {
+  return lines.map((line) => {
+    const parsed = parseTocLine(line);
+    if (!parsed.isMatch) return line;
+    const indent = Math.max(0, parsed.indentLevel + delta);
+    return `${" ".repeat(indent * TOC_INDENT_SPACES)}${line.trimStart()}`;
+  });
+}
+async function listFilesRecursively(directoryPath) {
+  const result = [];
+  const entries = await fs3.readdir(directoryPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const entryPath = path4.join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      result.push(...await listFilesRecursively(entryPath));
+    } else {
+      result.push(entryPath);
+    }
+  }
+  return result;
+}
+var Workspace = class {
+  constructor(options) {
+    this.queue = new MutationQueue();
+    this.disposed = false;
+    this.paths = createWorkspacePaths(options.rootPath);
+    this.logger = options.logger ?? {};
+    this.prettierByDefault = options.format?.prettier ?? true;
+    this.notes = {
+      read: (noteUuid) => this.readNote(noteUuid),
+      save: (input) => this.saveNote(input),
+      create: (input) => this.createNote(input),
+      rename: (input) => this.renameNote(input),
+      updateConfig: (input) => this.updateNoteConfig(input)
+    };
+    this.toc = {
+      move: (input) => this.moveTocEntry(input),
+      createGroup: (input) => this.createTocGroup(input),
+      renameGroup: (input) => this.renameTocGroup(input),
+      previewDelete: (entry) => this.previewDelete(entry),
+      deleteEntry: (input) => this.deleteTocEntry(input),
+      setDone: (input) => this.updateNoteConfig(input),
+      reconcileFromFiles: () => this.reconcileTocFromFiles()
+    };
+    this.attachments = {
+      writeLocal: (input) => this.writeLocalAttachment(input)
+    };
+  }
+  async inspect() {
+    this.assertActive();
+    return (await scanWorkspace(this.paths)).snapshot;
+  }
+  async refresh() {
+    return this.inspect();
+  }
+  /**
+   * Files-first TOC reconcile (0004): align TOC.md + sidebar.json with the
+   * disk truth. Valid notes missing from the TOC are appended at root level
+   * (by index); note dirs whose config is missing/invalid are soft-deleted to
+   * notes/.trash/. Idempotent: runs again without changes -> no file writes.
+   */
+  async reconcileTocFromFiles() {
+    return this.queue.run(async () => {
+      this.assertActive();
+      const scanned = await scanWorkspace(this.paths);
+      const { snapshot } = scanned;
+      if (!snapshot.config) {
+        throw new WorkspaceError(
+          "WORKSPACE_INVALID",
+          "\u77E5\u8BC6\u5E93\u914D\u7F6E\u5F02\u5E38\uFF0C\u7981\u6B62\u4FEE\u6539",
+          { diagnostics: snapshot.health.diagnostics }
+        );
+      }
+      const plan = planReconcile(snapshot);
+      const changedFiles = [];
+      if (plan.trashDirs.length > 0) {
+        const trashDir = path4.join(this.paths.notes, ".trash");
+        await fs3.mkdir(trashDir, { recursive: true });
+        for (const dir of plan.trashDirs) {
+          const source = path4.join(this.paths.notes, dir);
+          let target = path4.join(trashDir, dir);
+          try {
+            await fs3.stat(target);
+            target = path4.join(trashDir, `${dir}-${Date.now()}`);
+          } catch {
+          }
+          await fs3.rename(source, target);
+          changedFiles.push({ path: target, previousPath: source, kind: "trashed" });
+        }
+      }
+      const noteInfos = snapshot.notes.map(toNoteInfo);
+      const configByIndex = new Map(
+        snapshot.notes.map((note) => [note.index, { done: note.config.done }])
+      );
+      const lines = serializeTocTree(plan.tree, noteInfos, configByIndex);
+      const nextToc = normalizeTocContent(lines);
+      if (nextToc !== (scanned.tocText ?? "")) {
+        changedFiles.push({ path: this.paths.toc, kind: "updated" });
+        await writeFilesAtomically([{ path: this.paths.toc, data: nextToc }]);
+      }
+      const finalTocTree = parseTocToTree(
+        nextToc.split("\n"),
+        noteInfos
+      );
+      const sidebar = buildSidebarFromTocTree(finalTocTree, noteInfos, {
+        sidebarShowNoteId: snapshot.config.sidebarShowNoteId ?? true,
+        sidebarIsCollapsed: true
+      });
+      const nextSidebar = `${JSON.stringify(sidebar, null, 2)}
+`;
+      let currentSidebar = "";
+      try {
+        currentSidebar = await fs3.readFile(this.paths.sidebar, "utf-8");
+      } catch {
+      }
+      if (nextSidebar !== currentSidebar) {
+        changedFiles.push({ path: this.paths.sidebar, kind: "updated" });
+        await writeFilesAtomically([{ path: this.paths.sidebar, data: nextSidebar }]);
+      }
+      const refreshed = await this.inspect();
+      return {
+        value: refreshed,
+        changedFiles,
+        snapshotRevision: refreshed.revision
+      };
+    });
+  }
+  async reconcileTocCompletion() {
+    return this.queue.run(async () => {
+      const scanned = await this.scanReady();
+      const { snapshot, tocText } = scanned;
+      const config = requireConfig(snapshot);
+      const lines = (tocText ?? "").split("\n");
+      const completedByIndex = /* @__PURE__ */ new Map();
+      for (const line of lines) {
+        const parsed = parseTocLine(line);
+        if (parsed.noteIndex && !completedByIndex.has(parsed.noteIndex)) {
+          completedByIndex.set(parsed.noteIndex, parsed.completed);
+        }
+      }
+      const changedFiles = [];
+      const writes = [];
+      const updatedNotes = snapshot.notes.map((note) => {
+        const completed = completedByIndex.get(note.index);
+        if (completed === void 0 || completed === note.config.done) return note;
+        const updatedConfig = { ...note.config, done: completed };
+        writes.push({ path: note.configPath, data: serializeNoteConfig(updatedConfig) });
+        changedFiles.push({ path: note.configPath, kind: "updated" });
+        return { ...note, config: updatedConfig };
+      });
+      if (writes.length > 0) {
+        writes.push({
+          path: this.paths.sidebar,
+          data: sidebarContent(lines, updatedNotes, config)
+        });
+        changedFiles.push({ path: this.paths.sidebar, kind: "updated" });
+        await writeFilesAtomically(writes);
+      }
+      const value = await this.inspect();
+      return { value, changedFiles, snapshotRevision: value.revision };
+    });
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    await this.queue.dispose();
+  }
+  assertActive() {
+    if (this.disposed) {
+      throw new WorkspaceError("WORKSPACE_DISPOSED", "\u5DE5\u4F5C\u533A\u5B9E\u4F8B\u5DF2\u7ECF\u91CA\u653E");
+    }
+  }
+  async scanReady() {
+    this.assertActive();
+    const scanned = await scanWorkspace(this.paths);
+    requireConfig(scanned.snapshot);
+    return scanned;
+  }
+  async readNote(noteUuid) {
+    const snapshot = await this.inspect();
+    const note = findNote(snapshot, noteUuid);
+    return { ...note, content: await fs3.readFile(note.readmePath, "utf8") };
+  }
+  async saveNote(input) {
+    return this.queue.run(async () => {
+      const { snapshot } = await this.scanReady();
+      const config = requireConfig(snapshot);
+      const note = findNote(snapshot, input.noteUuid);
+      assertRevision(note.revision, input.expectedRevision, "\u7B14\u8BB0");
+      const formatted = await formatTNotesNote({
+        content: input.content,
+        noteIndex: note.index,
+        title: note.title,
+        repoOwner: config.author,
+        repoName: config.repoName,
+        noteConfig: note.config,
+        prettier: input.prettier ?? this.prettierByDefault
+      });
+      const current = await fs3.readFile(note.readmePath, "utf8");
+      const changedFiles = [];
+      if (formatted.content !== current) {
+        await writeFilesAtomically([
+          { path: note.readmePath, data: formatted.content }
+        ]);
+        changedFiles.push({ path: note.readmePath, kind: "updated" });
+      }
+      const value = await this.readNote(input.noteUuid);
+      const refreshed = await this.inspect();
+      return { value, changedFiles, snapshotRevision: refreshed.revision };
+    });
+  }
+  async createNote(input) {
+    return this.queue.run(async () => {
+      const { snapshot, tocText } = await this.scanReady();
+      const config = requireConfig(snapshot);
+      if (input.expectedSnapshotRevision) {
+        assertRevision(
+          snapshot.revision,
+          input.expectedSnapshotRevision,
+          "\u77E5\u8BC6\u5E93\u76EE\u5F55"
+        );
+      }
+      const title = validateTitle(input.title);
+      const index = allocateNoteIndex(snapshot.notes);
+      const dirName = `${index}. ${title}`;
+      const directoryPath = path4.join(this.paths.notes, dirName);
+      assertPathInside(this.paths.notes, directoryPath);
+      try {
+        await fs3.mkdir(directoryPath);
+      } catch (error) {
+        throw new WorkspaceError("FILESYSTEM_ERROR", "\u65E0\u6CD5\u521B\u5EFA\u7B14\u8BB0\u76EE\u5F55", {
+          directoryPath,
+          cause: error instanceof Error ? error.message : String(error)
+        });
+      }
+      const noteConfig = {
+        bilibili: [],
+        tnotes: [],
+        yuque: [],
+        done: false,
+        enableDiscussions: input.config?.enableDiscussions ?? false,
+        description: input.config?.description ?? "",
+        id: randomUUID2()
+      };
+      const readmePath = path4.join(directoryPath, "README.md");
+      const configPath = path4.join(directoryPath, ".tnotes.json");
+      const formatted = await formatTNotesNote({
+        content: getNewNoteReadmeBody(),
+        noteIndex: index,
+        title,
+        repoOwner: config.author,
+        repoName: config.repoName,
+        noteConfig,
+        prettier: this.prettierByDefault
+      });
+      const newNote = {
+        uuid: noteConfig.id,
+        index,
+        title,
+        dirName,
+        directoryPath,
+        readmePath,
+        configPath,
+        config: noteConfig,
+        revision: ""
+      };
+      const tocLines = (tocText ?? "").split("\n");
+      insertLineAtPlacement(
+        tocLines,
+        snapshot,
+        input.placement,
+        (indent) => buildTocLine(toNoteInfo(newNote), indent, false)
+      );
+      const updatedNotes = [...snapshot.notes, newNote];
+      const normalizedToc = normalizeTocContent(tocLines);
+      const normalizedLines = normalizedToc.split("\n");
+      try {
+        await writeFilesAtomically([
+          { path: readmePath, data: formatted.content },
+          { path: configPath, data: serializeNoteConfig(noteConfig) },
+          { path: this.paths.toc, data: normalizedToc },
+          {
+            path: this.paths.sidebar,
+            data: sidebarContent(normalizedLines, updatedNotes, config)
+          }
+        ]);
+      } catch (error) {
+        await fs3.rm(directoryPath, { recursive: true, force: true });
+        throw error;
+      }
+      const value = await this.readNote(noteConfig.id);
+      const refreshed = await this.inspect();
+      return {
+        value,
+        changedFiles: [
+          { path: directoryPath, kind: "created" },
+          { path: readmePath, kind: "created" },
+          { path: configPath, kind: "created" },
+          { path: this.paths.toc, kind: "updated" },
+          { path: this.paths.sidebar, kind: "updated" }
+        ],
+        snapshotRevision: refreshed.revision
+      };
+    });
+  }
+  async renameNote(input) {
+    return this.queue.run(async () => {
+      const { snapshot, tocText } = await this.scanReady();
+      const config = requireConfig(snapshot);
+      const note = findNote(snapshot, input.noteUuid);
+      assertRevision(note.revision, input.expectedRevision, "\u7B14\u8BB0");
+      const title = validateTitle(input.title);
+      const newDirName = `${note.index}. ${title}`;
+      if (newDirName === note.dirName) {
+        const value2 = await this.readNote(note.uuid);
+        return { value: value2, changedFiles: [], snapshotRevision: snapshot.revision };
+      }
+      const newDirectoryPath = path4.join(this.paths.notes, newDirName);
+      assertPathInside(this.paths.notes, newDirectoryPath);
+      try {
+        await fs3.access(newDirectoryPath);
+        throw new WorkspaceError("INVALID_TITLE", "\u76EE\u6807\u7B14\u8BB0\u76EE\u5F55\u5DF2\u7ECF\u5B58\u5728", {
+          newDirectoryPath
+        });
+      } catch (error) {
+        if (error instanceof WorkspaceError) throw error;
+      }
+      const currentContent = await fs3.readFile(note.readmePath, "utf8");
+      const formatted = await formatTNotesNote({
+        content: currentContent,
+        noteIndex: note.index,
+        title,
+        repoOwner: config.author,
+        repoName: config.repoName,
+        noteConfig: note.config,
+        prettier: this.prettierByDefault
+      });
+      const renamedNote = {
+        ...note,
+        title,
+        dirName: newDirName,
+        directoryPath: newDirectoryPath,
+        readmePath: path4.join(newDirectoryPath, "README.md"),
+        configPath: path4.join(newDirectoryPath, ".tnotes.json")
+      };
+      const tocLines = (tocText ?? "").split("\n");
+      for (let index = 0; index < tocLines.length; index++) {
+        const parsed = parseTocLine(tocLines[index]);
+        if (parsed.noteIndex === note.index) {
+          tocLines[index] = buildTocLine(
+            toNoteInfo(renamedNote),
+            parsed.indentLevel,
+            parsed.completed
+          );
+        }
+      }
+      const normalizedToc = normalizeTocContent(tocLines);
+      const updatedNotes = snapshot.notes.map(
+        (item) => item.uuid === note.uuid ? renamedNote : item
+      );
+      await fs3.rename(note.directoryPath, newDirectoryPath);
+      try {
+        await writeFilesAtomically([
+          { path: renamedNote.readmePath, data: formatted.content },
+          { path: this.paths.toc, data: normalizedToc },
+          {
+            path: this.paths.sidebar,
+            data: sidebarContent(normalizedToc.split("\n"), updatedNotes, config)
+          }
+        ]);
+      } catch (error) {
+        await fs3.rename(newDirectoryPath, note.directoryPath);
+        throw error;
+      }
+      const value = await this.readNote(note.uuid);
+      const refreshed = await this.inspect();
+      return {
+        value,
+        changedFiles: [
+          {
+            path: newDirectoryPath,
+            previousPath: note.directoryPath,
+            kind: "renamed"
+          },
+          { path: renamedNote.readmePath, kind: "updated" },
+          { path: this.paths.toc, kind: "updated" },
+          { path: this.paths.sidebar, kind: "updated" }
+        ],
+        snapshotRevision: refreshed.revision
+      };
+    });
+  }
+  async updateNoteConfig(input) {
+    return this.queue.run(async () => {
+      const { snapshot, tocText } = await this.scanReady();
+      const config = requireConfig(snapshot);
+      const note = findNote(snapshot, input.noteUuid);
+      assertRevision(note.revision, input.expectedRevision, "\u7B14\u8BB0");
+      const updatedConfig = { ...note.config, ...input.updates };
+      const writes = [
+        { path: note.configPath, data: serializeNoteConfig(updatedConfig) }
+      ];
+      const changedFiles = [
+        { path: note.configPath, kind: "updated" }
+      ];
+      if (typeof input.updates.done === "boolean") {
+        const lines = (tocText ?? "").split("\n");
+        let updated = false;
+        const tempNote = { ...note, config: updatedConfig };
+        for (let index = 0; index < lines.length; index++) {
+          const parsed = parseTocLine(lines[index]);
+          if (parsed.noteIndex === note.index) {
+            lines[index] = buildTocLine(
+              toNoteInfo(tempNote),
+              parsed.indentLevel,
+              input.updates.done
+            );
+            updated = true;
+          }
+        }
+        if (updated) {
+          const normalizedToc = normalizeTocContent(lines);
+          const updatedNotes = snapshot.notes.map(
+            (item) => item.uuid === note.uuid ? tempNote : item
+          );
+          writes.push(
+            { path: this.paths.toc, data: normalizedToc },
+            {
+              path: this.paths.sidebar,
+              data: sidebarContent(normalizedToc.split("\n"), updatedNotes, config)
+            }
+          );
+          changedFiles.push(
+            { path: this.paths.toc, kind: "updated" },
+            { path: this.paths.sidebar, kind: "updated" }
+          );
+        }
+      }
+      await writeFilesAtomically(writes);
+      const value = await this.readNote(note.uuid);
+      const refreshed = await this.inspect();
+      return { value, changedFiles, snapshotRevision: refreshed.revision };
+    });
+  }
+  async moveTocEntry(input) {
+    return this.queue.run(async () => {
+      const { snapshot, tocText } = await this.scanReady();
+      const config = requireConfig(snapshot);
+      assertRevision(snapshot.revision, input.expectedSnapshotRevision, "\u77E5\u8BC6\u5E93\u76EE\u5F55");
+      const lines = (tocText ?? "").split("\n");
+      const sourceLine = resolveEntryLine(lines, snapshot, input.source);
+      const targetLine = resolveEntryLine(lines, snapshot, input.target);
+      const sourceRange = getTocEntrySubtreeRange(lines, sourceLine);
+      if (targetLine >= sourceRange.start && targetLine < sourceRange.end) {
+        throw new WorkspaceError(
+          "INVALID_TOC_ENTRY",
+          "\u4E0D\u80FD\u628A\u76EE\u5F55\u6761\u76EE\u79FB\u52A8\u5230\u81EA\u8EAB\u6216\u81EA\u8EAB\u5B50\u6811\u5185"
+        );
+      }
+      const moving = lines.splice(
+        sourceRange.start,
+        sourceRange.end - sourceRange.start
+      );
+      const adjustedTarget = adjustTocLineIndexAfterSubtreeRemoval(
+        targetLine,
+        sourceRange.start,
+        sourceRange.end
+      );
+      const target = parseTocLine(lines[adjustedTarget]);
+      if (!target.isMatch) {
+        throw new WorkspaceError("INVALID_TOC_ENTRY", "\u79FB\u52A8\u76EE\u6807\u65E0\u6548");
+      }
+      let insertAt;
+      let indent;
+      if (input.placement === "inside") {
+        insertAt = getTocEntrySubtreeRange(lines, adjustedTarget).end;
+        indent = target.indentLevel + 1;
+      } else if (input.placement === "before") {
+        insertAt = adjustedTarget;
+        indent = target.indentLevel;
+      } else {
+        insertAt = getTocEntrySubtreeRange(lines, adjustedTarget).end;
+        indent = target.indentLevel;
+      }
+      const oldIndent = parseTocLine(moving[0]).indentLevel;
+      lines.splice(insertAt, 0, ...adjustIndent(moving, indent - oldIndent));
+      const normalizedToc = normalizeTocContent(lines);
+      await writeFilesAtomically([
+        { path: this.paths.toc, data: normalizedToc },
+        {
+          path: this.paths.sidebar,
+          data: sidebarContent(normalizedToc.split("\n"), snapshot.notes, config)
+        }
+      ]);
+      const value = await this.inspect();
+      return {
+        value,
+        changedFiles: [
+          { path: this.paths.toc, kind: "updated" },
+          { path: this.paths.sidebar, kind: "updated" }
+        ],
+        snapshotRevision: value.revision
+      };
+    });
+  }
+  async createTocGroup(input) {
+    return this.queue.run(async () => {
+      const { snapshot, tocText } = await this.scanReady();
+      const config = requireConfig(snapshot);
+      assertRevision(snapshot.revision, input.expectedSnapshotRevision, "\u77E5\u8BC6\u5E93\u76EE\u5F55");
+      const title = validateTitle(input.title);
+      const lines = (tocText ?? "").split("\n");
+      insertLineAtPlacement(
+        lines,
+        snapshot,
+        input.placement,
+        (indent) => buildFolderTocLine(title, indent)
+      );
+      const normalizedToc = normalizeTocContent(lines);
+      await writeFilesAtomically([
+        { path: this.paths.toc, data: normalizedToc },
+        {
+          path: this.paths.sidebar,
+          data: sidebarContent(normalizedToc.split("\n"), snapshot.notes, config)
+        }
+      ]);
+      const value = await this.inspect();
+      return {
+        value,
+        changedFiles: [
+          { path: this.paths.toc, kind: "updated" },
+          { path: this.paths.sidebar, kind: "updated" }
+        ],
+        snapshotRevision: value.revision
+      };
+    });
+  }
+  async renameTocGroup(input) {
+    return this.queue.run(async () => {
+      const { snapshot, tocText } = await this.scanReady();
+      const config = requireConfig(snapshot);
+      assertRevision(snapshot.revision, input.expectedSnapshotRevision, "\u77E5\u8BC6\u5E93\u76EE\u5F55");
+      const lines = (tocText ?? "").split("\n");
+      const lineIndex = resolveEntryLine(lines, snapshot, {
+        type: "folder",
+        folderPath: input.folderPath
+      });
+      const updatedLines = renameFolderLine(lines, lineIndex, validateTitle(input.title));
+      const normalizedToc = normalizeTocContent(updatedLines);
+      await writeFilesAtomically([
+        { path: this.paths.toc, data: normalizedToc },
+        {
+          path: this.paths.sidebar,
+          data: sidebarContent(normalizedToc.split("\n"), snapshot.notes, config)
+        }
+      ]);
+      const value = await this.inspect();
+      return {
+        value,
+        changedFiles: [
+          { path: this.paths.toc, kind: "updated" },
+          { path: this.paths.sidebar, kind: "updated" }
+        ],
+        snapshotRevision: value.revision
+      };
+    });
+  }
+  async previewDelete(entry) {
+    const { snapshot, tocText } = await this.scanReady();
+    const lines = (tocText ?? "").split("\n");
+    const lineIndex = resolveEntryLine(lines, snapshot, entry);
+    const indexes = collectNoteIndexesInSubtree(lines, lineIndex);
+    const notes = indexes.map((index) => snapshot.notes.find((note) => note.index === index)).filter((note) => Boolean(note));
+    const filePaths = (await Promise.all(notes.map((note) => listFilesRecursively(note.directoryPath)))).flat();
+    return {
+      entry,
+      notes: notes.map((note) => ({
+        noteUuid: note.uuid,
+        index: note.index,
+        title: note.title,
+        directoryPath: note.directoryPath
+      })),
+      filePaths,
+      directoryPaths: notes.map((note) => note.directoryPath),
+      snapshotRevision: snapshot.revision
+    };
+  }
+  async deleteTocEntry(input) {
+    return this.queue.run(async () => {
+      const { snapshot, tocText } = await this.scanReady();
+      const config = requireConfig(snapshot);
+      assertRevision(snapshot.revision, input.expectedSnapshotRevision, "\u77E5\u8BC6\u5E93\u76EE\u5F55");
+      const lines = (tocText ?? "").split("\n");
+      const lineIndex = resolveEntryLine(lines, snapshot, input.entry);
+      const range = getTocEntrySubtreeRange(lines, lineIndex);
+      const indexes = collectNoteIndexesInSubtree(lines, lineIndex);
+      const notes = indexes.map((index) => snapshot.notes.find((note) => note.index === index)).filter((note) => Boolean(note));
+      lines.splice(range.start, range.end - range.start);
+      const remainingNotes = snapshot.notes.filter(
+        (note) => !indexes.includes(note.index)
+      );
+      const normalizedToc = normalizeTocContent(lines);
+      const movedDirectories = [];
+      try {
+        for (const note of notes) {
+          const temporary = path4.join(
+            this.paths.notes,
+            `.${path4.basename(note.directoryPath)}.desk-delete-${randomUUID2()}`
+          );
+          await fs3.rename(note.directoryPath, temporary);
+          movedDirectories.push({ original: note.directoryPath, temporary });
+        }
+        await writeFilesAtomically([
+          { path: this.paths.toc, data: normalizedToc },
+          {
+            path: this.paths.sidebar,
+            data: sidebarContent(normalizedToc.split("\n"), remainingNotes, config)
+          }
+        ]);
+      } catch (error) {
+        for (const moved of movedDirectories.reverse()) {
+          await fs3.rename(moved.temporary, moved.original);
+        }
+        throw error;
+      }
+      for (const moved of movedDirectories) {
+        await fs3.rm(moved.temporary, { recursive: true, force: true });
+      }
+      const value = await this.inspect();
+      return {
+        value,
+        changedFiles: [
+          ...notes.map((note) => ({
+            path: note.directoryPath,
+            kind: "deleted"
+          })),
+          { path: this.paths.toc, kind: "updated" },
+          { path: this.paths.sidebar, kind: "updated" }
+        ],
+        snapshotRevision: value.revision
+      };
+    });
+  }
+  async writeLocalAttachment(input) {
+    return this.queue.run(async () => {
+      const { snapshot } = await this.scanReady();
+      const note = findNote(snapshot, input.noteUuid);
+      const assetsPath = path4.join(note.directoryPath, "assets");
+      assertPathInside(note.directoryPath, assetsPath);
+      const requestedName = sanitizeFileName(input.fileName);
+      const extension = path4.extname(requestedName);
+      const base = path4.basename(requestedName, extension);
+      let candidate = requestedName;
+      let suffix = 1;
+      while (true) {
+        try {
+          await fs3.access(path4.join(assetsPath, candidate));
+          candidate = `${base}-${suffix}${extension}`;
+          suffix++;
+        } catch {
+          break;
+        }
+      }
+      const absolutePath = path4.join(assetsPath, candidate);
+      assertPathInside(assetsPath, absolutePath);
+      await writeFilesAtomically([{ path: absolutePath, data: input.data }]);
+      const value = {
+        absolutePath,
+        markdownPath: `./assets/${candidate}`
+      };
+      const refreshed = await this.inspect();
+      return {
+        value,
+        changedFiles: [{ path: absolutePath, kind: "created" }],
+        snapshotRevision: refreshed.revision
+      };
+    });
+  }
+};
+
+// workspace/index.ts
+function createWorkspace(options) {
+  return new Workspace(options);
+}
+
+export {
+  getNewNoteReadmeBody,
+  generateNoteTitle,
+  WorkspaceError,
+  parseTocCompletedNotes,
+  createWorkspace
+};