@janga/norna 0.7.22 → 0.7.24

package/scripts/lib/code-fence-metadata.mjs

@@ -0,0 +1,223 @@
+const titlePrefix = 'title="';
+const lineSelectorPattern = /^\{(\d+(?:-\d+)?(?:,\d+(?:-\d+)?)*)\}$/;
+
+const invalidMetadata = (message, fix) => ({
+	error: {
+		code: 'invalid-code-fence-metadata',
+		fix,
+		message,
+	},
+});
+
+const parseTitle = (source) => {
+	let title = '';
+	let index = titlePrefix.length;
+
+	while (index < source.length) {
+		const character = source[index];
+		if (character === '"') {
+			return {
+				rest: source.slice(index + 1),
+				title,
+			};
+		}
+
+		if (character === '\\') {
+			const escaped = source[index + 1];
+			if (escaped !== '"' && escaped !== '\\') {
+				return invalidMetadata(
+					`Code title contains unsupported escape "\\${escaped ?? ''}".`,
+					'Only escape a double quote (\\") or backslash (\\\\) inside the title.',
+				);
+			}
+			title += escaped;
+			index += 2;
+			continue;
+		}
+
+		title += character;
+		index += 1;
+	}
+
+	return invalidMetadata(
+		'Code title is missing its closing double quote.',
+		'Close the title, for example title="src/config.js".',
+	);
+};
+
+const parseHighlightedLines = (selector, lineCount) => {
+	const match = selector.match(lineSelectorPattern);
+	if (!match) {
+		return invalidMetadata(
+			`Invalid code line selector "${selector}".`,
+			'Use positive line numbers and inclusive ranges without spaces, for example {2,4-6}.',
+		);
+	}
+
+	const highlightedLines = new Set();
+	for (const part of match[1].split(',')) {
+		const [startSource, endSource = startSource] = part.split('-');
+		const start = Number.parseInt(startSource, 10);
+		const end = Number.parseInt(endSource, 10);
+
+		if (start < 1 || end < start) {
+			return invalidMetadata(
+				`Invalid code line range "${part}".`,
+				'Use positive line numbers with the lower number first, for example {2,4-6}.',
+			);
+		}
+		if (Number.isInteger(lineCount) && end > lineCount) {
+			return invalidMetadata(
+				`Code line selector "${part}" refers to line ${end}, but the block has ${lineCount} ${lineCount === 1 ? 'line' : 'lines'}.`,
+				`Select only lines 1-${lineCount}.`,
+			);
+		}
+
+		for (let line = start; line <= end; line += 1) {
+			if (highlightedLines.has(line)) {
+				return invalidMetadata(
+					`Code line ${line} is selected more than once.`,
+					'Remove overlapping or repeated line numbers from the selector.',
+				);
+			}
+			highlightedLines.add(line);
+		}
+	}
+
+	return { highlightedLines: [...highlightedLines].sort((left, right) => left - right) };
+};
+
+export const parseCodeFenceMetadata = (rawMetadata, options = {}) => {
+	const source = String(rawMetadata ?? '').trim();
+	if (!source) return { highlightedLines: [], title: null };
+
+	let rest = source;
+	let title = null;
+	if (rest.startsWith(titlePrefix)) {
+		const titleResult = parseTitle(rest);
+		if (titleResult.error) return titleResult;
+		if (!titleResult.title.trim()) {
+			return invalidMetadata(
+				'Code title cannot be empty.',
+				'Remove title="" or provide a short filename or label.',
+			);
+		}
+		title = titleResult.title;
+		rest = titleResult.rest;
+		if (rest && !rest.startsWith(' ')) {
+			return invalidMetadata(
+				'Code title must be separated from the line selector by one space.',
+				'Write metadata as title="src/config.js" {2,4-6}.',
+			);
+		}
+		rest = rest.trim();
+	}
+
+	if (!rest) return { highlightedLines: [], title };
+	if (!rest.startsWith('{')) {
+		return invalidMetadata(
+			`Unknown code fence metadata "${rest}".`,
+			'Use an optional title followed by an optional line selector: title="src/config.js" {2,4-6}.',
+		);
+	}
+	if (/^\{[^}]*\}\s+/.test(rest)) {
+		return invalidMetadata(
+			'The code line selector must come after the optional title.',
+			'Write metadata as title="src/config.js" {2,4-6}.',
+		);
+	}
+
+	const linesResult = parseHighlightedLines(rest, options.lineCount);
+	if (linesResult.error) return linesResult;
+	return {
+		highlightedLines: linesResult.highlightedLines,
+		title,
+	};
+};
+
+const formatDiagnostic = ({ error, label, line, offset }) => ({
+	...error,
+	line,
+	message: `${label} line ${line}: ${error.message}`,
+	offset,
+});
+
+export const getCodeFenceMetadataDiagnostics = (tree, options = {}) => {
+	const diagnostics = [];
+	const label = options.label ?? 'Markdown';
+	const lineOffset = options.lineOffset ?? 0;
+	const excludedLanguages = options.excludedLanguages ?? new Set();
+
+	const visit = (node) => {
+		if (!node || typeof node !== 'object') return;
+		if (node.type === 'code' && !excludedLanguages.has(node.lang)) {
+			const metadataWithoutLanguage = typeof node.lang === 'string'
+				&& (node.lang.startsWith('title=') || node.lang.startsWith('{'));
+			const result = metadataWithoutLanguage
+				? invalidMetadata(
+					'Code fence metadata requires a language before it.',
+					'Add a language first, for example ```js title="src/config.js" {2}.',
+				)
+				: parseCodeFenceMetadata(node.meta, {
+				lineCount: String(node.value ?? '').split('\n').length,
+				});
+			if (result.error) {
+				const line = lineOffset + (node.position?.start.line ?? 1);
+				diagnostics.push(formatDiagnostic({
+					error: result.error,
+					label,
+					line,
+					offset: node.position?.start.offset ?? 0,
+				}));
+			}
+		}
+
+		for (const child of node.children ?? []) visit(child);
+	};
+
+	visit(tree);
+	return diagnostics;
+};
+
+const getTransformerMetadata = (context) => {
+	if (!context.meta.nornaCodeFence) {
+		const result = parseCodeFenceMetadata(context.options.meta?.__raw, {
+			lineCount: context.tokens?.length,
+		});
+		if (result.error) throw new Error(`${result.error.message} ${result.error.fix}`);
+		context.meta.nornaCodeFence = result;
+	}
+	return context.meta.nornaCodeFence;
+};
+
+export const nornaCodeFenceTransformer = {
+	name: 'norna-code-fence-metadata',
+	line(node, line) {
+		const metadata = getTransformerMetadata(this);
+		if (!metadata.highlightedLines.includes(line)) return;
+		this.addClassToHast(node, 'norna-code-line-highlighted');
+		node.properties.dataLine = String(line);
+	},
+	pre(node) {
+		const metadata = getTransformerMetadata(this);
+		if (metadata.highlightedLines.length > 0) {
+			this.addClassToHast(node, 'norna-code-has-highlighted-lines');
+		}
+		if (!metadata.title) return;
+
+		return {
+			type: 'element',
+			tagName: 'figure',
+			properties: { className: ['norna-code-example'] },
+			children: [
+				{
+					type: 'element',
+					tagName: 'figcaption',
+					properties: { className: ['norna-code-title'] },
+					children: [{ type: 'text', value: metadata.title }],
+				},
+				node,
+			],
+		};
+	},
+};

