@textmode/tooling-scripts 0.1.0

package/src/typedoc-plugins/all-member-pages-router/constants.js

@@ -0,0 +1,58 @@
+// @ts-check
+
+import { ReflectionKind } from 'typedoc';
+
+export const ROUTER_NAME = 'all-member-pages';
+
+export const ALWAYS_OWN_PAGE_KIND_NAMES = ['Module', 'Namespace', 'Document'];
+
+export const MAX_INLINE_SANDPACK_EXAMPLES = 3;
+
+export const MEMBER_PAGE_OWNER_KINDS = new Set([ReflectionKind.Class, ReflectionKind.Interface]);
+
+export const MEMBER_PAGE_KINDS = new Set([ReflectionKind.Method, ReflectionKind.Property, ReflectionKind.Accessor]);
+
+export const MEMBER_DIRECTORIES = new Map([
+	[ReflectionKind.Method, 'methods'],
+	[ReflectionKind.Property, 'properties'],
+	[ReflectionKind.Accessor, 'accessors'],
+]);
+
+const MEMBER_KIND_BY_NAME = new Map([
+	['method', ReflectionKind.Method],
+	['property', ReflectionKind.Property],
+	['accessor', ReflectionKind.Accessor],
+]);
+
+/**
+ * @param {string[]} memberPageKindNames
+ * @returns {void}
+ */
+export function configureMemberPages(memberPageKindNames) {
+	MEMBER_PAGE_KINDS.clear();
+	MEMBER_DIRECTORIES.clear();
+
+	const normalizedMemberPageKindNames = Array.isArray(memberPageKindNames)
+		? memberPageKindNames
+		: String(memberPageKindNames).split(',');
+
+	for (const memberPageKindName of normalizedMemberPageKindNames) {
+		const kind = MEMBER_KIND_BY_NAME.get(String(memberPageKindName).toLowerCase());
+
+		if (kind === undefined) {
+			continue;
+		}
+
+		MEMBER_PAGE_KINDS.add(kind);
+	}
+
+	if (MEMBER_PAGE_KINDS.has(ReflectionKind.Method)) {
+		MEMBER_DIRECTORIES.set(ReflectionKind.Method, 'methods');
+	}
+	if (MEMBER_PAGE_KINDS.has(ReflectionKind.Property)) {
+		MEMBER_DIRECTORIES.set(ReflectionKind.Property, 'properties');
+	}
+	if (MEMBER_PAGE_KINDS.has(ReflectionKind.Accessor)) {
+		MEMBER_DIRECTORIES.set(ReflectionKind.Accessor, 'accessors');
+	}
+}

package/src/typedoc-plugins/all-member-pages-router/index.js

@@ -0,0 +1,28 @@
+// @ts-check
+
+import { Converter, ParameterType } from 'typedoc';
+
+import { configureMemberPages, ROUTER_NAME } from './constants.js';
+import { AllMemberPagesRouter } from './router.js';
+
+/**
+ * TypeDoc plugin load function.
+ *
+ * @param {import('typedoc').Application} app
+ * @returns {void}
+ */
+export function load(app) {
+	app.options.addDeclaration({
+		name: 'textmodeMemberPageKinds',
+		help: 'Direct member kinds that may be split into focused API pages.',
+		type: ParameterType.Array,
+		defaultValue: ['method', 'property', 'accessor'],
+	});
+
+	app.converter.on(Converter.EVENT_BEGIN, () => {
+		configureMemberPages(app.options.getValue('textmodeMemberPageKinds'));
+	});
+
+	app.renderer.defineRouter(ROUTER_NAME, AllMemberPagesRouter);
+	app.logger.verbose('[typedoc] Registered all member pages router');
+}

package/src/typedoc-plugins/all-member-pages-router/member-paths.js

