livemark 0.28.3 → 0.28.4

package/build/helpers/task-queue.d.ts

@@ -0,0 +1,7 @@
+/** 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 declare function createTaskQueue(props: {
+    onError: (error: unknown) => void;
+}): {
+    enqueue(key: string, task: () => Promise<unknown>): Promise<void>;
+};

package/build/helpers/task-queue.js

@@ -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) {
+    const pending = new Map();
+    let draining;
+    return {
+        enqueue(key, task) {
+            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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/helpers/task-queue.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/build/helpers/task-queue.unit.js

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vite-plus/test";
+import { createTaskQueue } from "./task-queue.js";
+describe("createTaskQueue", () => {
+    it("runs one task at a time", async () => {
+        const queue = createTaskQueue({ onError: () => { } });
+        const log = [];
+        const task = (name, ms) => 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 = [];
+        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 = [];
+        let release = () => { };
+        queue.enqueue("file", async () => {
+            runs.push(1);
+            await new Promise(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 = [];
+        const queue = createTaskQueue({ onError: error => errors.push(error) });
+        const runs = [];
+        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 = [];
+        await queue.enqueue("a", async () => runs.push("a"));
+        await queue.enqueue("a", async () => runs.push("again"));
+        expect(runs).toEqual(["a", "again"]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/plugins/vite-content.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from "vite";
+export interface ContentOptions {
+    configPath: string;
+    contentDir: string;
+}
+/** 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 declare function content(opts: ContentOptions): Plugin;

package/build/plugins/vite-content.js

@@ -0,0 +1,60 @@
+import { existsSync, watch } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { createBuilder } from "@content-collections/core";
+import { configureLogging } from "@content-collections/integrations";
+import { createTaskQueue } from "../helpers/task-queue.js";
+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) {
+    const queue = createTaskQueue({ onError: error => console.error(error) });
+    let builder;
+    let initialBuild;
+    let watcher;
+    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;
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidml0ZS1jb250ZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc291cmNlL3BsdWdpbnMvdml0ZS1jb250ZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsS0FBSyxFQUFrQixNQUFNLFNBQVMsQ0FBQTtBQUMzRCxPQUFPLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDbEQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDJCQUEyQixDQUFBO0FBQ3pELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1DQUFtQyxDQUFBO0FBRXBFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQTtBQVMxRCxNQUFNLGFBQWEsR0FBRyw0Q0FBNEMsQ0FBQTtBQUVsRTs7d0VBRXdFO0FBQ3hFLE1BQU0sVUFBVSxPQUFPLENBQUMsSUFBb0I7SUFDMUMsTUFBTSxLQUFLLEdBQUcsZUFBZSxDQUFDLEVBQUUsT0FBTyxFQUFFLEtBQUssQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUE7SUFDekUsSUFBSSxPQUE0QixDQUFBO0lBQ2hDLElBQUksWUFBdUMsQ0FBQTtJQUMzQyxJQUFJLE9BQThCLENBQUE7SUFDbEMsT0FBTztRQUNMLElBQUksRUFBRSxrQkFBa0I7UUFDeEIsTUFBTSxDQUFDLE1BQU07WUFDWCxNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLElBQUksSUFBSSxPQUFPLENBQUMsR0FBRyxFQUFFLEVBQUUsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFBO1lBQ3pFLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsVUFBVSxDQUFDLEVBQUUsc0JBQXNCLEVBQUUsV0FBVyxDQUFDLENBQUE7WUFDaEYsT0FBTztnQkFDTCxZQUFZLEVBQUUsRUFBRSxPQUFPLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQyxFQUFFO2dCQUNsRCxPQUFPLEVBQUUsRUFBRSxLQUFLLEVBQUUsRUFBRSxxQkFBcUIsRUFBRSxTQUFTLEVBQUUsRUFBRTtnQkFDeEQsR0FBRyxDQUFDLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxFQUFFLEVBQUUsS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLElBQUk7b0JBQ2pELE1BQU0sRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUFFLEtBQUssRUFBRSxDQUFDLFNBQVMsQ0FBQyxFQUFFLEVBQUU7aUJBQ3ZDLENBQUM7YUFDSCxDQUFBO1FBQ0gsQ0FBQztRQUNELEtBQUssQ0FBQyxjQUFjLENBQUMsTUFBTTtZQUN6QixPQUFPLEdBQUcsTUFBTSxhQUFhLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUE7WUFDcEUsZ0JBQWdCLENBQUMsT0FBTyxDQUFDLENBQUE7UUFDM0IsQ0FBQztRQUNELFVBQVU7WUFDUixNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUE7WUFDdkIsSUFBSSxDQUFDLE9BQU87Z0JBQUUsT0FBTTtZQUNwQixzRUFBc0U7WUFDdEUsK0JBQStCO1lBQy9CLFlBQVksS0FBSyxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtnQkFDL0MsS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQTtZQUNyRSxDQUFDLENBQUMsQ0FBQTtZQUNGLE9BQU8sWUFBWSxDQUFBO1FBQ3JCLENBQUM7UUFDRCxlQUFlO1lBQ2IsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFBO1lBQ3ZCLElBQUksQ0FBQyxPQUFPO2dCQUFFLE9BQU07WUFDcEIsT0FBTyxHQUFHLEtBQUssQ0FDYixJQUFJLENBQUMsVUFBVSxFQUNmLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsYUFBYSxFQUFFLEVBQzFDLENBQUMsQ0FBQyxFQUFFLFFBQVEsRUFBRSxFQUFFO2dCQUNkLElBQUksQ0FBQyxRQUFRO29CQUFFLE9BQU07Z0JBQ3JCLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxFQUFFLFFBQVEsQ0FBQyxDQUFBO2dCQUM1QyxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxHQUFHLEVBQUUsQ0FDdkIsT0FBTyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUMzRCxDQUFBO1lBQ0gsQ0FBQyxDQUNGLENBQUE7UUFDSCxDQUFDO1FBQ0QsV0FBVztZQUNULE9BQU8sRUFBRSxLQUFLLEVBQUUsQ0FBQTtZQUNoQixPQUFPLEdBQUcsU0FBUyxDQUFBO1FBQ3JCLENBQUM7S0FDRixDQUFBO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGV4aXN0c1N5bmMsIHdhdGNoLCB0eXBlIEZTV2F0Y2hlciB9IGZyb20gXCJub2RlOmZzXCJcbmltcG9ydCB7IGRpcm5hbWUsIGpvaW4sIHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCJcbmltcG9ydCB7IGNyZWF0ZUJ1aWxkZXIgfSBmcm9tIFwiQGNvbnRlbnQtY29sbGVjdGlvbnMvY29yZVwiXG5pbXBvcnQgeyBjb25maWd1cmVMb2dnaW5nIH0gZnJvbSBcIkBjb250ZW50LWNvbGxlY3Rpb25zL2ludGVncmF0aW9uc1wiXG5pbXBvcnQgdHlwZSB7IFBsdWdpbiB9IGZyb20gXCJ2aXRlXCJcbmltcG9ydCB7IGNyZWF0ZVRhc2tRdWV1ZSB9IGZyb20gXCIuLi9oZWxwZXJzL3Rhc2stcXVldWUudHNcIlxuXG5leHBvcnQgaW50ZXJmYWNlIENvbnRlbnRPcHRpb25zIHtcbiAgY29uZmlnUGF0aDogc3RyaW5nXG4gIGNvbnRlbnREaXI6IHN0cmluZ1xufVxuXG50eXBlIEJ1aWxkZXIgPSBBd2FpdGVkPFJldHVyblR5cGU8dHlwZW9mIGNyZWF0ZUJ1aWxkZXI+PlxuXG5jb25zdCBJR05PUkVEX1BBVEhTID0gLyhefFsvXFxcXF0pKG5vZGVfbW9kdWxlc3xcXC5bXi9cXFxcXSspKFsvXFxcXF18JCkvXG5cbi8qKiBCdWlsZCB0aGUgY29udGVudCBjb2xsZWN0aW9ucyBhbmQgcmVidWlsZCB0aGVtIG9uIGVkaXRzLCBvbmUgYnVpbGQgYXQgYSB0aW1lOlxuICogIGBAY29udGVudC1jb2xsZWN0aW9ucy92aXRlYCBidWlsZHMgcGVyIGZpbGUgZXZlbnQsIGEgc2F2ZSBmaXJlcyB0d28sIGFuZCB0aGVpclxuICogIG92ZXJsYXBwaW5nIHdyaXRlcyB0b3JlIGBhbGxBcnRpY2xlcy5qc2Agc28gZXZlcnkgcmVxdWVzdCBmYWlsZWQuICovXG5leHBvcnQgZnVuY3Rpb24gY29udGVudChvcHRzOiBDb250ZW50T3B0aW9ucyk6IFBsdWdpbiB7XG4gIGNvbnN0IHF1ZXVlID0gY3JlYXRlVGFza1F1ZXVlKHsgb25FcnJvcjogZXJyb3IgPT4gY29uc29sZS5lcnJvcihlcnJvcikgfSlcbiAgbGV0IGJ1aWxkZXI6IEJ1aWxkZXIgfCB1bmRlZmluZWRcbiAgbGV0IGluaXRpYWxCdWlsZDogUHJvbWlzZTx2b2lkPiB8IHVuZGVmaW5lZFxuICBsZXQgd2F0Y2hlcjogRlNXYXRjaGVyIHwgdW5kZWZpbmVkXG4gIHJldHVybiB7XG4gICAgbmFtZTogXCJsaXZlbWFyazpjb250ZW50XCIsXG4gICAgY29uZmlnKGNvbmZpZykge1xuICAgICAgY29uc3QgY29uZmlnUGF0aCA9IHJlc29sdmUoY29uZmlnLnJvb3QgPz8gcHJvY2Vzcy5jd2QoKSwgb3B0cy5jb25maWdQYXRoKVxuICAgICAgY29uc3QgZ2VuZXJhdGVkID0gam9pbihkaXJuYW1lKGNvbmZpZ1BhdGgpLCBcIi5jb250ZW50LWNvbGxlY3Rpb25zXCIsIFwiZ2VuZXJhdGVkXCIpXG4gICAgICByZXR1cm4ge1xuICAgICAgICBvcHRpbWl6ZURlcHM6IHsgZXhjbHVkZTogW1wiY29udGVudC1jb2xsZWN0aW9uc1wiXSB9LFxuICAgICAgICByZXNvbHZlOiB7IGFsaWFzOiB7IFwiY29udGVudC1jb2xsZWN0aW9uc1wiOiBnZW5lcmF0ZWQgfSB9LFxuICAgICAgICAuLi4oKGNvbmZpZy5zZXJ2ZXI/LmZzPy5hbGxvdz8ubGVuZ3RoID8/IDApID4gMCAmJiB7XG4gICAgICAgICAgc2VydmVyOiB7IGZzOiB7IGFsbG93OiBbZ2VuZXJhdGVkXSB9IH0sXG4gICAgICAgIH0pLFxuICAgICAgfVxuICAgIH0sXG4gICAgYXN5bmMgY29uZmlnUmVzb2x2ZWQoY29uZmlnKSB7XG4gICAgICBidWlsZGVyID0gYXdhaXQgY3JlYXRlQnVpbGRlcihyZXNvbHZlKGNvbmZpZy5yb290LCBvcHRzLmNvbmZpZ1BhdGgpKVxuICAgICAgY29uZmlndXJlTG9nZ2luZyhidWlsZGVyKVxuICAgIH0sXG4gICAgYnVpbGRTdGFydCgpIHtcbiAgICAgIGNvbnN0IGN1cnJlbnQgPSBidWlsZGVyXG4gICAgICBpZiAoIWN1cnJlbnQpIHJldHVyblxuICAgICAgLy8gT25jZSwgbm90IHBlciBlbnZpcm9ubWVudCwgYW5kIHRocm91Z2ggdGhlIHF1ZXVlIHNvIGFuIGVkaXQgbGFuZGluZ1xuICAgICAgLy8gYmVmb3JlIGl0IGNhbm5vdCBvdmVybGFwIGl0LlxuICAgICAgaW5pdGlhbEJ1aWxkID8/PSBuZXcgUHJvbWlzZSgocmVzb2x2ZSwgcmVqZWN0KSA9PiB7XG4gICAgICAgIHF1ZXVlLmVucXVldWUoXCJidWlsZFwiLCAoKSA9PiBjdXJyZW50LmJ1aWxkKCkudGhlbihyZXNvbHZlLCByZWplY3QpKVxuICAgICAgfSlcbiAgICAgIHJldHVybiBpbml0aWFsQnVpbGRcbiAgICB9LFxuICAgIGNvbmZpZ3VyZVNlcnZlcigpIHtcbiAgICAgIGNvbnN0IGN1cnJlbnQgPSBidWlsZGVyXG4gICAgICBpZiAoIWN1cnJlbnQpIHJldHVyblxuICAgICAgd2F0Y2hlciA9IHdhdGNoKFxuICAgICAgICBvcHRzLmNvbnRlbnREaXIsXG4gICAgICAgIHsgcmVjdXJzaXZlOiB0cnVlLCBpZ25vcmU6IElHTk9SRURfUEFUSFMgfSxcbiAgICAgICAgKF8sIGZpbGVuYW1lKSA9PiB7XG4gICAgICAgICAgaWYgKCFmaWxlbmFtZSkgcmV0dXJuXG4gICAgICAgICAgY29uc3QgZmlsZSA9IGpvaW4ob3B0cy5jb250ZW50RGlyLCBmaWxlbmFtZSlcbiAgICAgICAgICBxdWV1ZS5lbnF1ZXVlKGZpbGUsICgpID0+XG4gICAgICAgICAgICBjdXJyZW50LnN5bmMoZXhpc3RzU3luYyhmaWxlKSA/IFwidXBkYXRlXCIgOiBcImRlbGV0ZVwiLCBmaWxlKSxcbiAgICAgICAgICApXG4gICAgICAgIH0sXG4gICAgICApXG4gICAgfSxcbiAgICBjbG9zZUJ1bmRsZSgpIHtcbiAgICAgIHdhdGNoZXI/LmNsb3NlKClcbiAgICAgIHdhdGNoZXIgPSB1bmRlZmluZWRcbiAgICB9LFxuICB9XG59XG4iXX0=

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.4",
   "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/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/vite.config.ts

@@ -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.ts"
 import { agents } from "./plugins/vite-agents.ts"
+import { content } from "./plugins/vite-content.ts"
 import { livemark } from "./plugins/vite-livemark.ts"
 import { robots } from "./plugins/vite-robots.ts"
 
@@ -34,7 +34,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