hd-garden 0.13.2 → 0.13.3

package/app/components/MarkdownArticle.tsx

@@ -5,12 +5,11 @@ import { remarkA2 } from "../lib/remark-a2.mjs";
 import { remarkLinkCard } from "../lib/remark-link-card.mjs";
 import {
   Children,
-  cloneElement,
   isValidElement,
   type HTMLAttributes,
   type ReactNode,
 } from "react";
-import { articleHeadingBase, autoNumbersHeadings, displayHeadingLevel, splitHeadingNumber } from "../lib/content";
+import { articleHeadingBase, displayHeadingLevel } from "../lib/content";
 import Link from "next/link";
 import ReactMarkdown from "react-markdown";
 import rehypeRaw from "rehype-raw";
@@ -150,31 +149,7 @@ function CodeBlock({
   );
 }
 
-function stripPrefix(children: ReactNode, prefix: string): ReactNode {
-  let rest = prefix;
-  const walk = (node: ReactNode): ReactNode => {
-    if (!rest) return node;
-    if (typeof node === "string" || typeof node === "number") {
-      const value = String(node);
-      if (value.startsWith(rest)) {
-        const kept = value.slice(rest.length);
-        rest = "";
-        return kept;
-      }
-      if (rest.startsWith(value)) {
-        rest = rest.slice(value.length);
-        return "";
-      }
-      return value;
-    }
-    if (Array.isArray(node)) return node.map(walk);
-    if (isValidElement<{ children?: ReactNode }>(node)) {
-      return cloneElement(node, undefined, walk(node.props.children));
-    }
-    return node;
-  };
-  return walk(children);
-}
+
 
 
 /**
@@ -227,36 +202,18 @@ const headingText = (children: ReactNode) => {
   return parts.join("");
 };
 
-export function MarkdownArticle({ content, numbering, lang, fieldTables, refDemos, handbook }: { content: string; numbering?: boolean; lang?: UiLang; fieldTables?: boolean; refDemos?: boolean; handbook?: boolean }) {
+export function MarkdownArticle({ content, lang, fieldTables, refDemos, handbook }: { content: string; numbering?: boolean; lang?: UiLang; fieldTables?: boolean; refDemos?: boolean; handbook?: boolean }) {
   const internalRoute = handbook ? handbookRoute : siteRoute;
   const t = ui(lang);
   // Optional layer 2: a Worker that refreshes card text. Without it, cards stay as built.
   const cardWorker = content.includes("{card}") ? siteConfig.linkPreview?.worker : undefined;
-  const numbers = { h2: 0, h3: 0 };
-  const autoNumber = autoNumbersHeadings(content, numbering);
   const headingBase = articleHeadingBase(content);
-  const section = (depth: 2 | 3, children: ReactNode) => {
-    const raw = headingText(children).trim();
-    const split = splitHeadingNumber(raw);
-    if (split) {
-      if (depth === 2) { numbers.h2 += 1; numbers.h3 = 0; }
-      else numbers.h3 += 1;
-      const prefix = raw.slice(0, raw.length - split.text.length);
-      return { no: split.no, children: stripPrefix(children, prefix) };
-    }
-    if (!autoNumber) return { no: "", children };
-    if (depth === 2) { numbers.h2 += 1; numbers.h3 = 0; return { no: String(numbers.h2), children }; }
-    numbers.h3 += 1;
-    return { no: numbers.h2 ? `${numbers.h2}.${numbers.h3}` : String(numbers.h3), children };
-  };
   const heading = (source: 2 | 3 | 4, children: ReactNode, props: HTMLAttributes<HTMLHeadingElement> & { node?: unknown }) => {
     const level = displayHeadingLevel(source, headingBase);
     const Tag = level === 2 ? "h2" : level === 3 ? "h3" : "h4";
     const domProps = { ...props };
     Reflect.deleteProperty(domProps, "node");
-    if (level > 3) return <Tag {...domProps}>{children}</Tag>;
-    const sectioned = section(level as 2 | 3, children);
-    return <Tag {...domProps}>{sectioned.no ? <span className="sec-no">{sectioned.no}</span> : null}{sectioned.children}</Tag>;
+    return <Tag {...domProps}>{children}</Tag>;
   };
   const gardenComponents = {
     "garden-linkcard": (props: Record<string, string | undefined>) => (

package/app/components/TableOfContents.tsx

@@ -365,7 +365,6 @@ export function TableOfContents({
             onFocus={() => prefetchHeadingLayout(node.id)}
             aria-current={activeId === node.id ? "location" : undefined}
           >
-            {node.no ? <span className="t-no">{node.no}</span> : null}
             {node.text}
           </a>
           {node.children.length > 0 ? (

package/app/lib/content.ts

@@ -80,39 +80,22 @@ export { splitHeadingNumber };
  * Parses the same Markdown heading text that ReactMarkdown sends to
  * rehype-slug. Every heading depth advances the slugger so headings outside
  * the H2-H5 TOC range cannot shift the IDs shown in the directory.
- * `no` follows the prototype: keep an author-written number, otherwise
- * auto-number h2/h3 only when the article has no numbered headings and its
- * front matter does not say `numbering: false`.
+ * Heading text is literal: no synthetic numbers and no extraction of authored numbers.
  */
