caracms 0.4.0 → 0.5.0

package/src/editor/types.ts

@@ -186,6 +186,11 @@ export interface AdminProps {
 	 * document's address. `opened` is then Home, the page under the inbox.
 	 */
 	inbox?: { id: string | null } | null;
+	/**
+	 * Arrange pages (Decision 15): the address opened the arrange screen (`/admin/arrange`),
+	 * with nothing arranged. `opened` is then Home, the page under it.
+	 */
+	arrange?: boolean;
 	/**
 	 * M6 Decision 9: the unread count for the Site-wide row, read as /admin renders; or,
 	 * when the production server has no submissions bucket, the sentence naming what's
@@ -281,6 +286,8 @@ export const ENDPOINTS = {
 	delete: '/_caracms/delete',
 	// Pre-M7 item 8: changing a document's address, both modes.
 	move: '/_caracms/move',
+	// Arrange pages (Contracts): the arrange screen's Apply, both modes.
+	arrange: '/_caracms/arrange',
 	// M5b Phase 2: the media routes, both modes (MEDIA_ENDPOINTS below has each one).
 	media: '/_caracms/media',
 	// M4 Phase 2 (live mode only; local mode answers 404).
@@ -506,6 +513,12 @@ export interface StatusResponse {
 	 * an autosave), so the chrome picks up a change on the next poll with no reload.
 	 */
 	brand: EditorBrand;
+	/**
+	 * Arrange pages (Decision 18): a short hash of Site Settings' `pageOrder` as it stands in
+	 * the store (the autosave on top of `drafts`); `""` when there's none. When it changes,
+	 * the tab re-reads the listing, as it does when the waiting list's keys change.
+	 */
+	pageOrderStamp: string;
 }
 
 /** POST /_caracms/lock `{ file, action }`. */
@@ -629,6 +642,39 @@ export interface MoveResponse {
 	redirects: { from: string; to: string }[];
 }
 
