caracms 0.3.3 → 0.4.0

package/src/content-schema.ts

@@ -126,13 +126,16 @@ function document(collection: ResolvedCollection, properties: Record<string, Sch
 }
 
 /** A collection's schema (`schemas/<collection>.schema.json`, or the reserved two's names). */
-export function collectionSchema(site: Pick<ResolvedSite, 'blocks'>, collection: ResolvedCollection): Schema {
+export function collectionSchema(site: Pick<ResolvedSite, 'blocks'> & Partial<Pick<ResolvedSite, 'collections'>>, collection: ResolvedCollection): Schema {
 	const own = Object.fromEntries(Object.entries(collection.fields ?? {}).map(([key, f]) => [key, fieldSchema(f)]));
 	switch (collection.kind) {
 		case 'sections':
 			// M9 Decision 7: `hidden: true` keeps the page off the site; absent, it's shown.
 			const hidden: Schema = { description: 'Hidden from the site: not served, not in the sitemap, still edited in /admin.', const: true };
-			return document(collection, { hidden, ...own, blocks: { type: 'array', items: { anyOf: [{ $ref: '#/$defs/shared' }, anyBlock(site)] } }, seo }, ['title', 'blocks'], { shared: sharedEntry, ...blockDefs(site) });
+			// Collections under pages (Decision 5): a page of a collection some collection's heldBy names may hold one of them.
+			const holdable = Object.values(site.collections ?? {}).filter((c) => c.heldBy === collection.name).map((c) => c.name);
+			const holds: Schema | null = holdable.length ? { description: 'The collection this page holds: its documents are at this page\'s address + their slug.', enum: holdable } : null;
+			return document(collection, { hidden, ...(holds ? { holds } : {}), ...own, blocks: { type: 'array', items: { anyOf: [{ $ref: '#/$defs/shared' }, anyBlock(site)] } }, seo }, ['title', 'blocks'], { shared: sharedEntry, ...blockDefs(site) });
 		case 'fields':
 			return document(collection, { ...own, seo }, ['title']);
 		case 'shared':

package/src/content.ts

@@ -36,6 +36,9 @@ import { isBuiltInColumn } from './columns.ts';
 import { fieldsCover, sectionsCover, type CardCover } from './cards.ts';
 import { own, parseAnyDocument, type AnyDocument, type DocumentKind } from './document.ts';
 import { parseSource } from './json-source.ts';
+import { hasHeld, heldBases, type HeldBase } from './held.ts';
+import { leftBehindMessage, leftBehindRoutes, ownRoutedCollections } from './code-routes.ts';
+import { sameAddress } from './slug.ts';
 
 // Posts and tags, Decision 14: a route's reader on the disk (read.ts).
 export { contentReader } from './read.ts';
@@ -79,6 +82,16 @@ export interface DocumentEntry {
 	 */
 	hidden?: true;
 	hiddenBy?: string;
+	/**
+	 * Collections under pages (Decision 11): set when `hiddenBy` is a page of another collection,
+	 * the page that holds this document's collection (`pages`). Absent: `hiddenBy` is in this one.
+	 */
+	hiddenByCollection?: string;
+	/**
+	 * Collections under pages (Decision 5): a page's `"holds"`, the collection it holds (held.ts).
+	 * Read from a file that can't be opened too, as far as it can be, so a broken holder is named.
+	 */
+	holds?: string;
 	/** A section builder's shared-block entries, by shared block path, in block order, once each (Decision 8). Absent otherwise. */
 	uses?: string[];
 	/** A shared block: its block's type (`''` when it has none). Absent otherwise. */
@@ -220,13 +233,17 @@ export function resolveDocumentFile(site: Pick<ResolvedSite, 'collections'>, col
 	return file;
 }
 
-/** Every document in one collection, or in all of them (in config order), with warnings, in the editor's order. */
+/**
+ * Every document in one collection, in several (in the order given), or in all of them (in
+ * config order), with warnings, in the editor's order. A held collection's documents have
+ * their resolved addresses (held.ts), whichever collections are listed.
+ */
 export async function listDocuments(
 	site: Pick<ResolvedSite, 'collections' | 'root' | 'blocks'>,
-	collectionName?: string,
+	collectionName?: string | readonly string[],
 	source: ContentSource = diskSource,
 ): Promise<DocumentEntry[]> {
-	const names = collectionName ? [collectionName] : Object.keys(site.collections);
+	const names = collectionName === undefined ? Object.keys(site.collections) : typeof collectionName === 'string' ? [collectionName] : [...collectionName];
 	const all: DocumentEntry[] = [];
 	for (const name of names) {
 		const collection = own(site.collections, name);
@@ -236,7 +253,20 @@ export async function listDocuments(
 		if (collection.nested) hideChildren(entries);
 		all.push(...(collection.nested ? flattenTree(pageTree(entries)) : entries.sort(byLabel)));
 	}
-	if (!collectionName) {
+	// Collections under pages (Decision 7): a held collection's addresses come from its holder's listing.
+	const held = names.map((n) => site.collections[n]!).filter((c) => c.heldBy);
+	if (held.length) {
+		const holding: DocumentEntry[] = [];
+		for (const by of new Set(held.map((c) => c.heldBy!))) {
+			holding.push(...(names.includes(by) ? all.filter((e) => e.collection === by) : await listDocuments(site, by, source)));
+		}
+		const bases = heldBases(site.collections, holding);
+		for (const entry of all) {
+			const base = own(bases, entry.collection);
+			if (base) placeHeld(entry, base);
+		}
+	}
+	if (collectionName === undefined) {
 		// Decision 8's "used on": every document whose block list has an entry for the shared block.
 		for (const entry of all) {
 			if (entry.kind !== 'shared') continue;
@@ -246,6 +276,44 @@ export async function listDocuments(
 	return all;
 }
 
+/** A held document's address and hidden mark from its collection's resolved base (held.ts). */
+function placeHeld(entry: DocumentEntry, held: HeldBase): void {
+	entry.url = held.base === null ? null : held.base + entry.path;
+	// Decision 11: a hidden holder hides its documents, as a hidden page hides the pages under it.
+	if (held.hidden && held.holder) {
+		entry.hidden = true;
+		entry.hiddenBy = held.holder.path;
+		entry.hiddenByCollection = held.holder.collection;
+	}
+}
+
+/** A held collection's resolved base, from its holder collection's listing through `source`. */
+export async function heldBaseOf(site: Pick<ResolvedSite, 'collections' | 'root' | 'blocks'>, collectionName: string, source: ContentSource = diskSource): Promise<HeldBase | null> {
+	const collection = own(site.collections, collectionName);
+	if (!collection?.heldBy) return null;
+	return heldBases({ [collection.name]: collection }, await listDocuments(site, collection.heldBy, source))[collection.name] ?? null;
+}
+
+/** Every held collection's resolved base (held.ts), from the listings of the collections that hold them; `{}` on a site with none. */
+export async function heldBasesOf(site: Pick<ResolvedSite, 'collections' | 'root' | 'blocks'>, source: ContentSource = diskSource): Promise<Record<string, HeldBase>> {
+	if (!hasHeld(site.collections)) return {};
+	const by = [...new Set(Object.values(site.collections).flatMap((c) => (c.heldBy ? [c.heldBy] : [])))];
+	const holding = (await Promise.all(by.map((name) => listDocuments(site, name, source)))).flat();
+	return heldBases(site.collections, holding);
+}
+
+/**
+ * A document's public address as its listing gives it: `documentUrl` for a collection with a
+ * prefix, the holder's address + `/` + the path for a held one (null while it isn't held).
+ */
+export async function documentAddress(site: Pick<ResolvedSite, 'collections' | 'root' | 'blocks'>, collectionName: string, path: string, source: ContentSource = diskSource): Promise<string | null> {
+	const collection = own(site.collections, collectionName);
+	if (!collection) return null;
+	if (!collection.heldBy) return documentUrl(collection, path);
+	const held = await heldBaseOf(site, collectionName, source);
+	return held?.base ? held.base + path : null;
+}
+
 /** M9 Decision 7: a hidden page's children are hidden with it; `hiddenBy` names the topmost hidden page above. */
 function hideChildren(entries: DocumentEntry[]): void {
 	const hidden = new Set(entries.filter((e) => e.hidden).map((e) => e.path));
@@ -279,6 +347,10 @@ export async function readDocument(
 	if (text === null) throw new DocumentError('not-found', `${collection.label}: no document "${path}".`);
 	const { entry, document } = inspect(site, collection, path, text);
 	if (entry.warning || !document) throw new DocumentError(entry.warning!.code, entry.warning!.message);
+	if (collection.heldBy) {
+		const held = await heldBaseOf(site, collection.name, source);
+		if (held) placeHeld(entry, held);
+	}
 	return { entry, text, document };
 }
 
@@ -312,10 +384,12 @@ function inspect(
 		url: documentUrl(collection, path),
 	};
 	const fileLabel = titleCase(path.split('/').pop()!);
-	const warn = (code: WarningCode, message: string, title = '') => ({
-		entry: { ...base, title, label: title || fileLabel, warning: { code, message } },
-		document: null,
-	});
+	// Decision 13: a broken holder is named, so its `"holds"` is read from the text as far as it can be.
+	const holdsIn = () => (collection.kind === 'sections' ? /"holds"\s*:\s*"([^"\\]*)"/.exec(text)?.[1] : undefined);
+	const warn = (code: WarningCode, message: string, title = '') => {
+		const holds = holdsIn();
+		return { entry: { ...base, title, label: title || fileLabel, warning: { code, message }, ...(holds !== undefined ? { holds } : {}) }, document: null };
+	};
 
 	if (collection.nested && path.endsWith('/index')) {
 		const parent = path.slice(0, -'/index'.length);
@@ -336,6 +410,7 @@ function inspect(
 	const entry: DocumentEntry = { ...base, title, label: title, warning: null };
 	// M9 Decision 7: the home page is never hidden.
 	if ((document.kind === undefined || document.kind === 'sections') && document.hidden && path !== 'index') entry.hidden = true;
+	if ((document.kind === undefined || document.kind === 'sections') && document.holds !== undefined) entry.holds = document.holds;
 	if (document.kind === undefined || document.kind === 'sections') {
 		entry.uses = [...new Set(document.blocks.flatMap((b) => (b.shared !== undefined ? [b.shared] : [])))];
 	} else if (document.kind === 'shared') {
@@ -422,3 +497,68 @@ const collator = new Intl.Collator('en', { sensitivity: 'base', numeric: true })
 function byLabel(a: { label: string; path: string }, b: { label: string; path: string }): number {
 	return collator.compare(a.label, b.label) || collator.compare(a.path, b.path);
 }
+
+// ── The catch-all's reader (collections under pages, Decision 14) ────────────────
+
+/** A public page the site's catch-all serves: its collection, its path there, and its address. */
+export interface AddressedDocument {
+	collection: string;
+	path: string;
+	/** `/`, `/about`, `/journal/a-day-on-the-ferry`: no trailing slash, as the listing gives it. */
+	url: string;
+}
+
+/** What the reader reads: the site, and the routes in its `src/pages/` (the integration sets `pageRoutes`). */
+type CatchAllSite = Pick<ResolvedSite, 'collections' | 'root' | 'blocks'> & Partial<Pick<ResolvedSite, 'pageRoutes'>>;
+
+const logged = new Set<string>();
+/** The build's and dev's log, once per sentence per process (Decision 13: logged, never a failed build). */
+function logOnce(message: string): void {
+	if (logged.has(message)) return;
+	logged.add(message);
+	console.warn(`[caracms] ${message}`);
+}
+
+/**
+ * Every public page of every collection with an address, for the site's one catch-all route
+ * (`src/pages/[...path].astro`'s `getStaticPaths`): Pages, every held collection's documents at
+ * their holder's address, and every prefix collection's (`/tags/<slug>`), in config order then
+ * the editor's. Left out: a file that can't be opened, a hidden page (and the documents of a
+ * hidden holder), a held collection no page holds, and a prefix collection whose base has its
+ * own route (`src/pages/tags/[slug].astro`), which that route serves. A holder problem or a
+ * route left at a held base is logged once (`caracms validate` reports both as errors).
+ * `source`: where the files come from (the disk by default, as a build reads them).
+ */
+export async function addressedDocuments(site: CatchAllSite, source: ContentSource = diskSource): Promise<AddressedDocument[]> {
+	const collections = Object.values(site.collections);
+	const routes = site.pageRoutes ?? [];
+	const ownRouted = new Set(ownRoutedCollections(routes, collections).map((c) => c.name));
+	const names = collections.filter((c) => (c.urlBase !== null || c.heldBy) && !ownRouted.has(c.name)).map((c) => c.name);
+	const entries = await listDocuments(site, names, source);
+	if (hasHeld(site.collections)) {
+		const held: { name: string; label: string; base: string; holder: string }[] = [];
+		for (const base of Object.values(await heldBasesOf(site, source))) {
+			if (base.problem) logOnce(base.problem);
+			const c = site.collections[base.collection]!;
+			if (base.base && base.holder) held.push({ name: c.name, label: c.label, base: base.base, holder: base.holder.label });
+		}
+		for (const left of leftBehindRoutes(routes, held)) logOnce(leftBehindMessage(left));
+	}
+	return entries.filter((e): e is DocumentEntry & { url: string } => e.url !== null && !e.warning && !e.hidden).map(({ collection, path, url }) => ({ collection, path, url }));
+}
+
+/**
+ * The document a request's path is (`/journal/a-day-on-the-ferry`, with or without a trailing
+ * slash, URL-encoded or not), for a catch-all that renders on demand; null when no public page
+ * is there (`addressedDocuments` says which are).
+ */
+export async function documentAt(site: CatchAllSite, pathname: string, source: ContentSource = diskSource): Promise<{ collection: string; path: string } | null> {
+	let at: string;
+	try {
+		at = sameAddress(decodeURIComponent(pathname));
+	} catch {
+		return null;
+	}
+	const found = (await addressedDocuments(site, source)).find((d) => sameAddress(d.url) === at);
+	return found ? { collection: found.collection, path: found.path } : null;
+}

package/src/document.ts

@@ -67,6 +67,13 @@ export interface SiteDocument {
 	 * the key out of the file. The home page (`index`) can't be hidden (content.ts reads it as shown).
 	 */
 	hidden?: boolean;
+	/**
+	 * Collections under pages (Decision 5): the collection this page holds (the file's
+	 * top-level `"holds"`, after `title` and `hidden`): its documents are at this page's
+	 * address + `/` + their slug (held.ts). Edited in the file only, never by the editor,
+	 * whose saves keep it where it is.
+	 */
+	holds?: string;
 	/**
 	 * M6c (G2): the page fields' parsed values, keyed by field, every field of the
 	 * collection's `fields` present (the file's top-level keys after `title`). Present
@@ -225,6 +232,7 @@ export function parseDocument(raw: unknown, site: Pick<ResolvedSite, 'blocks'>):
 		blocks: rawBlocks.map((b, index) => parseBlock(b, index, site)),
 		...seoOf(doc),
 		...(doc.hidden === true ? { hidden: true } : {}),
+		...(typeof doc.holds === 'string' ? { holds: doc.holds } : {}),
 	};
 }
 

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) });