caracms 0.1.0 → 0.2.0

package/src/editor/client/overlays/rich-text-bar.ts

@@ -211,8 +211,8 @@ export function startRichTextBar(editor: Editor, overlays: Overlays, pageEdit: P
 
 	/** The bar's buttons, for the field's options (built once per set of options). */
 	function build(s: Shown) {
-		const { headings, links } = s.state.options;
-		const key = `${headings.join(',')}|${links}`;
+		const { headings, links, heading } = s.state.options;
+		const key = `${headings.join(',')}|${links}|${!!heading}`;
 		if (s.built === key) return;
 		s.built = key;
 		const sep = '<span class="cms-rtsep" aria-hidden="true"></span>';
@@ -223,10 +223,10 @@ export function startRichTextBar(editor: Editor, overlays: Overlays, pageEdit: P
 				? `<button type="button" class="cms-st" data-rtc="style" aria-haspopup="menu" aria-expanded="false" aria-label="Paragraph style: Paragraph">Paragraph${icon('chev-d')}</button>${sep}`
 				: '') +
 			button('bold', 'Bold', 'Bold (⌘B)', '<b>B</b>') +
-			button('italic', 'Italic', 'Italic (⌘I)', '<i>I</i>') +
-			sep +
-			button('ul', 'Bulleted list', 'Bulleted list', icon('ul')) +
-			button('ol', 'Numbered list', 'Numbered list', icon('ol')) +
+			// M9 Decision 11: a heading field is bold and line breaks only.
+			(heading
+				? ''
+				: button('italic', 'Italic', 'Italic (⌘I)', '<i>I</i>') + sep + button('ul', 'Bulleted list', 'Bulleted list', icon('ul')) + button('ol', 'Numbered list', 'Numbered list', icon('ol'))) +
 			(links ? sep + button('link', 'Link', 'Link (⌘K)', icon('link'), ' aria-haspopup="dialog"') : '');
 	}
 

package/src/editor/client/pane/levels/DocumentLevel.tsx

@@ -20,6 +20,7 @@ import { DocNotices, ReadOnlyChip } from '../../live/notices.tsx';
 import { DocMenu } from '../../documents/DocMenu.tsx';
 import { FieldsDocumentLevel, SettingsLevel, SharedDocumentLevel } from './FormLevel.tsx';
 import { SeoGroup } from '../../fields/SeoGroup.tsx';
+import { HiddenToggle } from '../../fields/HiddenToggle.tsx';
 import { PageFields } from '../../fields/PageFields.tsx';
 
 /** The open document's level, by its kind (M5a): a section builder's blocks, or a form. */
@@ -81,6 +82,8 @@ function SectionsLevel() {
 				)}
 				{/* M6c (G2): the page's own fields, when its collection has some, under its blocks. */}
 				<PageFields />
+				{/* M9 Decision 7: hidden from the site, or not. */}
+				<HiddenToggle />
 				{/* M6 Decision 13: the page's own Search and sharing, under its blocks. */}
 				<SeoGroup />
 			</div>

package/src/editor/client/preview/driver.ts

@@ -83,13 +83,13 @@ import type { DocumentStore } from '../state/document-store.ts';
 import { createStore, type Store } from '../state/store.ts';
 import { ENDPOINTS, PREVIEW_MARK, TRUE_WIDTH, WIDTHS, sameDoc, type DocRef, type EditorSite, type Width } from '../../types.ts';
 import { createSequencer, type Sequencer } from './render-sequencer.ts';
-import { fieldText } from './field-text.ts';
+import { fieldText, shownText, writeFieldText } from './field-text.ts';
 import { restoreSelection, saveSelection } from './selection.ts';
 import { readLockups, type LockupWarning } from './warnings.ts';
 import { ACTIVITY_EVENTS } from '../state/live.ts';
 import { fieldElement } from './markers.ts';
 import { mountedIn, writeRichText } from './page-editor-registry.ts';
