@tnotesjs/core 0.2.0 → 0.2.2

package/dist/vitepress/config/index.js

@@ -0,0 +1,1686 @@
+import {
+  FileWatcherService,
+  NoteIndexCache,
+  NoteService,
+  RenameNoteCommand,
+  TocService,
+  UpdateNoteConfigCommand,
+  generateAnchor,
+  logger
+} from "../../chunk-5QN44ES5.js";
+import {
+  ConfigManager
+} from "../../chunk-5Y5IYS6C.js";
+
+// vitepress/config/index.ts
+import fs3 from "fs";
+import path5 from "path";
+import { defineConfig } from "vitepress";
+
+// vitepress/configs/constants.ts
+function getIgnoreList(config) {
+  return [...config.ignore_dirs.map((dir) => `**/${dir}/**`)];
+}
+function getGithubPageUrl(config) {
+  return "https://" + config.author.toLowerCase() + ".github.io/" + config.repoName + "/";
+}
+
+// vitepress/configs/head.config.ts
+function getHeadConfig(config, githubPageUrl) {
+  const head = [
+    [
+      "meta",
+      {
+        name: "keywords",
+        content: config.keywords.join(", ")
+      }
+    ],
+    ["meta", { name: "author", content: config.author }],
+    ["link", { rel: "canonical", href: githubPageUrl }],
+    ["link", { rel: "icon", href: githubPageUrl + "favicon.ico" }],
+    ["link", { rel: "preconnect", href: "https://fonts.googleapis.com" }]
+  ];
+  return head;
+}
+
+// vitepress/configs/markdown.config.ts
+import fs from "fs";
+import markdownItContainer from "markdown-it-container";
+import mila from "markdown-it-link-attributes";
+import markdownItTaskLists from "markdown-it-task-lists";
+import path from "path";
+function esc(s = "") {
+  return s.replace(
+    /[&<>"']/g,
+    (ch) => ({
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;"
+    })[ch]
+  );
+}
+var simpleMermaidMarkdown = (md) => {
+  const fence = md.renderer.rules.fence ? md.renderer.rules.fence.bind(md.renderer.rules) : () => "";
+  md.renderer.rules.fence = (tokens, index, options, env, slf) => {
+    const token = tokens[index];
+    if (token.info.trim() === "mermaid") {
+      try {
+        const key = `mermaid-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const content = token.content;
+        return `<Mermaid id="${key}" graph="${encodeURIComponent(content)}" />`;
+      } catch (err) {
+        return `<pre>${err}</pre>`;
+      }
+    }
+    if (token.info.trim() === "mmd") {
+      tokens[index].info = "mermaid";
+    }
+    return fence(tokens, index, options, env, slf);
+  };
+};
+function configureMarkMapContainer(md) {
+  md.use(markdownItContainer, "markmap", {
+    marker: "`",
+    validate(params) {
+      const p = (params || "").trim();
+      return p.startsWith("markmap");
+    },
+    render() {
+      return "";
+    }
+  });
+  md.core.ruler.after("block", "tn_replace_markmap_container", (state) => {
+    const src = state.env.source || "";
+    const lines = src.split("\n");
+    const tokens = state.tokens;
+    for (let i = 0; i < tokens.length; i++) {
+      const t = tokens[i];
+      if (t.type === "container_markmap_open") {
+        let j = i + 1;
+        while (j < tokens.length && tokens[j].type !== "container_markmap_close")
+          j++;
+        if (j >= tokens.length) continue;
+        const open = t;
+        const startLine = open.map ? open.map[0] + 1 : null;
+        const endLine = open.map ? open.map[1] - 1 : null;
+        const params = {};
+        if (open.map && typeof open.map[0] === "number") {
+          const openLine = (lines[open.map[0]] || "").trim();
+          let paramPart = "";
+          const braceMatch = openLine.match(/\{([^}]*)\}/);
+          if (braceMatch) {
+            paramPart = braceMatch[1].trim();
+          } else {
+            const after = openLine.replace(/^`+\s*/, "");
+            if (after.startsWith("markmap")) {
+              paramPart = after.slice("markmap".length).trim();
+            }
+          }
+          if (paramPart) {
+            const tokenArr = paramPart.match(/"[^"]*"|'[^']*'|\S+/g) || [];
+            let startIdx = 0;
+            if (tokenArr.length > 0 && /^\d+$/.test(tokenArr[0])) {
+              params.initialExpandLevel = Number(tokenArr[0]);
+              startIdx = 1;
+            }
+            for (let k = startIdx; k < tokenArr.length; k++) {
+              const pair = tokenArr[k];
+              if (!pair) continue;
+              const m = pair.match(/^([^=:\s]+)\s*(=|:)\s*(.+)$/);
+              if (m) {
+                const key = m[1];
+                let val = m[3];
+                if (/^".*"$/.test(val) && val.length >= 2 || /^'.*'$/.test(val) && val.length >= 2) {
+                  val = val.slice(1, -1);
+                } else if (/^\d+$/.test(val)) {
+                  val = String(Number(val));
+                }
+                params[key] = val;
+              }
+            }
+          }
+        }
+        let content = "";
+        if (startLine !== null && endLine !== null) {
+          for (let k = startLine; k <= endLine && k < lines.length; k++) {
+            content += lines[k] + "\n";
+          }
+        } else {
+          for (let k = i + 1; k < j; k++) {
+            content += tokens[k].content || "";
+          }
+        }
+        const firstNonEmptyLine = (content || "").split("\n").find((ln) => ln.trim() !== "") || "";
+        const refMatch = firstNonEmptyLine.trim().match(/^<<<\s*(.+)$/);
+        if (refMatch) {
+          const refRaw = refMatch[1].trim().replace(/^['"]|['"]$/g, "");
+          try {
+            const env = state.env || {};
+            const possibleRel = env.relativePath || env.path || env.filePath || env.file || "";
+            let refFullPath = refRaw;
+            if (!path.isAbsolute(refRaw)) {
+              if (possibleRel) {
+                const currentDir = path.dirname(possibleRel);
+                refFullPath = path.resolve(process.cwd(), currentDir, refRaw);
+              } else {
+                refFullPath = path.resolve(process.cwd(), refRaw);
+              }
+            } else {
+              refFullPath = refRaw;
+            }
+            const fileContent = fs.readFileSync(refFullPath, "utf-8");
+            content = fileContent;
+          } catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            content = `Failed to load referenced file: ${esc(
+              String(refRaw)
+            )}
+
+Error: ${esc(errorMsg)}`;
+          }
+        }
+        const encodedContent = encodeURIComponent(content.trim());
+        let propsStr = `content="${encodedContent}"`;
+        for (const [k, v] of Object.entries(params)) {
+          if (typeof v === "number" || /^\d+$/.test(String(v))) {
+            propsStr += ` :${k}="${v}"`;
+          } else {
+            const safe = String(v).replace(/"/g, "&quot;");
+            propsStr += ` ${k}="${safe}"`;
+          }
+        }
+        const html = `<MarkMap ${propsStr}></MarkMap>
+`;
+        const htmlToken = new state.Token("html_block", "", 0);
+        htmlToken.content = html;
+        tokens.splice(i, j - i + 1, htmlToken);
+      }
+    }
+    return true;
+  });
+}
+function configureSwiperContainer(md) {
+  let __tn_swiper_uid = 0;
+  let __tn_rules_stack = [];
+  md.core.ruler.before("block", "tn_swiper_reset_uid", () => {
+    __tn_swiper_uid = 0;
+    __tn_rules_stack = [];
+    return true;
+  });
+  md.use(markdownItContainer, "swiper", {
+    render: (tokens, idx) => {
+      if (tokens[idx].nesting === 1) {
+        __tn_rules_stack.push({
+          image: md.renderer.rules.image,
+          pOpen: md.renderer.rules.paragraph_open,
+          pClose: md.renderer.rules.paragraph_close
+        });
+        md.renderer.rules.paragraph_open = () => "";
+        md.renderer.rules.paragraph_close = () => "";
+        md.renderer.rules.image = (tokens2, i) => {
+          const token = tokens2[i];
+          const src = token.attrGet("src") || "";
+          const alt = token.content || "";
+          const title = alt && alt.trim() ? alt : "img";
+          return `<div class="swiper-slide" data-title="${esc(
+            title
+          )}"><img src="${esc(src)}" alt="${esc(alt)}"></div>`;
+        };
+        const id = `tn-swiper-${++__tn_swiper_uid}`;
+        return `
+<div class="tn-swiper" data-swiper-id="${id}">
+  <div class="tn-swiper-tabs"></div>
+  <div class="swiper-container">
+    <div class="swiper-wrapper">
+`;
+      } else {
+        const prev = __tn_rules_stack.pop() || {
+          image: null,
+          pOpen: null,
+          pClose: null
+        };
+        md.renderer.rules.image = prev.image;
+        md.renderer.rules.paragraph_open = prev.pOpen;
+        md.renderer.rules.paragraph_close = prev.pClose;
+        return `
+    </div>
+    <!-- \u4E0B\u4E00\u9875\u6309\u94AE -->
+    <!-- <div class="swiper-button-next"></div> -->
+    <!-- \u4E0A\u4E00\u9875\u6309\u94AE -->
+    <!-- <div class="swiper-button-prev"></div> -->
+    <!-- \u5206\u9875\u5BFC\u822A -->
+    <!-- <div class="swiper-pagination"></div> -->
+  </div>
+</div>
+`;
+      }
+    }
+  });
+}
+function getMarkdownConfig() {
+  const markdown = {
+    lineNumbers: true,
+    math: true,
+    config(md) {
+      md.core.ruler.before("normalize", "save-source", (state) => {
+        state.env.source = state.src;
+        return true;
+      });
+      simpleMermaidMarkdown(md);
+      configureMarkMapContainer(md);
+      md.use(markdownItTaskLists);
+      md.use(mila, {
+        attrs: {
+          target: "_self",
+          rel: "noopener"
+        }
+      });
+      configureSwiperContainer(md);
+    },
+    anchor: {
+      slugify: generateAnchor
+    },
+    image: {
+      lazyLoading: true
+    }
+  };
+  return markdown;
+}
+
+// vitepress/configs/theme.config.ts
+function getThemeConfig(config) {
+  const themeConfig = {
+    docFooter: {
+      prev: "\u4E0A\u4E00\u7BC7",
+      next: "\u4E0B\u4E00\u7BC7"
+    },
+    externalLinkIcon: true,
+    outline: {
+      level: [2, 3],
+      label: "\u76EE\u5F55"
+    },
+    nav: [
+      {
+        text: "\u{1F440} README",
+        link: "/README"
+      },
+      {
+        text: "Menus",
+        items: config.menuItems
+      }
+    ],
+    search: {
+      // 使用本地搜索（不依赖远程服务器）
+      provider: "local",
+      options: {
+        miniSearch: {
+          /**
+           * 控制如何对文档进行分词、字段提取等预处理
+           * @type {Pick<import('minisearch').Options, 'extractField' | 'tokenize' | 'processTerm'>}
+           */
+          options: {
+            // 自定义分词逻辑
+            tokenize: (text, language) => {
+              if (language === "zh") {
+                return text.match(/[\u4e00-\u9fa5]+|\S+/g) || [];
+              }
+              return text.split(/\s+/);
+            },
+            // 将所有词转为小写，确保大小写不敏感匹配
+            processTerm: (term) => term.toLowerCase()
+          },
+          /**
+           * 控制搜索时的行为（如模糊匹配、权重）
+           * @type {import('minisearch').SearchOptions}
+           * @default
+           * { fuzzy: 0.2, prefix: true, boost: { title: 4, text: 2, titles: 1 } }
+           */
+          searchOptions: {
+            fuzzy: 0.2,
+            // 模糊匹配阈值（0-1），允许拼写错误的阈值（数值越低越严格）
+            prefix: true,
+            // 是否启用前缀匹配（输入"jav"可匹配"javascript"）
+            boost: {
+              title: 10,
+              // 文件名作为 h1 标题，权重最高
+              headings: 5,
+              // h2 - h6
+              text: 3,
+              // 正文内容索引
+              code: 1
+              // 代码块索引权重
+            }
+          }
+        },
+        /**
+         * 控制哪些 Markdown 内容参与本地搜索引擎索引
+         * @param {string} src 当前 Markdown 文件的原始内容（即 .md 文件中的文本）
+         * @param {import('vitepress').MarkdownEnv} env 包含当前页面环境信息的对象，比如 frontmatter、路径等
+         * @param {import('markdown-it-async')} md 一个 Markdown 渲染器实例，用来将 Markdown 转换为 HTML
+         */
+        async _render(src, env, md) {
+          const filePath = env.relativePath;
+          if (filePath.includes("TOC.md")) return "";
+          const notesIndex = filePath.indexOf("notes/");
+          let folderName = "";
+          if (notesIndex !== -1) {
+            const pathAfterNotes = filePath.slice(notesIndex + "notes/".length);
+            folderName = pathAfterNotes.split("/")[0];
+          }
+          const titleField = `# ${folderName}
+`;
+          const html = md.render(titleField + "\n\n" + src, env);
+          return html;
+        }
+      }
+    },
+    // VitePress 只有 sidebar 非空才会渲染 sidebar 插槽，自定义侧边栏依赖这个外壳。
+    sidebar: [
+      {
+        text: "",
+        items: []
+      }
+    ],
+    socialLinks: config.socialLinks
+  };
+  return themeConfig;
+}
+
+// vitepress/plugins/buildProgressPlugin.ts
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync
+} from "fs";
+import { join } from "path";
+var CACHE_DIR = join(process.cwd(), "node_modules", ".tnotes-progress");
+var CACHE_FILE = join(CACHE_DIR, "build-cache.json");
+function getCacheData() {
+  try {
+    if (existsSync(CACHE_FILE)) {
+      return JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return { transformCount: 0, chunkCount: 0 };
+}
+function setCacheData(data) {
+  try {
+    if (!existsSync(CACHE_DIR)) {
+      mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    writeFileSync(CACHE_FILE, JSON.stringify(data), "utf-8");
+  } catch {
+  }
+}
+var globalStartTime = 0;
+var globalTransformCount = 0;
+var globalChunkCount = 0;
+var globalHasError = false;
+var globalIsBuilding = false;
+var globalOutDir = "";
+var globalLastPercent = 0;
+var globalLastLoggedPercent = -1;
+var globalLastOutputTime = 0;
+var globalTransformEndTime = 0;
+var globalLastHookTime = 0;
+var globalStallTimer = null;
+var isTTY = !!(process.stdout.isTTY && process.stderr.isTTY);
+var isCI = !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.TRAVIS || process.env.JENKINS_URL);
+var useSingleLineMode = isTTY && !isCI;
+var originalStdoutWrite = null;
+var originalStderrWrite = null;
+function interceptOutput() {
+  if (originalStdoutWrite) return;
+  originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  originalStderrWrite = process.stderr.write.bind(process.stderr);
+  const filter = (chunk) => {
+    const str = chunk.toString();
+    return str.includes("\u{1F528}") || str.includes("\u2705 \u6784\u5EFA\u6210\u529F") || str.includes("\u274C \u6784\u5EFA\u5931\u8D25") || str.includes("\u{1F4C1}") || str.includes("\u{1F4CA}") || str.includes("\u{1F4E6}") || str.includes("\u23F1\uFE0F") || str.includes("\x1B[2K");
+  };
+  process.stdout.write = ((chunk, encodingOrCallback, callback) => {
+    if (filter(chunk)) {
+      return originalStdoutWrite(chunk, encodingOrCallback, callback);
+    }
+    if (typeof encodingOrCallback === "function") encodingOrCallback();
+    else if (callback) callback();
+    return true;
+  });
+  process.stderr.write = ((chunk, encodingOrCallback, callback) => {
+    const str = chunk.toString();
+    if (filter(chunk) || str.toLowerCase().includes("error")) {
+      return originalStderrWrite(chunk, encodingOrCallback, callback);
+    }
+    if (typeof encodingOrCallback === "function") encodingOrCallback();
+    else if (callback) callback();
+    return true;
+  });
+}
+function restoreOutput() {
+  if (originalStdoutWrite) {
+    process.stdout.write = originalStdoutWrite;
+    originalStdoutWrite = null;
+  }
+  if (originalStderrWrite) {
+    process.stderr.write = originalStderrWrite;
+    originalStderrWrite = null;
+  }
+}
+function renderProgress(percent, transforms, chunks, width, complete, incomplete, isFinal = false) {
+  if (!originalStderrWrite) return;
+  if (!useSingleLineMode && !isFinal) {
+    const currentPercent = Math.floor(percent * 100);
+    const currentBucket = Math.floor(currentPercent / 10) * 10;
+    const now = Date.now();
+    if (currentBucket <= globalLastLoggedPercent || now - globalLastOutputTime < 500) {
+      return;
+    }
+    globalLastLoggedPercent = currentBucket;
+    globalLastOutputTime = now;
+  }
+  const filled = Math.floor(percent * width);
+  const empty = width - filled;
+  const bar = complete.repeat(filled) + incomplete.repeat(empty);
+  const percentStr = (percent * 100).toFixed(0).padStart(3, " ");
+  const elapsed = ((Date.now() - globalStartTime) / 1e3).toFixed(1);
+  const prefix = useSingleLineMode ? "\r\x1B[2K" : "";
+  const ending = isFinal || !useSingleLineMode ? "\n" : "";
+  const line = `${prefix}Building [${bar}] ${percentStr}% | Transforms: ${transforms} | Chunks: ${chunks} | Time: ${elapsed}s${ending}`;
+  originalStderrWrite(line);
+}
+function buildProgressPlugin(options = {}) {
+  const { width = 40, complete = "\u2588", incomplete = "\u2591" } = options;
+  const cache = getCacheData();
+  const hasCache = cache.transformCount > 0;
+  return {
+    name: "tnotes-build-progress",
+    enforce: "pre",
+    apply: "build",
+    config(config, { command }) {
+      if (command === "build") {
+        config.logLevel = "silent";
+        if (!globalIsBuilding) {
+          globalIsBuilding = true;
+          globalStartTime = Date.now();
+          globalTransformCount = 0;
+          globalChunkCount = 0;
+          globalHasError = false;
+          globalLastPercent = 0;
+          globalLastLoggedPercent = -1;
+          globalLastOutputTime = 0;
+          globalTransformEndTime = 0;
+          globalLastHookTime = Date.now();
+          globalOutDir = config.build?.outDir || "dist";
+          interceptOutput();
+          globalStallTimer = setInterval(() => {
+            if (!globalIsBuilding || globalLastPercent <= 0 || globalLastPercent >= 0.98)
+              return;
+            const now = Date.now();
+            if (now - globalLastHookTime < 2e3) return;
+            const remaining = 0.98 - globalLastPercent;
+            globalLastPercent += remaining * 0.02;
+            const transformsStr = hasCache ? `${globalTransformCount}/${cache.transformCount * 2}` : `${globalTransformCount}`;
+            const chunksStr = hasCache ? `${globalChunkCount}/${cache.chunkCount * 2}` : `${globalChunkCount}`;
+            renderProgress(
+              globalLastPercent,
+              transformsStr,
+              chunksStr,
+              width,
+              complete,
+              incomplete
+            );
+          }, 1e3);
+        }
+      }
+    },
+    transform(_code, _id) {
+      globalTransformCount++;
+      globalLastHookTime = Date.now();
+      const transformWeight = hasCache && cache.transformEndRatio != null ? Math.max(0.1, Math.min(0.85, cache.transformEndRatio * 0.98)) : 0.85;
+      if (hasCache) {
+        const totalTransforms = cache.transformCount * 2;
+        globalLastPercent = Math.min(
+          transformWeight,
+          globalTransformCount / totalTransforms * transformWeight
+        );
+      } else {
+        const k = 500;
+        globalLastPercent = Math.min(
+          transformWeight,
+          transformWeight * globalTransformCount / (globalTransformCount + k)
+        );
+      }
+      const transformsStr = hasCache ? `${globalTransformCount}/${cache.transformCount * 2}` : `${globalTransformCount}`;
+      const chunksStr = hasCache ? `${globalChunkCount}/${cache.chunkCount * 2}` : `${globalChunkCount}`;
+      renderProgress(
+        globalLastPercent,
+        transformsStr,
+        chunksStr,
+        width,
+        complete,
+        incomplete
+      );
+      return null;
+    },
+    renderChunk() {
+      globalChunkCount++;
+      globalLastHookTime = Date.now();
+      if (!globalTransformEndTime) {
+        globalTransformEndTime = Date.now();
+      }
+      const transformWeight = hasCache && cache.transformEndRatio != null ? Math.max(0.1, Math.min(0.85, cache.transformEndRatio * 0.98)) : 0.85;
+      const chunkWeight = 0.98 - transformWeight;
+      if (hasCache) {
+        const totalChunks = cache.chunkCount * 2;
+        globalLastPercent = Math.min(
+          0.98,
+          transformWeight + globalChunkCount / totalChunks * chunkWeight
+        );
+      } else {
+        globalLastPercent = Math.max(globalLastPercent, transformWeight);
+        globalLastPercent = Math.min(0.98, globalLastPercent + 5e-5);
+      }
+      const transformsStr = hasCache ? `${globalTransformCount}/${cache.transformCount * 2}` : `${globalTransformCount}`;
+      const chunksStr = hasCache ? `${globalChunkCount}/${cache.chunkCount * 2}` : `${globalChunkCount}`;
+      renderProgress(
+        globalLastPercent,
+        transformsStr,
+        chunksStr,
+        width,
+        complete,
+        incomplete
+      );
+      return null;
+    },
+    buildEnd(err) {
+      if (err) {
+        globalHasError = true;
+      }
+    },
+    closeBundle() {
+      setTimeout(() => {
+        if (!globalIsBuilding) return;
+        if (globalStallTimer) {
+          clearInterval(globalStallTimer);
+          globalStallTimer = null;
+        }
+        const elapsed = ((Date.now() - globalStartTime) / 1e3).toFixed(1);
+        const totalTransforms = hasCache ? cache.transformCount * 2 : globalTransformCount;
+        const totalChunks = hasCache ? cache.chunkCount * 2 : globalChunkCount;
+        const transformsStr = `${totalTransforms}/${totalTransforms}`;
+        const chunksStr = `${totalChunks}/${totalChunks}`;
+        renderProgress(
+          1,
+          transformsStr,
+          chunksStr,
+          width,
+          complete,
+          incomplete,
+          true
+        );
+        restoreOutput();
+        if (!globalHasError) {
+          const totalTime = Date.now() - globalStartTime;
+          const transformTime = globalTransformEndTime ? globalTransformEndTime - globalStartTime : totalTime;
+          setCacheData({
+            transformCount: Math.floor(globalTransformCount / 2),
+            chunkCount: Math.floor(globalChunkCount / 2),
+            transformEndRatio: transformTime / totalTime
+          });
+          console.log(`\u{1F528} Rollup \u6253\u5305\u5B8C\u6210`);
+          console.log(`   \u{1F4C1} \u8F93\u51FA\u76EE\u5F55: ${globalOutDir}`);
+          console.log(`   \u23F1\uFE0F  \u8017\u65F6: ${elapsed}s`);
+          console.log(`   \u23F3 VitePress \u6B63\u5728\u6E32\u67D3\u9875\u9762...`);
+        } else {
+          console.log(`
+\u274C \u6784\u5EFA\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u9519\u8BEF\u4FE1\u606F`);
+        }
+        globalIsBuilding = false;
+      }, 500);
+    }
+  };
+}
+
+// vitepress/plugins/fileWatcherBridgePlugin.ts
+var RENAME_EVENT = "tnotes:note-renamed";
+var BROADCAST_PATH = "/__tnotes_broadcast_rename";
+function fileWatcherBridgePlugin() {
+  return {
+    name: "tnotes-file-watcher-bridge",
+    apply: "serve",
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        const url = req.url ?? "";
+        const isBroadcast = url === BROADCAST_PATH || url.endsWith(BROADCAST_PATH);
+        if (!isBroadcast || req.method !== "POST") {
+          return next();
+        }
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const data = JSON.parse(body || "{}");
+            server.ws.send({ type: "custom", event: RENAME_EVENT, data });
+            res.statusCode = 204;
+            res.end();
+          } catch (error) {
+            res.statusCode = 400;
+            res.end(
+              error instanceof Error ? error.message : "Bad rename payload"
+            );
+          }
+        });
+      });
+    }
+  };
+}
+
+// vitepress/plugins/getNoteByConfigIdPlugin.ts
+function getNoteByConfigIdPlugin() {
+  return {
+    name: "tnotes-get-note-by-config-id",
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        if (req.url?.startsWith("/__tnotes_get_note?") && req.method === "GET") {
+          try {
+            const url = new URL(req.url, `http://${req.headers.host}`);
+            const configId = url.searchParams.get("configId");
+            if (!configId) {
+              res.statusCode = 400;
+              res.setHeader("Content-Type", "application/json");
+              res.end(
+                JSON.stringify({
+                  success: false,
+                  error: "Missing configId parameter"
+                })
+              );
+              return;
+            }
+            const noteIndexCache = NoteIndexCache.getInstance();
+            if (!noteIndexCache.isInitialized()) {
+              res.statusCode = 503;
+              res.setHeader("Content-Type", "application/json");
+              res.end(
+                JSON.stringify({
+                  success: false,
+                  error: "Service not initialized"
+                })
+              );
+              return;
+            }
+            const noteItem = noteIndexCache.getByConfigId(configId);
+            if (!noteItem) {
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(
+                JSON.stringify({
+                  success: true,
+                  found: false,
+                  data: null
+                })
+              );
+              return;
+            }
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({
+                success: true,
+                found: true,
+                data: {
+                  noteIndex: noteItem.noteIndex,
+                  folderName: noteItem.folderName,
+                  // 构建笔记的完整 URL（包含 README）
+                  url: `/notes/${encodeURIComponent(
+                    noteItem.folderName
+                  )}/README`
+                }
+              })
+            );
+            logger.debug(
+              `\u67E5\u8BE2\u7B14\u8BB0: configId=${configId}, noteIndex=${noteItem.noteIndex}`
+            );
+          } catch (error) {
+            logger.error("\u67E5\u8BE2\u7B14\u8BB0\u5931\u8D25:", error);
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+              })
+            );
+          }
+        } else {
+          next();
+        }
+      });
+    }
+  };
+}
+
+// vitepress/plugins/localSearchReindexPlugin.ts
+import path4 from "path";
+
+// vitepress/plugins/localSearchIndexBuilder.ts
+import MiniSearch from "minisearch";
+import fs2 from "fs/promises";
+import path3 from "path";
+import {
+  createMarkdownRenderer,
+  resolvePages
+} from "vitepress";
+
+// vitepress/plugins/localSearchReindexLogic.ts
+import path2 from "path";
+function slash(value) {
+  return value.replace(/\\/g, "/");
+}
+var NOTE_README_RE = /(?:^|[\\/])notes[\\/](\d{4}\.[^\\/]+)[\\/]README\.md$/i;
+function isNoteReadmePath(filePath, ignoreDirNames = []) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const match = NOTE_README_RE.exec(normalized);
+  if (!match) return false;
+  const folderName = match[1];
+  if (!folderName) return false;
+  return !ignoreDirNames.some((dir) => folderName === dir);
+}
+function getDocIdFromFile(input) {
+  const absoluteFile = path2.isAbsolute(input.absoluteOrRelativeFile) ? input.absoluteOrRelativeFile : path2.join(input.srcDir, input.absoluteOrRelativeFile);
+  let relFile = slash(path2.relative(input.srcDir, absoluteFile));
+  if (input.rewrites?.[relFile]) {
+    relFile = input.rewrites[relFile];
+  }
+  let id = slash(path2.posix.join(input.base, relFile));
+  id = id.replace(/(^|\/)index\.md$/, "$1");
+  id = id.replace(/\.md$/, input.cleanUrls ? "" : ".html");
+  return id;
+}
+
+// vitepress/plugins/localSearchIndexBuilder.ts
+var headingRegex = /<h(\d*).*?>(.*?<a.*? href="#.*?".*?>.*?<\/a>)<\/h\1>/gi;
+var headingContentRegex = /(.*?)<a.*? href="#(.*?)".*?>.*?<\/a>/i;
+function slash2(value) {
+  return value.replace(/\\/g, "/");
+}
+function clearHtmlTags(str) {
+  return str.replace(/<[^>]*>/g, "");
+}
+function getSearchableText(content) {
+  return clearHtmlTags(content);
+}
+function* splitPageIntoSections(html) {
+  const result = html.split(headingRegex);
+  result.shift();
+  let parentTitles = [];
+  for (let i = 0; i < result.length; i += 3) {
+    const level = parseInt(result[i], 10) - 1;
+    const heading = result[i + 1];
+    const headingResult = headingContentRegex.exec(heading);
+    const title = clearHtmlTags(headingResult?.[1] ?? "").trim();
+    const anchor = headingResult?.[2] ?? "";
+    const content = result[i + 2];
+    if (!title || !content) continue;
+    let titles = parentTitles.slice(0, level);
+    titles[level] = title;
+    titles = titles.filter(Boolean);
+    yield { anchor, titles, text: getSearchableText(content) };
+    if (level === 0) {
+      parentTitles = [title];
+    } else {
+      parentTitles[level] = title;
+    }
+  }
+}
+function getLocaleForPath(site, page) {
+  const normalizedPage = slash2(page);
+  for (const [localePath, localeConfig] of Object.entries(site.locales ?? {})) {
+    const prefix = localePath.replace(/\\/g, "/");
+    if (prefix === "root") continue;
+    const normalizedPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+    if (normalizedPage.startsWith(normalizedPrefix)) {
+      return localePath;
+    }
+    if (localeConfig?.lang && normalizedPage === prefix.replace(/\/$/, "")) {
+      return localePath;
+    }
+  }
+  return "root";
+}
+async function createLocalSearchMarkdownRenderer(siteConfig) {
+  return createMarkdownRenderer(
+    siteConfig.srcDir,
+    siteConfig.markdown,
+    siteConfig.site.base,
+    siteConfig.logger
+  );
+}
+async function renderPageHtml(siteConfig, md, absoluteFile) {
+  if (!await fs2.stat(absoluteFile).catch(() => null)) return "";
+  const srcDir = siteConfig.srcDir;
+  const relativePath = slash2(path3.relative(srcDir, absoluteFile));
+  const env = {
+    path: absoluteFile,
+    relativePath,
+    cleanUrls: siteConfig.cleanUrls ?? false,
+    frontmatter: {}
+  };
+  const options = siteConfig.site.themeConfig?.search?.options ?? {};
+  const mdRaw = await fs2.readFile(absoluteFile, "utf-8");
+  if (options._render) {
+    return await options._render(mdRaw, env, md);
+  }
+  const html = md.render(mdRaw, env);
+  return env.frontmatter?.search === false ? "" : html;
+}
+async function indexPage(siteConfig, md, page, index) {
+  const absoluteFile = path3.join(siteConfig.srcDir, page);
+  const fileId = getDocIdFromFile({
+    srcDir: siteConfig.srcDir,
+    base: siteConfig.site.base,
+    cleanUrls: siteConfig.cleanUrls ?? false,
+    rewrites: siteConfig.rewrites.map,
+    absoluteOrRelativeFile: absoluteFile
+  });
+  const html = await renderPageHtml(siteConfig, md, absoluteFile);
+  const sections = splitPageIntoSections(html);
+  for (const section of sections) {
+    if (!section || !(section.text || section.titles)) break;
+    const { anchor, text, titles } = section;
+    const id = anchor ? [fileId, anchor].join("#") : fileId;
+    if (index.has(id)) index.discard(id);
+    index.add({
+      id,
+      text,
+      title: titles[titles.length - 1],
+      titles: titles.slice(0, -1)
+    });
+  }
+}
+async function buildLocalSearchIndexSnapshot(siteConfig, md) {
+  const { pages } = await resolvePages(
+    siteConfig.srcDir,
+    siteConfig.userConfig,
+    siteConfig.logger
+  );
+  const options = siteConfig.site.themeConfig?.search?.options ?? {};
+  const indexByLocale = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const locale = getLocaleForPath(siteConfig.site, page);
+    let index = indexByLocale.get(locale);
+    if (!index) {
+      index = new MiniSearch({
+        fields: ["title", "titles", "text"],
+        storeFields: ["title", "titles"],
+        ...options.miniSearch?.options
+      });
+      indexByLocale.set(locale, index);
+    }
+    await indexPage(siteConfig, md, page, index);
+  }
+  const snapshot = /* @__PURE__ */ new Map();
+  for (const [locale, index] of indexByLocale) {
+    snapshot.set(locale, JSON.stringify(JSON.stringify(index)));
+  }
+  return { snapshot, pageCount: pages.length };
+}
+
+// vitepress/plugins/localSearchReindexPatch.ts
+function patchVPNavBarSearch(code) {
+  if (code.includes("localSearchIndexBridge")) return null;
+  if (!code.includes("VPLocalSearchBox")) return null;
+  let next = code.replace(
+    /<script lang="ts" setup>\r?\n/,
+    `<script lang="ts" setup>
+import { searchBoxRemountKey } from '@tnotesjs/core/vitepress/client/localSearchIndexBridge'
+`
+  );
+  next = next.replace(
+    /<VPLocalSearchBox\r?\n\s+v-if="showSearch"\r?\n\s+@close="showSearch = false"\r?\n\s+\/>/,
+    `<VPLocalSearchBox
+        v-if="showSearch"
+        :key="searchBoxRemountKey"
+        @close="showSearch = false"
+      />`
+  );
+  return next === code ? null : next;
+}
+
+// vitepress/plugins/localSearchReindexPlugin.ts
+var LOCAL_SEARCH_INDEX_REQUEST_PATH = "/@localSearchIndex";
+var LOCAL_SEARCH_INDEX_ID = "@localSearchIndex";
+var SEARCH_REINDEX_HTTP_PATH = "/__tnotes_search_reindex";
+var SEARCH_INDEX_HMR_EVENT = "tnotes:search-index-updated";
+var REBUILD_DEBOUNCE_MS = 400;
+var VP_NAV_BAR_SEARCH = /vitepress[/\\]dist[/\\]client[/\\]theme-default[/\\]components[/\\]VPNavBarSearch\.vue$/;
+var reindexController = null;
+var indexSnapshot = null;
+var snapshotRevision = 0;
+var DEBUG = process.env.TNOTES_DEBUG_SEARCH_REINDEX === "1";
+function debugLog(message, detail) {
+  if (!DEBUG) return;
+  if (detail === void 0) {
+    console.log(`[tnotes:search-reindex] ${message}`);
+    return;
+  }
+  console.log(`[tnotes:search-reindex] ${message}`, detail);
+}
+function logInfo(message) {
+  console.warn(`[tnotes:search-reindex] ${message}`);
+}
+function normalizeId(id) {
+  return id.replace(/\\/g, "/");
+}
+function getVitePressSiteConfig(server) {
+  return server.config.vitepress ?? null;
+}
+function isLocalSearchEnabled(server) {
+  return server.config.plugins.some(
+    (entry) => entry.name === "vitepress:local-search" && typeof entry.load === "function"
+  );
+}
+function normalizeLocalSearchModuleId(id) {
+  return id.split("?")[0];
+}
+function getLocaleFromIndexModuleId(id) {
+  const normalized = normalizeLocalSearchModuleId(id);
+  if (normalized === LOCAL_SEARCH_INDEX_REQUEST_PATH) return null;
+  if (!normalized.startsWith(LOCAL_SEARCH_INDEX_REQUEST_PATH)) return null;
+  return normalized.slice(LOCAL_SEARCH_INDEX_REQUEST_PATH.length) || null;
+}
+function getSearchIndexModuleIds(snapshot) {
+  const ids = [LOCAL_SEARCH_INDEX_REQUEST_PATH];
+  for (const locale of snapshot.keys()) {
+    ids.push(`${LOCAL_SEARCH_INDEX_REQUEST_PATH}${locale}`);
+  }
+  return ids;
+}
+function notifySearchIndexUpdated(server, snapshot, revision) {
+  const moduleIds = getSearchIndexModuleIds(snapshot);
+  const updates = [];
+  for (const moduleId of moduleIds) {
+    server.moduleGraph.onFileChange(moduleId);
+    const mod = server.moduleGraph.getModuleById(moduleId);
+    if (mod) {
+      server.moduleGraph.invalidateModule(mod);
+      updates.push({
+        acceptedPath: mod.url,
+        path: mod.url,
+        timestamp: Date.now(),
+        type: "js-update"
+      });
+      continue;
+    }
+    debugLog(`HMR module not loaded yet: ${moduleId}`);
+  }
+  if (updates.length > 0) {
+    server.ws.send({ type: "update", updates });
+    debugLog("HMR pushed", updates.map((item) => item.path));
+  } else {
+    debugLog("HMR skipped: no loaded search index modules");
+  }
+  server.ws.send({
+    type: "custom",
+    event: SEARCH_INDEX_HMR_EVENT,
+    data: { revision }
+  });
+  debugLog("custom HMR event sent", { revision });
+}
+function renderSnapshotLoad(id, snapshot) {
+  const normalizedId = normalizeLocalSearchModuleId(id);
+  if (normalizedId === LOCAL_SEARCH_INDEX_REQUEST_PATH) {
+    const records = [];
+    for (const locale2 of snapshot.keys()) {
+      records.push(
+        `${JSON.stringify(locale2)}: () => import('${LOCAL_SEARCH_INDEX_ID}${locale2}')`
+      );
+    }
+    return `export default {${records.join(",")}}`;
+  }
+  const locale = getLocaleFromIndexModuleId(id);
+  if (locale !== null) {
+    const payload = snapshot.get(locale) ?? JSON.stringify({});
+    return `export default ${payload}`;
+  }
+  return null;
+}
+function createDebouncer(delayMs) {
+  let timer = null;
+  let pendingReason = "";
+  return (reason, task) => {
+    pendingReason = reason;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(async () => {
+      timer = null;
+      const reasonToRun = pendingReason;
+      pendingReason = "";
+      try {
+        await task();
+      } catch (error) {
+        console.error(
+          `[tnotes:search-reindex] rebuild failed (${reasonToRun})`,
+          error
+        );
+      }
+    }, delayMs);
+  };
+}
+function matchesSearchReindexPath(url) {
+  return url === SEARCH_REINDEX_HTTP_PATH || url.endsWith(SEARCH_REINDEX_HTTP_PATH);
+}
+function scheduleNoteSearchReindex(reason = "external") {
+  if (!reindexController) {
+    logInfo(`schedule ignored (plugin not ready): ${reason}`);
+    return;
+  }
+  reindexController.schedule(reason);
+}
+function localSearchReindexPlugin() {
+  return {
+    name: "tnotes-local-search-reindex",
+    apply: "serve",
+    enforce: "pre",
+    resolveId(source) {
+      if (!source.startsWith(LOCAL_SEARCH_INDEX_ID)) return null;
+      const clean = source.split("?")[0];
+      if (clean === source) return null;
+      return `/${clean}`;
+    },
+    transform(code, id) {
+      const normalizedId = normalizeId(id);
+      if (VP_NAV_BAR_SEARCH.test(normalizedId)) {
+        return patchVPNavBarSearch(code);
+      }
+      return null;
+    },
+    load(id) {
+      if (!indexSnapshot || !id.startsWith(LOCAL_SEARCH_INDEX_REQUEST_PATH)) {
+        return null;
+      }
+      return renderSnapshotLoad(id, indexSnapshot);
+    },
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        const url = req.url ?? "";
+        if (!matchesSearchReindexPath(url) || req.method !== "POST") {
+          return next();
+        }
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const data = JSON.parse(body || "{}");
+            scheduleNoteSearchReindex(data.reason || "bridge:http");
+            res.statusCode = 204;
+            res.end();
+          } catch (error) {
+            res.statusCode = 400;
+            res.end(
+              error instanceof Error ? error.message : "Bad search reindex payload"
+            );
+          }
+        });
+      });
+      return async () => {
+        indexSnapshot = null;
+        snapshotRevision = 0;
+        if (!isLocalSearchEnabled(server)) {
+          reindexController = null;
+          logInfo("vitepress:local-search not found, reindex disabled");
+          return;
+        }
+        const siteConfig = getVitePressSiteConfig(server);
+        if (!siteConfig) {
+          reindexController = null;
+          logInfo("server.config.vitepress missing, reindex disabled");
+          return;
+        }
+        ConfigManager.init({ rootPath: process.cwd() });
+        const ignoreDirNames = ConfigManager.getInstance().getAll().ignore_dirs ?? [];
+        const md = await createLocalSearchMarkdownRenderer(siteConfig);
+        const debouncedRebuild = createDebouncer(REBUILD_DEBOUNCE_MS);
+        async function rebuildFullIndex(reason) {
+          const startedAt = Date.now();
+          snapshotRevision += 1;
+          debugLog(`rebuild start (${reason}) rev=${snapshotRevision}`);
+          const { snapshot, pageCount } = await buildLocalSearchIndexSnapshot(
+            siteConfig,
+            md
+          );
+          indexSnapshot = snapshot;
+          notifySearchIndexUpdated(server, indexSnapshot, snapshotRevision);
+          logInfo(
+            `rebuild done (${reason}) rev=${snapshotRevision} pages=${pageCount} locales=${indexSnapshot.size} elapsed=${Date.now() - startedAt}ms`
+          );
+        }
+        reindexController = {
+          schedule(reason) {
+            debugLog(`scheduled (${reason})`);
+            debouncedRebuild(reason, () => rebuildFullIndex(reason));
+          }
+        };
+        const onWatcherEvent = (absoluteFile, event) => {
+          if (!isNoteReadmePath(absoluteFile, ignoreDirNames)) return;
+          scheduleNoteSearchReindex(
+            `watcher:${event}:${path4.basename(absoluteFile)}`
+          );
+        };
+        server.watcher.on("add", (file) => onWatcherEvent(file, "add"));
+        server.watcher.on("change", (file) => onWatcherEvent(file, "change"));
+        server.watcher.on("unlink", (file) => onWatcherEvent(file, "unlink"));
+      };
+    }
+  };
+}
+
+// vitepress/plugins/renameNotePlugin.ts
+function renameNotePlugin() {
+  const renameCommand = new RenameNoteCommand();
+  return {
+    name: "tnotes-rename-note",
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        if (req.url === "/__tnotes_rename_note" && req.method === "POST") {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", async () => {
+            try {
+              const { noteIndex, newTitle } = JSON.parse(body);
+              if (!noteIndex || !newTitle) {
+                res.statusCode = 400;
+                res.end("Missing noteIndex or newTitle");
+                return;
+              }
+              const startTime = Date.now();
+              await renameCommand.renameNote({ noteIndex, newTitle });
+              const duration = Date.now() - startTime;
+              const newFolderName = `${noteIndex}. ${newTitle.trim()}`;
+              const newUrl = `/notes/${encodeURIComponent(
+                newFolderName
+              )}/README`;
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(
+                JSON.stringify({
+                  success: true,
+                  duration,
+                  newTitle,
+                  newFolderName,
+                  newUrl,
+                  message: "\u91CD\u547D\u540D\u5B8C\u6210"
+                })
+              );
+            } catch (error) {
+              res.statusCode = 500;
+              res.end(error instanceof Error ? error.message : "Rename failed");
+            }
+          });
+        } else {
+          next();
+        }
+      });
+    }
+  };
+}
+
+// vitepress/plugins/sidebarStructurePlugin.ts
+async function readJsonBody(req) {
+  let body = "";
+  await new Promise((resolve, reject) => {
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", resolve);
+    req.on("error", reject);
+  });
+  return body ? JSON.parse(body) : {};
+}
+function sendJson(res, statusCode, payload) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+function normalizePathname(url) {
+  return (url || "").split("?")[0];
+}
+function normalizeCount(value) {
+  const count = Number(value ?? 1);
+  if (!Number.isInteger(count) || count < 1 || count > 100) {
+    throw new Error("count must be an integer between 1 and 100");
+  }
+  return count;
+}
+function getCreatedNotePayload(notes) {
+  return notes.map((note) => ({
+    index: note.index,
+    dirName: note.dirName,
+    link: `/notes/${encodeURIComponent(note.dirName)}/README`
+  }));
+}
+function buildNoteReadmeLink(note) {
+  return `/notes/${encodeURIComponent(note.dirName)}/README`;
+}
+function resolveDeleteRedirectUrl(noteService, previousNoteIndex) {
+  if (!previousNoteIndex) return "/";
+  const previousNote = noteService.getNoteByIndex(previousNoteIndex);
+  if (!previousNote) return "/";
+  return buildNoteReadmeLink(previousNote);
+}
+async function withSuspendedWatcher(task) {
+  const watcher = FileWatcherService.getInstance();
+  try {
+    watcher?.suspend();
+    return await task();
+  } finally {
+    watcher?.unsuspend();
+  }
+}
+function sidebarStructurePlugin() {
+  const noteService = NoteService.getInstance();
+  const tocService = TocService.getInstance();
+  async function createNotes(count) {
+    const notes = [];
+    const usedIndexes = /* @__PURE__ */ new Set();
+    for (const note of noteService.getAllNotes()) {
+      const index = parseInt(note.index, 10);
+      if (!isNaN(index)) {
+        usedIndexes.add(index);
+      }
+    }
+    for (let i = 0; i < count; i++) {
+      const note = await noteService.createNote({
+        title: "new",
+        usedIndexes
+      });
+      const index = parseInt(note.index, 10);
+      if (!isNaN(index)) {
+        usedIndexes.add(index);
+      }
+      notes.push(note);
+    }
+    return notes;
+  }
+  async function refreshTocAndSidebar() {
+    await tocService.regenerateSidebar();
+  }
+  return {
+    name: "tnotes-sidebar-structure",
+    configureServer(server) {
+      server.middlewares.use(async (req, res, next) => {
+        const pathname = normalizePathname(req.url);
+        const handledPaths = /* @__PURE__ */ new Set([
+          "/__tnotes_sidebar_create_note",
+          "/__tnotes_sidebar_create_notes",
+          "/__tnotes_sidebar_create_folder",
+          "/__tnotes_sidebar_delete_note",
+          "/__tnotes_sidebar_delete_entry",
+          "/__tnotes_sidebar_rename_folder",
+          "/__tnotes_sidebar_reorder"
+        ]);
+        if (!handledPaths.has(pathname)) {
+          next();
+          return;
+        }
+        if (req.method !== "POST") {
+          sendJson(res, 405, { success: false, message: "Method Not Allowed" });
+          return;
+        }
+        try {
+          const data = await readJsonBody(req);
+          const result = await withSuspendedWatcher(async () => {
+            if (pathname === "/__tnotes_sidebar_delete_note") {
+              const noteIndex = String(data.noteIndex || "");
+              if (!noteIndex) throw new Error("Missing noteIndex");
+              const previousNoteIndex = await tocService.getPreviousNoteIndexBeforeDelete(noteIndex);
+              await tocService.deleteNoteFromToc(noteIndex);
+              await noteService.deleteNote(noteIndex);
+              await refreshTocAndSidebar();
+              scheduleNoteSearchReindex("api:delete-note");
+              return {
+                success: true,
+                sidebarChanged: true,
+                redirectUrl: resolveDeleteRedirectUrl(
+                  noteService,
+                  previousNoteIndex
+                ),
+                redirectNoteIndex: previousNoteIndex,
+                deletedNoteIndexes: [noteIndex],
+                message: "\u7B14\u8BB0\u5DF2\u5220\u9664"
+              };
+            }
+            if (pathname === "/__tnotes_sidebar_delete_entry") {
+              const tocLineIndex = Number(data.tocLineIndex);
+              if (!Number.isInteger(tocLineIndex) || tocLineIndex < 0) {
+                throw new Error("Missing tocLineIndex");
+              }
+              const currentNoteIndex = String(data.currentNoteIndex || "");
+              const previousNoteIndex = await tocService.getPreviousNoteIndexBeforeEntryDelete(
+                tocLineIndex
+              );
+              const inSubtree = currentNoteIndex && await tocService.isNoteInTocEntrySubtree(
+                tocLineIndex,
+                currentNoteIndex
+              );
+              const deletedNoteIndexes = await tocService.deleteTocEntryCascade(tocLineIndex);
+              await refreshTocAndSidebar();
+              scheduleNoteSearchReindex("api:delete-entry");
+              return {
+                success: true,
+                sidebarChanged: true,
+                redirectUrl: inSubtree ? resolveDeleteRedirectUrl(noteService, previousNoteIndex) : void 0,
+                redirectNoteIndex: inSubtree ? previousNoteIndex : null,
+                deletedNoteIndexes,
+                message: "\u5DF2\u5220\u9664"
+              };
+            }
+            if (pathname === "/__tnotes_sidebar_rename_folder") {
+              const tocLineIndex = Number(data.tocLineIndex);
+              const newTitle = String(data.newTitle || "");
+              if (!Number.isInteger(tocLineIndex) || tocLineIndex < 0) {
+                throw new Error("Missing tocLineIndex");
+              }
+              await tocService.renameFolderInToc(tocLineIndex, newTitle);
+              await refreshTocAndSidebar();
+              return {
+                success: true,
+                sidebarChanged: true,
+                message: "\u76EE\u5F55\u5DF2\u91CD\u547D\u540D"
+              };
+            }
+            if (pathname === "/__tnotes_sidebar_reorder") {
+              if (data.node_uuid && data.action === "prependChild" && !data.target_uuid) {
+                await tocService.prependToRootByNodeId(String(data.node_uuid));
+                await refreshTocAndSidebar();
+                return {
+                  success: true,
+                  sidebarChanged: true,
+                  message: "\u6392\u5E8F\u5DF2\u66F4\u65B0"
+                };
+              }
+              if (data.node_uuid && data.target_uuid && (data.action === "moveAfter" || data.action === "prependChild")) {
+                if (data.action === "moveAfter") {
+                  await tocService.moveAfterByNodeId(
+                    String(data.node_uuid),
+                    String(data.target_uuid)
+                  );
+                } else {
+                  await tocService.prependChildByNodeId(
+                    String(data.node_uuid),
+                    String(data.target_uuid)
+                  );
+                }
+                await refreshTocAndSidebar();
+                return {
+                  success: true,
+                  sidebarChanged: true,
+                  message: "\u6392\u5E8F\u5DF2\u66F4\u65B0"
+                };
+              }
+              const dragTocLineIndex = Number(data.dragTocLineIndex);
+              if (!Number.isInteger(dragTocLineIndex) || dragTocLineIndex < 0) {
+                throw new Error("Missing dragTocLineIndex");
+              }
+              const placement = data.targetType === "group" || data.placement === "inside" ? "inside" : data.placement === "after" ? "after" : "before";
+              if (data.targetTocLineIndex !== void 0 && data.targetTocLineIndex !== null) {
+                await tocService.moveTocEntryByLineIndex(dragTocLineIndex, {
+                  targetTocLineIndex: Number(data.targetTocLineIndex),
+                  placement
+                });
+              } else if (Array.isArray(data.targetFolderPath) && data.targetFolderPath.length > 0) {
+                await tocService.moveTocEntryByLineIndex(dragTocLineIndex, {
+                  targetType: "folder",
+                  targetFolderPath: data.targetFolderPath.map(String),
+                  placement
+                });
+              } else {
+                const targetNoteIndex = String(
+                  data.targetNoteIndex || data.targetGroupNoteIndex || ""
+                );
+                if (!targetNoteIndex) throw new Error("Missing targetNoteIndex");
+                await tocService.moveTocEntryByLineIndex(dragTocLineIndex, {
+                  targetType: "note",
+                  targetNoteIndex,
+                  placement
+                });
+              }
+              await refreshTocAndSidebar();
+              return {
+                success: true,
+                sidebarChanged: true,
+                message: "\u6392\u5E8F\u5DF2\u66F4\u65B0"
+              };
+            }
+            if (pathname === "/__tnotes_sidebar_create_folder") {
+              const parentTocLineIndex = Number(data.parentTocLineIndex);
+              const title = String(data.title || "");
+              if (!Number.isInteger(parentTocLineIndex) || parentTocLineIndex < 0) {
+                throw new Error("Missing parentTocLineIndex");
+              }
+              await tocService.insertFolderUnderParent(
+                parentTocLineIndex,
+                title
+              );
+              await refreshTocAndSidebar();
+              return {
+                success: true,
+                sidebarChanged: true,
+                message: "\u76EE\u5F55\u5DF2\u521B\u5EFA"
+              };
+            }
+            const count = normalizeCount(data.count);
+            const notes = await createNotes(count);
+            if (data.targetNoteIndex) {
+              const placement = data.placement === "after" ? "after" : "before";
+              await tocService.insertNotesAroundNote(
+                String(data.targetNoteIndex),
+                notes,
+                placement
+              );
+            } else if (data.parentTocLineIndex !== void 0 && data.parentTocLineIndex !== null) {
+              await tocService.insertNotesUnderTocLine(
+                Number(data.parentTocLineIndex),
+                notes
+              );
+            } else if (Array.isArray(data.parentFolderPath) && data.parentFolderPath.length > 0) {
+              await tocService.insertNotesUnderFolder(
+                data.parentFolderPath.map(String),
+                notes
+              );
+            } else if (data.parentNoteIndex) {
+              await tocService.insertNotesUnderParent(
+                String(data.parentNoteIndex),
+                notes
+              );
+            } else {
+              for (const note of notes) {
+                await tocService.appendNoteToToc(note.index);
+              }
+            }
+            await refreshTocAndSidebar();
+            scheduleNoteSearchReindex("api:create-notes");
+            return {
+              success: true,
+              sidebarChanged: true,
+              createdNotes: getCreatedNotePayload(notes),
+              message: "\u7B14\u8BB0\u5DF2\u521B\u5EFA"
+            };
+          });
+          sendJson(res, 200, result);
+        } catch (error) {
+          console.error("\u4FA7\u8FB9\u680F\u7ED3\u6784\u64CD\u4F5C\u5931\u8D25:", error);
+          sendJson(res, 500, {
+            success: false,
+            message: error instanceof Error ? error.message : String(error)
+          });
+        }
+      });
+    }
+  };
+}
+
+// vitepress/plugins/updateConfigPlugin.ts
+function updateConfigPlugin() {
+  let updateCommand;
+  return {
+    name: "tnotes-update-config",
+    configureServer(server) {
+      updateCommand = new UpdateNoteConfigCommand();
+      server.middlewares.use(async (req, res, next) => {
+        if (req.url === "/__tnotes_update_config" && req.method === "POST") {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", async () => {
+            try {
+              const data = JSON.parse(body);
+              const { noteIndex, config } = data;
+              if (!noteIndex || !config) {
+                res.statusCode = 400;
+                res.end("Missing noteIndex or config");
+                return;
+              }
+              await updateCommand.updateConfig({
+                noteIndex,
+                config: {
+                  done: config.done,
+                  enableDiscussions: config.enableDiscussions,
+                  description: config.description
+                }
+              });
+              res.statusCode = 200;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ success: true }));
+            } catch (error) {
+              console.error("\u66F4\u65B0\u914D\u7F6E\u5931\u8D25:", error);
+              res.statusCode = 500;
+              res.end(error instanceof Error ? error.message : String(error));
+            }
+          });
+        } else {
+          next();
+        }
+      });
+    }
+  };
+}
+
+// vitepress/config/index.ts
+function defineNotesConfig(overrides = {}) {
+  const rootPath = process.cwd();
+  ConfigManager.init({ rootPath });
+  const config = ConfigManager.getInstance().getAll();
+  const { repoName } = config;
+  const IGNORE_LIST = getIgnoreList(config);
+  const GITHUB_PAGE_URL = getGithubPageUrl(config);
+  const {
+    transformPageData: overrideTransformPageData,
+    vite: overrideVite,
+    ...restOverrides
+  } = overrides;
+  return defineConfig({
+    appearance: "dark",
+    base: "/" + repoName + "/",
+    cleanUrls: true,
+    description: repoName,
+    head: getHeadConfig(config, GITHUB_PAGE_URL),
+    ignoreDeadLinks: true,
+    lang: "zh-Hans",
+    lastUpdated: false,
+    markdown: getMarkdownConfig(),
+    sitemap: {
+      hostname: GITHUB_PAGE_URL,
+      lastmodDateOnly: false
+    },
+    themeConfig: getThemeConfig(config),
+    title: repoName,
+    srcExclude: IGNORE_LIST,
+    vite: {
+      plugins: [
+        buildProgressPlugin(),
+        updateConfigPlugin(),
+        renameNotePlugin(),
+        sidebarStructurePlugin(),
+        getNoteByConfigIdPlugin(),
+        fileWatcherBridgePlugin(),
+        localSearchReindexPlugin(),
+        ...overrideVite?.plugins || []
+      ],
+      server: {
+        // 显式同时监听 IPv4 / IPv6，避免 Node 18+ 在 Windows 下偶发只绑定 ::1
+        // 导致 Chrome 解析 localhost → 127.0.0.1 时连接被拒、页面一直 pending。
+        // host: true,
+        watch: {
+          ignored: IGNORE_LIST
+        },
+        ...overrideVite?.server
+      },
+      css: {
+        preprocessorOptions: {
+          scss: {
+            silenceDeprecations: ["legacy-js-api"]
+          }
+        },
+        ...overrideVite?.css
+      },
+      build: {
+        chunkSizeWarningLimit: 1e3,
+        ...overrideVite?.build
+      },
+      define: {
+        __TNOTES_REPO_NAME__: JSON.stringify(config.repoName),
+        __TNOTES_AUTHOR__: JSON.stringify(config.author),
+        __TNOTES_IGNORE_DIRS__: JSON.stringify(config.ignore_dirs),
+        __TNOTES_ROOT_ITEM__: JSON.stringify(config.root_item),
+        ...overrideVite?.define
+      },
+      resolve: {
+        dedupe: ["vue", "vitepress"],
+        ...overrideVite?.resolve
+      },
+      optimizeDeps: {
+        include: [
+          // VitePress 内部 CJS 依赖 —— 需要 Vite 预构建为 ESM
+          "vitepress > @vscode/markdown-it-katex",
+          "vitepress > @braintree/sanitize-url",
+          "vitepress > dayjs",
+          "vitepress > dayjs/plugin/utc",
+          "vitepress > dayjs/plugin/localizedFormat"
+        ],
+        ...overrideVite?.optimizeDeps
+      }
+    },
+    transformPageData(pageData, ctx) {
+      if (/^notes\/\d{4}/.test(pageData.relativePath)) {
+        const fullPath = path5.resolve(rootPath, pageData.relativePath);
+        try {
+          const raw = fs3.readFileSync(fullPath, "utf-8");
+          pageData.frontmatter.rawContent = Buffer.from(raw, "utf-8").toString(
+            "base64"
+          );
+        } catch {
+          pageData.frontmatter.rawContent = null;
+        }
+      }
+      if (typeof overrideTransformPageData === "function") {
+        return overrideTransformPageData(pageData, ctx);
+      }
+    },
+    router: {
+      prefetchLinks: false
+    },
+    ...restOverrides
+  });
+}
+export {
+  defineNotesConfig
+};