canopycms 0.12.0 → 0.12.1

package/dist/editor/conflict-choices.d.ts

@@ -0,0 +1,60 @@
+/**
+ * What a choice on a conflict card does to the open entry's form value (conflict-cards.ts builds
+ * the cards). Pure. A choice is an unsaved edit: the save that writes it sends the conflict's key in
+ * `resolvedConflicts` (api/content.ts), which is what resolves it.
+ */
+import type { TextConflictRegion } from '../merge/text-merge.js';
+import type { FieldConflict } from './conflict-cards.js';
+import type { EntryChange } from './entry-diff.js';
+type FormValue = Record<string, unknown>;
+/** A region's choice: the latest version's lines, yours, or the latest's followed by yours. */
+export type RegionChoice = 'latest' | 'yours' | 'both';
+/**
+ * `latest`: the latest version's value, which for a removed one removes it. `yours`: your saved
+ * value as it stands. `edited`: what the form holds now, marked resolved after an edit. `regions`:
+ * long text chosen region by region, resolved once every region is chosen.
+ */
+export type FieldChoice = {
+    how: 'latest';
+} | {
+    how: 'yours';
+} | {
+    how: 'edited';
+} | {
+    how: 'regions';
+    regions: Readonly<Record<number, RegionChoice>>;
+};
+/** An entry's choices, by conflict key, each for the merge it was made on. */
+export type EntryChoices = Readonly<Record<string, {
+    mergeSha: string;
+    choice: FieldChoice;
+}>>;
+/** The change-shaped handle `undo-change.ts` places a value by. */
+export declare const placeOf: (field: Pick<FieldConflict, "key" | "dataPath" | "item">) => EntryChange;
+/** Whether a choice says everything its conflict needs. */
+export declare const isDecided: (field: FieldConflict, choice: FieldChoice | undefined) => boolean;
+/**
+ * The text the merge left with each region as `regions` chooses it. A region's lines sit where the
+ * merge put yours (`TextConflictRegion.line`), so regions are placed from the last up.
+ * @internal Exported for tests.
+ */
+export declare function textWithChoices(text: {
+    merged: string;
+    regions: readonly TextConflictRegion[];
+}, regions: Readonly<Record<number, RegionChoice>>): string;
+/**
+ * Whether the form still holds the conflict's place as the last choice (or, before any, your saved
+ * value) left it. False once it was edited by hand: a choice would then replace that edit.
+ */
+export declare function holdsChoice(current: FormValue, saved: FormValue, field: FieldConflict, choice: FieldChoice | undefined, bodyField: string | undefined): boolean;
+/**
+ * `current` with the latest version at the conflict's place; undefined when it can't be placed, as
+ * where the latest version couldn't be read or doesn't hold the items on the place's path
+ * ({@link FieldConflict.latestPlaceable}).
+ */
+export declare const withLatest: (current: FormValue, field: FieldConflict, bodyField: string | undefined) => FormValue | undefined;
+/** `current` with your saved value back at the conflict's place, as before any choice. */
+export declare const withYours: (current: FormValue, saved: FormValue, field: FieldConflict, bodyField: string | undefined) => FormValue | undefined;
+/** `current` with long text as `regions` chooses it. */
+export declare const withRegions: (current: FormValue, field: FieldConflict, regions: Readonly<Record<number, RegionChoice>>, bodyField: string | undefined) => FormValue | undefined;
+export {};

package/dist/editor/conflict-choices.js

