canopycms 0.0.67-int.90 → 0.0.67

package/dist/editor/Editor.js

@@ -15,7 +15,6 @@ 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
-// (same rationale as BranchManager.tsx's identical import)
 import { isAdmin } from '../authorization/helpers.js';
 import { buildPreviewSrc, buildCollectionLabels, buildBreadcrumbSegments } from './editor-utils.js';
 import { useEditorLayout, useDraftManager, useEntryManager, useGroupManager, usePermissionManager, useCommentSystem, useBranchManager, useUserContext, useSchemaManager, } from './hooks/index.js';
@@ -34,7 +33,6 @@ import { MediaLibrary } from './media/MediaLibrary.js';
  * 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, currentUser = 'current-user', canResolveComments = true, assetBaseUrl, basePath, AccountComponent, onAccountClick, onLogoutClick, customRenderers, }) => {
-    // Per-resource loading states
     const [branchesLoading, setBranchesLoading] = useState(false);
     const [entriesLoading, setEntriesLoading] = useState(false);
     const [commentsLoading] = useState(false);
@@ -44,17 +42,14 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
     const [branchManagerOpen, setBranchManagerOpen] = useState(false);
     const [mediaLibraryOpen, setMediaLibraryOpen] = useState(false);
     const [systemHealthOpen, setSystemHealthOpen] = useState(false);
-    // Schema editor state
     const [collectionEditorOpen, setCollectionEditorOpen] = useState(false);
     const [editingCollection, setEditingCollection] = useState(null);
     const [collectionEditorParentPath, setCollectionEditorParentPath] = useState(undefined);
     const [collectionEditorError, setCollectionEditorError] = useState(null);
-    // Rename entry modal state
     const [renameModalOpen, setRenameModalOpen] = useState(false);
     const [renamingEntry, setRenamingEntry] = useState(null);
     const [renameModalError, setRenameModalError] = useState(null);
     const [renameModalSaving, setRenameModalSaving] = useState(false);
-    // Delete confirmation modal state
     const [deleteCollectionModalOpen, setDeleteCollectionModalOpen] = useState(false);
     const [deletingCollectionPath, setDeletingCollectionPath] = useState(null);
     const [deleteEntryModalOpen, setDeleteEntryModalOpen] = useState(false);
@@ -65,15 +60,12 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
     const [previewLoadingState, setPreviewLoadingState] = useState({});
     // Draft compile/render error reported by the preview page (null = renders cleanly)
     const [previewError, setPreviewError] = useState(null);
-    // API client for schema operations
     const apiClient = useApiClient();
-    // Fetch current user context for permission checks
     const { userContext } = useUserContext();
-    // The System Health panel (PR-U1) is admin-only -- gate both the sidebar
+    // 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);
-    // Use custom hooks for layout, entry, draft, group, permission, comment, and branch management
     const { layout, setLayout, highlightEnabled, setHighlightEnabled, headerRef, headerHeight } = useEditorLayout();
     // Comments state (shared between useCommentSystem and useBranchManager)
     const [commentsForBranchSummaries, setCommentsForBranchSummaries] = useState([]);
@@ -90,21 +82,11 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
     // computed server-side by the same getBranchProtection() call the writableBranch
     // guard uses, so the UI can never drift from what the API will accept.
     //
-    // Fail CLOSED (`?? true`) when `currentBranch` is undefined or the wire didn't
-    // carry `writeBlocked` at all (branches-list fetch still in flight/failed, or
-    // editor/server version skew where an older server doesn't emit the flag). This
-    // is a deliberately inverted default from the OLD client-side derivation this
-    // flag replaced (`branchStatus !== 'editing'`), which locked correctly even with
-    // zero data from the server -- "no answer yet" and "not editing" both compute to
-    // locked when the fallback is itself a status comparison. Moving the decision
-    // server-side was the right call (the API guard and the UI now read one source
-    // of truth instead of two independent derivations that could drift), but an
-    // `?? false` default silently flipped what "no answer yet" means: a client that
-    // can't hear the server's answer now assumed UNLOCKED instead of LOCKED. A brief
-    // flash of locked (corrected the moment the branch list loads) is strictly safer
-    // than a flash of unlocked that invites a click the server is going to reject --
-    // and the pane is already showing a loading state during that same window, so
-    // the flash is not even visible in practice.
+    // `?? true`: with no answer from the server (branches fetch in flight or
+    // failed, or an older server without the flag) the editor must stay locked. A
+    // brief flash of locked, corrected when the list loads, is safer than a flash
+    // of unlocked that invites a click the server rejects -- and the pane shows a
+    // 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({
@@ -121,12 +103,10 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         }),
         setBusy: setEntriesLoading,
     });
