@haruhimemoe/next-kit 0.5.0 → 0.6.0

package/dist/docs/files/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @file src/docs/files/index.ts
+ * @desc @haruhimemoe/next-kit/docs/files: reads the markdown files a content registry's entries
+ *       point at. Server only: loads node:fs (kept out of the pure `docs` entry point on
+ *       purpose). A section's markdown source lives at "<root>/content/<section>/<slug>.mdx";
+ *       `readContentMarkdown` converts one with `mdxToMarkdown`, and `contentFileDrift` compares
+ *       the registry against the files actually on disk.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sun Oct 4, 2026
+ * @modified Sun Oct 4, 2026
+ */
+import { type Content, type ContentSection, type MarkdownOptions } from "../index.js";
+/**
+ * @function readContentMarkdown
+ * @param content {Content} a validated registry from `defineContent`
+ * @param section {ContentSection} the section the entry lives under
+ * @param slug {string} the entry's slug
+ * @param options {{ root?: string; siteUrl: string; transforms?: MarkdownOptions["transforms"] }}
+ *   `root` defaults to `process.cwd()`; the source file is read from
+ *   "<root>/content/<section>/<slug>.mdx"
+ * @returns {Promise<string | null>} the converted markdown, or null when the slug isn't
+ *   registered in `content`
+ * @throws {Error} the file system's ENOENT when the slug is registered but its file is missing
+ */
+export declare const readContentMarkdown: (content: Content, section: ContentSection, slug: string, options: {
+    root?: string;
+    siteUrl: string;
+    transforms?: MarkdownOptions["transforms"];
+}) => Promise<string | null>;
+/**
+ * @function contentFileDrift
+ * @param content {Content} a validated registry from `defineContent`
+ * @param options {{ root?: string }} `root` defaults to `process.cwd()`
+ * @returns {{ missingFiles: string[]; unregistered: string[] }} `missingFiles` lists every
+ *   registered entry with no ".mdx" file on disk (like "guides/x.mdx"); `unregistered` lists
+ *   every ".mdx" file on disk with no matching registry entry
+ */
+export declare const contentFileDrift: (content: Content, options?: {
+    root?: string;
+}) => {
+    missingFiles: string[];
+    unregistered: string[];
+};

package/dist/docs/files/index.js

@@ -0,0 +1,74 @@
+/**
+ * @file src/docs/files/index.ts
+ * @desc @haruhimemoe/next-kit/docs/files: reads the markdown files a content registry's entries
+ *       point at. Server only: loads node:fs (kept out of the pure `docs` entry point on
+ *       purpose). A section's markdown source lives at "<root>/content/<section>/<slug>.mdx";
+ *       `readContentMarkdown` converts one with `mdxToMarkdown`, and `contentFileDrift` compares
+ *       the registry against the files actually on disk.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sun Oct 4, 2026
+ * @modified Sun Oct 4, 2026
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { CONTENT_SECTIONS, findEntry, mdxToMarkdown, } from "../index.js";
+const MDX_EXTENSION = ".mdx";
+/** Where an entry's source markdown lives, relative to root: "<section>/<slug>.mdx". */
+const entryFile = (section, slug) => `${section}/${slug}${MDX_EXTENSION}`;
+/**
+ * @function readContentMarkdown
+ * @param content {Content} a validated registry from `defineContent`
+ * @param section {ContentSection} the section the entry lives under
+ * @param slug {string} the entry's slug
+ * @param options {{ root?: string; siteUrl: string; transforms?: MarkdownOptions["transforms"] }}
+ *   `root` defaults to `process.cwd()`; the source file is read from
+ *   "<root>/content/<section>/<slug>.mdx"
+ * @returns {Promise<string | null>} the converted markdown, or null when the slug isn't
+ *   registered in `content`
+ * @throws {Error} the file system's ENOENT when the slug is registered but its file is missing
+ */
+export const readContentMarkdown = async (content, section, slug, options) => {
+    const entry = findEntry(content, section, slug);
+    if (!entry)
+        return null;
+    const root = options.root ?? process.cwd();
+    const source = await readFile(join(root, "content", entryFile(section, slug)), "utf8");
+    return mdxToMarkdown(source, {
+        title: entry.title,
+        siteUrl: options.siteUrl,
+        ...(options.transforms !== undefined ? { transforms: options.transforms } : {}),
+    });
+};
+/**
+ * @function contentFileDrift
+ * @param content {Content} a validated registry from `defineContent`
+ * @param options {{ root?: string }} `root` defaults to `process.cwd()`
+ * @returns {{ missingFiles: string[]; unregistered: string[] }} `missingFiles` lists every
+ *   registered entry with no ".mdx" file on disk (like "guides/x.mdx"); `unregistered` lists
+ *   every ".mdx" file on disk with no matching registry entry
+ */
+export const contentFileDrift = (content, options = {}) => {
+    const root = options.root ?? process.cwd();
+    const missingFiles = [];
+    const unregistered = [];
+    for (const section of CONTENT_SECTIONS) {
+        const slugs = new Set(content.entries[section].map((entry) => entry.slug));
+        for (const slug of slugs) {
+            if (!existsSync(join(root, "content", entryFile(section, slug))))
+                missingFiles.push(entryFile(section, slug));
+        }
+        let files;
+        try {
+            files = readdirSync(join(root, "content", section));
+        }
+        catch {
+            files = [];
+        }
+        for (const file of files) {
+            if (file.endsWith(MDX_EXTENSION) && !slugs.has(file.slice(0, -MDX_EXTENSION.length)))
+                unregistered.push(`${section}/${file}`);
+        }
+    }
+    return { missingFiles, unregistered };
+};

