canopycms 0.0.68-int.98 → 0.1.0

package/dist/editor/Editor.js

@@ -1,39 +1,76 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useState, useRef } from 'react';
-import { ActionIcon, Alert, Box, Drawer, Group, Menu, Paper, Text, Title, } from '@mantine/core';
-import { IconChevronDown, IconChevronUp, IconDots, IconFolderPlus, IconPlus, } from '@tabler/icons-react';
+import { ActionIcon, Alert, Box, Button, Menu, Paper, Skeleton, Stack, Text, Tooltip, } from '@mantine/core';
+import { IconChevronDown, IconChevronUp, IconDots, IconFolderPlus, IconPlus, IconSearch, } from '@tabler/icons-react';
+import { useMediaQuery } from '@mantine/hooks';
 import { notifications } from '@mantine/notifications';
+const noop = () => { };
 import { EntryNavigator } from './EntryNavigator.js';
 import { FormRenderer } from './FormRenderer.js';
-import { PreviewFrame } from './preview-bridge.js';
-import { EditorPanes } from './EditorPanes.js';
+import { PreviewPane } from './PreviewPane.js';
+import { clientOperatingStrategy } from '../operating-mode/client.js';
+import { EditorShell } from './shell/EditorShell.js';
+import { PaneLayout } from './shell/PaneLayout.js';
+import { SidePanelHost } from './shell/SidePanelHost.js';
 import { CanopyCMSProvider } from './theme.js';
 import { BranchManager } from './BranchManager.js';
+import { BranchesDrawer } from './components/BranchesDrawer.js';
 import { CommentsPanel } from './CommentsPanel.js';
 import { GroupManager } from './GroupManager.js';
 import { PermissionManager } from './PermissionManager.js';
 import { SystemHealthPanel } from './admin/SystemHealthPanel.js';
 // Import directly from helpers to avoid server-only code in authorization barrel
-import { isAdmin } from '../authorization/helpers.js';
-import { buildPreviewSrc, buildCollectionLabels, buildBreadcrumbSegments } from './editor-utils.js';
+import { isAdmin, isPrivileged, isReviewer } from '../authorization/helpers.js';
+import { fieldBreadcrumb } from './field-breadcrumb.js';
+import { buildPreviewRoute, buildPreviewSrc, buildCollectionLabels, entryStatusLabel, entryTypeLabel, buildBreadcrumbSegments, } from './editor-utils.js';
 import { useEditorLayout, useDraftManager, useEntryManager, useGroupManager, usePermissionManager, useCommentSystem, useBranchManager, useUserContext, useSchemaManager, } from './hooks/index.js';
 import { useBranchActions } from './hooks/useBranchActions.js';
+import { CONTENT_PANEL_WIDTH_MAX, CONTENT_PANEL_WIDTH_MIN, editorLayoutStorageKey, } from './hooks/useEditorLayout.js';
+import { EntrySchemaUnavailableError } from './hooks/useEntryManager.js';
 import { useEntryLinkResolution } from './hooks/useEntryLinkResolution.js';
-import { EditorFooter, EditorHeader, EditorSidebar } from './components/index.js';
+import { useReferenceResolution } from './hooks/useReferenceResolution.js';
+import { usePreviewMarks } from './hooks/usePreviewMarks.js';
+import { BranchLockBanner, EditorHeader, EditorRail } from './components/index.js';
+import { showSaveAllResult } from './components/SaveAllResult.js';
 import { RenameEntryModal } from './components/RenameEntryModal.js';
+import { QuickOpenPalette } from './components/QuickOpenPalette.js';
+import { rememberOpener, returnTarget } from './utils/focus-return.js';
+import { modKeyLabel } from './platform.js';
+import { EDITOR_ACTIONS } from './copy.js';
 import { EntryCreateModal } from './components/EntryCreateModal.js';
 import { ConfirmDeleteModal } from './components/ConfirmDeleteModal.js';
+import { ReferencedByList, referencedDeleteMessage } from './components/ReferencedByList.js';
 import { NoEditPermissionNotice } from './components/NoEditPermissionNotice.js';
-import { CollectionEditor } from './schema-editor/index.js';
-import { AssetContextProvider, useApiClient } from './context/index.js';
+import { ReadOnlyDraftNotice } from './components/ReadOnlyDraftNotice.js';
+import { UnavailableEntryNotice } from './components/UnavailableEntryNotice.js';
+import { unavailableSchemaRefs } from './unavailable-entry-type.js';
+import { EditorCrashBoundary } from './components/EditorCrashScreen.js';
+import { CollectionEditor, } from './schema-editor/index.js';
+import { collectionDraftLanded } from './schema-editor/collection-draft.js';
+import { hideCollectionOutcomeUnknown } from './hooks/useSchemaManager.js';
+import { AssetContextProvider, SiteMdxAllowContext, authenticatedAssetBase, useApiClient, } from './context/index.js';
 import { EntryLinkContext } from './fields/entry-link/index.js';
 import { MediaLibrary } from './media/MediaLibrary.js';
+import { removalAnchors, restoreRemoval, openThreadsWithin, restoredFieldPath, } from './undo-removal.js';
+import { formatCanopyPath } from './canopy-path.js';
+import { itemKeysOnPath, resolveThreadPath, withItemKeys } from '../item-keys.js';
+import { ENTRY_NOT_LOADED_COMMENT_MESSAGE, NEW_ITEM_COMMENT_MESSAGE, } from './comments/item-anchor-copy.js';
+import { findFieldTarget, focusFieldTarget } from './field-target.js';
+import { UndoToastMessage } from './components/UndoToastMessage.js';
+import { getNotificationDuration } from './utils/env.js';
+import { MayHaveLandedError } from './unanswered.js';
+// Stable fallbacks, so reference resolution's memo and effect don't re-run on every render
+// while no entry is open.
+const EMPTY_SCHEMA = [];
+const CONTENT_PANEL_ID = 'canopy-content-panel';
+const EMPTY_VALUE = {};
 /**
  * High-level editor wrapper that wires entry navigation, form rendering,
  * saving/loading, and preview rendering using entry definitions.
  */
-export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtitle = subtitle, branchName = '', collections, contentRoot, entryLinkUrl, initialSelectedId, initialValues, renderPreview, onCreateEntry, themeOptions, operatingMode, previewBaseByCollection, previewPrefix, currentUser = 'current-user', canResolveComments = true, assetBaseUrl, basePath, AccountComponent, onAccountClick, onLogoutClick, customRenderers, }) => {
+export const Editor = (props) => (_jsx(EditorCrashBoundary, { themeOptions: props.themeOptions, children: _jsx(EditorContent, { ...props }) }));
+const EditorContent = ({ entries, title, siteTitle = title, branchName = '', collections, contentRoot, entryLinkUrl, initialSelectedId, initialValues, renderPreview, onCreateEntry, themeOptions, operatingMode, previewBaseByCollection, previewPrefix, mdxAllow, currentUser = 'current-user', canResolveComments = true, basePath, AccountComponent, onAccountClick, onLogoutClick, customRenderers, }) => {
     const [branchesLoading, setBranchesLoading] = useState(false);
     const [entriesLoading, setEntriesLoading] = useState(false);
     const [commentsLoading] = useState(false);
@@ -47,6 +84,29 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
     const [editingCollection, setEditingCollection] = useState(null);
     const [collectionEditorParentPath, setCollectionEditorParentPath] = useState(undefined);
     const [collectionEditorError, setCollectionEditorError] = useState(null);
+    // What the last unanswered collection create or details save sent, until its dialog's opener
+    // sees it land on a fresh read, a matching save succeeds, or the user discards it.
+    const collectionDraftRef = useRef(null);
+    // The draft the open dialog was filled from, if any: its save replaces that draft.
+    const refilledDraftRef = useRef(null);
+    // What the dialog fills in, decided by its opener against a fresh tree.
+    const [restoredCollectionInput, setRestoredCollectionInput] = useState(null);
+    // Each open or close of the collection dialog moves it on, so a slow open answers only if current.
+    const collectionOpeningRef = useRef(0);
+    const [quickOpenOpen, setQuickOpenOpen] = useState(false);
+    const [quickOpenFromOverlay, setQuickOpenFromOverlay] = useState(false);
+    const navigatorToggleRef = useRef(null);
+    const mediaButtonRef = useRef(null);
+    const branchToggleRef = useRef(null);
+    const settingsToggleRef = useRef(null);
+    // Null when the branches drawer opened from a menu item; see `rememberOpener`.
+    const branchOpenerRef = useRef(null);
+    // Null when the panel opened from a menu item, which unmounts on click, or with focus on the page.
+    const navigatorOpenerRef = useRef(null);
+    const quickOpenOpenRef = useRef(false);
+    useEffect(() => {
+        quickOpenOpenRef.current = quickOpenOpen;
+    }, [quickOpenOpen]);
     const [renameModalOpen, setRenameModalOpen] = useState(false);
     const [renamingEntry, setRenamingEntry] = useState(null);
     const [renameModalError, setRenameModalError] = useState(null);
@@ -55,27 +115,53 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
     const [deletingCollectionPath, setDeletingCollectionPath] = useState(null);
     const [deleteEntryModalOpen, setDeleteEntryModalOpen] = useState(false);
     const [deletingEntryPath, setDeletingEntryPath] = useState(null);
+    // Named at open: a delete that lands takes the entry out of the list while the dialog fades.
+    const [deletingEntryLabel, setDeletingEntryLabel] = useState();
+    // Set once the server refuses a delete because other entries reference the entry.
+    const [deletingEntryReferencedBy, setDeletingEntryReferencedBy] = useState(null);
     const [deleteInProgress, setDeleteInProgress] = useState(false);
-    // Preview data with resolved references for live preview
-    const [previewData, setPreviewData] = useState({});
-    const [previewLoadingState, setPreviewLoadingState] = useState({});
+    // A rename or delete asked for from the top bar's entry menu, whose item is gone once it acts.
+    const [entryChangeFromMenu, setEntryChangeFromMenu] = useState(false);
+    const allContentCrumbRef = useRef(null);
     // Draft compile/render error reported by the preview page (null = renders cleanly)
     const [previewError, setPreviewError] = useState(null);
     const apiClient = useApiClient();
     const { userContext } = useUserContext();
-    // The System Health panel is admin-only -- gate both the sidebar
-    // menu item and the modal mount on it, same pattern BranchManager.tsx uses
-    // for its own admin-only actions.
-    const showSystemHealth = isAdmin(userContext?.groups);
-    const { layout, setLayout, highlightEnabled, setHighlightEnabled, headerRef, headerHeight } = useEditorLayout();
+    // Admin surfaces (permissions, groups, system health, collection management and entry order,
+    // whose API routes all take the `admin` guard) render only for admins: each menu item, action
+    // and drawer mount is gated here. Until whoami answers, the user counts as no admin.
+    const userIsAdmin = isAdmin(userContext?.groups);
+    // Name lookups take the `privileged` guard (admins and reviewers); no lookup is sent that would
+    // only be refused. Comment surfaces name their people for everyone (getCommentUserMetadata).
+    const canResolveUserNames = isPrivileged(userContext?.groups);
+    // Reviewers and admins resolve any thread; everyone else only the threads they started.
+    const canResolveAnyComment = canResolveComments && isReviewer(userContext?.groups);
+    // The signed-in user, so "started by me" matches the thread authors the server records.
+    const commentUserId = userContext?.userId ?? currentUser;
+    // Below 64em (1024px) the editor starts stacked and the content panel never docks.
+    const wideWindow = useMediaQuery('(min-width: 64em)', true, { getInitialValueInEffect: false }) !== false;
+    const { loaded: layoutLoaded, layout, setLayout, highlightEnabled, setHighlightEnabled, sideSplitPercent, stackedSplitPercent, setSplitPercent, previewWidth, setPreviewWidth, contentPanelOpen, setContentPanelOpen, contentPanelWidth, setContentPanelWidth, } = useEditorLayout({
+        storageKey: editorLayoutStorageKey(basePath),
+        defaultLayout: wideWindow ? 'side' : 'stacked',
+    });
+    // In the stacked layout the content panel lays over the form only, so the preview stays in view.
+    const contentPanelDocked = layout === 'side' && wideWindow;
     // Comments state (shared between useCommentSystem and useBranchManager)
     const [commentsForBranchSummaries, setCommentsForBranchSummaries] = useState([]);
     // 1. Branch manager (provides branchNameState, no dependencies)
+    const resolveUnsavedRef = useRef(async () => ({
+        count: 0,
+        labels: [],
+    }));
+    const applySubmitStampsRef = useRef(() => { });
     const { branchName: branchNameState, setBranchName, branchSummaries, currentBranch, addCreatedBranch, handleSubmit, handleWithdraw, handleRequestChanges, handleDelete, handleReloadBranchData, loadBranches, } = useBranchManager({
         initialBranch: branchName,
         operatingMode,
         setBusy: setBranchesLoading,
         comments: commentsForBranchSummaries,
+        // The draft manager comes later, as it depends on this hook's branch.
+        getUnsaved: () => resolveUnsavedRef.current(),
+        onStamped: (stamped) => applySubmitStampsRef.current(stamped),
     });
     // Content mutations (add/delete/rename/reorder entries) are locked whenever the
     // server says writes are blocked -- the protected base branch, or a workflow
@@ -90,7 +176,7 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
     // loading state during that window anyway.
     const branchContentLocked = currentBranch?.writeBlocked ?? true;
     // 2. Entry manager (depends on branchNameState, owns selectedPath)
-    const { selectedPath, setSelectedPath, entries: entriesState, collections: collectionsFromApi, currentEntry, availableSchemas, entriesInitializing, navigatorOpen, setNavigatorOpen, refreshEntries, handleCreateEntry, renameEntry, loadEntry, saveEntry, getEntryVersion, createModalOpen, createModalCollection, createModalError, createModalCreating, createModalExistingSlugs, handleCreateModalSubmit, closeCreateModal, } = useEntryManager({
+    const { selectedPath, setSelectedPath, closeEntry, entries: entriesState, collections: collectionsFromApi, currentEntry, availableSchemas, entriesInitializing, entriesLoadFailed, navigatorOpen, setNavigatorOpen, refreshEntries, refreshContent, handleCreateEntry, renameEntry, loadEntry, readEntryValue, saveEntry, getEntryVersion, adoptEntryVersion, followMovedEntry, recreateEntry, createModalOpen, createModalCollection, createModalError, createModalCreating, createModalExistingSlugs, handleCreateModalSubmit, closeCreateModal, } = useEntryManager({
         initialEntries: entries,
         initialSelectedId,
         branchName: branchNameState,
@@ -104,6 +190,28 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         }),
         setBusy: setEntriesLoading,
     });
+    // The content overlay and a maximized preview hide the form; `navigatorOpen` is only the
+    // overlay's. Anything that focuses something in the form reveals it first. Opening an entry
+    // closes the overlay only, so the preview stays maximized across entries (see
+    // `previewShownMaximized` for the loads in between).
+    const [previewMaximized, setPreviewMaximized] = useState(false);
+    const revealForm = () => {
+        setNavigatorOpen(false);
+        setPreviewMaximized(false);
+    };
+    const openEntry = (path) => {
+        setSelectedPath(path);
+        setNavigatorOpen(false);
+    };
+    // An open overlay docks open, as the URL's ask for no entry does at load; `navigatorOpen` is only
+    // the overlay's, so a docked panel never resurfaces as one. Waits for the stored layout, whose
+    // arrival could otherwise dock an overlay the stacked layout keeps.
+    useEffect(() => {
+        if (layoutLoaded && contentPanelDocked && navigatorOpen) {
+            setContentPanelOpen(true);
+            setNavigatorOpen(false);
+        }
+    }, [layoutLoaded, contentPanelDocked, navigatorOpen, setContentPanelOpen, setNavigatorOpen]);
     // Keeps the entry-type list referentially stable while the create modal shows
     // the same collection: a new array on every render would churn Mantine's
     // Select `data` identity and give EntryCreateModal's form-seeding effect a
@@ -114,52 +222,72 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         format: et.format,
         default: et.default,
         maxItems: et.maxItems,
+        unavailable: et.unavailable,
+        titleField: et.titleField,
     })) ?? [], [createModalCollection]);
