canopycms 0.2.0-int.121 → 0.3.0

package/dist/editor/branch-lock.d.ts

@@ -0,0 +1,42 @@
+import type { BranchStatus } from '../types.js';
+export interface BranchLockInput {
+    branchStatus: BranchStatus | undefined;
+    /** The protected base branch, read-only in prod. */
+    branchReadOnly?: boolean;
+    branchWriteBlocked?: boolean;
+    /** The branch list is still being fetched, so details aren't unavailable yet, only pending. */
+    branchPending?: boolean;
+    /** The branch list answered without this branch: no access to it, or it no longer exists. */
+    branchMissing?: boolean;
+}
+/**
+ * Which lock applies. `branchWriteBlocked` is the server's own answer (getBranchProtection), so
+ * nothing offers a write the API would reject; `branchReadOnly` only picks the message, and
+ * base-branch read-only takes precedence over a workflow status lock.
+ * @internal Exported for tests; the bar reads it through `branchBarStatus`.
+ */
+export declare function branchLockState({ branchStatus, branchReadOnly, branchWriteBlocked, }: BranchLockInput): {
+    readOnly: boolean;
+    statusLocked: boolean;
+    branchDataUnavailable: boolean;
+};
+/** Why the branch takes no writes, and the way forward, as Save, row locks and the status say. */
+export declare function describeBranchLock(lock: BranchLockInput): string | undefined;
+export interface BranchBarStatusInput extends BranchLockInput {
+    /** The listed branch's `isProtected`, with no fallback here: no listed branch names no protection. */
+    isProtected: boolean | undefined;
+}
+export interface BranchBarStatus {
+    /** The status element's text; undefined for an editable branch, which shows none. */
+    label?: string;
+    value: string;
+    readOnly: boolean;
+    /** The way forward; `workflow` leaves it to the Withdraw control, never offered twice. */
+    action?: 'newBranch' | 'switchBranch' | 'refreshBranch' | 'workflow';
+}
+/**
+ * The branch bar's status and way forward, one row of the lock-state table, checked in order.
+ * Pending comes first because a fetch in flight is also `branchDataUnavailable`, and `readOnly`
+ * before any status lock, as in `describeBranchLock`.
+ */
+export declare function branchBarStatus(input: BranchBarStatusInput): BranchBarStatus;

package/dist/editor/branch-lock.js

@@ -0,0 +1,79 @@
+import { branchStatusPresentation } from './branch-status.js';
+/**
+ * Which lock applies. `branchWriteBlocked` is the server's own answer (getBranchProtection), so
+ * nothing offers a write the API would reject; `branchReadOnly` only picks the message, and
+ * base-branch read-only takes precedence over a workflow status lock.
+ * @internal Exported for tests; the bar reads it through `branchBarStatus`.
+ */
+export function branchLockState({ branchStatus, branchReadOnly = false, branchWriteBlocked = false, }) {
+    const statusLocked = branchWriteBlocked && !branchReadOnly;
+    // `branchStatus` can't describe the lock while branch data loads (undefined) or under version
+    // skew (an old server omits `branchWriteBlocked` but reports 'editing'), so both read as
+    // unavailable data rather than naming a status the lock contradicts.
+    const branchDataUnavailable = statusLocked && (branchStatus === undefined || branchStatus === 'editing');
+    return { readOnly: branchReadOnly, statusLocked, branchDataUnavailable };
+}
+/** Why the branch takes no writes, and the way forward, as Save, row locks and the status say. */
+export function describeBranchLock(lock) {
+    const { readOnly, statusLocked, branchDataUnavailable } = branchLockState(lock);
+    if (readOnly)
+        return 'The base branch is read-only. Create a branch to make changes.';
+    if (branchDataUnavailable)
+        return lock.branchPending
+            ? 'Wait for the branch details to load.'
+            : lock.branchMissing
+                ? `You don't have access to this branch, or it no longer exists. Use "Switch branch…" to open another.`
+                : 'Branch details could not be loaded. Use "Refresh branch" to try again.';
+    if (!statusLocked)
+        return undefined;
+    if (lock.branchStatus === 'submitted')
+        return 'This branch is in review. Withdraw it to make changes.';
+    if (lock.branchStatus === 'approved')
+        return 'This branch is approved. Withdraw it to make changes.';
+    return `This branch is ${lock.branchStatus}. Its content is read-only.`;
+}
+const capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+/**
+ * The branch bar's status and way forward, one row of the lock-state table, checked in order.
+ * Pending comes first because a fetch in flight is also `branchDataUnavailable`, and `readOnly`
+ * before any status lock, as in `describeBranchLock`.
+ */
+export function branchBarStatus(input) {
+    const { readOnly, statusLocked, branchDataUnavailable } = branchLockState(input);
+    const status = input.branchStatus;
+    if (input.branchPending)
+        return { label: 'Loading branch…', value: 'loading', readOnly: false };
+    if (branchDataUnavailable)
+        return input.branchMissing
+            ? {
+                label: 'Not available · read-only',
+                value: 'not-available',
+                readOnly: true,
+                action: 'switchBranch',
+            }
+            : {
+                label: 'Details unavailable · read-only',
+                value: 'unavailable',
+                readOnly: true,
+                action: 'refreshBranch',
+            };
+    if (readOnly)
+        return {
+            label: 'Protected · read-only',
+            value: 'protected',
+            readOnly: true,
+            action: 'newBranch',
+        };
+    if (!statusLocked)
+        return input.isProtected === true
+            ? { label: 'Protected', value: 'protected-editable', readOnly: false }
+            : { value: 'editable', readOnly: false };
+    // A lock with no status is `branchDataUnavailable`, handled above.
+    const label = capitalize(branchStatusPresentation(status)?.label ?? String(status));
+    return {
+        label: `${label} · read-only`,
+        value: String(status),
+        readOnly: true,
+        action: status === 'submitted' || status === 'approved' ? 'workflow' : 'switchBranch',
+    };
+}