@@ -0,0 +1,48 @@
+// @ts-check
+
+import { MEMBER_DIRECTORIES } from './constants.js';
+
+/**
+ * @typedef {{
+ *   getIdealBaseName(reflection: import('typedoc').Reflection): string;
+ * }} MemberDirectoryRouter
+ */
+
+/**
+ * @typedef {{
+ *   getReflectionAlias(reflection: import('typedoc').Reflection): string;
+ * }} ReflectionAliasRouter
+ */
+
+/**
+ * Get the directory name for a direct Sandpack member kind.
+ *
+ * @param {import('typedoc').ReflectionKind} kind
+ * @returns {string | undefined}
+ */
+export function getMemberDirectoryName(kind) {
+	return MEMBER_DIRECTORIES.get(kind);
+}
+
+/**
+ * Build the directory path for a direct Sandpack member page.
+ *
+ * @param {MemberDirectoryRouter} router
+ * @param {import('typedoc').Reflection} reflection
+ * @returns {string}
+ */
+export function getDirectMemberDirectory(router, reflection) {
+	const directory = getMemberDirectoryName(reflection.kind);
+	return `${router.getIdealBaseName(reflection.parent)}/${directory}`;
+}
+
+/**
+ * Build a reflection filename for a direct Sandpack member page.
+ *
+ * @param {ReflectionAliasRouter} router
+ * @param {import('typedoc').Reflection} reflection
+ * @returns {string}
+ */
+export function getReflectionFileName(router, reflection) {
+	return router.getReflectionAlias(reflection);
+}

package/src/typedoc-plugins/all-member-pages-router/member-reflections.js

