@phtngyn/cms 0.2.0-beta.3 → 0.2.0-beta.5

package/src/{Configuration-BU-UyGoH.js → Configuration-JQ1qyaU0.js}

@@ -1,7 +1,8 @@
-import { Ct as CollectionName, St as AddressPattern, Tt as SourceDirectory, b as MarkdownNode, n as CmsMarkdownDocument, wt as Locale } from "./models-ChRxBChy.js";
-import { r as FormCapabilities } from "./Forms-BbkE7QfC.js";
-import { c as resolveCmsComarkAttributes, d as createCmsComarkRenderData, l as withCmsComarkProps, r as formStructureIssues, s as projectCmsEditorComponentAttributes } from "./Forms-DoB56hfe.js";
-import { a as createEditorNodeId, n as editorMetadata, o as editorNodeId } from "./metadata-BEZPWh-3.js";
+import { S as MarkdownNode, at as Locale, it as CollectionName, n as CmsMarkdownDocument, ot as RoutePattern } from "./models-VmGmG19-.js";
+import { i as decodeManagedMediaReference, r as decodeAuthoredDocumentReference } from "./References-CCPDAPve.js";
+import { r as FormCapabilities } from "./Forms-CfNPTiCr.js";
+import { c as resolveCmsComarkAttributes, d as createCmsComarkRenderData, l as withCmsComarkProps, r as formStructureIssues, s as projectCmsEditorComponentAttributes } from "./Forms-CX-hwmJF.js";
+import { a as createEditorNodeId, n as editorMetadata, o as editorNodeId } from "./metadata-UzZmjwxM.js";
 import { Effect, Option, Predicate, Schema } from "effect";
 import { Extension } from "@tiptap/core";
 import { ySyncPluginKey } from "@tiptap/y-tiptap";
