caracms 0.2.0 → 0.3.0

package/src/live/autosaves.ts

@@ -41,10 +41,14 @@
  * counts while its old file is gone and its new file is there (`movesIn`, git.ts).
  *
  * Paths are site-relative (`content/pages/index.json`). Values are JSON text.
+ *
+ * **The status cache** (status-cache.ts, Redis diet Decision 2): every write here of a
+ * key the status poll reads (autosaves, change records, moves) tells it what landed.
  */
 import type { AnyDocument } from '../document.ts';
 import type { Person } from './messages.ts';
 import type { RedisClient } from './redis.ts';
+import { landed, type StatusCache } from './status-cache.ts';
 import type { LiveTimings } from './timings.ts';
 
 export interface Autosave {
@@ -131,17 +135,34 @@ export class Autosaves {
 	readonly timings: LiveTimings;
 	readonly now: () => number;
 	readonly prefix: string;
+	private readonly cache: StatusCache | null;
 
-	constructor(redis: RedisClient, timings: LiveTimings, now: () => number, prefix = 'caracms:') {
+	constructor(redis: RedisClient, timings: LiveTimings, now: () => number, prefix = 'caracms:', cache: StatusCache | null = null) {
 		this.redis = redis;
 		this.timings = timings;
 		this.now = now;
 		this.prefix = prefix;
+		this.cache = cache;
 	}
 
 	key = (file: string) => `${this.prefix}autosave:${file}`;
+	/** What every autosave key starts with (the status cache scans it). */
+	get keyPrefix(): string {
+		return this.key('');
+	}
 	private committedKey = (file: string) => `${this.prefix}committed:${file}`;
-	private changedKey = (file: string) => `${this.prefix}changed:${file}`;
+	readonly changedKey = (file: string) => `${this.prefix}changed:${file}`;
+	readonly movesKey = () => movesKey(this.prefix);
+
+	/** A compare-and-swap (or delete) on an autosave key, and the status cache told what came of it. */
+	private async swap(key: string, expected: string | null, raw: string | null): Promise<boolean> {
+		const ok = await landed(this.cache, key, () =>
+			raw === null ? this.redis.compareAndDelete(key, expected!) : this.redis.compareAndSet(key, expected, raw, { px: this.timings.autosaveTtlMs }),
+		);
+		if (ok) this.cache?.string(key, raw);
+		else this.cache?.drop(key);
+		return ok;
+	}
 
 	async get(file: string): Promise<Read<Autosave> | null> {
 		const raw = await this.redis.get(this.key(file));
@@ -151,30 +172,34 @@ export class Autosaves {
 
 	/** Every autosave: one SCAN and one MGET. */
 	async all(): Promise<Read<Autosave>[]> {
-		const keys = await this.redis.scan(`${this.prefix}autosave:*`);
+		const keys = await this.redis.scan(`${this.keyPrefix}*`);
 		if (keys.length === 0) return [];
-		const raws = await this.redis.mget(keys);
+		return Autosaves.allFrom(await this.redis.mget(keys));
+	}
+
+	/** The autosaves among these values (a scan of `keyPrefix`'s, read). */
+	static allFrom(raws: Iterable<string | null>): Read<Autosave>[] {
 		const out: Read<Autosave>[] = [];
-		raws.forEach((raw) => {
+		for (const raw of raws) {
 			const value = parse<Autosave>(raw);
 			if (raw !== null && value) out.push({ raw, value });
-		});
+		}
 		return out;
 	}
 
 	/** Store it only if the autosave is still what was read (`null`: only if there's none), so a write that read an older one never replaces a newer. */
 	putIf(read: Read<Autosave> | null, autosave: Autosave): Promise<boolean> {
-		return this.redis.compareAndSet(this.key(autosave.file), read?.raw ?? null, JSON.stringify(autosave), { px: this.timings.autosaveTtlMs });
+		return this.swap(this.key(autosave.file), read?.raw ?? null, JSON.stringify(autosave));
 	}
 
 	/** Delete it only if it's still what was read (a newer write wins). */
 	removeIf(read: Read<Autosave>): Promise<boolean> {
-		return this.redis.compareAndDelete(this.key(read.value.file), read.raw);
+		return this.swap(this.key(read.value.file), read.raw, null);
 	}
 
 	/** Replace it only if it's still what was read. */
 	replaceIf(read: Read<Autosave>, next: Autosave): Promise<boolean> {
-		return this.redis.compareAndSet(this.key(next.file), read.raw, JSON.stringify(next), { px: this.timings.autosaveTtlMs });
+		return this.swap(this.key(next.file), read.raw, JSON.stringify(next));
 	}
 
 	async committed(file: string): Promise<Committed | null> {
@@ -186,7 +211,12 @@ export class Autosaves {
 	}
 
 	async changed(file: string): Promise<ChangeRecord | null> {
-		return parse<ChangeRecord>(await this.redis.get(this.changedKey(file)));
+		return Autosaves.changedFrom(await this.redis.get(this.changedKey(file)));
+	}
+
+	/** A change record from its text as read. */
+	static changedFrom(raw: string | null): ChangeRecord | null {
+		return parse<ChangeRecord>(raw);
 	}
 
 	/** Several files' records in one MGET (the documents list's "Last edited"), in the order asked; none: null. */
@@ -197,7 +227,9 @@ export class Autosaves {
 
 	/** No expiry: one small key per file, overwritten on each change, so "who changed it" is never forgotten while Redis keeps its data. */
 	async setChanged(file: string, record: ChangeRecord): Promise<void> {
-		await this.redis.set(this.changedKey(file), JSON.stringify(record));
+		const raw = JSON.stringify(record);
+		await landed(this.cache, this.changedKey(file), () => this.redis.set(this.changedKey(file), raw));
+		this.cache?.string(this.changedKey(file), raw);
 	}
 
 	/**
@@ -205,7 +237,8 @@ export class Autosaves {
 	 * from `main` leaves `{ by: null }` ("only merges"), and never overwrites an editor's.
 	 */
 	async setChangedIfAbsent(file: string, record: Omit<ChangeRecord, 'by'> & { by: Person | null }): Promise<void> {
-		await this.redis.set(this.changedKey(file), JSON.stringify(record), { nx: true });
+		const raw = JSON.stringify(record);
+		if (await landed(this.cache, this.changedKey(file), () => this.redis.set(this.changedKey(file), raw, { nx: true }))) this.cache?.string(this.changedKey(file), raw);
 	}
 
 	/** Pre-M7 item 8: the moves waiting to publish, old file → new file. */
@@ -213,6 +246,16 @@ export class Autosaves {
 		return new Map(Object.entries(await this.redis.hgetall(movesKey(this.prefix))));
 	}
 
+	private async setMove(from: string, to: string): Promise<void> {
+		await landed(this.cache, movesKey(this.prefix), () => this.redis.hset(movesKey(this.prefix), { [from]: to }));
+		this.cache?.hash(movesKey(this.prefix), { [from]: to });
+	}
+
+	private async dropMoves(...from: string[]): Promise<void> {
+		await landed(this.cache, movesKey(this.prefix), () => this.redis.hdel(movesKey(this.prefix), ...from));
+		this.cache?.hash(movesKey(this.prefix), {}, from);
+	}
+
 	/**
 	 * A document moved from `from` to `to`. Moved since the last Publish already (a record
 	 * ends at `from`): that record now ends at `to`, or goes when `to` is where it started
@@ -223,16 +266,16 @@ export class Autosaves {
 		const moves = await this.moves();
 		const earlier = [...moves].find(([, t]) => t === from)?.[0];
 		if (earlier !== undefined) {
-			if (earlier === to) await this.redis.hdel(movesKey(this.prefix), earlier);
-			else await this.redis.hset(movesKey(this.prefix), { [earlier]: to });
-		} else if (wasLive) await this.redis.hset(movesKey(this.prefix), { [from]: to });
+			if (earlier === to) await this.dropMoves(earlier);
+			else await this.setMove(earlier, to);
+		} else if (wasLive) await this.setMove(from, to);
 	}
 
 	/** A deleted document's move, if it was moved, is no move any more: it's a deletion. */
 	async forgetMoveTo(file: string): Promise<void> {
 		const moves = await this.moves();
 		const olds = [...moves].filter(([, t]) => t === file).map(([o]) => o);
-		if (olds.length) await this.redis.hdel(movesKey(this.prefix), ...olds);
+		if (olds.length) await this.dropMoves(...olds);
 	}
 
 	/** The merge's ancestor for an autosave (Decision 6). See `ancestorFor`. */

package/src/live/backend.ts

@@ -15,7 +15,7 @@
  */
 import { createHash } from 'node:crypto';
 import { gunzipSync } from 'node:zlib';
-import { GitHubClient, GraphQLError, HttpError, Tracker } from './github.ts';
+import { GitHubClient, GraphQLError, HttpError, Tracker, type GitHubAccessProblem } from './github.ts';
 
 export interface Head {
 	commit: string;
@@ -139,6 +139,8 @@ export interface GitBackend {
 	listDeployments(count: number): Promise<Deployment[]>;
 	/** A deployment's newest status, or null when it has none yet. */
 	deploymentStatus(id: number): Promise<DeploymentStatus | null>;
+	/** What's wrong with GitHub access now, from the responses so far (runs-anywhere Decision 5); null when nothing is. */
+	accessProblem(): GitHubAccessProblem | null;
 }
 
 /** Is this GraphQL error a stale head (someone moved the ref)? M1 → G6 (a): often it can't tell. */
@@ -188,6 +190,10 @@ export class GitHubBackend implements GitBackend {
 		return this.gh.tracker;
 	}
 
+	accessProblem(): GitHubAccessProblem | null {
+		return this.gh.accessProblem();
+	}
+
 	async readHeads(): Promise<Heads> {
 		const d = await this.gh.graphql<{ repository: { id: string; main: RefNode; drafts: RefNode } }>(
 			HEADS_QUERY,
@@ -411,6 +417,8 @@ export class MemoryBackend implements GitBackend {
 	deployments: MemoryDeployment[] = [];
 	/** Called before each recorded request, with its endpoint: tests inject races here. */
 	beforeRequest: ((endpoint: string) => Promise<void> | void) | null = null;
+	/** The GitHub access problem the status reports; tests set it (the GitHub client's own is tested with faked responses). */
+	access: GitHubAccessProblem | null = null;
 	private readonly now: () => number;
 	private inHook = false;
 	private blobs = new Map<string, string>();
@@ -541,6 +549,10 @@ export class MemoryBackend implements GitBackend {
 
 	// GitBackend.
 
+	accessProblem(): GitHubAccessProblem | null {
+		return this.access;
+	}
+
 	async readHeads() {
 		await this.rec('graphql readHeads', false);
 		return { main: this.head('main'), drafts: this.head('drafts') };

package/src/live/drafts-store.ts

@@ -41,7 +41,7 @@ import { parseAnyDocument } from '../document.ts';
 import type { DraftsStore } from '../editor/server/drafts-store.ts';
 import { confinePath, fileVersion, WriteRefused, writeText, type WriteContext, type WriteRequest, type WriteResponse } from '../editor/server/write.ts';
 import type { CreateResponse, DeleteResponse, LastChange, LockRefusal, MoveResponse, ReplaceFileResponse } from '../editor/types.ts';
-import type { Autosave, Autosaves, Read } from './autosaves.ts';
+import type { Autosave, Autosaves, ChangeRecord, Read } from './autosaves.ts';
 import { titleOf, type LiveGit } from './git.ts';
 import type { LockRecord, Locks } from './locks.ts';
 import { displayName, type Person } from './messages.ts';
@@ -79,8 +79,9 @@ export function unavailable(error: unknown): WriteRefused {
  * expire, so a file with none was never changed in the editor or Redis lost its data, and
  * the server can't tell which: the keeper holds edits on unknown rather than re-send them.
  */
-export async function lastChangeOf(parts: Pick<LiveStoreParts, 'git' | 'autosaves'>, file: string): Promise<LastChange> {
-	const record = await parts.autosaves.changed(file);
+/** `known`: the file's change record as the caller already read it (the status poll's cache); otherwise read here. */
+export async function lastChangeOf(parts: Pick<LiveStoreParts, 'git' | 'autosaves'>, file: string, known?: ChangeRecord | null): Promise<LastChange> {
+	const record = known !== undefined ? known : await parts.autosaves.changed(file);
 	if (record) return { by: record.by, version: record.version, at: record.at };
 	const editor = parts.git.waiting().find((w) => w.file === file)?.editors[0];
 	return editor ? { by: editor.person, version: null, at: editor.at } : { by: null, version: null, at: null, known: false };

package/src/live/editor.ts

@@ -15,6 +15,11 @@
  * **A poll asks GitHub for nothing** beyond `git.check()` (once a minute) and the
  * deployment reads while a publish is in flight (git.ts, every 10 s at most).
  *
+ * **A poll asks Redis for little** (Redis diet): its reads come from the status cache
+ * (status-cache.ts, `git.statusCache`), refreshed from Redis once 30 s old; it writes
+ * only its presence, and a heartbeat when the lock needs one. The other handlers read
+ * Redis directly (Decision 3).
+ *
  * 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.
  */
@@ -39,17 +44,27 @@ import type {
 } from '../editor/types.ts';
 import { Autosaves } from './autosaves.ts';
 import { lastChangeOf, liveDraftsStore, unavailable } from './drafts-store.ts';
-import { movesIn, titleOf } from './git.ts';
+import { LiveGit, movesIn, NO_REDEPLOYER_REASON, titleOf } from './git.ts';
+import { accessProblemMessage, type GitHubAccessProblem } from './github.ts';
 import { parseRedirects, type Redirect } from '../redirects.ts';
 import { Locks } from './locks.ts';
 import { displayName, type Person } from './messages.ts';
 import type { LiveSettings } from './mode.ts';
+import { Notices, type StoodNotice } from './notices.ts';
 import { RedisUnavailableError } from './redis.ts';
 import { liveRuntime, type LiveRuntime } from './runtime.ts';
 import { Sweep, type Schedule } from './sweep.ts';
 
 type Handler = (request: Request, person: Person | null) => Promise<Response>;
 
+
+/** The heading of the editor's GitHub access note (runs-anywhere Decision 5); the sentence says what to fix. */
+const ACCESS_TITLE: Record<GitHubAccessProblem['kind'], string> = {
+	refused: 'GitHub refused this site',
+	permission: 'GitHub refused a change',
+	expiring: "This site's GitHub token expires soon",
+};
+
 export interface LiveEditor {
 	readonly runtime: Pick<LiveRuntime, 'site' | 'settings' | 'git' | 'redis' | 'timings' | 'now'>;
 	readonly autosaves: Autosaves;
@@ -84,15 +99,6 @@ const sameEmail = (a: Person, b: Person) => a.email.toLowerCase() === b.email.to
 const NOTICE_ID = /^(kept|stood):[^\s\p{C}]+$/u;
 const NOTICE_ID_MAX = 512;
 
-interface StoodNotice {
-	id: string;
-	for: string;
-	file: string;
-	title: string;
-	by: Person;
-	at: string;
-}
-
 /** Map a site file to its document (collection and path), or nulls. */
 /** Site Settings' redirects, from its text (none when it's missing or unreadable). */
 function redirectsIn(text: string | null): Redirect[] {
@@ -120,8 +126,11 @@ export async function createLiveEditor(
 	const sleep = options.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
 	const prefix = options.prefix ?? 'caracms:';
 	const log = options.log ?? ((line: string) => console.log(`[caracms] ${line}`));
-	const autosaves = new Autosaves(redis, timings, now, prefix);
-	const locks = new Locks(redis, timings, now, async (file) => (await autosaves.get(file)) !== null, prefix);
+	// Redis diet Decision 2: every module that writes what the status poll reads tells its cache.
+	const cache = git.statusCache;
+	const autosaves = new Autosaves(redis, timings, now, prefix, cache);
+	const locks = new Locks(redis, timings, now, async (file) => (await autosaves.get(file)) !== null, prefix, cache);
+	const noticeStore = new Notices(redis, timings, prefix, cache);
 	const sweep = new Sweep({ redis, git, autosaves, locks, timings, now, schedule: options.schedule, sleep: options.sleep, log, prefix });
 	const store = liveDraftsStore({ site, git, autosaves, locks, sweep, now });
 	// Publish's step 1 and Decision 8's "commit every pending autosave first".
@@ -139,12 +148,6 @@ export async function createLiveEditor(
 	// hook above in place, so a merge from main commits every pending autosave first.
 	await git.check({ force: true }).catch((error: unknown) => log(`check at startup: ${error instanceof Error ? error.message : String(error)}`));
 
-	const keys = {
-		publishLock: `${prefix}publish:lock`,
-		dismissed: `${prefix}dismissed`,
-		notices: `${prefix}notices`,
-	};
-
 	/** Common gate: a person, the same origin for anything but GET, Redis outages as 503. */
 	const handler =
 		(methods: string[], fn: (request: Request, person: Person) => Promise<Response>): Handler =>
@@ -204,36 +207,22 @@ export async function createLiveEditor(
 		return list;
 	};
 
-	const publishView = async (): Promise<PublishView> => {
-		const running = (await redis.get(keys.publishLock)) !== null;
+	/** `read`: the Publish lock and record as the status poll's cache has them; otherwise read from Redis. */
+	const publishView = async (read?: { running: boolean; record: PublishView['record'] }): Promise<PublishView> => {
+		const running = read ? read.running : (await redis.get(git.publishLockKey)) !== null;
 		let st;
 		try {
-			st = await git.publishStatus();
+			st = await git.publishStatus(read ? { record: read.record } : {});
 		} catch (error) {
 			log(`publish status: ${error instanceof Error ? error.message : String(error)}`);
-			const record = await git.lastPublish();
+			const record = read ? read.record : await git.lastPublish();
 			st = { state: record ? ('publishing' as const) : ('none' as const), record, assumed: false, canTryAgain: false };
 		}
-		return { state: st.state, running, record: st.record, assumed: st.assumed, canTryAgain: st.canTryAgain, hasToken: settings.railway !== null };
+		return { state: st.state, running, record: st.record, assumed: st.assumed, canTryAgain: st.canTryAgain, hasRedeployer: Boolean(settings.deployHook) || settings.railway !== null };
 	};
 
-	const notices = async (person: Person): Promise<NoticeView[]> => {
-		const dismissed = new Set(await redis.smembers(keys.dismissed));
-		const out: NoticeView[] = [];
-		for (const n of git.keptDraftNotices()) {
-			const id = `kept:${n.file}:${n.commit}`;
-			if (!dismissed.has(id)) out.push({ id, kind: 'draft-kept', file: n.file, title: git.titleFor(n.file) });
-		}
-		for (const raw of Object.values(await redis.hgetall(keys.notices))) {
-			try {
-				const n = JSON.parse(raw) as StoodNotice;
-				if (n.for === person.email.toLowerCase()) out.push({ id: n.id, kind: 'published-as-it-stood', file: n.file, title: n.title, by: n.by, at: n.at });
-			} catch {
-				/* skip */
-			}
-		}
-		return out;
-	};
+	const titleFor = (file: string) => git.titleFor(file);
+	const notices = (person: Person): Promise<NoticeView[]> => noticeStore.of(person, git.keptDraftNotices(), titleFor);
 
 	// The write route: M3's handler over the live store, which answers 401 with no person.
 	const write: Handler = (request, person) => handleWrite(request, store, { person });
@@ -256,19 +245,36 @@ export async function createLiveEditor(
 		// so it lapses by itself (Take over, 2026-10-15). A tab that doesn't say is treated as active.
 		const input = Number(url.searchParams.get('input'));
 		const active = !url.searchParams.has('input') || !(input >= timings.lockIdleMs);
+		// Redis diet Contracts: `interval` is how long until the tab's next poll, which its
+		// presence holds by (Decision 9). None, or not a number: a 5-second tab (an old page).
+		const every = Number(url.searchParams.get('interval'));
+		const interval = Number.isFinite(every) && every > 0 ? Math.min(every, Math.max(timings.pollMs, timings.slowPollMs)) : timings.pollMs;
+
+		// Every read from the status cache (Decision 1): memory, or Redis once 30 s old.
+		const snap = await cache.read({
+			scans: [autosaves.keyPrefix, locks.keyPrefix],
+			hashes: [locks.presenceKey(), autosaves.movesKey(), noticeStore.noticesKey],
+			sets: [noticeStore.dismissedKey],
+			strings: [git.publishLockKey, git.publishRecordKey, ...(file ? [autosaves.changedKey(file)] : [])],
+		});
 		if (tab) {
-			await locks.present(tab, person, file);
-			if (file && active) await locks.beat(file, tab, person);
+			await locks.present(tab, person, file, interval);
+			// Decision 6: a beat only when the lock (as cached) is this tab's and needs one.
+			if (file && active) {
+				const cached = locks.allFrom(snap.scan(locks.keyPrefix)).get(file) ?? null;
+				if (locks.needsBeat(cached, tab, person)) await locks.beat(file, tab, person, cached);
+			}
 		}
 		// Decision 8's check, throttled to once a minute and shared inside git.ts. Started, not
 		// awaited: the poll answers with what's known, and never waits on GitHub.
 		void git.check().catch((error: unknown) => log(`check: ${error instanceof Error ? error.message : String(error)}`));
 
-		const saves = (await autosaves.all()).map((r) => r.value);
+		// From the snapshot after this poll's own writes landed in it (its presence, its beat).
+		const saves = Autosaves.allFrom(snap.scan(autosaves.keyPrefix).values()).map((r) => r.value);
 		if (saves.length) sweep.poke(); // they may have come in on the other server during a deploy
 		const pending = new Set(saves.map((a) => a.file));
-		const presence = await locks.presence();
-		const lockViews = [...(await locks.all())]
+		const presence = await locks.presenceFrom(snap.hash(locks.presenceKey()));
+		const lockViews = [...locks.allFrom(snap.scan(locks.keyPrefix))]
 			.filter(([f, r]) => locks.holds(r.lock, pending.has(f)))
 			.map(([f, r]) => locks.view(f, r.lock, tab, person));
 
@@ -315,7 +321,7 @@ export async function createLiveEditor(
 		// Pre-M7 item 8: a moved document is one entry, on its new file, with its old address.
 		// Read from the moves as recorded, not Site Settings' redirects: removing the redirect leaves it a move.
 		const readNow = (f: string) => (textNow.has(f) ? (textNow.get(f) ?? null) : git.read(f));
-		const moves = movesIn(site, [...waiting.keys()], readNow, await autosaves.moves());
+		const moves = movesIn(site, [...waiting.keys()], readNow, new Map(snap.hash(autosaves.movesKey())));
 		const redirects = moves.from.size ? redirectsIn(readNow(SITE_SETTINGS_FILE)) : [];
 		for (const [file, from] of moves.from) {
 			const w = waiting.get(file)!;
@@ -330,12 +336,14 @@ export async function createLiveEditor(
 			const lock = lockViews.find((l) => l.file === file) ?? null;
 			// M5a Decision 12: a viewer learns the document was deleted, and by whom, on this poll.
 			let deleted: NonNullable<StatusResponse['open']>['deleted'] = null;
-			if (!(await exists(file))) {
-				const record = await autosaves.changed(file);
+			const save = saves.find((a) => a.file === file);
+			const record = Autosaves.changedFrom(snap.string(autosaves.changedKey(file)));
+			if (save ? save.gone : git.read(file) === null) {
 				deleted = record?.gone ? { by: record.by, at: record.at } : { by: null, at: null };
 			}
-			open = { file, state: Locks.state(lock), lock, lastChange: await lastChangeOf({ git, autosaves }, file), deleted };
+			open = { file, state: Locks.state(lock), lock, lastChange: await lastChangeOf({ git, autosaves }, file, record), deleted };
 		}
+		const access = git.backend.accessProblem();
 		const body: StatusResponse = {
 			mode: 'live',
 			you: person,
@@ -346,8 +354,10 @@ export async function createLiveEditor(
 			waiting: list,
 			locks: lockViews,
 			presence,
-			notices: await notices(person),
-			publish: await publishView(),
+			notices: Notices.forPerson(person, git.keptDraftNotices(), titleFor, snap.set(noticeStore.dismissedKey), snap.hash(noticeStore.noticesKey).values()),
+			publish: await publishView({ running: snap.string(git.publishLockKey) !== null, record: LiveGit.publishRecordFrom(snap.string(git.publishRecordKey)) }),
+			// Runs-anywhere Decision 5: while it holds, not dismissable.
+			githubAccess: access ? { kind: access.kind, title: ACCESS_TITLE[access.kind], message: accessProblemMessage(access) } : null,
 			// M5a Decision 10: from the committed copy, never an autosave.
 			brand: editorBrand(brandFrom(git.read(SITE_SETTINGS_FILE), site)),
 		};
@@ -395,28 +405,44 @@ export async function createLiveEditor(
 
 	const publish = handler(['POST'], async (_request, person) => {
 		const before = await locks.presence();
-		const result = await git.publish(person);
+		const work = git.publish(person).then(async (result) => {
+			await stoodNotices(result, before, person);
+			return result;
+		});
+		// Runs-anywhere (Watch-outs): Cloudflare gives up on an answer after 100 s, and a
+		// Publish whose GitHub calls are slow can take longer. Past `publishAnswerMs` the
+		// request answers "joined" with the status (the Publish lock shows it running) and
+		// the Publish carries on; the panel follows it on the poll.
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		const late = new Promise<null>((resolve) => {
+			timer = setTimeout(() => resolve(null), timings.publishAnswerMs);
+		});
+		const result = await Promise.race([work, late]).finally(() => clearTimeout(timer));
+		if (result === null) {
+			work.catch((error: unknown) => log(`publish (answered early): ${error instanceof Error ? error.message : String(error)}`));
+			return json(200, { result: 'joined', publish: await publishView() } satisfies PublishResponse);
+		}
+		return json(200, { result: result.kind, publish: await publishView() } satisfies PublishResponse);
+	});
+
+	/** "Aoife published Home as it stood at 14:20" for whoever had a published document open (Decision 10 step 1). */
+	const stoodNotices = async (result: Awaited<ReturnType<typeof git.publish>>, before: Awaited<ReturnType<typeof locks.presence>>, person: Person) => {
 		if (result.kind === 'published') {
 			// "Aoife published Home as it stood at 14:20" for whoever had a published document open (Decision 10 step 1).
 			const { record } = result;
-			const fields: Record<string, string> = {};
+			const stood: StoodNotice[] = [];
 			for (const p of before) {
 				const i = record.files.indexOf(p.file);
 				if (i === -1) continue;
 				for (const someone of p.people) {
 					if (sameEmail(someone, person)) continue;
 					const id = `stood:${record.commit}:${p.file}:${someone.email.toLowerCase()}`;
-					const notice: StoodNotice = { id, for: someone.email.toLowerCase(), file: p.file, title: result.fileTitles[i] ?? titleOf(p.file, null), by: person, at: record.at };
-					fields[id] = JSON.stringify(notice);
+					stood.push({ id, for: someone.email.toLowerCase(), file: p.file, title: result.fileTitles[i] ?? titleOf(p.file, null), by: person, at: record.at });
 				}
 			}
-			if (Object.keys(fields).length) {
-				await redis.hset(keys.notices, fields);
-				await redis.pexpire(keys.notices, timings.autosaveTtlMs);
-			}
+			await noticeStore.addStood(stood);
 		}
-		return json(200, { result: result.kind, publish: await publishView() } satisfies PublishResponse);
-	});
+	};
 
 	const history = handler(['GET'], async () => {
 		const entries = await git.history({ refresh: true });
@@ -424,9 +450,10 @@ export async function createLiveEditor(
 	});
 
 	const tryAgain = handler(['POST'], async () => {
-		if (!settings.railway) return json(409, { ok: false, error: 'No CARACMS_RAILWAY_TOKEN: a developer can redeploy from Railway.' } satisfies TryAgainResponse);
+		if (!settings.deployHook && !settings.railway) return json(409, { ok: false, error: NO_REDEPLOYER_REASON } satisfies TryAgainResponse);
 		const st = await publishView();
-		if (st.state !== 'failed') return json(409, { ok: false, error: 'The last publish hasn\'t failed, so there\'s nothing to try again.' } satisfies TryAgainResponse);
+		// Runs-anywhere Decision 10: taking longer than usual offers it too. One click, one call (the editor's button waits for the answer).
+		if (st.state !== 'failed' && st.state !== 'slow') return json(409, { ok: false, error: 'The last publish hasn\'t failed, so there\'s nothing to try again.' } satisfies TryAgainResponse);
 		const r = await git.tryAgain();
 		return r.ok ? json(200, { ok: true } satisfies TryAgainResponse) : json(502, { ok: false, error: r.reason } satisfies TryAgainResponse);
 	});
@@ -439,10 +466,8 @@ export async function createLiveEditor(
 		if (typeof id !== 'string' || id.length > NOTICE_ID_MAX || !NOTICE_ID.test(id)) throw new WriteRefused(400, '"id" must be a notice\'s id.');
 		const shown = (await notices(person)).find((n) => n.id === id);
 		if (!shown) throw new WriteRefused(404, 'There\'s no such notice for you to dismiss.');
-		if (shown.kind === 'draft-kept') {
-			await redis.sadd(keys.dismissed, id);
-			await redis.pexpire(keys.dismissed, timings.autosaveTtlMs);
-		} else await redis.hdel(keys.notices, id);
+		if (shown.kind === 'draft-kept') await noticeStore.dismiss(id);
+		else await noticeStore.remove(id);
 		return json(200, { ok: true });
 	});