+    // The route a slug's page is served at, shown under the slug: `buildPreviewSrc`'s route before
+    // its prefix, base path, trailing slash and `?branch=`. Undefined when the entry has no page.
+    const previewPathFor = (entry) => buildPreviewRoute(entry, { previewBaseByCollection, contentRoot });
     // Use collections from API (falls back to props if not loaded yet)
     const activeCollections = collectionsFromApi.length > 0 ? collectionsFromApi : collections;
-    // Reset preview state when switching entries so a stale previous entry's
-    // preview never lingers for entries whose FormRenderer doesn't mount
-    // (still loading, canEdit === false, or empty schema)
+    // A preview error belongs to the entry that reported it.
     useEffect(() => {
         setPreviewError(null);
-        setPreviewData({});
-        setPreviewLoadingState({});
     }, [currentEntry?.contentId]);
     // 3. Draft manager (depends on branchNameState, selectedPath from useEntryManager)
-    const { setDrafts, loadedValues, setLoadedValues, effectiveValue, modifiedCount, editedFiles, handleSave, handleDiscardDrafts, handleDiscardFileDraft, handleReload, isSelectedDirty, isAnyDirty, fieldErrors, } = useDraftManager({
+    const { drafts, setDrafts, loadedValues, setLoadedValues, loadedValue, effectiveValue, modifiedCount, editedFiles, handleSave, singleSaving, lastSaved, handleSaveAll, saveAllProgress, isSaveAllRunning, handleDiscardDrafts, handleDiscardFileDraft, handleReload, isSelectedDirty, resolveUnsaved, fieldErrors, draftStorageFailed, applySubmitStamps, } = useDraftManager({
         branchName: branchNameState,
         selectedPath,
         currentEntry,
         entries: entriesState,
         initialValues,
         loadEntry,
+        readEntryValue,
         saveEntry,
         getEntryVersion,
+        adoptEntryVersion,
+        followMovedEntry,
+        recreateEntry,
         setBusy: setEntriesLoading,
+        // The errors are in the form.
+        onSaveBlocked: () => setPreviewMaximized(false),
         onSaved: () => {
             void refreshEntries(branchNameState).catch((err) => console.error('Failed to refresh entries after save', err));
         },
+        // An Undo built on a discarded draft would put back an item the server's copy already has.
+        onDraftsReset: (contentId) => dismissUndoToasts(contentId),
     });
-    // 4. Branch actions (depends on isAnyDirty, setBranchName)
-    const { handleBranchChange, handleCreateBranch } = useBranchActions({
+    resolveUnsavedRef.current = resolveUnsaved;
+    applySubmitStampsRef.current = applySubmitStamps;
+    // 4. Branch actions (depends on resolveUnsaved, setBranchName)
+    const { handleBranchChange, confirmCreate: confirmCreateBranch, handleCreateBranch, confirmOpen: branchConfirmOpen, } = useBranchActions({
         branchName: branchNameState,
         setBranchName,
-        isAnyDirty,
+        getUnsaved: resolveUnsaved,
         onReloadBranches: () => loadBranches(),
         onBranchCreated: addCreatedBranch,
+        userId: userContext?.userId,
     });
     // 5. Comment system (depends on branchNameState)
-    const { comments, focusedFieldPath, highlightThreadId, commentsPanelOpen, setCommentsPanelOpen, handleAddComment, handleResolveThread, handleJumpToField, handleJumpToEntry, handleJumpToBranch, } = useCommentSystem({
+    const { comments, getCommentUser, focusedFieldPath, highlightThreadId, commentsPanelOpen, setCommentsPanelOpen, handleAddComment, handleResolveThread, handleJumpToField, handleJumpToEntry, handleJumpToBranch, } = useCommentSystem({
         branchName: branchNameState,
         selectedPath,
         currentEntry,
-        currentUser,
-        canResolveComments,
+        currentUser: commentUserId,
+        canResolveComments: canResolveAnyComment,
         setSelectedPath,
-        setBranchManagerOpen,
+        setBranchManagerOpen: (open) => {
+            if (open)
+                branchOpenerRef.current = rememberOpener();
+            setBranchManagerOpen(open);
+        },
         onCommentsChange: setCommentsForBranchSummaries,
+        onRevealForm: revealForm,
     });
     const { groupsData, groupsLoading, handleSaveGroups, handleSearchUsers, handleGetUserMetadata, handleSearchExternalGroups, } = useGroupManager({ isOpen: groupManagerOpen });
+    // The comments and branches responses name their people, without email; a privileged lookup
+    // adds the email.
+    const getCommentUserMetadata = canResolveUserNames ? handleGetUserMetadata : getCommentUser;
     const { permissionsData, permissionsLoading, handleSavePermissions, handleListGroups } = usePermissionManager({
         isOpen: permissionManagerOpen,
     });
@@ -168,8 +296,224 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         branchName: branchNameState,
         onSchemaChange: () => refreshEntries(branchNameState),
     });
+    // Read-only content shows the saved value, never a draft; a restored draft is kept, unseen,
+    // until it is discarded or the branch unlocks.
+    const contentReadOnly = branchContentLocked || currentEntry?.canEdit === false;
+    const displayValue = contentReadOnly ? loadedValue : effectiveValue;
+    // Read when an edit lands, which an upload or other async field work can do renders later.
+    const contentReadOnlyRef = useRef(contentReadOnly);
+    contentReadOnlyRef.current = contentReadOnly;
+    // Undo for a form Remove: a toast whose Undo puts the item back into the entry's draft as it
+    // is then, through a functional update, so edits made since are kept. It acts only on the
+    // branch and entry it was raised for, and its toast closes when either changes.
+    const loadedValuesRef = useRef(loadedValues);
+    loadedValuesRef.current = loadedValues;
+    const draftsRef = useRef(drafts);
+    draftsRef.current = drafts;
+    // Open Undo toasts, by id, with the entry each belongs to.
+    const undoToastsRef = useRef(new Map());
+    const nextUndoToastRef = useRef(0);
+    const dismissUndoToasts = (contentId) => {
+        undoToastsRef.current.forEach((entry, id) => {
+            if (contentId !== undefined && entry !== contentId)
+                return;
+            notifications.hide(id);
+            undoToastsRef.current.delete(id);
+        });
+    };
+    const handleFieldRemoved = (removal) => {
+        const contentId = currentEntry?.contentId;
+        if (!contentId || contentReadOnlyRef.current)
+            return;
+        const branch = branchNameState;
+        const fields = schema;
+        // Taken from the value this render shows, which the removal has not reached yet.
+        const anchored = {
+            ...removal,
+            anchors: displayValue ? removalAnchors(fields, displayValue, removal) : undefined,
+        };
+        const doing = removal.action === 'clear' ? 'clearing' : 'removing';
+        // Open threads keyed inside what was removed leave their fields for the entry's thread list.
+        const movedThreads = currentEntry
+            ? openThreadsWithin(displayComments, currentEntry.path, removal.kind === 'list-item' ? [...removal.listPath, removal.index] : removal.path)
+            : 0;
+        nextUndoToastRef.current += 1;
+        const id = `canopy-undo-${nextUndoToastRef.current}`;
+        let used = false;
+        const undo = () => {
+            // A closing toast stays clickable while it animates out: act once, and only while open.
+            if (used)
+                return;
+            used = true;
+            const open = undoToastsRef.current.has(id);
+            notifications.hide(id);
+            undoToastsRef.current.delete(id);
+            if (!open) {
+                notifications.show({
+                    message: `Too late to undo ${doing} ${removal.label}.`,
+                    color: 'yellow',
+                });
+                return;
+            }
+            if (currentBranchRef.current !== branch ||
+                currentContentIdRef.current !== contentId ||
+                contentReadOnlyRef.current) {
+                return;
+            }
+            const now = draftsRef.current[contentId] ?? loadedValuesRef.current[contentId];
+            if (!now || !restoreRemoval(fields, now, anchored)) {
+                notifications.show({
+                    message: `Couldn't undo ${doing} ${removal.label}: that part of the entry has changed. ${removal.action === 'clear' ? 'Fill it in again' : 'Add it again'} if you still need it.`,
+                    color: 'yellow',
+                });
+                return;
+            }
+            const restoredPath = formatCanopyPath(restoredFieldPath(fields, now, removal));
+            setDrafts((prev) => {
+                const base = prev[contentId] ?? loadedValuesRef.current[contentId];
+                const restored = base ? restoreRemoval(fields, base, anchored) : undefined;
+                return restored ? { ...prev, [contentId]: restored } : prev;
+            });
+            // The toast's Undo button unmounts with it, so focus goes to the restored row once rendered.
+            revealForm();
+            requestAnimationFrame(() => {
+                const target = findFieldTarget(restoredPath);
+                if (target)
+                    focusFieldTarget(target.element);
+            });
+        };
+        undoToastsRef.current.set(id, contentId);
+        const toast = {
+            id,
+            message: (_jsx(UndoToastMessage, { label: removal.label, action: removal.action, note: movedThreads > 0
+                    ? `Its ${movedThreads === 1 ? 'comment thread' : `${movedThreads} comment threads`} moved to "Comment on this entry".`
+                    : undefined, onUndo: undo, onHold: () => notifications.update({ ...toast, autoClose: false }), onRelease: () => notifications.update(toast) })),
+            autoClose: getNotificationDuration(8000),
+            withCloseButton: true,
+            onClose: () => undoToastsRef.current.delete(id),
+        };
+        notifications.show(toast);
+    };
+    useEffect(() => () => dismissUndoToasts(), [currentEntry?.contentId, branchNameState]);
+    // Only once the branch has answered, so the fail-closed lock while it loads raises no notice.
+    const hiddenDraftNotice = contentReadOnly && currentBranch !== undefined && !!currentEntry && isSelectedDirty();
     const collectionLabels = useMemo(() => buildCollectionLabels(activeCollections), [activeCollections]);
-    const schema = currentEntry?.schema ?? [];
+    const schema = currentEntry?.schema ?? EMPTY_SCHEMA;
+    // Field threads follow their items' keys, placed in their entry's value where it is at hand.
+    const entryValue = (entry) => {
+        if (entry.path === currentEntry?.path)
+            return displayValue;
+        // As `displayValue` would show it: read-only content shows its saved value, not a draft.
+        const readOnly = branchContentLocked || entry.canEdit === false;
+        return (readOnly ? undefined : drafts[entry.contentId]) ?? loadedValues[entry.contentId];
+    };
+    const displayComments = useMemo(() => {
+        const byPath = new Map(entriesState.map((entry) => [entry.path, entry]));
+        return comments.map((thread) => {
+            const entry = thread.entryPath ? byPath.get(thread.entryPath) : undefined;
+            const value = entry ? entryValue(entry) : undefined;
+            if (thread.type !== 'field' || !thread.canopyPath || !thread.itemKeys?.length)
+                return thread;
+            if (!entry || !value)
+                return thread;
+            const path = resolveThreadPath(entry.schema, value, thread.canopyPath, thread.itemKeys);
+            if (path === null)
+                return { ...thread, onRemovedItem: true };
+            return path === thread.canopyPath ? thread : { ...thread, canopyPath: path };
+        });
+        // `entryValue` reads the open entry, its shown value, and the drafts and loads.
+    }, [
+        comments,
+        entriesState,
+        currentEntry,
+        displayValue,
+        drafts,
+        loadedValues,
+        branchContentLocked,
+    ]);
+    // A jump into another entry waits for its value to place the thread; the stored path may be stale.
+    const [pendingFieldJump, setPendingFieldJump] = useState(null);
+    const jumpToThreadField = (entryPath, canopyPath, threadId) => {
+        if (entryPath === currentEntry?.path) {
+            handleJumpToField(entryPath, canopyPath, threadId);
+            return;
+        }
+        setPendingFieldJump({ entryPath, canopyPath, threadId });
+        setSelectedPath(entryPath);
+    };
+    useEffect(() => {
+        if (!pendingFieldJump)
+            return;
+        if (selectedPath !== pendingFieldJump.entryPath) {
+            setPendingFieldJump(null);
+            return;
+        }
+        if (currentEntry?.path !== pendingFieldJump.entryPath || !displayValue)
+            return;
+        const { entryPath, canopyPath, threadId } = pendingFieldJump;
+        setPendingFieldJump(null);
+        const placed = displayComments.find((t) => t.id === threadId);
+        // A thread whose item is gone lives on its entry, not at the index it was made at.
+        if (placed?.onRemovedItem)
+            handleJumpToEntry(entryPath, threadId);
+        else
+            handleJumpToField(entryPath, placed?.canopyPath ?? canopyPath, threadId);
+    }, [pendingFieldJump, selectedPath, currentEntry, displayValue, displayComments]);
+    // A thread on an item only the draft has is refused: a discard would leave it on nothing.
+    const handleAddDisplayedComment = async (text, type, entryPath, canopyPath, threadId) => {
+        if (type !== 'field' ||
+            threadId ||
+            !canopyPath ||
+            !currentEntry ||
+            entryPath !== currentEntry.path ||
+            !displayValue) {
+            return handleAddComment(text, type, entryPath, canopyPath, threadId);
+        }
+        const itemKeys = itemKeysOnPath(currentEntry.schema, displayValue, canopyPath);
+        if (!itemKeys?.length)
+            return handleAddComment(text, type, entryPath, canopyPath);
+        // The field's control says so before anyone types (`commentBlockedReason`); this is the backstop.
+        if (!loadedValue)
+            throw new Error(ENTRY_NOT_LOADED_COMMENT_MESSAGE);
+        if (onUnsavedItem(itemKeys, canopyPath))
+            throw new Error(NEW_ITEM_COMMENT_MESSAGE);
+        return handleAddComment(text, type, entryPath, canopyPath, undefined, itemKeys);
+    };
+    const onUnsavedItem = (itemKeys, canopyPath) => !currentEntry ||
+        !loadedValue ||
+        resolveThreadPath(currentEntry.schema, loadedValue, canopyPath, itemKeys) === null;
+    // Says nothing until the saved value is known, which is what tells a new item from a saved one.
+    const commentBlockedReason = (canopyPath) => {
+        if (!currentEntry || !displayValue || !loadedValue)
+            return undefined;
+        const itemKeys = itemKeysOnPath(currentEntry.schema, displayValue, canopyPath);
+        return itemKeys?.length && onUnsavedItem(itemKeys, canopyPath)
+            ? NEW_ITEM_COMMENT_MESSAGE
+            : undefined;
+    };
+    const commentEntryLabel = (entryPath) => entriesState.find((e) => e.path === entryPath)?.label;
+    // Only the open entry's value is at hand; for another entry the breadcrumb falls back to its
+    // schema's field labels.
+    // Items are named only where a value placed the thread; otherwise its indexes may be stale.
+    const commentFieldLabel = (thread) => {
+        const entry = entriesState.find((e) => e.path === thread.entryPath);
+        if (!entry || !thread.canopyPath)
+            return undefined;
+        const value = entryValue(entry);
+        // While a removal is only in the draft, the saved value still holds the item to name.
+        const saved = thread.onRemovedItem ? loadedValues[entry.contentId] : undefined;
+        const savedPath = saved
+            ? resolveThreadPath(entry.schema, saved, thread.canopyPath, thread.itemKeys)
+            : null;
+        if (saved && savedPath !== null) {
+            return fieldBreadcrumb(entry.schema, saved, savedPath).join(' › ');
+        }
+        const placed = !!value && !thread.onRemovedItem;
+        const items = placed || !thread.itemKeys?.length;
+        return fieldBreadcrumb(entry.schema, placed ? value : undefined, thread.canopyPath, {
+            items,
+        }).join(' › ');
+    };
     // Gated on `loadedValues[contentId]` (not `drafts[contentId]`) so a
     // restored-from-localStorage draft never skips the load: skipping left
     // `loadedValues[contentId]` permanently undefined, which made dirty-
@@ -186,6 +530,44 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
     // that same id. Qualifying the key lets both loads coexist; the branch check
     // at settle time decides which one is allowed to write.
     const loadingEntryIdsRef = useRef(new Set());
+    // The entry (keyed like `loadingEntryIdsRef`) whose last read failed, and Retry's bump that
+    // runs the load effect below again.
+    const [loadFailedKey, setLoadFailedKey] = useState(null);
+    const [loadAttempt, setLoadAttempt] = useState(0);
+    // Reset during render, not in an effect, so returning to a failed entry never paints its Alert
+    // for the frame before its load starts again.
+    const selectionKey = `${branchNameState}:${currentEntry?.contentId ?? ''}`;
+    const [loadFailedSelection, setLoadFailedSelection] = useState(selectionKey);
+    if (loadFailedSelection !== selectionKey) {
+        setLoadFailedSelection(selectionKey);
+        setLoadFailedKey(null);
+    }
+    // Entries (keyed like `loadingEntryIdsRef`) whose read the API refused as SCHEMA_UNAVAILABLE.
+    // The ref stops the load effect retrying them; the state re-renders the notice.
+    const schemaUnavailableRef = useRef(new Set());
+    const [schemaUnavailableKeys, setSchemaUnavailableKeys] = useState(new Set());
+    // A refetch of entries or schema is the signal the server's schema may have changed, so every
+    // refusal is forgotten and the next open of each entry reads it once more. Declared before the
+    // load effect so a refetch's retry sees the cleared set in the same commit.
+    useEffect(() => {
+        if (schemaUnavailableRef.current.size === 0)
+            return;
+        schemaUnavailableRef.current = new Set();
+        setSchemaUnavailableKeys(new Set());
+    }, [entriesState, collectionsFromApi]);
+    // A successful read (File > Reload) of a refused entry ends the refusal.
+    useEffect(() => {
+        if (schemaUnavailableRef.current.size === 0)
+            return;
+        const stale = [...schemaUnavailableRef.current].filter((key) => {
+            const [keyBranch, ...id] = key.split(':');
+            return keyBranch === branchNameState && loadedValues[id.join(':')] !== undefined;
+        });
+        if (stale.length === 0)
+            return;
+        stale.forEach((key) => schemaUnavailableRef.current.delete(key));
+        setSchemaUnavailableKeys(new Set(schemaUnavailableRef.current));
+    }, [loadedValues, branchNameState]);
     // The contentId this effect is CURRENTLY targeting, kept in sync every
     // render (not in an effect -- it must be current by the time an in-flight
     // load's `finally`/`catch` runs, which can be after several re-renders).
@@ -213,6 +595,9 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         const load = async () => {
             if (!currentEntry || !contentId || loadedValues[contentId] !== undefined)
                 return;
+            // An unavailable type has no schema to read it against; the server would refuse the read.
+            if (currentEntry.unavailable || schemaUnavailableRef.current.has(inFlightKey))
+                return;
             // Guard against overlapping renders re-firing the same in-flight load
             // (e.g. `currentEntry` getting a new object reference from an entries
             // refresh while the fetch below is still pending).
@@ -220,6 +605,7 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
                 return;
             loadingEntryIdsRef.current.add(inFlightKey);
             setEntriesLoading(true);
+            setLoadFailedKey((failed) => (failed === inFlightKey ? null : failed));
             try {
                 const loaded = await loadEntry(currentEntry);
                 // A branch switch during the await makes this response another
@@ -255,93 +641,108 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
             }
         };
         load().catch((err) => {
+            if (err instanceof EntrySchemaUnavailableError) {
+                schemaUnavailableRef.current.add(inFlightKey);
+                setSchemaUnavailableKeys((prev) => new Set(prev).add(inFlightKey));
+                return;
+            }
             console.error(err);
             // Same staleness guard as above: don't tell the user an entry failed
             // to load when they've already navigated to a different one (or to a
             // different branch).
             if (currentBranchRef.current === requestBranch && currentContentIdRef.current === contentId) {
                 notifications.show({ message: 'Failed to load entry', color: 'red' });
+                setLoadFailedKey(inFlightKey);
             }
         });
         // eslint-disable-next-line react-hooks/exhaustive-deps -- stable setters, run only on entry/path/branch/loadedValues change
-    }, [currentEntry, loadedValues, selectedPath, branchNameState]);
+    }, [currentEntry, loadedValues, selectedPath, branchNameState, loadAttempt]);
+    // The collection dialog's entry types, with schema and usage, as the branch has them; null when
+    // the API refuses the read or the collection is gone, and a rejection when the read times out.
+    const readEntryTypes = async (collectionPath) => {
+        const result = await apiClient.schema.getCollection({
+            branch: branchNameState,
+            collectionPath,
+        });
+        const withUsage = result.ok ? result.data?.entryTypesWithUsage : undefined;
+        return withUsage
+            ? withUsage.map((et) => ({
+                name: et.name,
+                label: et.label,
+                format: et.format,
+                schema: et.schemaRef,
+                default: et.default,
+                maxItems: et.maxItems,
+                usageCount: et.usageCount,
+            }))
+            : null;
+    };
     const handleOpenCollectionEditor = async (collection, parentPath) => {
-        if (collection) {
-            try {
-                const result = await apiClient.schema.getCollection({
-                    branch: branchNameState,
-                    collectionPath: collection.path,
-                });
-                if (result.ok && result.data && result.data.collection) {
-                    const entries = result.data.entryTypesWithUsage
-                        ? result.data.entryTypesWithUsage.map((et) => ({
-                            name: et.name,
-                            label: et.label,
-                            format: et.format,
-                            schema: et.schemaRef,
-                            default: et.default,
-                            maxItems: et.maxItems,
-                            usageCount: et.usageCount,
-                        }))
-                        : (collection.entryTypes ?? []).map((et) => ({
-                            name: et.name,
-                            label: et.label,
-                            format: et.format,
-                            schema: '', // Fallback if entryTypesWithUsage not available
-                            default: et.default,
-                            maxItems: et.maxItems,
-                        }));
-                    const existingCollection = {
-                        name: collection.name,
-                        label: collection.label,
-                        logicalPath: collection.path,
-                        entries,
-                    };
-                    setEditingCollection(existingCollection);
-                }
-                else {
-                    const existingCollection = {
-                        name: collection.name,
-                        label: collection.label,
-                        logicalPath: collection.path,
-                        entries: (collection.entryTypes ?? []).map((et) => ({
-                            name: et.name,
-                            label: et.label,
-                            format: et.format,
-                            schema: '',
-                            default: et.default,
-                            maxItems: et.maxItems,
-                        })),
-                    };
-                    setEditingCollection(existingCollection);
-                }
+        const opening = ++collectionOpeningRef.current;
+        const branch = branchNameState;
+        const stillCurrent = () => opening === collectionOpeningRef.current && currentBranchRef.current === branch;
+        // A draft is checked on a fresh tree first: refilling a create that landed would duplicate it.
+        const draft = collectionDraftRef.current;
+        // A details save that changed the slug and landed is reopened at its new path, never refilled.
+        const atNewPath = draft?.kind === 'details' &&
+            !!draft.updates.slug &&
+            collection?.path ===
+                `${draft.collectionPath.slice(0, draft.collectionPath.lastIndexOf('/') + 1)}${draft.updates.slug}`;
+        const refills = draft?.branch === branch &&
+            (draft.kind === 'create'
+                ? !collection && draft.input.parentPath === parentPath
+                : collection?.path === draft.collectionPath || atNewPath);
+        let restore = null;
+        if (draft && refills) {
+            const fresh = await refreshContent(branch).catch((err) => {
+                console.error(err);
+                return null;
+            });
+            if (!stillCurrent())
+                return;
+            if (fresh && collectionDraftLanded(fresh.collections, draft)) {
+                settleCollectionDraft(draft);
             }
-            catch {
-                const existingCollection = {
-                    name: collection.name,
-                    label: collection.label,
-                    logicalPath: collection.path,
-                    entries: (collection.entryTypes ?? []).map((et) => ({
-                        name: et.name,
-                        label: et.label,
-                        format: et.format,
-                        schema: '',
-                        default: et.default,
-                        maxItems: et.maxItems,
-                    })),
-                };
-                setEditingCollection(existingCollection);
+            else if (collectionDraftRef.current === draft &&
+                !atNewPath &&
+                (fresh || draft.kind === 'details')) {
+                // A create no read has ruled out stays unfilled; a details save resends the same change.
+                restore = draft.kind === 'create' ? draft.input : draft.updates;
             }
+        }
+        if (collection) {
+            // The tree's entry types, the fallback, carry no schema or usage.
+            const read = await readEntryTypes(collection.path).catch(() => null);
+            if (!stillCurrent())
+                return;
+            const entries = read ??
+                (collection.entryTypes ?? []).map((et) => ({
+                    name: et.name,
+                    label: et.label,
+                    format: et.format,
+                    schema: '',
+                    default: et.default,
+                    maxItems: et.maxItems,
+                }));
+            setEditingCollection({
+                name: collection.name,
+                label: collection.label,
+                logicalPath: collection.path,
+                entries,
+            });
             setCollectionEditorParentPath(undefined);
         }
         else {
             setEditingCollection(null);
             setCollectionEditorParentPath(parentPath);
         }
+        refilledDraftRef.current = restore ? draft : null;
+        setRestoredCollectionInput(restore);
         setCollectionEditorError(null);
         setCollectionEditorOpen(true);
     };
     const handleCloseCollectionEditor = () => {
+        collectionOpeningRef.current++;
         setCollectionEditorOpen(false);
         setEditingCollection(null);
         setCollectionEditorParentPath(undefined);
@@ -352,9 +753,23 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         // createCollection/updateCollection are contractually non-throwing (they
         // return result objects — see useSchemaManager), so branch on `result.ok`
         // instead of try/catch.
+        const draft = collectionDraftRef.current;
         if (isNew) {
-            const result = await createCollection(data);
-            if (result.ok) {
+            const input = data;
+            const result = await createCollection(input);
+            // A retried create that had landed makes a second collection, so an unanswered one closes
+            // the dialog too, leaving the hook's toast to say to check the "Content" panel first.
+            if (result.ok || result.unanswered) {
+                if (!result.ok) {
+                    collectionDraftRef.current = { branch: branchNameState, kind: 'create', input };
+                }
+                else if (collectionDraftRef.current === draft &&
+                    draft?.kind === 'create' &&
+                    draft.branch === branchNameState &&
+                    draft.input.parentPath === input.parentPath &&
+                    (draft === refilledDraftRef.current || draft.input.name === input.name)) {
+                    collectionDraftRef.current = null;
+                }
                 handleCloseCollectionEditor();
             }
             else {
@@ -362,8 +777,29 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
             }
         }
         else if (editingCollection) {
-            const result = await updateCollection(editingCollection.logicalPath, data);
-            if (result.ok) {
+            const updates = data;
+            const collectionPath = editingCollection.logicalPath;
+            const result = await updateCollection(collectionPath, updates);
+            // An unanswered save may have renamed the collection, leaving `editingCollection`'s path
+            // stale, so the dialog closes; the hook's toast says to reopen it and check.
+            if (result.ok || result.unanswered) {
+                // An update with no defined value sent nothing worth filling in again.
+                const sent = Object.values(updates).some((value) => value !== undefined);
+                if (!result.ok && sent) {
+                    collectionDraftRef.current = {
+                        branch: branchNameState,
+                        kind: 'details',
+                        collectionPath,
+                        updates,
+                    };
+                }
+                else if (result.ok &&
+                    collectionDraftRef.current === draft &&
+                    draft?.kind === 'details' &&
+                    draft.branch === branchNameState &&
+                    draft.collectionPath === collectionPath) {
+                    collectionDraftRef.current = null;
+                }
                 handleCloseCollectionEditor();
             }
             else {
@@ -371,6 +807,18 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
             }
         }
     };
+    /** The draft's write landed: drop it, take its warning down and say so, once. */
+    const settleCollectionDraft = (draft) => {
+        if (collectionDraftRef.current !== draft)
+            return;
+        collectionDraftRef.current = null;
+        setRestoredCollectionInput(null);
+        hideCollectionOutcomeUnknown();
+        notifications.show({
+            message: draft.kind === 'create' ? `Collection "${draft.input.name}" created` : 'Collection updated',
+            color: 'green',
+        });
+    };
     const handleDeleteCollection = (collectionPath) => {
         setDeletingCollectionPath(collectionPath);
         setDeleteCollectionModalOpen(true);
@@ -388,50 +836,62 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
             setDeleteInProgress(false);
         }
     };
-    const handleDeleteEntry = (entryPath) => {
+    const handleDeleteEntry = (entryPath, fromMenu = false) => {
+        setEntryChangeFromMenu(fromMenu);
         setDeletingEntryPath(entryPath);
+        setDeletingEntryLabel(entriesState.find((e) => e.path === entryPath)?.label);
+        setDeletingEntryReferencedBy(null);
         setDeleteEntryModalOpen(true);
     };
+    // What the dialog names stays until the next delete, so its exit shows no change of text.
+    const closeDeleteEntryModal = () => setDeleteEntryModalOpen(false);
     const confirmDeleteEntry = async () => {
-        if (!deletingEntryPath)
+        // Its button stays clickable while the closed dialog fades; that click deletes nothing.
+        if (!deleteEntryModalOpen || !deletingEntryPath)
             return;
         setDeleteInProgress(true);
         try {
-            const result = await deleteEntry(deletingEntryPath);
-            if (result.ok && selectedPath === deletingEntryPath) {
-                setSelectedPath('');
+            // The user has seen the referencing entries only once the server has named them.
+            const result = await deleteEntry(deletingEntryPath, {
+                confirmReferenced: deletingEntryReferencedBy !== null,
+            });
+            if (!result.ok && 'referencedBy' in result) {
+                setDeletingEntryReferencedBy(result.referencedBy);
+                return;
             }
-            setDeleteEntryModalOpen(false);
-            setDeletingEntryPath(null);
+            if (result.ok && selectedPath === deletingEntryPath)
+                closeEntry();
+            closeDeleteEntryModal();
         }
         finally {
             setDeleteInProgress(false);
         }
     };
-    const handleRenameEntry = (entryPath) => {
-        // Find the entry being renamed
+    const handleRenameEntry = (entryPath, fromMenu = false) => {
         const entry = entriesState.find((e) => e.path === entryPath);
         if (!entry) {
             notifications.show({ message: 'Entry not found', color: 'red' });
             return;
         }
+        setEntryChangeFromMenu(fromMenu);
         setRenamingEntry(entry);
         setRenameModalError(null);
         setRenameModalOpen(true);
     };
     const handleRenameSubmit = async (newSlug) => {
-        if (!renamingEntry)
+        if (!renameModalOpen || !renamingEntry)
             return;
         setRenameModalSaving(true);
         setRenameModalError(null);
         try {
             await renameEntry(renamingEntry.path, newSlug);
             setRenameModalOpen(false);
-            setRenamingEntry(null);
         }
         catch (err) {
-            const errorMessage = err instanceof Error ? err.message : 'Rename failed';
-            setRenameModalError(errorMessage);
+            setRenameModalError({
+                message: err instanceof Error ? err.message : 'Rename failed',
+                mayHaveLanded: err instanceof MayHaveLandedError,
+            });
         }
         finally {
             setRenameModalSaving(false);
@@ -494,6 +954,10 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         [newOrder[currentIndex], newOrder[newIndex]] = [newOrder[newIndex], newOrder[currentIndex]];
         await updateOrder(collectionPath, newOrder);
     };
+    // The entry's type has no schema here, or the API refused its read as unavailable. Its
+    // form is replaced by a notice, so nothing about it can be saved.
+    const isEntryUnavailable = (entry) => !!entry.unavailable || schemaUnavailableKeys.has(`${branchNameState}:${entry.contentId}`);
+    const currentEntryUnavailable = !!currentEntry && isEntryUnavailable(currentEntry);
     // Determine if we should hide the root collection (but keep its context for ordering)
     const hiddenRootPath = useMemo(() => {
         if (activeCollections?.length === 1 && activeCollections[0].path === contentRoot) {
@@ -512,15 +976,25 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
             list.push({
                 path: entry.path,
                 label: entry.label,
-                status: entry.status,
+                slug: entry.slug,
+                status: entryStatusLabel(activeCollections, entry),
                 contentId: entry.contentId,
+                readOnly: entry.canEdit === false || undefined,
                 conflictNotice: !!(entry.contentId && currentBranch?.conflictFiles?.includes(entry.contentId)),
+                unavailable: isEntryUnavailable(entry) || undefined,
             });
             grouped.set(entry.collectionPath, list);
         });
         const build = (node) => {
             const entries = grouped.get(node.path) ?? [];
             const children = node.children?.map((child) => build(child)) ?? [];
+            const unavailableRefs = unavailableSchemaRefs(node.entryTypes);
+            // No entry can be created where every entry type is unavailable.
+            const allUnavailable = !!node.entryTypes?.length && node.entryTypes.every((et) => et.unavailable);
+            // A collection that holds only collections has no entry type to add (`entryTypes` is
+            // undefined when its list is empty).
+            const addable = node.type !== 'entry' && !allUnavailable && (node.entryTypes?.length ?? 0) > 0;
+            const canAddEntry = addable && node.canAddEntry !== false;
             return {
                 path: node.path,
                 label: node.label ?? node.name,
@@ -530,14 +1004,20 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
                 entries: entries.length > 0 ? entries : undefined,
                 children: children.length > 0 ? children : undefined,
                 conflictNotice: !!(node.contentId && currentBranch?.conflictFiles?.includes(node.contentId)),
-                onAdd: node.type !== 'entry'
+                unavailableSchemaRefs: unavailableRefs.length > 0 ? unavailableRefs : undefined,
+                addRefused: (addable && node.canAddEntry === false) || undefined,
+                onAdd: canAddEntry
                     ? () => (onCreateEntry ? onCreateEntry(node.path) : handleCreateEntry(node.path))
                     : undefined,
-                onEdit: node.type === 'collection' ? () => handleOpenCollectionEditor(node) : undefined,
-                onAddSubCollection: node.type === 'collection'
+                onEdit: userIsAdmin && node.type === 'collection'
+                    ? () => handleOpenCollectionEditor(node)
+                    : undefined,
+                onAddSubCollection: userIsAdmin && node.type === 'collection'
                     ? () => handleOpenCollectionEditor(null, node.path)
                     : undefined,
-                onDelete: node.type === 'collection' ? () => handleDeleteCollection(node.path) : undefined,
+                onDelete: userIsAdmin && node.type === 'collection'
+                    ? () => handleDeleteCollection(node.path)
+                    : undefined,
             };
         };
         return activeCollections.map((node) => build(node));
@@ -549,8 +1029,87 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         handleCreateEntry,
         contentRoot,
         currentBranch,
+        schemaUnavailableKeys,
+        userIsAdmin,
     ]);
-    // Tree expansion state - persists across drawer close/open
+    const quickOpenShortcut = modKeyLabel() === '⌘' ? '⌘P' : 'Ctrl+P';
+    const quickOpenKeys = modKeyLabel() === '⌘' ? 'Meta+P' : 'Control+P';
+    // Docked, the content panel's open state is the stored preference; as an overlay it is
+    // `navigatorOpen`, which starts open when the URL asks for no entry.
+    const contentPanelShown = contentPanelDocked ? contentPanelOpen : navigatorOpen;
+    const setContentPanelShown = (open) => contentPanelDocked ? setContentPanelOpen(open) : setNavigatorOpen(open);
+    // The overlay lives in the form pane, under a maximized preview.
+    const contentOverlayShown = !contentPanelDocked && contentPanelShown;
+    useEffect(() => {
+        if (contentOverlayShown)
+            setPreviewMaximized(false);
+    }, [contentOverlayShown]);
+    // Bumped on every ask for the panel, so one already open still takes focus.
+    const [contentPanelFocusRequest, setContentPanelFocusRequest] = useState(0);
+    const openNavigator = () => {
+        navigatorOpenerRef.current = rememberOpener();
+        // In the same commit as the overlay mounts, so its focus request meets no inert form panel.
+        if (!contentPanelDocked)
+            setPreviewMaximized(false);
+        setContentPanelShown(true);
+        setContentPanelFocusRequest((request) => request + 1);
+    };
+    // A collection crumb opens the panel as "All content" does, then its collection's row takes focus.
+    const [collectionReveal, setCollectionReveal] = useState();
+    // Only ever rises: the navigator serves each seq once, and the request is cleared once served.
+    const revealSeqRef = useRef(0);
+    const revealCollection = (path) => {
+        openNavigator();
+        revealSeqRef.current += 1;
+        setCollectionReveal({ path, seq: revealSeqRef.current });
+    };
+    // An ask the panel closed on before serving it must not fire when the panel next opens.
+    useEffect(() => {
+        if (!contentPanelShown)
+            setCollectionReveal(undefined);
+    }, [contentPanelShown]);
+    const runSaveAll = () => {
+        void handleSaveAll()
+            .then((result) => {
+            if (!result)
+                return;
+            showSaveAllResult(result, {
+                // Focus goes to the entry's menu, where its reason's "Refresh from server" is.
+                onOpenEntry: (path) => {
+                    openEntry(path);
+                    requestAnimationFrame(() => navigatorToggleRef.current?.focus());
+                },
+                onRetry: runSaveAll,
+            });
+        })
+            .catch(console.error);
+    };
+    // The entry menu's trigger stands in for its item; once the entry is deleted, "All content".
+    const entryChangeReturnTarget = entryChangeFromMenu
+        ? () => navigatorToggleRef.current ?? allContentCrumbRef.current
+        : undefined;
+    const navigatorReturnTarget = () => returnTarget(navigatorOpenerRef.current, () => navigatorToggleRef.current);
+    const branchReturnTarget = () => returnTarget(branchOpenerRef.current, () => branchToggleRef.current);
+    const settingsReturnTarget = () => settingsToggleRef.current;
+    // The palette replaces the overlay panel; a docked one stays. Opened from inside the overlay,
+    // whose tree then unmounts, it returns focus to the panel's opener.
+    const openQuickOpen = () => {
+        if (!quickOpenOpen) {
+            const panel = document.getElementById(CONTENT_PANEL_ID);
+            setQuickOpenFromOverlay(!contentPanelDocked && navigatorOpen && !!panel?.contains(document.activeElement));
+        }
+        if (!contentPanelDocked)
+            setNavigatorOpen(false);
+        setQuickOpenOpen(true);
+    };
+    const dirtyPaths = useMemo(() => new Set(editedFiles.map((file) => file.path)), [editedFiles]);
+    // Slugs of the entries beside the one being renamed, for the duplicate check.
+    const renameExistingSlugs = useMemo(() => new Set(entriesState
+        .filter((e) => e.collectionPath === renamingEntry?.collectionPath &&
+        e.contentId !== renamingEntry?.contentId &&
+        e.slug)
+        .map((e) => e.slug)), [entriesState, renamingEntry]);
+    // Tree expansion state - persists across panel close/open
     const treeExpandedStateRef = useRef({});
     const treeControllerRef = useRef(null);
     const handleTreeControllerReady = (controller) => {
@@ -572,12 +1131,15 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         contentRoot,
         entryLinkUrl,
     });
-    const previewFrameData = useMemo(() => {
-        const data = Object.keys(previewData).length > 0 ? previewData : effectiveValue;
-        if (!data)
-            return data;
-        return resolveEntryLinks(data);
-    }, [previewData, effectiveValue, resolveEntryLinks]);
+    // Resolved here, outside the form and its per-field crash boundaries, and during render, so
+    // the preview never receives a bare reference id: a reference is its target or `null`.
+    const { resolvedValue: previewValue, loadingState: previewLoadingState } = useReferenceResolution({
+        value: displayValue ?? EMPTY_VALUE,
+        fields: schema,
+        branch: branchNameState,
+        entryKey: currentEntry?.contentId,
+    });
+    const previewFrameData = useMemo(() => (displayValue ? resolveEntryLinks(previewValue) : displayValue), [previewValue, displayValue, resolveEntryLinks]);
     // Entry link context for the InsertEntryLink toolbar button
     const entryLinkContextValue = useMemo(() => ({
         entries: entriesState.map((e) => ({
@@ -594,13 +1156,38 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
             justifyContent: 'center',
             height: '100%',
         }, children: _jsx(Text, { size: "sm", c: "dimmed", children: children }) }));
-    const defaultPreview = currentEntry?.previewSrc && previewFrameData ? (_jsxs(Box, { pos: "relative", w: "100%", h: "100%", children: [previewError && (_jsx(Alert, { color: "red", title: "Preview error", withCloseButton: true, onClose: () => setPreviewError(null), style: { position: 'absolute', top: 8, left: 8, right: 8, zIndex: 2 }, children: previewError.fieldPath
-                    ? `${previewError.fieldPath}: ${previewError.message}`
-                    : previewError.message })), _jsx(PreviewFrame, { src: currentEntry.previewSrc, path: currentEntry.previewSrc, data: previewFrameData, isLoading: previewLoadingState, style: {
-                    width: '100%',
-                    height: '100%',
-                    border: '1px solid var(--mantine-color-gray-3)',
-                }, highlightEnabled: highlightEnabled, onPreviewError: setPreviewError })] })) : (_jsx(Paper, { withBorder: true, shadow: "xs", h: "100%", bg: "white", style: {
+    const { onMarks: onPreviewMarks, clearMarks: clearPreviewMarks, marksNothing: previewMarksNothing, inexactMarks: previewInexactMarks, } = usePreviewMarks({
+        src: currentEntry?.previewSrc,
+        highlightEnabled,
+        fields: schema,
+        data: displayValue,
+    });
+    // Only the default preview has the toolbar that maximizes and restores it. With no value to
+    // preview (an entry loading, or failed to load, with no draft) the form shows instead, and the
+    // choice reapplies once a value arrives.
+    const previewCanMaximize = !renderPreview && Boolean(currentEntry?.previewSrc) && !currentEntryUnavailable;
+    const previewShownMaximized = previewMaximized && previewCanMaximize && Boolean(previewFrameData);
+    useEffect(() => {
+        if (!previewCanMaximize)
+            setPreviewMaximized(false);
+    }, [previewCanMaximize]);
+    const [paneResizing, setPaneResizing] = useState(false);
+    const previewErrorField = previewError?.fieldPath
+        ? fieldBreadcrumb(schema, displayValue, previewError.fieldPath).join(' › ')
+        : '';
+    // An unavailable entry previews nothing: the site cannot read it, and a stored draft would
+    // otherwise mount the frame at a page that answers not-found.
+    const defaultPreview = currentEntry?.previewSrc && previewFrameData && !currentEntryUnavailable ? (_jsx(PreviewPane, { src: currentEntry.previewSrc, data: previewFrameData, isLoading: previewLoadingState, highlightEnabled: highlightEnabled, onPreviewError: setPreviewError, onMarks: onPreviewMarks, assetBase: authenticatedAssetBase(basePath), mount: { basePath, previewPrefix }, previewWidth: previewWidth, onPreviewWidthChange: setPreviewWidth, onHighlightToggle: () => {
+            setHighlightEnabled(!highlightEnabled);
+            clearPreviewMarks();
+        }, marksNothing: previewMarksNothing, inexactMarks: previewInexactMarks, showMarkDiagnostics: userIsAdmin, layout: layout, maximized: previewShownMaximized, onMaximizedChange: (maximized) => {
+            // A docked panel stays beside a maximized preview; an overlay one would sit inert under it.
+            if (maximized && !contentPanelDocked)
+                setNavigatorOpen(false);
+            setPreviewMaximized(maximized);
+        }, resizing: paneResizing, notice: previewError && (_jsx(Alert, { color: "red", title: "Preview error", withCloseButton: true, onClose: () => setPreviewError(null), radius: 0, children: previewErrorField
+                ? `${previewErrorField}: ${previewError.message}`
+                : previewError.message })) })) : (_jsx(Paper, { withBorder: true, shadow: "xs", h: "100%", bg: "var(--mantine-color-body)", style: {
             display: 'flex',
             alignItems: 'center',
             justifyContent: 'center',
@@ -611,89 +1198,175 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
                     : currentEntry && !currentEntry.previewSrc
                         ? 'No preview for this entry.'
                         : 'Select an item to start editing.' }) }));
-    const sidebarWidth = 64;
-    const footerHeight = 40;
-    const headerTitle = currentEntry?.label ?? currentEntry?.slug ?? title;
     const breadcrumbSegments = useMemo(() => buildBreadcrumbSegments(currentEntry, collectionLabels), [collectionLabels, currentEntry]);
-    return (_jsx(CanopyCMSProvider, { ...(themeOptions ?? {}), children: _jsx(AssetContextProvider, { baseUrl: assetBaseUrl, basePath: basePath, children: _jsxs(Box, { bg: "gray.0", style: { minHeight: '100vh', width: '100%' }, children: [_jsx(EditorHeader, { ref: headerRef, siteTitle: siteTitle, siteSubtitle: siteSubtitle, headerTitle: headerTitle, currentEntry: currentEntry, branchName: branchNameState, operatingMode: operatingMode, branchStatus: currentBranch?.status, busy: busy, breadcrumbSegments: breadcrumbSegments, editedFiles: editedFiles, modifiedCount: modifiedCount, unresolvedCommentCount: comments.filter((t) => !t.resolved).length, comments: comments, hasUnsavedChanges: isSelectedDirty(), userContext: userContext, branchCreatedBy: currentBranch?.createdBy, branchAccess: currentBranch?.access, 
-                        // Fail-closed for the same reason branchContentLocked above is:
-                        // isProtected/writeBlocked gate real actions in EditorHeader (hiding
-                        // Submit, disabling Save), so a missing wire value must read as
-                        // "protected"/"blocked", not "unprotected"/"unblocked".
-                        // branchWriteBlocked reuses branchContentLocked itself rather than
-                        // re-deriving `?? true` a second time here, so there is exactly one
-                        // fail-closed computation of "are writes blocked" in this component.
-                        branchIsProtected: currentBranch?.isProtected ?? true, branchReadOnly: currentBranch?.readOnly, branchWriteBlocked: branchContentLocked, onNavigatorOpen: () => setNavigatorOpen(true), onFileReload: handleReload, onFileDiscardDraft: handleDiscardFileDraft, onEntrySelect: setSelectedPath, onBranchReloadData: handleReloadBranchData, onBranchDiscardDrafts: handleDiscardDrafts, onBranchManagerOpen: () => {
-                            setBranchManagerOpen(true);
-                            // Always retry, not only when branchless. Opening the manager is
-                            // the one in-app retry for a failed branches fetch, and the fetch
-                            // is terminal on its own: SWRProvider sets shouldRetryOnError and
-                            // revalidateOnFocus false, and useBranchesData's refreshInterval
-                            // is 0 without data. Reloading is idempotent.
-                            loadBranches().catch(console.error);
-                        }, onCommentsPanelOpen: () => setCommentsPanelOpen(true), onSave: handleSave, onSubmit: () => branchNameState && handleSubmit(branchNameState), onWithdraw: () => branchNameState && handleWithdraw(branchNameState) }), _jsx(Box, { style: {
-                            paddingTop: headerHeight,
-                            paddingBottom: footerHeight,
-                            paddingRight: sidebarWidth,
-                            minHeight: '100vh',
-                            width: '100%',
-                        }, children: _jsxs(Box, { style: {
-                                height: `calc(100vh - ${headerHeight + footerHeight}px)`,
-                                minHeight: 0,
-                                position: 'relative',
-                            }, children: [_jsx(Box, { style: { flex: 1, minHeight: 0, height: '100%', width: '100%' }, children: _jsx(EditorPanes, { layout: layout, onLayoutChange: (next) => setLayout(next), preview: renderPreview && currentEntry
-                                            ? renderPreview(currentEntry, effectiveValue)
-                                            : defaultPreview, form: !currentEntry ? (_jsx(CenteredMessage, { children: !branchNameState && busy
-                                                ? 'Setting up your branch workspace…'
-                                                : entriesInitializing
-                                                    ? 'Loading content…'
-                                                    : 'Select an item to start editing.' })) : currentEntry.canEdit === false ? (_jsx(NoEditPermissionNotice, { entryPath: currentEntry.path })) : schema.length > 0 && effectiveValue ? (_jsx(EntryLinkContext.Provider, { value: entryLinkContextValue, children: _jsx(FormRenderer, { fields: schema, value: effectiveValue, onChange: (next) => {
-                                                    const contentId = currentEntry?.contentId;
-                                                    if (contentId) {
-                                                        setDrafts((prev) => ({ ...prev, [contentId]: next }));
-                                                    }
-                                                }, customRenderers: customRenderers, branch: branchNameState, onResolvedValueChange: setPreviewData, onLoadingStateChange: setPreviewLoadingState, comments: comments, currentEntryPath: selectedPath, currentUserId: currentUser, canResolve: canResolveComments, focusedFieldPath: focusedFieldPath, highlightThreadId: highlightThreadId, onAddComment: handleAddComment, onResolveThread: handleResolveThread, fieldErrors: fieldErrors, conflictNotice: !!(currentEntry?.contentId &&
-                                                    currentBranch?.conflictFiles?.includes(currentEntry.contentId)) }) })) : (_jsx(CenteredMessage, { children: "No fields to edit." })) }) }), _jsx(EditorSidebar, { layout: layout, highlightEnabled: highlightEnabled, sidebarWidth: sidebarWidth, headerHeight: headerHeight, footerHeight: footerHeight, onLayoutChange: setLayout, onHighlightToggle: () => setHighlightEnabled(!highlightEnabled), onPermissionManagerOpen: () => setPermissionManagerOpen(true), onGroupManagerOpen: () => setGroupManagerOpen(true), onMediaLibraryOpen: () => setMediaLibraryOpen(true), onSystemHealthOpen: showSystemHealth ? () => setSystemHealthOpen(true) : undefined, AccountComponent: AccountComponent, onAccountClick: onAccountClick, onLogoutClick: onLogoutClick })] }) }), _jsx(EditorFooter, {}), _jsxs(Drawer.Root, { opened: navigatorOpen, onClose: () => setNavigatorOpen(false), position: "left", size: 360, children: [_jsx(Drawer.Overlay, { blur: 2 }), _jsxs(Drawer.Content, { children: [_jsxs(Drawer.Header, { children: [_jsx(Drawer.Title, { children: "Content" }), _jsxs(Group, { gap: "xs", children: [navCollections &&
-                                                        navCollections.length > 0 &&
-                                                        !branchContentLocked &&
-                                                        (navCollections[0].onAdd || navCollections[0].onAddSubCollection) && (_jsxs(Menu, { shadow: "md", width: 200, withinPortal: true, position: "bottom-end", children: [_jsx(Menu.Target, { children: _jsx(ActionIcon, { variant: "subtle", color: "gray", size: "sm", "aria-label": "Content actions", children: _jsx(IconDots, { size: 16 }) }) }), _jsxs(Menu.Dropdown, { children: [navCollections[0].onAdd && (_jsx(Menu.Item, { leftSection: _jsx(IconPlus, { size: 14 }), onClick: () => navCollections[0].onAdd?.(), children: "Add Entry" })), navCollections[0].onAddSubCollection && (_jsx(Menu.Item, { leftSection: _jsx(IconFolderPlus, { size: 14 }), onClick: () => navCollections[0].onAddSubCollection?.(), children: "Add Collection" }))] })] })), _jsx(ActionIcon, { variant: "subtle", color: "gray", size: "sm", onClick: handleCollapseAll, title: "Collapse all folders", "aria-label": "Collapse all folders", children: _jsx(IconChevronUp, { size: 16 }) }), _jsx(ActionIcon, { variant: "subtle", color: "gray", size: "sm", onClick: handleExpandAll, title: "Expand all folders", "aria-label": "Expand all folders", children: _jsx(IconChevronDown, { size: 16 }) }), _jsx(Drawer.CloseButton, {})] })] }), _jsx(Drawer.Body, { p: 0, children: _jsx(Box, { px: "md", children: _jsx(EntryNavigator, { collections: navCollections, items: navCollections
-                                                    ? undefined
-                                                    : entriesState.map((e) => ({
-                                                        path: e.path,
-                                                        label: e.label,
-                                                        status: e.status,
-                                                    })), selectedPath: selectedPath, onSelect: (id) => {
-                                                    setSelectedPath(id);
-                                                    setNavigatorOpen(false);
-                                                }, onTreeControllerReady: handleTreeControllerReady, expandedStateRef: treeExpandedStateRef, onExpandedStateChange: handleExpandedStateChange, onDeleteEntry: handleDeleteEntry, onRenameEntry: handleRenameEntry, onReorderEntry: handleReorderEntry, hiddenRootPath: hiddenRootPath, loading: entriesInitializing, readOnly: branchContentLocked }) }) })] })] }), _jsx(Drawer, { opened: branchManagerOpen, onClose: () => setBranchManagerOpen(false), position: "right", title: _jsxs("div", { children: [_jsx(Title, { order: 4, children: "Branches" }), _jsx(Text, { size: "xs", c: "dimmed", children: "Manage access, status, and lifecycle" })] }), padding: "md", size: 420, overlayProps: { blur: 2 }, children: _jsx(BranchManager, { branches: branchSummaries, mode: operatingMode, user: userContext, onSelect: async (name) => {
-                                try {
-                                    await handleBranchChange(name);
-                                    setBranchManagerOpen(false);
-                                }
-                                catch (err) {
-                                    console.error('Branch change failed or was cancelled:', err);
-                                    // Don't close branch manager if there was an error or user cancelled
-                                }
-                            }, onCreate: handleCreateBranch, onSubmit: (name) => {
-                                handleSubmit(name).catch((err) => console.error(err));
-                            }, onWithdraw: (name) => {
-                                handleWithdraw(name).catch((err) => console.error(err));
-                            }, onRequestChanges: (name) => {
-                                handleRequestChanges(name).catch((err) => console.error(err));
-                            }, onDelete: (name) => {
-                                handleDelete(name).catch((err) => console.error(err));
-                            }, onClose: () => setBranchManagerOpen(false), comments: comments, currentUserId: currentUser, canResolve: canResolveComments, onAddComment: handleAddComment, onResolveThread: handleResolveThread, highlightThreadId: highlightThreadId, onGetUserMetadata: handleGetUserMetadata }) }), commentsPanelOpen && branchNameState && (_jsx(CommentsPanel, { branchName: branchNameState, comments: comments, canResolve: true, onAddComment: handleAddComment, onResolveThread: handleResolveThread, onClose: () => setCommentsPanelOpen(false), onJumpToField: handleJumpToField, onGetUserMetadata: handleGetUserMetadata, onJumpToEntry: handleJumpToEntry, onJumpToBranch: handleJumpToBranch })), _jsx(Drawer, { opened: groupManagerOpen, onClose: () => setGroupManagerOpen(false), position: "right", title: _jsxs("div", { children: [_jsx(Title, { order: 4, children: "Groups" }), _jsx(Text, { size: "xs", c: "dimmed", children: "Manage groups and organizations" })] }), padding: "md", size: 600, overlayProps: { blur: 2 }, children: _jsx(GroupManager, { internalGroups: groupsData, loading: groupsLoading, canEdit: true, onSave: handleSaveGroups, onSearchUsers: handleSearchUsers, onGetUserMetadata: handleGetUserMetadata, onSearchExternalGroups: handleSearchExternalGroups, onClose: () => setGroupManagerOpen(false) }) }), _jsx(Drawer, { opened: permissionManagerOpen, onClose: () => setPermissionManagerOpen(false), position: "right", title: _jsxs("div", { children: [_jsx(Title, { order: 4, children: "Permissions" }), _jsx(Text, { size: "xs", c: "dimmed", children: "Manage content access by path (read, edit, review)" })] }), padding: "md", size: 700, overlayProps: { blur: 2 }, children: _jsx(PermissionManager, { collections: activeCollections, contentRoot: contentRoot, permissions: permissionsData, loading: permissionsLoading, canEdit: true, onSave: handleSavePermissions, onSearchUsers: handleSearchUsers, onGetUserMetadata: handleGetUserMetadata, onListGroups: handleListGroups, onClose: () => setPermissionManagerOpen(false) }) }), showSystemHealth && (_jsx(SystemHealthPanel, { opened: systemHealthOpen, onClose: () => setSystemHealthOpen(false) })), _jsx(MediaLibrary, { opened: mediaLibraryOpen, onClose: () => setMediaLibraryOpen(false), mode: "manage" }), _jsx(CollectionEditor, { isOpen: collectionEditorOpen, editingCollection: editingCollection, parentPath: collectionEditorParentPath, availableSchemas: availableSchemas, onSave: handleCollectionSave, onAddEntryType: editingCollection ? (path, entryType) => addEntryType(path, entryType) : undefined, onUpdateEntryType: editingCollection
-                            ? (path, name, updates) => updateEntryType(path, name, updates)
-                            : undefined, onRemoveEntryType: editingCollection ? (path, name) => removeEntryType(path, name) : undefined, onClose: handleCloseCollectionEditor, isSaving: schemaLoading, error: collectionEditorError }), renamingEntry && (_jsx(RenameEntryModal, { isOpen: renameModalOpen, entryLabel: renamingEntry.label, currentSlug: renamingEntry.slug || '', onSave: handleRenameSubmit, onClose: () => {
-                            setRenameModalOpen(false);
-                            setRenamingEntry(null);
-                            setRenameModalError(null);
-                        }, isSaving: renameModalSaving, error: renameModalError })), createModalCollection && (_jsx(EntryCreateModal, { isOpen: createModalOpen, collectionLabel: createModalCollection.label || createModalCollection.name, entryTypes: createModalEntryTypes, onCreate: handleCreateModalSubmit, onClose: closeCreateModal, isCreating: createModalCreating, error: createModalError, existingSlugs: createModalExistingSlugs })), _jsx(ConfirmDeleteModal, { isOpen: deleteCollectionModalOpen, title: "Delete Collection", message: "Are you sure you want to delete this collection? This cannot be undone.", confirmLabel: "Delete Collection", onConfirm: confirmDeleteCollection, onClose: () => {
-                            setDeleteCollectionModalOpen(false);
-                            setDeletingCollectionPath(null);
-                        }, loading: deleteInProgress }), _jsx(ConfirmDeleteModal, { isOpen: deleteEntryModalOpen, title: "Delete Entry", message: "Are you sure you want to delete this entry? This cannot be undone.", confirmLabel: "Delete Entry", onConfirm: confirmDeleteEntry, onClose: () => {
-                            setDeleteEntryModalOpen(false);
-                            setDeletingEntryPath(null);
-                        }, loading: deleteInProgress })] }) }) }));
+    // The browser tab names the open entry and the site.
+    const tabTitle = currentEntry
+        ? `${currentEntry.label ?? currentEntry.slug} · ${siteTitle}`
+        : siteTitle;
+    // The host page's title comes back on unmount only if the tab still shows the editor's: a route
+    // navigated to may have set its own by then.
+    const writtenTitleRef = useRef(null);
+    useEffect(() => {
+        const hostTitle = document.title;
+        return () => {
+            if (document.title === writtenTitleRef.current)
+                document.title = hostTitle;
+        };
+    }, []);
+    useEffect(() => {
+        document.title = tabTitle;
+        writtenTitleRef.current = tabTitle;
+    }, [tabTitle]);
+    const openBranchManager = () => {
+        branchOpenerRef.current = rememberOpener();
+        setBranchManagerOpen(true);
+        // Always retry, not only when branchless. Opening the manager is
+        // the one in-app retry for a failed branches fetch, and the fetch
+        // is terminal on its own: SWRProvider sets shouldRetryOnError and
+        // revalidateOnFocus false, and useBranchesData's refreshInterval
+        // is 0 without data. Reloading is idempotent.
+        loadBranches().catch(console.error);
+    };
+    const contentPanel = (_jsx(SidePanelHost, { id: CONTENT_PANEL_ID, title: "Content", mode: contentPanelDocked ? 'docked' : 'overlay', opened: contentPanelShown, width: contentPanelWidth, minWidth: CONTENT_PANEL_WIDTH_MIN, maxWidth: CONTENT_PANEL_WIDTH_MAX, onWidthChange: setContentPanelWidth, onClose: () => setContentPanelShown(false), focusRequest: contentPanelFocusRequest, 
+        // Quick open takes focus as it replaces the overlay.
+        returnFocusTo: () => (quickOpenOpen ? null : navigatorReturnTarget()), "data-testid": "content-panel", actions: _jsxs(_Fragment, { children: [navCollections &&
+                    navCollections.length > 0 &&
+                    !branchContentLocked &&
+                    (navCollections[0].onAdd || navCollections[0].onAddSubCollection) && (_jsxs(Menu, { shadow: "md", width: 200, withinPortal: true, position: "bottom-end", children: [_jsx(Tooltip, { label: "Content actions", withinPortal: true, children: _jsx(Menu.Target, { children: _jsx(ActionIcon, { variant: "subtle", color: "gray", "aria-label": "Content actions", children: _jsx(IconDots, { size: 16 }) }) }) }), _jsxs(Menu.Dropdown, { children: [navCollections[0].onAdd && (_jsx(Menu.Item, { leftSection: _jsx(IconPlus, { size: 14 }), onClick: () => navCollections[0].onAdd?.(), children: "Add entry\u2026" })), navCollections[0].onAddSubCollection && (_jsxs(_Fragment, { children: [navCollections[0].onAdd && _jsx(Menu.Divider, {}), _jsx(Menu.Label, { children: "Admin" }), _jsx(Menu.Item, { leftSection: _jsx(IconFolderPlus, { size: 14 }), onClick: () => navCollections[0].onAddSubCollection?.(), children: "Add collection\u2026" })] }))] })] })), _jsx(Tooltip, { label: `${EDITOR_ACTIONS.openEntry} (${quickOpenShortcut})`, withinPortal: true, children: _jsx(ActionIcon, { variant: "subtle", color: "gray", onClick: openQuickOpen, "aria-label": EDITOR_ACTIONS.openEntry, "aria-keyshortcuts": quickOpenKeys, "data-testid": "quick-open-button", children: _jsx(IconSearch, { size: 16 }) }) }), _jsx(Tooltip, { label: "Collapse all folders", withinPortal: true, children: _jsx(ActionIcon, { variant: "subtle", color: "gray", onClick: handleCollapseAll, "aria-label": "Collapse all folders", children: _jsx(IconChevronUp, { size: 16 }) }) }), _jsx(Tooltip, { label: "Expand all folders", withinPortal: true, children: _jsx(ActionIcon, { variant: "subtle", color: "gray", onClick: handleExpandAll, "aria-label": "Expand all folders", children: _jsx(IconChevronDown, { size: 16 }) }) })] }), children: _jsx(Box, { px: "md", children: _jsx(EntryNavigator, { collections: navCollections, items: navCollections
+                    ? undefined
+                    : entriesState.map((e) => ({
+                        path: e.path,
+                        label: e.label,
+                        slug: e.slug,
+                        status: entryStatusLabel(activeCollections, e),
+                        readOnly: e.canEdit === false || undefined,
+                    })), selectedPath: selectedPath, onSelect: openEntry, onTreeControllerReady: handleTreeControllerReady, expandedStateRef: treeExpandedStateRef, onExpandedStateChange: handleExpandedStateChange, onDeleteEntry: handleDeleteEntry, onRenameEntry: handleRenameEntry, onReorderEntry: userIsAdmin ? handleReorderEntry : undefined, hiddenRootPath: hiddenRootPath, loading: entriesInitializing, readOnly: branchContentLocked, dirtyPaths: dirtyPaths, revealCollection: collectionReveal, onRevealed: () => setCollectionReveal(undefined) }) }) }));
+    return (_jsx(CanopyCMSProvider, { ...(themeOptions ?? {}), children: _jsx(AssetContextProvider, { basePath: basePath, children: _jsx(EditorShell, { topBar: _jsx(EditorHeader, { currentEntry: currentEntry, branchName: branchNameState, operatingMode: operatingMode, branchStatus: currentBranch?.status, busy: busy, breadcrumbSegments: breadcrumbSegments, editedFiles: editedFiles, modifiedCount: modifiedCount, 
+                    // A draft kept for an unavailable entry stays in storage but cannot be saved.
+                    hasUnsavedChanges: !currentEntryUnavailable && !contentReadOnly && isSelectedDirty(), entryHasDraft: isSelectedDirty(), entryReadOnly: currentEntry?.canEdit === false, draftStorageFailed: draftStorageFailed, userContext: userContext, branchCreatedBy: currentBranch?.createdBy, branchAccess: currentBranch?.access, 
+                    // Fail-closed for the same reason branchContentLocked above is:
+                    // isProtected/writeBlocked gate real actions in EditorHeader (hiding
+                    // Submit, disabling Save), so a missing wire value must read as
+                    // "protected"/"blocked", not "unprotected"/"unblocked".
+                    // branchWriteBlocked reuses branchContentLocked itself rather than
+                    // re-deriving `?? true` a second time here, so there is exactly one
+                    // fail-closed computation of "are writes blocked" in this component.
+                    branchIsProtected: currentBranch?.isProtected ?? true, branchReadOnly: currentBranch?.readOnly, branchWriteBlocked: branchContentLocked, 
+                    // A failed fetch leaves the list empty too; the banner says that one.
+                    branchLoading: !currentBranch && (branchesLoading || branchSummaries.length === 0), onNavigatorOpen: openNavigator, onCollectionOpen: revealCollection, navigatorToggleRef: navigatorToggleRef, branchToggleRef: branchToggleRef, onFileReload: () => handleReload(() => navigatorToggleRef.current), onFileDiscardDraft: () => handleDiscardFileDraft(() => navigatorToggleRef.current), onEntryRename: () => currentEntry && handleRenameEntry(currentEntry.path, true), onEntryDelete: () => currentEntry && handleDeleteEntry(currentEntry.path, true), allContentRef: allContentCrumbRef, entryUnavailable: currentEntryUnavailable, onEntrySelect: openEntry, onBranchReloadData: () => {
+                        void Promise.all([handleReloadBranchData(), refreshEntries(branchNameState)]).catch(console.error);
+                    }, onBranchDiscardDrafts: () => handleDiscardDrafts(() => branchToggleRef.current), onBranchManagerOpen: openBranchManager, onSave: currentEntryUnavailable ? noop : handleSave, onSaveAll: runSaveAll, saveAllProgress: saveAllProgress, saving: singleSaving?.branch === branchNameState &&
+                        singleSaving.contentId === currentEntry?.contentId, savedSignal: lastSaved?.seq, savedHere: lastSaved?.branch === branchNameState &&
+                        lastSaved.contentId === currentEntry?.contentId, 
+                    // Save all finds each draft's entry in the list, so with none listed it would save nothing.
+                    entryListFailed: entriesLoadFailed && entriesState.length === 0, onSubmit: () => {
+                        if (branchNameState && !isSaveAllRunning()) {
+                            handleSubmit(branchNameState).catch(console.error);
+                        }
+                    }, onWithdraw: () => {
+                        if (branchNameState && !isSaveAllRunning()) {
+                            handleWithdraw(branchNameState).catch(console.error);
+                        }
+                    } }), banner: _jsx(BranchLockBanner, { branchName: branchNameState, branchStatus: currentBranch?.status, branchReadOnly: currentBranch?.readOnly, branchWriteBlocked: branchContentLocked, onBranchManagerOpen: openBranchManager }), rail: _jsx(EditorRail, { siteTitle: siteTitle, onHomeOpen: () => {
+                        const first = entriesState[0];
+                        if (first)
+                            openEntry(first.path);
+                    }, contentPanelOpen: contentPanelShown, contentPanelId: CONTENT_PANEL_ID, onContentToggle: () => contentPanelShown ? setContentPanelShown(false) : openNavigator(), onQuickOpen: openQuickOpen, quickOpenShortcut: quickOpenShortcut, quickOpenKeys: quickOpenKeys, branchesOpen: branchManagerOpen, onBranchesOpen: openBranchManager, onCommentsOpen: clientOperatingStrategy(operatingMode ?? 'prod').supportsComments() &&
+                        branchNameState
+                        ? () => setCommentsPanelOpen(true)
+                        : undefined, commentsOpen: commentsPanelOpen, unresolvedCommentCount: comments.filter((t) => !t.resolved).length, mediaLibraryOpen: mediaLibraryOpen, onMediaLibraryOpen: () => setMediaLibraryOpen(true), mediaButtonRef: mediaButtonRef, layout: layout, onLayoutChange: setLayout, layoutBlocked: previewShownMaximized, onPermissionManagerOpen: userIsAdmin ? () => setPermissionManagerOpen(true) : undefined, onGroupManagerOpen: userIsAdmin ? () => setGroupManagerOpen(true) : undefined, onSystemHealthOpen: userIsAdmin ? () => setSystemHealthOpen(true) : undefined, settingsToggleRef: settingsToggleRef, AccountComponent: AccountComponent, onAccountClick: onAccountClick, onLogoutClick: onLogoutClick }), panel: contentPanelDocked ? contentPanel : undefined, main: _jsx(Box, { h: "100%", children: _jsx(PaneLayout, { formOverlay: contentPanelDocked ? undefined : contentPanel, formInert: contentOverlayShown, previewMaximized: previewShownMaximized, 
+                        // Sizing the pane, by pointer or key, gives the page the pane's width.
+                        onSeparatorDrag: (dragging) => {
+                            setPaneResizing(dragging);
+                            if (dragging)
+                                setPreviewWidth('fit');
+                        }, arrangement: layout, sideSplitPercent: sideSplitPercent, stackedSplitPercent: stackedSplitPercent, onSplitPercentChange: (arrangement, percent) => {
+                            setSplitPercent(arrangement, percent);
+                            setPreviewWidth('fit');
+                        }, preview: renderPreview && currentEntry && !currentEntryUnavailable
+                            ? renderPreview(currentEntry, displayValue)
+                            : defaultPreview, form: !currentEntry ? (_jsx(CenteredMessage, { children: !branchNameState && busy
+                                ? 'Setting up your branch workspace…'
+                                : entriesInitializing
+                                    ? 'Loading content…'
+                                    : 'Select an item to start editing.' })) : currentEntryUnavailable ? (_jsx(UnavailableEntryNotice, { schemaRefs: currentEntry.unavailable ? [currentEntry.unavailable.schemaRef] : [] })) : currentEntry.canEdit === false ? (_jsx(NoEditPermissionNotice, { entryLabel: currentEntry.label })) : schema.length > 0 && displayValue ? (_jsx(EntryLinkContext.Provider, { value: entryLinkContextValue, children: _jsx(SiteMdxAllowContext.Provider, { value: mdxAllow, children: _jsx(FormRenderer, { notice: hiddenDraftNotice && (_jsx(ReadOnlyDraftNotice, { permanentlyReadOnly: (currentBranch?.isProtected ?? true) ||
+                                            currentBranch?.status === 'archived', 
+                                        // A hidden draft's discard changes nothing on screen, so it says so.
+                                        onDiscard: () => handleDiscardFileDraft(() => navigatorToggleRef.current, {
+                                            announce: true,
+                                        }) })), fields: schema, value: displayValue, readOnly: contentReadOnly, onRemoved: handleFieldRemoved, commentBlockedReason: commentBlockedReason, removedItemFieldLabel: commentFieldLabel, onGetUserMetadata: getCommentUserMetadata, header: {
+                                        title: currentEntry.label,
+                                        typeLabel: entryTypeLabel(activeCollections, currentEntry),
+                                    }, 
+                                    // The one writer of drafts. Read-only content gets none, whatever a
+                                    // field emits (MDXEditor's mount-time normalisation included).
+                                    onChange: (next) => {
+                                        const contentId = currentEntry?.contentId;
+                                        if (contentId && !contentReadOnlyRef.current) {
+                                            // Every list item keeps a key, whatever field made it.
+                                            const keyed = withItemKeys(schema, next, 'random');
+                                            setDrafts((prev) => ({ ...prev, [contentId]: keyed }));
+                                        }
+                                    }, customRenderers: customRenderers, branch: branchNameState, comments: displayComments, currentEntryPath: selectedPath, currentUserId: commentUserId, canResolve: canResolveAnyComment, focusedFieldPath: focusedFieldPath, highlightThreadId: highlightThreadId, onAddComment: handleAddDisplayedComment, onResolveThread: handleResolveThread, fieldErrors: fieldErrors, format: currentEntry.format, conflictNotice: !!(currentEntry?.contentId &&
+                                        currentBranch?.conflictFiles?.includes(currentEntry.contentId)) }) }) })) : schema.length === 0 ? (_jsx(CenteredMessage, { children: "No fields to edit." })) : loadFailedKey !== `${branchNameState}:${currentEntry.contentId}` ? (_jsx(Stack, { gap: "lg", p: "md", "data-testid": "entry-loading-skeleton", children: [0, 1, 2].map((row) => (_jsxs(Stack, { gap: 6, children: [_jsx(Skeleton, { h: 12, w: 120 }), _jsx(Skeleton, { h: 36 })] }, row))) })) : (_jsx(Alert, { color: "red", variant: "light", m: "md", title: "This entry couldn't be loaded.", "data-testid": "entry-load-failed", children: _jsx(Button, { variant: "default", onClick: () => {
+                                    setLoadFailedKey(null);
+                                    setLoadAttempt((attempt) => attempt + 1);
+                                }, children: "Retry" }) })) }) }), overlays: _jsxs(_Fragment, { children: [_jsx(QuickOpenPalette, { opened: quickOpenOpen, onOpen: openQuickOpen, onClose: () => setQuickOpenOpen(false), returnFocusTo: quickOpenFromOverlay ? navigatorReturnTarget : undefined, entries: entriesState, 
+                            // The hidden root's entries sit at the top of the tree, so they get no heading here either.
+                            collectionLabel: (path) => path === hiddenRootPath ? '' : collectionLabels.get(path), onSelect: setSelectedPath }), _jsx(BranchesDrawer, { opened: branchManagerOpen, onClose: () => setBranchManagerOpen(false), confirmOpen: branchConfirmOpen, returnFocusTo: branchReturnTarget, children: _jsx(BranchManager, { branches: branchSummaries, mode: operatingMode, user: userContext, currentBranchName: currentBranch?.name ?? branchNameState, currentWorkflowBlockedReason: saveAllProgress ? 'Wait for Save all to finish.' : undefined, onSelect: async (name) => {
+                                    try {
+                                        await handleBranchChange(name);
+                                        setBranchManagerOpen(false);
+                                    }
+                                    catch (err) {
+                                        console.error('Branch change failed or was cancelled:', err);
+                                        // Don't close branch manager if there was an error or user cancelled
+                                    }
+                                }, onBeforeCreate: confirmCreateBranch, onCreate: handleCreateBranch, 
+                                // A Save all mid-run on the open branch would be submitted partway through.
+                                onSubmit: (name) => {
+                                    if (name === branchNameState && isSaveAllRunning())
+                                        return;
+                                    handleSubmit(name).catch((err) => console.error(err));
+                                }, onWithdraw: (name) => {
+                                    if (name === branchNameState && isSaveAllRunning())
+                                        return;
+                                    handleWithdraw(name).catch((err) => console.error(err));
+                                }, onRequestChanges: (name) => {
+                                    handleRequestChanges(name).catch((err) => console.error(err));
+                                }, onDelete: (name) => {
+                                    handleDelete(name).catch((err) => console.error(err));
+                                }, onClose: () => setBranchManagerOpen(false), comments: comments, currentUserId: commentUserId, canResolve: canResolveAnyComment, onAddComment: handleAddComment, onResolveThread: handleResolveThread, highlightThreadId: highlightThreadId, onGetUserMetadata: canResolveUserNames ? handleGetUserMetadata : undefined, onGetOwnerMetadata: getCommentUserMetadata, onGetCommentUserMetadata: getCommentUserMetadata }) }), branchNameState && (_jsx(CommentsPanel, { opened: commentsPanelOpen, branchName: branchNameState, comments: displayComments, canResolve: canResolveAnyComment, currentUserId: commentUserId, entryLabel: commentEntryLabel, fieldLabel: commentFieldLabel, onAddComment: handleAddDisplayedComment, onResolveThread: handleResolveThread, onClose: () => setCommentsPanelOpen(false), onJumpToField: jumpToThreadField, onGetUserMetadata: getCommentUserMetadata, onJumpToEntry: handleJumpToEntry, onJumpToBranch: handleJumpToBranch }, branchNameState)), userIsAdmin && (_jsx(GroupManager, { opened: groupManagerOpen, onClose: () => setGroupManagerOpen(false), returnFocusTo: settingsReturnTarget, internalGroups: groupsData, loading: groupsLoading, canEdit: userIsAdmin, onSave: handleSaveGroups, onSearchUsers: handleSearchUsers, onGetUserMetadata: handleGetUserMetadata, onSearchExternalGroups: handleSearchExternalGroups })), userIsAdmin && (_jsx(PermissionManager, { opened: permissionManagerOpen, onClose: () => setPermissionManagerOpen(false), returnFocusTo: settingsReturnTarget, collections: activeCollections, contentRoot: contentRoot, permissions: permissionsData, loading: permissionsLoading, canEdit: userIsAdmin, onSave: handleSavePermissions, onSearchUsers: handleSearchUsers, onGetUserMetadata: handleGetUserMetadata, onListGroups: handleListGroups })), userIsAdmin && (_jsx(SystemHealthPanel, { opened: systemHealthOpen, onClose: () => setSystemHealthOpen(false), returnFocusTo: settingsReturnTarget })), _jsx(MediaLibrary, { opened: mediaLibraryOpen, onClose: () => setMediaLibraryOpen(false), mode: "manage", returnFocusTo: () => mediaButtonRef.current }), userIsAdmin && (_jsx(CollectionEditor, { isOpen: collectionEditorOpen, editingCollection: editingCollection, parentPath: collectionEditorParentPath, availableSchemas: availableSchemas, onSave: handleCollectionSave, onAddEntryType: editingCollection
+                                ? (path, entryType) => addEntryType(path, entryType)
+                                : undefined, onUpdateEntryType: editingCollection
+                                ? (path, name, updates) => updateEntryType(path, name, updates)
+                                : undefined, onRemoveEntryType: editingCollection ? (path, name) => removeEntryType(path, name) : undefined, onReloadEntryTypes: editingCollection ? readEntryTypes : undefined, onClose: handleCloseCollectionEditor, isSaving: schemaLoading, error: collectionEditorError, restored: restoredCollectionInput, onDiscardRestored: () => {
+                                collectionDraftRef.current = null;
+                                setRestoredCollectionInput(null);
+                            } })), renamingEntry && (_jsx(RenameEntryModal, { isOpen: renameModalOpen, entryLabel: renamingEntry.label, currentSlug: renamingEntry.slug || '', onSave: handleRenameSubmit, 
+                            // `renamingEntry` stays until the next rename, so the dialog plays its exit and
+                            // returns focus.
+                            onClose: () => {
+                                setRenameModalOpen(false);
+                                setRenameModalError(null);
+                            }, isSaving: renameModalSaving, returnFocusTo: entryChangeReturnTarget, error: renameModalError?.mayHaveLanded ? null : renameModalError?.message, warning: renameModalError?.mayHaveLanded ? renameModalError.message : null, existingSlugs: renameExistingSlugs, previewPath: (slug) => previewPathFor({
+                                collectionPath: renamingEntry.collectionPath ?? '',
+                                collectionName: renamingEntry.collectionName,
+                                slug,
+                                entryType: renamingEntry.entryType,
+                            }) })), createModalCollection && (_jsx(EntryCreateModal, { isOpen: createModalOpen, collectionLabel: createModalCollection.label || createModalCollection.name, entryTypes: createModalEntryTypes, onCreate: handleCreateModalSubmit, onClose: closeCreateModal, isCreating: createModalCreating, error: createModalError, existingSlugs: createModalExistingSlugs, previewPath: (slug, entryTypeName) => previewPathFor({
+                                collectionPath: createModalCollection.path,
+                                collectionName: createModalCollection.name,
+                                slug,
+                                entryType: entryTypeName,
+                            }) })), _jsx(ConfirmDeleteModal, { isOpen: deleteCollectionModalOpen, title: "Delete Collection", message: "Are you sure you want to delete this collection? This cannot be undone.", confirmLabel: "Delete Collection", onConfirm: confirmDeleteCollection, onClose: () => {
+                                setDeleteCollectionModalOpen(false);
+                                setDeletingCollectionPath(null);
+                            }, loading: deleteInProgress }), _jsx(ConfirmDeleteModal, { isOpen: deleteEntryModalOpen, title: "Delete entry", message: deletingEntryReferencedBy
+                                ? referencedDeleteMessage(deletingEntryReferencedBy)
+                                : `Delete ${deletingEntryLabel ? `"${deletingEntryLabel}"` : 'this entry'}? This cannot be undone.`, confirmLabel: deletingEntryReferencedBy ? 'Delete anyway' : 'Delete entry', onConfirm: confirmDeleteEntry, onClose: closeDeleteEntryModal, loading: deleteInProgress, returnFocusTo: entryChangeReturnTarget, children: deletingEntryReferencedBy && (_jsx(ReferencedByList, { referencedBy: deletingEntryReferencedBy, onOpenEntry: (entryPath) => {
+                                    closeDeleteEntryModal();
+                                    openEntry(entryPath);
+                                } })) })] }) }) }) }));
 };
 export default Editor;