canopycms 0.11.1 → 0.12.1

package/dist/editor/EntryNavigator.d.ts

@@ -21,7 +21,7 @@ export interface EntryNavItem {
     noPage?: boolean;
     collectionPath?: LogicalPath;
     contentId?: ContentId;
-    /** True when this entry's file conflicted during rebase */
+    /** The entry has conflicts open: values changed by the branch and the latest version alike. */
     conflictNotice?: boolean;
     /** True when the entry's type is unavailable; it shows no menu, since every item in it writes. */
     unavailable?: boolean;
@@ -36,8 +36,16 @@ export interface EntryNavCollection {
     order?: readonly string[];
     entries?: EntryNavItem[];
     children?: EntryNavCollection[];
-    /** True when this collection's .collection.json conflicted during rebase */
+    /** The collection's settings have conflicts open. */
     conflictNotice?: boolean;
+    /**
+     * An admin's way to keep the branch's version of the collection's conflicting settings or other
+     * files, which no entry's "Show changes" reaches: the menu item's label, and its action.
+     */
+    conflictKeep?: {
+        label: string;
+        onKeep: () => void;
+    };
     /** Registry keys of this collection's unavailable entry types; non-empty shows the message once. */
     unavailableSchemaRefs?: readonly string[];
     /** True when this user's path rules refuse a new entry here: the collection says so once. */

package/dist/editor/EntryNavigator.js

@@ -384,6 +384,7 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
                         type: col.type,
                         collectionPath: col.path,
                         conflictNotice: col.conflictNotice,
+                        conflictKeep: col.conflictKeep,
                         unavailableSchemaRefs: col.unavailableSchemaRefs,
                         addRefused: col.addRefused,
                         onAdd: col.onAdd,
@@ -742,6 +743,9 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
         const onEdit = readOnly ? undefined : rawOnEdit;
         const onAddSubCollection = readOnly ? undefined : rawOnAddSubCollection;
         const onDelete = readOnly ? undefined : rawOnDelete;
+        const conflictKeep = readOnly
+            ? undefined
+            : node.nodeProps?.conflictKeep;
         const entryPath = node.nodeProps?.entryPath;
         const contentId = node.nodeProps?.contentId;
         const parentCollectionPath = node.nodeProps?.parentCollectionPath;
@@ -766,7 +770,8 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
         const canMoveUp = canReorder && childIndex > 0;
         const canMoveDown = canReorder && typeof totalChildrenCount === 'number' && childIndex < totalChildrenCount - 1;
         // Collections show menu for add/edit/delete actions OR for reordering (subcollections)
-        const hasCollectionMenu = isCollection && (onAdd || onEdit || onAddSubCollection || onDelete || canReorder);
+        const hasCollectionMenu = isCollection &&
+            (onAdd || onEdit || onAddSubCollection || onDelete || conflictKeep || canReorder);
         // An unavailable entry cannot be written, so its menu (rename, delete, reorder) is not offered.
         const entryUnavailable = node.nodeProps?.unavailable;
         // The same holds for an entry this user may not edit, on any branch: its own lock stays, since a
@@ -800,7 +805,7 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
                 : undefined;
         const showEntryDirtyDot = isEntry && !!entryPath && !!dirtyPaths?.has(entryPath);
         const showCollectionDirtyDot = !isEntry && dirtyCollections.has(node.value);
-        const adminItems = onAddSubCollection || onEdit || onDelete;
+        const adminItems = onAddSubCollection || onEdit || onDelete || conflictKeep;
         const hasCollectionContentItems = onAdd || canReorder;
         return (_jsx(RowDetailTip, { detail: detail, children: _jsxs(Box, { ...elementProps, ref: selected ? selectedNodeRef : undefined, "data-nav-row": true, "data-nav-selected": selected ? '' : undefined, "data-testid": `entry-nav-item-${testIdSuffix}`, onClick: (event) => {
                     elementProps.onClick(event);
@@ -825,7 +830,7 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
                                             flexShrink: 0,
                                             alignItems: 'center',
                                             justifyContent: 'center',
-                                        }, children: _jsx(Chevron, { expanded: expanded, visible: showChevron }) }), _jsxs(Stack, { gap: 0, style: { flex: 1, minWidth: 0 }, children: [_jsxs(Group, { gap: 6, wrap: "nowrap", style: { minWidth: 0 }, children: [_jsx(TruncatedLabel, { label: label, highlight: filtering ? query.trim() : '', fw: selected ? 600 : 500 }), changeMarker && (_jsx(ChangeMarker, { kind: changeMarker, context: (rowChange && movedFrom(rowChange)) ?? undefined })), showEntryDirtyDot && _jsx(UnsavedDot, { label: "Unsaved changes" }), showCollectionDirtyDot && _jsx(UnsavedDot, { label: "Contains unsaved changes" }), conflictNotice && (_jsx(Tooltip, { label: "This content was updated on the base branch \u2014 a reviewer will reconcile", withArrow: true, children: _jsx(Badge, { size: "xs", variant: "light", color: "orange", "data-testid": "conflict-badge", style: { flexShrink: 0 }, children: "Conflict" }) })), entryLocked && (_jsx(Tooltip, { label: "You can't edit this entry", withinPortal: true, children: _jsx(Box, { component: "span", role: "img", "aria-label": "You can't edit this entry", "data-testid": "entry-lock", c: "dimmed", style: { display: 'inline-flex', flexShrink: 0 }, children: _jsx(IconLock, { size: 14, "aria-hidden": true }) }) }))] }), detail && (_jsx(Box, { "data-testid": "entry-nav-detail", style: { minWidth: 0 }, children: _jsx(TruncatedLabel, { label: detail, size: "xs", 
+                                        }, children: _jsx(Chevron, { expanded: expanded, visible: showChevron }) }), _jsxs(Stack, { gap: 0, style: { flex: 1, minWidth: 0 }, children: [_jsxs(Group, { gap: 6, wrap: "nowrap", style: { minWidth: 0 }, children: [_jsx(TruncatedLabel, { label: label, highlight: filtering ? query.trim() : '', fw: selected ? 600 : 500 }), changeMarker && (_jsx(ChangeMarker, { kind: changeMarker, context: (rowChange && movedFrom(rowChange)) ?? undefined })), showEntryDirtyDot && _jsx(UnsavedDot, { label: "Unsaved changes" }), showCollectionDirtyDot && _jsx(UnsavedDot, { label: "Contains unsaved changes" }), conflictNotice && (_jsx(Tooltip, { label: 'Changed by you and by someone else. Choose what to keep in "Show changes".', withArrow: true, children: _jsxs(Badge, { size: "xs", variant: "light", color: "yellow", "data-testid": "conflict-badge", style: { flexShrink: 0 }, children: ["Conflict", _jsx(VisuallyHidden, { children: ". Changed by you and by someone else. Choose what to keep in \"Show changes\"." })] }) })), entryLocked && (_jsx(Tooltip, { label: "You can't edit this entry", withinPortal: true, children: _jsx(Box, { component: "span", role: "img", "aria-label": "You can't edit this entry", "data-testid": "entry-lock", c: "dimmed", style: { display: 'inline-flex', flexShrink: 0 }, children: _jsx(IconLock, { size: 14, "aria-hidden": true }) }) }))] }), detail && (_jsx(Box, { "data-testid": "entry-nav-detail", style: { minWidth: 0 }, children: _jsx(TruncatedLabel, { label: detail, size: "xs", 
                                                     // A missing file is an error, in error text, not a dimmed type.
                                                     c: entryMissing ? 'var(--canopy-danger-text)' : 'dimmed' }) }))] })] }), _jsxs(Group, { gap: 4, wrap: "nowrap", style: { flexShrink: 0 }, children: [hasCollectionMenu && (_jsxs(Menu, { shadow: "md", width: 200, withinPortal: true, position: "bottom-end", onOpen: onRowMenuOpen, children: [_jsx(Menu.Target, { children: _jsx(ActionIcon, { size: "xs", variant: "subtle", color: "gray", onClick: (event) => event.stopPropagation(), "aria-label": "Collection actions", "data-testid": `collection-menu-${testIdSuffix}`, children: _jsx(IconDots, { size: 14 }) }) }), _jsxs(Menu.Dropdown, { onKeyDown: stopTreeKeys, children: [onAdd && (_jsx(Menu.Item, { leftSection: _jsx(IconPlus, { size: 14 }), onClick: (event) => {
                                                             event.stopPropagation();
@@ -836,7 +841,10 @@ export const EntryNavigator = ({ items, collections, selectedPath, onSelect, onT
                                                                 }, children: "Move up" }), _jsx(ReasonedMenuItem, { leftSection: _jsx(IconArrowDown, { size: 14 }), blockedReason: canMoveDown ? undefined : 'Already last', onClick: (event) => {
                                                                     event.stopPropagation();
                                                                     onReorderEntry?.(parentCollectionPath, contentId, 'down');
-                                                                }, children: "Move down" })] })), adminItems && (_jsxs(_Fragment, { children: [hasCollectionContentItems && _jsx(Menu.Divider, {}), _jsx(Menu.Label, { children: "Admin" })] })), onAddSubCollection && (_jsx(Menu.Item, { leftSection: _jsx(IconFolderPlus, { size: 14 }), onClick: (event) => {
+                                                                }, children: "Move down" })] })), adminItems && (_jsxs(_Fragment, { children: [hasCollectionContentItems && _jsx(Menu.Divider, {}), _jsx(Menu.Label, { children: "Admin" })] })), conflictKeep && (_jsx(Menu.Item, { leftSection: _jsx(IconAlertTriangle, { size: 14 }), onClick: (event) => {
+                                                            event.stopPropagation();
+                                                            conflictKeep.onKeep();
+                                                        }, "data-testid": `collection-keep-conflicts-${testIdSuffix}`, children: conflictKeep.label })), onAddSubCollection && (_jsx(Menu.Item, { leftSection: _jsx(IconFolderPlus, { size: 14 }), onClick: (event) => {
                                                             event.stopPropagation();
                                                             onAddSubCollection();
                                                         }, children: "Add sub-collection\u2026" })), onEdit && (_jsx(Menu.Item, { leftSection: _jsx(IconEdit, { size: 14 }), onClick: (event) => {

package/dist/editor/FormRenderer.d.ts

@@ -28,8 +28,14 @@ export interface FormRendererProps {
     highlightThreadId?: string;
     onAddComment?: (text: string, type: 'field' | 'entry' | 'branch', entryPath?: string, canopyPath?: string, threadId?: string) => Promise<void>;
     onResolveThread?: (threadId: string) => Promise<void>;
-    /** True when this entry's content conflicts with a recent change on the base branch */
-    conflictNotice?: boolean;
+    /**
+     * The entry's open conflicts, said once above the fields (conflict-notice.ts), with the way to
+     * "Show changes" when it is offered.
+     */
+    conflictNotice?: {
+        message: string;
+        onShowChanges?: () => void;
+    };
     /**
      * Per-field validation errors keyed by canonical canopy path (e.g.
      * `blocks[0].title`). Rendered as a summary alert plus an inline message

package/dist/editor/FormRenderer.js

@@ -1,8 +1,9 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef, useState } from 'react';
-import { Alert, Stack, Text } from '@mantine/core';
-import { IconInfoCircle } from '@tabler/icons-react';
+import { Alert, Button, Group, Stack, Text } from '@mantine/core';
+import { IconAlertTriangle } from '@tabler/icons-react';
+import { EDITOR_ACTIONS } from './copy.js';
 import { MarkdownField } from './fields/MarkdownField.js';
 import { useSiteMdxAllow } from './context/index.js';
 import { markdownPolicyOf } from '../validation/mdx-allowlist.js';
@@ -99,7 +100,7 @@ const FieldBoundary = ({ canopyPath, resetKey, update, build, fallback }) => {
             setGeneration(liveGeneration.current);
         }, fallback: fallback, children: _jsx(FieldControl, { build: () => build(guardedUpdate) }) }));
 };
-export const FormRenderer = ({ fields, value, onChange, customRenderers, branch = 'main', comments = [], currentEntryPath, currentUserId, canResolve = false, focusedFieldPath, highlightThreadId, onAddComment, onResolveThread, conflictNotice = false, fieldErrors, format, readOnly = false, onRemoved, savedValue, onGetUserMetadata, header, notice, commentBlockedReason, removedItemFieldLabel, }) => {
+export const FormRenderer = ({ fields, value, onChange, customRenderers, branch = 'main', comments = [], currentEntryPath, currentUserId, canResolve = false, focusedFieldPath, highlightThreadId, onAddComment, onResolveThread, conflictNotice, fieldErrors, format, readOnly = false, onRemoved, savedValue, onGetUserMetadata, header, notice, commentBlockedReason, removedItemFieldLabel, }) => {
     const emit = readOnly ? noop : onChange;
     const formRef = useRef(null);
     const customTypes = new Set(Object.keys(customRenderers ?? {}));
@@ -310,9 +311,7 @@ export const FormRenderer = ({ fields, value, onChange, customRenderers, branch
                         }, onExpandAll: hasCollapsibleList(fields, customTypes)
                             ? (expanded) => setExpansionCommand((prev) => ({ seq: (prev?.seq ?? 0) + 1, expanded }))
                             : undefined })), notice, readOnly && _jsx(ReadOnlyFormStyles, {}), currentEntryPath && currentUserId && onAddComment && onResolveThread && (_jsx(EntryComments, { comments: comments, entryPath: currentEntryPath, currentUserId: currentUserId, canResolve: canResolve, onAddComment: onAddComment, onResolveThread: onResolveThread, highlightThreadId: highlightThreadId, onGetUserMetadata: onGetUserMetadata, resetKey: boundaryResetKey, removedItemFieldLabel: (thread) => removedItemFieldLabel?.(thread) ??
-                            fieldBreadcrumb(fields, undefined, thread.canopyPath ?? '', { items: false }).join(' › ') })), conflictNotice && (_jsx(Alert, { icon: _jsx(IconInfoCircle, { size: 16 }), color: "orange", variant: "light", title: "Page updated since your draft started", "data-testid": "conflict-alert", children: readOnly
-                            ? 'Someone else has recently changed this page.'
-                            : 'Someone else has recently changed this page. You can keep editing — a reviewer will reconcile your changes when you submit.' })), fieldErrors && _jsx(ValidationSummary, { fields: fields, value: value, errors: fieldErrors }), fields.map((field) => {
+                            fieldBreadcrumb(fields, undefined, thread.canopyPath ?? '', { items: false }).join(' › ') })), conflictNotice && (_jsx(Alert, { icon: _jsx(IconAlertTriangle, { size: 16 }), color: "yellow", variant: "light", "data-testid": "conflict-alert", children: _jsxs(Group, { gap: "xs", justify: "space-between", wrap: "wrap", children: [_jsx(Text, { size: "sm", children: conflictNotice.message }), conflictNotice.onShowChanges && (_jsx(Button, { size: "compact-sm", variant: "subtle", onClick: conflictNotice.onShowChanges, "data-testid": "conflict-alert-show-changes", children: EDITOR_ACTIONS.showChanges }))] }) })), fieldErrors && _jsx(ValidationSummary, { fields: fields, value: value, errors: fieldErrors }), fields.map((field) => {
                         // Inline groups are transparent to the value — render them directly with parent value/onChange
                         if (field.type === 'group') {
                             const groupField = field;

package/dist/editor/base-update-wait.d.ts

@@ -0,0 +1,74 @@
+import type { BranchMetadata, LastBaseUpdate } from '../types.js';
+/**
+ * The editor's side of a request for the latest changes (base-update.ts): whether the open
+ * branch is waiting on one, how often to poll meanwhile, and what to say. The request and the
+ * answer both live on branch.json, so every viewer whose branch list shows the request waits,
+ * and a reload keeps waiting.
+ */
+/**
+ * How long the form stays read-only before the wait reads as slow and the form unlocks.
+ * @internal Exported for tests.
+ */
+export declare const BASE_UPDATE_SLOW_MS: number;
+/**
+ * The poll while the form is read-only.
+ * @internal Exported for tests.
+ */
+export declare const BASE_UPDATE_POLL_MS = 3000;
+/**
+ * The poll once the wait is slow.
+ * @internal Exported for tests.
+ */
+export declare const BASE_UPDATE_SLOW_POLL_MS = 15000;
+/**
+ * `waiting`: asked under {@link BASE_UPDATE_SLOW_MS} ago; the form is read-only. `slow`: asked
+ * longer ago, under {@link BASE_UPDATE_GIVE_UP_MS}; the form is editable again. `none`: no
+ * request is standing, or it is too old to wait on, or the branch left editing, which the worker
+ * never brings the base into.
+ */
+export type BaseUpdateWait = 'none' | 'waiting' | 'slow';
+type WaitFields = Pick<BranchMetadata, 'status' | 'baseUpdateRequestedAt' | 'lastBaseUpdate'>;
+export declare function baseUpdateWait(branch: WaitFields | undefined, now: number): BaseUpdateWait;
+/** When a branch's wait next changes on its own, for a timer to re-render at; undefined for never. */
+export declare function nextBaseUpdateWaitChange(branch: WaitFields | undefined, now: number): number | undefined;
+/** How often the open branch's listing is re-read while it waits; 0 when it doesn't. */
+export declare function baseUpdatePollMs(wait: BaseUpdateWait): number;
+/** @internal Exported for tests. */
+export declare const GET_LATEST_CHANGES_TOOLTIP = "Bring in changes made on the site since you started this branch.";
+/** The Tooltip; an admin also learns which branch the changes come from. */
+export declare function getLatestChangesTooltip(baseBranch: string | undefined, isAdmin: boolean): string;
+export declare const GETTING_LATEST_CHANGES = "Getting latest changes\u2026";
+export declare const SAVE_FIRST_REASON = "Save your changes first.";
+export declare const WAITING_NOTICE = "Getting the latest changes. You can edit again when it finishes.";
+export declare const SLOW_NOTICE = "This is taking longer than usual. You can keep editing; the latest changes will come in when the server gets to them.";
+/** Why Submit for review waits while the latest changes come in. */
+export declare const WAITING_SUBMIT_REASON = "Wait for the latest changes to come in.";
+/** The waiting notice's addition for a viewer whose unsaved changes it hides meanwhile. */
+export declare const WAITING_DRAFT_NOTE = "Your unsaved changes come back when it finishes.";
+/** When the editor stops waiting on a request the server hasn't answered. */
+export declare const GAVE_UP_MESSAGE = "The latest changes haven't come in yet. They will when the server gets to them; use \"Refresh branch\" in the branch menu to see them.";
+/** A request the server didn't answer, which may still have gone through. */
+export declare const UNANSWERED_MESSAGE = "Your request for the latest changes may have gone through even though the server didn't answer. Choose \"Refresh branch\" in the branch menu to check.";
+export declare const REQUEST_FAILED_MESSAGE = "The latest changes couldn't be requested.";
+/**
+ * The toast an answer gets: its colour, its text, and whether it stays until dismissed.
+ * `openConflicts` is the choices the branch has open once a merge with conflicts lands, read from
+ * the branch's conflicts; undefined when they couldn't be counted.
+ */
+export declare function baseUpdateResultMessage(answer: LastBaseUpdate, openConflicts?: number): {
+    color: 'green' | 'yellow' | 'red';
+    message: string;
+    sticky: boolean;
+};
+/** What the bar and the branch card need to offer "Get latest changes" on the open branch. */
+export interface BaseUpdateControl {
+    wait: BaseUpdateWait;
+    /** The request itself is in flight. */
+    requesting: boolean;
+    /** Why it can't be asked now. */
+    blockedReason?: string;
+    /** The Tooltip while it can be asked ({@link getLatestChangesTooltip}). */
+    tooltip: string;
+    onRequest: () => void;
+}
+export {};

package/dist/editor/base-update-wait.js

@@ -0,0 +1,91 @@
+import { BASE_UPDATE_CLOCK_SKEW_MS, BASE_UPDATE_GIVE_UP_MS, isBaseUpdatePending, } from '../base-update.js';
+import { latestChangesConflictsMessage } from './conflict-notice.js';
+/**
+ * The editor's side of a request for the latest changes (base-update.ts): whether the open
+ * branch is waiting on one, how often to poll meanwhile, and what to say. The request and the
+ * answer both live on branch.json, so every viewer whose branch list shows the request waits,
+ * and a reload keeps waiting.
+ */
+/**
+ * How long the form stays read-only before the wait reads as slow and the form unlocks.
+ * @internal Exported for tests.
+ */
+export const BASE_UPDATE_SLOW_MS = 2 * 60_000;
+/**
+ * The poll while the form is read-only.
+ * @internal Exported for tests.
+ */
+export const BASE_UPDATE_POLL_MS = 3_000;
+/**
+ * The poll once the wait is slow.
+ * @internal Exported for tests.
+ */
+export const BASE_UPDATE_SLOW_POLL_MS = 15_000;
+export function baseUpdateWait(branch, now) {
+    if (!branch || branch.status !== 'editing' || !isBaseUpdatePending(branch))
+        return 'none';
+    const age = now - Date.parse(branch.baseUpdateRequestedAt ?? '');
+    if (!(age < BASE_UPDATE_GIVE_UP_MS) || age < -BASE_UPDATE_CLOCK_SKEW_MS)
+        return 'none';
+    return age < BASE_UPDATE_SLOW_MS ? 'waiting' : 'slow';
+}
+/** When a branch's wait next changes on its own, for a timer to re-render at; undefined for never. */
+export function nextBaseUpdateWaitChange(branch, now) {
+    const wait = baseUpdateWait(branch, now);
+    if (wait === 'none')
+        return undefined;
+    const requestedAt = Date.parse(branch?.baseUpdateRequestedAt ?? '');
+    return requestedAt + (wait === 'waiting' ? BASE_UPDATE_SLOW_MS : BASE_UPDATE_GIVE_UP_MS);
+}
+/** How often the open branch's listing is re-read while it waits; 0 when it doesn't. */
+export function baseUpdatePollMs(wait) {
+    return wait === 'waiting' ? BASE_UPDATE_POLL_MS : wait === 'slow' ? BASE_UPDATE_SLOW_POLL_MS : 0;
+}
+/** @internal Exported for tests. */
+export const GET_LATEST_CHANGES_TOOLTIP = 'Bring in changes made on the site since you started this branch.';
+/** The Tooltip; an admin also learns which branch the changes come from. */
+export function getLatestChangesTooltip(baseBranch, isAdmin) {
+    return isAdmin && baseBranch
+        ? `${GET_LATEST_CHANGES_TOOLTIP.slice(0, -1)} (from ${baseBranch}).`
+        : GET_LATEST_CHANGES_TOOLTIP;
+}
+export const GETTING_LATEST_CHANGES = 'Getting latest changes…';
+export const SAVE_FIRST_REASON = 'Save your changes first.';
+export const WAITING_NOTICE = 'Getting the latest changes. You can edit again when it finishes.';
+export const SLOW_NOTICE = 'This is taking longer than usual. You can keep editing; the latest changes will come in when the server gets to them.';
+/** Why Submit for review waits while the latest changes come in. */
+export const WAITING_SUBMIT_REASON = 'Wait for the latest changes to come in.';
+/** The waiting notice's addition for a viewer whose unsaved changes it hides meanwhile. */
+export const WAITING_DRAFT_NOTE = 'Your unsaved changes come back when it finishes.';
+/** When the editor stops waiting on a request the server hasn't answered. */
+export const GAVE_UP_MESSAGE = 'The latest changes haven\'t come in yet. They will when the server gets to them; use "Refresh branch" in the branch menu to see them.';
+/** A request the server didn't answer, which may still have gone through. */
+export const UNANSWERED_MESSAGE = 'Your request for the latest changes may have gone through even though the server didn\'t answer. Choose "Refresh branch" in the branch menu to check.';
+export const REQUEST_FAILED_MESSAGE = "The latest changes couldn't be requested.";
+/**
+ * The toast an answer gets: its colour, its text, and whether it stays until dismissed.
+ * `openConflicts` is the choices the branch has open once a merge with conflicts lands, read from
+ * the branch's conflicts; undefined when they couldn't be counted.
+ */
+export function baseUpdateResultMessage(answer, openConflicts) {
+    switch (answer.outcome) {
+        case 'merged':
+            return { color: 'green', message: 'Latest changes added', sticky: false };
+        case 'up-to-date':
+            return { color: 'green', message: 'You already have the latest changes', sticky: false };
+        case 'conflicts':
+            if (openConflicts === 0)
+                return { color: 'green', message: 'Latest changes added', sticky: false };
+            return {
+                color: 'yellow',
+                message: latestChangesConflictsMessage(openConflicts),
+                sticky: true,
+            };
+        case 'failed':
+            return {
+                color: 'red',
+                message: "The latest changes couldn't be added. Your work is safe.",
+                sticky: true,
+            };
+    }
+}

package/dist/editor/branch-status.js

@@ -42,7 +42,7 @@ export function branchHoldMessage(hold, viewer) {
                 return `${stuck} Use "Request changes" to send it back to its editor.`;
             if (viewer.role === 'none')
                 return `${stuck} Its editor needs to withdraw it from review.`;
-            return `${stuck} Use "Withdraw from review", check any flagged entries, then submit it again.`;
+            return `${stuck} Use "Withdraw from review" to bring in the latest changes, check any flagged entries, then submit it again.`;
         }
         case 'retargeted':
             return `This pull request now merges into ${escapeForLog(hold.base)} on GitHub, so CanopyCMS isn't updating it. Update it on the pull request${viewer.isAdmin ? '' : ', or ask an admin'}.`;

package/dist/editor/components/BaseUpdateNotice.d.ts

@@ -0,0 +1,12 @@
+import { type BaseUpdateWait } from '../base-update-wait.js';
+/**
+ * The one notice above the form while the open branch gets the latest changes: blue while the
+ * form is read-only, then yellow once the wait is slow and the form is editable again, which can
+ * be dismissed until the wait changes. The bar's status region announces the wait starting, so the
+ * blue notice is not a live region; the yellow one, which the bar doesn't announce, is polite.
+ */
+export declare function BaseUpdateNotice({ wait, hidesDraft, }: {
+    wait: Exclude<BaseUpdateWait, 'none'>;
+    /** The read-only form hides this viewer's unsaved changes meanwhile. */
+    hidesDraft?: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/editor/components/BaseUpdateNotice.js

@@ -0,0 +1,24 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Alert } from '@mantine/core';
+import { IconAlertTriangle, IconInfoCircle } from '@tabler/icons-react';
+import { SLOW_NOTICE, WAITING_DRAFT_NOTE, WAITING_NOTICE, } from '../base-update-wait.js';
+/**
+ * The one notice above the form while the open branch gets the latest changes: blue while the
+ * form is read-only, then yellow once the wait is slow and the form is editable again, which can
+ * be dismissed until the wait changes. The bar's status region announces the wait starting, so the
+ * blue notice is not a live region; the yellow one, which the bar doesn't announce, is polite.
+ */
+export function BaseUpdateNotice({ wait, hidesDraft = false, }) {
+    // Dismissed for one wait only: a new phase shows it again.
+    const [dismissedFor, setDismissedFor] = useState(null);
+    if (wait === 'waiting') {
+        return (_jsx(Alert, { color: "blue", variant: "light", 
+            // Mantine sets role="alert" after the props it's given, so the root sets the role.
+            renderRoot: (props) => _jsx("div", { ...props, role: "note" }), icon: _jsx(IconInfoCircle, { size: 16, "aria-hidden": "true" }), "data-testid": "base-update-waiting-notice", children: hidesDraft ? `${WAITING_NOTICE} ${WAITING_DRAFT_NOTE}` : WAITING_NOTICE }));
+    }
+    if (dismissedFor === wait)
+        return null;
+    return (_jsx(Alert, { color: "yellow", variant: "light", renderRoot: (props) => _jsx("div", { ...props, role: "status" }), icon: _jsx(IconAlertTriangle, { size: 16, "aria-hidden": "true" }), withCloseButton: true, closeButtonLabel: "Dismiss", onClose: () => setDismissedFor(wait), "data-testid": "base-update-slow-notice", children: SLOW_NOTICE }));
+}

package/dist/editor/components/BranchPill.d.ts

@@ -1,4 +1,5 @@
 import { type Ref } from 'react';
+import type { BaseUpdateControl } from '../base-update-wait.js';
 export interface BranchPillProps {
     branchName: string;
     /** The editor is busy; with no branch name yet, that is the branch list loading. */
@@ -10,9 +11,11 @@ export interface BranchPillProps {
     onDiscardAll: () => void;
     /** The pill, which stands in for a menu item that opened something. */
     pillRef?: Ref<HTMLButtonElement>;
+    /** "Get latest changes" as a menu item, where the bar has no room for its button. */
+    getLatest?: BaseUpdateControl;
 }
 /**
  * The branch's name. Its menu, headed by the name untruncated, holds the branch actions. Below
  * `sm` the name truncates shorter, so the actions don't clip.
  */
-export declare function BranchPill({ branchName, loading, unsavedCount: unsaved, onSwitchBranch, onRefreshBranch, onDiscardAll, pillRef, }: BranchPillProps): import("react/jsx-runtime").JSX.Element;
+export declare function BranchPill({ branchName, loading, unsavedCount: unsaved, onSwitchBranch, onRefreshBranch, onDiscardAll, pillRef, getLatest, }: BranchPillProps): import("react/jsx-runtime").JSX.Element;

package/dist/editor/components/BranchPill.js

@@ -8,12 +8,13 @@ import { EDITOR_ACTIONS } from '../copy.js';
 import { DestructiveMenuItem } from './DestructiveMenuItem.js';
 import { ReasonedMenuItem } from './ReasonedMenuItem.js';
 import { useMenuItemFocusReturn } from '../utils/focus-return.js';
+import { getLatestChangesReason } from './GetLatestChangesButton.js';
 const plural = (count, one, many) => `${count} ${count === 1 ? one : many}`;
 /**
  * The branch's name. Its menu, headed by the name untruncated, holds the branch actions. Below
  * `sm` the name truncates shorter, so the actions don't clip.
  */
-export function BranchPill({ branchName, loading, unsavedCount: unsaved, onSwitchBranch, onRefreshBranch, onDiscardAll, pillRef, }) {
+export function BranchPill({ branchName, loading, unsavedCount: unsaved, onSwitchBranch, onRefreshBranch, onDiscardAll, pillRef, getLatest, }) {
     const trigger = useRef(null);
     const triggerRef = useMergedRef(trigger, pillRef);
     const menuFocus = useMenuItemFocusReturn(trigger);
@@ -22,7 +23,9 @@ export function BranchPill({ branchName, loading, unsavedCount: unsaved, onSwitc
     const name = branchName || (loading ? 'Loading branches…' : 'No branch open');
     return (_jsxs(Menu, { withinPortal: true, shadow: "sm", position: "bottom-start", ...menuFocus.menu, children: [_jsx(Tooltip, { label: name, disabled: wide, events: { hover: true, focus: true, touch: true }, children: _jsx(Menu.Target, { children: _jsx(Button, { ref: triggerRef, variant: "default", size: "sm", miw: 0, px: { base: 8, sm: 14 }, 
                         // The bar's row wraps before the pill's name clips.
-                        style: { flexShrink: 0 }, leftSection: _jsx(IconGitBranch, { size: 16, "aria-hidden": "true" }), rightSection: wide ? _jsx(IconChevronDown, { size: 14, "aria-hidden": "true" }) : undefined, loading: !branchName && loading, "data-testid": "branch-dropdown-button", styles: { label: { minWidth: 0, gap: 6 } }, children: _jsx(Text, { span: true, inherit: true, truncate: "end", maw: { base: 120, sm: 200 }, children: name }) }) }) }), _jsxs(Menu.Dropdown, { "data-testid": "branch-menu", ...menuFocus.dropdown, children: [branchName && _jsx(Menu.Label, { children: branchName }), _jsx(Menu.Item, { onClick: onSwitchBranch, "data-testid": "manage-branches-menu-item", children: `${EDITOR_ACTIONS.switchBranch}…` }), _jsx(ReasonedMenuItem, { onClick: onRefreshBranch, blockedReason: noBranch, "data-testid": "refresh-branch-menu-item", children: "Refresh branch" }), _jsx(Menu.Divider, {}), _jsx(DestructiveMenuItem, { "data-testid": "discard-all-drafts-menu-item", onClick: onDiscardAll, blockedReason: noBranch ?? (unsaved === 0 ? 'Nothing to discard.' : undefined), children: unsaved > 0
+                        style: { flexShrink: 0 }, leftSection: _jsx(IconGitBranch, { size: 16, "aria-hidden": "true" }), rightSection: wide ? _jsx(IconChevronDown, { size: 14, "aria-hidden": "true" }) : undefined, loading: !branchName && loading, "data-testid": "branch-dropdown-button", styles: { label: { minWidth: 0, gap: 6 } }, children: _jsx(Text, { span: true, inherit: true, truncate: "end", maw: { base: 120, sm: 200 }, children: name }) }) }) }), _jsxs(Menu.Dropdown, { "data-testid": "branch-menu", ...menuFocus.dropdown, children: [branchName && _jsx(Menu.Label, { children: branchName }), _jsx(Menu.Item, { onClick: onSwitchBranch, "data-testid": "manage-branches-menu-item", children: `${EDITOR_ACTIONS.switchBranch}…` }), _jsx(ReasonedMenuItem, { onClick: onRefreshBranch, blockedReason: noBranch, "data-testid": "refresh-branch-menu-item", children: "Refresh branch" }), getLatest && (_jsx(ReasonedMenuItem, { onClick: getLatest.onRequest, blockedReason: getLatest.requesting || getLatest.wait !== 'none'
+                            ? getLatestChangesReason(getLatest)
+                            : getLatest.blockedReason, "data-testid": "get-latest-changes-menu-item", children: EDITOR_ACTIONS.getLatestChanges })), _jsx(Menu.Divider, {}), _jsx(DestructiveMenuItem, { "data-testid": "discard-all-drafts-menu-item", onClick: onDiscardAll, blockedReason: noBranch ?? (unsaved === 0 ? 'Nothing to discard.' : undefined), children: unsaved > 0
                             ? `Discard all changes (${plural(unsaved, 'entry', 'entries')})`
                             : 'Discard all changes' })] })] }));
 }

package/dist/editor/components/ConflictsGroup.d.ts

@@ -0,0 +1,100 @@
+/**
+ * The "Conflicts" group at the top of "Show changes": one card per place both you and someone else
+ * changed since you started the branch, showing how it read before, in the latest version and in
+ * yours, and the choices that settle it. A field's choice is an unsaved edit that the entry's next
+ * save resolves (conflict-choices.ts); an entry-level choice acts at once, through the API.
+ * Authors never see a branch name here; an admin's Tooltip names the branch the latest version
+ * comes from.
+ */
+import React from 'react';
+import type { EntryConflictChoice, EntryConflictData } from '../../api/merge-conflicts.js';
+import type { ConflictCard, EntryConflicts, FieldConflict } from '../conflict-cards.js';
+import { type EntryChoices, type FieldChoice } from '../conflict-choices.js';
+type FormValue = Record<string, unknown>;
+/**
+ * The three versions a card shows, each label with the Tooltip that says what it is.
+ * @internal Exported for tests.
+ */
+export declare const VERSION_LABELS: {
+    readonly before: {
+        readonly label: "Before";
+        readonly tooltip: "How this field read when you started this branch.";
+    };
+    readonly latest: {
+        readonly label: "Latest version";
+        readonly tooltip: "How it reads now on the site's shared copy, changed since you started (by another person's approved changes or a developer).";
+    };
+    readonly yours: {
+        readonly label: "Your version";
+        readonly tooltip: "Your change on this branch.";
+    };
+};
+/**
+ * The latest version's Tooltip; an admin also learns which branch it comes from.
+ * @internal Exported for tests.
+ */
+export declare const latestTooltip: (adminBaseBranch: string | undefined) => string;
+/**
+ * Why a choice can't replace what the form holds: an edit made since, which it would lose.
+ * @internal Exported for tests.
+ */
+export declare const EDITED_IN_FORM_REASON = "You've edited this in the form. Choose \"Mark resolved\" to keep your edit.";
+/**
+ * Why an entry-level choice that rewrites the entry waits: it would replace unsaved edits.
+ * @internal Exported for tests.
+ */
+export declare const SAVE_FIRST_REASON = "Save or discard this entry's unsaved changes first.";
+/**
+ * Why a choice that takes the latest version can't: the latest version couldn't be read, its list
+ * items on the way to the place can't be matched to the ones the merge named, or the form no longer
+ * has the place. "Mark resolved" shows once the form is edited at the place.
+ * @internal Exported for tests.
+ */
+export declare const LATEST_UNPLACEABLE_REASON = "The latest version of this can't be placed here. Change it in the form by hand, then choose \"Mark resolved\".";
+/**
+ * A card's heading: where, and what happened there, in plain words.
+ * @internal Exported for tests.
+ */
+export declare function conflictHeading(card: ConflictCard): string;
+/**
+ * Why an entry-level choice didn't act: `warning` where nothing is lost or the outcome is unknown,
+ * `error` for a failure a retry may pass.
+ */
+export interface EntryChoiceRefusal {
+    message: string;
+    tone: 'warning' | 'error';
+}
+/** The open entry's form, which field choices change. */
+interface ConflictsForm {
+    value: FormValue;
+    saved: FormValue;
+    update: (update: (value: FormValue) => FormValue) => void;
+    /** The schema's body field on an md/mdx entry. */
+    bodyField?: string;
+}
+export interface ConflictsGroupProps {
+    data: EntryConflictData;
+    conflicts: EntryConflicts;
+    /** The branch the latest version comes from, given only for an admin. */
+    adminBaseBranch?: string;
+    choices: EntryChoices;
+    /** The open entry's form; without it the cards only show, and say to open the entry. */
+    form?: ConflictsForm;
+    /** Records a field's choice, or clears it with undefined. `decided` says it settles the field. */
+    onChoose?: (field: FieldConflict, choice: FieldChoice | undefined, decided: boolean) => void;
+    /** Closes the drawer and focuses the field in the form. */
+    onEdit?: (field: FieldConflict) => void;
+    /** Settles an entry-level conflict; resolves with why it couldn't, when it couldn't. */
+    onResolveEntry?: (choice: EntryConflictChoice) => Promise<EntryChoiceRefusal | undefined>;
+    /** Why this user can't change the entry: the choices are hidden. */
+    noEditReason?: string;
+    /** Why the choices can't act now: they stay, disabled, saying so. */
+    lockedReason?: string;
+    /** The entry has unsaved edits, which an entry-level choice would replace. */
+    unsavedEdits?: boolean;
+    /** The branch deleted the entry, so its field conflicts have no form to be chosen in. */
+    entryDeleted?: boolean;
+}
+/** The "Conflicts" group: a heading, a count heard as it changes, and the cards. */
+export declare const ConflictsGroup: React.FC<ConflictsGroupProps>;
+export {};