-export const extractHeadings = (markdown: string, { numbering }: { numbering?: boolean } = {}) => {
+export const extractHeadings = (markdown: string, _options: { numbering?: boolean } = {}) => {
+  // Accept the legacy option without changing authored heading text.
+  void _options;
   const slugger = new GithubSlugger();
-  const autoNumber = autoNumbersHeadings(markdown, numbering);
   const base = articleHeadingBase(markdown);
   const headings: Array<{ depth: number; text: string; id: string; no?: string }> = [];
   const tree = unified().use(remarkParse).use(markdownPlugins).parse(markdown);
-  let h2 = 0;
-  let h3 = 0;
 
   visit(tree, "heading", (node) => {
     const raw = toString(node).trim();
     const id = slugger.slug(raw);
     if (!(raw && node.depth >= 2 && node.depth <= 5)) return;
     const level = displayHeadingLevel(node.depth, base);
-    let text = raw;
-    let no: string | undefined;
-    if (level === 2 || level === 3) {
-      const split = splitHeadingNumber(raw);
-      if (split) {
-        no = split.no;
-        text = split.text;
-        if (level === 2) { h2 += 1; h3 = 0; }
-        else h3 += 1;
-      } else if (autoNumber) {
-        if (level === 2) { h2 += 1; h3 = 0; no = String(h2); }
-        else { h3 += 1; no = h2 ? `${h2}.${h3}` : String(h3); }
-      }
-    }
-    headings.push({ depth: level, text, id, ...(no ? { no } : {}) });
+    headings.push({ depth: level, text: raw, id });
   });
 
   return headings;

package/app/lib/heading-number.ts

@@ -13,10 +13,5 @@ const NUMBERED_ARTICLE = /^#{2,3}[ \t]+\d/m;
 /** True when the article writes its own section numbers (`## 2. …`). */
 export const articleUsesHeadingNumbers = (markdown: string) => NUMBERED_ARTICLE.test(markdown);
 
-/**
- * Whether h2/h3 get automatic numbers. Off when the author writes numbers, or
- * when the front matter says `numbering: false`. Author-written numbers are
- * always kept.
- */
-export const autoNumbersHeadings = (markdown: string, numbering?: boolean) =>
-  numbering !== false && !articleUsesHeadingNumbers(markdown);
+/** Compatibility export: headings are now always rendered literally. */
+export const autoNumbersHeadings = () => false;

package/bin/garden.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { randomBytes } from "node:crypto";
 import { spawnSync } from "node:child_process";
+import { startDev } from "../scripts/dev-server.mjs";
 import fs from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
@@ -312,12 +313,19 @@ function ensureDevGitHubLogin() {
   if (!/^GITHUB_SESSION_SECRET=\S+/m.test(text)) {
     text = upsertEnv(text, "GITHUB_SESSION_SECRET", randomBytes(32).toString("base64url"));
   }
-  fs.writeFileSync(local, text.endsWith("\n") ? text : `${text}\n`);
+  const next = text.endsWith("\n") ? text : `${text}\n`;
+  if (!fs.existsSync(local) || fs.readFileSync(local, "utf8") !== next) fs.writeFileSync(local, next);
 }
 
 async function runVinext(vinextArgs, { copyDist = false } = {}) {
-  await sync();
   const cwd = vinextRoot();
+  if (vinextArgs[0] === "dev") {
+    const { finished } = await startDev({ cwd, executable: resolveVinext(), args: vinextArgs.slice(1), env: siteEnv(), prepare: sync });
+    const result = await finished;
+    if (result.status !== 0) process.exit(result.status || 1);
+    return;
+  }
+  await sync();
   const result = spawnSync(process.execPath, [resolveVinext(), ...vinextArgs], {
     cwd,
     env: siteEnv(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hd-garden",
-  "version": "0.13.2",
+  "version": "0.13.3",
   "private": false,
   "description": "\u7528 Markdown \u5199\u4f5c\u3001\u7528 GitHub Pages \u53d1\u5e03\u7684\u4e2a\u4eba\u535a\u5ba2\u5f15\u64ce\u3002",
   "license": "MIT",

package/scripts/build-content.mjs

@@ -1,5 +1,13 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
+
+// Preserve mtimes of unchanged generated output to avoid dev reload storms.
+function writeChanged(file, value) {
+  const next = Buffer.isBuffer(value) ? value : Buffer.from(value);
+  if (fs.existsSync(file) && fs.readFileSync(file).equals(next)) return;
+  fs.writeFileSync(file, next);
+}
+
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import matter from "gray-matter";
@@ -201,7 +209,7 @@ function copyLocalAsset(value, markdownPath, sourcePath, options = {}) {
       .join(path.sep)}${extension.toLowerCase()}`;
     const destination = path.join(generatedMediaRoot, safeRelative);
     fs.mkdirSync(path.dirname(destination), { recursive: true });
-    fs.copyFileSync(absoluteSource, destination);
+    writeChanged(destination, fs.readFileSync(absoluteSource));
     const url = `${basePath}/media/${safeRelative.split(path.sep).map(encodeURIComponent).join("/")}`;
     assetCache.set(absoluteSource, url);
     assetFiles.set(url, { source: absoluteSource, destination });
@@ -363,7 +371,7 @@ function resolveFileEntry(file, markdownPath, sourcePath, options = {}) {
     const { content } = matter(fs.readFileSync(resolved.path, "utf8"));
     const html = renderFilePreview(rewriteMarkdownAssets(content.trim(), resolved.path, sourcePath, assetOptions), { lang });
     const { destination } = assetFiles.get(url.split(/[?#]/u, 1)[0]);
-    fs.writeFileSync(previewFileName(destination), previewDocument(html, { title: entry.title, lang, icon: previewIcon() }));
+    writeChanged(previewFileName(destination), previewDocument(html, { title: entry.title, lang, icon: previewIcon() }));
     next.previewSrc = previewFileName(url.split(/[?#]/u, 1)[0]);
   }
   return next;
@@ -748,7 +756,10 @@ function readHandbookDocs() {
   return walk(handbookRoot).sort((a, b) => a.order - b.order || a.path.localeCompare(b.path));
 }
 
-fs.rmSync(generatedMediaRoot, { recursive: true, force: true });
+// Keep existing preview assets while regenerating; deleting the whole tree
+// triggers browser reloads before validation finishes (and destroys last-good
+// output on an invalid save). Public builds still clean stale assets.
+if (uiMode !== "preview") fs.rmSync(generatedMediaRoot, { recursive: true, force: true });
 
 const posts = readMarkdownTree(path.join(contentRoot, "posts"), "post").sort(
   (a, b) => Date.parse(b.date) - Date.parse(a.date),
@@ -924,9 +935,9 @@ export const imageSizes: Record<string, { width: number; height: number }> = ${J
 `;
 
 fs.mkdirSync(path.dirname(output), { recursive: true });
-fs.writeFileSync(output, source);
+writeChanged(output, source);
 const fullIndex = buildFullIndex({ posts, columns, thoughts });
-fs.writeFileSync(
+writeChanged(
   siteConfigOutput,
   `// Generated by garden sync. Edit site.config.yaml instead.
 export const siteConfig = ${JSON.stringify(siteConfig, null, 2)} as const;
@@ -942,11 +953,11 @@ export const siteLinks = ${JSON.stringify({ address: siteAddress, basePath, trai
 `,
 );
 fs.mkdirSync(path.join(root, "public"), { recursive: true });
-fs.writeFileSync(path.join(root, "public", "search-index.json"), JSON.stringify(buildSearchIndex({ posts, columns, thoughts }, { lang: siteLang })));
+writeChanged(path.join(root, "public", "search-index.json"), JSON.stringify(buildSearchIndex({ posts, columns, thoughts }, { lang: siteLang })));
 for (const name of fs.readdirSync(path.join(root, "public"))) {
   if (/^search-full\.[0-9a-f]+\.json$/u.test(name) && name !== fullIndex.fileName) fs.rmSync(path.join(root, "public", name));
 }
-fs.writeFileSync(path.join(root, "public", fullIndex.fileName), fullIndex.json);
+writeChanged(path.join(root, "public", fullIndex.fileName), fullIndex.json);
 
 const escapeXml = (value) =>
   value
@@ -988,7 +999,7 @@ function writeRssFeed(fileName, entries) {
       <content:encoded><![CDATA[${cdata(marked.parse(contentForFeed(entry.content, { pageUrl: `${publicBaseUrl}${entry.path}`, siteUrl: publicBaseUrl })))}]]></content:encoded>
     </item>`).join("");
 
-  fs.writeFileSync(path.join(publicRoot, fileName), `<?xml version="1.0" encoding="UTF-8" ?>
+  writeChanged(path.join(publicRoot, fileName), `<?xml version="1.0" encoding="UTF-8" ?>
 <rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
   <channel>
     <title>${escapeXml(siteName)}</title>
@@ -1019,16 +1030,16 @@ const sitemapEntries = [
   ].map(pageAddress)),
 ];
 // Card URLs in published entries: the only pages the link-card Worker may read.
-fs.writeFileSync(
+writeChanged(
   path.join(publicRoot, "link-allowlist.json"),
   `${JSON.stringify({ urls: [...new Set([...posts, ...columns, ...thoughts].flatMap((entry) => cardUrls(entry.content)))].sort() }, null, 2)}\n`,
 );
-fs.writeFileSync(path.join(publicRoot, "sitemap.xml"), `<?xml version="1.0" encoding="UTF-8" ?>
+writeChanged(path.join(publicRoot, "sitemap.xml"), `<?xml version="1.0" encoding="UTF-8" ?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${sitemapEntries.map((entry) => `
   <url><loc>${escapeXml(`${publicBaseUrl}${entry}`)}</loc></url>`).join("")}
 </urlset>
 `);
-fs.writeFileSync(path.join(publicRoot, "robots.txt"), `User-agent: *\nAllow: /\nSitemap: ${publicBaseUrl}/sitemap.xml\n`);
+writeChanged(path.join(publicRoot, "robots.txt"), `User-agent: *\nAllow: /\nSitemap: ${publicBaseUrl}/sitemap.xml\n`);
 console.log(
   `Synced ${posts.length} posts, ${columns.length} column entries, and ${thoughts.length} thoughts (${contentHash}).`,
 );

package/scripts/dev-server.mjs

@@ -0,0 +1,114 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync, spawn } from "node:child_process";
+import net from "node:net";
+import { setTimeout as delay } from "node:timers/promises";
+
+const alive = (pid) => {
+  if (!Number.isInteger(pid) || pid <= 1) return false;
+  try { process.kill(pid, 0); return true; } catch (error) { return error.code !== "ESRCH"; }
+};
+const read = (file) => {
+  try { return JSON.parse(fs.readFileSync(file, "utf8")); }
+  catch (error) { if (error.code === "ENOENT") return null; throw error; }
+};
+const ps = (pid, field) => execFileSync("ps", ["-p", String(pid), "-o", `${field}=`], { encoding: "utf8", env: { ...process.env, LC_ALL: "C" } }).trim();
+function identity(pid, executable) {
+  if (process.platform !== "linux" && process.platform !== "darwin") throw new Error("Automatic dev replacement requires Linux or macOS process inspection.");
+  if (Number(ps(pid, "uid")) !== process.getuid()) throw new Error("Dev process belongs to another user; nothing was stopped.");
+  const start = Date.parse(ps(pid, "lstart"));
+  let cwd;
+  let matches;
+  if (process.platform === "linux") {
+    cwd = fs.realpathSync(`/proc/${pid}/cwd`);
+    const args = fs.readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0");
+    matches = args[1] === executable && args[2] === "dev";
+  } else {
+    const entries = execFileSync("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], { encoding: "utf8" });
+    cwd = fs.realpathSync(entries.split("\n").find((line) => line.startsWith("n"))?.slice(1) ?? "");
+    const command = ps(pid, "command");
+    // Exact script path and subcommand, not a substring such as `node -e ...`.
+    const node = ps(pid, "comm");
+    matches = command.startsWith(`${node} ${executable} dev`) && /^(?:\s|$)/u.test(command.slice(`${node} ${executable} dev`.length));
+  }
+  if (!matches || !Number.isFinite(start)) throw new Error(`PID ${pid} is not the expected Vinext dev process.`);
+  return { cwd, start };
+}
+async function portFree(lock) {
+  if (!Number.isInteger(lock.port) || lock.port < 1 || lock.port > 65535) return true;
+  // Only probe loopback; never connect to a target supplied by lock metadata.
+  return new Promise((resolve) => {
+    const socket = net.connect({ host: "127.0.0.1", port: lock.port });
+    socket.setTimeout(200);
+    socket.once("connect", () => { socket.destroy(); resolve(false); });
+    socket.once("error", () => { socket.destroy(); resolve(true); });
+    socket.once("timeout", () => { socket.destroy(); resolve(false); });
+  });
+}
+
+/** Serialize same-runtime replacement/startup. Never infer ownership from a port. */
+export async function startDev({ cwd, executable, args = [], env = process.env, prepare = async () => {}, timeoutMs = 15000, stdio = "inherit" }) {
+  cwd = fs.realpathSync(cwd);
+  executable = fs.realpathSync(executable);
+  const guard = path.join(cwd, ".garden-dev-start");
+  const lockPath = path.join(cwd, ".vinext/dev/lock.json");
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    try {
+      fs.mkdirSync(guard);
+      fs.writeFileSync(path.join(guard, "owner.json"), JSON.stringify({ pid: process.pid }));
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const owner = read(path.join(guard, "owner.json"));
+      if (owner && !alive(owner.pid)) throw new Error(`Interrupted Garden startup guard at ${guard}; no process was stopped. Remove this guard only after confirming no startup is in progress.`);
+      if (Date.now() >= deadline) throw new Error("Another Garden dev start is in progress; ownership could not be safely resolved.");
+      await delay(100);
+    }
+  }
+  let child;
+  try {
+    const lock = read(lockPath);
+    if (lock && alive(lock.pid)) {
+      if (lock.pid === process.pid) throw new Error("Refusing to replace this process.");
+      const previous = identity(lock.pid, executable);
+      if (previous.cwd !== cwd || fs.realpathSync(lock.cwd) !== cwd || !Number.isFinite(lock.startedAt) || previous.start > lock.startedAt + 1000 || lock.startedAt - previous.start > 120000) {
+        throw new Error("Dev lock ownership is unproven (runtime or process start time mismatch); nothing was stopped.");
+      }
+      // Recheck identity immediately before signalling to reduce PID-reuse races.
+      const current = identity(lock.pid, executable);
+      if (current.start !== previous.start || current.cwd !== cwd || read(lockPath)?.startedAt !== lock.startedAt) throw new Error("Dev owner changed during replacement; nothing was stopped.");
+      process.kill(lock.pid, "SIGTERM");
+      while (alive(lock.pid) || !(await portFree(lock))) {
+        if (Date.now() >= deadline) throw new Error("Previous dev server did not release its process/port in time; no force-kill attempted.");
+        await delay(100);
+      }
+      const remaining = read(lockPath);
+      if (remaining && remaining.pid !== lock.pid) throw new Error("Dev lock changed during shutdown; refusing to replace another owner.");
+    }
+    // Vinext itself takes over dead-PID locks. Do not unlink someone else's lock.
+    await prepare();
+    child = spawn(process.execPath, [executable, "dev", ...args], { cwd, env, stdio });
+    const exited = new Promise((resolve, reject) => { child.once("error", reject); child.once("exit", (code, signal) => resolve({ status: code, signal })); });
+    const forward = (signal) => { if (child.exitCode === null && child.signalCode === null) child.kill(signal); };
+    const interrupt = () => forward("SIGINT");
+    const terminate = () => forward("SIGTERM");
+    process.on("SIGINT", interrupt);
+    process.on("SIGTERM", terminate);
+    const finished = exited.finally(() => { process.off("SIGINT", interrupt); process.off("SIGTERM", terminate); });
+    // The guard only covers startup, not the server's whole lifetime.
+    const startupDeadline = Date.now() + timeoutMs;
+    while (child.exitCode === null && child.signalCode === null) {
+      if (read(lockPath)?.pid === child.pid) break;
+      if (Date.now() >= startupDeadline) {
+        child.kill("SIGTERM");
+        await Promise.race([finished, delay(1000)]);
+        throw new Error("Dev server did not establish its runtime lock in time; graceful stop requested (no force kill).");
+      }
+      await delay(100);
+    }
+    return { child, finished };
+  } finally {
+    fs.rmSync(guard, { recursive: true });
+  }
+}

package/templates/site/README.en.md

@@ -17,3 +17,5 @@ Running `npx garden dev` for the first time fills in any missing `Makefile` or s
 Comments are disabled by default. Before publishing, open [Giscus](https://giscus.app), write the repository, repository ID, category, and category ID into `.env.local`, and set the matching `GISCUS_REPO`, `GISCUS_REPO_ID`, `GISCUS_CATEGORY`, and `GISCUS_CATEGORY_ID` under GitHub Actions Variables. Leaving them empty fails the publish workflow. To publish without comments, set `GISCUS_DISABLED` to `1`.
 
 To upgrade the engine, update `hd-garden` in `package.json` to the new version and run `npm install`.
+
+Running `make dev` again gracefully replaces a verified Vinext process from the same project, never an unrelated port owner. Markdown edits, additions and deletions update the preview. Headings stay literal; ranges like `4~6` are plain text and strikethrough requires `~~text~~`.

package/templates/site/README.md

@@ -17,3 +17,5 @@ make dev
 评论默认关闭。发布前打开 [Giscus](https://giscus.app/zh-CN)，把仓库、仓库 ID、分类、分类 ID 写入 `.env.local`，并在 GitHub Actions Variables 设置同名的 `GISCUS_REPO`、`GISCUS_REPO_ID`、`GISCUS_CATEGORY`、`GISCUS_CATEGORY_ID`。留空会让发布失败。确定不开放评论时，把 `GISCUS_DISABLED` 设为 `1`。
 
 升级引擎：把 `package.json` 里的 `hd-garden` 改到新版本，例如 `^0.4.0`，再运行 `npm install`。
+
+再次运行 `make dev` 会先温和停止经验证属于同一项目的旧 Vinext，再启动新服务；不会按端口号杀死无关进程。修改、新建或删除 Markdown 会自动更新预览。标题按原文显示；范围 `4~6` 不作删除线，显式删除线用 `~~删除线~~`。

package/ui/garden/markdown-syntax.mjs

@@ -9,4 +9,4 @@ import remarkMath from "remark-math";
  * (app/lib/markdown-plugins.ts); a previewed Markdown file uses this list as
  * is (scripts/file-preview.mjs), so both read the same Markdown the same way.
  */
-export const markdownSyntaxPlugins = [remarkGfm, remarkCjkFriendly, remarkBreaks, remarkMath];
+export const markdownSyntaxPlugins = [[remarkGfm, { singleTilde: false }], remarkCjkFriendly, remarkBreaks, remarkMath];

package/vite.config.ts

@@ -46,7 +46,7 @@ const localBindingConfig = {
 
 function gardenContent() {
   const sync = (mode?: "preview") => {
-    spawnSync(process.execPath, [path.join(gardenPackageRoot, "scripts", "build-content.mjs")], {
+    return spawnSync(process.execPath, [path.join(gardenPackageRoot, "scripts", "build-content.mjs")], {
       cwd: siteRoot,
       env: { ...process.env, GARDEN_SITE: siteRoot, ...(mode ? { GARDEN_CONTENT_MODE: mode } : {}) },
       stdio: "inherit",
@@ -78,12 +78,37 @@ function gardenContent() {
       const contentDir = path.join(siteRoot, "content");
       const configFile = path.join(siteRoot, "site.config.yaml");
       server.watcher.add([contentDir, configFile]);
-      server.watcher.on("change", (file) => {
-        if (file.startsWith(contentDir) || file === configFile) {
-          // While editing, a broken ui block shows as an error card instead of stopping the server.
-          sync("preview");
-          server.ws.send({ type: "full-reload" });
-        }
+      let pending: ReturnType<typeof setTimeout> | undefined;
+      const onContentEvent = (file: string) => {
+        const relative = path.relative(contentDir, file);
+        if (file !== configFile && (relative.startsWith("..") || path.isAbsolute(relative))) return;
+        clearTimeout(pending);
+        // Coalesce editor atomic writes/renames; regenerate before asking browsers
+        // to reload, including newly created and deleted Markdown routes.
+        pending = setTimeout(() => {
+          const result = sync("preview");
+          if (result.status === 0) {
+            // The generator is synchronous; filesystem notifications have not
+            // necessarily reached Vite yet. Invalidate generated imports before
+            // any browser can request the new document.
+            for (const environment of Object.values(server.environments)) {
+              for (const generated of [generatedContent, generatedSiteConfig]) {
+                const modules = environment.moduleGraph.getModulesByFile(generated);
+                for (const generatedModule of modules ?? []) environment.moduleGraph.invalidateModule(generatedModule);
+              }
+            }
+            server.ws.send({ type: "full-reload" });
+          }
+        }, 100);
+      };
+      server.watcher.on("add", onContentEvent);
+      server.watcher.on("change", onContentEvent);
+      server.watcher.on("unlink", onContentEvent);
+      server.httpServer?.once("close", () => {
+        clearTimeout(pending);
+        server.watcher.off("add", onContentEvent);
+        server.watcher.off("change", onContentEvent);
+        server.watcher.off("unlink", onContentEvent);
       });
     },
   };