caracms 0.3.4 → 0.4.0

package/src/editor/client/collections/CollectionTable.tsx

@@ -28,7 +28,7 @@ import { useEditor, useStore } from '../context.tsx';
 import type { Editor } from '../editor.ts';
 import { createStore, type Store } from '../state/store.ts';
 import { Icon } from '../shell/Icons.tsx';
-import { docIcon } from '../nav/DocRow.tsx';
+import { docIcon, hiddenTitle } from '../nav/DocRow.tsx';
 import { DocMarksView } from '../live/marks.tsx';
 import { when } from '../live/format.ts';
 import { openDialog } from '../documents/dialogs.tsx';
@@ -378,6 +378,14 @@ function Row(props: { doc: ListedDocument; columns: readonly TableColumn[]; curr
 										<span className="sr">, can't be opened: {doc.warning.message}</span>
 									</span>
 								) : null}
+								{/* M9 Decision 7, collections under pages (Decision 11): hidden, or hidden with the page that holds it, named. */}
+								{/* The sidebar's mark: the word, small and grey; the page that hides it on hover and to a screen reader. */}
+								{doc.hidden ? (
+									<span className="hmark" data-mark="hidden" title={hiddenTitle(doc, editor.documents.get())}>
+										Hidden
+										{doc.hiddenBy ? <span className="sr">: {hiddenTitle(doc, editor.documents.get())}</span> : null}
+									</span>
+								) : null}
 								{editor.mode === 'live' ? <DocMarksView file={doc.file} /> : <span data-slot="presence" hidden />}
 							</span>
 							{props.extra ? <span className="ct-extra">{props.extra}</span> : null}

package/src/editor/client/documents/actions.ts

@@ -70,31 +70,76 @@ export async function deleteDocument(editor: Editor, ref: DocRef, title: string)
 /**
  * Change a document's address (pre-M7 item 8). Its unsent edits go first (the move
  * carries them), then the document opens at its new address in place of the old one,
- * and the list is read again (other documents' links changed too).
+ * and the list is read again (other documents' links changed too). `redirect` false: no
+ * redirect from the old address.
  */