package/dist/docs/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file src/docs/index.ts
+ * @desc @haruhimemoe/next-kit/docs: the content registry (sections, entries, app-made extras),
+ *       the path helpers every docs, guides and legal page is built from, mdxToMarkdown's
+ *       MDX-to-plain-Markdown conversion, and the crawl helpers (llms.txt, llms-full.txt, sitemap
+ *       entries, the ".md" mirror rewrite) built from the registry. Pure: no node: imports, so it
+ *       runs in any route, edge or browser. File-backed markdown reading lives under the separate
+ *       `docs/files` entry point.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sun Oct 4, 2026
+ * @modified Sun Oct 4, 2026
+ */
+export { type ContentApiLink, type ContentLlmsFullOptions, type ContentLlmsTxtOptions, type ContentRewriteRule, contentLlmsFull, contentLlmsTxt, contentRewrites, contentSitemap, } from "./crawl.js";
+export { type MarkdownOptions, mdxToMarkdown } from "./markdown.js";
+export { CONTENT_SECTIONS, type Content, type ContentEntry, type ContentInput, type ContentSection, contentParams, contentPath, defineContent, type ExtraEntry, findEntry, type HowToStep, markdownPath, SECTION_LABELS, } from "./registry.js";

package/dist/docs/index.js

@@ -0,0 +1,15 @@
+/**
+ * @file src/docs/index.ts
+ * @desc @haruhimemoe/next-kit/docs: the content registry (sections, entries, app-made extras),
+ *       the path helpers every docs, guides and legal page is built from, mdxToMarkdown's
+ *       MDX-to-plain-Markdown conversion, and the crawl helpers (llms.txt, llms-full.txt, sitemap
+ *       entries, the ".md" mirror rewrite) built from the registry. Pure: no node: imports, so it
+ *       runs in any route, edge or browser. File-backed markdown reading lives under the separate
+ *       `docs/files` entry point.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sun Oct 4, 2026
+ * @modified Sun Oct 4, 2026
+ */
+export { contentLlmsFull, contentLlmsTxt, contentRewrites, contentSitemap, } from "./crawl.js";
+export { mdxToMarkdown } from "./markdown.js";
+export { CONTENT_SECTIONS, contentParams, contentPath, defineContent, findEntry, markdownPath, SECTION_LABELS, } from "./registry.js";