@@ -0,0 +1,108 @@
+/**
+ * What a choice on a conflict card does to the open entry's form value (conflict-cards.ts builds
+ * the cards). Pure. A choice is an unsaved edit: the save that writes it sends the conflict's key in
+ * `resolvedConflicts` (api/content.ts), which is what resolves it.
+ */
+import { holdsAs, setChangeBack, valueAtChange, withValueAt } from './undo-change.js';
+/** The change-shaped handle `undo-change.ts` places a value by. */
+export const placeOf = (field) => ({
+    key: field.key,
+    dataPath: field.dataPath,
+    path: [],
+    kind: 'changed',
+    ...(field.item && { item: true }),
+});
+/** Whether a choice says everything its conflict needs. */
+export const isDecided = (field, choice) => !!choice &&
+    (choice.how !== 'regions' ||
+        (!!field.text && field.text.regions.every((_, i) => choice.regions[i] !== undefined)));
+const linesOf = (text, count) => count === 0 || (count === undefined && text === '') ? [] : text.split('\n');
+/** A region's lines under `choice`; undecided, they are yours, as the merge left them. */
+const regionLines = (region, choice) => {
+    const yours = linesOf(region.branch, region.lines);
+    // Counted, as the branch's are: joined, one blank line reads as none.
+    const latest = linesOf(region.base, region.baseLines);
+    if (choice === 'latest')
+        return latest;
+    if (choice === 'both')
+        return [...latest, ...yours];
+    return yours;
+};
+/**
+ * The text the merge left with each region as `regions` chooses it. A region's lines sit where the
+ * merge put yours (`TextConflictRegion.line`), so regions are placed from the last up.
+ * @internal Exported for tests.
+ */
+export function textWithChoices(text, regions) {
+    const endBreak = text.merged.endsWith('\n');
+    const body = endBreak ? text.merged.slice(0, -1) : text.merged;
+    const lines = body === '' && !endBreak ? [] : body.split('\n');
+    for (let i = text.regions.length - 1; i >= 0; i--) {
+        const region = text.regions[i];
+        lines.splice(region.line, region.lines, ...regionLines(region, regions[i]));
+    }
+    const joined = lines.join('\n');
+    return endBreak ? `${joined}\n` : joined;
+}
+/** What the form would hold at the conflict's place under `choice`, given your saved value. */
+const expectedUnder = (field, choice, saved) => {
+    if (!choice || choice.how === 'yours')
+        return { from: saved };
+    if (choice.how === 'latest')
+        return field.latest ? { from: field.latest } : undefined;
+    if (choice.how === 'regions' && field.text)
+        return { text: textWithChoices(field.text, choice.regions) };
+    return undefined;
+};
+/**
+ * Whether the form still holds the conflict's place as the last choice (or, before any, your saved
+ * value) left it. False once it was edited by hand: a choice would then replace that edit.
+ */
+export function holdsChoice(current, saved, field, choice, bodyField) {
+    const expected = expectedUnder(field, choice, saved);
+    // A place with no path, such as where the entry is, holds nothing the form could edit.
+    if (!expected || field.dataPath.length === 0)
+        return true;
+    if ('text' in expected)
+        return valueAtChange(current, field, bodyField) === expected.text;
+    // An item on the way that the form no longer has holds nothing, though an empty value would
+    // compare equal to the nothing found there.
+    const from = expected.from;
+    const itemGone = field.dataPath.some((segment, i) => 'item' in segment &&
+        valueAtChange(from, { dataPath: field.dataPath.slice(0, i + 1) }, bodyField) !== undefined &&
+        valueAtChange(current, { dataPath: field.dataPath.slice(0, i + 1) }, bodyField) === undefined);
+    if (itemGone)
+        return false;
+    // Long text checks the merged text, which your saved value holds until a region is chosen.
+    if (field.text && (!choice || choice.how === 'yours')) {
+        return valueAtChange(current, field, bodyField) === valueAtChange(saved, field, bodyField);
+    }
+    return holdsAs(current, expected.from, placeOf(field), bodyField);
+}
+/**
+ * `current` with the conflict's place as `source` has it: a list item `source` lacks taken out, or
+ * one `current` lacks put in where `source` has it, through `undo-change.ts`; anything else, an item
+ * both hold included, replaced where it is, by key. Undefined when it can't be placed.
+ */
+const placeFrom = (current, source, field, bodyField) => {
+    const place = placeOf(field);
+    const wanted = valueAtChange(source, place, bodyField);
+    if (wanted === undefined ||
+        (field.item && valueAtChange(current, place, bodyField) === undefined))
+        return setChangeBack(current, source, place, bodyField);
+    return withValueAt(current, place, structuredClone(wanted), bodyField);
+};
+/**
+ * `current` with the latest version at the conflict's place; undefined when it can't be placed, as
+ * where the latest version couldn't be read or doesn't hold the items on the place's path
+ * ({@link FieldConflict.latestPlaceable}).
+ */
+export const withLatest = (current, field, bodyField) => field.latest && field.latestPlaceable
+    ? placeFrom(current, field.latest, field, bodyField)
+    : undefined;
+/** `current` with your saved value back at the conflict's place, as before any choice. */
+export const withYours = (current, saved, field, bodyField) => placeFrom(current, saved, field, bodyField);
+/** `current` with long text as `regions` chooses it. */
+export const withRegions = (current, field, regions, bodyField) => field.text
+    ? withValueAt(current, field, textWithChoices(field.text, regions), bodyField)
+    : undefined;

