caracms 0.1.0 → 0.2.0

package/src/config.ts

@@ -227,8 +227,19 @@ export interface SiteConfig {
 	 * hands it to the site's own routes as `seo.titleSeparator`, so their titles match.
 	 */
 	titleSeparator?: string;
+	/**
+	 * What a page without its own `seo.title` falls back to (M9, head.ts). `'page-and-brand'`
+	 * (the default): `<document title><titleSeparator><brand name>`, the home page excepted.
+	 * `'site'`: every page falls back as the home page does, to Site Settings' `seo.title`,
+	 * then the brand name, then the document title. For a site (a Tina template's, say)
+	 * whose pages all show the site's own title.
+	 */
+	titleFallback?: TitleFallback;
 }
 
+/** The config's `titleFallback` values (head.ts). */
+export type TitleFallback = 'page-and-brand' | 'site';
+
 /** The fallback title's separator when the config sets none (head.ts). */
 export const DEFAULT_TITLE_SEPARATOR = ' · ';
 
@@ -329,6 +340,8 @@ export interface ResolvedSite {
 	forms: Record<string, ResolvedForm>;
 	/** The fallback title's separator, spaces included (`DEFAULT_TITLE_SEPARATOR` when the config sets none). */
 	titleSeparator: string;
+	/** What a page without its own `seo.title` falls back to (`'page-and-brand'` when the config sets none). */
+	titleFallback: TitleFallback;
 	/**
 	 * M8 Decision 10: the URLs the site's own `src/pages/` serves (code-routes.ts), read by the
 	 * integration at setup (and by the commands). Absent before then: nothing is reserved.
@@ -563,7 +576,13 @@ export function resolveSite(config: SiteConfig, root: string): ResolvedSite {
 		fail(`titleSeparator must be the text between a page's title and the site's name, spaces included, like ' | ' (got ${JSON.stringify(config.titleSeparator)}).`);
 	}
 
-	return { root, collections, blocks, textStyles, page: abs(config.page), brand, sharedFolder, phoneLinesWidth, repoPath: repoPath!, timeZone, forms, titleSeparator };
+	// What a page without its own title falls back to (M9): the page and the brand, or the site's title.
+	const titleFallback = config.titleFallback ?? 'page-and-brand';
+	if (titleFallback !== 'page-and-brand' && titleFallback !== 'site') {
+		fail(`titleFallback must be 'page-and-brand' (the page's title and the site's name) or 'site' (Site Settings' title on every page) (got ${JSON.stringify(config.titleFallback)}).`);
+	}
+
+	return { root, collections, blocks, textStyles, page: abs(config.page), brand, sharedFolder, phoneLinesWidth, repoPath: repoPath!, timeZone, forms, titleSeparator, titleFallback };
 }
 
 interface FieldCheck {
@@ -617,6 +636,11 @@ function validateField(field: Field, where: string, check: FieldCheck): void {
 	// M6c (G8): help is plain text, said in the sidebar.
 	if (field.help !== undefined && (typeof field.help !== 'string' || field.help.trim() === '')) fail(`${where}: help is a sentence of plain text, shown under the field in the editor (got ${JSON.stringify(field.help)}).`);
 	switch (field.kind) {
+		case 'text':
+			// M9 Decision 10.
+			if (field.lines !== undefined && field.lines !== true) fail(`${where}: lines is true or left out (got ${JSON.stringify(field.lines)}).`);
+			if (field.lines && !field.multiline) fail(`${where}: lines draws each typed line as its own element, so the field takes several lines. Write text({ lines: true }) without multiline: false.`);
+			break;
 		case 'lockup':
 			if (!Object.hasOwn(check.textStyles, field.style)) fail(`${where} uses the text style "${field.style}", which isn't in textStyles.`);
 			break;
@@ -635,6 +659,10 @@ function validateField(field: Field, where: string, check: FieldCheck): void {
 						"An h3 with no h2 above it breaks the page's outline, and the page's h1 is a block's heading field.",
 				);
 			}
+			// M9 Decision 11: a heading is bold and line breaks only.
+			if (field.heading !== undefined && field.heading !== true) fail(`${where}: heading is true or left out (got ${JSON.stringify(field.heading)}).`);
+			if (field.heading && headings.length > 0) fail(`${where}: a heading rich-text field can't hold headings of its own; it is the block's heading. Leave headings out.`);
+			if (field.heading && field.links) fail(`${where}: a heading rich-text field takes bold and line breaks only, not links. Leave links out.`);
 			break;
 		}
 		case 'buttons':
@@ -701,6 +729,9 @@ function validateField(field: Field, where: string, check: FieldCheck): void {
 			if (field.only !== undefined && field.only !== 'image' && field.only !== 'video') fail(`${where}: media's only must be 'image' or 'video' (got ${JSON.stringify(field.only)}).`);
 			if (field.play !== undefined && field.play !== 'loop') fail(`${where}: media's play can only be 'loop' (a loop-only slot, like a hero's); leave it out to let each clip choose (got ${JSON.stringify(field.play)}).`);
 			if (field.play === 'loop' && field.only === 'image') fail(`${where}: play: 'loop' is for a slot that takes videos, but this one takes images only.`);
+			// M9 Decision 8.
+			if (field.format !== undefined && field.format !== 'webp' && field.format !== 'png') fail(`${where}: media's format must be 'png' or 'webp' (got ${JSON.stringify(field.format)}).`);
+			if (field.format !== undefined && field.only === 'video') fail(`${where}: format is for images, but this slot takes videos only.`);
 			break;
 		default:
 			break;

package/src/content-schema.ts

@@ -47,11 +47,12 @@ const clip: Schema = closed(
 const plainImage: Schema = closed({ key: { type: 'string', minLength: 1 }, w: size, h: size, focal }, ['key']);
 const seo: Schema = closed({ title: string, description: string, image: plainImage });
 
-function richText(headings: readonly string[]): Schema {
+function richText(headings: readonly string[], lists = true): Schema {
 	const kinds = ['p', ...headings];
 	const unit: Schema[] = [
 		...kinds.map((k) => closed({ [k]: string }, [k])),
-		...['ul', 'ol'].map((k) => closed({ [k]: strings }, [k])),
+		// M9 Decision 11: a heading rich-text field is paragraphs only.
+		...(lists ? ['ul', 'ol'] : []).map((k) => closed({ [k]: strings }, [k])),
 	];
 	// A plain string reads as rich text too (rich-text.ts → "A plain string is read as rich text").
 	return { anyOf: [string, { type: 'array', items: { oneOf: unit } }] };
@@ -68,7 +69,7 @@ export function fieldSchema(field: Field): Schema {
 		case 'select':
 			return described({ enum: field.options.map((o) => o.value) }, field);
 		case 'richText':
-			return described(richText(field.headings), field);
+			return described(richText(field.headings, !field.heading), field);
 		case 'link':
 			return described(field.addressOnly ? closed({ href: string }) : closed({ label: string, href: string }), field);
 		case 'buttons':
@@ -129,7 +130,9 @@ export function collectionSchema(site: Pick<ResolvedSite, 'blocks'>, collection:
 	const own = Object.fromEntries(Object.entries(collection.fields ?? {}).map(([key, f]) => [key, fieldSchema(f)]));
 	switch (collection.kind) {
 		case 'sections':
-			return document(collection, { ...own, blocks: { type: 'array', items: { anyOf: [{ $ref: '#/$defs/shared' }, anyBlock(site)] } }, seo }, ['title', 'blocks'], { shared: sharedEntry, ...blockDefs(site) });
+			// M9 Decision 7: `hidden: true` keeps the page off the site; absent, it's shown.
+			const hidden: Schema = { description: 'Hidden from the site: not served, not in the sitemap, still edited in /admin.', const: true };
+			return document(collection, { hidden, ...own, blocks: { type: 'array', items: { anyOf: [{ $ref: '#/$defs/shared' }, anyBlock(site)] } }, seo }, ['title', 'blocks'], { shared: sharedEntry, ...blockDefs(site) });
 		case 'fields':
 			return document(collection, { ...own, seo }, ['title']);
 		case 'shared':

package/src/content.ts

@@ -70,6 +70,13 @@ export interface DocumentEntry {
 	label: string;
 	/** Set when the file can't be opened. */
 	warning: DocumentWarning | null;
+	/**
+	 * M9 Decision 7: hidden from the site, by the page's own `"hidden": true` or (`hiddenBy`, the
+	 * path of the hidden page above it) a page it's nested under. A site's routes, the sitemap and
+	 * `contentReader().documents()` leave it out; the editor lists it, marked. Never the home page.
+	 */
+	hidden?: true;
+	hiddenBy?: string;
 	/** A section builder's shared-block entries, by shared block path, in block order, once each (Decision 8). Absent otherwise. */
 	uses?: string[];
 	/** A shared block: its block's type (`''` when it has none). Absent otherwise. */
@@ -224,6 +231,7 @@ export async function listDocuments(
 		if (!collection) throw new DocumentError('unknown-collection', `No collection "${name}" is declared.`);
 		const paths = await documentPaths(collection, source);
 		const entries = (await Promise.all(paths.map((path) => entryFor(site, collection, path, source)))).filter((e) => e !== null);
+		if (collection.nested) hideChildren(entries);
 		all.push(...(collection.nested ? flattenTree(pageTree(entries)) : entries.sort(byLabel)));
 	}
 	if (!collectionName) {
@@ -236,6 +244,22 @@ export async function listDocuments(
 	return all;
 }
 
+/** M9 Decision 7: a hidden page's children are hidden with it; `hiddenBy` names the topmost hidden page above. */
+function hideChildren(entries: DocumentEntry[]): void {
+	const hidden = new Set(entries.filter((e) => e.hidden).map((e) => e.path));
+	if (hidden.size === 0) return;
+	for (const entry of entries) {
+		const parts = entry.path.split('/');
+		for (let n = 1; n < parts.length; n++) {
+			const above = parts.slice(0, n).join('/');
+			if (!hidden.has(above)) continue;
+			entry.hidden = true;
+			entry.hiddenBy = above;
+			break;
+		}
+	}
+}
+
 /**
  * Read one document. Throws DocumentError: 'not-found', 'bad-path',
  * 'unknown-collection', or the listing's warning codes ('invalid-json',
@@ -308,6 +332,8 @@ function inspect(
 		return warn('no-title', 'This file has no title, so it can’t be opened. Add a "title".');
 	}
 	const entry: DocumentEntry = { ...base, title, label: title, warning: null };
+	// M9 Decision 7: the home page is never hidden.
+	if ((document.kind === undefined || document.kind === 'sections') && document.hidden && path !== 'index') entry.hidden = true;
 	if (document.kind === undefined || document.kind === 'sections') {
 		entry.uses = [...new Set(document.blocks.flatMap((b) => (b.shared !== undefined ? [b.shared] : [])))];
 	} else if (document.kind === 'shared') {

package/src/document.ts

@@ -60,6 +60,13 @@ export interface SiteDocument {
 	 * own `seo` as it is.
 	 */
 	seo?: Seo;
+	/**
+	 * M9 Decision 7: the page is hidden from the site (the file's top-level `"hidden": true`;
+	 * absent means shown). Not served, not in the sitemap, not offered by the link picker; still
+	 * edited, previewed and published in /admin. The editor sends `false` to unhide, which takes
+	 * the key out of the file. The home page (`index`) can't be hidden (content.ts reads it as shown).
+	 */
+	hidden?: boolean;
 	/**
 	 * M6c (G2): the page fields' parsed values, keyed by field, every field of the
 	 * collection's `fields` present (the file's top-level keys after `title`). Present
@@ -217,6 +224,7 @@ export function parseDocument(raw: unknown, site: Pick<ResolvedSite, 'blocks'>):
 		title: typeof doc.title === 'string' ? doc.title : '',
 		blocks: rawBlocks.map((b, index) => parseBlock(b, index, site)),
 		...seoOf(doc),
+		...(doc.hidden === true ? { hidden: true } : {}),
 	};
 }
 
@@ -279,6 +287,8 @@ export function normaliseDocument(input: unknown, site: Pick<ResolvedSite, 'bloc
 			return { source, type, known: true, data: parsed };
 		}),
 		...seoOf(asObject(input)),
+		// M9 Decision 7: true hides, false unhides, absent leaves the file's as it is.
+		...(typeof doc.hidden === 'boolean' ? { hidden: doc.hidden } : {}),
 	};
 }
 
@@ -366,6 +376,9 @@ export interface DocumentReader {
  * render from the document (never module state, so concurrent preview renders
  * can't leak into each other: M3 → Watch-outs).
  */
+/** M9 Decision 9: `<Blocks wrap>`'s rule and its runs, for a site's page component (`import type { WrapBlocks } from 'caracms/document'`). */
+export type { BlockRun, WrapBlock, WrapBlocks } from './block-runs.ts';
+
 export interface BlockContext {
 	/**
 	 * The block's position in the document being rendered: the editor's block index (0 for a
@@ -497,8 +510,8 @@ export function headingTag(cms: BlockContext, field: string): 'h1' | 'h2' {
 	return cms.h1Field === field ? 'h1' : 'h2';
 }
 
-/** Is a field one that can hold the page's heading (Decision 16): a lockup or a text field marked `heading`? */
-export const isHeadingField = (field: Field): boolean => (field.kind === 'lockup' || field.kind === 'text') && field.heading;
+/** Is a field one that can hold the page's heading (Decision 16): a lockup, or a text or rich-text field (M9 Decision 11) marked `heading`? */
+export const isHeadingField = (field: Field): boolean => (field.kind === 'lockup' || field.kind === 'text' || field.kind === 'richText') && !!field.heading;
 
 /**
  * Decision 16: the index of the first block, in render order (skipping unknown

package/src/editor/client/block-list/summary.ts

@@ -9,7 +9,8 @@
  *   fieldsSummary(block)        the picker's line under a type: its fields' labels
  */
 import { own, sharedEntryOf } from '../../../document.ts';
-import { titleCase, type Field } from '../../../fields.ts';
+import { parseField, titleCase, type Field } from '../../../fields.ts';
+import { richTextPlain, type RichTextValue } from '../../../rich-text.ts';
 import type { EditorBlock, EditorSite, ListedDocument } from '../../types.ts';
 
 /**
@@ -94,6 +95,11 @@ function firstText(fields: Record<string, Field>, block: Pick<EditorBlock, 'data
 			if (lines.length) return lines.join(' / ');
 		}
 		if (field.kind === 'text' && typeof value === 'string' && value.trim()) return value.replace(/\s+/g, ' ').trim();
+		// M9 Decision 11: a rich heading's words, without its bold.
+		if (field.kind === 'richText' && field.heading) {
+			const words = richTextPlain(parseField(field, value) as RichTextValue).replace(/\s+/g, ' ').trim();
+			if (words) return words;
+		}
 	}
 	return null;
 }

package/src/editor/client/fields/HiddenToggle.tsx

@@ -0,0 +1,51 @@
+/**
+ * M9 Decision 7: the page's "Hidden from the site" switch, at the document level under its
+ * page fields and above Search and sharing. It's the toggle field's switch (SimpleFields.tsx →
+ * ToggleField), set through `editor.doc.setHidden`, so it saves and publishes like any edit.
+ *
+ * - Only on a section builder's page with an address, and never on the home page (`index`),
+ *   which can't be hidden.
+ * - A page under a hidden page is hidden with it (content.ts → `hiddenBy`): the switch shows
+ *   on and can't be turned off here, and its help names the page to show again.
+ */
+import { useMemo } from 'react';
+import { useEditor, useStore } from '../context.tsx';
+import { FieldFrame } from './FieldFrame.tsx';
+import { FieldHostProvider, type FieldHost } from './host.tsx';
+
+const SCOPE = 'page-hidden';
+const NAME = 'hidden';
+
+export function HiddenToggle() {
+	const editor = useEditor();
+	const ref = useStore(editor.doc.state, (s) => s.ref);
+	const kind = useStore(editor.doc.state, (s) => s.document.kind);
+	const hidden = useStore(editor.doc.state, (s) => !!s.document.hidden);
+	const documents = useStore(editor.documents);
+	const readOnly = useStore(editor.access, (a) => a.readOnly);
+	const host = useMemo<FieldHost>(
+		() => ({ scope: SCOPE, picked: () => null, pick() {}, set: (_path, value) => editor.doc.setHidden(value === true), removeItem() {}, raw: () => undefined, readOnly }),
+		[editor, readOnly],
+	);
+	const collection = editor.site.collections.find((c) => c.name === ref.collection);
+	if (kind !== 'sections' || !collection?.urlBase || ref.path === 'index') return null;
+	const listed = documents.find((d) => d.collection === ref.collection && d.path === ref.path);
+	const by = listed?.hiddenBy ? documents.find((d) => d.collection === ref.collection && d.path === listed.hiddenBy) : undefined;
+	const on = hidden || !!by;
+	const id = `f-${SCOPE}-${NAME}`;
+	const help = by
+		? `Hidden with ${by.label}, the page it's under. Show that page again to show this one.`
+		: 'Visitors get the 404 page, and it’s left out of the sitemap and the link picker. You can still edit, preview and publish it.';
+	return (
+		<div className="page-hidden" data-page-hidden={on ? 'on' : 'off'}>
+			<FieldHostProvider host={host}>
+				<FieldFrame blockKey={SCOPE} name={NAME} label="Hidden from the site" help={help} htmlFor={id}>
+					<button type="button" className="switch" role="switch" id={id} data-path={NAME} aria-checked={on} disabled={readOnly || !!by} onClick={() => host.set(NAME, !hidden)}>
+						<span className="track" />
+						<span>{on ? 'On' : 'Off'}</span>
+					</button>
+				</FieldFrame>
+			</FieldHostProvider>
+		</div>
+	);
+}

package/src/editor/client/fields/LinkField.tsx

@@ -88,6 +88,7 @@ export function LinkControl(props: { path: string; href: string; onChange: (href
 	const file = fileKeyOf(href.trim());
 	const doc = href && !file ? documentAt(href, linkable) : undefined;
 	const missing = props.warnings.find((w) => w.code === 'link-missing');
+	const hiddenTarget = props.warnings.find((w) => w.code === 'link-hidden');
 	const rule = props.warnings.find((w) => w.code === 'link-rule');
 	const files = useLibraryFiles();
 	const chooseFile = () => {
@@ -181,20 +182,24 @@ export function LinkControl(props: { path: string; href: string; onChange: (href
 	if (doc && !rule) {
 		const collection = editor.site.collections.find((c) => c.name === doc.collection);
 		const crumb = collection?.nested ? parentLabel(doc, documents) : '';
+		// M9 Decision 7: a link to a hidden page keeps its chip, with the warning under it.
 		return (
-			<div className="lnk" data-link-path={props.path}>
-				<div className="lnk-box" data-path={props.path} tabIndex={-1}>
-					<Icon name={docIcon(collection)} />
-					<span className="lnk-doc">
-						<b>
-							{crumb ? `${crumb} / ` : ''}
-							{doc.label || doc.title}
-						</b>
-						<span className="mono">{doc.url}</span>
-					</span>
-					{clear}
+			<>
+				<div className="lnk" data-link-path={props.path} data-link-hidden={hiddenTarget ? '' : undefined}>
+					<div className="lnk-box" data-path={props.path} tabIndex={-1}>
+						<Icon name={docIcon(collection)} />
+						<span className="lnk-doc">
+							<b>
+								{crumb ? `${crumb} / ` : ''}
+								{doc.label || doc.title}
+							</b>
+							<span className="mono">{doc.url}</span>
+						</span>
+						{clear}
+					</div>
 				</div>
-			</div>
+				{hiddenTarget ? <Warnings warnings={[hiddenTarget]} /> : null}
+			</>
 		);
 	}
 	if (missing && !rule) {

package/src/editor/client/fields/ReferenceField.tsx

@@ -148,6 +148,12 @@ export function RefPicker(props: { to: string; taken?: readonly string[]; onPick
 							<Icon name={icon} />
 							<span className="nm">{d.label || d.title}</span>
 							<span className="meta">
+								{/* M9 Decision 7: a hidden page is still offered (the reference is legitimate), marked as the pages list marks it. */}
+								{d.hidden ? (
+									<span className="hmark" data-mark="hidden" title={d.hiddenBy ? 'Hidden from the site with the page it’s under' : 'Hidden from the site'}>
+										Hidden
+									</span>
+								) : null}
 								<span>{on ? 'Added' : <span className="mono">{d.url ?? d.path}</span>}</span>
 							</span>
 						</button>

package/src/editor/client/fields/RichTextField.tsx

@@ -5,7 +5,8 @@
  *
  * - **The toolbar:** the paragraph style (only when the field allows headings:
  *   Paragraph, Heading 2, and Heading 3 where allowed; never Heading 1), Bold,
- *   Italic, Bulleted list, Numbered list, and Link (when the field allows links).
+ *   Italic, Bulleted list, Numbered list, and Link (when the field allows links). A heading
+ *   field (M9 Decision 11) has Bold only.
  *   ⌘B, ⌘I and ⌘K do the same.
  * - **The link popover** (⌘K or the toolbar): find a document by title or address,
  *   or type an address; picking a document stores its URL (Decision 4). An address
@@ -23,7 +24,7 @@
  */
 import { Editor } from '@tiptap/core';
 import { useEffect, useRef, useState, type FocusEvent } from 'react';
-import type { RichTextField as RichTextDescriptor } from '../../../fields.ts';
+import { richTextOptions, type RichTextField as RichTextDescriptor } from '../../../fields.ts';
 import { fileAddress, fileKeyOf } from '../../../files.ts';
 import type { LibraryFile } from '../../types.ts';
 import { richTextHtml, type RichTextValue } from '../../../rich-text.ts';
@@ -48,8 +49,8 @@ export function RichTextField(props: { name: string; label: string; field: RichT
 	const { name, field } = props;
 	const id = `f-${host.scope}-${name}`.replace(/\./g, '-');
 	const value = (Array.isArray(props.value) ? props.value : []) as RichTextValue;
-	const options = { headings: field.headings, links: field.links };
-	const optionsKey = `${field.headings.join(',')}|${field.links}`;
+	const options = richTextOptions(field);
+	const optionsKey = `${field.headings.join(',')}|${field.links}|${!!field.heading}`;
 	const linkable = useLinkable();
 	const warnings = useFieldWarnings(name, field, props.value);
 
@@ -79,7 +80,7 @@ export function RichTextField(props: { name: string; label: string; field: RichT
 		const ed = new Editor({
 			element: el,
 			extensions: richTextExtensions(latest.current.options),
-			content: toDoc(JSON.parse(lastValue.current) as RichTextValue),
+			content: toDoc(JSON.parse(lastValue.current) as RichTextValue, latest.current.options),
 			injectCSS: false,
 			enableInputRules: false,
 			enablePasteRules: false,
@@ -126,7 +127,7 @@ export function RichTextField(props: { name: string; label: string; field: RichT
 		const json = JSON.stringify(value);
 		if (!ed || json === lastValue.current) return;
 		lastValue.current = json;
-		if (JSON.stringify(fromDoc(ed.getJSON() as PMNode, options)) !== json) ed.commands.setContent(toDoc(value), { emitUpdate: false });
+		if (JSON.stringify(fromDoc(ed.getJSON() as PMNode, options)) !== json) ed.commands.setContent(toDoc(value, options), { emitUpdate: false });
 	}, [props.value]);
 
 	useEffect(() => {
@@ -172,8 +173,8 @@ export function RichTextField(props: { name: string; label: string; field: RichT
 	};
 
 	const shownAsText = warnings.filter((w) => w.code === 'disallowed-kind').length;
-	const quiet = warnings.filter((w) => w.code === 'disallowed-kind' || w.code === 'link-off');
-	const loud = warnings.filter((w) => w.code !== 'disallowed-kind' && w.code !== 'link-off');
+	const quiet = warnings.filter((w) => w.code === 'disallowed-kind' || w.code === 'link-off' || w.code === 'italic-off');
+	const loud = warnings.filter((w) => w.code !== 'disallowed-kind' && w.code !== 'link-off' && w.code !== 'italic-off');
 	const disabled = host.readOnly;
 
 	return (
@@ -215,30 +216,35 @@ export function RichTextField(props: { name: string; label: string; field: RichT
 					<button type="button" aria-label="Bold" aria-pressed={active('bold')} disabled={disabled} onMouseDown={keep} onClick={() => run((e) => e.chain().focus().toggleMark('bold').run())}>
 						<b>B</b>
 					</button>
-					<button type="button" aria-label="Italic" aria-pressed={active('italic')} disabled={disabled} onMouseDown={keep} onClick={() => run((e) => e.chain().focus().toggleMark('italic').run())}>
-						<i className="tb-i">I</i>
-					</button>
-					<span className="sep" aria-hidden="true" />
-					<button
-						type="button"
-						aria-label="Bulleted list"
-						aria-pressed={active('bulletList')}
-						disabled={disabled}
-						onMouseDown={keep}
-						onClick={() => run((e) => toggleList(e, 'bulletList'))}
-					>
-						<FieldIcon name="ul" size="sm" />
-					</button>
-					<button
-						type="button"
-						aria-label="Numbered list"
-						aria-pressed={active('orderedList')}
-						disabled={disabled}
-						onMouseDown={keep}
-						onClick={() => run((e) => toggleList(e, 'orderedList'))}
-					>
-						<FieldIcon name="ol" size="sm" />
-					</button>
+					{/* M9 Decision 11: a heading field is bold and line breaks only. */}
+					{field.heading ? null : (
+						<>
+							<button type="button" aria-label="Italic" aria-pressed={active('italic')} disabled={disabled} onMouseDown={keep} onClick={() => run((e) => e.chain().focus().toggleMark('italic').run())}>
+								<i className="tb-i">I</i>
+							</button>
+							<span className="sep" aria-hidden="true" />
+							<button
+								type="button"
+								aria-label="Bulleted list"
+								aria-pressed={active('bulletList')}
+								disabled={disabled}
+								onMouseDown={keep}
+								onClick={() => run((e) => toggleList(e, 'bulletList'))}
+							>
+								<FieldIcon name="ul" size="sm" />
+							</button>
+							<button
+								type="button"
+								aria-label="Numbered list"
+								aria-pressed={active('orderedList')}
+								disabled={disabled}
+								onMouseDown={keep}
+								onClick={() => run((e) => toggleList(e, 'orderedList'))}
+							>
+								<FieldIcon name="ol" size="sm" />
+							</button>
+						</>
+					)}
 					{field.links ? (
 						<>
 							<span className="sep" aria-hidden="true" />

package/src/editor/client/fields/host.tsx

@@ -20,6 +20,7 @@ import { fieldWarnings, getAtPath, parseField, splitPath, type Field, type Field
 import { mediaFor } from '../media/store.ts';
 import { useEditor, useStore } from '../context.tsx';
 import type { Editor, View } from '../editor.ts';
+import { hiddenDocuments, hiddenPages } from '../../../links.ts';
 
 export interface FieldHost {
 	/**
@@ -121,6 +122,10 @@ export function useWarningContext(): WarningContext {
 		const keys = files ? new Set(files.map((f) => f.key)) : null;
 		return {
 			addresses: documents.map((d) => d.url),
+			// M9 Decision 7: a link to a hidden page warns.
+			hiddenPages: hiddenPages(documents),
+			// ...and so does a reference to one.
+			hiddenDocuments: hiddenDocuments(documents),
 			// M8 trial (item 3): an address the site's own code serves exists too.
 			codeRoutes: editor.site.codeRoutes ?? [],
 			documentExists: (collection: string, path: string) => ids.has(`${collection}/${path}`),

package/src/editor/client/fields/parts.tsx

@@ -113,7 +113,8 @@ export interface LinkHits {
 export function linkHits(query: string, documents: readonly ListedDocument[], collections: Editor['site']['collections']): LinkHits {
 	const q = query.trim();
 	const address: LinkHit | null = q && looksLikeAddress(q) ? { key: `addr:${q}`, href: q, doc: null, crumb: '' } : null;
-	const linkable = documents.filter((d) => typeof d.url === 'string');
+	// M9 Decision 7: a hidden page isn't offered (a link to one only warns).
+	const linkable = documents.filter((d) => typeof d.url === 'string' && !d.hidden);
 	const groups = q
 		? searchDocuments(q, linkable, collections).map((g) => ({
 				label: g.collection.label,

package/src/editor/client/fields/rich-text-doc.ts

@@ -10,6 +10,10 @@
  *   a run      ↔ text with marks bold, italic, link { href }
  *   "\n"       ↔ hardBreak (Shift+Enter: a break inside the paragraph, heading or item)
  *
+ * A heading field (M9 Decision 11, `options.heading`) has no blocks: its document's
+ * content is inline, as its heading tag holds it, each paragraph a line, the lines
+ * joined by hardBreaks. Read back, every break starts a paragraph.
+ *
  * `fromDoc` reads back through Phase 1's `parseRichText`, so what the store holds
  * is always the field's own value: empty paragraphs, items and lists dropped,
  * breaks at a unit's start or end trimmed, kinds the field doesn't allow as `p`,
@@ -56,8 +60,13 @@ const textblock = (type: string, runs: readonly TextRun[], attrs?: Record<string
 	return { type, ...(attrs ? { attrs } : {}), ...(content.length ? { content } : {}) };
 };
 
-/** A value as the editor's document. Never empty: an empty value is one empty paragraph. */
-export function toDoc(value: RichTextValue): PMNode {
+/** A value as the editor's document. Never empty: an empty value is one empty paragraph (a heading's: no content). */
+export function toDoc(value: RichTextValue, options?: Pick<RichTextOptions, 'heading'>): PMNode {
+	if (options?.heading) {
+		const lines = value.flatMap((block) => ('items' in block ? block.items : [block.runs]));
+		const content = lines.flatMap((runs, i) => [...(i > 0 ? [{ type: 'hardBreak' }] : []), ...inlineNodes(runs)]);
+		return { type: 'doc', ...(content.length ? { content } : {}) };
+	}
 	const content: PMNode[] = value.map((block) => {
 		if ('items' in block) {
 			return {
@@ -91,6 +100,18 @@ export function runsOf(content: readonly PMNode[] | undefined): TextRun[] {
 	return runs;
 }
 
+/** Runs split at each `\n`: a heading field's lines (M9 Decision 11). */
+export function splitLines(runs: readonly TextRun[]): TextRun[][] {
+	const lines: TextRun[][] = [[]];
+	for (const run of runs) {
+		run.text.split('\n').forEach((part, i) => {
+			if (i > 0) lines.push([]);
+			if (part !== '') lines.at(-1)!.push({ ...run, text: part });
+		});
+	}
+	return lines;
+}
+
 const isBlock = (node: PMNode) => node.type === 'paragraph' || node.type === 'heading';
 
 /**
@@ -105,6 +126,11 @@ const itemRuns = (item: PMNode): TextRun[] => {
 
 /** The editor's document as the field's value (normalised by the field's rules). */
 export function fromDoc(doc: PMNode, options: RichTextOptions): RichTextValue {
+	if (options.heading) {
+		// A heading's document is inline (or, from older content, paragraphs): each line a paragraph.
+		const content = (doc.content ?? []).some(isBlock) ? (doc.content ?? []).filter(isBlock).flatMap((child, i) => [...(i > 0 ? [{ type: 'hardBreak' }] : []), ...(child.content ?? [])]) : doc.content;
+		return parseRichText(splitLines(runsOf(content)).map((runs) => ({ kind: 'p', runs })), options);
+	}
 	const blocks: unknown[] = [];
 	for (const node of doc.content ?? []) {
 		if (node.type === 'paragraph') blocks.push({ kind: 'p', runs: runsOf(node.content) });

package/src/editor/client/fields/rich-text-schema.ts

@@ -20,6 +20,8 @@
  * - **Paste keeps only what the field allows:** HTML is read through this schema
  *   (anything else is dropped or becomes text); plain text has a blank line start a
  *   paragraph and a single newline make a break.
+ * - **A heading field** (M9 Decision 11): the document is inline content (no paragraph,
+ *   list or heading nodes), with bold and hardBreak only; Enter is a line break too.
  * - Undo inside the field is its own (⌘Z / ⇧⌘Z), as every text field's is (Decision 14).
  */
 import { Extension, Mark, Node } from '@tiptap/core';
@@ -153,8 +155,41 @@ const Keys = () =>
 		},
 	});
 
+/**
+ * A heading field's document (M9 Decision 11): inline content straight inside the
+ * heading tag, as RichText.astro draws it, so there's no paragraph to put a `<p>` in.
+ */
+const InlineDoc = Node.create({ name: 'doc', topNode: true, content: 'inline*' });
+
+/** A heading field's keys: Enter and Shift+Enter both start a new line; bold only. */
+const HeadingKeys = () =>
+	Extension.create({
+		name: 'caracmsHeadingKeys',
+		priority: 1000,
+		addProseMirrorPlugins: () => [history()],
+		addKeyboardShortcuts() {
+			const editor = this.editor;
+			const lineBreak = () =>
+				editor.commands.command(({ tr, state, dispatch }) => {
+					if (dispatch) tr.replaceSelectionWith(state.schema.nodes.hardBreak!.create(), false).scrollIntoView();
+					return true;
+				});
+			return {
+				'Shift-Enter': lineBreak,
+				Enter: lineBreak,
+				'Mod-b': () => editor.commands.toggleMark('bold'),
+				'Mod-i': () => true,
+				'Mod-z': () => undo(editor.state, editor.view.dispatch),
+				'Shift-Mod-z': () => redo(editor.state, editor.view.dispatch),
+				'Mod-y': () => redo(editor.state, editor.view.dispatch),
+				Tab: () => false,
+			};
+		},
+	});
+
 /** Every extension the field's editor runs with. */
-export function richTextExtensions(options: { headings: readonly HeadingKind[]; links: boolean }) {
+export function richTextExtensions(options: { headings: readonly HeadingKind[]; links: boolean; heading?: boolean }) {
+	if (options.heading) return [InlineDoc, Text, HardBreak, Bold, HeadingKeys()];
 	const levels = options.headings.map((h) => (h === 'h2' ? 2 : 3));
 	return [
 		Doc,
@@ -172,9 +207,13 @@ export function richTextExtensions(options: { headings: readonly HeadingKind[];
 	];
 }
 
-/** Plain text pasted (Spec → Text): a blank line starts a new paragraph, a single newline is a break. */
+/** Plain text pasted (Spec → Text): a blank line starts a new paragraph, a single newline is a break. In a heading (no paragraphs): each a line. */
 export function clipboardTextParser(text: string, _context: unknown, _plain: boolean, view: EditorView): Slice {
 	const schema = view.state.schema;
+	if (!schema.nodes.paragraph) {
+		const inline = pastedParagraphs(text).flatMap((nodes, i) => [...(i > 0 ? [{ type: 'hardBreak' } as PMNode] : []), ...nodes]);
+		return new Slice(Fragment.fromArray(inline.map((n) => (n.type === 'hardBreak' ? schema.nodes.hardBreak!.create() : schema.text(n.text!)))), 0, 0);
+	}
 	const paragraphs = pastedParagraphs(text).map((inline) =>
 		schema.nodes.paragraph!.create(
 			null,

package/src/editor/client/nav/DocRow.tsx

@@ -85,6 +85,12 @@ export function DocRow(props: {
 							<span className="sr">, can't be opened</span>
 						</span>
 					) : null}
+					{/* M9 Decision 7: hidden from the site (or under a hidden page). */}
+					{doc.hidden ? (
+						<span className="hmark" data-mark="hidden" title={doc.hiddenBy ? 'Hidden from the site with the page it’s under' : 'Hidden from the site'}>
+							Hidden
+						</span>
+					) : null}
 					{tooLong ? (
 						<span className="wmark" title="Too long for mobile" data-mark="too-long">
 							<Icon name="phone" size="xs" />