-import { fieldAt, getAtPath, isKeyPath, type Fields, type RichTextField } from '../../../fields.ts';
+import { fieldAt, getAtPath, isKeyPath, richTextOptions, type Fields, type RichTextField } from '../../../fields.ts';
 import { fieldsOfBlock } from '../state/schema.ts';
 
 export interface PreviewFrame {
@@ -501,7 +501,7 @@ export function createPreviewDriver(options: {
 	function setRichText(doc: Document, block: number, field: string, value: unknown, descriptor: RichTextField) {
 		const el = fieldElement(doc, block, field, 'richText');
 		if (!el || mountedIn(doc)?.el === el) return;
-		writeRichText(el, value, { headings: descriptor.headings, links: descriptor.links });
+		writeRichText(el, value, richTextOptions(descriptor));
 	}
 
 	/** The field's descriptor in a block, when it's a rich-text field typed on the page (top level, or in a group). */
@@ -515,14 +515,14 @@ export function createPreviewDriver(options: {
 
 	/**
 	 * Put a plain text field's text into a frame. `\n` becomes <br> (innerText's setter;
-	 * the line-break rule); the text is compared as typed (field-text.ts), not as the
+	 * the line-break rule), or a line each in the lines rendering (field-text.ts); the text is compared as typed (field-text.ts), not as the
 	 * site's CSS shows it. `skipActive`: leave the field being typed in alone (it's the
 	 * source of the text, and rewriting it would lose the caret).
 	 */
 	function setText(doc: Document, block: number, field: string, text: string, skipActive = false) {
 		const el = fieldElement(doc, block, field, 'text');
 		if (!el || (skipActive && doc.activeElement === el)) return;
-		if (fieldText(el) !== text) el.innerText = text;
+		if (fieldText(el) !== shownText(el, text)) writeFieldText(el, text);
 	}
 
 	store.subscribe((session, change) => {

package/src/editor/client/preview/field-text.ts

@@ -5,7 +5,8 @@
  * capitals), and a contenteditable's spaces come back as no-break spaces.
  *
  * - a text node is its text (no-break spaces as spaces); a `<br>` is `\n`
- * - a block element the browser inserted (a `<div>` on Enter) starts a new line
+ * - a block element the browser inserted (a `<div>` on Enter) starts a new line, and so
+ *   does a line of the lines rendering (`[data-cms-line]`, M9 Decision 10)
  * - the trailing `<br>` a browser adds so an empty last line shows is dropped
  * - one line only: breaks become spaces
  */
@@ -20,7 +21,7 @@ export function fieldText(el: Element, multiline = true): string {
 				const tag = (child as Element).tagName;
 				if (tag === 'BR') out += '\n';
 				else {
-					if (BLOCKS.has(tag) && out && !out.endsWith('\n')) out += '\n';
+					if ((BLOCKS.has(tag) || (child as Element).hasAttribute('data-cms-line')) && out && !out.endsWith('\n')) out += '\n';
 					walk(child);
 				}
 			}
@@ -31,3 +32,40 @@ export function fieldText(el: Element, multiline = true): string {
 	if (out.endsWith('\n')) out = out.slice(0, -1);
 	return multiline ? out : out.replace(/\n+/g, ' ');
 }
+
+/**
+ * The text a field element shows for `text`: a lines-rendering field (`[data-cms-lines]`,
+ * M9 Decision 10) trims each line and drops blank ones, as Text.astro does; any other field shows it all.
+ */
+export function shownText(el: Element, text: string): string {
+	return el.hasAttribute('data-cms-lines') ? text.split('\n').map((line) => line.trim()).filter((line) => line !== '').join('\n') : text;
+}
+
+/**
+ * Put a plain text field's text into its element as the render draws it. `\n` becomes
+ * `<br>` (innerText's setter; the line-break rule), except in the lines rendering (M9
+ * Decision 10): blank lines drop, one line is bare text, and two or more are a `<span>`
+ * each with the component's `lineClass` and the `data-cms-line` marker.
+ */
+export function writeFieldText(el: HTMLElement, text: string): void {
+	if (!el.hasAttribute('data-cms-lines')) {
+		el.innerText = text;
+		return;
+	}
+	const lines = shownText(el, text).split('\n').filter((line) => line !== '');
+	if (lines.length <= 1) {
+		el.textContent = lines[0] ?? '';
+		return;
+	}
+	const doc = el.ownerDocument;
+	const cls = el.getAttribute('data-cms-line-class');
+	el.replaceChildren(
+		...lines.map((line) => {
+			const span = doc.createElement('span');
+			if (cls) span.className = cls;
+			span.setAttribute('data-cms-line', '');
+			span.textContent = line;
+			return span;
+		}),
+	);
+}

package/src/editor/client/preview/page-edit.ts

@@ -46,7 +46,7 @@ import { blockElement, blockIndexOf, blockRootOf, fieldElement, skippedAnchor, s
 import { mountPageEditor, pointInField, positionOf, type MountedPageEditor } from './page-editor.ts';
 import { mountedIn, setMounted } from './page-editor-registry.ts';
 import { fieldsOfBlock } from '../state/schema.ts';
-import { fieldAt, getAtPath, isKeyPath } from '../../../fields.ts';
+import { fieldAt, getAtPath, isKeyPath, richTextOptions } from '../../../fields.ts';
 import type { RichTextOptions } from '../../../rich-text.ts';
 
 export interface Typing {
@@ -227,7 +227,7 @@ export function pageEditFor(editor: Editor): PageEdit | null {
 		const block = editor.doc.block(key);
 		const session = editor.doc.get();
 		const descriptor = block?.known ? fieldAt(fieldsOfBlock(editor.site, session.document, session.ref.collection, block), field) : undefined;
-		return descriptor?.kind === 'richText' ? { headings: descriptor.headings, links: descriptor.links } : null;
+		return descriptor?.kind === 'richText' ? richTextOptions(descriptor) : null;
 	};
 
 	/** Mount the page editor on a field (tearing down any other). Null where it isn't typed on the page. */

package/src/editor/client/preview/page-editor-registry.ts

@@ -8,7 +8,7 @@
  * Light on purpose (no Tiptap here): page-edit.ts mounts and registers; the driver
  * only asks.
  */
-import { parseRichText, richTextHtml, type RichTextOptions } from '../../../rich-text.ts';
+import { parseRichText, richHeadingHtml, richTextHtml, type RichTextOptions } from '../../../rich-text.ts';
 
 export interface MountedField {
 	/** The field's element: the editor's root while mounted. */
@@ -42,9 +42,10 @@ export function setMounted(doc: Document, mounted: MountedField | null): void {
 	else byDoc.delete(doc);
 }
 
-/** A field's value as the render gives it: the same HTML RichText.astro writes. */
+/** A field's value as the render gives it: the same HTML RichText.astro writes (a heading's: its lines, M9 Decision 11). */
 export function renderedHtml(raw: unknown, options: RichTextOptions): string {
-	return richTextHtml(parseRichText(raw, options));
+	const value = parseRichText(raw, options);
+	return options.heading ? richHeadingHtml(value) : richTextHtml(value);
 }
 
 /**

package/src/editor/client/preview/page-editor.ts

@@ -141,7 +141,7 @@ export function mountPageEditor(
 		onKeyDown?: (event: KeyboardEvent) => boolean;
 	},
 ): MountedPageEditor {
-	const options = { headings: [...init.options.headings], links: init.options.links };
+	const options: RichTextOptions = { headings: [...init.options.headings], links: init.options.links, ...(init.options.heading ? { heading: true } : {}) };
 	let value = parseRichText(init.value, options);
 	let last = JSON.stringify(value);
 	// Decision 5's recipe: the attributes exactly as the render left them.
@@ -152,7 +152,7 @@ export function mountPageEditor(
 		// Decision 3: ProseMirror uses the element itself only when given `{ mount }`.
 		element: { mount: el } as unknown as HTMLElement,
 		extensions: richTextExtensions(options),
-		content: toDoc(value),
+		content: toDoc(value, options),
 		injectCSS: false,
 		enableInputRules: false,
 		enablePasteRules: false,
@@ -189,7 +189,7 @@ export function mountPageEditor(
 			// Only the part that differs is replaced, so the selection maps through it (a
 			// whole-document setContent would put it at the end), without an update and
 			// outside the page's own undo (Decision 11).
-			const target = editor.schema.nodeFromJSON(toDoc(next));
+			const target = editor.schema.nodeFromJSON(toDoc(next, options));
 			const current = editor.state.doc;
 			const start = current.content.findDiffStart(target.content);
 			if (start === null) return;

package/src/editor/client/state/document-store.ts

@@ -62,6 +62,8 @@ export type DocumentChange =
 	/** `field` is the path that was set: a field's key, or a dotted path into it (`credits.1.name`). */
 	| { kind: 'field'; key: string; field: string; origin: ChangeOrigin }
 	| { kind: 'title' }
+	/** M9 Decision 7: the page hidden from the site, or shown again. */
+	| { kind: 'hidden' }
 	| { kind: 'add'; key: string }
 	| { kind: 'remove'; key: string }
 	| { kind: 'move'; key: string }
@@ -114,6 +116,8 @@ export interface DocumentStore {
 	 */
 	setField(key: string, field: string, value: unknown, options?: { origin?: ChangeOrigin; undoLabel?: string }): void;
 	setTitle(title: string): void;
+	/** M9 Decision 7: hide a section builder's page from the site, or show it again (never the home page's). */
+	setHidden(hidden: boolean): void;
 	/** Add a new, empty block of a known type at `index` (default: the end). Returns its key. */
 	addBlock(type: string, index?: number): string;
 	/**
@@ -196,11 +200,12 @@ export function createDocumentStore(
 					: doc.blocks.map(keyed);
 		const seo = (doc.kind === undefined || doc.kind === 'sections' || doc.kind === 'fields') && doc.seo !== undefined ? { seo: doc.seo as Record<string, unknown> } : {};
 		const data = (doc.kind === undefined || doc.kind === 'sections') && doc.data !== undefined ? { data: doc.data } : {};
+		const hidden = (doc.kind === undefined || doc.kind === 'sections') && doc.hidden ? { hidden: true } : {};
 		return {
 			ref: { collection: input.ref.collection, path: input.ref.path },
 			entry: input.entry,
 			base: input.base,
-			document: { kind, title: doc.title, blocks, ...seo, ...data },
+			document: { kind, title: doc.title, blocks, ...seo, ...data, ...hidden },
 			revision: 0,
 			undo: [],
 		};
@@ -268,6 +273,13 @@ export function createDocumentStore(
 			commit({ ...current, document: { ...current.document, title }, revision: current.revision + 1 }, { kind: 'title' });
 		},
 
+		setHidden(hidden) {
+			if (!editable() || !builder()) return;
+			const current = state.get();
+			if (!!current.document.hidden === hidden) return;
+			commit({ ...current, document: { ...current.document, hidden }, revision: current.revision + 1 }, { kind: 'hidden' });
+		},
+
 		addBlock(type, index) {
 			if (!editable() || !builder()) return '';
 			const created = emptyBlock(type, site as Parameters<typeof emptyBlock>[1]);
@@ -418,7 +430,13 @@ export function createDocumentStore(
 				case 'shared':
 					return { kind: 'shared', title: document.title, block: first ? plain(first) : { source: 0, type: '', known: false, data: {} } };
 				default:
-					return { title: document.title, blocks: document.blocks.map(plain), ...seoWire(), ...(document.data !== undefined ? { data: document.data } : {}) };
+					return {
+						title: document.title,
+						blocks: document.blocks.map(plain),
+						...seoWire(),
+						...(document.data !== undefined ? { data: document.data } : {}),
+						...(document.hidden !== undefined ? { hidden: document.hidden } : {}),
+					};
 			}
 		},
 	};

package/src/editor/styles/editor.css

@@ -215,6 +215,8 @@ details.fgroup[open]>summary .i{rotate:90deg}
 details.fgroup>.in{padding:0 var(--space-4) var(--space-2)}
 details.fgroup>summary .wmark{margin-left:var(--space-1)}
 details.fgroup>summary .wmark .i{margin-left:0;rotate:none}
+/* M9 Decision 7: the page's "Hidden from the site" switch, between its page fields and Search and sharing. */
+.page-hidden{margin-top:var(--space-4)}
 /* A group field (group()): Page details' section, among a form's fields; inside a list item it keeps to the item's width. */
 details.fgroup.group-field{margin-block:var(--space-3)}
 details.fgroup.group-field+details.fgroup.group-field{margin-top:calc(-1 * var(--space-3))}

package/src/editor/types.ts

@@ -235,6 +235,8 @@ export interface EditorDocument {
 	 * has page fields. Set through `setField(PAGE_SCOPE, …)` (document-store.ts).
 	 */
 	data?: Record<string, unknown>;
+	/** M9 Decision 7: a section builder hidden from the site; absent when the file isn't. Set through `setHidden`. */
+	hidden?: boolean;
 }
 
 /** The preview widths (M2 Decision 3): each iframe at its true width. */

package/src/fields.ts

@@ -7,6 +7,7 @@
  *
  *   text()                     one line
  *   text({ multiline: true })  several lines; a break is stored as `\n` (the line-break rule)
+ *   text({ lines: true })      several lines, each drawn as its own element (M9 Decision 10)
  *   text({ max: 200 })         M6: a soft limit, counted in the editor and amber past it (nothing refused)
  *   lockup({ style })          display text set as lines, optionally with phone lines (Decisions 10–11)
  *   select({ options })        one of a fixed list
@@ -24,7 +25,7 @@
  *
  * M5b (Decision 3) adds:
  *
- *   media({ only?, play? })          an image `{ key, alt, … }` or a Mux clip `{ video, play, … }` (media-value.ts)
+ *   media({ only?, play?, format? }) an image `{ key, alt, … }` or a Mux clip `{ video, play, … }` (media-value.ts)
  *
  * M6c adds `help` (G8: plain text under the field in the sidebar) to every helper, and
  * `link({ addressOnly: true })` (G9): `{ "href" }`, a link with no words of its own.
@@ -47,9 +48,9 @@
  */
 import { fileAddress, fileKeyOf, fileTypeOf, isFileKey } from './files.ts';
 import { codeRouteAt, type CodeRoute } from './code-routes.ts';
-import { internalLinkPath, isLinkHref, missingLinkTarget, validateLink } from './links.ts';
+import { hiddenLinkTarget, hiddenReferenceTarget, internalLinkPath, isLinkHref, missingLinkTarget, validateLink } from './links.ts';
 import { MISSING_ALT_MESSAGE, mediaKind, mediaToJson, parseMedia, renderMedia, type MediaOnly, type MediaValue, type RenderMedia } from './media-value.ts';
-import { readRichText, richTextHrefs, serializeRichText, type HeadingKind, type RichTextValue } from './rich-text.ts';
+import { readRichText, richTextHrefs, serializeRichText, type HeadingKind, type RichTextOptions, type RichTextValue } from './rich-text.ts';
 
 export type { RichTextValue } from './rich-text.ts';
 export type { ClipValue, ImageValue, MediaOnly, MediaValue, PlayAs, RenderClip, RenderImage, RenderMedia } from './media-value.ts';
@@ -80,7 +81,12 @@ export interface TextField extends FieldBase {
 	 * M6: a soft limit (the Form block's intro, Decision 17): the editor counts the
 	 * characters and turns amber past it. Nothing is refused: it's kept as written.
 	 */
-	max?: number;
+	max?: number;	/**
+	 * M9 Decision 10: the lines rendering. Each typed line draws as its own element (Text's
+	 * `lineClass`), blank lines draw nothing, and a single line draws unwrapped. Always
+	 * multiline: a break is still stored as `\n`.
+	 */
+	lines?: true;
 }
 
 export interface LockupField extends FieldBase {
@@ -108,6 +114,12 @@ export interface RichTextField extends FieldBase {
 	headings: readonly HeadingKind[];
 	/** Links allowed (default true). */
 	links: boolean;
+	/**
+	 * M9 Decision 11: the block's heading, typed on the page with bold and line breaks only.
+	 * It can hold the page's `h1` (M3 Decision 16) and draws inside its heading tag, its
+	 * paragraphs as lines joined by `<br>`. No headings, no links, no lists, no italic.
+	 */
+	heading?: true;
 }
 
 export interface LinkField extends FieldBase {
@@ -200,14 +212,19 @@ export interface ReferenceField extends FieldBase {
 /**
  * A media slot (M5b Decision 3): an image or a Mux clip. `only` limits it to one
  * kind (a value of the other is kept and warned); `play: 'loop'` makes it loop-only
- * (the hero): any clip in it renders as a loop.
+ * (the hero): any clip in it renders as a loop. `format: 'png'` serves its images as
+ * PNG instead of WebP (M9 Decision 8: WebP smears flat artwork).
  */
 export interface MediaField extends FieldBase {
 	kind: 'media';
 	only?: MediaOnly;
 	play?: 'loop';
+	format?: ImageFormat;
 }
 
+/** The format a resized image is served in (M9 Decision 8). WebP unless a media field asks for PNG. */
+export type ImageFormat = 'webp' | 'png';
+
 export type Field =
 	| TextField
 	| LockupField
@@ -288,9 +305,10 @@ export type BlockData<F extends Fields> = { [K in keyof F]: FieldValue<F[K]> };
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
-export function text(options: { label?: string; help?: string; multiline?: boolean; heading?: boolean; max?: number } = {}): TextField {
-	const field: TextField = { kind: 'text', label: options.label, multiline: options.multiline ?? false, heading: options.heading ?? false };
+export function text(options: { label?: string; help?: string; multiline?: boolean; heading?: boolean; max?: number; lines?: boolean } = {}): TextField {
+	const field: TextField = { kind: 'text', label: options.label, multiline: options.multiline ?? options.lines ?? false, heading: options.heading ?? false };
 	if (options.max !== undefined) field.max = options.max;
+	if (options.lines) field.lines = true;
 	return withHelp(field, options);
 }
 
@@ -316,9 +334,14 @@ export function select<const V extends string>(options: {
 	return withHelp({ kind: 'select', label: options.label, options: list, default: fallback }, options);
 }
 
-/** Rich text (Decision 3). `headings`: `['h2']` or `['h2', 'h3']`, off by default. `links`: on by default. */
-export function richText(options: { label?: string; help?: string; headings?: readonly HeadingKind[]; links?: boolean } = {}): RichTextField {
-	return withHelp({ kind: 'richText', label: options.label, headings: [...(options.headings ?? [])], links: options.links ?? true }, options);
+/**
+ * Rich text (Decision 3). `headings`: `['h2']` or `['h2', 'h3']`, off by default. `links`: on by default.
+ * `heading: true` (M9 Decision 11): the block's heading, bold and line breaks only (links off).
+ */
+export function richText(options: { label?: string; help?: string; headings?: readonly HeadingKind[]; links?: boolean; heading?: boolean } = {}): RichTextField {
+	const field: RichTextField = { kind: 'richText', label: options.label, headings: [...(options.headings ?? [])], links: options.links ?? !options.heading };
+	if (options.heading) field.heading = true;
+	return withHelp(field, options);
 }
 
 /**
@@ -399,12 +422,14 @@ export function group<const F extends Fields>(fields: F, options: { label?: stri
 
 /**
  * An image or a clip (M5b Decision 3). `only: 'image'` or `'video'` takes one kind;
- * `play: 'loop'` makes the slot loop-only (a clip in it always plays as a loop).
+ * `play: 'loop'` makes the slot loop-only (a clip in it always plays as a loop);
+ * `format: 'png'` serves its images as PNG (M9 Decision 8).
  */
-export function media(options: { label?: string; help?: string; only?: MediaOnly; play?: 'loop' } = {}): MediaField {
+export function media(options: { label?: string; help?: string; only?: MediaOnly; play?: 'loop'; format?: ImageFormat } = {}): MediaField {
 	const field: MediaField = { kind: 'media', label: options.label };
 	if (options.only !== undefined) field.only = options.only;
 	if (options.play !== undefined) field.play = options.play;
+	if (options.format !== undefined) field.format = options.format;
 	return withHelp(field, options);
 }
 
@@ -444,7 +469,7 @@ export function parseDay(value: unknown): string | null {
 	return at.getUTCFullYear() === y && at.getUTCMonth() === mo - 1 && at.getUTCDate() === d ? m[0]! : null;
 }
 
-const richTextOptions = (field: RichTextField) => ({ headings: field.headings, links: field.links });
+export const richTextOptions = (field: RichTextField): RichTextOptions => ({ headings: field.headings, links: field.links, ...(field.heading ? { heading: true } : {}) });
 
 function parseButton(field: ButtonsField, raw: Record<string, unknown>): ButtonValue {
 	const style = typeof raw.style === 'string' && field.styles.some((o) => o.value === raw.style) ? raw.style : field.styles[0]!.value;
@@ -732,12 +757,18 @@ export type FieldWarningCode =
 	| 'disallowed-kind'
 	/** Rich text: a link where the field has links off, shown as its text. */
 	| 'link-off'
+	/** Rich text: italic in a heading rich-text field (M9 Decision 11), shown as plain text. */
+	| 'italic-off'
 	/** A value (or a rich-text entry) the field can't read: shown as empty, kept until the field is edited. */
 	| 'unreadable'
 	/** A link that fails the link rule (Decision 4): shown as text. */
 	| 'link-rule'
 	/** An internal link to a path no document has (Decision 4). */
 	| 'link-missing'
+	/** M9 Decision 7: an internal link to a page hidden from the site. */
+	| 'link-hidden'
+	/** M9 Decision 7: a reference to a page hidden from the site (a warning, as `link-hidden` is). */
+	| 'reference-hidden'
 	/** A link or button with only one of its label and its link: shows nothing. */
 	| 'half-link'
 	/** More buttons than the field's `max`: the extra ones don't show. */
@@ -782,6 +813,13 @@ export interface WarningContext {
 	 * address under it, since which ones it builds isn't known from its file name.
 	 */
 	codeRoutes?: readonly CodeRoute[];
+	/** M9 Decision 7: hidden pages, their address (normalised) to their name. A link to one warns. */
+	hiddenPages?: ReadonlyMap<string, string>;
+	/**
+	 * M9 Decision 7: hidden documents, `collection/path` to their name and address (links.ts
+	 * `hiddenDocuments`). A reference to one warns.
+	 */
+	hiddenDocuments?: ReadonlyMap<string, { label: string; url: string | null }>;
 }
 
 const join = (base: string, part: string | number) => (base === '' ? String(part) : `${base}.${part}`);
@@ -804,6 +842,11 @@ function hrefWarnings(href: string, path: string, context: WarningContext, out:
 	if (context.addresses) {
 		const target = internalLinkPath(href);
 		if (target !== null && codeRouteAt(target, context.codeRoutes)) return;
+		const hidden = context.hiddenPages && hiddenLinkTarget(href, context.hiddenPages);
+		if (hidden) {
+			out.push({ path, code: 'link-hidden', message: hidden });
+			return;
+		}
 		const missing = missingLinkTarget(href, context.addresses);
 		if (missing) out.push({ path, code: 'link-missing', message: missing });
 	}
@@ -834,6 +877,8 @@ export function fieldWarnings(field: Field, raw: unknown, context: WarningContex
 						code: 'disallowed-kind',
 						message: `${issue.kind === 'h1' ? 'An h1' : `A${/^[aeiouh]/i.test(issue.kind) ? 'n' : ''} ${issue.kind}`} isn't allowed in this field, so it shows as a paragraph.`,
 					});
+				} else if (issue.code === 'italic-off') {
+					out.push({ path: at, code: 'italic-off', message: 'This heading takes bold only, so italic here shows as plain text.' });
 				} else if (issue.code === 'link-off') {
 					out.push({
 						path: at,
@@ -898,6 +943,9 @@ export function fieldWarnings(field: Field, raw: unknown, context: WarningContex
 			const v = parseField(field, raw) as string | null;
 			if (v !== null && context.documentExists && !context.documentExists(field.to, v)) {
 				out.push({ path, code: 'missing-reference', message: `This points at "${v}", which isn't in ${titleCase(field.to)} any more.` });
+			} else if (v !== null && context.hiddenDocuments) {
+				const message = hiddenReferenceTarget(field.to, v, context.hiddenDocuments);
+				if (message) out.push({ path, code: 'reference-hidden', message });
 			}
 			break;
 		}
@@ -987,12 +1035,12 @@ export const isKeyPath = (path: string) => path !== '' && !splitPath(path).some(
 
 /**
  * The fields that can hold the page's heading (M3 Decision 16: a lockup, or a text
- * field marked `heading`), as paths, in the order they're tried: the top-level ones in
+ * or rich-text field marked `heading`, M9 Decision 11), as paths, in the order they're tried: the top-level ones in
  * schema order, then those inside groups (`left.heading`), groups in schema order. A
  * top-level heading always comes before a group's.
  */
 export function headingPaths(fields: Fields): string[] {
-	const isHeading = (field: Field) => (field.kind === 'lockup' || field.kind === 'text') && !!field.heading;
+	const isHeading = (field: Field) => (field.kind === 'lockup' || field.kind === 'text' || field.kind === 'richText') && !!field.heading;
 	const top = Object.entries(fields).filter(([, f]) => isHeading(f)).map(([key]) => key);
 	const grouped = Object.entries(fields).flatMap(([key, f]) => (f.kind === 'group' ? Object.entries(f.fields).filter(([, g]) => isHeading(g)).map(([sub]) => `${key}.${sub}`) : []));
 	return [...top, ...grouped];

package/src/forms/rules.ts

@@ -43,6 +43,8 @@ export interface FormFieldConfig {
 	 * Plain text, trimmed; blank is the same as leaving it out.
 	 */
 	prefix?: string;
+	/** A textarea's height in lines (`rows`), a whole number from 1 to 50. Default 6. Textarea only. */
+	rows?: number;
 }
 
 /** One form (Contracts → The forms config). Its key is its id: stored on submissions, keys `formRecipients`; never renamed once live. */
@@ -66,6 +68,7 @@ export interface ResolvedFormField {
 	error?: string;
 	placeholder?: string;
 	prefix?: string;
+	rows?: number;
 }
 
 /** A form as the package uses it: its fields as a list, in order, each with its type. Plain JSON. */
@@ -122,7 +125,7 @@ export const FILE_ACCEPT = Object.keys(FILE_TYPES)
 	.join(',');
 
 /** The types that take a placeholder: the ones a visitor types into. */
-const PLACEHOLDER_TYPES: readonly FormFieldType[] = ['text', 'email', 'tel', 'textarea'];
+export const PLACEHOLDER_TYPES: readonly FormFieldType[] = ['text', 'email', 'tel', 'textarea'];
 /** The types that take a prefix: a one-line box where a fixed lead-in reads naturally ("$", "+353"). */
 const PREFIX_TYPES: readonly FormFieldType[] = ['text', 'tel'];
 
@@ -188,6 +191,10 @@ export function checkForms(forms: unknown, fail: (message: string) => never): Re
 			if (placeholder && !PLACEHOLDER_TYPES.includes(type)) fail(`${at}: a ${type} field has no box to type in, so it can't take a placeholder (only ${PLACEHOLDER_TYPES.join(', ')} can).`);
 			const prefix = field.prefix?.trim() ?? '';
 			if (prefix && !PREFIX_TYPES.includes(type)) fail(`${at}: only a text or tel field takes a prefix (this one is ${type}).`);
+			if (field.rows !== undefined) {
+				if (type !== 'textarea') fail(`${at}: only a textarea takes rows (this one is ${type}).`);
+				if (!Number.isInteger(field.rows) || field.rows < 1 || field.rows > 50) fail(`${at}: rows must be a whole number from 1 to 50 (got ${JSON.stringify(field.rows)}).`);
+			}
 			fields.push({
 				name,
 				label: field.label!.trim(),
@@ -199,6 +206,7 @@ export function checkForms(forms: unknown, fail: (message: string) => never): Re
 				...(field.error ? { error: field.error } : {}),
 				...(placeholder ? { placeholder } : {}),
 				...(prefix ? { prefix } : {}),
+				...(field.rows !== undefined ? { rows: field.rows } : {}),
 			});
 		}
 		const email = fields.find((f) => f.name === 'email');

package/src/head.ts

@@ -4,7 +4,8 @@
  *
  * - **Title:** the page's `seo.title` as written; otherwise, for the home page, Site
  *   Settings' `seo.title`, then the brand's name; otherwise `<document title> · <brand name>`,
- *   where ` · ` is the config's `titleSeparator` (default ` · `, M8 trial round 2).
+ *   where ` · ` is the config's `titleSeparator` (default ` · `, M8 trial round 2). With the
+ *   config's `titleFallback: 'site'` (M9), every page falls back as the home page does.
  * - **Description and share image** fall back from the page's `seo` to Site Settings'.
  * - **Canonical link and `og:url`** only with the site's address (`SITE_URL`), and never
  *   in a preview.
@@ -13,7 +14,7 @@
  * - **The Google tag** is an ID, never a script: `GTM-…` loads Tag Manager, `G-…` loads
  *   gtag.js, anything else nothing. Only in a production build, never in a preview.
  */
-import { DEFAULT_TITLE_SEPARATOR } from './config.ts';
+import { DEFAULT_TITLE_SEPARATOR, type TitleFallback } from './config.ts';
 import { parseSettingsBrand, type PageDocument } from './document.ts';
 import { imageUrl, isResizable, type MediaConfig } from './media.ts';
 import { googleTagKind, parseGoogleTag, parseSeo, SHARE_IMAGE, type Seo, type SeoImage } from './seo.ts';
@@ -33,6 +34,8 @@ export interface HeadInput {
 	listPage?: number;
 	/** The config's `titleSeparator` (ResolvedSite), spaces included; ` · ` when left out. */
 	titleSeparator?: string;
+	/** The config's `titleFallback` (ResolvedSite); `'page-and-brand'` when left out. */
+	titleFallback?: TitleFallback;
 }
 
 export interface Head {
@@ -73,7 +76,8 @@ export function headOf(input: HeadInput): Head {
 	const docTitle = document.title.trim();
 	// Decision 16: " — page N" straight after the page's own part, before the brand, so ten pages don't share one title.
 	const paged = (text: string) => (input.listPage && input.listPage > 1 && text ? `${text} — page ${input.listPage}` : text);
-	const fallback = home ? paged(settings.seo.title || settings.brandName || docTitle) : [paged(docTitle), settings.brandName].filter(Boolean).join(input.titleSeparator ?? DEFAULT_TITLE_SEPARATOR);
+	const siteWide = home || input.titleFallback === 'site';
+	const fallback = siteWide ? paged(settings.seo.title || settings.brandName || docTitle) : [paged(docTitle), settings.brandName].filter(Boolean).join(input.titleSeparator ?? DEFAULT_TITLE_SEPARATOR);
 	const title = paged(own.title ?? '') || fallback;
 	const imageValue = own.image ?? settings.seo.image ?? null;
 	const image = imageValue ? shareImage(imageValue, input.media) : null;

package/src/links.ts

@@ -76,6 +76,41 @@ export function normaliseAddress(url: string): string {
  * `/`, `/about`, `/journal/my-first-post`), from the store's listing (Phase 2
  * wires it). Never an error: a warning the field shows.
  */
+/** M9 Decision 7: the hidden pages in a listing, as `WarningContext.hiddenPages` takes them (address → name). */
+export function hiddenPages(entries: Iterable<{ url: string | null; label: string; hidden?: true }>): Map<string, string> {
+	const out = new Map<string, string>();
+	for (const e of entries) if (e.hidden && e.url !== null) out.set(normaliseAddress(e.url), e.label);
+	return out;
+}
+
+/** M9 Decision 7: the hidden documents in a listing, as `WarningContext.hiddenDocuments` takes them (`collection/path` → name and address). */
+export function hiddenDocuments(entries: Iterable<{ collection: string; path: string; url: string | null; label: string; hidden?: true }>): Map<string, { label: string; url: string | null }> {
+	const out = new Map<string, { label: string; url: string | null }>();
+	for (const e of entries) if (e.hidden) out.set(`${e.collection}/${e.path}`, { label: e.label, url: e.url === null ? null : normaliseAddress(e.url) });
+	return out;
+}
+
+/**
+ * M9 Decision 7's warning for a reference (a `reference()` field) to a hidden page, worded as
+ * the link one is. Never an error: unhiding the page fixes it.
+ */
+export function hiddenReferenceTarget(collection: string, path: string, hidden: ReadonlyMap<string, { label: string; url: string | null }>): string | undefined {
+	const doc = hidden.get(`${collection}/${path}`);
+	if (!doc) return undefined;
+	return `Points at ${doc.url ?? path}, the ${doc.label || path} page, which is hidden from the site. Visitors get its 404 until it's shown again.`;
+}
+
+/**
+ * M9 Decision 7's warning: a link to a hidden page. `hidden` maps a hidden page's address
+ * (normalised) to its name. Never an error: unhiding the page fixes it.
+ */
+export function hiddenLinkTarget(href: unknown, hidden: ReadonlyMap<string, string>): string | undefined {
+	const path = internalLinkPath(href);
+	if (path === null) return undefined;
+	const name = hidden.get(path);
+	return name === undefined ? undefined : `Links to ${path}, the ${name} page, which is hidden from the site. Visitors get its 404 until it's shown again.`;
+}
+
 export function missingLinkTarget(href: unknown, addresses: Iterable<string | null | undefined>): string | undefined {
 	const path = internalLinkPath(href);
 	if (path === null) return undefined;

package/src/live/README.md

@@ -15,6 +15,7 @@ live drafts store, sweep, locks and status route, and Phase 3's sign-in, sit on
 | `status.ts` | Pure: `waitingFromCommits()`, `publishState()`, `PublishRecord` |
 | `redis.ts` | `RedisClient`; `connectRedis(url)` (ioredis with M1 → R2's retry and idle close) and `memoryRedis()` (the stand-in, with `calls` and `flush()`) |
 | `backend.ts` | `GitBackend`; `GitHubBackend`, `MemoryBackend` (test helpers: `seed`, `push`, `file`, `deployments`, `beforeRequest`); `StaleHeadError` |
+| `branches.ts` | `Branch` (a role: `main` or `drafts`), `BranchNames` (the refs behind them), `DEFAULT_BRANCHES`. `CARACMS_MAIN_BRANCH` and `CARACMS_DRAFTS_BRANCH` (read by `mode.ts`, M9 Decision 6) name the branch Publish commits to and the one autosaves land on; unset, `main` and `drafts`. They're set together or not at all: one alone is a problem, so the mode is unconfigured (`/admin` answers 503 saying both must be set; the public site still serves). Only the backends turn a role into a ref name, so with both set a branch called `main` is never read or moved. `MemoryBackend.refs` is keyed by name |
 | `github.ts` | The App's JWT, the installation token (one repo, refreshed early), `Tracker` (request counts) |
 | `webhook.ts` | `handleGithubWebhook()`, behind `POST /_caracms/github` (`../editor/routes/github.ts`) |
 | `autosaves.ts` | Phase 2. Autosaves in Redis (`caracms:autosave:<file>`, a week; stored compare-and-set, ordered per tab by `X-Caracms-Seq`), the session's last commit (the merge's ancestor) and who last changed a document (Decision 11; no expiry, and `known: false` when neither Redis nor git can say). M5a: a new document's autosave carries `created: { over }` (its ancestor until committed), a deletion is a "gone" autosave (`text` and `document` null, `gone: { title }`) |