livemark 0.10.5 → 0.11.1

package/build/actions/changelog/build.d.ts

@@ -0,0 +1,22 @@
+import type { Config } from "../../models/config.ts";
+import type { ChangelogSection } from "../../models/section.ts";
+interface ChangelogEntry {
+    slug: string;
+    title: string;
+    date?: string;
+    body: string;
+    sourceUrl?: string;
+}
+/** Glob (absolute path) covering all cached changelog markdown files for
+ *  a given consumer. Used by content-collections to include them in the
+ *  article scan. */
+export declare function cacheIncludeGlob(config: Config): string;
+/** Build the per-version changelog cache files. Livemark allows one
+ *  changelog per project, so all cache state lives in a single
+ *  `cache/changelog/`: the rendered `.md` entries plus a `meta.json`
+ *  holding the etag for conditional GETs. On refresh we wipe only the
+ *  `.md` files, leaving meta intact. */
+export declare function buildChangelog(section: ChangelogSection, config: Config): Promise<void>;
+/** Parse CHANGELOG.md into per-version entries using mdast */
+export declare function splitLocalChangelog(body: string): ChangelogEntry[];
+export {};

package/build/actions/changelog/build.js

@@ -0,0 +1,198 @@
+import { access, mkdir, readFile, readdir, rm, writeFile, } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import slugify from "@sindresorhus/slugify";
+import { toString as mdastToString } from "mdast-util-to-string";
+import remarkParse from "remark-parse";
+import remarkStringify from "remark-stringify";
+import { unified } from "unified";
+import { visit } from "unist-util-visit";
+import { isGitHubUrl, parseGitHubRepo } from "../../helpers/changelog-source.js";
+import { targetDirFor } from "../target/build.js";
+const CACHE_SUBDIR = "cache/changelog";
+const parser = unified().use(remarkParse);
+const stringifier = unified().use(remarkStringify, {
+    bullet: "-",
+    fences: true,
+    emphasis: "_",
+});
+/** Glob (absolute path) covering all cached changelog markdown files for
+ *  a given consumer. Used by content-collections to include them in the
+ *  article scan. */
+export function cacheIncludeGlob(config) {
+    return join(targetDirFor(config.configPath), CACHE_SUBDIR, "**", "*.md");
+}
+/** Build the per-version changelog cache files. Livemark allows one
+ *  changelog per project, so all cache state lives in a single
+ *  `cache/changelog/`: the rendered `.md` entries plus a `meta.json`
+ *  holding the etag for conditional GETs. On refresh we wipe only the
+ *  `.md` files, leaving meta intact. */
+export async function buildChangelog(section, config) {
+    const targetDir = targetDirFor(config.configPath);
+    const cacheDir = join(targetDir, CACHE_SUBDIR);
+    const metaPath = join(cacheDir, "meta.json");
+    const entries = isGitHubUrl(section.source)
+        ? await buildFromGitHub(section.source, metaPath, cacheDir)
+        : await buildFromLocal(section.source, config.root);
+    if (entries === undefined)
+        return;
+    await mkdir(cacheDir, { recursive: true });
+    for (const f of await readdir(cacheDir).catch(() => [])) {
+        if (f.endsWith(".md"))
+            await rm(join(cacheDir, f), { force: true });
+    }
+    for (const entry of entries) {
+        const markdown = wrapFrontmatter(entry, section);
+        await writeFile(join(cacheDir, `${entry.slug}.md`), markdown, "utf-8");
+    }
+}
+async function buildFromLocal(source, root) {
+    const filePath = resolve(root, source);
+    const body = await readFile(filePath, "utf-8");
+    return splitLocalChangelog(body);
+}
+/** Parse CHANGELOG.md into per-version entries using mdast */
+export function splitLocalChangelog(body) {
+    const tree = parser.parse(body);
+    const entries = [];
+    let current;
+    for (const child of tree.children) {
+        if (child.type === "heading" && child.depth === 2) {
+            if (current)
+                entries.push(finalizeEntry(current));
+            current = { heading: mdastToString(child), children: [] };
+        }
+        else if (current) {
+            current.children.push(child);
+        }
+    }
+    if (current)
+        entries.push(finalizeEntry(current));
+    return entries;
+}
+function finalizeEntry(input) {
+    const versionMatch = input.heading.match(/^\[?([^\]\s]+)\]?/);
+    const version = versionMatch?.[1] ?? input.heading;
+    const dateMatch = input.heading.match(/\d{4}-\d{2}-\d{2}/);
+    const body = renderEntryBody(input.children);
+    return {
+        slug: slugify(version),
+        title: version,
+        date: dateMatch?.[0],
+        body,
+    };
+}
+/** Serialize an entry's mdast children back to markdown */
+function renderEntryBody(children) {
+    const root = { type: "root", children };
+    return stringifier.stringify(root).trimEnd();
+}
+/** Drop the body's leading h1 (typically the conventional-changelog
+ * `# 0.7.2 (2026-04-25)` boilerplate that duplicates the article's title),
+ * shift h2–h6 up by one so subsection headings become h1 / h2 / …, and
+ * escape stray `<` outside code so MDX doesn't mistake them for JSX. */
+function processBody(body) {
+    const tree = parser.parse(body);
+    visit(tree, "heading", node => {
+        if (node.depth > 1)
+            node.depth = (node.depth - 1);
+    });
+    if (tree.children[0]?.type === "heading" && tree.children[0].depth === 1) {
+        tree.children.shift();
+    }
+    return escapeMdxAngles(stringifier.stringify(tree).trimEnd());
+}
+/** Escape `<` to `\<` outside fenced code blocks and inline backtick spans
+ * so commit messages with placeholders like `<subdir>` don't get parsed as
+ * JSX by MDX. */
+function escapeMdxAngles(markdown) {
+    let inFence = false;
+    return markdown
+        .split("\n")
+        .map(line => {
+        if (line.startsWith("```")) {
+            inFence = !inFence;
+            return line;
+        }
+        if (inFence)
+            return line;
+        return line.replace(/`[^`]*`|</g, match => match === "<" ? "\\<" : match);
+    })
+        .join("\n");
+}
+async function buildFromGitHub(source, metaPath, cacheDir) {
+    const parsed = parseGitHubRepo(source);
+    if (!parsed) {
+        throw new Error(`Could not parse GitHub repo from source: ${source}`);
+    }
+    const url = `https://api.github.com/repos/${parsed.owner}/${parsed.repo}/releases?per_page=100`;
+    const headers = {
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+    };
+    const token = process.env.GITHUB_TOKEN;
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const meta = await readMeta(metaPath);
+    const hasCache = await exists(cacheDir);
+    if (meta && hasCache)
+        headers["If-None-Match"] = meta.etag;
+    const res = await fetch(url, { headers });
+    if (res.status === 304)
+        return undefined;
+    if (!res.ok) {
+        const remaining = res.headers.get("x-ratelimit-remaining");
+        const reset = res.headers.get("x-ratelimit-reset");
+        const msg = `GitHub API ${res.status} ${res.statusText} (rate-limit remaining: ${remaining ?? "?"}, reset: ${reset ?? "?"})`;
+        if (hasCache) {
+            console.warn(`${msg} — falling back to cached changelog`);
+            return undefined;
+        }
+        throw new Error(msg);
+    }
+    const releases = (await res.json());
+    const etag = res.headers.get("etag");
+    if (etag) {
+        await mkdir(dirname(metaPath), { recursive: true });
+        await writeFile(metaPath, JSON.stringify({ etag, fetchedAt: new Date().toISOString() }, null, 2), "utf-8");
+    }
+    return releases.map(release => ({
+        slug: slugify(release.tag_name),
+        title: release.tag_name,
+        date: release.published_at ?? undefined,
+        body: (release.body ?? "").trim(),
+        sourceUrl: release.html_url ?? undefined,
+    }));
+}
+function wrapFrontmatter(entry, section) {
+    const lines = [
+        "---",
+        `title: ${entry.title}`,
+        `path: ${section.prefix}${entry.slug}/`,
+    ];
+    if (entry.date)
+        lines.push(`date: ${entry.date}`);
+    if (entry.sourceUrl) {
+        lines.push(`sourceUrl: ${entry.sourceUrl}`, "sourceAction: view");
+    }
+    lines.push("---", "", `# ${entry.title}`, "", processBody(entry.body));
+    return lines.join("\n");
+}
+async function readMeta(metaPath) {
+    try {
+        const raw = await readFile(metaPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build.js","sourceRoot":"","sources":["../../../source/actions/changelog/build.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  access,\n  mkdir,\n  readFile,\n  readdir,\n  rm,\n  writeFile,\n} from \"node:fs/promises\"\nimport { dirname, join, resolve } from \"node:path\"\nimport slugify from \"@sindresorhus/slugify\"\nimport type { Root, RootContent } from \"mdast\"\nimport { toString as mdastToString } from \"mdast-util-to-string\"\nimport remarkParse from \"remark-parse\"\nimport remarkStringify from \"remark-stringify\"\nimport { unified } from \"unified\"\nimport { visit } from \"unist-util-visit\"\nimport type { Config } from \"../../models/config.ts\"\nimport type { ChangelogSection } from \"../../models/section.ts\"\nimport { isGitHubUrl, parseGitHubRepo } from \"../../helpers/changelog-source.ts\"\nimport { targetDirFor } from \"../target/build.ts\"\n\ninterface Release {\n  tag_name: string\n  name?: string | null\n  published_at?: string | null\n  body?: string | null\n  html_url?: string | null\n}\n\ninterface CacheMeta {\n  etag: string\n  fetchedAt: string\n}\n\ninterface ChangelogEntry {\n  slug: string\n  title: string\n  date?: string\n  body: string\n  sourceUrl?: string\n}\n\nconst CACHE_SUBDIR = \"cache/changelog\"\n\nconst parser = unified().use(remarkParse)\nconst stringifier = unified().use(remarkStringify, {\n  bullet: \"-\",\n  fences: true,\n  emphasis: \"_\",\n})\n\n/** Glob (absolute path) covering all cached changelog markdown files for\n *  a given consumer. Used by content-collections to include them in the\n *  article scan. */\nexport function cacheIncludeGlob(config: Config) {\n  return join(targetDirFor(config.configPath), CACHE_SUBDIR, \"**\", \"*.md\")\n}\n\n/** Build the per-version changelog cache files. Livemark allows one\n *  changelog per project, so all cache state lives in a single\n *  `cache/changelog/`: the rendered `.md` entries plus a `meta.json`\n *  holding the etag for conditional GETs. On refresh we wipe only the\n *  `.md` files, leaving meta intact. */\nexport async function buildChangelog(\n  section: ChangelogSection,\n  config: Config,\n) {\n  const targetDir = targetDirFor(config.configPath)\n  const cacheDir = join(targetDir, CACHE_SUBDIR)\n  const metaPath = join(cacheDir, \"meta.json\")\n\n  const entries = isGitHubUrl(section.source)\n    ? await buildFromGitHub(section.source, metaPath, cacheDir)\n    : await buildFromLocal(section.source, config.root)\n\n  if (entries === undefined) return\n\n  await mkdir(cacheDir, { recursive: true })\n  for (const f of await readdir(cacheDir).catch(() => [])) {\n    if (f.endsWith(\".md\")) await rm(join(cacheDir, f), { force: true })\n  }\n\n  for (const entry of entries) {\n    const markdown = wrapFrontmatter(entry, section)\n    await writeFile(join(cacheDir, `${entry.slug}.md`), markdown, \"utf-8\")\n  }\n}\n\nasync function buildFromLocal(source: string, root: string) {\n  const filePath = resolve(root, source)\n  const body = await readFile(filePath, \"utf-8\")\n  return splitLocalChangelog(body)\n}\n\n/** Parse CHANGELOG.md into per-version entries using mdast */\nexport function splitLocalChangelog(body: string): ChangelogEntry[] {\n  const tree = parser.parse(body) as Root\n  const entries: ChangelogEntry[] = []\n  let current: { heading: string; children: RootContent[] } | undefined\n\n  for (const child of tree.children) {\n    if (child.type === \"heading\" && child.depth === 2) {\n      if (current) entries.push(finalizeEntry(current))\n      current = { heading: mdastToString(child), children: [] }\n    } else if (current) {\n      current.children.push(child)\n    }\n  }\n  if (current) entries.push(finalizeEntry(current))\n  return entries\n}\n\nfunction finalizeEntry(input: {\n  heading: string\n  children: RootContent[]\n}): ChangelogEntry {\n  const versionMatch = input.heading.match(/^\\[?([^\\]\\s]+)\\]?/)\n  const version = versionMatch?.[1] ?? input.heading\n  const dateMatch = input.heading.match(/\\d{4}-\\d{2}-\\d{2}/)\n  const body = renderEntryBody(input.children)\n  return {\n    slug: slugify(version),\n    title: version,\n    date: dateMatch?.[0],\n    body,\n  }\n}\n\n/** Serialize an entry's mdast children back to markdown */\nfunction renderEntryBody(children: RootContent[]) {\n  const root: Root = { type: \"root\", children }\n  return stringifier.stringify(root).trimEnd()\n}\n\n/** Drop the body's leading h1 (typically the conventional-changelog\n * `# 0.7.2 (2026-04-25)` boilerplate that duplicates the article's title),\n * shift h2–h6 up by one so subsection headings become h1 / h2 / …, and\n * escape stray `<` outside code so MDX doesn't mistake them for JSX. */\nfunction processBody(body: string) {\n  const tree = parser.parse(body) as Root\n  visit(tree, \"heading\", node => {\n    if (node.depth > 1) node.depth = (node.depth - 1) as 1 | 2 | 3 | 4 | 5\n  })\n  if (tree.children[0]?.type === \"heading\" && tree.children[0].depth === 1) {\n    tree.children.shift()\n  }\n  return escapeMdxAngles(stringifier.stringify(tree).trimEnd())\n}\n\n/** Escape `<` to `\\<` outside fenced code blocks and inline backtick spans\n * so commit messages with placeholders like `<subdir>` don't get parsed as\n * JSX by MDX. */\nfunction escapeMdxAngles(markdown: string) {\n  let inFence = false\n  return markdown\n    .split(\"\\n\")\n    .map(line => {\n      if (line.startsWith(\"```\")) {\n        inFence = !inFence\n        return line\n      }\n      if (inFence) return line\n      return line.replace(/`[^`]*`|</g, match =>\n        match === \"<\" ? \"\\\\<\" : match,\n      )\n    })\n    .join(\"\\n\")\n}\n\nasync function buildFromGitHub(\n  source: string,\n  metaPath: string,\n  cacheDir: string,\n): Promise<ChangelogEntry[] | undefined> {\n  const parsed = parseGitHubRepo(source)\n  if (!parsed) {\n    throw new Error(`Could not parse GitHub repo from source: ${source}`)\n  }\n\n  const url = `https://api.github.com/repos/${parsed.owner}/${parsed.repo}/releases?per_page=100`\n  const headers: Record<string, string> = {\n    Accept: \"application/vnd.github+json\",\n    \"X-GitHub-Api-Version\": \"2022-11-28\",\n  }\n\n  const token = process.env.GITHUB_TOKEN\n  if (token) headers.Authorization = `Bearer ${token}`\n\n  const meta = await readMeta(metaPath)\n  const hasCache = await exists(cacheDir)\n  if (meta && hasCache) headers[\"If-None-Match\"] = meta.etag\n\n  const res = await fetch(url, { headers })\n\n  if (res.status === 304) return undefined\n\n  if (!res.ok) {\n    const remaining = res.headers.get(\"x-ratelimit-remaining\")\n    const reset = res.headers.get(\"x-ratelimit-reset\")\n    const msg = `GitHub API ${res.status} ${res.statusText} (rate-limit remaining: ${remaining ?? \"?\"}, reset: ${reset ?? \"?\"})`\n    if (hasCache) {\n      console.warn(`${msg} — falling back to cached changelog`)\n      return undefined\n    }\n    throw new Error(msg)\n  }\n\n  const releases = (await res.json()) as Release[]\n  const etag = res.headers.get(\"etag\")\n  if (etag) {\n    await mkdir(dirname(metaPath), { recursive: true })\n    await writeFile(\n      metaPath,\n      JSON.stringify(\n        { etag, fetchedAt: new Date().toISOString() } satisfies CacheMeta,\n        null,\n        2,\n      ),\n      \"utf-8\",\n    )\n  }\n\n  return releases.map(release => ({\n    slug: slugify(release.tag_name),\n    title: release.tag_name,\n    date: release.published_at ?? undefined,\n    body: (release.body ?? \"\").trim(),\n    sourceUrl: release.html_url ?? undefined,\n  }))\n}\n\nfunction wrapFrontmatter(entry: ChangelogEntry, section: ChangelogSection) {\n  const lines = [\n    \"---\",\n    `title: ${entry.title}`,\n    `path: ${section.prefix}${entry.slug}/`,\n  ]\n  if (entry.date) lines.push(`date: ${entry.date}`)\n  if (entry.sourceUrl) {\n    lines.push(`sourceUrl: ${entry.sourceUrl}`, \"sourceAction: view\")\n  }\n  lines.push(\"---\", \"\", `# ${entry.title}`, \"\", processBody(entry.body))\n  return lines.join(\"\\n\")\n}\n\nasync function readMeta(metaPath: string): Promise<CacheMeta | undefined> {\n  try {\n    const raw = await readFile(metaPath, \"utf-8\")\n    return JSON.parse(raw) as CacheMeta\n  } catch {\n    return undefined\n  }\n}\n\nasync function exists(path: string) {\n  try {\n    await access(path)\n    return true\n  } catch {\n    return false\n  }\n}\n"]}

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

@@ -0,0 +1,12 @@
+import type { Config } from "../../models/config.ts";
+/**
+ * Load and validate a config file, checking --config/-c CLI arg, then cwd.
+ *
+ * If a path is provided explicitly (arg or `--config`/`-c`) and the
+ * file is missing, throws — the user asked for a specific config and
+ * it isn't there. If no path is provided and no `livemark.config.ts`
+ * exists in cwd, falls back to the default config with a synthesized
+ * `configPath = <cwd>/livemark.config.ts` so downstream code (target
+ * hash, watcher) still has a stable per-project key.
+ */
+export declare function loadConfig(path?: string): Promise<Config>;

package/build/actions/config/load.js

@@ -0,0 +1,41 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { defineConfig } from "./define.js";
+/**
+ * Load and validate a config file, checking --config/-c CLI arg, then cwd.
+ *
+ * If a path is provided explicitly (arg or `--config`/`-c`) and the
+ * file is missing, throws — the user asked for a specific config and
+ * it isn't there. If no path is provided and no `livemark.config.ts`
+ * exists in cwd, falls back to the default config with a synthesized
+ * `configPath = <cwd>/livemark.config.ts` so downstream code (target
+ * hash, watcher) still has a stable per-project key.
+ */
+export async function loadConfig(path) {
+    const configIndex = process.argv.findIndex(a => a === "-c" || a === "--config");
+    const cliPath = configIndex !== -1 ? process.argv[configIndex + 1] : undefined;
+    const explicit = path ?? cliPath;
+    const resolved = resolve(explicit ?? "livemark.config.ts");
+    let input = {};
+    if (existsSync(resolved)) {
+        // Cache-bust the ESM import so dev-server restart reloads edits on disk.
+        const url = `${pathToFileURL(resolved).href}?t=${Date.now()}`;
+        const module = await import(__rewriteRelativeImportExtension(url));
+        input = module.default ?? {};
+    }
+    else if (explicit) {
+        throw new Error(`Config file not found: ${resolved}`);
+    }
+    const validated = defineConfig(input);
+    return { ...validated, root: dirname(resolved), configPath: resolved };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+import { join } from "node:path";
+import { temporaryDirectoryTask } from "tempy";
+import { describe, expect, it } from "vite-plus/test";
+import { loadConfig } from "./load.js";
+describe("loadConfig", () => {
+    it("should throw when an explicit path points at a missing file", async () => {
+        await expect(loadConfig("/nonexistent/config.ts")).rejects.toThrow(/not found/);
+    });
+    it("should return defaults when no path is given and cwd has no config", () => temporaryDirectoryTask(async (tmpDir) => {
+        const cwd = process.cwd();
+        try {
+            process.chdir(tmpDir);
+            const config = await loadConfig();
+            expect(config.title).toBe("Livemark");
+            expect(config.include).toBe("**/*.md");
+            expect(config.root).toBe(tmpDir);
+            expect(config.configPath).toBe(join(tmpDir, "livemark.config.ts"));
+        }
+        finally {
+            process.chdir(cwd);
+        }
+    }));
+    it("should load config from explicit path", () => temporaryDirectoryTask(async (tmpDir) => {
+        const configPath = join(tmpDir, "livemark.config.ts");
+        fs.writeFileSync(configPath, 'export default { include: "articles/**/*.mdx" }\n');
+        const config = await loadConfig(configPath);
+        expect(config.include).toBe("articles/**/*.mdx");
+        expect(config.root).toBe(tmpDir);
+    }));
+    it("should apply defaults when fields are omitted", () => temporaryDirectoryTask(async (tmpDir) => {
+        const configPath = join(tmpDir, "livemark.config.ts");
+        fs.writeFileSync(configPath, "export default {}\n");
+        const config = await loadConfig(configPath);
+        expect(config.include).toBe("**/*.md");
+        expect(config.title).toBe("Livemark");
+    }));
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+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 targetDirFor(configPath: string): string;

package/build/actions/target/build.js

@@ -0,0 +1,87 @@
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+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.
+ */
+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 });
+    }
+    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 });
+        }
+    }
+    for (const file of ESCAPABLE_FILES) {
+        const overlay = join(overridesRoot, file);
+        if (!existsSync(overlay))
+            continue;
+        cpSync(overlay, join(targetDir, file), { force: true });
+    }
+    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. */
+export function targetDirFor(configPath) {
+    const hash = createHash("sha256")
+        .update(configPath)
+        .digest("hex")
+        .slice(0, 16);
+    return join(TARGETS_ROOT, hash);
+}
+//# 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\")\n    .update(configPath)\n    .digest(\"hex\")\n    .slice(0, 16)\n  return join(TARGETS_ROOT, hash)\n}\n"]}