-    // Keep the entry-type list referentially stable for as long as the create
-    // modal is showing the same collection. Building it inline in the JSX handed
-    // EntryCreateModal a new array on every render of this component, which its
-    // form-seeding effect used to treat as a reason to reset the user's input.
-    // That effect no longer keys on the array, but a stable prop is still the
-    // right thing to pass: it also keeps Mantine's Select `data` identity steady.
+    // 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
+    // spurious reason to reset the user's input.
     const createModalEntryTypes = useMemo(() => createModalCollection?.entryTypes?.map((et) => ({
         name: et.name,
         label: et.label,
@@ -188,8 +168,6 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
     });
     const collectionLabels = useMemo(() => buildCollectionLabels(activeCollections), [activeCollections]);
     const schema = currentEntry?.schema ?? [];
-    // Effect to load entry data when selection changes.
-    //
     // 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-
@@ -252,7 +230,7 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
                 if (currentBranchRef.current !== requestBranch)
                     return;
                 setLoadedValues((prev) => ({ ...prev, [contentId]: loaded }));
-                // NOTE: no draft is seeded here. `effectiveValue` is
+                // No draft is seeded here. `effectiveValue` is
                 // `drafts[id] ?? loadedValues[id]`, so the form renders from the line
                 // above alone; seeding `drafts[id] = loaded` only manufactured a
                 // pristine draft for every entry the user merely OPENED, which
@@ -286,17 +264,14 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         });
         // eslint-disable-next-line react-hooks/exhaustive-deps -- stable setters, run only on entry/path/branch/loadedValues change
     }, [currentEntry, loadedValues, selectedPath, branchNameState]);