package/scripts/lib/content-sync-apply.mjs

@@ -0,0 +1,34 @@
+import { mkdir, rename } from 'node:fs/promises';
+import path from 'node:path';
+
+export const applyImageSyncPlan = async (
+	moves,
+	{
+		makeDirectory = (directoryPath) => mkdir(directoryPath, { recursive: true }),
+		moveFile = rename,
+	} = {},
+) => {
+	const completedMoves = [];
+
+	for (const [index, move] of moves.entries()) {
+		try {
+			await makeDirectory(path.dirname(move.to));
+			await moveFile(move.from, move.to);
+			completedMoves.push(move);
+		} catch (error) {
+			return {
+				completedMoves,
+				error,
+				failedMove: move,
+				remainingMoves: moves.slice(index),
+			};
+		}
+	}
+
+	return {
+		completedMoves,
+		error: null,
+		failedMove: null,
+		remainingMoves: [],
+	};
+};

package/scripts/lib/content-sync-plan.mjs

@@ -0,0 +1,179 @@
+import path from 'node:path';
+
+import { toPosixPath } from './site-content.mjs';
+
+export const getExpectedImagePath = (contentFile, imageName) =>
+	path.join(contentFile.imagesDir, imageName);
+
+export const getExpectedImageLabel = (contentFile, imageName) =>
+	`${contentFile.imagesLabel}/${imageName}`;
+
+export const getImageRootLabel = (contentFile) => contentFile.imagesLabel.replace(/\/images$/, '');
+
+export const getImageCandidateLabel = ({ contentFile, imagePath }) =>
+	`${contentFile.imagesLabel}/${toPosixPath(path.relative(contentFile.imagesDir, imagePath))}`;
+
+const getReferenceLabel = (contentFile, section) =>
+	`${contentFile.contentLabel} [${section.id ?? 'page title'}]`;
+
+const addMapEntry = (map, key, value) => {
+	if (!map.has(key)) map.set(key, []);
+	map.get(key).push(value);
+};
+
+const addReferenceIssue = (issues, entry, issue) => {
+	issues.push({ ...entry, issue, phase: 'reference' });
+};
+
+const addConflictIssue = (issues, move, issue) => {
+	issues.push({
+		contentFile: move.contentFile,
+		section: move.section,
+		reference: move.reference,
+		issue,
+		phase: 'conflict',
+	});
+};
+
+const addMoveConflicts = (moves, issues) => {
+	const movesBySource = new Map();
+	const movesByDestination = new Map();
+
+	for (const move of moves) {
+		addMapEntry(movesBySource, move.from, move);
+		addMapEntry(movesByDestination, move.to, move);
+	}
+
+	for (const sourceMoves of movesBySource.values()) {
+		const destinations = new Set(sourceMoves.map((move) => move.to));
+		if (destinations.size <= 1) continue;
+
+		const firstMove = sourceMoves[0];
+		addConflictIssue(issues, firstMove, {
+			severity: 'error',
+			message: `Cannot relocate "${firstMove.imageName}" because the same source file is referenced from multiple destinations: ${sourceMoves.map((move) => getExpectedImageLabel(move.contentFile, move.imageName)).join(', ')}.`,
+			fix: 'Duplicate the image manually or rename one of the image files so each move has a single destination.',
+		});
+	}
+
+	for (const destinationMoves of movesByDestination.values()) {
+		const sources = new Set(destinationMoves.map((move) => move.from));
+		if (sources.size <= 1) continue;
+
+		const firstMove = destinationMoves[0];
+		addConflictIssue(issues, firstMove, {
+			severity: 'error',
+			message: `Cannot relocate "${firstMove.imageName}" because multiple source files would move to ${getExpectedImageLabel(firstMove.contentFile, firstMove.imageName)}: ${destinationMoves.map((move) => getImageCandidateLabel({ contentFile: move.sourceContentFile, imagePath: move.from })).join(', ')}.`,
+			fix: 'Move the intended file manually or rename files so the destination is unambiguous.',
+		});
+	}
+};
+
+export const createImageSyncPlan = ({
+	imageCandidates,
+	references,
+	reportMisplaced,
+}) => {
+	const candidatesByName = new Map();
+	const expectedReferencesByPath = new Map();
+	const issues = [];
+	const moves = [];
+	const referencedImagePaths = new Set();
+	const resolvedPathByReference = new Map();
+
+	for (const candidate of imageCandidates) {
+		addMapEntry(candidatesByName, candidate.imageName, candidate);
+	}
+
+	for (const candidates of candidatesByName.values()) {
+		candidates.sort((left, right) => left.imagePath.localeCompare(right.imagePath, 'sv'));
+	}
+
+	for (const entry of references) {
+		const expectedPath = getExpectedImagePath(entry.contentFile, entry.reference.image);
+		addMapEntry(expectedReferencesByPath, expectedPath, entry);
+	}
+
+	for (const entry of references) {
+		const { contentFile, reference, section } = entry;
+		const imageName = reference.image;
+		const expectedPath = getExpectedImagePath(contentFile, imageName);
+		const expectedLabel = getExpectedImageLabel(contentFile, imageName);
+		const candidates = (candidatesByName.get(imageName) ?? [])
+			.filter(({ imagePath }) => imagePath !== expectedPath);
+		const expectedCandidate = (candidatesByName.get(imageName) ?? [])
+			.find(({ imagePath }) => imagePath === expectedPath);
+
+		if (expectedCandidate) {
+			referencedImagePaths.add(expectedPath);
+			resolvedPathByReference.set(reference, expectedPath);
+			continue;
+		}
+
+		if (candidates.length === 0) {
+			addReferenceIssue(issues, entry, {
+				severity: 'error',
+				message: `Image "${imageName}" does not exist at ${expectedLabel} or anywhere under any page image root.`,
+				fix: `Add the source image directly to ${contentFile.imagesLabel}/ or remove the Norna-managed image reference.`,
+			});
+			continue;
+		}
+
+		if (candidates.length > 1) {
+			addReferenceIssue(issues, entry, {
+				severity: 'error',
+				message: `Cannot relocate "${imageName}". Multiple files with this filename were found: ${candidates.map(getImageCandidateLabel).join(', ')}.`,
+				fix: 'Move the intended file manually or rename files so the move is unambiguous.',
+			});
+			continue;
+		}
+
+		const sourceCandidate = candidates[0];
+		const sourcePath = sourceCandidate.imagePath;
+		const referencesAtCurrentLocation = (expectedReferencesByPath.get(sourcePath) ?? [])
+			.filter((expectedReference) => expectedReference.contentFile !== contentFile);
+
+		if (referencesAtCurrentLocation.length > 0) {
+			addReferenceIssue(issues, entry, {
+				severity: 'error',
+				message: `Cannot relocate "${imageName}" from ${getImageCandidateLabel(sourceCandidate)} because it is still referenced from ${referencesAtCurrentLocation.map((expectedReference) => getReferenceLabel(expectedReference.contentFile, expectedReference.section)).join(', ')}.`,
+				fix: 'Remove the extra reference, duplicate the image file manually, or rename one of the image files so the intended move is unambiguous.',
+			});
+			continue;
+		}
+
+		if (!moves.some((move) => move.from === sourcePath && move.to === expectedPath)) {
+			moves.push({
+				imageName,
+				from: sourcePath,
+				to: expectedPath,
+				contentFile,
+				sourceContentFile: sourceCandidate.contentFile,
+				section,
+				reference,
+			});
+		}
+
+		referencedImagePaths.add(sourcePath);
+		resolvedPathByReference.set(reference, sourcePath);
+
+		if (reportMisplaced) {
+			addReferenceIssue(issues, entry, {
+				severity: 'error',
+				message: `Image "${imageName}" is used here but is located in ${getImageCandidateLabel(sourceCandidate)}.`,
+				fix: sourceCandidate.contentFile === contentFile
+					? 'Run norna content:sync to move it directly into the current page image root.'
+					: `Run norna content:sync to move it from ${getImageRootLabel(sourceCandidate.contentFile)} to ${getImageRootLabel(contentFile)}.`,
+			});
+		}
+	}
+
+	addMoveConflicts(moves, issues);
+
+	return {
+		issues,
+		moves,
+		referencedImagePaths,
+		resolvedPathByReference,
+	};
+};