+/**
+ * POST /_caracms/arrange (arrange pages, Contracts): the arrangement as its result.
+ * - `moves`: the roots only, each page whose path changes and isn't carried by a root above
+ *   it (its old path under that root's `fromPath`, its new path that root's `toPath` + the
+ *   same rest). The server expands each to everything under it (pages at any depth, a held
+ *   collection's documents) except what's under another root, which wins for its own subtree.
+ * - `order`: the full child list for every parent whose children or order changed, keyed by
+ *   the parent's path after the moves (`""` the top level); an empty list drops the key.
+ *   Every other saved list is re-keyed after the moves by the server.
+ * - `redirect: false`: no redirects from the old addresses (the review's tick unticked).
+ */
+export interface ArrangeRequest {
+	moves: ArrangeMove[];
+	order: Record<string, string[]>;
+	redirect?: boolean;
+	/**
+	 * Collection name → page-order.ts's `listingStamp` of every document path in that
+	 * collection (hidden ones included) as the review's listing had them: Pages, and each
+	 * collection held by a page that moves. Any difference at Apply refuses with 409
+	 * `changed` and nothing is written (Decision 10). Absent: no check.
+	 */
+	expect?: Record<string, string>;
+}
+export interface ArrangeMove {
+	collection: string;
+	fromPath: string;
+	toPath: string;
+}
+/** 200: the moves and the order landed together (live mode: as autosaves, out at the next Publish). Refused: an ApiError like the move route's (`{ error, code }`, a lock refusal's state with `locked`). */
+export interface ArrangeResponse {
+	ok: true;
+}
+
 /**
  * Why a create or delete was refused: `{ error, code }` with a status.
  * - 400 `bad-request` (the body), `bad-path` (not a document path, outside its
@@ -639,7 +685,7 @@ export interface MoveResponse {
  *   block with no or an unknown block type), `not-held` (collections under pages, Decision 7: a
  *   held collection no page holds, or whose holding is a problem; the message is held.ts's sentence);
  * - 404 `not-found` (delete: no such document);
- * - 409 `exists` (create: the document is already there), `address-taken` (another
+ * - 409 `changed` (arrange: the listing isn't the one the review was planned on), `exists` (create: the document is already there), `address-taken` (another
  *   document has that address: "There's already a page at /services/packaging"),
  *   `in-use` (a shared block something still uses; `usedOn` says where), `locked`
  *   (live: someone else holds the document's lock: "Aoife is editing Contact"; the
@@ -667,7 +713,11 @@ export type CreateDeleteCode =
 	| 'in-use'
 	| 'holds'
 	| 'locked'
-	| 'same';
+	| 'same'
+	// Arrange pages (Decision 10): the listing changed since the review (ArrangeRequest.expect).
+	| 'changed'
+	// Arrange pages: an order-only Apply when Site Settings, which holds the order, isn't valid JSON.
+	| 'invalid-json';
 
 // ── Media (M5b Phase 2: Decisions 6, 7 and 12) ────────────────────────────────
 

package/src/index.ts

@@ -125,6 +125,8 @@ export const EDITOR_ROUTES = [
 	{ pattern: '/_caracms/delete', entrypoint: 'editor/routes/delete.ts' },
 	// Pre-M7 item 8: changing a document's address, both modes.
 	{ pattern: '/_caracms/move', entrypoint: 'editor/routes/move.ts' },
+	// Arrange pages: the arrange screen's Apply, both modes.
+	{ pattern: '/_caracms/arrange', entrypoint: 'editor/routes/arrange.ts' },
 	// M5b Phase 2: the media library, uploads and Mux, both modes (types.ts → MEDIA_ENDPOINTS).
 	{ pattern: '/_caracms/media/[...path]', entrypoint: 'editor/routes/media.ts' },
 	// M4 Decision 14: GitHub's push webhook (signature-checked; 404 with no secret).

package/src/live/drafts-store.ts

@@ -34,7 +34,8 @@
 import { join, relative, sep } from 'node:path';
 import { SITE_SETTINGS_FILE, type ResolvedSite } from '../config.ts';
 import { filesSource, listDocuments, readDocument, resolveDocumentFile } from '../content.ts';
-import { planCreate, planDelete, refused } from '../editor/server/create.ts';
+import { assertSettingsReadable, orderEdit, planArrange } from '../editor/server/arrange.ts';
+import { planCreate, planDelete, refused, target } from '../editor/server/create.ts';
 import { movesChanges, moveResponse, movesUnder, planMoves, settingsWithoutRedirectFrom, type ManyMoveRequest, type MovePlan } from '../editor/server/move.ts';
 import { replaceChanges, replaceResponse } from '../editor/server/replace.ts';
 import { parseAnyDocument } from '../document.ts';
@@ -286,6 +287,9 @@ export function liveDraftsStore(parts: LiveStoreParts): DraftsStore {
 	 *   can't commit a redirect for a move that then fails.
 	 * - **A document that was never live gets no redirect**: one made since the last Publish,
 	 *   or one already moved since then (its live address already redirects, and follows).
+	 *   But when a move vacates an address that is another document's live address (a chain
+	 *   before the Publish: A → B, then B's document to C, so B had none), it redirects to
+	 *   where that document is now, so the old public address still finds it.
 	 *   Each refiled document's move is recorded for Publish ("Moved from"), and every changed
 	 *   address's live one (autosaves.ts → `recordAddresses`), so a held document whose file
 	 *   stays is named too.
@@ -299,7 +303,9 @@ export function liveDraftsStore(parts: LiveStoreParts): DraftsStore {
 			const addresses = await autosaves.addresses();
 			const onMain = (file: string) => git.changeOf(file, '') === 'changed';
 			const wasLive = (p: MovePlan) => onMain(p.from.file) && !addresses.has(p.from.file);
-			const changes = await movesChanges(site, plans, documents, (file) => source.readText(join(site.root, file)), (p) => request.redirect !== false && wasLive(p), request.editSettings);
+			// A live address a chain left without a redirect gets one once a move vacates it (move.ts → `movesChanges`).
+			const liveAddressOf = request.redirect === false ? undefined : (file: string) => addresses.get(file) ?? null;
+			const changes = await movesChanges(site, plans, documents, (file) => source.readText(join(site.root, file)), (p) => request.redirect !== false && wasLive(p), request.editSettings, liveAddressOf);
 			const refiled = plans.filter((p) => p.refiled);
 			const vacated = new Set(refiled.map((p) => p.from.file));
 			const targets = new Set(refiled.map((p) => p.to.file));
@@ -531,12 +537,64 @@ export function liveDraftsStore(parts: LiveStoreParts): DraftsStore {
 			}),
 
 		move: async (request, context): Promise<MoveResponse> => {
-			const moves = movesUnder(site, request, await listed());
-			return moveMany({ moves, ...(request.redirect === false ? { redirect: false } : {}) }, context);
+			const documents = await listed();
+			const moves = movesUnder(site, request, documents);
+			// Arrange pages (Decision 6): a saved order follows the move, in the same Site Settings write.
+			return moveMany({ moves, ...(request.redirect === false ? { redirect: false } : {}), editSettings: orderEdit(site, moves, documents) }, context);
 		},
 
 		moveMany: (request, context) => moveMany(request, context),
 
+		/**
+		 * Arrange pages (Contracts): the plan against the listing with every autosave on top,
+		 * then the moves through `moveMany` (every lock up front, someone else's on any file
+		 * refuses it all, a rollback on any failure) with the arranged order riding its Site
+		 * Settings write. The engine keeps the first document's lock, as Change address…'s tab
+		 * moves on to it; the arrange screen has no document open, so it's let go here. With no
+		 * moves (Decision 21), Site Settings alone, under its lock, as one autosave.
+		 */
+		arrange: (request, context) =>
+			guard(async () => {
+				const { person, tab } = who(context);
+				const plan = planArrange(site, request, await listed());
+				// An unreadable Site Settings would drop the order and the redirects without a word: refuse every Apply.
+				if (plan.moves.length) assertSettingsReadable(site, (await autosaves.get(SITE_SETTINGS_FILE))?.value.text ?? git.read(SITE_SETTINGS_FILE));
+				if (plan.moves.length) {
+					const first = plan.moves[0]!;
+					const kept = target(site, first.collection, first.to).file;
+					const before = await locks.read(kept);
+					await moveMany({ moves: plan.moves, ...(request.redirect === false ? { redirect: false } : {}), editSettings: (text) => plan.edit(text) ?? text }, context);
+					if (!(before && before.lock.tab === tab)) await locks.release(kept, tab, person);
+					return { ok: true as const };
+				}
+				const took: string[] = [];
+				const written: Written[] = [];
+				try {
+					await takeAll([SITE_SETTINGS_FILE], tab, person, took, (_file, who, mine) => `${who} editing Site Settings${mine ? ' in another tab' : ''}, which holds the order of the Pages tree, so the order can't change until ${mine ? 'that tab is closed' : "they're done"}.`);
+					const current = (await autosaves.get(SITE_SETTINGS_FILE))?.value.text ?? git.read(SITE_SETTINGS_FILE);
+					assertSettingsReadable(site, current);
+					const next = plan.edit(current);
+					if (next !== null && next !== current) {
+						const t = now();
+						let after = next;
+						written.push(
+							await stash(SITE_SETTINGS_FILE, tab, (prior, drafts) => {
+								const base = prior ? prior.text : drafts;
+								after = plan.edit(base) ?? base ?? next;
+								return saved(SITE_SETTINGS_FILE, after, 'settings', person, tab, t)(prior, drafts);
+							}),
+						);
+						await autosaves.setChanged(SITE_SETTINGS_FILE, { by: person, version: fileVersion(after), at: new Date(t).toISOString() });
+					}
+				} catch (error) {
+					await undo(written, took, tab, person);
+					throw error;
+				}
+				for (const f of took) await locks.release(f, tab, person);
+				sweep.poke();
+				return { ok: true as const };
+			}),
+
 		/**
 		 * M6c G4 (Decision 9): Replace… on a file. Every document with a link to the old file
 		 * (replace.ts, read with the autosaves on top) is this tab's before anything is written,

package/src/live/editor.ts

@@ -23,6 +23,8 @@
  * State lives in Redis and git (two servers run during a deploy); what's held here
  * is the sweep's "am I ticking" and git.ts's caches.
  */
