@tsdoctor/pages 0.1.0

package/Examples.js

@@ -0,0 +1,237 @@
+import { CodeText, Example } from "./Blocks.js";
+import { classifyCutDirective, isTwoslashDirective } from "./TwoslashDirectives.js";
+import { Effect, Schema } from "effect";
+import { TypeReferenceExtractor } from "@tsdoctor/model";
+import { format } from "prettier";
+
+//#region src/Examples.ts
+/**
+* Prettier could not format an example.
+*
+* @remarks
+* Malformed example code is author input, so this is a typed failure rather
+* than a defect. The original Prettier error rides in `cause` rather than
+* being flattened to a string; an adapter that reports it (the RSPress
+* `PrettierError` event) reads the message from there and falls back to the
+* unformatted code.
+*
+* @public
+*/
+var ExampleFormatError = class extends Schema.TaggedError("ExampleFormatError")("ExampleFormatError", {
+	/** The fence language the parser was chosen for. */
+	language: Schema.String,
+	/** The original Prettier error. */
+	cause: Schema.Defect()
+}) {
+	get message() {
+		return `Prettier could not format a ${this.language} example`;
+	}
+};
+const TYPESCRIPT_LANGUAGES = /* @__PURE__ */ new Set([
+	"typescript",
+	"ts",
+	"javascript",
+	"js"
+]);
+/**
+* Prepare an example for Twoslash: prepend `import { name } from "pkg"`
+* unless the example already imports the package, and prepend `// @noErrors`
+* when errors are suppressed. Non-TypeScript examples pass through untouched.
+*
+* @param example - The example with language and code
+* @param apiItemName - The documented item, imported at the top of the example
+* @param packageName - The package to import it from
+* @param suppressErrors - Whether to suppress TypeScript errors (default `true`)
+* @public
+*/
+function prepareExampleCode(example, apiItemName, packageName, suppressErrors = true) {
+	const { language, code } = example;
+	if (!TYPESCRIPT_LANGUAGES.has(language)) return {
+		code,
+		isTypeScript: false,
+		language
+	};
+	const importLine = `import { ${apiItemName} } from "${packageName}";`;
+	const finalCode = code.includes(`from "${packageName}"`) || code.includes(`from '${packageName}'`) ? code : `${importLine}\n${code}`;
+	return {
+		code: `${suppressErrors ? "// @noErrors\n" : ""}${finalCode}`,
+		isTypeScript: true,
+		language: "typescript"
+	};
+}
+/**
+* Strip Twoslash directives from code for display: config directives
+* (`// @noErrors`, `// @errors: 2304`, `// @filename: …`), annotation markers
+* (`// ^?`) and the cut directives — `// ---cut---` removes itself and every
+* line before it, `// ---cut-after---` itself and every line after, and a
+* `// ---cut-start---` / `// ---cut-end---` pair removes the range between.
+*
+* @param code - The code containing Twoslash directives
+* @returns The code a reader sees and copies
+* @public
+*/
+function stripTwoslashDirectives(code) {
+	const lines = code.split("\n");
+	let cutBeforeIndex = -1;
+	let cutAfterIndex = -1;
+	const cutRanges = [];
+	const cutStartStack = [];
+	for (let i = 0; i < lines.length; i++) {
+		const cutType = classifyCutDirective(lines[i].trim());
+		if (cutType === "cut-before") cutBeforeIndex = i;
+		else if (cutType === "cut-after") cutAfterIndex = i;
+		else if (cutType === "cut-start") cutStartStack.push(i);
+		else if (cutType === "cut-end") {
+			const startIdx = cutStartStack.pop();
+			if (startIdx !== void 0) cutRanges.push([startIdx, i]);
+		}
+	}
+	let filteredLines = lines;
+	if (cutBeforeIndex >= 0) {
+		filteredLines = filteredLines.slice(cutBeforeIndex + 1);
+		if (cutAfterIndex >= 0) cutAfterIndex = cutAfterIndex - cutBeforeIndex - 1;
+		for (const range of cutRanges) {
+			range[0] -= cutBeforeIndex + 1;
+			range[1] -= cutBeforeIndex + 1;
+		}
+	}
+	if (cutAfterIndex >= 0) filteredLines = filteredLines.slice(0, cutAfterIndex);
+	const excludedLines = /* @__PURE__ */ new Set();
+	for (const [start, end] of cutRanges) for (let i = start; i <= end; i++) if (i >= 0 && i < filteredLines.length) excludedLines.add(i);
+	return filteredLines.filter((line, i) => !excludedLines.has(i) && !isTwoslashDirective(line.trim())).join("\n").trim();
+}
+/**
+* Prepend hidden imports to code using the Twoslash cut directive, so the
+* type-checker resolves external types while the reader never sees the
+* import lines. Returns the code unchanged when there is nothing to import.
+*
+* @param code - The code to prepend imports to
+* @param imports - The import statements to add
+* @public
+*/
+function prependHiddenImports(code, imports) {
+	if (imports.length === 0) return code;
+	return `${TypeReferenceExtractor.formatImports([...imports]).join("\n")}\n// ---cut---\n${code}`;
+}
+/**
+* Build both spellings of a code block from its type-check text: the
+* `source` as given, the `display` with every directive stripped.
+*
+* @param source - The type-check text — hidden imports, cut marker, directives intact
+* @public
+*/
+function codeText(source) {
+	return CodeText.make({
+		display: stripTwoslashDirectives(source),
+		source
+	});
+}
+/**
+* Add logical blank lines between code sections for visual clarity: after an
+* import block, before a section comment and before a `return`.
+*
+* @remarks
+* Runs after Prettier, which does not insert breathing room of its own. Lines
+* inside a multi-line import and Twoslash directive lines never trigger a
+* rule, so a directive stays attached to the line it annotates.
+*
+* @param code - Prettier-formatted code
+* @public
+*/
+function addLogicalBlankLines(code) {
+	const lines = code.split("\n");
+	const result = [];
+	let inMultiLineImport = false;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		const wasInMultiLineImport = inMultiLineImport;
+		if (!inMultiLineImport && trimmed.startsWith("import ") && !trimmed.endsWith(";")) inMultiLineImport = true;
+		else if (inMultiLineImport && trimmed.endsWith(";")) inMultiLineImport = false;
+		const isCurrentImport = trimmed.startsWith("import ") || wasInMultiLineImport;
+		if (result.length > 0 && !isCurrentImport) {
+			const prevTrimmed = result[result.length - 1].trim();
+			if (prevTrimmed !== "") {
+				const isDirective = isTwoslashDirective(trimmed);
+				const prevIsImportEnd = prevTrimmed.startsWith("import ") && prevTrimmed.endsWith(";") || /}\s*from\s+/.test(prevTrimmed) && prevTrimmed.endsWith(";");
+				if (prevIsImportEnd && trimmed !== "" && !isDirective) result.push("");
+				if (trimmed.startsWith("//") && !isDirective && !prevTrimmed.startsWith("//") && !prevIsImportEnd) result.push("");
+				if (/^return[\s;(]/.test(trimmed) && !prevTrimmed.startsWith("//")) result.push("");
+			}
+		}
+		result.push(line);
+	}
+	return result.join("\n");
+}
+/** Fence languages Prettier can format, mapped to its parser name. */
+const LANGUAGE_TO_PARSER = {
+	typescript: "typescript",
+	ts: "typescript",
+	tsx: "typescript",
+	javascript: "babel",
+	js: "babel",
+	jsx: "babel",
+	node: "babel"
+};
+/** The one Prettier configuration every adapter formats examples with. */
+const PRETTIER_OPTIONS = {
+	printWidth: 80,
+	tabWidth: 2,
+	useTabs: false,
+	semi: true,
+	singleQuote: false,
+	trailingComma: "es5",
+	bracketSpacing: true,
+	arrowParens: "always"
+};
+/**
+* Format example code with Prettier, then add logical blank lines. A
+* language Prettier has no parser for is returned unchanged.
+*
+* @param code - The code to format
+* @param language - The fence language (`typescript`, `ts`, `js`, …)
+* @public
+*/
+const formatExampleCode = Effect.fn("Examples.formatExampleCode")(function* (code, language) {
+	const parser = LANGUAGE_TO_PARSER[language.toLowerCase()];
+	if (!parser) return code;
+	return addLogicalBlankLines((yield* Effect.tryPromise({
+		try: () => format(code, {
+			...PRETTIER_OPTIONS,
+			parser
+		}),
+		catch: (cause) => new ExampleFormatError({
+			language,
+			cause
+		})
+	})).trim());
+});
+/**
+* Build an {@link Example} block item from a raw TSDoc example: prepare it
+* for Twoslash, format it, and produce both code spellings once.
+*
+* @remarks
+* A non-TypeScript example is not type-checked, so its `display` and
+* `source` are the same formatted text and emitters render it in a plain
+* fence.
+*
+* @param example - The example with language and code
+* @param apiItemName - The documented item, imported at the top of the example
+* @param packageName - The package to import it from
+* @param suppressErrors - Whether to suppress TypeScript errors (default `true`)
+* @public
+*/
+const buildExample = Effect.fn("Examples.buildExample")(function* (example, apiItemName, packageName, suppressErrors = true) {
+	const prepared = prepareExampleCode(example, apiItemName, packageName, suppressErrors);
+	const formatted = yield* formatExampleCode(prepared.code, prepared.language);
+	return Example.make({
+		language: prepared.language,
+		code: prepared.isTypeScript ? codeText(formatted) : CodeText.make({
+			display: formatted,
+			source: formatted
+		}),
+		typeChecked: prepared.isTypeScript
+	});
+});
+
+//#endregion
+export { ExampleFormatError, addLogicalBlankLines, buildExample, codeText, formatExampleCode, prepareExampleCode, prependHiddenImports, stripTwoslashDirectives };

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 C. Spencer Beggs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/Llms.js