package/scripts/lib/edit-source-link.mjs

@@ -0,0 +1,49 @@
+const assertHttpUrl = (value, label) => {
+	if (typeof value !== 'string' || value.trim() === '') {
+		throw new Error(`${label} must be a non-empty absolute URL.`);
+	}
+
+	let url;
+	try {
+		url = new URL(value.trim());
+	} catch {
+		throw new Error(`${label} must be an absolute URL such as "https://github.com/owner/repository/edit/main/".`);
+	}
+
+	if (!['http:', 'https:'].includes(url.protocol)) {
+		throw new Error(`${label} must use http or https.`);
+	}
+	if (url.username || url.password) {
+		throw new Error(`${label} must not contain credentials.`);
+	}
+	if (url.search || url.hash) {
+		throw new Error(`${label} must not contain a query string or fragment.`);
+	}
+
+	return url;
+};
+
+export const normalizeEditLinkBaseUrl = (value, label = 'editLink.baseUrl') => {
+	const url = assertHttpUrl(value, label);
+	if (!url.pathname.endsWith('/')) url.pathname = `${url.pathname}/`;
+	return url.href;
+};
+
+export const getEditSourceUrl = ({ baseUrl, sourcePath }) => {
+	const normalizedBaseUrl = normalizeEditLinkBaseUrl(baseUrl);
+	if (typeof sourcePath !== 'string' || sourcePath.trim() === '') {
+		throw new Error('Edit-source path must be a non-empty project-relative path.');
+	}
+
+	const normalizedSourcePath = sourcePath.trim().replaceAll('\\', '/');
+	const segments = normalizedSourcePath.split('/');
+	if (
+		normalizedSourcePath.startsWith('/')
+		|| segments.some((segment) => segment === '' || segment === '.' || segment === '..')
+	) {
+		throw new Error(`Edit-source path "${sourcePath}" must be a project-relative path without traversal segments.`);
+	}
+
+	const encodedPath = segments.map((segment) => encodeURIComponent(segment)).join('/');
+	return new URL(encodedPath, normalizedBaseUrl).href;
+};

