livemark 0.2.0 → 0.7.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License (MIT)
+
+Copyright © 2025 Evgeny Karev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,7 @@
 # Livemark
 
-Livemark implementation in TypeScript
+[![Build](https://img.shields.io/github/actions/workflow/status/datisthq/livemark/general.yaml?branch=main)](https://github.com/datisthq/livemark/actions)
+[![Coverage](https://img.shields.io/codecov/c/github/datisthq/livemark/main)](https://codecov.io/gh/datisthq/livemark)
+[![Version](https://img.shields.io/npm/v/livemark)](https://www.npmjs.com/package/livemark)
+
+Livemark turns your .md files into a fast, modern documentation site — with Shiki, Mermaid, LaTeX, MDX components, blog and changelog sections, all built in. For more information, please read the [project's documentation](https://livemark.dev).

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

@@ -0,0 +1,14 @@
+import type { Config } from "../../models/config.ts";
+import type { ChangelogSection } from "../../models/section.ts";
+interface ChangelogEntry {
+    slug: string;
+    title: string;
+    date?: string;
+    body: string;
+}
+export declare function cacheIncludeGlob(): string;
+/** Build the per-version changelog cache files for a changelog section */
+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,158 @@
+import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { 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 "../../website/helpers/changelog-source.js";
+const CACHE_DIR = ".livemark/cache/changelog";
+const META_FILE = ".livemark/cache/changelog.meta.json";
+const parser = unified().use(remarkParse);
+const stringifier = unified().use(remarkStringify, {
+    bullet: "-",
+    fences: true,
+    emphasis: "_",
+});
+export function cacheIncludeGlob() {
+    return `${CACHE_DIR}/**/*.md`;
+}
+/** Build the per-version changelog cache files for a changelog section */
+export async function buildChangelog(section, config) {
+    const cacheDir = join(config.root, CACHE_DIR);
+    const metaPath = join(config.root, META_FILE);
+    const entries = isGitHubUrl(section.source)
+        ? await buildFromGitHub(section.source, metaPath, cacheDir)
+        : await buildFromLocal(section.source, config.root);
+    if (entries === undefined)
+        return;
+    await rm(cacheDir, { recursive: true, force: true });
+    await mkdir(cacheDir, { recursive: 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();
+}
+/** Shift h2–h6 up by one so the version becomes the article's h1 */
+function promoteHeadings(body) {
+    const tree = parser.parse(body);
+    visit(tree, "heading", node => {
+        if (node.depth > 1)
+            node.depth = (node.depth - 1);
+    });
+    return stringifier.stringify(tree).trimEnd();
+}
+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 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?.slice(0, 10),
+        body: (release.body ?? "").trim(),
+    }));
+}
+function wrapFrontmatter(entry, section) {
+    const lines = [
+        "---",
+        `title: ${entry.title}`,
+        `path: ${section.prefix}${entry.slug}/`,
+    ];
+    if (entry.date)
+        lines.push(`date: ${entry.date}`);
+    lines.push("---", "", `# ${entry.title}`, "", promoteHeadings(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":["../../../actions/changelog/build.ts"],"names":[],"mappings":"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","sourcesContent":["import { access, mkdir, readFile, rm, writeFile } from \"node:fs/promises\"\nimport { 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 {\n  isGitHubUrl,\n  parseGitHubRepo,\n} from \"../../website/helpers/changelog-source.ts\"\n\ninterface Release {\n  tag_name: string\n  name?: string | null\n  published_at?: string | null\n  body?: 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}\n\nconst CACHE_DIR = \".livemark/cache/changelog\"\nconst META_FILE = \".livemark/cache/changelog.meta.json\"\n\nconst parser = unified().use(remarkParse)\nconst stringifier = unified().use(remarkStringify, {\n  bullet: \"-\",\n  fences: true,\n  emphasis: \"_\",\n})\n\nexport function cacheIncludeGlob() {\n  return `${CACHE_DIR}/**/*.md`\n}\n\n/** Build the per-version changelog cache files for a changelog section */\nexport async function buildChangelog(\n  section: ChangelogSection,\n  config: Config,\n) {\n  const cacheDir = join(config.root, CACHE_DIR)\n  const metaPath = join(config.root, META_FILE)\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 rm(cacheDir, { recursive: true, force: true })\n  await mkdir(cacheDir, { recursive: true })\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/** Shift h2–h6 up by one so the version becomes the article's h1 */\nfunction promoteHeadings(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  return stringifier.stringify(tree).trimEnd()\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 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?.slice(0, 10),\n    body: (release.body ?? \"\").trim(),\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  lines.push(\"---\", \"\", `# ${entry.title}`, \"\", promoteHeadings(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/changelog/build.unit.js

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vite-plus/test";
+import { splitLocalChangelog } from "./build.js";
+describe("splitLocalChangelog", () => {
+    it("splits by h2 headings", () => {
+        const input = `# Changelog
+
+## [0.2.0] - 2026-04-15
+
+### Added
+
+- Foo
+
+## [0.1.0] - 2026-04-10
+
+Initial release.
+`;
+        const entries = splitLocalChangelog(input);
+        expect(entries).toHaveLength(2);
+        expect(entries[0]?.title).toBe("0.2.0");
+        expect(entries[0]?.date).toBe("2026-04-15");
+        expect(entries[0]?.slug).toBe("0-2-0");
+        expect(entries[1]?.title).toBe("0.1.0");
+        expect(entries[1]?.date).toBe("2026-04-10");
+    });
+    it("preserves h3 heading structure in body", () => {
+        const input = `## 1.0.0
+
+### Added
+
+- Thing one
+`;
+        const entries = splitLocalChangelog(input);
+        expect(entries[0]?.body).toContain("### Added");
+        expect(entries[0]?.body).toContain("- Thing one");
+    });
+    it("ignores ## inside fenced code blocks", () => {
+        const input = `## 1.0.0
+
+Some prose.
+
+\`\`\`md
+## Not a real version heading
+\`\`\`
+
+## 0.9.0
+
+Older.
+`;
+        const entries = splitLocalChangelog(input);
+        expect(entries).toHaveLength(2);
+        expect(entries[0]?.title).toBe("1.0.0");
+        expect(entries[0]?.body).toContain("Not a real version heading");
+        expect(entries[1]?.title).toBe("0.9.0");
+    });
+    it("handles bare version headings without brackets or date", () => {
+        const input = `## v1.2.3
+
+Release notes.
+`;
+        const entries = splitLocalChangelog(input);
+        expect(entries[0]?.title).toBe("v1.2.3");
+        expect(entries[0]?.slug).toBe("v1-2-3");
+        expect(entries[0]?.date).toBeUndefined();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,6 @@
+import type { z } from "zod";
+import { UserConfig } from "../../models/config.ts";
+/**
+ * Validate and fill defaults for a partial config object.
+ */
+export declare function defineConfig(input: z.input<typeof UserConfig>): z.output<typeof UserConfig>;

package/build/actions/config/define.js

@@ -0,0 +1,8 @@
+import { UserConfig } from "../../models/config.js";
+/**
+ * Validate and fill defaults for a partial config object.
+ */
+export function defineConfig(input) {
+    return UserConfig.parse(input);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmaW5lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vYWN0aW9ucy9jb25maWcvZGVmaW5lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQTtBQUVuRDs7R0FFRztBQUNILE1BQU0sVUFBVSxZQUFZLENBQzFCLEtBQWlDO0lBRWpDLE9BQU8sVUFBVSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQTtBQUNoQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyB6IH0gZnJvbSBcInpvZFwiXG5pbXBvcnQgeyBVc2VyQ29uZmlnIH0gZnJvbSBcIi4uLy4uL21vZGVscy9jb25maWcudHNcIlxuXG4vKipcbiAqIFZhbGlkYXRlIGFuZCBmaWxsIGRlZmF1bHRzIGZvciBhIHBhcnRpYWwgY29uZmlnIG9iamVjdC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGRlZmluZUNvbmZpZyhcbiAgaW5wdXQ6IHouaW5wdXQ8dHlwZW9mIFVzZXJDb25maWc+LFxuKTogei5vdXRwdXQ8dHlwZW9mIFVzZXJDb25maWc+IHtcbiAgcmV0dXJuIFVzZXJDb25maWcucGFyc2UoaW5wdXQpXG59XG4iXX0=

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

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vite-plus/test";
+import { defineConfig } from "./define.js";
+describe("defineConfig", () => {
+    it("should accept include as a string", () => {
+        const config = defineConfig({ include: "articles/**/*.mdx" });
+        expect(config.include).toBe("articles/**/*.mdx");
+    });
+    it("should accept include as an array", () => {
+        const config = defineConfig({
+            include: ["articles/**/*.mdx", "guides/**/*.mdx"],
+        });
+        expect(config.include).toEqual(["articles/**/*.mdx", "guides/**/*.mdx"]);
+    });
+    it("should accept optional exclude", () => {
+        const config = defineConfig({
+            include: "**/*.mdx",
+            exclude: "drafts/**",
+        });
+        expect(config.exclude).toBe("drafts/**");
+    });
+    it("should allow omitting exclude", () => {
+        const config = defineConfig({ include: "**/*.mdx" });
+        expect(config.exclude).toBeUndefined();
+    });
+    it("should reject missing include", () => {
+        expect(() => defineConfig({})).toThrow();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+import type { Config } from "../../models/config.ts";
+/**
+ * Load and validate a config file, checking --config/-c CLI arg, then cwd.
+ */
+export declare function loadConfig(path?: string): Promise<Config>;

package/build/actions/config/load.js

@@ -0,0 +1,25 @@
+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 { 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.
+ */
+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 resolved = resolve(path ?? cliPath ?? "livemark.config.ts");
+    // 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));
+    const input = defineConfig(module.default);
+    return { ...input, root: dirname(resolved), configPath: resolved };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,23 @@
+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 no config file exists", async () => {
+        await expect(loadConfig("/nonexistent/config.ts")).rejects.toThrow();
+    });
+    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 validate loaded config", () => temporaryDirectoryTask(async (tmpDir) => {
+        const configPath = join(tmpDir, "livemark.config.ts");
+        fs.writeFileSync(configPath, "export default {}\n");
+        await expect(loadConfig(configPath)).rejects.toThrow();
+    }));
+});
+//# sourceMappingURL=data:application/json;base64,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

package/build/commands/build.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+/**
+ * Build the site for production.
+ */
+export declare const build: Command;

package/build/commands/build.js

@@ -0,0 +1,14 @@
+import { join } from "node:path";
+import { Command } from "commander";
+import { createBuilder } from "vite";
+const configFile = join(import.meta.dirname, "..", "website", "vite.config.ts");
+/**
+ * Build the site for production.
+ */
+export const build = new Command("build")
+    .description("Build the site for production")
+    .action(async () => {
+    const builder = await createBuilder({ configFile });
+    await builder.buildApp();
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9jb21tYW5kcy9idWlsZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ2hDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDbkMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLE1BQU0sQ0FBQTtBQUVwQyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsT0FBTyxJQUFJLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQTtBQUUvRTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FBRyxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUM7S0FDdEMsV0FBVyxDQUFDLCtCQUErQixDQUFDO0tBQzVDLE1BQU0sQ0FBQyxLQUFLLElBQUksRUFBRTtJQUNqQixNQUFNLE9BQU8sR0FBRyxNQUFNLGFBQWEsQ0FBQyxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUE7SUFDbkQsTUFBTSxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUE7QUFDMUIsQ0FBQyxDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBqb2luIH0gZnJvbSBcIm5vZGU6cGF0aFwiXG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiXG5pbXBvcnQgeyBjcmVhdGVCdWlsZGVyIH0gZnJvbSBcInZpdGVcIlxuXG5jb25zdCBjb25maWdGaWxlID0gam9pbihpbXBvcnQubWV0YS5kaXJuYW1lLCBcIi4uXCIsIFwid2Vic2l0ZVwiLCBcInZpdGUuY29uZmlnLnRzXCIpXG5cbi8qKlxuICogQnVpbGQgdGhlIHNpdGUgZm9yIHByb2R1Y3Rpb24uXG4gKi9cbmV4cG9ydCBjb25zdCBidWlsZCA9IG5ldyBDb21tYW5kKFwiYnVpbGRcIilcbiAgLmRlc2NyaXB0aW9uKFwiQnVpbGQgdGhlIHNpdGUgZm9yIHByb2R1Y3Rpb25cIilcbiAgLmFjdGlvbihhc3luYyAoKSA9PiB7XG4gICAgY29uc3QgYnVpbGRlciA9IGF3YWl0IGNyZWF0ZUJ1aWxkZXIoeyBjb25maWdGaWxlIH0pXG4gICAgYXdhaXQgYnVpbGRlci5idWlsZEFwcCgpXG4gIH0pXG4iXX0=

package/build/commands/escape.d.ts

@@ -0,0 +1,9 @@
+import { Command } from "commander";
+/**
+ * List or copy overridable 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 declare const escape: Command;

package/build/commands/escape.js

@@ -0,0 +1,56 @@
+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 { OVERRIDE_SUBDIRS } from "../website/plugins/vite-livemark.js";
+const defaultsRoot = join(import.meta.dirname, "..", "website");
+/**
+ * List or copy overridable 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 overridable livemark files into .livemark/")
+    .argument("[path]", "path relative to .livemark/ (e.g. components/Footer.tsx)")
+    .action((relPath) => {
+    if (!relPath) {
+        for (const file of listOverridable())
+            console.log(file);
+        console.log(pc.dim("\nRun 'livemark escape <path>' to copy a file into .livemark/"));
+        return;
+    }
+    const [first] = relPath.split("/");
+    if (!first || !OVERRIDE_SUBDIRS.includes(first) || relPath.includes("..")) {
+        console.error(pc.red(`Error: '${relPath}' is not under an overridable subdir (${OVERRIDE_SUBDIRS.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 listOverridable() {
+    const files = [];
+    for (const subdir of OVERRIDE_SUBDIRS) {
+        const dir = join(defaultsRoot, subdir);
+        if (!existsSync(dir))
+            continue;
+        for (const entry of readdirSync(dir)) {
+            if (statSync(join(dir, entry)).isFile())
+                files.push(`${subdir}/${entry}`);
+        }
+    }
+    return files.sort();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/commands/preview.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+/**
+ * Preview the production build locally.
+ */
+export declare const preview: Command;

package/build/commands/preview.js

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

package/build/commands/start.d.ts

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+/**
+ * Start a development server.
+ */
+export declare const start: Command;

package/build/commands/start.js

@@ -0,0 +1,19 @@
+import { join } from "node:path";
+import { Command } from "commander";
+import { createServer } from "vite";
+const configFile = join(import.meta.dirname, "..", "website", "vite.config.ts");
+/**
+ * Start a development server.
+ */
+export const start = new Command("start")
+    .description("Start a live server")
+    .action(async () => {
+    const server = await createServer({
+        configFile,
+        server: { port: 8000, host: true },
+    });
+    await server.listen();
+    server.printUrls();
+    server.bindCLIShortcuts({ print: true });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9jb21tYW5kcy9zdGFydC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ2hDLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDbkMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLE1BQU0sQ0FBQTtBQUVuQyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsT0FBTyxJQUFJLENBQUMsT0FBTyxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQTtBQUUvRTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FBRyxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUM7S0FDdEMsV0FBVyxDQUFDLHFCQUFxQixDQUFDO0tBQ2xDLE1BQU0sQ0FBQyxLQUFLLElBQUksRUFBRTtJQUNqQixNQUFNLE1BQU0sR0FBRyxNQUFNLFlBQVksQ0FBQztRQUNoQyxVQUFVO1FBQ1YsTUFBTSxFQUFFLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFO0tBQ25DLENBQUMsQ0FBQTtJQUNGLE1BQU0sTUFBTSxDQUFDLE1BQU0sRUFBRSxDQUFBO0lBQ3JCLE1BQU0sQ0FBQyxTQUFTLEVBQUUsQ0FBQTtJQUNsQixNQUFNLENBQUMsZ0JBQWdCLENBQUMsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQTtBQUMxQyxDQUFDLENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGpvaW4gfSBmcm9tIFwibm9kZTpwYXRoXCJcbmltcG9ydCB7IENvbW1hbmQgfSBmcm9tIFwiY29tbWFuZGVyXCJcbmltcG9ydCB7IGNyZWF0ZVNlcnZlciB9IGZyb20gXCJ2aXRlXCJcblxuY29uc3QgY29uZmlnRmlsZSA9IGpvaW4oaW1wb3J0Lm1ldGEuZGlybmFtZSwgXCIuLlwiLCBcIndlYnNpdGVcIiwgXCJ2aXRlLmNvbmZpZy50c1wiKVxuXG4vKipcbiAqIFN0YXJ0IGEgZGV2ZWxvcG1lbnQgc2VydmVyLlxuICovXG5leHBvcnQgY29uc3Qgc3RhcnQgPSBuZXcgQ29tbWFuZChcInN0YXJ0XCIpXG4gIC5kZXNjcmlwdGlvbihcIlN0YXJ0IGEgbGl2ZSBzZXJ2ZXJcIilcbiAgLmFjdGlvbihhc3luYyAoKSA9PiB7XG4gICAgY29uc3Qgc2VydmVyID0gYXdhaXQgY3JlYXRlU2VydmVyKHtcbiAgICAgIGNvbmZpZ0ZpbGUsXG4gICAgICBzZXJ2ZXI6IHsgcG9ydDogODAwMCwgaG9zdDogdHJ1ZSB9LFxuICAgIH0pXG4gICAgYXdhaXQgc2VydmVyLmxpc3RlbigpXG4gICAgc2VydmVyLnByaW50VXJscygpXG4gICAgc2VydmVyLmJpbmRDTElTaG9ydGN1dHMoeyBwcmludDogdHJ1ZSB9KVxuICB9KVxuIl19