@tnotesjs/core 0.5.0 → 0.6.0

package/dist/workspace/index.js

@@ -0,0 +1,1207 @@
+import {
+  formatTNotesNote
+} from "../chunk-UNFSW5C2.js";
+import {
+  TOC_INDENT_SPACES,
+  adjustTocLineIndexAfterSubtreeRemoval,
+  buildFolderTocLine,
+  buildSidebarFromTocTree,
+  buildTocLine,
+  collectNoteIndexesInSubtree,
+  findFolderLineIndex,
+  findTocLineIndex,
+  getNewNoteReadmeBody,
+  getTocEntrySubtreeRange,
+  parseTocLine,
+  parseTocToTree,
+  processTocEmptyLines,
+  renameFolderLine
+} from "../chunk-U6IBLREL.js";
+import "../chunk-CZXRQPFJ.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/scanner.ts
+import { createHash } from "crypto";
+import fs2 from "fs/promises";
+import path3 from "path";
+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);
+}
+
+// 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)
+    };
+    this.attachments = {
+      writeLocal: (input) => this.writeLocalAttachment(input)
+    };
+  }
+  async inspect() {
+    this.assertActive();
+    return (await scanWorkspace(this.paths)).snapshot;
+  }
+  async refresh() {
+    return this.inspect();
+  }
+  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 {
+  WorkspaceError,
+  createWorkspace
+};