+import { orderIn } from '../editor/server/arrange.ts';
+import { pageOrderStamp } from '../page-order.ts';
 import { SITE_SETTINGS_FILE, type ResolvedSite } from '../config.ts';
 import { filesSource, heldBasesOf } from '../content.ts';
 import { brandFrom, editorBrand } from '../editor/brand.ts';
@@ -378,6 +380,8 @@ export async function createLiveEditor(
 				: null,
 			// M5a Decision 10: from the committed copy, never an autosave.
 			brand: editorBrand(brandFrom(git.read(SITE_SETTINGS_FILE), site)),
+			// Arrange pages (Decision 18): from the autosaves already in the snapshot, else the copy; no Redis command of its own.
+			pageOrderStamp: pageOrderStamp(orderIn(readNow(SITE_SETTINGS_FILE))),
 		};
 		return json(200, body);
 	});

package/src/page-order.ts

@@ -0,0 +1,253 @@
+/**
+ * The Pages tree's saved order (arrange pages, Decisions 6, 7 and 19). Browser-safe: no
+ * node or disk imports, so the editor's client uses the same rules as the server.
+ *
+ * - **`PageOrder`** is Site Settings' `pageOrder`: a parent's path (`""` for the top level)
+ *   → its children's slugs, pages and groups alike, in order. Absent means "the rule".
+ * - **The order of one level** (`orderSiblings`, Decision 7): Home first, always; then the
+ *   siblings the saved list names, in that order (an unknown slug is ignored); then the
+ *   unlisted ones, those with pages or a held collection under them first, then A–Z by
+ *   label (content.ts's collator).
+ * - **After moves** (`orderAfterMoves`, Decision 6): a moved page's slug leaves its old
+ *   parent's list and goes at the end of its new parent's (when that level has a saved
+ *   list; with none, the rule places it); every key at or under a moved path is re-keyed,
+ *   at any depth; a group renamed (every page under it moving to the same place under a new
+ *   folder) changes its key and its slug in place; a list left empty is dropped.
+ * - **The Apply's merge** (`arrangedOrder`): the re-keyed saved order, then the request's
+ *   own lists replacing those keys.
+ * - **The stamp** (`pageOrderStamp`, Decision 18): a short hash of the order, so another
+ *   tab sees an order-only change on its next poll.
+ */
+
+/** Site Settings' `pageOrder`: parent path (`""` is the top level) → its children's slugs in order. */
+export type PageOrder = Record<string, string[]>;
+
+/** One path that changes: a page's (or a group's folder's) path in the Pages collection, before → after. */
+export interface PathChange {
+	from: string;
+	to: string;
+}
+
+/** The collection the saved order is for: the nested section builder at `/` (Pages). */
+export function isOrderedCollection(collection: { nested?: boolean; urlBase: string | null }): boolean {
+	return !!collection.nested && collection.urlBase === '/';
+}
+
+/** A path's parent (`''` at the top level). */
+export const parentOf = (path: string): string => (path.includes('/') ? path.slice(0, path.lastIndexOf('/')) : '');
+/** A path's last part. */
+export const slugOf = (path: string): string => path.slice(path.lastIndexOf('/') + 1);
+const isHome = (path: string) => path === 'index' || path.endsWith('/index');
+const under = (path: string, folder: string) => path === folder || path.startsWith(`${folder}/`);
+
+const collator = new Intl.Collator('en', { sensitivity: 'base', numeric: true });
+/** A–Z by label, then by path (content.ts's order). */
+export 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);
+}
+
+/**
+ * One level of the tree in order (Decision 7): Home first; then the siblings `saved` names,
+ * in its order; then the rest, those `filled` (pages or a held collection under them) first,
+ * then A–Z by label. `saved` undefined: the rule alone.
+ */
+export function orderSiblings<T extends { path: string; label: string }>(items: readonly T[], saved: readonly string[] | undefined, filled: (item: T) => boolean): T[] {
+	const rank = new Map<string, number>();
+	(saved ?? []).forEach((slug, i) => {
+		if (!rank.has(slug)) rank.set(slug, i);
+	});
+	return [...items].sort((a, b) => {
+		const ha = isHome(a.path);
+		const hb = isHome(b.path);
+		if (ha !== hb) return ha ? -1 : 1;
+		const ra = rank.get(slugOf(a.path));
+		const rb = rank.get(slugOf(b.path));
+		if (ra !== undefined || rb !== undefined) {
+			if (ra === undefined) return 1;
+			if (rb === undefined) return -1;
+			if (ra !== rb) return ra - rb;
+		}
+		const fa = filled(a);
+		const fb = filled(b);
+		if (fa !== fb) return fa ? -1 : 1;
+		return byLabel(a, b);
+	});
+}
+
+/** `pageOrder` as read from a file: an object of string lists; anything else dropped, each list without repeats, empty lists left out. */
+export function parsePageOrder(raw: unknown): PageOrder {
+	if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+	const out: PageOrder = {};
+	for (const [key, list] of Object.entries(raw as Record<string, unknown>)) {
+		if (!Array.isArray(list)) continue;
+		const slugs = [...new Set(list.filter((s): s is string => typeof s === 'string' && s !== ''))];
+		if (slugs.length) out[key] = slugs;
+	}
+	return out;
+}
+
+/** The order without its empty lists (and without repeats in a list). */
+function tidy(order: PageOrder): PageOrder {
+	const out: PageOrder = {};
+	for (const [key, list] of Object.entries(order)) {
+		const slugs = [...new Set(list)];
+		if (slugs.length) out[key] = slugs;
+	}
+	return out;
+}
+
+/**
+ * The groups the moves rename: a folder with no page of its own (in `pathsBefore`, the Pages
+ * collection's paths before the moves) all of whose pages move to the same place under one
+ * new folder that's free once the moves land (a swap is fine). Topmost only.
+ */
+export function groupRenames(pathsBefore: readonly string[], moves: readonly PathChange[]): PathChange[] {
+	const pages = new Set(pathsBefore);
+	const moving = new Map(moves.map((m) => [m.from, m.to]));
+	const folders = new Set<string>();
+	for (const p of pathsBefore) {
+		const parts = p.split('/');
+		for (let i = 1; i < parts.length; i++) folders.add(parts.slice(0, i).join('/'));
+	}
+	const renames: PathChange[] = [];
+	for (const group of [...folders].filter((f) => !pages.has(f)).sort((a, b) => a.split('/').length - b.split('/').length)) {
+		if (renames.some((r) => under(group, r.from))) continue;
+		const inside = pathsBefore.filter((p) => p.startsWith(`${group}/`));
+		let to: string | null = null;
+		const same = inside.every((p) => {
+			const target = moving.get(p);
+			const rest = p.slice(group.length);
+			if (target === undefined || !target.endsWith(rest)) return false;
+			const folder = target.slice(0, target.length - rest.length);
+			if (to === null) to = folder;
+			return folder === to;
+		});
+		if (!same || to === null || to === '' || to === group || under(to, group)) continue;
+		const into = to as string;
+		// The new folder is free once the moves land: whatever's there now moves away.
+		if (pathsBefore.some((p) => under(p, into) && !moving.has(p))) continue;
+		renames.push({ from: group, to: into });
+	}
+	return renames;
+}
+
+/**
+ * The saved order once these moves land (Decision 6). `moves`: every page path that changes
+ * (Change address…'s or an Apply's, expanded: the pages under a moved page included);
+ * `pathsBefore`: the Pages collection's paths before them, for the groups they rename.
+ */
+export function orderAfterMoves(order: PageOrder, moves: readonly PathChange[], pathsBefore: readonly string[] = []): PageOrder {
+	const all = [...moves.filter((m) => m.from !== m.to), ...groupRenames(pathsBefore, moves)].sort((a, b) => a.from.split('/').length - b.from.split('/').length);
+	// The moves that aren't carried by a move above them: those change a list.
+	const units: PathChange[] = [];
+	for (const m of all) {
+		if (units.some((u) => u.from === m.from)) continue;
+		const carried = units.some((u) => m.from.startsWith(`${u.from}/`) && m.to === u.to + m.from.slice(u.from.length));
+		if (!carried) units.push(m);
+	}
+	if (units.length === 0) return tidy(order);
+	const rekey = (path: string) => {
+		let best: PathChange | null = null;
+		for (const u of units) if (under(path, u.from) && (!best || u.from.length > best.from.length)) best = u;
+		return best ? best.to + path.slice(best.from.length) : path;
+	};
+	const out: PageOrder = {};
+	for (const [key, list] of Object.entries(order)) {
+		const into = (out[rekey(key)] ??= []);
+		for (const slug of list) if (!into.includes(slug)) into.push(slug);
+	}
+	// Each unit's place in its old list, marked first, so a swap's slugs can't meet.
+	const marks = units.map((_, i) => `\u0000${i}`);
+	units.forEach((u, i) => {
+		const list = out[rekey(parentOf(u.from))];
+		const at = list ? list.indexOf(slugOf(u.from)) : -1;
+		if (at >= 0) list![at] = marks[i]!;
+	});
+	units.forEach((u, i) => {
+		const oldKey = rekey(parentOf(u.from));
+		const newKey = parentOf(u.to);
+		const slug = slugOf(u.to);
+		const old = out[oldKey];
+		const at = old ? old.indexOf(marks[i]!) : -1;
+		if (oldKey === newKey) {
+			// Renamed in place (a group rename, or a page's own slug): it keeps its place.
+			if (at >= 0) {
+				if (old!.includes(slug)) old!.splice(at, 1);
+				else old![at] = slug;
+			}
+			return;
+		}
+		if (at >= 0) old!.splice(at, 1);
+		const into = out[newKey];
+		if (into && !into.includes(slug)) into.push(slug);
+	});
+	for (const list of Object.values(out)) for (let i = list.length - 1; i >= 0; i--) if (list[i]!.startsWith('\u0000')) list.splice(i, 1);
+	return tidy(out);
+}
+
+/** The Apply's order (Contracts): the saved order re-keyed after the moves, then the request's lists replacing those keys, empty lists dropped. */
+export function arrangedOrder(saved: PageOrder, requested: PageOrder, moves: readonly PathChange[], pathsBefore: readonly string[] = []): PageOrder {
+	return tidy({ ...orderAfterMoves(saved, moves, pathsBefore), ...requested });
+}
+
+/** The saved order's entries that name nothing: a key that's no page or group, or a slug that's no child of its key. `paths`: the Pages collection's paths. */
+export function unknownOrderEntries(order: PageOrder, paths: readonly string[]): { key: string; slug: string | null }[] {
+	const known = new Set<string>(['']);
+	for (const p of paths) {
+		const parts = p.split('/');
+		for (let i = 1; i <= parts.length; i++) known.add(parts.slice(0, i).join('/'));
+	}
+	const out: { key: string; slug: string | null }[] = [];
+	for (const [key, list] of Object.entries(order)) {
+		if (!known.has(key)) {
+			out.push({ key, slug: null });
+			continue;
+		}
+		for (const slug of list) if (!known.has(key === '' ? slug : `${key}/${slug}`)) out.push({ key, slug });
+	}
+	return out;
+}
+
+/** The order without the entries `unknownOrderEntries` finds, and how many slugs went. */
+export function prunedOrder(order: PageOrder, paths: readonly string[]): { order: PageOrder; pruned: number } {
+	const unknown = unknownOrderEntries(order, paths);
+	if (unknown.length === 0) return { order, pruned: 0 };
+	const out: PageOrder = {};
+	let pruned = 0;
+	for (const [key, list] of Object.entries(order)) {
+		if (unknown.some((u) => u.key === key && u.slug === null)) {
+			pruned += list.length;
+			continue;
+		}
+		const kept = list.filter((slug) => !unknown.some((u) => u.key === key && u.slug === slug));
+		pruned += list.length - kept.length;
+		if (kept.length) out[key] = kept;
+	}
+	return { order: out, pruned };
+}
+
+/** FNV-1a over a text, in base 36. */
+function fnv(text: string): string {
+	let hash = 0x811c9dc5;
+	for (let i = 0; i < text.length; i++) {
+		hash ^= text.charCodeAt(i);
+		hash = Math.imul(hash, 0x01000193) >>> 0;
+	}
+	return hash.toString(36);
+}
+
+/**
+ * Decision 10: a short hash of a collection's document paths, sorted (FNV-1a), so the Apply
+ * can tell the listing it was planned on from the one it lands on (`ArrangeRequest.expect`).
+ */
+export function listingStamp(paths: readonly string[]): string {
+	return fnv(JSON.stringify([...paths].sort()));
+}
+
+/** Decision 18: a short hash of the order (FNV-1a over its keys in order); `""` when there's none. */
+export function pageOrderStamp(order: PageOrder | null | undefined): string {
+	if (!order) return '';
+	const keys = Object.keys(order).sort();
+	if (keys.length === 0) return '';
+	return fnv(JSON.stringify(keys.map((k) => [k, order[k]])));
+}