@@ -29,7 +30,7 @@ function finiteNumberAttribute(value, fallback) {
 
 //#endregion
 //#region ../document/src/internal/editor/image.ts
-const isJsonObject$2 = Schema.is(Schema.JsonObject);
+const isJsonObject$3 = Schema.is(Schema.JsonObject);
 const EditorImageLayout = Schema.Literals([
 	"natural",
 	"content",
@@ -71,7 +72,7 @@ function normalizeEditorImageLayout(value) {
 	return isEditorImageLayout(value) ? value : "natural";
 }
 function jsonObject$1(value) {
-	return isJsonObject$2(value) ? value : {};
+	return isJsonObject$3(value) ? value : {};
 }
 function stringValue(value) {
 	return Predicate.isString(value) || Predicate.isNumber(value) ? String(value) : "";
@@ -105,7 +106,7 @@ function isComarkMark(tag) {
 
 //#endregion
 //#region ../document/src/internal/comark/to-editor.ts
-const isJsonObject$1 = Schema.is(Schema.JsonObject);
+const isJsonObject$2 = Schema.is(Schema.JsonObject);
 const OPAQUE_BLOCK_TAGS = /* @__PURE__ */ new Set([
 	"math",
 	"table",
@@ -384,7 +385,7 @@ function elementChildren(node) {
 	return children;
 }
 function jsonObject(value) {
-	return isJsonObject$1(value) ? value : {};
+	return isJsonObject$2(value) ? value : {};
 }
 function mergeJsonAttributes(attributes, additions) {
 	return compactJsonAttributes(Object.assign({}, attributes, additions));
@@ -664,6 +665,181 @@ var EditorDocumentInvalid = class extends Schema.TaggedError()("EditorDocument.I
 }) {};
 var EditorRenderFailed = class extends Schema.TaggedError()("EditorDocument.RenderFailed", { cause: Schema.Defect() }) {};
 
+//#endregion
+//#region ../document/src/StructuredFields.ts
+function compileStructuredFields(definitions) {
+	const fields = new Map(definitions.map((field) => [field.name, field]));
+	if (fields.size !== definitions.length) throw new Error("Structured field names must be unique.");
+	for (const field of definitions) {
+		if (field.defaultValue === void 0) continue;
+		const issue = fieldIssue(field, field.defaultValue, "working");
+		if (issue) throw new Error(`Invalid default for ${field.label}: ${issue.message}`);
+	}
+	const listField = (name) => {
+		const field = fields.get(name);
+		if (!field || field.type !== "array" || field.input !== "list") throw new Error(`Structured field "${name}" is not a repeatable object.`);
+		return field;
+	};
+	const validateDetailed = (value, purpose) => {
+		const issues = [];
+		for (const name of Object.keys(value)) if (!fields.has(name)) issues.push({
+			message: `${name} is not editable.`,
+			path: [name]
+		});
+		for (const field of definitions) {
+			const issue = fieldIssue(field, value[field.name] ?? (value[field.name] === null ? null : field.defaultValue), purpose, [field.name]);
+			if (issue) issues.push(issue);
+		}
+		return issues;
+	};
+	return {
+		create: () => createObject(definitions),
+		set(current, name, value) {
+			const field = fields.get(name);
+			if (!field) throw new Error(`Structured field "${name}" is unavailable.`);
+			const issue = fieldIssue(field, value, "working");
+			if (issue) throw new Error(issue.message);
+			const next = Object.fromEntries(Object.entries(current));
+			if (value === void 0) delete next[name];
+			else next[name] = structuredClone(value);
+			return next;
+		},
+		validate: (value, purpose) => validateDetailed(value, purpose).map((issue) => issue.message),
+		validateDetailed,
+		validateIdentities: (value) => identityIssues(definitions, value),
+		createListItem(name) {
+			return createObject(listField(name).fields ?? [], true);
+		},
+		duplicateListItem(name, item) {
+			const field = listField(name);
+			const copied = cloneWithFreshIdentities(item, field.fields ?? []);
+			return Object.assign(createObject(field.fields ?? [], true), copied, { id: createEditorNodeId() });
+		},
+		moveListItem(items, id, offset) {
+			const index = items.findIndex((item) => item.id === id);
+			const target = index + offset;
+			if (index < 0 || target < 0 || target >= items.length) return items;
+			const next = [...items];
+			const item = next.splice(index, 1)[0];
+			if (!item) return items;
+			next.splice(target, 0, item);
+			return next;
+		},
+		removeListItem: (items, id) => items.filter((item) => item.id !== id)
+	};
+}
+function identityIssues(fields, value, parent = []) {
+	return fields.flatMap((field) => {
+		const current = value[field.name];
+		const path = [...parent, field.name];
+		if (field.type === "object" && isJsonObject$1(current)) return identityIssues(field.fields ?? [], current, path);
+		if (field.type !== "array" || !Array.isArray(current)) return [];
+		const seen = /* @__PURE__ */ new Set();
+		return current.flatMap((item, index) => {
+			if (!isJsonObject$1(item)) return [];
+			const id = item.id;
+			const issue = !Predicate.isString(id) || !id || seen.has(id) ? [{
+				message: `${field.label} items need unique identities.`,
+				path: [
+					...path,
+					index,
+					"id"
+				]
+			}] : [];
+			if (Predicate.isString(id) && id) seen.add(id);
+			return [...issue, ...identityIssues(field.fields ?? [], item, [...path, index])];
+		});
+	});
+}
+function createObject(fields, listItem = false) {
+	return {
+		...listItem ? { id: createEditorNodeId() } : void 0,
+		...Object.fromEntries(fields.flatMap((field) => field.required || field.defaultValue !== void 0 ? [[field.name, structuredClone(field.defaultValue ?? defaultValue(field))]] : []))
+	};
+}
+function defaultValue(field) {
+	if (field.type === "object") return createObject(field.fields ?? []);
+	if (field.type === "array") return [];
+	if (field.type === "string[]") return [];
+	if (field.type === "number") return 0;
+	if (field.type === "boolean") return false;
+	return field.options[0]?.value ?? "";
+}
+function cloneWithFreshIdentities(value, fields) {
+	const byName = new Map(fields.map((field) => [field.name, field]));
+	const copy = {};
+	for (const [name, child] of Object.entries(value)) {
+		if (name === "id") continue;
+		const field = byName.get(name);
+		if (field?.type === "object" && isJsonObject$1(child)) copy[name] = cloneWithFreshIdentities(child, field.fields ?? []);
+		else if (field?.type === "array" && Array.isArray(child)) copy[name] = child.map((item) => isJsonObject$1(item) ? Object.assign(cloneWithFreshIdentities(item, field.fields ?? []), { id: createEditorNodeId() }) : structuredClone(item));
+		else copy[name] = structuredClone(child);
+	}
+	return copy;
+}
+function fieldIssue(field, value, purpose, path = [field.name]) {
+	const issue = (message, issuePath = path) => ({
+		message,
+		path: issuePath
+	});
+	if (value === void 0) return field.required && purpose === "publish" ? issue(`${field.label} is required.`) : void 0;
+	if (value === null && field.nullable) return void 0;
+	if (!(field.type === "string" || field.type === "date" ? Predicate.isString(value) : field.type === "number" ? Predicate.isNumber(value) && Number.isFinite(value) : field.type === "boolean" ? Predicate.isBoolean(value) : field.type === "string[]" ? Array.isArray(value) && value.every(Predicate.isString) : field.type === "array" ? Array.isArray(value) : isJsonObject$1(value))) return issue(`${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 [index, entry] of entries.entries()) {
+			const entryPath = field.type === "array" ? [...path, index] : path;
+			if (!isJsonObject$1(entry)) return issue(`${field.label} must contain objects.`, entryPath);
+			if (field.type === "array") {
+				const id = entry.id;
+				if (!Predicate.isString(id) || !id || ids.has(id)) return issue(`${field.label} items need unique identities.`, [...entryPath, "id"]);
+				ids.add(id);
+			}
+			for (const key of Object.keys(entry)) if (!(field.type === "array" && key === "id") && !field.fields?.some((child) => child.name === key)) return issue(`${field.label} contains an unavailable field.`, [...entryPath, key]);
+			for (const child of field.fields ?? []) {
+				const childIssue = fieldIssue(child, entry[child.name], purpose, [...entryPath, child.name]);
+				if (childIssue) return {
+					...childIssue,
+					message: `${field.label}: ${childIssue.message}`
+				};
+			}
+		}
+	}
+	if (purpose === "publish" && field.required && value === "" && [
+		"image",
+		"link",
+		"document",
+		"media"
+	].includes(field.input)) return issue(`${field.label} is required.`);
+	if (purpose === "publish" && Predicate.isString(value) && value && (field.input === "image" || field.input === "link") && !(field.input === "link" && decodeAuthoredDocumentReference(value)) && !validAuthoringUrl(value, field.input)) return issue(`${field.label} needs a valid ${field.input === "image" ? "image URL" : "link"}.`);
+	if (purpose === "publish" && Predicate.isString(value) && value && field.input === "document" && !decodeAuthoredDocumentReference(value)) return issue(`${field.label} needs a valid document reference.`);
+	if (purpose === "publish" && Predicate.isString(value) && value && field.input === "media" && !decodeManagedMediaReference(value)) return issue(`${field.label} needs a valid managed-media reference.`);
+	if (field.options.length) {
+		if ((Array.isArray(value) ? value : [value]).some((entry) => !field.options.some((option) => option.value === entry))) return issue(`${field.label} must use only available choices.`);
+	}
+}
+function isJsonObject$1(value) {
+	return Schema.is(Schema.JsonObject)(value);
+}
+/** URL values remain ordinary strings; identity-backed references use dedicated field inputs. */
+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 ../document/src/AuthoringSchema.ts
 const parseAuthoringContent = Effect.fn("AuthoringSchema.parseContent")(function* (markdown) {
@@ -684,7 +860,7 @@ function collectionComponents(components, body) {
 /** 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}.`)])),
+		...components.flatMap((component) => component.authoring.slots.flatMap((slot) => slot.input === "blocks" ? [...(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}".`)
 	];
@@ -692,16 +868,28 @@ function validateCollectionBody(components, body) {
 function contentIssues(node, schemas, allowed, purpose, collectionAllowed = allowed) {
 	const issues = [];
 	if (node.type === "cmsBlock") {
-		const name = String(node.attrs?.tag).toLowerCase();
+		const name = String(node.attrs?.tag ?? "unknown").toLowerCase() || "unknown";
 		const schema = schemas.get(name);
-		if (!schema) issues.push("This block is unavailable. Ask your site developer to restore its definition.");
+		if (!schema) issues.push({
+			component: name,
+			message: "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 (!allowed.has(name)) issues.push({
+				component: name,
+				message: `${schema.definition.label} is not allowed in this content region.`
+			});
+			issues.push(...schema.validateDetailed(node, purpose));
+			if (purpose === "publish" && schema.definition.form) issues.push(...formStructureIssues(node.attrs?.props?.steps, schema.definition.form, name).map((message) => ({
+				component: name,
+				message
+			})));
 		}
 	}
-	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 === "cmsOpaque" || node.type === "cmsInlineOpaque") issues.push({
+		component: String(node.attrs?.tag ?? node.type),
+		message: "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 ?? []) {
@@ -726,18 +914,11 @@ function createAuthoringDocumentValidator(components) {
 	};
 }
 function createAuthoringSchema(name, definition) {
+	const structuredFields = compileStructuredFields(definition.props);
 	const fields = new Map(definition.props.map((field) => [field.name, field]));
 	const slots = new Map(definition.slots.map((slot) => [slot.name, slot]));
 	if (fields.size !== definition.props.length || slots.size !== definition.slots.length) throw new Error(`${definition.label}: authoring names must be unique.`);
-	const initialProps = {
-		...Object.fromEntries(definition.props.flatMap((field) => field.defaultValue === void 0 ? [] : [[field.name, field.defaultValue]])),
-		...definition.initialProps
-	};
-	for (const field of definition.props) {
-		if (field.defaultValue === void 0) continue;
-		const issue = propertyIssue(field, field.defaultValue, "working");
-		if (issue) throw new Error(`Invalid default for ${definition.label}: ${issue}`);
-	}
+	const initialProps = Object.assign({}, structuredFields.create(), definition.initialProps);
 	function createSlot(slotName) {
 		const slot = slots.get(slotName);
 		if (!slot) throw new Error(`${definition.label}: unknown content region ${slotName}.`);
@@ -767,81 +948,57 @@ function createAuthoringSchema(name, definition) {
 			content: definition.slots.filter((slot) => slot.required || slot.initial !== void 0).map((slot) => createSlot(slot.name))
 		};
 	}
-	function validate(node, purpose) {
+	function validateDetailed(node, purpose) {
 		const issues = [];
 		const attributes = node.attrs?.props;
 		const values = isJsonObject(attributes) ? attributes : {};
-		for (const key of Object.keys(values)) if (!fields.has(key)) issues.push(`${definition.label}: ${key} is not editable.`);
-		for (const field of definition.props) {
-			const issue = propertyIssue(field, values[field.name] ?? (values[field.name] === null ? null : field.defaultValue), purpose);
-			if (issue) issues.push(issue);
-		}
+		issues.push(...structuredFields.validateDetailed(values, purpose).map((issue) => ({
+			component: name,
+			field: issue.path,
+			message: issue.message
+		})));
 		const used = /* @__PURE__ */ new Set();
 		for (const region of node.content ?? []) {
 			const key = String(region.attrs?.name ?? "default");
 			const slot = slots.get(key);
 			if (!slot || region.type !== "cmsSlot") {
-				issues.push(`${definition.label}: unsupported content region ${key}.`);
+				issues.push({
+					component: name,
+					message: `${definition.label}: unsupported content region ${key}.`
+				});
 				continue;
 			}
-			if (used.has(key)) issues.push(`${slot.label} can only appear once.`);
+			if (used.has(key)) issues.push({
+				component: name,
+				message: `${slot.label} can only appear once.`
+			});
 			used.add(key);
-			if (!validRegion(slot, region.content ?? [])) issues.push(`${slot.label} contains unsupported formatting or blocks.`);
+			if (!validRegion(slot, region.content ?? [])) issues.push({
+				component: name,
+				message: `${slot.label} contains unsupported formatting or blocks.`
+			});
 		}
-		for (const slot of definition.slots) if (slot.required && !used.has(slot.name)) issues.push(`${slot.label} is required.`);
+		for (const slot of definition.slots) if (slot.required && !used.has(slot.name)) issues.push({
+			component: name,
+			message: `${slot.label} is required.`
+		});
 		return issues;
 	}
+	const validate = (node, purpose) => validateDetailed(node, purpose).map((issue) => issue.message);
 	const schema = {
 		definition,
 		createContent,
 		createSlot,
 		validate,
+		validateDetailed,
 		setProperty(current, key, value) {
-			const field = fields.get(key);
-			if (!field) throw new Error(`${definition.label}: ${key} is not editable.`);
-			const issue = propertyIssue(field, value, "working");
-			if (issue) throw new Error(issue);
-			const next = Object.fromEntries(Object.entries(current));
-			if (value === void 0) delete next[key];
-			else next[key] = value;
-			return next;
+			return structuredFields.set(current, key, value);
 		}
 	};
 	const issues = validate(createContent(), "publish");
 	if (issues.length) throw new Error(`Invalid initial content for ${definition.label}: ${issues.join(" ")}`);
 	return schema;
 }
-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;
-	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([
@@ -850,86 +1007,130 @@ function validRegion(slot, content) {
 		"hardBreak"
 	]);
 	const marks = /* @__PURE__ */ new Set();
-	if (slot.input === "text" && content.length > 1) return false;
-	if (slot.input === "rich-text") for (const feature of slot.features) if (feature === "bullet-list") {
+	if (slot.input !== "rich-text" && content.length > 1) return false;
+	if (slot.input === "inline-text" || slot.input === "rich-text") for (const feature of slot.features) if (feature === "bullet-list") {
 		types.add("bulletList");
 		types.add("listItem");
 	} else marks.add(feature);
 	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({
+//#region ../protocol/src/StructuredFields.ts
+const presentation = {
 	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,
+	description: Schema.optionalKey(Schema.String),
 	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({
+	required: Schema.Boolean,
+	nullable: Schema.Boolean
+};
+const stringOptions = Schema.Array(Schema.Struct({
+	value: Schema.String,
+	label: Schema.String
+}));
+const numberOptions = Schema.Array(Schema.Struct({
+	value: Schema.Finite,
+	label: Schema.String
+}));
+const noOptions = Schema.Tuple([]);
+const StructuredField = Schema.Union([
+	Schema.Struct({
+		...presentation,
+		type: Schema.tag("boolean"),
+		input: Schema.Literal("toggle"),
+		options: noOptions
+	}),
+	Schema.Struct({
+		...presentation,
+		type: Schema.tag("date"),
+		input: Schema.Literal("date"),
+		options: noOptions
+	}),
+	Schema.Struct({
+		...presentation,
+		type: Schema.tag("number"),
+		input: Schema.Literals(["number", "select"]),
+		options: numberOptions
+	}),
+	Schema.Struct({
+		...presentation,
+		type: Schema.tag("string"),
+		input: Schema.Literals([
+			"select",
+			"text",
+			"textarea",
+			"image",
+			"link",
+			"document",
+			"media"
+		]),
+		options: stringOptions
+	}),
+	Schema.Struct({
+		...presentation,
+		type: Schema.tag("string[]"),
+		input: Schema.Literal("multiselect"),
+		options: stringOptions
+	}),
+	Schema.Struct({
+		...presentation,
+		type: Schema.tag("object"),
+		input: Schema.Literal("object"),
+		options: noOptions,
+		fields: Schema.Array(Schema.suspend(() => StructuredField))
+	}),
+	Schema.Struct({
+		...presentation,
+		type: Schema.tag("array"),
+		input: Schema.Literal("list"),
+		options: noOptions,
+		fields: Schema.Array(Schema.suspend(() => StructuredField))
+	})
+]);
+
+//#endregion
+//#region ../protocol/src/Authoring.ts
+const inlineTextFeature = Schema.Literals([
+	"bold",
+	"italic",
+	"link",
+	"code"
+]);
+const richTextFeature = Schema.Union([inlineTextFeature, Schema.Literal("bullet-list")]);
+const slotBase = {
 	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 noFeatures = Schema.Tuple([]);
+const BlockSlot = Schema.Union([
+	Schema.Struct({
+		...slotBase,
+		input: Schema.Literal("text"),
+		features: noFeatures
+	}),
+	Schema.Struct({
+		...slotBase,
+		input: Schema.Literal("inline-text"),
+		features: Schema.Array(inlineTextFeature)
+	}),
+	Schema.Struct({
+		...slotBase,
+		input: Schema.Literal("rich-text"),
+		features: Schema.Array(richTextFeature)
+	}),
+	Schema.Struct({
+		...slotBase,
+		input: Schema.Literal("blocks"),
+		features: noFeatures,
+		blocks: Schema.optionalKey(Schema.Array(Schema.NonEmptyString)),
+		groups: Schema.optionalKey(Schema.Array(Schema.NonEmptyString))
+	})
+]);
 const BlockAuthoring = Schema.Struct({
 	version: Schema.Literal(1),
 	form: Schema.optionalKey(FormCapabilities),
@@ -937,73 +1138,30 @@ const BlockAuthoring = Schema.Struct({
 	description: Schema.optionalKey(Schema.String),
 	group: Schema.optionalKey(Schema.String),
 	icon: Schema.optionalKey(Schema.String),
-	props: Schema.Array(BlockProp),
+	props: Schema.Array(StructuredField),
 	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 CollectionRoutes = Schema.Struct({
+	home: RoutePattern,
+	entry: RoutePattern
+}).annotate({ identifier: "CollectionRoutes" });
 const CollectionDefinition = Schema.Struct({
 	collection: CollectionName,
 	body: Schema.optionalKey(CollectionBody),
 	label: Schema.NonEmptyString,
 	description: Schema.String,
-	directory: SourceDirectory,
-	addressPattern: AddressPattern,
+	routes: CollectionRoutes,
 	hierarchy: Schema.Boolean,
 	canCreate: Schema.Boolean,
-	authoringFields: Schema.Array(DocumentField)
+	authoringFields: Schema.Array(StructuredField)
 }).annotate({ identifier: "CollectionDefinition" });
 const LocaleConfiguration = Schema.Struct({
 	locales: Schema.Array(Locale),
@@ -1029,5 +1187,5 @@ const MediaConfiguration = Schema.Struct({
 });
 
 //#endregion
-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-BU-UyGoH.js.map
+export { compactJsonAttributes as C, normalizeEditorImageLayout as S, nonEmptyStringAttribute as T, EDITOR_MARK_TYPES as _, BlockAuthoring as a, EDITOR_IMAGE_LAYOUT_ATTRIBUTE as b, parseAuthoringContent as c, EditorDocumentInvalid as d, EditorRenderFailed as f, comarkToEditor as g, SOURCE_MAPPINGS_META_KEY as h, MediaConfiguration as i, validateCollectionBody as l, createDocumentParser as m, ComponentDefinition as n, createAuthoringDocumentValidator as o, DOCUMENT_ENGINE_FINGERPRINT as p, DocumentConfiguration as r, createAuthoringSchema as s, AuthoringCatalog as t, compileStructuredFields as u, comarkTagForEditorMark as v, finiteNumberAttribute as w, encodeEditorImageAttributes as x, isEditorMark as y };
+//# sourceMappingURL=Configuration-JQ1qyaU0.js.map