package/dist/editor/branch-status.d.ts

@@ -15,9 +15,3 @@ export declare const BRANCH_STATUS_PRESENTATION: Record<BranchStatus, BranchStat
  * Returns undefined when there is nothing to show.
  */
 export declare function branchStatusPresentation(status: string | undefined, isProtected?: boolean): BranchStatusPresentation | undefined;
-/**
- * The status the top bar shows: only one that tells the user something, so not 'editing', the
- * state every branch starts in. The Branches drawer shows every status through
- * `branchStatusPresentation`.
- */
-export declare function branchBarStatusPresentation(status: string | undefined, isProtected?: boolean): BranchStatusPresentation | undefined;

package/dist/editor/branch-status.js

@@ -27,13 +27,3 @@ export function branchStatusPresentation(status, isProtected = false) {
         return BRANCH_STATUS_PRESENTATION[status];
     return { label: status, color: 'gray', variant: 'light' };
 }
-/**
- * The status the top bar shows: only one that tells the user something, so not 'editing', the
- * state every branch starts in. The Branches drawer shows every status through
- * `branchStatusPresentation`.
- */
-export function branchBarStatusPresentation(status, isProtected = false) {
-    if (!isProtected && status === 'editing')
-        return undefined;
-    return branchStatusPresentation(status, isProtected);
-}

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

@@ -0,0 +1,11 @@
+export interface BranchNotAvailableNoticeProps {
+    /** Opens the Branches drawer. Without it the notice is text alone. */
+    onSwitchBranch?: () => void;
+    align?: 'flex-start' | 'center';
+    'data-testid'?: string;
+}
+/**
+ * The empty state of a branch on the bar's "Not available" row (`branchBarStatus`), where the
+ * branch list answered without it, so nothing of the branch can show.
+ */
+export declare function BranchNotAvailableNotice({ onSwitchBranch, align, 'data-testid': testId, }: BranchNotAvailableNoticeProps): import("react/jsx-runtime").JSX.Element;