package/src/redirects.ts

@@ -6,7 +6,7 @@
  *
  *   parseRedirects(raw)                        the list as the file holds it, cleaned
  *   redirectsAfterMove(list, from, to, add)    the list once a document moves
- *   redirectsAfterMoves(list, moves)           the list once several move at once (swaps, chains)
+ *   redirectsAfterMoves(list, moves, homes?)   the list once several move at once (swaps, chains)
  *   redirectFor(list, pathname)                where a request for `pathname` goes, or null
  *
  * - **Both ends are `/paths`**, without a trailing slash (`/` stays `/`). An entry that
@@ -65,6 +65,29 @@ export function redirectsAfterMove(list: readonly Redirect[], from: string, to:
 	return next;
 }
 
+/**
+ * A document's live address (the one the public site served at the last Publish) and
+ * where it is once the plan has landed: live mode's documents moved since the last Publish
+ * (autosaves.ts → `recordAddresses`). `redirectsAfterMoves` adds `live → now` when a move
+ * in the plan vacates `live`.
+ */
+export interface LiveHome {
+	live: string;
+	now: string;
+}
+
+/** The homes whose live address a move in the plan vacates and no document then takes: each adds `live → now`. */
+function strandedHomes(moves: readonly { from: string; to: string }[], homes: readonly LiveHome[]): Redirect[] {
+	const taken = (address: string) => moves.some((m) => same(m.to, address));
+	const out: Redirect[] = [];
+	for (const h of homes) {
+		if (same(h.live, h.now) || taken(h.live) || !moves.some((m) => same(m.from, h.live))) continue;
+		if (out.some((r) => same(r.from, h.live))) continue;
+		out.push({ from: h.live, to: h.now });
+	}
+	return out;
+}
+
 /**
  * The list once several documents move at once (the many-move engine): every move is
  * taken against the list before the plan, so a swap or a chain comes out as its
@@ -74,10 +97,17 @@ export function redirectsAfterMove(list: readonly Redirect[], from: string, to:
  * `from → to` is added, unless another document now sits at `from` (in a swap neither
  * is added). With no address both vacated and taken, this is `redirectsAfterMove` per
  * move, in order.
+ *
+ * `homes` (live mode, and only when the move leaves redirects): when a move vacates an
+ * address that is another document's live address (a chain before a Publish left that
+ * document without a redirect from it, since a document sat there), `live → now` is added
+ * too, replacing any entry from that address, so the public site's old address still
+ * finds its document after the Publish.
  */