@@ -0,0 +1,282 @@
+//#region src/Llms.ts
+/** Pre-compiled regex for parsing llms.txt link lines. */
+const LLMS_TXT_LINE_RE = /^-\s+\[([^\]]+)\]\(([^)]+)\)(?::\s*(.+))?$/;
+/**
+* Parse a single line from llms.txt format.
+*
+* Recognizes the pattern: `- [title](url): description`
+* The description portion (`: description`) is optional.
+*
+* @param line - A single line from an llms.txt file
+* @returns Parsed entry or null for non-link lines (headers, empty lines, plain text)
+*
+* @public
+*/
+function parseLlmsTxtLine(line) {
+	const trimmed = line.trim();
+	if (trimmed === "") return null;
+	const match = LLMS_TXT_LINE_RE.exec(trimmed);
+	if (!match) return null;
+	const title = match[1];
+	const url = match[2];
+	const rawDescription = match[3];
+	return {
+		title,
+		url,
+		description: rawDescription ? rawDescription.trim() : void 0
+	};
+}
+/**
+* Filter API page entries from global llms.txt content.
+*
+* Removes lines whose parsed URL is in the `apiRoutes` set.
+* Appends pointer lines for per-package llms files when `pointers` is non-empty.
+*
+* @param content - Full llms.txt content string
+* @param apiRoutes - Set of API route paths to remove
+* @param pointers - Per-package pointer entries to append
+* @returns Filtered llms.txt content
+*
+* @public
+*/
+function filterLlmsTxt(content, apiRoutes, pointers) {
+	const lines = content.split("\n");
+	const filtered = [];
+	for (const line of lines) {
+		const entry = parseLlmsTxtLine(line);
+		if (entry && apiRoutes.has(entry.url)) continue;
+		filtered.push(line);
+	}
+	let result = filtered.join("\n");
+	if (pointers.length > 0) {
+		result += "\n\n";
+		for (const pointer of pointers) result += `- For ${pointer.name} API docs, see [${pointer.name} llms.txt](${pointer.llmsTxtUrl})\n`;
+	}
+	return result;
+}
+/**
+* Generate a structured global llms.txt that groups pages by package scope.
+*
+* Output format:
+* ```
+* # {site title}
+*
+* ## Others
+* - [Blog Post](/blog/post.md)
+*
+* ## Packages
+*
+* ### {name} {version}
+* {description}
+* - [Guide Page](/pkg/guides/guide.md)
+* - [API Reference](/pkg/llms-api.txt)
+* ```
+*
+* @param content - Original RSPress-generated llms.txt content
+* @param apiRoutes - Set of API route paths to exclude as individual entries
+* @param packages - Package scope metadata
+* @returns Restructured llms.txt content
+*
+* @public
+*/
+function generateStructuredLlmsTxt(content, apiRoutes, packages) {
+	const lines = content.split("\n");
+	let title = "";
+	for (const line of lines) if (line.startsWith("# ")) {
+		title = line;
+		break;
+	}
+	const allEntries = [];
+	for (const line of lines) {
+		const entry = parseLlmsTxtLine(line);
+		if (entry && !apiRoutes.has(entry.url)) allEntries.push(entry);
+	}
+	const packageEntries = /* @__PURE__ */ new Map();
+	const others = [];
+	for (const entry of allEntries) {
+		let matched = false;
+		for (const pkg of packages) {
+			const base = pkg.packageRoute.endsWith("/") ? pkg.packageRoute : `${pkg.packageRoute}/`;
+			if (entry.url.startsWith(base) || entry.url === pkg.packageRoute) {
+				const existing = packageEntries.get(pkg.packageName) ?? [];
+				existing.push(entry);
+				packageEntries.set(pkg.packageName, existing);
+				matched = true;
+				break;
+			}
+		}
+		if (!matched) others.push(entry);
+	}
+	const output = [];
+	if (title) {
+		output.push(title);
+		output.push("");
+	}
+	if (others.length > 0) {
+		output.push("## Others");
+		output.push("");
+		for (const entry of others) output.push(formatEntry(entry));
+		output.push("");
+	}
+	const packagesWithEntries = packages;
+	if (packagesWithEntries.length > 0) {
+		output.push("## Packages");
+		output.push("");
+		for (const pkg of packagesWithEntries) {
+			const versionSuffix = pkg.version ? ` ${pkg.version}` : "";
+			output.push(`### ${pkg.name}${versionSuffix}`);
+			output.push("");
+			if (pkg.description) {
+				output.push(pkg.description);
+				output.push("");
+			}
+			const entries = packageEntries.get(pkg.packageName) ?? [];
+			for (const entry of entries) output.push(formatEntry(entry));
+			output.push(`- [API Reference](${pkg.llmsApiTxtUrl})`);
+			output.push("");
+		}
+	}
+	return output.join("\n");
+}
+/**
+* Parse llms-full.txt content into sections delimited by frontmatter blocks.
+*
+* Each section has the format:
+* ```
+* ---
+* url: /path/to/page
+* ---
+*
+* Content here...
+* ```
+*/
+function parseSections(content) {
+	if (content.trim() === "") return [];
+	const sections = [];
+	const frontmatterPattern = /^---\nurl:\s*(.+)\n---$/gm;
+	let match = frontmatterPattern.exec(content);
+	const boundaries = [];
+	while (match !== null) {
+		boundaries.push({
+			url: match[1].trim(),
+			start: match.index,
+			fmEnd: match.index + match[0].length
+		});
+		match = frontmatterPattern.exec(content);
+	}
+	for (let i = 0; i < boundaries.length; i++) {
+		const boundary = boundaries[i];
+		const nextStart = i + 1 < boundaries.length ? boundaries[i + 1].start : content.length;
+		const sectionContent = content.slice(boundary.start, nextStart);
+		sections.push({
+			url: boundary.url,
+			raw: sectionContent.trimEnd()
+		});
+	}
+	return sections;
+}
+/**
+* Filter API page content sections from global llms-full.txt.
+*
+* Sections are delimited by `---\nurl: {path}\n---` frontmatter blocks.
+* Removes entire sections whose URL matches a known API route.
+*
+* @param content - Full llms-full.txt content string
+* @param apiRoutes - Set of API route paths to remove
+* @returns Filtered llms-full.txt content
+*
+* @public
+*/
+function filterLlmsFullTxt(content, apiRoutes) {
+	if (content.trim() === "") return "";
+	const kept = parseSections(content).filter((section) => !apiRoutes.has(section.url));
+	if (kept.length === 0) return "";
+	return kept.map((section) => section.raw).join("\n\n\n");
+}
+/**
+* Format a single llms.txt link entry.
+*/
+function formatEntry(entry) {
+	if (entry.description) return `- [${entry.title}](${entry.url}): ${entry.description}`;
+	return `- [${entry.title}](${entry.url})`;
+}
+/**
+* Generate a per-package llms.txt index.
+*
+* Output format:
+* ```
+* # {name}
+*
+* ## Guides
+*
+* - [Guide Title](/path): Description
+*
+* ## API Reference
+*
+* - [ApiItem](/path): Description
+* ```
+*
+* Sections with no entries are omitted.
+*
+* @param input - Package name, guide pages, and API pages
+* @returns Generated llms.txt content
+*
+* @public
+*/
+function generatePackageLlmsTxt(input) {
+	const parts = [
+		`# ${input.name}`,
+		"",
+		`> API documentation for the ${input.packageName} package`
+	];
+	if (input.guidePages.length > 0) {
+		parts.push("");
+		parts.push("## Guides");
+		parts.push("");
+		for (const page of input.guidePages) parts.push(formatEntry(page));
+	}
+	if (input.apiPages.length > 0) {
+		parts.push("");
+		parts.push("## API Reference");
+		parts.push("");
+		for (const page of input.apiPages) parts.push(formatEntry(page));
+	}
+	parts.push("");
+	return parts.join("\n");
+}
+/**
+* Concatenate page contents with frontmatter delimiters.
+*
+* Used for llms-full.txt, llms-docs.txt, and llms-api.txt generation
+* (pass different page sets for each).
+*
+* Output format:
+* ```
+* ---
+* url: /path/to/page
+* ---
+*
+* Content here...
+*
+*
+* ---
+* url: /path/to/next
+* ---
+*
+* More content...
+* ```
+*
+* @param pages - Array of page URLs and their markdown content
+* @returns Concatenated content with frontmatter delimiters
+*
+* @public
+*/
+function generatePackageLlmsFullTxt(pages) {
+	if (pages.length === 0) return "";
+	const sections = [];
+	for (const page of pages) sections.push(`---\nurl: ${page.url}\n---\n\n${page.content}`);
+	return sections.join("\n\n\n");
+}
+
+//#endregion
+export { filterLlmsFullTxt, filterLlmsTxt, generatePackageLlmsFullTxt, generatePackageLlmsTxt, generateStructuredLlmsTxt, parseLlmsTxtLine };