package/scripts/lib/editor-language-service.mjs

@@ -5,9 +5,15 @@ import {
 	getOpenMarkdownFenceAtLine,
 	nornaMarkdownBlockDefinitions,
 } from './norna-markdown-blocks.mjs';
-import { inspectPublicAssetFilenames, logoAssetFilenames } from './public-asset-conventions.mjs';
+import { resolveNavigationModel } from './navigation-model.mjs';
+import {
+	inspectPublicAssetFilenames,
+	logoAssetFilenames,
+	socialImageAssetFilenames,
+} from './public-asset-conventions.mjs';
 import { parsePageMarkdownSource } from './page-markdown.mjs';
 import { siteSchema } from './schema-definitions.mjs';
+import { homePageDirectory } from './site-conventions.mjs';
 
 const supportedImageExtensions = new Set(['.jpg', '.jpeg', '.png', '.svg']);
 const siteConfigNames = ['config.yaml'];
@@ -33,6 +39,132 @@ export const findNornaSiteRoot = async (documentPath) => {
 	}
 };
 
+const readEditorYaml = async (filePath) => {
+	try {
+		const source = await readFile(filePath, 'utf8');
+		const data = load(source) ?? {};
+		return data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+	} catch {
+		return null;
+	}
+};
+
+const readContentFrontmatterForEditor = (source) => {
+	const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+	if (!match) return {};
+	try {
+		const data = load(match[1]) ?? {};
+		return data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+	} catch {
+		return {};
+	}
+};
+
+const getNavigationNodesForEditor = async (siteRoot) => {
+	const nodes = [];
+
+	const visit = async (pagesDirectory, depth = 1) => {
+		const entries = (await readdir(pagesDirectory, { withFileTypes: true }).catch((error) => {
+			if (error?.code === 'ENOENT') return [];
+			throw error;
+		}))
+			.filter((entry) => entry.isDirectory())
+			.sort((left, right) => left.name.localeCompare(right.name, 'en'));
+
+		for (const entry of entries) {
+			const nodeDirectory = path.join(pagesDirectory, entry.name);
+			const contentPath = path.join(nodeDirectory, 'content.md');
+			const categoryPath = path.join(nodeDirectory, 'category.yaml');
+			const [hasContent, hasCategory] = await Promise.all([
+				fileExists(contentPath),
+				fileExists(categoryPath),
+			]);
+
+			if (hasContent !== hasCategory) {
+				if (hasCategory) {
+					nodes.push({
+						depth,
+						headings: [],
+						isHome: false,
+						kind: 'category',
+						listed: true,
+					});
+				} else {
+					const source = await readFile(contentPath, 'utf8');
+					const data = readContentFrontmatterForEditor(source);
+					const document = await parsePageMarkdownSource(source, { label: contentPath });
+					nodes.push({
+						depth,
+						headings: document.navigationHeadings,
+						isHome: depth === 1 && entry.name === homePageDirectory,
+						kind: 'page',
+						listed: data.navigation?.listed !== false,
+					});
+				}
+			}
+
+			await visit(path.join(nodeDirectory, 'pages'), depth + 1);
+		}
+	};
+
+	await visit(path.join(siteRoot, 'pages'));
+	return nodes;
+};
+
+const getNavigationModeForEditor = async (siteRoot) => {
+	const config = await readEditorYaml(path.join(siteRoot, 'config.yaml'));
+	if (!config) return null;
+	const requestedMode = config.navigation?.mode ?? 'automatic';
+	if (requestedMode !== 'automatic') return requestedMode;
+
+	try {
+		return resolveNavigationModel({
+			mode: requestedMode,
+			nodes: await getNavigationNodesForEditor(siteRoot),
+		}).mode;
+	} catch {
+		return null;
+	}
+};
+
+const findNestedYamlPropertyLine = (source, parentKey, propertyKey) => {
+	const lines = source.replace(/\r\n?/g, '\n').split('\n');
+	let insideParent = false;
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (new RegExp(`^${parentKey}:\\s*(?:#.*)?$`).test(line)) {
+			insideParent = true;
+			continue;
+		}
+		if (!insideParent) continue;
+		if (/^[A-Za-z][A-Za-z0-9-]*:/.test(line)) return 1;
+		if (new RegExp(`^  ${propertyKey}:`).test(line)) return index + 1;
+	}
+	return 1;
+};
+
+export const getThemeDiagnostics = async ({ documentPath, source }) => {
+	let theme;
+	try {
+		theme = load(source) ?? {};
+	} catch {
+		return [];
+	}
+	if (!theme || typeof theme !== 'object' || Array.isArray(theme)) return [];
+
+	const backgroundPattern = theme.sections?.backgroundPattern;
+	if (backgroundPattern === undefined || backgroundPattern === 'uniform') return [];
+	const siteRoot = await findNornaSiteRoot(documentPath);
+	if (!siteRoot || await getNavigationModeForEditor(siteRoot) !== 'tree') return [];
+
+	return [{
+		code: 'tree-section-background-pattern',
+		line: findNestedYamlPropertyLine(source, 'sections', 'backgroundPattern'),
+		message: `sections.backgroundPattern "${backgroundPattern}" cannot be used because this site resolves to tree navigation. Tree navigation uses one uniform reading surface so the navigation rail and page content remain distinct. Remove sections.backgroundPattern or set it to uniform.`,
+		severity: 'error',
+	}];
+};
+
 const readSitewideLogoForEditor = async (siteRoot) => {
 	const filename = await findFile(siteRoot, ['sitewide-content.yaml']);
 	if (!filename) return null;
@@ -89,6 +221,18 @@ export const getSitePublicAssetStatus = async (documentPath) => {
 			});
 		}
 	}