package/build/commands/build.js

@@ -0,0 +1,15 @@
+import { join } from "node:path";
+import { Command } from "commander";
+import { createBuilder } from "vite";
+const configFile = join(import.meta.dirname, "..", "..", "source", "vite.config.ts");
+/**
+ * Build the site for production.
+ */
+export const build = new Command("build")
+    .description("Build the site for production")
+    .option("--clear", "Wipe and fully rebuild the runtime target dir")
+    .action(async () => {
+    const builder = await createBuilder({ configFile });
+    await builder.buildApp();
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zb3VyY2UvY29tbWFuZHMvYnVpbGQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUNoQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ25DLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxNQUFNLENBQUE7QUFFcEMsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUNyQixPQUFPLElBQUksQ0FBQyxPQUFPLEVBQ25CLElBQUksRUFDSixJQUFJLEVBQ0osUUFBUSxFQUNSLGdCQUFnQixDQUNqQixDQUFBO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxLQUFLLEdBQUcsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDO0tBQ3RDLFdBQVcsQ0FBQywrQkFBK0IsQ0FBQztLQUM1QyxNQUFNLENBQUMsU0FBUyxFQUFFLCtDQUErQyxDQUFDO0tBQ2xFLE1BQU0sQ0FBQyxLQUFLLElBQUksRUFBRTtJQUNqQixNQUFNLE9BQU8sR0FBRyxNQUFNLGFBQWEsQ0FBQyxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUE7SUFDbkQsTUFBTSxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUE7QUFDMUIsQ0FBQyxDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBqb2luIH0gZnJvbSBcIm5vZGU6cGF0aFwiXG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiXG5pbXBvcnQgeyBjcmVhdGVCdWlsZGVyIH0gZnJvbSBcInZpdGVcIlxuXG5jb25zdCBjb25maWdGaWxlID0gam9pbihcbiAgaW1wb3J0Lm1ldGEuZGlybmFtZSxcbiAgXCIuLlwiLFxuICBcIi4uXCIsXG4gIFwic291cmNlXCIsXG4gIFwidml0ZS5jb25maWcudHNcIixcbilcblxuLyoqXG4gKiBCdWlsZCB0aGUgc2l0ZSBmb3IgcHJvZHVjdGlvbi5cbiAqL1xuZXhwb3J0IGNvbnN0IGJ1aWxkID0gbmV3IENvbW1hbmQoXCJidWlsZFwiKVxuICAuZGVzY3JpcHRpb24oXCJCdWlsZCB0aGUgc2l0ZSBmb3IgcHJvZHVjdGlvblwiKVxuICAub3B0aW9uKFwiLS1jbGVhclwiLCBcIldpcGUgYW5kIGZ1bGx5IHJlYnVpbGQgdGhlIHJ1bnRpbWUgdGFyZ2V0IGRpclwiKVxuICAuYWN0aW9uKGFzeW5jICgpID0+IHtcbiAgICBjb25zdCBidWlsZGVyID0gYXdhaXQgY3JlYXRlQnVpbGRlcih7IGNvbmZpZ0ZpbGUgfSlcbiAgICBhd2FpdCBidWlsZGVyLmJ1aWxkQXBwKClcbiAgfSlcbiJdfQ==

package/{target → build}/commands/escape.d.ts

@@ -1,6 +1,6 @@
 import { Command } from "commander";
 /**
- * List or copy overridable livemark files into `.livemark/`.
+ * List or copy escapable livemark files into `.livemark/`.
  *
  * Without an argument, prints every file you can shadow. With a path, copies
  * the default from the livemark package into `.livemark/<path>`; fails if the

package/build/commands/escape.js

@@ -0,0 +1,62 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { Command } from "commander";
+import pc from "picocolors";
+import { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from "../settings.js";
+const defaultsRoot = join(import.meta.dirname, "..", "..", "source");
+/**
+ * List or copy escapable livemark files into `.livemark/`.
+ *
+ * Without an argument, prints every file you can shadow. With a path, copies
+ * the default from the livemark package into `.livemark/<path>`; fails if the
+ * destination already exists.
+ */
+export const escape = new Command("escape")
+    .description("List or copy escapable livemark files into .livemark/")
+    .argument("[path]", "path relative to .livemark/ (e.g. components/Footer.tsx, client.tsx)")
+    .action((relPath) => {
+    if (!relPath) {
+        for (const file of listEscapable())
+            console.log(file);
+        console.log(pc.dim("\nRun 'livemark escape <path>' to copy a file into .livemark/"));
+        return;
+    }
+    const isTopLevelFile = !relPath.includes("/") && ESCAPABLE_FILES.includes(relPath);
+    const [first] = relPath.split("/");
+    const isFolderPath = !!first && ESCAPABLE_FOLDERS.includes(first) && !relPath.includes("..");
+    if (!isTopLevelFile && !isFolderPath) {
+        console.error(pc.red(`Error: '${relPath}' is not escapable (folders: ${ESCAPABLE_FOLDERS.join(", ")}; files: ${ESCAPABLE_FILES.join(", ")})`));
+        process.exit(1);
+    }
+    const src = join(defaultsRoot, relPath);
+    if (!existsSync(src) || !statSync(src).isFile()) {
+        console.error(pc.red(`Error: '${relPath}' is not a livemark file`));
+        process.exit(1);
+    }
+    const dest = join(process.cwd(), ".livemark", relPath);
+    if (existsSync(dest)) {
+        console.error(pc.red(`Error: .livemark/${relPath} already exists`));
+        process.exit(1);
+    }
+    mkdirSync(dirname(dest), { recursive: true });
+    writeFileSync(dest, readFileSync(src));
+    console.log(`Copied ${pc.dim(relPath)} → ${pc.green(`.livemark/${relPath}`)}`);
+});
+function listEscapable() {
+    const files = [];
+    for (const folder of ESCAPABLE_FOLDERS) {
+        const dir = join(defaultsRoot, folder);
+        if (!existsSync(dir))
+            continue;
+        for (const entry of readdirSync(dir)) {
+            if (statSync(join(dir, entry)).isFile())
+                files.push(`${folder}/${entry}`);
+        }
+    }
+    for (const file of ESCAPABLE_FILES) {
+        if (existsSync(join(defaultsRoot, file)))
+            files.push(file);
+    }
+    return files.sort();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/commands/preview.js

@@ -0,0 +1,19 @@
+import { join } from "node:path";
+import { Command } from "commander";
+import { preview as vitePreview } from "vite";
+const configFile = join(import.meta.dirname, "..", "..", "source", "vite.config.ts");
+/**
+ * Preview the production build locally.
+ */
+export const preview = new Command("preview")
+    .description("Preview the production build locally")
+    .option("--clear", "Wipe and fully rebuild the runtime target dir")
+    .action(async () => {
+    const server = await vitePreview({
+        configFile,
+        preview: { port: 8000, host: true },
+    });
+    server.printUrls();
+    server.bindCLIShortcuts({ print: true });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldmlldy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NvdXJjZS9jb21tYW5kcy9wcmV2aWV3LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDaEMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUNuQyxPQUFPLEVBQUUsT0FBTyxJQUFJLFdBQVcsRUFBRSxNQUFNLE1BQU0sQ0FBQTtBQUU3QyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQ3JCLE9BQU8sSUFBSSxDQUFDLE9BQU8sRUFDbkIsSUFBSSxFQUNKLElBQUksRUFDSixRQUFRLEVBQ1IsZ0JBQWdCLENBQ2pCLENBQUE7QUFFRDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxJQUFJLE9BQU8sQ0FBQyxTQUFTLENBQUM7S0FDMUMsV0FBVyxDQUFDLHNDQUFzQyxDQUFDO0tBQ25ELE1BQU0sQ0FBQyxTQUFTLEVBQUUsK0NBQStDLENBQUM7S0FDbEUsTUFBTSxDQUFDLEtBQUssSUFBSSxFQUFFO0lBQ2pCLE1BQU0sTUFBTSxHQUFHLE1BQU0sV0FBVyxDQUFDO1FBQy9CLFVBQVU7UUFDVixPQUFPLEVBQUUsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUU7S0FDcEMsQ0FBQyxDQUFBO0lBQ0YsTUFBTSxDQUFDLFNBQVMsRUFBRSxDQUFBO0lBQ2xCLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFBO0FBQzFDLENBQUMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgam9pbiB9IGZyb20gXCJub2RlOnBhdGhcIlxuaW1wb3J0IHsgQ29tbWFuZCB9IGZyb20gXCJjb21tYW5kZXJcIlxuaW1wb3J0IHsgcHJldmlldyBhcyB2aXRlUHJldmlldyB9IGZyb20gXCJ2aXRlXCJcblxuY29uc3QgY29uZmlnRmlsZSA9IGpvaW4oXG4gIGltcG9ydC5tZXRhLmRpcm5hbWUsXG4gIFwiLi5cIixcbiAgXCIuLlwiLFxuICBcInNvdXJjZVwiLFxuICBcInZpdGUuY29uZmlnLnRzXCIsXG4pXG5cbi8qKlxuICogUHJldmlldyB0aGUgcHJvZHVjdGlvbiBidWlsZCBsb2NhbGx5LlxuICovXG5leHBvcnQgY29uc3QgcHJldmlldyA9IG5ldyBDb21tYW5kKFwicHJldmlld1wiKVxuICAuZGVzY3JpcHRpb24oXCJQcmV2aWV3IHRoZSBwcm9kdWN0aW9uIGJ1aWxkIGxvY2FsbHlcIilcbiAgLm9wdGlvbihcIi0tY2xlYXJcIiwgXCJXaXBlIGFuZCBmdWxseSByZWJ1aWxkIHRoZSBydW50aW1lIHRhcmdldCBkaXJcIilcbiAgLmFjdGlvbihhc3luYyAoKSA9PiB7XG4gICAgY29uc3Qgc2VydmVyID0gYXdhaXQgdml0ZVByZXZpZXcoe1xuICAgICAgY29uZmlnRmlsZSxcbiAgICAgIHByZXZpZXc6IHsgcG9ydDogODAwMCwgaG9zdDogdHJ1ZSB9LFxuICAgIH0pXG4gICAgc2VydmVyLnByaW50VXJscygpXG4gICAgc2VydmVyLmJpbmRDTElTaG9ydGN1dHMoeyBwcmludDogdHJ1ZSB9KVxuICB9KVxuIl19