@@ -0,0 +1,164 @@
+// @ts-check
+
+import { ReflectionKind } from 'typedoc';
+
+import {
+	ALWAYS_OWN_PAGE_KIND_NAMES,
+	MEMBER_PAGE_KINDS,
+	MEMBER_PAGE_OWNER_KINDS,
+	MAX_INLINE_SANDPACK_EXAMPLES,
+} from './constants.js';
+
+/**
+ * @typedef {{
+ *   membersWithOwnFile: string[];
+ *   kindsToString: Map<import('typedoc').ReflectionKind, string>;
+ * }} OwnPagePolicyRouter
+ */
+
+/**
+ * @param {import('typedoc').Reflection | undefined} reflection
+ * @returns {string[]}
+ */
+function getOwnSandpackExamples(reflection) {
+	return (reflection?.comment?.blockTags || []).flatMap((tag) => {
+		if (tag.tag !== '@example') {
+			return [];
+		}
+
+		const content = (tag.content || []).map((part) => part.text).join('');
+		return /```(?:js|javascript|jsx|ts|typescript|tsx)\b/i.test(content) && /@title\b/.test(content)
+			? [content]
+			: [];
+	});
+}
+
+/**
+ * @param {import('typedoc').Reflection} reflection
+ * @returns {number}
+ */
+function countReflectionSandpackExamples(reflection) {
+	const examples = new Set([
+		...getOwnSandpackExamples(reflection),
+		...(reflection.signatures || []).flatMap((signature) => getOwnSandpackExamples(signature)),
+		...getOwnSandpackExamples(reflection.getSignature),
+		...getOwnSandpackExamples(reflection.setSignature),
+	]);
+
+	return examples.size;
+}
+
+/**
+ * @param {import('typedoc').Reflection} reflection
+ * @returns {boolean}
+ */
+function isPropertyLikeReflection(reflection) {
+	return reflection.kind === ReflectionKind.Property || reflection.kind === ReflectionKind.Accessor;
+}
+
+/**
+ * @param {import('typedoc').Reflection} reflection
+ * @returns {boolean}
+ */
+function isSandpackThresholdMemberReflection(reflection) {
+	return (
+		(reflection.kind === ReflectionKind.Method || isPropertyLikeReflection(reflection)) &&
+		countReflectionSandpackExamples(reflection) > 0
+	);
+}
+
+/**
+ * @param {import('typedoc').Reflection} owner
+ * @returns {number}
+ */
+function countInlineMemberSandpackExamples(owner) {
+	return (owner.children || [])
+		.filter((child) => isSandpackThresholdMemberReflection(child))
+		.reduce((count, member) => count + countReflectionSandpackExamples(member), 0);
+}
+
+/**
+ * Check whether direct members should become focused pages for this owner.
+ *
+ * @param {import('typedoc').Reflection} owner
+ * @returns {boolean}
+ */
+function shouldRenderMemberPages(owner) {
+	if (!MEMBER_PAGE_OWNER_KINDS.has(owner.kind)) {
+		return false;
+	}
+
+	const inlineExampleCount = countReflectionSandpackExamples(owner) + countInlineMemberSandpackExamples(owner);
+	return inlineExampleCount > MAX_INLINE_SANDPACK_EXAMPLES;
+}
+
+/**
+ * @param {import('typedoc').Reflection | undefined} reflection
+ * @returns {boolean}
+ */
+function isDirectManagedMemberReflection(reflection) {
+	return Boolean(
+		reflection?.parent &&
+			MEMBER_PAGE_OWNER_KINDS.has(reflection.parent.kind) &&
+			MEMBER_PAGE_KINDS.has(reflection.kind)
+	);
+}
+
+function shouldSuppressDefaultDirectMemberPagePolicy() {
+	return MEMBER_PAGE_KINDS.has(ReflectionKind.Property) || MEMBER_PAGE_KINDS.has(ReflectionKind.Accessor);
+}
+
+function shouldRenderAllDirectMethodPages() {
+	return MEMBER_PAGE_KINDS.size === 1 && MEMBER_PAGE_KINDS.has(ReflectionKind.Method);
+}
+
+/**
+ * Check whether a reflection is a direct method or example-bearing property
+ * that should become a focused page.
+ *
+ * @param {import('typedoc').Reflection | undefined} reflection
+ * @returns {boolean}
+ */
+export function isDirectMemberPageReflection(reflection) {
+	if (
+		shouldRenderAllDirectMethodPages() &&
+		reflection?.parent &&
+		MEMBER_PAGE_OWNER_KINDS.has(reflection.parent.kind) &&
+		reflection.kind === ReflectionKind.Method
+	) {
+		return true;
+	}
+
+	if (!isDirectManagedMemberReflection(reflection) || !shouldRenderMemberPages(reflection.parent)) {
+		return false;
+	}
+
+	if (reflection.kind === ReflectionKind.Method) {
+		return true;
+	}
+
+	return isSandpackThresholdMemberReflection(reflection);
+}
+
+/**
+ * Preserve the markdown MemberRouter own-page policy while extending it to
+ * direct methods and example-bearing properties when the owner page would
+ * otherwise render too many Sandpack examples.
+ *
+ * @param {import('typedoc').Reflection} reflection
+ * @param {OwnPagePolicyRouter} router
+ * @returns {boolean}
+ */
+export function shouldRenderOwnPage(reflection, router) {
+	if (isDirectMemberPageReflection(reflection)) {
+		return true;
+	}
+
+	if (shouldSuppressDefaultDirectMemberPagePolicy() && isDirectManagedMemberReflection(reflection)) {
+		return false;
+	}
+
+	return [...ALWAYS_OWN_PAGE_KIND_NAMES, ...router.membersWithOwnFile].includes(
+		router.kindsToString.get(reflection.kind)
+	);
+}

package/src/typedoc-plugins/all-member-pages-router/namespace-paths.js

@@ -0,0 +1,44 @@
+// @ts-check
+
+import { ReflectionKind } from 'typedoc';
+
+/**
+ * Check whether a namespace is directly rooted in the TypeDoc project after
+ * walking through any nested namespace ancestors.
+ *
+ * @param {import('typedoc').Reflection} reflection
+ * @returns {boolean}
+ */
+export function isProjectNamespace(reflection) {
+	let ancestor = reflection.parent;
+	while (ancestor && ancestor.kind === ReflectionKind.Namespace) {
+		ancestor = ancestor.parent;
+	}
+	return ancestor?.kind === ReflectionKind.Project;
+}
+
+/**
+ * Build the flattened project namespace path used by the textmode.js docs.
+ *
+ * @param {{
+ *   directories: Map<import('typedoc').ReflectionKind, string>;
+ *   getReflectionAlias(reflection: import('typedoc').Reflection): string;
+ * }} router
+ * @param {import('typedoc').Reflection} reflection
+ * @returns {string}
+ */
+export function buildNamespacePath(router, reflection) {
+	const stack = [];
+	let current = reflection;
+	while (current && current.kind === ReflectionKind.Namespace) {
+		stack.unshift(current);
+		current = current.parent;
+	}
+
+	const segments = [];
+	for (const namespace of stack) {
+		segments.push(router.directories.get(ReflectionKind.Namespace), router.getReflectionAlias(namespace));
+	}
+
+	return segments.join('/');
+}

package/src/typedoc-plugins/all-member-pages-router/router.js

@@ -0,0 +1,58 @@
+// @ts-check
+
+import { PageKind } from 'typedoc';
+import { MemberRouter } from 'typedoc-plugin-markdown';
+
+import { buildMemberRouterChildPages } from './child-pages.js';
+import { getDirectMemberDirectory, getReflectionFileName as getMemberReflectionFileName } from './member-paths.js';
+import { isDirectMemberPageReflection } from './member-reflections.js';
+import { buildNamespacePath, isProjectNamespace } from './namespace-paths.js';
+
+export class AllMemberPagesRouter extends MemberRouter {
+	/** @param {import('typedoc').Reflection} reflection */
+	getPageKind(reflection) {
+		if (isDirectMemberPageReflection(reflection)) {
+			return PageKind.Reflection;
+		}
+
+		return super.getPageKind(reflection);
+	}
+
+	/**
+	 * This mirrors typedoc-plugin-markdown's MemberRouter child traversal while
+	 * delegating the "own page" policy to this plugin's helpers.
+	 *
+	 * @param {import('typedoc').Reflection} reflection
+	 * @param {import('typedoc').PageDefinition[]} outPages
+	 */
+	buildChildPages(reflection, outPages) {
+		buildMemberRouterChildPages(this, reflection, outPages);
+	}
+
+	/** @param {import('typedoc').Reflection} reflection */
+	getNamespaceDirectory(reflection) {
+		if (isProjectNamespace(reflection)) {
+			return buildNamespacePath(this, reflection);
+		}
+
+		return super.getNamespaceDirectory(reflection);
+	}
+
+	/** @param {import('typedoc').Reflection} reflection */
+	getReflectionDirectory(reflection) {
+		if (isDirectMemberPageReflection(reflection)) {
+			return getDirectMemberDirectory(this, reflection);
+		}
+
+		return super.getReflectionDirectory(reflection);
+	}
+
+	/** @param {import('typedoc').Reflection} reflection */
+	getReflectionFileName(reflection) {
+		if (isDirectMemberPageReflection(reflection)) {
+			return getMemberReflectionFileName(this, reflection);
+		}
+
+		return super.getReflectionFileName(reflection);
+	}
+}

package/src/typedoc-plugins/api-frontmatter/README.md

@@ -0,0 +1,66 @@
+# API Frontmatter
+
+## Purpose
+
+This TypeDoc plugin adds textmode.js API metadata to Markdown pages generated by `typedoc-plugin-markdown` and
+`typedoc-plugin-frontmatter`.
+
+`typedoc-plugin-frontmatter` creates the YAML block and handles configured globals such as `layout` and `editLink`.
+This plugin enriches that frontmatter with API-specific fields used by the VitePress documentation experience.
+
+## Metadata
+
+The plugin preserves existing frontmatter and adds:
+
+- `title`
+- `description`
+- `category`
+- `api`
+- `owner`
+- `namespace`
+- `kind`
+- `ecosystem`
+- `lastModified`
+- `hasConstructor`
+- `isInterface`
+
+Undefined values are removed before the page is written.
+
+## Behavior
+
+Descriptions come from the first useful TypeDoc comment summary on the reflection, call signature, getter signature, or
+setter signature. The summary is reduced to the first paragraph, sanitized for YAML frontmatter, and truncated to a
+short SEO-friendly length. If no summary exists, the plugin generates a kind-specific fallback description.
+
+`lastModified` intentionally uses the docs build date to preserve the existing generated output contract.
+
+Packages whose names start with `textmode` are assigned to the `textmode.js` ecosystem. Other package names use their
+own name as the ecosystem.
+
+## Preserved Output Contract
+
+- Existing frontmatter is preserved first, then API fields override matching keys.
+- Undefined values are removed before output.
+- Descriptions prefer reflection comments, then call signatures, getter signatures, setter signatures, then fallback
+  templates.
+- Descriptions use the first paragraph, strip markdown links/raw URLs/backticks, collapse whitespace, and truncate to
+  160 characters.
+- `lastModified` remains the docs build date.
+
+## Contributor Notes
+
+- Safe to edit: constants, helper names, fallback tests, and README wording.
+- Be careful with: YAML sanitization and description truncation, because those values feed SEO metadata.
+- Do not casually change: frontmatter key names, merge precedence, textmode ecosystem detection, or build-date output.
+
+## Maintenance
+
+This plugin is project-specific glue between TypeDoc, `typedoc-plugin-markdown`, `typedoc-plugin-frontmatter`, and the
+textmode.js VitePress site. Re-check the event hook and frontmatter object shape after upgrading TypeDoc or
+`typedoc-plugin-markdown`.
+
+Upgrade checklist:
+
+- Confirm `MarkdownPageEvent.BEGIN` still exposes `page.model`, `page.project`, and mutable `page.frontmatter`.
+- Run `npm run test:tooling`.
+- Inspect generated frontmatter for a project page, namespace member, class, interface, accessor, and method.

package/src/typedoc-plugins/api-frontmatter/constants.js

@@ -0,0 +1,52 @@
+// @ts-check
+
+import { ReflectionKind } from 'typedoc';
+
+export const UNKNOWN_LIBRARY_NAME = 'Unknown Library';
+export const TEXTMODE_ECOSYSTEM_NAME = 'textmode.js';
+export const TEXTMODE_PACKAGE_PREFIX = 'textmode';
+export const DESCRIPTION_MAX_LENGTH = 160;
+export const DESCRIPTION_TRUNCATION_SUFFIX = '...';
+
+/**
+ * @type {ReadonlyMap<import('typedoc').ReflectionKind, string>}
+ */
+export const CATEGORY_BY_KIND = new Map([
+	[ReflectionKind.Class, 'Classes'],
+	[ReflectionKind.Interface, 'Interfaces'],
+	[ReflectionKind.Enum, 'Enumerations'],
+	[ReflectionKind.Function, 'Functions'],
+	[ReflectionKind.TypeAlias, 'Type Aliases'],
+	[ReflectionKind.Variable, 'Variables'],
+	[ReflectionKind.Property, 'Properties'],
+	[ReflectionKind.Accessor, 'Accessors'],
+	[ReflectionKind.Method, 'Methods'],
+	[ReflectionKind.Constructor, 'Constructors'],
+	[ReflectionKind.Namespace, 'Namespaces'],
+	[ReflectionKind.Module, 'Modules'],
+]);
+
+/**
+ * Fallback description templates for each reflection kind.
+ * `{name}` is replaced with the reflection name and `{library}` with the library name.
+ *
+ * @type {ReadonlyMap<import('typedoc').ReflectionKind, string>}
+ */
+export const DESCRIPTION_TEMPLATE_BY_KIND = new Map([
+	[ReflectionKind.Class, 'API documentation for the {name} class in {library}.'],
+	[ReflectionKind.Interface, 'API documentation for the {name} interface in {library}.'],
+	[ReflectionKind.Enum, '{name} enumeration values and usage in {library}.'],
+	[ReflectionKind.Function, '{name} function API reference for {library}.'],
+	[ReflectionKind.TypeAlias, '{name} type definition and usage in {library}.'],
+	[ReflectionKind.Variable, '{name} variable reference in {library}.'],
+	[ReflectionKind.Property, '{name} property reference for {library}.'],
+	[ReflectionKind.Accessor, '{name} accessor reference for {library}.'],
+	[ReflectionKind.Method, '{name} method reference for {library}.'],
+	[ReflectionKind.Constructor, '{name} constructor reference for {library}.'],
+	[ReflectionKind.Namespace, '{name} namespace - types and utilities in {library}.'],
+	[ReflectionKind.Project, 'Complete API reference for {library}.'],
+	[ReflectionKind.Module, 'API reference documentation for {name}.'],
+]);
+
+export const DEFAULT_DESCRIPTION_TEMPLATE = 'API reference for {name} in {library}.';
+export const API_REFERENCE_CATEGORY = 'API Reference';

package/src/typedoc-plugins/api-frontmatter/descriptions.js

@@ -0,0 +1,80 @@
+// @ts-check
+
+import { ReflectionKind } from 'typedoc';
+
+import {
+	DEFAULT_DESCRIPTION_TEMPLATE,
+	DESCRIPTION_MAX_LENGTH,
+	DESCRIPTION_TEMPLATE_BY_KIND,
+	DESCRIPTION_TRUNCATION_SUFFIX,
+} from './constants.js';
+
+/**
+ * Sanitize text for YAML frontmatter.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+export function sanitizeForYaml(text) {
+	return text
+		.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+		.replace(/https?:\/\/[^\s]+/g, '')
+		.replace(/`([^`]+)`/g, '$1')
+		.replace(/\s+/g, ' ')
+		.trim();
+}
+
+/**
+ * Generate a fallback description using reflection kind templates.
+ *
+ * @param {import('typedoc').Reflection} model
+ * @param {import('./library-context.js').LibraryContext} library
+ * @returns {string}
+ */
+export function generateFallbackDescription(model, library) {
+	const kind = model.kind;
+	const name = model.name;
+
+	if ((kind === ReflectionKind.Project || kind === ReflectionKind.Module) && name === library.name) {
+		return library.description;
+	}
+
+	const template = DESCRIPTION_TEMPLATE_BY_KIND.get(kind) ?? DEFAULT_DESCRIPTION_TEMPLATE;
+
+	return template.replace('{name}', name).replace('{library}', library.name);
+}
+
+/**
+ * Extract a page description from TypeDoc comments, or generate a fallback.
+ *
+ * @param {import('typedoc').Reflection} model
+ * @param {import('./library-context.js').LibraryContext} library
+ * @returns {string}
+ */
+export function extractDescription(model, library) {
+	const comment =
+		model.comment ?? model.signatures?.[0]?.comment ?? model.getSignature?.comment ?? model.setSignature?.comment;
+
+	if (comment?.summary) {
+		const summary = comment.summary
+			.map((part) => part.text || '')
+			.join('')
+			.trim();
+
+		if (summary) {
+			const firstParagraph = summary.split(/\n\s*\n/)[0].trim();
+			const sanitized = sanitizeForYaml(firstParagraph);
+
+			if (sanitized.length > DESCRIPTION_MAX_LENGTH) {
+				return (
+					sanitized.substring(0, DESCRIPTION_MAX_LENGTH - DESCRIPTION_TRUNCATION_SUFFIX.length) +
+					DESCRIPTION_TRUNCATION_SUFFIX
+				);
+			}
+
+			return sanitized;
+		}
+	}
+
+	return generateFallbackDescription(model, library);
+}

package/src/typedoc-plugins/api-frontmatter/frontmatter.js

@@ -0,0 +1,56 @@
+// @ts-check
+
+import { ReflectionKind } from 'typedoc';
+
+import { extractDescription } from './descriptions.js';
+import {
+	getCategoryForKind,
+	getHasConstructor,
+	getIsInterface,
+	getNamespacePath,
+	getOwnerName,
+	isInNamespace,
+} from './reflection-metadata.js';
+
+/**
+ * Remove undefined values from a frontmatter object.
+ *
+ * @param {Record<string, unknown>} frontmatter
+ * @returns {Record<string, unknown>}
+ */
+export function removeUndefinedValues(frontmatter) {
+	for (const key of Object.keys(frontmatter)) {
+		if (frontmatter[key] === undefined) {
+			delete frontmatter[key];
+		}
+	}
+
+	return frontmatter;
+}
+
+/**
+ * Build API frontmatter for a TypeDoc markdown page.
+ *
+ * @param {import('typedoc').Reflection} model
+ * @param {Record<string, unknown>} existingFrontmatter
+ * @param {import('./library-context.js').LibraryContext} library
+ * @returns {Record<string, unknown>}
+ */
+export function buildApiFrontmatter(model, existingFrontmatter, library) {
+	const kind = model.kind;
+
+	return removeUndefinedValues({
+		...existingFrontmatter,
+		title: model.name,
+		description: extractDescription(model, library),
+		category: getCategoryForKind(kind),
+		api: true,
+		owner: getOwnerName(model),
+		namespace: isInNamespace(model) ? getNamespacePath(model) : undefined,
+		kind: ReflectionKind[kind],
+		ecosystem: library.ecosystem !== library.name ? library.ecosystem : undefined,
+		lastModified: new Date().toISOString().split('T')[0],
+		hasConstructor: getHasConstructor(model),
+		isInterface: getIsInterface(model),
+	});
+}

package/src/typedoc-plugins/api-frontmatter/index.js

@@ -0,0 +1,38 @@
+// @ts-check
+
+import { MarkdownPageEvent } from 'typedoc-plugin-markdown';
+
+import { buildApiFrontmatter } from './frontmatter.js';
+import { extractLibraryContext } from './library-context.js';
+
+/**
+ * TypeDoc plugin load function.
+ *
+ * @param {import('typedoc-plugin-markdown').MarkdownApplication} app
+ * @returns {void}
+ */
+export function load(app) {
+	app.logger.verbose('[frontmatter] Registered textmode.js API frontmatter plugin');
+
+	/** @type {import('./library-context.js').LibraryContext | null} */
+	let libraryContext = null;
+
+	app.renderer.on(
+		MarkdownPageEvent.BEGIN,
+		/** @param {import('typedoc-plugin-markdown').MarkdownPageEvent} page */
+		(page) => {
+			if (!page.model) {
+				return;
+			}
+
+			if (!libraryContext) {
+				libraryContext = extractLibraryContext(page.project);
+				app.logger.verbose(
+					`[frontmatter] Library: ${libraryContext.name} (ecosystem: ${libraryContext.ecosystem})`
+				);
+			}
+
+			page.frontmatter = buildApiFrontmatter(page.model, page.frontmatter, libraryContext);
+		}
+	);
+}