@phtngyn/cms 0.1.0-beta.0 → 0.1.0-beta.2

package/src/{AuthoringSchema-BQ5kbhVB.js → Configuration-CA_jvQKG.js}

@@ -1,7 +1,10 @@
-import { n as CmsMarkdownDocument } from "./models-Citx8jBi.js";
-import { a as createEditorNodeId, c as createCmsComarkRenderData, f as toMutableComarkAttributes, l as mutableJson, n as editorMetadata, o as editorNodeId, u as mutableJsonObject } from "./metadata-Czvi3E4K.js";
+import { r as FormCapabilities } from "./Forms-CfcI3tPU.js";
+import { c as resolveCmsComarkAttributes, d as createCmsComarkRenderData, l as withCmsComarkProps, r as formStructureIssues, s as projectCmsEditorComponentAttributes } from "./Forms-DxbkU3_5.js";
+import { C as MarkdownNode, Dt as Locale, Et as CollectionName, Ot as SourceDirectory, Tt as AddressPattern, n as CmsMarkdownDocument } from "./models-DwYioyNV.js";
+import { a as createEditorNodeId, n as editorMetadata, o as editorNodeId } from "./metadata-BEZPWh-3.js";
 import { Effect, Option, Predicate, Schema } from "effect";
-import { resolveAttributes } from "comark/utils";
+import { Extension } from "@tiptap/core";
+import { ySyncPluginKey } from "@tiptap/y-tiptap";
 import { createMarkdownParser } from "comark/parse";
 import alert from "comark/plugins/alert";
 import attributes from "comark/plugins/attributes";
@@ -11,399 +14,7 @@ import headings from "comark/plugins/headings";
 import security from "comark/plugins/security";
 import taskList from "comark/plugins/task-list";
 import toc from "comark/plugins/toc";
-import { Extension } from "@tiptap/core";
-import { ySyncPluginKey } from "@tiptap/y-tiptap";
-
-//#region ../document/src/internal/comark/bindings.ts
-const isJsonObject$3 = Schema.is(Schema.JsonObject);
-const decodeJson = Schema.decodeUnknownOption(Schema.Json);
-/** Normalizes bindings exactly as Comark's framework renderers do before passing props to a component. */
-function resolveCmsComarkAttributes(attributes, renderData) {
-	const resolved = /* @__PURE__ */ new Map();
-	for (const [name, value] of Object.entries(resolveAttributes(toMutableComarkAttributes(attributes), renderData, { parseJson: true }))) {
-		if (Predicate.isUndefined(value)) {
-			resolved.set(name, void 0);
-			continue;
-		}
-		const decoded = decodeJson(value);
-		if (Option.isNone(decoded)) throw new Error(`Comark resolved non-JSON attribute "${name}".`);
-		resolved.set(name, decoded.value);
-	}
-	return resolved;
-}
-/** Projects bindings to editable values while retaining enough metadata to reconstruct their authored form. */
-function projectCmsEditorComponentAttributes(attributes, renderData) {
-	const resolved = resolveCmsComarkAttributes(attributes, renderData);
-	const props = {};
-	for (const [name, value] of resolved) if (!Predicate.isUndefined(value)) props[name] = mutableJson(value);
-	const bindings = {};
-	for (const [authoredName, authoredValue] of Object.entries(attributes)) {
-		if (!authoredName.startsWith(":") || authoredName.length === 1) continue;
-		const name = authoredName.slice(1);
-		if (!resolved.has(name)) continue;
-		const literal = jsonLiteral(authoredValue);
-		if (!Predicate.isString(authoredValue) || literal !== authoredValue) {
-			bindings[name] = { kind: "literal" };
-			continue;
-		}
-		const resolvedValue = resolved.get(name);
-		bindings[name] = Object.assign({
-			expression: authoredValue,
-			kind: "expression"
-		}, Predicate.isUndefined(resolvedValue) ? void 0 : { resolved: mutableJson(resolvedValue) });
-	}
-	return {
-		bindings,
-		props,
-		renderData: withCmsComarkProps(renderData, resolved)
-	};
-}
-/** Reconstructs authored bindings, keeping expressions until a user replaces their resolved value. */
-function encodeCmsEditorComponentAttributes(props, bindings) {
-	const attributes = mutableJsonObject(props);
-	for (const [name, encodedBinding] of Object.entries(bindings)) {
-		const binding = jsonObject$2(encodedBinding);
-		const kind = binding.kind;
-		if (kind !== "literal" && kind !== "expression") continue;
-		const current = props[name];
-		if (Predicate.isUndefined(current)) {
-			const expression = binding.expression;
-			if (kind === "expression" && Predicate.isString(expression)) attributes[`:${name}`] = expression;
-			continue;
-		}
-		delete attributes[name];
-		const expression = binding.expression;
-		const resolved = binding.resolved;
-		attributes[`:${name}`] = kind === "expression" && Predicate.isString(expression) && Object.hasOwn(binding, "resolved") && sameJson(current, resolved) ? expression : mutableJson(current);
-	}
-	return attributes;
-}
-function withCmsComarkProps(renderData, attributes) {
-	return attributes.size > 0 ? {
-		...renderData,
-		props: Object.fromEntries(attributes)
-	} : renderData;
-}
-/** Restores typed component bindings that Comark's block-YAML roundtrip can emit as plain attributes. */
-function normalizeCmsComponentBindings(document, components) {
-	if (!components) return document;
-	return CmsMarkdownDocument.make({
-		frontmatter: document.frontmatter,
-		meta: document.meta,
-		nodes: document.nodes.map((node) => normalizeComponentNode(node, components))
-	});
-}
-function matchesCmsComponentPropType(value, type) {
-	switch (type) {
-		case "array": return Array.isArray(value);
-		case "boolean": return Predicate.isBoolean(value);
-		case "number": return Predicate.isNumber(value);
-		case "object": return isJsonObject$3(value);
-		case "string": return Predicate.isString(value);
-	}
-}
-function normalizeComponentNode(node, components) {
-	if (Predicate.isString(node) || node[0] === null) return node;
-	const [tag, originalAttributes, ...originalChildren] = node;
-	const attributes = mutableJsonObject(originalAttributes);
-	const definition = components.get(tag.toLocaleLowerCase());
-	if (definition) for (const prop of definition.props) {
-		if (prop.type === "string" || `:${prop.name}` in attributes || !(prop.name in attributes)) continue;
-		const value = attributes[prop.name];
-		if (Predicate.isUndefined(value)) continue;
-		if (!matchesCmsComponentPropType(jsonLiteral(value), prop.type)) continue;
-		delete attributes[prop.name];
-		attributes[`:${prop.name}`] = value;
-	}
-	return [
-		tag,
-		attributes,
-		...originalChildren.map((child) => normalizeComponentNode(child, components))
-	];
-}
-function jsonLiteral(value) {
-	if (!Predicate.isString(value)) return value;
-	try {
-		const decoded = decodeJson(JSON.parse(value));
-		return Option.isSome(decoded) ? decoded.value : value;
-	} catch {
-		return value;
-	}
-}
-function jsonObject$2(value) {
-	return isJsonObject$3(value) ? value : {};
-}
-function sameJson(left, right) {
-	return !Predicate.isUndefined(right) && JSON.stringify(left) === JSON.stringify(right);
-}
 