package/dist/editor/components/BranchNotAvailableNotice.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Stack, Text } from '@mantine/core';
+import { EDITOR_ACTIONS } from '../copy.js';
+/**
+ * The empty state of a branch on the bar's "Not available" row (`branchBarStatus`), where the
+ * branch list answered without it, so nothing of the branch can show.
+ */
+export function BranchNotAvailableNotice({ onSwitchBranch, align = 'flex-start', 'data-testid': testId, }) {
+    return (_jsxs(Stack, { gap: 4, py: "sm", align: align, "data-testid": testId, children: [_jsx(Text, { size: "sm", c: "dimmed", children: "You don't have access to this branch, or it no longer exists." }), onSwitchBranch && (_jsx(Button, { size: "compact-sm", variant: "subtle", onClick: onSwitchBranch, children: `${EDITOR_ACTIONS.switchBranch}…` }))] }));
+}

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

@@ -1,33 +1,18 @@
 import { type Ref } from 'react';
-import type { LogicalPath } from '../../paths/types.js';
 export interface BranchPillProps {
     branchName: string;
     /** The editor is busy; with no branch name yet, that is the branch list loading. */
     loading: boolean;
-    /** The status label ("In review", "Protected"), set only for a status worth a place in the bar. */
-    status?: {
-        label: string;
-        testId: string;
-        value: string;
-    };
     /** How many entries on the branch have unsaved changes, counting any the list can't name yet. */
     unsavedCount: number;
-    /** The listed entries with unsaved changes. */
-    unsavedEntries: Array<{
-        path: LogicalPath;
-        label: string;
-    }>;
     onSwitchBranch: () => void;
     onRefreshBranch: () => void;
     onDiscardAll: () => void;
-    onEntrySelect: (path: LogicalPath) => void;
     /** The pill, which stands in for a menu item that opened something. */
     pillRef?: Ref<HTMLButtonElement>;
 }
 /**
- * The branch's name, status and unsaved count: the unsaved mark and a number. Its menu holds the
- * branch actions and lists the unsaved entries, each opening that entry. Below `sm` it is the
- * branch icon and the count, its name then in its Tooltip, accessible name and menu label: the
- * row's actions must not clip.
+ * The branch's name. Its menu, headed by the full name, holds the branch actions. Below `sm` the
+ * name truncates shorter, so the actions don't clip.
  */
-export declare function BranchPill({ branchName, loading, status, unsavedCount: unsaved, unsavedEntries, onSwitchBranch, onRefreshBranch, onDiscardAll, onEntrySelect, pillRef, }: BranchPillProps): import("react/jsx-runtime").JSX.Element;
+export declare function BranchPill({ branchName, loading, unsavedCount: unsaved, onSwitchBranch, onRefreshBranch, onDiscardAll, pillRef, }: BranchPillProps): import("react/jsx-runtime").JSX.Element;

package/dist/editor/components/BranchPill.js

@@ -1,31 +1,28 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRef } from 'react';
-import { Box, Button, Menu, Text, Tooltip, VisuallyHidden } from '@mantine/core';
+import { Button, Menu, Text, Tooltip } from '@mantine/core';
 import { useMediaQuery, useMergedRef } from '@mantine/hooks';
 import { IconChevronDown, IconGitBranch } from '@tabler/icons-react';
 import { EDITOR_ACTIONS } from '../copy.js';
 import { DestructiveMenuItem } from './DestructiveMenuItem.js';
 import { ReasonedMenuItem } from './ReasonedMenuItem.js';
-import { UnsavedMark } from './UnsavedMark.js';
 import { useMenuItemFocusReturn } from '../utils/focus-return.js';
 const plural = (count, one, many) => `${count} ${count === 1 ? one : many}`;
 /**
- * The branch's name, status and unsaved count: the unsaved mark and a number. Its menu holds the
- * branch actions and lists the unsaved entries, each opening that entry. Below `sm` it is the
- * branch icon and the count, its name then in its Tooltip, accessible name and menu label: the
- * row's actions must not clip.
+ * The branch's name. Its menu, headed by the full name, holds the branch actions. Below `sm` the
+ * name truncates shorter, so the actions don't clip.
  */
