canopycms 0.12.0 → 0.13.0

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/admin/ConflictsStatusAlert.d.ts

@@ -0,0 +1,8 @@
+import type { ConflictsStatusFailure } from '../../types.js';
+/**
+ * The last git sync could not set the "CanopyCMS conflicts" status on some pull requests
+ * (worker/conflicts-status.ts).
+ */
+export declare function ConflictsStatusAlert({ failure }: {
+    failure: ConflictsStatusFailure;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/editor/admin/ConflictsStatusAlert.js

@@ -0,0 +1,22 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Alert, Code, Group, List, Stack, Text } from '@mantine/core';
+import { IconAlertTriangle } from '@tabler/icons-react';
+import { escapeForLog } from '../../utils/escape-text.js';
+import { RelativeTime } from '../components/RelativeTime.js';
+/** A long unbroken name wraps inside the alert rather than widening it. */
+const WRAP = { overflowWrap: 'anywhere' };
+const WHY = {
+    permission: (_jsxs(_Fragment, { children: [_jsx(Text, { size: "sm", children: "GitHub refused it: the worker's GitHub credential lacks the \"Commit statuses\" permission." }), _jsxs(List, { size: "sm", spacing: 2, children: [_jsxs(List.Item, { children: ["A GitHub App: its owner adds \"Commit statuses: read and write\" in the App's permissions on GitHub, then an owner of the account it is installed on accepts the request in the installation's settings.", ' ', _jsx(Code, { style: { whiteSpace: 'nowrap' }, children: "canopycms init-github-app verify" }), " confirms it."] }), _jsx(List.Item, { children: "A fine-grained token: give it \"Commit statuses: read and write\". A classic token's repo scope already has it." })] })] })),
+    unreachable: (_jsx(Text, { size: "sm", children: "GitHub couldn't be reached, or was busy. The next git sync tries again." })),
+    other: (_jsx(Text, { size: "sm", children: "GitHub refused it, or the branch's record of conflicts couldn't be read. The next git sync tries again; if it keeps failing, the worker log names each branch and why." })),
+};
+/**
+ * The last git sync could not set the "CanopyCMS conflicts" status on some pull requests
+ * (worker/conflicts-status.ts).
+ */
+export function ConflictsStatusAlert({ failure }) {
+    const unlisted = failure.count - failure.branches.length;
+    const pullRequests = `${failure.count} pull request${failure.count === 1 ? '' : 's'}`;
+    return (_jsx(Alert, { color: "orange", icon: _jsx(IconAlertTriangle, { size: 16 }), title: `Conflicts status not set on ${pullRequests}`, "data-testid": "conflicts-status-alert", children: _jsxs(Stack, { gap: 4, children: [_jsx(Text, { size: "sm", children: "The \"CanopyCMS conflicts\" check on the pull request of each branch below keeps its last result, or has none yet. Where it is a required check, merging waits on it. Saving, submitting and pull request updates are unaffected." }), WHY[failure.reason], _jsx(Group, { gap: 4, children: failure.branches.map((name) => (_jsx(Code, { style: WRAP, children: escapeForLog(name) }, name))) }), unlisted > 0 && _jsxs(Text, { size: "sm", children: ["And ", unlisted, " more."] }), _jsxs(Text, { size: "xs", c: "dimmed", style: WRAP, children: ["The last error: \u201C", escapeForLog(failure.message), "\u201D"] }), _jsx(RelativeTime, { iso: failure.at, prefix: "Last tried ", size: "xs", c: "dimmed" })] }) }));
+}

package/dist/editor/admin/SystemHealthPanel.js

@@ -21,6 +21,7 @@ import { ageDeletionHold, archivedBefore, archivedCutoff, deletableByAge, } from
 import { escapeForLog } from '../../utils/escape-text.js';
 import { TooltipDetail } from '../components/TooltipDetail.js';
 import { DISMISS_UNPUBLISHED_ATTRIBUTE, UnpublishedAtMergeAlert } from './UnpublishedAtMergeAlert.js';
+import { ConflictsStatusAlert } from './ConflictsStatusAlert.js';
 import { HOLD_BADGE, branchHoldMessage, branchStatusPresentation, endSentence, } from '../branch-status.js';
 // ============================================================================
 // Small pure helpers
@@ -132,7 +133,7 @@ function BaseHoldAlert({ hold }) {
  * and never listed. Names come from GitHub and are attacker-chosen, so each is shown escaped.
  */
 function DivergedBranchesAlert({ names }) {
-    return (_jsx(Alert, { color: "orange", icon: _jsx(IconAlertTriangle, { size: 16 }), title: `${plural(names.length, 'branch')} diverged from GitHub`, "data-testid": "diverged-branches-alert", children: _jsxs(Stack, { gap: 4, children: [_jsx(Text, { size: "sm", children: "This deployment's copy of each branch below holds editor work that conflicts with the branch on GitHub, usually because the GitHub branch was rebased or force-pushed, or because another CanopyCMS deployment sharing this repository uses the same branch name. Neither copy has been changed, and publishing the branch fails until they agree. A branch that only gained commits on GitHub clears on its own at the next sync." }), _jsx(Text, { size: "sm", children: "A developer decides which version to keep. To keep GitHub's, first push it to a new branch name on GitHub, because \"Delete branch\" in the editor also deletes a published branch on GitHub; then delete this branch in the editor (withdraw it from review first if it is in review). The editor's changes cannot be copied to another branch: to keep them, leave this branch as it is, or re-enter them by hand in a new branch. For the base branch or a settings branch, ask a developer to check what changed on GitHub." }), _jsx(Group, { gap: 4, children: names.map((name) => (_jsx(Code, { children: escapeForLog(name) }, name))) })] }) }));
+    return (_jsx(Alert, { color: "orange", icon: _jsx(IconAlertTriangle, { size: 16 }), title: `${plural(names.length, 'branch')} diverged from GitHub`, "data-testid": "diverged-branches-alert", children: _jsxs(Stack, { gap: 4, children: [_jsx(Text, { size: "sm", children: "This deployment's copy of each branch below holds editor work that conflicts with the branch on GitHub, usually because the GitHub branch was rebased or force-pushed, or because another CanopyCMS deployment sharing this repository uses the same branch name. Neither copy has been changed, and publishing the branch fails until they agree. A branch that only gained commits on GitHub clears on its own at the next sync." }), _jsx(Text, { size: "sm", children: "A developer decides which version to keep. To keep GitHub's, first push it to a new branch name on GitHub, because \"Delete branch\" in the editor also deletes a published branch on GitHub; then delete this branch in the editor (withdraw it from review first if it is in review). The editor's changes cannot be copied to another branch: to keep them, leave this branch as it is, or re-enter them by hand in a new branch. For the base branch or a settings branch, ask a developer to check what changed on GitHub." }), _jsx(Group, { gap: 4, children: names.map((name) => (_jsx(Code, { style: { overflowWrap: 'anywhere' }, children: escapeForLog(name) }, name))) })] }) }));
 }
 /**
  * The branch namespace the CMS creates branches in, against the one the GitHub gateway writes. A
@@ -150,7 +151,7 @@ function BranchNamespaceAlert({ own, gateway, }) {
 }
 /** Branch refs from metadata the CMS Lambda can write, so each is shown escaped. */
 function BranchRefs({ branches }) {
-    return (_jsx(Group, { gap: 4, children: branches.map((branch, i) => (_jsx(Code, { children: escapeForLog(branch.name) }, i))) }));
+    return (_jsx(Group, { gap: 4, children: branches.map((branch, i) => (_jsx(Code, { style: { overflowWrap: 'anywhere' }, children: escapeForLog(branch.name) }, i))) }));
 }
 /**
  * Editor branches the GitHub gateway will not publish, by ref, which is what a developer lists
@@ -307,7 +308,7 @@ function OverviewTab({ health, overviewTabRef, }) {
         workerVersion !== build.canopycmsVersion;
     return (_jsxs(Stack, { ref: overviewRef, gap: "md", children: [error && (_jsx(Alert, { color: "red", icon: _jsx(IconAlertCircle, { size: 16 }), variant: "light", children: error })), _jsxs(Group, { gap: "sm", children: [_jsx(Badge, { color: liveness.color, variant: "light", size: "lg", children: liveness.label }), status.mode === 'dev' && (_jsx(Text, { size: "xs", c: "dimmed", children: "No worker runs in dev mode" }))] }), isRecentFatalError && lastFatalError && (_jsxs(Alert, { color: "red", icon: _jsx(IconAlertCircle, { size: 16 }), title: lastFatalError.phase === 'startup'
                     ? 'The worker failed to start'
-                    : 'The worker stopped while running', children: [_jsx(Text, { size: "sm", children: lastFatalError.message }), _jsxs(Text, { size: "xs", c: "dimmed", mt: 4, children: ["at ", lastFatalError.at] })] })), status.settingsWorkspaceError && (_jsx(Alert, { color: "red", icon: _jsx(IconAlertCircle, { size: 16 }), title: "Settings workspace unavailable: groups and path rules are not loading", children: _jsx(Text, { size: "sm", children: status.settingsWorkspaceError }) })), status.schemaIssues && status.schemaIssues.length > 0 && (_jsx(Alert, { color: "yellow", icon: _jsx(IconAlertTriangle, { size: 16 }), title: "Content types this editor version doesn't know", "data-testid": "schema-issues-alert", children: _jsx(Stack, { gap: 4, children: status.schemaIssues.map((issue) => (_jsx(Text, { size: "sm", children: issue.kind === 'unknown-schema' ? (_jsxs(_Fragment, { children: [_jsx(Code, { children: issue.metaFile }), " names ", _jsx(Code, { children: issue.schemaRef }), ", so entry type ", _jsx(Code, { children: issue.entryType }), " is unavailable"] })) : (issue.message) }, `${issue.kind}:${issue.message}`))) }) })), _jsx(BranchNamespaceAlert, { own: status.branchNamespace, gateway: status.workerStatus?.gatewayBranchNamespace }), status.workerStatus?.baseHold && _jsx(BaseHoldAlert, { hold: status.workerStatus.baseHold }), unpublished.length > 0 && (_jsx(UnpublishedAtMergeAlert, { branches: unpublished, onDismiss: handleDismissUnpublished })), status.statusReadError && (_jsxs(Text, { size: "xs", c: "orange", children: ["Warning: could not read worker status (", status.statusReadError, ")"] })), lastGitSync?.tracked && lastGitSync.tracked.diverged.length > 0 && (_jsx(DivergedBranchesAlert, { names: lastGitSync.tracked.diverged })), status.workerStatus?.unpublishableBranches && (_jsx(UnpublishableBranchesAlert, { report: status.workerStatus.unpublishableBranches, namespace: status.workerStatus.gatewayBranchNamespace })), status.workerStatus?.lastGitSyncError && (_jsxs(Alert, { color: "orange", icon: _jsx(IconAlertCircle, { size: 16 }), title: "Last git sync failed", children: [_jsx(Text, { size: "sm", children: status.workerStatus.lastGitSyncError.message }), _jsxs(Text, { size: "xs", c: "dimmed", mt: 4, children: ["at ", status.workerStatus.lastGitSyncError.at] })] })), versionSkew && (_jsx(Alert, { color: "orange", icon: _jsx(IconAlertCircle, { size: 16 }), title: "API and worker versions differ", "data-testid": "version-skew-warning", children: _jsxs(Text, { size: "sm", children: ["The API runs canopycms ", build.canopycmsVersion, " but the worker runs canopycms", ' ', workerVersion, ". They were deployed from different builds."] }) })), _jsxs(Paper, { withBorder: true, p: "sm", children: [_jsx(Text, { size: "sm", fw: 600, children: "Build" }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-api-version", children: ["API: canopycms ", build.canopycmsVersion] }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-source-revision", children: ["Source revision:", ' ', build.sourceRevision ? (_jsx(Tooltip, { label: build.sourceRevision, children: _jsx(Code, { children: build.sourceRevision.slice(0, 12) }) })) : ('not set (pass the CANOPY_SOURCE_SHA build arg to the image build)')] }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-worker-version", children: ["Worker version: ", workerVersion ? `canopycms ${workerVersion}` : 'unknown'] }), lastShutdown && (_jsxs(Text, { size: "xs", c: lastShutdown.outcome === 'drained' ? 'dimmed' : 'orange', "data-testid": "build-last-shutdown", children: ["Last worker shutdown: ", lastShutdown.reason, " at ", lastShutdown.at, lastShutdown.outcome === 'deadline' &&
+                    : 'The worker stopped while running', children: [_jsx(Text, { size: "sm", children: lastFatalError.message }), _jsxs(Text, { size: "xs", c: "dimmed", mt: 4, children: ["at ", lastFatalError.at] })] })), status.settingsWorkspaceError && (_jsx(Alert, { color: "red", icon: _jsx(IconAlertCircle, { size: 16 }), title: "Settings workspace unavailable: groups and path rules are not loading", children: _jsx(Text, { size: "sm", children: status.settingsWorkspaceError }) })), status.schemaIssues && status.schemaIssues.length > 0 && (_jsx(Alert, { color: "yellow", icon: _jsx(IconAlertTriangle, { size: 16 }), title: "Content types this editor version doesn't know", "data-testid": "schema-issues-alert", children: _jsx(Stack, { gap: 4, children: status.schemaIssues.map((issue) => (_jsx(Text, { size: "sm", children: issue.kind === 'unknown-schema' ? (_jsxs(_Fragment, { children: [_jsx(Code, { children: issue.metaFile }), " names ", _jsx(Code, { children: issue.schemaRef }), ", so entry type ", _jsx(Code, { children: issue.entryType }), " is unavailable"] })) : (issue.message) }, `${issue.kind}:${issue.message}`))) }) })), _jsx(BranchNamespaceAlert, { own: status.branchNamespace, gateway: status.workerStatus?.gatewayBranchNamespace }), status.workerStatus?.baseHold && _jsx(BaseHoldAlert, { hold: status.workerStatus.baseHold }), unpublished.length > 0 && (_jsx(UnpublishedAtMergeAlert, { branches: unpublished, onDismiss: handleDismissUnpublished })), status.statusReadError && (_jsxs(Text, { size: "xs", c: "orange", children: ["Warning: could not read worker status (", status.statusReadError, ")"] })), lastGitSync?.tracked && lastGitSync.tracked.diverged.length > 0 && (_jsx(DivergedBranchesAlert, { names: lastGitSync.tracked.diverged })), status.workerStatus?.unpublishableBranches && (_jsx(UnpublishableBranchesAlert, { report: status.workerStatus.unpublishableBranches, namespace: status.workerStatus.gatewayBranchNamespace })), status.workerStatus?.conflictsStatusFailure && (_jsx(ConflictsStatusAlert, { failure: status.workerStatus.conflictsStatusFailure })), status.workerStatus?.lastGitSyncError && (_jsxs(Alert, { color: "orange", icon: _jsx(IconAlertCircle, { size: 16 }), title: "Last git sync failed", children: [_jsx(Text, { size: "sm", children: status.workerStatus.lastGitSyncError.message }), _jsxs(Text, { size: "xs", c: "dimmed", mt: 4, children: ["at ", status.workerStatus.lastGitSyncError.at] })] })), versionSkew && (_jsx(Alert, { color: "orange", icon: _jsx(IconAlertCircle, { size: 16 }), title: "API and worker versions differ", "data-testid": "version-skew-warning", children: _jsxs(Text, { size: "sm", children: ["The API runs canopycms ", build.canopycmsVersion, " but the worker runs canopycms", ' ', workerVersion, ". They were deployed from different builds."] }) })), _jsxs(Paper, { withBorder: true, p: "sm", children: [_jsx(Text, { size: "sm", fw: 600, children: "Build" }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-api-version", children: ["API: canopycms ", build.canopycmsVersion] }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-source-revision", children: ["Source revision:", ' ', build.sourceRevision ? (_jsx(Tooltip, { label: build.sourceRevision, children: _jsx(Code, { children: build.sourceRevision.slice(0, 12) }) })) : ('not set (pass the CANOPY_SOURCE_SHA build arg to the image build)')] }), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-worker-version", children: ["Worker version: ", workerVersion ? `canopycms ${workerVersion}` : 'unknown'] }), lastShutdown && (_jsxs(Text, { size: "xs", c: lastShutdown.outcome === 'drained' ? 'dimmed' : 'orange', "data-testid": "build-last-shutdown", children: ["Last worker shutdown: ", lastShutdown.reason, " at ", lastShutdown.at, lastShutdown.outcome === 'deadline' &&
                                 ` · drain deadline hit, aborted ${lastShutdown.abandoned?.join(', ') ?? 'in-flight work'}`, lastShutdown.outcome === 'drained' &&
                                 lastShutdown.drainMs !== undefined &&
                                 ` · drained in ${(lastShutdown.drainMs / 1000).toFixed(1)}s`, lastShutdown.outcome === 'not-drained' && ' (a crash or a forced stop)'] })), lastFatalError?.phase === 'startup' && (_jsxs(Text, { size: "xs", c: "orange", "data-testid": "build-failed-start", children: ["Last start failed at ", lastFatalError.at] })), _jsxs(Text, { size: "xs", c: "dimmed", "data-testid": "build-media", children: ["Media storage:", ' ', status.assetStore.configured ? 'configured' : 'not configured — uploads are disabled'] }), _jsxs(Text, { size: "xs", c: status.imageProcessing.available ? 'dimmed' : 'orange', "data-testid": "build-image-processing", children: ["Image processing:", ' ', status.imageProcessing.available

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

@@ -0,0 +1,78 @@
+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";
+/** The bar's badge while the automatic sync leaves the base out for the branch's saved work. */
+export declare const LATEST_CHANGES_WAITING = "Latest changes waiting";
+/** The badge's detail: below `md` the action is in the branch menu, and unsaved changes hold it. */
+export declare function latestChangesWaitingDetail(inMenu: boolean, saveFirst: boolean): string;
+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,98 @@
+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…';
+/** The bar's badge while the automatic sync leaves the base out for the branch's saved work. */
+export const LATEST_CHANGES_WAITING = 'Latest changes waiting';
+/** The badge's detail: below `md` the action is in the branch menu, and unsaved changes hold it. */
+export function latestChangesWaitingDetail(inMenu, saveFirst) {
+    const control = `"Get latest changes"${inMenu ? ' in the branch menu' : ''}`;
+    return `Newer changes made on the site are waiting for this branch. ${saveFirst ? `Save your changes, then choose ${control}` : `Choose ${control}`} to bring them in.`;
+}
+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' })] })] }));
 }