package/dist/docs/markdown-segments.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @file src/docs/markdown-segments.ts
+ * @desc Fence-aware line segmenting for mdxToMarkdown, split out to keep markdown.ts under 200
+ *       lines: splits text into fence and prose runs (a fence may be indented, e.g. under a list
+ *       item), and merges a <Callout> opened in one prose segment with its closing tag in a
+ *       later segment (because its body holds a fenced code block) into one already-converted
+ *       blockquote segment. Pure: no node: imports.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sun Oct 4, 2026
+ * @modified Sun Oct 4, 2026
+ */
+/** One run of consecutive lines, either inside a fence (left alone) or prose (converted). */
+export type Segment = {
+    readonly isFence: boolean;
+    readonly lines: readonly string[];
+};
+/**
+ * @function segmentFences
+ * @param text {string} the MDX prose, after transforms and newline normalization
+ * @returns {Segment[]} fence and prose runs, in order; a fence's opening indentation is not
+ *   required on its closing line, only the same marker character repeated at least as many times
+ */
+export declare const segmentFences: (text: string) => Segment[];
+/**
+ * @function mergeCalloutSegments
+ * @param segments {Segment[]} the result of `segmentFences`
+ * @param processBodyProse {(text: string) => string} rules 4/5 (JSX removal, link absolutizing),
+ *   run on every non-fence chunk of a merged callout's body before it is quoted; fence chunks of
+ *   the body are passed to `toBlockquote` untouched
+ * @param toBlockquote {(attrs: string, body: string) => string} rule 3's attrs+body-to-blockquote
+ *   converter
+ * @returns {Segment[]} the same segments, except a `<Callout>` opened in one prose segment and
+ *   closed in a later one (its body holds a fenced code block, so `segmentFences` split it out)
+ *   becomes a single, already-converted blockquote segment marked `isFence: true` so the caller
+ *   does not run prose rules over it again
+ */
+export declare const mergeCalloutSegments: (segments: Segment[], processBodyProse: (text: string) => string, toBlockquote: (attrs: string, body: string) => string) => Segment[];

package/dist/docs/markdown-segments.js