package/dist/editor/conflict-notice.d.ts

@@ -0,0 +1,25 @@
+/**
+ * What the editor says about a branch's open conflicts outside "Show changes": the open entry's
+ * notice, Submit's reason, the bar's badge and the "Get latest changes" toast. A count is of the
+ * choices left (`MergeConflictsData.openCount`): one per field, and one per entry-level conflict
+ * (`openConflictCount`, merge-conflicts.ts). No copy names a
+ * branch: an author may not know the branch theirs was cut from.
+ */
+import type { MergeConflictListItem } from '../api/merge-conflicts.js';
+/** The notice above an entry's form while it has conflicts; the list item when it is loaded. */
+export declare function entryConflictNotice(item: MergeConflictListItem | undefined): string;
+/** Why Submit for review waits while choices are open. */
+export declare const conflictsSubmitReason: (count: number) => string;
+/** The bar's "Needs action" detail while choices are open. */
+export declare const conflictsHoldMessage: (count: number) => string;
+/**
+ * The "Get latest changes" toast when the merge left choices; undefined: not yet counted. None
+ * left is a plain success, which base-update-wait.ts says instead.
+ */
+export declare const latestChangesConflictsMessage: (count: number | undefined) => string;
+/** The bar's "Needs action" detail while the branch's record of conflicts is held. */
+export declare const conflictRecordHeldMessage = "This branch's record of conflicts was damaged and set aside, so it's on hold: it can't be submitted or approved until an admin releases the hold.";
+/** The same, to an admin, who has the way out beside it. */
+export declare const conflictRecordHeldAdminMessage = "This branch's record of conflicts was damaged and set aside, so it's on hold: it can't be submitted or approved. Use \"Release hold\" to let it go on.";
+/** What "Release hold" gives up, in its confirm. */
+export declare const releaseHoldConsequences = "Releasing lets this branch be submitted and approved again. The list of fields that needed a choice is lost for good: each field keeps the value it has now, and no one will be asked to choose. Check the branch's changes first.";

package/dist/editor/conflict-notice.js

@@ -0,0 +1,39 @@
+/**
+ * What the editor says about a branch's open conflicts outside "Show changes": the open entry's
+ * notice, Submit's reason, the bar's badge and the "Get latest changes" toast. A count is of the
+ * choices left (`MergeConflictsData.openCount`): one per field, and one per entry-level conflict
+ * (`openConflictCount`, merge-conflicts.ts). No copy names a
+ * branch: an author may not know the branch theirs was cut from.
+ */
+/** "1 field needs", "2 fields need". */
+const fieldsNeed = (count) => count === 1 ? '1 field needs' : `${count} fields need`;
+const CHOOSE = 'Choose what to keep in "Show changes".';
+/** The notice above an entry's form while it has conflicts; the list item when it is loaded. */
+export function entryConflictNotice(item) {
+    switch (item?.kind) {
+        case 'deleted-on-base':
+            return `This entry was deleted in the latest version, but you changed it. ${CHOOSE}`;
+        case 'unreadable':
+        case 'deleted-on-branch':
+            return `This entry was changed by you and by someone else. ${CHOOSE}`;
+        case 'fields':
+            return `${item.fieldCount === 1 ? '1 field was' : `${item.fieldCount} fields were`} changed by you and by someone else. ${CHOOSE}`;
+        default:
+            return `Some fields were changed by you and by someone else. ${CHOOSE}`;
+    }
+}
+/** Why Submit for review waits while choices are open. */
+export const conflictsSubmitReason = (count) => `${fieldsNeed(count)} your choice before this branch can be submitted. Choose what to keep in "Show changes" on each flagged entry.`;
+/** The bar's "Needs action" detail while choices are open. */
+export const conflictsHoldMessage = (count) => `${fieldsNeed(count)} your choice: changed by you and by someone else. Choose what to keep in "Show changes" on each flagged entry, then submit.`;
+/**
+ * The "Get latest changes" toast when the merge left choices; undefined: not yet counted. None
+ * left is a plain success, which base-update-wait.ts says instead.
+ */
+export const latestChangesConflictsMessage = (count) => `Latest changes added. ${count === undefined ? 'Some fields need' : fieldsNeed(count)} your choice.`;
+/** The bar's "Needs action" detail while the branch's record of conflicts is held. */
+export const conflictRecordHeldMessage = "This branch's record of conflicts was damaged and set aside, so it's on hold: it can't be submitted or approved until an admin releases the hold.";
+/** The same, to an admin, who has the way out beside it. */
+export const conflictRecordHeldAdminMessage = "This branch's record of conflicts was damaged and set aside, so it's on hold: it can't be submitted or approved. Use \"Release hold\" to let it go on.";
+/** What "Release hold" gives up, in its confirm. */
+export const releaseHoldConsequences = "Releasing lets this branch be submitted and approved again. The list of fields that needed a choice is lost for good: each field keeps the value it has now, and no one will be asked to choose. Check the branch's changes first.";

