caracms 0.1.0 → 0.3.0

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/live/publish.tsx

@@ -4,13 +4,16 @@
  * #live #failed #blocked #history). Live mode only.
  *
  * - **The bar's button**: "3 waiting" with who, and Publish; "Publishing…" with the
- *   running bar; "Live · 14:12"; "Publish failed" with Try again; "Nothing waiting".
+ *   running bar; "Live · 14:12"; "Publish failed" with Try again; "Taking longer than
+ *   usual" (runs-anywhere Decision 10: not live 15 minutes on, no failure known), with
+ *   Try again when a redeployer is set; "Nothing waiting".
  *   Off while the server can't be reached or you're signed out.
  * - **The popover is the summary**: each waiting document, who changed it and when,
  *   "Editing now", uncommitted changes included (the status merges them), the merge
  *   notice where the draft was kept, then the final Publish button. Then publishing →
- *   live, or failed with Try again, or failed with the line that a developer can
- *   redeploy from Railway when there's no token (`hasToken: false`).
+ *   live, or failed (or taking longer than usual) with Try again, or with the line that
+ *   a developer can redeploy it when no redeployer is set (`hasRedeployer: false`;
+ *   runs-anywhere Decision 11: no host's name).
  * - **History**: who published, when, which documents, and whether each went live,
  *   in the site's time zone, named once. Read when the waiting popover opens (on
  *   intent), so it's there when History is pressed, and the last read shows while
@@ -129,12 +132,12 @@ export function PublishButton() {
 			</button>
 		);
 	}
-	if (pub.state === 'failed' && !n) {
+	if ((pub.state === 'failed' || pub.state === 'slow') && !n) {
 		return (
-			<button {...common} className="pub fail" data-pub="failed">
+			<button {...common} className="pub fail" data-pub={pub.state}>
 				<span className="wt">
 					<Icon name="warn" size="sm" />
-					Publish failed
+					{pub.state === 'slow' ? 'Taking longer than usual' : 'Publish failed'}
 				</span>
 				<span className={`pb${pub.canTryAgain ? '' : ' off'}`}>{pub.canTryAgain ? 'Try again' : 'Publish'}</span>
 			</button>
@@ -280,14 +283,16 @@ export function WaitingPop() {
 			</>,
 		);
 	}
-	if (pub.state === 'failed' && !n) {
+	if ((pub.state === 'failed' || pub.state === 'slow') && !n) {
+		const slow = pub.state === 'slow';
+		const published = record ? `${names} ${record.titles.length === 1 ? 'was' : 'were'} published at ${clock(record.at, status.timeZone)}` : null;
 		return wrap(
 			<>
 				<div className="pop-h">
 					<div>
-						<h2 style={{ color: 'var(--status-danger)' }}>The publish didn't go live</h2>
+						<h2 style={{ color: 'var(--status-danger)' }}>{slow ? 'This publish is taking longer than usual' : "The publish didn't go live"}</h2>
 						<p className="sub">
-							{record ? `${names} ${record.titles.length === 1 ? 'was' : 'were'} published at ${clock(record.at, status.timeZone)}, but` : 'The'} the live site couldn't be updated.
+							{slow ? `${published ? `${published}. ` : ''}It may have failed.` : `${published ? `${published}, but` : 'The'} the live site couldn't be updated.`}
 						</p>
 					</div>
 				</div>
@@ -305,7 +310,7 @@ export function WaitingPop() {
 						<div className="note danger" data-note="no-token">
 							<Icon name="warn" />
 							<div>
-								<b>A developer can redeploy it from Railway</b>
+								<b>A developer can redeploy it</b>
 							</div>
 						</div>
 					)}
@@ -597,6 +602,11 @@ export function HistoryPop() {
 												<Icon name="warn" size="xs" />
 												Failed
 											</span>
+										) : h.state === 'slow' ? (
+											<span className="chip danger" data-chip="slow">
+												<Icon name="warn" size="xs" />
+												Taking longer than usual
+											</span>
 										) : (
 											<span className="chip waiting">Publishing</span>
 										)}

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" />

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/pane/parts.tsx

@@ -1,7 +1,8 @@
 /**
  * Pieces every pane level is built from (the mockup's sidebar components): the
  * trail with the stacked level tabs, the current level's header, the notes every
- * level shows, and the Recent strip at the foot. A level is
+ * level shows (the GitHub access note among them, runs-anywhere Decision 5), and the
+ * Recent strip at the foot. A level is
  *
  *   <>
  *     <Trail>{level tabs}<CurrentHead … /></Trail>
@@ -76,13 +77,44 @@ export function CurrentHead(props: {
 }
 
 /**
- * Notes every level shows above its content: "Can't reach the server" (Decision 6),
+ * Notes every level shows above its content: GitHub access (live mode, below), then
+ * "Can't reach the server" (Decision 6),
  * or, when the server answered a write with a refusal (a 4xx: the edits don't fit
  * their base, the file was renamed or deleted while open), its own message. M3
  * retries with the next change or a reload (no timer), so M4's countdown, "Try now"
  * and unsent count are slots without data.
  */
 export function GlobalNotes() {
+	return (
+		<>
+			<GitHubAccessNote />
+			<KeepNotes />
+		</>
+	);
+}
+
+/**
+ * Runs-anywhere Decision 5: the site's GitHub access is wrong (a refused credential, a
+ * missing permission, a token expiring soon), for everyone, on every level, while it
+ * holds. Not dismissable. The sentence is the server's (`status.githubAccess`).
+ */
+function GitHubAccessNote() {
+	const editor = useEditor();
+	const access = useStore(editor.liveState, (s) => s.status?.githubAccess ?? null);
+	if (editor.mode !== 'live' || !access) return null;
+	const expiring = access.kind === 'expiring';
+	return (
+		<div className={`note ${expiring ? 'warn' : 'danger'}`} role={expiring ? 'status' : 'alert'} data-note="github-access" data-kind={access.kind}>
+			<Icon name="warn" />
+			<div>
+				<b>{access.title}</b>
+				<p>{access.message}</p>
+			</div>
+		</div>
+	);
+}
+
+function KeepNotes() {
 	const editor = useEditor();
 	const state = useStore(editor.keep, (k) => k.state);
 	const error = useStore(editor.keep, (k) => k.error);

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 } : {}),
+					};
 			}
 		},
 	};