@@ -0,0 +1,147 @@
+/**
+ * @file src/docs/markdown-segments.ts
+ * @desc Fence-aware line segmenting for mdxToMarkdown, split out to keep markdown.ts under 200
+ *       lines: splits text into fence and prose runs (a fence may be indented, e.g. under a list
+ *       item), and merges a <Callout> opened in one prose segment with its closing tag in a
+ *       later segment (because its body holds a fenced code block) into one already-converted
+ *       blockquote segment. Pure: no node: imports.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sun Oct 4, 2026
+ * @modified Sun Oct 4, 2026
+ */
+const FENCE_OPEN = /^(\s*)(`{3,}|~{3,})/;
+const CALLOUT_OPEN_OR_CLOSE = /<Callout([^>]*)>|<\/Callout>/g;
+const CALLOUT_CLOSE_TAG = "</Callout>";
+/**
+ * @function segmentFences
+ * @param text {string} the MDX prose, after transforms and newline normalization
+ * @returns {Segment[]} fence and prose runs, in order; a fence's opening indentation is not
+ *   required on its closing line, only the same marker character repeated at least as many times
+ */
+export const segmentFences = (text) => {
+    const lines = text.split("\n");
+    const segments = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line === undefined)
+            break;
+        const open = line.match(FENCE_OPEN);
+        if (!open) {
+            const prose = [];
+            while (i < lines.length) {
+                const proseLine = lines[i];
+                if (proseLine === undefined || FENCE_OPEN.test(proseLine))
+                    break;
+                prose.push(proseLine);
+                i++;
+            }
+            segments.push({ isFence: false, lines: prose });
+            continue;
+        }
+        const marker = open[2]?.[0] ?? "`";
+        const minLength = open[2]?.length ?? 3;
+        const close = new RegExp(`^\\s*${marker}{${minLength},}\\s*$`);
+        const fence = [line];
+        i++;
+        while (i < lines.length) {
+            const fenceLine = lines[i];
+            if (fenceLine === undefined)
+                break;
+            fence.push(fenceLine);
+            const isClose = close.test(fenceLine);
+            i++;
+            if (isClose)
+                break;
+        }
+        segments.push({ isFence: true, lines: fence });
+    }
+    return segments;
+};
+/** Finds a trailing `<Callout>` open tag in `text` with no matching `</Callout>` after it. */
+const findUnmatchedCallout = (text) => {
+    let depth = 0;
+    let pending = null;
+    CALLOUT_OPEN_OR_CLOSE.lastIndex = 0;
+    let match = CALLOUT_OPEN_OR_CLOSE.exec(text);
+    while (match !== null) {
+        if (match[1] !== undefined) {
+            if (depth === 0) {
+                pending = { start: match.index, end: match.index + match[0].length, attrs: match[1] };
+            }
+            depth++;
+        }
+        else {
+            depth = Math.max(0, depth - 1);
+            if (depth === 0)
+                pending = null;
+        }
+        match = CALLOUT_OPEN_OR_CLOSE.exec(text);
+    }
+    return depth > 0 ? pending : null;
+};
+/**
+ * @function mergeCalloutSegments
+ * @param segments {Segment[]} the result of `segmentFences`
+ * @param processBodyProse {(text: string) => string} rules 4/5 (JSX removal, link absolutizing),
+ *   run on every non-fence chunk of a merged callout's body before it is quoted; fence chunks of
+ *   the body are passed to `toBlockquote` untouched
+ * @param toBlockquote {(attrs: string, body: string) => string} rule 3's attrs+body-to-blockquote
+ *   converter
+ * @returns {Segment[]} the same segments, except a `<Callout>` opened in one prose segment and
+ *   closed in a later one (its body holds a fenced code block, so `segmentFences` split it out)
+ *   becomes a single, already-converted blockquote segment marked `isFence: true` so the caller
+ *   does not run prose rules over it again
+ */
+export const mergeCalloutSegments = (segments, processBodyProse, toBlockquote) => {
+    const merged = [];
+    let attrs = null;
+    let chunks = null;
+    for (const segment of segments) {
+        if (chunks !== null) {
+            const text = segment.lines.join("\n");
+            const closeAt = segment.isFence ? -1 : text.indexOf(CALLOUT_CLOSE_TAG);
+            if (closeAt === -1) {
+                chunks.push({ isFence: segment.isFence, text });
+                continue;
+            }
+            const bodyPart = text.slice(0, closeAt);
+            const remainder = text.slice(closeAt + CALLOUT_CLOSE_TAG.length);
+            if (bodyPart.length > 0)
+                chunks.push({ isFence: false, text: bodyPart });
+            const body = chunks
+                .map((chunk) => (chunk.isFence ? chunk.text : processBodyProse(chunk.text)))
+                .join("\n");
+            const blockquote = toBlockquote(attrs ?? "", body);
+            merged.push({ isFence: true, lines: blockquote.split("\n") });
+            chunks = null;
+            attrs = null;
+            if (remainder.length > 0) {
+                const rest = mergeCalloutSegments([{ isFence: false, lines: remainder.split("\n") }], processBodyProse, toBlockquote);
+                merged.push(...rest);
+            }
+            continue;
+        }
+        if (segment.isFence) {
+            merged.push(segment);
+            continue;
+        }
+        const text = segment.lines.join("\n");
+        const unmatched = findUnmatchedCallout(text);
+        if (!unmatched) {
+            merged.push(segment);
+            continue;
+        }
+        const before = text.slice(0, unmatched.start);
+        if (before.length > 0)
+            merged.push({ isFence: false, lines: before.split("\n") });
+        attrs = unmatched.attrs;
+        chunks = [{ isFence: false, text: text.slice(unmatched.end) }];
+    }
+    if (chunks !== null) {
+        // Unterminated callout (malformed input): best-effort passthrough, raw.
+        const body = chunks.map((chunk) => chunk.text).join("\n");
+        merged.push({ isFence: false, lines: body.split("\n") });
+    }
+    return merged;
+};