-//#endregion
-//#region ../document/src/internal/comark/source-mapping.ts
-const SOURCE_MAPPINGS_META_KEY = "__cmsSourceMappings";
-const BLOCK_TAGS = /* @__PURE__ */ new Map([
-	["blockquote_open", "blockquote"],
-	["bullet_list_open", "ul"],
-	["list_item_open", "li"],
-	["ordered_list_open", "ol"],
-	["paragraph_open", "p"],
-	["table_open", "table"],
-	["tbody_open", "tbody"],
-	["td_open", "td"],
-	["th_open", "th"],
-	["thead_open", "thead"],
-	["tr_open", "tr"]
-]);
-const ComarkToken = Schema.Struct({
-	attrs: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.Tuple([Schema.String, Schema.String])))),
-	hidden: Schema.optionalKey(Schema.Boolean),
-	level: Schema.optionalKey(Schema.Finite),
-	map: Schema.optionalKey(Schema.NullOr(Schema.Tuple([Schema.Finite, Schema.Finite]))),
-	nesting: Schema.optionalKey(Schema.Finite),
-	tag: Schema.optionalKey(Schema.String),
-	type: Schema.optionalKey(Schema.String)
-});
-const WRAPPER_TAGS = /* @__PURE__ */ new Set([
-	"blockquote",
-	"ol",
-	"pre",
-	"table",
-	"ul"
-]);
-/** Captures the durable source before frontmatter or other pre-parse stages mutate it. */
-function sourceCapturePlugin() {
-	return {
-		name: "cms-source-capture",
-		pre(state) {
-			state.__cmsOriginalMarkdown = state.markdown;
-		}
-	};
-}
-/** Translate Comark block token line maps into exact JavaScript source offsets. */
-function sourceMappingPlugin() {
-	return {
-		name: "cms-source-mapping",
-		post(state) {
-			const source = state.__cmsOriginalMarkdown ?? state.markdown;
-			const descriptors = createBlockDescriptors(state.tokens.flatMap((token) => {
-				const decoded = Schema.decodeUnknownOption(ComarkToken)(token);
-				return decoded._tag === "Some" ? [decoded.value] : [];
-			}), source, state.markdown, state.parsedLines ?? 0);
-			const mappings = [];
-			mapNodes(state.tree.nodes, descriptors, [], mappings);
-			state.tree.meta[SOURCE_MAPPINGS_META_KEY] = mappings;
-		}
-	};
-}
-function createBlockDescriptors(tokens, source, parsedMarkdown, parsedLines) {
-	const roots = [];
-	const stack = [];
-	const sourceLineStarts = indexLineStarts(source);
-	const parsedLineStarts = indexLineStarts(parsedMarkdown);
-	const parsedOffset = source.lastIndexOf(parsedMarkdown);
-	const slotMaps = createSlotTokenMaps(tokens, parsedMarkdown);
-	for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex++) {
-		const token = tokens[tokenIndex];
-		if (!token) continue;
-		const tag = blockTag(token);
-		const tokenMap = token.map ?? slotMaps.get(tokenIndex);
-		if (!tag || !tokenMap) continue;
-		const level = token.level ?? 0;
-		while (true) {
-			const current = stack.at(-1);
-			if (!current || current.level < level) break;
-			stack.pop();
-		}
-		const descriptor = {
-			children: [],
-			range: rangeFromParsedLines(source, sourceLineStarts, parsedMarkdown, parsedLineStarts, parsedOffset, tokenMap[0], tokenMap[1] + (token.type === "mdc_block_open" ? 1 : 0), parsedLines),
-			tag
-		};
-		((stack.at(-1)?.descriptor)?.children ?? roots).push(descriptor);
-		if (token.nesting === 1) stack.push({
-			descriptor,
-			level
-		});
-	}
-	return roots.map(collapseComarkWrapper).map(groupProjectedSlotContent);
-}
-function blockTag(token) {
-	if (token.hidden || !token.type) return void 0;
-	if (token.type === "heading_open") return token.tag;
-	if (token.type === "mdc_block_open" || token.type === "mdc_block_shorthand" && token.nesting !== -1) return token.tag || "component";
-	if (token.type === "mdc_block_slot" && token.nesting === 1) return "template";
-	if ([
-		"fence",
-		"fenced_code_block",
-		"code_block"
-	].includes(token.type)) return "pre";
-	if (token.type === "math_block") return "math";
-	if (token.type === "html_block") return "*";
-	if (token.type === "hr") return "hr";
-	return BLOCK_TAGS.get(token.type);
-}
-function createSlotTokenMaps(tokens, parsedMarkdown) {
-	const maps = /* @__PURE__ */ new Map();
-	const markers = slotMarkers(parsedMarkdown);
-	const stack = [];
-	let nextMarker = 0;
-	for (let index = 0; index < tokens.length; index++) {
-		const token = tokens[index];
-		if (!token || token.type !== "mdc_block_slot") continue;
-		if (token.nesting === 1) {
-			const name = token.attrs?.[0]?.[0]?.replace(/^#/u, "");
-			let markerIndex = nextMarker;
-			while (markerIndex < markers.length && markers[markerIndex]?.name !== name) markerIndex++;
-			const marker = markers[markerIndex];
-			if (marker) {
-				stack.push({
-					index,
-					marker: marker.line
-				});
-				nextMarker = markerIndex + 1;
-			}
-			continue;
-		}
-		if (token.nesting !== -1) continue;
-		const open = stack.pop();
-		if (!open) continue;
-		let endLine = open.marker + 1;
-		for (let childIndex = open.index + 1; childIndex < index; childIndex++) {
-			const child = tokens[childIndex];
-			const map = child?.map ?? maps.get(childIndex);
-			if (child && map) endLine = Math.max(endLine, map[1] + (child.type === "mdc_block_open" ? 1 : 0));
-		}
-		maps.set(open.index, [open.marker, endLine]);
-	}
-	return maps;
-}
-function slotMarkers(source) {
-	return source.split(/\r?\n/u).flatMap((line, index) => {
-		const name = line.match(/^\s*#([^\s{]+)/u)?.[1];
-		return name ? [{
-			line: index,
-			name
-		}] : [];
-	});
-}
-function collapseComarkWrapper(descriptor) {
-	const children = descriptor.children.map(collapseComarkWrapper);
-	if (WRAPPER_TAGS.has(descriptor.tag) && children.length === 1 && children[0]?.tag === descriptor.tag) return {
-		...descriptor,
-		children: children[0].children
-	};
-	return {
-		...descriptor,
-		children
-	};
-}
-/** Comark projects siblings after a named slot into that active slot. */
-function groupProjectedSlotContent(descriptor) {
-	const grouped = [];
-	let activeSlot;
-	for (const rawChild of descriptor.children) {
-		const child = groupProjectedSlotContent(rawChild);
-		if (child.tag === "template") {
-			activeSlot = child;
-			grouped.push(child);
-			continue;
-		}
-		if (!activeSlot) {
-			grouped.push(child);
-			continue;
-		}
-		activeSlot.children.push(child);
-		if (child.range.end.offset > activeSlot.range.end.offset) activeSlot.range = {
-			start: activeSlot.range.start,
-			end: child.range.end
-		};
-	}
-	return {
-		...descriptor,
-		children: grouped
-	};
-}
-function mapNodes(nodes, descriptors, parentPath, mappings) {
-	let descriptorIndex = 0;
-	for (let nodeIndex = 0; nodeIndex < nodes.length; nodeIndex++) {
-		const node = nodes[nodeIndex];
-		if (!node || !isElementNode$1(node)) continue;
-		let matchIndex = descriptorIndex;
-		while (matchIndex < descriptors.length && descriptors[matchIndex]?.tag !== "*" && descriptors[matchIndex]?.tag !== node[0]) matchIndex++;
-		const descriptor = descriptors[matchIndex];
-		if (!descriptor) continue;
-		descriptorIndex = matchIndex + 1;
-		const nodePath = [...parentPath, nodeIndex];
-		mappings.push({
-			nodePath,
-			range: descriptor.range
-		});
-		const [, , ...children] = node;
-		mapNodes(children, descriptor.children, nodePath, mappings);
-	}
-}
-function isElementNode$1(node) {
-	return Array.isArray(node) && Predicate.isString(node[0]);
-}
-function indexLineStarts(source) {
-	const starts = [0];
-	for (let offset = 0; offset < source.length; offset++) if (source.charCodeAt(offset) === 10) starts.push(offset + 1);
-	return starts;
-}
-function rangeFromParsedLines(source, sourceLineStarts, parsedMarkdown, parsedLineStarts, parsedOffset, startLine, endLine, fallbackLineOffset) {
-	const startOffset = parsedOffset >= 0 ? parsedOffset + (parsedLineStarts[startLine] ?? parsedMarkdown.length) : sourceLineStarts[startLine + fallbackLineOffset] ?? source.length;
-	const endOffset = parsedOffset >= 0 ? parsedOffset + (parsedLineStarts[endLine] ?? parsedMarkdown.length) : sourceLineStarts[endLine + fallbackLineOffset] ?? source.length;
-	return {
-		start: pointAt(source, sourceLineStarts, startOffset),
-		end: pointAt(source, sourceLineStarts, Math.max(startOffset, endOffset))
-	};
-}
-function pointAt(source, lineStarts, rawOffset) {
-	const offset = Math.min(Math.max(rawOffset, 0), source.length);
-	let low = 0;
-	let high = lineStarts.length - 1;
-	while (low < high) {
-		const middle = Math.ceil((low + high) / 2);
-		if ((lineStarts[middle] ?? source.length) <= offset) low = middle;
-		else high = middle - 1;
-	}
-	return {
-		offset,
-		line: low + 1,
-		column: offset - (lineStarts[low] ?? 0) + 1
-	};
-}
-
-//#endregion
-//#region ../document/src/internal/comark/grammar.ts
-/**
-* Changes when parsing, normalization, or projection semantics change. Stored
-* with compiled documents so migrations can identify stale derived content.
-*/
-const DOCUMENT_ENGINE_FINGERPRINT = "comark@0.6.2/frontmatter+alert+task-list+components+attributes+security+headings+toc+source-mapping/v1";
-/** One explicit grammar for authoring, preview, delivery, and analysis projections. */
-function createDocumentParser() {
-	return createMarkdownParser({
-		autoClose: false,
-		registerDefaultPlugins: false,
-		plugins: [
-			sourceCapturePlugin(),
-			frontmatter(),
-			alert(),
-			taskList(),
-			components(),
-			attributes(),
-			security(),
-			headings(),
-			toc({
-				depth: 5,
-				searchDepth: 6
-			}),
-			sourceMappingPlugin()
-		]
-	});
-}
-
-//#endregion
 //#region ../document/src/internal/editor/attributes.ts
 function compactJsonAttributes(attributes) {
 	return Object.fromEntries(Object.entries(attributes).filter((entry) => entry[1] !== void 0));
@@ -578,11 +189,11 @@ function decodeBlock(node, context, renderData) {
 			content: decodeBlocks(children, context, childRenderData)
 		};
 		case "pre": {
-			const code = children.find(isElementNode);
+			const code = children.find(isElementNode$1);
 			return {
 				type: "codeBlock",
 				attrs: mergeJsonAttributes(commonAttrs, { language: nonEmptyStringAttribute(attrs.language) ?? nonEmptyStringAttribute(code?.[1].class)?.replace(/^language-/u, "") }),
-				content: textContent$1(code ? elementChildren(code) : children)
+				content: textContent(code ? elementChildren(code) : children)
 			};
 		}
 		case "hr": return {
@@ -643,7 +254,7 @@ function decodeSlot(node, context, renderData) {
 	};
 }
 function decodeListItems(nodes, context, renderData) {
-	return nodes.filter(isElementNode).filter((node) => node[0] === "li").map((node) => decodeBlock(node, context, renderData));
+	return nodes.flatMap((node) => isElementNode$1(node) && node[0] === "li" ? [decodeBlock(node, context, renderData)] : []);
 }
 function decodeInlines(nodes, context, renderData, inheritedMarks = []) {
 	const result = [];
@@ -681,105 +292,368 @@ function decodeInlines(nodes, context, renderData, inheritedMarks = []) {
 			result.push(withMarks({ type: "hardBreak" }, inheritedMarks));
 			continue;
 		}
-		if (node[0] === "img") {
-			result.push(withMarks({
-				type: "image",
-				attrs: mergeJsonAttributes(decodeEditorImageAttributes(cleanAttrs(node[1])), { cmsNodeId: claimIdentity(context, node[1]) })
-			}, inheritedMarks));
-			continue;
+		if (node[0] === "img") {
+			result.push(withMarks({
+				type: "image",
+				attrs: mergeJsonAttributes(decodeEditorImageAttributes(cleanAttrs(node[1])), { cmsNodeId: claimIdentity(context, node[1]) })
+			}, inheritedMarks));
+			continue;
+		}
+		result.push(withMarks({
+			type: "cmsInlineOpaque",
+			attrs: {
+				label: node[0],
+				node: stripInternalMetadata(node)
+			}
+		}, inheritedMarks));
+	}
+	return result;
+}
+function claimIdentity(context, attributes) {
+	return claimIdentityValue(context, attributes ? editorMetadata(attributes)?.nodeId : void 0);
+}
+function claimIdentityValue(context, candidate) {
+	const existing = editorNodeId(candidate);
+	if (existing !== void 0 && !context.usedIds.has(existing)) {
+		context.usedIds.add(existing);
+		return existing;
+	}
+	for (let attempt = 0; attempt < 100; attempt++) {
+		const created = createEditorNodeId();
+		if (!context.usedIds.has(created)) {
+			context.usedIds.add(created);
+			return created;
+		}
+	}
+	throw new Error("The editor identity factory did not produce a unique identity.");
+}
+function opaqueBlock(node, label, cmsNodeId) {
+	return {
+		type: "cmsOpaque",
+		attrs: {
+			cmsNodeId,
+			label,
+			node: stripInternalMetadata(node)
+		}
+	};
+}
+function stripInternalMetadata(node) {
+	if (node[0] === null) return [
+		null,
+		cleanAttrs(node[1]),
+		node[2]
+	];
+	const [tag, attributes, ...children] = node;
+	return [
+		tag,
+		cleanAttrs(attributes),
+		...children.map((child) => Predicate.isString(child) ? child : stripInternalMetadata(child))
+	];
+}
+function slotContent(content) {
+	return content.length ? content : [{
+		type: "paragraph",
+		attrs: { cmsSynthetic: true }
+	}];
+}
+function slotName(attrs) {
+	return nonEmptyStringAttribute(attrs.name) ?? "default";
+}
+function cleanAttrs(attrs) {
+	const { $: _internal, "data-cms-node": _marker, ...clean } = attrs;
+	return structuredClone(clean);
+}
+function textContent(nodes) {
+	const text = nodes.map((node) => Predicate.isString(node) ? node : node[0] === null ? node[2] : textContent(elementChildren(node))?.map((child) => child.text ?? "").join("") ?? "").join("");
+	return text ? [{
+		type: "text",
+		text
+	}] : void 0;
+}
+function isInlineElement(node) {
+	return node[0] !== null && (isComarkMark(node[0]) || node[0] === "br" || node[0] === "img" || jsonObject(node[1].$).block === 0);
+}
+function isSlotTemplate(node) {
+	return isElementNode$1(node) && node[0] === "template";
+}
+function isElementNode$1(node) {
+	return Array.isArray(node) && Predicate.isString(node[0]);
+}
+function elementChildren(node) {
+	const [, , ...children] = node;
+	return children;
+}
+function jsonObject(value) {
+	return isJsonObject$1(value) ? value : {};
+}
+function mergeJsonAttributes(attributes, additions) {
+	return compactJsonAttributes(Object.assign({}, attributes, additions));
+}
+function withMarks(content, marks) {
+	return marks.length ? Object.assign({}, content, { marks }) : content;
+}
+
+//#endregion
+//#region ../document/src/internal/comark/source-mapping.ts
+const SOURCE_MAPPINGS_META_KEY = "__cmsSourceMappings";
+const BLOCK_TAGS = /* @__PURE__ */ new Map([
+	["blockquote_open", "blockquote"],
+	["bullet_list_open", "ul"],
+	["list_item_open", "li"],
+	["ordered_list_open", "ol"],
+	["paragraph_open", "p"],
+	["table_open", "table"],
+	["tbody_open", "tbody"],
+	["td_open", "td"],
+	["th_open", "th"],
+	["thead_open", "thead"],
+	["tr_open", "tr"]
+]);
+const ComarkToken = Schema.Struct({
+	attrs: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.Tuple([Schema.String, Schema.String])))),
+	hidden: Schema.optionalKey(Schema.Boolean),
+	level: Schema.optionalKey(Schema.Finite),
+	map: Schema.optionalKey(Schema.NullOr(Schema.Tuple([Schema.Finite, Schema.Finite]))),
+	nesting: Schema.optionalKey(Schema.Finite),
+	tag: Schema.optionalKey(Schema.String),
+	type: Schema.optionalKey(Schema.String)
+});
+const WRAPPER_TAGS = /* @__PURE__ */ new Set([
+	"blockquote",
+	"ol",
+	"pre",
+	"table",
+	"ul"
+]);
+function sourceCapturePlugin() {
+	return {
+		name: "cms-source-capture",
+		pre(state) {
+			state.__cmsOriginalMarkdown = state.markdown;
+		}
+	};
+}
+function sourceMappingPlugin() {
+	return {
+		name: "cms-source-mapping",
+		post(state) {
+			const source = state.__cmsOriginalMarkdown ?? state.markdown;
+			const descriptors = createBlockDescriptors(state.tokens.flatMap((token) => {
+				const decoded = Schema.decodeUnknownOption(ComarkToken)(token);
+				return Option.isSome(decoded) ? [decoded.value] : [];
+			}), source, state.markdown, state.parsedLines ?? 0);
+			const mappings = [];
+			mapNodes(state.tree.nodes, descriptors, [], mappings);
+			state.tree.meta[SOURCE_MAPPINGS_META_KEY] = mappings;
+		}
+	};
+}
+function createBlockDescriptors(tokens, source, parsedMarkdown, parsedLines) {
+	const roots = [];
+	const stack = [];
+	const sourceLineStarts = indexLineStarts(source);
+	const parsedLineStarts = indexLineStarts(parsedMarkdown);
+	const parsedOffset = source.lastIndexOf(parsedMarkdown);
+	const slotMaps = createSlotTokenMaps(tokens, parsedMarkdown);
+	for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex++) {
+		const token = tokens[tokenIndex];
+		if (!token) continue;
+		const tag = blockTag(token);
+		const tokenMap = token.map ?? slotMaps.get(tokenIndex);
+		if (!tag || !tokenMap) continue;
+		const level = token.level ?? 0;
+		while (true) {
+			const current = stack.at(-1);
+			if (!current || current.level < level) break;
+			stack.pop();
+		}
+		const descriptor = {
+			children: [],
+			range: rangeFromParsedLines(source, sourceLineStarts, parsedMarkdown, parsedLineStarts, parsedOffset, tokenMap[0], tokenMap[1] + (token.type === "mdc_block_open" ? 1 : 0), parsedLines),
+			tag
+		};
+		((stack.at(-1)?.descriptor)?.children ?? roots).push(descriptor);
+		if (token.nesting === 1) stack.push({
+			descriptor,
+			level
+		});
+	}
+	return roots.map(collapseComarkWrapper).map(groupProjectedSlotContent);
+}
+function blockTag(token) {
+	if (token.hidden || !token.type) return void 0;
+	if (token.type === "heading_open") return token.tag;
+	if (token.type === "mdc_block_open" || token.type === "mdc_block_shorthand" && token.nesting !== -1) return token.tag || "component";
+	if (token.type === "mdc_block_slot" && token.nesting === 1) return "template";
+	if ([
+		"fence",
+		"fenced_code_block",
+		"code_block"
+	].includes(token.type)) return "pre";
+	if (token.type === "math_block") return "math";
+	if (token.type === "html_block") return "*";
+	if (token.type === "hr") return "hr";
+	return BLOCK_TAGS.get(token.type);
+}
+function createSlotTokenMaps(tokens, parsedMarkdown) {
+	const maps = /* @__PURE__ */ new Map();
+	const markers = slotMarkers(parsedMarkdown);
+	const stack = [];
+	let nextMarker = 0;
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (!token || token.type !== "mdc_block_slot") continue;
+		if (token.nesting === 1) {
+			const name = token.attrs?.[0]?.[0]?.replace(/^#/u, "");
+			let markerIndex = nextMarker;
+			while (markerIndex < markers.length && markers[markerIndex]?.name !== name) markerIndex++;
+			const marker = markers[markerIndex];
+			if (marker) {
+				stack.push({
+					index,
+					marker: marker.line
+				});
+				nextMarker = markerIndex + 1;
+			}
+			continue;
+		}
+		if (token.nesting !== -1) continue;
+		const open = stack.pop();
+		if (!open) continue;
+		let endLine = open.marker + 1;
+		for (let childIndex = open.index + 1; childIndex < index; childIndex++) {
+			const child = tokens[childIndex];
+			const map = child?.map ?? maps.get(childIndex);
+			if (child && map) endLine = Math.max(endLine, map[1] + (child.type === "mdc_block_open" ? 1 : 0));
 		}
-		result.push(withMarks({
-			type: "cmsInlineOpaque",
-			attrs: {
-				label: node[0],
-				node: stripInternalMetadata(node)
-			}
-		}, inheritedMarks));
+		maps.set(open.index, [open.marker, endLine]);
 	}
-	return result;
+	return maps;
 }
