livemark 0.28.3 → 0.28.5

package/build/vite.config.js

@@ -1,4 +1,3 @@
-import contentCollections from "@content-collections/vite";
 import tailwind from "@tailwindcss/vite";
 import { devtools } from "@tanstack/devtools-vite";
 import { tanstackStart } from "@tanstack/react-start/plugin/vite";
@@ -7,6 +6,7 @@ import { defineConfig } from "vite";
 import svgr from "vite-plugin-svgr";
 import { loadConfig } from "./actions/config/load.js";
 import { agents } from "./plugins/vite-agents.js";
+import { content } from "./plugins/vite-content.js";
 import { livemark } from "./plugins/vite-livemark.js";
 import { robots } from "./plugins/vite-robots.js";
 const config = await loadConfig();
@@ -31,7 +31,7 @@ export default defineConfig({
         // any browser error back and forth forever.
         devtools({ consolePiping: { enabled: false } }),
         tailwind(),
-        contentCollections({ configPath: "content-collections.ts" }),
+        content({ configPath: "content-collections.ts", contentDir: config.root }),
         tanstackStart({
             srcDirectory: ".",
             // Seed path must match what the crawler produces (router-emitted
@@ -57,4 +57,4 @@ export default defineConfig({
         svgr(),
     ],
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livemark",
-  "version": "0.28.3",
+  "version": "0.28.5",
   "description": "Livemark description",
   "license": "MIT",
   "author": "Evgeny Karev",
@@ -30,8 +30,8 @@
     "@base-ui/react": "1.9.0",
     "@clack/prompts": "1.8.1",
     "@content-collections/core": "0.15.3",
+    "@content-collections/integrations": "0.5.0",
     "@content-collections/mdx": "0.2.2",
-    "@content-collections/vite": "0.3.1",
     "@orama/orama": "^3.1.18",
     "@shikijs/rehype": "4.5.0",
     "@shikijs/twoslash": "^4.5.0",

package/skills/livemark-configuration/SKILL.md

@@ -80,7 +80,7 @@ export default defineConfig({
 
 - **Article** (default when `type` is omitted): flat docs with a tree sidebar.
 - **Blog** (`type: "blog"`): auto-generated index at `prefix`, sorts by `date`, exposes `/prefix/tags/<tag>/` pages.
-- **Changelog** (`type: "changelog"`): reads `source` file; with `version: true`, splits on semver headings into per-version articles. Several changelog sections may coexist as long as their prefixes differ — each is cached in its own `cache/changelog/<slug-of-prefix>-<hash-of-prefix>/` directory (the hash keeps prefixes that slugify alike, like `/python/changelog/` and `/python-changelog/`, apart), so a version shared by two changelogs never collides. The `(version)` suffix only renders for `position: "header"` sections.
+- **Changelog** (`type: "changelog"`): reads `source` file; with `version: true`, splits on semver headings into per-version articles. Several changelog sections may coexist as long as their prefixes differ — each is cached in its own `.livemark/.cache/changelog/<slug-of-prefix>-<hash-of-prefix>/` directory (the hash keeps prefixes that slugify alike, like `/python/changelog/` and `/python-changelog/`, apart), so a version shared by two changelogs never collides. The `(version)` suffix only renders for `position: "header"` sections.
 
 Shared fields on every section: `title`, `prefix` (keep trailing-slashed), `type`, `icon` (lucide), `position` (`"header"` default, `"sidebar"` also available). Header sections and links never overflow: past the bar's width Search turns icon-only, then the rest fold into a "More" menu.
 

package/skills/livemark-customization/SKILL.md

@@ -118,7 +118,7 @@ Custom routes win over the Markdown catch-all at exact URLs. Don't create a rout
 3. **Override files are full replacements**, not diffs. Copy the default first (via `escape`), then edit.
 4. **Import Livemark internals via `livemark/*`**, not via relative paths — the plugin resolves those to the project's copy, so chained overrides (e.g., your Layout using your Header) compose correctly.
 5. **Static files belong in `.livemark/public/`**, which Vite exposes at the site root.
-6. **Never edit `.livemark/.target/`** — it is the generated mount Vite runs (Livemark's source with your overrides copied in), rebuilt on every run, so stack traces point there but edits are lost. Gitignore it alongside `.livemark/build/`.
+6. **Never edit `.livemark/.serve/` or `.livemark/.build/`** — they are the generated mounts Vite runs for the dev server and the production build (Livemark's source with your overrides copied in), rebuilt on every run, so stack traces point there but edits are lost. Each carries its own `.gitignore`.
 7. **Keyboard shortcuts live in the component they drive** — bare keys through `@tanstack/react-hotkeys`, ignored while typing: `L` sidebar (`Sidebar`), `S` search (`Search`), `T` theme (`Theme`), `J`/`K` scroll (`Root`), `B` back to top (`BackToTop`). Overriding one of these drops its key unless the copy keeps the `useHotkey` call; register a key in a component that mounts once, or one press fires twice.
 8. **Search highlights live in `Article`** — picking a result opens the page with `?highlight=<query>`, and `Article` passes it to `useSearchHighlight` with a ref on its `.prose` wrapper. An overridden `components/Article.tsx` must keep that call and ref, or matches stop being marked. Theme the mark through the `--highlight` and `--highlight-foreground` tokens; code blocks are never marked.
 9. **Edited Markdown reaches the page through `router.tsx`** — articles are route loader data, and route HMR keeps loader data, so `getRouter` re-runs loaders on Vite's `vite:afterUpdate`. An overridden `router.tsx` must keep that hook, or Markdown edits show only after a reload.

package/skills/livemark-deployment/SKILL.md

@@ -23,7 +23,7 @@ npx livemark build     # prerender every route into .livemark/build/client/
 npx livemark preview   # serve that build locally on port 8000
 ```
 
-`.livemark/build/client/` is the **only** directory to publish: an `index.html` per route plus assets, `sitemap.xml`, `robots.txt`, RSS feeds, Markdown twins, `llms.txt` and a `_headers` file. Not `dist/`, and not `.livemark/build/` itself — its `server/` sibling is the prerender bundle, not a site. Gitignore `.livemark/build/` and `.livemark/.target/`; both are regenerated on every build.
+`.livemark/build/client/` is the **only** directory to publish: an `index.html` per route plus assets, `sitemap.xml`, `robots.txt`, RSS feeds, Markdown twins, `llms.txt` and a `_headers` file. Not `dist/`, and not `.livemark/build/` itself — its `server/` sibling is the prerender bundle, not a site. Gitignore `.livemark/build/`; it is regenerated on every build.
 
 ## Config that affects deployment
 

package/source/actions/changelog/build.ts

@@ -11,7 +11,7 @@ import { visit } from "unist-util-visit"
 import type { Config } from "../../models/config.ts"
 import type { ChangelogSection } from "../../models/section.ts"
 import { isGitHubUrl, parseGitHubRepo } from "../../helpers/changelog-source.ts"
-import { targetDirFor } from "../target/build.ts"
+import { cacheDirFor } from "../../helpers/target-dir.ts"
 
 interface Release {
   tag_name: string
@@ -34,8 +34,6 @@ interface ChangelogEntry {
   sourceUrl?: string
 }
 
-const CACHE_SUBDIR = "cache/changelog"
-
 const parser = unified().use(remarkParse)
 const stringifier = unified().use(remarkStringify, {
   bullet: "-",
@@ -52,7 +50,7 @@ export function cacheIncludeGlob(section: ChangelogSection, config: Config) {
 
 /** Directory holding one changelog section's cache state: the rendered
  *  `.md` entries plus a `meta.json` holding the etag for conditional
- *  GETs. Each section gets its own subdirectory of `cache/changelog/`,
+ *  GETs. Each section gets its own subdirectory of `.livemark/.cache/changelog/`,
  *  keyed by its prefix's slug plus a hash of the raw prefix
  *  (`/python/changelog/` → `python-changelog-<hash>`), so several
  *  changelogs never overwrite each other's entries even when their
@@ -60,7 +58,7 @@ export function cacheIncludeGlob(section: ChangelogSection, config: Config) {
 export function changelogCacheDir(section: ChangelogSection, config: Config) {
   const slug = slugify(section.prefix) || "index"
   const hash = createHash("sha256").update(section.prefix).digest("hex").slice(0, 8)
-  return join(targetDirFor(config.configPath), CACHE_SUBDIR, `${slug}-${hash}`)
+  return join(cacheDirFor(config.configPath), "changelog", `${slug}-${hash}`)
 }
 
 /** Build the per-version changelog cache files of one changelog section
@@ -77,6 +75,7 @@ export async function buildChangelog(section: ChangelogSection, config: Config)
   if (entries === undefined) return
 
   await mkdir(cacheDir, { recursive: true })
+  await writeFile(join(cacheDirFor(config.configPath), ".gitignore"), "*\n")
   for (const f of await readdir(cacheDir).catch(() => [])) {
     if (f.endsWith(".md")) await rm(join(cacheDir, f), { force: true })
   }

package/source/actions/changelog/build.unit.ts

@@ -5,7 +5,7 @@ import { describe, expect, it } from "vite-plus/test"
 import { partitionBySection } from "../../helpers/section.ts"
 import { Config } from "../../models/config.ts"
 import type { ChangelogSection } from "../../models/section.ts"
-import { targetDirFor } from "../target/build.ts"
+import { cacheDirFor } from "../../helpers/target-dir.ts"
 import {
   buildChangelog,
   cacheIncludeGlob,
@@ -49,7 +49,7 @@ describe("buildChangelog", () => {
 
         const standardDir = changelogCacheDir(standard, config)
         const pythonDir = changelogCacheDir(python, config)
-        const cacheRoot = join(targetDirFor(configPath), "cache/changelog")
+        const cacheRoot = join(cacheDirFor(configPath), "changelog")
         expect(dirname(standardDir)).toBe(cacheRoot)
         expect(dirname(pythonDir)).toBe(cacheRoot)
         expect(basename(standardDir)).toMatch(/^changelog-[0-9a-f]{8}$/)
@@ -79,7 +79,7 @@ describe("buildChangelog", () => {
           "/python/changelog/0-2-0/",
         ])
       } finally {
-        await rm(targetDirFor(configPath), { recursive: true, force: true })
+        await rm(cacheDirFor(configPath), { recursive: true, force: true })
       }
     }))
 
@@ -114,7 +114,7 @@ describe("buildChangelog", () => {
         expect(await readdir(changelogCacheDir(standard, config))).toEqual(["0-4-0.md"])
         expect(await readdir(changelogCacheDir(python, config))).toEqual(["0-3-0.md"])
       } finally {
-        await rm(targetDirFor(configPath), { recursive: true, force: true })
+        await rm(cacheDirFor(configPath), { recursive: true, force: true })
       }
     }))
 
@@ -150,7 +150,7 @@ describe("buildChangelog", () => {
         expect(await readdir(nestedDir)).toEqual(["0-1-0.md"])
         expect(await readdir(flatDir)).toEqual(["0-2-0.md"])
       } finally {
-        await rm(targetDirFor(configPath), { recursive: true, force: true })
+        await rm(cacheDirFor(configPath), { recursive: true, force: true })
       }
     }))
 })

package/source/actions/target/build.ts

@@ -1,18 +1,35 @@
-import { cpSync, existsSync, mkdirSync, readlinkSync, rmSync, symlinkSync } from "node:fs"
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readlinkSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs"
 import { basename, dirname, join, relative, resolve } from "node:path"
 import { resolveDependencyDir } from "../../helpers/dependency-dir.ts"
+import { removeTargetDir } from "../../helpers/target-dir.ts"
 import { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from "../../settings.ts"
 
 /**
- * Synthesize the project's Vite mount at `.livemark/.target/`: livemark's `source/` with
- * the project's `.livemark/` escapes copied over it, plus a `node_modules` link to
- * livemark's dependencies. Escapable folders are rebuilt on every run, so a removed escape
- * never keeps rendering. Returns the target dir.
+ * Synthesize the project's Vite mount — `.livemark/.serve/` for the dev server,
+ * `.livemark/.build/` for a production build or preview: livemark's `source/` with the
+ * project's `.livemark/` escapes copied over it, plus a `node_modules` link to livemark's
+ * dependencies. Escapable folders are rebuilt on every run, so a removed escape never
+ * keeps rendering. Returns the target dir.
  */
-export function buildTarget(props: { configPath: string; sourceDir: string }) {
-  const targetDir = targetDirFor(props.configPath)
+export function buildTarget(props: {
+  configPath: string
+  sourceDir: string
+  command?: TargetCommand
+}) {
+  const targetDir = targetDirFor(props.configPath, props.command)
   const overridesRoot = dirname(targetDir)
+  // `.target/` was the mount before `.serve/` and `.build/`; an upgrade must not keep it.
+  removeTargetDir(join(overridesRoot, ".target"))
   mkdirSync(targetDir, { recursive: true })
+  writeFileSync(join(targetDir, ".gitignore"), "*\n")
 
   cpSync(props.sourceDir, targetDir, {
     recursive: true,
@@ -36,9 +53,12 @@ export function buildTarget(props: { configPath: string; sourceDir: string }) {
   return targetDir
 }
 
+/** Which mount a run uses: the dev server's, or the production build's. */
+export type TargetCommand = "serve" | "build"
+
 /** Locate the project's target dir without building it. */
-export function targetDirFor(configPath: string) {
-  return join(dirname(configPath), ".livemark", ".target")
+export function targetDirFor(configPath: string, command: TargetCommand = "serve") {
+  return join(dirname(configPath), ".livemark", `.${command}`)
 }
 
 function isPackageFile(src: string) {

package/source/actions/target/build.unit.ts

@@ -14,7 +14,7 @@ describe("buildTarget", () => {
 
       const targetDir = buildTarget({ configPath, sourceDir })
 
-      expect(targetDir).toBe(join(root, "project/.livemark/.target"))
+      expect(targetDir).toBe(join(root, "project/.livemark/.serve"))
       expect(read(targetDir, "components/Footer.tsx")).toBe("escaped")
       expect(read(targetDir, "components/Header.tsx")).toBe("default")
       expect(read(targetDir, "head.ts")).toBe("escaped head")
@@ -22,6 +22,29 @@ describe("buildTarget", () => {
       expect(existsSync(join(targetDir, "helpers/util.unit.ts"))).toBe(false)
     }))
 
+  it("mounts a production build apart from the dev server's target", () =>
+    temporaryDirectoryTask(async root => {
+      const { configPath, sourceDir } = await createFixture(root)
+
+      const targetDir = buildTarget({ configPath, sourceDir, command: "build" })
+
+      expect(targetDir).toBe(join(root, "project/.livemark/.build"))
+      expect(read(targetDir, "routes/index.tsx")).toBe("index")
+      expect(existsSync(targetDirFor(configPath))).toBe(false)
+    }))
+
+  it("ignores itself in git and removes the legacy .target mount", () =>
+    temporaryDirectoryTask(async root => {
+      const { configPath, sourceDir } = await createFixture(root)
+      const legacyDir = join(root, "project/.livemark/.target")
+      await put(join(legacyDir, "routes/index.tsx"), "stale")
+
+      const targetDir = buildTarget({ configPath, sourceDir })
+
+      expect(read(targetDir, ".gitignore")).toBe("*\n")
+      expect(existsSync(legacyDir)).toBe(false)
+    }))
+
   it("drops escapes removed since the last run", () =>
     temporaryDirectoryTask(async root => {
       const { configPath, sourceDir } = await createFixture(root)

package/source/actions/target/clear.ts

@@ -1,14 +1,15 @@
-import { rmSync } from "node:fs"
-import { join } from "node:path"
+import { cacheDirFor, removeTargetDir } from "../../helpers/target-dir.ts"
 import { targetDirFor } from "./build.ts"
 
 /**
- * Wipe the project's target dir so the next run rebuilds it from scratch.
+ * Wipe the project's target dirs and cache so the next run rebuilds them from scratch.
  */
 export function clearTarget(configPath: string) {
-  const targetDir = targetDirFor(configPath)
-  // Unlink the dependency link first so the recursive remove cannot reach the store.
-  rmSync(join(targetDir, "node_modules"), { force: true })
-  rmSync(targetDir, { recursive: true, force: true })
-  return targetDir
+  const targetDirs = [
+    targetDirFor(configPath, "serve"),
+    targetDirFor(configPath, "build"),
+    cacheDirFor(configPath),
+  ]
+  for (const targetDir of targetDirs) removeTargetDir(targetDir)
+  return targetDirs
 }

package/source/actions/target/clear.unit.ts

@@ -3,22 +3,29 @@ import { mkdir, symlink, writeFile } from "node:fs/promises"
 import { join } from "node:path"
 import { temporaryDirectoryTask } from "tempy"
 import { describe, expect, it } from "vite-plus/test"
+import { cacheDirFor } from "../../helpers/target-dir.ts"
 import { targetDirFor } from "./build.ts"
 import { clearTarget } from "./clear.ts"
 
 describe("clearTarget", () => {
-  it("removes the target dir without following its dependency link", () =>
+  it("removes the target dirs without following their dependency link", () =>
     temporaryDirectoryTask(async root => {
       const configPath = join(root, "livemark.config.ts")
       const targetDir = targetDirFor(configPath)
+      const buildDir = targetDirFor(configPath, "build")
+      const cacheDir = cacheDirFor(configPath)
+      await mkdir(buildDir, { recursive: true })
+      await mkdir(cacheDir, { recursive: true })
       await mkdir(join(targetDir, "cache"), { recursive: true })
       await writeFile(join(targetDir, "cache", "entry.md"), "cached")
       await mkdir(join(root, "deps"))
       await writeFile(join(root, "deps", "kept.js"), "")
       await symlink(join(root, "deps"), join(targetDir, "node_modules"), "junction")
 
-      expect(clearTarget(configPath)).toBe(targetDir)
+      expect(clearTarget(configPath)).toEqual([targetDir, buildDir, cacheDir])
       expect(existsSync(targetDir)).toBe(false)
+      expect(existsSync(buildDir)).toBe(false)
+      expect(existsSync(cacheDir)).toBe(false)
       expect(existsSync(join(root, "deps", "kept.js"))).toBe(true)
       expect(() => clearTarget(configPath)).not.toThrow()
     }))

package/source/commands/clear.ts

@@ -4,12 +4,13 @@ import { loadConfig } from "../actions/config/load.ts"
 import { clearTarget } from "../actions/target/clear.ts"
 
 /**
- * Wipe the generated `.livemark/.target/` mount.
+ * Wipe the generated `.livemark/.serve/` and `.livemark/.build/` mounts and `.livemark/.cache/`.
  */
 export const clear = new Command("clear")
-  .description("Wipe the generated .livemark/.target/ mount")
+  .description("Wipe the generated .livemark/.serve/, .build/ and .cache/")
   .action(async () => {
     const config = await loadConfig()
-    const targetDir = clearTarget(config.configPath)
-    console.log(`Cleared ${pc.dim(targetDir)}`)
+    for (const targetDir of clearTarget(config.configPath)) {
+      console.log(`Cleared ${pc.dim(targetDir)}`)
+    }
   })

package/source/helpers/tailwind-sources.unit.ts

@@ -1,14 +1,14 @@
 import { describe, expect, it } from "vite-plus/test"
 import { excludeTailwindSources } from "./tailwind-sources.ts"
 
-const targetDir = "/project/.livemark/.target"
+const targetDir = "/project/.livemark/.serve"
 
 describe("excludeTailwindSources", () => {
   it("excludes the dependency link and the content cache from a Tailwind entry", () => {
     const css = `@import "tailwindcss";\n@import "./shape.css";`
     expect(excludeTailwindSources({ css, targetDir })).toBe(
-      `${css}\n@source not "/project/.livemark/.target/node_modules";\n` +
-        `@source not "/project/.livemark/.target/.content-collections/cache";\n`,
+      `${css}\n@source not "/project/.livemark/.serve/node_modules";\n` +
+        `@source not "/project/.livemark/.serve/.content-collections/cache";\n`,
     )
   })
 

package/source/helpers/target-dir.ts

@@ -0,0 +1,12 @@
+import { rmSync } from "node:fs"
+import { dirname, join } from "node:path"
+
+export function removeTargetDir(targetDir: string) {
+  // Unlink the dependency link first so the recursive remove cannot reach the store.
+  rmSync(join(targetDir, "node_modules"), { force: true })
+  rmSync(targetDir, { recursive: true, force: true })
+}
+
+export function cacheDirFor(configPath: string) {
+  return join(dirname(configPath), ".livemark", ".cache")
+}

package/source/helpers/target-export.unit.ts

@@ -3,7 +3,7 @@ import { describe, expect, it } from "vite-plus/test"
 import packageJson from "../../package.json" with { type: "json" }
 import { resolveTargetExport } from "./target-export.ts"
 
-const targetDir = "/project/.livemark/.target"
+const targetDir = "/project/.livemark/.serve"
 
 function resolveId(id: string) {
   return resolveTargetExport({ id, targetDir, exports: packageJson.exports })

package/source/helpers/task-queue.ts

@@ -0,0 +1,28 @@
+/** Run keyed async tasks one at a time; a key enqueued again before its task
+ *  starts replaces it, so a burst of events for one file costs one run. */
+export function createTaskQueue(props: { onError: (error: unknown) => void }) {
+  const pending = new Map<string, () => Promise<unknown>>()
+  let draining: Promise<void> | undefined
+
+  return {
+    enqueue(key: string, task: () => Promise<unknown>) {
+      pending.set(key, task)
+      draining ??= drain()
+      return draining
+    },
+  }
+
+  async function drain() {
+    // A Map iterator also visits entries set during iteration, which is what
+    // picks up keys enqueued while a task runs.
+    for (const [key, task] of pending) {
+      pending.delete(key)
+      try {
+        await task()
+      } catch (error) {
+        props.onError(error)
+      }
+    }
+    draining = undefined
+  }
+}

package/source/helpers/task-queue.unit.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vite-plus/test"
+import { createTaskQueue } from "./task-queue.ts"
+
+describe("createTaskQueue", () => {
+  it("runs one task at a time", async () => {
+    const queue = createTaskQueue({ onError: () => {} })
+    const log: string[] = []
+    const task = (name: string, ms: number) => async () => {
+      log.push(`start ${name}`)
+      await new Promise(resolve => setTimeout(resolve, ms))
+      log.push(`end ${name}`)
+    }
+    queue.enqueue("a", task("a", 30))
+    await queue.enqueue("b", task("b", 1))
+    expect(log).toEqual(["start a", "end a", "start b", "end b"])
+  })
+
+  it("collapses a key enqueued again before it starts", async () => {
+    const queue = createTaskQueue({ onError: () => {} })
+    const runs: string[] = []
+    queue.enqueue("first", async () => runs.push("first"))
+    queue.enqueue("file", async () => runs.push("stale"))
+    await queue.enqueue("file", async () => runs.push("latest"))
+    expect(runs).toEqual(["first", "latest"])
+  })
+
+  it("reruns a key enqueued while it is running", async () => {
+    const queue = createTaskQueue({ onError: () => {} })
+    const runs: number[] = []
+    let release = () => {}
+    queue.enqueue("file", async () => {
+      runs.push(1)
+      await new Promise<void>(resolve => (release = resolve))
+    })
+    const done = queue.enqueue("file", async () => runs.push(2))
+    release()
+    await done
+    expect(runs).toEqual([1, 2])
+  })
+
+  it("reports a failed task and keeps draining", async () => {
+    const errors: unknown[] = []
+    const queue = createTaskQueue({ onError: error => errors.push(error) })
+    const runs: string[] = []
+    queue.enqueue("a", async () => {
+      throw new Error("boom")
+    })
+    await queue.enqueue("b", async () => runs.push("b"))
+    expect(errors).toHaveLength(1)
+    expect(runs).toEqual(["b"])
+  })
+
+  it("starts a fresh drain after the previous one finished", async () => {
+    const queue = createTaskQueue({ onError: () => {} })
+    const runs: string[] = []
+    await queue.enqueue("a", async () => runs.push("a"))
+    await queue.enqueue("a", async () => runs.push("again"))
+    expect(runs).toEqual(["a", "again"])
+  })
+})

package/source/plugins/vite-content.ts

@@ -0,0 +1,72 @@
+import { existsSync, watch, type FSWatcher } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { createBuilder } from "@content-collections/core"
+import { configureLogging } from "@content-collections/integrations"
+import type { Plugin } from "vite"
+import { createTaskQueue } from "../helpers/task-queue.ts"
+
+export interface ContentOptions {
+  configPath: string
+  contentDir: string
+}
+
+type Builder = Awaited<ReturnType<typeof createBuilder>>
+
+const IGNORED_PATHS = /(^|[/\\])(node_modules|\.[^/\\]+)([/\\]|$)/
+
+/** Build the content collections and rebuild them on edits, one build at a time:
+ *  `@content-collections/vite` builds per file event, a save fires two, and their
+ *  overlapping writes tore `allArticles.js` so every request failed. */
+export function content(opts: ContentOptions): Plugin {
+  const queue = createTaskQueue({ onError: error => console.error(error) })
+  let builder: Builder | undefined
+  let initialBuild: Promise<void> | undefined
+  let watcher: FSWatcher | undefined
+  return {
+    name: "livemark:content",
+    config(config) {
+      const configPath = resolve(config.root ?? process.cwd(), opts.configPath)
+      const generated = join(dirname(configPath), ".content-collections", "generated")
+      return {
+        optimizeDeps: { exclude: ["content-collections"] },
+        resolve: { alias: { "content-collections": generated } },
+        ...((config.server?.fs?.allow?.length ?? 0) > 0 && {
+          server: { fs: { allow: [generated] } },
+        }),
+      }
+    },
+    async configResolved(config) {
+      builder = await createBuilder(resolve(config.root, opts.configPath))
+      configureLogging(builder)
+    },
+    buildStart() {
+      const current = builder
+      if (!current) return
+      // Once, not per environment, and through the queue so an edit landing
+      // before it cannot overlap it.
+      initialBuild ??= new Promise((resolve, reject) => {
+        queue.enqueue("build", () => current.build().then(resolve, reject))
+      })
+      return initialBuild
+    },
+    configureServer() {
+      const current = builder
+      if (!current) return
+      watcher = watch(
+        opts.contentDir,
+        { recursive: true, ignore: IGNORED_PATHS },
+        (_, filename) => {
+          if (!filename) return
+          const file = join(opts.contentDir, filename)
+          queue.enqueue(file, () =>
+            current.sync(existsSync(file) ? "update" : "delete", file),
+          )
+        },
+      )
+    },
+    closeBundle() {
+      watcher?.close()
+      watcher = undefined
+    },
+  }
+}

package/source/plugins/vite-livemark.ts

@@ -42,7 +42,8 @@ const LOCKFILES = [
 const VIRTUAL_ID = "livemark:virtual"
 const VIRTUAL_RESOLVED_ID = `\0${VIRTUAL_ID}`
 
-/** Owns the project's `.livemark/.target/` mount: synthesizes it via
+/** Owns the project's `.livemark/.serve/` mount (`.build/` when building, so a build
+ *  never rewrites a running dev server's files): synthesizes it via
  *  `buildTarget()`, returns the Vite config that anchors there, and
  *  copies `.livemark/` edits (plus livemark's `source/` in its own dev)
  *  into the target. Vite watches the target natively, so its own HMR
@@ -58,6 +59,7 @@ export function livemark(opts: LivemarkOptions): Plugin {
       targetDir = buildTarget({
         configPath: opts.config.configPath,
         sourceDir: SOURCE_DIR,
+        command: env.command === "build" || env.isPreview ? "build" : "serve",
       })
       const base: ViteUserConfig = {
         root: targetDir,
@@ -137,14 +139,22 @@ export function livemark(opts: LivemarkOptions): Plugin {
           return
         }
         if (isWithin(file, targetDir) || isWithin(file, outDir)) return
-        const overlayHit = matchPath(file, overridesRoot)
-        if (overlayHit) {
-          syncOverlay(overlayHit, kind, targetDir, overridesRoot)
-          return
-        }
-        const sourceHit = matchPath(file, SOURCE_DIR)
-        if (sourceHit && !sourceHit.rel.includes("routeTree.gen.ts")) {
-          syncSource(sourceHit, kind, targetDir, overridesRoot)
+        // A watcher callback that throws kills the server, and a copy racing another
+        // writer of the target (an editor's atomic save, `livemark clear`) fails.
+        try {
+          const overlayHit = matchPath(file, overridesRoot)
+          if (overlayHit) {
+            syncOverlay(overlayHit, kind, targetDir, overridesRoot)
+            return
+          }
+          const sourceHit = matchPath(file, SOURCE_DIR)
+          if (sourceHit && !sourceHit.rel.includes("routeTree.gen.ts")) {
+            syncSource(sourceHit, kind, targetDir, overridesRoot)
+          }
+        } catch (error) {
+          server.config.logger.error(`[livemark] failed to sync ${file}: ${error}`, {
+            error: error instanceof Error ? error : undefined,
+          })
         }
       }
     },