package/dist/docs/markdown.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @file src/docs/markdown.ts
+ * @desc Converts bb-flavored MDX (<Callout>, capitalized JSX like <Example>, import/export lines)
+ *       into plain Markdown for an app's generated .md pages: callouts become blockquotes,
+ *       import/export lines are dropped, root-relative links and images become absolute with the
+ *       site's origin, and a missing title heading is added. Pure: no node: imports, so it runs
+ *       anywhere. Everything inside a fenced code block (``` or ~~~, 3+ characters, matched close,
+ *       optionally indented) is left exactly as written; a `<Callout>` whose body holds one of
+ *       those fences still converts to a blockquote (see markdown-segments.ts).
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sun Oct 4, 2026
+ * @modified Sun Oct 4, 2026
+ */
+/** Options for `mdxToMarkdown`. */
+export type MarkdownOptions = {
+    title: string;
+    siteUrl: string;
+    /** Run first, over the whole raw source (bb's <Example>). */
+    transforms?: readonly ((source: string) => string)[];
+};
+/**
+ * @function mdxToMarkdown
+ * @param source {string} the raw MDX source
+ * @param options {MarkdownOptions} the fallback title, the site's origin for root-relative
+ *   links and images, and any transforms to run first over the whole source
+ * @returns {string} the converted Markdown: content inside fenced code blocks is untouched,
+ *   import/export lines and other capitalized JSX are removed, callouts become blockquotes,
+ *   root-relative links and images become absolute, a title heading is added when missing, and
+ *   the result ends with exactly one trailing newline
+ */
+export declare const mdxToMarkdown: (source: string, options: MarkdownOptions) => string;

package/dist/docs/markdown.js

@@ -0,0 +1,117 @@
+/**
+ * @file src/docs/markdown.ts
+ * @desc Converts bb-flavored MDX (<Callout>, capitalized JSX like <Example>, import/export lines)
+ *       into plain Markdown for an app's generated .md pages: callouts become blockquotes,
+ *       import/export lines are dropped, root-relative links and images become absolute with the
+ *       site's origin, and a missing title heading is added. Pure: no node: imports, so it runs
+ *       anywhere. Everything inside a fenced code block (``` or ~~~, 3+ characters, matched close,
+ *       optionally indented) is left exactly as written; a `<Callout>` whose body holds one of
+ *       those fences still converts to a blockquote (see markdown-segments.ts).
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sun Oct 4, 2026
+ * @modified Sun Oct 4, 2026
+ */
+import { mergeCalloutSegments, segmentFences } from "./markdown-segments.js";
+const EXPORT_OBJECT_OPEN = /^export\s+const\s+\S+\s*=\s*\{\s*$/;
+const EXPORT_OBJECT_CLOSE = /^\}\s*;?\s*$/;
+const IMPORT_OR_EXPORT = /^(?:import|export)\b/;
+const CALLOUT = /<Callout([^>]*)>([\s\S]*?)<\/Callout>/g;
+const CALLOUT_TYPE = /\btype="([^"]*)"/;
+const JSX_TAG = /<\/?[A-Z][\w.]*(?:\s[^<>]*)?\s*\/?>/g;
+const ROOT_LINK_TARGET = /\]\(\/(?!\/)([^)]*)\)/g;
+const titleCase = (value) => value.length === 0 ? value : value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+/** Rule 2: drops top-level import/export lines, and an export const object block. */
+const dropImportExport = (text) => {
+    const lines = text.split("\n");
+    const kept = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line === undefined)
+            break;
+        if (EXPORT_OBJECT_OPEN.test(line)) {
+            i++;
+            while (i < lines.length) {
+                const blockLine = lines[i];
+                if (blockLine === undefined || EXPORT_OBJECT_CLOSE.test(blockLine))
+                    break;
+                i++;
+            }
+            i++;
+            continue;
+        }
+        if (IMPORT_OR_EXPORT.test(line)) {
+            i++;
+            continue;
+        }
+        kept.push(line);
+        i++;
+    }
+    return kept.join("\n");
+};
+/**
+ * Rule 3: turns a `<Callout type="x" title="...">body</Callout>` match's attrs and body into a
+ * blockquote: the label on the first line, every other body line (fence lines included, for a
+ * callout whose body holds a fenced code block) prefixed with `> `.
+ */
+const calloutBodyToBlockquote = (attrs, body) => {
+    const type = CALLOUT_TYPE.exec(attrs)?.[1] ?? "note";
+    const label = titleCase(type);
+    const lines = body.replace(/^\n+/, "").replace(/\n+$/, "").split("\n");
+    const [first = "", ...rest] = lines;
+    return [`> **${label}:** ${first}`, ...rest.map((line) => `> ${line}`)].join("\n");
+};
+/** Rule 3: <Callout type="x" title="...">body</Callout> becomes a blockquote. */
+const convertCallouts = (text) => text.replace(CALLOUT, (_match, attrs, body) => calloutBodyToBlockquote(attrs, body));
+/** Rule 4: removes any other capitalized JSX tag, keeping the text between tags. */
+const removeJsxTags = (text) => text.replace(JSX_TAG, "");
+/** Rule 5: a link or image target starting with a single "/" becomes absolute. */
+const absolutizeRootLinks = (text, siteUrl) => text.replace(ROOT_LINK_TARGET, (_match, target) => `](${siteUrl}/${target})`);
+const processProse = (text, siteUrl) => absolutizeRootLinks(removeJsxTags(convertCallouts(dropImportExport(text))), siteUrl);
+/** Rule 6: prepends the title heading when the first non-blank line isn't one. */
+const ensureTitle = (text, title) => {
+    const firstContentLine = text.split("\n").find((line) => line.trim() !== "");
+    return firstContentLine?.startsWith("# ") ? text : `# ${title}\n\n${text}`;
+};
+/** Rule 7: collapses runs of 3+ blank lines to 2, then trims to exactly one trailing newline. */
+const finalize = (text) => {
+    const lines = text.split("\n");
+    const kept = [];
+    let blankRun = 0;
+    for (const line of lines) {
+        if (line.trim() === "") {
+            blankRun++;
+            if (blankRun <= 2)
+                kept.push(line);
+        }
+        else {
+            blankRun = 0;
+            kept.push(line);
+        }
+    }
+    return `${kept.join("\n").trim()}\n`;
+};
+/**
+ * @function mdxToMarkdown
+ * @param source {string} the raw MDX source
+ * @param options {MarkdownOptions} the fallback title, the site's origin for root-relative
+ *   links and images, and any transforms to run first over the whole source
+ * @returns {string} the converted Markdown: content inside fenced code blocks is untouched,
+ *   import/export lines and other capitalized JSX are removed, callouts become blockquotes,
+ *   root-relative links and images become absolute, a title heading is added when missing, and
+ *   the result ends with exactly one trailing newline
+ */
+export const mdxToMarkdown = (source, options) => {
+    const { title, siteUrl, transforms = [] } = options;
+    let text = source.replace(/\r\n?/g, "\n");
+    for (const transform of transforms)
+        text = transform(text);
+    text = text.replace(/\r\n?/g, "\n");
+    // Rules 4/5 only, run on a fence-spanning callout's non-fence body chunks before quoting; see
+    // mergeCalloutSegments's doc comment for why fence chunks skip this.
+    const processBodyProse = (body) => absolutizeRootLinks(removeJsxTags(body), siteUrl);
+    const converted = mergeCalloutSegments(segmentFences(text), processBodyProse, calloutBodyToBlockquote)
+        .map((segment) => segment.isFence ? segment.lines.join("\n") : processProse(segment.lines.join("\n"), siteUrl))
+        .join("\n");
+    return finalize(ensureTitle(converted, title));
+};