-function claimIdentity(context, attributes) {
-	return claimIdentityValue(context, attributes ? editorMetadata(attributes)?.nodeId : void 0);
+function slotMarkers(source) {
+	return source.split(/\r?\n/u).flatMap((line, index) => {
+		const name = line.match(/^\s*#([^\s{]+)/u)?.[1];
+		return name ? [{
+			line: index,
+			name
+		}] : [];
+	});
 }
-function claimIdentityValue(context, candidate) {
-	const existing = editorNodeId(candidate);
-	if (existing !== void 0 && !context.usedIds.has(existing)) {
-		context.usedIds.add(existing);
-		return existing;
-	}
-	for (let attempt = 0; attempt < 100; attempt++) {
-		const created = createEditorNodeId();
-		if (!context.usedIds.has(created)) {
-			context.usedIds.add(created);
-			return created;
+function collapseComarkWrapper(descriptor) {
+	const children = descriptor.children.map(collapseComarkWrapper);
+	if (WRAPPER_TAGS.has(descriptor.tag) && children.length === 1 && children[0]?.tag === descriptor.tag) return {
+		...descriptor,
+		children: children[0].children
+	};
+	return {
+		...descriptor,
+		children
+	};
+}
+/** Comark projects siblings after a named slot into that active slot. */
+function groupProjectedSlotContent(descriptor) {
+	const grouped = [];
+	let activeSlot;
+	for (const rawChild of descriptor.children) {
+		const child = groupProjectedSlotContent(rawChild);
+		if (child.tag === "template") {
+			activeSlot = child;
+			grouped.push(child);
+			continue;
+		}
+		if (!activeSlot) {
+			grouped.push(child);
+			continue;
 		}
+		activeSlot.children.push(child);
+		if (child.range.end.offset > activeSlot.range.end.offset) activeSlot.range = {
+			start: activeSlot.range.start,
+			end: child.range.end
+		};
 	}
-	throw new Error("The editor identity factory did not produce a unique identity.");
-}
-function opaqueBlock(node, label, cmsNodeId) {
 	return {
-		type: "cmsOpaque",
-		attrs: {
-			cmsNodeId,
-			label,
-			node: stripInternalMetadata(node)
-		}
+		...descriptor,
+		children: grouped
 	};
 }
-function stripInternalMetadata(node) {
-	if (node[0] === null) return [
-		null,
-		cleanAttrs(node[1]),
-		node[2]
-	];
-	const [tag, attributes, ...children] = node;
-	return [
-		tag,
-		cleanAttrs(attributes),
-		...children.map((child) => Predicate.isString(child) ? child : stripInternalMetadata(child))
-	];
-}
-function slotContent(content) {
-	return content.length ? content : [{
-		type: "paragraph",
-		attrs: { cmsSynthetic: true }
-	}];
-}
-function slotName(attrs) {
-	return nonEmptyStringAttribute(attrs.name) ?? "default";
-}
-function cleanAttrs(attrs) {
-	const { $: _internal, "data-cms-node": _marker, ...clean } = attrs;
-	return structuredClone(clean);
-}
-function textContent$1(nodes) {
-	const text = nodes.map((node) => Predicate.isString(node) ? node : node[0] === null ? node[2] : textContent$1(elementChildren(node))?.map((child) => child.text ?? "").join("") ?? "").join("");
-	return text ? [{
-		type: "text",
-		text
-	}] : void 0;
-}
-function isInlineElement(node) {
-	return node[0] !== null && (isComarkMark(node[0]) || node[0] === "br" || node[0] === "img" || jsonObject(node[1].$).block === 0);
-}
-function isSlotTemplate(node) {
-	return isElementNode(node) && node[0] === "template";
+function mapNodes(nodes, descriptors, parentPath, mappings) {
+	let descriptorIndex = 0;
+	for (let nodeIndex = 0; nodeIndex < nodes.length; nodeIndex++) {
+		const node = nodes[nodeIndex];
+		if (!node || !isElementNode(node)) continue;
+		let matchIndex = descriptorIndex;
+		while (matchIndex < descriptors.length && descriptors[matchIndex]?.tag !== "*" && descriptors[matchIndex]?.tag !== node[0]) matchIndex++;
+		const descriptor = descriptors[matchIndex];
+		if (!descriptor) continue;
+		descriptorIndex = matchIndex + 1;
+		const nodePath = [...parentPath, nodeIndex];
+		mappings.push({
+			nodePath,
+			range: descriptor.range
+		});
+		const [, , ...children] = node;
+		mapNodes(children, descriptor.children, nodePath, mappings);
+	}
 }
 function isElementNode(node) {
 	return Array.isArray(node) && Predicate.isString(node[0]);
 }
-function elementChildren(node) {
-	const [, , ...children] = node;
-	return children;
+function indexLineStarts(source) {
+	const starts = [0];
+	for (let offset = 0; offset < source.length; offset++) if (source.charCodeAt(offset) === 10) starts.push(offset + 1);
+	return starts;
 }
-function jsonObject(value) {
-	return isJsonObject$1(value) ? value : {};
+function rangeFromParsedLines(source, sourceLineStarts, parsedMarkdown, parsedLineStarts, parsedOffset, startLine, endLine, fallbackLineOffset) {
+	const startOffset = parsedOffset >= 0 ? parsedOffset + (parsedLineStarts[startLine] ?? parsedMarkdown.length) : sourceLineStarts[startLine + fallbackLineOffset] ?? source.length;
+	const endOffset = parsedOffset >= 0 ? parsedOffset + (parsedLineStarts[endLine] ?? parsedMarkdown.length) : sourceLineStarts[endLine + fallbackLineOffset] ?? source.length;
+	return {
+		start: pointAt(source, sourceLineStarts, startOffset),
+		end: pointAt(source, sourceLineStarts, Math.max(startOffset, endOffset))
+	};
 }
-function mergeJsonAttributes(attributes, additions) {
-	return compactJsonAttributes(Object.assign({}, attributes, additions));
+function pointAt(source, lineStarts, rawOffset) {
+	const offset = Math.min(Math.max(rawOffset, 0), source.length);
+	let low = 0;
+	let high = lineStarts.length - 1;
+	while (low < high) {
+		const middle = Math.ceil((low + high) / 2);
+		if ((lineStarts[middle] ?? source.length) <= offset) low = middle;
+		else high = middle - 1;
+	}
+	return {
+		offset,
+		line: low + 1,
+		column: offset - (lineStarts[low] ?? 0) + 1
+	};
 }
-function withMarks(content, marks) {
-	return marks.length ? Object.assign({}, content, { marks }) : content;
+
+//#endregion
+//#region ../document/src/internal/comark/grammar.ts
+/**
+* Changes when parsing, normalization, or projection semantics change. Stored
+* with compiled documents so migrations can identify stale derived content.
+*/
+const DOCUMENT_ENGINE_FINGERPRINT = "comark@0.6.2/frontmatter+alert+task-list+components+attributes+security+headings+toc+source-mapping/v1";
+function createDocumentParser() {
+	return createMarkdownParser({
+		autoClose: false,
+		registerDefaultPlugins: false,
+		plugins: [
+			sourceCapturePlugin(),
+			frontmatter(),
+			alert(),
+			taskList(),
+			components(),
+			attributes(),
+			security(),
+			headings(),
+			toc({
+				depth: 5,
+				searchDepth: 6
+			}),
+			sourceMappingPlugin()
+		]
+	});
 }
 
 //#endregion
@@ -792,7 +666,6 @@ var EditorRenderFailed = class extends Schema.TaggedError()("EditorDocument.Rend
 
 //#endregion
 //#region ../document/src/AuthoringSchema.ts
-/** Compiles insertion content with the same grammar used for publication. */
 const parseAuthoringContent = Effect.fn("AuthoringSchema.parseContent")(function* (markdown) {
 	const body = yield* Effect.tryPromise({
 		try: () => createDocumentParser()(markdown),
@@ -804,14 +677,53 @@ const parseAuthoringContent = Effect.fn("AuthoringSchema.parseContent")(function
 	return (yield* Schema.decodeUnknownEffect(CmsMarkdownDocument)(body)).nodes;
 });
 const isJsonObject = Schema.is(Schema.JsonObject);
-/** Validates authored blocks during single-document compilation as well as catalog publication. */
-function validateAuthoringDocument(body, components) {
-	if (!components || ![...components.values()].some((component) => component.authoring)) return [];
-	function visit(node) {
-		const component = node.type === "cmsBlock" ? components?.get(String(node.attrs?.tag).toLowerCase()) : void 0;
-		return [...component?.authoring ? createAuthoringSchema(component.name, component.authoring).validate(node, "publish") : [], ...(node.content ?? []).flatMap(visit)];
+function collectionComponents(components, body) {
+	if (!body) return components;
+	return components.filter((component) => body.blocks?.includes(component.name) || component.authoring.group !== void 0 && body.groups?.includes(component.authoring.group));
+}
+/** Configuration errors belong to developers, before an installation adopts the catalog. */
+function validateCollectionBody(components, body) {
+	return [
+		...components.flatMap((component) => component.authoring.slots.flatMap((slot) => [...(slot.blocks ?? []).filter((name) => !components.some((candidate) => candidate.name === name)).map((name) => `Unknown block "${name}" in ${slot.label}.`), ...(slot.groups ?? []).filter((group) => !components.some((candidate) => candidate.authoring.group === group)).map((group) => `Unknown block group "${group}" in ${slot.label}.`)])),
+		...(body?.blocks ?? []).filter((name) => !components.some((component) => component.name === name)).map((name) => `Unknown block "${name}".`),
+		...(body?.groups ?? []).filter((group) => !components.some((component) => component.authoring.group === group)).map((group) => `Unknown block group "${group}".`)
+	];
+}
+function contentIssues(node, schemas, allowed, purpose, collectionAllowed = allowed) {
+	const issues = [];
+	if (node.type === "cmsBlock") {
+		const name = String(node.attrs?.tag).toLowerCase();
+		const schema = schemas.get(name);
+		if (!schema) issues.push("This block is unavailable. Ask your site developer to restore its definition.");
+		else {
+			if (!allowed.has(name)) issues.push(`${schema.definition.label} is not allowed in this content region.`);
+			issues.push(...schema.validate(node, purpose));
+			if (purpose === "publish" && schema.definition.form) issues.push(...formStructureIssues(node.attrs?.props?.steps, schema.definition.form, name));
+		}
+	}
+	if (node.type === "cmsOpaque" || node.type === "cmsInlineOpaque") issues.push("This content is unsupported. Ask your site developer to update it before publishing.");
+	if (node.type === "cmsBlock") {
+		const schema = schemas.get(String(node.attrs?.tag).toLowerCase());
+		for (const region of node.content ?? []) {
+			const slot = schema?.definition.slots.find((candidate) => candidate.name === region.attrs?.name);
+			const permitted = slot?.input === "blocks" ? new Set(collectionComponents([...schemas].map(([name, schema]) => ({
+				name,
+				authoring: schema.definition
+			})), slot.blocks === void 0 && slot.groups === void 0 ? void 0 : slot).map((component) => component.name).filter((name) => collectionAllowed.has(name))) : collectionAllowed;
+			issues.push(...contentIssues(region, schemas, permitted, purpose, collectionAllowed));
+		}
+		return issues;
 	}
-	return comarkToEditor(body.nodes, createCmsComarkRenderData(body)).flatMap(visit);
+	return [...issues, ...(node.content ?? []).flatMap((child) => contentIssues(child, schemas, allowed, purpose, collectionAllowed))];
+}
+/** Resolves a component catalog once so document compilation can reuse its authoring rules. */
+function createAuthoringDocumentValidator(components) {
+	const definitions = [...components.values()];
+	const schemas = new Map(definitions.map((component) => [component.name, createAuthoringSchema(component.name, component.authoring)]));
+	return (body, bodyPolicy) => {
+		const allowed = new Set(collectionComponents(definitions, bodyPolicy).map((component) => component.name));
+		return comarkToEditor(body.nodes, createCmsComarkRenderData(body)).flatMap((node) => contentIssues(node, schemas, allowed, "publish"));
+	};
 }
 function createAuthoringSchema(name, definition) {
 	const fields = new Map(definition.props.map((field) => [field.name, field]));
@@ -902,10 +814,36 @@ function createAuthoringSchema(name, definition) {
 function propertyIssue(field, value, purpose) {
 	if (value === void 0) return field.required && purpose === "publish" ? `${field.label} is required.` : void 0;
 	if (value === null && field.nullable) return void 0;
-	if (!(field.type === "string" ? Predicate.isString(value) : field.type === "number" ? Predicate.isNumber(value) && Number.isFinite(value) : Predicate.isBoolean(value))) return `${field.label} must be ${field.type}.`;
+	let valid;
+	if (field.type === "string") valid = Predicate.isString(value);
+	else if (field.type === "number") valid = Predicate.isNumber(value) && Number.isFinite(value);
+	else if (field.type === "boolean") valid = Predicate.isBoolean(value);
+	else if (field.type === "array") valid = Array.isArray(value);
+	else valid = isJsonObject(value);
+	if (!valid) return `${field.label} must be ${field.type}.`;
+	if (field.type === "object" || field.type === "array") {
+		const entries = Array.isArray(value) ? value : [value];
+		const ids = /* @__PURE__ */ new Set();
+		for (const entry of entries) {
+			if (!isJsonObject(entry)) return `${field.label} must contain objects.`;
+			if (field.type === "array") {
+				const id = entry.id;
+				if (!Predicate.isString(id) || !id || ids.has(id)) return `${field.label} items need unique identities.`;
+				ids.add(id);
+			}
+			for (const key of Object.keys(entry)) if (!(field.type === "array" && key === "id") && !field.fields?.some((child) => child.name === key)) return `${field.label} contains an unavailable field.`;
+			for (const child of field.fields ?? []) {
+				const issue = propertyIssue(child, entry[child.name], purpose);
+				if (issue) return `${field.label}: ${issue}`;
+			}
+		}
+	}
+	if (purpose === "publish" && field.required && value === "" && (field.input === "image" || field.input === "link")) return `${field.label} is required.`;
+	if (purpose === "publish" && Predicate.isString(value) && value && (field.input === "image" || field.input === "link") && !validAuthoringUrl(value, field.input)) return `${field.label} needs a valid ${field.input === "image" ? "image URL" : "link"}.`;
 	if (field.options.length && !field.options.some((option) => option.value === value)) return `${field.label} must use one of its available choices.`;
 }
 function validRegion(slot, content) {
+	if (slot.input === "blocks") return content.every((node) => node.type === "cmsBlock" || node.type === "paragraph" && !node.content?.length);
 	const types = /* @__PURE__ */ new Set([
 		"paragraph",
 		"text",
@@ -920,7 +858,176 @@ function validRegion(slot, content) {
 	const valid = (node) => types.has(node.type ?? "") && (node.marks ?? []).every((mark) => marks.has(mark.type)) && (node.content ?? []).every(valid);
 	return content.every(valid);
 }
+/** URL values remain ordinary Vue strings and use the document model's public paths. */
+function validAuthoringUrl(value, input) {
+	if (value.trim() !== value || value.includes("\\")) return false;
+	for (const character of value) if (character.charCodeAt(0) <= 32) return false;
+	if (value.startsWith("/") && !value.startsWith("//")) return true;
+	if (input === "link" && value.startsWith("#")) return true;
+	try {
+		const url = new URL(value);
+		return [
+			"https:",
+			"http:",
+			...input === "link" ? ["mailto:", "tel:"] : []
+		].includes(url.protocol);
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region ../protocol/src/Authoring.ts
+const BlockProp = Schema.Struct({
+	name: Schema.NonEmptyString,
+	label: Schema.NonEmptyString,
+	help: Schema.optionalKey(Schema.String),
+	type: Schema.Literals([
+		"string",
+		"number",
+		"boolean",
+		"object",
+		"array"
+	]),
+	input: Schema.Literals([
+		"text",
+		"textarea",
+		"select",
+		"number",
+		"toggle",
+		"image",
+		"link",
+		"object",
+		"list"
+	]),
+	required: Schema.Boolean,
+	nullable: Schema.Boolean,
+	defaultValue: Schema.optionalKey(Schema.Json),
+	fields: Schema.optionalKey(Schema.Array(Schema.suspend(() => BlockProp))),
+	options: Schema.Array(Schema.Struct({
+		value: Schema.String,
+		label: Schema.String
+	}))
+});
+const BlockSlot = Schema.Struct({
+	name: Schema.NonEmptyString,
+	label: Schema.NonEmptyString,
+	help: Schema.optionalKey(Schema.String),
+	required: Schema.Boolean,
+	input: Schema.Literals([
+		"text",
+		"rich-text",
+		"blocks"
+	]),
+	blocks: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
+	groups: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
+	features: Schema.Array(Schema.Literals([
+		"bold",
+		"italic",
+		"link",
+		"bullet-list",
+		"code"
+	])),
+	initial: Schema.optionalKey(Schema.Array(MarkdownNode))
+});
+const BlockAuthoring = Schema.Struct({
+	version: Schema.Literal(1),
+	form: Schema.optionalKey(FormCapabilities),
+	label: Schema.NonEmptyString,
+	description: Schema.optionalKey(Schema.String),
+	group: Schema.optionalKey(Schema.String),
+	icon: Schema.optionalKey(Schema.String),
+	props: Schema.Array(BlockProp),
+	slots: Schema.Array(BlockSlot),
+	initialProps: Schema.JsonObject
+});
+
+//#endregion
+//#region ../protocol/src/Configuration.ts
+const fieldPresentation = {
+	path: Schema.NonEmptyString,
+	label: Schema.NonEmptyString,
+	description: Schema.optionalKey(Schema.String),
+	defaultValue: Schema.optionalKey(Schema.Json),
+	required: Schema.Boolean
+};
+const BooleanAuthoringField = Schema.Struct({
+	type: Schema.tag("boolean"),
+	...fieldPresentation,
+	input: Schema.Literal("toggle")
+});
+const DateAuthoringField = Schema.Struct({
+	type: Schema.tag("date"),
+	...fieldPresentation,
+	input: Schema.Literal("date")
+});
+const NumberAuthoringField = Schema.Struct({
+	type: Schema.tag("number"),
+	...fieldPresentation,
+	input: Schema.Literals(["number", "select"]),
+	options: Schema.Array(Schema.Finite)
+});
+const StringAuthoringField = Schema.Struct({
+	type: Schema.tag("string"),
+	...fieldPresentation,
+	input: Schema.Literals([
+		"select",
+		"text",
+		"textarea"
+	]),
+	options: Schema.Array(Schema.String)
+});
+const StringArrayAuthoringField = Schema.Struct({
+	type: Schema.tag("string[]"),
+	...fieldPresentation,
+	input: Schema.Literal("multiselect"),
+	options: Schema.Array(Schema.String)
+});
+const DocumentField = Schema.Union([
+	BooleanAuthoringField,
+	DateAuthoringField,
+	NumberAuthoringField,
+	StringArrayAuthoringField,
+	StringAuthoringField
+]);
+const CollectionBody = Schema.Struct({
+	blocks: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
+	groups: Schema.optionalKey(Schema.Array(Schema.NonEmptyString))
+});
+const CollectionDefinition = Schema.Struct({
+	collection: CollectionName,
+	body: Schema.optionalKey(CollectionBody),
+	label: Schema.NonEmptyString,
+	description: Schema.String,
+	directory: SourceDirectory,
+	addressPattern: AddressPattern,
+	hierarchy: Schema.Boolean,
+	canCreate: Schema.Boolean,
+	authoringFields: Schema.Array(DocumentField)
+}).annotate({ identifier: "CollectionDefinition" });
+const LocaleConfiguration = Schema.Struct({
+	locales: Schema.Array(Locale),
+	defaultLocale: Locale,
+	fallbackLocale: Schema.NullOr(Locale),
+	prefixDefaultLocale: Schema.Boolean
+}).annotate({ identifier: "LocaleConfiguration" });
+const DocumentConfiguration = Schema.Struct({
+	types: Schema.Array(CollectionDefinition),
+	locales: Schema.optionalKey(LocaleConfiguration)
+}).annotate({ identifier: "DocumentConfiguration" });
+const ComponentDefinition = Schema.Struct({
+	authoring: BlockAuthoring,
+	name: Schema.NonEmptyString
+}).annotate({ identifier: "ComponentDefinition" });
+const AuthoringCatalog = Schema.Struct({
+	revision: Schema.NonEmptyString,
+	components: Schema.Array(ComponentDefinition)
+});
+const MediaConfiguration = Schema.Struct({
+	enabled: Schema.Boolean,
+	maxUploadBytes: Schema.Int.check(Schema.isGreaterThan(0))
+});
 
 //#endregion
-export { withCmsComarkProps as C, resolveCmsComarkAttributes as S, createDocumentParser as _, EditorRenderFailed as a, matchesCmsComponentPropType as b, comarkTagForEditorMark as c, encodeEditorImageAttributes as d, normalizeEditorImageLayout as f, DOCUMENT_ENGINE_FINGERPRINT as g, nonEmptyStringAttribute as h, EditorDocumentInvalid as i, isEditorMark as l, finiteNumberAttribute as m, parseAuthoringContent as n, comarkToEditor as o, compactJsonAttributes as p, validateAuthoringDocument as r, EDITOR_MARK_TYPES as s, createAuthoringSchema as t, EDITOR_IMAGE_LAYOUT_ATTRIBUTE as u, SOURCE_MAPPINGS_META_KEY as v, normalizeCmsComponentBindings as x, encodeCmsEditorComponentAttributes as y };
-//# sourceMappingURL=AuthoringSchema-BQ5kbhVB.js.map
+export { finiteNumberAttribute as C, compactJsonAttributes as S, comarkTagForEditorMark as _, BlockAuthoring as a, encodeEditorImageAttributes as b, parseAuthoringContent as c, EditorRenderFailed as d, DOCUMENT_ENGINE_FINGERPRINT as f, EDITOR_MARK_TYPES as g, comarkToEditor as h, MediaConfiguration as i, validateCollectionBody as l, SOURCE_MAPPINGS_META_KEY as m, ComponentDefinition as n, createAuthoringDocumentValidator as o, createDocumentParser as p, DocumentConfiguration as r, createAuthoringSchema as s, AuthoringCatalog as t, EditorDocumentInvalid as u, isEditorMark as v, nonEmptyStringAttribute as w, normalizeEditorImageLayout as x, EDITOR_IMAGE_LAYOUT_ATTRIBUTE as y };
+//# sourceMappingURL=Configuration-CA_jvQKG.js.map