package/dist/editor/copy.d.ts

@@ -9,6 +9,7 @@ export declare const EDITOR_ACTIONS: {
     readonly refreshFromServer: "Refresh from server";
     readonly submitForReview: "Submit for review";
     readonly withdrawFromReview: "Withdraw from review";
+    readonly getLatestChanges: "Get latest changes";
     readonly approve: "Approve";
     readonly review: "Review";
     readonly requestChanges: "Request changes";
@@ -28,7 +29,18 @@ export declare const EDITOR_ACTIONS: {
     readonly redoAllChanges: "Redo all changes";
     readonly restoreEntry: "Restore entry";
     readonly deleteEntry: "Delete entry";
+    readonly useLatestVersion: "Use latest version";
+    readonly keepYourVersion: "Keep your version";
+    readonly useBoth: "Use both";
+    readonly markResolved: "Mark resolved";
+    readonly releaseHold: "Release hold";
+    readonly removeIt: "Remove it";
+    readonly keepIt: "Keep it";
+    readonly keepItDeleted: "Keep it deleted";
+    readonly chooseAgain: "Choose again";
 };
+/** Withdraw's confirm on a branch that conflicts with its base, which then gets the latest changes. */
+export declare const WITHDRAW_AND_GET_LATEST = "Withdraw and get latest changes";
 /**
  * Why a list at its `maxItems` adds nothing more, as a disabled Add's Tooltip or an input's hint.
  * `one` and `many` name what the list holds.

package/dist/editor/copy.js

@@ -9,6 +9,7 @@ export const EDITOR_ACTIONS = {
     refreshFromServer: 'Refresh from server',
     submitForReview: 'Submit for review',
     withdrawFromReview: 'Withdraw from review',
+    getLatestChanges: 'Get latest changes',
     approve: 'Approve',
     review: 'Review',
     requestChanges: 'Request changes',
@@ -28,7 +29,18 @@ export const EDITOR_ACTIONS = {
     redoAllChanges: 'Redo all changes',
     restoreEntry: 'Restore entry',
     deleteEntry: 'Delete entry',
+    useLatestVersion: 'Use latest version',
+    keepYourVersion: 'Keep your version',
+    useBoth: 'Use both',
+    markResolved: 'Mark resolved',
+    releaseHold: 'Release hold',
+    removeIt: 'Remove it',
+    keepIt: 'Keep it',
+    keepItDeleted: 'Keep it deleted',
+    chooseAgain: 'Choose again',
 };
+/** Withdraw's confirm on a branch that conflicts with its base, which then gets the latest changes. */
+export const WITHDRAW_AND_GET_LATEST = 'Withdraw and get latest changes';
 /**
  * Why a list at its `maxItems` adds nothing more, as a disabled Add's Tooltip or an input's hint.
  * `one` and `many` name what the list holds.

package/dist/editor/entry-diff.d.ts

@@ -151,8 +151,9 @@ export interface EntryDiffInput {
  * text's spacing, so one side read back from its parts would not be the text it was.
  * Undefined once `deadline` (a `Date.now()`) passes: no line diff starts after it. A short word
  * diff runs until the later `wordDeadline`.
- * @internal Exported for tests.
  */
 export declare function textDiff(before: string, after: string, long?: boolean, deadline?: number, wordDeadline?: number): TextDiff | undefined;
+/** `value` of `field` as the drawer shows it whole, for a value a conflict compares whole. */
+export declare function displayWhole(field: FieldConfig | undefined, value: unknown, referenceTitle?: (id: string) => string | undefined): DisplayValue;
 /** The entry's changes between `before` and `after`, in schema order. */
 export declare function computeEntryDiff({ fields, before, after, referenceTitle, marks, }: EntryDiffInput): EntryDiff;

package/dist/editor/entry-diff.js

@@ -5,8 +5,8 @@
  * so a reordered item reads as moved, not as one removed and one added.
  */
 import { diffLines, diffWordsWithSpace } from 'diff';
-import equal from 'fast-deep-equal';
 import { ITEM_KEY } from '../item-keys.js';
+import { isEmptyValue as isEmpty, normalizedValue as normalized, sameValue, } from '../merge/value-equality.js';
 import { findBodyFieldName } from '../utils/body-field.js';
 import { isCalendarDay, localMidnight } from '../utils/calendar-day.js';
 import { flattenGroupFields } from '../utils/flatten-group-fields.js';
@@ -40,25 +40,6 @@ const formValue = (fields, side) => {
         return side.data;
     return { ...side.data, [side.bodyFieldName ?? findBodyFieldName(fields)]: side.body };
 };
-const isEmpty = (value) => value === undefined ||
-    value === null ||
-    value === '' ||
-    (Array.isArray(value) && value.length === 0) ||
-    (isPlainRecord(value) && Object.keys(value).every((k) => k === ITEM_KEY || isEmpty(value[k])));
-/** `value` without item keys and empty members, so equal content compares equal. */
-const normalized = (value) => {
-    if (Array.isArray(value))
-        return value.map(normalized);
-    if (!isPlainRecord(value))
-        return value;
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-        if (k !== ITEM_KEY && !isEmpty(v))
-            out[k] = normalized(v);
-    }
-    return out;
-};
-const sameValue = (a, b) => (isEmpty(a) && isEmpty(b)) || equal(normalized(a), normalized(b));
 const at = (parent, label, key, segment) => ({
     path: [...parent.path, label],
     key: parent.key ? `${parent.key}.${key}` : key,
@@ -505,7 +486,6 @@ const splitLines = (value) => {
  * text's spacing, so one side read back from its parts would not be the text it was.
  * Undefined once `deadline` (a `Date.now()`) passes: no line diff starts after it. A short word
  * diff runs until the later `wordDeadline`.
- * @internal Exported for tests.
  */
 export function textDiff(before, after, long = false, deadline = Date.now() + DIFF_TIMEOUT_MS, wordDeadline = Date.now() + SHORT_DIFF_TIMEOUT_MS) {
     // jsdiff restarts its clock on each call, so each is given only what is left of the budget.
@@ -593,6 +573,10 @@ const withContext = (lines) => {
     }
     return out;
 };
+/** `value` of `field` as the drawer shows it whole, for a value a conflict compares whole. */
+export function displayWhole(field, value, referenceTitle) {
+    return new Walker(referenceTitle, 0, 0).display(field, value);
+}
 /** The entry's changes between `before` and `after`, in schema order. */
 export function computeEntryDiff({ fields, before, after, referenceTitle, marks = true, }) {
     // One budget for the whole entry: see DIFF_TIMEOUT_MS and SHORT_DIFF_TIMEOUT_MS. Without

package/dist/editor/hooks/useBaseUpdate.d.ts

@@ -0,0 +1,36 @@
+import type { BranchListItem } from '../../api/branch.js';
+import type { OperatingMode } from '../../operating-mode/types.js';
+import { type BaseUpdateWait } from '../base-update-wait.js';
+export interface UseBaseUpdateOptions {
+    /** The open branch. */
+    branch: BranchListItem | undefined;
+    operatingMode: OperatingMode;
+    /** The user may take the branch's workflow actions, which asking for the latest changes is. */
+    permitted: boolean;
+    /** Entries with unsaved changes on the branch; asking waits until they are saved. */
+    unsavedCount: number;
+    /** Re-read the branch's entries and the open one, keeping drafts: the worker rewrote them. */
+    onUpdated: () => void;
+    /** Opens the branch's conflicts, offered by the toast of a merge that left some. */
+    onShowConflicts?: () => void;
+}
+export interface UseBaseUpdateReturn {
+    /** "Get latest changes" applies here: a worker answers, the branch is editing, the user may ask. */
+    available: boolean;
+    /** The open branch's wait; `waiting` makes its form read-only. */
+    wait: BaseUpdateWait;
+    /** The open branch's request itself is in flight. */
+    requesting: boolean;
+    /** Why it can't be asked now; undefined when it can. */
+    blockedReason?: string;
+    /** Asks for the open branch, unless unsaved changes hold it. */
+    request: () => Promise<void>;
+}
+/**
+ * "Get latest changes" for the open branch: asks, then re-reads the branch list while the branch
+ * waits, and reports the worker's answer in a toast once it lands. Only a wait this tab saw end
+ * reports, so a reload onto an answered request stays quiet. The wait is timed by the server's
+ * clock (server-clock.ts), and a request this tab made counts even when a listing fetched before
+ * it lands after it.
+ */
+export declare function useBaseUpdate(options: UseBaseUpdateOptions): UseBaseUpdateReturn;

package/dist/editor/hooks/useBaseUpdate.js

@@ -0,0 +1,269 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useSWRConfig } from 'swr';
+import { notifications } from '@mantine/notifications';
+import { clientOperatingStrategy } from '../../operating-mode/client.js';
+import { isBaseUpdatePending } from '../../base-update.js';
+import { useApiClient } from '../context/index.js';
+import { getErrorMessage } from '../../utils/error.js';
+import { BRANCHES_KEY } from './useBranchesData.js';
+import { RetryToastMessage } from '../components/RetryToastMessage.js';
+import { EDITOR_ACTIONS } from '../copy.js';
+import { GAVE_UP_MESSAGE, REQUEST_FAILED_MESSAGE, SAVE_FIRST_REASON, UNANSWERED_MESSAGE, baseUpdatePollMs, baseUpdateResultMessage, baseUpdateWait, nextBaseUpdateWaitChange, } from '../base-update-wait.js';
+import { serverNow } from '../server-clock.js';
+import { UnansweredError, isGatewayFailure, isUnanswered } from '../unanswered.js';
+const RESULT_TOAST_ID = 'canopy-base-update-result';
+/** Writes the branch a request answered into the listing, so its wait shows at once. */
+function withBranch(data, branch) {
+    if (!data)
+        return data;
+    return { ...data, branches: data.branches.map((b) => (b.name === branch.name ? branch : b)) };
+}
+/** Whether `a` is a later request time than `b`, an absent one being earliest. */
+const laterThan = (a, b) => b === undefined || Date.parse(a) > Date.parse(b);
+const sameBranch = (branch, record) => record?.name === branch.name && record.createdAt === branch.createdAt;
+/** The listed branch, carrying this tab's newer request. */
+function withAsked(branch, asked) {
+    if (!branch || !sameBranch(branch, asked))
+        return branch;
+    return laterThan(asked.requestedAt, branch.baseUpdateRequestedAt)
+        ? { ...branch, baseUpdateRequestedAt: asked.requestedAt }
+        : branch;
+}
+/** The branch, carrying the answer this tab already reported when the listing hasn't caught up. */
+function withSettled(branch, settled) {
+    if (!branch || !sameBranch(branch, settled) || !isBaseUpdatePending(branch))
+        return branch;
+    return laterThan(branch.baseUpdateRequestedAt ?? '', settled.requestedAt) &&
+        branch.baseUpdateRequestedAt !== undefined
+        ? branch
+        : {
+            ...branch,
+            baseUpdateRequestedAt: settled.requestedAt,
+            lastBaseUpdate: settled.lastBaseUpdate,
+        };
+}
+/**
+ * A toast in the one slot this hook uses, replacing what it showed before. `onAction` offers
+ * Retry, or `actionLabel`.
+ */
+function showResult(color, message, onAction, actionLabel) {
+    notifications.hide(RESULT_TOAST_ID);
+    notifications.show({
+        id: RESULT_TOAST_ID,
+        color,
+        autoClose: color === 'green' ? undefined : false,
+        message: onAction ? (_jsx(RetryToastMessage, { message: message, onRetry: onAction, actionLabel: actionLabel })) : (message),
+    });
+}
+/**
+ * "Get latest changes" for the open branch: asks, then re-reads the branch list while the branch
+ * waits, and reports the worker's answer in a toast once it lands. Only a wait this tab saw end
+ * reports, so a reload onto an answered request stays quiet. The wait is timed by the server's
+ * clock (server-clock.ts), and a request this tab made counts even when a listing fetched before
+ * it lands after it.
+ */
+export function useBaseUpdate(options) {
+    const { operatingMode, permitted, unsavedCount, onUpdated } = options;
+    const apiClient = useApiClient();
+    const { mutate } = useSWRConfig();
+    const [requestingFor, setRequestingFor] = useState(null);
+    // The last request this tab made, by branch, which a listing that predates it can't undo.
+    const [asked, setAsked] = useState(null);
+    // The last answer this tab reported, by branch, which a listing that predates it can't undo:
+    // another host can serve the branch list from an older snapshot.
+    const [settled, setSettled] = useState(null);
+    const [, setTick] = useState(0);
+    const listed = options.branch;
+    const name = listed?.name;
+    const branch = withSettled(withAsked(listed, asked), settled);
+    const available = !!branch &&
+        clientOperatingStrategy(operatingMode).syncsBranchesWithBase() &&
+        branch.status === 'editing' &&
+        branch.isProtected === false &&
+        permitted;
+    const wait = baseUpdateWait(branch, serverNow());
+    const requestedAt = branch?.baseUpdateRequestedAt;
+    const answer = branch?.lastBaseUpdate;
+    const status = branch?.status;
+    const createdAt = branch?.createdAt;
+    // The wait changes on its own at the slow and give-up marks; nothing else would re-render then.
+    const changeAt = nextBaseUpdateWaitChange(branch, serverNow());
+    useEffect(() => {
+        if (changeAt === undefined)
+            return;
+        const timer = setTimeout(() => setTick((n) => n + 1), Math.max(0, changeAt - serverNow()) + 50);
+        return () => clearTimeout(timer);
+    }, [changeAt]);
+    // Re-read the listing while the branch waits, on a timer of its own: SWR stops polling a key
+    // whose last fetch failed, and one failed read must not end the wait. Each read starts only once
+    // the last has settled, since SWR drops an in-flight read's result when another starts.
+    const pollMs = baseUpdatePollMs(wait);
+    useEffect(() => {
+        if (pollMs === 0)
+            return;
+        let stopped = false;
+        let timer;
+        const next = () => {
+            timer = setTimeout(async () => {
+                if (typeof document === 'undefined' || document.visibilityState !== 'hidden') {
+                    await mutate(BRANCHES_KEY).catch(() => undefined);
+                }
+                if (!stopped)
+                    next();
+            }, pollMs);
+        };
+        next();
+        return () => {
+            stopped = true;
+            clearTimeout(timer);
+        };
+    }, [pollMs, mutate]);
+    const latest = useRef({ name, unsavedCount, available });
+    latest.current = { name, unsavedCount, available };
+    const onUpdatedRef = useRef(onUpdated);
+    onUpdatedRef.current = onUpdated;
+    const onShowConflictsRef = useRef(options.onShowConflicts);
+    onShowConflictsRef.current = options.onShowConflicts;
+    const requestRef = useRef(async () => { });
+    // Stable, and reads only refs, so the toasts that carry it keep working.
+    const retry = useCallback(() => {
+        notifications.hide(RESULT_TOAST_ID);
+        void requestRef.current();
+    }, []);
+    const report = useCallback((on, result) => {
+        setSettled({ ...on, lastBaseUpdate: result });
+        if (result.outcome !== 'failed')
+            onUpdatedRef.current();
+        if (result.outcome === 'conflicts') {
+            // The toast counts the choices left, which the branch's conflicts hold.
+            void apiClient.conflicts
+                .list({ branch: on.name })
+                .then((answer) => (answer.ok ? answer.data?.openCount : undefined))
+                .catch(() => undefined)
+                .then((count) => {
+                if (latest.current.name !== on.name)
+                    return;
+                const { color, message } = baseUpdateResultMessage(result, count);
+                const show = () => {
+                    notifications.hide(RESULT_TOAST_ID);
+                    onShowConflictsRef.current?.();
+                };
+                showResult(color, message, onShowConflictsRef.current && count !== 0 ? show : undefined, EDITOR_ACTIONS.showChanges);
+            });
+            return;
+        }
+        const { color, message } = baseUpdateResultMessage(result);
+        // Retry only for someone who may ask; another viewer just learns how it went.
+        const canRetry = result.outcome === 'failed' && latest.current.available;
+        showResult(color, message, canRetry ? retry : undefined);
+    }, [apiClient, retry]);
+    // A result is about the branch it came from: switching away closes it.
+    useEffect(() => () => {
+        notifications.hide(RESULT_TOAST_ID);
+    }, [name]);
+    // A wait this tab saw, by branch and request, reports when its answer lands, even after the
+    // editor stopped waiting on it; giving up says so, once.
+    const watched = useRef(undefined);
+    useEffect(() => {
+        if (!name || !requestedAt)
+            return;
+        const seen = watched.current;
+        const same = seen?.name === name && seen.requestedAt === requestedAt;
+        if (wait !== 'none') {
+            if (!same)
+                watched.current = { name, requestedAt, gaveUp: false };
+            return;
+        }
+        if (!seen || !same)
+            return;
+        if (answer &&
+            !isBaseUpdatePending({ baseUpdateRequestedAt: requestedAt, lastBaseUpdate: answer })) {
+            watched.current = undefined;
+            report({ name, createdAt: createdAt ?? '', requestedAt }, answer);
+        }
+        else if (!seen.gaveUp && status === 'editing') {
+            seen.gaveUp = true;
+            showResult('yellow', GAVE_UP_MESSAGE);
+        }
+    }, [name, createdAt, requestedAt, answer, wait, status, report]);
+    const request = useCallback(async () => {
+        const target = latest.current.name;
+        if (!target)
+            return;
+        if (latest.current.unsavedCount > 0) {
+            showResult('yellow', SAVE_FIRST_REASON);
+            return;
+        }
+        // What lands after the user moved to another branch is about that one, not this.
+        const stillOpen = () => latest.current.name === target;
+        setRequestingFor(target);
+        try {
+            try {
+                const result = await apiClient.workflow.updateFromBase({ branch: target });
+                if (isGatewayFailure(result))
+                    throw new UnansweredError();
+                if (result.ok && result.data) {
+                    const { branch: answered, requestedAt: at } = result.data;
+                    await mutate(BRANCHES_KEY, (data) => withBranch(data, answered), {
+                        revalidate: false,
+                    });
+                    if (!stillOpen())
+                        return;
+                    const on = { name: target, createdAt: answered.createdAt, requestedAt: at };
+                    setAsked(on);
+                    if (!isBaseUpdatePending(answered) && answered.lastBaseUpdate) {
+                        report(on, answered.lastBaseUpdate);
+                    }
+                    else {
+                        watched.current = { name: target, requestedAt: at, gaveUp: false };
+                    }
+                    return;
+                }
+                // A refusal can mean the branch moved on (submitted meanwhile): re-read it, and offer Retry
+                // only if it can still ask.
+                const fresh = await mutate(BRANCHES_KEY);
+                if (!stillOpen())
+                    return;
+                const now = fresh?.branches.find((b) => b.name === target);
+                const canRetry = now === undefined || now.status === 'editing';
+                showResult('red', result.error ?? REQUEST_FAILED_MESSAGE, canRetry ? retry : undefined);
+            }
+            catch (err) {
+                if (!isUnanswered(err))
+                    throw err;
+                // It may have gone through, and a reload that shows the wait settles it.
+                const fresh = await mutate(BRANCHES_KEY);
+                if (!stillOpen())
+                    return;
+                const reloaded = fresh?.branches.find((b) => b.name === target);
+                if (baseUpdateWait(reloaded, serverNow()) === 'none') {
+                    showResult('yellow', UNANSWERED_MESSAGE, retry);
+                }
+            }
+        }
+        catch (err) {
+            if (!stillOpen())
+                return;
+            notifications.hide(RESULT_TOAST_ID);
+            notifications.show({
+                id: RESULT_TOAST_ID,
+                color: 'red',
+                autoClose: false,
+                message: (_jsx(RetryToastMessage, { message: REQUEST_FAILED_MESSAGE, onRetry: retry, details: getErrorMessage(err) })),
+            });
+        }
+        finally {
+            setRequestingFor((current) => (current === target ? null : current));
+        }
+    }, [apiClient, mutate, report, retry]);
+    requestRef.current = request;
+    return {
+        available,
+        wait,
+        requesting: !!name && requestingFor === name,
+        blockedReason: unsavedCount > 0 ? SAVE_FIRST_REASON : undefined,
+        request,
+    };
+}