package/dist/docs/registry.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @file src/docs/registry.ts
+ * @desc The content registry every haruhime.moe site builds its docs, guides and legal pages
+ *       from: a frozen list of sections, the entry shape each page fills in, the app-made extra
+ *       entries a section's nav and search also carry (like bb's tag pages), and the validation
+ *       that catches a bad slug, a duplicate, a made-up date or a blank title at build time
+ *       instead of at a 404. Pure: no node: imports, so it runs anywhere.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sun Oct 4, 2026
+ * @modified Sun Oct 4, 2026
+ */
+/** Every content section a haruhime.moe site can have, in the order it's shown. */
+export declare const CONTENT_SECTIONS: readonly ["docs", "guides", "legal"];
+/** One of `CONTENT_SECTIONS`. */
+export type ContentSection = (typeof CONTENT_SECTIONS)[number];
+/** The nav label for each section. */
+export declare const SECTION_LABELS: Record<ContentSection, string>;
+/** One numbered step of a HowTo entry. */
+export type HowToStep = {
+    name: string;
+    text: string;
+};
+/** A page backed by a markdown file: its slug, nav copy and when it last changed. */
+export type ContentEntry = {
+    slug: string;
+    title: string;
+    navTitle?: string;
+    description: string;
+    /** YYYY-MM-DD. */
+    lastUpdated: string;
+    howTo?: readonly HowToStep[];
+};
+/** An app-made page shown in a section's nav and search, e.g. bb's tag pages. */
+export type ExtraEntry = {
+    href: string;
+    title: string;
+    navTitle?: string;
+    description: string;
+    group: string;
+    badge?: string;
+    lastUpdated?: string;
+    markdownHref?: string;
+};
+/** What an app passes to `defineContent`: its entries and extras, by section. */
+export type ContentInput = Partial<Record<ContentSection, readonly ContentEntry[]>> & {
+    extra?: Partial<Record<ContentSection, readonly ExtraEntry[]>>;
+};
+/** A validated, section-complete content registry. */
+export type Content = {
+    /** Non-empty sections, in `CONTENT_SECTIONS` order. */
+    sections: ContentSection[];
+    entries: Record<ContentSection, readonly ContentEntry[]>;
+    extra: Record<ContentSection, readonly ExtraEntry[]>;
+};
+/**
+ * @function defineContent
+ * @param input {ContentInput} each section's entries, and the app-made extras under `extra`
+ * @returns {Content} every section filled in (empty arrays for the ones left out), and
+ *   `sections` listing only the non-empty ones, in `CONTENT_SECTIONS` order
+ * @throws {Error} naming the section and slug or extra href, for a bad slug, a duplicate slug,
+ *   a duplicate extra href, a `lastUpdated` that isn't a real `YYYY-MM-DD` date, or a blank title
+ */
+export declare const defineContent: (input: ContentInput) => Content;
+/**
+ * @function contentPath
+ * @param section {ContentSection} the section the page lives under
+ * @param slug {string} the entry's slug
+ * @returns {string} the page's path, like "/guides/make-a-pack"
+ */
+export declare const contentPath: (section: ContentSection, slug: string) => string;
+/**
+ * @function markdownPath
+ * @param section {ContentSection} the section the page lives under
+ * @param slug {string} the entry's slug
+ * @returns {string} the page's raw markdown path, like "/guides/make-a-pack.md"
+ */
+export declare const markdownPath: (section: ContentSection, slug: string) => string;
+/**
+ * @function findEntry
+ * @param content {Content} a registry from `defineContent`
+ * @param section {ContentSection} the section to search
+ * @param slug {string} the entry's slug
+ * @returns {ContentEntry | undefined} the matching entry, or undefined
+ */
+export declare const findEntry: (content: Content, section: ContentSection, slug: string) => ContentEntry | undefined;
+/**
+ * @function contentParams
+ * @param content {Content} a registry from `defineContent`
+ * @param section {ContentSection} the section to list
+ * @returns {{ slug: string }[]} one param per entry, for a dynamic route's `generateStaticParams`
+ */
+export declare const contentParams: (content: Content, section: ContentSection) => {
+    slug: string;
+}[];