livemark 0.24.1 → 0.26.0

package/README.md

@@ -9,7 +9,7 @@ Livemark turns plain Markdown into a fast, modern documentation site. Point it a
 - **Diagrams and math.** [Mermaid](https://mermaid.js.org/) flowcharts and KaTeX equations, theme-aware, zero config.
 - **Rich elements.** Callouts, tabs, file trees, cards, columns, badges, package tabs (npm/pnpm/yarn/bun), embeds (YouTube, SoundCloud), and more — all as Markdown directives or MDX components.
 - **Sections.** First-class support for docs, blog (with tags + RSS), and changelog (local `CHANGELOG.md` or GitHub releases).
-- **Search.** Full-text search powered by [Orama](https://oramasearch.com/), keyboard shortcuts, smart table-of-contents.
+- **Search.** Full-text search powered by [Orama](https://oramasearch.com/), with matches highlighted on the page you land on, keyboard shortcuts, smart table-of-contents.
 - **Themable.** Tailwind v4, shadcn-style primitives, dark mode, and per-file overrides via a `.livemark/` folder.
 - **Built on TanStack Start.** SSR, prerendering, sitemap, and routing for free.
 
@@ -66,9 +66,10 @@ Welcome!
 npx livemark start    # dev server with HMR at http://localhost:8000
 npx livemark build    # production build to .livemark/build/
 npx livemark preview  # serve the production build locally
+npx livemark clear    # wipe the generated .livemark/.target/ (stop the dev server first)
 ```
 
-That's the whole loop.
+That's the whole loop. Add `.livemark/build/` and `.livemark/.target/` to your `.gitignore`.
 
 ## Project structure
 

package/build/actions/config/define.d.ts

@@ -9,6 +9,7 @@ export declare function defineConfig(input: UserConfig): {
     logo?: string | undefined;
     title: string;
     description: string;
+    banner?: string | undefined;
     include: string | string[];
     exclude?: string | string[] | undefined;
     codeThemeLight: "ayu-light" | "catppuccin-latte" | "everforest-light" | "github-light" | "github-light-default" | "github-light-high-contrast" | "gruvbox-light-hard" | "gruvbox-light-medium" | "gruvbox-light-soft" | "horizon-bright" | "kanagawa-lotus" | "light-plus" | "material-theme-lighter" | "min-light" | "night-owl-light" | "one-light" | "rose-pine-dawn" | "slack-ochin" | "snazzy-light" | "solarized-light" | "vitesse-light";
@@ -78,5 +79,10 @@ export declare function defineConfig(input: UserConfig): {
             sourceAction?: "edit" | "view" | undefined;
         };
     }[] | undefined;
+    head?: {
+        meta?: Record<string, string>[] | undefined;
+        links?: Record<string, string>[] | undefined;
+        scripts?: Record<string, string>[] | undefined;
+    } | undefined;
     vite?: unknown;
 };

package/build/actions/config/define.unit.js

@@ -26,5 +26,12 @@ describe("defineConfig", () => {
         const config = defineConfig({});
         expect(config.include).toBe("**/*.md");
     });
+    it("should accept an inline Markdown banner", () => {
+        const config = defineConfig({ banner: "Hi · [x](/y/)" });
+        expect(config.banner).toBe("Hi · [x](/y/)");
+    });
+    it("should leave banner unset by default", () => {
+        expect(defineConfig({}).banner).toBeUndefined();
+    });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/actions/escape/copy.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copy a livemark default into `<root>/.livemark/<path>`.
+ *
+ * Throws when the path is not escapable, is not a livemark file, or the
+ * destination already exists. Returns the destination path.
+ */
+export declare function copyEscape(props: {
+    root: string;
+    sourceRoot: string;
+    path: string;
+}): string;

package/build/actions/escape/copy.js

@@ -0,0 +1,29 @@
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from "../../settings.js";
+/**
+ * Copy a livemark default into `<root>/.livemark/<path>`.
+ *
+ * Throws when the path is not escapable, is not a livemark file, or the
+ * destination already exists. Returns the destination path.
+ */
+export function copyEscape(props) {
+    const isTopLevelFile = !props.path.includes("/") && ESCAPABLE_FILES.includes(props.path);
+    const [first] = props.path.split("/");
+    const isFolderPath = !!first && ESCAPABLE_FOLDERS.includes(first) && !props.path.includes("..");
+    if (!isTopLevelFile && !isFolderPath) {
+        throw new Error(`'${props.path}' is not escapable (folders: ${ESCAPABLE_FOLDERS.join(", ")}; files: ${ESCAPABLE_FILES.join(", ")})`);
+    }
+    const src = join(props.sourceRoot, props.path);
+    if (!existsSync(src) || !statSync(src).isFile()) {
+        throw new Error(`'${props.path}' is not a livemark file`);
+    }
+    const dest = join(props.root, ".livemark", props.path);
+    if (existsSync(dest)) {
+        throw new Error(`.livemark/${props.path} already exists`);
+    }
+    mkdirSync(dirname(dest), { recursive: true });
+    writeFileSync(dest, readFileSync(src));
+    return dest;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/actions/escape/copy.unit.d.ts

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

package/build/actions/escape/copy.unit.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import { join } from "node:path";
+import { temporaryDirectoryTask } from "tempy";
+import { describe, expect, it } from "vite-plus/test";
+import { copyEscape } from "./copy.js";
+describe("copyEscape", () => {
+    it("should copy a default into .livemark/", () => temporaryDirectoryTask(async (tmpDir) => {
+        const sourceRoot = createSource(tmpDir);
+        const dest = copyEscape({ root: tmpDir, sourceRoot, path: "components/Footer.tsx" });
+        expect(dest).toBe(join(tmpDir, ".livemark", "components", "Footer.tsx"));
+        expect(fs.readFileSync(dest, "utf8")).toBe("default\n");
+    }));
+    it("should refuse to overwrite an existing override", () => temporaryDirectoryTask(async (tmpDir) => {
+        const sourceRoot = createSource(tmpDir);
+        copyEscape({ root: tmpDir, sourceRoot, path: "client.tsx" });
+        expect(() => copyEscape({ root: tmpDir, sourceRoot, path: "client.tsx" })).toThrow(/already exists/);
+    }));
+    it("should reject paths outside the escape contract", () => temporaryDirectoryTask(async (tmpDir) => {
+        const sourceRoot = createSource(tmpDir);
+        for (const path of ["index.ts", "components/../index.ts", "helpers/toc.ts"]) {
+            expect(() => copyEscape({ root: tmpDir, sourceRoot, path })).toThrow(/not escapable/);
+        }
+    }));
+    it("should reject an escapable path with no livemark file", () => temporaryDirectoryTask(async (tmpDir) => {
+        const sourceRoot = createSource(tmpDir);
+        expect(() => copyEscape({ root: tmpDir, sourceRoot, path: "components/Missing.tsx" })).toThrow(/not a livemark file/);
+    }));
+});
+function createSource(tmpDir) {
+    const sourceRoot = join(tmpDir, "source");
+    fs.mkdirSync(join(sourceRoot, "components"), { recursive: true });
+    fs.writeFileSync(join(sourceRoot, "components", "Footer.tsx"), "default\n");
+    fs.writeFileSync(join(sourceRoot, "client.tsx"), "default\n");
+    fs.writeFileSync(join(sourceRoot, "index.ts"), "default\n");
+    return sourceRoot;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/actions/escape/list.d.ts

@@ -0,0 +1,12 @@
+/** An escapable livemark file and whether the project already shadows it. */
+export interface Escape {
+    path: string;
+    escaped: boolean;
+}
+/**
+ * List every file a project can shadow under `.livemark/`, sorted by path.
+ */
+export declare function listEscapes(props: {
+    root: string;
+    sourceRoot: string;
+}): Escape[];

package/build/actions/escape/list.js

@@ -0,0 +1,27 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from "../../settings.js";
+/**
+ * List every file a project can shadow under `.livemark/`, sorted by path.
+ */
+export function listEscapes(props) {
+    const paths = [];
+    for (const folder of ESCAPABLE_FOLDERS) {
+        const dir = join(props.sourceRoot, folder);
+        if (!existsSync(dir))
+            continue;
+        for (const entry of readdirSync(dir)) {
+            if (statSync(join(dir, entry)).isFile())
+                paths.push(`${folder}/${entry}`);
+        }
+    }
+    for (const file of ESCAPABLE_FILES) {
+        if (existsSync(join(props.sourceRoot, file)))
+            paths.push(file);
+    }
+    return paths.sort().map((path) => ({
+        path,
+        escaped: existsSync(join(props.root, ".livemark", path)),
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/actions/escape/list.unit.d.ts

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

package/build/actions/escape/list.unit.js

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import { join } from "node:path";
+import { temporaryDirectoryTask } from "tempy";
+import { describe, expect, it } from "vite-plus/test";
+import { listEscapes } from "./list.js";
+describe("listEscapes", () => {
+    it("should list folder files and top-level files, sorted", () => temporaryDirectoryTask(async (tmpDir) => {
+        const sourceRoot = join(tmpDir, "source");
+        writeFile(join(sourceRoot, "components", "Footer.tsx"));
+        writeFile(join(sourceRoot, "styles", "general.css"));
+        writeFile(join(sourceRoot, "client.tsx"));
+        writeFile(join(sourceRoot, "index.ts"));
+        fs.mkdirSync(join(sourceRoot, "elements", "nested"), { recursive: true });
+        const escapes = listEscapes({ root: tmpDir, sourceRoot });
+        expect(escapes.map(escape => escape.path)).toEqual([
+            "client.tsx",
+            "components/Footer.tsx",
+            "styles/general.css",
+        ]);
+    }));
+    it("should mark files the project already shadows", () => temporaryDirectoryTask(async (tmpDir) => {
+        const sourceRoot = join(tmpDir, "source");
+        writeFile(join(sourceRoot, "components", "Footer.tsx"));
+        writeFile(join(sourceRoot, "components", "Header.tsx"));
+        writeFile(join(tmpDir, ".livemark", "components", "Footer.tsx"));
+        expect(listEscapes({ root: tmpDir, sourceRoot })).toEqual([
+            { path: "components/Footer.tsx", escaped: true },
+            { path: "components/Header.tsx", escaped: false },
+        ]);
+    }));
+});
+function writeFile(path) {
+    fs.mkdirSync(join(path, ".."), { recursive: true });
+    fs.writeFileSync(path, "default\n");
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/actions/target/build.d.ts

@@ -1,29 +1,12 @@
 /**
- * Synthesize a fully self-contained per-consumer Vite mount at
- * `<livemark-pkg>/targets/<hash>/`.
- *
- * The mount is built by copying livemark's `source/` wholesale, then
- * overlaying any matching files from the consumer's `.livemark/`. Every
- * file lives at its target path as a real file — no symlinks — so
- * Vite's relative-import and bare-specifier resolution all anchor
- * inside the target dir, where node_modules walks reach livemark's pnpm
- * subtree natively.
- *
- * Behavior:
- * - First run (target dir missing): full source copy + overlay.
- * - Subsequent runs: skip the source copy. Source is immutable in
- *   installed mode; in livemark's own dev the watcher keeps the target
- *   in sync. Only the `.livemark/` overlay is re-applied each time —
- *   cheap, and may have changed between runs.
- * - With `--clear` in argv: wipe the entire target dir (including
- *   downstream caches like `.vite/`, `.content-collections/`,
- *   `cache/`, `routeTree.gen.ts`) and rebuild from scratch. Use this
- *   to recover from a stale or corrupted cache.
- *
- * Returns the absolute path to the target dir.
+ * 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.
  */
-export declare function buildTarget(configPath: string): string;
-/** Compute the target dir for a given consumer config path without
- *  rebuilding it. Used by code that needs to write into the target
- *  (e.g. cache writers) outside of `buildTarget`'s setup phase. */
+export declare function buildTarget(props: {
+    configPath: string;
+    sourceDir: string;
+}): string;
+/** Locate the project's target dir without building it. */
 export declare function targetDirFor(configPath: string): string;

package/build/actions/target/build.js

@@ -1,84 +1,63 @@
-import { createHash } from "node:crypto";
-import { cpSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { cpSync, existsSync, mkdirSync, readlinkSync, rmSync, symlinkSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { resolveDependencyDir } from "../../helpers/dependency-dir.js";
 import { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from "../../settings.js";
-// This file ships at <livemark-pkg>/source/actions/target/build.ts AND
-// gets copied into <livemark-pkg>/targets/<hash>/actions/target/build.ts
-// as part of every per-consumer mount. content-collections loads the
-// COPIED version, so `import.meta.dirname` can land inside `targets/`.
-// Walk up to the first directory holding livemark's `package.json` so
-// SOURCE_DIR / TARGETS_ROOT always anchor at the package, never at a
-// per-consumer dir.
-const LIVEMARK_PKG = findLivemarkPkg(import.meta.dirname);
-const SOURCE_DIR = join(LIVEMARK_PKG, "source");
-const TARGETS_ROOT = join(LIVEMARK_PKG, "targets");
-function findLivemarkPkg(start) {
-    let cur = start;
-    while (cur !== dirname(cur)) {
-        if (existsSync(join(cur, "package.json")))
-            return cur;
-        cur = dirname(cur);
-    }
-    throw new Error(`Could not locate livemark package root from ${start}`);
-}
 /**
- * Synthesize a fully self-contained per-consumer Vite mount at
- * `<livemark-pkg>/targets/<hash>/`.
- *
- * The mount is built by copying livemark's `source/` wholesale, then
- * overlaying any matching files from the consumer's `.livemark/`. Every
- * file lives at its target path as a real file — no symlinks — so
- * Vite's relative-import and bare-specifier resolution all anchor
- * inside the target dir, where node_modules walks reach livemark's pnpm
- * subtree natively.
- *
- * Behavior:
- * - First run (target dir missing): full source copy + overlay.
- * - Subsequent runs: skip the source copy. Source is immutable in
- *   installed mode; in livemark's own dev the watcher keeps the target
- *   in sync. Only the `.livemark/` overlay is re-applied each time —
- *   cheap, and may have changed between runs.
- * - With `--clear` in argv: wipe the entire target dir (including
- *   downstream caches like `.vite/`, `.content-collections/`,
- *   `cache/`, `routeTree.gen.ts`) and rebuild from scratch. Use this
- *   to recover from a stale or corrupted cache.
- *
- * Returns the absolute path to the target dir.
+ * 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.
  */
-export function buildTarget(configPath) {
-    const targetDir = targetDirFor(configPath);
-    const overridesRoot = join(dirname(configPath), ".livemark");
-    const clear = process.argv.includes("--clear");
-    if (clear)
-        rmSync(targetDir, { recursive: true, force: true });
-    if (!existsSync(targetDir)) {
-        mkdirSync(targetDir, { recursive: true });
-        cpSync(SOURCE_DIR, targetDir, { recursive: true });
-    }
+export function buildTarget(props) {
+    const targetDir = targetDirFor(props.configPath);
+    const overridesRoot = dirname(targetDir);
+    mkdirSync(targetDir, { recursive: true });
+    cpSync(props.sourceDir, targetDir, {
+        recursive: true,
+        filter: src => isPackageFile(src) && !isEscapableFolder(src, props.sourceDir),
+    });
     for (const folder of ESCAPABLE_FOLDERS) {
-        const overlay = join(overridesRoot, folder);
-        if (!existsSync(overlay))
-            continue;
         const dest = join(targetDir, folder);
-        if (!existsSync(dest))
-            mkdirSync(dest, { recursive: true });
-        for (const f of readdirSync(overlay)) {
-            cpSync(join(overlay, f), join(dest, f), { recursive: true, force: true });
-        }
+        rmSync(dest, { recursive: true, force: true });
+        const source = join(props.sourceDir, folder);
+        if (existsSync(source))
+            cpSync(source, dest, { recursive: true, filter: isPackageFile });
+        const overlay = join(overridesRoot, folder);
+        if (existsSync(overlay))
+            cpSync(overlay, dest, { recursive: true });
     }
     for (const file of ESCAPABLE_FILES) {
         const overlay = join(overridesRoot, file);
-        if (!existsSync(overlay))
-            continue;
-        cpSync(overlay, join(targetDir, file), { force: true });
+        if (existsSync(overlay))
+            cpSync(overlay, join(targetDir, file));
     }
+    linkDependencies(targetDir, resolveDependencyDir(props.sourceDir));
     return targetDir;
 }
-/** Compute the target dir for a given consumer config path without
- *  rebuilding it. Used by code that needs to write into the target
- *  (e.g. cache writers) outside of `buildTarget`'s setup phase. */
+/** Locate the project's target dir without building it. */
 export function targetDirFor(configPath) {
-    const hash = createHash("sha256").update(configPath).digest("hex").slice(0, 16);
-    return join(TARGETS_ROOT, hash);
+    return join(dirname(configPath), ".livemark", ".target");
+}
+function isPackageFile(src) {
+    return !/\.unit\.tsx?$/.test(src) && basename(src) !== "fixtures";
+}
+function isEscapableFolder(src, sourceDir) {
+    return ESCAPABLE_FOLDERS.includes(relative(sourceDir, src));
+}
+function linkDependencies(targetDir, dependencyDir) {
+    const link = join(targetDir, "node_modules");
+    if (readLink(link) === resolve(dependencyDir))
+        return;
+    // Not recursive: a stale link must go without touching the store it points into.
+    rmSync(link, { force: true });
+    symlinkSync(dependencyDir, link, "junction");
+}
+function readLink(path) {
+    try {
+        return resolve(dirname(path), readlinkSync(path));
+    }
+    catch {
+        return undefined;
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../source/actions/target/build.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from \"node:crypto\"\nimport { cpSync, existsSync, mkdirSync, readdirSync, rmSync } from \"node:fs\"\nimport { dirname, join } from \"node:path\"\nimport { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from \"../../settings.ts\"\n\n// This file ships at <livemark-pkg>/source/actions/target/build.ts AND\n// gets copied into <livemark-pkg>/targets/<hash>/actions/target/build.ts\n// as part of every per-consumer mount. content-collections loads the\n// COPIED version, so `import.meta.dirname` can land inside `targets/`.\n// Walk up to the first directory holding livemark's `package.json` so\n// SOURCE_DIR / TARGETS_ROOT always anchor at the package, never at a\n// per-consumer dir.\nconst LIVEMARK_PKG = findLivemarkPkg(import.meta.dirname)\nconst SOURCE_DIR = join(LIVEMARK_PKG, \"source\")\nconst TARGETS_ROOT = join(LIVEMARK_PKG, \"targets\")\n\nfunction findLivemarkPkg(start: string) {\n  let cur = start\n  while (cur !== dirname(cur)) {\n    if (existsSync(join(cur, \"package.json\"))) return cur\n    cur = dirname(cur)\n  }\n  throw new Error(`Could not locate livemark package root from ${start}`)\n}\n\n/**\n * Synthesize a fully self-contained per-consumer Vite mount at\n * `<livemark-pkg>/targets/<hash>/`.\n *\n * The mount is built by copying livemark's `source/` wholesale, then\n * overlaying any matching files from the consumer's `.livemark/`. Every\n * file lives at its target path as a real file — no symlinks — so\n * Vite's relative-import and bare-specifier resolution all anchor\n * inside the target dir, where node_modules walks reach livemark's pnpm\n * subtree natively.\n *\n * Behavior:\n * - First run (target dir missing): full source copy + overlay.\n * - Subsequent runs: skip the source copy. Source is immutable in\n *   installed mode; in livemark's own dev the watcher keeps the target\n *   in sync. Only the `.livemark/` overlay is re-applied each time —\n *   cheap, and may have changed between runs.\n * - With `--clear` in argv: wipe the entire target dir (including\n *   downstream caches like `.vite/`, `.content-collections/`,\n *   `cache/`, `routeTree.gen.ts`) and rebuild from scratch. Use this\n *   to recover from a stale or corrupted cache.\n *\n * Returns the absolute path to the target dir.\n */\nexport function buildTarget(configPath: string) {\n  const targetDir = targetDirFor(configPath)\n  const overridesRoot = join(dirname(configPath), \".livemark\")\n  const clear = process.argv.includes(\"--clear\")\n\n  if (clear) rmSync(targetDir, { recursive: true, force: true })\n\n  if (!existsSync(targetDir)) {\n    mkdirSync(targetDir, { recursive: true })\n    cpSync(SOURCE_DIR, targetDir, { recursive: true })\n  }\n\n  for (const folder of ESCAPABLE_FOLDERS) {\n    const overlay = join(overridesRoot, folder)\n    if (!existsSync(overlay)) continue\n    const dest = join(targetDir, folder)\n    if (!existsSync(dest)) mkdirSync(dest, { recursive: true })\n    for (const f of readdirSync(overlay)) {\n      cpSync(join(overlay, f), join(dest, f), { recursive: true, force: true })\n    }\n  }\n  for (const file of ESCAPABLE_FILES) {\n    const overlay = join(overridesRoot, file)\n    if (!existsSync(overlay)) continue\n    cpSync(overlay, join(targetDir, file), { force: true })\n  }\n\n  return targetDir\n}\n\n/** Compute the target dir for a given consumer config path without\n *  rebuilding it. Used by code that needs to write into the target\n *  (e.g. cache writers) outside of `buildTarget`'s setup phase. */\nexport function targetDirFor(configPath: string) {\n  const hash = createHash(\"sha256\").update(configPath).digest(\"hex\").slice(0, 16)\n  return join(TARGETS_ROOT, hash)\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/build/actions/target/build.unit.js

@@ -0,0 +1,76 @@
+import { existsSync, readFileSync, readlinkSync, realpathSync } from "node:fs";
+import { mkdir, rm, symlink, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { temporaryDirectoryTask } from "tempy";
+import { describe, expect, it } from "vite-plus/test";
+import { buildTarget, targetDirFor } from "./build.js";
+describe("buildTarget", () => {
+    it("copies the source, overlays escapes and skips unit tests", () => temporaryDirectoryTask(async (root) => {
+        const { configPath, sourceDir } = await createFixture(root);
+        await put(join(root, "project/.livemark/components/Footer.tsx"), "escaped");
+        await put(join(root, "project/.livemark/head.ts"), "escaped head");
+        const targetDir = buildTarget({ configPath, sourceDir });
+        expect(targetDir).toBe(join(root, "project/.livemark/.target"));
+        expect(read(targetDir, "components/Footer.tsx")).toBe("escaped");
+        expect(read(targetDir, "components/Header.tsx")).toBe("default");
+        expect(read(targetDir, "head.ts")).toBe("escaped head");
+        expect(read(targetDir, "helpers/util.ts")).toBe("util");
+        expect(existsSync(join(targetDir, "helpers/util.unit.ts"))).toBe(false);
+    }));
+    it("drops escapes removed since the last run", () => temporaryDirectoryTask(async (root) => {
+        const { configPath, sourceDir } = await createFixture(root);
+        const overrides = join(root, "project/.livemark");
+        await put(join(overrides, "components/Footer.tsx"), "escaped");
+        await put(join(overrides, "routes/about.tsx"), "about");
+        await put(join(overrides, "head.ts"), "escaped head");
+        buildTarget({ configPath, sourceDir });
+        await rm(join(overrides, "components"), { recursive: true });
+        await rm(join(overrides, "routes"), { recursive: true });
+        await rm(join(overrides, "head.ts"));
+        const targetDir = buildTarget({ configPath, sourceDir });
+        expect(read(targetDir, "components/Footer.tsx")).toBe("default");
+        expect(existsSync(join(targetDir, "routes/about.tsx"))).toBe(false);
+        expect(read(targetDir, "head.ts")).toBe("head");
+    }));
+    it("keeps generated entries between runs", () => temporaryDirectoryTask(async (root) => {
+        const { configPath, sourceDir } = await createFixture(root);
+        const targetDir = buildTarget({ configPath, sourceDir });
+        await put(join(targetDir, "cache/changelog/entry.md"), "cached");
+        buildTarget({ configPath, sourceDir });
+        expect(read(targetDir, "cache/changelog/entry.md")).toBe("cached");
+    }));
+    it("links node_modules to livemark's dependencies and repairs a stale link", () => temporaryDirectoryTask(async (root) => {
+        const { configPath, sourceDir } = await createFixture(root);
+        const link = join(targetDirFor(configPath), "node_modules");
+        const dependencyDir = realpathSync(join(root, "livemark/node_modules"));
+        buildTarget({ configPath, sourceDir });
+        expect(readlinkSync(link)).toBe(dependencyDir);
+        await rm(link);
+        await mkdir(join(root, "elsewhere"));
+        await symlink(join(root, "elsewhere"), link, "junction");
+        buildTarget({ configPath, sourceDir });
+        expect(readlinkSync(link)).toBe(dependencyDir);
+        expect(existsSync(join(root, "elsewhere"))).toBe(true);
+    }));
+});
+async function createFixture(root) {
+    const sourceDir = join(root, "livemark/source");
+    await put(join(sourceDir, "components/Footer.tsx"), "default");
+    await put(join(sourceDir, "components/Header.tsx"), "default");
+    await put(join(sourceDir, "routes/index.tsx"), "index");
+    await put(join(sourceDir, "helpers/util.ts"), "util");
+    await put(join(sourceDir, "helpers/util.unit.ts"), "test");
+    await put(join(sourceDir, "head.ts"), "head");
+    await mkdir(join(root, "livemark/node_modules"));
+    const configPath = join(root, "project/livemark.config.ts");
+    await put(configPath, "export default {}");
+    return { configPath, sourceDir };
+}
+async function put(path, content) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content);
+}
+function read(dir, path) {
+    return readFileSync(join(dir, path), "utf-8");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build.unit.js","sourceRoot":"","sources":["../../../source/actions/target/build.unit.ts"],"names":[],"mappings":"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","sourcesContent":["import { existsSync, readFileSync, readlinkSync, realpathSync } from \"node:fs\"\nimport { mkdir, rm, symlink, writeFile } from \"node:fs/promises\"\nimport { dirname, join } from \"node:path\"\nimport { temporaryDirectoryTask } from \"tempy\"\nimport { describe, expect, it } from \"vite-plus/test\"\nimport { buildTarget, targetDirFor } from \"./build.ts\"\n\ndescribe(\"buildTarget\", () => {\n  it(\"copies the source, overlays escapes and skips unit tests\", () =>\n    temporaryDirectoryTask(async root => {\n      const { configPath, sourceDir } = await createFixture(root)\n      await put(join(root, \"project/.livemark/components/Footer.tsx\"), \"escaped\")\n      await put(join(root, \"project/.livemark/head.ts\"), \"escaped head\")\n\n      const targetDir = buildTarget({ configPath, sourceDir })\n\n      expect(targetDir).toBe(join(root, \"project/.livemark/.target\"))\n      expect(read(targetDir, \"components/Footer.tsx\")).toBe(\"escaped\")\n      expect(read(targetDir, \"components/Header.tsx\")).toBe(\"default\")\n      expect(read(targetDir, \"head.ts\")).toBe(\"escaped head\")\n      expect(read(targetDir, \"helpers/util.ts\")).toBe(\"util\")\n      expect(existsSync(join(targetDir, \"helpers/util.unit.ts\"))).toBe(false)\n    }))\n\n  it(\"drops escapes removed since the last run\", () =>\n    temporaryDirectoryTask(async root => {\n      const { configPath, sourceDir } = await createFixture(root)\n      const overrides = join(root, \"project/.livemark\")\n      await put(join(overrides, \"components/Footer.tsx\"), \"escaped\")\n      await put(join(overrides, \"routes/about.tsx\"), \"about\")\n      await put(join(overrides, \"head.ts\"), \"escaped head\")\n      buildTarget({ configPath, sourceDir })\n\n      await rm(join(overrides, \"components\"), { recursive: true })\n      await rm(join(overrides, \"routes\"), { recursive: true })\n      await rm(join(overrides, \"head.ts\"))\n      const targetDir = buildTarget({ configPath, sourceDir })\n\n      expect(read(targetDir, \"components/Footer.tsx\")).toBe(\"default\")\n      expect(existsSync(join(targetDir, \"routes/about.tsx\"))).toBe(false)\n      expect(read(targetDir, \"head.ts\")).toBe(\"head\")\n    }))\n\n  it(\"keeps generated entries between runs\", () =>\n    temporaryDirectoryTask(async root => {\n      const { configPath, sourceDir } = await createFixture(root)\n      const targetDir = buildTarget({ configPath, sourceDir })\n      await put(join(targetDir, \"cache/changelog/entry.md\"), \"cached\")\n\n      buildTarget({ configPath, sourceDir })\n\n      expect(read(targetDir, \"cache/changelog/entry.md\")).toBe(\"cached\")\n    }))\n\n  it(\"links node_modules to livemark's dependencies and repairs a stale link\", () =>\n    temporaryDirectoryTask(async root => {\n      const { configPath, sourceDir } = await createFixture(root)\n      const link = join(targetDirFor(configPath), \"node_modules\")\n      const dependencyDir = realpathSync(join(root, \"livemark/node_modules\"))\n\n      buildTarget({ configPath, sourceDir })\n      expect(readlinkSync(link)).toBe(dependencyDir)\n\n      await rm(link)\n      await mkdir(join(root, \"elsewhere\"))\n      await symlink(join(root, \"elsewhere\"), link, \"junction\")\n      buildTarget({ configPath, sourceDir })\n\n      expect(readlinkSync(link)).toBe(dependencyDir)\n      expect(existsSync(join(root, \"elsewhere\"))).toBe(true)\n    }))\n})\n\nasync function createFixture(root: string) {\n  const sourceDir = join(root, \"livemark/source\")\n  await put(join(sourceDir, \"components/Footer.tsx\"), \"default\")\n  await put(join(sourceDir, \"components/Header.tsx\"), \"default\")\n  await put(join(sourceDir, \"routes/index.tsx\"), \"index\")\n  await put(join(sourceDir, \"helpers/util.ts\"), \"util\")\n  await put(join(sourceDir, \"helpers/util.unit.ts\"), \"test\")\n  await put(join(sourceDir, \"head.ts\"), \"head\")\n  await mkdir(join(root, \"livemark/node_modules\"))\n  const configPath = join(root, \"project/livemark.config.ts\")\n  await put(configPath, \"export default {}\")\n  return { configPath, sourceDir }\n}\n\nasync function put(path: string, content: string) {\n  await mkdir(dirname(path), { recursive: true })\n  await writeFile(path, content)\n}\n\nfunction read(dir: string, path: string) {\n  return readFileSync(join(dir, path), \"utf-8\")\n}\n"]}

package/build/actions/target/clear.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Wipe the project's target dir so the next run rebuilds it from scratch.
+ */
+export declare function clearTarget(configPath: string): string;

package/build/actions/target/clear.js

@@ -0,0 +1,14 @@
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+import { targetDirFor } from "./build.js";
+/**
+ * Wipe the project's target dir so the next run rebuilds it from scratch.
+ */
+export function clearTarget(configPath) {
+    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;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xlYXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zb3VyY2UvYWN0aW9ucy90YXJnZXQvY2xlYXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLFNBQVMsQ0FBQTtBQUNoQyxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ2hDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxZQUFZLENBQUE7QUFFekM7O0dBRUc7QUFDSCxNQUFNLFVBQVUsV0FBVyxDQUFDLFVBQWtCO0lBQzVDLE1BQU0sU0FBUyxHQUFHLFlBQVksQ0FBQyxVQUFVLENBQUMsQ0FBQTtJQUMxQyxtRkFBbUY7SUFDbkYsTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsY0FBYyxDQUFDLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQTtJQUN4RCxNQUFNLENBQUMsU0FBUyxFQUFFLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQTtJQUNuRCxPQUFPLFNBQVMsQ0FBQTtBQUNsQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcm1TeW5jIH0gZnJvbSBcIm5vZGU6ZnNcIlxuaW1wb3J0IHsgam9pbiB9IGZyb20gXCJub2RlOnBhdGhcIlxuaW1wb3J0IHsgdGFyZ2V0RGlyRm9yIH0gZnJvbSBcIi4vYnVpbGQudHNcIlxuXG4vKipcbiAqIFdpcGUgdGhlIHByb2plY3QncyB0YXJnZXQgZGlyIHNvIHRoZSBuZXh0IHJ1biByZWJ1aWxkcyBpdCBmcm9tIHNjcmF0Y2guXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjbGVhclRhcmdldChjb25maWdQYXRoOiBzdHJpbmcpIHtcbiAgY29uc3QgdGFyZ2V0RGlyID0gdGFyZ2V0RGlyRm9yKGNvbmZpZ1BhdGgpXG4gIC8vIFVubGluayB0aGUgZGVwZW5kZW5jeSBsaW5rIGZpcnN0IHNvIHRoZSByZWN1cnNpdmUgcmVtb3ZlIGNhbm5vdCByZWFjaCB0aGUgc3RvcmUuXG4gIHJtU3luYyhqb2luKHRhcmdldERpciwgXCJub2RlX21vZHVsZXNcIiksIHsgZm9yY2U6IHRydWUgfSlcbiAgcm1TeW5jKHRhcmdldERpciwgeyByZWN1cnNpdmU6IHRydWUsIGZvcmNlOiB0cnVlIH0pXG4gIHJldHVybiB0YXJnZXREaXJcbn1cbiJdfQ==

package/build/actions/target/clear.unit.d.ts

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