livemark 0.10.4 → 0.11.0

package/build/content-collections.js

@@ -0,0 +1,218 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { basename, relative, resolve } from "node:path";
+import { DEFAULT_EXCLUDES } from "./settings.js";
+import { defineCollection, defineConfig } from "@content-collections/core";
+import { compileMDX } from "@content-collections/mdx";
+import rehypeShiki from "@shikijs/rehype";
+import { transformerTwoslash } from "@shikijs/twoslash";
+import rehypeKatex from "rehype-katex";
+import rehypeSlug from "rehype-slug";
+import remarkDefinitionList from "remark-definition-list";
+import remarkDirective from "remark-directive";
+import remarkGemoji from "remark-gemoji";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+import { loadConfig } from "./actions/config/load.js";
+import { buildChangelog, cacheIncludeGlob } from "./actions/changelog/build.js";
+import { Article } from "./models/article.js";
+import { pickDefaultIcon } from "./helpers/article-icon.js";
+import slugify from "@sindresorhus/slugify";
+import remarkCustomHeadingId from "./plugins/remark-custom-heading-id.js";
+import { remarkCallout } from "./plugins/remark-callout.js";
+import { remarkCard } from "./plugins/remark-card.js";
+import { remarkColumns } from "./plugins/remark-columns.js";
+import { remarkTab } from "./plugins/remark-tab.js";
+import { remarkBadge } from "./plugins/remark-badge.js";
+import { remarkButton } from "./plugins/remark-button.js";
+import { remarkAbbr } from "./plugins/remark-abbr.js";
+import { remarkDeflist } from "./plugins/remark-deflist.js";
+import { remarkDetails } from "./plugins/remark-details.js";
+import { remarkFiletree } from "./plugins/remark-filetree.js";
+import { remarkIcon } from "./plugins/remark-icon.js";
+import { remarkCodeTabs } from "./plugins/remark-code-tabs.js";
+import { remarkGithubCallout } from "./plugins/remark-github-callout.js";
+import { remarkImage } from "./plugins/remark-image.js";
+import { remarkMedia } from "./plugins/remark-media.js";
+import { remarkAnsi } from "./plugins/remark-ansi.js";
+import { remarkMermaid } from "./plugins/remark-mermaid.js";
+import { remarkToc } from "./plugins/remark-toc.js";
+import { remarkNpm } from "./plugins/remark-npm.js";
+import { remarkSteps } from "./plugins/remark-steps.js";
+import { remarkPassthroughDirective } from "./plugins/remark-passthrough-directive.js";
+import { transformerLineHighlight, transformerNotations, } from "./plugins/shiki-line-highlight.js";
+import { rehypeInlineCode } from "./plugins/rehype-inline-code.js";
+import { rehypeTaskListA11y } from "./plugins/rehype-task-list-a11y.js";
+import { transformerIcon } from "./plugins/shiki-icon.js";
+import { resolveAssetPath } from "./helpers/resolve-asset-path.js";
+import { resolveIncludes } from "./helpers/resolve-includes.js";
+import { extractSearchText } from "./helpers/search-text.js";
+import { extractToc } from "./helpers/toc.js";
+const config = await loadConfig();
+const changelogSections = config.sections?.filter(s => s.type === "changelog") ?? [];
+for (const section of changelogSections) {
+    await buildChangelog(section, config);
+}
+const configInclude = Array.isArray(config.include)
+    ? config.include
+    : [config.include];
+const include = changelogSections.length
+    ? [...configInclude, cacheIncludeGlob(config)]
+    : configInclude;
+const userExclude = config.exclude
+    ? Array.isArray(config.exclude)
+        ? config.exclude
+        : [config.exclude]
+    : [];
+// When the consumer doesn't have a .gitignore, fall back to a sensible
+// floor so `**/*.md` doesn't sweep up every README.md under node_modules,
+// build outputs, etc. With a .gitignore present we trust the user.
+const hasGitignore = existsSync(resolve(config.root, ".gitignore"));
+const defaultExclude = hasGitignore ? [] : [...DEFAULT_EXCLUDES];
+const exclude = [...defaultExclude, ...userExclude];
+// content-collections compiles this file to .content-collections/cache/;
+// going up 2 levels reconstructs the baseDirectory it uses for path resolution
+const baseDir = resolve(import.meta.dirname, "../..");
+const directory = relative(baseDir, config.root) || ".";
+function toPath(filePath) {
+    const name = basename(filePath).replace(/\.\w+$/, "");
+    return slugify(name);
+}
+function getLastUpdated(filePath) {
+    try {
+        const timestamp = execSync(`git log -1 --format=%cI -- "${filePath}"`, {
+            cwd: config.root,
+            encoding: "utf-8",
+        }).trim();
+        return timestamp || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function stripLeadingH1(content) {
+    return content.replace(/^[ \t]*#\s+[^\n]*\n+/, "");
+}
+function extractTitle(content, path) {
+    const match = /^#\s+(.+)$/m.exec(content);
+    if (match)
+        return match[1];
+    return (path
+        .split("/")
+        .pop()
+        ?.replace(/\.\w+$/, "") ?? path);
+}
+const articles = defineCollection({
+    name: "articles",
+    directory,
+    include,
+    exclude,
+    schema: Article,
+    transform: async (document, context) => {
+        const patch = config.patches?.find(p => p.file === document._meta.filePath);
+        const doc = patch ? { ...document, ...patch.article } : document;
+        const filePath = resolve(config.root, doc._meta.filePath);
+        const content = resolveIncludes(doc.content, filePath);
+        const title = doc.title ?? extractTitle(content, doc._meta.path);
+        const icon = doc.icon ?? pickDefaultIcon(doc._meta.path);
+        const path = doc.path ?? toPath(doc._meta.filePath);
+        // The article's h1 is rendered from `title` by the layout, so strip any
+        // leading h1 in the body to avoid two h1s side-by-side (especially when
+        // a content patch overrides the title to something different from the
+        // body's own heading).
+        const bodyContent = stripLeadingH1(content);
+        const mdx = await compileMDX(context, { ...doc, content: bodyContent }, {
+            remarkPlugins: [
+                remarkGfm,
+                remarkGemoji,
+                remarkDefinitionList,
+                remarkDeflist,
+                remarkMath,
+                remarkDirective,
+                remarkCallout,
+                remarkCard,
+                remarkColumns,
+                remarkTab,
+                remarkDetails,
+                remarkFiletree,
+                remarkIcon,
+                remarkBadge,
+                remarkButton,
+                remarkAbbr,
+                remarkGithubCallout,
+                [
+                    remarkImage,
+                    {
+                        filePath: resolve(config.root, doc._meta.filePath),
+                        root: config.root,
+                    },
+                ],
+                remarkAnsi,
+                remarkMermaid,
+                remarkMedia,
+                remarkToc,
+                remarkNpm,
+                remarkCodeTabs,
+                remarkSteps,
+                remarkCustomHeadingId,
+                // Run last: anything still typed as a directive after every handler
+                // above is unintended (e.g. `3.2:1`, `port:8080`) — passthrough as
+                // plain text so it doesn't render as an empty span/div.
+                remarkPassthroughDirective,
+            ],
+            rehypePlugins: [
+                [
+                    rehypeShiki,
+                    {
+                        themes: {
+                            light: config.codeThemeLight,
+                            dark: config.codeThemeDark,
+                        },
+                        // Darken catppuccin-latte's green (the colour used for strings and
+                        // some comments) — the theme default #40A02B lands at 3.2:1 on the
+                        // code-block background, below the WCAG AA 4.5:1 threshold.
+                        colorReplacements: {
+                            "catppuccin-latte": {
+                                "#40a02b": "#2a7e16",
+                            },
+                        },
+                        transformers: [
+                            transformerTwoslash({ explicitTrigger: true }),
+                            transformerIcon(),
+                            transformerNotations(),
+                            transformerLineHighlight(),
+                        ],
+                        parseMetaString: (meta) => ({ "data-meta": meta }),
+                    },
+                ],
+                rehypeInlineCode,
+                rehypeSlug,
+                rehypeKatex,
+                rehypeTaskListA11y,
+            ],
+        });
+        const tocItems = extractToc(content);
+        const searchText = extractSearchText(content);
+        const lastUpdated = getLastUpdated(doc._meta.filePath);
+        const image = doc.image
+            ? resolveAssetPath(doc.image, filePath, config.root)
+            : undefined;
+        return {
+            ...doc,
+            file: doc._meta.filePath,
+            lastUpdated,
+            image,
+            title,
+            icon,
+            path,
+            tocItems,
+            searchText,
+            mdx,
+        };
+    },
+});
+export default defineConfig({
+    // @ts-expect-error tsgo picks wrong overload when rehype-slug augments unified types
+    content: [articles],
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"content-collections.js","sourceRoot":"","sources":["../source/content-collections.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AACrD,OAAO,WAAW,MAAM,iBAAiB,CAAA;AACzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,WAAW,MAAM,cAAc,CAAA;AACtC,OAAO,UAAU,MAAM,aAAa,CAAA;AACpC,OAAO,oBAAoB,MAAM,wBAAwB,CAAA;AACzD,OAAO,eAAe,MAAM,kBAAkB,CAAA;AAC9C,OAAO,YAAY,MAAM,eAAe,CAAA;AACxC,OAAO,SAAS,MAAM,YAAY,CAAA;AAClC,OAAO,UAAU,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AACrD,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AAC/E,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,OAAO,MAAM,uBAAuB,CAAA;AAC3C,OAAO,qBAAqB,MAAM,uCAAuC,CAAA;AACzE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAA;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,EAAE,0BAA0B,EAAE,MAAM,2CAA2C,CAAA;AACtF,OAAO,EACL,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAA;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAA;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C,MAAM,MAAM,GAAG,MAAM,UAAU,EAAE,CAAA;AAEjC,MAAM,iBAAiB,GACrB,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,WAAW,CAAC,IAAI,EAAE,CAAA;AAC5D,KAAK,MAAM,OAAO,IAAI,iBAAiB,EAAE,CAAC;IACxC,MAAM,cAAc,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;AACvC,CAAC;AAED,MAAM,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;IACjD,CAAC,CAAC,MAAM,CAAC,OAAO;IAChB,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;AACpB,MAAM,OAAO,GAAG,iBAAiB,CAAC,MAAM;IACtC,CAAC,CAAC,CAAC,GAAG,aAAa,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC,CAAC,aAAa,CAAA;AAEjB,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO;IAChC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;QAC7B,CAAC,CAAC,MAAM,CAAC,OAAO;QAChB,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;IACpB,CAAC,CAAC,EAAE,CAAA;AACN,uEAAuE;AACvE,0EAA0E;AAC1E,mEAAmE;AACnE,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAA;AACnE,MAAM,cAAc,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAA;AAChE,MAAM,OAAO,GAAG,CAAC,GAAG,cAAc,EAAE,GAAG,WAAW,CAAC,CAAA;AAEnD,yEAAyE;AACzE,+EAA+E;AAC/E,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;AACrD,MAAM,SAAS,GAAG,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,GAAG,CAAA;AAEvD,SAAS,MAAM,CAAC,QAAgB;IAC9B,MAAM,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAA;IACrD,OAAO,OAAO,CAAC,IAAI,CAAC,CAAA;AACtB,CAAC;AAED,SAAS,cAAc,CAAC,QAAgB;IACtC,IAAI,CAAC;QACH,MAAM,SAAS,GAAG,QAAQ,CAAC,+BAA+B,QAAQ,GAAG,EAAE;YACrE,GAAG,EAAE,MAAM,CAAC,IAAI;YAChB,QAAQ,EAAE,OAAO;SAClB,CAAC,CAAC,IAAI,EAAE,CAAA;QACT,OAAO,SAAS,IAAI,SAAS,CAAA;IAC/B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAA;IAClB,CAAC;AACH,CAAC;AAED,SAAS,cAAc,CAAC,OAAe;IACrC,OAAO,OAAO,CAAC,OAAO,CAAC,sBAAsB,EAAE,EAAE,CAAC,CAAA;AACpD,CAAC;AAED,SAAS,YAAY,CAAC,OAAe,EAAE,IAAY;IACjD,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACzC,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC,CAAC,CAAE,CAAA;IAC3B,OAAO,CACL,IAAI;SACD,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,EAAE;QACN,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,IAAI,CAClC,CAAA;AACH,CAAC;AAED,MAAM,QAAQ,GAAG,gBAAgB,CAAC;IAChC,IAAI,EAAE,UAAU;IAChB,SAAS;IACT,OAAO;IACP,OAAO;IACP,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE;QACrC,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;QAC3E,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,QAAQ,EAAE,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAA;QAChE,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;QACzD,MAAM,OAAO,GAAG,eAAe,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;QACtD,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,IAAI,YAAY,CAAC,OAAO,EAAE,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAChE,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,IAAI,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QACxD,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;QACnD,wEAAwE;QACxE,wEAAwE;QACxE,sEAAsE;QACtE,uBAAuB;QACvB,MAAM,WAAW,GAAG,cAAc,CAAC,OAAO,CAAC,CAAA;QAC3C,MAAM,GAAG,GAAG,MAAM,UAAU,CAC1B,OAAO,EACP,EAAE,GAAG,GAAG,EAAE,OAAO,EAAE,WAAW,EAAE,EAChC;YACE,aAAa,EAAE;gBACb,SAAS;gBACT,YAAY;gBACZ,oBAAoB;gBACpB,aAAa;gBACb,UAAU;gBACV,eAAe;gBACf,aAAa;gBACb,UAAU;gBACV,aAAa;gBACb,SAAS;gBACT,aAAa;gBACb,cAAc;gBACd,UAAU;gBACV,WAAW;gBACX,YAAY;gBACZ,UAAU;gBACV,mBAAmB;gBACnB;oBACE,WAAW;oBACX;wBACE,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC;wBAClD,IAAI,EAAE,MAAM,CAAC,IAAI;qBAClB;iBACF;gBACD,UAAU;gBACV,aAAa;gBACb,WAAW;gBACX,SAAS;gBACT,SAAS;gBACT,cAAc;gBACd,WAAW;gBACX,qBAAqB;gBACrB,oEAAoE;gBACpE,mEAAmE;gBACnE,wDAAwD;gBACxD,0BAA0B;aAC3B;YACD,aAAa,EAAE;gBACb;oBACE,WAAW;oBACX;wBACE,MAAM,EAAE;4BACN,KAAK,EAAE,MAAM,CAAC,cAAc;4BAC5B,IAAI,EAAE,MAAM,CAAC,aAAa;yBAC3B;wBACD,mEAAmE;wBACnE,mEAAmE;wBACnE,4DAA4D;wBAC5D,iBAAiB,EAAE;4BACjB,kBAAkB,EAAE;gCAClB,SAAS,EAAE,SAAS;6BACrB;yBACF;wBACD,YAAY,EAAE;4BACZ,mBAAmB,CAAC,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC;4BAC9C,eAAe,EAAE;4BACjB,oBAAoB,EAAE;4BACtB,wBAAwB,EAAE;yBAC3B;wBACD,eAAe,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;qBAC3D;iBACF;gBACD,gBAAgB;gBAChB,UAAU;gBACV,WAAW;gBACX,kBAAkB;aACnB;SACF,CACF,CAAA;QACD,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,CAAC,CAAA;QACpC,MAAM,UAAU,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAA;QAC7C,MAAM,WAAW,GAAG,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;QACtD,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK;YACrB,CAAC,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAC;YACpD,CAAC,CAAC,SAAS,CAAA;QACb,OAAO;YACL,GAAG,GAAG;YACN,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,QAAQ;YACxB,WAAW;YACX,KAAK;YACL,KAAK;YACL,IAAI;YACJ,IAAI;YACJ,QAAQ;YACR,UAAU;YACV,GAAG;SACJ,CAAA;IACH,CAAC;CACF,CAAC,CAAA;AAEF,eAAe,YAAY,CAAC;IAC1B,qFAAqF;IACrF,OAAO,EAAE,CAAC,QAAQ,CAAC;CACpB,CAAC,CAAA","sourcesContent":["import { execSync } from \"node:child_process\"\nimport { existsSync } from \"node:fs\"\nimport { basename, relative, resolve } from \"node:path\"\nimport { DEFAULT_EXCLUDES } from \"./settings.ts\"\nimport { defineCollection, defineConfig } from \"@content-collections/core\"\nimport { compileMDX } from \"@content-collections/mdx\"\nimport rehypeShiki from \"@shikijs/rehype\"\nimport { transformerTwoslash } from \"@shikijs/twoslash\"\nimport rehypeKatex from \"rehype-katex\"\nimport rehypeSlug from \"rehype-slug\"\nimport remarkDefinitionList from \"remark-definition-list\"\nimport remarkDirective from \"remark-directive\"\nimport remarkGemoji from \"remark-gemoji\"\nimport remarkGfm from \"remark-gfm\"\nimport remarkMath from \"remark-math\"\nimport { loadConfig } from \"./actions/config/load.ts\"\nimport { buildChangelog, cacheIncludeGlob } from \"./actions/changelog/build.ts\"\nimport { Article } from \"./models/article.ts\"\nimport { pickDefaultIcon } from \"./helpers/article-icon.ts\"\nimport slugify from \"@sindresorhus/slugify\"\nimport remarkCustomHeadingId from \"./plugins/remark-custom-heading-id.ts\"\nimport { remarkCallout } from \"./plugins/remark-callout.ts\"\nimport { remarkCard } from \"./plugins/remark-card.ts\"\nimport { remarkColumns } from \"./plugins/remark-columns.ts\"\nimport { remarkTab } from \"./plugins/remark-tab.ts\"\nimport { remarkBadge } from \"./plugins/remark-badge.ts\"\nimport { remarkButton } from \"./plugins/remark-button.ts\"\nimport { remarkAbbr } from \"./plugins/remark-abbr.ts\"\nimport { remarkDeflist } from \"./plugins/remark-deflist.ts\"\nimport { remarkDetails } from \"./plugins/remark-details.ts\"\nimport { remarkFiletree } from \"./plugins/remark-filetree.ts\"\nimport { remarkIcon } from \"./plugins/remark-icon.ts\"\nimport { remarkCodeTabs } from \"./plugins/remark-code-tabs.ts\"\nimport { remarkGithubCallout } from \"./plugins/remark-github-callout.ts\"\nimport { remarkImage } from \"./plugins/remark-image.ts\"\nimport { remarkMedia } from \"./plugins/remark-media.ts\"\nimport { remarkAnsi } from \"./plugins/remark-ansi.ts\"\nimport { remarkMermaid } from \"./plugins/remark-mermaid.ts\"\nimport { remarkToc } from \"./plugins/remark-toc.ts\"\nimport { remarkNpm } from \"./plugins/remark-npm.ts\"\nimport { remarkSteps } from \"./plugins/remark-steps.ts\"\nimport { remarkPassthroughDirective } from \"./plugins/remark-passthrough-directive.ts\"\nimport {\n  transformerLineHighlight,\n  transformerNotations,\n} from \"./plugins/shiki-line-highlight.ts\"\nimport { rehypeInlineCode } from \"./plugins/rehype-inline-code.ts\"\nimport { rehypeTaskListA11y } from \"./plugins/rehype-task-list-a11y.ts\"\nimport { transformerIcon } from \"./plugins/shiki-icon.ts\"\nimport { resolveAssetPath } from \"./helpers/resolve-asset-path.ts\"\nimport { resolveIncludes } from \"./helpers/resolve-includes.ts\"\nimport { extractSearchText } from \"./helpers/search-text.ts\"\nimport { extractToc } from \"./helpers/toc.ts\"\n\nconst config = await loadConfig()\n\nconst changelogSections =\n  config.sections?.filter(s => s.type === \"changelog\") ?? []\nfor (const section of changelogSections) {\n  await buildChangelog(section, config)\n}\n\nconst configInclude = Array.isArray(config.include)\n  ? config.include\n  : [config.include]\nconst include = changelogSections.length\n  ? [...configInclude, cacheIncludeGlob(config)]\n  : configInclude\n\nconst userExclude = config.exclude\n  ? Array.isArray(config.exclude)\n    ? config.exclude\n    : [config.exclude]\n  : []\n// When the consumer doesn't have a .gitignore, fall back to a sensible\n// floor so `**/*.md` doesn't sweep up every README.md under node_modules,\n// build outputs, etc. With a .gitignore present we trust the user.\nconst hasGitignore = existsSync(resolve(config.root, \".gitignore\"))\nconst defaultExclude = hasGitignore ? [] : [...DEFAULT_EXCLUDES]\nconst exclude = [...defaultExclude, ...userExclude]\n\n// content-collections compiles this file to .content-collections/cache/;\n// going up 2 levels reconstructs the baseDirectory it uses for path resolution\nconst baseDir = resolve(import.meta.dirname, \"../..\")\nconst directory = relative(baseDir, config.root) || \".\"\n\nfunction toPath(filePath: string) {\n  const name = basename(filePath).replace(/\\.\\w+$/, \"\")\n  return slugify(name)\n}\n\nfunction getLastUpdated(filePath: string) {\n  try {\n    const timestamp = execSync(`git log -1 --format=%cI -- \"${filePath}\"`, {\n      cwd: config.root,\n      encoding: \"utf-8\",\n    }).trim()\n    return timestamp || undefined\n  } catch {\n    return undefined\n  }\n}\n\nfunction stripLeadingH1(content: string) {\n  return content.replace(/^[ \\t]*#\\s+[^\\n]*\\n+/, \"\")\n}\n\nfunction extractTitle(content: string, path: string) {\n  const match = /^#\\s+(.+)$/m.exec(content)\n  if (match) return match[1]!\n  return (\n    path\n      .split(\"/\")\n      .pop()\n      ?.replace(/\\.\\w+$/, \"\") ?? path\n  )\n}\n\nconst articles = defineCollection({\n  name: \"articles\",\n  directory,\n  include,\n  exclude,\n  schema: Article,\n  transform: async (document, context) => {\n    const patch = config.patches?.find(p => p.file === document._meta.filePath)\n    const doc = patch ? { ...document, ...patch.article } : document\n    const filePath = resolve(config.root, doc._meta.filePath)\n    const content = resolveIncludes(doc.content, filePath)\n    const title = doc.title ?? extractTitle(content, doc._meta.path)\n    const icon = doc.icon ?? pickDefaultIcon(doc._meta.path)\n    const path = doc.path ?? toPath(doc._meta.filePath)\n    // The article's h1 is rendered from `title` by the layout, so strip any\n    // leading h1 in the body to avoid two h1s side-by-side (especially when\n    // a content patch overrides the title to something different from the\n    // body's own heading).\n    const bodyContent = stripLeadingH1(content)\n    const mdx = await compileMDX(\n      context,\n      { ...doc, content: bodyContent },\n      {\n        remarkPlugins: [\n          remarkGfm,\n          remarkGemoji,\n          remarkDefinitionList,\n          remarkDeflist,\n          remarkMath,\n          remarkDirective,\n          remarkCallout,\n          remarkCard,\n          remarkColumns,\n          remarkTab,\n          remarkDetails,\n          remarkFiletree,\n          remarkIcon,\n          remarkBadge,\n          remarkButton,\n          remarkAbbr,\n          remarkGithubCallout,\n          [\n            remarkImage,\n            {\n              filePath: resolve(config.root, doc._meta.filePath),\n              root: config.root,\n            },\n          ],\n          remarkAnsi,\n          remarkMermaid,\n          remarkMedia,\n          remarkToc,\n          remarkNpm,\n          remarkCodeTabs,\n          remarkSteps,\n          remarkCustomHeadingId,\n          // Run last: anything still typed as a directive after every handler\n          // above is unintended (e.g. `3.2:1`, `port:8080`) — passthrough as\n          // plain text so it doesn't render as an empty span/div.\n          remarkPassthroughDirective,\n        ],\n        rehypePlugins: [\n          [\n            rehypeShiki,\n            {\n              themes: {\n                light: config.codeThemeLight,\n                dark: config.codeThemeDark,\n              },\n              // Darken catppuccin-latte's green (the colour used for strings and\n              // some comments) — the theme default #40A02B lands at 3.2:1 on the\n              // code-block background, below the WCAG AA 4.5:1 threshold.\n              colorReplacements: {\n                \"catppuccin-latte\": {\n                  \"#40a02b\": \"#2a7e16\",\n                },\n              },\n              transformers: [\n                transformerTwoslash({ explicitTrigger: true }),\n                transformerIcon(),\n                transformerNotations(),\n                transformerLineHighlight(),\n              ],\n              parseMetaString: (meta: string) => ({ \"data-meta\": meta }),\n            },\n          ],\n          rehypeInlineCode,\n          rehypeSlug,\n          rehypeKatex,\n          rehypeTaskListA11y,\n        ],\n      },\n    )\n    const tocItems = extractToc(content)\n    const searchText = extractSearchText(content)\n    const lastUpdated = getLastUpdated(doc._meta.filePath)\n    const image = doc.image\n      ? resolveAssetPath(doc.image, filePath, config.root)\n      : undefined\n    return {\n      ...doc,\n      file: doc._meta.filePath,\n      lastUpdated,\n      image,\n      title,\n      icon,\n      path,\n      tocItems,\n      searchText,\n      mdx,\n    }\n  },\n})\n\nexport default defineConfig({\n  // @ts-expect-error tsgo picks wrong overload when rehype-slug augments unified types\n  content: [articles],\n})\n"]}

package/{target → build}/models/config.d.ts

@@ -1,8 +1,18 @@
 import { z } from "zod";
+import type { ConfigEnv, UserConfig as ViteUserConfig } from "vite";
+/** Escape hatch for arbitrary Vite config — accepts either a config
+ *  object (simple overrides) or a function form (`(env) => config`,
+ *  matching Vite's own `defineConfig`). Merged on top of livemark's
+ *  defaults via `mergeConfig`, so plugin arrays concatenate, defines
+ *  merge, etc. Use this for deployment-target tweaks (e.g. CF Workers
+ *  via `environments.ssr.resolve.conditions: ["workerd", ...]`). */
+export type ViteOverride = ViteUserConfig | ((env: ConfigEnv) => ViteUserConfig | Promise<ViteUserConfig>);
 /**
  * User-provided configuration for Livemark.
  */
-export type UserConfig = z.infer<typeof UserConfig>;
+export type UserConfig = Omit<z.infer<typeof UserConfig>, "vite"> & {
+    vite?: ViteOverride;
+};
 export declare const UserConfig: z.ZodObject<{
     site: z.ZodOptional<z.ZodString>;
     favicon: z.ZodOptional<z.ZodString>;
@@ -143,6 +153,7 @@ export declare const UserConfig: z.ZodObject<{
             }>>>;
         }, z.core.$strict>;
     }, z.core.$strip>>>;
+    vite: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 /** Website configuration injected at build time via Vite define */
 export type WebsiteConfig = z.infer<typeof WebsiteConfig>;
@@ -203,6 +214,10 @@ export declare const SystemConfig: z.ZodObject<{
 }, z.core.$strip>;
 /**
  * Fully resolved Livemark configuration.
+ *
+ * `vite` stays `unknown` here because that's what the runtime schema
+ * produces — consumer-facing typing happens via {@link UserConfig} so
+ * `defineConfig` shows the right shape in editors.
  */
 export type Config = z.infer<typeof Config>;
 export declare const Config: z.ZodObject<{
@@ -345,6 +360,7 @@ export declare const Config: z.ZodObject<{
             }>>>;
         }, z.core.$strict>;
     }, z.core.$strip>>>;
+    vite: z.ZodOptional<z.ZodUnknown>;
     root: z.ZodString;
     configPath: z.ZodString;
 }, z.core.$strip>;

package/build/models/config.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { Link } from "./link.js";
+import { Patch } from "./patch.js";
+import { Section } from "./section.js";
+import { CodeThemeDark, CodeThemeLight } from "./theme.js";
+export const UserConfig = z.object({
+    site: z.string().optional(),
+    favicon: z.string().optional(),
+    logo: z.string().optional(),
+    title: z.string().default("Livemark"),
+    description: z.string().default("Markdown site generator"),
+    include: z.union([z.string(), z.array(z.string())]).default("**/*.md"),
+    exclude: z.union([z.string(), z.array(z.string())]).optional(),
+    codeThemeLight: CodeThemeLight.default("catppuccin-latte"),
+    codeThemeDark: CodeThemeDark.default("catppuccin-mocha"),
+    links: z.array(Link).optional(),
+    sections: z.array(Section).optional(),
+    patches: z.array(Patch).optional(),
+    // Stored as `unknown` in the schema (zod can't type a Vite UserConfig
+    // or a function returning one meaningfully); the public TypeScript
+    // surface above lifts it back to ViteOverride for editor support.
+    vite: z.unknown().optional(),
+});
+export const WebsiteConfig = UserConfig.pick({
+    title: true,
+    description: true,
+    site: true,
+    favicon: true,
+    logo: true,
+    links: true,
+    sections: true,
+});
+export const SystemConfig = z.object({
+    root: z.string(),
+    configPath: z.string(),
+});
+export const Config = UserConfig.merge(SystemConfig);
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,12 @@
+import type { Plugin } from "vite";
+import type { Config } from "../models/config.ts";
+export interface LivemarkOptions {
+    config: Config;
+}
+/** Owns the per-consumer `targets/<hash>/` mount: synthesizes it via
+ *  `buildTarget()`, returns the Vite config that anchors there, and
+ *  watches the consumer's `.livemark/` (plus livemark's `source/` in
+ *  dev) for changes that need to be re-copied into the target. The
+ *  override mechanism is pure file-system (full copies) — no resolveId
+ *  redirection, no realpath surprises. */
+export declare function livemark(opts: LivemarkOptions): Plugin;

package/build/plugins/vite-livemark.js

@@ -0,0 +1,165 @@
+import { cpSync, existsSync, rmSync } from "node:fs";
+import { join, sep } from "node:path";
+import { mergeConfig } from "vite";
+import { buildTarget } from "../actions/target/build.js";
+import { WebsiteConfig } from "../models/config.js";
+import { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from "../settings.js";
+const SOURCE_DIR = join(import.meta.dirname, "..");
+/** Single virtual module exposing livemark's runtime values to consumer
+ *  override files via named exports:
+ *
+ *      import { config } from "livemark:virtual"
+ *
+ *  Currently exports `config` (validated `WebsiteConfig`); future
+ *  additions (e.g. `articles`, `sections`) land here as new named
+ *  exports without consumers changing their import statements.
+ *
+ *  The `\0` prefix on the resolved id is Vite's convention to signal
+ *  "this is a virtual module — no other plugin should try to resolve
+ *  or load it from disk". */
+const VIRTUAL_ID = "livemark:virtual";
+const VIRTUAL_RESOLVED_ID = `\0${VIRTUAL_ID}`;
+/** Owns the per-consumer `targets/<hash>/` mount: synthesizes it via
+ *  `buildTarget()`, returns the Vite config that anchors there, and
+ *  watches the consumer's `.livemark/` (plus livemark's `source/` in
+ *  dev) for changes that need to be re-copied into the target. The
+ *  override mechanism is pure file-system (full copies) — no resolveId
+ *  redirection, no realpath surprises. */
+export function livemark(opts) {
+    const overridesRoot = join(opts.config.root, ".livemark");
+    let targetDir = "";
+    return {
+        name: "livemark",
+        enforce: "pre",
+        async config(_, env) {
+            targetDir = buildTarget(opts.config.configPath);
+            const base = {
+                root: targetDir,
+                // outDir lives outside the target root (in the consumer's
+                // .livemark/) so the consumer can find their deployable output
+                // without digging into node_modules. Vite's default refusal to
+                // empty out-of-root directories doesn't apply here because the
+                // target/ root is livemark's, not the consumer's.
+                build: { outDir: join(overridesRoot, "build"), emptyOutDir: true },
+                resolve: { dedupe: ["react", "react-dom"] },
+            };
+            const override = await resolveViteOverride(opts.config.vite, env);
+            return override ? mergeConfig(base, override) : base;
+        },
+        resolveId(id) {
+            if (id === VIRTUAL_ID)
+                return VIRTUAL_RESOLVED_ID;
+            return null;
+        },
+        load(id) {
+            if (id !== VIRTUAL_RESOLVED_ID)
+                return null;
+            const config = WebsiteConfig.parse(opts.config);
+            return `export const config = ${JSON.stringify(config)}`;
+        },
+        configureServer(server) {
+            server.watcher.add(opts.config.configPath);
+            server.watcher.add(join(overridesRoot, "**", "*"));
+            server.watcher.add(join(SOURCE_DIR, "**", "*"));
+            server.watcher.on("change", file => onChange(file, "change"));
+            server.watcher.on("add", file => onChange(file, "add"));
+            server.watcher.on("unlink", file => onChange(file, "unlink"));
+            function onChange(file, kind) {
+                if (file === opts.config.configPath) {
+                    server.restart();
+                    return;
+                }
+                const overlayHit = matchOverlay(file, overridesRoot);
+                if (overlayHit) {
+                    syncOverlay(overlayHit, kind, targetDir, overridesRoot);
+                    if (kind !== "change")
+                        fullReload(server);
+                    return;
+                }
+                const sourceHit = matchSource(file);
+                if (sourceHit) {
+                    syncSource(sourceHit, kind, targetDir, overridesRoot);
+                    if (kind !== "change")
+                        fullReload(server);
+                }
+            }
+        },
+    };
+}
+function matchOverlay(file, overridesRoot) {
+    const prefix = `${overridesRoot}${sep}`;
+    if (!file.startsWith(prefix))
+        return null;
+    const rel = file.slice(prefix.length);
+    return { rel, category: classify(rel) };
+}
+function matchSource(file) {
+    const prefix = `${SOURCE_DIR}${sep}`;
+    if (!file.startsWith(prefix))
+        return null;
+    // Skip the targets/ output dir itself (sibling of source/) and any
+    // `.gen.ts` files that downstream tools regenerate inside the target.
+    const rel = file.slice(prefix.length);
+    if (rel === "" || rel.includes("routeTree.gen.ts"))
+        return null;
+    return { rel, category: classify(rel) };
+}
+function classify(rel) {
+    const [head] = rel.split(sep);
+    if (head && ESCAPABLE_FOLDERS.includes(head))
+        return "folder";
+    if (ESCAPABLE_FILES.includes(rel))
+        return "file";
+    // Non-escapable source files still need to flow into target during
+    // livemark's own dev — the user is editing the canonical source.
+    return null;
+}
+function syncOverlay(hit, kind, targetDir, overridesRoot) {
+    if (!hit.category)
+        return;
+    const dest = join(targetDir, hit.rel);
+    const source = join(SOURCE_DIR, hit.rel);
+    if (kind === "unlink") {
+        rmSync(dest, { force: true, recursive: true });
+        if (existsSync(source))
+            cpSync(source, dest, { recursive: true, force: true });
+        return;
+    }
+    const overlay = join(overridesRoot, hit.rel);
+    if (existsSync(overlay))
+        cpSync(overlay, dest, { recursive: true, force: true });
+}
+function syncSource(hit, kind, targetDir, overridesRoot) {
+    // If the consumer has an overlay for this file (and it's escapable),
+    // the overlay wins — ignore source changes.
+    if (hit.category && existsSync(join(overridesRoot, hit.rel)))
+        return;
+    const dest = join(targetDir, hit.rel);
+    const source = join(SOURCE_DIR, hit.rel);
+    if (kind === "unlink") {
+        rmSync(dest, { force: true, recursive: true });
+        return;
+    }
+    if (existsSync(source))
+        cpSync(source, dest, { recursive: true, force: true });
+}
+function fullReload(server) {
+    server.ws.send({ type: "full-reload" });
+}
+/** Resolve livemark.config.ts's `vite` field — either a config object
+ *  or a function `(env) => config` (matching Vite's own `defineConfig`).
+ *  Schema stores it as `unknown`; typing for the consumer's editor
+ *  lives on {@link ViteOverride}. */
+async function resolveViteOverride(vite, env) {
+    if (!vite)
+        return null;
+    if (typeof vite === "function") {
+        const result = await Reflect.apply(vite, undefined, [env]);
+        return isObject(result) ? result : null;
+    }
+    return isObject(vite) ? vite : null;
+}
+function isObject(v) {
+    return v !== null && typeof v === "object";
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vite-livemark.js","sourceRoot":"","sources":["../../source/plugins/vite-livemark.ts"],"names":[],"mappings":"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","sourcesContent":["import { cpSync, existsSync, rmSync } from \"node:fs\"\nimport { join, sep } from \"node:path\"\nimport type {\n  ConfigEnv,\n  Plugin,\n  UserConfig as ViteUserConfig,\n  ViteDevServer,\n} from \"vite\"\nimport { mergeConfig } from \"vite\"\nimport { buildTarget } from \"../actions/target/build.ts\"\nimport type { Config } from \"../models/config.ts\"\nimport { WebsiteConfig } from \"../models/config.ts\"\nimport { ESCAPABLE_FILES, ESCAPABLE_FOLDERS } from \"../settings.ts\"\n\nexport interface LivemarkOptions {\n  config: Config\n}\n\nconst SOURCE_DIR = join(import.meta.dirname, \"..\")\n\n/** Single virtual module exposing livemark's runtime values to consumer\n *  override files via named exports:\n *\n *      import { config } from \"livemark:virtual\"\n *\n *  Currently exports `config` (validated `WebsiteConfig`); future\n *  additions (e.g. `articles`, `sections`) land here as new named\n *  exports without consumers changing their import statements.\n *\n *  The `\\0` prefix on the resolved id is Vite's convention to signal\n *  \"this is a virtual module — no other plugin should try to resolve\n *  or load it from disk\". */\nconst VIRTUAL_ID = \"livemark:virtual\"\nconst VIRTUAL_RESOLVED_ID = `\\0${VIRTUAL_ID}`\n\n/** Owns the per-consumer `targets/<hash>/` mount: synthesizes it via\n *  `buildTarget()`, returns the Vite config that anchors there, and\n *  watches the consumer's `.livemark/` (plus livemark's `source/` in\n *  dev) for changes that need to be re-copied into the target. The\n *  override mechanism is pure file-system (full copies) — no resolveId\n *  redirection, no realpath surprises. */\nexport function livemark(opts: LivemarkOptions): Plugin {\n  const overridesRoot = join(opts.config.root, \".livemark\")\n  let targetDir = \"\"\n  return {\n    name: \"livemark\",\n    enforce: \"pre\",\n    async config(_, env) {\n      targetDir = buildTarget(opts.config.configPath)\n      const base: ViteUserConfig = {\n        root: targetDir,\n        // outDir lives outside the target root (in the consumer's\n        // .livemark/) so the consumer can find their deployable output\n        // without digging into node_modules. Vite's default refusal to\n        // empty out-of-root directories doesn't apply here because the\n        // target/ root is livemark's, not the consumer's.\n        build: { outDir: join(overridesRoot, \"build\"), emptyOutDir: true },\n        resolve: { dedupe: [\"react\", \"react-dom\"] },\n      }\n      const override = await resolveViteOverride(opts.config.vite, env)\n      return override ? mergeConfig(base, override) : base\n    },\n    resolveId(id) {\n      if (id === VIRTUAL_ID) return VIRTUAL_RESOLVED_ID\n      return null\n    },\n    load(id) {\n      if (id !== VIRTUAL_RESOLVED_ID) return null\n      const config = WebsiteConfig.parse(opts.config)\n      return `export const config = ${JSON.stringify(config)}`\n    },\n    configureServer(server) {\n      server.watcher.add(opts.config.configPath)\n      server.watcher.add(join(overridesRoot, \"**\", \"*\"))\n      server.watcher.add(join(SOURCE_DIR, \"**\", \"*\"))\n\n      server.watcher.on(\"change\", file => onChange(file, \"change\"))\n      server.watcher.on(\"add\", file => onChange(file, \"add\"))\n      server.watcher.on(\"unlink\", file => onChange(file, \"unlink\"))\n\n      function onChange(file: string, kind: \"change\" | \"add\" | \"unlink\") {\n        if (file === opts.config.configPath) {\n          server.restart()\n          return\n        }\n        const overlayHit = matchOverlay(file, overridesRoot)\n        if (overlayHit) {\n          syncOverlay(overlayHit, kind, targetDir, overridesRoot)\n          if (kind !== \"change\") fullReload(server)\n          return\n        }\n        const sourceHit = matchSource(file)\n        if (sourceHit) {\n          syncSource(sourceHit, kind, targetDir, overridesRoot)\n          if (kind !== \"change\") fullReload(server)\n        }\n      }\n    },\n  }\n}\n\ninterface Hit {\n  rel: string\n  category: \"folder\" | \"file\" | null\n}\n\nfunction matchOverlay(file: string, overridesRoot: string): Hit | null {\n  const prefix = `${overridesRoot}${sep}`\n  if (!file.startsWith(prefix)) return null\n  const rel = file.slice(prefix.length)\n  return { rel, category: classify(rel) }\n}\n\nfunction matchSource(file: string): Hit | null {\n  const prefix = `${SOURCE_DIR}${sep}`\n  if (!file.startsWith(prefix)) return null\n  // Skip the targets/ output dir itself (sibling of source/) and any\n  // `.gen.ts` files that downstream tools regenerate inside the target.\n  const rel = file.slice(prefix.length)\n  if (rel === \"\" || rel.includes(\"routeTree.gen.ts\")) return null\n  return { rel, category: classify(rel) }\n}\n\nfunction classify(rel: string): \"folder\" | \"file\" | null {\n  const [head] = rel.split(sep)\n  if (head && ESCAPABLE_FOLDERS.includes(head)) return \"folder\"\n  if (ESCAPABLE_FILES.includes(rel)) return \"file\"\n  // Non-escapable source files still need to flow into target during\n  // livemark's own dev — the user is editing the canonical source.\n  return null\n}\n\nfunction syncOverlay(\n  hit: Hit,\n  kind: \"change\" | \"add\" | \"unlink\",\n  targetDir: string,\n  overridesRoot: string,\n) {\n  if (!hit.category) return\n  const dest = join(targetDir, hit.rel)\n  const source = join(SOURCE_DIR, hit.rel)\n  if (kind === \"unlink\") {\n    rmSync(dest, { force: true, recursive: true })\n    if (existsSync(source))\n      cpSync(source, dest, { recursive: true, force: true })\n    return\n  }\n  const overlay = join(overridesRoot, hit.rel)\n  if (existsSync(overlay))\n    cpSync(overlay, dest, { recursive: true, force: true })\n}\n\nfunction syncSource(\n  hit: Hit,\n  kind: \"change\" | \"add\" | \"unlink\",\n  targetDir: string,\n  overridesRoot: string,\n) {\n  // If the consumer has an overlay for this file (and it's escapable),\n  // the overlay wins — ignore source changes.\n  if (hit.category && existsSync(join(overridesRoot, hit.rel))) return\n  const dest = join(targetDir, hit.rel)\n  const source = join(SOURCE_DIR, hit.rel)\n  if (kind === \"unlink\") {\n    rmSync(dest, { force: true, recursive: true })\n    return\n  }\n  if (existsSync(source)) cpSync(source, dest, { recursive: true, force: true })\n}\n\nfunction fullReload(server: ViteDevServer) {\n  server.ws.send({ type: \"full-reload\" })\n}\n\n/** Resolve livemark.config.ts's `vite` field — either a config object\n *  or a function `(env) => config` (matching Vite's own `defineConfig`).\n *  Schema stores it as `unknown`; typing for the consumer's editor\n *  lives on {@link ViteOverride}. */\nasync function resolveViteOverride(\n  vite: unknown,\n  env: ConfigEnv,\n): Promise<Record<string, unknown> | null> {\n  if (!vite) return null\n  if (typeof vite === \"function\") {\n    const result = await Reflect.apply(vite, undefined, [env])\n    return isObject(result) ? result : null\n  }\n  return isObject(vite) ? vite : null\n}\n\nfunction isObject(v: unknown): v is Record<string, unknown> {\n  return v !== null && typeof v === \"object\"\n}\n"]}