package/Markdown.js

@@ -0,0 +1,155 @@
+import { Blockquote, Code, Heading, InlineCode, Link, List, ListItem, Markdown, Paragraph, Root, Strong, Table, TableCell, TableRow, Text } from "@effected/markdown";
+import { Effect, Result } from "effect";
+
+//#region src/Markdown.ts
+const text = (value) => Text.make({ value });
+const heading = (depth, value) => Heading.make({
+	depth,
+	children: [text(value)]
+});
+const paragraph = (children) => Paragraph.make({ children: [...children] });
+const fence = (value, lang) => Code.make({
+	value,
+	lang
+});
+const cell = (children) => TableCell.make({ children: [...children] });
+const row = (cells) => TableRow.make({ children: [...cells] });
+const parametersTable = (rows) => Table.make({ children: [row([
+	cell([text("Name")]),
+	cell([text("Type")]),
+	cell([text("Description")])
+]), ...rows.map((r) => row([
+	cell([InlineCode.make({ value: r.name })]),
+	cell(r.type === void 0 ? [] : [InlineCode.make({ value: r.type })]),
+	cell(r.description)
+]))] });
+const enumMembersTable = (rows) => Table.make({ children: [row([
+	cell([text("Name")]),
+	cell([text("Value")]),
+	cell([text("Description")])
+]), ...rows.map((r) => row([
+	cell([InlineCode.make({ value: r.name })]),
+	cell(r.value === void 0 ? [] : [InlineCode.make({ value: r.value })]),
+	cell(r.description)
+]))] });
+const memberNodes = (member) => {
+	const nodes = [heading(3, member.name), fence(member.code.display, "ts")];
+	if (member.summary && member.summary.length > 0) nodes.push(paragraph(member.summary));
+	if (member.parameters && member.parameters.length > 0) nodes.push(parametersTable(member.parameters));
+	if (member.returns && member.returns.length > 0) nodes.push(paragraph([
+		Strong.make({ children: [text("Returns:")] }),
+		text(" "),
+		...member.returns
+	]));
+	return nodes;
+};
+/**
+* Render one block to flow nodes.
+*
+* @public
+*/
+function markdownBlockTree(block) {
+	switch (block.kind) {
+		case "title": {
+			const nodes = [heading(1, block.name)];
+			if (block.deprecation && block.deprecation.length > 0) nodes.push(Blockquote.make({ children: [paragraph([
+				Strong.make({ children: [text("Deprecated:")] }),
+				text(" "),
+				...block.deprecation
+			])] }));
+			if (block.releaseTag !== "Public") nodes.push(paragraph([InlineCode.make({ value: block.releaseTag })]));
+			return nodes;
+		}
+		case "available-from": {
+			const children = [text("Available from: ")];
+			block.entryPoints.forEach((entryPoint, index) => {
+				if (index > 0) children.push(text(", "));
+				const spec = entryPoint === "default" ? block.packageName : `${block.packageName}/${entryPoint}`;
+				children.push(InlineCode.make({ value: spec }));
+			});
+			return [paragraph(children)];
+		}
+		case "prose": return block.role === "summary" ? block.content : [heading(2, block.role === "remarks" ? "Remarks" : "Returns"), ...block.content];
+		case "source-link": return [paragraph([Link.make({
+			url: block.href,
+			children: [text("Source")]
+		})])];
+		case "signature": return [fence(block.code.display, "ts")];
+		case "base-class": return [
+			heading(2, "Base Class"),
+			paragraph([
+				InlineCode.make({ value: block.className }),
+				text(" extends "),
+				InlineCode.make({ value: block.baseName }),
+				text(", a compiler-generated declaration that is not exported from "),
+				InlineCode.make({ value: block.packageName }),
+				text(".")
+			]),
+			fence(block.code.display, "ts")
+		];
+		case "member-group": return [heading(2, block.title), ...block.members.flatMap(memberNodes)];
+		case "parameters": return [parametersTable(block.rows)];
+		case "enum-members": return [enumMembersTable(block.rows)];
+		case "examples": return [heading(2, "Examples"), ...block.items.map((item) => fence(item.code.display, item.language))];
+		case "see-also": return [heading(2, "See Also"), List.make({
+			ordered: false,
+			spread: false,
+			children: block.references.map((reference) => ListItem.make({
+				spread: false,
+				children: [paragraph(reference)]
+			}))
+		})];
+		case "member-index": return [heading(2, block.title), List.make({
+			ordered: false,
+			spread: false,
+			children: block.entries.map((entry) => {
+				const children = [Link.make({
+					url: entry.route,
+					children: [text(entry.name)]
+				})];
+				if (entry.summary && entry.summary.length > 0) children.push(text(" - "), ...entry.summary);
+				return ListItem.make({
+					spread: false,
+					children: [paragraph(children)]
+				});
+			})
+		})];
+	}
+}
+/**
+* Render a page's body to flow nodes — the pre-serialization form of
+* {@link renderMarkdownResult}.
+*
+* @public
+*/
+function markdownTree(page) {
+	return page.blocks.flatMap(markdownBlockTree);
+}
+/**
+* Render a page's body to a markdown string. No frontmatter: that is the
+* adapter's, built from the page facts.
+*
+* @remarks
+* A stringify failure on a tree this module built itself is surfaced rather
+* than thrown, because the prose inside a block arrived from a builder and
+* may carry any node the kit admits; the kit's own error names what it could
+* not serialize.
+*
+* @public
+*/
+function renderMarkdownResult(page) {
+	const root = Root.make({ children: [...markdownTree(page)] });
+	return Result.map(Markdown.stringifyResult(root), (markdown) => {
+		const trimmed = markdown.trim();
+		return trimmed ? `${trimmed}\n` : "\n";
+	});
+}
+/**
+* The Effect form of {@link renderMarkdownResult}.
+*
+* @public
+*/
+const renderMarkdown = Effect.fn("Markdown.renderMarkdown")((page) => Effect.fromResult(renderMarkdownResult(page)));
+
+//#endregion
+export { markdownBlockTree, markdownTree, renderMarkdown, renderMarkdownResult };