-    // Schema editor handlers
     const handleOpenCollectionEditor = async (collection, parentPath) => {
         if (collection) {
-            // Edit mode - fetch full collection data with usage counts
             try {
                 const result = await apiClient.schema.getCollection({
                     branch: branchNameState,
                     collectionPath: collection.path,
                 });
                 if (result.ok && result.data && result.data.collection) {
-                    // Use entry types with usage counts from API if available
                     const entries = result.data.entryTypesWithUsage
                         ? result.data.entryTypesWithUsage.map((et) => ({
                             name: et.name,
@@ -324,7 +299,6 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
                     setEditingCollection(existingCollection);
                 }
                 else {
-                    // Fallback to using EditorCollection data
                     const existingCollection = {
                         name: collection.name,
                         label: collection.label,
@@ -342,7 +316,6 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
                 }
             }
             catch {
-                // Fallback on error
                 const existingCollection = {
                     name: collection.name,
                     label: collection.label,
@@ -361,7 +334,6 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
             setCollectionEditorParentPath(undefined);
         }
         else {
-            // Create mode
             setEditingCollection(null);
             setCollectionEditorParentPath(parentPath);
         }
@@ -426,7 +398,6 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         try {
             const result = await deleteEntry(deletingEntryPath);
             if (result.ok && selectedPath === deletingEntryPath) {
-                // If we deleted the currently selected entry, clear selection
                 setSelectedPath('');
             }
             setDeleteEntryModalOpen(false);
@@ -466,7 +437,6 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         }
     };
     const handleReorderEntry = async (collectionPath, contentId, direction) => {
-        // Find the collection to get its current order array
         const findCollection = (cols, path) => {
             if (!cols)
                 return undefined;
@@ -479,21 +449,13 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
             }
             return undefined;
         };
-        // Resolve against `collectionsFromApi`, NOT `activeCollections`. The
-        // latter falls back to the build-time `collections` prop whenever the
-        // fetched list is empty (`activeCollections = collectionsFromApi.length >
-        // 0 ? collectionsFromApi : collections`, above) -- which is exactly the
-        // state mid-branch-switch, before the new branch's entries/collections
-        // fetch has committed. Resolving a WRITE against that fallback meant this
-        // guard could never fire during a switch: it would happily find the OLD
-        // branch's collection in the stale build-time props and send ITS `order`
-        // array as a PATCH to the NEW branch. Reading `collectionsFromApi`
-        // directly makes "not yet loaded for this branch" and "loaded, has no
-        // such collection" the same (correct) not-found outcome, so the guard
-        // below is reachable again. See the correction to PR #196's "unreachable
-        // with entries empty" claim in
-        // .claude/future-tasks/resolved/program-b-final-review-followups.md for the write
-        // hazard this closes -- found by the 2026-08-12 adversarial review.
+        // Resolve against `collectionsFromApi`, NOT `activeCollections`: the latter
+        // falls back to the build-time `collections` prop whenever the fetch is
+        // still empty -- exactly the state mid-branch-switch. A write resolved
+        // against that fallback would silently PATCH the OLD branch's `order` onto
+        // the NEW branch instead of hitting the not-found guard below; reading
+        // `collectionsFromApi` directly makes "not yet loaded" and "loaded, no such
+        // collection" the same not-found outcome.
         const collection = findCollection(collectionsFromApi, collectionPath);
         if (!collection) {
             // A silent no-op on a clicked menu item reads as a broken button --
@@ -507,14 +469,11 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
             });
             return;
         }
-        // Use the collection's order array as the source of truth
-        // If no order array exists, build one from current entries and children
         let currentOrder;
         if (collection.order && collection.order.length > 0) {
             currentOrder = [...collection.order];
         }
         else {
-            // Fallback: build order from entries and children
             const collectionEntries = entriesState.filter((e) => e.collectionPath === collectionPath);
             const entryIds = collectionEntries
                 .map((e) => e.contentId)
@@ -524,18 +483,14 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
                 .filter((id) => !!id);
             currentOrder = [...entryIds, ...subCollectionIds];
         }
-        // Find current position
         const currentIndex = currentOrder.indexOf(contentId);
         if (currentIndex === -1)
             return;
-        // Calculate new position
         const newIndex = direction === 'up' ? currentIndex - 1 : currentIndex + 1;
         if (newIndex < 0 || newIndex >= currentOrder.length)
             return;
-        // Swap positions
         const newOrder = [...currentOrder];
         [newOrder[currentIndex], newOrder[newIndex]] = [newOrder[newIndex], newOrder[currentIndex]];
-        // Update via API
         await updateOrder(collectionPath, newOrder);
     };
     // Determine if we should hide the root collection (but keep its context for ordering)
@@ -565,7 +520,6 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
         const build = (node) => {
             const entries = grouped.get(node.path) ?? [];
             const children = node.children?.map((child) => build(child)) ?? [];
-            // Pass entries, children, and order to EntryNavigator for interleaved ordering
             return {
                 path: node.path,
                 label: node.label ?? node.name,
@@ -597,7 +551,6 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
     ]);
     // Tree expansion state - persists across drawer close/open
     const treeExpandedStateRef = useRef({});
-    // Tree controller ref for collapse/expand all functionality
     const treeControllerRef = useRef(null);
     const handleTreeControllerReady = (controller) => {
         treeControllerRef.current = controller;
@@ -607,15 +560,12 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
     };
     const handleCollapseAll = () => {
         treeControllerRef.current?.collapseAllNodes();
-        // Sync the ref to empty state
         treeExpandedStateRef.current = {};
     };
     const handleExpandAll = () => {
         treeControllerRef.current?.expandAllNodes();
-        // Sync the ref with all expanded nodes from controller
         treeExpandedStateRef.current = treeControllerRef.current?.expandedState ?? {};
     };
-    // Resolve entry:ID links in body content for live preview
     const { resolveEntryLinks } = useEntryLinkResolution({
         entries: entriesState,
         contentRoot,
@@ -637,7 +587,6 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
             collectionName: e.collectionName,
         })),
     }), [entriesState]);