-export function redirectsAfterMoves(list: readonly Redirect[], moves: readonly { from: string; to: string; add: boolean }[]): Redirect[] {
+export function redirectsAfterMoves(list: readonly Redirect[], moves: readonly { from: string; to: string; add: boolean }[], homes: readonly LiveHome[] = []): Redirect[] {
 	const taken = (address: string) => moves.some((m) => same(m.to, address));
-	const replaced = (address: string) => moves.some((m) => m.add && same(m.from, address));
+	const stranded = strandedHomes(moves, homes);
+	const replaced = (address: string) => moves.some((m) => m.add && same(m.from, address)) || stranded.some((r) => same(r.from, address));
 	const next = list
 		.filter((r) => !taken(r.from) && !replaced(r.from))
 		.map((r) => {
@@ -85,14 +115,16 @@ export function redirectsAfterMoves(list: readonly Redirect[], moves: readonly {
 			return m ? { from: r.from, to: m.to } : r;
 		})
 		.filter((r) => !same(r.from, r.to));
-	for (const m of moves) if (m.add && !same(m.from, m.to) && !taken(m.from)) next.push({ from: m.from, to: m.to });
+	for (const r of redirectsAddedBy(moves, homes)) next.push(r);
 	return next;
 }
 
-/** The redirects a plan adds (`redirectsAfterMoves`): one per move with `add`, unless another document now sits at its old address. */
-export function redirectsAddedBy(moves: readonly { from: string; to: string; add: boolean }[]): Redirect[] {
+/** The redirects a plan adds (`redirectsAfterMoves`): one per move with `add`, unless another document now sits at its old address, and one per stranded live address (`homes`). */
+export function redirectsAddedBy(moves: readonly { from: string; to: string; add: boolean }[], homes: readonly LiveHome[] = []): Redirect[] {
 	const taken = (address: string) => moves.some((m) => same(m.to, address));
-	return moves.filter((m) => m.add && !same(m.from, m.to) && !taken(m.from)).map((m) => ({ from: m.from, to: m.to }));
+	const added = moves.filter((m) => m.add && !same(m.from, m.to) && !taken(m.from)).map((m) => ({ from: m.from, to: m.to }));
+	for (const r of strandedHomes(moves, homes)) if (!added.some((a) => same(a.from, r.from))) added.push(r);
+	return added;
 }
 
 /** Where a request for `pathname` goes, or null. Matched without a trailing slash; letter case counts, as it does for pages. */

package/src/reserved.ts

@@ -19,6 +19,7 @@ export const RESERVED_COLLECTIONS = ['shared', 'settings'] as const;
  * The keys of Site Settings the package owns (Decision 10); the site's own
  * `settings.fields` can't use them. M6 adds the search and sharing defaults, the
  * Google tag and the form emails' recipients (M6 Decision 14); pre-M7 item 8, the
- * redirects (redirects.ts).
+ * redirects (redirects.ts); arrange pages (Decision 6), the Pages tree's saved order
+ * (page-order.ts), which only the arrange screen writes.
  */
-export const SETTINGS_KEYS = ['title', 'editors', 'brand', 'seo', 'googleTag', 'formRecipients', 'redirects'] as const;
+export const SETTINGS_KEYS = ['title', 'editors', 'brand', 'seo', 'googleTag', 'formRecipients', 'redirects', 'pageOrder'] as const;

package/src/serialize.ts

@@ -57,6 +57,7 @@ import {
 import { fieldToJson, isEmptyValue, parseField, type Field, type Fields } from './fields.ts';
 import { mediaLine } from './media-value.ts';
 import { parseRedirects } from './redirects.ts';
+import { parsePageOrder } from './page-order.ts';
 import { member, parseSource, slice, type ArrayNode, type JsonNode, type MemberNode, type ObjectNode, type ParsedSource } from './json-source.ts';
 import { isEmptySeo, parseFormRecipients, parseGoogleTag, parseSeo, seoText, type Seo } from './seo.ts';
 import { SCHEMA_KEY } from './schema-key.ts';
@@ -384,6 +385,18 @@ const redirectsCodec: KeyCodec = {
 	removeWhenEmpty: true,
 };
 
+/** Arrange pages (Decision 6): the saved order, one parent's list per line. */
+const pageOrderCodec: KeyCodec = {
+	parse: parsePageOrder,
+	text: (v, depth) => {
+		const entries = Object.entries(parsePageOrder(v));
+		if (entries.length === 0) return '{}';
+		return `{\n${entries.map(([k, list]) => `${pad(depth + 1)}${JSON.stringify(k)}: [${list.map((s) => JSON.stringify(s)).join(', ')}]`).join(',\n')}\n${pad(depth)}}`;
+	},
+	empty: (v) => Object.keys(parsePageOrder(v)).length === 0,
+	removeWhenEmpty: true,
+};
+
 const fieldCodec = (field: Field): KeyCodec => ({
 	parse: (raw) => parseField(field, raw),
 	text: (value, depth) => fieldText(field, value, depth),
@@ -419,6 +432,7 @@ function codecsFor(collection: Pick<ResolvedCollection, 'kind' | 'fields'>): Map
 		codecs.set('googleTag', googleTagCodec);
 		codecs.set('formRecipients', recipientsCodec);
 		codecs.set('redirects', redirectsCodec);
+		codecs.set('pageOrder', pageOrderCodec);
 	}
 	for (const [key, field] of Object.entries(collection.fields ?? ({} as Fields))) codecs.set(key, fieldCodec(field));
 	return codecs;
@@ -692,6 +706,9 @@ export function savedForm(text: string, collection: Pick<ResolvedCollection, 'ki
 		// brandCodec: logo and icon on one line each; redirectsCodec: one redirect per line.
 		keys.set('brand', { kind: 'object', keys: new Map([['logo', INLINE], ['icon', INLINE]]) });
 		keys.set('redirects', { kind: 'list', item: INLINE });
+		// pageOrderCodec: one parent's list per line.
+		const order = (raw as Record<string, unknown>).pageOrder;
+		if (order && typeof order === 'object' && !Array.isArray(order)) keys.set('pageOrder', { kind: 'object', keys: new Map(Object.keys(order).map((k) => [k, INLINE])) });
 	}
 	return `${layout(raw, { kind: 'object', keys }, 0)}\n`;
 }