-export function BranchPill({ branchName, loading, status, unsavedCount: unsaved, unsavedEntries, onSwitchBranch, onRefreshBranch, onDiscardAll, onEntrySelect, pillRef, }) {
+export function BranchPill({ branchName, loading, unsavedCount: unsaved, onSwitchBranch, onRefreshBranch, onDiscardAll, pillRef, }) {
     const trigger = useRef(null);
     const triggerRef = useMergedRef(trigger, pillRef);
     const menuFocus = useMenuItemFocusReturn(trigger);
     const noBranch = branchName ? undefined : 'Open a branch first.';
     const wide = useMediaQuery('(min-width: 48em)');
     const name = branchName || (loading ? 'Loading branches…' : 'No branch open');
-    return (_jsxs(Menu, { withinPortal: true, shadow: "sm", position: "bottom-end", ...menuFocus.menu, children: [_jsx(Tooltip, { label: status ? `${name} · ${status.label}` : name, disabled: wide, events: { hover: true, focus: true, touch: false }, children: _jsx(Menu.Target, { children: _jsxs(Button, { ref: triggerRef, variant: "default", size: "sm", miw: 0, px: { base: 8, sm: 14 }, 
-                        // The count is the bar's one branch-wide unsaved signal: the row wraps before it 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: 200, visibleFrom: "sm", children: name }), _jsx(VisuallyHidden, { component: "span", hiddenFrom: "sm", children: name }), branchName && status && (_jsxs(Text, { span: true, size: "xs", c: "dimmed", visibleFrom: "md", style: { flexShrink: 0 }, children: [_jsx("span", { "aria-hidden": "true", children: "\u00B7 " }), _jsx("span", { "data-testid": status.testId, "data-status": status.value, children: status.label })] })), unsaved > 0 && (_jsxs(Box, { component: "span", display: "inline-flex", style: { alignItems: 'center', gap: 4, flexShrink: 0 }, "data-testid": "branch-unsaved-count", children: [_jsx(UnsavedMark, { "aria-hidden": "true" }), _jsx(Text, { span: true, size: "xs", fw: 600, "aria-hidden": "true", children: unsaved }), _jsx(VisuallyHidden, { component: "span", children: `, ${plural(unsaved, 'entry', 'entries')} with unsaved changes` })] }))] }) }) }), _jsxs(Menu.Dropdown, { "data-testid": "branch-menu", ...menuFocus.dropdown, children: [branchName && status && (_jsx(Menu.Label, { hiddenFrom: "md", children: `${branchName} · ${status.label}` })), _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(Menu.Label, { children: "Unsaved changes" }), unsavedEntries.length === 0 ? (_jsx(Text, { size: "sm", c: "dimmed", px: "sm", py: 6, "data-testid": "edited-entries-empty", children: unsaved === 0 ? 'No unsaved changes on this branch.' : 'Loading their names…' })) : (unsavedEntries.map((entry) => (_jsx(Menu.Item, { onClick: () => onEntrySelect(entry.path), children: entry.label }, entry.path)))), _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
+    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
                             ? `Discard all changes (${plural(unsaved, 'entry', 'entries')})`
                             : 'Discard all changes' })] })] }));
 }

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

@@ -4,7 +4,9 @@ import React from 'react';
  * writes. It matches the menu button's footprint so rows do not shift between branches, and takes
  * the menu's name; the reason is its Tooltip and its description. It stays `aria-disabled` rather
  * than `disabled`, so the reason opens on keyboard focus and touch too. Space is stopped here: the
- * tree would read it as expand/collapse.
+ * tree would read it as expand/collapse. `data-row-lock` marks it for the theme stylesheet, which
+ * draws it only on the hovered, focused or selected row (opacity, never `display`, so
+ * focusing it reveals it); a touch user sees it on the row they tapped.
  */
 export declare const BranchRowLock: React.FC<{
     label: string;

package/dist/editor/components/BranchRowLock.js

@@ -8,11 +8,13 @@ import { IconLock } from '@tabler/icons-react';
  * writes. It matches the menu button's footprint so rows do not shift between branches, and takes
  * the menu's name; the reason is its Tooltip and its description. It stays `aria-disabled` rather
  * than `disabled`, so the reason opens on keyboard focus and touch too. Space is stopped here: the
- * tree would read it as expand/collapse.
+ * tree would read it as expand/collapse. `data-row-lock` marks it for the theme stylesheet, which
+ * draws it only on the hovered, focused or selected row (opacity, never `display`, so
+ * focusing it reveals it); a touch user sees it on the row they tapped.
  */
 export const BranchRowLock = ({ label, reason }) => {
     const reasonId = useId();
-    return (_jsx(Tooltip, { label: reason, withinPortal: true, position: "bottom-end", multiline: true, w: 240, events: { hover: true, focus: true, touch: true }, children: _jsxs(ActionIcon, { size: "xs", variant: "transparent", c: "dimmed", "aria-disabled": true, "aria-label": label, "aria-describedby": reasonId, "data-testid": "branch-lock", style: { cursor: 'default' }, onClick: (event) => event.stopPropagation(), onKeyDown: (event) => {
+    return (_jsx(Tooltip, { label: reason, withinPortal: true, position: "bottom-end", multiline: true, w: 240, events: { hover: true, focus: true, touch: true }, children: _jsxs(ActionIcon, { size: "xs", variant: "transparent", c: "dimmed", "aria-disabled": true, "aria-label": label, "aria-describedby": reasonId, "data-testid": "branch-lock", "data-row-lock": true, style: { cursor: 'default' }, onClick: (event) => event.stopPropagation(), onKeyDown: (event) => {
                 if (event.nativeEvent.code === 'Space')
                     event.stopPropagation();
             }, children: [_jsx(IconLock, { size: 14, "aria-hidden": true }), _jsx(VisuallyHidden, { component: "span", id: reasonId, children: reason })] }) }));

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

@@ -1,66 +1,34 @@
 import { type Ref } from 'react';
-import type { OperatingMode } from '../../operating-mode/index.js';
 import type { BranchStatus } from '../../types.js';
-import type { EditorEntry } from '../Editor.js';
-import type { LogicalPath } from '../../paths/types.js';
-import type { BreadcrumbSegment } from '../editor-utils.js';
 import type { SaveAllProgress } from '../hooks/save-all.js';
 export interface EditorHeaderProps {
-    currentEntry: EditorEntry | undefined;
     branchName: string;
-    operatingMode: OperatingMode;
     /** Whether operations are currently in progress. */
     busy: boolean;
-    /** The crumbs before the open entry's own. */
-    breadcrumbSegments: BreadcrumbSegment[];
-    /** The listed entries with unsaved changes on the branch. */
-    editedFiles: Array<{
-        path: LogicalPath;
-        label: string;
-    }>;
     /** Entries with unsaved changes on the branch. */
     modifiedCount: number;
-    /** Opens the content panel on a collection. */
-    onCollectionOpen: (collectionPath: string) => void;
-    /** The entry menu's trigger. */
-    navigatorToggleRef?: Ref<HTMLButtonElement>;
+    /** Lists the unsaved entries: the content panel, filtered to Changed. */
+    onShowUnsaved: () => void;
     /** The branch pill. */
     branchToggleRef?: Ref<HTMLButtonElement>;
-    /** Replaces the open entry with the server's copy. */
-    onFileReload: () => void;
-    onFileDiscardDraft: () => void;
-    /** Opens the open entry's "Change URL" dialog. */
-    onEntryRename: () => void;
-    /** Asks to delete the open entry. */
-    onEntryDelete: () => void;
-    onEntrySelect: (path: LogicalPath) => void;
     /** Re-reads the branch and its entry list, keeping drafts. */
     onBranchReloadData: () => void;
     onBranchDiscardDrafts: () => void;
     onBranchManagerOpen: () => void;
-    onSave: () => void;
+    /** Opens Branches with its new-branch form; Branches alone without it. */
+    onNewBranch?: () => void;
     onSaveAll: () => void;
     saveAllProgress: SaveAllProgress | null;
-    /** A Save of the open entry is in flight. */
-    saving?: boolean;
-    /** Rises each time a single Save lands, whichever entry it saved. */
-    savedSignal?: number;
-    /** The last Save that landed saved the open entry. */
-    savedHere?: boolean;
+    /** A single Save is in flight, on any entry. */
+    singleSaving?: boolean;
     /** The branch's entry list failed to load and none is held. */
     entryListFailed?: boolean;
-    onSubmit: () => void;
-    onWithdraw: () => void;
-    /** The open entry has unsaved changes it could save. */
-    hasUnsavedChanges: boolean;
-    /** The open entry has a draft, savable or not (a read-only branch's still discards). */
-    entryHasDraft?: boolean;
+    /** Opens the submit dialog, which returns focus to `returnFocusTo()` when given. */
+    onSubmit: (returnFocusTo?: () => HTMLElement | null) => void;
+    /** Opens the withdraw dialog, which returns focus to `returnFocusTo()` when given. */
+    onWithdraw: (returnFocusTo?: () => HTMLElement | null) => void;
     /** Writing drafts to localStorage failed, so they live only in this tab. */
     draftStorageFailed?: boolean;
-    /** The open entry can't be edited by this user (a path rule). */
-    entryReadOnly?: boolean;
-    /** The open entry's type has no schema in the running code. */
-    entryUnavailable?: boolean;
     /** Current branch status (undefined if unknown). */
     branchStatus: BranchStatus | undefined;
     /** Current user context for permission checks. */
@@ -76,22 +44,26 @@ export interface EditorHeaderProps {
     };
     /**
      * Whether the current branch is the protected base branch (see
-     * authorization/protected-branch.ts). Hides the Submit button (Withdraw
-     * stays, as the recovery path). Default false.
+     * authorization/protected-branch.ts). Hides Submit, as a button or in the caret
+     * (Withdraw stays, as the recovery path). Default false.
      */
     branchIsProtected?: boolean;
-    /** Whether the current branch is read-only (protected base branch in prod); disables Save. */
+    /** `currentBranch.isProtected` for the status, unlike `branchIsProtected` not failed closed here. */
+    branchServerProtected?: boolean;
+    /** Whether the current branch is read-only (protected base branch in prod); disables Save all. */
     branchReadOnly?: boolean;
     /** Server-computed: content writes are rejected on this branch; see `branchLockState`. */
     branchWriteBlocked?: boolean;
-    /**
-     * No branch details yet (loading, or the list failed and the banner says so): the fail-closed
-     * lock defaults are guesses, so neither the chip nor the status names them.
-     */
+    /** No branch details yet: the fail-closed lock defaults are guesses the status doesn't name. */
     branchLoading?: boolean;
+    /** The branch list is still being fetched, as opposed to having failed or lacking this branch. */
+    branchPending?: boolean;
+    /** The branch list answered without this branch. */
+    branchMissing?: boolean;
 }
 /**
- * The top bar's contents: the breadcrumb with the entry menu and "Read-only" chip, then the branch
- * pill, Submit or Withdraw, and Save with Save all.
+ * The branch bar: the pill, the branch's status and its unsaved count, then the draft-storage
+ * warning, Save all, the way forward and Submit or Withdraw. The open entry's own controls are in
+ * `EntryHeader`.
  */
-export declare function EditorHeader({ currentEntry, branchName, operatingMode, busy, breadcrumbSegments, editedFiles, modifiedCount, onCollectionOpen, navigatorToggleRef, branchToggleRef, onFileReload, onFileDiscardDraft, onEntryRename, onEntryDelete, onEntrySelect, onBranchReloadData, onBranchDiscardDrafts, onBranchManagerOpen, onSave, onSaveAll, saveAllProgress, saving, savedSignal, savedHere, entryListFailed, onSubmit, onWithdraw, hasUnsavedChanges, entryHasDraft, draftStorageFailed, entryReadOnly, entryUnavailable, branchStatus, userContext, branchCreatedBy, branchAccess, branchIsProtected, branchReadOnly, branchWriteBlocked, branchLoading, }: EditorHeaderProps): import("react/jsx-runtime").JSX.Element;
+export declare function EditorHeader({ branchName, busy, modifiedCount, onShowUnsaved, branchToggleRef, onBranchReloadData, onBranchDiscardDrafts, onBranchManagerOpen, onNewBranch, onSaveAll, saveAllProgress, singleSaving, entryListFailed, onSubmit, onWithdraw, draftStorageFailed, branchStatus, userContext, branchCreatedBy, branchAccess, branchIsProtected, branchServerProtected, branchReadOnly, branchWriteBlocked, branchLoading, branchPending, branchMissing, }: EditorHeaderProps): import("react/jsx-runtime").JSX.Element;