@haruhimemoe/next-kit 0.4.0 → 0.6.0

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;
+}[];

package/dist/docs/registry.js

@@ -0,0 +1,102 @@
+/**
+ * @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
+ */
+/** A slug is lowercase words separated by single hyphens, like "make-a-pack". */
+const SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** A date is YYYY-MM-DD and a real calendar day. */
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+/** Every content section a haruhime.moe site can have, in the order it's shown. */
+export const CONTENT_SECTIONS = ["docs", "guides", "legal"];
+/** The nav label for each section. */
+export const SECTION_LABELS = {
+    docs: "Docs",
+    guides: "Guides",
+    legal: "Legal",
+};
+const assertEntries = (section, entries) => {
+    const seen = new Set();
+    for (const entry of entries) {
+        if (!SLUG_PATTERN.test(entry.slug))
+            throw new Error(`docs: bad slug "${entry.slug}" in ${section}`);
+        if (seen.has(entry.slug))
+            throw new Error(`docs: duplicate slug "${entry.slug}" in ${section}`);
+        seen.add(entry.slug);
+        if (!DATE_PATTERN.test(entry.lastUpdated) || Number.isNaN(Date.parse(entry.lastUpdated)))
+            throw new Error(`docs: bad lastUpdated "${entry.lastUpdated}" in ${section} "${entry.slug}"`);
+        if (!entry.title.trim())
+            throw new Error(`docs: blank title in ${section} "${entry.slug}"`);
+    }
+};
+const assertExtras = (section, extras) => {
+    const seen = new Set();
+    for (const extra of extras) {
+        if (!extra.href.startsWith("/"))
+            throw new Error(`docs: extra href "${extra.href}" must start with "/" in ${section}`);
+        if (seen.has(extra.href))
+            throw new Error(`docs: duplicate extra href "${extra.href}" in ${section}`);
+        seen.add(extra.href);
+        if (!extra.title.trim())
+            throw new Error(`docs: blank title for extra "${extra.href}" in ${section}`);
+    }
+};
+/**
+ * @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 const defineContent = (input) => {
+    const entries = {};
+    const extra = {};
+    const sections = [];
+    for (const section of CONTENT_SECTIONS) {
+        const sectionEntries = input[section] ?? [];
+        const sectionExtras = input.extra?.[section] ?? [];
+        assertEntries(section, sectionEntries);
+        assertExtras(section, sectionExtras);
+        entries[section] = sectionEntries;
+        extra[section] = sectionExtras;
+        if (sectionEntries.length > 0 || sectionExtras.length > 0)
+            sections.push(section);
+    }
+    return { sections, entries, extra };
+};
+/**
+ * @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 const contentPath = (section, slug) => `/${section}/${slug}`;
+/**
+ * @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 const markdownPath = (section, slug) => `${contentPath(section, slug)}.md`;
+/**
+ * @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 const findEntry = (content, section, slug) => content.entries[section].find((entry) => entry.slug === slug);
+/**
+ * @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 const contentParams = (content, section) => content.entries[section].map((entry) => ({ slug: entry.slug }));

package/dist/server/security-txt.d.ts

@@ -6,7 +6,7 @@
  *       caller passes them here.
  * @author David @dvhsh (https://dvh.sh)
  * @created Mon Sep 28, 2026
- * @modified Mon Sep 28, 2026
+ * @modified Sat Oct 3, 2026
  */
 /** RFC 9116 asks for an Expires less than a year out. */
 export declare const SECURITY_TXT_LIFETIME_DAYS = 365;
@@ -22,11 +22,13 @@ export type SecurityTxtOptions = {
     policyUrl: string;
     /** When the file is built (build time for a static route). */
     now: Date;
+    /** A preferred report URL (like a GitHub advisory form), listed before the email. */
+    contactUrl?: string;
 };
 /**
  * @function buildSecurityTxt
- * @param options {SecurityTxtOptions} contact, site, policy and build time
- * @returns {string} the security.txt body: Contact, Expires, Preferred-Languages, Canonical,
- *          Policy, one field per line, ending in one newline
+ * @param options {SecurityTxtOptions} contact, site, policy, build time, and optional contact URL
+ * @returns {string} the security.txt body: Contact (URL first if present), Contact (mailto),
+ *          Expires, Preferred-Languages, Canonical, Policy, one field per line, ending in one newline
  */
-export declare const buildSecurityTxt: ({ contactEmail, siteUrl, policyUrl, now, }: SecurityTxtOptions) => string;
+export declare const buildSecurityTxt: ({ contactEmail, siteUrl, policyUrl, now, contactUrl, }: SecurityTxtOptions) => string;

