caracms 0.7.0 → 0.8.1

package/src/cloud-middleware.ts

@@ -14,13 +14,23 @@
  *
  * `cloudSettingsForBuild()` is the build's start (`astro:build:start`): the same fetch, and
  * a refusal or an unreachable cloud **fails the build** with the cloud's sentence or the
- * package's own. The build ignores `github.repo`: a site with no repo linked still builds.
+ * package's own. A refusal fails it at once; an unreachable cloud (no answer, a timeout, an
+ * answer that isn't the API's, such as a 502 page) is tried again with growing waits for
+ * about three minutes first (`BUILD_RETRY_WAITS_MS`, `BUILD_RETRY_WINDOW_MS`), one log line
+ * per wait, since a Convex blip during a Publish's deploy would otherwise leave the site
+ * unchanged. Only the build retries: the server's first request keeps one try and `RETRY_MS`.
+ * The build ignores `github.repo`: a site with no repo linked still builds.
  * The key beside the site's own forms and email variables fails it too (caracms-cloud M4
  * Decision 22), whether or not the media is the cloud's.
+ *
+ * With the config's `services` (caracms-cloud M5): `'self-hosted'` never fetches (the key is
+ * ignored); `'cloud'` without the key fails the build with Decision 4's sentence. The build
+ * names the ignored variables once, here; the server, at its first request (`cloudMedia`).
  */
 import type { MiddlewareHandler } from 'astro';
 import { CLOUD_NO_MEDIA, CLOUD_UNREACHABLE_BUILD, isCloudRefusal, heldCloudSettings, loadCloudSettings } from './live/cloud.ts';
 import { cloudFormsConflict } from './live/mode.ts';
+import { CLOUD_KEY_MISSING_PROBLEM, servicesEnv, type Services } from './live/services.ts';
 import { cloudMedia } from './media.ts';
 
 type Env = Record<string, string | undefined>;
@@ -63,12 +73,48 @@ export const onRequest: MiddlewareHandler = async (_context, next) => {
 	return next();
 };
 