-export async function moveDocument(editor: Editor, ref: DocRef, to: string, title: string): Promise<{ ok: true; body: MoveResponse } | Refused> {
-	const id = docId(ref);
-	const open = sameDoc(editor.doc.get().ref, ref);
+export async function moveDocument(editor: Editor, ref: DocRef, to: string, title: string, redirect = true): Promise<{ ok: true; body: MoveResponse } | Refused> {
+	// Everything under it moves with it (collections under pages, Decision 9): each of those documents' unsent edits too.
+	const moving = addressesMoving(editor.site?.collections ?? [], ref, to, editor.documents?.get() ?? []).map((m) => ({ collection: m.doc.collection, path: m.doc.path }));
+	const refs = moving.some((m) => sameDoc(m, ref)) ? moving : [ref, ...moving];
 	// Nothing moves while the keeper still holds edits the server hasn't got (a held conflict, a
 	// signed-out session, a refused write): the move would discard them.
-	let flushed = true;
-	await editor.keeper?.flush(id).catch(() => {
-		flushed = false;
-	});
-	if (!flushed || editor.keeper?.dirty(id)) {
-		return { ok: false, status: 0, error: `${title} has changes that haven't been saved yet, so its address can't change. Sort those out first (Use mine or Discard mine, or sign in again), then try again.`, code: 'unsent', usedOn: null };
+	for (const r of refs) {
+		const id = docId(r);
+		let flushed = true;
+		await editor.keeper?.flush(id).catch(() => {
+			flushed = false;
+		});
+		if (!flushed || editor.keeper?.dirty(id)) {
+			const what = sameDoc(r, ref) ? title : (editor.documents?.get().find((d) => sameDoc(d, r))?.label ?? r.path);
+			return { ok: false, status: 0, error: `${what} has changes that haven't been saved yet, so ${sameDoc(r, ref) ? 'its' : `${title}'s`} address can't change. Sort those out first (Use mine or Discard mine, or sign in again), then try again.`, code: 'unsent', usedOn: null };
+		}
 	}
-	const answer = await post<MoveResponse>(editor, ENDPOINTS.move, { collection: ref.collection, path: ref.path, to });
+	const answer = await post<MoveResponse>(editor, ENDPOINTS.move, { collection: ref.collection, path: ref.path, to, ...(redirect ? {} : { redirect: false }) });
 	if (!answer.ok) return answer;
-	editor.keeper?.discard(id);
-	await editor.refreshDocuments().catch(() => undefined);
-	if (open) await editor.openDocument({ collection: answer.body.collection, path: answer.body.path }, { history: 'replace' });
 	const { url, from } = answer.body;
-	editor.toast(`Moved ${title} to ${url}.`, 'check');
-	editor.announce(`Moved ${title} from ${from.url} to ${url}.`);
+	const moved = answer.body.moved ?? [];
+	for (const r of refs) editor.keeper?.discard(docId(r));
+	await editor.refreshDocuments().catch(() => undefined);
+	// The open document goes with it when it's under it.
+	const openRef = editor.doc.get().ref;
+	const opened = sameDoc(openRef, ref) ? { collection: answer.body.collection, from: ref.path, to: answer.body.path } : moved.find((m) => m.collection === openRef.collection && m.from === openRef.path);
+	if (opened && opened.from !== opened.to) await editor.openDocument({ collection: opened.collection, path: opened.to }, { history: 'replace' });
+	else if (opened) await editor.reloadOpen();
+	const more = Math.max(moved.length - 1, 0);
+	editor.toast(more ? `Moved ${title} to ${url}, with ${more} more under it.` : `Moved ${title} to ${url}.`, 'check');
+	editor.announce(more ? `Moved ${title} from ${from.url} to ${url}, and ${more} more addresses under it.` : `Moved ${title} from ${from.url} to ${url}.`);
 	return answer;
 }
 
+/** One address Change address… changes (collections under pages, Decision 9). */
+export interface AddressChange {
+	doc: ListedDocument;
+	/** Its new address; null while the new path isn't one yet. */
+	toUrl: string | null;
+	/** A document of a collection a page in the move holds (its file stays; only its address changes). */
+	held: boolean;
+}
+
+/**
+ * Every address Change address… on `ref` changes once it's at `to` (Decision 9): the
+ * document, the pages under it at any depth, and the documents of each collection held by
+ * it or a page under it. move.ts → `movesUnder` and `planMoves` work out the same, so the
+ * dialog lists them before asking.
+ */
+export function addressesMoving(collections: readonly EditorAnyCollection[], ref: DocRef, to: string, documents: readonly ListedDocument[]): AddressChange[] {
+	const collection = collections.find((c) => c.name === ref.collection);
+	const root = documents.find((d) => d.collection === ref.collection && d.path === ref.path);
+	if (!collection || !root) return [];
+	const newPath = (path: string) => (path === ref.path ? to : `${to}${path.slice(ref.path.length)}`);
+	const pages = [root, ...(collection.nested ? pagesUnder(collection.name, ref.path, documents) : [])];
+	const out: AddressChange[] = pages.map((d) => ({ doc: d, toUrl: addressFor(collection, newPath(d.path)), held: false }));
+	for (const held of collections) {
+		const holder = held.holder;
+		if (!held.heldBy || !holder || holder.collection !== ref.collection) continue;
+		if (holder.path !== ref.path && !holder.path.startsWith(`${ref.path}/`)) continue;
+		const holderUrl = addressFor(collection, newPath(holder.path));
+		const base = holderUrl === null ? null : `${holderUrl.replace(/\/+$/, '')}/`;
+		for (const d of documents) if (d.collection === held.name && d.url !== null && !d.warning) out.push({ doc: d, toUrl: base === null ? null : base + d.path, held: true });
+	}
+	return out;
+}
+
 /**
  * M6c G4 (Decision 9): Replace… on a file. Every unsent edit in this tab goes first, and
  * nothing is replaced while any is still held (a conflict, a refusal, a signed-out

package/src/editor/client/documents/dialogs.tsx

@@ -19,6 +19,7 @@
  */
 import { useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
 import { INDEX_MESSAGE, NO_ADDRESS_MESSAGE, RESERVED_SLUG, addressProblem, slugify } from '../../../slug.ts';
+import { documentsNoun, holdsMessage } from '../../../held.ts';
 import { useEditor, useStore } from '../context.tsx';
 import type { Editor } from '../editor.ts';
 import { blockIcon } from '../block-list/summary.ts';
@@ -27,7 +28,7 @@ import { Icon } from '../shell/Icons.tsx';
 import { createStore, type Store } from '../state/store.ts';
 import type { CreateDeleteRefusal, DocRef, ListedDocument } from '../../types.ts';
 import { INSIDE_CLOSE, InsidePicker } from './InsidePicker.tsx';
-import { addressFor, andList, createDocument, deleteDocument, insideOptions, moveDocument, pagesUnder, singular } from './actions.ts';
+import { addressFor, addressesMoving, andList, createDocument, deleteDocument, insideOptions, moveDocument, pagesUnder, singular } from './actions.ts';
 import { filesLabel, inboxFor } from '../inbox/store.ts';
 import { ReplaceDialog } from '../media/ReplaceDialog.tsx';
 
@@ -297,7 +298,18 @@ function NewDocument(props: { collection: string; inside?: string; at?: string }
 /**
  * A document's new address: for nested Pages the group it sits in ("Inside", New page's
  * select, with New group…) and the address's last part, shown whole as it's typed, with
- * New page's rules checked before asking the server. Pages under it stay where they are.
+ * New page's rules checked before asking the server.
+ *
+ * **Everything under it moves with it** (collections under pages, Decision 9): the pages
+ * under it at any depth, and the documents of a collection it (or a page under it) holds.
+ * Then the dialog lists every address that changes ("Its 1 page moves with it",
+ * "Its 24 journal entries move with it", the collection's own word for its documents), warns about a route of the site's own code under
+ * the old address (it doesn't move), and has one tick for the lot. A page with nothing
+ * under it keeps the single-page dialog.
+ *
+ * "Leave a redirect from …" ("Leave redirects from the old addresses" for several), ticked
+ * to start with, says whether the old addresses redirect; it shows only when there's one to
+ * leave (a live address, not one an earlier move since the last Publish already redirects).
  */
 function MoveDocument({ docRef }: { docRef: DocRef }) {
 	const editor = useEditor();
@@ -311,8 +323,9 @@ function MoveDocument({ docRef }: { docRef: DocRef }) {
 	const [part, setPart] = useState(docRef.path.slice(slash + 1));
 	const [error, setError] = useState<string | null>(null);
 	const [busy, setBusy] = useState(false);
-	// Every page but this one: a page can't go under itself.
-	const options = useMemo(() => (collection?.nested ? insideOptions(collection, documents).filter((o) => o.path !== docRef.path) : []), [collection, documents, docRef.path]);
+	const [redirect, setRedirect] = useState(true);
+	// Every page but this one and the pages under it: a page can't go under itself.
+	const options = useMemo(() => (collection?.nested ? insideOptions(collection, documents).filter((o) => o.path !== docRef.path && !o.path.startsWith(`${docRef.path}/`)) : []), [collection, documents, docRef.path]);
 	if (!doc || !collection || !doc.url) return null;
 	const nested = collection.nested;
 	const newGroup = nested && inside === NEW_GROUP;
@@ -323,8 +336,10 @@ function MoveDocument({ docRef }: { docRef: DocRef }) {
 	const url = addressFor(collection, path);
 	const base = addressFor(collection, folder ? `${folder}/` : '') ?? '/';
 	const same = path === docRef.path;
-	const others = documents.filter((d) => !(d.collection === docRef.collection && d.path === docRef.path));
-	// New page's rules, before asking the server (it applies the same).
+	const moving = addressesMoving(editor.site.collections, docRef, path, documents);
+	const many = moving.length > 1;
+	const others = documents.filter((d) => !moving.some((m) => m.doc === d));
+	// New page's rules, before asking the server (it applies the same, and checks every address that changes).
 	const local = (() => {
 		if (same) return null;
 		if (newGroup && !slugify(group)) return group.trim() ? NO_ADDRESS_MESSAGE : null;
@@ -334,21 +349,38 @@ function MoveDocument({ docRef }: { docRef: DocRef }) {
 	})();
 	const shown = error ?? local;
 	const blocked = same || !last || (newGroup && !slugify(group)) || !!local || busy;
-	// Made since the last Publish: nobody has its address yet. Moved since then: its live address is the one it came from.
-	const pending = (waiting ?? []).find((w) => w.collection === docRef.collection && w.path === docRef.path && w.change === 'new');
+	// Made since the last Publish: nobody has its address yet. Moved since then: its live address is the one it came from,
+	// and its redirect from there is there already, following this move.
+	const pendingOf = (d: ListedDocument) => (waiting ?? []).find((w) => w.collection === d.collection && w.path === d.path && (w.change === 'new' || !!w.movedFrom));
+	const pending = pendingOf(doc);
 	const liveAddress = pending ? (pending.movedFrom ?? null) : doc.url;
-	const kids = nested ? pagesUnder(collection.name, docRef.path, documents) : [];
+	const choose = many ? moving.some((m) => !pendingOf(m.doc)) : !pending;
 	const host = editor.site.host;
 	const confirm = async () => {
 		if (blocked) return;
 		setBusy(true);
 		setError(null);
-		const answer = await moveDocument(editor, docRef, path, doc.label);
+		const answer = await moveDocument(editor, docRef, path, doc.label, !choose || redirect);
 		setBusy(false);
 		if (answer.ok) closeDialog(editor);
 		else setError(answer.error);
 	};
-	const intro = liveAddress ? `${liveAddress} will redirect here.${editor.mode === 'live' ? ' Goes live at the next Publish.' : ''}` : null;
+	const publish = editor.mode === 'live' ? ' Goes live at the next Publish.' : '';
+	const intro = !many && liveAddress && !choose ? `${liveAddress} will redirect here.${publish}` : null;
+	// What moves with it: the pages under it, then each held collection's documents.
+	const under = moving.filter((m) => !m.held && m.doc !== doc);
+	const heldBy = new Map<string, number>();
+	for (const m of moving) if (m.held) heldBy.set(m.doc.collection, (heldBy.get(m.doc.collection) ?? 0) + 1);
+	const labelOf = (name: string) => editor.site.collections.find((c) => c.name === name)?.label ?? name;
+	// "Its 1 page moves with it." "Its 24 journal entries move with it." "Its 2 pages and 24 journal entries move with it."
+	const heldParts = [...heldBy].map(([name, n]) => `${n} ${n === 1 ? singular({ kind: 'sections', nested: false, label: labelOf(name) }) : documentsNoun(labelOf(name))}`);
+	const parts = [...(under.length ? [`${under.length} page${under.length === 1 ? '' : 's'}`] : []), ...heldParts];
+	if (parts.length) parts[0] = `Its ${parts[0]}`;
+	const one = moving.length === 2 && parts.length === 1;
+	const withIt = `${andList(parts)} move${one ? 's' : ''} with it.`;
+	// A route of the site's own code under the old address stays where it is (Decision 10).
+	const oldBase = `${doc.url.replace(/\/+$/, '')}/`;
+	const routes = many ? (editor.site.codeRoutes ?? []).filter((r) => r.url.toLowerCase().startsWith(oldBase.toLowerCase())) : [];
 	return (
 		<Frame label="move">
 			<form
@@ -408,10 +440,49 @@ function MoveDocument({ docRef }: { docRef: DocRef }) {
 						</p>
 					)}
 				</div>
-				{kids.length ? (
-					<p className="field-help" data-kids={kids.length}>
-						{andList(kids.map((k) => k.label))} stay{kids.length === 1 ? 's' : ''} where {kids.length === 1 ? 'it is' : 'they are'}, at {doc.url}/…
-					</p>
+				{many ? (
+					<div className="field" data-moving={moving.length}>
+						<p className="field-help">
+							{withIt} {same ? 'The addresses now:' : 'The new addresses:'}
+						</p>
+						<ul className="mv-list" aria-label="Every address that changes" tabIndex={0}>
+							{moving.map((m) => (
+								<li key={`${m.doc.collection}/${m.doc.path}`} className="mono" data-to={m.toUrl ?? ''}>
+									{same ? m.doc.url : (m.toUrl ?? '…')}
+								</li>
+							))}
+						</ul>
+						{routes.length ? (
+							<p className="field-help" data-routes={routes.length}>
+								<Icon name="warn" size="xs" /> {andList(routes.map((r) => r.file))} {routes.length === 1 ? 'is' : 'are'} the site’s own code under {doc.url}, so {routes.length === 1 ? 'it stays' : 'they stay'} where {routes.length === 1 ? 'it is' : 'they are'}.
+							</p>
+						) : null}
+					</div>
+				) : null}
+				{choose ? (
+					<div className="field">
+						<label className="check">
+							<input type="checkbox" id="mv-redirect" checked={redirect} aria-describedby="mv-redirect-h" onChange={(e) => setRedirect(e.target.checked)} />
+							<span>
+								{many ? (
+									'Leave redirects from the old addresses'
+								) : (
+									<>
+										Leave a redirect from <span className="mono">{doc.url}</span>
+									</>
+								)}
+							</span>
+						</label>
+						<p className="field-help" id="mv-redirect-h">
+							{many
+								? redirect
+									? `Anyone with an old address lands on the new one.${publish}`
+									: 'Nothing will be at the old addresses: links to them from elsewhere will find no page.'
+								: redirect
+									? `Anyone with the old address lands here.${publish}`
+									: `Nothing will be at ${doc.url}: links to it from elsewhere will find no page.`}
+						</p>
+					</div>
 				) : null}
 				<div className="acts">
 					<button type="button" className="btn" onClick={() => closeDialog(editor)}>
@@ -569,6 +640,24 @@ function DeleteDocument({ docRef }: { docRef: DocRef }) {
 	const doc = documents.find((d) => d.collection === docRef.collection && d.path === docRef.path);
 	const collection = editor.site.collections.find((c) => c.name === docRef.collection);
 	if (!doc || !collection) return null;
+	// Collections under pages (Decision 12): a page that holds a collection isn't deleted, and says so instead of asking.
+	const held = doc.holds ? editor.site.collections.find((c) => c.name === doc.holds && c.heldBy === collection.name) : undefined;
+	if (held) {
+		return (
+			<Frame alert label="holds" describedBy="dlg-d">
+				<div className="icon-h" style={{ background: 'var(--status-warning-wash)', color: 'var(--status-warning)' }}>
+					<Icon name="warn" />
+				</div>
+				<h2 id="dlg-h">{doc.label} can’t be deleted</h2>
+				<p id="dlg-d">{holdsMessage(doc.label, held.label)}</p>
+				<div className="acts">
+					<button type="button" className="btn ink" data-act="holds-ok" onClick={() => closeDialog(editor)}>
+						OK
+					</button>
+				</div>
+			</Frame>
+		);
+	}
 	const shared = collection.kind === 'shared';
 	const kids = collection.nested ? pagesUnder(collection.name, doc.path, documents) : [];
 	const host = editor.site.host;

package/src/editor/client/editor.ts

@@ -31,6 +31,7 @@
  *   dismissNotice(id) / signOut() / signInAgain()
  */
 import { addressOf, inboxAddress, inboxFromAddress, refFromAddress } from '../addresses.ts';
+import { heldBases } from '../../held.ts';
 import {
 	docId,
 	ENDPOINTS,
@@ -298,6 +299,24 @@ export interface Editor {
 	timeZone(): string;
 }
 
+/**
+ * Collections under pages (Decision 7): each held collection's base, worked out again from a
+ * fresh listing (held.ts), so a holder that moved takes its collection's addresses with it in
+ * every dialog and table without a reload. The payload's own objects are updated in place.
+ */
+export function followHolders(site: Pick<EditorSite, 'collections' | 'allCollections'>, listed: readonly ListedDocument[]): void {
+	if (!site.collections.some((c) => c.heldBy)) return;
+	const bases = heldBases(Object.fromEntries(site.collections.map((c) => [c.name, c])), listed);
+	for (const b of Object.values(bases)) {
+		for (const c of [...site.collections, ...(site.allCollections ?? [])]) {
+			if (c.name !== b.collection) continue;
+			c.urlBase = b.base;
+			c.holder = b.holder ? { collection: b.holder.collection, path: b.holder.path } : null;
+			c.problem = b.problem;
+		}
+	}
+}
+
 export function createEditor(props: AdminProps, options: { client: boolean }): Editor {
 	const { site } = props;
 	const opened = props.opened;
@@ -743,7 +762,9 @@ export function createEditor(props: AdminProps, options: { client: boolean }): E
 		async refreshDocuments() {
 			const response = await fetch(ENDPOINTS.documents, { headers: { Accept: 'application/json' } });
 			if (!response.ok) return;
-			documents.set((await response.json()) as ListedDocument[]);
+			const listed = (await response.json()) as ListedDocument[];
+			followHolders(site, listed);
+			documents.set(listed);
 			// M6 Decision 9: the unread count rides along (absent when it couldn't be read).
 			const unread = response.headers.get(UNREAD_HEADER);
 			if (unread !== null && /^\d+$/.test(unread)) submissions.set({ unread: Number(unread) });

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

@@ -7,11 +7,16 @@
  *   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.
+ * - Collections under pages (Decision 5): a page that holds a collection says so beside it,
+ *   "Holds Journal (24)" (every document, hidden ones included). Nothing here changes it:
+ *   the `holds` line is the file's, a developer's call.
  */
 import { useMemo } from 'react';
 import { useEditor, useStore } from '../context.tsx';
 import { FieldFrame } from './FieldFrame.tsx';
 import { FieldHostProvider, type FieldHost } from './host.tsx';
+import { docIcon } from '../nav/DocRow.tsx';
+import { Icon } from '../shell/Icons.tsx';
 
 const SCOPE = 'page-hidden';
 const NAME = 'hidden';
@@ -30,11 +35,14 @@ export function HiddenToggle() {
 	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;
+	// Collections under pages (Decision 11): a held document is hidden with the page that holds its collection.
+	const byCollection = listed?.hiddenByCollection ?? ref.collection;
+	const by = listed?.hiddenBy ? documents.find((d) => d.collection === byCollection && d.path === listed.hiddenBy) : undefined;
 	const on = hidden || !!by;
+	const holds = listed?.holds ? editor.site.collections.find((c) => c.name === listed.holds && c.heldBy === ref.collection) : undefined;
 	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.`
+		? `Hidden with ${by.label}, the page ${listed?.hiddenByCollection ? `that holds ${collection.label}` : "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'}>
@@ -46,6 +54,14 @@ export function HiddenToggle() {
 					</button>
 				</FieldFrame>
 			</FieldHostProvider>
+			{holds ? (
+				<p className="page-holds" data-holds={holds.name}>
+					<Icon name={docIcon(holds)} size="xs" />
+					<span>
+						Holds {holds.label} ({documents.filter((d) => d.collection === holds.name).length})
+					</span>
+				</p>
+			) : null}
 		</div>
 	);
 }

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

@@ -26,6 +26,13 @@ export function docIcon(collection: { nested: boolean; kind?: string } | undefin
 	return 'journal';
 }
 
+/** A hidden document's mark's words: "Journal is hidden" for one hidden with the page that holds its collection (or the page it's under). */
+export function hiddenTitle(doc: ListedDocument, documents: readonly ListedDocument[]): string {
+	if (!doc.hiddenBy) return 'Hidden from the site';
+	const by = documents.find((d) => d.collection === (doc.hiddenByCollection ?? doc.collection) && d.path === doc.hiddenBy);
+	return by ? `${by.label} is hidden` : 'Hidden with the page it’s under';
+}
+
 export function DocRow(props: {
 	doc: ListedDocument;
 	crumb?: string;
@@ -84,7 +91,7 @@ export function DocRow(props: {
 					) : 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'}>
+						<span className="hmark" data-mark="hidden" title={hiddenTitle(doc, editor.documents.get())}>
 							Hidden
 						</span>
 					) : null}

package/src/editor/client/nav/tree.ts

@@ -29,6 +29,22 @@ export type TreeRow =
 			/** Documents under it (any depth), for a bubbled mark when it's closed. */
 			under: ListedDocument[];
 	  }
+	| {
+			/**
+			 * Collections under pages (Decision 4): a collection the page above holds, as one row
+			 * (its name and count, opening its table), the first row under its holder whenever the
+			 * holder's row shows. Its documents never go in the tree.
+			 */
+			kind: 'held';
+			/** The holder's path (the row's position). */
+			path: string;
+			depth: number;
+			collection: string;
+			label: string;
+			/** Every document in it, hidden ones included (as its sidebar entry counts them). */
+			count: number;
+			files: string[];
+	  }
 	| {
 			/** A folder with no page of its own: shows or hides its children only. */
 			kind: 'group';
@@ -46,7 +62,13 @@ export type TreeRow =
  * closed group (at any depth) isn't returned. `documents` must be one collection's,
  * in the reader's order.
  */
-export function treeRows(collection: string, documents: readonly ListedDocument[], open: UiState['open']): TreeRow[] {
+export function treeRows(
+	collection: string,
+	documents: readonly ListedDocument[],
+	open: UiState['open'],
+	/** The collections pages of this one hold, each with its holder's path and its documents' files. */
+	held: readonly { collection: string; label: string; holder: string; files: string[] }[] = [],
+): TreeRow[] {
 	const paths = new Set(documents.map((d) => d.path));
 	const isOpen = (path: string) => open[groupKey(collection, path)] === true;
 	const under = (path: string) => documents.filter((d) => d.path.startsWith(`${path}/`));
@@ -88,6 +110,9 @@ export function treeRows(collection: string, documents: readonly ListedDocument[
 			key: groupKey(collection, doc.path),
 			under: kids,
 		});
+		for (const h of held) {
+			if (h.holder === doc.path) rows.push({ kind: 'held', path: doc.path, depth: segments.length, collection: h.collection, label: h.label, count: h.files.length, files: h.files });
+		}
 	}
 	return rows;
 }

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

@@ -103,7 +103,7 @@ export function DocumentsLevel() {
 					) : (
 						<>
 							{nested.map((c) => (
-								<PagesSection key={c.name} collection={c} documents={documents.filter((d) => d.collection === c.name)} />
+								<PagesSection key={c.name} collection={c} documents={documents.filter((d) => d.collection === c.name)} all={documents} />
 							))}
 							{flat.length > 0 ? (
 								<section className="grp" aria-label="Collections">
@@ -131,10 +131,14 @@ export function DocumentsLevel() {
 	);
 }
 
-function PagesSection({ collection, documents }: { collection: EditorCollection; documents: ListedDocument[] }) {
+function PagesSection({ collection, documents, all }: { collection: EditorCollection; documents: ListedDocument[]; all: ListedDocument[] }) {
 	const editor = useEditor();
 	const open = useStore(editor.ui, (u) => u.open);
-	const rows = treeRows(collection.name, documents, open);
+	// Collections under pages (Decision 4): each collection a page here holds, as a row under it.
+	const held = editor.site.collections
+		.filter((c) => c.heldBy === collection.name && c.holder?.collection === collection.name)
+		.map((c) => ({ collection: c.name, label: c.label, holder: c.holder!.path, files: all.filter((d) => d.collection === c.name).map((d) => d.file) }));
+	const rows = treeRows(collection.name, documents, open, held);
 	return (
 		<section className="grp" aria-label={collection.label} data-collection={collection.name}>
 			<div className="grp-h">
@@ -155,6 +159,22 @@ function PagesSection({ collection, documents }: { collection: EditorCollection;
 function TreeNode({ row, collection }: { row: TreeRow; collection: EditorCollection }) {
 	const editor = useEditor();
 	const depth = { ['--depth' as string]: row.depth };
+	if (row.kind === 'held') {
+		const held = editor.site.collections.find((c) => c.name === row.collection);
+		return (
+			<div className="tnode" data-tnode-held={row.collection}>
+				<button type="button" className="drow t coll is-held" style={depth} data-held={row.collection} aria-label={`${row.label}, ${row.count}`} title={`${row.label}, held by this page: its documents are at its address`} onClick={() => editor.openCollection(row.collection)}>
+					<Icon name={docIcon(held)} />
+					<span className="nm">{row.label}</span>
+					<span className="meta">
+						{editor.mode === 'live' ? <Bubble files={row.files} /> : <span data-slot="bubble" hidden />}
+						<span className="cnt">{row.count}</span>
+					</span>
+					<Icon name="chev-r" size="sm" />
+				</button>
+			</div>
+		);
+	}
 	if (row.kind === 'group') {
 		return (
 			<div className="tnode" data-tnode-group={row.path}>
@@ -344,17 +364,42 @@ function SubmissionsRow() {
 function CollectionRow({ collection, documents }: { collection: EditorCollection; documents: ListedDocument[] }) {
 	const editor = useEditor();
 	const n = documents.length;
+	// Collections under pages (Decision 13): a held collection no page holds (or two do) has no addresses; its entry says why.
+	const problem = collection.problem ?? null;
 	return (
-		<button type="button" className="drow coll" data-coll={collection.name} aria-label={`${collection.label}, ${n}`} onClick={() => editor.openCollection(collection.name)}>
-			<Icon name={docIcon(collection)} />
-			<span className="nm">{collection.label}</span>
-			<span className="meta">
-				{/* M4: presence and waiting dots inside the collection, bubbled up. */}
-				{editor.mode === 'live' ? <Bubble files={documents.map((d) => d.file)} /> : <span data-slot="bubble" hidden />}
-				<span className="cnt">{n}</span>
-			</span>
-			<Icon name="chev-r" size="sm" />
-		</button>
+		<>
+			<button
+				type="button"
+				className={problem ? 'drow coll is-warned' : 'drow coll'}
+				data-coll={collection.name}
+				aria-label={`${collection.label}, ${n}${problem ? ', has no addresses' : ''}`}
+				title={problem ?? undefined}
+				onClick={() => editor.openCollection(collection.name)}
+			>
+				<Icon name={docIcon(collection)} />
+				<span className="nm">{collection.label}</span>
+				<span className="meta">
+					{problem ? (
+						<span className="wmark" data-warning="not-held">
+							<Icon name="warn" size="xs" />
+						</span>
+					) : null}
+					{/* M4: presence and waiting dots inside the collection, bubbled up. */}
+					{editor.mode === 'live' ? <Bubble files={documents.map((d) => d.file)} /> : <span data-slot="bubble" hidden />}
+					<span className="cnt">{n}</span>
+				</span>
+				<Icon name="chev-r" size="sm" />
+			</button>
+			{problem ? (
+				<div className="note warn tight doc-why" role="note" data-why={`coll-${collection.name}`}>
+					<Icon name="warn" />
+					<div>
+						<b>{collection.label} has no addresses</b>
+						<p>{problem}</p>
+					</div>
+				</div>
+			) : null}
+		</>
 	);
 }
 

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

@@ -107,12 +107,25 @@ function GitHubAccessNote() {
 			<Icon name="warn" />
 			<div>
 				<b>{access.title}</b>
-				<p>{access.message}</p>
+				<p>{withLink(access.message, access.link ?? null)}</p>
 			</div>
 		</div>
 	);
 }
 
+/** The sentence as it came, with `link` as a link where it names it (or after it); the words are never changed. */
+function withLink(message: string, link: string | null) {
+	if (!link) return message;
+	const a = (key: number) => (
+		<a key={key} href={link} target="_blank" rel="noopener noreferrer">
+			{link}
+		</a>
+	);
+	const parts = message.split(link);
+	if (parts.length === 1) return [message, ' ', a(0)];
+	return parts.flatMap((part, i) => (i === 0 ? [part] : [a(i), part]));
+}
+
 function KeepNotes() {
 	const editor = useEditor();
 	const state = useStore(editor.keep, (k) => k.state);

package/src/editor/routes/move.ts

@@ -1,5 +1,5 @@
 /**
- * POST /_caracms/move: `{ collection, path, to }` → MoveResponse, or `{ error, code }`
+ * POST /_caracms/move: `{ collection, path, to, redirect? }` → MoveResponse, or `{ error, code }`
  * (pre-M7 item 8; shapes: ../types.ts → MoveRequest). The rules are in ../server/move.ts;
  * the store is the mode's (server/mode.ts), as for create and delete: on disk in local
  * mode, autosaves under this tab's locks in live mode, where the request carries

package/src/editor/server/admin-props.ts

@@ -7,6 +7,7 @@ import { createHash } from 'node:crypto';
 import { relative } from 'node:path';
 import type { Brand, ResolvedSite } from '../../config.ts';
 import { DocumentError } from '../../content.ts';
+import { heldBases, withHeldBases } from '../../held.ts';
 import { inboxFromAddress, refFromAddress } from '../addresses.ts';
 import { handleSubmissions, SUBMISSIONS_PREFIX, submissionsSetupQuick, type SubmissionResponse, type SubmissionsListResponse } from '../../forms/inbox.ts';
 import { ENDPOINTS, type AdminProps, type DocRef, type EditorSite, type ListedDocument, type LiveProps, type MediaSetup, type EditorForm, type Person, type StatusResponse } from '../types.ts';
@@ -34,7 +35,24 @@ export function homeOf(site: Pick<ResolvedSite, 'collections'>, documents: reado
  */
 export function editorSite(site: ResolvedSite, documents: readonly ListedDocument[], host: string, brand: Brand): EditorSite {
 	// Every kind of collection (M5a Phase 5): the site's own in config order, then `shared` and `settings`.
-	const collections = Object.values(site.collections).map(({ name, label, kind, urlBase, nested, fields, columns, sort, view, blocks }) => ({ name, label, kind, urlBase, nested, fields, columns, sort: sort ?? null, view: view ?? null, blocks: blocks ?? null }));
+	// Collections under pages (Decision 7): a held collection's urlBase is resolved from the listing, so the browser never works one out.
+	const bases = heldBases(site.collections, documents);
+	const collections = Object.values(withHeldBases(site, bases).collections).map(({ name, label, kind, urlBase, nested, fields, columns, sort, view, blocks, heldBy }) => {
+		const held = heldBy ? bases[name] : undefined;
+		return {
+			name,
+			label,
+			kind,
+			urlBase,
+			nested,
+			fields,
+			columns,
+			sort: sort ?? null,
+			view: view ?? null,
+			blocks: blocks ?? null,
+			...(held ? { heldBy, holder: held.holder && !held.problem ? { collection: held.holder.collection, path: held.holder.path } : null, problem: held.problem } : {}),
+		};
+	});
 	return {
 		collections,
 		allCollections: collections,