canopycms 0.12.1 → 0.13.0

package/dist/editor/hooks/useBranchManager.js

@@ -33,6 +33,13 @@ class StaleStatusError extends Error {
         this.name = 'StaleStatusError';
     }
 }
+/** The API's `BRANCH_MOVED`: the branch's head isn't the one the reviewer's page was pinned to. */
+class BranchMovedError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'BranchMovedError';
+    }
+}
 /** An answer that refused the action, with its HTTP status: a 4xx is a refusal no retry passes. */
 class RefusedError extends Error {
     constructor(message, status) {
@@ -51,6 +58,8 @@ function actionError(result, fallback, staleIsConflict = false) {
     const message = result.error || fallback;
     if (result.ok)
         return new Error(message);
+    if (result.code === 'BRANCH_MOVED')
+        return new BranchMovedError(message);
     // Open conflicts refuse the action where the branch still is, so they are no stale status.
     return staleIsConflict &&
         result.status === 409 &&
@@ -478,6 +487,52 @@ export function useBranchManager(options) {
     // these at confirm time rather than from that render's closure.
     const latest = useRef({ branchName, resolved, branches, branchesData });
     latest.current = { branchName, resolved, branches, branchesData };
+    // The head a review sends, never newer than what the page shows of the branch. One not shown
+    // follows each listing; opening one, a head listed for the open one while its pin is null, and a
+    // refusal's recovery pin it from a listing already fetched once its content is read again.
+    const reviewPins = useRef(new Map());
+    const shown = useRef(new Set());
+    const pinning = useRef(new Map());
+    const lastOpen = useRef(undefined);
+    const pinThenReread = async (branch, data) => {
+        const headSha = data?.branches.find((b) => b.name === branch)?.headSha;
+        const claim = Symbol(branch);
+        pinning.current.set(branch, claim);
+        reviewPins.current.set(branch, null);
+        try {
+            if (headSha)
+                await options.onReviewPinned?.(branch);
+            // A failed read leaves it null, for the next listing to try again.
+            if (pinning.current.get(branch) === claim)
+                reviewPins.current.set(branch, headSha ?? null);
+        }
+        finally {
+            if (pinning.current.get(branch) === claim)
+                pinning.current.delete(branch);
+        }
+    };
+    useEffect(() => {
+        const listed = branchesData?.branches ?? [];
+        for (const b of listed) {
+            if (!shown.current.has(b.name))
+                reviewPins.current.set(b.name, b.headSha ?? null);
+        }
+        const open = currentBranchName && listed.find((b) => b.name === currentBranchName);
+        if (!open)
+            return;
+        const firstHead = open.headSha && reviewPins.current.get(open.name) === null && !pinning.current.has(open.name);
+        // Coming back to a branch opens it again: its entries are read afresh, so its pin is too.
+        const reopened = lastOpen.current !== open.name;
+        lastOpen.current = open.name;
+        if (!shown.current.has(open.name) || firstHead || reopened) {
+            shown.current.add(open.name);
+            pinThenReread(open.name, branchesData).catch(console.error);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- `pinThenReread` reads only refs and options
+    }, [branchesData, currentBranchName]);
+    const reviewedHead = (branch) => ({
+        headSha: reviewPins.current.get(branch) ?? undefined,
+    });
     // A card, deep link or URL can carry a short name, an exact form or the raw form of a listed
     // name; the actions resolve it once, the way an arriving name resolves, then key, look up and
     // send the listed name.
@@ -588,6 +643,11 @@ export function useBranchManager(options) {
         }
     };
     const reviewFailureId = (kind, branch) => `canopy-${kind}-failed-${branch}`;
+    /** A verdict that went through answers either kind's refusal. */
+    const hideReviewFailures = (branch) => {
+        notifications.hide(reviewFailureId('approve', branch));
+        notifications.hide(reviewFailureId('request-changes', branch));
+    };
     const submitRefusedId = (branch) => `canopy-submit-refused-${branch}`;
     const deleteRefusedId = (branch) => `canopy-delete-refused-${branch}`;
     /**
@@ -597,6 +657,22 @@ export function useBranchManager(options) {
      * submit didn't finish (see `showLeftReview`, which shows the server's reason either way).
      */
     const reportReviewFailure = async (err, kind, branch, details) => {
+        if (err instanceof BranchMovedError) {
+            // A listing that fails, or leaves the branch out, pins none for now.
+            void pinThenReread(branch, await reloadBranches()).catch(console.error);
+            const id = reviewFailureId(kind, branch);
+            notifications.hide(id);
+            notifications.show({
+                id,
+                message: details.note
+                    ? `${err.message} Your note is kept for when you request changes again.`
+                    : err.message,
+                color: 'yellow',
+                autoClose: false,
+                withCloseButton: true,
+            });
+            return;
+        }
         if (err instanceof StaleStatusError) {
             showLeftReview(branch, err.message, details.note);
             // What the branch is now decides whether a Request changes note is still wanted.
@@ -808,12 +884,10 @@ export function useBranchManager(options) {
             showApproveConfirmation(shownName(branchNameToApprove), pullRequestOf(branchNameToApprove), async () => {
                 options.setBusy(true);
                 try {
-                    const result = await apiClient.workflow.approve({
-                        branch: sendName(branchNameToApprove),
-                    });
+                    const result = await apiClient.workflow.approve({ branch: sendName(branchNameToApprove) }, reviewedHead(branchNameToApprove));
                     if (!result.ok)
                         throw actionError(result, 'Failed to approve branch', true);
-                    notifications.hide(reviewFailureId('approve', branchNameToApprove));
+                    hideReviewFailures(branchNameToApprove);
                     notifications.show({ message: 'Branch approved', color: 'green' });
                     updateCreatedBranch(branchNameToApprove, result.data?.branch);
                     await loadBranches();
@@ -846,11 +920,11 @@ export function useBranchManager(options) {
             }, async (note) => {
                 options.setBusy(true);
                 try {
-                    const result = await apiClient.workflow.requestChanges({ branch: sendName(branchNameForChanges) }, { note: note.trim() || undefined });
+                    const result = await apiClient.workflow.requestChanges({ branch: sendName(branchNameForChanges) }, { note: note.trim() || undefined, ...reviewedHead(branchNameForChanges) });
                     if (!result.ok)
                         throw actionError(result, 'Failed to request changes', true);
                     noteDrafts.current.delete(branchNameForChanges);
-                    notifications.hide(reviewFailureId('request-changes', branchNameForChanges));
+                    hideReviewFailures(branchNameForChanges);
                     notifications.show({ message: 'Changes requested', color: 'blue' });
                     // The note is saved apart from the status change, so it can fail on its own;
                     // the warning stays up, with the note to copy, because the words are not saved.

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

@@ -25,7 +25,7 @@ export interface UseDraftManagerOptions {
     currentEntry: EditorEntry | undefined;
     entries: EditorEntry[];
     initialValues?: Record<string, FormValue>;
-    loadEntry: (entry: EditorEntry) => Promise<FormValue>;
+    loadEntry: (entry: EditorEntry, isCurrent?: () => boolean) => Promise<FormValue>;
     /**
      * Server read that records no OCC token (useEntryManager's `readEntryValue`),
      * for checking restored drafts of unopened entries. Without it they stay
@@ -79,6 +79,13 @@ export interface UseDraftManagerReturn {
     setDrafts: React.Dispatch<React.SetStateAction<Record<string, FormValue>>>;
     loadedValues: Record<string, FormValue>;
     setLoadedValues: React.Dispatch<React.SetStateAction<Record<string, FormValue>>>;
+    /**
+     * Drops the saved copies `keep` doesn't name, so each is read again; a read already in flight
+     * then lands nothing, as it can predate the head the branch is pinned to.
+     */
+    forgetLoadedValues: (keep: (contentId: string) => boolean) => void;
+    /** Bumped by {@link forgetLoadedValues}: a read whose generation is gone writes nothing. */
+    readGeneration: React.MutableRefObject<number>;
     selectedValue: FormValue | undefined;
     loadedValue: FormValue | undefined;
     effectiveValue: FormValue | undefined;

package/dist/editor/hooks/useDraftManager.js

@@ -100,6 +100,11 @@ const VERIFY_WAIT_CAP_MS = 3000;
 export function useDraftManager(options) {
     const [drafts, setDrafts] = useState(() => options.initialValues ?? {});
     const [loadedValues, setLoadedValues] = useState({});
+    const readGeneration = useRef(0);
+    const forgetLoadedValues = (keep) => {
+        readGeneration.current += 1;
+        setLoadedValues((prev) => Object.fromEntries(Object.entries(prev).filter(([id]) => keep(id))));
+    };
     // Per-field validation errors from a blocked/rejected save (ED-H1), keyed by
     // the entry they belong to. Keying by entry id — and deriving the exposed
     // `fieldErrors` map below instead of clearing it in a separate effect after
@@ -1275,9 +1280,17 @@ export function useDraftManager(options) {
         if (!options.currentEntry || !currentId)
             return;
         const branch = options.branchName;
+        const entry = options.currentEntry;
         options.setBusy(true);
         try {
-            const loaded = await options.loadEntry(options.currentEntry);
+            // A read the branch's re-read overtakes is read again, as the reload was asked for.
+            let loaded;
+            let generation;
+            do {
+                generation = readGeneration.current;
+                const read = generation;
+                loaded = await options.loadEntry(entry, () => readGeneration.current === read);
+            } while (readGeneration.current !== generation);
             // Content ids repeat across branches; the next branch's state is not this read's.
             if (latestOptionsRef.current.branchName !== branch)
                 return;
@@ -1454,6 +1467,8 @@ export function useDraftManager(options) {
         setDrafts,
         loadedValues,
         setLoadedValues,
+        forgetLoadedValues,
+        readGeneration,
         selectedValue,
         loadedValue,
         effectiveValue,

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

@@ -72,6 +72,10 @@ export interface UseEntryManagerOptions {
         onSaved: (branch: string, contentId: string, sent: ResolvedFieldConflict[], cleared: ResolvedFieldConflict[]) => void;
     };
 }
+/** `withChanges: false` leaves the branch's changes to the caller, who reads them itself. */
+interface RefreshOptions {
+    withChanges?: boolean;
+}
 export interface UseEntryManagerReturn {
     selectedPath: string;
     /** Opens an entry the user chose, adding a history entry, so Back returns to the one before. */
@@ -95,15 +99,16 @@ export interface UseEntryManagerReturn {
     entriesLoadFailed: boolean;
     navigatorOpen: boolean;
     setNavigatorOpen: (open: boolean) => void;
-    refreshEntries: (branch?: string) => Promise<EditorEntry[]>;
+    refreshEntries: (branch?: string, refresh?: RefreshOptions) => Promise<EditorEntry[]>;
     /** `refreshEntries`, resolving to the collections it read too. */
-    refreshContent: (branch?: string) => Promise<{
+    refreshContent: (branch?: string, refresh?: RefreshOptions) => Promise<{
         entries: EditorEntry[];
         collections: EditorCollection[];
     }>;
     handleCreateEntry: (collectionPath: LogicalPath, entryTypeName?: string) => Promise<void>;
     renameEntry: (path: string, newSlug: string) => Promise<void>;
-    loadEntry: (entry: EditorEntry) => Promise<FormValue>;
+    /** `isCurrent`, asked once the read lands, says whether to record its OCC token. */
+    loadEntry: (entry: EditorEntry, isCurrent?: () => boolean) => Promise<FormValue>;
     /** Reads an entry's server value without recording the OCC token that `loadEntry` records. */
     readEntryValue: (entry: EditorEntry) => Promise<FormValue>;
     saveEntry: (entry: EditorEntry, value: FormValue) => Promise<FormValue>;

package/dist/editor/hooks/useEntryManager.js

@@ -293,14 +293,14 @@ export function useEntryManager(options) {
         }
         return result.data;
     };
-    const loadEntry = async (entry) => {
+    const loadEntry = async (entry, isCurrent = () => true) => {
         // Pin the branch this request targets: if the user switches branches
         // while the read is in flight, the token must be recorded under the
         // branch that actually served it, not the current one.
         const requestBranch = options.branchName;
         const data = await readEntryPayload(entry, requestBranch);
         // Capture OCC version token for next save
-        if (entry.contentId && typeof data?.version === 'number') {
+        if (entry.contentId && typeof data?.version === 'number' && isCurrent()) {
             entryVersionsRef.current.set(versionKey(requestBranch, entry.contentId), data.version);
         }
         return normalizeContentPayload(data);
@@ -459,10 +459,11 @@ export function useEntryManager(options) {
     // refreshSeqRef doc comment above; also warms the SWR cache for `branch`
     // so a later automatic re-fetch of the same key (e.g. switching away and
     // back) can reuse it instead of refetching.
-    const refreshContent = async (branch = options.branchName) => {
+    const refreshContent = async (branch = options.branchName, { withChanges = true } = {}) => {
         if (!branch)
             return { entries: [], collections: [] };
-        options.onContentRefresh?.(branch);
+        if (withChanges)
+            options.onContentRefresh?.(branch);
         const seq = claimRefreshSeq(branch);
         const fetched = await fetchEntriesAndSchema(apiClient, branch, {
             resolvePreviewSrc: options.resolvePreviewSrc,
@@ -482,7 +483,7 @@ export function useEntryManager(options) {
         }
         return fetched;
     };
-    const refreshEntries = async (branch = options.branchName) => (await refreshContent(branch)).entries;
+    const refreshEntries = async (branch = options.branchName, refresh) => (await refreshContent(branch, refresh)).entries;
     const handleCreateEntry = async (collectionPath, _) => {
         const col = collectionByPath.get(collectionPath);
         if (!col || col.type === 'entry') {

package/dist/git-manager.d.ts

@@ -574,6 +574,7 @@ export declare class GitManager {
     ensureRemote(remoteUrl: string): Promise<void>;
     hasUncommittedChanges(): Promise<boolean>;
     getUncommittedFiles(): Promise<string[]>;
+    /** The remote's URL as configured; `git remote -v`'s listing would split a path with a space. */
     getRemoteUrl(): Promise<string | undefined>;
     /**
      * Excludes `pattern` (e.g. `.canopy-meta/`) from this workspace's git, so it

package/dist/git-manager.js

@@ -1849,10 +1849,15 @@ export class GitManager {
         const status = await this.status();
         return status.files.map((f) => f.path);
     }
+    /** The remote's URL as configured; `git remote -v`'s listing would split a path with a space. */
     async getRemoteUrl() {
-        const remotes = await this.git.getRemotes(true);
-        const remote = remotes.find((r) => r.name === this.remote);
-        return remote?.refs.push || remote?.refs.fetch;
+        try {
+            const url = (await this.git.raw(['remote', 'get-url', this.remote])).trim();
+            return url === '' ? undefined : url;
+        }
+        catch {
+            return undefined;
+        }
     }
     /**
      * Excludes `pattern` (e.g. `.canopy-meta/`) from this workspace's git, so it

package/dist/merge/entry-merge.js

@@ -400,11 +400,12 @@ function mergeList(o, a, b, at, walk, namedBy) {
 }
 function identifyByKey(O, a, b, inEntry, moved) {
     const oKeys = itemKeysAsRead(O).map((key, i) => key ?? `${i}`);
-    const aligned = alignToAncestor(a, O, oKeys, 'a', inEntry, moved.a);
-    const bAligned = alignToAncestor(b, O, oKeys, 'b', inEntry, moved.b);
+    const aligned = alignToAncestor(a, O, oKeys, 'a', inEntry, moved.a, b);
+    const bAligned = alignToAncestor(b, O, oKeys, 'b', inEntry, moved.b, a);
     if (!aligned || !bAligned)
         return undefined;
-    pairNewItems(a, aligned.ids, b, bAligned.ids);
+    const known = new Set(oKeys);
+    pairNewItems(a, aligned.ids, b, bAligned.ids, (key) => inEntry.has(key) && !known.has(key));
     return {
         oKeys,
         aIds: aligned.ids,

package/dist/merge/list-alignment.d.ts

@@ -23,26 +23,29 @@ export interface Alignment {
  * side an identity of its own. `ancestorKeys` are the ancestor's items' keys as a read gives them.
  * An item with a key of its own is named by the key a read gives it: that key the first time the
  * list holds it, else a hash of its content. A name the ancestor's read gave, or another key a
- * read could have given an ancestor item ({@link ancestorAliases}), is that ancestor item; any
+ * read could have given an ancestor item ({@link ancestorAliases}) unless an item here holds that
+ * item's own key or the ancestor's read gave it to an item of another list, is that ancestor item; any
  * other key marks the item new when it was minted for it, the ancestor knows it (a copy), or the
  * ancestor's read gave it to an item of another list (`inEntry`, every key the ancestor's read
  * gives across the entry): that item moved here.
  *
  * The rest align as diff3 aligns lines: equal content in order, then equal content out of order
  * (a move), then, in each gap between two matches, by shared values and last by place
- * ({@link pairInGap}).
+ * ({@link pairInGap}). `otherSide` is the other version's list: its copy of an item counts here
+ * where it holds the same rewrite.
  * Undefined when the diff ran out of time.
  */
-export declare function alignToAncestor(items: readonly unknown[], ancestorItems: readonly unknown[], ancestorKeys: readonly string[], side: string, inEntry: ReadonlySet<string>, movedIn: ReadonlySet<string>): Alignment | undefined;
+export declare function alignToAncestor(items: readonly unknown[], ancestorItems: readonly unknown[], ancestorKeys: readonly string[], side: string, inEntry: ReadonlySet<string>, movedIn: ReadonlySet<string>, otherSide?: readonly unknown[]): Alignment | undefined;
 /** True for an identity {@link alignToAncestor} gave an item new on its side. */
 export declare const isNewIdentity: (id: string) => boolean;
 /**
  * Pairs the items new on the base with the items new on the branch that are the same addition:
  * the same key, else equal content, in order. The branch's identity replaces the base's in
- * `baseIds` for each pair, so an item both sides added alike is one item. Pairing is skipped by
- * content when the diff runs out of time: the additions stay apart, and none is lost.
+ * `baseIds` for each pair, so an item both sides added alike is one item; one moved in from another
+ * list (`movedHere`) is no addition, and pairs by key only. Pairing is skipped by content when the
+ * diff runs out of time: the additions stay apart, and none is lost.
  */
-export declare function pairNewItems(baseItems: readonly unknown[], baseIds: string[], branchItems: readonly unknown[], branchIds: readonly string[]): void;
+export declare function pairNewItems(baseItems: readonly unknown[], baseIds: string[], branchItems: readonly unknown[], branchIds: readonly string[], movedHere: (key: string) => boolean): void;
 /**
  * The order of the merged list's identities: one side's order, with the items only the other side
  * holds placed after the item that precedes them there. The branch's order leads unless the

package/dist/merge/list-alignment.js

@@ -65,17 +65,19 @@ const ancestorAliases = (ancestorItems, ancestorKeys) => {
  * side an identity of its own. `ancestorKeys` are the ancestor's items' keys as a read gives them.
  * An item with a key of its own is named by the key a read gives it: that key the first time the
  * list holds it, else a hash of its content. A name the ancestor's read gave, or another key a
- * read could have given an ancestor item ({@link ancestorAliases}), is that ancestor item; any
+ * read could have given an ancestor item ({@link ancestorAliases}) unless an item here holds that
+ * item's own key or the ancestor's read gave it to an item of another list, is that ancestor item; any
  * other key marks the item new when it was minted for it, the ancestor knows it (a copy), or the
  * ancestor's read gave it to an item of another list (`inEntry`, every key the ancestor's read
  * gives across the entry): that item moved here.
  *
  * The rest align as diff3 aligns lines: equal content in order, then equal content out of order
  * (a move), then, in each gap between two matches, by shared values and last by place
- * ({@link pairInGap}).
+ * ({@link pairInGap}). `otherSide` is the other version's list: its copy of an item counts here
+ * where it holds the same rewrite.
  * Undefined when the diff ran out of time.
  */
-export function alignToAncestor(items, ancestorItems, ancestorKeys, side, inEntry, movedIn) {
+export function alignToAncestor(items, ancestorItems, ancestorKeys, side, inEntry, movedIn, otherSide = []) {
     const known = new Set(ancestorKeys);
     const aliases = ancestorAliases(ancestorItems, ancestorKeys);
     const readKeys = itemKeysAsRead(items);
@@ -103,32 +105,73 @@ export function alignToAncestor(items, ancestorItems, ancestorKeys, side, inEntr
             unheldFresh.add(token);
     });
     const at = new Map(ancestorKeys.map((key, i) => [key, i]));
-    const usurped = (j, own) => {
+    // Content a copy holds, under a key minted for it that the ancestor doesn't know.
+    const copies = (list) => new Set(list.flatMap((item) => {
+        const own = ownKey(item);
+        return own !== undefined && !hasContentKeyShape(own) && !known.has(own)
+            ? [valueToken(item)]
+            : [];
+    }));
+    const [copied, otherCopied] = [copies(items), copies(otherSide)];
+    // The other side's copy counts where it holds the same rewrite, so both read that item alike.
+    // A key is compared by the ancestor item it names, so an alias matches its read key.
+    const names = (key) => key === undefined || known.has(key) ? key : (aliases.get(key) ?? key);
+    const otherHolds = new Set(otherSide.map((item) => `${names(ownKey(item))}\u0000${valueToken(item)}`));
+    const sameRewrite = (j, own) => otherHolds.has(`${names(own)}\u0000${valueToken(items[j])}`);
+    // Whether the item may be the unheld item holding its content: `named` when its key names
+    // another, `keyed` when a copy also shows that one was rewritten, `unnamed` when it names none.
+    const claim = (j, own) => {
         if (!hasContentKeyShape(own))
-            return false;
+            return undefined;
         const content = valueToken(items[j]);
         const holders = unheld.get(content) ?? 0;
         if (holders === 0)
-            return false;
+            return undefined;
         const read = readKeys[j];
         const named = read !== undefined && known.has(read) ? read : aliases.get(own);
         const i = named === undefined ? undefined : at.get(named);
         // A key that has gone stale on both sides is history, not content: it names its item.
         if (i !== undefined) {
             if (isMinted(ancestorItems[i]) && isMinted(items[j]))
-                return false;
+                return undefined;
             // A key takes only an unheld item still under its read key: one gone stale was edited.
             if (!unheldFresh.has(content))
-                return false;
-            return valueToken(ancestorItems[i]) !== content;
+                return undefined;
+            // With a copy of the item its key names beside it, the side rewrote that item: read by key.
+            const was = valueToken(ancestorItems[i]);
+            if (was === content)
+                return undefined;
+            return copied.has(was) || (otherCopied.has(was) && sameRewrite(j, own)) ? 'keyed' : 'named';
         }
         // A key naming no item here pairs by content only where one item holds it, twins by place.
-        return holders === 1;
+        return holders === 1 ? 'unnamed' : undefined;
+    };
+    const claims = items.map((item, j) => {
+        const own = ownKey(item);
+        return own === undefined ? undefined : claim(j, own);
+    });
+    const claimants = new Map();
+    claims.forEach((c, j) => {
+        const content = valueToken(items[j]);
+        if (c !== undefined)
+            claimants.set(content, (claimants.get(content) ?? 0) + 1);
+    });
+    // More claimants than holders can't all be those items: one a key names is that item instead.
+    const usurped = (j) => {
+        const content = valueToken(items[j]);
+        if (claims[j] !== 'named')
+            return claims[j] === 'unnamed';
+        return (claimants.get(content) ?? 0) <= (unheld.get(content) ?? 0);
+    };
+    const literal = new Set(items.flatMap((item) => ownKey(item) ?? []).filter((k) => known.has(k)));
+    const aliasOf = (own) => {
+        const id = inEntry.has(own) ? undefined : aliases.get(own);
+        return id !== undefined && !literal.has(id) ? id : undefined;
     };
     items.forEach((item, j) => {
         const own = ownKey(item);
         const read = readKeys[j];
-        if (own !== undefined && usurped(j, own)) {
+        if (own !== undefined && usurped(j)) {
             minted.add(j);
             byContent.add(j);
             stale.add(j);
@@ -141,7 +184,7 @@ export function alignToAncestor(items, ancestorItems, ancestorKeys, side, inEntr
             : read !== undefined && known.has(read)
                 ? read
                 : !known.has(own)
-                    ? aliases.get(own)
+                    ? aliasOf(own)
                     : undefined;
         if (id !== undefined && !taken.has(id)) {
             ids[j] = id;
@@ -376,10 +419,11 @@ export const isNewIdentity = (id) => id.startsWith(INTERNAL);
 /**
  * Pairs the items new on the base with the items new on the branch that are the same addition:
  * the same key, else equal content, in order. The branch's identity replaces the base's in
- * `baseIds` for each pair, so an item both sides added alike is one item. Pairing is skipped by
- * content when the diff runs out of time: the additions stay apart, and none is lost.
+ * `baseIds` for each pair, so an item both sides added alike is one item; one moved in from another
+ * list (`movedHere`) is no addition, and pairs by key only. Pairing is skipped by content when the
+ * diff runs out of time: the additions stay apart, and none is lost.
  */
-export function pairNewItems(baseItems, baseIds, branchItems, branchIds) {
+export function pairNewItems(baseItems, baseIds, branchItems, branchIds, movedHere) {
     const baseNew = baseIds.flatMap((id, j) => (isNewIdentity(id) ? [j] : []));
     const branchNew = branchIds.flatMap((id, j) => (isNewIdentity(id) ? [j] : []));
     const pairedBase = new Set();
@@ -404,7 +448,12 @@ export function pairNewItems(baseItems, baseIds, branchItems, branchIds) {
     // Equal content pairs two additions, unless both carry minted keys: two items reading alike.
     const restBase = baseNew.filter((j) => !pairedBase.has(j));
     const restBranch = branchNew.filter((j) => !pairedBranch.has(j));
-    const pairs = (commonPairs(restBase.map((j) => valueToken(baseItems[j])), restBranch.map((j) => valueToken(branchItems[j]))) ?? []).filter(([x, y]) => !(isMinted(baseItems[restBase[x]]) && isMinted(branchItems[restBranch[y]])));
+    const pairs = (commonPairs(restBase.map((j) => valueToken(baseItems[j])), restBranch.map((j) => valueToken(branchItems[j]))) ?? []).filter(([x, y]) => {
+        const [a, b] = [baseItems[restBase[x]], branchItems[restBranch[y]]];
+        const [ka, kb] = [ownKey(a), ownKey(b)];
+        const movedIn = (k) => k !== undefined && movedHere(k);
+        return !(isMinted(a) && isMinted(b)) && !(ka !== kb && (movedIn(ka) || movedIn(kb)));
+    });
     for (const [x, y] of pairs)
         baseIds[restBase[x]] = branchIds[restBranch[y]];
 }

package/dist/merge/rekey.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The field merge's keys, onto what a git-level merge wrote: git keeps each item under its side's
+ * key, which can name another item once the other side changed it.
+ */
+/**
+ * `merged` with each list item under the key `fieldMerged` gives the item holding its content, in
+ * `merged`'s order, alike items matched in order; nested lists alike. Undefined where the two don't
+ * hold the same content, item keys and the order of list items aside. A list of plain values is
+ * content in its order.
+ */
+export declare function rekeyAsMerged(merged: unknown, fieldMerged: unknown): unknown;

package/dist/merge/rekey.js

@@ -0,0 +1,75 @@
+/**
+ * The field merge's keys, onto what a git-level merge wrote: git keeps each item under its side's
+ * key, which can name another item once the other side changed it.
+ */
+import { ITEM_KEY } from '../item-keys.js';
+import { isPlainRecord } from '../validation/field-traversal.js';
+import { isEmptyValue, valueToken } from './value-equality.js';
+const owns = (record, name) => Object.prototype.hasOwnProperty.call(record, name);
+const isRecordList = (value) => Array.isArray(value) && value.length > 0 && value.every(isPlainRecord);
+/** `value`'s content with item keys aside and each list of records in any order. */
+const looseToken = (value) => {
+    if (isEmptyValue(value))
+        return '';
+    if (isRecordList(value))
+        return `[${value.map(looseToken).sort().join(',')}]`;
+    if (!isPlainRecord(value))
+        return valueToken(value);
+    const members = Object.entries(value)
+        .filter(([name, v]) => name !== ITEM_KEY && !isEmptyValue(v))
+        .sort(([x], [y]) => (x < y ? -1 : x > y ? 1 : 0));
+    return `{${members.map(([name, v]) => `${JSON.stringify(name)}:${looseToken(v)}`).join(',')}}`;
+};
+/**
+ * `merged` with each list item under the key `fieldMerged` gives the item holding its content, in
+ * `merged`'s order, alike items matched in order; nested lists alike. Undefined where the two don't
+ * hold the same content, item keys and the order of list items aside. A list of plain values is
+ * content in its order.
+ */
+export function rekeyAsMerged(merged, fieldMerged) {
+    if (isRecordList(merged) && isRecordList(fieldMerged)) {
+        if (merged.length !== fieldMerged.length)
+            return undefined;
+        const pool = fieldMerged.map((item) => ({ item, token: looseToken(item) }));
+        const out = [];
+        for (const item of merged) {
+            const token = looseToken(item);
+            const at = pool.findIndex((p) => p.token === token);
+            if (at === -1)
+                return undefined;
+            const [{ item: match }] = pool.splice(at, 1);
+            const rekeyed = rekeyAsMerged(item, match);
+            if (rekeyed === undefined)
+                return undefined;
+            out.push(rekeyed);
+        }
+        return out;
+    }
+    if (isPlainRecord(merged) && isPlainRecord(fieldMerged)) {
+        // Git's members in git's order, so the text changes only where a key does.
+        const out = [];
+        const key = owns(fieldMerged, ITEM_KEY) ? fieldMerged[ITEM_KEY] : undefined;
+        for (const [name, value] of Object.entries(merged)) {
+            if (name === ITEM_KEY) {
+                if (key !== undefined)
+                    out.push([name, key]);
+                continue;
+            }
+            const other = owns(fieldMerged, name) ? fieldMerged[name] : undefined;
+            const rekeyed = isEmptyValue(value) && isEmptyValue(other) ? value : rekeyAsMerged(value, other);
+            if (rekeyed === undefined)
+                return undefined;
+            out.push([name, rekeyed]);
+        }
+        for (const [name, value] of Object.entries(fieldMerged)) {
+            if (owns(merged, name))
+                continue;
+            if (name === ITEM_KEY)
+                out.push([name, value]);
+            else if (!isEmptyValue(value))
+                return undefined;
+        }
+        return Object.fromEntries(out);
+    }
+    return valueToken(merged) === valueToken(fieldMerged) ? merged : undefined;
+}

package/dist/operating-mode/client-safe-strategy.js

@@ -46,7 +46,7 @@ export class DevClientSafeStrategy {
         return false; // No real GitHub in local dev mode
     }
     syncsBranchesWithBase() {
-        return false;
+        return true;
     }
     getPermissionsFileName() {
         return 'permissions.json';

package/dist/operating-mode/client-unsafe-strategy.js

@@ -39,6 +39,9 @@ class ProdStrategy extends ProdClientSafeStrategy {
             autoDetectRemotePath: path.join(this.getWorkspaceRoot(), 'remote.git'),
         };
     }
+    baseUpdateRunsInRequest() {
+        return false;
+    }
     requiresExistingRepo() {
         return false; // Will clone if needed
     }
@@ -91,6 +94,9 @@ class DevStrategy extends DevClientSafeStrategy {
             envVarName: 'CANOPYCMS_REMOTE_URL',
         };
     }
+    baseUpdateRunsInRequest() {
+        return true;
+    }
     requiresExistingRepo() {
         return false;
     }

package/dist/operating-mode/types.d.ts

@@ -34,8 +34,9 @@ export interface ClientSafeStrategy {
     supportsComments(): boolean;
     supportsPullRequests(): boolean;
     /**
-     * Whether a worker brings the base branch into editing branches, so a request for the latest
-     * changes (base-update.ts) gets an answer. Dev runs no git sync.
+     * Whether a request for the latest changes (base-update.ts) gets an answer, so the editor offers
+     * "Get latest changes": from the worker's sync, or from the request itself
+     * ({@link ClientUnsafeStrategy.baseUpdateRunsInRequest}).
      */
     syncsBranchesWithBase(): boolean;
     /** Get the permissions file name (e.g., 'permissions.json' or 'permissions.local.json') */
@@ -79,6 +80,13 @@ export interface ClientUnsafeStrategy extends ClientSafeStrategy {
     getPermissionsFilePath(root: string): string;
     getGroupsFilePath(root: string): string;
     getRemoteUrlConfig(): RemoteUrlConfig;
+    /**
+     * Whether a request for the latest changes runs the worker's merge for its branch in the request
+     * (services.ts `runBaseUpdateNow`), for a mode with no worker loop to answer it. False where the
+     * worker answers: there the request is only queued, and a merge in a request would race the
+     * worker's own.
+     */
+    baseUpdateRunsInRequest(): boolean;
     /** Whether this mode requires an existing git repository */
     requiresExistingRepo(): boolean;
     /** The permissions/groups branch: `canopycms-settings-{deploymentName}`. */