emdash 0.28.1 → 0.30.0

package/src/cli/commands/media.ts

@@ -10,9 +10,12 @@ import { basename } from "node:path";
 import { defineCommand } from "citty";
 import { consola } from "consola";
 
+import type { MediaUsageRepairInput, MediaUsageRepairResponse } from "../../client/index.js";
 import { connectionArgs, createClientFromArgs } from "../client-factory.js";
 import { configureOutputMode, output } from "../output.js";
 
+const repairScopeError = "Specify exactly one of --collection or --all";
+
 const listCommand = defineCommand({
 	meta: {
 		name: "list",
@@ -155,6 +158,129 @@ const deleteCommand = defineCommand({
 	},
 });
 
+const repairUsageCommand = defineCommand({
+	meta: {
+		name: "repair-usage",
+		description:
+			"Repair content media usage indexes. partial/stale exit 0; automation should use --json and parse status.",
+	},
+	args: {
+		...connectionArgs,
+		collection: {
+			type: "string",
+			alias: "c",
+			description: "Repair one content collection",
+		},
+		all: {
+			type: "boolean",
+			description: "Repair every content collection",
+		},
+	},
+	async run({ args }) {
+		configureOutputMode(args);
+
+		const hasCollectionArg = args.collection !== undefined;
+		const hasCollection = typeof args.collection === "string";
+		const hasAll = args.all === true;
+		if ((hasCollectionArg && !hasCollection) || hasCollection === hasAll) {
+			consola.error(repairScopeError);
+			process.exit(1);
+		}
+
+		const client = createClientFromArgs(args);
+
+		try {
+			const repairInput: MediaUsageRepairInput = hasCollection
+				? { scope: "collection", collection: args.collection }
+				: { scope: "all" };
+			const result = await client.mediaRepairUsage(repairInput);
+
+			if (args.json || !process.stdout.isTTY) {
+				output(result, args);
+			} else {
+				printRepairUsageSummary(result, repairInput);
+			}
+
+			if (result.status === "failed") {
+				process.exitCode = 1;
+			}
+		} catch (error) {
+			consola.error(
+				"Failed to repair media usage:",
+				error instanceof Error ? error.message : error,
+			);
+			process.exit(1);
+		}
+	},
+});
+
+type RepairUsageSummary = {
+	level: "success" | "warn";
+	message: string;
+};
+
+export function formatRepairUsageSummary(
+	result: MediaUsageRepairResponse,
+	input: MediaUsageRepairInput,
+): RepairUsageSummary {
+	const counts = `indexed ${result.indexedSourceCount}, failed ${result.failedSourceCount}, skipped ${result.skippedSourceCount}, deleted ${result.deletedSourceCount}`;
+	const scope =
+		input.scope === "collection"
+			? `collection ${input.collection}`
+			: `all content (${formatCollectionCount(result.collections.length)})`;
+
+	if (result.status === "complete") {
+		return {
+			level: "success",
+			message: `Media usage repair complete for ${scope} (${counts}).`,
+		};
+	}
+
+	const details = result.collections
+		.filter((collection) => collection.status !== "complete")
+		.map((collection) => {
+			const error = collection.lastErrorCode ? `, ${collection.lastErrorCode}` : "";
+			return `${collection.collection}: ${collection.status}${error}`;
+		})
+		.join("; ");
+	const suffix = details ? ` ${details}.` : "";
+
+	if (result.status === "stale") {
+		return {
+			level: "warn",
+			message: `Media usage repair is stale for ${scope}; trustworthy complete coverage was not established because another writer, repair, or stale marker won the race. Rerun when writes are quiet (${counts}).${suffix}`,
+		};
+	}
+
+	if (result.status === "partial") {
+		return {
+			level: "warn",
+			message: `Media usage repair is partial for ${scope}; some sources or collections need attention (${counts}).${suffix}`,
+		};
+	}
+
+	return {
+		level: "warn",
+		message: `Media usage repair failed for ${scope} (${counts}).${suffix}`,
+	};
+}
+
+function printRepairUsageSummary(
+	result: MediaUsageRepairResponse,
+	input: MediaUsageRepairInput,
+): void {
+	const summary = formatRepairUsageSummary(result, input);
+	if (summary.level === "success") {
+		consola.success(summary.message);
+	} else {
+		consola.warn(summary.message);
+	}
+}
+
+function formatCollectionCount(count: number): string {
+	return `${count} collection${count === 1 ? "" : "s"}`;
+}
+
 export const mediaCommand = defineCommand({
 	meta: {
 		name: "media",
@@ -165,5 +291,6 @@ export const mediaCommand = defineCommand({
 		upload: uploadCommand,
 		get: getCommand,
 		delete: deleteCommand,
+		"repair-usage": repairUsageCommand,
 	},
 });

package/src/client/index.ts

@@ -127,6 +127,62 @@ export interface Field {
 	sortOrder?: number;
 }
 
+/** Aggregate trust state for media usage reads */
+export type MediaUsageCoverageStatus =
+	| "complete"
+	| "never"
+	| "running"
+	| "partial"
+	| "failed"
+	| "stale"
+	| "unknown";
+
+/** Aggregate media usage coverage across all content collections */
+export interface MediaUsageCoverage {
+	scope: "all_content_collections";
+	status: MediaUsageCoverageStatus;
+}
+
+/** Coverage-aware usage count for a media item */
+export interface MediaUsageSummary {
+	count: number | null;
+	coverage: MediaUsageCoverage;
+}
+
+/** One indexed media reference within a content source */
+export interface MediaUsageOccurrenceDetail {
+	fieldSlug: string;
+	fieldPath: string;
+	occurrenceIndex: number;
+	referenceType: "image_field" | "file_field" | "portable_text_image" | "unknown";
+}
+
+/** Indexed references from one visible content source */
+export interface MediaUsageSourceDetail {
+	variant: "columns" | "draft_overlay";
+	occurrences: MediaUsageOccurrenceDetail[];
+}
+
+/** One content entry that references a media item */
+export interface MediaUsageEntryDetail {
+	collection: string;
+	contentId: string;
+	title: string | null;
+	slug: string | null;
+	locale: string | null;
+	status: string | null;
+	scheduledAt: string | null;
+	deletedAt: string | null;
+	sources: MediaUsageSourceDetail[];
+}
+
+/** Entry-grouped media usage details */
+export interface MediaUsageDetailsResponse {
+	items: MediaUsageEntryDetail[];
+	nextCursor?: string;
+	coverage: MediaUsageCoverage;
+}
+
 /** Media item */
 export interface MediaItem {
 	id: string;
@@ -140,6 +196,36 @@ export interface MediaItem {
 	caption?: string;
 	createdAt: string;
 	updatedAt: string;
+	usage?: MediaUsageSummary;
+}
+
+/** Media usage repair request */
+export type MediaUsageRepairInput = { scope: "collection"; collection: string } | { scope: "all" };
+
+/** Media usage repair status */
+export type MediaUsageRepairStatus = "complete" | "partial" | "failed" | "stale";
+
+/** Per-collection media usage repair summary */
+export interface MediaUsageRepairCollectionSummary {
+	collection: string;
+	status: MediaUsageRepairStatus;
+	indexedSourceCount: number;
+	failedSourceCount: number;
+	skippedSourceCount: number;
+	deletedSourceCount: number;
+	lastErrorCode: string | null;
+	startedAt: string;
+	completedAt: string | null;
+}
+
+/** Media usage repair response */
+export interface MediaUsageRepairResponse {
+	status: MediaUsageRepairStatus;
+	indexedSourceCount: number;
+	failedSourceCount: number;
+	skippedSourceCount: number;
+	deletedSourceCount: number;
+	collections: MediaUsageRepairCollectionSummary[];
 }
 
 /** Search result */
@@ -649,22 +735,47 @@ export class EmDashClient {
 		mimeType?: string;
 		limit?: number;
 		cursor?: string;
+		includeUsage?: boolean;
 	}): Promise<ListResult<MediaItem>> {
 		const params = new URLSearchParams();
 		if (options?.mimeType) params.set("mimeType", options.mimeType);
 		if (options?.limit) params.set("limit", String(options.limit));
 		if (options?.cursor) params.set("cursor", options.cursor);
+		if (options?.includeUsage === true) params.set("includeUsage", "1");
 
 		const qs = params.toString();
 		return this.request<ListResult<MediaItem>>("GET", `/media${qs ? `?${qs}` : ""}`);
 	}
 
 	/** Get a single media item */
-	async mediaGet(id: string): Promise<MediaItem> {
-		const data = await this.request<{ item: MediaItem }>("GET", `/media/${encodeURIComponent(id)}`);
+	async mediaGet(id: string, options?: { includeUsage?: boolean }): Promise<MediaItem> {
+		const params = new URLSearchParams();
+		if (options?.includeUsage === true) params.set("includeUsage", "1");
+
+		const qs = params.toString();
+		const data = await this.request<{ item: MediaItem }>(
+			"GET",
+			`/media/${encodeURIComponent(id)}${qs ? `?${qs}` : ""}`,
+		);
 		return data.item;
 	}
 
+	/** Get entry-grouped usage details for a media item */
+	async mediaGetUsage(
+		id: string,
+		options?: { limit?: number; cursor?: string },
+	): Promise<MediaUsageDetailsResponse> {
+		const params = new URLSearchParams();
+		if (options?.limit !== undefined) params.set("limit", String(options.limit));
+		if (options?.cursor !== undefined) params.set("cursor", options.cursor);
+
+		const qs = params.toString();
+		return this.request<MediaUsageDetailsResponse>(
+			"GET",
+			`/media/${encodeURIComponent(id)}/usage${qs ? `?${qs}` : ""}`,
+		);
+	}
+
 	/** Upload a media file */
 	async mediaUpload(
 		file: Uint8Array | Blob,
@@ -702,6 +813,11 @@ export class EmDashClient {
 		await this.request<unknown>("DELETE", `/media/${encodeURIComponent(id)}`);
 	}
 
+	/** Repair content media usage indexes for one collection or all collections */
+	async mediaRepairUsage(input: MediaUsageRepairInput): Promise<MediaUsageRepairResponse> {
+		return this.request<MediaUsageRepairResponse>("POST", "/admin/media-usage/repair", input);
+	}
+
 	// -----------------------------------------------------------------------
 	// Search
 	// -----------------------------------------------------------------------
@@ -846,6 +962,11 @@ export class EmDashClient {
 	}
 }
 
+type _AssertTrue<T extends true> = T;
+type _MediaRepairUsageRequiresExplicitInput = _AssertTrue<
+	Parameters<EmDashClient["mediaRepairUsage"]> extends [MediaUsageRepairInput] ? true : false
+>;
+
 // Re-export transport types for interceptor authors
 export type { Interceptor } from "./transport.js";
 export {

package/src/client/transport.ts

@@ -163,7 +163,7 @@ export function refreshInterceptor(options: {
 
 		const json = (await res.json()) as Record<string, unknown>;
 
-		// The token endpoint wraps the response in { data: ... } via apiSuccess.
+		// The token endpoint wraps the response in { success, data: ... } via apiSuccess.
 		// Handle both wrapped and bare shapes for robustness.
 		const tokenData: TokenFields =
 			json.data && typeof json.data === "object" && "access_token" in json.data

package/src/comments/service.ts

@@ -135,7 +135,7 @@ export async function createComment(
 		authorEmail: event.comment.authorEmail,
 		authorUserId: event.comment.authorUserId,
 		body: event.comment.body,
-		status: decision.status as CommentStatus,
+		status: decision.status,
 		ipHash: event.comment.ipHash,
 		userAgent: event.comment.userAgent,
 		moderationMetadata: Object.keys(event.metadata).length > 0 ? event.metadata : null,

package/src/comments/turnstile.ts

@@ -0,0 +1,64 @@
+/**
+ * Server-side Turnstile verification for public comment submissions.
+ *
+ * The comment form widget (`CommentForm.astro`) submits a `turnstileToken`;
+ * this verifies it against Cloudflare's siteverify API. Enforcement is
+ * opt-in: it only runs when the operator configures the Turnstile secret
+ * key (`EMDASH_TURNSTILE_SECRET_KEY` or `TURNSTILE_SECRET_KEY`), so
+ * existing non-Turnstile sites are unaffected.
+ *
+ * Mirrors `verifyTurnstile` in `@emdash-cms/plugin-forms` (not imported —
+ * core doesn't depend on plugin packages).
+ */
+
+const SITEVERIFY_URL = "https://challenges.cloudflare.com/turnstile/v0/siteverify";
+
+/**
+ * Resolve the configured Turnstile secret key, or `""` when Turnstile
+ * enforcement is not configured.
+ */
+export function getTurnstileSecretKey(): string {
+	return import.meta.env.EMDASH_TURNSTILE_SECRET_KEY || import.meta.env.TURNSTILE_SECRET_KEY || "";
+}
+
+/**
+ * Verify a Turnstile response token via siteverify.
+ *
+ * Fails closed: a missing token, a failed verification, and a siteverify
+ * transport error all return `false` — when the operator has configured a
+ * secret, an unverifiable submission must not be persisted.
+ */
+export async function verifyTurnstileToken(
+	token: string | undefined,
+	secretKey: string,
+	remoteIp?: string | null,
+): Promise<boolean> {
+	if (!token) return false;
+
+	const body: Record<string, string> = { secret: secretKey, response: token };
+	if (remoteIp) {
+		body.remoteip = remoteIp;
+	}
+
+	try {
+		const res = await fetch(SITEVERIFY_URL, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body),
+			// Fail closed *quickly* if siteverify is slow — without a timeout
+			// the comment POST would hang until the runtime kills it
+			signal: AbortSignal.timeout(10_000),
+		});
+		const data: { success?: boolean; "error-codes"?: string[] } = await res.json();
+		if (!data.success) {
+			console.warn("[comments] Turnstile verification failed:", data["error-codes"] ?? []);
+		}
+		return data.success === true;
+	} catch (error) {
+		console.error(
+			"[comments] Turnstile siteverify request failed:",
+			error instanceof Error ? error.message : error,
+		);
+		return false;
+	}
+}

package/src/components/BlockquoteGroup.astro

@@ -0,0 +1,34 @@
+---
+/**
+ * Renders a run of consecutive `style: "blockquote"` Portable Text blocks
+ * as ONE `<blockquote>` with a paragraph per block.
+ *
+ * Portable Text is flat, so a multi-paragraph quote is stored as
+ * consecutive blockquote-styled blocks; rendering each as its own
+ * `<blockquote>` split single quotes into disconnected fragments (#1884).
+ * The grouping itself happens in `portable-text-blockquote-group.ts`,
+ * applied by the `PortableText` wrapper.
+ */
+import { PortableText } from "astro-portabletext";
+
+import type { BlockquoteGroupNode } from "./portable-text-blockquote-group.js";
+import Block from "./Block.astro";
+import { emdashMarkComponents } from "./marks.js";
+
+export interface Props {
+	node: BlockquoteGroupNode;
+}
+
+const { node } = Astro.props;
+
+// Restyle the quoted blocks as "normal" so each renders as a <p> inside
+// the shared <blockquote> (and doesn't re-trigger blockquote handling).
+const paragraphs = (node?.blocks ?? []).map((block) => ({ ...block, style: "normal" }));
+---
+
+<blockquote>
+	<PortableText
+		value={paragraphs}
+		components={{ block: Block, mark: emdashMarkComponents }}
+	/>
+</blockquote>

package/src/components/CommentForm.astro

@@ -22,7 +22,12 @@ interface Props {
 	contentId: string;
 	parentId?: string | null;
 	class?: string;
-	/** Turnstile site key. If provided, the widget is rendered. */
+	/**
+	 * Turnstile site key. If provided, the widget is rendered and its
+	 * token is submitted. Set the matching secret key on the server
+	 * (EMDASH_TURNSTILE_SECRET_KEY) so submissions are actually verified —
+	 * without it the token is ignored.
+	 */
 	turnstileSiteKey?: string;
 }
 
@@ -182,10 +187,6 @@ const endpoint = `/_emdash/api/comments/${encodeURIComponent(collection)}/${enco
 					"textarea[name='body']"
 				);
 				if (textarea) textarea.value = "";
-				// Reset Turnstile if present
-				if (typeof window.turnstile !== "undefined") {
-					window.turnstile.reset();
-				}
 			} else {
 				statusEl.textContent =
 					result.error?.message ||
@@ -197,6 +198,12 @@ const endpoint = `/_emdash/api/comments/${encodeURIComponent(collection)}/${enco
 			statusEl.textContent = "Network error. Please try again.";
 			statusEl.classList.add("ec-comment-form-error");
 		} finally {
+			// Reset Turnstile on success and failure alike (incl. network
+			// errors) — tokens are single-use, so any retry needs a fresh
+			// challenge
+			if (typeof window.turnstile !== "undefined") {
+				window.turnstile.reset();
+			}
 			submitBtn.disabled = false;
 			submitBtn.textContent = "Post Comment";
 		}

package/src/components/EmDashHead.astro

@@ -17,8 +17,10 @@
  * ```
  */
 import type { PublicPageContext, PageMetadataContribution } from "../plugins/types.js";
+// @ts-ignore - virtual module
+import virtualConfig from "virtual:emdash/config";
 import {
-	createSha256CspHash,
+	registerJsonLdCspHashes,
 	resolvePageMetadata,
 	renderPageMetadata,
 	type ResolvedPageMetadata,
@@ -33,6 +35,8 @@ import { renderSiteIdentity } from "../page/site-identity.js";
 import { getPageRuntime } from "../page/index.js";
 import { getSiteSettings } from "../settings/index.js";
 import { absolutizeMediaUrl } from "../page/absolute-url.js";
+import { getHreflangAlternates } from "../seo/hreflang.js";
+import { isI18nEnabled } from "../i18n/config.js";
 
 interface Props {
 	page: PublicPageContext;
@@ -83,8 +87,32 @@ if (runtime) {
 		defaultOgImage,
 	);
 
+	// hreflang alternates for translated content entries (#1690). Only
+	// queried when i18n is enabled and this page renders a content entry;
+	// non-i18n sites skip this entirely. Contributions sit with the base
+	// layer, so plugins can override individual hreflang entries (dedup
+	// key is the hreflang value).
+	let hreflangContributions: PageMetadataContribution[] = [];
+	if (page.content && isI18nEnabled()) {
+		const siteUrl = page.siteUrl || siteSettings.url || new URL(page.url).origin;
+		const alternates = await getHreflangAlternates(page.content.collection, page.content.id, {
+			siteUrl,
+		});
+		hreflangContributions = alternates.map((a) => ({
+			kind: "link",
+			rel: "alternate",
+			href: a.href,
+			hreflang: a.hreflang,
+		}));
+	}
+
 	const siteContributions = generateSiteSeoContributions(siteSettings.seo);
-	const allContributions = [...pluginContributions, ...siteContributions, ...baseContributions];
+	const allContributions = [
+		...pluginContributions,
+		...siteContributions,
+		...baseContributions,
+		...hreflangContributions,
+	];
 	const resolved = resolvePageMetadata(allContributions);
 	jsonLdScripts = resolved.jsonld;
 	metadataHtml = renderPageMetadata(resolved, { includeJsonLd: false });
@@ -98,13 +126,7 @@ if (runtime) {
 	metadataHtml = renderPageMetadata(resolved, { includeJsonLd: false });
 }
 
-if (Astro.csp && jsonLdScripts.length > 0) {
-	await Promise.all(
-		jsonLdScripts.map(async ({ json }) => {
-			Astro.csp?.insertScriptHash(await createSha256CspHash(json));
-		}),
-	);
-}
+await registerJsonLdCspHashes(virtualConfig.astroCspEnabled === true, () => Astro.csp, jsonLdScripts);
 ---
 
 <Fragment set:html={metadataHtml} />

package/src/components/InlinePortableTextEditor.tsx

@@ -365,6 +365,40 @@ function portableTextToPM(blocks: PTBlock[]): JSONContent {
 				} else break;
 			}
 			content.push(convertPTList(listBlocks, listType));
+		} else if (
+			isPTTextBlock(block) &&
+			block.style === "blockquote" &&
+			block.listItem === undefined
+		) {
+			// Group consecutive blockquote blocks into ONE blockquote node —
+			// PT is flat, so a multi-paragraph quote is stored as a run of
+			// blockquote-styled blocks. Mirrors the grouping in
+			// content/converters/portable-text-to-prosemirror.ts; without it
+			// merges revert on reload in the inline editor too (#1884).
+			const quoteBlocks: PTTextBlock[] = [];
+			while (i < blocks.length) {
+				const cur = blocks[i];
+				if (
+					!cur ||
+					!isPTTextBlock(cur) ||
+					cur.style !== "blockquote" ||
+					cur.listItem !== undefined
+				) {
+					break;
+				}
+				quoteBlocks.push(cur);
+				i++;
+			}
+			content.push({
+				type: "blockquote",
+				content: quoteBlocks.map((quoteBlock) => {
+					const pmContent = convertPTSpans(quoteBlock.children, quoteBlock.markDefs || []);
+					return {
+						type: "paragraph",
+						content: pmContent.length > 0 ? pmContent : undefined,
+					};
+				}),
+			});
 		} else {
 			const c = convertPTBlock(block);
 			if (c) content.push(c);
@@ -1830,44 +1864,65 @@ export function InlinePortableTextEditor({
 		return pmToPortableText(json);
 	}, []);
 
-	const save = React.useCallback(async () => {
-		if (savingRef.current) return;
+	const save = React.useCallback(
+		async (options?: { keepalive?: boolean }) => {
+			// A pagehide flush must not be skipped: an in-flight blur save is
+			// cancelled by the navigation, so the keepalive request is the only
+			// one that can still land (#1582).
+			if (savingRef.current && !options?.keepalive) return;
 
-		const current = JSON.stringify(getBlocks());
-		const initial = JSON.stringify(initialRef.current);
-		if (current === initial) return;
+			const current = JSON.stringify(getBlocks());
+			const initial = JSON.stringify(initialRef.current);
+			if (current === initial) return;
 
-		savingRef.current = true;
-		try {
-			const res = await fetch(
-				`/_emdash/api/content/${encodeURIComponent(collection)}/${encodeURIComponent(entryId)}`,
-				{
-					method: "PUT",
-					credentials: "same-origin",
-					headers: { "Content-Type": "application/json", "X-EmDash-Request": "1" },
-					body: JSON.stringify({ data: { [field]: getBlocks() } }),
-				},
-			);
-
-			if (res.ok) {
-				initialRef.current = getBlocks();
-				document.dispatchEvent(new CustomEvent("emdash:save", { detail: { state: "saved" } }));
-				document.dispatchEvent(
-					new CustomEvent("emdash:content-changed", {
-						detail: { collection, id: entryId },
-					}),
+			savingRef.current = true;
+			try {
+				const res = await fetch(
+					`/_emdash/api/content/${encodeURIComponent(collection)}/${encodeURIComponent(entryId)}`,
+					{
+						method: "PUT",
+						credentials: "same-origin",
+						headers: { "Content-Type": "application/json", "X-EmDash-Request": "1" },
+						body: JSON.stringify({ data: { [field]: getBlocks() } }),
+						keepalive: options?.keepalive ?? false,
+					},
 				);
-			} else {
+
+				if (res.ok) {
+					initialRef.current = getBlocks();
+					document.dispatchEvent(new CustomEvent("emdash:save", { detail: { state: "saved" } }));
+					document.dispatchEvent(
+						new CustomEvent("emdash:content-changed", {
+							detail: { collection, id: entryId },
+						}),
+					);
+				} else {
+					document.dispatchEvent(new CustomEvent("emdash:save", { detail: { state: "error" } }));
+					console.error("Save failed:", res.status);
+				}
+			} catch (err) {
 				document.dispatchEvent(new CustomEvent("emdash:save", { detail: { state: "error" } }));
-				console.error("Save failed:", res.status);
+				console.error("Save failed:", err);
+			} finally {
+				savingRef.current = false;
 			}
-		} catch (err) {
-			document.dispatchEvent(new CustomEvent("emdash:save", { detail: { state: "error" } }));
-			console.error("Save failed:", err);
-		} finally {
-			savingRef.current = false;
-		}
-	}, [collection, entryId, field, getBlocks]);
+		},
+		[collection, entryId, field, getBlocks],
+	);
+
+	// Flush unsaved edits when the page goes away (browser back/forward,
+	// link click, tab close). The blur handler doesn't cover this: unload
+	// doesn't reliably fire React blur, and a plain fetch started during
+	// unload is cancelled by the navigation — edits were silently lost
+	// (#1582). `keepalive` lets the PUT outlive the page.
+	// Caveat: keepalive caps the body at 64KB — a very long document
+	// can still be lost on unload. Upgrade path: debounced autosave
+	// while typing (like the admin editor) so unload flushes are rare.
+	React.useEffect(() => {
+		const flush = () => void save({ keepalive: true });
+		window.addEventListener("pagehide", flush);
+		return () => window.removeEventListener("pagehide", flush);
+	}, [save]);
 
 	// Create slash commands extension once — uses refs to avoid re-render loop
 	const slashCommandsExtension = React.useMemo(