@janga/norna 0.7.18 → 0.7.22

package/scripts/lib/norna-markdown-blocks.mjs

@@ -1,4 +1,3 @@
-import { Buffer } from 'node:buffer';
 import { documentationLink } from './documentation-links.mjs';
 
 const field = (description, options = {}) => Object.freeze({ description, ...options });
@@ -55,13 +54,12 @@ export const nornaMarkdownBlockDefinitions = Object.freeze({
 					xl: value('Extra large', 'Use the largest card and image size.'),
 				}),
 			}),
-			width: field('Limit the width of the complete card list. Defaults to normal.', {
-				default: 'normal',
+			width: field('Override the root theme\'s maximum width for this card list.', {
 				values: Object.freeze({
-					text: value('Text', 'Match the active body-text width.'),
-					narrow: value('Narrow', 'Use a narrow card-list width.'),
-					normal: value('Normal', 'Use the balanced default card-list width.'),
-					wide: value('Wide', 'Allow the card list to use more horizontal space.'),
+					text: value('Text', 'Match the active body-text width, including a reader-selected reading width.'),
+					narrow: value('Narrow', 'Limit the complete card list to at most 48rem.'),
+					normal: value('Normal', 'Limit the complete card list to at most 56rem.'),
+					wide: value('Wide', 'Allow the complete card list to use the available page-layout width.'),
 				}),
 			}),
 		}),