-    // Helper component for centered messages
     const CenteredMessage = ({ children }) => (_jsx("div", { style: {
             display: 'flex',
             alignItems: 'center',
@@ -677,13 +626,7 @@ export const Editor = ({ entries, title, subtitle, siteTitle = title, siteSubtit
                             // 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. This used to be gated on `!branchNameState`,
-                            // which was harmless while a failed fetch merely left the UI
-                            // unlocked -- but content writes now fail CLOSED on missing branch
-                            // data, so with a pinned branch (every ordinary adopter setup)
-                            // that gate turned one network blip into a session-long lockout
-                            // whose only escape was a page reload, behind a "Manage Branches"
-                            // button that pointedly did not retry. Reloading is idempotent.
+                            // 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,

package/dist/editor/EditorAuthGate.d.ts

@@ -0,0 +1,27 @@
+/**
+ * EditorAuthGate — decides, from the SERVER, whether the editor below it may mount.
+ *
+ * A 401 from the CMS API is the only signed-out signal trusted: the API accepts or rejects every
+ * request, and client-side auth state (Clerk's `isSignedIn`, a dev cookie) can disagree with it.
+ *
+ * - The editor mounts only once `whoami` succeeds, so it always belongs to a known identity. A
+ *   401 first shows the provider's `SignInComponent` full-screen; any other failure shows the
+ *   error with Retry. The editor's first requests therefore wait one `whoami` round trip.
+ * - After mount, a 401 from ANY request overlays the sign-in UI on the still-mounted editor, so
+ *   unsaved edits survive re-authentication. The request that 401'd is not retried.
+ * - Re-authenticating as the same user keeps the editor and revalidates its SWR cache; as a
+ *   different user the editor and its cache remount, because the SWRProvider is keyed by user id.
+ * - A re-check that fails for a non-auth reason keeps the sign-in UI up with the error and Retry,
+ *   so a provider that has already reported sign-in is never left waiting on nothing.
+ */
+import React from 'react';
+import type { EditorSignInProps } from '../config/index.js';
+import { type CanopyThemeOptions } from './theme.js';
+export interface EditorAuthGateProps {
+    children: React.ReactNode;
+    /** The auth provider's sign-in UI. Absent, a plain "sign in, then continue" notice is shown. */
+    SignInComponent?: React.ComponentType<EditorSignInProps>;
+    /** The editor's theme, so the gate's own screens match it. */
+    themeOptions?: CanopyThemeOptions;
+}
+export declare function EditorAuthGate({ children, SignInComponent, themeOptions }: EditorAuthGateProps): import("react/jsx-runtime").JSX.Element;

package/dist/editor/EditorAuthGate.js

@@ -0,0 +1,140 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * EditorAuthGate — decides, from the SERVER, whether the editor below it may mount.
+ *
+ * A 401 from the CMS API is the only signed-out signal trusted: the API accepts or rejects every
+ * request, and client-side auth state (Clerk's `isSignedIn`, a dev cookie) can disagree with it.
+ *
+ * - The editor mounts only once `whoami` succeeds, so it always belongs to a known identity. A
+ *   401 first shows the provider's `SignInComponent` full-screen; any other failure shows the
+ *   error with Retry. The editor's first requests therefore wait one `whoami` round trip.
+ * - After mount, a 401 from ANY request overlays the sign-in UI on the still-mounted editor, so
+ *   unsaved edits survive re-authentication. The request that 401'd is not retried.
+ * - Re-authenticating as the same user keeps the editor and revalidates its SWR cache; as a
+ *   different user the editor and its cache remount, because the SWRProvider is keyed by user id.
+ * - A re-check that fails for a non-auth reason keeps the sign-in UI up with the error and Retry,
+ *   so a provider that has already reported sign-in is never left waiting on nothing.
+ */
+import { useCallback, useEffect, useMemo, useReducer, useRef } from 'react';
+import { Alert, Button, Center, Loader, Modal, Paper, Stack, Text, Title } from '@mantine/core';
+import { useSWRConfig } from 'swr';
+import { getErrorMessage } from '../utils/error.js';
+import { useApiClient, useOnUnauthorized } from './context/ApiClientContext.js';
+import { EditorIdentityContext } from './context/EditorIdentityContext.js';
+import { SWRProvider } from './context/SWRProvider.js';
+import { CanopyCMSProvider } from './theme.js';
+const initialGateState = {
+    phase: 'checking',
+    user: undefined,
+    sessionRejected: false,
+    error: undefined,
+    reauthCount: 0,
+};
+function gateReducer(state, action) {
+    switch (action.type) {
+        case 'accepted':
+            return {
+                phase: 'signed-in',
+                user: action.user,
+                sessionRejected: false,
+                error: undefined,
+                reauthCount: state.phase === 'signed-out' ? state.reauthCount + 1 : state.reauthCount,
+            };
+        case 'unauthorized': {
+            // Sticky while signed out: the mounted editor keeps making requests behind the overlay,
+            // they 401 too, and they must not clear a rejection the provider is showing.
+            const sessionRejected = (state.phase === 'signed-out' && state.sessionRejected) || action.afterSignIn;
+            // A re-check's own 401 supersedes an earlier failure; a background 401 does not.
+            const error = action.afterSignIn ? undefined : state.error;
+            const unchanged = state.phase === 'signed-out' &&
+                sessionRejected === state.sessionRejected &&
+                error === state.error;
+            return unchanged ? state : { ...state, phase: 'signed-out', sessionRejected, error };
+        }
+        case 'failed':
+            if (state.phase === 'signed-in')
+                return state;
+            return {
+                ...state,
+                phase: state.phase === 'checking' ? 'error' : state.phase,
+                error: action.error,
+            };
+        case 'retry':
+            return state.phase === 'error' ? { ...state, phase: 'checking', error: undefined } : state;
+    }
+}
+export function EditorAuthGate({ children, SignInComponent, themeOptions }) {
+    const apiClient = useApiClient();
+    const [state, dispatch] = useReducer(gateReducer, initialGateState);
+    const handleUnauthorized = useCallback(() => {
+        dispatch({ type: 'unauthorized', afterSignIn: false });
+    }, []);
+    useOnUnauthorized(handleUnauthorized);
+    const check = useCallback(async (afterSignIn) => {
+        try {
+            const result = await apiClient.user.whoami();
+            if (result.ok && result.data) {
+                dispatch({
+                    type: 'accepted',
+                    user: { userId: result.data.userId, groups: result.data.groups },
+                });
+            }
+            else if (result.status === 401) {
+                dispatch({ type: 'unauthorized', afterSignIn });
+            }
+            else {
+                dispatch({ type: 'failed', error: result.error ?? 'Failed to load user context' });
+            }
+        }
+        catch (err) {
+            // Only non-auth failures land here: the client returns every 401 as a result.
+            dispatch({ type: 'failed', error: getErrorMessage(err) });
+        }
+    }, [apiClient]);
+    useEffect(() => {
+        void check(false);
+    }, [check]);
+    const onSignedIn = useCallback(() => {
+        void check(true);
+    }, [check]);
+    const retryInitial = useCallback(() => {
+        dispatch({ type: 'retry' });
+        void check(false);
+    }, [check]);
+    const identity = useMemo(() => (state.user ? { user: state.user } : null), [state.user]);
+    const signIn = (_jsxs(_Fragment, { children: [state.phase === 'signed-out' && state.error && (_jsx(RetryNotice, { title: "Couldn't confirm your sign-in", error: state.error, onRetry: onSignedIn })), SignInComponent ? (_jsx(SignInComponent, { onSignedIn: onSignedIn, sessionRejected: state.sessionRejected })) : (_jsx(DefaultSignedOutNotice, { onSignedIn: onSignedIn, sessionRejected: state.sessionRejected }))] }));
+    if (!state.user || !identity) {
+        return (_jsx(CanopyCMSProvider, { ...themeOptions, withNotifications: false, children: _jsx(Center, { mih: "100vh", p: "md", children: state.phase === 'signed-out' ? (_jsx(Stack, { align: "center", gap: "md", "data-testid": "canopy-sign-in-screen", children: signIn })) : state.phase === 'error' ? (_jsx(RetryNotice, { title: "Couldn't load the editor", error: state.error ?? 'Unknown error', onRetry: retryInitial })) : (_jsxs(Stack, { align: "center", gap: "xs", "data-testid": "canopy-auth-checking", children: [_jsx(Loader, {}), _jsx(Text, { size: "sm", c: "dimmed", children: "Checking sign-in\u2026" })] })) }) }));
+    }
+    return (_jsxs(EditorIdentityContext.Provider, { value: identity, children: [_jsxs(SWRProvider, { children: [_jsx(RevalidateOnReauth, { reauthCount: state.reauthCount }), children] }, state.user.userId), state.phase === 'signed-out' && (
+            // The editor's own MantineProvider is inside <Editor>, so the overlay brings its own.
+            // Notifications stay with the editor's provider; a second container would duplicate them.
+            _jsx(CanopyCMSProvider, { ...themeOptions, withNotifications: false, children: _jsx(Modal, { opened: true, onClose: keepOpen, withCloseButton: false, closeOnClickOutside: false, closeOnEscape: false, centered: true, title: "Sign in to continue", children: _jsxs(Stack, { gap: "md", "data-testid": "canopy-sign-in-overlay", children: [_jsx(Text, { size: "sm", children: "Your session has ended. Unsaved edits stay in place if you sign back in as the same user." }), signIn] }) }) }))] }));
+}
+/** The overlay closes only when the server accepts a session again. */
+function keepOpen() { }
+/**
+ * Revalidates every SWR key when the same identity is re-accepted. `revalidateOnFocus` is off
+ * (see SWRProvider), so without this the data that 401'd behind the overlay would stay stale.
+ * A different identity remounts the SWRProvider instead, and this with it.
+ */
+function RevalidateOnReauth({ reauthCount }) {
+    const { mutate } = useSWRConfig();
+    const seen = useRef(reauthCount);
+    useEffect(() => {
+        if (seen.current === reauthCount)
+            return;
+        seen.current = reauthCount;
+        // Each data hook surfaces its own fetch error; nothing to add here.
+        mutate(() => true).catch(() => undefined);
+    }, [reauthCount, mutate]);
+    return null;
+}
+function RetryNotice(props) {
+    return (_jsx(Alert, { color: "red", title: props.title, maw: 480, "data-testid": "canopy-auth-error", children: _jsxs(Stack, { gap: "xs", align: "flex-start", children: [_jsx(Text, { size: "sm", children: props.error }), _jsx(Button, { size: "xs", variant: "light", onClick: props.onRetry, children: "Retry" })] }) }));
+}
+/** Re-checks rather than reloading: in the overlay, a reload would discard the unsaved edits. */
+function DefaultSignedOutNotice({ onSignedIn, sessionRejected }) {
+    return (_jsx(Paper, { withBorder: true, p: "xl", radius: "md", maw: 420, children: _jsxs(Stack, { gap: "sm", children: [_jsx(Title, { order: 3, children: "Sign in required" }), _jsx(Text, { size: "sm", children: "You are not signed in to the CMS. Sign in through this site's auth provider, then continue." }), sessionRejected && (_jsx(Text, { size: "sm", c: "red", children: "Still not signed in." })), _jsx(Button, { onClick: onSignedIn, children: "Continue" })] }) }));
+}

package/dist/editor/EntryNavigator.js

@@ -36,7 +36,6 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
                 const childCollections = col.children ?? [];
                 const totalChildren = entries.length + childCollections.length;
                 const order = col.order ?? [];
-                // Build entry nodes keyed by contentId
                 const entryNodesByContentId = new Map();
                 entries.forEach((entry) => {
                     const node = {
@@ -57,7 +56,6 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
                         entryNodesByContentId.set(entry.contentId, node);
                     }
                 });
-                // Build child collection nodes keyed by contentId
                 const childNodesByContentId = new Map();
                 childCollections.forEach((child) => {
                     const childTree = toTree(child);
@@ -75,10 +73,8 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
                         childNodesByContentId.set(child.contentId, node);
                     }
                 });
-                // Interleave entries and children based on order array
                 const allChildren = [];
                 const usedContentIds = new Set();
-                // First, add items in order
                 for (const contentId of order) {
                     const entryNode = entryNodesByContentId.get(contentId);
                     if (entryNode) {
@@ -100,7 +96,6 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
                         usedContentIds.add(contentId);
                     }
                 }
-                // Add any entries not in order (alphabetically)
                 const unorderedEntries = entries
                     .filter((e) => !e.contentId || !usedContentIds.has(e.contentId))
                     .sort((a, b) => (a.label ?? '').localeCompare(b.label ?? ''));
@@ -121,7 +116,6 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
                     };
                     allChildren.push(node);
                 }
-                // Add any child collections not in order (alphabetically)
                 const unorderedChildren = childCollections
                     .filter((c) => !c.contentId || !usedContentIds.has(c.contentId))
                     .sort((a, b) => (a.label ?? '').localeCompare(b.label ?? ''));
@@ -172,34 +166,27 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
             nodeProps: { status: item.status, isEntry: true, entryPath: item.path },
         }));
     }, [collections, items, hiddenRootPath]);
