@glw907/cairn-cms 0.60.0 → 0.62.1

package/dist/components/EditPage.svelte

@@ -16,1206 +16,733 @@ pending), and an overflow menu for Discard and Delete. One feedback strip under
 transient flashes, and the editor card's footer is the writing-environment strip: the word
 count, the Prose/Markup posture pair, the focus and typewriter toggles, and the Markdown help.
 -->
-<script lang="ts">
-  import { flushSync, untrack, getContext } from 'svelte';
-  import { beforeNavigate } from '$app/navigation';
-  import { deserialize } from '$app/forms';
-  import { page } from '$app/state';
-  import BlocksIcon from '@lucide/svelte/icons/blocks';
-  import SquarePenIcon from '@lucide/svelte/icons/square-pen';
-  import LinkIcon from '@lucide/svelte/icons/link';
-  import FileSymlinkIcon from '@lucide/svelte/icons/file-symlink';
-  import PanelRightIcon from '@lucide/svelte/icons/panel-right';
-  import ImageIcon from '@lucide/svelte/icons/image';
-  import { useTopbar } from './topbar-context.js';
-  import CsrfField from './CsrfField.svelte';
-  import MarkdownEditor from './MarkdownEditor.svelte';
-  import EditorToolbar from './EditorToolbar.svelte';
-  import ComponentInsertDialog, { insertableDefs, hasSchema } from './ComponentInsertDialog.svelte';
-  import LinkPicker from './LinkPicker.svelte';
-  import WebLinkDialog from './WebLinkDialog.svelte';
-  import MediaInsertPopover from './MediaInsertPopover.svelte';
-  import MediaHeroField from './MediaHeroField.svelte';
-  import MediaFigureControl from './MediaFigureControl.svelte';
-  import DeleteDialog from './DeleteDialog.svelte';
-  import RenameDialog from './RenameDialog.svelte';
-  import MarkdownHelpDialog from './MarkdownHelpDialog.svelte';
-  import ShortcutsDialog from './ShortcutsDialog.svelte';
-  import TidyReview from './TidyReview.svelte';
-  import SparklesIcon from '@lucide/svelte/icons/sparkles';
-  import { validateTidy, TIDY_REJECTION_MESSAGE } from './tidy-validate.js';
-  import type { Change } from './tidy-diff.js';
-  import { cairnLinkCompletionSource } from './link-completion.js';
-  import {
-    findMediaImagesNeedingAlt,
-    unwrapCairnLink,
-    unwrapFigure,
-    updateFigure,
-    wrapImageInFigure,
-    type FigureAtImage,
-    type FigureRole,
-    type FormatKind,
-  } from './markdown-format.js';
-  import { buildPreviewDoc, deviceLabel, previewDevice, previewDevices, type PreviewDeviceId } from './preview-doc.js';
-  import { directiveLineKind, findInlineDirectives } from './markdown-directives.js';
-  import type { ComponentRegistry, ComponentDef } from '../render/registry.js';
-  import { parseComponent, componentRoundTripSafety } from '../render/component-grammar.js';
-  import type { IconSet } from '../render/glyph.js';
-  import type { ContentFormFailure, EditData } from '../sveltekit/content-routes.js';
-  import type { TextareaField, TagsField, FreeTagsField, ImageValue } from '../content/types.js';
-  import type { LinkResolve } from '../content/links.js';
-  import { manifestLinkResolver } from '../content/manifest.js';
-  import type { MediaResolve } from '../render/resolve-media.js';
-  import { manifestMediaResolver } from '../render/resolve-media.js';
-  import type { MediaEntry } from '../media/manifest.js';
-  import { mediaLibraryEntry } from '../media/library-entry.js';
-  import { CSRF_CONTEXT_KEY } from './csrf-context.js';
-
-  interface Props {
-    /** The edit load's data, plus the site name for the heading. */
-    data: EditData & { siteName: string };
-    /** The site's component registry, for the insert palette. */
-    registry?: ComponentRegistry;
-    /** The site's design-accurate render pipeline; the preview pane renders its output, which the floored pipeline already sanitized. */
-    render?: (
-      md: string,
-      opts?: { stagger?: boolean; resolve?: LinkResolve; resolveMedia?: MediaResolve },
-    ) => string | Promise<string>;
-    /** The site's icon set, for the guided form's icon fields. */
-    icons?: IconSet;
-    /** The last content action's failure: the save guard's broken links, the delete guard's
-     *  inbound linkers, or a rename refusal, each carrying the shared `error` summary. */
-    form?: ContentFormFailure | null;
-  }
-
-  let { data, registry, render, icons, form }: Props = $props();
-
-  // The client-side tidy deadline (spec 2.1, Task 14): a slow call becomes a cancel/retry rather than a
-  // hung review. Set above the action's own 30s Worker deadline so the server's retryable fail lands
-  // first when the model is merely slow; this catches a stalled connection past that.
-  const TIDY_CLIENT_TIMEOUT_MS = 45_000;
-
-  // The topbar context portal (AdminLayout owns the holder). The desk snippet below carries the
-  // document's status and action clusters; this effect registers it into the band on mount and
-  // nulls it on teardown, so CairnAdmin's view switch (which unmounts EditPage) clears the band.
-  // The holder is absent only when EditPage renders outside AdminLayout (it always renders inside
-  // it in the app); the optional chaining keeps that case inert.
-  const topbar = useTopbar();
-  $effect(() => {
-    if (!topbar) return;
-    topbar.desk = desk;
-    // Zen drops the band: AdminLayout reads this flag to remove the whole topbar element, so the
-    // desk's clusters and AdminLayout's own chrome (the drawer toggle, the breadcrumb) all slide
-    // away together. The effect tracks `zen`, so a toggle reaches the band live.
-    topbar.zen = zen;
-    return () => {
-      topbar.desk = null;
-      topbar.zen = false;
-    };
-  });
-
-  // `body` is local editor state seeded once; it diverges as the user types. A blocked save returns
-  // the author's edited markdown as form.body, so seed from that when present to keep the edits and
-  // the broken link they were told to fix. On the success and delete-refused paths form carries no
-  // body, so it falls back to the committed data.body. untrack() captures the initial value without
-  // subscribing to future prop changes.
-  let body = $state(untrack(() => form?.body ?? data.body));
-  // True from the moment the save form submits until the navigation it triggers replaces the page,
-  // so the Save button shows a calm "Saving…" state instead of looking inert.
-  let saving = $state(false);
-  // The same working state for the Publish button, which rides the edit form via formaction. The
-  // submit handler reads the submitter to flip the right one, so Save never reads "Saving…" while
-  // a publish is in flight.
-  let publishing = $state(false);
-  function onEditSubmit(e: SubmitEvent) {
-    const formaction = (e.submitter as HTMLButtonElement | null)?.getAttribute('formaction');
-    if (formaction === '?/publish') publishing = true;
-    else saving = true;
-    // Commit any pending personal-dictionary additions alongside the save. Fire-and-forget: the words
-    // are already live in the Worker, so the in-flight commit never blocks the save navigation; an add
-    // that does not land stays pending for the next save (declared before the navigation reads it).
-    void commitPendingDictionary();
-  }
-  // Either in-flight submit disables both buttons, so a second click cannot fire a second POST
-  // while the first navigation is still pending.
-  const busy = $derived(saving || publishing);
-  // True once a non-edit POST (discard, delete, rename) submits. Those forms navigate the
-  // document without flipping busy, so without this the leave guard would fire mid-discard while
-  // the page is still dirty, which is the primary discard scenario.
-  let leaving = $state(false);
-
-  // Dirty tracking. The body compares against the text the page loaded with (or the edited body a
-  // blocked save returned, which seeded the editor); the uncontrolled sidebar fields flip a flag
-  // on any input event, and the navigation a save triggers reloads the page, which resets both.
-  const bodyDirty = $derived(body !== (form?.body ?? data.body));
-  let fieldsDirty = $state(false);
-  const dirty = $derived(bodyDirty || fieldsDirty);
-  // What the header's save-state indicator says.
-  const saveState = $derived(dirty ? 'Unsaved changes' : data.saved ? 'Saved' : '');
-  function onFormInput(e: Event) {
-    const target = e.target as Element | null;
-    // Two kinds of input event bubble through the form without being frontmatter edits: the link
-    // picker's search box (its dialog sits in the toolbar snippet) and the editing surface's
-    // contenteditable. Skipping the surface keeps body edits owned by bodyDirty, so undoing back
-    // to the committed text reads clean again.
-    if (target?.closest('dialog, #cairn-pane-write')) return;
-    fieldsDirty = true;
+<script lang="ts">import { flushSync, untrack, getContext } from "svelte";
+import { beforeNavigate } from "$app/navigation";
+import { deserialize } from "$app/forms";
+import { page } from "$app/state";
+import BlocksIcon from "@lucide/svelte/icons/blocks";
+import SquarePenIcon from "@lucide/svelte/icons/square-pen";
+import LinkIcon from "@lucide/svelte/icons/link";
+import FileSymlinkIcon from "@lucide/svelte/icons/file-symlink";
+import PanelRightIcon from "@lucide/svelte/icons/panel-right";
+import ImageIcon from "@lucide/svelte/icons/image";
+import { useTopbar } from "./topbar-context.js";
+import CsrfField from "./CsrfField.svelte";
+import MarkdownEditor from "./MarkdownEditor.svelte";
+import EditorToolbar from "./EditorToolbar.svelte";
+import ComponentInsertDialog, { insertableDefs, hasSchema } from "./ComponentInsertDialog.svelte";
+import LinkPicker from "./LinkPicker.svelte";
+import WebLinkDialog from "./WebLinkDialog.svelte";
+import MediaInsertPopover from "./MediaInsertPopover.svelte";
+import MediaHeroField from "./MediaHeroField.svelte";
+import MediaFigureControl from "./MediaFigureControl.svelte";
+import DeleteDialog from "./DeleteDialog.svelte";
+import RenameDialog from "./RenameDialog.svelte";
+import MarkdownHelpDialog from "./MarkdownHelpDialog.svelte";
+import ShortcutsDialog from "./ShortcutsDialog.svelte";
+import TidyReview from "./TidyReview.svelte";
+import SparklesIcon from "@lucide/svelte/icons/sparkles";
+import { validateTidy, TIDY_REJECTION_MESSAGE } from "./tidy-validate.js";
+import { cairnLinkCompletionSource } from "./link-completion.js";
+import {
+  findMediaImagesNeedingAlt,
+  unwrapCairnLink,
+  unwrapFigure,
+  updateFigure,
+  wrapImageInFigure
+} from "./markdown-format.js";
+import { buildPreviewDoc, deviceLabel, previewDevice, previewDevices } from "./preview-doc.js";
+import { directiveLineKind, findInlineDirectives } from "./markdown-directives.js";
+import { parseComponent, componentRoundTripSafety } from "../render/component-grammar.js";
+import { manifestLinkResolver } from "../content/manifest.js";
+import { manifestMediaResolver } from "../render/resolve-media.js";
+import { mediaLibraryEntry } from "../media/library-entry.js";
+import { CSRF_CONTEXT_KEY } from "./csrf-context.js";
+let { data, registry, render, icons, form } = $props();
+const TIDY_CLIENT_TIMEOUT_MS = 45e3;
+const topbar = useTopbar();
+$effect(() => {
+  if (!topbar) return;
+  topbar.desk = desk;
+  topbar.zen = zen;
+  return () => {
+    topbar.desk = null;
+    topbar.zen = false;
+  };
+});
+let body = $state(untrack(() => form?.body ?? data.body));
+let saving = $state(false);
+let publishing = $state(false);
+function onEditSubmit(e) {
+  const formaction = e.submitter?.getAttribute("formaction");
+  if (formaction === "?/publish") publishing = true;
+  else saving = true;
+  void commitPendingDictionary();
+}
+const busy = $derived(saving || publishing);
+let leaving = $state(false);
+const bodyDirty = $derived(body !== (form?.body ?? data.body));
+let fieldsDirty = $state(false);
+const dirty = $derived(bodyDirty || fieldsDirty);
+const saveState = $derived(dirty ? "Unsaved changes" : data.saved ? "Saved" : "");
+function onFormInput(e) {
+  const target = e.target;
+  if (target?.closest("dialog, #cairn-pane-write")) return;
+  fieldsDirty = true;
+}
+function markFieldsDirty() {
+  fieldsDirty = true;
+}
+let editForm = $state(null);
+let publishButton = $state(null);
+function onFormInvalid(e) {
+  const target = e.target;
+  if (target?.closest("aside")) {
+    if (!detailsOpen) flushSync(() => detailsOpen = true);
+    return;
   }
-  // Mark the details fields dirty without a form input event. The hero field writes its value to
-  // hidden inputs, whose programmatic value changes do not fire the form's oninput, so it signals
-  // dirty through this helper instead.
-  function markFieldsDirty() {
-    fieldsDirty = true;
+  if (mode === "write") return;
+  flushSync(() => mode = "write");
+}
+beforeNavigate((navigation) => {
+  if (navigation.willUnload) {
+    if (dirty && !busy && !leaving) navigation.cancel();
+    return;
   }
-
-  // The edit form element, for the Ctrl/Cmd+S shortcut's requestSubmit.
-  let editForm = $state<HTMLFormElement | null>(null);
-  // The header's Publish submitter, for the Ctrl/Cmd+Shift+S shortcut: requesting submit through it
-  // carries the ?/publish formaction and trips the busy flags down the existing submit path. It
-  // exists only while data.pending, so the shortcut no-ops when there is nothing to publish.
-  let publishButton = $state<HTMLButtonElement | null>(null);
-
-  // A required field hidden from the browser's validation report cannot take it: an invisible
-  // control is unfocusable, so the browser cancels the save silently with no message. Two surfaces
-  // can hide a required field, so this capture-phase invalid listener reveals whichever holds the
-  // invalid control before the report that follows fires. A field in the write pane needs Preview
-  // flipped back to Write; a field in the details slide-over needs the panel opened. flushSync
-  // forces the reveal inside the event, so the report lands on a now-visible control.
-  function onFormInvalid(e: Event) {
-    const target = e.target as Element | null;
-    if (target?.closest('aside')) {
-      if (!detailsOpen) flushSync(() => (detailsOpen = true));
+  if (dirty && !busy && !leaving && !confirm("You have unsaved changes. Leave anyway?"))
+    navigation.cancel();
+});
+$effect(() => {
+  const onBeforeUnload = (e) => {
+    if (dirty && !busy && !leaving) e.preventDefault();
+  };
+  const onWindowKeydown = (e) => {
+    if (e.key === "Escape" && (detailsOpen || zen)) {
+      const inDialog2 = !!e.target?.closest?.("dialog");
+      if (inDialog2) return;
+      e.preventDefault();
+      if (detailsOpen) closeDetails();
+      else setZen(false);
       return;
     }
-    if (mode === 'write') return;
-    flushSync(() => (mode = 'write'));
-  }
-
-  // The SvelteKit half of the leave guard. Registered at component init (beforeNavigate wraps
-  // onMount, so it must run synchronously here) and auto-unregistered on destroy. A submit's own
-  // navigation passes through because busy flips before it starts, and a non-edit POST's because
-  // leaving does.
-  beforeNavigate((navigation) => {
-    // A full-page unload (refresh, tab close, external link): per SvelteKit semantics, cancel()
-    // on a leave navigation is what asks the browser for its native dialog, so no confirm()
-    // here or two prompts would stack. The beforeunload listener below is deliberate
-    // belt-and-braces, not the dialog's source.
-    if (navigation.willUnload) {
-      if (dirty && !busy && !leaving) navigation.cancel();
+    if (!(e.ctrlKey || e.metaKey)) return;
+    const key = e.key.toLowerCase();
+    const inDialog = !!e.target?.closest?.("dialog");
+    if (!e.shiftKey && !e.altKey && e.key === "/") {
+      e.preventDefault();
+      if (inDialog) return;
+      shortcutsDialog?.open();
       return;
     }
-    if (dirty && !busy && !leaving && !confirm('You have unsaved changes. Leave anyway?'))
-      navigation.cancel();
-  });
-
-  // The browser half of the leave guard plus the page-wide save shortcut. The handlers read the
-  // current dirty and busy values at event time, so the effect itself tracks nothing and runs once.
-  $effect(() => {
-    const onBeforeUnload = (e: BeforeUnloadEvent) => {
-      if (dirty && !busy && !leaving) e.preventDefault();
-    };
-    // Guard-clause style on purpose: svelte 5.56.1 misprints `(a || b) && c` by dropping the
-    // parentheses, and consumers compile this source with their own svelte.
-    const onWindowKeydown = (e: KeyboardEvent) => {
-      // Escape precedence, top to bottom: an open dialog claims Escape natively, so step aside
-      // when one is up. Otherwise the details slide-over closes first (Task 8: it is a region, not
-      // a dialog, so it has no native light-dismiss), and only when no panel is open does Escape
-      // exit zen. So under zen with the panel open, the first Escape closes the panel and the
-      // second exits zen, which keeps the two affordances independent.
-      if (e.key === 'Escape' && (detailsOpen || zen)) {
-        const inDialog = !!(e.target as Element | null)?.closest?.('dialog');
-        if (inDialog) return;
-        e.preventDefault();
-        if (detailsOpen) closeDetails();
-        else setZen(false);
-        return;
-      }
-      if (!(e.ctrlKey || e.metaKey)) return;
-      const key = e.key.toLowerCase();
-      // The page-wide chords never act on a surface the author cannot see: a save, publish, mode
-      // flip, or focus toggle from inside an open modal is suppressed the same way.
-      const inDialog = !!(e.target as Element | null)?.closest?.('dialog');
-      // Ctrl+/ opens the shortcuts sheet, the third discoverability surface. It reads off e.key so
-      // it survives the shifted glyph differences across layouts, and it stays clear of dialogs the
-      // same way the other chords do (the sheet is itself a dialog, so opening from inside one would
-      // stack modals over a surface the author cannot see).
-      if (!e.shiftKey && !e.altKey && e.key === '/') {
-        e.preventDefault();
-        if (inDialog) return;
-        shortcutsDialog?.open();
-        return;
-      }
-      if (e.shiftKey && key === 's') {
-        // Publish rides the header's Publish submitter so the ?/publish formaction and the busy
-        // flags follow the existing submit path; it exists only while pending, so this no-ops
-        // otherwise.
-        e.preventDefault();
-        if (busy || inDialog || !data.pending) return;
-        editForm?.requestSubmit(publishButton);
-        return;
-      }
-      if (e.altKey && key === 'p') {
-        e.preventDefault();
-        if (inDialog) return;
-        setMode(mode === 'write' ? 'preview' : 'write');
-        return;
-      }
-      if (e.shiftKey && key === 'f') {
-        e.preventDefault();
-        if (inDialog) return;
-        setFocusMode(!focusMode);
-        return;
-      }
-      // Ctrl+Shift+. toggles zen (the bindings' zen key); the period reads off e.key. This sits
-      // before the Ctrl+. panel block so the shifted chord is not mistaken for the panel toggle.
-      if (e.shiftKey && !e.altKey && e.key === '.') {
-        e.preventDefault();
-        if (inDialog) return;
-        setZen(!zen);
-        return;
-      }
-      // Ctrl+. toggles the details slide-over (the bindings' panel key); the period reads off
-      // e.key with no shift or alt.
-      if (!e.shiftKey && !e.altKey && e.key === '.') {
-        e.preventDefault();
-        if (inDialog) return;
-        toggleDetails();
-        return;
-      }
-      if (e.shiftKey || e.altKey) return;
-      if (key !== 's') return;
-      // Always claim the shortcut so the browser's save-page dialog never opens over the admin.
+    if (e.shiftKey && key === "s") {
+      e.preventDefault();
+      if (busy || inDialog || !data.pending) return;
+      editForm?.requestSubmit(publishButton);
+      return;
+    }
+    if (e.altKey && key === "p") {
       e.preventDefault();
-      // Gate the submit itself: an in-flight POST must not race a second one, a clean page has
-      // nothing to save (a no-op save would still cut a pending branch), and a save from inside
-      // an open modal would act on a surface the author cannot see.
-      if (busy) return;
-      if (!dirty && !data.isNew) return;
       if (inDialog) return;
-      editForm?.requestSubmit();
-    };
-    window.addEventListener('beforeunload', onBeforeUnload);
-    window.addEventListener('keydown', onWindowKeydown);
-    return () => {
-      window.removeEventListener('beforeunload', onBeforeUnload);
-      window.removeEventListener('keydown', onWindowKeydown);
-    };
-  });
-  // The discard confirm, on the DeleteDialog pattern: a native <dialog> holding the POST form.
-  let discardDialog = $state<HTMLDialogElement | null>(null);
-  // Which pane the editor card shows. The toolbar's tablist drives it; Write is always the
-  // landing tab.
-  let mode = $state<'write' | 'preview'>('write');
-  // Preview is read-only, so the insert controls the page renders into the toolbar disable with the
-  // strip's own format buttons. Declared here (above the Edit-block derivations that read it) so it
-  // is in scope before its first use.
-  // Tidy mode disables the toolbar and makes the surface read-only while a review is open. The host
-  // sets it when the review opens and clears it on apply or cancel. Declared here so the insert-disable
-  // derivation below can read it.
-  let tidyMode = $state(false);
-  // The tidy request in-flight flag, so the Tidy control reads busy while a call runs.
-  let tidyBusy = $state(false);
-  // The insert controls disable in Preview (read-only) and while a tidy review is open (the author
-  // cannot edit underneath a pending review, the same posture Preview takes).
-  const insertDisabled = $derived(mode === 'preview' || tidyMode);
-  let previewHtml = $state('');
-  // True after a render call threw, so the preview pane can say so instead of going blank.
-  let previewFailed = $state(false);
-  // The preview frame's device width, a per-browser preference under its own key (the legacy
-  // 'cairn-admin:preview' key from the removed split-pane preview stays untouched). Desktop is
-  // the default; the storage read sits in an effect so it never runs during SSR, and it tracks
-  // nothing reactive, so it runs once.
-  const deviceStorageKey = 'cairn-editor-preview-device';
-  let device = $state<PreviewDeviceId>('desktop');
-  $effect(() => {
-    const stored = localStorage.getItem(deviceStorageKey);
-    if (previewDevices.some((d) => d.id === stored)) device = stored as PreviewDeviceId;
-  });
-  function setDevice(id: PreviewDeviceId) {
-    device = id;
-    localStorage.setItem(deviceStorageKey, id);
-  }
-  // The writing modes (focus, typewriter) and the surface posture, per-browser preferences on
-  // the device pick's pattern: read in an effect so SSR never touches localStorage, written by
-  // the card footer's toggles. The effect tracks nothing reactive, so it runs once.
-  const focusStorageKey = 'cairn-editor-focus-mode';
-  const typewriterStorageKey = 'cairn-editor-typewriter';
-  const surfaceStorageKey = 'cairn-editor-surface';
-  const zenStorageKey = 'cairn-editor-zen';
-  // Spellcheck (the markdown-aware lint underlines) defaults ON, so a fresh editor checks spelling
-  // without a choice. The toggle joins the editor-preference family on the same pattern: a localStorage
-  // key read once in the effect below, written by the footer setter. Stored as 'false' only when the
-  // author turns it off; any other value (including unset) reads as on.
-  const spellcheckStorageKey = 'cairn-editor-spellcheck';
-  let focusMode = $state(false);
-  let typewriter = $state(false);
-  let spellcheck = $state(true);
-  // Zen: the manuscript alone on the recessed ground. The band, the document title, the toolbar
-  // strip, and the footer go; the editing surface stays. It joins the editor-preference family on
-  // the same pattern (a localStorage key, read once below, written by the setter), and composes
-  // with focus mode and the postures rather than resetting them.
-  let zen = $state(false);
-  // The surface posture: prose (the writing instrument) by default; markup is the dense
-  // working surface.
-  let surface = $state<'prose' | 'markup'>('prose');
-  $effect(() => {
-    focusMode = localStorage.getItem(focusStorageKey) === 'true';
-    typewriter = localStorage.getItem(typewriterStorageKey) === 'true';
-    zen = localStorage.getItem(zenStorageKey) === 'true';
-    if (localStorage.getItem(surfaceStorageKey) === 'markup') surface = 'markup';
-    // Spellcheck is on unless the author explicitly stored it off.
-    spellcheck = localStorage.getItem(spellcheckStorageKey) !== 'false';
-  });
-  function setFocusMode(on: boolean) {
-    focusMode = on;
-    localStorage.setItem(focusStorageKey, String(on));
-  }
-  function setTypewriter(on: boolean) {
-    typewriter = on;
-    localStorage.setItem(typewriterStorageKey, String(on));
-  }
-  function setSpellcheck(on: boolean) {
-    spellcheck = on;
-    localStorage.setItem(spellcheckStorageKey, String(on));
-  }
-
-  // The personal-dictionary pending additions (spec 1.6), owned here and shared with MarkdownEditor's
-  // lint source: an add-to-dictionary choice records the lowercased word here (and clears the underline
-  // at once), and this host commits the set through the addDictionaryWord action at save time. An add
-  // that fails to commit stays here for the session and re-attempts on the next save, so the word is
-  // never silently dropped. A plain Set, not $state: the lint source mutates it, and nothing renders
-  // from it, so reactivity is unneeded.
-  const pendingAdditions = new Set<string>();
-  // The CSRF token getter from the admin layout context, for the raw-body dictionary commit.
-  const csrf = getContext<(() => string) | undefined>(CSRF_CONTEXT_KEY);
-
-  /** Commit the pending personal-dictionary additions through the addDictionaryWord action, then drop
-   *  the words the server confirms from the pending set. Fire-and-forget at save time: the words are
-   *  already live in the Worker's in-memory set, so a slow or failed commit never blocks the save. A
-   *  failure leaves the words pending for the next save (never dropped). The transport mirrors the media
-   *  raw-body actions: a text/plain POST, the CSRF token in X-Cairn-CSRF, a JSON `{ words }` body. */
-  async function commitPendingDictionary(): Promise<void> {
-    if (pendingAdditions.size === 0) return;
-    const words = [...pendingAdditions];
-    try {
-      const res = await fetch(`/admin/${data.conceptId}/${data.id}?/addDictionaryWord`, {
-        method: 'POST',
-        redirect: 'manual',
-        headers: { 'Content-Type': 'text/plain', 'X-Cairn-CSRF': csrf?.() ?? '' },
-        body: JSON.stringify({ words }),
-      });
-      // The guard's expired-session 303 under redirect: 'manual' surfaces as an opaque, status-0
-      // response with no body: leave the words pending and bail.
-      if (res.type === 'opaqueredirect' || res.status === 0) return;
-      // deserialize turns the devalue-encoded form-action result back into an ActionResult; a 500 HTML
-      // error page is not devalue-encoded, so it throws into the catch below. Only a success carries
-      // the merged word list; a fail (csrf, 400, 409) leaves the words pending for the next save.
-      const result = deserialize(await res.text()) as
-        | { type: 'success'; data?: { words?: unknown } }
-        | { type: 'failure' | 'error' | 'redirect' };
-      if (result.type !== 'success') return;
-      const merged = result.data?.words;
-      if (!Array.isArray(merged)) return;
-      // Reconcile: drop every now-committed word (matched lowercased, the form the action stored) from
-      // the pending set so it is not re-sent. A word the server did not confirm stays pending.
-      const committed = new Set(merged.filter((w): w is string => typeof w === 'string').map((w) => w.toLowerCase()));
-      for (const w of words) if (committed.has(w.toLowerCase())) pendingAdditions.delete(w);
-    } catch {
-      // A network failure or an unparseable server response leaves the pending set intact for the next
-      // save; the words stay live in the Worker for the session, so the author sees no regression.
+      setMode(mode === "write" ? "preview" : "write");
+      return;
     }
-  }
-  function setSurface(posture: 'prose' | 'markup') {
-    surface = posture;
-    localStorage.setItem(surfaceStorageKey, posture);
-  }
-  function setZen(on: boolean) {
-    // Entering zen hides the band, the document title, the toolbar strip, and the footer. Focus on
-    // any of those (a band action like Publish, a strip button, the title input, a footer toggle)
-    // would strand on a detached node when its host leaves the DOM, so move focus into the editing
-    // surface first. The surface (.cm-editor) and the exit chip are all that survive, so any focus
-    // outside the surface is about to hide. Reading activeElement before the DOM updates is what
-    // tells a hiding control from the surviving one.
-    const surface = editorCard?.querySelector('.cm-editor');
-    const focusHides = on && !surface?.contains(document.activeElement);
-    zen = on;
-    localStorage.setItem(zenStorageKey, String(on));
-    if (focusHides) {
-      // flushSync applies the zen layout (the strip and footer leave the DOM) before we reach for
-      // the surface, so the focus call lands on the now-sole interactive region.
-      flushSync();
-      (editorCard?.querySelector('.cm-content') as HTMLElement | null)?.focus();
+    if (e.shiftKey && key === "f") {
+      e.preventDefault();
+      if (inDialog) return;
+      setFocusMode(!focusMode);
+      return;
     }
+    if (e.shiftKey && !e.altKey && e.key === ".") {
+      e.preventDefault();
+      if (inDialog) return;
+      setZen(!zen);
+      return;
+    }
+    if (!e.shiftKey && !e.altKey && e.key === ".") {
+      e.preventDefault();
+      if (inDialog) return;
+      toggleDetails();
+      return;
+    }
+    if (e.shiftKey || e.altKey) return;
+    if (key !== "s") return;
+    e.preventDefault();
+    if (busy) return;
+    if (!dirty && !data.isNew) return;
+    if (inDialog) return;
+    editForm?.requestSubmit();
+  };
+  window.addEventListener("beforeunload", onBeforeUnload);
+  window.addEventListener("keydown", onWindowKeydown);
+  return () => {
+    window.removeEventListener("beforeunload", onBeforeUnload);
+    window.removeEventListener("keydown", onWindowKeydown);
+  };
+});
+let discardDialog = $state(null);
+let mode = $state("write");
+let tidyMode = $state(false);
+let tidyBusy = $state(false);
+const insertDisabled = $derived(mode === "preview" || tidyMode);
+let previewHtml = $state("");
+let previewFailed = $state(false);
+const deviceStorageKey = "cairn-editor-preview-device";
+let device = $state("desktop");
+$effect(() => {
+  const stored = localStorage.getItem(deviceStorageKey);
+  if (previewDevices.some((d) => d.id === stored)) device = stored;
+});
+function setDevice(id) {
+  device = id;
+  localStorage.setItem(deviceStorageKey, id);
+}
+const focusStorageKey = "cairn-editor-focus-mode";
+const typewriterStorageKey = "cairn-editor-typewriter";
+const surfaceStorageKey = "cairn-editor-surface";
+const zenStorageKey = "cairn-editor-zen";
+const spellcheckStorageKey = "cairn-editor-spellcheck";
+let focusMode = $state(false);
+let typewriter = $state(false);
+let spellcheck = $state(true);
+let zen = $state(false);
+let surface = $state("prose");
+$effect(() => {
+  focusMode = localStorage.getItem(focusStorageKey) === "true";
+  typewriter = localStorage.getItem(typewriterStorageKey) === "true";
+  zen = localStorage.getItem(zenStorageKey) === "true";
+  if (localStorage.getItem(surfaceStorageKey) === "markup") surface = "markup";
+  spellcheck = localStorage.getItem(spellcheckStorageKey) !== "false";
+});
+function setFocusMode(on) {
+  focusMode = on;
+  localStorage.setItem(focusStorageKey, String(on));
+}
+function setTypewriter(on) {
+  typewriter = on;
+  localStorage.setItem(typewriterStorageKey, String(on));
+}
+function setSpellcheck(on) {
+  spellcheck = on;
+  localStorage.setItem(spellcheckStorageKey, String(on));
+}
+const pendingAdditions = /* @__PURE__ */ new Set();
+const csrf = getContext(CSRF_CONTEXT_KEY);
+async function commitPendingDictionary() {
+  if (pendingAdditions.size === 0) return;
+  const words = [...pendingAdditions];
+  try {
+    const res = await fetch(`/admin/${data.conceptId}/${data.id}?/addDictionaryWord`, {
+      method: "POST",
+      redirect: "manual",
+      headers: { "Content-Type": "text/plain", "X-Cairn-CSRF": csrf?.() ?? "" },
+      body: JSON.stringify({ words })
+    });
+    if (res.type === "opaqueredirect" || res.status === 0) return;
+    const result = deserialize(await res.text());
+    if (result.type !== "success") return;
+    const merged = result.data?.words;
+    if (!Array.isArray(merged)) return;
+    const committed = new Set(merged.filter((w) => typeof w === "string").map((w) => w.toLowerCase()));
+    for (const w of words) if (committed.has(w.toLowerCase())) pendingAdditions.delete(w);
+  } catch {
   }
-  // The footer controls dress as what they are (the spec's rule). Each helper returns a verbatim
-  // Tailwind class string: the admin CSS build's @source scan reads this file as raw text, so the
-  // utilities must appear whole, never assembled from fragments.
-  //
-  // A segment of the bordered posture control (the mockup's .seg). The shared group border carries
-  // the pick-one semantics, so a segment stays borderless; the active one tints and bolds. The
-  // admin's scoped button reset (cairn-admin.css) already strips the UA border and fill.
-  function segButtonClass(pressed: boolean): string {
-    return `inline-flex items-center gap-1 px-2.5 py-1 text-xs font-normal ${pressed ? 'bg-primary/10 text-primary font-medium' : 'text-[var(--color-muted)]'}`;
+}
+function setSurface(posture) {
+  surface = posture;
+  localStorage.setItem(surfaceStorageKey, posture);
+}
+function setZen(on) {
+  const surface2 = editorCard?.querySelector(".cm-editor");
+  const focusHides = on && !surface2?.contains(document.activeElement);
+  zen = on;
+  localStorage.setItem(zenStorageKey, String(on));
+  if (focusHides) {
+    flushSync();
+    editorCard?.querySelector(".cm-content")?.focus();
   }
-  // A standalone writing-mode toggle (the mockup's .ftr-toggle): rounded, transparent until hover,
-  // check-and-tint when pressed.
-  function ftrToggleClass(pressed: boolean): string {
-    return `ftr-toggle inline-flex items-center gap-1 rounded-lg px-2 py-1 text-xs font-normal hover:bg-base-content/[0.06] ${pressed ? 'bg-primary/10 text-primary font-medium' : 'text-[var(--color-muted)]'}`;
+}
+function segButtonClass(pressed) {
+  return `inline-flex items-center gap-1 px-2.5 py-1 text-xs font-normal ${pressed ? "bg-primary/10 text-primary font-medium" : "text-[var(--color-muted)]"}`;
+}
+function ftrToggleClass(pressed) {
+  return `ftr-toggle inline-flex items-center gap-1 rounded-lg px-2 py-1 text-xs font-normal hover:bg-base-content/[0.06] ${pressed ? "bg-primary/10 text-primary font-medium" : "text-[var(--color-muted)]"}`;
+}
+const activeDevice = $derived(previewDevice(device));
+const previewDoc = $derived(buildPreviewDoc(previewHtml, data.preview));
+let insert = $state.raw(() => {
+});
+let replaceRange = $state.raw(() => {
+});
+let selectRange = $state.raw(() => {
+});
+let insertLink = $state.raw(() => {
+});
+let getSelection = $state.raw(() => "");
+let getSelectionRange = $state.raw(() => null);
+let format = $state.raw(() => {
+});
+let tidyApi = $state.raw(null);
+let undoEditor = $state.raw(() => {
+});
+let tidyReview = $state.raw(null);
+let tidyMessage = $state(null);
+let tidyNoop = $state(false);
+let tidyApplied = $state(false);
+let tidyController = null;
+let tidyWorkingDialog = $state(null);
+let tidyNoopDialog = $state(null);
+let tidyMessageDialog = $state(null);
+$effect(() => {
+  if (tidyBusy) tidyWorkingDialog?.showModal();
+});
+$effect(() => {
+  if (tidyNoop) tidyNoopDialog?.showModal();
+});
+$effect(() => {
+  if (tidyMessage) tidyMessageDialog?.showModal();
+});
+const tidyEnabled = $derived(data.tidy?.enabled ?? false);
+async function runTidy() {
+  if (!tidyEnabled || tidyBusy || tidyMode) return;
+  tidyMessage = null;
+  tidyNoop = false;
+  tidyApplied = false;
+  const selected = getSelection();
+  const range = getSelectionRange();
+  const useSelection = selected.length > 0;
+  let offset = 0;
+  if (range) {
+    offset = range.from;
+  } else if (useSelection) {
+    offset = Math.max(body.indexOf(selected), 0);
   }
-  const activeDevice = $derived(previewDevice(device));
-  // The iframe document around the rendered html: the site's stylesheets from the adapter's
-  // preview knob, or a styleless document (behind the hint below) when the site sets none.
-  const previewDoc = $derived(buildPreviewDoc(previewHtml, data.preview));
-  let insert = $state.raw<(text: string) => void>(() => {});
-  // The editor's range-replace seam, registered by MarkdownEditor on mount; the dialog's Update
-  // routes through it to overwrite an edited block's source span. A no-op until then.
-  let replaceRange = $state.raw<(from: number, to: number, text: string) => void>(() => {});
-  // The editor's select-range seam, registered by MarkdownEditor on mount; the needs-alt notice's
-  // jump control routes through it to land the author on an image that lacks alt. A no-op until then.
-  let selectRange = $state.raw<(from: number, to: number) => void>(() => {});
-  let insertLink = $state.raw<(href: string, title: string) => void>(() => {});
-  // The editor's current selection, registered by MarkdownEditor on mount; the web link dialog
-  // reads it for the Text field's default.
-  let getSelection = $state.raw<() => string>(() => '');
-  // The editor's selection range, registered by MarkdownEditor on mount; tidy reads it for the exact
-  // selected span's offset so a selection tidy never maps onto an identical passage earlier in the
-  // document. Returns null when the selection is empty (a bare caret), which reads as document scope.
-  let getSelectionRange = $state.raw<() => { from: number; to: number } | null>(() => null);
-  // The editor's selection transform, registered by MarkdownEditor on mount; a no-op until then.
-  let format = $state.raw<(kind: FormatKind) => void>(() => {});
-
-  // The tidy apply seam, registered by MarkdownEditor on mount; the review surface drives the in-buffer
-  // decorations and the batched apply through it. Null until the editor mounts.
-  let tidyApi = $state.raw<import('./editor-tidy.js').TidyApi | null>(null);
-  // The editor's undo, registered on mount; the Undo-tidy chip calls it. A no-op until then.
-  let undoEditor = $state.raw<() => void>(() => {});
-  // The open review's data: the validated change set, the captured original it was diffed against, the
-  // scope, and the model. Null when no review is open. The diff positions index `tidyOriginal`, which
-  // for a selection tidy is the FULL document (the changes are offset back before they reach here).
-  let tidyReview = $state.raw<{ changes: Change[]; original: string; model: string } | null>(null);
-  // The error message a refused or failed tidy surfaces. The working state is cancelable through the
-  // AbortController; a validation rejection or an action failure lands here.
-  let tidyMessage = $state<string | null>(null);
-  // The no-op confirmation: a clean result (tidy found nothing to fix) shows "Nothing to fix" and never
-  // opens an empty review. Cleared on the next tidy run.
-  let tidyNoop = $state(false);
-  // The session-level "Undo tidy" affordance: surfaced right after Apply, dismissed on the next edit.
-  let tidyApplied = $state(false);
-  // The in-flight controller, for Cancel and the bounded client timeout.
-  let tidyController: AbortController | null = null;
-
-  // The three tidy status dialogs (working, no-op, message). Each is promoted to the top layer with
-  // showModal() the way TidyReview does, so the focus trap, Escape, and inert background come from the
-  // platform. The $effect below opens each when its flag flips and closes it when the flag clears; the
-  // {#if} mounts the element, so the ref is set before the effect reads it.
-  let tidyWorkingDialog = $state<HTMLDialogElement | null>(null);
-  let tidyNoopDialog = $state<HTMLDialogElement | null>(null);
-  let tidyMessageDialog = $state<HTMLDialogElement | null>(null);
-  $effect(() => {
-    if (tidyBusy) tidyWorkingDialog?.showModal();
-  });
-  $effect(() => {
-    if (tidyNoop) tidyNoopDialog?.showModal();
-  });
-  $effect(() => {
-    if (tidyMessage) tidyMessageDialog?.showModal();
-  });
-
-  // True when tidy is enabled for the site (the developer-tier master switch). Gates the Tidy control.
-  // The optional chain mirrors the component's tolerance of a partial data load: a degraded load that
-  // omits the tidy block simply reads disabled rather than throwing.
-  const tidyEnabled = $derived(data.tidy?.enabled ?? false);
-
-  /** Run tidy (spec 2.1, Task 11) over the whole document or the current selection. The action receives
-   *  only the selected text plus a scope flag; the diff is computed against that text and the changes'
-   *  ranges are offset back into the full document before they reach the apply seam. On success the
-   *  result is validated as a proofread (Task 13); a rejection shows the honest message and writes
-   *  nothing; a clean result shows "Nothing to fix"; otherwise the review opens. */
-  async function runTidy() {
-    if (!tidyEnabled || tidyBusy || tidyMode) return;
-    tidyMessage = null;
-    tidyNoop = false;
-    tidyApplied = false;
-    // Scope: a non-empty selection tidies that range; otherwise the whole body. The offset is where the
-    // selected text begins in the full document, so the diff positions map back. The range seam carries
-    // the exact selection offsets, so a passage that repeats earlier in the body still maps the
-    // corrections onto the actually-selected occurrence. Fall back to the first textual match only when
-    // no range is available (offset 0 keeps document-scope tidy unchanged).
-    const selected = getSelection();
-    const range = getSelectionRange();
-    const useSelection = selected.length > 0;
-    let offset = 0;
-    if (range) {
-      offset = range.from;
-    } else if (useSelection) {
-      offset = Math.max(body.indexOf(selected), 0);
+  const text = useSelection ? selected : body;
+  tidyBusy = true;
+  tidyController = new AbortController();
+  const timer = setTimeout(() => tidyController?.abort(), TIDY_CLIENT_TIMEOUT_MS);
+  try {
+    const res = await fetch(`/admin/${data.conceptId}/${data.id}?/tidy`, {
+      method: "POST",
+      redirect: "manual",
+      headers: { "Content-Type": "text/plain", "X-Cairn-CSRF": csrf?.() ?? "" },
+      body: JSON.stringify({ text, scope: useSelection ? "selection" : "document" }),
+      signal: tidyController.signal
+    });
+    if (res.type === "opaqueredirect" || res.status === 0) {
+      tidyMessage = "Your session expired. Sign in again to tidy.";
+      return;
     }
-    const text = useSelection ? selected : body;
-
-    tidyBusy = true;
-    tidyController = new AbortController();
-    // The bounded client timeout: a slow call becomes a cancel/retry rather than hanging the review.
-    const timer = setTimeout(() => tidyController?.abort(), TIDY_CLIENT_TIMEOUT_MS);
-    try {
-      const res = await fetch(`/admin/${data.conceptId}/${data.id}?/tidy`, {
-        method: 'POST',
-        redirect: 'manual',
-        headers: { 'Content-Type': 'text/plain', 'X-Cairn-CSRF': csrf?.() ?? '' },
-        body: JSON.stringify({ text, scope: useSelection ? 'selection' : 'document' }),
-        signal: tidyController.signal,
-      });
-      if (res.type === 'opaqueredirect' || res.status === 0) {
-        tidyMessage = 'Your session expired. Sign in again to tidy.';
-        return;
-      }
-      const result = deserialize(await res.text()) as
-        | { type: 'success'; data?: { corrected?: unknown; model?: unknown } }
-        | { type: 'failure'; data?: { error?: unknown } }
-        | { type: 'error' | 'redirect' };
-      if (result.type !== 'success') {
-        tidyMessage =
-          result.type === 'failure' && typeof result.data?.error === 'string' && result.data.error !== 'csrf'
-            ? result.data.error
-            : 'Tidy could not finish. Try again.';
-        return;
-      }
-      const corrected = typeof result.data?.corrected === 'string' ? result.data.corrected : '';
-      const model = typeof result.data?.model === 'string' ? result.data.model : data.tidy.model;
-      if (corrected.length === 0 || corrected === text) {
-        // A clean result: tidy found nothing to fix. Never open an empty review.
-        tidyNoop = true;
-        return;
-      }
-      // Validate the result as a proofread (Task 13). A rejection writes nothing and shows the message.
-      const validation = validateTidy(text, corrected);
-      if (!validation.ok) {
-        tidyMessage = TIDY_REJECTION_MESSAGE;
-        return;
-      }
-      if (validation.changes.length === 0) {
-        tidyNoop = true;
-        return;
-      }
-      // Offset the changes back into the full document (a selection tidy diffs the selected text). The
-      // captured original handed to the review is the full body, so every line label and context row is
-      // computed against the real document.
-      const changes: Change[] = validation.changes.map((c) => ({
-        ...c,
-        from: c.from + offset,
-        to: c.to + offset,
-      }));
-      tidyReview = { changes, original: body, model };
-      tidyMode = true;
-      tidyApi?.enter(changes);
-    } catch {
-      // An abort (Cancel or the client timeout) or a network/parse failure both map to the same
-      // retryable message; the buffer is untouched.
-      tidyMessage = tidyController?.signal.aborted ? null : 'Tidy could not finish. Try again.';
-    } finally {
-      clearTimeout(timer);
-      tidyController = null;
-      tidyBusy = false;
+    const result = deserialize(await res.text());
+    if (result.type !== "success") {
+      tidyMessage = result.type === "failure" && typeof result.data?.error === "string" && result.data.error !== "csrf" ? result.data.error : "Tidy could not finish. Try again.";
+      return;
     }
-  }
-
-  /** Cancel an in-flight tidy: abort the request and clear the working state. The buffer is untouched. */
-  function cancelTidy() {
-    tidyController?.abort();
+    const corrected = typeof result.data?.corrected === "string" ? result.data.corrected : "";
+    const model = typeof result.data?.model === "string" ? result.data.model : data.tidy.model;
+    if (corrected.length === 0 || corrected === text) {
+      tidyNoop = true;
+      return;
+    }
+    const validation = validateTidy(text, corrected);
+    if (!validation.ok) {
+      tidyMessage = TIDY_REJECTION_MESSAGE;
+      return;
+    }
+    if (validation.changes.length === 0) {
+      tidyNoop = true;
+      return;
+    }
+    const changes = validation.changes.map((c) => ({
+      ...c,
+      from: c.from + offset,
+      to: c.to + offset
+    }));
+    tidyReview = { changes, original: body, model };
+    tidyMode = true;
+    tidyApi?.enter(changes);
+  } catch {
+    tidyMessage = tidyController?.signal.aborted ? null : "Tidy could not finish. Try again.";
+  } finally {
+    clearTimeout(timer);
+    tidyController = null;
     tidyBusy = false;
-    tidyMessage = null;
   }
-
-  /** Close the review: clear tidy mode and the review data. On apply the "Undo tidy" affordance shows
-   *  until the next edit; on cancel nothing changed. */
-  function closeTidyReview(applied: boolean) {
-    tidyMode = false;
-    tidyReview = null;
-    tidyApplied = applied;
-    // Record the body the apply produced, so the next edit (a different body) dismisses the Undo chip.
-    tidyAppliedBody = applied ? body : null;
-  }
-  // The body snapshot right after Apply; the Undo-tidy chip dismisses once the body diverges from it.
-  let tidyAppliedBody = $state<string | null>(null);
-  $effect(() => {
-    const current = body;
-    if (tidyApplied && tidyAppliedBody !== null && current !== tidyAppliedBody) {
-      tidyApplied = false;
-      tidyAppliedBody = null;
-    }
-  });
-  // Undo the whole applied tidy in one move (ordinary editor Undo of the one batched transaction). The
-  // chip names it so the author knows the whole tidy is one move back.
-  function undoTidy() {
-    undoEditor();
+}
+function cancelTidy() {
+  tidyController?.abort();
+  tidyBusy = false;
+  tidyMessage = null;
+}
+function closeTidyReview(applied) {
+  tidyMode = false;
+  tidyReview = null;
+  tidyApplied = applied;
+  tidyAppliedBody = applied ? body : null;
+}
+let tidyAppliedBody = $state(null);
+$effect(() => {
+  const current = body;
+  if (tidyApplied && tidyAppliedBody !== null && current !== tidyAppliedBody) {
     tidyApplied = false;
     tidyAppliedBody = null;
   }
-
-  // The media insert seams, registered by MarkdownEditor on mount, mirroring the range holders
-  // above. The popover drives the optimistic upload loop through them: the caret anchor, the focus
-  // restore, the placeholder api, and the direct-insert path for a picked image. The placeholder
-  // api type is referenced inline (import('...').Type), never a static `import type ... from`, so
-  // no static edge to the dynamically-imported editor-placeholder module sits in this component
-  // (the editor-boundary test bars that edge by a textual `from` scan).
-  let caretCoords = $state.raw<() => { left: number; right: number; top: number; bottom: number } | null>(
-    () => null,
-  );
-  let focusEditor = $state.raw<() => void>(() => {});
-  let placeholders = $state.raw<import('./editor-placeholder.js').ImagePlaceholderApi | null>(null);
-  let insertImageFn = $state.raw<(alt: string, ref: string) => void>(() => {});
-
-  // A no-op placeholder api so the editor object handed to the popover is never null before the
-  // editor registers its real one on mount.
-  const noopPlaceholders: import('./editor-placeholder.js').ImagePlaceholderApi = {
-    begin: () => 0,
-    progress: () => {},
-    resolveTo: () => {},
-    cancel: () => {},
-  };
-
-  // The editor object the popover drives, delegating through the holders so the latest registered
-  // function is always used (the holders start as no-ops and are replaced on mount).
-  const editorApi = $derived({
-    caretCoords: () => caretCoords(),
-    focusEditor: () => focusEditor(),
-    placeholders: placeholders ?? noopPlaceholders,
-    insertImage: (alt: string, ref: string) => insertImageFn(alt, ref),
-  });
-
-  // The headless media insert popover, opened from the toolbar control, paste, or drop.
-  let mediaPopover = $state<MediaInsertPopover | null>(null);
-
-  // The rendered hero fields' refs (for the needs-alt notice's "Add alt text" action, which focuses
-  // the field's own alt input) and their reported needs-alt signals, keyed by field name. A hero is
-  // a frontmatter value with no body offset, so its needs-alt signal comes from the field, not the
-  // body scanner (findMediaImagesNeedingAlt), and its remediation focuses the alt input, never a
-  // source range (selectRange). The records are keyed by field name; `data.fields` is static for the
-  // page's lifetime, so a key never goes stale (no per-key cleanup on unmount is needed).
-  let heroFieldRefs = $state<Record<string, MediaHeroField>>({});
-  let heroNeedsAlt = $state<Record<string, boolean>>({});
-
-  // The server-owned records from each successful upload this session. They ride the save form as
-  // the hidden `media` field, so the save action merges them into media.json.
-  let uploadedRecords = $state<MediaEntry[]>([]);
-  // A headless dialog instance, typed structurally over its exported open() (the linkPicker idiom).
-  type DialogHandle = { open: () => void };
-  // The toolbar's insert dialogs. Each holds its own <form>, so they mount outside the edit form
-  // (a form nested in a form is invalid HTML the parser repairs by dropping the outer tag, which
-  // breaks SSR and hydration); the toolbar snippet renders plain triggers that open them here.
-  let webLinkDialog = $state<DialogHandle | null>(null);
-  let linkPicker = $state<DialogHandle | null>(null);
-  // The insert dialog binds the full instance, not the bare DialogHandle: the Edit-block control
-  // drives editComponent(def, values, range) on it, beyond the shared open().
-  let insertDialog = $state<ComponentInsertDialog | null>(null);
-  // The lifecycle dialogs, opened from the header's overflow menu.
-  let deleteDialog = $state<DialogHandle | null>(null);
-  let renameDialog = $state<DialogHandle | null>(null);
-  // The Markdown cheat sheet, opened from the editor card's footer.
-  let helpDialog = $state<DialogHandle | null>(null);
-  // The keyboard shortcuts sheet, opened from anywhere on the desk by Ctrl+/.
-  let shortcutsDialog = $state<DialogHandle | null>(null);
-
-  // Whether the registry offers anything insertable, the same condition the insert dialog lists
-  // by, so the toolbar trigger and the dialog appear and disappear together.
-  const hasComponents = $derived(insertableDefs(registry).length > 0);
-
-  // The directive container at the editor caret, reported by MarkdownEditor whenever it changes
-  // (null outside any container). The Edit-block control resolves it against the registry and the
-  // round-trip safety gate below; its identity is the key the async gate guards against a stale
-  // result. The reporter's name+markdown+from+to shape; declared locally because MarkdownEditor's
-  // matching interface is not exported.
-  type CaretComponent = { name: string | null; markdown: string; from: number; to: number };
-  let caretComponent = $state<CaretComponent | null>(null);
-
-  // The media image at the editor caret, reported by MarkdownEditor whenever it changes (null off any
-  // media image). The Figure control reads it to wrap a bare image or edit an existing figure; it
-  // writes source through the replaceRange seam. The figure dialog is mounted headless below.
-  let mediaAtCaret = $state<FigureAtImage | null>(null);
-  // The figure control's host <dialog>, opened by the toolbar control. Mounted outside the edit form
-  // (a form nested in a form is invalid HTML), the Edit-block dialog pattern.
-  let figureDialog = $state<HTMLDialogElement | null>(null);
-  // Whether the Figure control is available: a media image sits at the caret and Preview is not
-  // showing (the insert controls disable together with the Write surface). The control is always
-  // rendered (it never mounts on caret move); only its enabled state changes.
-  const figureAvailable = $derived(mediaAtCaret != null && !insertDisabled);
-  const figureLabel = $derived(
-    figureAvailable
-      ? mediaAtCaret?.figure
-        ? 'Edit the figure at the cursor'
-        : 'Wrap the image at the cursor in a figure'
-      : 'Place the cursor on an image to add a figure',
-  );
-  // Whether the image at the caret is decorative (empty or whitespace-only alt). The token came from
-  // a parsed image node, so the alt is the source between `![` and the closing `]` before `](`. An
-  // empty alt is the needs-alt signal; the figure control surfaces it and the decorative-plus-caption
-  // warning. Derived from the reported token so it tracks the caret.
-  const figureDecorative = $derived.by(() => {
-    if (!mediaAtCaret) return false;
-    const token = body.slice(mediaAtCaret.imageFrom, mediaAtCaret.imageTo);
-    const match = /^!\[([\s\S]*?)\]\(/.exec(token);
-    return (match?.[1] ?? '').trim() === '';
-  });
-  // A def is actionable for guided edit when it has a schema (the same notion the insert catalog
-  // lists by): a template-only def has no form to re-open into. Reuses the dialog's exported
-  // hasSchema so the two surfaces can never drift on what counts as editable.
-  function editableDef(name: string | null): ComponentDef | undefined {
-    if (!name) return undefined;
-    const def = registry?.get(name);
-    if (!def) return undefined;
-    return hasSchema(def) ? def : undefined;
+});
+function undoTidy() {
+  undoEditor();
+  tidyApplied = false;
+  tidyAppliedBody = null;
+}
+let caretCoords = $state.raw(
+  () => null
+);
+let focusEditor = $state.raw(() => {
+});
+let placeholders = $state.raw(null);
+let insertImageFn = $state.raw(() => {
+});
+const noopPlaceholders = {
+  begin: () => 0,
+  progress: () => {
+  },
+  resolveTo: () => {
+  },
+  cancel: () => {
   }
-  // The resolved editability: the def, the source range, and the validated markdown when the caret
-  // sits on a known, schema-bearing component whose round-trip safety check passed for the CURRENT
-  // caret; null otherwise. The def, range, and markdown are captured from one caretComponent
-  // snapshot, so editBlock() never mixes a newer markdown with an older range. The Edit-block
-  // control enables only when this is set.
-  let editable = $state<{ def: ComponentDef; range: { from: number; to: number }; markdown: string } | null>(null);
-  // Why edit is unavailable, distinguishing "not on a component" from "on an unsafe one" so the
-  // disabled tooltip is honest. 'none' covers both no-caret-component and an unknown/template-only
-  // one (no guided form either way); 'unsafe' is a known component the safety gate refused.
-  let editReason = $state<'none' | 'unsafe'>('none');
-  // Resolve editability when the caret-component changes, async-safe. componentRoundTripSafety is
-  // async, so a slow check could resolve after a newer caret move; guard latest-wins on the
-  // caretComponent identity (the EditPage preview-debounce pattern), only applying a result when
-  // the caret has not moved since the check started. A block whose check did not pass for the
-  // current caret never enables edit.
-  $effect(() => {
-    const current = caretComponent;
-    const def = editableDef(current?.name ?? null);
-    if (!current || !def) {
+};
+const editorApi = $derived({
+  caretCoords: () => caretCoords(),
+  focusEditor: () => focusEditor(),
+  placeholders: placeholders ?? noopPlaceholders,
+  insertImage: (alt, ref) => insertImageFn(alt, ref)
+});
+let mediaPopover = $state(null);
+let heroFieldRefs = $state({});
+let heroNeedsAlt = $state({});
+let uploadedRecords = $state([]);
+let webLinkDialog = $state(null);
+let linkPicker = $state(null);
+let insertDialog = $state(null);
+let deleteDialog = $state(null);
+let renameDialog = $state(null);
+let helpDialog = $state(null);
+let shortcutsDialog = $state(null);
+const hasComponents = $derived(insertableDefs(registry).length > 0);
+let caretComponent = $state(null);
+let mediaAtCaret = $state(null);
+let figureDialog = $state(null);
+const figureAvailable = $derived(mediaAtCaret != null && !insertDisabled);
+const figureLabel = $derived(
+  figureAvailable ? mediaAtCaret?.figure ? "Edit the figure at the cursor" : "Wrap the image at the cursor in a figure" : "Place the cursor on an image to add a figure"
+);
+const figureDecorative = $derived.by(() => {
+  if (!mediaAtCaret) return false;
+  const token = body.slice(mediaAtCaret.imageFrom, mediaAtCaret.imageTo);
+  const match = /^!\[([\s\S]*?)\]\(/.exec(token);
+  return (match?.[1] ?? "").trim() === "";
+});
+function editableDef(name) {
+  if (!name) return void 0;
+  const def = registry?.get(name);
+  if (!def) return void 0;
+  return hasSchema(def) ? def : void 0;
+}
+let editable = $state(null);
+let editReason = $state("none");
+$effect(() => {
+  const current = caretComponent;
+  const def = editableDef(current?.name ?? null);
+  if (!current || !def) {
+    editable = null;
+    editReason = "none";
+    return;
+  }
+  let stale = false;
+  void componentRoundTripSafety(current.markdown, def).then((result) => {
+    if (stale || caretComponent !== current) return;
+    if (result.safe) {
+      editable = { def, range: { from: current.from, to: current.to }, markdown: current.markdown };
+      editReason = "none";
+    } else {
       editable = null;
-      editReason = 'none';
-      return;
+      editReason = "unsafe";
     }
-    let stale = false;
-    void componentRoundTripSafety(current.markdown, def)
-      .then((result) => {
-        if (stale || caretComponent !== current) return;
-        if (result.safe) {
-          editable = { def, range: { from: current.from, to: current.to }, markdown: current.markdown };
-          editReason = 'none';
-        } else {
-          editable = null;
-          editReason = 'unsafe';
-        }
-      })
-      .catch(() => {
-        // A parse throw during the safety check must never leave a stale block enabled. Guarded by
-        // the same latest-wins identity, fall back to the safe default of no editable block.
-        if (stale || caretComponent !== current) return;
-        editable = null;
-        editReason = 'none';
-      });
-    return () => {
-      stale = true;
-    };
+  }).catch(() => {
+    if (stale || caretComponent !== current) return;
+    editable = null;
+    editReason = "none";
   });
-  // The Edit-block control's accessible label and tooltip: a plain reason in each state. Enabled
-  // names the action; the two disabled reasons are honest about why.
-  const editBlockLabel = $derived(
-    editable
-      ? 'Edit the component at the cursor'
-      : editReason === 'unsafe'
-        ? "This block can't be edited in the form. Edit it as markdown."
-        : 'Place the cursor in a component to edit it',
-  );
-  // Whether the Edit-block control is unavailable: either Preview hides the Write surface, or the
-  // caret is not on a safe, schema-bearing component. The control stays focusable and announced in
-  // this state (aria-disabled, not the native disabled attribute), so its reason reaches assistive
-  // technology; the dead click is made inert in editBlock().
-  const editBlockUnavailable = $derived(insertDisabled || !editable);
-  // Activate edit: parse the block into form values, then open the dialog in edit mode over the
-  // stored source range. Guarded by editable AND the preview-mode disable, so the control is inert
-  // unless the gate passed and the editor is on the Write tab. The def, range, and markdown all come
-  // from the one editable snapshot, so a newer caret markdown is never paired with an older range.
-  async function editBlock() {
-    if (insertDisabled || !editable) return;
-    const values = await parseComponent(editable.markdown, editable.def);
-    insertDialog?.editComponent(editable.def, values, editable.range);
-  }
-
-  // The figure dialog's pre-fill, snapshotted when the control opens so the form never mixes a newer
-  // caret with the values it opened on. Captured from mediaAtCaret at open time: edit mode with the
-  // figure's caption/role when a figure wraps the image, else wrap mode with empty caption and the
-  // measure default. decorative rides the snapshot too. Null while the dialog is closed.
-  let figurePrefill = $state<{
-    mode: 'wrap' | 'edit';
-    caption: string;
-    role: FigureRole | null;
-    decorative: boolean;
-    image: { from: number; to: number };
-    figureRange: { from: number; to: number } | null;
-  } | null>(null);
-
-  // Open the figure control over the media image at the caret. Inert unless a media image sits there
-  // and the Write surface is up, the same gate the toolbar control shows. The snapshot is the source
-  // of truth for the apply handlers, so a caret move while the dialog is open never re-targets it.
-  function openFigure() {
-    if (!figureAvailable || !mediaAtCaret) return;
-    const at = mediaAtCaret;
-    figurePrefill = {
-      mode: at.figure ? 'edit' : 'wrap',
-      caption: at.figure?.caption ?? '',
-      role: at.figure?.role ?? null,
-      decorative: figureDecorative,
-      image: { from: at.imageFrom, to: at.imageTo },
-      figureRange: at.figure ? { from: at.figure.from, to: at.figure.to } : null,
-    };
-    figureDialog?.showModal();
-  }
-
-  // Apply the control's choice through the replaceRange seam, then close. Wrap a bare image or update
-  // an existing figure, off the snapshot the dialog opened on. The pure transform owns the source
-  // shape and keeps the media token byte-intact; the preview stays read-only.
-  function applyFigure(choice: { caption: string; role: FigureRole | null }) {
-    const pre = figurePrefill;
-    if (!pre) return;
-    const result =
-      pre.mode === 'edit' && pre.figureRange
-        ? updateFigure(body, pre.figureRange, choice.caption, choice.role)
-        : wrapImageInFigure(body, pre.image.from, pre.image.to, choice.caption, choice.role);
-    writeFigureResult(result);
-  }
-
-  // Unwrap the figure back to its bare image, then close. Edit mode only (the snapshot carries the
-  // figure range). The bare image token is restored verbatim by the pure transform.
-  function unwrapFigureAction() {
-    const pre = figurePrefill;
-    if (!pre || !pre.figureRange) return;
-    writeFigureResult(unwrapFigure(body, pre.figureRange));
-  }
-
-  // Write a figure transform's result back to the editor: overwrite the whole doc through the
-  // replaceRange seam, then place the selection the transform chose (the seam alone drops the caret
-  // at the end). replaceRange dispatches the doc change and focuses the surface; selectRange then
-  // dispatches a selection-only transaction, which CodeMirror's history does not record as its own
-  // undoable event, so one undo reverts the whole figure write. Close the dialog last.
-  function writeFigureResult(result: { doc: string; from: number; to: number }) {
-    replaceRange(0, body.length, result.doc);
-    selectRange(result.from, result.to);
-    figureDialog?.close();
-  }
-
-  // The header's status badge, in ConceptList's vocabulary: a pending entry reads Edited (or New
-  // when it has never been published); otherwise the live site matches and it reads Published.
-  const status = $derived.by(() => {
-    if (!data.pending) return 'Published';
-    return data.published ? 'Edited' : 'New';
-  });
-  const statusBadge = $derived.by(() => {
-    if (status === 'Edited') return 'badge-warning';
-    if (status === 'New') return 'badge-info';
-    return 'badge-ghost';
-  });
-
-  // The band overflow menu's popover element and its open state, mirrored from the toggle
-  // event into aria-expanded on the trigger.
-  let actionsMenu = $state<HTMLUListElement | null>(null);
-  let actionsOpen = $state(false);
-
-  // The details slide-over. The aside below carries the frontmatter groups; it stays physically
-  // inside the edit form (so the uncontrolled fields submit) but presents as a fixed panel under
-  // the band, hidden when closed so it leaves the a11y tree and the tab order while its
-  // display:none fields still post. Focus moves into the panel on open and returns to the trigger
-  // on close, the region-with-focus-management pattern (the a11y reviewer adjudicates region vs
-  // dialog at the pass gate).
-  let detailsOpen = $state(false);
-  let detailsTrigger = $state<HTMLButtonElement | null>(null);
-  let detailsClose = $state<HTMLButtonElement | null>(null);
-  function openDetails() {
-    // flushSync removes the panel's `hidden` attribute synchronously; a hidden element cannot
-    // take focus, so the close button must be visible before we move focus to it.
-    flushSync(() => (detailsOpen = true));
-    detailsClose?.focus();
+  return () => {
+    stale = true;
+  };
+});
+const editBlockLabel = $derived(
+  editable ? "Edit the component at the cursor" : editReason === "unsafe" ? "This block can't be edited in the form. Edit it as markdown." : "Place the cursor in a component to edit it"
+);
+const editBlockUnavailable = $derived(insertDisabled || !editable);
+async function editBlock() {
+  if (insertDisabled || !editable) return;
+  const values = await parseComponent(editable.markdown, editable.def);
+  insertDialog?.editComponent(editable.def, values, editable.range);
+}
+let figurePrefill = $state(null);
+function openFigure() {
+  if (!figureAvailable || !mediaAtCaret) return;
+  const at = mediaAtCaret;
+  figurePrefill = {
+    mode: at.figure ? "edit" : "wrap",
+    caption: at.figure?.caption ?? "",
+    role: at.figure?.role ?? null,
+    decorative: figureDecorative,
+    image: { from: at.imageFrom, to: at.imageTo },
+    figureRange: at.figure ? { from: at.figure.from, to: at.figure.to } : null
+  };
+  figureDialog?.showModal();
+}
+function applyFigure(choice) {
+  const pre = figurePrefill;
+  if (!pre) return;
+  const result = pre.mode === "edit" && pre.figureRange ? updateFigure(body, pre.figureRange, choice.caption, choice.role) : wrapImageInFigure(body, pre.image.from, pre.image.to, choice.caption, choice.role);
+  writeFigureResult(result);
+}
+function unwrapFigureAction() {
+  const pre = figurePrefill;
+  if (!pre || !pre.figureRange) return;
+  writeFigureResult(unwrapFigure(body, pre.figureRange));
+}
+function writeFigureResult(result) {
+  replaceRange(0, body.length, result.doc);
+  selectRange(result.from, result.to);
+  figureDialog?.close();
+}
+const status = $derived.by(() => {
+  if (!data.pending) return "Published";
+  return data.published ? "Edited" : "New";
+});
+const statusBadge = $derived.by(() => {
+  if (status === "Edited") return "badge-warning";
+  if (status === "New") return "badge-info";
+  return "badge-ghost";
+});
+let actionsMenu = $state(null);
+let actionsOpen = $state(false);
+let detailsOpen = $state(false);
+let detailsTrigger = $state(null);
+let detailsClose = $state(null);
+function openDetails() {
+  flushSync(() => detailsOpen = true);
+  detailsClose?.focus();
+}
+function closeDetails() {
+  detailsOpen = false;
+  detailsTrigger?.focus();
+}
+function toggleDetails() {
+  if (detailsOpen) closeDetails();
+  else openDetails();
+}
+function pickAction(action) {
+  action();
+  if (actionsMenu?.matches(":popover-open")) actionsMenu.hidePopover();
+}
+const brokenLinks = $derived(form?.brokenLinks ?? []);
+let removedLinks = $state([]);
+const visibleBrokenLinks = $derived(brokenLinks.filter((h) => !removedLinks.includes(h)));
+function removeBrokenLink(href) {
+  const next = unwrapCairnLink(body, href);
+  if (next !== body) {
+    body = next;
+    removedLinks = [...removedLinks, href];
   }
-  function closeDetails() {
+}
+const needsAlt = $derived(findMediaImagesNeedingAlt(body));
+const imageFields = $derived(
+  data.fields.filter((f) => f.type === "image").map((f) => ({ name: f.name, label: f.label }))
+);
+const heroRows = $derived(imageFields.filter((f) => heroNeedsAlt[f.name]));
+const needsAltCount = $derived(needsAlt.length + heroRows.length);
+const renderNotices = $derived([
+  ...data.advisories.map((notice) => ({
+    kind: notice.kind,
+    message: notice.message,
+    rows: (notice.actions ?? []).map((action) => ({ label: action.label, href: action.href }))
+  })),
+  ...needsAltCount ? [
+    {
+      kind: "needs-alt",
+      message: `${needsAltCount} ${needsAltCount === 1 ? "image needs" : "images need"} alt text`,
+      detail: "Alt text describes an image for readers who cannot see it. Add it now, or save and come back to it.",
+      rows: [
+        ...needsAlt.map((item) => ({
+          rowLabel: item.ref,
+          rowCode: true,
+          label: "Add alt text",
+          onAct: () => selectRange(item.from, item.to)
+        })),
+        ...heroRows.map((hero) => ({
+          rowLabel: hero.label,
+          label: "Add alt text",
+          onAct: () => heroFieldRefs[hero.name]?.focusAlt()
+        }))
+      ]
+    }
+  ] : []
+]);
+const deleteRefusedLinks = $derived(form?.inboundLinks ?? []);
+const formError = $derived(
+  form?.error && !form.brokenLinks?.length && !form.inboundLinks?.length ? form.error : ""
+);
+const entryKey = $derived(data.conceptId + "/" + data.id);
+let seededKey = untrack(() => entryKey);
+$effect.pre(() => {
+  const key = entryKey;
+  if (key === seededKey) return;
+  seededKey = key;
+  untrack(() => {
+    body = form?.body ?? data.body;
+    saving = false;
+    publishing = false;
+    leaving = false;
+    fieldsDirty = false;
+    mode = "write";
     detailsOpen = false;
-    detailsTrigger?.focus();
-  }
-  function toggleDetails() {
-    if (detailsOpen) closeDetails();
-    else openDetails();
-  }
-
-  // An overflow-menu pick runs its action, then dismisses the popover menu. Opening a modal
-  // dialog already closes an auto popover, so the explicit hide fires only when the menu is
-  // still up.
-  function pickAction(action: () => void) {
-    action();
-    if (actionsMenu?.matches(':popover-open')) actionsMenu.hidePopover();
+    previewHtml = "";
+    previewFailed = false;
+    removedLinks = [];
+  });
+});
+const draftWarning = $derived.by(() => {
+  const drafts = page.url.searchParams.get("drafts");
+  return drafts ? drafts.split(",").filter(Boolean).join(", ") : "";
+});
+const flash = $derived.by(() => {
+  if (data.saved && !draftWarning)
+    return "Saved. Your site keeps showing the published version until you publish.";
+  if (data.publishedFlash) return "Published. The live site is rebuilding.";
+  if (data.discardedFlash) return "Changes discarded.";
+  if (data.renamed) return `The URL is now ${data.slug}.`;
+  return "";
+});
+const politeMessage = $derived(
+  draftWarning ? `Saved. This page links to unpublished pages: ${draftWarning}.` : flash
+);
+const assertiveMessage = $derived.by(() => {
+  if (data.error) return data.error;
+  if (formError) return formError;
+  if (deleteRefusedLinks.length) {
+    const count = deleteRefusedLinks.length;
+    return `This ${data.label.toLowerCase()} could not be deleted. ${count} ${count === 1 ? "page links" : "pages link"} to it.`;
   }
-
-  // The save guard's broken links, from the blocked action result. The fix unwraps a link in the
-  // local body, which the bound editor reconciles, so the author re-saves clean.
-  const brokenLinks = $derived(form?.brokenLinks ?? []);
-  // Track the hrefs the author has already fixed this session. The banner reads the immutable action
-  // result, so without this a fixed row would linger and "Remove link" would read as a no-op.
-  let removedLinks = $state<string[]>([]);
-  const visibleBrokenLinks = $derived(brokenLinks.filter((h) => !removedLinks.includes(h)));
-  function removeBrokenLink(href: string) {
-    // Hide the row only when the unwrap changed the body. A genuine no-op keeps the row honest.
-    const next = unwrapCairnLink(body, href);
-    if (next !== body) {
-      body = next;
-      removedLinks = [...removedLinks, href];
-    }
+  if (visibleBrokenLinks.length) {
+    const count = visibleBrokenLinks.length;
+    return `This page links to ${count} missing ${count === 1 ? "page" : "pages"}.`;
   }
-
-  // The media images in the live body that carry no alt text, recomputed as the author types. Alt is
-  // accessibility debt, never a render or publish failure, so this drives a non-blocking warning the
-  // author can act on or leave; the count drops and the notice clears as each alt is filled.
-  const needsAlt = $derived(findMediaImagesNeedingAlt(body));
-
-  // The declared image (hero) fields, for labelling the needs-alt notice's frontmatter rows.
-  const imageFields = $derived(
-    data.fields.filter((f) => f.type === 'image').map((f) => ({ name: f.name, label: f.label })),
-  );
-  // The frontmatter-hero needs-alt rows: each image field whose hero reports a needs-alt signal. The
-  // row's action focuses the field's alt input (the body scanner and its source-range jump cannot
-  // reach a frontmatter value). The headline count sums these with the body scanner's hits.
-  const heroRows = $derived(imageFields.filter((f) => heroNeedsAlt[f.name]));
-  const needsAltCount = $derived(needsAlt.length + heroRows.length);
-
-  // The delete guard's inbound linkers, from a refused delete (fail 409). Empty when the delete was
-  // not refused. When set, a delete was blocked by a link that appeared since the page loaded.
-  const deleteRefusedLinks = $derived(form?.inboundLinks ?? []);
-
-  // The shared failure summary, rendered only when no richer banner claims the failure: the save
-  // and delete guards get their own banners from brokenLinks and inboundLinks below, so this
-  // surfaces the rest (a rename refusal, today).
-  const formError = $derived(
-    form?.error && !form.brokenLinks?.length && !form.inboundLinks?.length ? form.error : '',
-  );
-
-  // The entry this surface is editing. SvelteKit reuses the page component across a same-route
-  // navigation (the delete-refused and broken-link banners link entry to entry), so the per-entry
-  // state seeded at init would survive the hop and show entry A's body over entry B's data with
-  // the dirty indicator armed. When the identity changes, re-seed the state here; the {#key}
-  // block around the template remounts the DOM to match (CodeMirror with its undo history, the
-  // uncontrolled sidebar fields, any open dialog). The leave guard still protects the hop:
-  // beforeNavigate runs before the navigation completes, so it reads the old dirty value.
-  const entryKey = $derived(data.conceptId + '/' + data.id);
-  let seededKey = untrack(() => entryKey);
-  $effect.pre(() => {
-    const key = entryKey;
-    if (key === seededKey) return;
-    seededKey = key;
-    untrack(() => {
-      body = form?.body ?? data.body;
-      saving = false;
-      publishing = false;
-      leaving = false;
-      fieldsDirty = false;
-      mode = 'write';
-      detailsOpen = false;
-      previewHtml = '';
-      previewFailed = false;
-      removedLinks = [];
-    });
-  });
-
-  // After a save that links to a draft target, the redirect carries ?drafts=<tokens>. page.url
-  // is reactive kit state, so a client-side navigation that swaps the search string re-derives
-  // this, and the read is SSR-safe.
-  const draftWarning = $derived.by(() => {
-    const drafts = page.url.searchParams.get('drafts');
-    return drafts ? drafts.split(',').filter(Boolean).join(', ') : '';
-  });
-
-  // The one transient feedback strip under the sticky header. The redirect flags are mutually
-  // exclusive in practice; the chain picks one so a surprise overlap still renders a single strip.
-  // A saved flash with a draft warning yields to the warning alert below, the prior behavior.
-  const flash = $derived.by(() => {
-    if (data.saved && !draftWarning)
-      return 'Saved. Your site keeps showing the published version until you publish.';
-    if (data.publishedFlash) return 'Published. The live site is rebuilding.';
-    if (data.discardedFlash) return 'Changes discarded.';
-    if (data.renamed) return `The URL is now ${data.slug}.`;
-    return '';
-  });
-
-  // One persistent live region announces the current message, since a {#if}-gated role element
-  // inserted fresh is announced inconsistently. A polite region carries the success and draft
-  // notices (the flash, plus the draft notice the strip yields to); an assertive region carries
-  // the errors. The visible banners below keep their styling but drop their roles, so a message
-  // is announced once.
-  const politeMessage = $derived(
-    draftWarning ? `Saved. This page links to unpublished pages: ${draftWarning}.` : flash,
-  );
-  const assertiveMessage = $derived.by(() => {
-    if (data.error) return data.error;
-    if (formError) return formError;
-    if (deleteRefusedLinks.length) {
-      const count = deleteRefusedLinks.length;
-      return `This ${data.label.toLowerCase()} could not be deleted. ${count} ${count === 1 ? 'page links' : 'pages link'} to it.`;
-    }
-    if (visibleBrokenLinks.length) {
-      const count = visibleBrokenLinks.length;
-      return `This page links to ${count} missing ${count === 1 ? 'page' : 'pages'}.`;
-    }
-    return '';
-  });
-
-  // One line of body text reduced to its prose: inline directives drop wholesale, then the
-  // markdown marker characters become spaces. Spacing rather than deleting keeps "[text](url)"
-  // as two words instead of mashing the link text into its destination, so a link counts its
-  // text plus its URL and the count never undercounts prose.
-  function proseOnly(line: string): string {
-    let out = '';
-    let cursor = 0;
-    for (const { from, to } of findInlineDirectives(line)) {
-      out += line.slice(cursor, from);
-      cursor = to;
-    }
-    out += line.slice(cursor);
-    return out.replace(/[*_~`[\]()#]/g, ' ');
+  return "";
+});
+function proseOnly(line) {
+  let out = "";
+  let cursor = 0;
+  for (const { from, to } of findInlineDirectives(line)) {
+    out += line.slice(cursor, from);
+    cursor = to;
   }
-
-  // The editor footer's word count, over the local body so it tracks every keystroke. Directive
-  // machinery lines and table rows are dropped first and the inline syntax stripped, so the
-  // count reads as the author's prose.
-  const countedBody = $derived(
-    body
-      .split('\n')
-      .filter((line) => directiveLineKind(line) === null && !/^\s*\|/.test(line))
-      .map(proseOnly)
-      .join('\n'),
-  );
-  const wordCount = $derived(countedBody.trim() ? countedBody.trim().split(/\s+/).length : 0);
-  const wordLabel = $derived(wordCount === 1 ? '1 word' : `${wordCount} words`);
-
-  // The manifest-backed resolver turns a cairn: link into its live permalink in the preview, and
-  // returns undefined for a missing target so the render step marks it cairn-broken-link.
-  const resolveLink = $derived(manifestLinkResolver(data.linkTargets));
-
-  // The media analog: it turns a media: reference into its /media delivery path in the preview, and
-  // returns undefined for a missing target so the render step marks it cairn-broken-media. The
-  // committed mediaTargets projection is merged with this session's uploaded records (the same
-  // override the picker's library does), so a just-uploaded image renders its thumbnail in the live
-  // preview before the next save commits it, rather than reading as a broken reference.
-  const resolveMediaTargets = $derived({
-    ...data.mediaTargets,
-    ...Object.fromEntries(
-      uploadedRecords.map((r) => [r.hash, { slug: r.slug, ext: r.ext, contentType: r.contentType }]),
-    ),
-  });
-  const resolveMedia = $derived(manifestMediaResolver(resolveMediaTargets));
-
-  // The picker's library, the committed projection merged with this session's uploaded records,
-  // keyed by content hash. An uploaded record overrides a committed entry on a hash match (the same
-  // hash is the same bytes, so the override is harmless). This is what the editor decorates with, so
-  // a just-uploaded image carries its source chip before the next save commits it.
-  const mediaLibrary = $derived({
-    ...data.mediaLibrary,
-    ...Object.fromEntries(uploadedRecords.map((r) => [r.hash, mediaLibraryEntry(r)])),
-  });
-
-  // The [[ autocomplete source over the same link targets, handed to the editor's generic seam.
-  const completionSources = $derived([cairnLinkCompletionSource(data.linkTargets)]);
-
-  function setMode(m: 'write' | 'preview') {
-    mode = m;
+  out += line.slice(cursor);
+  return out.replace(/[*_~`[\]()#]/g, " ");
+}
+const countedBody = $derived(
+  body.split("\n").filter((line) => directiveLineKind(line) === null && !/^\s*\|/.test(line)).map(proseOnly).join("\n")
+);
+const wordCount = $derived(countedBody.trim() ? countedBody.trim().split(/\s+/).length : 0);
+const wordLabel = $derived(wordCount === 1 ? "1 word" : `${wordCount} words`);
+const resolveLink = $derived(manifestLinkResolver(data.linkTargets));
+const resolveMediaTargets = $derived({
+  ...data.mediaTargets,
+  ...Object.fromEntries(
+    uploadedRecords.map((r) => [r.hash, { slug: r.slug, ext: r.ext, contentType: r.contentType }])
+  )
+});
+const resolveMedia = $derived(manifestMediaResolver(resolveMediaTargets));
+const mediaLibrary = $derived({
+  ...data.mediaLibrary,
+  ...Object.fromEntries(uploadedRecords.map((r) => [r.hash, mediaLibraryEntry(r)]))
+});
+const completionSources = $derived([cairnLinkCompletionSource(data.linkTargets)]);
+function setMode(m) {
+  mode = m;
+}
+let editorCard = $state(null);
+$effect(() => {
+  const card = editorCard;
+  if (!card) return;
+  card.addEventListener("keydown", onEditorKeydown);
+  return () => card.removeEventListener("keydown", onEditorKeydown);
+});
+function onEditorKeydown(e) {
+  if (!(e.ctrlKey || e.metaKey)) return;
+  const key = e.key.toLowerCase();
+  const fmt = formatForKeydown(e);
+  if (fmt) {
+    e.preventDefault();
+    format(fmt);
+  } else if (key === "b") {
+    e.preventDefault();
+    format("bold");
+  } else if (key === "i") {
+    e.preventDefault();
+    format("italic");
+  } else if (key === "k") {
+    e.preventDefault();
+    webLinkDialog?.open();
   }
-
-  // The editor card's keyboard shortcuts. Bound to the card so they fire wherever focus sits in the
-  // strip or the surface, without claiming the keys page-wide. The listener attaches
-  // programmatically: it is event delegation, not an interaction affordance, which Svelte's a11y
-  // rule cannot tell apart on a declarative handler.
-  let editorCard = $state<HTMLDivElement | null>(null);
-  $effect(() => {
-    const card = editorCard;
-    if (!card) return;
-    card.addEventListener('keydown', onEditorKeydown);
-    return () => card.removeEventListener('keydown', onEditorKeydown);
-  });
-  function onEditorKeydown(e: KeyboardEvent) {
-    if (!(e.ctrlKey || e.metaKey)) return;
-    const key = e.key.toLowerCase();
-    // The shifted-digit list trio (Ctrl+Shift+9/8/7) arrives as '('/'*'/'&' for e.key on US
-    // layouts, so the digit identity comes from e.code; the heading pair rides Ctrl+Alt+2/3.
-    const fmt = formatForKeydown(e);
-    if (fmt) {
-      e.preventDefault();
-      format(fmt);
-    } else if (key === 'b') {
-      e.preventDefault();
-      format('bold');
-    } else if (key === 'i') {
-      e.preventDefault();
-      format('italic');
-    } else if (key === 'k') {
-      e.preventDefault();
-      webLinkDialog?.open();
-    }
+}
+function formatForKeydown(e) {
+  if (e.altKey) {
+    if (e.key === "2") return "h2";
+    if (e.key === "3") return "h3";
+    return null;
   }
-  // Maps the format-key chords to their FormatKind. Inline code is the plain Ctrl+E; quote and the
-  // two lists are Ctrl+Shift with the digit read from e.code (the shifted key glyph is layout
-  // dependent); the headings are the Ctrl+Alt+2/3 Google Docs idiom.
-  function formatForKeydown(e: KeyboardEvent): FormatKind | null {
-    if (e.altKey) {
-      if (e.key === '2') return 'h2';
-      if (e.key === '3') return 'h3';
-      return null;
-    }
-    if (e.shiftKey) {
-      if (e.code === 'Digit9') return 'quote';
-      if (e.code === 'Digit8') return 'ul';
-      if (e.code === 'Digit7') return 'ol';
-      return null;
-    }
-    if (e.key.toLowerCase() === 'e') return 'code';
+  if (e.shiftKey) {
+    if (e.code === "Digit9") return "quote";
+    if (e.code === "Digit8") return "ul";
+    if (e.code === "Digit7") return "ol";
     return null;
   }
-
-  // Render the design-accurate preview as the body changes, debounced. The site's render is the
-  // floored engine pipeline, so its output is already sanitized; the preview mirrors the page.
-  // previewRun is a plain counter (not reactive state) used as a latest-wins guard: if a slow earlier
-  // async render call resolves after a newer one has started, the stale result is discarded.
-  let previewRun = 0;
-  $effect(() => {
-    if (mode !== 'preview' || !render) return;
-    const md = body;
-    const resolve = resolveLink; // tracked read in the effect body
-    const resolveMediaRef = resolveMedia; // tracked read in the effect body
-    const run = ++previewRun;
-    const handle = setTimeout(async () => {
-      try {
-        const html = await render(md, { resolve, resolveMedia: resolveMediaRef });
-        if (run === previewRun) {
-          previewHtml = html;
-          previewFailed = false;
-        }
-      } catch {
-        if (run === previewRun) {
-          previewHtml = '';
-          previewFailed = true;
-        }
+  if (e.key.toLowerCase() === "e") return "code";
+  return null;
+}
+let previewRun = 0;
+$effect(() => {
+  if (mode !== "preview" || !render) return;
+  const md = body;
+  const resolve = resolveLink;
+  const resolveMediaRef = resolveMedia;
+  const run = ++previewRun;
+  const handle = setTimeout(async () => {
+    try {
+      const html = await render(md, { resolve, resolveMedia: resolveMediaRef });
+      if (run === previewRun) {
+        previewHtml = html;
+        previewFailed = false;
       }
-    }, 150);
-    return () => {
-      clearTimeout(handle);
-      // Every re-run and the final teardown invalidate the in-flight render. The entry-key reset
-      // above cannot reach this counter, so without the bump a slow render for entry A could
-      // resolve after a same-route hop and write A's html into entry B's pane.
-      previewRun++;
-    };
-  });
-
-  // Coerce a frontmatter value to a string for text/date/textarea inputs.
-  function str(v: unknown): string {
-    return v == null ? '' : String(v);
-  }
-
-  // The eyebrow legend each sidebar group opens with, one class string for all three.
-  const eyebrowClass =
-    'mb-2 text-[0.6875rem] font-semibold uppercase tracking-[0.08em] text-[var(--color-muted)]';
-
-  // The sidebar's grouping. The title field hoists above the editor card as the document title,
-  // and a boolean named draft becomes the Visibility group's Hidden toggle (both production
-  // adapters use that name); everything else is a Details field.
-  const titleField = $derived(data.fields.find((f) => f.name === 'title'));
-  const draftField = $derived(data.fields.find((f) => f.type === 'boolean' && f.name === 'draft'));
-  const detailFields = $derived(data.fields.filter((f) => f !== titleField && f !== draftField));
+    } catch {
+      if (run === previewRun) {
+        previewHtml = "";
+        previewFailed = true;
+      }
+    }
+  }, 150);
+  return () => {
+    clearTimeout(handle);
+    previewRun++;
+  };
+});
+function str(v) {
+  return v == null ? "" : String(v);
+}
+const eyebrowClass = "mb-2 text-[0.6875rem] font-semibold uppercase tracking-[0.08em] text-[var(--color-muted)]";
+const titleField = $derived(data.fields.find((f) => f.name === "title"));
+const draftField = $derived(data.fields.find((f) => f.type === "boolean" && f.name === "draft"));
+const detailFields = $derived(data.fields.filter((f) => f !== titleField && f !== draftField));
+const DATE_PUBLISH_HINT = "Sets the date for this post. Publishing is a separate step you choose.";
 </script>
 
 <!-- The desk controls live in the one header band: AdminLayout renders this snippet through the
@@ -1342,6 +869,17 @@ count, the Prose/Markup posture pair, the focus and typewriter toggles, and the
   </div>
 {/snippet}
 
+<!-- The author-facing hint under a Details field. The id pairs with the input's aria-describedby
+     (`<name>-hint`); its uniqueness rests on schema field names being unique within a concept, which
+     is also the loop key. So assistive tech announces the sentence without bloating the accessible
+     name. Each field branch decides whether and where to render it; this snippet holds the one shape.
+     The `fld-hint` class is a styling hook with no rule today; the Tailwind utilities do the work. -->
+{#snippet fieldHint(name: string, text: string)}
+  <p id={`${name}-hint`} class="fld-hint mt-1 text-sm text-[var(--color-muted)]">
+    {text}
+  </p>
+{/snippet}
+
 <!-- The whole edit surface remounts when navigation lands on another entry (see the entryKey
      reset above); script-level state and the beforeNavigate registration sit outside the block,
      so only the template rebuilds. -->
@@ -1388,44 +926,61 @@ count, the Prose/Markup posture pair, the focus and typewriter toggles, and the
     </ul>
   </div>
 {/if}
-<!-- The publish-time needs-alt notice: a non-blocking warning, never a block. Alt text is
-     accessibility debt, so the author can add it now or save without it; the count drops live as
-     each alt is filled and the notice clears at zero. The leading glyph carries the state alongside
-     the count, so the caution reads without relying on hue. Each row's jump control selects the
-     image in the source through the editor's select-range seam, landing the author on it to type
-     the alt. The role="status" live region renders unconditionally (present and empty at load), so
-     when the first debt appears its count change announces; a region conditionally mounted with its
-     first content may not be observed by assistive tech (WCAG 4.1.3). The visible alert chrome and
-     content gate on the count, so an empty region shows nothing. A plain wrapper (not display:contents)
-     carries the role, since some assistive tech drops a role off a display:contents box. -->
-<div role="status">
-  {#if needsAltCount}
+<!-- The shared advisory notices: one live-region surface for every non-blocking editor warning. It
+     carries the server's address-collision advisory and the client-derived needs-alt notice through
+     one snippet. Each renders as one alert-warning row: the caution glyph, the message, an optional
+     detail sentence, and a list of action rows. Each is a warning, never a block: the author can act
+     on it or save without it. The leading glyph carries the state alongside the message, so the
+     caution reads without relying on hue. A row with an href is a server advisory's link; a row with
+     onAct is the needs-alt jump that runs an editor callback (selecting the image source, or focusing
+     a hero alt input). -->
+<!-- Keyed by index, not by notice.kind: the kind is a free string with no uniqueness constraint, so
+     two notices of one kind would otherwise throw each_key_duplicate. The list is append-only and
+     never reordered, so the index is a stable key here. -->
+{#snippet advisoryNotices(notices: RenderNotice[])}
+  {#each notices as notice, i (i)}
     <div class="alert alert-warning mb-4 flex-col items-start text-sm">
       <p class="flex items-center gap-2 font-medium">
         <svg class="h-4 w-4 shrink-0" viewBox="0 0 24 24" fill="none" stroke="currentColor" aria-hidden="true">
           <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v4m0 4h.01M10.29 3.86 1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" />
         </svg>
-        <span>{needsAltCount} {needsAltCount === 1 ? 'image needs' : 'images need'} alt text</span>
+        <span>{notice.message}</span>
       </p>
-      <p>Alt text describes an image for readers who cannot see it. Add it now, or save and come back to it.</p>
-      <ul class="mt-1 w-full">
-        {#each needsAlt as item (item.from)}
-          <li class="flex items-center justify-between gap-2">
-            <code class="text-xs">{item.ref}</code>
-            <button type="button" class="btn btn-xs" onclick={() => selectRange(item.from, item.to)}>Add alt text</button>
-          </li>
-        {/each}
-        <!-- The frontmatter-hero rows: a hero has no body offset, so its action focuses the field's
-             own alt input rather than a source range. -->
-        {#each heroRows as hero (hero.name)}
-          <li class="flex items-center justify-between gap-2">
-            <span class="text-xs font-medium">{hero.label}</span>
-            <button type="button" class="btn btn-xs" onclick={() => heroFieldRefs[hero.name]?.focusAlt()}>Add alt text</button>
-          </li>
-        {/each}
-      </ul>
+      {#if notice.detail}
+        <p>{notice.detail}</p>
+      {/if}
+      {#if notice.rows.length}
+        <ul class="mt-1 w-full">
+          {#each notice.rows as row, i (i)}
+            <li class="flex items-center justify-between gap-2">
+              {#if row.rowLabel}
+                <!-- A body needs-alt row labels with its source reference in a code span; a hero row
+                     and any future labelled row use a plain label. -->
+                {#if row.rowCode}
+                  <code class="text-xs">{row.rowLabel}</code>
+                {:else}
+                  <span class="text-xs font-medium">{row.rowLabel}</span>
+                {/if}
+              {/if}
+              {#if row.href}
+                <a class="btn btn-xs" href={row.href}>{row.label}</a>
+              {:else}
+                <button type="button" class="btn btn-xs" onclick={row.onAct}>{row.label}</button>
+              {/if}
+            </li>
+          {/each}
+        </ul>
+      {/if}
     </div>
-  {/if}
+  {/each}
+{/snippet}
+<!-- The role="status" live region renders unconditionally (present and empty at load), so when the
+     first notice appears it announces; a region conditionally mounted with its first content may not
+     be observed by assistive tech (WCAG 4.1.3). The notices gate on their own presence, so an empty
+     region shows nothing. A plain wrapper (not display:contents) carries the role, since some
+     assistive tech drops a role off a display:contents box. -->
+<div role="status">
+  {@render advisoryNotices(renderNotices)}
 </div>
 {#if draftWarning}
   <div class="alert alert-warning mb-4 text-sm">
@@ -1817,23 +1372,37 @@ count, the Prose/Markup posture pair, the focus and typewriter toggles, and the
           {@const f = field as TextareaField}
           <label class="flex flex-col gap-1">
             <span class="text-sm font-medium">{f.label}</span>
-            <textarea class="textarea textarea-sm" name={f.name} aria-label={f.label} rows={f.rows ?? 3}>{str(data.frontmatter[f.name])}</textarea>
+            <textarea class="textarea textarea-sm" name={f.name} aria-label={f.label} aria-describedby={f.description ? `${f.name}-hint` : undefined} rows={f.rows ?? 3}>{str(data.frontmatter[f.name])}</textarea>
+            {#if f.description}
+              {@render fieldHint(f.name, f.description)}
+            {/if}
           </label>
         {:else if field.type === 'date'}
           <label class="flex flex-col gap-1">
             <span class="text-sm font-medium">{field.label}</span>
-            <input class="input input-sm" type="date" name={field.name} aria-label={field.label} value={str(data.frontmatter[field.name])} />
+            <!-- A date field always carries a hint: the adapter's description when set, else the
+                 built-in publish-clarity default. So aria-describedby always points at the paragraph. -->
+            <input class="input input-sm" type="date" name={field.name} aria-label={field.label} aria-describedby={`${field.name}-hint`} value={str(data.frontmatter[field.name])} />
+            {@render fieldHint(field.name, field.description || DATE_PUBLISH_HINT)}
           </label>
         {:else if field.type === 'boolean'}
-          <label class="label cursor-pointer justify-start gap-2">
-            <input class="checkbox checkbox-sm" type="checkbox" name={field.name} aria-label={field.label} checked={data.frontmatter[field.name] === true} />
-            <span class="text-sm">{field.label}</span>
-          </label>
+          <div class="flex flex-col gap-1">
+            <label class="label cursor-pointer justify-start gap-2">
+              <input class="checkbox checkbox-sm" type="checkbox" name={field.name} aria-label={field.label} aria-describedby={field.description ? `${field.name}-hint` : undefined} checked={data.frontmatter[field.name] === true} />
+              <span class="text-sm">{field.label}</span>
+            </label>
+            {#if field.description}
+              {@render fieldHint(field.name, field.description)}
+            {/if}
+          </div>
         {:else if field.type === 'tags'}
           {@const f = field as TagsField}
           {@const selected = (data.frontmatter[f.name] ?? []) as string[]}
-          <fieldset class="fieldset">
+          <fieldset class="fieldset" aria-describedby={f.description ? `${f.name}-hint` : undefined}>
             <legend class="fieldset-legend">{f.label}</legend>
+            {#if f.description}
+              {@render fieldHint(f.name, f.description)}
+            {/if}
             <div class="flex flex-wrap gap-2">
               {#each f.options as option (option)}
                 <label class="label cursor-pointer justify-start gap-2">
@@ -1858,9 +1427,13 @@ count, the Prose/Markup posture pair, the focus and typewriter toggles, and the
               class="input input-sm"
               name={f.name}
               aria-label={f.label}
+              aria-describedby={f.description ? `${f.name}-hint` : undefined}
               placeholder={f.placeholder}
               value={tagValue}
             />
+            {#if f.description}
+              {@render fieldHint(f.name, f.description)}
+            {/if}
           </label>
         {:else if field.type === 'image'}
           {@const heroValue = data.frontmatter[field.name] as ImageValue | undefined}
@@ -1879,7 +1452,10 @@ count, the Prose/Markup posture pair, the focus and typewriter toggles, and the
         {:else}
           <label class="flex flex-col gap-1">
             <span class="text-sm font-medium">{field.label}</span>
-            <input class="input input-sm" name={field.name} aria-label={field.label} value={str(data.frontmatter[field.name])} required={field.required} />
+            <input class="input input-sm" name={field.name} aria-label={field.label} aria-describedby={field.description ? `${field.name}-hint` : undefined} value={str(data.frontmatter[field.name])} required={field.required} />
+            {#if field.description}
+              {@render fieldHint(field.name, field.description)}
+            {/if}
           </label>
         {/if}
       {/each}