caracms 0.3.4 → 0.5.0

package/src/editor/server/arrange.ts

@@ -0,0 +1,245 @@
+/**
+ * Arrange pages (Contracts → Apply request): the arrange screen's Apply, both modes.
+ *
+ * **A security boundary, as move is** (move.ts): the paths come from the browser, so the
+ * route is the same POST-JSON-same-origin handler, and every move goes through the
+ * many-move engine (`moveMany`: create.ts → `target`, the store's own checks and locks).
+ *
+ * - `planArrange` expands each root with Change address…'s expansion (move.ts →
+ *   `movesUnder`): everything under it, except what's under another root, which wins for its
+ *   own subtree. It checks every `order` key and slug against the Pages collection as it
+ *   will be once the moves land, and builds the engine's Site Settings edit: the saved order
+ *   re-keyed after the moves, the request's lists replacing those keys (page-order.ts →
+ *   `arrangedOrder`), so the order and the redirects land, or roll back, in one write.
+ * - With no moves (an order-only Apply, Decision 21), the store writes Site Settings alone,
+ *   taking its lock in live mode (`DraftsStore.arrange`).
+ * - Change address… keeps the order current the same way (`orderEdit`, Decision 6).
+ */
+import type { ResolvedCollection, ResolvedSite } from '../../config.ts';
+import type { DocumentEntry } from '../../content.ts';
+import { parseAnyDocument, type SettingsDocument } from '../../document.ts';
+import type { Person } from '../../live/messages.ts';
+import { arrangedOrder, isOrderedCollection, listingStamp, orderAfterMoves, parsePageOrder, type PageOrder, type PathChange } from '../../page-order.ts';
+import { applyKeyedEdits } from '../../serialize.ts';
+import type { ArrangeRequest, ArrangeResponse } from '../types.ts';
+import { refused } from './create.ts';
+import { movesUnder, type PathMove } from './move.ts';
+import { checkOrigin, seqOf, tabOf, WriteRefused, type WriteContext } from './write.ts';
+
+type Site = Pick<ResolvedSite, 'root' | 'collections' | 'blocks'>;
+
+/** An Apply's body can carry a whole tree's order and moves. */
+export const MAX_ARRANGE_BODY_BYTES = 256 * 1024;
+
+const ARRANGE_SHAPE = '{ moves: [{ collection, fromPath, toPath }…], order: { "<parent path>": ["slug"…] }, redirect?, expect? }';
+
+/** Decision 10's sentence when the listing isn't the one the review was planned on. */
+export const CHANGED_MESSAGE = 'The pages changed since you opened the review.';
+
+/** Validate an Apply body's shape. Throws WriteRefused 400. */
+export function parseArrangeBody(body: unknown): ArrangeRequest {
+	const bad = (why: string) => refused(400, 'bad-request', `Malformed body: ${why}. Send ${ARRANGE_SHAPE}.`);
+	if (!body || typeof body !== 'object' || Array.isArray(body)) throw bad('it must be a JSON object');
+	const b = body as Record<string, unknown>;
+	const extra = Object.keys(b).filter((k) => !['moves', 'order', 'redirect', 'expect'].includes(k));
+	if (extra.length) throw bad(`unexpected ${extra.map((k) => JSON.stringify(k.slice(0, 60))).join(', ')}`);
+	if (!Array.isArray(b.moves)) throw bad('"moves" must be a list');
+	const moves = b.moves.map((m, i) => {
+		if (!m || typeof m !== 'object' || Array.isArray(m)) throw bad(`moves[${i}] must be { collection, fromPath, toPath }`);
+		const r = m as Record<string, unknown>;
+		if (Object.keys(r).some((k) => !['collection', 'fromPath', 'toPath'].includes(k))) throw bad(`moves[${i}] must be { collection, fromPath, toPath }`);
+		if (typeof r.collection !== 'string' || r.collection === '') throw bad(`moves[${i}].collection must be a collection's name`);
+		if (typeof r.fromPath !== 'string' || r.fromPath === '') throw bad(`moves[${i}].fromPath must be the page's path`);
+		if (typeof r.toPath !== 'string') throw bad(`moves[${i}].toPath must be the page's new path`);
+		if (r.fromPath.length > 512 || r.toPath.length > 512) throw refused(400, 'bad-path', 'That path is too long.');
+		return { collection: r.collection, fromPath: r.fromPath, toPath: r.toPath };
+	});
+	if (!b.order || typeof b.order !== 'object' || Array.isArray(b.order)) throw bad('"order" must be an object of lists');
+	const order: PageOrder = {};
+	for (const [key, list] of Object.entries(b.order as Record<string, unknown>)) {
+		if (!Array.isArray(list) || !list.every((s) => typeof s === 'string' && s !== '')) throw bad(`order[${JSON.stringify(key.slice(0, 60))}] must be a list of slugs`);
+		if (key.length > 512) throw refused(400, 'bad-path', 'That path is too long.');
+		order[key] = [...new Set(list as string[])];
+	}
+	if (b.redirect !== undefined && typeof b.redirect !== 'boolean') throw bad('"redirect" must be true or false');
+	let expect: Record<string, string> | undefined;
+	if (b.expect !== undefined) {
+		if (!b.expect || typeof b.expect !== 'object' || Array.isArray(b.expect) || !Object.values(b.expect).every((v) => typeof v === 'string')) throw bad('"expect" must be { "<collection>": "<stamp>" }');
+		expect = { ...(b.expect as Record<string, string>) };
+	}
+	return { moves, order, ...(b.redirect === false ? { redirect: false } : {}), ...(expect ? { expect } : {}) };
+}
+
+const orderedCollection = (site: Pick<Site, 'collections'>): ResolvedCollection | undefined => Object.values(site.collections).find((c) => isOrderedCollection(c));
+const settingsCollection = (site: Pick<Site, 'collections'>): ResolvedCollection | undefined => Object.values(site.collections).find((c) => c.kind === 'settings');
+
+/** Site Settings' `pageOrder` in its text (`{}`: none, or the text isn't JSON). */
+export function orderIn(text: string | null): PageOrder {
+	if (text === null) return {};
+	try {
+		const raw = JSON.parse(text) as unknown;
+		return raw && typeof raw === 'object' && !Array.isArray(raw) ? parsePageOrder((raw as Record<string, unknown>).pageOrder) : {};
+	} catch {
+		return {};
+	}
+}
+
+/**
+ * Site Settings' text with `pageOrder` set to `order` (taken out when it's empty), every
+ * other key as it was; `text` null: a new file. Unchanged text when the order is the same,
+ * or when the text isn't JSON (the editor warns about that file).
+ */
+export function settingsWithOrder(site: Pick<Site, 'collections' | 'blocks'>, text: string | null, order: PageOrder): string | null {
+	const collection = settingsCollection(site);
+	if (!collection) return text;
+	let doc: SettingsDocument | null = null;
+	if (text !== null) {
+		try {
+			doc = parseAnyDocument(JSON.parse(text), site, collection) as SettingsDocument;
+		} catch {
+			return text;
+		}
+	}
+	if (doc === null && Object.keys(order).length === 0) return text;
+	return applyKeyedEdits(text, { title: doc?.title ?? 'Site Settings', data: { ...(doc?.data ?? {}), pageOrder: order } }, collection);
+}
+
+/** The sentence an order-only Apply is refused with when Site Settings, which holds the order, can't be read. */
+export const UNREADABLE_SETTINGS_MESSAGE = "Site Settings isn't valid JSON, so the new order can't be saved there. Nothing was changed: fix Site Settings, then apply again.";
+
+/**
+ * An order-only Apply (Decision 21) writes nothing but Site Settings, so one that can't be read
+ * is refused (422 invalid-json) rather than answered `{ ok: true }` with the order dropped.
+ * `text` null (no file yet) is fine: the order makes a new one.
+ */
+export function assertSettingsReadable(site: Pick<Site, 'collections' | 'blocks'>, text: string | null): void {
+	const collection = settingsCollection(site);
+	if (!collection || text === null) return;
+	try {
+		parseAnyDocument(JSON.parse(text), site, collection);
+	} catch {
+		throw refused(422, 'invalid-json', UNREADABLE_SETTINGS_MESSAGE);
+	}
+}
+
+/** The ordered collection's path changes in a list of moves. */
+function pathChanges(site: Pick<Site, 'collections'>, moves: readonly PathMove[]): PathChange[] {
+	const pages = orderedCollection(site);
+	return pages ? moves.filter((m) => m.collection === pages.name).map((m) => ({ from: m.path, to: m.to })) : [];
+}
+const pathsOf = (site: Pick<Site, 'collections'>, documents: readonly DocumentEntry[]) => {
+	const pages = orderedCollection(site);
+	return pages ? documents.filter((d) => d.collection === pages.name).map((d) => d.path) : [];
+};
+
+/** Change address… (Decision 6): the engine's Site Settings edit that keeps a saved order current after these moves. */
+export function orderEdit(site: Site, moves: readonly PathMove[], documents: readonly DocumentEntry[]): (text: string) => string {
+	const changes = pathChanges(site, moves);
+	const before = pathsOf(site, documents);
+	return (text) => {
+		const saved = orderIn(text);
+		if (changes.length === 0 || Object.keys(saved).length === 0) return text;
+		return settingsWithOrder(site, text, orderAfterMoves(saved, changes, before)) ?? text;
+	};
+}
+
+export interface ArrangePlan {
+	/** Every document whose path changes, roots first (each root, then what it carries); empty for an order-only Apply. */
+	moves: PathMove[];
+	/** Site Settings' text → its text with the arranged order (the engine's `editSettings`, or the order-only write). */
+	edit: (text: string | null) => string | null;
+}
+
+/**
+ * The Apply's plan against the listing as it is (`documents`): the roots expanded, the
+ * order checked against the Pages collection as it will be. Throws WriteRefused: the
+ * engine's own refusals for a root (move.ts → `movesUnder`), `not-found` (404) for an
+ * order entry that names nothing once the moves land.
+ */
+export function planArrange(site: Site, request: ArrangeRequest, documents: readonly DocumentEntry[]): ArrangePlan {
+	// Decision 10: the review's listing, collection by collection, before anything is planned.
+	for (const [collection, stamp] of Object.entries(request.expect ?? {})) {
+		const paths = documents.filter((d) => d.collection === collection).map((d) => d.path);
+		if (listingStamp(paths) !== stamp) throw refused(409, 'changed', CHANGED_MESSAGE);
+	}
+	const key = (m: { collection: string; path: string }) => `${m.collection}\0${m.path}`;
+	// Shallowest first, so an inner root wins for its own subtree.
+	const roots = [...request.moves].sort((a, b) => a.fromPath.split('/').length - b.fromPath.split('/').length);
+	const seen = new Set<string>();
+	for (const r of roots) {
+		const k = key({ collection: r.collection, path: r.fromPath });
+		if (seen.has(k)) throw refused(400, 'bad-request', `${r.fromPath} is in the plan twice.`);
+		seen.add(k);
+	}
+	const planned = new Map<string, PathMove>();
+	for (const r of roots) {
+		for (const m of movesUnder(site, { collection: r.collection, path: r.fromPath, to: r.toPath }, documents)) planned.set(key(m), m);
+	}
+	// Roots in the order asked, each followed by what it carries (what the innermost root above it carries).
+	const ownerOf = (m: PathMove) =>
+		request.moves.filter((o) => o.collection === m.collection && (m.path === o.fromPath || m.path.startsWith(`${o.fromPath}/`))).sort((a, b) => b.fromPath.length - a.fromPath.length)[0]!;
+	const ordered: PathMove[] = [];
+	for (const r of request.moves) {
+		ordered.push(planned.get(key({ collection: r.collection, path: r.fromPath }))!);
+		for (const m of planned.values()) if (m.path !== r.fromPath && ownerOf(m) === r) ordered.push(m);
+	}
+
+	// The Pages collection once the moves land: every `order` key and slug names something there.
+	const changes = pathChanges(site, ordered);
+	const before = pathsOf(site, documents);
+	const moving = new Map(changes.map((c) => [c.from, c.to]));
+	const after = before.map((p) => moving.get(p) ?? p);
+	const known = new Set<string>(['']);
+	for (const p of after) {
+		const parts = p.split('/');
+		for (let i = 1; i <= parts.length; i++) known.add(parts.slice(0, i).join('/'));
+	}
+	for (const [parent, slugs] of Object.entries(request.order)) {
+		if (!known.has(parent)) throw refused(404, 'not-found', `There's no page or group at /${parent} any more.`);
+		for (const slug of slugs) {
+			const path = parent === '' ? slug : `${parent}/${slug}`;
+			if (!known.has(path)) throw refused(404, 'not-found', `There's no page or group at /${path} any more.`);
+		}
+	}
+	const edit = (text: string | null) => settingsWithOrder(site, text, arrangedOrder(orderIn(text), request.order, changes, before));
+	return { moves: ordered, edit };
+}
+
+// ── The route ──────────────────────────────────────────────────────────────
+
+const json = (status: number, body: unknown, headers: Record<string, string> = {}) =>
+	new Response(JSON.stringify(body), {
+		status,
+		headers: { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store', ...headers },
+	});
+
+/** What the route needs of the drafts store. */
+export interface Arranges {
+	arrange(request: ArrangeRequest, context?: WriteContext): Promise<ArrangeResponse>;
+}
+
+/** POST /_caracms/arrange: a Request in, a Response out, through the mode's store (move.ts's handling, the same checks). */
+export async function handleArrange(request: Request, store: Arranges, who: { person?: Person | null } = {}): Promise<Response> {
+	try {
+		if (request.method !== 'POST') throw new WriteRefused(405, 'The arrange route only takes POST.');
+		checkOrigin(request);
+		const type = request.headers.get('content-type') ?? '';
+		if (!/^application\/json\s*(;|$)/i.test(type)) throw new WriteRefused(415, 'Send JSON (Content-Type: application/json).');
+		const length = Number(request.headers.get('content-length') ?? 0);
+		if (length > MAX_ARRANGE_BODY_BYTES) throw new WriteRefused(413, 'That body is too large.');
+		const raw = await request.text();
+		if (Buffer.byteLength(raw) > MAX_ARRANGE_BODY_BYTES) throw new WriteRefused(413, 'That body is too large.');
+		let body: unknown;
+		try {
+			body = JSON.parse(raw);
+		} catch {
+			throw refused(400, 'bad-request', 'Malformed body: it isn\'t valid JSON.');
+		}
+		const context: WriteContext = { person: who.person ?? null, tab: tabOf(request), release: false, seq: seqOf(request) };
+		return json(200, await store.arrange(parseArrangeBody(body), context));
+	} catch (error) {
+		if (error instanceof WriteRefused) return json(error.status, { error: error.message, ...error.body }, error.status === 405 ? { Allow: 'POST' } : {});
+		console.error('[caracms] arrange failed:', error);
+		return json(500, { error: `That didn't work (${error instanceof Error ? error.message : String(error)}).` });
+	}
+}

package/src/editor/server/create.ts

@@ -46,6 +46,7 @@ import { link, lstat, mkdir, realpath, rm, rmdir, stat, unlink, writeFile } from
 import { basename, dirname, join, relative, sep } from 'node:path';
 import type { ResolvedCollection, ResolvedSite } from '../../config.ts';
 import { DocumentError, documentUrl, resolveDocumentFile, type DocumentEntry } from '../../content.ts';
+import { heldBases, holdsMessage, withHeldBases } from '../../held.ts';
 import { own, parseAnyDocument, type AnyDocument } from '../../document.ts';
 import type { Person } from '../../live/messages.ts';
 import { applyDocumentEdits } from '../../serialize.ts';
@@ -197,10 +198,15 @@ function firstText(site: Site, collection: ResolvedCollection, title: string, bl
  * Check a create against the rules and the store's listing (`documents`: every
  * document in every collection now), and work out the new file. Throws WriteRefused.
  */
-export function planCreate(site: Site, request: CreateRequest, documents: readonly DocumentEntry[]): CreatePlan {
+export function planCreate(configured: Site, request: CreateRequest, documents: readonly DocumentEntry[]): CreatePlan {
+	// Collections under pages (Decision 7): a held collection's base is resolved from the listing.
+	const bases = heldBases(configured.collections, documents);
+	const site = withHeldBases(configured, bases);
 	const collection = own(site.collections, request.collection);
 	if (!collection) throw refused(400, 'bad-path', `No collection "${printable(request.collection)}" is declared.`);
 	if (collection.kind === 'settings') throw refused(400, 'not-allowed', 'Site Settings is always there, so it\'s never created.');
+	const unheld = own(bases, collection.name)?.problem;
+	if (unheld) throw refused(400, 'not-held', unheld);
 	if (request.path === '') throw refused(400, 'bad-name', NO_ADDRESS_MESSAGE);
 	if (request.path.split('/').includes(RESERVED_SLUG)) throw refused(400, 'index', INDEX_MESSAGE);
 
@@ -227,7 +233,7 @@ export function planCreate(site: Site, request: CreateRequest, documents: readon
 		throw refused(409, 'exists', url ? `There's already a page at ${url}.` : `There's already a ${collection.kind === 'shared' ? 'shared block' : 'document'} called "${where.path}".`);
 	}
 	if (url !== null) {
-		const collections = Object.values(site.collections).map(({ name, label, urlBase }) => ({ name, label, urlBase }));
+		const collections = Object.values(site.collections).map(({ name, label, urlBase, heldBy }) => ({ name, label, urlBase, heldBy }));
 		const problem = addressProblem(url, collection.name, collections, documents, site.codeRoutes);
 		if (problem) throw refused(problem.code === 'address-taken' ? 409 : 400, problem.code, problem.message);
 	}
@@ -252,6 +258,11 @@ export function planDelete(site: Site, request: DeleteRequest, documents: readon
 		throw refused(400, 'not-allowed', collection.urlBase === '/' ? 'Home can\'t be deleted.' : `${entry?.label ?? 'This page'} is the top of ${collection.label}, so it can't be deleted.`);
 	}
 	if (!entry) throw refused(404, 'not-found', `${collection.label}: no document "${printable(where.path)}".`);
+	// Collections under pages (Decision 12): a page that holds a collection stays, as Home does.
+	const held = entry.holds ? Object.values(site.collections).find((c) => c.name === entry.holds && c.heldBy === collection.name) : undefined;
+	if (held) {
+		throw refused(409, 'holds', holdsMessage(entry.label, held.label));
+	}
 	if (collection.kind === 'shared' && entry.usedOn?.length) {
 		const usedOn = entry.usedOn.map((u) => ({ ...u, title: documents.find((d) => d.collection === u.collection && d.path === u.path)?.label ?? u.path }));
 		throw refused(

package/src/editor/server/drafts-store.ts

@@ -6,13 +6,14 @@
  *
  * Everything reads at request time (never imported, Decision 5), and keeps no state.
  */
-import { stat } from 'node:fs/promises';
+import { stat, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { SITE_SETTINGS_FILE, type ResolvedSite } from '../../config.ts';
 import { diskSource, listDocuments, readDocument, type ContentSource } from '../../content.ts';
-import type { AnyOpenedDocument, CreateRequest, CreateResponse, DeleteRequest, DeleteResponse, ListedDocument, MoveRequest, MoveResponse, OpenedDocument, ReplaceFileRequest, ReplaceFileResponse } from '../types.ts';
+import type { AnyOpenedDocument, ArrangeRequest, ArrangeResponse, CreateRequest, CreateResponse, DeleteRequest, DeleteResponse, ListedDocument, MoveRequest, MoveResponse, OpenedDocument, ReplaceFileRequest, ReplaceFileResponse } from '../types.ts';
 import { confineOnDisk, createOnDisk, deleteOnDisk, planCreate, planDelete, target } from './create.ts';
-import { moveChanges, moveOnDisk, moveResponse, planMove, settingsWithoutRedirectFrom } from './move.ts';
+import { assertSettingsReadable, orderEdit, planArrange } from './arrange.ts';
+import { movesChanges, movesOnDisk, moveResponse, movesUnder, planMoves, settingsWithoutRedirectFrom, type ManyMoveRequest } from './move.ts';
 import { replaceChanges, replaceResponse } from './replace.ts';
 import { applyWrite, fileVersion, writeAtomic, type WriteContext, type WriteRequest, type WriteResponse } from './write.ts';
 
@@ -53,11 +54,26 @@ export interface DraftsStore {
 	/**
 	 * Change a document's address (pre-M7 item 8; move.ts has the rules, the same in both
 	 * stores): the document moves, every link and reference to it is rewritten, and Site
-	 * Settings gets a redirect from the old address. Local: on disk, the new file first and
-	 * the old one last. Live: every change is an autosave under this tab's locks, all going
-	 * out at the next Publish. Throws WriteRefused.
+	 * Settings gets a redirect from the old address. Collections under pages (Decision 9):
+	 * everything under a page moves with it, through `moveMany`. Throws WriteRefused.
 	 */
 	move(request: MoveRequest, context?: WriteContext): Promise<MoveResponse>;
+	/**
+	 * The many-move engine (collections under pages, Contracts): every document in the
+	 * request at its new path, and each held document whose holder's address changes,
+	 * checked as a whole, then applied all or nothing, each linking file rewritten once and
+	 * Site Settings written once and last, with every redirect and the caller's own edit.
+	 * Local: on disk, put back on a failure. Live: every lock taken up front, every change an
+	 * autosave, all rolled back on a failure, all going out at the next Publish. Throws WriteRefused.
+	 */
+	moveMany(request: ManyMoveRequest, context?: WriteContext): Promise<MoveResponse>;
+	/**
+	 * Arrange pages (Contracts → Apply request): the roots expanded and checked (arrange.ts →
+	 * `planArrange`), then the moves through `moveMany` with the arranged order as its Site
+	 * Settings edit, landing or rolling back together; with no moves, Site Settings alone
+	 * (live mode: under its lock, Decision 21). Throws WriteRefused.
+	 */
+	arrange(request: ArrangeRequest, context?: WriteContext): Promise<ArrangeResponse>;
 	/**
 	 * M6c G4 (Decision 9): Replace… on a file. Every link to `from`, in every document, points
 	 * at `to` (replace.ts has the rules, the same in both stores). Local: each file written
@@ -71,6 +87,15 @@ type Site = Pick<ResolvedSite, 'root' | 'collections' | 'blocks'>;
 
 /** The local store: the content files on disk. */
 export function localDraftsStore(site: Site): DraftsStore {
+	const moveMany = async (request: ManyMoveRequest): Promise<MoveResponse> => {
+		for (const m of request.moves) await confineOnDisk(site, target(site, m.collection, m.path).file);
+		const documents = await listDocuments(site);
+		const plans = planMoves(site, request.moves, documents);
+		const read = (file: string) => diskSource.readText(join(site.root, file));
+		const changes = await movesChanges(site, plans, documents, read, () => request.redirect !== false, request.editSettings);
+		await movesOnDisk(site, changes);
+		return moveResponse(plans, changes);
+	};
 	return {
 		async list() {
 			const entries = await listDocuments(site);
@@ -109,10 +134,30 @@ export function localDraftsStore(site: Site): DraftsStore {
 			// The file first (a link out of the collection is refused before anything else), then the rules.
 			await confineOnDisk(site, target(site, request.collection, request.path).file);
 			const documents = await listDocuments(site);
-			const plan = planMove(site, request, documents);
-			const changes = await moveChanges(site, plan, documents, (file) => diskSource.readText(join(site.root, file)), true);
-			await moveOnDisk(site, plan, changes);
-			return moveResponse(site, plan, changes);
+			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) });
+		},
+		moveMany,
+		async arrange(request) {
+			// The files first (a link out of the collection is refused before anything else), then the plan.
+			for (const m of request.moves) await confineOnDisk(site, target(site, m.collection, m.fromPath).file);
+			const plan = planArrange(site, request, await listDocuments(site));
+			// An unreadable Site Settings would drop the order and the redirects without a word: refuse every Apply.
+			assertSettingsReadable(site, await diskSource.readText(join(site.root, SITE_SETTINGS_FILE)));
+			if (plan.moves.length) {
+				await moveMany({ moves: plan.moves, ...(request.redirect === false ? { redirect: false } : {}), editSettings: (text) => plan.edit(text) ?? text });
+				return { ok: true };
+			}
+			const file = join(site.root, SITE_SETTINGS_FILE);
+			const before = await diskSource.readText(file);
+			assertSettingsReadable(site, before);
+			const after = plan.edit(before);
+			if (after !== null && after !== before) {
+				if (before === null) await writeFile(file, after, { encoding: 'utf8', flag: 'wx', mode: 0o644 });
+				else await writeAtomic(file, after);
+			}
+			return { ok: true };
 		},
 		async replaceFile(request) {
 			const changes = await replaceChanges(site, request, await listDocuments(site), (file) => diskSource.readText(join(site.root, file)));