-    // Initialize tree controller
     const tree = useTree({
         initialExpandedState: expandedStateRef?.current ?? {},
         onNodeExpand: (value) => {
-            // Update local state synchronously
             localExpandedStateRef.current = {
                 ...localExpandedStateRef.current,
                 [value]: true,
             };
-            // Notify parent immediately
             onExpandedStateChange?.(localExpandedStateRef.current);
         },
         onNodeCollapse: (value) => {
-            // Update local state synchronously
             localExpandedStateRef.current = {
                 ...localExpandedStateRef.current,
                 [value]: false,
             };
-            // Notify parent immediately
             onExpandedStateChange?.(localExpandedStateRef.current);
         },
     });
-    // Forward tree controller to parent for collapse/expand all functionality
     useEffect(() => {
         onTreeControllerReady?.(tree);
         // eslint-disable-next-line react-hooks/exhaustive-deps -- fire only when callback ref changes, not on tree state
     }, [onTreeControllerReady]);
-    // Cleanup: save current state when component unmounts
     // Empty dependency array ensures this only runs on mount/unmount, not on re-renders
     useEffect(() => {
         return () => {
@@ -207,12 +194,10 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, []);
-    // Restore state on mount and when selectedPath changes
     useEffect(() => {
         if (!selectedPath || !treeData)
             return;
         const savedState = expandedStateRef?.current ?? {};
-        // Calculate path to current entry and merge with saved state
         const pathToEntry = calculatePathToEntry(selectedPath, treeData);
         const baseState = { ...savedState, ...pathToEntry };
         // Only update if state actually changed to avoid infinite loops
@@ -221,13 +206,11 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
         if (currentStateJson !== newStateJson) {
             tree.setExpandedState(baseState);
             localExpandedStateRef.current = baseState;
-            // Notify parent of the merged state
             onExpandedStateChange?.(baseState);
         }
         // Dependencies limited to data changes only to prevent infinite update loops
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [selectedPath, treeData]);
-    // Auto-scroll to selected entry when drawer opens
     useEffect(() => {
         if (selectedPath && selectedNodeRef.current && !hasScrolledRef.current) {
             // Small delay to ensure tree expansion completes first
@@ -242,7 +225,6 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
             return () => clearTimeout(timeoutId);
         }
     }, [selectedPath, tree.expandedState]);
-    // Reset scroll flag when component mounts (drawer opens)
     useEffect(() => {
         hasScrolledRef.current = false;
     }, []);
@@ -272,11 +254,9 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
         // Mantine only provides hasChildren=true if children.length > 0, but we want
         // collections to always be expandable
         const showChevron = hasChildren || Boolean(isCollection);
-        // Reordering is available for both entries and collections that have contentId and parent path
         const canReorder = onReorderEntry && contentId && parentCollectionPath && typeof childIndex === 'number';
         const canMoveUp = canReorder && childIndex > 0;
         const canMoveDown = canReorder && typeof totalChildrenCount === 'number' && childIndex < totalChildrenCount - 1;
-        // Determine if we should show a context menu
         // Collections show menu for add/edit/delete actions OR for reordering (subcollections)
         const hasCollectionMenu = isCollection && (onAdd || onEdit || onAddSubCollection || onDelete || canReorder);
         const hasEntryMenu = isEntry && entryPath && (onDeleteEntry || onRenameEntry || onReorderEntry);

package/dist/editor/FormRenderer.d.ts

@@ -32,9 +32,8 @@ export interface FormRendererProps {
      * Per-field validation errors keyed by canonical canopy path (e.g.
      * `blocks[0].title`). Rendered as a summary alert plus an inline message
      * under each offending field. Produced by the save-path schema validation
-     * in useDraftManager (ED-H1) and by server 422 rejections.
+     * in useDraftManager and by server 422 rejections.
      */
     fieldErrors?: Record<string, string>;
 }
 export declare const FormRenderer: React.FC<FormRendererProps>;
-export default FormRenderer;