+	if (inspection.socialImages.length > 1) {
+		const message = `Multiple social sharing images were found: ${inspection.socialImages.join(', ')}. Keep exactly one of ${socialImageAssetFilenames.join(', ')} in site/public.`;
+		for (const filename of inspection.socialImages) {
+			issues.push({
+				absolutePath: path.join(publicDirectory, filename),
+				code: 'multiple-social-image-files',
+				filename,
+				message,
+				severity: 'error',
+			});
+		}
+	}
 	if (inspection.logos.length === 0 && sitewideLogo?.logoConfigured) {
 		const publicLabel = toPosixPath(path.relative(path.dirname(siteRoot), publicDirectory));
 		issues.push({
@@ -336,7 +480,7 @@ export const getImageCompletionContext = async ({ documentPath, source, line })
 	const page = getPageContext(siteRoot, documentPath);
 	if (!page) return null;
 	const fence = getOpenMarkdownFenceAtLine(source, line);
-	if (!fence || !['norna-image-stack', 'norna-image-carousel', 'norna-card-list'].includes(fence.type)) return null;
+	if (!fence || !['image-stack', 'image-carousel', 'card-list'].includes(fence.type)) return null;
 
 	const currentLine = source.replace(/\r\n?/g, '\n').split('\n')[line] ?? '';
 	if (!/^\s*(?:-\s+)?image:\s*[^\s]*$/.test(currentLine)) return null;
@@ -435,7 +579,7 @@ export const getMarkdownDiagnostics = async ({ documentPath, source }) => {
 			code: 'local-markdown-image',
 			severity: 'warning',
 			line: reference.line,
-			message: `Local Markdown image "${reference.target}" is not managed by Norna. Use norna-image-stack, norna-image-carousel, or norna-card-list for validated and synchronized site images.`,
+			message: `Local Markdown image "${reference.target}" is not managed by Norna. Use image-stack, image-carousel, or card-list for validated and synchronized site images.`,
 		});
 	}
 
@@ -491,16 +635,20 @@ export const getMarkdownDiagnostics = async ({ documentPath, source }) => {
 };
 
 export const nornaBlockDefinitions = Object.freeze({
-	'norna-image-stack': Object.freeze({
-		...nornaMarkdownBlockDefinitions['norna-image-stack'],
-		snippet: '```norna-image-stack\n- image: ${1:filename.jpg}\n  alt: ${2:Alternative text}\n  caption: ${3:Caption}\n```',
+	'image-stack': Object.freeze({
+		...nornaMarkdownBlockDefinitions['image-stack'],
+		snippet: '```image-stack\n- image: ${1:filename.jpg}\n  alt: ${2:Alternative text}\n  caption: ${3:Caption}\n```',
+	}),
+	'image-carousel': Object.freeze({
+		...nornaMarkdownBlockDefinitions['image-carousel'],
+		snippet: '```image-carousel\n- image: ${1:first.jpg}\n  alt: ${2:Alternative text}\n- image: ${3:second.jpg}\n  alt: ${4:Alternative text}\n```',
 	}),
-	'norna-image-carousel': Object.freeze({
-		...nornaMarkdownBlockDefinitions['norna-image-carousel'],
-		snippet: '```norna-image-carousel\n- image: ${1:first.jpg}\n  alt: ${2:Alternative text}\n- image: ${3:second.jpg}\n  alt: ${4:Alternative text}\n```',
+	'card-list': Object.freeze({
+		...nornaMarkdownBlockDefinitions['card-list'],
+		snippet: '```card-list\nlayout: ${1|image-top,image-left,image-right|}\nflow: ${2|grid,stack|}\nsize: ${3|s,m,l,xl|}\n\n- title: ${4:Card title}\n  text: ${5:Card text}\n  image: ${6:filename.jpg}\n```',
 	}),
-	'norna-card-list': Object.freeze({
-		...nornaMarkdownBlockDefinitions['norna-card-list'],
-		snippet: '```norna-card-list\nlayout: ${1|image-top,image-left,image-right|}\nflow: ${2|grid,stack|}\nsize: ${3|s,m,l,xl|}\n\n- title: ${4:Card title}\n  text: ${5:Card text}\n  image: ${6:filename.jpg}\n```',
+	'page-list': Object.freeze({
+		...nornaMarkdownBlockDefinitions['page-list'],
+		snippet: '```page-list\n```',
 	}),
 });