package/dist/server/security-txt.js

@@ -6,7 +6,7 @@
  *       caller passes them here.
  * @author David @dvhsh (https://dvh.sh)
  * @created Mon Sep 28, 2026
- * @modified Mon Sep 28, 2026
+ * @modified Sat Oct 3, 2026
  */
 /** RFC 9116 asks for an Expires less than a year out. */
 export const SECURITY_TXT_LIFETIME_DAYS = 365;
@@ -14,13 +14,14 @@ export const SECURITY_TXT_LIFETIME_DAYS = 365;
 export const SECURITY_TXT_PATH = "/.well-known/security.txt";
 /**
  * @function buildSecurityTxt
- * @param options {SecurityTxtOptions} contact, site, policy and build time
- * @returns {string} the security.txt body: Contact, Expires, Preferred-Languages, Canonical,
- *          Policy, one field per line, ending in one newline
+ * @param options {SecurityTxtOptions} contact, site, policy, build time, and optional contact URL
+ * @returns {string} the security.txt body: Contact (URL first if present), Contact (mailto),
+ *          Expires, Preferred-Languages, Canonical, Policy, one field per line, ending in one newline
  */
-export const buildSecurityTxt = ({ contactEmail, siteUrl, policyUrl, now, }) => {
+export const buildSecurityTxt = ({ contactEmail, siteUrl, policyUrl, now, contactUrl, }) => {
     const expires = new Date(now.getTime() + SECURITY_TXT_LIFETIME_DAYS * 86_400_000);
     const lines = [
+        ...(contactUrl ? [`Contact: ${contactUrl}`] : []),
         `Contact: mailto:${contactEmail}`,
         `Expires: ${expires.toISOString()}`,
         "Preferred-Languages: en",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@haruhimemoe/next-kit",
-  "version": "0.4.0",
-  "description": "The Next.js plumbing the haruhime.moe tools share: JSON route helpers, rate limits and budgets in MongoDB, bearer machine auth, zod env parsing, a connect-once MongoDB client with safe index builds, better-auth with osu! sign-in, the signed-in marker and account store for the browser, and SEO: metadata, robots.txt, sitemaps, JSON-LD and llms.txt.",
+  "version": "0.6.0",
+  "description": "The Next.js plumbing the haruhime.moe tools share: JSON route helpers, rate limits and budgets in MongoDB, bearer machine auth, zod env parsing, a connect-once MongoDB client with safe index builds, better-auth with osu! sign-in, the signed-in marker and account store for the browser, SEO: metadata, robots.txt, sitemaps, JSON-LD and llms.txt, and per-app API keys and the /api/v1 guard.",
   "keywords": [
     "nextjs",
     "next.js",
@@ -14,7 +14,8 @@
     "seo",
     "json-ld",
     "sitemap",
-    "llms.txt"
+    "llms.txt",
+    "api keys"
   ],
   "homepage": "https://github.com/haruhimemoe/next-kit#readme",
   "bugs": "https://github.com/haruhimemoe/next-kit/issues",
@@ -25,6 +26,9 @@
   "license": "MIT",
   "author": "David (https://dvh.sh)",
   "type": "module",
+  "bin": {
+    "next-kit": "./dist/check/cli.js"
+  },
   "exports": {
     "./server": {
       "types": "./dist/server/index.d.ts",
@@ -54,6 +58,18 @@
       "types": "./dist/seo/index.d.ts",
       "default": "./dist/seo/index.js"
     },
+    "./api-keys": {
+      "types": "./dist/api-keys/index.d.ts",
+      "default": "./dist/api-keys/index.js"
+    },
+    "./docs": {
+      "types": "./dist/docs/index.d.ts",
+      "default": "./dist/docs/index.js"
+    },
+    "./docs/files": {
+      "types": "./dist/docs/files/index.d.ts",
+      "default": "./dist/docs/files/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -84,7 +100,7 @@
   },
   "peerDependencies": {
     "@haruhimemoe/osu": "^0.2.0 || ^0.3.0 || ^0.4.0",
-    "@haruhimemoe/ui": "^0.5.0",
+    "@haruhimemoe/ui": "^0.5.0 || ^0.6.0 || ^0.7.0 || ^0.8.0 || ^0.9.0 || ^0.10.0",
     "better-auth": "^1.7.5",
     "mongodb": "^7.6.0",
     "mongodb-memory-server": "^11.3.0",