-/** The build's start: the settings, or an Error with the sentence that fails the build. Nothing for a site off the cloud. */
-export async function cloudSettingsForBuild(env: Env = process.env): Promise<void> {
+/** The build's waits between tries at an unreachable cloud, in order; the last repeats while the window lasts. */
+export const BUILD_RETRY_WAITS_MS = [5_000, 10_000, 20_000, 40_000, 60_000];
+/** No wait starts that would end more than this long after the first try began. */
+export const BUILD_RETRY_WINDOW_MS = 210_000;
+
+/** The build's clock, its waits and its log line (tests). */
+export interface BuildRetry {
+	now?: () => number;
+	wait?: (ms: number) => Promise<void>;
+	log?: (line: string) => void;
+}
+
+/** The settings for the build: an unreachable cloud is tried again within the window; a refusal is thrown at once. */
+async function loadForBuild(connection: Parameters<typeof loadCloudSettings>[0], retry: BuildRetry) {
+	const { now = Date.now, wait = (ms) => new Promise<void>((done) => setTimeout(done, ms)), log = (line) => console.warn(line) } = retry;
+	const end = now() + BUILD_RETRY_WINDOW_MS;
+	for (let tries = 1; ; tries++) {
+		try {
+			return await loadCloudSettings(connection);
+		} catch (error) {
+			if (isCloudRefusal(error) && error.error !== 'unreachable') throw error;
+			const ms = BUILD_RETRY_WAITS_MS[Math.min(tries, BUILD_RETRY_WAITS_MS.length) - 1]!;
+			if (now() + ms > end) throw error;
+			const what = isCloudRefusal(error) && error.detail ? ` (${error.detail})` : '';
+			const at = new Date(now() + ms).toISOString().slice(11, 19);
+			log(`[caracms] CaraCMS Cloud couldn't be reached for the build's settings${what}, try ${tries}; trying again in ${ms / 1000} s, at ${at} UTC.`);
+			await wait(ms);
+		}
+	}
+}
+
+/**
+ * The build's start: the settings, or an Error with the sentence that fails the build. Nothing for a site off the cloud.
+ * `services` is the config's (the integration passes it: this runs outside the bundle, where the build's defines don't reach).
+ */
+export async function cloudSettingsForBuild(env: Env = process.env, services: Services | null = null, retry: BuildRetry = {}): Promise<void> {
+	env = servicesEnv(env, services);
+	if (services === 'cloud' && !env.CARACMS_CLOUD_KEY?.trim()) throw new Error(`caracms: ${CLOUD_KEY_MISSING_PROBLEM}`);
 	// caracms-cloud M4 Decision 22: the key with the site's own forms and email variables fails the build too.
 	const conflict = cloudFormsConflict(env);
 	const forms = conflict ? [conflict] : [];
-	const cloud = cloudMedia(env);
+	const cloud = cloudMedia(env, services);
 	if (!cloud) {
 		if (forms.length) throw new Error(`caracms: ${forms.join(' ')}`);
 		return;
@@ -76,7 +122,7 @@ export async function cloudSettingsForBuild(env: Env = process.env): Promise<voi
 	if (cloud.problems.length || forms.length) throw new Error(`caracms: ${[...cloud.problems, ...forms].join(' ')}`);
 	let settings;
 	try {
-		settings = await loadCloudSettings(cloud.connection);
+		settings = await loadForBuild(cloud.connection, retry);
 	} catch (error) {
 		const message = isCloudRefusal(error) && error.error !== 'unreachable' ? error.message : CLOUD_UNREACHABLE_BUILD;
 		throw new Error(`caracms: ${message}`);

package/src/config.ts

@@ -253,8 +253,19 @@ export interface SiteConfig {
 	 * whose pages all show the site's own title.
 	 */
 	titleFallback?: TitleFallback;
+	/**
+	 * Where the site's services come from (caracms-cloud M5 Decision 1): GitHub access,
+	 * media, forms and email, video. `'cloud'`: CaraCMS Cloud, through `CARACMS_CLOUD_KEY`.
+	 * `'self-hosted'`: the site's own variables. The other mode's variables are ignored,
+	 * with a warning (live/services.ts). Unset, the key decides, as before M5 (Decision 3).
+	 * `caracms init --cloud` or `--self-hosted` writes it.
+	 */
+	services?: Services;
 }
 
+/** The config's `services` values (live/services.ts). */
+export type Services = 'cloud' | 'self-hosted';
+
 /** The config's `titleFallback` values (head.ts). */
 export type TitleFallback = 'page-and-brand' | 'site';
 
@@ -366,6 +377,8 @@ export interface ResolvedSite {
 	titleSeparator: string;
 	/** What a page without its own `seo.title` falls back to (`'page-and-brand'` when the config sets none). */
 	titleFallback: TitleFallback;
+	/** Where the site's services come from (caracms-cloud M5 Decision 1); null when the config doesn't say. */
+	services: Services | null;
 	/**
 	 * M8 Decision 10: the URLs the site's own `src/pages/` serves (code-routes.ts), read by the
 	 * integration at setup (and by the commands). Absent before then: nothing is reserved.
@@ -628,7 +641,13 @@ export function resolveSite(config: SiteConfig, root: string): ResolvedSite {
 		fail(`titleFallback must be 'page-and-brand' (the page's title and the site's name) or 'site' (Site Settings' title on every page) (got ${JSON.stringify(config.titleFallback)}).`);
 	}
 
-	return { root, collections, blocks, textStyles, page: abs(config.page), brand, sharedFolder, phoneLinesWidth, repoPath: repoPath!, timeZone, forms, titleSeparator, titleFallback };
+	// caracms-cloud M5 Decision 1: where the site's services come from.
+	const services = config.services ?? null;
+	if (services !== null && services !== 'cloud' && services !== 'self-hosted') {
+		fail(`services must be 'cloud' (CaraCMS Cloud) or 'self-hosted' (the site's own GitHub access, bucket, imgproxy and so on) (got ${JSON.stringify(config.services)}).`);
+	}
+
+	return { root, collections, blocks, textStyles, page: abs(config.page), brand, sharedFolder, phoneLinesWidth, repoPath: repoPath!, timeZone, forms, titleSeparator, titleFallback, services };
 }
 
 interface FieldCheck {

package/src/content.ts

@@ -43,6 +43,7 @@ import { leftBehindMessage, leftBehindRoutes, ownRoutedCollections } from './cod
 import { sameAddress } from './slug.ts';
 import { byLabel, isOrderedCollection, orderSiblings, parsePageOrder, type PageOrder } from './page-order.ts';
 import { SITE_SETTINGS_FILE } from './reserved.ts';
+import { documentProblems } from './document-problems.ts';
 
 // Posts and tags, Decision 14: a route's reader on the disk (read.ts).
 export { contentReader } from './read.ts';
@@ -360,19 +361,25 @@ function hideChildren(entries: DocumentEntry[]): void {
  * Read one document. Throws DocumentError: 'not-found', 'bad-path',
  * 'unknown-collection', or the listing's warning codes ('invalid-json',
  * 'no-title', 'nested-index') for a file that can't be opened.
+ *
+ * `untitled: true` is the editor's read (caracms-cloud adversarial review, finding 15): a
+ * document with no title opens, its entry still warned, so the title can be put back there.
+ * Everything that renders the site reads without it, so such a document has no page there.
  */
 export async function readDocument(
 	site: Pick<ResolvedSite, 'collections' | 'root' | 'blocks'>,
 	collectionName: string,
 	path: string,
 	source: ContentSource = diskSource,
+	options: { untitled?: boolean } = {},
 ): Promise<ReadDocument> {
 	const file = resolveDocumentFile(site, collectionName, path);
 	const collection = site.collections[collectionName]!;
 	const text = await source.readText(file);
 	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);
+	const opens = !entry.warning || (options.untitled === true && entry.warning.code === 'no-title');
+	if (!opens || !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);
@@ -429,11 +436,13 @@ function inspect(
 	} catch (error) {
 		return warn('invalid-json', `This file isn't valid JSON (${error instanceof Error ? error.message : String(error)}).`);
 	}
-	const title = (raw as { title?: unknown } | null)?.title;
-	if (typeof title !== 'string' || title.trim() === '') {
-		return warn('no-title', 'This file has no title, so it can’t be opened. Add a "title".');
-	}
-	const entry: DocumentEntry = { ...base, title, label: title, warning: null };
+	// caracms-cloud adversarial review, finding 15: a blank title keeps the document off the site
+	// (the listing's warning), but it's still read, columns and all, so the editor can open it
+	// and put one back.
+	const untitled = documentProblems(raw).length > 0;
+	const title = untitled ? '' : (raw as { title: string }).title;
+	const warning: DocumentWarning | null = untitled ? { code: 'no-title', message: 'This has no title, so it isn’t on the site. Open it to add one.' } : null;
+	const entry: DocumentEntry = { ...base, title, label: title || fileLabel, warning };
 	// M9 Decision 7: the home page is never hidden.
 	if ((document.kind === undefined || document.kind === 'sections') && document.hidden && path !== 'index') entry.hidden = entry.hiddenSelf = true;
 	if ((document.kind === undefined || document.kind === 'sections') && document.holds !== undefined) entry.holds = document.holds;

package/src/document-problems.ts

@@ -0,0 +1,48 @@
+/**
+ * What makes a document one the reader won't open (caracms-cloud adversarial review,
+ * finding 15), said the way the editor says it. One rule for three places, so they never
+ * disagree: content.ts → `inspect` (the listing's "no title" warning), the editor's note on
+ * the field while it's typed, and Publish, which holds a document like this back (it stays
+ * waiting) and publishes the rest (live/git.ts → `publish`).
+ *
+ * Today that's the title: every kind of document needs one that isn't blank. Fields have no
+ * "required" of their own, and a field's value of the wrong shape parses as empty, never
+ * refused (document.ts → `parseAnyDocument`), so nothing else makes a document unreadable.
+ * A file that isn't JSON can't be read at all; only a hand edit makes one.
+ *
+ * Browser-safe: the editor imports it.
+ */
+
+export interface DocumentProblem {
+	/** Where it is: `title`, or `''` for the whole file. */
+	path: string;
+	/** The note on the field, in its own words: "This needs a title." */
+	note: string;
+	/** Why Publish held it back, after "<title> wasn't published: ": "its title is empty". */
+	reason: string;
+}
+
+export const NO_TITLE: DocumentProblem = { path: 'title', note: 'This needs a title.', reason: 'its title is empty' };
+const NOT_JSON: DocumentProblem = { path: '', note: "This file isn't valid JSON.", reason: "its file isn't valid JSON" };
+
+/** A document's problems, from its plain value (a file's, or the editor's own). Empty: the reader opens it. */
+export function documentProblems(document: unknown): DocumentProblem[] {
+	const title = document && typeof document === 'object' && !Array.isArray(document) ? (document as { title?: unknown }).title : undefined;
+	return typeof title === 'string' && title.trim() !== '' ? [] : [NO_TITLE];
+}
+
+/** A file's problems, from its text. */
+export function textProblems(text: string): DocumentProblem[] {
+	let value: unknown;
+	try {
+		value = JSON.parse(text);
+	} catch {
+		return [NOT_JSON];
+	}
+	return documentProblems(value);
+}
+
+/** "About wasn't published: its title is empty." */
+export function heldBackSentence(title: string, reason: string): string {
+	return `${title} wasn't published: ${reason}.`;
+}

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

@@ -19,7 +19,7 @@ import { docIcon } from '../nav/DocRow.tsx';
 import { Avatar, DocMarksView } from '../live/marks.tsx';
 import { displayName } from '../live/format.ts';
 import { fmtDur } from '../fields/MediaField.tsx';
-import { docId, type CardPicture, type EditorAnyCollection, type ListedDocument } from '../../types.ts';
+import { docId, warnedWords, type CardPicture, type EditorAnyCollection, type ListedDocument } from '../../types.ts';
 import { ratioValue } from '../../../cards.ts';
 import { cellText, type RefIndex, type TableColumn } from './table.ts';
 
@@ -76,7 +76,7 @@ function Card(props: { doc: ListedDocument; collection: EditorAnyCollection; cap
 						{doc.warning ? (
 							<span className="wmark" data-warning={doc.warning.code} title={doc.warning.message}>
 								<Icon name="warn" size="xs" />
-								<span className="sr">, can't be opened: {doc.warning.message}</span>
+								<span className="sr">{warnedWords(doc)}: {doc.warning.message}</span>
 							</span>
 						) : null}
 						{live ? <DocMarksView file={doc.file} compact lock={false} /> : null}

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

@@ -34,7 +34,7 @@ import { when } from '../live/format.ts';
 import { openDialog } from '../documents/dialogs.tsx';
 import { PAGELESS_SUB, singular } from '../documents/actions.ts';
 import { usedOnLine } from '../block-list/summary.ts';
-import { docId, type EditorAnyCollection, type ListedDocument } from '../../types.ts';
+import { docId, opensInEditor, warnedWords, type EditorAnyCollection, type ListedDocument } from '../../types.ts';
 import { captionColumns, cellText, cellValue, defaultView, filterable, MISSING, nextSort, orderOptions, orderValue, refIndex, refParts, sortable, tableColumns, viewRows, type FilterValue, type RefIndex, type TableColumn, type TableView } from './table.ts';
 import { useCollection } from '../fields/ReferenceField.tsx';
 import { CollectionGrid } from './CollectionGrid.tsx';
@@ -83,7 +83,7 @@ export function useViewMode(collection: EditorAnyCollection): ViewMode {
 }
 
 const openDoc = (editor: Editor, doc: ListedDocument) => {
-	if (doc.warning) {
+	if (doc.warning && !opensInEditor(doc)) {
 		editor.announce(`${doc.label} can't be opened. ${doc.warning.message}`);
 		return;
 	}
@@ -375,7 +375,7 @@ function Row(props: { doc: ListedDocument; columns: readonly TableColumn[]; curr
 								{doc.warning ? (
 									<span className="wmark" data-warning={doc.warning.code} title={doc.warning.message}>
 										<Icon name="warn" size="xs" />
-										<span className="sr">, can't be opened: {doc.warning.message}</span>
+										<span className="sr">{warnedWords(doc)}: {doc.warning.message}</span>
 									</span>
 								) : null}
 								{/* M9 Decision 7, collections under pages (Decision 11): hidden, or hidden with the page that holds it, named. */}

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

@@ -11,15 +11,24 @@
  * study, a journal entry), off for Home or a collection's top page and while someone
  * else is editing it.
  *
+ * Discard changes (live mode): **Discard changes…** (or Discard this new page…) while the
+ * document is waiting to publish, which opens the confirmation; off, with the reason, while
+ * someone else is editing it.
+ *
  * M6c (G1): a document with no page of its own (a shared block, a fields collection
  * with no `urlBase`) has neither View on the live site nor Change address…, only Delete.
+ *
+ * `TitleNote` (caracms-cloud adversarial review, finding 15): a page or a shared block with
+ * no title says so at the top of its level, with Rename… beside it (a case study's title is
+ * the first field of its form, which says so itself: FormLevel.tsx → TitleField).
  */
 import { useEffect, useRef, useState, type KeyboardEvent } from 'react';
 import { useEditor, useStore } from '../context.tsx';
 import { displayName } from '../live/format.ts';
 import { Icon } from '../shell/Icons.tsx';
+import { NO_TITLE } from '../../../document-problems.ts';
 import { docId, sameDoc } from '../../types.ts';
-import { singular } from './actions.ts';
+import { discardWording, singular } from './actions.ts';
 import { openDialog } from './dialogs.tsx';
 
 export function DocMenu({ label }: { label: string }) {
@@ -54,6 +63,8 @@ export function DocMenu({ label }: { label: string }) {
 	const shared = collection.kind === 'shared';
 	const noPage = collection.urlBase === null;
 	const pending = (waiting ?? []).find((w) => w.collection === ref.collection && w.path === ref.path && w.change === 'new');
+	// Discard changes: this document is waiting to publish.
+	const waitingHere = (waiting ?? []).find((w) => w.file === entry.file) ?? null;
 	const isNew = !!pending;
 	const listed = documents.find((d) => docId(d) === docId(ref));
 	const home = sameDoc(ref, editor.site.home);
@@ -145,6 +156,25 @@ export function DocMenu({ label }: { label: string }) {
 							<hr />
 						</>
 					)}
+					{waitingHere ? (
+						<>
+							<button
+								type="button"
+								role="menuitem"
+								data-act="discard-document"
+								disabled={!!holder}
+								onClick={() => (setOpen(false), openDialog(editor, { kind: 'discard', file: waitingHere.file }))}
+							>
+								<Icon name="undo" />
+								{discardWording(waitingHere, editor.you, shared ? 'shared block' : singular(collection)).menu}
+							</button>
+							{holder ? (
+								<div className="why" data-why="discard">
+									{holder} is editing it.
+								</div>
+							) : null}
+						</>
+					) : null}
 					<button type="button" role="menuitem" className="danger" data-act="delete-document" disabled={!!why} onClick={remove}>
 						<Icon name="trash" />
 						Delete {shared ? 'shared block' : singular(collection)}…
@@ -159,3 +189,28 @@ export function DocMenu({ label }: { label: string }) {
 		</div>
 	);
 }
+
+/**
+ * The open document has no title (blanked, or read that way from its file): it's kept as it
+ * is, isn't on the site, and Publish holds it back until it has one. Renaming it gives it one.
+ */
+export function TitleNote() {
+	const editor = useEditor();
+	const untitled = useStore(editor.doc.state, (s) => s.document.title.trim() === '');
+	const readOnly = useStore(editor.access, (a) => a.readOnly);
+	if (!untitled) return null;
+	return (
+		<div className="note warn tight" role="status" data-note="no-title">
+			<Icon name="warn" />
+			<div>
+				<b>{NO_TITLE.note}</b>
+				<p>Until it has one, it isn't on the site and Publish leaves it waiting.</p>
+				<div className="acts">
+					<button type="button" className="btn sm" data-act="rename-untitled" disabled={readOnly} onClick={() => openDialog(editor, { kind: 'rename' })}>
+						Rename…
+					</button>
+				</div>
+			</div>
+		</div>
+	);
+}

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

@@ -13,7 +13,8 @@
 import { titleCase } from '../../../fields.ts';
 import { RESERVED_SLUG, slugify } from '../../../slug.ts';
 import type { Editor } from '../editor.ts';
-import { docId, ENDPOINTS, MEDIA_ENDPOINTS, TAB_HEADER, sameDoc, type CreateDeleteRefusal, type CreateRequest, type CreateResponse, type DeleteResponse, type DocRef, type MoveResponse, type EditorAnyCollection, type ListedDocument, type ReplaceFileResponse } from '../../types.ts';
+import { displayName } from '../../../live/messages.ts';
+import { docId, ENDPOINTS, MEDIA_ENDPOINTS, TAB_HEADER, sameDoc, type CreateDeleteRefusal, type CreateRequest, type CreateResponse, type DeleteResponse, type DocRef, type MoveResponse, type EditorAnyCollection, type ListedDocument, type Person, type ReplaceFileResponse, type WaitingView } from '../../types.ts';
 
 export type Refused = { ok: false; status: number; error: string; code: string | null; usedOn: CreateDeleteRefusal['usedOn'] | null };
 
@@ -274,3 +275,31 @@ export function andList(names: readonly string[]): string {
 
 /** An address part from what's typed, by the name rule (slug.ts). */
 export const partFrom = (typed: string) => slugify(typed);
+
+/**
+ * Discard changes' words (the waiting list's Discard…, the document menu's item, the
+ * confirmation), from the waiting entry: who else changed it is named ("…including Ann's?").
+ */
+export function discardWording(
+	item: Pick<WaitingView, 'title' | 'change' | 'editors' | 'movedFrom'>,
+	you: Person | null,
+	noun: string,
+): { heading: string; body: string; confirm: string; menu: string } {
+	const others = item.editors.filter((e) => !you || e.person.email.toLowerCase() !== you.email.toLowerCase()).map((e) => `${displayName(e.person)}'s`);
+	const names = others.length < 2 ? others.join('') : `${others.slice(0, -1).join(', ')} and ${others.at(-1)}`;
+	// A moved document waits as new on its new file; it's the move that goes.
+	if (item.change === 'new' && !item.movedFrom) {
+		return {
+			heading: names ? `Discard this new ${noun}, including ${names} changes?` : `Discard this new ${noun}?`,
+			body: `${item.title} isn't on the live site yet, so it's removed.`,
+			confirm: `Discard this new ${noun}`,
+			menu: `Discard this new ${noun}…`,
+		};
+	}
+	return {
+		heading: names ? `Discard the unpublished changes to ${item.title}, including ${names}?` : `Discard the unpublished changes to ${item.title}?`,
+		body: item.movedFrom ? `It goes back to ${item.movedFrom}, as it is on the live site.` : item.change === 'deleted' ? 'It comes back, as it is on the live site.' : "It goes back to what's live.",
+		confirm: 'Discard changes',
+		menu: 'Discard changes…',
+	};
+}

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

@@ -11,6 +11,7 @@
  *   openDialog(editor, { kind: 'move', ref })                       Change address… (pre-M7 item 8)
  *   openDialog(editor, { kind: 'rename' })                          Rename… on the open document
  *   openDialog(editor, { kind: 'replace', key })                    Replace… on a file (M6c G4, media/ReplaceDialog.tsx)
+ *   openDialog(editor, { kind: 'discard', file })                   Discard changes… (live mode: back to what's live)
  *
  * Esc closes the dialog only (the editor's own Esc, going up a level, doesn't run).
  * Addresses are shown before creating, made by slug.ts as the server makes them, and
@@ -28,7 +29,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, addressesMoving, andList, createDocument, deleteDocument, insideOptions, moveDocument, pagesUnder, singular } from './actions.ts';
+import { addressFor, addressesMoving, andList, createDocument, deleteDocument, discardWording, insideOptions, moveDocument, pagesUnder, singular } from './actions.ts';
 import { filesLabel, inboxFor } from '../inbox/store.ts';
 import { ReplaceDialog } from '../media/ReplaceDialog.tsx';
 
@@ -46,7 +47,9 @@ export type Dialog =
 	/** M6c G4 Decision 9: Replace… on a file in the library (its key). */
 	| { kind: 'replace'; key: string }
 	/** Arrange pages (Decision 15): leaving the screen with something arranged; `go` leaves, dropping it. */
-	| { kind: 'arrange-leave'; go: () => void };
+	| { kind: 'arrange-leave'; go: () => void }
+	/** Discard changes (live mode): a waiting document, by its file, back to what's live. */
+	| { kind: 'discard'; file: string };
 
 const dialogs = new WeakMap<Editor, Store<Dialog | null>>();
 
@@ -85,6 +88,8 @@ export function DocumentDialogs() {
 			return <ReplaceDialog key={dialog.key} fileKey={dialog.key} />;
 		case 'arrange-leave':
 			return <LeaveArrange go={dialog.go} />;
+		case 'discard':
+			return <DiscardChanges key={dialog.file} file={dialog.file} />;
 	}
 }
 
@@ -517,12 +522,14 @@ function MoveDocument({ docRef }: { docRef: DocRef }) {
  */
 function RenameDocument() {
 	const editor = useEditor();
+	const title = useStore(editor.doc.state, (s) => s.document.title);
 	const current = useStore(editor.doc.state, (s) => s.document.title || s.entry.label);
 	// Taken by someone else, signed out or deleted since the menu opened: setTitle would do nothing.
 	const readOnly = useStore(editor.access, (a) => a.readOnly);
 	const [name, setName] = useState(current);
 	const next = name.replace(/\s+/g, ' ').trim();
-	const blocked = !next || next === current || readOnly;
+	// Finding 15: a document with no title may take the name it's listed by as its title.
+	const blocked = !next || next === title || readOnly;
 	const confirm = () => {
 		if (blocked) return;
 		editor.doc.setTitle(next);
@@ -641,6 +648,57 @@ function NewShared() {
 	);
 }
 
+// ── Discard changes ──────────────────────────────────────────────────────────
+
+/**
+ * Discard changes (live mode): asks first, naming anyone else whose changes go too, then puts
+ * the document back to what's live (editor.discardChanges). The server's sentence when it
+ * refuses (someone editing it now, a Publish running). Gone from the waiting list meanwhile:
+ * it closes.
+ */
+function DiscardChanges({ file }: { file: string }) {
+	const editor = useEditor();
+	const item = useStore(editor.liveState, (s) => s.status?.waiting.find((w) => w.file === file) ?? null);
+	const you = useStore(editor.liveState, (s) => s.status?.you ?? null);
+	const [error, setError] = useState<string | null>(null);
+	const [busy, setBusy] = useState(false);
+	const [seen] = useState(item);
+	const shown = item ?? (busy ? seen : null);
+	useEffect(() => {
+		if (!shown) closeDialog(editor);
+	}, [shown, editor]);
+	if (!shown) return null;
+	const collection = editor.site.collections.find((c) => c.name === shown.collection);
+	const noun = collection?.kind === 'shared' ? 'shared block' : collection ? singular(collection) : 'page';
+	const words = discardWording(shown, you ?? editor.you, noun);
+	const confirm = async () => {
+		setBusy(true);
+		setError(null);
+		const answer = await editor.discardChanges(shown);
+		setBusy(false);
+		if (answer.ok) closeDialog(editor);
+		else setError(answer.error);
+	};
+	return (
+		<Frame alert label="discard" describedBy="dlg-d">
+			<div className="icon-h" style={{ background: 'var(--status-danger-wash)', color: 'var(--status-danger)' }}>
+				<Icon name="undo" />
+			</div>
+			<h2 id="dlg-h">{words.heading}</h2>
+			<p id="dlg-d">{words.body}</p>
+			<Err id="discard-err" text={error} />
+			<div className="acts">
+				<button type="button" className="btn" onClick={() => closeDialog(editor)}>
+					Cancel
+				</button>
+				<button type="button" className="btn danger" data-act="confirm-discard" disabled={busy} onClick={() => void confirm()}>
+					{words.confirm}
+				</button>
+			</div>
+		</Frame>
+	);
+}
+
 // ── Delete ───────────────────────────────────────────────────────────────────
 
 function DeleteDocument({ docRef }: { docRef: DocRef }) {