@topik/content 0.0.0-stage → 0.1.0-alpha.6

package/dist/index.mjs

@@ -0,0 +1,4529 @@
+import { decodeString } from "micromark-util-decode-string";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { frontmatter } from "micromark-extension-frontmatter";
+import { frontmatterFromMarkdown, frontmatterToMarkdown } from "mdast-util-frontmatter";
+import { TagSyntaxError, tagFromMarkdown, tagSyntax, tagToMarkdown, writeTextTemplate } from "@topik/remark-tags";
+import { gfmFootnote } from "micromark-extension-gfm-footnote";
+import { gfmStrikethrough } from "micromark-extension-gfm-strikethrough";
+import { gfmTable } from "micromark-extension-gfm-table";
+import { gfmTaskListItem } from "micromark-extension-gfm-task-list-item";
+import { gfmFootnoteFromMarkdown, gfmFootnoteToMarkdown } from "mdast-util-gfm-footnote";
+import { gfmStrikethroughFromMarkdown, gfmStrikethroughToMarkdown } from "mdast-util-gfm-strikethrough";
+import { gfmTableFromMarkdown, gfmTableToMarkdown } from "mdast-util-gfm-table";
+import { gfmTaskListItemFromMarkdown, gfmTaskListItemToMarkdown } from "mdast-util-gfm-task-list-item";
+import { defaultHandlers, toMarkdown } from "mdast-util-to-markdown";
+import GithubSlugger from "github-slugger";
+//#region src/extensions/accordion.ts
+const accordionDefinition = {
+	kind: "block",
+	render: "TopikAccordion",
+	description: "A single disclosure section with a required title.",
+	attributes: {
+		title: {
+			type: "string",
+			required: true,
+			description: "Accordion title."
+		},
+		open: {
+			type: "boolean",
+			description: "Whether the accordion is expanded by default."
+		}
+	},
+	children: "blocks"
+};
+//#endregion
+//#region src/extensions/badge.ts
+const badgeDefinition = {
+	kind: "inline",
+	render: "TopikBadge",
+	description: "Small inline status or metadata label.",
+	attributes: { variant: {
+		type: "enum",
+		values: [
+			"neutral",
+			"info",
+			"success",
+			"warning",
+			"danger"
+		],
+		default: "neutral",
+		description: "Badge color/semantic variant."
+	} },
+	children: "inline"
+};
+//#endregion
+//#region src/extensions/callout.ts
+const calloutDefinition = {
+	kind: "block",
+	render: "TopikCallout",
+	description: "Highlighted contextual content such as a note, tip, warning, or danger message.",
+	attributes: {
+		variant: {
+			type: "enum",
+			values: [
+				"info",
+				"tip",
+				"warning",
+				"danger"
+			],
+			default: "info"
+		},
+		title: { type: "string" }
+	},
+	children: "blocks"
+};
+//#endregion
+//#region src/extensions/cards.ts
+const cardGridDefinition = {
+	kind: "block",
+	render: "TopikCardGrid",
+	description: "Responsive grid of card links or summary cards.",
+	attributes: { columns: {
+		type: "number",
+		min: 1,
+		max: 4,
+		integer: true,
+		description: "Preferred number of columns, from 1 to 4."
+	} },
+	children: { components: ["card"] }
+};
+const cardDefinition = {
+	kind: "block",
+	render: "TopikCard",
+	description: "A card within a card grid.",
+	attributes: {
+		title: {
+			type: "string",
+			required: true,
+			description: "Card title."
+		},
+		href: {
+			type: "string",
+			description: "Optional target URL."
+		},
+		icon: {
+			type: "string",
+			description: "Optional icon identifier."
+		}
+	},
+	children: "blocks",
+	selfClosing: true
+};
+//#endregion
+//#region src/extensions/code.ts
+const codeGroupDefinition = {
+	kind: "block",
+	render: "TopikCodeGroup",
+	description: "A set of labeled code tabs.",
+	attributes: {},
+	children: {
+		components: ["codeTab"],
+		min: 1
+	}
+};
+const codeTabDefinition = {
+	kind: "block",
+	render: "TopikCodeTab",
+	description: "A labeled code example inside a code group.",
+	attributes: {
+		title: {
+			type: "string",
+			required: true,
+			description: "Visible code tab label."
+		},
+		icon: {
+			type: "string",
+			description: "Optional icon identifier."
+		}
+	},
+	children: {
+		nodes: [
+			"code",
+			"topikCodeTemplate",
+			"topikCodePresentation"
+		],
+		min: 1
+	},
+	allowedParents: ["codeGroup"]
+};
+//#endregion
+//#region src/extensions/figure.ts
+const figureDefinition = {
+	kind: "block",
+	render: "TopikFigure",
+	description: "Media with an optional caption.",
+	attributes: {
+		src: {
+			type: "string",
+			required: true,
+			asset: true,
+			assetReference: {
+				slot: "figure.src",
+				role: "image-light"
+			},
+			description: "Default/light image source URL."
+		},
+		darkSrc: {
+			type: "string",
+			asset: true,
+			assetReference: {
+				slot: "figure.darkSrc",
+				role: "image-dark"
+			},
+			description: "Optional dark-mode image source URL."
+		},
+		alt: {
+			type: "string",
+			required: true,
+			description: "Accessible alternative text."
+		},
+		caption: {
+			type: "string",
+			description: "Optional figure caption."
+		}
+	},
+	children: "none"
+};
+//#endregion
+//#region src/extensions/math.ts
+const mathDefinition = {
+	kind: "block",
+	render: "TopikMath",
+	description: "Block math expression.",
+	attributes: { content: {
+		type: "string",
+		required: true,
+		escapedWhitespace: true,
+		description: "Math source."
+	} },
+	children: "none"
+};
+const mathInlineDefinition = {
+	kind: "inline",
+	render: "TopikMathInline",
+	description: "Inline math expression.",
+	attributes: { content: {
+		type: "string",
+		required: true,
+		escapedWhitespace: true,
+		description: "Math source."
+	} },
+	children: "none"
+};
+//#endregion
+//#region src/extensions/native.ts
+const nativeComponents = {
+	codeBlock: {
+		name: "codeBlock",
+		render: "TopikCodeBlock",
+		kind: "block",
+		description: "A fenced code block with an optional language.",
+		attributes: { language: {
+			type: "string",
+			description: "Code language identifier."
+		} }
+	},
+	inlineCode: {
+		name: "inlineCode",
+		render: "TopikInlineCode",
+		kind: "inline",
+		description: "Inline code text."
+	},
+	image: {
+		name: "image",
+		render: "TopikImage",
+		kind: "block",
+		description: "Markdown image rendered through Topik asset resolution.",
+		attributes: {
+			src: {
+				type: "string",
+				required: true,
+				description: "Image source URL.",
+				assetReference: {
+					slot: "image.src",
+					role: "image"
+				}
+			},
+			alt: {
+				type: "string",
+				description: "Accessible alternative text."
+			},
+			title: {
+				type: "string",
+				description: "Optional image title."
+			}
+		}
+	},
+	link: {
+		name: "link",
+		render: "TopikLink",
+		kind: "inline",
+		description: "Markdown link with optional application-level navigation interception.",
+		attributes: {
+			href: {
+				type: "string",
+				required: true,
+				description: "Link target URL.",
+				assetReference: {
+					slot: "link.href",
+					role: "download",
+					conditional: "proven-download"
+				}
+			},
+			title: {
+				type: "string",
+				description: "Optional link title."
+			}
+		}
+	},
+	mermaid: {
+		name: "mermaid",
+		render: "TopikMermaid",
+		kind: "block",
+		description: "Mermaid diagram rendered from a fenced mermaid code block.",
+		attributes: { content: {
+			type: "string",
+			required: true,
+			description: "Mermaid diagram source."
+		} }
+	},
+	table: {
+		name: "table",
+		render: "TopikTable",
+		kind: "block",
+		description: "Markdown table."
+	},
+	tableRow: {
+		name: "tableRow",
+		render: "TopikTableRow",
+		kind: "block",
+		description: "A row inside a Markdown table."
+	},
+	tableCell: {
+		name: "tableCell",
+		render: "TopikTableCell",
+		kind: "block",
+		description: "A cell inside a Markdown table."
+	},
+	tableHeader: {
+		name: "tableHeader",
+		render: "TopikTableHeader",
+		kind: "block",
+		description: "A header cell inside a Markdown table."
+	}
+};
+//#endregion
+//#region src/extensions/quiz.ts
+const quizDefinition = {
+	kind: "block",
+	render: "TopikQuiz",
+	description: "Self-check quiz made of question components.",
+	attributes: {},
+	children: {
+		components: ["question"],
+		min: 1
+	}
+};
+function validateQuestion(component, props) {
+	const choices = component.children.filter((child) => child.type === "topikComponent" && child.name === "choice");
+	const issues = [];
+	if (choices.length < 2) issues.push({
+		id: "topik-question-choice-count",
+		message: "question requires at least two choice children"
+	});
+	const correct = choices.filter((choice) => choice.props.correct === true).length;
+	if (props.type === "multiple-choice" && correct === 0) issues.push({
+		id: "topik-question-correct-choice-required",
+		message: "multiple-choice questions require at least one correct choice"
+	});
+	else if (props.type !== "multiple-choice" && correct !== 1) issues.push({
+		id: "topik-question-single-correct-choice",
+		message: "single-choice questions require exactly one correct choice"
+	});
+	return issues;
+}
+const questionDefinition = {
+	kind: "block",
+	render: "TopikQuestion",
+	description: "Quiz question containing at least two choices.",
+	attributes: { type: {
+		type: "enum",
+		values: ["single-choice", "multiple-choice"],
+		default: "single-choice",
+		description: "Question interaction model."
+	} },
+	children: { components: ["choice", "explanation"] },
+	allowedParents: ["quiz"],
+	validate: validateQuestion
+};
+const choiceDefinition = {
+	kind: "block",
+	render: "TopikChoice",
+	description: "Answer choice inside a quiz question.",
+	attributes: { correct: {
+		type: "boolean",
+		default: false,
+		description: "Whether this choice is correct."
+	} },
+	children: "blocks",
+	allowedParents: ["question"]
+};
+const explanationDefinition = {
+	kind: "block",
+	render: "TopikExplanation",
+	description: "Explanation shown after answering a quiz question.",
+	attributes: {},
+	children: "blocks",
+	allowedParents: ["question"]
+};
+//#endregion
+//#region src/extensions/steps.ts
+const stepsDefinition = {
+	kind: "block",
+	render: "TopikSteps",
+	description: "Ordered instructional steps.",
+	attributes: {},
+	children: {
+		components: ["step"],
+		min: 1
+	}
+};
+const stepDefinition = {
+	kind: "block",
+	render: "TopikStep",
+	description: "One step inside a steps component.",
+	attributes: { title: {
+		type: "string",
+		description: "Optional step heading."
+	} },
+	children: "blocks",
+	allowedParents: ["steps"]
+};
+//#endregion
+//#region src/extensions/tabs.ts
+const tabsDefinition = {
+	kind: "block",
+	render: "TopikTabs",
+	description: "A tab set containing one or more tab panels.",
+	attributes: {},
+	children: {
+		components: ["tab"],
+		min: 1
+	}
+};
+const tabDefinition = {
+	kind: "block",
+	render: "TopikTab",
+	description: "A tab panel inside a tabs component.",
+	attributes: { title: {
+		type: "string",
+		required: true,
+		description: "Visible tab label."
+	} },
+	children: "blocks",
+	allowedParents: ["tabs"]
+};
+//#endregion
+//#region src/extensions/underline.ts
+const underlineDefinition = {
+	kind: "inline",
+	render: "TopikUnderline",
+	description: "Inline underlined text.",
+	attributes: {},
+	children: "inline"
+};
+//#endregion
+//#region src/registry.ts
+const TOPIK_CONTENT_SCHEMA_VERSION = "0.2.2";
+const CALLOUT_VARIANTS = [
+	"info",
+	"tip",
+	"warning",
+	"danger"
+];
+const BADGE_VARIANTS = [
+	"neutral",
+	"info",
+	"success",
+	"warning",
+	"danger"
+];
+const QUIZ_QUESTION_TYPES = ["single-choice", "multiple-choice"];
+function deepFreeze(value) {
+	if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+		for (const child of Object.values(value)) deepFreeze(child);
+		Object.freeze(value);
+	}
+	return value;
+}
+function textAttributes(definition, names) {
+	const attributes = { ...definition.attributes };
+	for (const name of names) {
+		const attribute = attributes[name];
+		if (attribute.type !== "string" || attribute.asset || attribute.assetReference) throw new Error("Template slots must be plain string attributes");
+		attributes[name] = {
+			...attribute,
+			interpolation: "text"
+		};
+	}
+	return {
+		...definition,
+		attributes
+	};
+}
+const authoredComponents = {
+	accordion: textAttributes(accordionDefinition, ["title"]),
+	badge: badgeDefinition,
+	callout: textAttributes(calloutDefinition, ["title"]),
+	card: textAttributes(cardDefinition, ["title"]),
+	cardGrid: cardGridDefinition,
+	codeGroup: codeGroupDefinition,
+	codeTab: {
+		...textAttributes(codeTabDefinition, ["title"]),
+		children: {
+			nodes: [
+				"code",
+				"topikCodeTemplate",
+				"topikCodePresentation"
+			],
+			min: 1
+		}
+	},
+	choice: choiceDefinition,
+	explanation: explanationDefinition,
+	figure: textAttributes(figureDefinition, ["alt", "caption"]),
+	math: mathDefinition,
+	mathInline: mathInlineDefinition,
+	question: questionDefinition,
+	quiz: quizDefinition,
+	step: textAttributes(stepDefinition, ["title"]),
+	steps: stepsDefinition,
+	tab: textAttributes(tabDefinition, ["title"]),
+	tabs: tabsDefinition,
+	underline: underlineDefinition
+};
+/** Canonical schemas are immutable; callers add custom names in a separate registry. */
+const components = deepFreeze({
+	...authoredComponents,
+	u: underlineDefinition
+});
+function metadata(name, definition) {
+	const constraint = definition.children;
+	const allowedChildren = typeof constraint === "object" ? "components" in constraint ? constraint.components : constraint.nodes.map((node) => node === "code" ? "fence" : node) : void 0;
+	const requiredChildren = name === "question" ? ["choice"] : typeof constraint === "object" && constraint.min ? allowedChildren?.slice(0, 1) : void 0;
+	return {
+		name,
+		kind: definition.kind,
+		render: String(definition.render),
+		description: definition.description ?? "",
+		...Object.keys(definition.attributes).length ? { attributes: definition.attributes } : {},
+		...allowedChildren ? { allowedChildren } : {},
+		...requiredChildren ? { requiredChildren } : {}
+	};
+}
+/** Legacy catalog metadata, derived from authored definitions plus native mdast nodes. */
+const topikComponents = deepFreeze({
+	...Object.fromEntries(Object.entries(authoredComponents).map(([name, definition]) => [name, metadata(name, definition)])),
+	...nativeComponents
+});
+/** Defaults are for reading/rendering; authored absence stays unchanged. */
+function getEffectiveProps(component, registry = components) {
+	const definition = Object.hasOwn(registry, component.name) ? registry[component.name] : void 0;
+	if (!definition) throw new Error(`Unknown component ${component.name}`);
+	const defaults = {};
+	for (const [name, attribute] of Object.entries(definition.attributes)) if (attribute.default !== void 0) defaults[name] = attribute.default;
+	return {
+		...defaults,
+		...component.props
+	};
+}
+//#endregion
+//#region src/limits.ts
+/** Fixed admission limits, measured in UTF-16 code units and tree nodes. */
+const CONTENT_LIMITS = Object.freeze({
+	sourceLength: 1e6,
+	/** Inline delimiter attempts; code-span attempts are weighted by delimiter run length. */
+	parserSteps: 4096,
+	treeDepth: 64,
+	treeNodes: 5e4,
+	dataDepth: 160,
+	dataEntries: 5e5,
+	dataStringLength: 1e6,
+	expressionLength: 16384,
+	expressionDepth: 32,
+	expressionNodes: 256,
+	/** Bounded escaped payload and row decorations, before reader allocation. */
+	presentationOutputLength: 8e6
+});
+var ContentLimitError = class extends Error {
+	id = "topik-content-limit";
+	constructor(message) {
+		super(message);
+		this.name = "ContentLimitError";
+	}
+};
+var ContentDataError = class extends Error {
+	id = "topik-node-invalid";
+};
+function limitDiagnostic(error) {
+	return {
+		id: error.id,
+		message: error.message
+	};
+}
+function assertSourceLimit(source) {
+	if (source.length > CONTENT_LIMITS.sourceLength) throw new ContentLimitError(`Content exceeds the source length limit of ${CONTENT_LIMITS.sourceLength}`);
+}
+/** Check before recursive transforms and return the number of admitted nodes. */
+function assertTreeLimits(root) {
+	const active = /* @__PURE__ */ new Set();
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [{
+		node: root,
+		depth: 0,
+		exit: false
+	}];
+	let count = 0;
+	while (stack.length) {
+		const { node, depth, exit } = stack.pop();
+		if (exit) {
+			active.delete(node);
+			continue;
+		}
+		if (!node || typeof node !== "object") continue;
+		if (active.has(node)) throw new ContentLimitError("Content tree contains a cycle");
+		if (seen.has(node)) throw new ContentDataError("Content nodes must not be shared between tree positions");
+		seen.add(node);
+		if (depth > CONTENT_LIMITS.treeDepth) throw new ContentLimitError(`Content exceeds the tree depth limit of ${CONTENT_LIMITS.treeDepth}`);
+		if (++count > CONTENT_LIMITS.treeNodes) throw new ContentLimitError(`Content exceeds the tree node limit of ${CONTENT_LIMITS.treeNodes}`);
+		const templates = (node.type === "topikCodeTemplate" || node.type === "tagCodeTemplate") && node.template ? [node.template] : [];
+		const properties = node.type === "topikComponent" ? node.props : [
+			"tagText",
+			"tagLeaf",
+			"tagContainer"
+		].includes(node.type) ? node.attributes : void 0;
+		for (const value of Object.values(properties ?? {})) if (value && typeof value === "object" && value.type === "topikTextTemplate") templates.push(value);
+		for (const template of templates) count += 1 + (Array.isArray(template.segments) ? template.segments.length : 0);
+		if (count > CONTENT_LIMITS.treeNodes) throw new ContentLimitError(`Content exceeds the tree node limit of ${CONTENT_LIMITS.treeNodes}`);
+		active.add(node);
+		stack.push({
+			node,
+			depth,
+			exit: true
+		});
+		if (Array.isArray(node.children)) {
+			if (node.children.length > CONTENT_LIMITS.treeNodes) throw new ContentLimitError(`Content exceeds the tree node limit of ${CONTENT_LIMITS.treeNodes}`);
+			for (let index = node.children.length - 1; index >= 0; index--) stack.push({
+				node: node.children[index],
+				depth: depth + 1,
+				exit: false
+			});
+		}
+	}
+	return count;
+}
+/** Include metadata and expressions so cloning cannot bypass the authoring-tree limits. */
+function assertDataLimits(root, options = {}) {
+	const active = /* @__PURE__ */ new Set();
+	const stack = [{
+		value: root,
+		depth: 0,
+		exit: false
+	}];
+	let entries = 0;
+	let strings = 0;
+	while (stack.length) {
+		const { value, depth, exit, stringLength } = stack.pop();
+		if (exit) {
+			active.delete(value);
+			continue;
+		}
+		if (++entries > CONTENT_LIMITS.dataEntries) throw new ContentLimitError(`Content exceeds the data entry limit of ${CONTENT_LIMITS.dataEntries}`);
+		if (typeof value === "string") {
+			strings += stringLength ?? value.length;
+			if (strings > CONTENT_LIMITS.dataStringLength) throw new ContentLimitError(`Content exceeds the data string limit of ${CONTENT_LIMITS.dataStringLength}`);
+		}
+		if (options.plain && (typeof value === "function" || typeof value === "symbol" || typeof value === "bigint" || typeof value === "number" && !Number.isFinite(value))) throw new ContentDataError("Content must contain plain data values");
+		if (!value || typeof value !== "object") continue;
+		if (options.plain) {
+			const prototype = Object.getPrototypeOf(value);
+			if (Array.isArray(value) ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) throw new ContentDataError("Content must contain plain objects and arrays");
+		}
+		if (active.has(value)) throw new ContentLimitError("Content data contains a cycle");
+		if (depth > CONTENT_LIMITS.dataDepth) throw new ContentLimitError(`Content exceeds the data depth limit of ${CONTENT_LIMITS.dataDepth}`);
+		active.add(value);
+		stack.push({
+			value,
+			depth,
+			exit: true
+		});
+		const descriptors = Object.getOwnPropertyDescriptors(value);
+		for (const key of Reflect.ownKeys(descriptors)) {
+			const descriptor = descriptors[key];
+			if (options.plain && (typeof key === "symbol" || !descriptor.enumerable && !(Array.isArray(value) && key === "length"))) throw new ContentDataError("Content properties must be enumerable string keys");
+			if (!("value" in descriptor)) throw new ContentDataError("Content data must not contain accessors");
+			stack.push({
+				value: descriptor.value,
+				depth: depth + 1,
+				exit: false,
+				stringLength: options.stringLengths?.get(value)?.get(key)
+			});
+		}
+	}
+}
+//#endregion
+//#region src/expressions.ts
+const identifier = /^[A-Za-z_][A-Za-z0-9_]*/;
+const number = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/;
+const unsafeKeys$1 = /* @__PURE__ */ new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+function validPath(path) {
+	return Array.isArray(path) && path.length > 0 && path.every((part) => typeof part === "string" && /^[A-Za-z_][A-Za-z0-9_]*$/.test(part) && !unsafeKeys$1.has(part));
+}
+function parseExpression(source) {
+	if (source.length > CONTENT_LIMITS.expressionLength) throw new ContentLimitError(`Content exceeds the expression length limit of ${CONTENT_LIMITS.expressionLength}`);
+	let index = 0;
+	let nodes = 0;
+	function fail(message) {
+		throw new Error(`${message} at expression offset ${index}`);
+	}
+	function space() {
+		while (/\s/.test(source[index] ?? "")) index++;
+	}
+	function readIdentifier() {
+		const match = identifier.exec(source.slice(index));
+		if (!match) fail("Expected identifier");
+		index += match[0].length;
+		return match[0];
+	}
+	function expression(depth = 0) {
+		if (depth > CONTENT_LIMITS.expressionDepth) throw new ContentLimitError(`Content exceeds the expression depth limit of ${CONTENT_LIMITS.expressionDepth}`);
+		if (++nodes > CONTENT_LIMITS.expressionNodes) throw new ContentLimitError(`Content exceeds the expression node limit of ${CONTENT_LIMITS.expressionNodes}`);
+		space();
+		const char = source[index];
+		if (char === "\"" || char === "'") {
+			index++;
+			let value = "";
+			while (index < source.length) {
+				const next = source[index++];
+				if (next === char) return {
+					type: "literal",
+					value
+				};
+				if (next === "\\") {
+					const escaped = source[index++];
+					if (escaped === void 0) fail("Unterminated string escape");
+					if (escaped === "n") value += "\n";
+					else if (escaped === "r") value += "\r";
+					else if (escaped === "t") value += "	";
+					else if (escaped === "b") value += "\b";
+					else if (escaped === "f") value += "\f";
+					else if (escaped === "u") {
+						const digits = source.slice(index, index + 4);
+						if (!/^[0-9a-fA-F]{4}$/.test(digits)) fail("Invalid Unicode escape");
+						value += String.fromCharCode(Number.parseInt(digits, 16));
+						index += 4;
+					} else if (escaped === char || escaped === "\\") value += escaped;
+					else fail("Unsupported string escape");
+				} else value += next;
+			}
+			fail("Unterminated string");
+		}
+		if (char === "$") {
+			index++;
+			const path = [readIdentifier()];
+			while (source[index] === ".") {
+				index++;
+				path.push(readIdentifier());
+			}
+			if (!validPath(path)) fail("Unsafe variable path");
+			return {
+				type: "variable",
+				path
+			};
+		}
+		const numeric = number.exec(source.slice(index));
+		if (numeric) {
+			index += numeric[0].length;
+			const value = Number(numeric[0]);
+			if (!Number.isFinite(value)) fail("Number must be finite");
+			return {
+				type: "literal",
+				value
+			};
+		}
+		const name = readIdentifier();
+		if (name === "true" || name === "false" || name === "null") return {
+			type: "literal",
+			value: name === "null" ? null : name === "true"
+		};
+		if (name !== "equals" && name !== "and" && name !== "or" && name !== "not") fail(`Unknown expression function ${name}`);
+		space();
+		if (source[index++] !== "(") fail(`Expected ( after ${name}`);
+		const args = [];
+		space();
+		if (source[index] !== ")") while (true) {
+			args.push(expression(depth + 1));
+			space();
+			if (source[index] !== ",") break;
+			index++;
+		}
+		if (source[index++] !== ")") fail(`Expected ) after ${name}`);
+		if (args.length !== (name === "not" ? 1 : 2)) fail(`${name} requires ${name === "not" ? 1 : 2} argument(s)`);
+		return {
+			type: "call",
+			name,
+			args
+		};
+	}
+	const parsed = expression();
+	space();
+	if (index !== source.length) fail("Unexpected expression text");
+	return parsed;
+}
+function writeExpression(expression) {
+	const active = /* @__PURE__ */ new Set();
+	let nodes = 0;
+	function write(expression, depth = 0) {
+		if (active.has(expression)) throw new ContentLimitError("Expression contains a cycle");
+		if (depth > CONTENT_LIMITS.expressionDepth) throw new ContentLimitError(`Content exceeds the expression depth limit of ${CONTENT_LIMITS.expressionDepth}`);
+		if (++nodes > CONTENT_LIMITS.expressionNodes) throw new ContentLimitError(`Content exceeds the expression node limit of ${CONTENT_LIMITS.expressionNodes}`);
+		active.add(expression);
+		try {
+			return writeNode(expression, depth);
+		} finally {
+			active.delete(expression);
+		}
+	}
+	function writeNode(expression, depth) {
+		if (!expression || typeof expression !== "object") throw new Error("Invalid expression");
+		if (expression.type === "literal") {
+			const value = expression.value;
+			if (value === null || typeof value === "boolean") return String(value);
+			if (typeof value === "number" && Number.isFinite(value)) return Object.is(value, -0) ? "-0" : String(value);
+			if (typeof value === "string") return JSON.stringify(value);
+			throw new Error("Invalid expression literal");
+		}
+		if (expression.type === "variable") {
+			if (!validPath(expression.path)) throw new Error("Unsafe variable path");
+			return `$${expression.path.join(".")}`;
+		}
+		if (expression.type !== "call" || ![
+			"equals",
+			"and",
+			"or",
+			"not"
+		].includes(expression.name) || !Array.isArray(expression.args) || expression.args.length !== (expression.name === "not" ? 1 : 2)) throw new Error("Invalid expression call");
+		return `${expression.name}(${expression.args.map((argument) => write(argument, depth + 1)).join(", ")})`;
+	}
+	const result = write(expression);
+	if (result.length > CONTENT_LIMITS.expressionLength) throw new ContentLimitError(`Content exceeds the expression length limit of ${CONTENT_LIMITS.expressionLength}`);
+	return result;
+}
+//#endregion
+//#region src/node-grammar.ts
+const blockTypes = /* @__PURE__ */ new Set([
+	"paragraph",
+	"heading",
+	"blockquote",
+	"list",
+	"code",
+	"topikCodeTemplate",
+	"topikCodePresentation",
+	"table",
+	"thematicBreak",
+	"definition",
+	"topikConditional"
+]);
+const inlineTypes = /* @__PURE__ */ new Set([
+	"text",
+	"emphasis",
+	"strong",
+	"delete",
+	"inlineCode",
+	"break",
+	"link",
+	"image",
+	"linkReference",
+	"imageReference",
+	"topikVariable"
+]);
+const inlineParentTypes = /* @__PURE__ */ new Set([
+	"paragraph",
+	"heading",
+	"tableCell",
+	"emphasis",
+	"strong",
+	"delete",
+	"link",
+	"linkReference"
+]);
+const parentTypes = /* @__PURE__ */ new Set([
+	...inlineParentTypes,
+	"root",
+	"blockquote",
+	"list",
+	"listItem",
+	"table",
+	"tableRow",
+	"topikComponent",
+	"topikConditional",
+	"topikBranch",
+	"topikCodePresentation"
+]);
+const nodeTypes = /* @__PURE__ */ new Set([
+	...parentTypes,
+	...blockTypes,
+	...inlineTypes,
+	"yaml"
+]);
+function isContentKind(node, kind, registry) {
+	if (node.type !== "topikComponent") return (kind === "inline" ? inlineTypes : blockTypes).has(node.type);
+	return typeof node.name === "string" && Object.hasOwn(registry, node.name) && registry[node.name].kind === kind;
+}
+function isInlineParent(node, registry) {
+	return inlineParentTypes.has(node.type) || node.type === "topikComponent" && isContentKind(node, "inline", registry);
+}
+//#endregion
+//#region src/node-validation.ts
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function string(value) {
+	return typeof value === "string" && !/[\0\r]/.test(value);
+}
+function optionalString(value) {
+	return value === void 0 || value === null || string(value);
+}
+function dense(array) {
+	const keys = Object.keys(array);
+	return keys.length === array.length && keys.every((key, index) => key === String(index));
+}
+function controls(value, allowTab = false, includeSpace = false) {
+	for (let index = 0; index < value.length; index++) {
+		const unit = value.charCodeAt(index);
+		if (unit < (includeSpace ? 33 : 32) && !(allowTab && unit === 9) || unit === 127) return true;
+	}
+	return false;
+}
+/** Admission runs after descriptor-based plain-data checks, before cloning or callbacks. */
+function textTemplateProblem(value, code = false, seen = /* @__PURE__ */ new Set()) {
+	const invalid = (message) => ({
+		id: "topik-template-syntax",
+		message
+	});
+	if (!record(value) || value.type !== "topikTextTemplate" || Object.keys(value).some((key) => key !== "type" && key !== "segments") || !Array.isArray(value.segments) || !dense(value.segments)) return invalid("Templates require a discriminator and an array of segments");
+	const claim = (object) => {
+		if (seen.has(object)) return false;
+		seen.add(object);
+		return true;
+	};
+	if (!claim(value) || !claim(value.segments)) return invalid("Template data must not be shared between authoring positions");
+	for (const segment of value.segments) {
+		if (!record(segment) || !claim(segment)) return invalid("Templates require independent plain-data segment objects");
+		if (segment.type === "literal") {
+			if (Object.keys(segment).some((key) => key !== "type" && key !== "value") || typeof segment.value !== "string") return invalid("Literal template segments require a string value");
+			if (code ? /[\0\r]/.test(segment.value) : controls(segment.value)) return {
+				id: "topik-template-control",
+				message: code ? "Code template literals cannot contain NUL or carriage returns" : "Attribute template literals must be single-line without controls"
+			};
+		} else if (segment.type === "variable") {
+			if (Object.keys(segment).some((key) => key !== "type" && key !== "path")) return invalid("Variable template segments require only a path");
+			if (Array.isArray(segment.path) && segment.path.length > CONTENT_LIMITS.treeNodes) return {
+				id: "topik-content-limit",
+				message: "Template path exceeds the item limit"
+			};
+			if (!Array.isArray(segment.path) || !dense(segment.path) || !validPath(segment.path)) return {
+				id: "topik-variable-path",
+				message: "Invalid template variable path"
+			};
+			if (!claim(segment.path)) return invalid("Template paths must not be shared between authoring positions");
+		} else return invalid("Unsupported template segment discriminator");
+	}
+}
+function codeTemplateProblem(node, seen = /* @__PURE__ */ new Set()) {
+	if (Object.keys(node).some((key) => ![
+		"type",
+		"lang",
+		"meta",
+		"template",
+		"position",
+		"data"
+	].includes(key))) return {
+		id: "topik-code-template-structure",
+		message: "Code templates have one authoritative template payload"
+	};
+	if (!optionalString(node.lang) || !optionalString(node.meta) || node.lang === "" || node.meta === "" || node.meta != null && !node.lang || typeof node.lang === "string" && controls(node.lang, false, true) || typeof node.meta === "string" && controls(node.meta, true)) return {
+		id: "topik-code-template-structure",
+		message: "Code template language and metadata must fit one fence header"
+	};
+	if (node.lang === "mermaid") return {
+		id: "topik-code-template-language",
+		message: "Code templates require a text code renderer"
+	};
+	return textTemplateProblem(node.template, true, seen);
+}
+/** Validate mdast fields and grammar before callbacks, cloning, or serialization. */
+function nodeShapeProblem(value, registry) {
+	if (!record(value) || typeof value.type !== "string") return "Content nodes must have a string type";
+	const node = value;
+	const type = node.type;
+	const children = node.children;
+	if (node.position !== void 0) {
+		const position = node.position;
+		if (!record(position) || [position.start, position.end].some((point) => !record(point) || !Number.isInteger(point.line) || point.line < 1 || !Number.isInteger(point.column) || point.column < 1 || point.offset !== void 0 && (!Number.isInteger(point.offset) || point.offset < 0))) return "Content positions require valid start and end points";
+	}
+	if (node.data !== void 0 && !record(node.data)) return "Content metadata must be an object";
+	if (parentTypes.has(type)) {
+		if (!Array.isArray(children) || children.some((child) => !record(child) || typeof child.type !== "string")) return `${type} requires an array of content nodes`;
+	} else if (children !== void 0) return `${type} cannot contain children`;
+	const nodes = children ?? [];
+	if (type === "root" || type === "blockquote" || type === "listItem") {
+		if (nodes.some((child) => !(type === "root" && child.type === "yaml") && !isContentKind(child, "block", registry))) return `${type} requires block children`;
+	}
+	if (inlineParentTypes.has(type) && nodes.some((child) => !isContentKind(child, "inline", registry))) return `${type} requires inline children`;
+	if (inlineParentTypes.has(type) && type !== "link" && type !== "linkReference" && nodes.at(-1)?.type === "break") return "A trailing hard break has no faithful Markdown representation";
+	switch (type) {
+		case "text":
+			if (!string(node.value) || !node.value) return "Text requires nonempty content without NUL or carriage returns";
+			break;
+		case "yaml":
+		case "code":
+			if (!string(node.value)) return `${type} requires a string value without NUL or carriage returns`;
+			if (type === "yaml" && /^---[ \t]*$/m.test(node.value)) return "Frontmatter content cannot contain its closing fence";
+			if (type === "code" && (!optionalString(node.lang) || !optionalString(node.meta) || node.meta != null && !node.lang)) return "Code language and metadata must fit one fence header";
+			break;
+		case "inlineCode":
+			if (!string(node.value) || !node.value || node.value.includes("\n")) return "Inline code requires nonempty single-line content";
+			break;
+		case "heading":
+			if (!Number.isInteger(node.depth) || node.depth < 1 || node.depth > 6) return "Heading depth must be an integer from 1 to 6";
+			if (record(node.data) && node.data.topikId !== void 0 && (typeof node.data.topikId !== "string" || !/^[A-Za-z0-9_.:-]+$/.test(node.data.topikId))) return "Explicit heading IDs must contain supported characters";
+			break;
+		case "emphasis":
+		case "strong":
+		case "delete":
+			if (!nodes.length) return `${type} requires inline children`;
+			break;
+		case "list":
+			if (!nodes.length || nodes.some((child) => child.type !== "listItem")) return "Lists require list item children";
+			if (node.ordered != null && typeof node.ordered !== "boolean") return "List ordered must be a boolean";
+			if (node.start != null && (!node.ordered || !Number.isInteger(node.start) || node.start < 0 || node.start > 999999999)) return "Ordered list start must be an integer from 0 to 999999999";
+			if (node.spread != null && typeof node.spread !== "boolean") return "List spread must be a boolean";
+			break;
+		case "listItem":
+			if (node.checked != null && typeof node.checked !== "boolean") return "List item checked must be a boolean";
+			if (node.spread != null && typeof node.spread !== "boolean") return "List item spread must be a boolean";
+			break;
+		case "table": {
+			if (!nodes.length || nodes.some((child) => child.type !== "tableRow" || !Array.isArray(child.children))) return "Tables require table row children";
+			const width = nodes[0].children.length;
+			if (!width) return "Table headers must have at least one column";
+			if (nodes.some((row) => row.children.length !== width)) return "Table rows must match the header column count";
+			if (node.align != null && (!Array.isArray(node.align) || node.align.length !== width || node.align.some((align) => align !== null && ![
+				"left",
+				"right",
+				"center"
+			].includes(align)))) return "Table alignment must match its columns";
+			break;
+		}
+		case "tableRow":
+			if (!nodes.length || nodes.some((child) => child.type !== "tableCell")) return "Table rows require table cells";
+			break;
+		case "image":
+		case "link":
+		case "definition":
+			if (!string(node.url) || !optionalString(node.title)) return "Resources require a string URL and an optional string title";
+			if (type === "image" && !optionalString(node.alt)) return "Image alt text must be a string";
+			break;
+		case "imageReference":
+			if (!optionalString(node.alt)) return "Image alt text must be a string";
+			break;
+		case "topikComponent": if (typeof node.name !== "string") return "Components require a string name";
+	}
+	if (type === "definition" || type === "imageReference" || type === "linkReference") {
+		if (!string(node.identifier) || !node.identifier.trim() || !optionalString(node.label)) return "References require a nonempty identifier and optional string label";
+		if (type !== "definition" && ![
+			"shortcut",
+			"collapsed",
+			"full"
+		].includes(node.referenceType)) return "References require a supported reference type";
+	}
+}
+//#endregion
+//#region src/code-presentation.ts
+/** Bounds are independent of ordinary, unpresented code admission. */
+const CODE_PRESENTATION_LIMITS = Object.freeze({
+	metadataLength: 16384,
+	selectionIntervals: 1024,
+	rows: 2e4,
+	decorativeOutput: 8e6
+});
+/** Fixed source order is part of the canonical writer policy. */
+const CODE_PRESENTATION_OPTION_KEYS = [
+	"filename",
+	"title",
+	"lineNumbers",
+	"startLine",
+	"highlight",
+	"focus",
+	"collapse",
+	"wrap",
+	"added",
+	"removed"
+];
+const selectionKeys = /* @__PURE__ */ new Set([
+	"highlight",
+	"focus",
+	"collapse",
+	"added",
+	"removed"
+]);
+const unsafeKeys = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const authoredKeys = /* @__PURE__ */ new Map([
+	["filename", "filename"],
+	["title", "title"],
+	["lines", "lineNumbers"],
+	["startLine", "startLine"],
+	["highlight", "highlight"],
+	["focus", "focus"],
+	["collapse", "collapse"],
+	["wrap", "wrap"],
+	["added", "added"],
+	["removed", "removed"]
+]);
+var CodePresentationError = class extends Error {
+	id;
+	option;
+	constructor(id, message, option) {
+		super(message);
+		this.id = id;
+		this.name = "CodePresentationError";
+		if (CODE_PRESENTATION_OPTION_KEYS.includes(option ?? "")) this.option = option;
+	}
+};
+function fail(id, message, option) {
+	throw new CodePresentationError(`topik-code-presentation-${id}`, message, option);
+}
+function withOption(option, action) {
+	try {
+		return action();
+	} catch (error) {
+		if (error instanceof CodePresentationError) throw new CodePresentationError(error.id, error.message, option);
+		throw error;
+	}
+}
+function ownRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) fail("metadata", "Code presentation options require a plain object");
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) fail("metadata", "Code presentation options require a plain object");
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	for (const key of Reflect.ownKeys(descriptors)) {
+		const descriptor = descriptors[key];
+		if (typeof key !== "string" || unsafeKeys.has(key) || !descriptor.enumerable || !("value" in descriptor)) fail("metadata", "Code presentation requires enumerable own data properties");
+	}
+	return descriptors;
+}
+function ownArray(value, message) {
+	if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) fail("lines", message);
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	const keys = Reflect.ownKeys(descriptors);
+	if (keys.length !== value.length + 1 || keys.some((key) => {
+		if (key === "length") return false;
+		const descriptor = descriptors[key];
+		return typeof key !== "string" || !/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= value.length || !descriptor.enumerable || !("value" in descriptor);
+	})) fail("lines", message);
+	return value;
+}
+function positive(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function containsControls(value, allowTab = false) {
+	for (let index = 0; index < value.length; index++) {
+		const unit = value.charCodeAt(index);
+		if (unit < 32 && !(allowTab && unit === 9) || unit === 127) return true;
+	}
+	return false;
+}
+function mergeIntervals(intervals) {
+	intervals.sort((left, right) => left[0] - right[0] || left[1] - right[1]);
+	const result = [];
+	for (const [start, end] of intervals) {
+		const previous = result.at(-1);
+		if (previous && start <= previous[1] + 1) previous[1] = Math.max(previous[1], end);
+		else result.push([start, end]);
+	}
+	return result;
+}
+/** Parse ranges without expanding endpoints into individual row allocations. */
+function parseCodeLineSelection(value, rowCount) {
+	if (value.length > CODE_PRESENTATION_LIMITS.metadataLength) throw new ContentLimitError("Code selection exceeds the metadata length limit");
+	if (!value || !/^[1-9][0-9]*(?:-[1-9][0-9]*)?(?:,[1-9][0-9]*(?:-[1-9][0-9]*)?)*$/.test(value)) fail("lines", "Line selections require positive numbers or closed ranges separated by commas");
+	let count = 1;
+	for (const character of value) if (character === ",") count++;
+	if (count > CODE_PRESENTATION_LIMITS.selectionIntervals) throw new ContentLimitError("Code selections exceed the 1024 interval limit");
+	const intervals = [];
+	for (const range of value.split(",")) {
+		const [first, last] = range.split("-");
+		const start = Number(first);
+		const end = last === void 0 ? start : Number(last);
+		if (!positive(start) || !positive(end) || start > end || end > rowCount) fail("line-bounds", "Line selections must remain within the physical code rows");
+		intervals.push([start, end]);
+	}
+	return mergeIntervals(intervals);
+}
+function normalizeSelection(value, rowCount) {
+	const array = ownArray(value, "Normalized line selections require interval arrays");
+	if (!array.length) fail("lines", "Line selections must not be empty");
+	if (array.length > CODE_PRESENTATION_LIMITS.selectionIntervals) throw new ContentLimitError("Code selections exceed the 1024 interval limit");
+	const seen = /* @__PURE__ */ new Set([array]);
+	const intervals = [];
+	for (const item of array) {
+		const interval = ownArray(item, "Line selections require pairs of positive integers");
+		if (seen.has(interval)) fail("metadata", "Code presentation data must not be shared");
+		seen.add(interval);
+		if (interval.length !== 2) fail("lines", "Line selections require pairs of positive integers");
+		const [start, end] = interval;
+		if (!positive(start) || !positive(end) || start > end || end > rowCount) fail("line-bounds", "Line selections must remain within the physical code rows");
+		intervals.push([start, end]);
+	}
+	return mergeIntervals(intervals);
+}
+function overlap(left, right) {
+	let first = 0;
+	let second = 0;
+	while (first < left.length && second < right.length) if (left[first][1] < right[second][0]) first++;
+	else if (right[second][1] < left[first][0]) second++;
+	else return true;
+	return false;
+}
+function normalizeCodePresentationOptions(value, rowCount) {
+	if (!positive(rowCount) || rowCount > CODE_PRESENTATION_LIMITS.rows) throw new ContentLimitError("Presented code exceeds the 20000 physical row limit");
+	const descriptors = ownRecord(value);
+	const result = {};
+	const claimed = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(descriptors)) {
+		if (!CODE_PRESENTATION_OPTION_KEYS.includes(key)) fail("option", "Code presentation contains an unsupported option");
+		const input = descriptors[key].value;
+		if (key === "filename" || key === "title") {
+			if (typeof input !== "string" || !input.trim() || input.length > 256 || containsControls(input)) fail("option", `${key} must be a nonblank single-line string of at most 256 UTF-16 units`, key);
+			result[key] = input;
+		} else if (key === "lineNumbers" || key === "wrap") {
+			if (typeof input !== "boolean") fail("option", `${key} must be a boolean`, key);
+			result[key] = input;
+		} else if (key === "startLine") {
+			if (!positive(input) || input > 1e9 || !Number.isSafeInteger(input + rowCount - 1)) fail("option", "startLine must be an integer from 1 to 1000000000 with safe final labels", key);
+			result.startLine = input;
+		} else if (selectionKeys.has(key)) result[key] = withOption(key, () => {
+			if (input && typeof input === "object") {
+				if (claimed.has(input)) fail("metadata", "Code presentation data must not be shared");
+				claimed.add(input);
+				for (const item of ownArray(input, "Normalized line selections require interval arrays")) if (item && typeof item === "object") {
+					if (claimed.has(item)) fail("metadata", "Code presentation data must not be shared");
+					claimed.add(item);
+				}
+			}
+			return normalizeSelection(input, rowCount);
+		});
+	}
+	if (result.added && result.removed && overlap(result.added, result.removed)) fail("diff-conflict", "added and removed line selections must be disjoint", "added");
+	return result;
+}
+/** The parser reads this raw source spelling before CommonMark unescaping. */
+function parseCodePresentationMetadata(rawMeta, rowCount) {
+	if (rawMeta.length > CONTENT_LIMITS.sourceLength) throw new ContentLimitError("Code presentation metadata exceeds the source length limit");
+	let cursor = 0;
+	while (horizontal(rawMeta[cursor])) cursor++;
+	const start = cursor;
+	const values = {};
+	let suffixStart = cursor;
+	const bounded = () => {
+		if (cursor - start > CODE_PRESENTATION_LIMITS.metadataLength) throw new ContentLimitError("Code presentation attributes exceed the 16384 UTF-16 unit limit");
+	};
+	while (cursor < rawMeta.length) {
+		const nameStart = cursor;
+		while (nameCharacter(rawMeta[cursor])) cursor++;
+		const name = rawMeta.slice(nameStart, cursor);
+		const key = authoredKeys.get(name);
+		if (!key || cursor < rawMeta.length && !horizontal(rawMeta[cursor]) && rawMeta[cursor] !== "=") break;
+		if (Object.hasOwn(values, key)) fail("metadata", "Code presentation contains a duplicate attribute", key);
+		bounded();
+		const afterName = cursor;
+		while (horizontal(rawMeta[cursor])) cursor++;
+		let input;
+		if (rawMeta[cursor] !== "=") {
+			if (key !== "lineNumbers" && key !== "wrap") fail("option", `${name} requires an assigned value`, key);
+			cursor = afterName;
+			if (cursor < rawMeta.length && !horizontal(rawMeta[cursor])) fail("metadata", "Code presentation attributes require whitespace separators", key);
+			input = true;
+		} else {
+			cursor++;
+			while (horizontal(rawMeta[cursor])) cursor++;
+			bounded();
+			const quote = rawMeta[cursor] === "\"" || rawMeta[cursor] === "'" ? rawMeta[cursor++] : void 0;
+			const valueStart = cursor;
+			if (quote) {
+				let closed = false;
+				while (cursor < rawMeta.length) {
+					const character = rawMeta[cursor++];
+					bounded();
+					if (character === "\\") {
+						if (cursor < rawMeta.length) cursor++;
+						bounded();
+					} else if (character === quote) {
+						closed = true;
+						break;
+					}
+				}
+				if (!closed) fail("metadata", "Close the quoted code presentation attribute value", key);
+			} else while (cursor < rawMeta.length && !horizontal(rawMeta[cursor])) {
+				cursor++;
+				bounded();
+			}
+			const valueEnd = quote ? cursor - 1 : cursor;
+			if (valueEnd === valueStart && !quote) fail("option", `${name} requires an assigned value`, key);
+			if (cursor < rawMeta.length && !horizontal(rawMeta[cursor])) fail("metadata", "Code presentation attributes require whitespace separators", key);
+			const value = decodeString(rawMeta.slice(valueStart, valueEnd));
+			if (key === "lineNumbers" || key === "wrap") {
+				if (value !== "true" && value !== "false") fail("option", `${name} must be true or false`, key);
+				input = value === "true";
+			} else if (key === "startLine") {
+				if (!/^[1-9][0-9]*$/.test(value)) fail("option", `${name} requires a positive decimal integer`, key);
+				input = Number(value);
+			} else if (selectionKeys.has(key)) input = withOption(key, () => parseCodeLineSelection(value, rowCount));
+			else input = value;
+		}
+		values[key] = input;
+		bounded();
+		suffixStart = cursor;
+		while (horizontal(rawMeta[cursor])) cursor++;
+	}
+	if (!Object.keys(values).length) return void 0;
+	const opaqueMetaSuffix = decodeString(rawMeta.slice(suffixStart));
+	assertCodePresentationSuffix(opaqueMetaSuffix);
+	const options = normalizeCodePresentationOptions(values, rowCount);
+	assertCanonicalAttributeLimit(options);
+	return {
+		options,
+		opaqueMetaSuffix
+	};
+}
+function horizontal(value) {
+	return value === " " || value === "	";
+}
+function nameCharacter(value) {
+	return value !== void 0 && /[A-Za-z0-9_-]/.test(value);
+}
+function assertCodePresentationSuffix(value) {
+	if (typeof value !== "string" || value.length > 0 && value[0] !== " " && value[0] !== "	" || containsControls(value, true)) fail("metadata", "Opaque metadata suffix must be single-line and retain separating whitespace");
+}
+/** Quote raw fence attributes before exactly one CommonMark decoding pass. */
+function quoteAttribute(value) {
+	let result = "\"";
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index];
+		if (character === "\"") result += "\\\"";
+		else if (character === "\\") result += "&#92;";
+		else if (character === "&" && entityAt(value, index)) result += "&#38;";
+		else if (character === "`") result += "&#96;";
+		else result += character;
+	}
+	return result + "\"";
+}
+function entityAt(value, index) {
+	return /^&(?:#[0-9]+|#[xX][0-9A-Fa-f]+|[A-Za-z][A-Za-z0-9]*);/.test(value.slice(index));
+}
+/** A decoded opaque suffix may start with a word that otherwise becomes an option. */
+function suffixProtectedIndex(suffix) {
+	let cursor = 0;
+	while (horizontal(suffix[cursor])) cursor++;
+	const start = cursor;
+	while (nameCharacter(suffix[cursor])) cursor++;
+	return authoredKeys.has(suffix.slice(start, cursor)) && (cursor === suffix.length || horizontal(suffix[cursor]) || suffix[cursor] === "=") ? start : void 0;
+}
+/** Single-pass CommonMark encoding also preserves entity-looking decoded text. */
+function encodeCodePresentationSuffix(suffix) {
+	assertCodePresentationSuffix(suffix);
+	if (encodedSuffixLength(suffix) > CONTENT_LIMITS.sourceLength) throw new ContentLimitError("Code presentation suffix exceeds the source length limit");
+	const protectedIndex = suffixProtectedIndex(suffix);
+	let result = "";
+	for (let index = 0; index < suffix.length; index++) {
+		const character = suffix[index];
+		if (index === protectedIndex) result += `&#${character.charCodeAt(0)};`;
+		else if (character === "&") result += "&#38;";
+		else if (character === "\\") result += "&#92;";
+		else if (character === "`") result += "&#96;";
+		else result += character;
+	}
+	return result;
+}
+function encodedSuffixLength(suffix) {
+	let length = suffix.length;
+	for (let index = 0; index < suffix.length; index++) if (suffix[index] === "&" || suffix[index] === "\\" || suffix[index] === "`") length += 4;
+	const protectedIndex = suffixProtectedIndex(suffix);
+	if (protectedIndex !== void 0) length += String(suffix.charCodeAt(protectedIndex)).length + 2;
+	return length;
+}
+function selectionSource(value) {
+	return value.map(([start, end]) => start === end ? String(start) : `${start}-${end}`).join(",");
+}
+/** Measure quoted attribute output without allocating its escaped spelling. */
+function quotedAttributeLength(value) {
+	let length = 2;
+	for (let index = 0; index < value.length; index++) {
+		const unit = value.charCodeAt(index);
+		if (unit === 34) length += 2;
+		else if (unit === 92 || unit === 96 || unit === 38 && entityAt(value, index)) length += 5;
+		else length++;
+	}
+	return length;
+}
+function canonicalAttributeLength(options) {
+	let length = 0;
+	let members = 0;
+	for (const key of CODE_PRESENTATION_OPTION_KEYS) {
+		if (!Object.hasOwn(options, key)) continue;
+		if (members++) length++;
+		length += (key === "lineNumbers" ? "lines" : key).length;
+		const value = options[key];
+		if (typeof value === "boolean" && value) continue;
+		length++;
+		if (Array.isArray(value)) {
+			length += 2;
+			for (let index = 0; index < value.length; index++) {
+				if (index > 0) length++;
+				const [start, end] = value[index];
+				length += String(start).length;
+				if (start !== end) length += 1 + String(end).length;
+			}
+		} else length += typeof value === "string" ? quotedAttributeLength(value) : String(value).length;
+	}
+	return length;
+}
+function assertCanonicalAttributeLimit(options) {
+	const length = canonicalAttributeLength(options);
+	if (!length) fail("metadata", "Code presentation requires at least one authored option");
+	if (length > CODE_PRESENTATION_LIMITS.metadataLength) throw new ContentLimitError("Code presentation attributes exceed the 16384 UTF-16 unit limit");
+	return length;
+}
+/** Source writers can reserve escaped header growth before any string emission. */
+function codePresentationMetadataLength(options, opaqueMetaSuffix) {
+	const normalized = normalizeCodePresentationOptions(options, CODE_PRESENTATION_LIMITS.rows);
+	assertCodePresentationSuffix(opaqueMetaSuffix);
+	return assertCanonicalAttributeLimit(normalized) + encodedSuffixLength(opaqueMetaSuffix);
+}
+/** Returns a raw fence header. Do not pass it through Markdown unescaping or safe(). */
+function serializeCodePresentationMetadata(options, opaqueMetaSuffix) {
+	const normalized = normalizeCodePresentationOptions(options, CODE_PRESENTATION_LIMITS.rows);
+	const attributeLength = assertCanonicalAttributeLimit(normalized);
+	assertCodePresentationSuffix(opaqueMetaSuffix);
+	if (attributeLength + encodedSuffixLength(opaqueMetaSuffix) > CONTENT_LIMITS.sourceLength) throw new ContentLimitError("Code presentation metadata exceeds the source length limit");
+	const members = [];
+	for (const key of CODE_PRESENTATION_OPTION_KEYS) {
+		if (!Object.hasOwn(normalized, key)) continue;
+		const value = normalized[key];
+		const name = key === "lineNumbers" ? "lines" : key;
+		if (typeof value === "boolean" && value) {
+			members.push(name);
+			continue;
+		}
+		const encoded = Array.isArray(value) ? quoteAttribute(selectionSource(value)) : typeof value === "string" ? quoteAttribute(value) : String(value);
+		members.push(`${name}=${encoded}`);
+	}
+	return members.join(" ") + encodeCodePresentationSuffix(opaqueMetaSuffix);
+}
+function effectiveCodePresentationOptions(options) {
+	return {
+		...options,
+		lineNumbers: options.lineNumbers ?? false,
+		startLine: options.startLine ?? 1,
+		wrap: options.wrap ?? false
+	};
+}
+function codePresentationRows(payload) {
+	let count = 1;
+	for (let index = 0; index < payload.length; index++) if (payload[index] === "\n") count++;
+	return count;
+}
+/** Template substitutions are scalar single-line text, so literals define physical rows. */
+function codePresentationChildRows(child) {
+	if (child.type === "code") return codePresentationRows(typeof child.value === "string" ? child.value : "");
+	let count = 1;
+	const segments = child.template?.segments;
+	if (!Array.isArray(segments)) return count;
+	for (const segment of segments) if (segment?.type === "literal" && typeof segment.value === "string") count += codePresentationRows(segment.value) - 1;
+	return count;
+}
+/** Run after the document's descriptor/plain-data admission and before callbacks. */
+function codePresentationProblem(node, seen = /* @__PURE__ */ new Set()) {
+	try {
+		if (Object.keys(node).some((key) => ![
+			"type",
+			"children",
+			"options",
+			"opaqueMetaSuffix",
+			"position",
+			"data"
+		].includes(key)) || !Array.isArray(node.children) || node.children.length !== 1 || !["code", "topikCodeTemplate"].includes(node.children[0]?.type)) fail("scope", "A code presentation must own exactly one code or code-template child");
+		const child = node.children[0];
+		if (child.meta != null) fail("metadata", "Presentation options and opaque suffix are authoritative; child metadata must be absent");
+		if (child.lang != null && (typeof child.lang !== "string" || !child.lang || containsControls(child.lang) || child.lang.includes(" "))) fail("language", "Presented code language must fit one literal fence header word");
+		if (child.lang === "mermaid") fail("language", "Presented code requires a text code renderer");
+		if (child.type === "topikCodeTemplate") {
+			const problem = codeTemplateProblem(child);
+			if (problem) return problem;
+		}
+		assertCanonicalAttributeLimit(normalizeCodePresentationOptions(node.options, codePresentationChildRows(child)));
+		const claim = (value) => {
+			if (seen.has(value)) fail("metadata", "Code presentation data must not be shared between authoring positions");
+			seen.add(value);
+		};
+		claim(node.options);
+		for (const value of Object.values(node.options)) if (Array.isArray(value)) {
+			claim(value);
+			for (const interval of value) claim(interval);
+		}
+		assertCodePresentationSuffix(node.opaqueMetaSuffix);
+	} catch (error) {
+		if (error instanceof CodePresentationError || error instanceof ContentLimitError) return {
+			id: error.id,
+			message: error.message,
+			...error instanceof CodePresentationError && error.option !== void 0 ? { option: error.option } : {}
+		};
+		throw error;
+	}
+}
+//#endregion
+//#region src/presentation-output.ts
+/**
+* Reserve a conservative serialization budget before allocating reader rows.
+* Each text unit can expand to six HTML units; each row reserves 768 units for
+* its number, diff meaning, state classes and surrounding elements. Each
+* independent collapse region reserves another 768 units for its visible control. Syntax
+* highlighting is optional and must fall back when its tokens exceed a budget.
+*/
+function assertCodePresentationOutputLimit(document) {
+	let length = 0;
+	const stack = [document];
+	while (stack.length) {
+		const node = stack.pop();
+		if (node.type === "topikCodePresentation") {
+			const child = node.children?.[0];
+			let rows = 1;
+			let payloadLength = 0;
+			function measure(value) {
+				payloadLength += value.length;
+				for (let index = 0; index < value.length; index++) if (value.charCodeAt(index) === 10) rows++;
+			}
+			if (child?.type === "code") measure(child.value ?? "");
+			else for (const segment of child?.template?.segments ?? []) if (segment.type === "literal") measure(segment.value);
+			const collapseRegions = node.options?.collapse ? normalizeCodePresentationOptions(node.options, rows).collapse.length : 0;
+			length += payloadLength * 6 + (rows + collapseRegions) * 768 + 4096;
+			length += (child?.lang?.length ?? 0) * 6;
+			length += ((node.options?.title?.length ?? 0) + (node.options?.filename?.length ?? 0)) * 6;
+			if (length > CONTENT_LIMITS.presentationOutputLength) throw new ContentLimitError("Presented code exceeds the generated markup limit");
+		}
+		for (const child of node.children ?? []) stack.push(child);
+	}
+}
+//#endregion
+//#region src/document-index.ts
+function referenceIdentifier(identifier) {
+	return identifier.replace(/[\t\n\r ]+/gu, " ").replace(/^ | $/gu, "").toLowerCase().toUpperCase().toLowerCase();
+}
+/** Keep source escapes intact: decoded labels can identify a different definition. */
+function referenceSourceLabel(node) {
+	return (node.label && referenceIdentifier(node.label) === referenceIdentifier(node.identifier) ? node.label : node.identifier).replace(/[\t\n\r ]+/gu, " ").replace(/^ | $/gu, "");
+}
+/** One bounded traversal shared by validation, asset processing, and source analysis. */
+function indexDocument(document) {
+	assertDataLimits(document, { plain: true });
+	assertTreeLimits(document);
+	const entries = [];
+	const scopes = /* @__PURE__ */ new Map();
+	const rootScope = { definitions: /* @__PURE__ */ new Map() };
+	function visit(node, path, scope, parent) {
+		if (node.type === "topikBranch") scope = {
+			parent: scope,
+			definitions: /* @__PURE__ */ new Map()
+		};
+		entries.push({
+			node,
+			path,
+			scope,
+			parent
+		});
+		scopes.set(node, scope);
+		if (node.type === "definition") {
+			const definition = node;
+			const key = referenceIdentifier(definition.identifier);
+			if (!scope.definitions.has(key)) scope.definitions.set(key, definition);
+		}
+		for (const [index, child] of (node.children ?? []).entries()) visit(child, [...path, index], scope, node);
+	}
+	visit(document, [], rootScope);
+	return {
+		entries,
+		resolve(reference) {
+			const key = referenceIdentifier(reference.identifier);
+			for (let scope = scopes.get(reference); scope; scope = scope.parent) {
+				const definition = scope.definitions.get(key);
+				if (definition) return definition;
+			}
+		}
+	};
+}
+function isReference(node) {
+	return node.type === "imageReference" || node.type === "linkReference";
+}
+/** Bind before pruning branches so evaluation cannot change an authored destination. */
+function materializeReferences(document, index = indexDocument(document)) {
+	for (const { node } of index.entries) {
+		if (!isReference(node)) continue;
+		const definition = index.resolve(node);
+		if (!definition) throw new Error(`Reference ${node.identifier} has no definition in its scope`);
+		const resource = node;
+		resource.type = node.type === "imageReference" ? "image" : "link";
+		resource.url = definition.url;
+		resource.title = definition.title ?? null;
+		delete resource.identifier;
+		delete resource.label;
+		delete resource.referenceType;
+	}
+}
+//#endregion
+//#region src/validation.ts
+function issue(id, message) {
+	return {
+		id,
+		message
+	};
+}
+function kebab(name) {
+	return name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+function hasControl$1(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code < 32 || code === 127) return true;
+	}
+	return false;
+}
+/** Validate the literal source form and properties before tree-level checks. */
+function validateTag(tag, registry, templateData = /* @__PURE__ */ new Set()) {
+	const definition = Object.hasOwn(registry, tag.name) ? registry[tag.name] : void 0;
+	if (!definition) return issue("tag-undefined", `Unknown component ${tag.name}`);
+	if (tag.close) return;
+	if (!tag.props || typeof tag.props !== "object" || Array.isArray(tag.props)) return issue("attribute-type-invalid", `Invalid properties on ${tag.name}`);
+	if (definition.kind === "inline" && tag.selfClosing && definition.children !== "none") return issue("topik-tag-children", `Inline component ${tag.name} requires content`);
+	if (definition.kind === "inline" && !tag.selfClosing && definition.children === "none") return issue("topik-tag-children", `Inline component ${tag.name} must be self-closing`);
+	if (definition.kind === "block" && tag.selfClosing && definition.children !== "none" && !definition.selfClosing) return issue("topik-tag-children", `Block component ${tag.name} cannot be self-closing`);
+	if (definition.kind === "block" && !tag.selfClosing && definition.children === "none") return issue("topik-tag-children", `Block component ${tag.name} must be self-closing`);
+	for (const [key, value] of Object.entries(tag.props)) {
+		const attr = Object.hasOwn(definition.attributes, key) ? definition.attributes[key] : void 0;
+		if (!attr) return issue("attribute-undefined", `Unknown attribute ${key} on ${tag.name}`);
+		if (value !== null && typeof value === "object" && value.type === "topikTextTemplate") {
+			const canonicalDefinition = Object.hasOwn(components, tag.name) ? components[tag.name] : void 0;
+			const canonical = canonicalDefinition?.attributes[key];
+			if (definition.kind !== canonicalDefinition?.kind || attr.type !== "string" || attr.interpolation !== "text" || attr.asset || attr.assetReference || canonical?.type !== "string" || canonical.interpolation !== "text") return issue("topik-template-location", `Attribute ${key} on ${tag.name} is literal-only`);
+			const invalid = textTemplateProblem(value, false, templateData);
+			if (invalid) return invalid;
+			continue;
+		}
+		if (typeof value !== (attr.type === "enum" ? "string" : attr.type)) return issue("attribute-type-invalid", `Attribute ${key} on ${tag.name} must be a ${attr.type === "enum" ? "string" : attr.type}`);
+		if (typeof value === "string" && hasControl$1(attr.type === "string" && attr.escapedWhitespace ? value.replace(/[\t\n\r]/g, "") : value)) return issue("attribute-value-invalid", `Control character in ${key} on ${tag.name}`);
+		if (attr.type === "enum" && !attr.values.includes(value)) return issue("attribute-value-invalid", `Invalid ${key} on ${tag.name}`);
+		if (attr.type === "number") {
+			const numeric = value;
+			if (!Number.isFinite(numeric)) return issue("attribute-value-invalid", `Invalid ${key} on ${tag.name}`);
+			if (attr.integer && !Number.isInteger(numeric) || attr.min !== void 0 && numeric < attr.min || attr.max !== void 0 && numeric > attr.max) return issue(`topik-${kebab(key)}-range`, `Invalid ${key} on ${tag.name}`);
+		}
+	}
+	for (const [key, attr] of Object.entries(definition.attributes)) if (attr.required && !Object.hasOwn(tag.props, key)) return issue("attribute-missing-required", `Missing attribute ${key} on ${tag.name}`);
+}
+function diagnostic(problem, marker, id) {
+	return {
+		...typeof problem === "string" ? {
+			message: problem,
+			...id ? { id } : {}
+		} : problem,
+		line: marker?.position?.start?.line,
+		column: marker?.position?.start?.column
+	};
+}
+function matchesConstraint(child, constraint) {
+	if ("components" in constraint) return child.type === "topikComponent" && constraint.components.includes(child.name);
+	return constraint.nodes.includes(child.type);
+}
+function validateChildren(component, registry) {
+	const constraint = registry[component.name]?.children;
+	if (!constraint) return [];
+	const children = component.children;
+	const name = component.name;
+	if (constraint === "none") return children.length ? [issue(`topik-${kebab(name)}-children`, `${name} cannot contain children`)] : [];
+	if (constraint === "blocks") return children.some((child) => !isContentKind(child, "block", registry)) ? [issue(`topik-${kebab(name)}-children`, `${name} may contain only block children`)] : [];
+	if (constraint === "inline") {
+		if (!children.length) return [issue(`topik-${kebab(name)}-children`, `${name} requires inline children`)];
+		return children.some((child) => !isContentKind(child, "inline", registry)) ? [issue(`topik-${kebab(name)}-children`, `${name} may contain only inline children`)] : [];
+	}
+	const errors = [];
+	if (children.some((child) => !matchesConstraint(child, constraint))) errors.push(issue(`topik-${kebab(name)}-children`, `${name} may contain only ${("components" in constraint ? constraint.components : constraint.nodes).join(", ")} children`));
+	if (children.length < (constraint.min ?? 0)) {
+		const required = "components" in constraint ? constraint.components[0] : constraint.nodes[0] === "code" ? "fence" : constraint.nodes[0];
+		errors.push(issue(`topik-${kebab(name)}-requires-${kebab(required)}`, `${name} requires at least one ${required} child`));
+	}
+	return errors;
+}
+function validatePlacement(component, parent, registry) {
+	const definition = registry[component.name];
+	if (!definition) return [];
+	const errors = [];
+	if (definition.allowedParents && !(parent?.type === "topikComponent" && definition.allowedParents.includes(parent.name))) {
+		const required = definition.allowedParents[0];
+		errors.push(issue(`topik-${kebab(required)}-parent-required`, `${component.name} must be inside ${definition.allowedParents.join(", ")}`));
+	}
+	if (!parent) return errors;
+	const parentIsInline = isInlineParent(parent, registry);
+	if (definition.kind === "block" && parentIsInline) errors.push(issue("topik-tag-placement", `Block ${component.name} has invalid placement`));
+	if (definition.kind === "inline" && !parentIsInline) errors.push(issue("topik-tag-placement", `Inline ${component.name} has invalid placement`));
+	return errors;
+}
+function validateDocument(document, registry = components) {
+	return validateDocumentWithIndex(document, registry).diagnostics;
+}
+/** @internal Keep the reference index available to the source admission pipeline. */
+function validateDocumentWithIndex(document, registry) {
+	try {
+		assertDataLimits(document, { plain: true });
+		assertTreeLimits(document);
+	} catch (error) {
+		if (error instanceof ContentLimitError) return { diagnostics: [limitDiagnostic(error)] };
+		if (error instanceof ContentDataError) return { diagnostics: [{
+			id: error.id,
+			message: error.message
+		}] };
+		throw error;
+	}
+	const errors = [];
+	const templateData = /* @__PURE__ */ new Set();
+	const presentationData = /* @__PURE__ */ new Set();
+	const parents = /* @__PURE__ */ new WeakMap();
+	const callbacks = [];
+	function add(problem, node, id) {
+		errors.push(diagnostic(problem, node, id));
+	}
+	if (document?.type !== "root") return { diagnostics: [{
+		id: "topik-node-invalid",
+		message: "Content documents require a root node"
+	}] };
+	function walk(node, parent, insideLink = false, marks = {
+		emphasis: 0,
+		strong: 0,
+		delete: 0
+	}) {
+		if (parent) parents.set(node, parent);
+		const shapeProblem = nodeShapeProblem(node, registry);
+		if (shapeProblem) {
+			add(shapeProblem, node, "topik-node-invalid");
+			return;
+		}
+		if (!nodeTypes.has(node.type)) add(`Unsupported Markdown node ${node.type}`, node, "node-undefined");
+		if (node.type === "emphasis" || node.type === "strong" || node.type === "delete") marks = {
+			...marks,
+			[node.type]: marks[node.type] + 1
+		};
+		if (marks.emphasis > 2 || marks.strong > 2 || marks.delete > 1) {
+			add(marks.delete > 1 ? "Strikethrough marks cannot be nested" : "Emphasis and strong marks support at most two nesting levels per kind", node, "topik-mark-nesting");
+			return;
+		}
+		if (node.type === "root" && parent) add("Root nodes cannot be nested", node, "topik-node-invalid");
+		const link = node.type === "link" || node.type === "linkReference";
+		if (link && insideLink) add("Links cannot contain other links", node, "topik-node-invalid");
+		if (node.type === "yaml" && (parent?.type !== "root" || parent.children?.[0] !== node)) add("YAML frontmatter must be the first root child", node, "topik-frontmatter-placement");
+		if (node.type === "paragraph" && !node.children?.length) add("Empty paragraphs have no faithful Markdown representation", node, "topik-empty-paragraph");
+		if (node.type === "topikVariable") {
+			if (!validPath(node.path)) add("Invalid variable path", node, "topik-variable-path");
+			if (!parent || !isInlineParent(parent, registry)) add("Variable has invalid placement", node, "topik-variable-placement");
+		}
+		if (node.type === "topikCodeTemplate") {
+			const invalid = codeTemplateProblem(node, templateData);
+			if (invalid) add(invalid, node);
+		}
+		if (node.type === "topikConditional") {
+			const branches = node.children ?? [];
+			if (!parent || !(parent.type === "root" || parent.type === "blockquote" || parent.type === "listItem" || parent.type === "topikBranch" || parent.type === "topikComponent" && registry[parent.name]?.children === "blocks")) add("Conditional has invalid block placement", node, "topik-conditional-placement");
+			if (branches.length < 1 || branches.length > 2 || branches[0]?.type !== "topikBranch" || branches[0]?.condition == null || branches[1] && (branches[1].type !== "topikBranch" || branches[1].condition !== null)) add("Invalid conditional branches", node, "topik-conditional-branches");
+		}
+		if (node.type === "topikBranch") {
+			if (parent?.type !== "topikConditional") add("Branch must be inside a conditional", node, "topik-conditional-branches");
+			const branch = node;
+			if (branch.condition !== null) try {
+				writeExpression(branch.condition);
+			} catch (error) {
+				add(error.message, node, error instanceof ContentLimitError ? error.id : "topik-expression-invalid");
+			}
+			if ((node.children ?? []).some((child) => !isContentKind(child, "block", registry))) add("Conditional branches may contain only block children", node, "topik-conditional-children");
+		}
+		const errorsBeforeChildren = errors.length;
+		for (const child of node.children ?? []) walk(child, node, insideLink || link, marks);
+		const childrenValid = errors.length === errorsBeforeChildren;
+		if (node.type === "topikCodePresentation" && childrenValid) {
+			const invalid = codePresentationProblem(node, presentationData);
+			if (invalid) add(invalid, node);
+		}
+		if (node.type === "topikComponent") {
+			const component = node;
+			const invalid = validateTag({
+				name: component.name,
+				close: false,
+				selfClosing: registry[component.name]?.children === "none",
+				props: component.props
+			}, registry, templateData);
+			if (invalid) add(invalid, node);
+			for (const problem of [...validateChildren(component, registry), ...validatePlacement(component, parent, registry)]) add(problem, node);
+			const definition = registry[component.name];
+			if (definition?.validate && !invalid && childrenValid) {
+				const invoke = () => definition.validate(component, getEffectiveProps(component, registry));
+				if (definition.validate === components[component.name]?.validate) for (const problem of invoke()) add(problem, node);
+				else callbacks.push({
+					node,
+					invoke
+				});
+			}
+		}
+	}
+	walk(document);
+	if (errors.length === 0) try {
+		assertCodePresentationOutputLimit(document);
+	} catch (error) {
+		if (!(error instanceof ContentLimitError)) throw error;
+		errors.push(limitDiagnostic(error));
+	}
+	if (errors.length === 0) {
+		const invalidSubtrees = /* @__PURE__ */ new Set();
+		for (const { node, invoke } of callbacks) {
+			if (invalidSubtrees.has(node)) continue;
+			const problems = invoke();
+			for (const problem of problems) add(problem, node);
+			if (problems.length) {
+				let ancestor = node;
+				while (ancestor) {
+					invalidSubtrees.add(ancestor);
+					ancestor = parents.get(ancestor);
+				}
+			}
+		}
+	}
+	let index;
+	if (errors.length === 0) {
+		index = indexDocument(document);
+		for (const { node } of index.entries) {
+			if (isReference(node)) {
+				if (!index.resolve(node)) add("Reference has no definition in its conditional scope", node, "topik-reference-missing");
+			}
+			if (isReference(node) || node.type === "definition") {
+				const label = referenceSourceLabel(node);
+				if (!label || label.length > 999 || !/^(?:\\[\s\S]|[^[\]\\])+$/u.test(label)) add("Reference identifier has no faithful Markdown label", node, "topik-reference-label");
+			}
+		}
+	}
+	return {
+		diagnostics: errors,
+		index
+	};
+}
+//#endregion
+//#region src/document-meaning.ts
+/** Compare admitted authoring trees, retaining explicit heading IDs and every authored branch.
+* Source positions, cosmetic spelling and derived metadata do not affect equality.
+* This compares meaning; it does not validate arbitrary caller-constructed trees.
+*/
+function sameDocumentMeaning(left, right) {
+	return equal(meaning(left), meaning(right));
+}
+function meaning(node) {
+	const fields = { ...node };
+	delete fields.position;
+	delete fields.data;
+	delete fields.children;
+	for (const key of Object.keys(fields)) if (fields[key] === void 0) delete fields[key];
+	if (node.type === "heading") fields.topikId = node.data?.topikId ?? null;
+	if (node.type === "link" || node.type === "image" || node.type === "definition") fields.title ??= null;
+	if (node.type === "image" || node.type === "imageReference") fields.alt ??= "";
+	if (node.type === "code" || node.type === "topikCodeTemplate") {
+		fields.lang ??= null;
+		fields.meta ??= null;
+	}
+	if (node.type === "topikCodeTemplate") fields.template = templateMeaning(node.template);
+	if (node.type === "topikCodePresentation") fields.options = normalizeCodePresentationOptions(node.options, codePresentationChildRows(node.children[0]));
+	if (node.type === "topikComponent" && node.props) fields.props = Object.fromEntries(Object.entries(node.props).map(([key, value]) => [key, typeof value === "object" ? templateMeaning(value) : value]));
+	if ([
+		"definition",
+		"linkReference",
+		"imageReference"
+	].includes(node.type)) {
+		fields.identifier = referenceIdentifier(fields.identifier);
+		delete fields.label;
+		delete fields.referenceType;
+	}
+	if (node.type === "list") {
+		fields.ordered ??= false;
+		fields.start = fields.ordered ? fields.start ?? 1 : null;
+		fields.spread = fields.spread === true || (node.children ?? []).some((item) => {
+			return item.spread ?? (item.children?.length ?? 0) > 1;
+		});
+	}
+	if (node.type === "listItem") {
+		delete fields.spread;
+		fields.checked ??= null;
+	}
+	if (node.type === "table") fields.align ??= Array.from({ length: node.children?.[0]?.children?.length ?? 0 }, () => null);
+	if (node.children) {
+		const children = [];
+		for (const child of node.children) {
+			const next = meaning(child);
+			const previous = children.at(-1);
+			if (previous?.type === "text" && next.type === "text") previous.value = String(previous.value) + String(next.value);
+			else children.push(next);
+		}
+		fields.children = children;
+	}
+	return fields;
+}
+function templateMeaning(template) {
+	const segments = [];
+	for (const segment of template.segments) if (segment.type === "literal") {
+		if (!segment.value) continue;
+		const previous = segments.at(-1);
+		if (previous?.type === "literal") previous.value += segment.value;
+		else segments.push({
+			type: "literal",
+			value: segment.value
+		});
+	} else segments.push({
+		type: "variable",
+		path: segment.path
+	});
+	return {
+		type: "topikTextTemplate",
+		segments
+	};
+}
+function equal(left, right) {
+	if (Object.is(left, right)) return true;
+	if (!left || !right || typeof left !== "object" || typeof right !== "object") return false;
+	if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => equal(value, right[index]));
+	const a = left;
+	const b = right;
+	const keys = Object.keys(a);
+	return keys.length === Object.keys(b).length && keys.every((key) => Object.hasOwn(b, key) && equal(a[key], b[key]));
+}
+//#endregion
+//#region src/tag-options.ts
+/** Parser and writer share the exact registry attribute admission. */
+function tagOptions(registry) {
+	return {
+		expressions: true,
+		escapedWhitespace: Object.fromEntries(Object.entries(registry).map(([name, definition]) => [name, Object.entries(definition.attributes).filter(([, attribute]) => attribute.type === "string" && attribute.escapedWhitespace).map(([key]) => key)]))
+	};
+}
+//#endregion
+//#region src/gfm.ts
+function gfmSyntax() {
+	return [
+		gfmFootnote(),
+		gfmStrikethrough(),
+		gfmTable(),
+		gfmTaskListItem()
+	];
+}
+function gfmFromMarkdown() {
+	return [
+		gfmFootnoteFromMarkdown(),
+		gfmStrikethroughFromMarkdown(),
+		gfmTableFromMarkdown(),
+		gfmTaskListItemFromMarkdown()
+	];
+}
+function gfmToMarkdown() {
+	return { extensions: [
+		gfmFootnoteToMarkdown(),
+		gfmStrikethroughToMarkdown(),
+		gfmTableToMarkdown(),
+		gfmTaskListItemToMarkdown()
+	] };
+}
+//#endregion
+//#region src/heading-ids.ts
+const validId = /^[A-Za-z0-9_.:-]+$/;
+/** An independent inline construct, claimed before generic tag tokenization. */
+function headingIdSyntax() {
+	const tokenize = (effects, ok, nok) => {
+		let value = "";
+		return start;
+		function start(code) {
+			if (code !== 123) return nok(code);
+			effects.enter("topikHeadingId");
+			effects.consume(code);
+			return percent;
+		}
+		function percent(code) {
+			if (code !== 37) return nok(code);
+			effects.consume(code);
+			return hash;
+		}
+		function hash(code) {
+			if (code === 32 || code === -2 || code === -1) {
+				effects.consume(code);
+				return hash;
+			}
+			if (code !== 35) return nok(code);
+			effects.consume(code);
+			return id;
+		}
+		function id(code) {
+			if (code !== null && code > 0 && /^[A-Za-z0-9_.:-]$/.test(String.fromCharCode(code))) {
+				value += String.fromCharCode(code);
+				effects.consume(code);
+				return id;
+			}
+			if (!value) return nok(code);
+			return closePercent(code);
+		}
+		function closePercent(code) {
+			if (code === 32 || code === -2 || code === -1) {
+				effects.consume(code);
+				return closePercent;
+			}
+			if (code !== 37) return nok(code);
+			effects.consume(code);
+			return close;
+		}
+		function close(code) {
+			if (code !== 125) return nok(code);
+			effects.consume(code);
+			effects.exit("topikHeadingId");
+			return ok;
+		}
+	};
+	return { text: { 123: { tokenize } } };
+}
+function headingIdFromMarkdown() {
+	return {
+		enter: { topikHeadingId(token) {
+			const value = this.sliceSerialize(token).slice(2, -2).trim().slice(1);
+			this.enter({
+				type: "topikHeadingId",
+				value
+			}, token);
+		} },
+		exit: { topikHeadingId(token) {
+			this.exit(token);
+		} },
+		transforms: [(root) => {
+			function walk(node) {
+				for (const child of node.children ?? []) walk(child);
+				if (node.type !== "heading") return;
+				const marker = node.children?.at(-1);
+				if (marker?.type !== "topikHeadingId") return;
+				const heading = node;
+				heading.data = {
+					...heading.data,
+					topikId: marker.value
+				};
+				heading.children.pop();
+				const preceding = heading.children.at(-1);
+				if (preceding?.type === "text") {
+					preceding.value = preceding.value.replace(/[ \t]+$/, "");
+					if (!preceding.value) heading.children.pop();
+				}
+			}
+			walk(root);
+			return root;
+		}]
+	};
+}
+function headingIdToMarkdown() {
+	return { handlers: {
+		heading(node, parent, state, info) {
+			const id = node.data?.topikId;
+			if (id === void 0) return defaultHandlers.heading(node, parent, state, info);
+			if (typeof id !== "string" || !validId.test(id)) throw new Error("Invalid heading ID");
+			const children = [...node.children];
+			if (children.length) children.push({
+				type: "text",
+				value: " "
+			});
+			children.push({
+				type: "topikHeadingId",
+				value: id
+			});
+			return defaultHandlers.heading({
+				...node,
+				children
+			}, parent, state, info);
+		},
+		topikHeadingId(node) {
+			return `{% #${node.value} %}`;
+		}
+	} };
+}
+//#endregion
+//#region src/reference-source.ts
+const references = /* @__PURE__ */ new WeakMap();
+function referenceSourceExtension() {
+	return { enter: {
+		resourceDestinationString(token) {
+			references.set(this.stack.at(-1), this.sliceSerialize(token));
+			this.buffer();
+		},
+		definitionDestinationString(token) {
+			references.set(this.stack.at(-1), this.sliceSerialize(token));
+			this.buffer();
+		}
+	} };
+}
+function exactReference(node, source) {
+	const recorded = references.get(node);
+	if (recorded !== void 0) return recorded;
+	const start = node.position?.start.offset;
+	const end = node.position?.end.offset;
+	if (start === void 0 || end === void 0) return;
+	const spelling = source.slice(start, end);
+	if (spelling === `<${node.url}>`) return node.url;
+	if (node.url.startsWith("mailto:") && spelling === `<${node.url.slice(7)}>`) return node.url;
+}
+function sourceKey(node) {
+	const start = node.position?.start.offset;
+	const end = node.position?.end.offset;
+	if (start !== void 0 && end !== void 0) return `${node.type}:${start}:${end}`;
+}
+/** Recover copied nodes' evidence once, using the same parser and original source positions. */
+function createReferenceSourceLookup(source, reparse) {
+	let recovered;
+	return (node) => {
+		const recorded = exactReference(node, source);
+		if (recorded !== void 0) return recorded;
+		const key = sourceKey(node);
+		if (key === void 0) return "";
+		if (recovered === void 0) {
+			recovered = /* @__PURE__ */ new Map();
+			try {
+				for (const { node: original } of reparse().entries) {
+					if (!("url" in original) || typeof original.url !== "string") continue;
+					const key = sourceKey(original);
+					const reference = exactReference(original, source);
+					if (key !== void 0 && reference !== void 0) recovered.set(key, {
+						url: original.url,
+						reference
+					});
+				}
+			} catch {}
+		}
+		const match = recovered.get(key);
+		return match?.url === node.url ? match.reference : "";
+	};
+}
+//#endregion
+//#region src/parser-limits.ts
+/** Refuse expensive syntax before micromark resolves containers and inline delimiters. */
+function parserLimitSyntax(source) {
+	let steps = 0;
+	const containers = /* @__PURE__ */ new WeakMap();
+	const guard = function(_effects, _ok, nok) {
+		return (code) => {
+			let weight = 1;
+			if (code === 96) {
+				const offset = this.now().offset;
+				while (source[offset + weight] === "`") weight++;
+			}
+			steps += weight;
+			if (steps > CONTENT_LIMITS.parserSteps) throw new ContentLimitError(`Content exceeds the parser step limit of ${CONTENT_LIMITS.parserSteps}`);
+			return nok(code);
+		};
+	};
+	const containerGuard = function(_effects, _ok, nok) {
+		return (code) => {
+			const events = this.events;
+			const previous = containers.get(this);
+			const state = previous && previous.index <= events.length && events[previous.index - 1] === previous.last ? previous : {
+				index: 0,
+				last: void 0,
+				depth: 0
+			};
+			for (; state.index < events.length; state.index++) {
+				const [action, token] = events[state.index];
+				const weight = token.type === "blockQuote" ? 1 : token.type === "listOrdered" || token.type === "listUnordered" ? 2 : 0;
+				state.depth += action === "enter" ? weight : -weight;
+			}
+			state.last = events.at(-1);
+			containers.set(this, state);
+			if (state.depth >= CONTENT_LIMITS.treeDepth) throw new ContentLimitError(`Content exceeds the tree depth limit of ${CONTENT_LIMITS.treeDepth}`);
+			return nok(code);
+		};
+	};
+	return {
+		document: Object.fromEntries("*+->0123456789".split("").map((marker) => [marker.charCodeAt(0), { tokenize: containerGuard }])),
+		text: {
+			...Object.fromEntries("!*[_~".split("").map((marker) => [marker.charCodeAt(0), { tokenize: guard }])),
+			96: {
+				tokenize: guard,
+				previous(code) {
+					return code !== 96 || this.events.at(-1)?.[1].type === "characterEscape";
+				}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/line-endings.ts
+/** Normalize source syntax, leaving entity-decoded characters and original locations distinct. */
+function normalizeLineEndings(source) {
+	const crlfOffsets = [];
+	const normalized = source.replace(/\r\n?/g, (ending, offset) => {
+		if (ending.length === 2) crlfOffsets.push(offset - crlfOffsets.length);
+		return "\n";
+	});
+	function originalOffset(offset) {
+		let low = 0;
+		let high = crlfOffsets.length;
+		while (low < high) {
+			const middle = low + high >>> 1;
+			if (crlfOffsets[middle] < offset) low = middle + 1;
+			else high = middle;
+		}
+		return offset + low;
+	}
+	function restorePositions(node) {
+		if (crlfOffsets.length === 0) return;
+		const position = node.position;
+		if (position) node.position = {
+			start: {
+				...position.start,
+				...position.start.offset === void 0 ? {} : { offset: originalOffset(position.start.offset) }
+			},
+			end: {
+				...position.end,
+				...position.end.offset === void 0 ? {} : { offset: originalOffset(position.end.offset) }
+			}
+		};
+		for (const child of node.children ?? []) restorePositions(child);
+	}
+	return {
+		source: normalized,
+		restorePositions
+	};
+}
+//#endregion
+//#region src/parser.ts
+function declarations(registry) {
+	return Object.fromEntries(Object.entries(registry).map(([name, definition]) => [name, { kind: definition.kind }]));
+}
+function convertTags(root, registry, rawHeaders) {
+	const errors = [];
+	let presentationFailed = false;
+	function walk(node) {
+		if (!node.children) return;
+		node.children = node.children.map((originalChild) => {
+			let child = originalChild;
+			walk(child);
+			if (child.type === "tagVariable") return {
+				type: "topikVariable",
+				path: String(child.path).split("."),
+				position: child.position
+			};
+			if (child.type === "tagBranch") {
+				if (typeof child.condition === "string") try {
+					child.condition = parseExpression(child.condition);
+				} catch (error) {
+					if (error instanceof ContentLimitError) throw error;
+					errors.push(diagnostic(error.message, child));
+				}
+				return {
+					...child,
+					type: "topikBranch"
+				};
+			}
+			if (child.type === "tagConditional") return {
+				...child,
+				type: "topikConditional"
+			};
+			if (child.type === "tagCodeTemplate") child = {
+				type: "topikCodeTemplate",
+				lang: child.lang,
+				meta: child.meta,
+				template: child.template,
+				position: child.position
+			};
+			if (child.type === "code" || child.type === "topikCodeTemplate") {
+				const rawHeader = rawHeaders?.get(originalChild);
+				if (rawHeader === void 0) return child;
+				const unlabelled = /^(?:(?:lines|wrap)(?:[ \t=]|$)|(?:filename|title|startLine|highlight|focus|collapse|added|removed)[ \t]*=)/.test(rawHeader);
+				const rawMeta = unlabelled ? rawHeader : rawHeader.replace(/^[^ \t]+[ \t]*/, "");
+				try {
+					const presentation = parseCodePresentationMetadata(rawMeta, codePresentationChildRows(child));
+					if (!presentation) return child;
+					if (unlabelled) child.lang = null;
+					delete child.meta;
+					return {
+						type: "topikCodePresentation",
+						...presentation,
+						children: [child],
+						position: child.position
+					};
+				} catch (error) {
+					if (!(error instanceof CodePresentationError)) throw error;
+					presentationFailed = true;
+					errors.push(diagnostic({
+						id: error.id,
+						message: error.message,
+						...error.option ? { option: error.option } : {}
+					}, child));
+					return child;
+				}
+			}
+			if (![
+				"tagText",
+				"tagLeaf",
+				"tagContainer"
+			].includes(child.type)) return child;
+			const props = {};
+			for (const [key, value] of Object.entries(child.attributes ?? {})) if (value !== null && value !== void 0) props[key] = value;
+			const definition = child.name && Object.hasOwn(registry, child.name) ? registry[child.name] : void 0;
+			const invalid = validateTag({
+				name: child.name ?? "",
+				close: false,
+				selfClosing: child.type === "tagLeaf" || child.type === "tagText" && definition?.children === "none",
+				props
+			}, registry);
+			if (invalid) errors.push(diagnostic(invalid, child));
+			if (child.type === "tagLeaf" && child.children?.length) errors.push(diagnostic(`Leaf component ${child.name} cannot contain children`, child));
+			return {
+				type: "topikComponent",
+				name: child.name,
+				props,
+				children: child.children ?? [],
+				position: child.position
+			};
+		});
+	}
+	walk(root);
+	if (presentationFailed) throw new TagSyntaxError(errors);
+	return errors;
+}
+const FORMAT_VERSION = 1;
+/** Parse and convert even when semantic validation fails; syntax failures omit the tree. */
+function parseDocumentTree(source, registry = components, formatVersion = 1) {
+	if (formatVersion !== 1) return {
+		diagnostics: [{
+			id: "topik-format-version",
+			message: `Unsupported format version ${formatVersion}`
+		}],
+		source
+	};
+	let tree;
+	try {
+		assertSourceLimit(source);
+		const normalized = normalizeLineEndings(source);
+		const rawHeaders = /* @__PURE__ */ new WeakMap();
+		const syntaxOptions = {
+			...tagOptions(registry),
+			fencedCodeHeaders: rawHeaders
+		};
+		tree = fromMarkdown(normalized.source, {
+			extensions: [
+				frontmatter(),
+				...gfmSyntax(),
+				tagSyntax(declarations(registry), syntaxOptions),
+				headingIdSyntax(),
+				parserLimitSyntax(normalized.source)
+			],
+			mdastExtensions: [
+				{ transforms: [(root) => {
+					assertTreeLimits(root);
+					return root;
+				}] },
+				...gfmFromMarkdown(),
+				frontmatterFromMarkdown(),
+				tagFromMarkdown(declarations(registry), syntaxOptions),
+				{ transforms: [(root) => {
+					assertTreeLimits(root);
+					return root;
+				}] },
+				referenceSourceExtension(),
+				headingIdFromMarkdown(),
+				{ exit: {
+					resourceTitle() {
+						const node = this.stack.at(-1);
+						if (node.title === null) node.title = "";
+					},
+					definitionTitle() {
+						const node = this.stack.at(-1);
+						if (node.title === null) node.title = "";
+					}
+				} }
+			]
+		});
+		const nodeCount = assertTreeLimits(tree);
+		normalized.restorePositions(tree);
+		const tagErrors = convertTags(tree, registry, rawHeaders);
+		normalizeTables(tree, CONTENT_LIMITS.treeNodes - nodeCount);
+		const validated = validateDocumentWithIndex(tree, registry);
+		const errors = tagErrors.concat(validated.diagnostics);
+		return {
+			document: tree,
+			index: validated.index,
+			diagnostics: errors,
+			source
+		};
+	} catch (error) {
+		if (error instanceof ContentLimitError) return {
+			diagnostics: [limitDiagnostic(error)],
+			source
+		};
+		if (error instanceof TagSyntaxError) return {
+			diagnostics: error.diagnostics.map((item) => ({
+				...item,
+				..."id" in item && item.id === "tag-content-limit" ? { id: "topik-content-limit" } : {},
+				...item.message.startsWith("Unknown tag ") ? { id: "tag-undefined" } : {},
+				message: item.message.replace(/^Unknown tag /, "Unknown component ")
+			})),
+			source
+		};
+		throw error;
+	}
+}
+/** GFM missing cells mean empty cells; overflow is retained for an explicit diagnostic. */
+function normalizeTables(root, remainingNodes) {
+	function walk(node) {
+		if (node.type === "table") {
+			const width = node.children?.[0]?.children?.length ?? 0;
+			for (const row of node.children ?? []) {
+				if (!row.children) continue;
+				const missing = Math.max(0, width - row.children.length);
+				if (missing > remainingNodes) throw new ContentLimitError(`Content exceeds the tree node limit of ${CONTENT_LIMITS.treeNodes}`);
+				remainingNodes -= missing;
+				while (row.children.length < width) row.children.push({
+					type: "tableCell",
+					children: []
+				});
+			}
+		}
+		for (const child of node.children ?? []) walk(child);
+	}
+	walk(root);
+}
+//#endregion
+//#region src/markdown-marks.ts
+/** Choose delimiters before writing so handlers and their lookahead agree. */
+function markWriterExtension(root) {
+	const markers = /* @__PURE__ */ new WeakMap();
+	function walk(node, active = {}) {
+		let previous;
+		for (const child of node.children ?? []) {
+			const kind = child.type === "emphasis" || child.type === "strong" ? child.type : void 0;
+			const marker = (previous ?? (kind ? active[kind] : void 0) ?? (kind === "emphasis" && node.type === "strong" && node.children?.length === 1 ? markers.get(node) : void 0)) === "*" ? "_" : "*";
+			if (kind) markers.set(child, marker);
+			walk(child, kind ? {
+				...active,
+				[kind]: marker
+			} : active);
+			previous = kind ? marker : void 0;
+		}
+	}
+	walk(root);
+	function handler(kind) {
+		const attention = defaultHandlers[kind].attention;
+		const handle = (node, parent, state, info) => {
+			const previous = state.options[kind];
+			state.options[kind] = markers.get(node) ?? "*";
+			try {
+				return defaultHandlers[kind](node, parent, state, info);
+			} finally {
+				state.options[kind] = previous;
+			}
+		};
+		const peek = (node) => markers.get(node) ?? "*";
+		return Object.assign(handle, {
+			peek,
+			...attention && { attention: (node, state) => {
+				const previous = state.options[kind];
+				state.options[kind] = markers.get(node) ?? "*";
+				try {
+					return attention(node, state);
+				} finally {
+					state.options[kind] = previous;
+				}
+			} }
+		});
+	}
+	return { handlers: {
+		emphasis: handler("emphasis"),
+		strong: handler("strong")
+	} };
+}
+//#endregion
+//#region src/reference-writer.ts
+/** Escapes and entities are part of reference identity, not decoded Markdown text. */
+function referenceLabel(node, state) {
+	const value = referenceSourceLabel(node);
+	return state.stack.includes("tableCell") ? value.replaceAll("|", "\\|") : value;
+}
+function referenceWriterExtension() {
+	const reference = (untyped, _parent, state, info) => {
+		const node = untyped;
+		const exit = state.enter(node.type);
+		const labelExit = state.enter("label");
+		const tracker = state.createTracker(info);
+		const prefix = tracker.move(node.type === "imageReference" ? "![" : "[");
+		const context = {
+			before: prefix,
+			after: "]",
+			...tracker.current()
+		};
+		const text = node.type === "imageReference" ? state.safe(node.alt ?? "", context) : state.containerPhrasing(node, context);
+		labelExit();
+		const label = referenceLabel(node, state);
+		exit();
+		return `${prefix}${text}]${node.referenceType === "full" || !text || text !== label ? `[${label}]` : node.referenceType === "collapsed" ? "[]" : ""}`;
+	};
+	return { handlers: {
+		linkReference: Object.assign(reference.bind(null), { peek: () => "[" }),
+		imageReference: Object.assign(reference.bind(null), { peek: () => "!" })
+	} };
+}
+//#endregion
+//#region src/resource-writer.ts
+const entity = /&(?:#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/giu;
+/** Escape Markdown syntax, without changing the spelling of ordinary URL bytes. */
+function destination(url, state) {
+	const literal = !url || /[()<>\s]/u.test(url);
+	const escaped = url.replaceAll("\\", "\\\\").replace(entity, (value) => decodeString(value) === value ? value : `\\${value}`).replace(/[<>\n\r]/gu, (value) => value === "\n" ? "&#xa;" : value === "\r" ? "&#xd;" : `\\${value}`);
+	const tableSafe = state.stack.includes("tableCell") ? escaped.replaceAll("|", "\\|") : escaped;
+	return literal ? `<${tableSafe}>` : tableSafe;
+}
+function title(value, state) {
+	if (value == null) return "";
+	const exit = state.enter("titleQuote");
+	try {
+		return ` "${state.safe(value, {
+			before: "\"",
+			after: "\""
+		}).replaceAll("\n", "&#xa;")}"`;
+	} finally {
+		exit();
+	}
+}
+/** A CommonMark autolink is the only lossless source form for some literal URLs. */
+function autolink(node, state) {
+	if (node.title != null || node.children.length !== 1 || node.children[0].type !== "text") return;
+	if (node.children[0].value !== node.url || !/^[a-z][a-z\d+.-]{1,31}:[^\s<>]*$/iu.test(node.url)) return;
+	if (decodeString(node.url) === node.url) return;
+	if (state.stack.includes("tableCell") && node.url.includes("|")) return;
+	return `<${node.url}>`;
+}
+function resourceWriterExtension() {
+	const link = (untyped, _parent, state, info) => {
+		const node = untyped;
+		const literal = autolink(node, state);
+		if (literal !== void 0) return literal;
+		const exit = state.enter("link");
+		const labelExit = state.enter("label");
+		const tracker = state.createTracker(info);
+		let result = tracker.move("[");
+		result += tracker.move(state.containerPhrasing(node, {
+			before: result,
+			after: "](",
+			...tracker.current()
+		}));
+		labelExit();
+		result += `](${destination(node.url, state)}${title(node.title, state)})`;
+		exit();
+		return result;
+	};
+	const image = (untyped, _parent, state, info) => {
+		const node = untyped;
+		const exit = state.enter("image");
+		const labelExit = state.enter("label");
+		const alt = state.safe(node.alt ?? "", {
+			...info,
+			before: "![",
+			after: "]"
+		});
+		labelExit();
+		const result = `![${alt}](${destination(node.url, state)}${title(node.title, state)})`;
+		exit();
+		return result;
+	};
+	const definition = (untyped, _parent, state) => {
+		const node = untyped;
+		const exit = state.enter("definition");
+		const result = `[${referenceLabel(node, state)}]: ${destination(node.url, state)}${title(node.title, state)}`;
+		exit();
+		return result;
+	};
+	Object.assign(link, { peek: () => "[" });
+	Object.assign(image, { peek: () => "!" });
+	return { handlers: {
+		link,
+		image,
+		definition
+	} };
+}
+//#endregion
+//#region src/whitespace-writer.ts
+function boundaryWhitespaceWriterExtension() {
+	return { handlers: { text(node, parent, state, info) {
+		if (parent?.type !== "delete" && parent?.type !== "tableCell" && !node.value.includes("\n")) return defaultHandlers.text(node, parent, state, info);
+		const characters = Array.from(node.value);
+		let first = 0;
+		let last = characters.length;
+		while (first < last && /^\s$/u.test(characters[first])) first++;
+		while (last > first && /^\s$/u.test(characters[last - 1])) last--;
+		const blankLines = /\n[ \t]*\n/.test(node.value);
+		if (first === 0 && last === characters.length && !blankLines) return defaultHandlers.text(node, parent, state, info);
+		const entity = (character) => `&#x${character.codePointAt(0).toString(16)};`;
+		const before = characters.slice(0, first).map(entity).join("");
+		const after = characters.slice(last).map(entity).join("");
+		const middleInfo = {
+			...info,
+			before: before ? ";" : info.before,
+			after: after ? "&" : info.after
+		};
+		const value = characters.slice(first, last).join("");
+		const parts = blankLines ? value.split("\n") : [value];
+		return before + parts.map((part, index) => state.safe(part, {
+			...middleInfo,
+			before: index === 0 ? middleInfo.before : ";",
+			after: index === parts.length - 1 ? middleInfo.after : "&"
+		})).join("&#xa;") + after;
+	} } };
+}
+//#endregion
+//#region src/code-writer.ts
+/*!
+* @license MIT
+* Header escaping follows mdast-util-to-markdown's safe utility, with linear
+* offset storage and emission rather than repeated array membership searches.
+* Copyright (c) Titus Wormer <tituswormer@gmail.com>
+*
+* 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.
+*/
+const punctuation = /[!-/:-@[-`{-~]/;
+const marked = 1;
+const before = 2;
+const after = 4;
+function overflow() {
+	throw new ContentLimitError(`Content exceeds the source length limit of ${CONTENT_LIMITS.sourceLength}`);
+}
+/** Match the existing ordinary-code fence choice without allocating its spelling. */
+function ordinaryCodeFenceLength(value, marker = "`") {
+	let length = 3;
+	let run = 0;
+	for (let index = 0; index < value.length; index++) {
+		run = value[index] === marker ? run + 1 : 0;
+		length = Math.max(length, run + 1);
+	}
+	return length;
+}
+function inScope(stack, scope, absent) {
+	if (!scope || !scope.length) return absent;
+	return (typeof scope === "string" ? [scope] : scope).some((name) => stack.includes(name));
+}
+/** Emit normal backslash escaping without constructing a separate expanded span. */
+function* literalChunks(value, start, end, next) {
+	let chunk = start;
+	for (let index = start; index < end; index++) {
+		if (value[index] !== "\\" || !punctuation.test(index + 1 < end ? value[index + 1] : next[0] ?? "")) continue;
+		yield value.slice(chunk, index + 1);
+		yield "\\";
+		chunk = index + 1;
+	}
+	yield value.slice(chunk, end);
+}
+function* headerChunks(value, flags, start, end, config) {
+	let literal = start;
+	for (let index = start; index < end; index++) {
+		const current = flags[index];
+		if (!(current & marked)) continue;
+		const next = index + 1 < end ? flags[index + 1] : 0;
+		const previous = index > 0 ? flags[index - 1] : 0;
+		if (next & marked && current & after && !(next & 6) || previous & marked && current & before && !(previous & 6)) continue;
+		yield* literalChunks(value, literal, index, "\\");
+		const character = value[index];
+		if (punctuation.test(character) && !config.encode?.includes(character)) {
+			yield "\\";
+			literal = index;
+		} else {
+			yield `&#x${value.charCodeAt(index).toString(16).toUpperCase()};`;
+			literal = index + 1;
+		}
+	}
+	yield* literalChunks(value, literal, end, config.after);
+}
+function escapedHeader(state, input, config, remaining) {
+	const prefix = config.before || "";
+	const payload = input || "";
+	const suffix = config.after || "";
+	if (prefix.length + payload.length + suffix.length > CONTENT_LIMITS.sourceLength) overflow();
+	const value = prefix + payload + suffix;
+	const flags = new Uint8Array(value.length);
+	for (const pattern of state.unsafe) {
+		if (!inScope(state.stack, pattern.inConstruct, true) || inScope(state.stack, pattern.notInConstruct, false)) continue;
+		const expression = state.compilePattern(pattern);
+		let match;
+		while (match = expression.exec(value)) {
+			const hasBefore = "before" in pattern || Boolean(pattern.atBreak);
+			const offset = match.index + (hasBefore ? match[1].length : 0);
+			const bits = marked | (hasBefore ? before : 0) | ("after" in pattern ? after : 0);
+			flags[offset] = flags[offset] ? flags[offset] & bits : bits;
+		}
+	}
+	const start = prefix.length;
+	const end = value.length - suffix.length;
+	let length = 0;
+	for (const chunk of headerChunks(value, flags, start, end, config)) {
+		length += chunk.length;
+		if (length > remaining) overflow();
+	}
+	return Array.from(headerChunks(value, flags, start, end, config)).join("");
+}
+/** Keep the default handler's spelling and tracker, bounding only code headers. */
+function codeWriterExtension() {
+	return { handlers: { code(node, parent, state, info) {
+		const code = node;
+		if (state.options.fences === false && !code.lang) return defaultHandlers.code(node, parent, state, info);
+		const marker = state.options.fence || "`";
+		if (marker !== "`" && marker !== "~") return defaultHandlers.code(node, parent, state, info);
+		const raw = code.value || "";
+		const base = 2 * ordinaryCodeFenceLength(raw, marker) + 1 + (raw ? raw.length + 1 : 0) + (code.lang && code.meta ? 1 : 0);
+		if (base > CONTENT_LIMITS.sourceLength) overflow();
+		let remaining = CONTENT_LIMITS.sourceLength - base;
+		const previous = state.safe;
+		state.safe = (input, config) => {
+			let escaped = escapedHeader(state, input, config, remaining);
+			if (typeof input === "string" && /^(?:(?:lines|wrap)(?=[ \t=]|$)|(?:filename|title|startLine|highlight|focus|collapse|added|removed)(?=[ \t=]|$))/.test(input) && escaped[0] === input[0]) escaped = `&#${input.charCodeAt(0)};${escaped.slice(1)}`;
+			if (escaped.length > remaining) overflow();
+			remaining -= escaped.length;
+			return escaped;
+		};
+		try {
+			return defaultHandlers.code(node, parent, state, info);
+		} finally {
+			state.safe = previous;
+		}
+	} } };
+}
+//#endregion
+//#region src/code-presentation-writer.ts
+/** Header source has already been encoded for exactly one CommonMark decoding pass. */
+function codePresentationWriterExtension() {
+	return { handlers: { topikCodePresentation(node) {
+		const presentation = node;
+		const child = presentation.children[0];
+		const templated = child.type === "tagCodeTemplate";
+		const value = templated ? writeTextTemplate(child.template, true) : child.value;
+		const metadata = serializeCodePresentationMetadata(presentation.options, presentation.opaqueMetaSuffix);
+		const ticks = ordinaryCodeFenceLength(value);
+		const tildes = ordinaryCodeFenceLength(value, "~");
+		const marker = child.lang?.includes("`") || tildes < ticks ? "~" : "`";
+		const fence = marker.repeat(marker === "`" ? ticks : tildes);
+		let language = (child.lang ?? "").replace(/[&\\`]/g, (unit) => `&#${unit.charCodeAt(0)};`);
+		if (/^(?:lines|wrap)$|^(?:filename|title|lines|startLine|highlight|focus|collapse|wrap|added|removed)=/.test(language)) language = `&#${language.charCodeAt(0)};${language.slice(1)}`;
+		const body = `${fence}${language}${language ? " " : ""}${metadata}\n${value ? `${value}\n` : ""}${fence}`;
+		const scope = templated ? `{% template code %}\n${body}\n{% /template code %}` : body;
+		assertSourceLimit(scope);
+		return scope;
+	} } };
+}
+//#endregion
+//#region src/writer.ts
+/**
+* Count payload deltas from an empty-template/code skeleton. A cheap source
+* floor refuses obvious overflows before cloning or baseline serialization;
+* the existing writer then supplies exact ordinary markup and escaping.
+*/
+function sourceExpansion(document, registry) {
+	let total = 0;
+	let expansion = 0;
+	function charge(length) {
+		total += length;
+		if (total > CONTENT_LIMITS.sourceLength) throw new ContentLimitError(`Content exceeds the source length limit of ${CONTENT_LIMITS.sourceLength}`);
+	}
+	function attributeEscape(unit, table, label) {
+		return unit === "\"" || unit === "\\" || table && unit === "|" || label && (unit === "[" || unit === "]");
+	}
+	function measure(template, attribute, table, label, escapeOpeners = true) {
+		let length = 0;
+		let previous = "";
+		let ticks = 0;
+		let tildes = 0;
+		let longestTicks = 0;
+		let longestTildes = 0;
+		let blankLines = 0;
+		let nonblankLines = 0;
+		let lineHasContent = false;
+		for (const segment of template.segments) {
+			if (segment.type === "variable") {
+				length += 7 + segment.path.length - 1;
+				for (const part of segment.path) length += part.length;
+				lineHasContent = true;
+				previous = "";
+				ticks = 0;
+				tildes = 0;
+				continue;
+			}
+			for (const unit of segment.value) {
+				length += unit.length;
+				if (escapeOpeners && previous === "{" && unit === "%") length++;
+				if (attribute && attributeEscape(unit, table, label)) length++;
+				ticks = unit === "`" ? ticks + 1 : 0;
+				tildes = unit === "~" ? tildes + 1 : 0;
+				longestTicks = Math.max(longestTicks, ticks);
+				longestTildes = Math.max(longestTildes, tildes);
+				previous = unit;
+				if (unit === "\n") {
+					if (lineHasContent) nonblankLines++;
+					else blankLines++;
+					lineHasContent = false;
+				} else lineHasContent = true;
+			}
+		}
+		if (length) {
+			if (lineHasContent) nonblankLines++;
+			else blankLines++;
+		}
+		return {
+			length,
+			longestTicks,
+			longestTildes,
+			blankLines,
+			nonblankLines
+		};
+	}
+	function headerLength(value) {
+		let length = value?.length ?? 0;
+		for (const unit of value ?? "") length += unit === "&" || unit === "	" ? 4 : unit === "\\" || unit === "`" ? 5 : 0;
+		return length;
+	}
+	function prefixWidths(prefixes) {
+		let blank = 0;
+		let nonblank = 0;
+		let empty = true;
+		for (let index = prefixes.length - 1; index >= 0; index--) {
+			const prefix = prefixes[index];
+			nonblank += prefix === "quote" ? 2 : prefix;
+			if (prefix === "quote") {
+				blank += empty ? 1 : 2;
+				empty = false;
+			} else if (!empty) blank += prefix;
+		}
+		return {
+			blank,
+			nonblank
+		};
+	}
+	function walk(node, table = false, label = false, prefixes = [], parent, index = 0) {
+		if (node.type === "topikCodePresentation") charge(1 + (node.children?.[0]?.lang ? 1 : 0) + codePresentationMetadataLength(node.options, node.opaqueMetaSuffix));
+		if (node.type === "topikCodeTemplate" || node.type === "code") {
+			const explicit = node.type === "topikCodeTemplate";
+			const presented = parent?.type === "topikCodePresentation";
+			const measured = measure(explicit ? node.template : {
+				type: "topikTextTemplate",
+				segments: [{
+					type: "literal",
+					value: node.value
+				}]
+			}, false, false, false, explicit);
+			const ticks = Math.max(3, measured.longestTicks + 1);
+			const tildes = Math.max(3, measured.longestTildes + 1);
+			const fence = explicit || presented ? node.lang?.includes("`") || node.meta?.includes("`") ? tildes : Math.min(ticks, tildes) : ordinaryCodeFenceLength(node.value);
+			const prefix = prefixWidths(prefixes);
+			const payload = (measured.length ? measured.length + 1 : 0) + measured.nonblankLines * prefix.nonblank + measured.blankLines * prefix.blank;
+			expansion += payload + 2 * (fence - 3);
+			charge((explicit ? 42 : 1) + 2 * fence + (explicit || presented ? headerLength(node.lang) : node.lang?.length ?? 0) + (node.meta ? 1 + (explicit ? headerLength(node.meta) + (node.meta.startsWith(" ") ? 5 : 0) : node.meta.length) : 0) + payload + (explicit ? 4 : 2) * prefix.nonblank);
+		}
+		if ([
+			"text",
+			"inlineCode",
+			"html",
+			"yaml"
+		].includes(node.type) && typeof node.value === "string") charge(node.value.length);
+		if (node.type === "topikComponent") {
+			let templated = false;
+			for (const [name, value] of Object.entries(node.props ?? {})) if (value && typeof value === "object") {
+				const length = measure(value, true, table, label).length;
+				expansion += length;
+				charge(name.length + 5 + length);
+				templated = true;
+			} else if (typeof value === "string") {
+				let length = name.length + 4 + value.length;
+				for (const unit of value) if (attributeEscape(unit, table, label)) length++;
+				charge(length);
+			}
+			if (templated) {
+				const definition = registry[node.name];
+				const leaf = (node.children?.length ?? 0) === 0 && (definition.kind === "inline" || definition.selfClosing) || definition.children === "none";
+				charge((leaf ? 7 + node.name.length : 13 + 2 * node.name.length + (definition.kind === "block" ? 1 : 0)) + (leaf || definition.kind === "inline" ? 1 : 2) * prefixWidths(prefixes).nonblank);
+			}
+		}
+		let childPrefixes = prefixes;
+		if (node.type === "blockquote") childPrefixes = [...prefixes, "quote"];
+		else if (node.type === "listItem") {
+			const list = parent;
+			const width = list?.ordered ? String((list.start ?? 1) + index).length + 2 : 2;
+			childPrefixes = [...prefixes, width];
+		}
+		for (const [childIndex, child] of (node.children ?? []).entries()) {
+			walk(child, table || node.type === "tableCell", label || node.type === "link" || node.type === "linkReference", childPrefixes, node, childIndex);
+			const next = node.children?.[childIndex + 1];
+			if (next && [child, next].some((sibling) => [
+				"code",
+				"topikCodeTemplate",
+				"topikCodePresentation"
+			].includes(sibling.type))) {
+				const separator = node.spread === false ? 1 : 2;
+				charge(separator + (separator - 1) * prefixWidths(childPrefixes).blank);
+			}
+		}
+	}
+	walk(document);
+	return expansion;
+}
+function asTags(root, registry, emptyPayloads = false) {
+	const cloned = structuredClone(root);
+	function walk(node) {
+		if (!node.children) return;
+		node.children = node.children.map((child) => {
+			walk(child);
+			if (child.type === "topikVariable") return {
+				type: "tagVariable",
+				path: child.path.join(".")
+			};
+			if (child.type === "topikBranch") return {
+				type: "tagBranch",
+				condition: child.condition === null ? null : writeExpression(child.condition),
+				children: child.children
+			};
+			if (child.type === "topikConditional") return {
+				type: "tagConditional",
+				children: child.children
+			};
+			if (child.type === "topikCodeTemplate") return {
+				type: "tagCodeTemplate",
+				lang: child.lang,
+				meta: child.meta,
+				template: emptyPayloads ? {
+					type: "topikTextTemplate",
+					segments: []
+				} : child.template
+			};
+			if (child.type === "code" && emptyPayloads) child.value = "";
+			if (child.type !== "topikComponent") return child;
+			const component = child;
+			const definition = registry[component.name];
+			return {
+				type: definition.kind === "inline" ? "tagText" : definition.children === "none" || definition.selfClosing && component.children.length === 0 ? "tagLeaf" : "tagContainer",
+				name: component.name,
+				attributes: emptyPayloads ? Object.fromEntries(Object.entries(component.props).map(([name, value]) => [name, typeof value === "object" ? {
+					type: "topikTextTemplate",
+					segments: []
+				} : value])) : component.props,
+				children: component.children
+			};
+		});
+	}
+	walk(cloned);
+	return cloned;
+}
+function writeDocument(document, registry = components, formatVersion = 1) {
+	const written = serializeDocument(document, registry, formatVersion);
+	const parsed = parseDocumentTree(written, registry, formatVersion);
+	if (!parsed.document || parsed.diagnostics.length || !sameDocumentMeaning(document, parsed.document)) throw new Error("Content cannot be serialized without changing its meaning");
+	return written;
+}
+/** @internal Source operations reuse their output admission parse for the meaning check. */
+function serializeDocument(document, registry = components, formatVersion = 1) {
+	if (formatVersion !== 1) throw new Error(`Unsupported format version ${formatVersion}`);
+	const errors = validateDocument(document, registry);
+	if (errors.length) throw new Error(errors.map((error) => error.message).join("; "));
+	const expansion = sourceExpansion(document, registry);
+	const baseline = writeMarkdown(asTags(document, registry, true), registry);
+	assertSourceLimit(baseline);
+	if (expansion === 0) return baseline;
+	if (baseline.length + expansion > CONTENT_LIMITS.sourceLength) throw new ContentLimitError(`Content exceeds the source length limit of ${CONTENT_LIMITS.sourceLength}`);
+	const written = writeMarkdown(asTags(document, registry), registry);
+	assertSourceLimit(written);
+	return written;
+}
+function writeMarkdown(tree, registry) {
+	return toMarkdown(tree, {
+		extensions: [
+			gfmToMarkdown(),
+			markWriterExtension(tree),
+			frontmatterToMarkdown(),
+			tagToMarkdown(Object.fromEntries(Object.entries(registry).map(([name, definition]) => [name, { kind: definition.kind }])), tagOptions(registry)),
+			codeWriterExtension(),
+			codePresentationWriterExtension(),
+			resourceWriterExtension(),
+			referenceWriterExtension(),
+			boundaryWhitespaceWriterExtension(),
+			headingIdToMarkdown()
+		],
+		bullet: "-",
+		listItemIndent: "one",
+		incrementListMarker: true,
+		fences: true
+	});
+}
+//#endregion
+//#region src/markdown.ts
+function parseDocument(source, registry = components, formatVersion = 1) {
+	const result = parseDocumentTree(source, registry, formatVersion);
+	return result.document && result.diagnostics.length === 0 ? {
+		ok: true,
+		document: result.document,
+		source
+	} : {
+		ok: false,
+		diagnostics: result.diagnostics,
+		source
+	};
+}
+function formatDocument(source, registry = components) {
+	const result = parseDocument(source, registry);
+	if (!result.ok) return result;
+	try {
+		return {
+			...result,
+			formatted: writeDocument(result.document, registry)
+		};
+	} catch {
+		return {
+			ok: false,
+			source,
+			diagnostics: [{
+				id: "topik-write-failed",
+				message: "Content could not be serialized faithfully"
+			}]
+		};
+	}
+}
+//#endregion
+//#region src/assets.ts
+/** Rewrite asset definitions once, preserving reference identity and unrelated navigation. */
+function rewriteAssets(document, replace, registry = components) {
+	const inputErrors = validateDocument(document, registry);
+	if (inputErrors.length) throw new Error(inputErrors.map((error) => error.message).join("; "));
+	const cloned = structuredClone(document);
+	const index = indexDocument(cloned);
+	const images = /* @__PURE__ */ new Set();
+	const links = /* @__PURE__ */ new Set();
+	for (const { node } of index.entries) {
+		if (!isReference(node)) continue;
+		const definition = index.resolve(node);
+		if (definition) (node.type === "imageReference" ? images : links).add(definition);
+	}
+	for (const { node } of index.entries) if (node.type === "image") {
+		const image = node;
+		image.url = replace(image.url) ?? image.url;
+	} else if (node.type === "definition" && images.has(node)) {
+		const definition = node;
+		const next = replace(definition.url);
+		if (next !== void 0 && next !== definition.url && links.has(definition)) throw new Error(`Cannot rewrite definition ${definition.identifier}: it is shared by an image and a link`);
+		definition.url = next ?? definition.url;
+	} else if (node.type === "topikComponent") {
+		const component = node;
+		for (const [key, attribute] of Object.entries(registry[component.name].attributes)) {
+			const value = component.props[key];
+			if ((attribute.asset || attribute.assetReference) && typeof value === "string") component.props[key] = replace(value) ?? value;
+		}
+	}
+	const errors = validateDocument(cloned, registry);
+	if (errors.length) throw new Error(errors.map((error) => error.message).join("; "));
+	return cloned;
+}
+//#endregion
+//#region src/traversal.ts
+function walkContent(node, visit, path = []) {
+	assertDataLimits(node, { plain: true });
+	assertTreeLimits(node);
+	function walk(node, path) {
+		visit(node, path);
+		for (const [index, child] of (node.children ?? []).entries()) walk(child, [...path, index]);
+	}
+	walk(node, path);
+}
+function plainText(node) {
+	if (node.type === "text" || node.type === "inlineCode") return node.value ?? "";
+	if (node.type === "image" || node.type === "imageReference") return node.alt ?? "";
+	if (node.type === "break") return "\n";
+	return (node.children ?? []).map(plainText).join("");
+}
+//#endregion
+//#region src/headings.ts
+function assignTopikHeadingIds(document) {
+	const headings = [];
+	walkContent(document, (node) => {
+		if (node.type === "heading") headings.push(node);
+	});
+	return assignHeadingIds(headings);
+}
+/** @internal Reuse headings collected by a bounded document index. */
+function assignHeadingIds(headings) {
+	const slugger = new GithubSlugger();
+	const explicitIds = /* @__PURE__ */ new Set();
+	for (const heading of headings) if (typeof heading.data?.topikId === "string") explicitIds.add(heading.data.topikId);
+	return headings.map((heading) => {
+		const title = plainText(heading).trim().replace(/\s+/g, " ");
+		let id = heading.data?.topikId;
+		if (typeof id !== "string") do
+			id = slugger.slug(title);
+		while (explicitIds.has(id));
+		heading.data = {
+			...heading.data,
+			hProperties: { id }
+		};
+		return {
+			id,
+			level: heading.depth,
+			title
+		};
+	});
+}
+//#endregion
+//#region src/evaluate.ts
+var ContentEvaluationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ContentEvaluationError";
+	}
+};
+/** @internal Expected template failures retain their public diagnostic identity. */
+var TemplateEvaluationError = class extends ContentEvaluationError {
+	id;
+	attribute;
+	variable;
+	lines;
+	type;
+	constructor(id, node, message, attribute, variable) {
+		super(message);
+		this.id = id;
+		this.attribute = attribute;
+		this.variable = variable;
+		this.name = "TemplateEvaluationError";
+		this.lines = node.position ? [node.position.start.line] : [];
+		this.type = node.type;
+	}
+};
+function dataValue(value) {
+	return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value) || Array.isArray(value) || typeof value === "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function lookup(context, path, fail = (_kind, message) => {
+	throw new ContentEvaluationError(message);
+}) {
+	if (!validPath(path)) fail("path", "Unsafe variable path");
+	let current = context;
+	for (const part of path) {
+		if (!dataValue(current) || current === null || typeof current !== "object" || Array.isArray(current)) fail("type", `Cannot read $${path.join(".")}`);
+		const descriptor = Object.getOwnPropertyDescriptor(current, part);
+		if (!descriptor) fail("missing", `Missing variable $${path.join(".")}`);
+		if (!("value" in descriptor)) fail("type", `Missing variable $${path.join(".")}`);
+		current = descriptor.value;
+	}
+	if (!dataValue(current)) fail("type", `Non-data value $${path.join(".")}`);
+	return current;
+}
+function truthy(value) {
+	return value !== false && value !== null;
+}
+function hasControl(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code < 32 || code === 127) return true;
+	}
+	return false;
+}
+function evaluate(expression, context) {
+	if (expression.type === "literal") return expression.value;
+	if (expression.type === "variable") return lookup(context, expression.path);
+	const [left, right] = expression.args;
+	switch (expression.name) {
+		case "not": return !truthy(evaluate(left, context));
+		case "and": return truthy(evaluate(left, context)) && truthy(evaluate(right, context));
+		case "or": return truthy(evaluate(left, context)) || truthy(evaluate(right, context));
+		case "equals": {
+			const first = evaluate(left, context);
+			const second = evaluate(right, context);
+			if (first !== null && typeof first === "object" || second !== null && typeof second === "object") throw new ContentEvaluationError("equals accepts only scalar values");
+			return first === second;
+		}
+	}
+}
+/** Resolve into a new, writable document; the authored branches remain untouched. */
+function evaluateDocument(document, context, registry = components) {
+	const resolved = resolveDocument(document, context, registry, false);
+	try {
+		writeDocument(resolved, registry);
+	} catch {
+		throw new ContentEvaluationError("Evaluated content cannot be written without changing its meaning");
+	}
+	return resolved;
+}
+/** @internal Allocate reader anchors on the authored clone before selecting branches. */
+function evaluateDocumentForRendering(document, context, registry) {
+	return resolveDocument(document, context, registry, true);
+}
+function resolveDocument(document, context, registry, includeHeadingIds) {
+	const errors = validateDocument(document, registry);
+	if (errors.length) throw new ContentEvaluationError(errors.map((error) => error.message).join("; "));
+	if (!dataValue(context) || context === null || typeof context !== "object" || Array.isArray(context)) throw new ContentEvaluationError("Evaluation context must be a plain data object");
+	const resolved = structuredClone(document);
+	const index = indexDocument(resolved);
+	if (includeHeadingIds) assignHeadingIds(index.entries.filter(({ node }) => node.type === "heading").map(({ node }) => node));
+	materializeReferences(resolved, index);
+	let interpolatedLength = 0;
+	let templateResolved = false;
+	const strings = /* @__PURE__ */ new WeakMap();
+	const stringLengths = /* @__PURE__ */ new WeakMap();
+	function reserveString(target, key, plan) {
+		const fields = strings.get(target) ?? /* @__PURE__ */ new Map();
+		fields.set(key, plan);
+		strings.set(target, fields);
+		const lengths = stringLengths.get(target) ?? /* @__PURE__ */ new Map();
+		lengths.set(key, plan.length);
+		stringLengths.set(target, lengths);
+		target[key] = plan.length ? "x" : "";
+	}
+	function resolveTemplate(template, node, attribute) {
+		templateResolved = true;
+		const parts = [];
+		let length = 0;
+		for (const segment of template.segments) {
+			let text;
+			if (segment.type === "literal") text = segment.value;
+			else {
+				const variable = segment.path.reduce((length, part) => length + part.length + 1, -1) <= 256 ? segment.path.join(".") : void 0;
+				const value = lookup(context, segment.path, (kind) => {
+					throw new TemplateEvaluationError(kind === "path" ? "topik-variable-path" : `topik-template-variable-${kind}`, node, "Template variable lookup failed", attribute, variable);
+				});
+				if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") throw new TemplateEvaluationError("topik-template-variable-type", node, "Template variables require scalar values", attribute, variable);
+				text = value === null ? "" : String(value);
+				if (hasControl(text)) throw new TemplateEvaluationError("topik-template-control", node, "Template variable values must be single-line without controls", attribute, variable);
+				interpolatedLength += text.length;
+				if (interpolatedLength > CONTENT_LIMITS.dataStringLength) throw new TemplateEvaluationError("topik-content-limit", node, "Interpolated content exceeds the data string limit");
+			}
+			length += text.length;
+			if (length > CONTENT_LIMITS.dataStringLength) throw new TemplateEvaluationError("topik-content-limit", node, "Resolved template exceeds the data string limit");
+			parts.push(text);
+		}
+		return {
+			parts,
+			length
+		};
+	}
+	function resolveChildren(children) {
+		const result = [];
+		function append(node) {
+			const previous = result.at(-1);
+			if (previous?.type === "text" && node.type === "text") {
+				const before = strings.get(previous)?.get("value") ?? {
+					parts: [previous.value ?? ""],
+					length: previous.value?.length ?? 0
+				};
+				const after = strings.get(node)?.get("value") ?? {
+					parts: [node.value ?? ""],
+					length: node.value?.length ?? 0
+				};
+				for (const part of after.parts) before.parts.push(part);
+				before.length += after.length;
+				reserveString(previous, "value", before);
+				delete previous.position;
+			} else result.push(node);
+		}
+		for (const original of children) {
+			if (original.type === "topikConditional") {
+				const [first, alternate] = original.children;
+				const selected = truthy(evaluate(first.condition, context)) ? first : alternate;
+				if (selected) for (const child of resolveChildren(selected.children ?? [])) append(child);
+				continue;
+			}
+			if (original.type === "topikVariable") {
+				const value = lookup(context, original.path);
+				if (value !== null && typeof value === "object") throw new ContentEvaluationError(`Cannot interpolate object $${original.path.join(".")}`);
+				if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+					const text = String(value);
+					interpolatedLength += text.length;
+					if (interpolatedLength > CONTENT_LIMITS.dataStringLength) {
+						if (templateResolved) throw new TemplateEvaluationError("topik-content-limit", original, "Interpolated content exceeds the data string limit");
+						throw new ContentEvaluationError("Interpolated content exceeds the data string limit");
+					}
+					if (typeof value === "string" && hasControl(value)) throw new ContentEvaluationError("Interpolated text must be single-line without controls");
+					if (text) {
+						const node = {
+							type: "text",
+							value: ""
+						};
+						reserveString(node, "value", {
+							parts: [text],
+							length: text.length
+						});
+						append(node);
+					}
+				}
+				continue;
+			}
+			const node = original;
+			if (node.type === "topikCodeTemplate") {
+				reserveString(node, "value", resolveTemplate(node.template, node));
+				node.type = "code";
+				delete node.template;
+			}
+			if (node.type === "topikComponent") {
+				for (const [name, value] of Object.entries(node.props)) if (typeof value === "object") reserveString(node.props, name, resolveTemplate(value, node, name));
+			}
+			if (node.children) node.children = resolveChildren(node.children);
+			if (inlineParentTypes.has(node.type) && node.type !== "link" && node.type !== "linkReference") while (node.children?.at(-1)?.type === "break") node.children.pop();
+			const definition = node.type === "topikComponent" ? registry[node.name] : void 0;
+			if (node.children?.length === 0 && (node.type === "paragraph" || node.type === "strong" || node.type === "emphasis" || node.type === "delete" || definition?.kind === "inline" && definition.children === "inline")) continue;
+			append(node);
+		}
+		return result;
+	}
+	resolved.children = resolveChildren(resolved.children);
+	try {
+		assertDataLimits(resolved, {
+			plain: true,
+			stringLengths
+		});
+	} catch (error) {
+		if (error instanceof ContentLimitError) {
+			if (templateResolved) throw new TemplateEvaluationError("topik-content-limit", resolved, error.message);
+			throw new ContentEvaluationError(error.message);
+		}
+		throw error;
+	}
+	function materialize(value, seen = /* @__PURE__ */ new Set()) {
+		if (!value || typeof value !== "object" || seen.has(value)) return;
+		seen.add(value);
+		const plans = strings.get(value);
+		if (plans) for (const [key, plan] of plans) value[key] = plan.parts.join("");
+		for (const child of Object.values(value)) materialize(child, seen);
+	}
+	materialize(resolved);
+	const resolvedErrors = validateDocument(resolved, registry);
+	if (resolvedErrors.length) {
+		if (templateResolved && resolvedErrors[0].id === "topik-content-limit") throw new TemplateEvaluationError("topik-content-limit", resolved, "Resolved content exceeds the data limits");
+		throw new ContentEvaluationError(resolvedErrors.map((error) => error.message).join("; "));
+	}
+	return resolved;
+}
+//#endregion
+//#region src/config.ts
+function plainObject(value) {
+	return value !== null && typeof value === "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function ownEntries(value) {
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	if (Reflect.ownKeys(descriptors).some((key) => typeof key === "symbol")) throw new Error("Content configuration is invalid");
+	return Object.entries(descriptors).map(([key, descriptor]) => {
+		if (!("value" in descriptor) || key === "__proto__" || key === "constructor" || key === "prototype") throw new Error("Content configuration is invalid");
+		return [key, descriptor.value];
+	});
+}
+function validName(name) {
+	return /^[a-z][A-Za-z0-9-]*$/.test(name);
+}
+function allowedFields(value, fields) {
+	return Object.keys(value).every((field) => fields.includes(field));
+}
+function validAttribute(attribute) {
+	if (plainObject(attribute) && Object.hasOwn(attribute, "interpolation")) return false;
+	if (!plainObject(attribute) || !allowedFields(attribute, [
+		"type",
+		"required",
+		"default",
+		"description",
+		"values",
+		"min",
+		"max",
+		"integer",
+		"asset",
+		"assetReference",
+		"escapedWhitespace"
+	])) return false;
+	if (attribute.required !== void 0 && typeof attribute.required !== "boolean") return false;
+	if (attribute.description !== void 0 && typeof attribute.description !== "string") return false;
+	if (attribute.asset !== void 0 && typeof attribute.asset !== "boolean") return false;
+	if (attribute.escapedWhitespace !== void 0 && (attribute.type !== "string" || typeof attribute.escapedWhitespace !== "boolean")) return false;
+	if ((attribute.asset || attribute.assetReference !== void 0) && attribute.type !== "string" && attribute.type !== "enum") return false;
+	if (attribute.assetReference !== void 0) {
+		const reference = attribute.assetReference;
+		if (!plainObject(reference) || !allowedFields(reference, [
+			"slot",
+			"role",
+			"conditional"
+		]) || typeof reference.slot !== "string" || ![
+			"image",
+			"image-light",
+			"image-dark",
+			"media",
+			"download"
+		].includes(String(reference.role)) || reference.conditional !== void 0 && reference.conditional !== "proven-download") return false;
+	}
+	if (attribute.type === "string") return attribute.values === void 0 && attribute.min === void 0 && attribute.max === void 0 && attribute.integer === void 0 && (attribute.default === void 0 || typeof attribute.default === "string");
+	if (attribute.type === "enum") return Array.isArray(attribute.values) && attribute.values.length > 0 && attribute.values.every((value) => typeof value === "string") && attribute.min === void 0 && attribute.max === void 0 && attribute.integer === void 0 && (attribute.default === void 0 || typeof attribute.default === "string" && attribute.values.includes(attribute.default));
+	if (attribute.type === "boolean") return attribute.values === void 0 && attribute.min === void 0 && attribute.max === void 0 && attribute.integer === void 0 && (attribute.default === void 0 || typeof attribute.default === "boolean");
+	if (attribute.type === "number") return attribute.values === void 0 && (attribute.min === void 0 || typeof attribute.min === "number" && Number.isFinite(attribute.min)) && (attribute.max === void 0 || typeof attribute.max === "number" && Number.isFinite(attribute.max)) && (attribute.integer === void 0 || typeof attribute.integer === "boolean") && (attribute.default === void 0 || typeof attribute.default === "number" && Number.isFinite(attribute.default) && (attribute.min === void 0 || attribute.default >= attribute.min) && (attribute.max === void 0 || attribute.default <= attribute.max) && (!attribute.integer || Number.isInteger(attribute.default))) && (attribute.min === void 0 || attribute.max === void 0 || attribute.min <= attribute.max);
+	return false;
+}
+function validDefinition(definition) {
+	if (!plainObject(definition) || !allowedFields(definition, [
+		"kind",
+		"render",
+		"description",
+		"attributes",
+		"children",
+		"selfClosing",
+		"allowedParents"
+	])) return false;
+	if (definition.kind !== "block" && definition.kind !== "inline" || typeof definition.render !== "string" && typeof definition.render !== "boolean" || definition.description !== void 0 && typeof definition.description !== "string" || definition.selfClosing !== void 0 && typeof definition.selfClosing !== "boolean" || !plainObject(definition.attributes)) return false;
+	if (Object.entries(definition.attributes).some(([name, attribute]) => !validName(name) || !validAttribute(attribute))) return false;
+	if (definition.allowedParents !== void 0 && (!Array.isArray(definition.allowedParents) || !definition.allowedParents.every((name) => typeof name === "string" && validName(name)))) return false;
+	const children = definition.children;
+	if (children === "blocks" || children === "inline" || children === "none") return true;
+	if (!plainObject(children) || !allowedFields(children, [
+		"components",
+		"nodes",
+		"min"
+	])) return false;
+	const names = children.components ?? children.nodes;
+	return children.components === void 0 !== (children.nodes === void 0) && Array.isArray(names) && names.length > 0 && names.every((name) => typeof name === "string" && validName(name)) && (children.min === void 0 || typeof children.min === "number" && Number.isInteger(children.min) && children.min >= 0);
+}
+function cloneSchema(value, active = /* @__PURE__ */ new Set()) {
+	if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value !== "object") throw new Error("Content configuration is invalid");
+	if (active.has(value) || !Array.isArray(value) && !plainObject(value)) throw new Error("Content configuration is invalid");
+	active.add(value);
+	let cloned;
+	if (Array.isArray(value)) {
+		const entries = ownEntries(value);
+		if (entries.length !== value.length + 1 || entries.some(([key], index) => index < value.length && key !== String(index))) throw new Error("Content configuration is invalid");
+		cloned = entries.slice(0, -1).map(([, entry]) => cloneSchema(entry, active));
+	} else cloned = Object.fromEntries(ownEntries(value).map(([key, entry]) => [key, cloneSchema(entry, active)]));
+	active.delete(value);
+	return cloned;
+}
+/** Isolate schemas before validation; runtime variables are read without invoking accessors. */
+function mergeTopikContentConfig(extension = {}) {
+	try {
+		assertDataLimits(extension);
+	} catch {
+		throw new Error("Content configuration is invalid");
+	}
+	if (!plainObject(extension)) throw new Error("Content configuration is invalid");
+	const fields = Object.fromEntries(ownEntries(extension));
+	if (Object.keys(fields).some((key) => key !== "components" && key !== "variables")) throw new Error("Content configuration is invalid");
+	const additional = fields.components ?? {};
+	const variables = fields.variables ?? {};
+	if (!plainObject(additional) || !plainObject(variables)) throw new Error("Content configuration is invalid");
+	const registry = { ...components };
+	for (const [name, schema] of ownEntries(additional)) {
+		if (Object.hasOwn(components, name)) continue;
+		if (!validName(name) || name === "if" || name === "else" || !plainObject(schema)) throw new Error("Content configuration is invalid");
+		const definition = cloneSchema(schema);
+		if (!validDefinition(definition)) throw new Error("Content configuration is invalid");
+		registry[name] = definition;
+	}
+	return {
+		components: registry,
+		variables: cloneSchema(variables)
+	};
+}
+//#endregion
+//#region src/content.ts
+/** Parse the authoring tree. Use validateTopikContent at publication boundaries. */
+function parseTopikContent(source, options = {}) {
+	const result = parseDocumentTree(source, mergeTopikContentConfig(options.config).components);
+	if (!result.document) throw new Error("Content could not be parsed");
+	return result.document;
+}
+//#endregion
+//#region src/asset-reference-policy.ts
+const TOPIK_ASSET_REFERENCE_VERSION = "topik-asset-reference-v1";
+const TOPIK_GENERATED_ASSET_NAME_VALIDATOR = /^auto-v1-[a-z2-7]{51}[aq]$/u;
+/** Public grammar descriptor. Runtime admission uses an isolated boundary. */
+const TOPIK_GENERATED_ASSET_NAME_PATTERN = /^auto-v1-[a-z2-7]{51}[aq]$/u;
+function isTopikGeneratedAssetName(value) {
+	return typeof value === "string" && TOPIK_GENERATED_ASSET_NAME_VALIDATOR.test(value);
+}
+function parseTopikGeneratedAssetName(value) {
+	if (!isTopikGeneratedAssetName(value)) throw new TypeError("Generated Asset name is not canonical");
+	return value;
+}
+/** Validate the URL-facing portion of topik-asset-reference-v1 without filesystem access. */
+function validateTopikAssetReference(reference) {
+	if (containsUnsafeUnicode(reference) || reference.includes("\\")) return unsafe(reference);
+	if (reference.startsWith("asset:")) {
+		const name = reference.slice(6);
+		return isTopikGeneratedAssetName(name) ? {
+			valid: true,
+			kind: "asset",
+			name
+		} : {
+			valid: false,
+			kind: "unsafe",
+			failureKind: "local"
+		};
+	}
+	if (/^https:\/\//iu.test(reference)) try {
+		const url = new URL(reference);
+		return url.protocol === "https:" && url.username === "" && url.password === "" ? {
+			valid: true,
+			kind: "external-https"
+		} : {
+			valid: false,
+			kind: "unsafe",
+			failureKind: "external"
+		};
+	} catch {
+		return {
+			valid: false,
+			kind: "unsafe",
+			failureKind: "external"
+		};
+	}
+	if (reference.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(reference)) return {
+		valid: false,
+		kind: "unsafe",
+		failureKind: "external"
+	};
+	if (reference.length === 0 || reference.startsWith("/") || reference.includes("?") || reference.includes("#") || containsNonAscii(reference)) return {
+		valid: false,
+		kind: "unsafe",
+		failureKind: "local"
+	};
+	const bytes = [];
+	for (let index = 0; index < reference.length; index++) {
+		const character = reference[index];
+		if (character === "/") {
+			bytes.push(47);
+			continue;
+		}
+		if (character === "%") {
+			const pair = reference.slice(index + 1, index + 3);
+			if (!/^[0-9A-F]{2}$/u.test(pair)) return {
+				valid: false,
+				kind: "unsafe",
+				failureKind: "local"
+			};
+			const byte = Number.parseInt(pair, 16);
+			if (byte === 47 || byte === 92 || byte === 37) return {
+				valid: false,
+				kind: "unsafe",
+				failureKind: "local"
+			};
+			bytes.push(byte);
+			index += 2;
+			continue;
+		}
+		if (!/^[A-Za-z0-9._~-]$/u.test(character)) return {
+			valid: false,
+			kind: "unsafe",
+			failureKind: "local"
+		};
+		bytes.push(character.charCodeAt(0));
+	}
+	let decodedPath;
+	try {
+		decodedPath = new TextDecoder("utf-8", { fatal: true }).decode(Uint8Array.from(bytes));
+	} catch {
+		return {
+			valid: false,
+			kind: "unsafe",
+			failureKind: "local"
+		};
+	}
+	if (!isSafeDecodedPath(decodedPath) || encodeLocalPath(decodedPath) !== reference) return {
+		valid: false,
+		kind: "unsafe",
+		failureKind: "local"
+	};
+	return {
+		valid: true,
+		kind: "local",
+		decodedPath
+	};
+}
+function unsafe(reference) {
+	return {
+		valid: false,
+		kind: "unsafe",
+		failureKind: reference.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(reference) ? "external" : "local"
+	};
+}
+function isSafeDecodedPath(path) {
+	if (path.length === 0 || path.startsWith("/") || path.includes("\\") || path.includes("%") || path.normalize("NFC") !== path || containsUnsafeUnicode(path) || /[<>:"|?*]/u.test(path)) return false;
+	return path.split("/").every((component) => component.length > 0 && (component === "." || component === ".." || !/[. ]$/u.test(component)));
+}
+function encodeLocalPath(path) {
+	const encoder = new TextEncoder();
+	return path.split("/").map((component) => [...encoder.encode(component)].map((byte) => {
+		const character = String.fromCharCode(byte);
+		return /^[A-Za-z0-9._~-]$/u.test(character) ? character : `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+	}).join("")).join("/");
+}
+function containsUnsafeUnicode(value) {
+	return /[\p{Cc}\p{Cf}\p{Cs}\p{Co}\p{Cn}\p{Default_Ignorable_Code_Point}\p{Bidi_Control}\p{Noncharacter_Code_Point}]/u.test(value);
+}
+function containsNonAscii(value) {
+	for (const character of value) if ((character.codePointAt(0) ?? 0) > 127) return true;
+	return false;
+}
+//#endregion
+//#region src/resource-references.ts
+/** Version of the portable compiled-content resource reference contract. */
+const TOPIK_RESOURCE_REFERENCE_VERSION = 1;
+const RESOURCE_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+const RESOURCE_REFERENCE = /^ref:\/\/(wiki-page|guide|course-page)\/([^/?#]+)(?:\?[^#]*)?(?:#.*)?$/iu;
+/** Parse an explicit resource identity without consulting routes or fetching a catalogue. */
+function parseTopikResourceReference(href) {
+	if (typeof href !== "string" || /[\p{Cc}\p{White_Space}]/u.test(href)) return null;
+	const match = RESOURCE_REFERENCE.exec(href);
+	if (!match) return null;
+	try {
+		const name = decodeURIComponent(match[2]);
+		if (name.length > 63 || !RESOURCE_NAME.test(name)) return null;
+		const url = new URL(href);
+		decodeURIComponent(url.hash);
+		return {
+			type: match[1].toLowerCase() === "wiki-page" ? "WikiPage" : match[1].toLowerCase() === "guide" ? "Guide" : "CoursePage",
+			name,
+			search: url.search,
+			hash: url.hash.slice(1)
+		};
+	} catch {
+		return null;
+	}
+}
+/** Serialize an identity as a canonical ref:// URI; this is not a browser-facing URL. */
+function serializeTopikResourceReference(reference) {
+	if (reference.type !== "WikiPage" && reference.type !== "Guide" && reference.type !== "CoursePage" || typeof reference.name !== "string" || reference.name.length > 63 || !RESOURCE_NAME.test(reference.name) || typeof reference.search !== "string" || reference.search !== "" && !reference.search.startsWith("?") || reference.search.includes("#") || typeof reference.hash !== "string") throw new TypeError("Resource reference is not valid");
+	const kind = reference.type === "WikiPage" ? "wiki-page" : reference.type === "Guide" ? "guide" : "course-page";
+	const parsed = parseTopikResourceReference(`ref://${kind}/${reference.name}${reference.search}${reference.hash ? `#${reference.hash}` : ""}`);
+	if (!parsed) throw new TypeError("Resource reference is not valid");
+	return `ref://${kind}/${parsed.name}${parsed.search}${parsed.hash ? `#${parsed.hash}` : ""}`;
+}
+//#endregion
+//#region src/diagnostics.ts
+const TOPIK_LINK_DIAGNOSTIC_MESSAGES = {
+	"link-asset-invalid": "Asset link target is not a canonical generated name.",
+	"link-asset-navigation-unsupported": "Navigation targets cannot use generated Asset names.",
+	"link-fragment-not-found": "Link target heading was not found.",
+	"link-href-empty": "Link target is required.",
+	"link-page-not-found": "Internal link target page was not found.",
+	"link-reference-ambiguous": "Resource reference target is ambiguous.",
+	"link-reference-invalid": "Resource link target is not a valid reference.",
+	"link-reference-unresolved": "Resource link target requires a browser URL resolver.",
+	"link-scheme-unsafe": "Link scheme is unsafe.",
+	"link-scheme-unsupported": "Link scheme is unsupported.",
+	"link-url-credentials": "Link URL credentials are not supported.",
+	"link-url-invalid": "Link target is not a valid URL reference.",
+	"link-url-protocol-relative": "Protocol-relative link targets are not supported."
+};
+const TOPIK_CONTENT_DIAGNOSTIC_MESSAGES = {
+	...TOPIK_LINK_DIAGNOSTIC_MESSAGES,
+	TOPIK_ASSET_PATH_INVALID: "Local Asset reference is not canonical.",
+	TOPIK_ASSET_REFERENCE_MALFORMED: "Asset reference has an invalid generated name.",
+	TOPIK_EXTERNAL_REFERENCE_UNSAFE: "External Asset reference requires credential-free HTTPS.",
+	"attribute-missing-required": "A required attribute is missing.",
+	"attribute-type-invalid": "An attribute has an invalid type.",
+	"attribute-undefined": "An attribute is not supported.",
+	"attribute-value-invalid": "An attribute has an invalid value.",
+	"child-invalid": "A child node is not supported in this location.",
+	"duplicate-attribute": "An attribute is specified more than once.",
+	"fence-tag-error": "A fenced tag is invalid.",
+	"function-undefined": "A referenced function is not defined.",
+	"heading-id-duplicate": "Explicit heading IDs must be unique within a document.",
+	"missing-closing": "Content has a missing closing delimiter.",
+	"missing-opening": "Content has a missing opening delimiter.",
+	"node-undefined": "A node is not supported.",
+	"no-inline-annotations": "Inline annotations are not supported in this location.",
+	"parameter-missing-required": "A required function parameter is missing.",
+	"parameter-type-invalid": "A function parameter has an invalid type.",
+	"parameter-undefined": "A function parameter is not supported.",
+	"parse-error": "Content could not be parsed.",
+	"slot-missing-required": "A required slot is missing.",
+	"slot-undefined": "A slot is not supported.",
+	"table-syntax": "Table syntax is invalid.",
+	"tag-placement-invalid": "A tag is not supported in this location.",
+	"tag-selfclosing-has-children": "A self-closing tag cannot contain children.",
+	"tag-undefined": "A tag is not supported.",
+	"topik-accordion-children": "An accordion may contain only block content.",
+	"topik-badge-children": "A badge requires inline content.",
+	"topik-callout-children": "A callout may contain only block content.",
+	"topik-card-children": "A card may contain only block content.",
+	"topik-choice-children": "A choice may contain only block content.",
+	"topik-code-group-children": "A code group contains an unsupported child.",
+	"topik-code-group-requires-code-tab": "A code group requires at least one code tab.",
+	"topik-code-group-parent-required": "A code tab must be nested inside a code group.",
+	"topik-tabs-parent-required": "A tab must be nested inside tabs.",
+	"topik-steps-parent-required": "A step must be nested inside steps.",
+	"topik-code-tab-parent-required": "A code tab must be nested inside a code group.",
+	"topik-code-tab-children": "A code tab may contain only fenced code blocks.",
+	"topik-code-tab-requires-fence": "A code tab requires a fenced code block.",
+	"topik-columns-range": "Card grid columns must be an integer from 1 to 4.",
+	"topik-config-invalid": "Content configuration is invalid.",
+	"topik-content-limit": "Content exceeds the supported complexity limits.",
+	"topik-node-invalid": "A Markdown node cannot be represented without changing its meaning.",
+	"topik-reference-missing": "A reference has no definition in its conditional scope.",
+	"topik-reference-label": "A reference identifier has no faithful Markdown label.",
+	"topik-write-failed": "Content could not be written without changing its meaning.",
+	"topik-extension-failed": "Content extension validation failed.",
+	"topik-explanation-children": "An explanation may contain only block content.",
+	"topik-figure-children": "A figure cannot contain children; use its alt and caption attributes.",
+	"topik-math-children": "Block math cannot contain children; use its content attribute.",
+	"topik-math-inline-children": "Inline math cannot contain children; use its content attribute.",
+	"topik-mark-nesting": "Emphasis and strong marks allow at most two levels each; strikethrough cannot be nested.",
+	"topik-question-choice-count": "A question requires at least two choices.",
+	"topik-question-children": "A question contains an unsupported child.",
+	"topik-question-correct-choice-required": "A multiple-choice question requires at least one correct choice.",
+	"topik-question-parent-required": "Choices and explanations must be nested inside a question.",
+	"topik-question-single-correct-choice": "A single-choice question requires exactly one correct choice.",
+	"topik-partial-cycle": "Partial references must not be cyclic.",
+	"topik-partial-invalid": "Partial content is invalid or unavailable.",
+	"topik-quiz-children": "A quiz contains an unsupported child.",
+	"topik-quiz-requires-question": "A quiz requires at least one question.",
+	"topik-step-parent-required": "A step must be nested inside steps.",
+	"topik-step-children": "A step may contain only block content.",
+	"topik-steps-children": "Steps contain an unsupported child.",
+	"topik-steps-requires-step": "Steps require at least one step.",
+	"topik-tab-parent-required": "A tab must be nested inside tabs.",
+	"topik-tab-children": "A tab may contain only block content.",
+	"topik-tabs-children": "Tabs contain an unsupported child.",
+	"topik-tabs-requires-tab": "Tabs require at least one tab.",
+	"topik-transform-failed": "Content transformation failed.",
+	"topik-empty-paragraph": "Empty paragraphs cannot be written as Markdown.",
+	"topik-frontmatter-placement": "Frontmatter must be the first node in the document.",
+	"topik-variable-path": "Variable paths must use supported property names.",
+	"topik-variable-placement": "Variables must appear in inline content.",
+	"topik-template-syntax": "Text templates require valid variable tokens or escaped openers.",
+	"topik-template-location": "Text templates are not supported in this attribute.",
+	"topik-code-template-structure": "A code template requires exactly one closed fenced code block in the same content scope.",
+	"topik-code-template-language": "Code templates require a language that displays plain text.",
+	"topik-code-presentation-scope": "A presentation requires one code or code-template child; remove nested or extra blocks.",
+	"topik-code-presentation-metadata": "Use fence attributes such as filename=\"client.ts\", lines and highlight=\"1,3-5\"; quote values containing spaces.",
+	"topik-code-presentation-option": "Use supported presentation options with valid labels, booleans and integer bounds.",
+	"topik-code-presentation-lines": "Select physical rows using positive numbers or closed ranges, separated by commas without spaces.",
+	"topik-code-presentation-line-bounds": "Keep line selections within the physical payload rows; startLine changes labels only.",
+	"topik-code-presentation-diff-conflict": "Choose disjoint added and removed row selections.",
+	"topik-code-presentation-language": "Use presentation attributes with text code languages rather than interpreted Mermaid diagrams.",
+	"topik-template-variable-missing": "A template variable is not defined.",
+	"topik-template-variable-type": "Template variables require strings, finite numbers, booleans, or null.",
+	"topik-template-control": "Template text contains an unsupported control character.",
+	"topik-expression-invalid": "The conditional expression is not supported.",
+	"topik-conditional-placement": "Conditions must appear in ordinary block content.",
+	"topik-conditional-branches": "A condition requires one branch and at most one alternative.",
+	"topik-conditional-children": "Conditional branches must contain block content.",
+	"topik-tag-children": "The component requires a different opening or closing form.",
+	"topik-tag-placement": "The component cannot appear in this location.",
+	"topik-card-grid-children": "A card grid may contain only cards.",
+	"topik-quiz-parent-required": "A question must be nested inside a quiz.",
+	"topik-underline-children": "Underline requires inline content.",
+	"topik-u-children": "Underline requires inline content.",
+	"variable-undefined": "A referenced variable is not defined."
+};
+const DIAGNOSTIC_URL_BASE = new URL("https://topik.invalid/");
+const EXPLICIT_URL_SCHEME = /^[a-z][a-z0-9+.-]*:/iu;
+const WINDOWS_DRIVE_PREFIX = /^[a-z]:/iu;
+/** Fixed public wording for link diagnostics; authored targets are never accepted as input. */
+function topikLinkDiagnosticMessage(id) {
+	return Object.hasOwn(TOPIK_LINK_DIAGNOSTIC_MESSAGES, id) ? TOPIK_LINK_DIAGNOSTIC_MESSAGES[id] : void 0;
+}
+/** Re-apply fixed public messages and safe file labels when diagnostics cross package layers. */
+function sanitizeTopikContentDiagnostic(diagnostic) {
+	const message = Object.hasOwn(TOPIK_CONTENT_DIAGNOSTIC_MESSAGES, diagnostic.id) ? TOPIK_CONTENT_DIAGNOSTIC_MESSAGES[diagnostic.id] : "Content validation failed.";
+	const file = sanitizeTopikDiagnosticFile(diagnostic.file);
+	const { file: _untrustedFile, message: _untrustedMessage, attribute, variable, option, column, ...safe } = diagnostic;
+	const template = diagnostic.id.startsWith("topik-template-") || diagnostic.id === "topik-variable-path";
+	return {
+		...safe,
+		message,
+		...diagnostic.id.startsWith("topik-code-presentation-") && typeof option === "string" && [
+			"filename",
+			"title",
+			"lineNumbers",
+			"startLine",
+			"highlight",
+			"focus",
+			"collapse",
+			"wrap",
+			"added",
+			"removed"
+		].includes(option) ? { option } : {},
+		...diagnostic.id.startsWith("topik-code-presentation-") && typeof column === "number" && Number.isSafeInteger(column) && column > 0 && column <= 1e6 ? { column } : {},
+		...file === void 0 ? {} : { file },
+		...template && attribute !== void 0 && [
+			"title",
+			"alt",
+			"caption"
+		].includes(attribute) ? { attribute } : {},
+		...template && typeof variable === "string" && variable.length <= 256 && /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(variable) ? { variable } : {}
+	};
+}
+function toTopikContentDiagnostic(error) {
+	return sanitizeTopikContentDiagnostic({
+		id: error.error.id,
+		type: error.type,
+		level: error.error.level,
+		message: error.error.message,
+		lines: error.lines,
+		...error.location?.file ? { file: error.location.file } : {}
+	});
+}
+/** Convert an untrusted diagnostic location to a browser-compatible safe label. */
+function sanitizeTopikDiagnosticFile(file) {
+	if (file === void 0) return void 0;
+	if (hasAmbiguousDiagnosticCharacter(file) || hasHtmlCharacterReference(file)) return "content";
+	if (WINDOWS_DRIVE_PREFIX.test(file) || file.startsWith("\\")) return safeDiagnosticBasename(file);
+	if (EXPLICIT_URL_SCHEME.test(file) || file.startsWith("//") || file.includes("?") || file.includes("#")) try {
+		const url = new URL(file, DIAGNOSTIC_URL_BASE);
+		return url.pathname.startsWith("/") ? safeDiagnosticBasename(url.pathname) : "content";
+	} catch {
+		return "content";
+	}
+	if (file.startsWith("/")) return safeDiagnosticBasename(file);
+	return isSafeRelativeDiagnosticLabel(file) ? file : "content";
+}
+function hasAmbiguousDiagnosticCharacter(value) {
+	return /[%\p{Cc}\p{Cf}\p{Separator}\p{White_Space}]/u.test(value);
+}
+function hasHtmlCharacterReference(value) {
+	return /&(?:#(?:x[0-9a-f]*|[0-9]*)|[a-z][a-z0-9]*);?/iu.test(value);
+}
+function safeDiagnosticBasename(file) {
+	const label = file.replaceAll("\\", "/").split("/").at(-1)?.split(/[?#]/u, 1)[0];
+	return label !== void 0 && isSafeRelativeDiagnosticLabel(label) ? label : "content";
+}
+function isSafeRelativeDiagnosticLabel(value) {
+	return /^(?!\.\.?$)[a-z0-9._-]+(?:[\\/][a-z0-9._-]+)*$/iu.test(value);
+}
+//#endregion
+//#region src/links.ts
+const ALLOWED_SCHEMES = /* @__PURE__ */ new Set([
+	"asset",
+	"http",
+	"https",
+	"mailto",
+	"tel"
+]);
+const UNSAFE_SCHEMES = /* @__PURE__ */ new Set([
+	"data",
+	"javascript",
+	"vbscript"
+]);
+const SCHEME = /^([a-z][a-z0-9+.-]*):/i;
+const TOPIK_BASE_URL = new URL("https://topik.local/");
+function analyzeTopikContent(source, options = {}) {
+	return analyzeDocument(parseTopikContent(source, {
+		file: options.file,
+		config: options.config
+	}), options.file);
+}
+/** @internal Share analysis with validation without reparsing source. */
+function analyzeDocument(ast, file, index = indexDocument(ast)) {
+	const headingNodes = index.entries.filter(({ node }) => node.type === "heading").map(({ node }) => node);
+	const explicitIdNodes = /* @__PURE__ */ new Map();
+	for (const node of headingNodes) {
+		const id = node.data?.topikId;
+		if (!id) continue;
+		const nodes = explicitIdNodes.get(id) ?? [];
+		nodes.push(node);
+		explicitIdNodes.set(id, nodes);
+	}
+	const headings = assignHeadingIds(headingNodes).map((heading, index) => ({
+		...heading,
+		...locationFields(headingNodes[index], file)
+	}));
+	const diagnostics = [];
+	for (const [id, nodes] of explicitIdNodes) for (const node of nodes.slice(1)) diagnostics.push({
+		id: "heading-id-duplicate",
+		type: "heading",
+		level: "error",
+		message: `Explicit heading ID '${id}' is used more than once in this document.`,
+		...locationFields(node, file)
+	});
+	const links = [];
+	for (const { node } of index.entries) {
+		const kind = linkKind(node);
+		if (!kind) continue;
+		const resource = node;
+		const href = kind === "card" ? node.props?.href : isReference(node) ? index.resolve(node)?.url : resource.url;
+		if (typeof href === "string") links.push({
+			href,
+			kind,
+			...locationFields(node, file)
+		});
+	}
+	return {
+		diagnostics: diagnostics.map(sanitizeTopikContentDiagnostic),
+		headings,
+		links
+	};
+}
+function validateTopikHref(value) {
+	if (typeof value !== "string") return [];
+	if (value.length === 0) return [linkError("link-href-empty")];
+	if (value !== value.trim()) return [linkError("link-url-invalid")];
+	if (hasAsciiControl(value)) return [linkError("link-url-invalid")];
+	if (isNetworkPathReference(value)) return [linkError("link-url-protocol-relative")];
+	const explicitScheme = SCHEME.exec(value)?.[1].toLowerCase();
+	if (explicitScheme === "ref") return parseTopikResourceReference(value) ? [] : [linkError("link-reference-invalid")];
+	if (explicitScheme === "asset") return isTopikGeneratedAssetName(value.slice(6)) ? [] : [linkError("link-asset-invalid")];
+	try {
+		const parsed = new URL(value, TOPIK_BASE_URL);
+		const scheme = parsed.protocol.slice(0, -1).toLowerCase();
+		if (!ALLOWED_SCHEMES.has(scheme)) return [linkError(UNSAFE_SCHEMES.has(scheme) ? "link-scheme-unsafe" : "link-scheme-unsupported")];
+		if (!explicitScheme && parsed.origin !== TOPIK_BASE_URL.origin) return [linkError("link-url-protocol-relative")];
+		if (parsed.username !== "" || parsed.password !== "") return [linkError("link-url-credentials")];
+		if ((scheme === "http" || scheme === "https") && !parsed.hostname) return [linkError("link-url-invalid")];
+		if ((scheme === "mailto" || scheme === "tel") && !parsed.pathname) return [linkError("link-url-invalid")];
+		if (parsed.hash) decodeURIComponent(parsed.hash.slice(1));
+	} catch {
+		return [linkError("link-url-invalid")];
+	}
+	return [];
+}
+/** Admit only resolved hrefs at a boundary that can emit browser navigation. */
+function validateTopikBrowserHref(value) {
+	if (typeof value === "string" && SCHEME.exec(value)?.[1].toLowerCase() === "ref") return [linkError("link-reference-unresolved")];
+	return validateTopikHref(value);
+}
+function validateTopikNavigationHref(value) {
+	if (typeof value === "string" && SCHEME.exec(value)?.[1].toLowerCase() === "asset") return [linkError("link-asset-navigation-unsupported")];
+	return validateTopikHref(value);
+}
+/** Remove invalid navigation attributes before a renderer can emit a browser-facing URL. */
+function removeInvalidTopikNavigationReferences(root) {
+	walkContent(root, (node) => {
+		if (node.type !== "topikComponent" || node.name !== "card") return;
+		const href = node.props?.href;
+		if (href !== void 0 && validateTopikNavigationHref(href).length > 0) delete node.props.href;
+	});
+}
+function linkKind(node) {
+	if (node.type === "link" || node.type === "linkReference") return "link";
+	if (node.type === "topikComponent" && node.name === "card") return "card";
+}
+function locationFields(node, file) {
+	return {
+		...file ? { file } : {},
+		lines: node.position ? [node.position.start.line] : []
+	};
+}
+function linkError(id) {
+	const message = topikLinkDiagnosticMessage(id);
+	if (message === void 0) throw new TypeError("Unknown link diagnostic identifier");
+	return {
+		id,
+		level: "error",
+		message
+	};
+}
+function hasAsciiControl(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code <= 31 || code === 127) return true;
+	}
+	return false;
+}
+function isNetworkPathReference(value) {
+	const isPathSeparator = (character) => character === "/" || character === "\\";
+	return isPathSeparator(value[0]) && isPathSeparator(value[1]);
+}
+//#endregion
+//#region src/asset-references.ts
+/**
+* Closed registry for topik-asset-reference-v1. Extractors never infer a slot from an
+* attribute name and never recursively inspect arbitrary strings.
+*/
+const topikAssetReferenceSlots = Object.freeze([
+	{
+		node: "image",
+		attribute: "src",
+		slot: "image.src",
+		role: "image"
+	},
+	{
+		node: "tag",
+		tag: "figure",
+		attribute: "src",
+		slot: "figure.src",
+		role: "image-light"
+	},
+	{
+		node: "tag",
+		tag: "figure",
+		attribute: "darkSrc",
+		slot: "figure.darkSrc",
+		role: "image-dark"
+	},
+	{
+		node: "link",
+		attribute: "href",
+		slot: "link.href",
+		role: "download",
+		conditional: "proven-download"
+	}
+]);
+for (const slot of topikAssetReferenceSlots) Object.freeze(slot);
+/** @internal Ordinary navigation shares URL policy, but is not an asset location. */
+function requiresAssetValidation(occurrence) {
+	return occurrence.slot !== "link.href" || occurrence.kind === "asset" || occurrence.kind === "reserved-asset" || /^https?:/iu.test(occurrence.parsedReference);
+}
+function reservedScheme(value) {
+	const decoded = value.replace(/%([0-9a-f]{2})/giu, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+	return /^asset:/iu.test(decoded);
+}
+function classify(reference, parsed) {
+	if (reservedScheme(reference) || reservedScheme(parsed)) {
+		const result = validateTopikAssetReference(reference);
+		return reference === parsed && result.valid && result.kind === "asset" ? "asset" : "reserved-asset";
+	}
+	return reference === parsed ? validateTopikAssetReference(reference).kind : "unsafe";
+}
+/** @internal Keep the source node available for diagnostics without extending the occurrence protocol. */
+function locateDocumentAssetOccurrences(document, source, options, index = indexDocument(document)) {
+	const proven = new Set(options.provenDownloadPaths ?? []);
+	const referenceFromSource = source === void 0 ? void 0 : createReferenceSourceLookup(source, () => indexDocument(parseTopikContent(source, { config: options.config })));
+	const result = [];
+	for (const { node: untyped, path } of index.entries) {
+		const node = untyped;
+		const referenceForm = node.type === "imageReference" || node.type === "linkReference";
+		const definition = isReference(node) ? index.resolve(node) : void 0;
+		const image = node.type === "image" || node.type === "imageReference";
+		const link = node.type === "link" || node.type === "linkReference";
+		const figure = node.type === "topikComponent" && node.name === "figure";
+		if (!image && !link && !figure) continue;
+		for (const slot of topikAssetReferenceSlots) {
+			if (slot.node === "image" ? !image : slot.node === "link" ? !link : !figure) continue;
+			const resource = definition ?? node;
+			const parsedReference = figure ? node.props?.[slot.attribute] : resource.url;
+			if (typeof parsedReference !== "string") continue;
+			const reference = figure || referenceFromSource === void 0 ? parsedReference : referenceFromSource(resource);
+			const kind = classify(reference, parsedReference);
+			if (link && !options.includeGenericLinkCandidates && kind !== "asset" && kind !== "reserved-asset") {
+				const validation = validateTopikAssetReference(reference);
+				if (!validation.valid || validation.kind !== "local" || !proven.has(validation.decodedPath)) continue;
+			}
+			const alt = figure ? node.props?.alt : node.alt;
+			const title = resource.title;
+			const caption = figure ? node.props?.caption : void 0;
+			const occurrence = {
+				position: `${path.map((index) => `/children/${index}`).join("")}/attributes/${slot.attribute}`,
+				treePath: path,
+				slot: slot.slot,
+				role: slot.role,
+				parsedReference,
+				reference,
+				kind,
+				semantics: {
+					...typeof alt === "string" ? {
+						alt,
+						decorative: alt.length === 0
+					} : {},
+					...alt && typeof alt === "object" ? { altTemplate: structuredClone(alt) } : {},
+					...typeof title === "string" ? { title } : {},
+					...typeof caption === "string" ? { caption } : {},
+					...caption && typeof caption === "object" ? { captionTemplate: structuredClone(caption) } : {},
+					...slot.slot === "figure.src" ? { lightDarkRole: "light" } : {},
+					...slot.slot === "figure.darkSrc" ? { lightDarkRole: "dark" } : {},
+					...link ? { linkLabel: plainText(node) } : {}
+				}
+			};
+			result.push({
+				occurrence,
+				node,
+				replace(value) {
+					if (figure) {
+						node.props[slot.attribute] = value;
+						return;
+					}
+					if (referenceForm) {
+						node.type = image ? "image" : "link";
+						node.title = definition?.title ?? null;
+						delete node.identifier;
+						delete node.referenceType;
+						delete node.label;
+					}
+					node.url = value;
+				}
+			});
+		}
+	}
+	return result;
+}
+function extractTopikAssetOccurrences(source, options = {}) {
+	return extractDocumentAssetOccurrences(parseTopikContent(source, { config: options.config }), source, options);
+}
+/** @internal Reuse the parsed document during source admission. */
+function extractDocumentAssetOccurrences(document, source, options = {}, index) {
+	return locateDocumentAssetOccurrences(document, source, options, index).map(({ occurrence }) => occurrence);
+}
+/** @internal Validation must complete before user replacement callbacks run. */
+function rewriteDocumentAssetOccurrences(document, source, replace, options = {}, index) {
+	for (const located of locateDocumentAssetOccurrences(document, source, options, index)) {
+		const value = replace(located.occurrence);
+		if (value !== void 0) located.replace(value);
+	}
+}
+/** Remove unsafe destinations from a preview tree, retaining readable descriptions. */
+function removeInvalidTopikAssetReferences(document, source, options = {}) {
+	const removed = /* @__PURE__ */ new Set();
+	for (const { occurrence, node } of locateDocumentAssetOccurrences(document, source, {
+		...options,
+		includeGenericLinkCandidates: true
+	})) {
+		if (!(occurrence.slot === "link.href" && validateTopikHref(occurrence.parsedReference).length > 0 || requiresAssetValidation(occurrence) && (occurrence.kind === "unsafe" || occurrence.kind === "reserved-asset"))) continue;
+		if (occurrence.slot === "figure.darkSrc") delete node.props.darkSrc;
+		else removed.add(node);
+	}
+	if (removed.size === 0) return;
+	function sanitize(node, inline = false) {
+		const hadChildren = Boolean(node.children?.length);
+		if (node.children) {
+			const inlineChildren = inlineParentTypes.has(node.type) || node.type === "topikComponent" && inline;
+			node.children = node.children.flatMap((child) => sanitize(child, inlineChildren));
+			if (inlineParentTypes.has(node.type) && node.type !== "link" && node.type !== "linkReference") while (node.children.at(-1)?.type === "break") node.children.pop();
+		}
+		if (removed.has(node)) {
+			if (node.type === "link" || node.type === "linkReference") return node.children ?? [];
+			const figure = node.type === "topikComponent";
+			const value = figure ? [node.props?.alt, node.props?.caption].filter((part) => typeof part === "string" && part.length > 0).join("\n") : node.alt ?? "";
+			if (!value) return [];
+			const text = {
+				type: "text",
+				value,
+				position: node.position
+			};
+			return figure ? [{
+				type: "paragraph",
+				children: [text],
+				position: node.position
+			}] : [text];
+		}
+		if (hadChildren && node.children?.length === 0 && ([
+			"paragraph",
+			"emphasis",
+			"strong",
+			"delete"
+		].includes(node.type) || node.type === "topikComponent" && inline)) return [];
+		return [node];
+	}
+	sanitize(document);
+}
+//#endregion
+//#region src/custom-assets.ts
+/** Custom assets share URL admission, but do not extend the compiler's closed slot protocol. */
+function validateCustomAssetReferences(document, registry, allowCompiled, index = indexDocument(document)) {
+	const issues = [];
+	for (const { node } of index.entries) {
+		if (node.type !== "topikComponent" || !node.name || Object.hasOwn(components, node.name)) continue;
+		const definition = Object.hasOwn(registry, node.name) ? registry[node.name] : void 0;
+		if (!definition) continue;
+		const props = getEffectiveProps({
+			name: node.name,
+			props: node.props ?? {}
+		}, registry);
+		for (const [name, attribute] of Object.entries(definition.attributes)) {
+			if (!attribute.asset && !attribute.assetReference) continue;
+			const reference = props[name];
+			if (typeof reference !== "string") continue;
+			const result = validateTopikAssetReference(reference);
+			if (result.valid && (result.kind !== "asset" || allowCompiled)) continue;
+			issues.push({
+				id: /^asset:/iu.test(reference) ? "TOPIK_ASSET_REFERENCE_MALFORMED" : !result.valid && result.failureKind === "external" ? "TOPIK_EXTERNAL_REFERENCE_UNSAFE" : "TOPIK_ASSET_PATH_INVALID",
+				type: `${node.name}.${name}`,
+				lines: node.position ? [node.position.start.line] : []
+			});
+		}
+	}
+	return issues;
+}
+//#endregion
+//#region src/source.ts
+function writeFailure(source, file) {
+	return {
+		ok: false,
+		source,
+		diagnostics: [sanitizeTopikContentDiagnostic({
+			id: "topik-write-failed",
+			type: "document",
+			level: "error",
+			message: "",
+			lines: [],
+			...file === void 0 ? {} : { file }
+		})]
+	};
+}
+function prepareSource(source, options = {}) {
+	const errors = [];
+	function add(id, type = "document", lines = [], option, column) {
+		errors.push(sanitizeTopikContentDiagnostic({
+			id,
+			type,
+			level: [
+				"topik-config-invalid",
+				"tag-undefined",
+				"node-undefined",
+				"parse-error",
+				"topik-extension-failed"
+			].includes(id) ? "critical" : "error",
+			message: "",
+			lines,
+			...option === void 0 ? {} : { option },
+			...column === void 0 ? {} : { column },
+			...options.file === void 0 ? {} : { file: options.file }
+		}));
+	}
+	function failure() {
+		return {
+			ok: false,
+			source,
+			diagnostics: [...new Map(errors.map((error) => [JSON.stringify(error), error])).values()]
+		};
+	}
+	let config;
+	try {
+		config = mergeTopikContentConfig(options.config);
+	} catch {
+		add("topik-config-invalid");
+		return failure();
+	}
+	try {
+		const parsed = parseDocumentTree(source, config.components);
+		for (const diagnostic of parsed.diagnostics) add(diagnostic.id ?? "parse-error", diagnostic.type, diagnostic.line ? [diagnostic.line] : [], diagnostic.option, diagnostic.column);
+		if (!parsed.document) return failure();
+		const index = parsed.index ?? indexDocument(parsed.document);
+		for (const issue of validateCustomAssetReferences(parsed.document, config.components, options.allowCompiledAssetReferences === true, index)) add(issue.id, issue.type, issue.lines);
+		const analysis = analyzeDocument(parsed.document, options.file, index);
+		errors.push(...analysis.diagnostics);
+		for (const link of analysis.links) {
+			const validate = link.kind === "card" ? validateTopikNavigationHref : validateTopikHref;
+			for (const issue of validate(link.href)) add(issue.id, link.kind, link.lines);
+		}
+		for (const { occurrence, node } of locateDocumentAssetOccurrences(parsed.document, source, { includeGenericLinkCandidates: true }, index)) {
+			if (!requiresAssetValidation(occurrence)) continue;
+			const validation = validateTopikAssetReference(occurrence.reference || occurrence.parsedReference);
+			if (validation.valid && occurrence.kind !== "unsafe" && (validation.kind !== "asset" || options.allowCompiledAssetReferences)) continue;
+			const reserved = occurrence.kind === "asset" || occurrence.kind === "reserved-asset";
+			const external = validation.valid ? validation.kind === "external-https" : validation.failureKind === "external";
+			add(reserved ? "TOPIK_ASSET_REFERENCE_MALFORMED" : external ? "TOPIK_EXTERNAL_REFERENCE_UNSAFE" : "TOPIK_ASSET_PATH_INVALID", occurrence.slot, node.position ? [node.position.start.line] : []);
+		}
+		if (errors.length === 0) return {
+			ok: true,
+			source,
+			document: parsed.document,
+			config,
+			index,
+			diagnostics: []
+		};
+	} catch {
+		add("topik-extension-failed");
+	}
+	return failure();
+}
+//#endregion
+//#region src/validate.ts
+/** Source admission is the same boundary used by formatting and asset rewriting. */
+function validateTopikContent(source, options = {}) {
+	const result = prepareSource(source, options);
+	return {
+		source,
+		valid: result.ok,
+		errors: result.diagnostics
+	};
+}
+//#endregion
+//#region src/format.ts
+/** Validate source before formatting so unsupported input remains an exact opaque handoff. */
+function formatTopikContent(source, options = {}) {
+	const prepared = prepareSource(source, options);
+	if (!prepared.ok) return prepared;
+	let formatted;
+	try {
+		formatted = serializeDocument(prepared.document, prepared.config.components);
+	} catch {
+		return writeFailure(source, options.file);
+	}
+	const output = prepareSource(formatted, {
+		...options,
+		config: prepared.config
+	});
+	if (!output.ok) return {
+		ok: false,
+		source,
+		diagnostics: output.diagnostics
+	};
+	if (!sameDocumentMeaning(prepared.document, output.document)) return writeFailure(source, options.file);
+	return {
+		ok: true,
+		source,
+		diagnostics: [],
+		formatted
+	};
+}
+//#endregion
+//#region src/rewrite.ts
+function rewriteTopikAssetOccurrences(source, replace, options = {}) {
+	const prepared = prepareSource(source, options);
+	if (!prepared.ok) return prepared;
+	rewriteDocumentAssetOccurrences(prepared.document, source, replace, options, prepared.index);
+	let content;
+	try {
+		content = serializeDocument(prepared.document, prepared.config.components);
+	} catch {
+		return writeFailure(source, options.file);
+	}
+	const output = prepareSource(content, {
+		file: options.file,
+		config: prepared.config,
+		allowCompiledAssetReferences: true
+	});
+	if (!output.ok) return {
+		ok: false,
+		source,
+		diagnostics: output.diagnostics
+	};
+	if (!sameDocumentMeaning(prepared.document, output.document)) return writeFailure(source, options.file);
+	return {
+		ok: true,
+		source,
+		diagnostics: [],
+		content
+	};
+}
+//#endregion
+//#region src/navigation-rewrite.ts
+/** Rewrite actual navigation references, retaining definitions/scopes and every authored branch. */
+function rewriteTopikNavigationReferences(source, replace, options = {}) {
+	const prepared = prepareSource(source, options);
+	if (!prepared.ok) return prepared;
+	const index = indexDocument(prepared.document);
+	const changes = [];
+	const targets = /* @__PURE__ */ new Map();
+	const imageDefinitions = /* @__PURE__ */ new Set();
+	for (const { node } of index.entries) {
+		if (node.type !== "imageReference" || !isReference(node)) continue;
+		const definition = index.resolve(node);
+		if (definition) imageDefinitions.add(definition);
+	}
+	for (const { node, path } of index.entries) {
+		const kind = node.type === "link" || node.type === "linkReference" ? "link" : node.type === "topikComponent" && node.name === "card" ? "card" : void 0;
+		if (!kind) continue;
+		const target = isReference(node) ? index.resolve(node) : node;
+		if (!target) return writeFailure(source, options.file);
+		const href = kind === "card" ? node.props?.href : target.url;
+		if (typeof href !== "string") continue;
+		const reference = {
+			href,
+			kind,
+			position: path.join("/")
+		};
+		const replacement = replace(reference) ?? href;
+		const prior = targets.get(target);
+		if (prior !== void 0 && prior !== replacement || replacement !== href && imageDefinitions.has(target)) return writeFailure(source, options.file);
+		targets.set(target, replacement);
+		if (replacement !== href) changes.push({
+			...reference,
+			replacement
+		});
+	}
+	if (!changes.length) return {
+		ok: true,
+		content: source,
+		changes,
+		diagnostics: []
+	};
+	for (const [node, replacement] of targets) if (node.type === "topikComponent") node.props.href = replacement;
+	else node.url = replacement;
+	let content;
+	try {
+		content = writeDocument(prepared.document, prepared.config.components);
+	} catch {
+		return writeFailure(source, options.file);
+	}
+	const output = prepareSource(content, {
+		...options,
+		config: prepared.config
+	});
+	if (!output.ok || !sameDocumentMeaning(prepared.document, output.document)) return writeFailure(source, options.file);
+	return {
+		ok: true,
+		content,
+		changes,
+		diagnostics: []
+	};
+}
+//#endregion
+//#region src/render.ts
+var ContentTag = class {
+	name;
+	attributes;
+	children;
+	type = "element";
+	constructor(name, attributes = {}, children = []) {
+		this.name = name;
+		this.attributes = attributes;
+		this.children = children;
+	}
+};
+function isContentTag(value) {
+	return value !== null && typeof value === "object" && "type" in value && value.type === "element" && "name" in value && typeof value.name === "string" && "attributes" in value && value.attributes !== null && typeof value.attributes === "object" && "children" in value && Array.isArray(value.children);
+}
+/** Render a validated authored document through a separate evaluated document. */
+function transformTopikContent(document, options = {}) {
+	return transformDocument(document, mergeTopikContentConfig(options));
+}
+/** @internal Source compilation already owns an isolated configuration snapshot. */
+function transformDocument(document, config) {
+	const resolved = evaluateDocumentForRendering(document, config.variables, config.components);
+	assertCodePresentationOutputLimit(resolved);
+	function render(node, looseList = false) {
+		const children = () => "children" in node ? node.children.map((child) => render(child)) : [];
+		const tag = (name, attributes = {}, body = children()) => new ContentTag(name, attributes, body);
+		switch (node.type) {
+			case "root": return tag("article");
+			case "text": return node.value;
+			case "paragraph": return tag("p");
+			case "heading": return tag(`h${node.depth}`, { id: node.data?.hProperties?.id });
+			case "strong": return tag("strong");
+			case "emphasis": return tag("em");
+			case "delete": return tag("s");
+			case "inlineCode": return tag("TopikInlineCode", {}, [node.value]);
+			case "code": return tag(node.lang === "mermaid" ? "TopikMermaid" : "TopikCodeBlock", {
+				payload: node.value,
+				content: `${node.value}\n`,
+				language: node.lang ?? ""
+			}, []);
+			case "topikCodePresentation": {
+				const code = node.children[0];
+				if (code.type !== "code") throw new Error("Presented code must be evaluated first");
+				return tag("TopikCodeBlock", {
+					payload: code.value,
+					content: `${code.value}\n`,
+					language: code.lang ?? "",
+					presentation: effectiveCodePresentationOptions(normalizeCodePresentationOptions(node.options, codePresentationRows(code.value)))
+				}, []);
+			}
+			case "break": return tag("br", {}, []);
+			case "thematicBreak": return tag("hr", {}, []);
+			case "blockquote": return tag("blockquote");
+			case "list": {
+				const loose = node.spread === true || node.children.some((item) => item.spread ?? item.children.length > 1);
+				return tag(node.ordered ? "ol" : "ul", node.ordered && node.start != null && node.start !== 1 ? { start: node.start } : {}, node.children.map((item) => render(item, loose)));
+			}
+			case "listItem": {
+				const body = node.children.flatMap((child) => !looseList && child.type === "paragraph" ? child.children.map((item) => render(item)) : [render(child)]);
+				if (typeof node.checked === "boolean") {
+					const checkbox = new ContentTag("input", {
+						type: "checkbox",
+						checked: node.checked,
+						disabled: true
+					});
+					if (looseList && isContentTag(body[0]) && body[0].name === "p") body[0].children.unshift(checkbox);
+					else body.unshift(checkbox);
+				}
+				return tag("li", {}, body);
+			}
+			case "image": return tag("TopikImage", {
+				src: node.url,
+				alt: node.alt ?? "",
+				...node.title != null ? { title: node.title } : {}
+			}, []);
+			case "link": return tag("TopikLink", {
+				href: node.url,
+				...node.title != null ? { title: node.title } : {}
+			});
+			case "yaml":
+			case "definition": return null;
+			case "table": {
+				const width = node.children[0].children.length;
+				const rows = node.children.map((row, rowIndex) => new ContentTag("TopikTableRow", {}, Array.from({ length: width }, (_, column) => new ContentTag(rowIndex === 0 ? "TopikTableHeader" : "TopikTableCell", node.align?.[column] ? { align: node.align[column] } : {}, (row.children[column]?.children ?? []).map((child) => render(child))))));
+				return tag("TopikTable", {}, [new ContentTag("thead", {}, rows.slice(0, 1)), new ContentTag("tbody", {}, rows.slice(1))]);
+			}
+			case "topikComponent": {
+				const definition = config.components[node.name];
+				if (definition.render === false) return null;
+				if (definition.render === true) return children();
+				return tag(definition.render, getEffectiveProps(node, config.components));
+			}
+			default: throw new Error(`Unsupported evaluated content node ${node.type}`);
+		}
+	}
+	return render(resolved);
+}
+//#endregion
+//#region src/compile.ts
+/** Admit source once, including compiled asset references, and produce a reader tree. */
+function compileTopikContent(source, options = {}) {
+	const prepared = prepareSource(source, {
+		file: options.file,
+		config: options.config,
+		allowCompiledAssetReferences: true
+	});
+	if (!prepared.ok) {
+		for (const diagnostic of prepared.diagnostics) options.onDiagnostic?.(diagnostic);
+		return prepared;
+	}
+	try {
+		return {
+			ok: true,
+			source,
+			diagnostics: [],
+			tree: transformDocument(prepared.document, prepared.config)
+		};
+	} catch (error) {
+		const diagnostic = sanitizeTopikContentDiagnostic({
+			id: error instanceof TemplateEvaluationError || error instanceof ContentLimitError ? error.id : "topik-transform-failed",
+			type: error instanceof TemplateEvaluationError ? error.type : "document",
+			level: error instanceof TemplateEvaluationError ? "error" : "critical",
+			message: "",
+			lines: error instanceof TemplateEvaluationError ? error.lines : [],
+			...error instanceof TemplateEvaluationError && error.attribute !== void 0 ? { attribute: error.attribute } : {},
+			...error instanceof TemplateEvaluationError && error.variable !== void 0 ? { variable: error.variable } : {},
+			...options.file === void 0 ? {} : { file: options.file }
+		});
+		options.onDiagnostic?.(diagnostic);
+		return {
+			ok: false,
+			source,
+			diagnostics: [diagnostic]
+		};
+	}
+}
+//#endregion
+export { BADGE_VARIANTS, CALLOUT_VARIANTS, CODE_PRESENTATION_LIMITS, CONTENT_LIMITS, ContentEvaluationError, ContentLimitError, ContentTag, FORMAT_VERSION, QUIZ_QUESTION_TYPES, TOPIK_ASSET_REFERENCE_VERSION, TOPIK_CONTENT_SCHEMA_VERSION, TOPIK_GENERATED_ASSET_NAME_PATTERN, TOPIK_RESOURCE_REFERENCE_VERSION, analyzeTopikContent, assignTopikHeadingIds, compileTopikContent, components, effectiveCodePresentationOptions, evaluateDocument, extractTopikAssetOccurrences, formatDocument, formatTopikContent, getEffectiveProps, isContentTag, isTopikGeneratedAssetName, mergeTopikContentConfig, parseDocument, parseTopikContent, parseTopikGeneratedAssetName, parseTopikResourceReference, removeInvalidTopikAssetReferences, removeInvalidTopikNavigationReferences, rewriteAssets, rewriteTopikAssetOccurrences, rewriteTopikNavigationReferences, sameDocumentMeaning, sanitizeTopikContentDiagnostic, sanitizeTopikDiagnosticFile, serializeTopikResourceReference, toTopikContentDiagnostic, topikAssetReferenceSlots, topikComponents, topikLinkDiagnosticMessage, transformTopikContent, validateDocument, validateTopikAssetReference, validateTopikBrowserHref, validateTopikContent, validateTopikHref, validateTopikNavigationHref, writeDocument };