@@ -87,7 +85,6 @@ const blockTypeLabels = {
 
 const knownBlockTypeList = Array.from(nornaBlockTypes).join(', ');
 const imageNameRegex = /^[a-z0-9][a-z0-9.-]*\.(jpe?g|png|svg)$/i;
-const markerTagName = 'norna-block';
 const imageStackExample = [
 	'```norna-image-stack',
 	'- image: filename.jpg',
@@ -98,7 +95,6 @@ const cardListExample = [
 	'layout: image-top',
 	'flow: grid',
 	'size: m',
-	'width: normal',
 	'',
 	'- title: Adopt',
 	'  text: Give a dog a new home.',
@@ -203,6 +199,35 @@ const getFenceCloseInfo = (line, opening) => {
 	return fence;
 };
 
+export const getOpenMarkdownFenceAtLine = (markdown, lineIndex) => {
+	const lines = normalizeLines(markdown);
+	let open = null;
+
+	for (let index = 0; index <= Math.min(lineIndex, lines.length - 1); index += 1) {
+		const fence = getFenceInfo(lines[index]);
+		if (!fence || fence.length < 3) continue;
+
+		if (!open) {
+			open = {
+				character: fence.markerCharacter,
+				length: fence.length,
+				line: index,
+				type: fence.info.split(/\s+/)[0] ?? '',
+			};
+			continue;
+		}
+
+		if (getFenceCloseInfo(lines[index], {
+			length: open.length,
+			markerCharacter: open.character,
+		})) {
+			open = null;
+		}
+	}
+
+	return open;
+};
+
 const getNornaLineAttempt = (line) => {
 	const match = line.match(/^ {0,3}([`~]{0,2})(norna-[a-z0-9-]+)\s*$/);
 	if (!match) return null;
@@ -226,7 +251,14 @@ const getUnclosedNornaBlockMessage = (opening) =>
 	`This Norna block was started on line ${opening.line} but not closed. Add a closing ${opening.markerCharacter.repeat(opening.length)} line after the last entry.`;
 
 const scanMarkdownFencedBlocks = (markdown, options = {}) => {
-	const lines = normalizeLines(markdown);
+	const normalizedMarkdown = markdown.replace(/\r\n?/g, '\n');
+	const lines = normalizedMarkdown.split('\n');
+	const lineOffsets = [];
+	let nextLineOffset = 0;
+	for (const line of lines) {
+		lineOffsets.push(nextLineOffset);
+		nextLineOffset += line.length + 1;
+	}
 	const lineOffset = options.lineOffset ?? 0;
 	const blocks = [];
 	const errors = [];
@@ -242,6 +274,7 @@ const scanMarkdownFencedBlocks = (markdown, options = {}) => {
 			if (attempt) {
 				errors.push({
 					blockType: attempt.type,
+					code: 'invalid-norna-block-start',
 					line: lineNumber,
 					source: '',
 					message: failMessage(getNornaFenceStartMessage(attempt.type, attempt.marker), { ...options, line: lineNumber }),
@@ -257,6 +290,7 @@ const scanMarkdownFencedBlocks = (markdown, options = {}) => {
 			if (attempt) {
 				errors.push({
 					blockType: attempt.type,
+					code: 'invalid-norna-block-start',
 					line: lineNumber,
 					source: '',
 					message: failMessage(getNornaFenceStartMessage(attempt.type, attempt.marker), { ...options, line: lineNumber }),
@@ -288,7 +322,10 @@ const scanMarkdownFencedBlocks = (markdown, options = {}) => {
 			if (isNornaLike) {
 				errors.push({
 					blockType: type,
+					code: 'unclosed-norna-block',
+					endOffset: normalizedMarkdown.length,
 					line: lineNumber,
+					startOffset: lineOffsets[index],
 					source: lines.slice(bodyStartIndex).join('\n'),
 					message: failMessage(getUnclosedNornaBlockMessage(opening), { ...options, line: lineNumber }),
 				});
@@ -301,13 +338,19 @@ const scanMarkdownFencedBlocks = (markdown, options = {}) => {
 			if (nornaBlockTypes.has(type)) {
 				blocks.push({
 					blockType: type,
+					endLine: lineOffset + closingIndex + 1,
+					endOffset: lineOffsets[closingIndex] + lines[closingIndex].length,
 					line: lineNumber,
+					startOffset: lineOffsets[index],
 					source,
+					sourceEndOffset: lineOffsets[closingIndex],
 					sourceLine: lineNumber + 1,
+					sourceStartOffset: lineOffsets[bodyStartIndex],
 				});
 			} else {
 				errors.push({
 					blockType: type,
+					code: 'unknown-norna-block',
 					line: lineNumber,
 					source,
 					message: failMessage(getUnknownNornaBlockMessage(type), { ...options, line: lineNumber }),
@@ -337,7 +380,7 @@ const parseImageListBlock = (source, options = {}) => {
 		const lineNumber = (options.line ?? 1) + index;
 		const itemMatch = line.match(/^(\s*)-\s+image:\s*(.*?)\s*$/);
 		if (itemMatch) {
-			current = { image: decodeScalar(itemMatch[2]) };
+			current = { image: decodeScalar(itemMatch[2]), line: lineNumber };
 			images.push(current);
 			continue;
 		}
@@ -375,7 +418,7 @@ const parseCardListBlock = (source, options = {}) => {
 	let layout = cardListDefinition.options.layout.default;
 	let flow = cardListDefinition.options.flow.default;
 	let size = cardListDefinition.options.size.default;
-	let width = cardListDefinition.options.width.default;
+	let width;
 	let current = null;
 
 	for (const [index, line] of normalizeLines(source).entries()) {
@@ -384,7 +427,7 @@ const parseCardListBlock = (source, options = {}) => {
 		const lineNumber = (options.line ?? 1) + index;
 		const itemMatch = line.match(/^(\s*)-\s+title:\s*(.*?)\s*$/);
 		if (itemMatch) {
-			current = { title: decodeScalar(itemMatch[2]) };
+			current = { title: decodeScalar(itemMatch[2]), line: lineNumber };
 			cards.push(current);
 			continue;
 		}
@@ -486,26 +529,6 @@ export const parseNornaMarkdownBlock = (type, source, options = {}) => {
 
 const getLineNumber = (source, index) => source.slice(0, index).split(/\r?\n/).length;
 
-export const extractNornaMarkdownBlocks = (markdown, options = {}) => {
-	const blocks = [];
-	const { blocks: scannedBlocks, errors } = scanMarkdownFencedBlocks(markdown, options);
-
-	if (errors.length > 0) {
-		throw new Error(errors[0].message);
-	}
-
-	for (const block of scannedBlocks) {
-		blocks.push({
-			...parseNornaMarkdownBlock(block.blockType, block.source, { ...options, line: block.sourceLine }),
-			blockType: block.blockType,
-			line: block.line,
-			source: block.source,
-		});
-	}
-
-	return blocks;
-};
-
 export const extractNornaMarkdownBlockDiagnostics = (markdown, options = {}) => {
 	const blocks = [];
 	const { blocks: scannedBlocks, errors } = scanMarkdownFencedBlocks(markdown, options);
@@ -515,12 +538,18 @@ export const extractNornaMarkdownBlockDiagnostics = (markdown, options = {}) =>
 			blocks.push({
 				...parseNornaMarkdownBlock(block.blockType, block.source, { ...options, line: block.sourceLine }),
 				blockType: block.blockType,
+				endLine: block.endLine,
+				endOffset: block.endOffset,
 				line: block.line,
+				startOffset: block.startOffset,
 				source: block.source,
+				sourceEndOffset: block.sourceEndOffset,
+				sourceStartOffset: block.sourceStartOffset,
 			});
 		} catch (error) {
 			errors.push({
 				blockType: block.blockType,
+				code: 'invalid-norna-block',
 				line: block.line,
 				source: block.source,
 				message: error instanceof Error ? error.message : String(error),
@@ -570,18 +599,6 @@ const maskFencedCodeBlocks = (markdown) => {
 const isExternalImageTarget = (target) => /^[a-z][a-z0-9+.-]*:/i.test(target) || target.startsWith('//');
 const isRootRelativePublicTarget = (target) => target.startsWith('/');
 
-const stripTags = (value) => value.replace(/<[^>]*>/g, '');
-
-const decodeHtmlEntities = (value) =>
-	value
-		.replace(/&amp;/g, '&')
-		.replace(/&lt;/g, '<')
-		.replace(/&gt;/g, '>')
-		.replace(/&quot;/g, '"')
-		.replace(/&#39;/g, "'")
-		.replace(/&#x([0-9a-f]+);/gi, (_match, hex) => String.fromCodePoint(Number.parseInt(hex, 16)))
-		.replace(/&#(\d+);/g, (_match, decimal) => String.fromCodePoint(Number.parseInt(decimal, 10)));
-
 export const extractMarkdownImageReferences = (markdown) => {
 	const masked = maskFencedCodeBlocks(markdown);
 	const references = [];
@@ -610,7 +627,7 @@ export const getNornaBlockImageReferences = (blocks) =>
 					alt: card.title,
 					blockType: block.blockType,
 					blockDisplayType: block.type,
-					line: block.line,
+					line: card.line ?? block.line,
 				}));
 		}
 
@@ -618,54 +635,10 @@ export const getNornaBlockImageReferences = (blocks) =>
 			...image,
 			blockType: block.blockType,
 			blockDisplayType: block.type,
-			line: block.line,
+			line: image.line ?? block.line,
 		}));
 	});
 
-export const createNornaMarkdownBlockMarker = (type, source) => {
-	const encodedSource = Buffer.from(source, 'utf8').toString('base64');
-	return `<${markerTagName} data-type="${type}" data-source="${encodedSource}"></${markerTagName}>`;
-};
-
-export const splitNornaMarkdownBlockMarkers = (html, options = {}) => {
-	const blocks = [];
-	const markerRegex = /<norna-block\s+data-type="([^"]+)"\s+data-source="([^"]*)"\s*><\/norna-block>|<pre\b([^>]*)>\s*<code\b([^>]*)>([\s\S]*?)<\/code>\s*<\/pre>/g;
-	let cursor = 0;
-
-	for (const match of html.matchAll(markerRegex)) {
-		const start = match.index ?? 0;
-		if (start > cursor) {
-			blocks.push({ type: 'html', html: html.slice(cursor, start) });
-		}
-
-		if (match[1]) {
-			const blockType = match[1];
-			const source = Buffer.from(match[2] ?? '', 'base64').toString('utf8');
-			blocks.push(parseNornaMarkdownBlock(blockType, source, options));
-		} else {
-			const attributes = `${match[3] ?? ''} ${match[4] ?? ''}`;
-			const blockType = attributes.match(/\blanguage-(norna-[a-z0-9-]+)\b/)?.[1]
-				?? attributes.match(/\bdata-language="(norna-[a-z0-9-]+)"/)?.[1];
-			if (!nornaBlockTypes.has(blockType)) {
-				blocks.push({ type: 'html', html: match[0] });
-			} else {
-				const source = decodeHtmlEntities(stripTags(match[5] ?? ''));
-				blocks.push(parseNornaMarkdownBlock(blockType, source, options));
-			}
-		}
-
-		cursor = start + match[0].length;
-	}
-
-	if (cursor < html.length) {
-		blocks.push({ type: 'html', html: html.slice(cursor) });
-	}
-
-	return blocks.filter((block) => block.type !== 'html' || block.html.trim());
-};
-
-const normalizeBlockSource = (source) => source.replace(/\r\n?/g, '\n').trim();
-
 const inlineNoteReferenceRegex = /\{note-ref\}/g;
 const inlineNoteDeclarationOpeningRegex = /^\s*\{note:\s*(.*)$/;
 const inlineNoteDeclarationClosingRegex = /^(.*?)\}\s*$/;
@@ -918,57 +891,3 @@ export const extractInlineNoteDiagnostics = (markdown, options = {}) => {
 
 	return { notes, errors };
 };
-
-export const splitNornaRenderedCodeBlocks = (html, rawBlocks, options = {}) => {
-	const blocks = [];
-	const renderedCodeRegex = /<pre\b[^>]*>\s*<code\b[^>]*>([\s\S]*?)<\/code>\s*<\/pre>/g;
-	let cursor = 0;
-	let rawIndex = 0;
-
-	for (const match of html.matchAll(renderedCodeRegex)) {
-		const start = match.index ?? 0;
-		if (start > cursor) {
-			blocks.push({ type: 'html', html: html.slice(cursor, start) });
-		}
-
-		const rawBlock = rawBlocks[rawIndex];
-		const renderedSource = normalizeBlockSource(decodeHtmlEntities(stripTags(match[1] ?? '')));
-		const rawSource = normalizeBlockSource(rawBlock?.source ?? '');
-
-		if (rawBlock && renderedSource === rawSource) {
-			blocks.push(parseNornaMarkdownBlock(rawBlock.blockType, rawBlock.source, options));
-			rawIndex += 1;
-		} else {
-			blocks.push({ type: 'html', html: match[0] });
-		}
-
-		cursor = start + match[0].length;
-	}
-
-	if (cursor < html.length) {
-		blocks.push({ type: 'html', html: html.slice(cursor) });
-	}
-
-	return blocks.filter((block) => block.type !== 'html' || block.html.trim());
-};
-
-const visitCodeBlocks = (node) => {
-	if (!node || typeof node !== 'object') return;
-
-	if (Array.isArray(node.children)) {
-		for (const child of node.children) {
-			visitCodeBlocks(child);
-		}
-	}
-
-	if (node.type !== 'code' || !nornaBlockTypes.has(node.lang)) return;
-
-	node.type = 'html';
-	node.value = createNornaMarkdownBlockMarker(node.lang, node.value ?? '');
-	delete node.lang;
-	delete node.meta;
-};
-
-export const nornaMarkdownBlocksRemarkPlugin = () => (tree) => {
-	visitCodeBlocks(tree);
-};

package/scripts/lib/norna-markdown-render-plugin.mjs

@@ -0,0 +1,37 @@
+import { defineMdastPlugin } from 'satteri';
+import { nornaBlockTypes } from './norna-markdown-blocks.mjs';
+
+const stateKey = 'nornaMarkdownRender';
+
+const getState = (context) => {
+	if (!context.data[stateKey]) {
+		context.data[stateKey] = { blockIndex: 0, regionIndex: 0 };
+	}
+	return context.data[stateKey];
+};
+
+export const nornaMarkdownRenderPlugin = defineMdastPlugin({
+	name: 'norna-markdown-render',
+	code(node, context) {
+		if (!nornaBlockTypes.has(node.lang)) return;
+
+		const state = getState(context);
+		const blockIndex = state.blockIndex;
+		state.blockIndex += 1;
+		context.replaceNode(node, {
+			type: 'html',
+			value: `<norna-block data-index="${blockIndex}"></norna-block>`,
+		});
+	},
+	heading(node, context) {
+		if (node.depth !== 1 && node.depth !== 2) return;
+		const state = getState(context);
+		const regionIndex = state.regionIndex;
+		state.blockIndex = 0;
+		state.regionIndex += 1;
+		context.replaceNode(node, {
+			type: 'html',
+			value: `<norna-region data-index="${regionIndex}"></norna-region>`,
+		});
+	},
+});

package/scripts/lib/object.mjs

@@ -0,0 +1,28 @@
+export const isPlainObject = (value) => (
+	value !== null
+	&& typeof value === 'object'
+	&& !Array.isArray(value)
+);
+
+export const freezeDeep = (value) => {
+	if (value === null || typeof value !== 'object' || Object.isFrozen(value)) return value;
+
+	for (const child of Object.values(value)) freezeDeep(child);
+	return Object.freeze(value);
+};
+
+export const mergeDeep = (base, override) => {
+	if (!isPlainObject(override)) return structuredClone(base);
+
+	const merged = structuredClone(base);
+
+	for (const [key, value] of Object.entries(override)) {
+		if (isPlainObject(value) && isPlainObject(merged[key])) {
+			merged[key] = mergeDeep(merged[key], value);
+		} else if (value !== undefined) {
+			merged[key] = value;
+		}
+	}
+
+	return merged;
+};

package/scripts/lib/page-markdown.mjs

@@ -0,0 +1,282 @@
+import {
+	getHeadingIdentifierIssues,
+	getMarkdownHeadings,
+} from './heading-ids.mjs';
+import {
+	extractInlineNoteDiagnostics,
+	extractMarkdownImageReferences,
+	extractNornaMarkdownBlockDiagnostics,
+	getNornaBlockImageReferences,
+} from './norna-markdown-blocks.mjs';
+
+const normalizeMarkdown = (source) => source.replace(/\r\n?/g, '\n');
+
+const hasContent = (source) => source.trim().length > 0;
+
+export const splitPageMarkdownSource = (source) => {
+	const normalizedSource = normalizeMarkdown(source);
+	const lines = normalizedSource.split('\n');
+	if (lines[0]?.trim() !== '---') {
+		return {
+			body: normalizedSource,
+			bodyOffset: 0,
+			frontmatter: '',
+			frontmatterUnclosed: false,
+			lineOffset: 0,
+		};
+	}
+
+	const closingIndex = lines.findIndex((line, index) => index > 0 && line.trim() === '---');
+	if (closingIndex < 0) {
+		return {
+			body: '',
+			bodyOffset: normalizedSource.length,
+			frontmatter: normalizedSource,
+			frontmatterUnclosed: true,
+			lineOffset: lines.length,
+		};
+	}
+
+	const frontmatterLines = lines.slice(0, closingIndex + 1);
+	const frontmatter = frontmatterLines.join('\n');
+	const bodyOffset = frontmatter.length + (closingIndex < lines.length - 1 ? 1 : 0);
+	return {
+		body: normalizedSource.slice(bodyOffset),
+		bodyOffset,
+		frontmatter,
+		frontmatterUnclosed: false,
+		lineOffset: closingIndex + 1,
+	};
+};
+
+const getPageStructureDiagnostics = ({ headings, pageHeadings, prelude }, lineOffset) => {
+	const diagnostics = [];
+
+	if (pageHeadings.length === 0) {
+		diagnostics.push({
+			code: 'missing-page-title',
+			line: lineOffset + 1,
+			message: 'The page is missing its Markdown H1 title.',
+			severity: 'error',
+			fix: 'Add exactly one page title before any sections, for example "# About".',
+		});
+	} else if (pageHeadings.length > 1) {
+		for (const heading of pageHeadings.slice(1)) {
+			diagnostics.push({
+				code: 'duplicate-page-title',
+				line: lineOffset + heading.line,
+				message: `The page contains ${pageHeadings.length} Markdown H1 headings.`,
+				severity: 'error',
+				fix: 'Keep exactly one H1 page title. Use level 2 headings with explicit ids for sections.',
+			});
+		}
+	}
+
+	if (headings[0] && headings[0].depth !== 1) {
+		diagnostics.push({
+			code: 'page-title-order',
+			line: lineOffset + headings[0].line,
+			message: `The first content heading is "${headings[0].title}", but a Norna page must start with its H1 title.`,
+			severity: 'error',
+			fix: 'Move the single H1 page title before every section.',
+		});
+	}
+
+	if (hasContent(prelude)) {
+		diagnostics.push({
+			code: 'page-title-order',
+			line: lineOffset + 1,
+			message: 'The page contains content before its first heading.',
+			severity: 'error',
+			fix: 'Make the Markdown H1 page title the first content after optional frontmatter.',
+		});
+	}
+
+	return diagnostics;
+};
+
+const getHeadingDiagnostics = (headings, lineOffset) => getHeadingIdentifierIssues(headings).map((issue) => ({
+	code: issue.code,
+	heading: issue.heading,
+	line: lineOffset + issue.heading.line,
+	message: issue.message,
+	otherHeading: issue.otherHeading,
+	otherLine: issue.otherHeading ? lineOffset + issue.otherHeading.line : null,
+	severity: 'error',
+	fix: issue.fix,
+}));
+
+const getRegionContent = (regionMarkdown, blocks, regionOffset) => {
+	const content = [];
+	let cursor = 0;
+
+	for (const block of blocks) {
+		if (block.startOffset > cursor) {
+			content.push({
+				kind: 'markdown',
+				markdown: regionMarkdown.slice(cursor, block.startOffset),
+				range: {
+					start: regionOffset + cursor,
+					end: regionOffset + block.startOffset,
+				},
+			});
+		}
+
+		content.push({
+			kind: 'norna-block',
+			block,
+			range: {
+				start: regionOffset + block.startOffset,
+				end: regionOffset + block.endOffset,
+			},
+		});
+		cursor = block.endOffset;
+	}
+
+	if (cursor < regionMarkdown.length) {
+		content.push({
+			kind: 'markdown',
+			markdown: regionMarkdown.slice(cursor),
+			range: {
+				start: regionOffset + cursor,
+				end: regionOffset + regionMarkdown.length,
+			},
+		});
+	}
+
+	return content.filter((item) => item.kind !== 'markdown' || item.markdown.length > 0);
+};
+
+const createRegion = ({ heading, nextHeading, headings, source, label, lineOffset }) => {
+	const endOffset = nextHeading?.index ?? source.length;
+	const markdown = source.slice(heading.index, endOffset).trimEnd();
+	const regionLineOffset = lineOffset + heading.line - 1;
+	const blockResult = extractNornaMarkdownBlockDiagnostics(markdown, {
+		label,
+		lineOffset: regionLineOffset,
+	});
+	const noteResult = extractInlineNoteDiagnostics(markdown, {
+		label,
+		lineOffset: regionLineOffset,
+	});
+	const markdownImages = extractMarkdownImageReferences(markdown).map((reference) => ({
+		...reference,
+		line: regionLineOffset + reference.line,
+	}));
+	const regionHeadings = headings.filter((candidate) => (
+		candidate.index >= heading.index
+		&& candidate.index < endOffset
+	));
+
+	return {
+		bodyMarkdown: source.slice(heading.index + heading.source.length, endOffset).trimEnd(),
+		blocks: blockResult.blocks,
+		blockErrors: blockResult.errors,
+		content: getRegionContent(markdown, blockResult.blocks, heading.index),
+		endOffset,
+		heading,
+		headings: regionHeadings,
+		id: heading.id,
+		kind: heading.depth === 1 ? 'page-intro' : 'section',
+		bodyLine: heading.line,
+		line: lineOffset + heading.line,
+		managedImages: getNornaBlockImageReferences(blockResult.blocks),
+		markdown,
+		markdownImages,
+		notes: noteResult.notes,
+		noteErrors: noteResult.errors,
+		startOffset: heading.index,
+		title: heading.title,
+	};
+};
+
+export const parsePageMarkdown = async (markdown, options = {}) => {
+	const source = normalizeMarkdown(markdown);
+	const label = options.label ?? 'Markdown';
+	const lineOffset = options.lineOffset ?? 0;
+	const { headings } = await getMarkdownHeadings(source);
+	const structuralHeadings = headings.filter((heading) => heading.depth <= 2);
+	const prelude = structuralHeadings.length > 0
+		? source.slice(0, structuralHeadings[0].index)
+		: source;
+	const pageHeadings = structuralHeadings.filter((heading) => heading.depth === 1);
+	const regions = structuralHeadings.map((heading, index) => createRegion({
+		heading,
+		nextHeading: structuralHeadings[index + 1],
+		headings,
+		label,
+		lineOffset,
+		source,
+	}));
+	const headingIssues = getHeadingIdentifierIssues(headings);
+	const headingDiagnostics = getHeadingDiagnostics(headings, lineOffset);
+	const structureDiagnostics = getPageStructureDiagnostics({ headings, pageHeadings, prelude }, lineOffset);
+	const blockDiagnostics = regions.flatMap((region) => region.blockErrors.map((error) => ({
+		code: error.code ?? 'invalid-norna-block',
+		line: error.line,
+		message: error.message,
+		regionId: region.id,
+		severity: 'error',
+	})));
+	const noteDiagnostics = regions.flatMap((region) => region.noteErrors.map((error) => ({
+		code: 'invalid-inline-note',
+		line: error.line,
+		message: error.message,
+		regionId: region.id,
+		severity: 'error',
+	})));
+	const navigationHeadings = [];
+	let parentId = null;
+	for (const heading of headings) {
+		if (heading.depth === 2) parentId = heading.id;
+		if ((heading.depth !== 2 && heading.depth !== 3) || !heading.id) continue;
+		navigationHeadings.push({
+			depth: heading.depth,
+			id: heading.id,
+			line: lineOffset + heading.line,
+			parentId: heading.depth === 3 ? parentId : null,
+			title: heading.title,
+		});
+	}
+
+	return {
+		blocks: regions.flatMap((region) => region.blocks),
+		diagnostics: [
+			...structureDiagnostics,
+			...headingDiagnostics,
+			...blockDiagnostics,
+			...noteDiagnostics,
+		],
+		headings,
+		headingIssues,
+		intro: regions.find((region) => region.kind === 'page-intro') ?? null,
+		label,
+		lineOffset,
+		managedImages: regions.flatMap((region) => region.managedImages),
+		markdownImages: regions.flatMap((region) => region.markdownImages),
+		navigationHeadings,
+		notes: regions.flatMap((region) => region.notes),
+		pageTitle: pageHeadings[0] ?? null,
+		pageHeadings,
+		prelude,
+		regions,
+		sections: regions.filter((region) => region.kind === 'section'),
+		source,
+	};
+};
+
+export const parsePageMarkdownSource = async (source, options = {}) => {
+	const split = splitPageMarkdownSource(source);
+	const model = await parsePageMarkdown(split.body, {
+		...options,
+		lineOffset: (options.lineOffset ?? 0) + split.lineOffset,
+	});
+
+	return {
+		...model,
+		bodyOffset: split.bodyOffset,
+		frontmatter: split.frontmatter,
+		frontmatterUnclosed: split.frontmatterUnclosed,
+		fullSource: normalizeMarkdown(source),
+	};
+};