canopycms 0.12.0 → 0.13.0

package/dist/editor/conflict-cards.js

@@ -0,0 +1,284 @@
+/**
+ * The cards "Show changes" shows for an entry's open conflicts, built from what
+ * `GET /:branch/conflicts/...entryPath` answers (api/merge-conflicts.ts): each place's three
+ * versions as the drawer shows values, and long text split into the regions both sides changed.
+ * Pure. Where a choice lands in the form value is `conflict-choices.ts`.
+ */
+import equal from 'fast-deep-equal';
+import { LOCATION_CONFLICT_KEY } from '../merge/conflict-path.js';
+import { mergeText } from '../merge/text-merge.js';
+import { computeEntryDiff, displayWhole, textDiff, } from './entry-diff.js';
+import { flattenGroupFields } from '../utils/flatten-group-fields.js';
+import { humanizeName, schemaLabel } from './schema-label.js';
+import { formValueOfSide, valueAtChange } from './undo-change.js';
+import { ITEM_KEY } from '../item-keys.js';
+import { isPlainRecord } from '../validation/field-traversal.js';
+const EMPTY = { kind: 'empty' };
+/** The version a blob id names; undefined when it can't be shown. */
+const versionOf = (versions, sha) => {
+    if (sha === undefined)
+        return null;
+    const side = versions[sha];
+    return side === undefined || 'unavailable' in side ? undefined : side;
+};
+/**
+ * `version` with its list items along `from`, its own path to a conflict's place, keyed as `to`,
+ * the merged path, names them, so `to` finds the value in it: an item of a list a side left keyless
+ * reads there with a key of its own content (api/merge-conflicts.ts `EntryConflictField.sidePaths`).
+ * Unchanged where there is no `from` or it is `to`. Undefined, as a version that can't be shown,
+ * where the two paths don't run alike or a key `to` names is another item's in that list: the
+ * merged path would find that item there.
+ */
+const alignedTo = (version, from, to) => {
+    if (!version || !from || equal(from, to))
+        return version;
+    // A path one step short of an item names the list of a version without that item.
+    const last = to.at(-1);
+    const missing = from.length === to.length - 1 && last !== undefined && 'item' in last ? last.item : undefined;
+    if (missing === undefined && from.length !== to.length)
+        return undefined;
+    const data = structuredClone(version.data);
+    let node = data;
+    for (const [i, segment] of from.entries()) {
+        const target = to[i];
+        if ('field' in segment) {
+            if (!('field' in target) || target.field !== segment.field)
+                return undefined;
+            node = isPlainRecord(node) ? node[segment.field] : undefined;
+        }
+        else if ('blockData' in segment) {
+            if (!('blockData' in target))
+                return undefined;
+            node = isPlainRecord(node) ? (isPlainRecord(node.value) ? node.value : node) : undefined;
+        }
+        else {
+            if (!('item' in target) || !Array.isArray(node))
+                return undefined;
+            const keyed = (key) => node.find((x) => isPlainRecord(x) && x[ITEM_KEY] === key);
+            const item = keyed(segment.item);
+            if (!isPlainRecord(item))
+                return undefined;
+            if (target.item !== segment.item) {
+                if (keyed(target.item) !== undefined)
+                    return undefined;
+                item[ITEM_KEY] = target.item;
+            }
+            node = item;
+        }
+    }
+    if (missing !== undefined) {
+        // Another item there holding the key `to` names would be found as it: it takes another key.
+        if (!Array.isArray(node))
+            return undefined;
+        const other = node.find((x) => isPlainRecord(x) && x[ITEM_KEY] === missing);
+        if (isPlainRecord(other))
+            other[ITEM_KEY] = `${missing}~other`;
+    }
+    return { ...version, data };
+};
+/** A diff's changes by key, a whole entry missing on a side giving none. */
+const changesByKey = (fields, before, after, referenceTitle) => {
+    if (!before || !after)
+        return new Map();
+    const { changes } = computeEntryDiff({ fields, before, after, referenceTitle });
+    return new Map(changes.map((change) => [change.key, change]));
+};
+/**
+ * The schema field a data path ends at, and the labels of the fields on the way, for a conflict no
+ * change of the drawer names: one the merge compared whole, such as a list it had no schema for.
+ * A block's data has no one field set, so the walk stops there.
+ */
+const fieldAlong = (fields, dataPath) => {
+    let scope = fields;
+    let field;
+    const path = [];
+    for (const segment of dataPath) {
+        if ('field' in segment) {
+            field = scope && flattenGroupFields(scope).find((f) => f.name === segment.field);
+            path.push(field ? schemaLabel(field) : humanizeName(segment.field));
+            scope = field?.type === 'object' ? field.fields : undefined;
+        }
+        else if ('item' in segment) {
+            field = field && 'list' in field && field.list ? { ...field, list: false } : undefined;
+        }
+        else {
+            return { path };
+        }
+    }
+    return { field, path };
+};
+/** A string at `dataPath` in a version, as the form holds it. */
+const textAt = (version, dataPath, bodyField) => {
+    if (!version)
+        return version === null ? '' : undefined;
+    const value = valueAtChange(formValueOfSide(version), { dataPath }, bodyField);
+    return typeof value === 'string' ? value : value === undefined ? '' : undefined;
+};
+/**
+ * The cards for one entry's open field conflicts. `bodyField` is the schema's body field on an
+ * md/mdx entry. Each version the cards compare is diffed once per pair, however many fields share it.
+ */
+export function buildEntryConflicts(data, fields, bodyField, referenceTitle, saved) {
+    const diffs = new Map();
+    const diff = (from, to) => {
+        const id = `${from ?? '-'}>${to ?? '-'}`;
+        let found = diffs.get(id);
+        if (!found) {
+            found = changesByKey(fields, versionOf(data.versions, from), versionOf(data.versions, to), referenceTitle);
+            diffs.set(id, found);
+        }
+        return found;
+    };
+    let incomplete = false;
+    const out = data.fields.map((field) => {
+        const { ancestor, base, branch } = field.sides;
+        const read = {
+            before: versionOf(data.versions, ancestor),
+            latest: versionOf(data.versions, base),
+            yours: versionOf(data.versions, branch),
+        };
+        if (Object.values(read).some((v) => v === undefined))
+            incomplete = true;
+        // Each version keyed as the merge named this place, so the one data path finds it in all three.
+        const versions = {
+            before: alignedTo(read.before, field.sidePaths.ancestor, field.dataPath),
+            latest: alignedTo(read.latest, field.sidePaths.base, field.dataPath),
+            yours: alignedTo(read.yours, field.sidePaths.branch, field.dataPath),
+        };
+        const realigned = ['before', 'latest', 'yours'].some((v) => versions[v] !== read[v]);
+        if (Object.values(versions).some((v) => v === undefined))
+            incomplete = true;
+        const latest = versions.latest ? formValueOfSide(versions.latest) : undefined;
+        // Your saved value where a save since the merge changed it, which is what keeping yours keeps:
+        // the branch's version is only how it read at the merge.
+        const savedHere = saved && valueAtChange(saved, { dataPath: field.dataPath }, bodyField);
+        const branchHere = versions.yours &&
+            valueAtChange(formValueOfSide(versions.yours), { dataPath: field.dataPath }, bodyField);
+        // A save can give a look-alike the key of an item your version lacks once it is gone: a choice
+        // here would land on that other item.
+        const otherItemHere = field.item && !!versions.yours && branchHere === undefined && savedHere !== undefined;
+        const latestFound = !!latest &&
+            field.dataPath.every((segment, i) => !('item' in segment) ||
+                (field.item && field.kind === 'removed-on-base' && i === field.dataPath.length - 1) ||
+                valueAtChange(latest, { dataPath: field.dataPath.slice(0, i + 1) }, bodyField) !==
+                    undefined);
+        const latestPlaceable = latestFound && !otherItemHere;
+        const common = {
+            key: field.key,
+            mergeSha: field.mergeSha,
+            dataPath: field.dataPath,
+            item: !!field.item,
+            latestPlaceable,
+            ...(otherItemHere && { otherItemHere: true }),
+            ...(latest && { latest }),
+        };
+        const card = { key: field.key, mergeSha: field.mergeSha };
+        if (field.key === LOCATION_CONFLICT_KEY) {
+            return { ...common, cards: [{ ...card, id: field.key, type: 'location', path: [] }] };
+        }
+        // A realigned version is this field's own, so its diffs are too.
+        const pair = (from, to, fromSha, toSha) => (realigned ? changesByKey(fields, from, to, referenceTitle) : diff(fromSha, toSha));
+        const toLatest = pair(versions.before, versions.latest, ancestor, base);
+        const toYours = pair(versions.before, versions.yours, ancestor, branch);
+        const between = pair(versions.latest, versions.yours, base, branch);
+        const named = toLatest.get(field.drawerKey) ?? toYours.get(field.drawerKey);
+        const along = fieldAlong(fields, field.dataPath);
+        const path = named?.path ?? between.get(field.drawerKey)?.path ?? along.path;
+        const savedYours = saved && !otherItemHere && !equal(savedHere, branchHere)
+            ? displayWhole(along.field, savedHere, referenceTitle)
+            : undefined;
+        const savedMarks = (before) => savedYours && before.kind === 'text' && savedYours.kind === 'text'
+            ? textDiff(before.text, savedYours.text)
+            : undefined;
+        if (field.text) {
+            const texts = [versions.before, versions.latest, versions.yours].map((v) => textAt(v, field.dataPath, bodyField));
+            const [o, a, b] = texts;
+            const merged = latestPlaceable && o !== undefined && a !== undefined && b !== undefined
+                ? mergeText(o, a, b)
+                : undefined;
+            // Regions place their lines in the text the merge left, so they apply only while your saved
+            // text is that text: not once you saved since, nor where the merge kept your text whole.
+            const regionsApply = !!merged &&
+                merged.regions.length > 0 &&
+                (saved === undefined ||
+                    valueAtChange(saved, { dataPath: field.dataPath }, bodyField) === merged.text);
+            if (merged && regionsApply) {
+                return {
+                    ...common,
+                    text: { merged: merged.text, regions: merged.regions },
+                    cards: merged.regions.map((region, index) => ({
+                        ...card,
+                        id: `${field.key}#${index}`,
+                        type: 'region',
+                        path,
+                        index,
+                        count: merged.regions.length,
+                        before: region.ancestor,
+                        latest: region.base,
+                        yours: region.branch,
+                        latestText: textDiff(region.ancestor, region.base, true),
+                        yoursText: textDiff(region.ancestor, region.branch, true),
+                    })),
+                };
+            }
+        }
+        const fromLatest = toLatest.get(field.drawerKey);
+        const fromYours = toYours.get(field.drawerKey);
+        const across = between.get(field.drawerKey);
+        if (!fromLatest && !fromYours && !across) {
+            // No change of the drawer is at this place: the merge compared it whole, so it shows whole.
+            const whole = (version) => version
+                ? displayWhole(along.field, valueAtChange(formValueOfSide(version), { dataPath: field.dataPath }, bodyField), referenceTitle)
+                : EMPTY;
+            const [before, latestValue, yoursValue] = [
+                versions.before,
+                versions.latest,
+                versions.yours,
+            ].map(whole);
+            const marks = (to) => before.kind === 'text' && to.kind === 'text' ? textDiff(before.text, to.text) : undefined;
+            const latestText = marks(latestValue);
+            const yoursText = savedYours ? savedMarks(before) : marks(yoursValue);
+            return {
+                ...common,
+                cards: [
+                    {
+                        ...card,
+                        id: field.key,
+                        type: 'value',
+                        conflict: field.kind,
+                        item: !!field.item,
+                        path,
+                        before,
+                        latest: latestValue,
+                        ...(!latestFound && { latestUnavailable: true }),
+                        yours: savedYours ?? yoursValue,
+                        ...(latestText && { latestText }),
+                        ...(yoursText && { yoursText }),
+                    },
+                ],
+            };
+        }
+        const before = fromLatest?.before ?? fromYours?.before ?? EMPTY;
+        const yoursText = savedYours ? savedMarks(before) : fromYours?.text;
+        return {
+            ...common,
+            cards: [
+                {
+                    ...card,
+                    id: field.key,
+                    type: 'value',
+                    conflict: field.kind,
+                    item: !!field.item,
+                    path,
+                    before,
+                    latest: fromLatest ? (fromLatest.after ?? EMPTY) : (across?.before ?? EMPTY),
+                    ...(!latestFound && { latestUnavailable: true }),
+                    yours: savedYours ?? (fromYours ? (fromYours.after ?? EMPTY) : (across?.after ?? EMPTY)),
+                    ...(fromLatest?.text && { latestText: fromLatest.text }),
+                    ...(yoursText && { yoursText }),
+                },
+            ],
+        };
+    });
+    return { fields: out, incomplete };
+}

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