livemark 0.7.2 → 0.8.0

package/source/program.ts

@@ -0,0 +1,18 @@
+import { Command } from "commander"
+import { build } from "./commands/build.ts"
+import { escape } from "./commands/escape.ts"
+import { preview } from "./commands/preview.ts"
+import { start } from "./commands/start.ts"
+import { helpConfiguration } from "./helpers/program.ts"
+import packageJson from "../package.json" with { type: "json" }
+
+export const program = new Command()
+  .name("livemark")
+  .description("Livemark static site generator")
+  .version(packageJson.version, "-v, --version", "display the livemark version")
+  .option("-c, --config <path>", "path to config file")
+  .configureHelp(helpConfiguration)
+  .addCommand(start)
+  .addCommand(build)
+  .addCommand(preview)
+  .addCommand(escape)

package/source/settings.ts

@@ -0,0 +1,6 @@
+/** Sub-directories of `website/` that participate in the override mechanism. */
+export const OVERRIDE_SUBDIRS: readonly string[] = [
+  "components",
+  "elements",
+  "styles",
+]

package/{build/website → source}/vite.config.ts

@@ -13,9 +13,9 @@ import {
 import react from "@vitejs/plugin-react"
 import { defineConfig } from "vite"
 import svgr from "vite-plugin-svgr"
-import { loadConfig } from "../actions/config/load.ts"
-import { WebsiteConfig } from "../models/config.ts"
-import { OVERRIDE_SUBDIRS } from "../settings.ts"
+import { loadConfig } from "./actions/config/load.ts"
+import { WebsiteConfig } from "./models/config.ts"
+import { OVERRIDE_SUBDIRS } from "./settings.ts"
 import { livemark } from "./plugins/vite-livemark.ts"
 
 const config = await loadConfig()

package/{build → target}/actions/changelog/build.d.ts

@@ -5,6 +5,7 @@ interface ChangelogEntry {
     title: string;
     date?: string;
     body: string;
+    sourceUrl?: string;
 }
 export declare function cacheIncludeGlob(): string;
 /** Build the per-version changelog cache files for a changelog section */

package/target/actions/changelog/build.js

@@ -0,0 +1,187 @@
+import { access, mkdir, readFile, 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";
+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();
+}
+/** 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":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AACzE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAClD,OAAO,OAAO,MAAM,uBAAuB,CAAA;AAE3C,OAAO,EAAE,QAAQ,IAAI,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAChE,OAAO,WAAW,MAAM,cAAc,CAAA;AACtC,OAAO,eAAe,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACjC,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAGxC,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAA;AAuBhF,MAAM,SAAS,GAAG,2BAA2B,CAAA;AAC7C,MAAM,SAAS,GAAG,qCAAqC,CAAA;AAEvD,MAAM,MAAM,GAAG,OAAO,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC,CAAA;AACzC,MAAM,WAAW,GAAG,OAAO,EAAE,CAAC,GAAG,CAAC,eAAe,EAAE;IACjD,MAAM,EAAE,GAAG;IACX,MAAM,EAAE,IAAI;IACZ,QAAQ,EAAE,GAAG;CACd,CAAC,CAAA;AAEF,MAAM,UAAU,gBAAgB;IAC9B,OAAO,GAAG,SAAS,UAAU,CAAA;AAC/B,CAAC;AAED,0EAA0E;AAC1E,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,OAAyB,EACzB,MAAc;IAEd,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;IAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;IAE7C,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC;QACzC,CAAC,CAAC,MAAM,eAAe,CAAC,OAAO,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC;QAC3D,CAAC,CAAC,MAAM,cAAc,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;IAErD,IAAI,OAAO,KAAK,SAAS;QAAE,OAAM;IAEjC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;IACpD,MAAM,KAAK,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;IAE1C,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,QAAQ,GAAG,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAChD,MAAM,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,KAAK,CAAC,IAAI,KAAK,CAAC,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAA;IACxE,CAAC;AACH,CAAC;AAED,KAAK,UAAU,cAAc,CAAC,MAAc,EAAE,IAAY;IACxD,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IACtC,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;IAC9C,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAA;AAClC,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAC9C,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAS,CAAA;IACvC,MAAM,OAAO,GAAqB,EAAE,CAAA;IACpC,IAAI,OAAiE,CAAA;IAErE,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClC,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;YAClD,IAAI,OAAO;gBAAE,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAA;YACjD,OAAO,GAAG,EAAE,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAA;QAC3D,CAAC;aAAM,IAAI,OAAO,EAAE,CAAC;YACnB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAC9B,CAAC;IACH,CAAC;IACD,IAAI,OAAO;QAAE,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAA;IACjD,OAAO,OAAO,CAAA;AAChB,CAAC;AAED,SAAS,aAAa,CAAC,KAGtB;IACC,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAA;IAC7D,MAAM,OAAO,GAAG,YAAY,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAA;IAClD,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAA;IAC1D,MAAM,IAAI,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;IAC5C,OAAO;QACL,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC;QACtB,KAAK,EAAE,OAAO;QACd,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;QACpB,IAAI;KACL,CAAA;AACH,CAAC;AAED,2DAA2D;AAC3D,SAAS,eAAe,CAAC,QAAuB;IAC9C,MAAM,IAAI,GAAS,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAA;IAC7C,OAAO,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,CAAA;AAC9C,CAAC;AAED;;;wEAGwE;AACxE,SAAS,WAAW,CAAC,IAAY;IAC/B,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAS,CAAA;IACvC,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE;QAC5B,IAAI,IAAI,CAAC,KAAK,GAAG,CAAC;YAAE,IAAI,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAsB,CAAA;IACxE,CAAC,CAAC,CAAA;IACF,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;QACzE,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAA;IACvB,CAAC;IACD,OAAO,eAAe,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,CAAC,CAAA;AAC/D,CAAC;AAED;;iBAEiB;AACjB,SAAS,eAAe,CAAC,QAAgB;IACvC,IAAI,OAAO,GAAG,KAAK,CAAA;IACnB,OAAO,QAAQ;SACZ,KAAK,CAAC,IAAI,CAAC;SACX,GAAG,CAAC,IAAI,CAAC,EAAE;QACV,IAAI,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO,GAAG,CAAC,OAAO,CAAA;YAClB,OAAO,IAAI,CAAA;QACb,CAAC;QACD,IAAI,OAAO;YAAE,OAAO,IAAI,CAAA;QACxB,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,KAAK,CAAC,EAAE,CACxC,KAAK,KAAK,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAC9B,CAAA;IACH,CAAC,CAAC;SACD,IAAI,CAAC,IAAI,CAAC,CAAA;AACf,CAAC;AAED,KAAK,UAAU,eAAe,CAC5B,MAAc,EACd,QAAgB,EAChB,QAAgB;IAEhB,MAAM,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC,CAAA;IACtC,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,4CAA4C,MAAM,EAAE,CAAC,CAAA;IACvE,CAAC;IAED,MAAM,GAAG,GAAG,gCAAgC,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI,wBAAwB,CAAA;IAC/F,MAAM,OAAO,GAA2B;QACtC,MAAM,EAAE,6BAA6B;QACrC,sBAAsB,EAAE,YAAY;KACrC,CAAA;IAED,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAA;IACtC,IAAI,KAAK;QAAE,OAAO,CAAC,aAAa,GAAG,UAAU,KAAK,EAAE,CAAA;IAEpD,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAA;IACrC,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,CAAA;IACvC,IAAI,IAAI,IAAI,QAAQ;QAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC,IAAI,CAAA;IAE1D,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,CAAA;IAEzC,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG;QAAE,OAAO,SAAS,CAAA;IAExC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QACZ,MAAM,SAAS,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAA;QAC1D,MAAM,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAA;QAClD,MAAM,GAAG,GAAG,cAAc,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,UAAU,2BAA2B,SAAS,IAAI,GAAG,YAAY,KAAK,IAAI,GAAG,GAAG,CAAA;QAC5H,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,CAAC,IAAI,CAAC,GAAG,GAAG,qCAAqC,CAAC,CAAA;YACzD,OAAO,SAAS,CAAA;QAClB,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAAA;IACtB,CAAC;IAED,MAAM,QAAQ,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAAc,CAAA;IAChD,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;IACpC,IAAI,IAAI,EAAE,CAAC;QACT,MAAM,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;QACnD,MAAM,SAAS,CACb,QAAQ,EACR,IAAI,CAAC,SAAS,CACZ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAsB,EACjE,IAAI,EACJ,CAAC,CACF,EACD,OAAO,CACR,CAAA;IACH,CAAC;IAED,OAAO,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAC9B,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC;QAC/B,KAAK,EAAE,OAAO,CAAC,QAAQ;QACvB,IAAI,EAAE,OAAO,CAAC,YAAY,IAAI,SAAS;QACvC,IAAI,EAAE,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE;QACjC,SAAS,EAAE,OAAO,CAAC,QAAQ,IAAI,SAAS;KACzC,CAAC,CAAC,CAAA;AACL,CAAC;AAED,SAAS,eAAe,CAAC,KAAqB,EAAE,OAAyB;IACvE,MAAM,KAAK,GAAG;QACZ,KAAK;QACL,UAAU,KAAK,CAAC,KAAK,EAAE;QACvB,SAAS,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC,IAAI,GAAG;KACxC,CAAA;IACD,IAAI,KAAK,CAAC,IAAI;QAAE,KAAK,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,IAAI,EAAE,CAAC,CAAA;IACjD,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;QACpB,KAAK,CAAC,IAAI,CAAC,cAAc,KAAK,CAAC,SAAS,EAAE,EAAE,oBAAoB,CAAC,CAAA;IACnE,CAAC;IACD,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAA;IACtE,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACzB,CAAC;AAED,KAAK,UAAU,QAAQ,CAAC,QAAgB;IACtC,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;QAC7C,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAc,CAAA;IACrC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAA;IAClB,CAAC;AACH,CAAC;AAED,KAAK,UAAU,MAAM,CAAC,IAAY;IAChC,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,IAAI,CAAC,CAAA;QAClB,OAAO,IAAI,CAAA;IACb,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAA;IACd,CAAC;AACH,CAAC","sourcesContent":["import { access, mkdir, readFile, rm, writeFile } 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\"\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_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/** 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/target/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/target/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmaW5lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc291cmNlL2FjdGlvbnMvY29uZmlnL2RlZmluZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sd0JBQXdCLENBQUE7QUFFbkQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsWUFBWSxDQUMxQixLQUFpQztJQUVqQyxPQUFPLFVBQVUsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUE7QUFDaEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgeiB9IGZyb20gXCJ6b2RcIlxuaW1wb3J0IHsgVXNlckNvbmZpZyB9IGZyb20gXCIuLi8uLi9tb2RlbHMvY29uZmlnLnRzXCJcblxuLyoqXG4gKiBWYWxpZGF0ZSBhbmQgZmlsbCBkZWZhdWx0cyBmb3IgYSBwYXJ0aWFsIGNvbmZpZyBvYmplY3QuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWZpbmVDb25maWcoXG4gIGlucHV0OiB6LmlucHV0PHR5cGVvZiBVc2VyQ29uZmlnPixcbik6IHoub3V0cHV0PHR5cGVvZiBVc2VyQ29uZmlnPiB7XG4gIHJldHVybiBVc2VyQ29uZmlnLnBhcnNlKGlucHV0KVxufVxuIl19

package/target/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/target/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/target/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZC51bml0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc291cmNlL2FjdGlvbnMvY29uZmlnL2xvYWQudW5pdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxTQUFTLENBQUE7QUFDeEIsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUNoQyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxPQUFPLENBQUE7QUFDOUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFDckQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUV0QyxRQUFRLENBQUMsWUFBWSxFQUFFLEdBQUcsRUFBRTtJQUMxQixFQUFFLENBQUMseUNBQXlDLEVBQUUsS0FBSyxJQUFJLEVBQUU7UUFDdkQsTUFBTSxNQUFNLENBQUMsVUFBVSxDQUFDLHdCQUF3QixDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUE7SUFDdEUsQ0FBQyxDQUFDLENBQUE7SUFFRixFQUFFLENBQUMsdUNBQXVDLEVBQUUsR0FBRyxFQUFFLENBQy9DLHNCQUFzQixDQUFDLEtBQUssRUFBQyxNQUFNLEVBQUMsRUFBRTtRQUNwQyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsTUFBTSxFQUFFLG9CQUFvQixDQUFDLENBQUE7UUFDckQsRUFBRSxDQUFDLGFBQWEsQ0FDZCxVQUFVLEVBQ1YsbURBQW1ELENBQ3BELENBQUE7UUFDRCxNQUFNLE1BQU0sR0FBRyxNQUFNLFVBQVUsQ0FBQyxVQUFVLENBQUMsQ0FBQTtRQUMzQyxNQUFNLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxDQUFBO1FBQ2hELE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBQ2xDLENBQUMsQ0FBQyxDQUFDLENBQUE7SUFFTCxFQUFFLENBQUMsK0JBQStCLEVBQUUsR0FBRyxFQUFFLENBQ3ZDLHNCQUFzQixDQUFDLEtBQUssRUFBQyxNQUFNLEVBQUMsRUFBRTtRQUNwQyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsTUFBTSxFQUFFLG9CQUFvQixDQUFDLENBQUE7UUFDckQsRUFBRSxDQUFDLGFBQWEsQ0FBQyxVQUFVLEVBQUUscUJBQXFCLENBQUMsQ0FBQTtRQUNuRCxNQUFNLE1BQU0sQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUE7SUFDeEQsQ0FBQyxDQUFDLENBQUMsQ0FBQTtBQUNQLENBQUMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGZzIGZyb20gXCJub2RlOmZzXCJcbmltcG9ydCB7IGpvaW4gfSBmcm9tIFwibm9kZTpwYXRoXCJcbmltcG9ydCB7IHRlbXBvcmFyeURpcmVjdG9yeVRhc2sgfSBmcm9tIFwidGVtcHlcIlxuaW1wb3J0IHsgZGVzY3JpYmUsIGV4cGVjdCwgaXQgfSBmcm9tIFwidml0ZS1wbHVzL3Rlc3RcIlxuaW1wb3J0IHsgbG9hZENvbmZpZyB9IGZyb20gXCIuL2xvYWQudHNcIlxuXG5kZXNjcmliZShcImxvYWRDb25maWdcIiwgKCkgPT4ge1xuICBpdChcInNob3VsZCB0aHJvdyB3aGVuIG5vIGNvbmZpZyBmaWxlIGV4aXN0c1wiLCBhc3luYyAoKSA9PiB7XG4gICAgYXdhaXQgZXhwZWN0KGxvYWRDb25maWcoXCIvbm9uZXhpc3RlbnQvY29uZmlnLnRzXCIpKS5yZWplY3RzLnRvVGhyb3coKVxuICB9KVxuXG4gIGl0KFwic2hvdWxkIGxvYWQgY29uZmlnIGZyb20gZXhwbGljaXQgcGF0aFwiLCAoKSA9PlxuICAgIHRlbXBvcmFyeURpcmVjdG9yeVRhc2soYXN5bmMgdG1wRGlyID0+IHtcbiAgICAgIGNvbnN0IGNvbmZpZ1BhdGggPSBqb2luKHRtcERpciwgXCJsaXZlbWFyay5jb25maWcudHNcIilcbiAgICAgIGZzLndyaXRlRmlsZVN5bmMoXG4gICAgICAgIGNvbmZpZ1BhdGgsXG4gICAgICAgICdleHBvcnQgZGVmYXVsdCB7IGluY2x1ZGU6IFwiYXJ0aWNsZXMvKiovKi5tZHhcIiB9XFxuJyxcbiAgICAgIClcbiAgICAgIGNvbnN0IGNvbmZpZyA9IGF3YWl0IGxvYWRDb25maWcoY29uZmlnUGF0aClcbiAgICAgIGV4cGVjdChjb25maWcuaW5jbHVkZSkudG9CZShcImFydGljbGVzLyoqLyoubWR4XCIpXG4gICAgICBleHBlY3QoY29uZmlnLnJvb3QpLnRvQmUodG1wRGlyKVxuICAgIH0pKVxuXG4gIGl0KFwic2hvdWxkIHZhbGlkYXRlIGxvYWRlZCBjb25maWdcIiwgKCkgPT5cbiAgICB0ZW1wb3JhcnlEaXJlY3RvcnlUYXNrKGFzeW5jIHRtcERpciA9PiB7XG4gICAgICBjb25zdCBjb25maWdQYXRoID0gam9pbih0bXBEaXIsIFwibGl2ZW1hcmsuY29uZmlnLnRzXCIpXG4gICAgICBmcy53cml0ZUZpbGVTeW5jKGNvbmZpZ1BhdGgsIFwiZXhwb3J0IGRlZmF1bHQge31cXG5cIilcbiAgICAgIGF3YWl0IGV4cGVjdChsb2FkQ29uZmlnKGNvbmZpZ1BhdGgpKS5yZWplY3RzLnRvVGhyb3coKVxuICAgIH0pKVxufSlcbiJdfQ==

package/target/client.d.ts

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

package/target/client.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { StartClient } from "@tanstack/react-start/client";
+import { StrictMode } from "react";
+import { hydrateRoot } from "react-dom/client";
+hydrateRoot(document, _jsx(StrictMode, { children: _jsx(StartClient, {}) }));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc291cmNlL2NsaWVudC50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQTtBQUMxRCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sT0FBTyxDQUFBO0FBQ2xDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQTtBQUU5QyxXQUFXLENBQ1QsUUFBUSxFQUNSLEtBQUMsVUFBVSxjQUNULEtBQUMsV0FBVyxLQUFHLEdBQ0osQ0FDZCxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU3RhcnRDbGllbnQgfSBmcm9tIFwiQHRhbnN0YWNrL3JlYWN0LXN0YXJ0L2NsaWVudFwiXG5pbXBvcnQgeyBTdHJpY3RNb2RlIH0gZnJvbSBcInJlYWN0XCJcbmltcG9ydCB7IGh5ZHJhdGVSb290IH0gZnJvbSBcInJlYWN0LWRvbS9jbGllbnRcIlxuXG5oeWRyYXRlUm9vdChcbiAgZG9jdW1lbnQsXG4gIDxTdHJpY3RNb2RlPlxuICAgIDxTdGFydENsaWVudCAvPlxuICA8L1N0cmljdE1vZGU+LFxuKVxuIl19

package/target/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, "..", "..", "source", "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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zb3VyY2UvY29tbWFuZHMvYnVpbGQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUNoQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ25DLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxNQUFNLENBQUE7QUFFcEMsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUNyQixPQUFPLElBQUksQ0FBQyxPQUFPLEVBQ25CLElBQUksRUFDSixJQUFJLEVBQ0osUUFBUSxFQUNSLGdCQUFnQixDQUNqQixDQUFBO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxLQUFLLEdBQUcsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDO0tBQ3RDLFdBQVcsQ0FBQywrQkFBK0IsQ0FBQztLQUM1QyxNQUFNLENBQUMsS0FBSyxJQUFJLEVBQUU7SUFDakIsTUFBTSxPQUFPLEdBQUcsTUFBTSxhQUFhLENBQUMsRUFBRSxVQUFVLEVBQUUsQ0FBQyxDQUFBO0lBQ25ELE1BQU0sT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFBO0FBQzFCLENBQUMsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgam9pbiB9IGZyb20gXCJub2RlOnBhdGhcIlxuaW1wb3J0IHsgQ29tbWFuZCB9IGZyb20gXCJjb21tYW5kZXJcIlxuaW1wb3J0IHsgY3JlYXRlQnVpbGRlciB9IGZyb20gXCJ2aXRlXCJcblxuY29uc3QgY29uZmlnRmlsZSA9IGpvaW4oXG4gIGltcG9ydC5tZXRhLmRpcm5hbWUsXG4gIFwiLi5cIixcbiAgXCIuLlwiLFxuICBcInNvdXJjZVwiLFxuICBcInZpdGUuY29uZmlnLnRzXCIsXG4pXG5cbi8qKlxuICogQnVpbGQgdGhlIHNpdGUgZm9yIHByb2R1Y3Rpb24uXG4gKi9cbmV4cG9ydCBjb25zdCBidWlsZCA9IG5ldyBDb21tYW5kKFwiYnVpbGRcIilcbiAgLmRlc2NyaXB0aW9uKFwiQnVpbGQgdGhlIHNpdGUgZm9yIHByb2R1Y3Rpb25cIilcbiAgLmFjdGlvbihhc3luYyAoKSA9PiB7XG4gICAgY29uc3QgYnVpbGRlciA9IGF3YWl0IGNyZWF0ZUJ1aWxkZXIoeyBjb25maWdGaWxlIH0pXG4gICAgYXdhaXQgYnVpbGRlci5idWlsZEFwcCgpXG4gIH0pXG4iXX0=

package/target/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 "../settings.js";
+const defaultsRoot = join(import.meta.dirname, "..", "..", "source");
+/**
+ * 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/target/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, "..", "..", "source", "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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJldmlldy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NvdXJjZS9jb21tYW5kcy9wcmV2aWV3LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxXQUFXLENBQUE7QUFDaEMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUNuQyxPQUFPLEVBQUUsT0FBTyxJQUFJLFdBQVcsRUFBRSxNQUFNLE1BQU0sQ0FBQTtBQUU3QyxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQ3JCLE9BQU8sSUFBSSxDQUFDLE9BQU8sRUFDbkIsSUFBSSxFQUNKLElBQUksRUFDSixRQUFRLEVBQ1IsZ0JBQWdCLENBQ2pCLENBQUE7QUFFRDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxJQUFJLE9BQU8sQ0FBQyxTQUFTLENBQUM7S0FDMUMsV0FBVyxDQUFDLHNDQUFzQyxDQUFDO0tBQ25ELE1BQU0sQ0FBQyxLQUFLLElBQUksRUFBRTtJQUNqQixNQUFNLE1BQU0sR0FBRyxNQUFNLFdBQVcsQ0FBQztRQUMvQixVQUFVO1FBQ1YsT0FBTyxFQUFFLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFO0tBQ3BDLENBQUMsQ0FBQTtJQUNGLE1BQU0sQ0FBQyxTQUFTLEVBQUUsQ0FBQTtJQUNsQixNQUFNLENBQUMsZ0JBQWdCLENBQUMsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQTtBQUMxQyxDQUFDLENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGpvaW4gfSBmcm9tIFwibm9kZTpwYXRoXCJcbmltcG9ydCB7IENvbW1hbmQgfSBmcm9tIFwiY29tbWFuZGVyXCJcbmltcG9ydCB7IHByZXZpZXcgYXMgdml0ZVByZXZpZXcgfSBmcm9tIFwidml0ZVwiXG5cbmNvbnN0IGNvbmZpZ0ZpbGUgPSBqb2luKFxuICBpbXBvcnQubWV0YS5kaXJuYW1lLFxuICBcIi4uXCIsXG4gIFwiLi5cIixcbiAgXCJzb3VyY2VcIixcbiAgXCJ2aXRlLmNvbmZpZy50c1wiLFxuKVxuXG4vKipcbiAqIFByZXZpZXcgdGhlIHByb2R1Y3Rpb24gYnVpbGQgbG9jYWxseS5cbiAqL1xuZXhwb3J0IGNvbnN0IHByZXZpZXcgPSBuZXcgQ29tbWFuZChcInByZXZpZXdcIilcbiAgLmRlc2NyaXB0aW9uKFwiUHJldmlldyB0aGUgcHJvZHVjdGlvbiBidWlsZCBsb2NhbGx5XCIpXG4gIC5hY3Rpb24oYXN5bmMgKCkgPT4ge1xuICAgIGNvbnN0IHNlcnZlciA9IGF3YWl0IHZpdGVQcmV2aWV3KHtcbiAgICAgIGNvbmZpZ0ZpbGUsXG4gICAgICBwcmV2aWV3OiB7IHBvcnQ6IDgwMDAsIGhvc3Q6IHRydWUgfSxcbiAgICB9KVxuICAgIHNlcnZlci5wcmludFVybHMoKVxuICAgIHNlcnZlci5iaW5kQ0xJU2hvcnRjdXRzKHsgcHJpbnQ6IHRydWUgfSlcbiAgfSlcbiJdfQ==

package/target/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, "..", "..", "source", "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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhcnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zb3VyY2UvY29tbWFuZHMvc3RhcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLFdBQVcsQ0FBQTtBQUNoQyxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sV0FBVyxDQUFBO0FBQ25DLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxNQUFNLENBQUE7QUFFbkMsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUNyQixPQUFPLElBQUksQ0FBQyxPQUFPLEVBQ25CLElBQUksRUFDSixJQUFJLEVBQ0osUUFBUSxFQUNSLGdCQUFnQixDQUNqQixDQUFBO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxLQUFLLEdBQUcsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDO0tBQ3RDLFdBQVcsQ0FBQyxxQkFBcUIsQ0FBQztLQUNsQyxNQUFNLENBQUMsS0FBSyxJQUFJLEVBQUU7SUFDakIsTUFBTSxNQUFNLEdBQUcsTUFBTSxZQUFZLENBQUM7UUFDaEMsVUFBVTtRQUNWLE1BQU0sRUFBRSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRTtLQUNuQyxDQUFDLENBQUE7SUFDRixNQUFNLE1BQU0sQ0FBQyxNQUFNLEVBQUUsQ0FBQTtJQUNyQixNQUFNLENBQUMsU0FBUyxFQUFFLENBQUE7SUFDbEIsTUFBTSxDQUFDLGdCQUFnQixDQUFDLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxDQUFDLENBQUE7QUFDMUMsQ0FBQyxDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBqb2luIH0gZnJvbSBcIm5vZGU6cGF0aFwiXG5pbXBvcnQgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiXG5pbXBvcnQgeyBjcmVhdGVTZXJ2ZXIgfSBmcm9tIFwidml0ZVwiXG5cbmNvbnN0IGNvbmZpZ0ZpbGUgPSBqb2luKFxuICBpbXBvcnQubWV0YS5kaXJuYW1lLFxuICBcIi4uXCIsXG4gIFwiLi5cIixcbiAgXCJzb3VyY2VcIixcbiAgXCJ2aXRlLmNvbmZpZy50c1wiLFxuKVxuXG4vKipcbiAqIFN0YXJ0IGEgZGV2ZWxvcG1lbnQgc2VydmVyLlxuICovXG5leHBvcnQgY29uc3Qgc3RhcnQgPSBuZXcgQ29tbWFuZChcInN0YXJ0XCIpXG4gIC5kZXNjcmlwdGlvbihcIlN0YXJ0IGEgbGl2ZSBzZXJ2ZXJcIilcbiAgLmFjdGlvbihhc3luYyAoKSA9PiB7XG4gICAgY29uc3Qgc2VydmVyID0gYXdhaXQgY3JlYXRlU2VydmVyKHtcbiAgICAgIGNvbmZpZ0ZpbGUsXG4gICAgICBzZXJ2ZXI6IHsgcG9ydDogODAwMCwgaG9zdDogdHJ1ZSB9LFxuICAgIH0pXG4gICAgYXdhaXQgc2VydmVyLmxpc3RlbigpXG4gICAgc2VydmVyLnByaW50VXJscygpXG4gICAgc2VydmVyLmJpbmRDTElTaG9ydGN1dHMoeyBwcmludDogdHJ1ZSB9KVxuICB9KVxuIl19

package/target/components/Abbr.d.ts

@@ -0,0 +1,5 @@
+/** Renders an abbreviation with a shadcn tooltip showing its full form */
+export declare function Abbr(props: {
+    text: string;
+    title: string;
+}): import("react/jsx-runtime").JSX.Element;

package/target/components/Abbr.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Tooltip, TooltipContent, TooltipTrigger, } from "../elements/tooltip.js";
+/** Renders an abbreviation with a shadcn tooltip showing its full form */
+export function Abbr(props) {
+    return (_jsxs(Tooltip, { children: [
+            _jsx(TooltipTrigger, { className: "border-b border-dotted border-muted-foreground cursor-help", children: props.text }), _jsx(TooltipContent, { children: props.title })
+        ] }));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWJici5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NvdXJjZS9jb21wb25lbnRzL0FiYnIudHN4Il0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQ0wsT0FBTyxFQUNQLGNBQWMsRUFDZCxjQUFjLEdBQ2YsTUFBTSx3QkFBeUIsQ0FBQTtBQUVoQywwRUFBMEU7QUFDMUUsTUFBTSxVQUFVLElBQUksQ0FBQyxLQUFzQztJQUN6RCxPQUFPLENBQ0wsTUFBQyxPQUFPO1lBQ04sS0FBQyxjQUFjLElBQUMsU0FBUyxFQUFDLDREQUE0RCxZQUNuRixLQUFLLENBQUMsSUFBSSxHQUNJLEVBQ2pCLEtBQUMsY0FBYyxjQUFFLEtBQUssQ0FBQyxLQUFLLEdBQWtCO1lBQ3RDLENBQ1gsQ0FBQTtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBUb29sdGlwLFxuICBUb29sdGlwQ29udGVudCxcbiAgVG9vbHRpcFRyaWdnZXIsXG59IGZyb20gXCIuLi9lbGVtZW50cy90b29sdGlwLnRzeFwiXG5cbi8qKiBSZW5kZXJzIGFuIGFiYnJldmlhdGlvbiB3aXRoIGEgc2hhZGNuIHRvb2x0aXAgc2hvd2luZyBpdHMgZnVsbCBmb3JtICovXG5leHBvcnQgZnVuY3Rpb24gQWJicihwcm9wczogeyB0ZXh0OiBzdHJpbmc7IHRpdGxlOiBzdHJpbmcgfSkge1xuICByZXR1cm4gKFxuICAgIDxUb29sdGlwPlxuICAgICAgPFRvb2x0aXBUcmlnZ2VyIGNsYXNzTmFtZT1cImJvcmRlci1iIGJvcmRlci1kb3R0ZWQgYm9yZGVyLW11dGVkLWZvcmVncm91bmQgY3Vyc29yLWhlbHBcIj5cbiAgICAgICAge3Byb3BzLnRleHR9XG4gICAgICA8L1Rvb2x0aXBUcmlnZ2VyPlxuICAgICAgPFRvb2x0aXBDb250ZW50Pntwcm9wcy50aXRsZX08L1Rvb2x0aXBDb250ZW50PlxuICAgIDwvVG9vbHRpcD5cbiAgKVxufVxuIl19

package/target/components/AnsiCode.d.ts

@@ -0,0 +1,4 @@
+/** Renders pre-formatted HTML produced from ANSI escape sequences */
+export declare function AnsiCode(props: {
+    html: string;
+}): import("react/jsx-runtime").JSX.Element;