diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 5366e8a89..94399ed99 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -28,6 +28,9 @@ updates:
       - dependency-name: platform-bible-react
     allow:
       # dependencies
+      - dependency-name: '@dnd-kit/core'
+      - dependency-name: '@dnd-kit/sortable'
+      - dependency-name: '@dnd-kit/utilities'
       - dependency-name: '@reduxjs/toolkit'
       - dependency-name: react-redux
       # devDependencies
@@ -52,6 +55,7 @@ updates:
         applies-to: version-updates
         update-types: ['minor', 'patch']
         patterns:
+          - '@dnd-kit/*'
           - '@reduxjs/toolkit'
           - react-redux
       dev-tooling:
diff --git a/__mocks__/lucide-react.tsx b/__mocks__/lucide-react.tsx
index 2a01ea791..89679d3d0 100644
--- a/__mocks__/lucide-react.tsx
+++ b/__mocks__/lucide-react.tsx
@@ -12,6 +12,20 @@ export function LocateFixed(props: Readonly<{ className?: string }>): ReactEleme
   return <svg data-testid="locate-fixed-icon" {...props} />;
 }
 
+/**
+ * Stub for the ArrowUpToLine icon.
+ */
+export function ArrowUpToLine(props: Readonly<{ className?: string }>): ReactElement {
+  return <svg data-testid="arrow-up-to-line-icon" {...props} />;
+}
+
+/**
+ * Stub for the GripVertical icon.
+ */
+export function GripVertical(props: Readonly<{ className?: string }>): ReactElement {
+  return <svg data-testid="grip-vertical-icon" {...props} />;
+}
+
 /**
  * Stub for the Info icon.
  */
@@ -77,6 +91,11 @@ export function Merge(props: Readonly<{ className?: string }>): ReactElement {
   return <svg data-testid="merge-icon" {...props} />;
 }
 
+/** Stub for the ArrowRight icon. */
+export function ArrowRight(props: Readonly<{ className?: string }>): ReactElement {
+  return <svg data-testid="arrow-right-icon" {...props} />;
+}
+
 /**
  * Stub for the Split icon: one stroke diverging into two, the mirror of the {@link Merge} glyph's
  * join.
diff --git a/__mocks__/platform-bible-react.tsx b/__mocks__/platform-bible-react.tsx
index bb6ae6096..2587ff8c8 100644
--- a/__mocks__/platform-bible-react.tsx
+++ b/__mocks__/platform-bible-react.tsx
@@ -20,6 +20,7 @@ import {
 } from 'react';
 import type {
   ChangeEventHandler,
+  FocusEventHandler,
   CSSProperties,
   KeyboardEventHandler,
   MouseEventHandler,
@@ -420,6 +421,7 @@ export const Input = forwardRef<
     className?: string;
     style?: CSSProperties;
     disabled?: boolean;
+    onBlur?: FocusEventHandler<HTMLInputElement>;
     onChange?: ChangeEventHandler<HTMLInputElement>;
     onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
     'aria-label'?: string;
@@ -434,6 +436,7 @@ export const Input = forwardRef<
     className,
     style,
     disabled,
+    onBlur,
     onChange,
     onKeyDown,
     'aria-label': ariaLabel,
@@ -451,6 +454,7 @@ export const Input = forwardRef<
       className={className}
       style={style}
       disabled={disabled}
+      onBlur={onBlur}
       onChange={onChange}
       onKeyDown={onKeyDown}
       aria-label={ariaLabel}
@@ -610,6 +614,42 @@ export function Switch({
   );
 }
 
+/**
+ * Stub checkbox rendered as a native `<input type="checkbox">` so `toBeChecked`, `toBeDisabled`, and
+ * click interactions work in tests. (The real component renders a `<button role="checkbox">`; a
+ * native checkbox plays nicely with jest-dom's checked/disabled matchers.)
+ */
+export function Checkbox({
+  'aria-label': ariaLabel,
+  checked,
+  className,
+  'data-testid': testId,
+  disabled,
+  id,
+  onCheckedChange,
+}: Readonly<{
+  'aria-label'?: string;
+  checked?: boolean;
+  className?: string;
+  'data-testid'?: string;
+  disabled?: boolean;
+  id?: string;
+  onCheckedChange?: (checked: boolean) => void;
+}>): ReactElement {
+  return (
+    <input
+      aria-label={ariaLabel}
+      checked={checked ?? false}
+      className={className}
+      data-testid={testId}
+      disabled={disabled}
+      id={id}
+      onChange={(e) => onCheckedChange?.(e.target.checked)}
+      type="checkbox"
+    />
+  );
+}
+
 /**
  * Context carrying the {@link RadioGroup}'s selected value and change handler down to each
  * {@link RadioGroupItem}, mirroring how the real Radix-based component coordinates its items.
@@ -651,27 +691,33 @@ export function RadioGroup({
  * plays nicely with jest-dom's checked/disabled matchers.)
  */
 export function RadioGroupItem({
+  'aria-label': ariaLabel,
   className,
   'data-testid': testId,
   disabled,
   id,
+  style,
   value,
 }: Readonly<{
+  'aria-label'?: string;
   className?: string;
   'data-testid'?: string;
   disabled?: boolean;
   id?: string;
+  style?: CSSProperties;
   value: string;
 }>): ReactElement {
   const { onValueChange, value: groupValue } = useContext(RadioGroupContext);
   return (
     <input
+      aria-label={ariaLabel}
       checked={groupValue === value}
       className={className}
       data-testid={testId}
       disabled={disabled}
       id={id}
       onChange={() => onValueChange?.(value)}
+      style={style}
       type="radio"
     />
   );
@@ -918,25 +964,26 @@ const mountedDialogs: { current?: (open: boolean) => void }[] = [];
 /**
  * Stub dialog surface rendered as a `<div role="dialog" data-slot="dialog-content">` — the slot
  * being what tells a modal apart from a popover, since both carry the dialog role — that reports
- * Escape back through the root's change handler, which is the one dismissal path the extension's
- * own code implements. The
- * real component additionally traps focus, locks scrolling, and restores focus on close; those are
- * behaviors of the platform package rather than of this extension, so they are left to end-to-end
- * coverage rather than faked here.
+ * Escape and outside clicks back through the root's change handler, those being the dismissal
+ * paths the extension's own code implements. The real component additionally traps focus, locks
+ * scrolling, and restores focus on close; those are behaviors of the platform package rather than
+ * of this extension, so they are left to end-to-end coverage rather than faked here.
  *
- * `onInteractOutside` is accepted and ignored — there is no outside region to click in this stub.
- * A close button is never rendered because the extension always suppresses it.
+ * A sentinel `data-testid="dialog-outside"` button stands in for the region outside the surface:
+ * clicking it invokes `onInteractOutside` and, unless that prevents the event, reports the
+ * dismissal. The ref lands on the surface, as the real component's does. A close button is never
+ * rendered because the extension always suppresses it.
  */
-export function DialogContent({
-  children,
-  className,
-}: Readonly<{
-  'aria-describedby'?: undefined;
-  children?: ReactNode;
-  className?: string;
-  onInteractOutside?: (event: { preventDefault: () => void }) => void;
-  showCloseButton?: boolean;
-}>): ReactElement {
+export const DialogContent = forwardRef<
+  HTMLDivElement,
+  Readonly<{
+    'aria-describedby'?: undefined;
+    children?: ReactNode;
+    className?: string;
+    onInteractOutside?: (event: { preventDefault: () => void }) => void;
+    showCloseButton?: boolean;
+  }>
+>(function DialogContent({ children, className, onInteractOutside }, ref): ReactElement {
   const { onOpenChange, titleId } = useContext(DialogContext);
   const onOpenChangeRef = useRef(onOpenChange);
   useEffect(() => {
@@ -959,17 +1006,38 @@ export function DialogContent({
   }, []);
 
   return (
-    <div
-      aria-labelledby={titleId}
-      aria-modal="true"
-      className={className}
-      data-slot="dialog-content"
-      role="dialog"
-    >
-      {children}
-    </div>
+    <>
+      <div
+        ref={ref}
+        aria-labelledby={titleId}
+        aria-modal="true"
+        className={className}
+        data-slot="dialog-content"
+        role="dialog"
+      >
+        {children}
+      </div>
+      {/* Hidden from the accessibility tree: scaffolding standing in for the region outside the
+          surface is no control of the real component's. */}
+      <button
+        aria-hidden="true"
+        data-testid="dialog-outside"
+        type="button"
+        onClick={() => {
+          let prevented = false;
+          onInteractOutside?.({
+            preventDefault: () => {
+              prevented = true;
+            },
+          });
+          if (!prevented) onOpenChangeRef.current?.(false);
+        }}
+      >
+        outside
+      </button>
+    </>
   );
-}
+});
 
 /**
  * Stub dialog title rendered as the `<h2>` the real component produces, keeping the heading role and
@@ -997,10 +1065,14 @@ export function DialogTitle({
  * Context carrying the {@link Popover}'s open state and change handler down to
  * {@link PopoverTrigger}, mirroring how the real Radix-based component coordinates the two.
  */
-const PopoverContext = createContext<{
-  onOpenChange?: (open: boolean) => void;
-  open?: boolean;
-}>({});
+// Undefined outside a Popover, so PopoverAnchor can refuse as the real component does.
+const PopoverContext = createContext<
+  | {
+      onOpenChange?: (open: boolean) => void;
+      open?: boolean;
+    }
+  | undefined
+>(undefined);
 
 /**
  * Stub popover root that renders its children unconditionally. The extension conditionally mounts
@@ -1048,14 +1120,27 @@ export function PopoverTrigger({
  * Stub popover anchor that renders its children as-is, matching the real component's `asChild`
  * pass-through behavior.
  */
+/**
+ * Stub portal-container provider, rendering its children where they stand — jsdom has no portal
+ * behavior worth reproducing.
+ */
+export function PopoverPortalContainerProvider({
+  children,
+}: Readonly<{ children?: ReactNode; container?: HTMLElement | null }>): ReactElement {
+  return <>{children}</>;
+}
+
 export function PopoverAnchor({
   children,
 }: Readonly<{ children?: ReactNode; asChild?: boolean }>): ReactElement {
+  // Throws outside a Popover as the real component does.
+  if (useContext(PopoverContext) === undefined)
+    throw new Error('`PopoverAnchor` must be used within `Popover`');
   return <>{children}</>;
 }
 
 /**
- * Stub popover content rendered as a `<div role="dialog" data-testid="popover-content">` — the role
+ * Stub popover content rendered as a `<div role="dialog" data-slot="popover-content">` — the role
  * matching the real component, which is what makes its `aria-label` meaningful, and which is why a
  * test that must reach a modal instead selects on `[data-slot="dialog-content"]`. The real component
  * implements positioning, portaling, and dismissal internally; this stub exposes the dismissal
@@ -1140,6 +1225,7 @@ export function PopoverContent({
         ref={contentRef}
         aria-label={ariaLabel}
         className={className}
+        data-slot="popover-content"
         data-testid={testId}
         id={id}
         role={role}
diff --git a/contributions/localizedStrings.json b/contributions/localizedStrings.json
index bf9e3c2b7..08be7c0c2 100644
--- a/contributions/localizedStrings.json
+++ b/contributions/localizedStrings.json
@@ -47,11 +47,65 @@
       "%interlinearizer_analysisCatalog_confidence_low%": "Low",
       "%interlinearizer_analysisCatalog_confidence_guess%": "Guess",
       "%interlinearizer_analysisCatalog_noGloss%": "(no gloss)",
+      "%interlinearizer_analysisCatalog_morphemeNoGloss%": "(no gloss)",
+      "%interlinearizer_analysisCatalog_noBreakdown%": "(not split into morphemes)",
       "%interlinearizer_analysisCatalog_usageCount%": "Uses in the whole draft",
       "%interlinearizer_analysisCatalog_usageCountInBook%": "Uses in {book}",
       "%interlinearizer_analysisCatalog_noUsages%": "Not used anywhere",
       "%interlinearizer_analysisCatalog_showAllUsages%": "Show {count} more",
 
+      "%interlinearizer_analysisCatalog_editGloss%": "Gloss",
+      "%interlinearizer_analysisCatalog_editMorphemes%": "Split into morphemes",
+      "%interlinearizer_analysisCatalog_editMorphemesHint%": "Enter morpheme forms separated by spaces",
+      "%interlinearizer_analysisCatalog_editMorphemesSave%": "Save breakdown",
+      "%interlinearizer_analysisCatalog_editMorphemesCancel%": "Cancel",
+      "%interlinearizer_analysisCatalog_editMorphemesReset%": "Discard breakdown",
+      "%interlinearizer_analysisCatalog_editMorphemesOpen%": "Edit breakdown for {form}",
+      "%interlinearizer_analysisCatalog_confirmResetPrompt%": "Discard this breakdown, with the glosses and lexicon links on it, everywhere {form} is used?",
+      "%interlinearizer_analysisCatalog_confirmResetAction%": "Discard breakdown",
+      "%interlinearizer_analysisCatalog_confirmResplitPrompt%": "This breakdown drops {forms}, discarding the glosses and lexicon links on them everywhere this analysis is used. Save anyway?",
+      "%interlinearizer_analysisCatalog_confirmResplitAction%": "Save and discard",
+      "%interlinearizer_analysisCatalog_morphemeGloss%": "Gloss for morpheme {form}",
+      "%interlinearizer_analysisCatalog_appliesToAll%": "Edits here apply to all {count} uses of this analysis.",
+      "%interlinearizer_analysisCatalog_merge%": "Merge…",
+      "%interlinearizer_analysisCatalog_mergeTitle%": "Merge an analysis",
+      "%interlinearizer_analysisCatalog_mergeForm%": "Form",
+      "%interlinearizer_analysisCatalog_mergeUsageCount%": "{count} uses",
+      "%interlinearizer_analysisCatalog_mergePromote%": "Merge the others into {gloss}",
+      "%interlinearizer_analysisCatalog_mergeReorder%": "Reorder {gloss}",
+      "%interlinearizer_analysisCatalog_mergeRevertField%": "Undo this edit",
+      "%interlinearizer_analysisCatalog_mergeMorphemeGlosses%": "Morpheme glosses",
+      "%interlinearizer_analysisCatalog_mergeClearMorphemeGloss%": "Clear the gloss for {form}",
+      "%interlinearizer_analysisCatalog_mergeConfidence%": "Confidence",
+      "%interlinearizer_analysisCatalog_mergeConfidenceNone%": "Not recorded",
+      "%interlinearizer_analysisCatalog_mergeReset%": "Undo all edits",
+      "%interlinearizer_analysisCatalog_mergeWillCollapse%": "This will also absorb the identical analysis {gloss}, which is not selected.",
+      "%interlinearizer_analysisCatalog_mergeCancel%": "Cancel",
+      "%interlinearizer_analysisCatalog_mergeConfirm%": "Merge",
+      "%interlinearizer_analysisCatalog_merged%": "Merged into {gloss} — now {count} uses.",
+      "%interlinearizer_analysisCatalog_mergedNoGloss%": "Merged into {form} — now {count} uses.",
+      "%interlinearizer_analysisCatalog_mergedDismiss%": "Dismiss",
+      "%interlinearizer_analysisCatalog_draftStranded%": "An edit elsewhere removed the analysis of {form}, discarding the breakdown you were typing for it.",
+      "%interlinearizer_analysisCatalog_delete%": "Delete",
+      "%interlinearizer_analysisCatalog_deleteTitle%": "Delete the analysis of {form}?",
+      "%interlinearizer_analysisCatalog_deleteBlank%": "{count} uses will be left with no analysis.",
+      "%interlinearizer_analysisCatalog_deleteBlankNone%": "No token is analyzed as this, so nothing on screen changes.",
+      "%interlinearizer_analysisCatalog_deleteFallback%": "{count} uses will fall back to {gloss}.",
+      "%interlinearizer_analysisCatalog_deleteFallbackNoGloss%": "{count} uses will fall back to another analysis of the same form.",
+      "%interlinearizer_analysisCatalog_deleteFallbackDrifted%": "{count} uses will fall back to another analysis, which one depending on the text beneath each of them.",
+      "%interlinearizer_analysisCatalog_deleteUnapplied%": "{count} tokens also record this analysis without using it; those records are deleted too.",
+      "%interlinearizer_analysisCatalog_deleteUndoWarning%": "This cannot be undone.",
+      "%interlinearizer_analysisCatalog_deleteCancel%": "Cancel",
+      "%interlinearizer_analysisCatalog_deleteConfirm%": "Delete",
+      "%interlinearizer_analysisCatalog_closeConfirmTitle%": "Discard the unsaved breakdown?",
+      "%interlinearizer_analysisCatalog_closeConfirmPrompt%": "You have typed a morpheme breakdown but not saved it. Closing the catalog discards it.",
+      "%interlinearizer_analysisCatalog_closeConfirmCancel%": "Keep editing",
+      "%interlinearizer_analysisCatalog_closeConfirmDiscard%": "Discard and close",
+      "%interlinearizer_analysisCatalog_discardForDeletePrompt%": "You have typed a morpheme breakdown but not saved it. Deleting this analysis discards it.",
+      "%interlinearizer_analysisCatalog_discardForDeleteConfirm%": "Discard and delete",
+      "%interlinearizer_analysisCatalog_discardForMergePrompt%": "You have typed a morpheme breakdown but not saved it. Merging this analysis discards it.",
+      "%interlinearizer_analysisCatalog_discardForMergeConfirm%": "Discard and merge",
+
       "%interlinearizer_projectSettings_title%": "Interlinearizer",
       "%interlinearizer_projectSettings_continuousScroll%": "Continuous Scroll",
       "%interlinearizer_projectSettings_continuousScrollDescription%": "Display words in a continuous horizontal scroll strip instead of chapter-segmented rows",
@@ -83,8 +137,10 @@
       "%interlinearizer_morphemeEditor_cancel%": "Cancel",
       "%interlinearizer_morphemeEditor_done%": "Done",
       "%interlinearizer_morphemeEditor_emptyHint%": "Enter morpheme forms separated by spaces",
-      "%interlinearizer_morphemeEditor_confirmResetPrompt%": "Discard this breakdown and its glosses?",
+      "%interlinearizer_morphemeEditor_confirmResetPrompt%": "Discard this breakdown, with the glosses and lexicon links on it?",
       "%interlinearizer_morphemeEditor_confirmResetAction%": "Reset",
+      "%interlinearizer_morphemeEditor_confirmResplitPrompt%": "This breakdown drops {forms}, discarding the glosses and lexicon links on them. Save anyway?",
+      "%interlinearizer_morphemeEditor_confirmResplitAction%": "Save and discard",
       "%interlinearizer_morphemeGloss_label%": "Gloss for morpheme {form}",
       "%interlinearizer_tokenChip_editMorphemes%": "Edit morpheme breakdown for {token}",
       "%interlinearizer_tokenChip_defineMorphemes%": "Define morpheme breakdown for {token}",
diff --git a/package-lock.json b/package-lock.json
index 4fe399048..7319e7ee1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,6 +9,9 @@
       "version": "0.3.0-alpha.0",
       "license": "MIT",
       "dependencies": {
+        "@dnd-kit/core": "^6.3.1",
+        "@dnd-kit/sortable": "^10.0.0",
+        "@dnd-kit/utilities": "^3.2.2",
         "@reduxjs/toolkit": "^2.12.0",
         "@sillsdev/scripture": "^2.1.0",
         "platform-bible-utils": "file:../paranext-core/lib/platform-bible-utils",
@@ -1197,6 +1200,59 @@
         "node": ">=10.0.0"
       }
     },
+    "node_modules/@dnd-kit/accessibility": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/@dnd-kit/accessibility/-/accessibility-3.1.1.tgz",
+      "integrity": "sha512-2P+YgaXF+gRsIihwwY1gCsQSYnu9Zyj2py8kY5fFvUM1qm2WA2u639R6YNVfU4GWr+ZM5mqEsfHZZLoRONbemw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0"
+      }
+    },
+    "node_modules/@dnd-kit/core": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/@dnd-kit/core/-/core-6.3.1.tgz",
+      "integrity": "sha512-xkGBRQQab4RLwgXxoqETICr6S5JlogafbhNsidmrkVv2YRs5MLwpjoF2qpiGjQt8S9AoxtIV603s0GIUpY5eYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@dnd-kit/accessibility": "^3.1.1",
+        "@dnd-kit/utilities": "^3.2.2",
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0",
+        "react-dom": ">=16.8.0"
+      }
+    },
+    "node_modules/@dnd-kit/sortable": {
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/@dnd-kit/sortable/-/sortable-10.0.0.tgz",
+      "integrity": "sha512-+xqhmIIzvAYMGfBYYnbKuNicfSsk4RksY2XdmJhT+HAC01nix6fHCztU68jooFiMUB01Ky3F0FyOvhG/BZrWkg==",
+      "license": "MIT",
+      "dependencies": {
+        "@dnd-kit/utilities": "^3.2.2",
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "@dnd-kit/core": "^6.3.0",
+        "react": ">=16.8.0"
+      }
+    },
+    "node_modules/@dnd-kit/utilities": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/@dnd-kit/utilities/-/utilities-3.2.2.tgz",
+      "integrity": "sha512-+MKAJEOfaBe5SmV6t34p80MMKhjvUz0vRrvVJbPT0WElzaOJ/1xs+D+KDv+tD/NE5ujfrChEcshd4fLn0wpiqg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=16.8.0"
+      }
+    },
     "node_modules/@dotenvx/dotenvx": {
       "version": "1.75.1",
       "resolved": "https://registry.npmjs.org/@dotenvx/dotenvx/-/dotenvx-1.75.1.tgz",
@@ -17015,7 +17071,6 @@
       "version": "2.8.1",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
       "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
-      "dev": true,
       "license": "0BSD"
     },
     "node_modules/tw-animate-css": {
diff --git a/package.json b/package.json
index 5d8847ede..8ef9331e3 100644
--- a/package.json
+++ b/package.json
@@ -50,6 +50,9 @@
     "react-dom": ">=19.0.0"
   },
   "dependencies": {
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
     "@reduxjs/toolkit": "^2.12.0",
     "@sillsdev/scripture": "^2.1.0",
     "platform-bible-utils": "file:../paranext-core/lib/platform-bible-utils",
diff --git a/src/__tests__/components/AnalysisCatalogPanel.test.tsx b/src/__tests__/components/AnalysisCatalogPanel.test.tsx
index 9855ddd44..21d048377 100644
--- a/src/__tests__/components/AnalysisCatalogPanel.test.tsx
+++ b/src/__tests__/components/AnalysisCatalogPanel.test.tsx
@@ -38,13 +38,19 @@ function mockInterfaceLanguage(interfaceLanguage: string[] = ['und']): void {
   });
 }
 
-/** Builds a link from `tokenRef` to the analysis, approved unless another status is given. */
+/**
+ * Builds a link from `tokenRef` to the analysis, approved unless another status is given.
+ *
+ * `surfaceText` defaults to the form these fixtures' analyses overwhelmingly carry, since a
+ * snapshot disagreeing with its analysis is what the store reads as baseline drift.
+ */
 function link(
   analysisId: string,
   tokenRef: string,
   status: AssignmentStatus = 'approved',
+  surfaceText = 'ἀρχῇ',
 ): TokenAnalysisLink {
-  return { ...FIXTURE_STAMPS, analysisId, status, token: { tokenRef, surfaceText: 'word' } };
+  return { ...FIXTURE_STAMPS, analysisId, status, token: { tokenRef, surfaceText } };
 }
 
 /** The token ref {@link FocusRequestProbe} last claimed, or `undefined` when it claimed nothing. */
@@ -70,6 +76,10 @@ type PanelOptions = Partial<{
   currentBook: string;
   analysis: TextAnalysis;
   analysisLanguage: string;
+  /** Receives the analysis after every store write, so a test can assert on what was persisted. */
+  onSave: (analysis: TextAnalysis) => void;
+  /** Receives whether any edit is in progress, so a test can assert on the unsaved indicator. */
+  onPendingEditsChange: (pending: boolean) => void;
   /** Records every reference the panel navigates to, through the host scroll-group hook. */
   setScrRef: (ref: SerializedVerseRef) => void;
   /** Reference the host scroll group reports, i.e. where the view already sits. */
@@ -78,8 +88,17 @@ type PanelOptions = Partial<{
   mountedBook: string;
   /** Whether the project breaks words into morphemes. Defaults on, so the filter is under test. */
   showMorphology: boolean;
+  /** Whether the store holds a read-only analysis, as a Paratext 9 import does. */
+  readOnly: boolean;
+  /** Whether suggestions are shown. A deletion reports a fallback outcome only while they are. */
+  showSuggestions: boolean;
+  /** Live text per token ref. Defaults to {@link undriftedText}. */
+  liveSurfaceText: (tokenRef: string) => string | undefined;
 }>;
 
+/** Reads every token as still carrying the form its analysis was recorded under. */
+const undriftedText = () => 'ἀρχῇ';
+
 /**
  * Wraps a subject in the seeded analysis store and real navigation provider the panel needs.
  *
@@ -101,6 +120,10 @@ function PanelProviders({
       <AnalysisStoreProvider
         analysisLanguage={overrides.analysisLanguage ?? 'en'}
         initialAnalysis={overrides.analysis ?? emptyAnalysis()}
+        onPendingEditsChange={overrides.onPendingEditsChange}
+        onSave={overrides.onSave}
+        readOnly={overrides.readOnly}
+        showSuggestions={overrides.showSuggestions}
       >
         <FocusRequestProbe bookCode={overrides.mountedBook ?? 'GEN'} />
         {children}
@@ -115,6 +138,7 @@ function renderPanel(overrides: PanelOptions = {}) {
     <PanelProviders overrides={overrides}>
       <AnalysisCatalogPanel
         currentBook={overrides.currentBook ?? 'GEN'}
+        liveSurfaceText={overrides.liveSurfaceText ?? undriftedText}
         onClose={overrides.onClose ?? (() => {})}
         showMorphology={overrides.showMorphology ?? true}
         sourceLanguageTag="el"
@@ -137,6 +161,7 @@ function ReopenableCatalog() {
       {isOpen && (
         <AnalysisCatalogPanel
           currentBook="GEN"
+          liveSurfaceText={undriftedText}
           onClose={() => setIsOpen(false)}
           showMorphology
           sourceLanguageTag="el"
@@ -174,6 +199,7 @@ function renderPanelWithGlossEditing(overrides: PanelOptions = {}) {
       <GlossEditProbe />
       <AnalysisCatalogPanel
         currentBook={overrides.currentBook ?? 'GEN'}
+        liveSurfaceText={overrides.liveSurfaceText ?? undriftedText}
         onClose={overrides.onClose ?? (() => {})}
         showMorphology={overrides.showMorphology ?? true}
         sourceLanguageTag="el"
@@ -201,6 +227,19 @@ async function openFilters(): Promise<void> {
 }
 
 /** Reads the catalog row for `analysisId`, failing the test when the list has no such row. */
+/**
+ * Opens a row's breakdown editor the way a reader does: by clicking the forms row of the breakdown
+ * box, or the define-breakdown control where the analysis has no breakdown yet.
+ */
+async function openBreakdown(row: HTMLElement): Promise<void> {
+  const defineControl = within(row).queryByTestId('catalog-row-breakdown-open');
+  if (defineControl) {
+    await userEvent.click(defineControl);
+    return;
+  }
+  await userEvent.click(within(row).getAllByTestId('catalog-row-morpheme')[0]);
+}
+
 function rowFor(analysisId: string): HTMLElement {
   const row = screen
     .getAllByTestId('catalog-row')
@@ -209,11 +248,41 @@ function rowFor(analysisId: string): HTMLElement {
   return row;
 }
 
+/** The analyses the open merge picker offers, in the order it lists them. */
+function mergeCandidateIds(): (string | undefined)[] {
+  return screen
+    .getAllByTestId('catalog-merge-candidate')
+    .map((candidate) => candidate.dataset.analysisId);
+}
+
+/** The open merge picker's summary cell for one analysis, to scope a query to. */
+function mergeCandidateFor(analysisId: string): HTMLElement {
+  const candidate = screen
+    .getAllByTestId('catalog-merge-candidate')
+    .find((element) => element.dataset.analysisId === analysisId);
+  if (!candidate) throw new Error(`no merge candidate for "${analysisId}"`);
+  return candidate;
+}
+
+/** One analysis's checkbox in the open merge panel, which says whether the merge folds it in. */
+function mergeCheckFor(analysisId: string): HTMLElement {
+  return within(mergeCandidateFor(analysisId)).getByTestId('catalog-merge-check');
+}
+
+/** The control that makes one analysis the survivor the rest merge into. */
+function mergePromoteFor(analysisId: string): HTMLElement {
+  return within(mergeCandidateFor(analysisId)).getByTestId('catalog-merge-promote');
+}
+
 describe('AnalysisCatalogPanel', () => {
   beforeEach(() => {
     claimedFocusRequest = undefined;
     editGloss = () => {};
-    mockKeyAsValueLocalizedStrings();
+    // The merge prompt is resolved because it reaches the reader as tooltip content, which the
+    // platform stub refuses to render from an unresolved key.
+    mockKeyAsValueLocalizedStrings({
+      '%interlinearizer_analysisCatalog_mergePrompt%': 'Every use becomes the one you merge into.',
+    });
     mockInterfaceLanguage();
   });
 
@@ -560,7 +629,7 @@ describe('AnalysisCatalogPanel', () => {
       expect(listedAnalysisIds()).toEqual(['in-gen', 'in-exo']);
     });
 
-    it('keeps offering a chosen book the draft has since stopped using', async () => {
+    it('releases a chosen book the draft has since stopped using', async () => {
       const analysis: TextAnalysis = {
         ...PER_BOOK,
         tokenAnalyses: [
@@ -576,12 +645,12 @@ describe('AnalysisCatalogPanel', () => {
 
       act(() => editGloss('EXO 3:14:0', 'λόγος', ''));
 
-      // The books facet is down to one choice and would rightly offer none of its own, but the
-      // selection still narrows the list — so the choice that clears it has to stay on screen.
-      expect(screen.getByRole('option', { name: 'EXO' })).toBeInTheDocument();
+      // The books facet is down to one choice and offers none of its own, so the selection it was
+      // narrowing by is spent rather than left on screen to be cleared by hand.
+      expect(screen.queryByRole('option', { name: 'EXO' })).not.toBeInTheDocument();
     });
 
-    it('restores the list when a chosen book the draft stopped using is deselected', async () => {
+    it('restores the list when a chosen book the draft stopped using is withdrawn', async () => {
       const analysis: TextAnalysis = {
         ...PER_BOOK,
         tokenAnalyses: [
@@ -592,12 +661,11 @@ describe('AnalysisCatalogPanel', () => {
       renderPanelWithGlossEditing({ analysis });
       await openFilters();
       await userEvent.click(screen.getByRole('option', { name: 'EXO' }));
-      act(() => editGloss('EXO 3:14:0', 'λόγος', ''));
 
-      await userEvent.click(screen.getByRole('option', { name: 'EXO' }));
+      act(() => editGloss('EXO 3:14:0', 'λόγος', ''));
 
-      // Deselecting has to actually clear the filter rather than merely unmount its control, or the
-      // reader is left with an empty list and no way back to the draft.
+      // Releasing the filter has to widen the list on its own, or the reader is left with an empty
+      // list and no way back to the draft.
       expect(listedAnalysisIds()).toEqual(['in-gen']);
     });
 
@@ -721,11 +789,11 @@ describe('AnalysisCatalogPanel', () => {
       expect(listedAnalysisIds()).toEqual(['spaces']);
     });
 
-    it('stops marking a value rather than spinning when the marking cannot tell it apart', async () => {
+    it('numbers a value rather than spinning when the marking cannot tell it apart', async () => {
       // A localization that drops `{value}` leaves the marking spelling whatever name it was given,
-      // so repeating it can never clear a collision. Two choices then share a name and one of them
-      // is unselectable — but the panel renders, where a render that never returns takes the whole
-      // WebView down with it.
+      // so repeating it can never clear a collision. Numbering does not go through the marking, so
+      // it tells the two apart whatever the translation says — and the panel renders, where a
+      // render that never returns takes the whole WebView down with it.
       mockKeyAsValueLocalizedStrings({
         '%interlinearizer_analysisCatalog_filter_untagged%': '(none)',
         '%interlinearizer_analysisCatalog_filter_recordedValue%': '{value}',
@@ -739,10 +807,41 @@ describe('AnalysisCatalogPanel', () => {
         tokenAnalysisLinks: [link('named', 'GEN 1:1:0'), link('untagged', 'GEN 1:2:0')],
       };
       renderPanel({ analysis });
+      await openFilters();
+
+      await userEvent.click(screen.getByRole('option', { name: '(none) (2)' }));
+
+      expect(listedAnalysisIds()).toEqual(['named']);
+    });
 
+    it('counts past a numbered name another value already holds', async () => {
+      // A marking spelling a constant collides with itself, so more than one value falls through
+      // to numbering and they have to count past each other rather than each start over.
+      mockKeyAsValueLocalizedStrings({
+        '%interlinearizer_analysisCatalog_filter_empty%': '(empty)',
+        '%interlinearizer_analysisCatalog_filter_recordedValue%': 'recorded',
+      });
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'blank', surfaceText: 'λόγος', pos: '' },
+          { ...FIXTURE_STAMPS, id: 'one-space', surfaceText: 'ἦν', pos: ' ' },
+          { ...FIXTURE_STAMPS, id: 'two-spaces', surfaceText: 'θεός', pos: '  ' },
+          { ...FIXTURE_STAMPS, id: 'three-spaces', surfaceText: 'ἀρχή', pos: '   ' },
+        ],
+        tokenAnalysisLinks: [
+          link('blank', 'GEN 1:1:0'),
+          link('one-space', 'GEN 1:2:0'),
+          link('two-spaces', 'GEN 1:3:0'),
+          link('three-spaces', 'GEN 1:4:0'),
+        ],
+      };
+      renderPanel({ analysis });
       await openFilters();
 
-      expect(screen.getAllByRole('option', { name: '(none)' })).toHaveLength(2);
+      await userEvent.click(screen.getByRole('option', { name: '(empty) (3)' }));
+
+      expect(listedAnalysisIds()).toEqual(['three-spaces']);
     });
 
     it('names the language the missing-gloss filter asks about, in the interface language', async () => {
@@ -873,6 +972,92 @@ describe('AnalysisCatalogPanel', () => {
       expect(listedAnalysisIds()).toEqual(['blank']);
     });
 
+    // The platform combo box resolves a click by matching the label back to its entry, so a real
+    // value reading exactly as the untagged placeholder would otherwise take that choice's clicks.
+    /** Two analyses in two books, so the books facet is offered and one edit can collapse it. */
+    const TWO_BOOKS: TextAnalysis = {
+      ...emptyAnalysis(),
+      tokenAnalyses: [
+        { ...FIXTURE_STAMPS, id: 'in-gen', surfaceText: 'λόγος', gloss: { en: 'word' } },
+        { ...FIXTURE_STAMPS, id: 'in-exo', surfaceText: 'ἦν', gloss: { en: 'was' } },
+      ],
+      tokenAnalysisLinks: [link('in-gen', 'GEN 1:1:0'), link('in-exo', 'EXO 1:1:0')],
+    };
+
+    // An edit beside the panel can remove the last row carrying a chosen value, which takes that
+    // facet's control off screen. Holding the choice would narrow the list to nothing with no
+    // control left to widen it back by.
+    it('releases a book filter once an edit leaves that facet with nothing to offer', async () => {
+      renderPanelWithGlossEditing({ analysis: TWO_BOOKS, analysisLanguage: 'en' });
+      await openFilters();
+      const books = within(screen.getByTestId('catalog-filter-books'));
+      await userEvent.click(books.getByRole('option', { name: 'EXO' }));
+      expect(listedAnalysisIds()).toEqual(['in-exo']);
+
+      // Clearing its only gloss empties the payload, which drops the analysis and its link.
+      act(() => editGloss('EXO 1:1:0', 'ἦν', ''));
+
+      expect(listedAnalysisIds()).toEqual(['in-gen']);
+    });
+
+    // A withdrawn choice is spent, not merely unused: held, it would come back with its facet and
+    // narrow the listing by a filter the reader had already watched release.
+    it('leaves a released book filter released once the edge that withdrew it is undone', async () => {
+      renderPanelWithGlossEditing({ analysis: TWO_BOOKS, analysisLanguage: 'en' });
+      await openFilters();
+      const books = within(screen.getByTestId('catalog-filter-books'));
+      await userEvent.click(books.getByRole('option', { name: 'EXO' }));
+      act(() => editGloss('EXO 1:1:0', 'ἦν', ''));
+      expect(listedAnalysisIds()).toEqual(['in-gen']);
+
+      // Glossing it again analyzes the token afresh — a new payload under a new id, so the restored
+      // row is matched on count rather than named — and raises the books facet that offers EXO.
+      act(() => editGloss('EXO 1:1:0', 'ἦν', 'was'));
+
+      expect(listedAnalysisIds()).toHaveLength(2);
+      expect(listedAnalysisIds()).toContain('in-gen');
+    });
+
+    it('stops counting a filter the facets have withdrawn as active', async () => {
+      renderPanelWithGlossEditing({ analysis: TWO_BOOKS, analysisLanguage: 'en' });
+      await openFilters();
+      const books = within(screen.getByTestId('catalog-filter-books'));
+      await userEvent.click(books.getByRole('option', { name: 'EXO' }));
+
+      act(() => editGloss('EXO 1:1:0', 'ἦν', ''));
+
+      expect(screen.getByTestId('catalog-filters-button')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_filters%',
+      );
+    });
+
+    it('tells the untagged choice apart from a value that reads the same', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          {
+            ...FIXTURE_STAMPS,
+            id: 'named',
+            surfaceText: 'λόγος',
+            pos: '%interlinearizer_analysisCatalog_filter_untagged%',
+          },
+          { ...FIXTURE_STAMPS, id: 'untagged', surfaceText: 'ἦν' },
+        ],
+        tokenAnalysisLinks: [link('named', 'GEN 1:1:0'), link('untagged', 'GEN 1:2:0')],
+      };
+      renderPanel({ analysis });
+      await openFilters();
+
+      // The untagged choice keeps the plain label and the value reading the same is marked as a
+      // recorded value, so an exact match on the label reaches the choice rather than the value.
+      const pos = within(screen.getByTestId('catalog-filter-pos'));
+      await userEvent.click(
+        pos.getByRole('option', { name: '%interlinearizer_analysisCatalog_filter_untagged%' }),
+      );
+
+      expect(listedAnalysisIds()).toEqual(['untagged']);
+    });
+
     it('offers no book choice for a draft confined to one book', async () => {
       const analysis: TextAnalysis = {
         ...emptyAnalysis(),
@@ -991,6 +1176,7 @@ describe('AnalysisCatalogPanel', () => {
         <PanelProviders overrides={{ analysis: PER_BREAKDOWN }}>
           <AnalysisCatalogPanel
             currentBook="GEN"
+            liveSurfaceText={undriftedText}
             onClose={() => {}}
             showMorphology={false}
             sourceLanguageTag="el"
@@ -1145,6 +1331,7 @@ describe('AnalysisCatalogPanel', () => {
         <PanelProviders overrides={{ analysis: MANY, currentBook: 'MAT' }}>
           <AnalysisCatalogPanel
             currentBook="MAT"
+            liveSurfaceText={undriftedText}
             onClose={() => {}}
             showMorphology
             sourceLanguageTag="el"
@@ -1166,6 +1353,7 @@ describe('AnalysisCatalogPanel', () => {
         <PanelProviders overrides={{ analysis: MANY, currentBook: 'MAT' }}>
           <AnalysisCatalogPanel
             currentBook="MAT"
+            liveSurfaceText={undriftedText}
             onClose={() => {}}
             showMorphology
             sourceLanguageTag="el"
@@ -1232,8 +1420,14 @@ describe('AnalysisCatalogPanel', () => {
 
       await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
 
+      // Each morpheme's gloss is an editable field, so it reads off the input rather than the text.
       const morphemes = within(rowFor('ta-1')).getAllByTestId('catalog-row-morpheme');
-      expect(morphemes.map((m) => m.textContent)).toEqual(['λογword', 'οςNOM.SG']);
+      expect(morphemes.map((m) => m.textContent)).toEqual(['λογ', 'ος']);
+      expect(
+        within(rowFor('ta-1'))
+          .getAllByTestId('catalog-row-morpheme-gloss-input')
+          .map((i) => i.getAttribute('value')),
+      ).toEqual(['word', 'NOM.SG']);
     });
 
     it('shows a morpheme with no gloss in the active language as its form alone', async () => {
@@ -1495,4 +1689,1926 @@ describe('AnalysisCatalogPanel', () => {
 
     expect(onClose).toHaveBeenCalled();
   });
+
+  describe('editing a row', () => {
+    /** One analysis, shared by two tokens, so an edit here is visibly an edit to both. */
+    const SHARED: TextAnalysis = {
+      ...emptyAnalysis(),
+      tokenAnalyses: [
+        { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'λόγος', gloss: { en: 'word' } },
+      ],
+      tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0'), link('ta-1', 'GEN 1:3:4')],
+    };
+
+    /** Expands the row and returns its detail, where the edit controls live. */
+    async function expandRow(analysisId: string): Promise<HTMLElement> {
+      await userEvent.click(within(rowFor(analysisId)).getByTestId('catalog-row-toggle'));
+      return rowFor(analysisId);
+    }
+
+    it('names how many uses an edit here rewrites', async () => {
+      renderPanel({ analysis: SHARED });
+
+      await expandRow('ta-1');
+
+      expect(within(rowFor('ta-1')).getByTestId('catalog-row-applies-to-all')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_appliesToAll%',
+      );
+    });
+
+    it('omits the note for a lone use, which an edit reaches no further than', async () => {
+      const analysis: TextAnalysis = {
+        ...SHARED,
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0')],
+      };
+      renderPanel({ analysis });
+
+      await expandRow('ta-1');
+
+      expect(
+        within(rowFor('ta-1')).queryByTestId('catalog-row-applies-to-all'),
+      ).not.toBeInTheDocument();
+    });
+
+    it('omits the note for an analysis nothing uses', async () => {
+      const analysis: TextAnalysis = { ...SHARED, tokenAnalysisLinks: [] };
+      renderPanel({ analysis });
+
+      await expandRow('ta-1');
+
+      expect(
+        within(rowFor('ta-1')).queryByTestId('catalog-row-applies-to-all'),
+      ).not.toBeInTheDocument();
+    });
+
+    it('rewrites the gloss for every token linked to the analysis', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: SHARED, onSave });
+
+      const row = await expandRow('ta-1');
+      const input = within(row).getByTestId('catalog-row-gloss-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, 'message');
+      await userEvent.tab();
+
+      // One payload holding both links, so the single write reached both tokens without forking.
+      const saved: TextAnalysis = onSave.mock.calls.at(-1)[0];
+      expect(saved.tokenAnalyses).toHaveLength(1);
+      expect(saved.tokenAnalyses[0].gloss).toEqual({ en: 'message' });
+      expect(saved.tokenAnalysisLinks.map((l) => l.analysisId)).toEqual(['ta-1', 'ta-1']);
+    });
+
+    it('rewrites the morpheme breakdown for every token linked to the analysis', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: SHARED, onSave });
+
+      const row = await expandRow('ta-1');
+      await openBreakdown(row);
+      const input = within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, 'λογ ος');
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-save'));
+
+      const saved: TextAnalysis = onSave.mock.calls.at(-1)[0];
+      expect(saved.tokenAnalyses).toHaveLength(1);
+      expect(saved.tokenAnalyses[0].morphemes?.map((m) => m.form)).toEqual(['λογ', 'ος']);
+      expect(saved.tokenAnalysisLinks.map((l) => l.analysisId)).toEqual(['ta-1', 'ta-1']);
+    });
+
+    it('leaves the breakdown alone when the editor is canceled', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: SHARED, onSave });
+
+      const row = await expandRow('ta-1');
+      await openBreakdown(row);
+      await userEvent.type(
+        within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input'),
+        'λογ ος',
+      );
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-cancel'));
+
+      expect(onSave).not.toHaveBeenCalled();
+    });
+
+    /** A record with a breakdown whose morphemes carry no glosses of their own. */
+    const SEGMENTED_NO_GLOSSES: TextAnalysis = {
+      ...SHARED,
+      tokenAnalyses: [
+        {
+          ...SHARED.tokenAnalyses[0],
+          morphemes: [{ ...FIXTURE_STAMPS, id: 'm-1', form: 'λογ', writingSystem: 'el' }],
+        },
+      ],
+    };
+
+    /** A record whose morphemes carry glosses, so clearing its breakdown destroys them. */
+    const GLOSSED_MORPHEMES: TextAnalysis = {
+      ...SHARED,
+      tokenAnalyses: [
+        {
+          ...SHARED.tokenAnalyses[0],
+          morphemes: [
+            {
+              ...FIXTURE_STAMPS,
+              id: 'm-1',
+              form: 'λογ',
+              writingSystem: 'el',
+              gloss: { en: 'word' },
+            },
+            { ...FIXTURE_STAMPS, id: 'm-2', form: 'ος', writingSystem: 'el' },
+          ],
+        },
+      ],
+    };
+
+    /** Opens the breakdown editor on `ta-1` and asks it for the unsegmented state. */
+    async function clearBreakdown(): Promise<void> {
+      const row = await expandRow('ta-1');
+      await openBreakdown(row);
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-reset'));
+    }
+
+    it('confirms before clearing a breakdown whose morphemes carry glosses', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: GLOSSED_MORPHEMES, onSave });
+
+      await clearBreakdown();
+
+      expect(within(rowFor('ta-1')).getByTestId('catalog-row-editor')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_confirmResetPrompt%',
+      );
+      expect(onSave).not.toHaveBeenCalled();
+    });
+
+    it('clears the breakdown once the reset is confirmed', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: GLOSSED_MORPHEMES, onSave });
+
+      await clearBreakdown();
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('morpheme-reset-confirm-action'));
+
+      const saved: TextAnalysis = onSave.mock.calls.at(-1)[0];
+      expect(saved.tokenAnalyses[0].morphemes).toBeUndefined();
+    });
+
+    it('abandons the reset on Escape, keeping the breakdown', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: GLOSSED_MORPHEMES, onSave });
+
+      await clearBreakdown();
+      await userEvent.type(
+        within(rowFor('ta-1')).getByTestId('morpheme-breakdown-confirm-cancel'),
+        '{Escape}',
+      );
+
+      // A confirmation exists because the loss is irreversible, so nothing writes until it is
+      // taken, whichever way the panel is left.
+      expect(within(rowFor('ta-1')).getByTestId('catalog-row-editor')).not.toHaveTextContent(
+        '%interlinearizer_analysisCatalog_confirmResetPrompt%',
+      );
+      expect(onSave).not.toHaveBeenCalled();
+    });
+
+    it('keeps the breakdown when the reset is declined', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: GLOSSED_MORPHEMES, onSave });
+
+      await clearBreakdown();
+      await userEvent.click(
+        within(rowFor('ta-1')).getByTestId('morpheme-breakdown-confirm-cancel'),
+      );
+
+      expect(onSave).not.toHaveBeenCalled();
+      expect(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input')).toBeInTheDocument();
+    });
+
+    it('clears a breakdown carrying no morpheme glosses without asking', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: SEGMENTED_NO_GLOSSES, onSave });
+
+      await clearBreakdown();
+
+      const saved: TextAnalysis = onSave.mock.calls.at(-1)[0];
+      expect(saved.tokenAnalyses[0].morphemes).toBeUndefined();
+    });
+
+    /** Opens the breakdown editor on `ta-1` and re-splits it to `forms`, then saves. */
+    async function resplitBreakdown(forms: string): Promise<void> {
+      const row = await expandRow('ta-1');
+      await openBreakdown(row);
+      const input = within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, forms);
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-save'));
+    }
+
+    it('confirms before a re-split that strands a glossed morpheme', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: GLOSSED_MORPHEMES, onSave });
+
+      await resplitBreakdown('λογος');
+
+      expect(within(rowFor('ta-1')).getByTestId('morpheme-split-confirm')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_confirmResplitPrompt%',
+      );
+      expect(onSave).not.toHaveBeenCalled();
+    });
+
+    it('re-splits once the loss is confirmed', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: GLOSSED_MORPHEMES, onSave });
+
+      await resplitBreakdown('λογος');
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('morpheme-split-confirm-action'));
+
+      const saved: TextAnalysis = onSave.mock.calls.at(-1)[0];
+      expect(saved.tokenAnalyses[0].morphemes?.map((m) => m.form)).toEqual(['λογος']);
+    });
+
+    it('keeps the breakdown when the re-split is declined', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: GLOSSED_MORPHEMES, onSave });
+
+      await resplitBreakdown('λογος');
+      await userEvent.click(
+        within(rowFor('ta-1')).getByTestId('morpheme-breakdown-confirm-cancel'),
+      );
+
+      expect(onSave).not.toHaveBeenCalled();
+      expect(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input')).toHaveValue('λογος');
+    });
+
+    it('re-splits without asking when every glossed morpheme survives', async () => {
+      // Only the unglossed "ος" is dropped, and bare segmentation is cheap to retype.
+      const onSave = jest.fn();
+      renderPanel({ analysis: GLOSSED_MORPHEMES, onSave });
+
+      await resplitBreakdown('λογ');
+
+      const saved: TextAnalysis = onSave.mock.calls.at(-1)[0];
+      expect(saved.tokenAnalyses[0].morphemes?.map((m) => m.form)).toEqual(['λογ']);
+    });
+
+    it('keeps a breakdown draft across collapsing the row', async () => {
+      renderPanel({ analysis: SHARED });
+
+      const row = await expandRow('ta-1');
+      await openBreakdown(row);
+      const input = within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, 'λογ ος');
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      expect(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input')).toHaveValue('λογ ος');
+    });
+
+    it('keeps a breakdown draft across a search that stops listing the row', async () => {
+      renderPanel({ analysis: SHARED });
+
+      const row = await expandRow('ta-1');
+      await openBreakdown(row);
+      const input = within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, 'λογ ος');
+
+      await userEvent.type(searchBox(), 'zzz');
+      expect(screen.queryAllByTestId('catalog-row')).toHaveLength(0);
+      await userEvent.clear(searchBox());
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      expect(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input')).toHaveValue('λογ ος');
+    });
+
+    it('reports a held breakdown draft while its row is unmounted', async () => {
+      const onPendingEditsChange = jest.fn();
+      renderPanel({ analysis: SHARED, onPendingEditsChange });
+
+      const row = await expandRow('ta-1');
+      await openBreakdown(row);
+      await userEvent.type(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input'), '-ος');
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      expect(onPendingEditsChange).toHaveBeenLastCalledWith(true);
+    });
+
+    describe('closing over an unsaved breakdown', () => {
+      /** Opens the breakdown editor on `ta-1` and types a re-segmentation without saving it. */
+      async function typeUnsavedBreakdown() {
+        const row = await expandRow('ta-1');
+        await openBreakdown(row);
+        const input = within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input');
+        await userEvent.clear(input);
+        await userEvent.type(input, 'λογ ος');
+      }
+
+      it('asks before closing over a breakdown draft', async () => {
+        const onClose = jest.fn();
+        renderPanel({ analysis: SHARED, onClose });
+        await typeUnsavedBreakdown();
+
+        await userEvent.click(screen.getByTestId('analysis-catalog-close'));
+
+        expect(screen.getByTestId('catalog-close-title')).toBeInTheDocument();
+        expect(onClose).not.toHaveBeenCalled();
+      });
+
+      it('keeps the draft in hand when the close is declined', async () => {
+        const onClose = jest.fn();
+        renderPanel({ analysis: SHARED, onClose });
+        await typeUnsavedBreakdown();
+        await userEvent.click(screen.getByTestId('analysis-catalog-close'));
+
+        await userEvent.click(screen.getByTestId('catalog-close-cancel'));
+
+        expect(onClose).not.toHaveBeenCalled();
+        expect(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input')).toHaveValue(
+          'λογ ος',
+        );
+      });
+
+      it('closes without asking once the breakdown is saved', async () => {
+        const onClose = jest.fn();
+        renderPanel({ analysis: SHARED, onClose });
+        await typeUnsavedBreakdown();
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-save'));
+
+        await userEvent.click(screen.getByTestId('analysis-catalog-close'));
+
+        expect(onClose).toHaveBeenCalled();
+        expect(screen.queryByTestId('catalog-close-title')).not.toBeInTheDocument();
+      });
+
+      it('closes without asking when the draft only re-states the current breakdown', async () => {
+        const onClose = jest.fn();
+        renderPanel({ analysis: SHARED, onClose });
+        // The editor pre-fills the whole word, which is not typed work.
+        const row = await expandRow('ta-1');
+        await openBreakdown(row);
+
+        await userEvent.click(screen.getByTestId('analysis-catalog-close'));
+
+        expect(onClose).toHaveBeenCalled();
+      });
+
+      // An import can record the unsegmented state as one morpheme repeating the whole word.
+      it('closes without asking over an untouched breakdown of one morpheme spanning the word', async () => {
+        const onClose = jest.fn();
+        renderPanel({
+          analysis: {
+            ...SHARED,
+            tokenAnalyses: [
+              {
+                ...FIXTURE_STAMPS,
+                id: 'ta-1',
+                surfaceText: 'λόγος',
+                gloss: { en: 'word' },
+                morphemes: [{ id: 'm-1', form: 'λόγος', writingSystem: 'grc' }],
+              },
+            ],
+          },
+          onClose,
+        });
+        const row = await expandRow('ta-1');
+        await openBreakdown(row);
+
+        await userEvent.click(screen.getByTestId('analysis-catalog-close'));
+
+        expect(onClose).toHaveBeenCalled();
+      });
+
+      it('withdraws the question when the draft is canceled beneath it', async () => {
+        const onClose = jest.fn();
+        renderPanel({ analysis: SHARED, onClose });
+        await typeUnsavedBreakdown();
+        await userEvent.click(screen.getByTestId('analysis-catalog-close'));
+
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-cancel'));
+
+        expect(screen.queryByTestId('catalog-close-title')).not.toBeInTheDocument();
+        expect(onClose).not.toHaveBeenCalled();
+      });
+    });
+
+    describe('over a breakdown an edit beside the panel stranded', () => {
+      /**
+       * An analysis one token approves, carrying nothing but a gloss. Blanking that gloss from the
+       * view empties the record, which removes it — the shape that strands a draft. A record two
+       * tokens share forks instead, leaving the row standing.
+       */
+      const SOLE_USE: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'λόγος', gloss: { en: 'word' } },
+        ],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0')],
+      };
+
+      /**
+       * Opens the breakdown editor on `ta-1` and types a re-segmentation without saving it, in a
+       * panel rendered beside a probe standing in for the interlinear view.
+       */
+      async function typeStrandableBreakdown(overrides: PanelOptions = {}) {
+        const rendered = renderPanelWithGlossEditing({ analysis: SOLE_USE, ...overrides });
+        const row = await expandRow('ta-1');
+        await openBreakdown(row);
+        const input = within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input');
+        await userEvent.clear(input);
+        await userEvent.type(input, 'λογ ος');
+        return rendered;
+      }
+
+      it('reports the loss when an edit beside the panel removes the row', async () => {
+        mockKeyAsValueLocalizedStrings({
+          '%interlinearizer_analysisCatalog_draftStranded%': 'An edit removed {form}.',
+        });
+        await typeStrandableBreakdown();
+
+        act(() => editGloss('GEN 1:1:0', 'λόγος', ''));
+
+        // The form is all that is left to recognize the lost draft by, its record being gone.
+        expect(screen.getByTestId('catalog-stranded-draft-notice')).toHaveTextContent(
+          'An edit removed λόγος.',
+        );
+      });
+
+      it('dismisses the report on request', async () => {
+        await typeStrandableBreakdown();
+        act(() => editGloss('GEN 1:1:0', 'λόγος', ''));
+
+        await userEvent.click(screen.getByTestId('catalog-stranded-draft-notice-dismiss'));
+
+        expect(screen.queryByTestId('catalog-stranded-draft-notice')).not.toBeInTheDocument();
+      });
+
+      // Left in hand the draft would hold the unsaved mark on over work that can never be saved.
+      it('stops reporting uncommitted text once the draft is stranded', async () => {
+        const onPendingEditsChange = jest.fn();
+        await typeStrandableBreakdown({ onPendingEditsChange });
+        expect(onPendingEditsChange).toHaveBeenLastCalledWith(true);
+
+        act(() => editGloss('GEN 1:1:0', 'λόγος', ''));
+
+        expect(onPendingEditsChange).toHaveBeenLastCalledWith(false);
+      });
+
+      it('leaves a draft alone while its row is still listed', async () => {
+        await typeStrandableBreakdown();
+
+        act(() => editGloss('GEN 2:1:0', 'ἦν', 'was'));
+
+        expect(screen.queryByTestId('catalog-stranded-draft-notice')).not.toBeInTheDocument();
+        expect(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input')).toHaveValue(
+          'λογ ος',
+        );
+      });
+
+      it('does not report a draft the panel deleted the row for itself', async () => {
+        await typeStrandableBreakdown();
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-delete'));
+        await userEvent.click(screen.getByTestId('catalog-close-discard'));
+
+        await userEvent.click(screen.getByTestId('catalog-delete-confirm'));
+
+        expect(screen.queryByTestId('catalog-stranded-draft-notice')).not.toBeInTheDocument();
+      });
+    });
+
+    it('commits a gloss edit on Enter', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: SHARED, onSave });
+
+      const row = await expandRow('ta-1');
+      const input = within(row).getByTestId('catalog-row-gloss-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, 'message{Enter}');
+
+      const saved: TextAnalysis = onSave.mock.calls.at(-1)[0];
+      expect(saved.tokenAnalyses[0].gloss).toEqual({ en: 'message' });
+    });
+
+    it('reverts a gloss edit on Escape', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: SHARED, onSave });
+
+      const row = await expandRow('ta-1');
+      const input = within(row).getByTestId('catalog-row-gloss-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, 'message{Escape}');
+
+      // Reverted to the committed text, so the blur that follows has nothing left to write.
+      expect(input).toHaveAttribute('value', 'word');
+      await userEvent.tab();
+      expect(onSave).not.toHaveBeenCalled();
+    });
+
+    it('commits a breakdown edit on Enter', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: SHARED, onSave });
+
+      const row = await expandRow('ta-1');
+      await openBreakdown(row);
+      const input = within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, 'λογ ος{Enter}');
+
+      const saved: TextAnalysis = onSave.mock.calls.at(-1)[0];
+      expect(saved.tokenAnalyses[0].morphemes?.map((m) => m.form)).toEqual(['λογ', 'ος']);
+    });
+
+    it('abandons a breakdown edit on Escape', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: SHARED, onSave });
+
+      const row = await expandRow('ta-1');
+      await openBreakdown(row);
+      await userEvent.type(
+        within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input'),
+        'λογ ος{Escape}',
+      );
+
+      expect(onSave).not.toHaveBeenCalled();
+      expect(
+        within(rowFor('ta-1')).queryByTestId('morpheme-breakdown-input'),
+      ).not.toBeInTheDocument();
+    });
+
+    it('writes nothing when the editor is emptied, which reads as no breakdown at all', async () => {
+      const analysis: TextAnalysis = {
+        ...SHARED,
+        tokenAnalyses: [
+          {
+            ...SHARED.tokenAnalyses[0],
+            morphemes: [{ ...FIXTURE_STAMPS, id: 'm-1', form: 'λογ', writingSystem: 'el' }],
+          },
+        ],
+      };
+      const onSave = jest.fn();
+      renderPanel({ analysis, onSave });
+
+      const row = await expandRow('ta-1');
+      await openBreakdown(row);
+      await userEvent.clear(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input'));
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-save'));
+
+      // An empty field is one with nothing typed in it yet, not a request for the unsegmented
+      // state — which has its own control, so the save refuses rather than guessing between them.
+      expect(onSave).not.toHaveBeenCalled();
+      expect(within(rowFor('ta-1')).getByTestId('morpheme-empty-hint')).toBeInTheDocument();
+    });
+
+    it('keeps a whole-word draft as a one-morpheme breakdown', async () => {
+      const analysis: TextAnalysis = {
+        ...SHARED,
+        tokenAnalyses: [
+          {
+            ...SHARED.tokenAnalyses[0],
+            morphemes: [
+              { ...FIXTURE_STAMPS, id: 'm-1', form: 'λογ', writingSystem: 'el' },
+              { ...FIXTURE_STAMPS, id: 'm-2', form: 'ος', writingSystem: 'el' },
+            ],
+          },
+        ],
+      };
+      const onSave = jest.fn();
+      renderPanel({ analysis, onSave });
+
+      const row = await expandRow('ta-1');
+      await openBreakdown(row);
+      const input = within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input');
+      await userEvent.clear(input);
+      // Not a request for the unsegmented state, which has its own control.
+      await userEvent.type(input, 'λόγος');
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-save'));
+
+      const saved: TextAnalysis = onSave.mock.calls.at(-1)[0];
+      expect(saved.tokenAnalyses[0].morphemes?.map((m) => m.form)).toEqual(['λόγος']);
+    });
+
+    it('rewrites a morpheme gloss for every token linked to the analysis', async () => {
+      const analysis: TextAnalysis = {
+        ...SHARED,
+        tokenAnalyses: [
+          {
+            ...SHARED.tokenAnalyses[0],
+            morphemes: [{ ...FIXTURE_STAMPS, id: 'm-1', form: 'λογ', writingSystem: 'el' }],
+          },
+        ],
+      };
+      const onSave = jest.fn();
+      renderPanel({ analysis, onSave });
+
+      const row = await expandRow('ta-1');
+      await userEvent.type(
+        within(row).getByTestId('catalog-row-morpheme-gloss-input'),
+        'word-stem',
+      );
+      await userEvent.tab();
+
+      const saved: TextAnalysis = onSave.mock.calls.at(-1)[0];
+      expect(saved.tokenAnalyses[0].morphemes?.[0].gloss).toEqual({ en: 'word-stem' });
+    });
+
+    describe('reporting uncommitted text', () => {
+      /** One analysis with a breakdown, so the breakdown editor opens onto committed forms. */
+      const SEGMENTED: TextAnalysis = {
+        ...SHARED,
+        tokenAnalyses: [
+          {
+            ...SHARED.tokenAnalyses[0],
+            morphemes: [{ ...FIXTURE_STAMPS, id: 'm-1', form: 'λογ', writingSystem: 'el' }],
+          },
+        ],
+      };
+
+      it('reports a gloss held uncommitted, so the unsaved indicator lights while typing', async () => {
+        const onPendingEditsChange = jest.fn();
+        renderPanel({ analysis: SHARED, onPendingEditsChange });
+
+        const row = await expandRow('ta-1');
+        await userEvent.type(within(row).getByTestId('catalog-row-gloss-input'), '!');
+
+        expect(onPendingEditsChange).toHaveBeenLastCalledWith(true);
+      });
+
+      it('stops reporting a gloss once it commits on blur', async () => {
+        const onPendingEditsChange = jest.fn();
+        renderPanel({ analysis: SHARED, onPendingEditsChange });
+
+        const row = await expandRow('ta-1');
+        await userEvent.type(within(row).getByTestId('catalog-row-gloss-input'), '!');
+        await userEvent.tab();
+
+        expect(onPendingEditsChange).toHaveBeenLastCalledWith(false);
+      });
+
+      it('reports a breakdown held uncommitted', async () => {
+        const onPendingEditsChange = jest.fn();
+        renderPanel({ analysis: SEGMENTED, onPendingEditsChange });
+
+        const row = await expandRow('ta-1');
+        await openBreakdown(row);
+        await userEvent.type(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input'), '-ος');
+
+        expect(onPendingEditsChange).toHaveBeenLastCalledWith(true);
+      });
+
+      it('stops reporting a breakdown once it is canceled', async () => {
+        const onPendingEditsChange = jest.fn();
+        renderPanel({ analysis: SEGMENTED, onPendingEditsChange });
+
+        const row = await expandRow('ta-1');
+        await openBreakdown(row);
+        await userEvent.type(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input'), '-ος');
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-cancel'));
+
+        expect(onPendingEditsChange).toHaveBeenLastCalledWith(false);
+      });
+
+      // The editor pre-fills the whole word on an unsegmented row, which is not typed work.
+      it('reports nothing for a breakdown draft the reader has not touched', async () => {
+        const onPendingEditsChange = jest.fn();
+        renderPanel({ analysis: SHARED, onPendingEditsChange });
+
+        const row = await expandRow('ta-1');
+        await openBreakdown(row);
+
+        expect(onPendingEditsChange).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe('on a read-only analysis', () => {
+    /** An analysis with a breakdown and a homograph peer, so every control has something to act on. */
+    const READ_ONLY: TextAnalysis = {
+      ...emptyAnalysis(),
+      tokenAnalyses: [
+        {
+          ...FIXTURE_STAMPS,
+          id: 'ta-1',
+          surfaceText: 'λόγος',
+          gloss: { en: 'word' },
+          morphemes: [
+            {
+              ...FIXTURE_STAMPS,
+              id: 'm-1',
+              form: 'λογ',
+              gloss: { en: 'speak' },
+              writingSystem: 'el',
+            },
+            { ...FIXTURE_STAMPS, id: 'm-2', form: 'ος', gloss: { en: 'NOM' }, writingSystem: 'el' },
+          ],
+        },
+        { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'λόγος', gloss: { en: 'speech' } },
+      ],
+      tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0'), link('ta-2', 'GEN 1:2:0')],
+    };
+
+    /** Expands `ta-1` and returns its detail, where the edit controls would be. */
+    async function expandReadOnlyRow(): Promise<HTMLElement> {
+      renderPanel({ analysis: READ_ONLY, readOnly: true });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      return rowFor('ta-1');
+    }
+
+    // An import is not the extension's record to rewrite: the storage layer rejects the write, and
+    // the store has no save path, so an edit made here would vanish on the next remount.
+    it('renders the gloss as text rather than as an input', async () => {
+      const row = await expandReadOnlyRow();
+
+      expect(within(row).getByTestId('readonly-catalog-gloss')).toHaveTextContent('word');
+      expect(within(row).queryByTestId('catalog-row-gloss-input')).not.toBeInTheDocument();
+    });
+
+    it('renders the morpheme glosses as text rather than as inputs', async () => {
+      const row = await expandReadOnlyRow();
+
+      expect(
+        within(row)
+          .getAllByTestId('readonly-catalog-morpheme-gloss')
+          .map((el) => el.textContent),
+      ).toEqual(['speak', 'NOM']);
+      expect(within(row).queryByTestId('catalog-row-morpheme-gloss-input')).not.toBeInTheDocument();
+    });
+
+    it('shows the breakdown without the control that would re-segment it', async () => {
+      const row = await expandReadOnlyRow();
+
+      expect(
+        within(row)
+          .getAllByTestId('catalog-row-morpheme')
+          .map((el) => el.textContent),
+      ).toEqual(['λογ', 'ος']);
+      expect(within(row).queryByTestId('catalog-row-breakdown-open')).not.toBeInTheDocument();
+    });
+
+    it('withholds the merge and delete controls', async () => {
+      const row = await expandReadOnlyRow();
+
+      expect(within(row).queryByTestId('catalog-row-merge')).not.toBeInTheDocument();
+      expect(within(row).queryByTestId('catalog-row-delete')).not.toBeInTheDocument();
+    });
+
+    // The box's heading names a split the reader cannot make from a read-only row.
+    it('drops the breakdown box where the analysis segments nothing', async () => {
+      const unsegmented: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [{ ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'λόγος' }],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0')],
+      };
+      renderPanel({ analysis: unsegmented, readOnly: true });
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      expect(within(rowFor('ta-1')).queryByTestId('catalog-row-morpheme')).not.toBeInTheDocument();
+    });
+
+    it('still shows the gloss of an analysis that segments nothing', async () => {
+      const unsegmented: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'λόγος', gloss: { en: 'word' } },
+        ],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0')],
+      };
+      renderPanel({ analysis: unsegmented, analysisLanguage: 'en', readOnly: true });
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      expect(within(rowFor('ta-1')).getByTestId('readonly-catalog-gloss')).toHaveTextContent(
+        'word',
+      );
+    });
+
+    it('names an unglossed morpheme as unglossed rather than leaving it blank', async () => {
+      const unglossed: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          {
+            ...FIXTURE_STAMPS,
+            id: 'ta-1',
+            surfaceText: 'λόγος',
+            morphemes: [{ ...FIXTURE_STAMPS, id: 'm-1', form: 'λογ', writingSystem: 'el' }],
+          },
+        ],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0')],
+      };
+      renderPanel({ analysis: unglossed, readOnly: true });
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      expect(
+        within(rowFor('ta-1')).getByTestId('readonly-catalog-morpheme-gloss'),
+      ).toHaveTextContent('%interlinearizer_analysisCatalog_morphemeNoGloss%');
+    });
+
+    // Reading the catalog is the whole point of opening it on an import, so only the writes go.
+    it('still lists the analyses and their usages', async () => {
+      const row = await expandReadOnlyRow();
+
+      expect(listedAnalysisIds().toSorted()).toEqual(['ta-1', 'ta-2']);
+      expect(within(row).getByTestId('catalog-usage')).toHaveAttribute(
+        'data-token-ref',
+        'GEN 1:1:0',
+      );
+    });
+  });
+
+  describe('merging on edit', () => {
+    /** Two homographs whose glosses differ, so editing one into the other's collapses them. */
+    const TWO_HOMOGRAPHS: TextAnalysis = {
+      ...emptyAnalysis(),
+      tokenAnalyses: [
+        { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { en: 'start' } },
+        { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'ἀρχῇ', gloss: { en: 'beginning' } },
+      ],
+      tokenAnalysisLinks: [
+        link('ta-1', 'GEN 1:1:0'),
+        link('ta-2', 'GEN 1:3:4'),
+        link('ta-2', 'GEN 2:7:2'),
+      ],
+    };
+
+    /** Edits `ta-1`'s gloss to match `ta-2`'s, which collapses the two onto `ta-2`. */
+    async function editIntoEquality(): Promise<void> {
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      const input = within(rowFor('ta-1')).getByTestId('catalog-row-gloss-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, 'beginning');
+      await userEvent.tab();
+    }
+
+    it('drops the edited row and moves its usages onto the surviving one', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+
+      await editIntoEquality();
+
+      expect(listedAnalysisIds()).toEqual(['ta-2']);
+      expect(within(rowFor('ta-2')).getByTestId('catalog-row-usage-count')).toHaveTextContent('3');
+    });
+
+    it('announces where the edited row went', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+
+      await editIntoEquality();
+
+      // The notice names the surviving gloss and its new count, so a row vanishing while another's
+      // count jumps reads as the convergence it is rather than as lost work.
+      expect(screen.getByTestId('catalog-merge-notice')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_merged%',
+      );
+    });
+
+    it('names the survivor by its form when it carries no gloss', async () => {
+      const morphemes = [{ ...FIXTURE_STAMPS, id: 'm-1', form: 'ἀρχ', writingSystem: 'el' }];
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          // A breakdown apiece, so clearing ta-1's gloss leaves a record with content rather than
+          // an empty one — and one identical to ta-2, which collapses the two onto a survivor
+          // there is no gloss to name.
+          {
+            ...FIXTURE_STAMPS,
+            id: 'ta-1',
+            surfaceText: 'ἀρχῇ',
+            gloss: { en: 'start' },
+            morphemes,
+          },
+          { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'ἀρχῇ', morphemes },
+        ],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0'), link('ta-2', 'GEN 1:3:4')],
+      };
+      renderPanel({ analysis });
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      await userEvent.clear(within(rowFor('ta-1')).getByTestId('catalog-row-gloss-input'));
+      await userEvent.tab();
+
+      expect(screen.getByTestId('catalog-merge-notice')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_mergedNoGloss%',
+      );
+    });
+
+    it('leaves no notice when an edit empties the record away', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        // Gloss and nothing else, so clearing it leaves an empty record, which is removed outright
+        // rather than collapsed onto anything — there is no survivor to send the reader to.
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'λόγος', gloss: { en: 'word' } },
+        ],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0')],
+      };
+      renderPanel({ analysis });
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      await userEvent.clear(within(rowFor('ta-1')).getByTestId('catalog-row-gloss-input'));
+      await userEvent.tab();
+
+      expect(screen.queryByTestId('catalog-merge-notice')).not.toBeInTheDocument();
+      expect(screen.queryAllByTestId('catalog-row')).toHaveLength(0);
+    });
+
+    it('leaves no notice when the emptied record’s token keeps an unrelated candidate', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        // A token may carry several links at once, only the approved one being unique. Clearing the
+        // approved record's gloss empties it away, leaving the candidate behind untouched — which
+        // is not a collapse onto it, however much the surviving link looks like one.
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'λόγος', gloss: { en: 'word' } },
+          { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'λόγος', gloss: { en: 'reason' } },
+        ],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0'), link('ta-2', 'GEN 1:1:0', 'candidate')],
+      };
+      renderPanel({ analysis });
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      await userEvent.clear(within(rowFor('ta-1')).getByTestId('catalog-row-gloss-input'));
+      await userEvent.tab();
+
+      expect(screen.queryByTestId('catalog-merge-notice')).not.toBeInTheDocument();
+    });
+
+    it('announces where an unused row went', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        // ta-1 is unlinked, as an imported wordform inventory arrives. No usage count moves when it
+        // collapses, so the notice is all the reader gets.
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { en: 'start' } },
+          { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'ἀρχῇ', gloss: { en: 'beginning' } },
+        ],
+        tokenAnalysisLinks: [link('ta-2', 'GEN 1:3:4'), link('ta-2', 'GEN 2:7:2')],
+      };
+      renderPanel({ analysis });
+
+      await editIntoEquality();
+
+      expect(listedAnalysisIds()).toEqual(['ta-2']);
+      expect(screen.getByTestId('catalog-merge-notice')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_merged%',
+      );
+    });
+
+    it('leaves no notice when an edit collapses nothing', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      const input = within(rowFor('ta-1')).getByTestId('catalog-row-gloss-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, 'origin');
+      await userEvent.tab();
+
+      expect(screen.queryByTestId('catalog-merge-notice')).not.toBeInTheDocument();
+    });
+
+    // The earlier notice would name a row that is no longer there, over a count the merge moved.
+    it('replaces the notice when a merge takes the survivor it named away', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { en: 'start' } },
+          { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'ἀρχῇ', gloss: { en: 'beginning' } },
+          { ...FIXTURE_STAMPS, id: 'ta-3', surfaceText: 'ἀρχῇ', gloss: { en: 'origin' } },
+        ],
+        tokenAnalysisLinks: [
+          link('ta-1', 'GEN 1:1:0'),
+          link('ta-2', 'GEN 1:3:4'),
+          link('ta-3', 'GEN 2:7:2'),
+        ],
+      };
+      renderPanel({ analysis });
+      await editIntoEquality();
+      expect(screen.getByTestId('catalog-merge-notice')).toBeInTheDocument();
+
+      await userEvent.click(within(rowFor('ta-3')).getByTestId('catalog-row-toggle'));
+      await userEvent.click(within(rowFor('ta-3')).getByTestId('catalog-row-merge'));
+      await userEvent.click(mergeCheckFor('ta-2'));
+      await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+      expect(listedAnalysisIds()).toEqual(['ta-3']);
+      // Reporting the merge just made rather than the collapse an earlier edit caused.
+      expect(screen.getByTestId('catalog-merge-notice')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_merged%',
+      );
+    });
+
+    it('dismisses the notice from its own control', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+      await editIntoEquality();
+
+      await userEvent.click(screen.getByTestId('catalog-merge-notice-dismiss'));
+
+      expect(screen.queryByTestId('catalog-merge-notice')).not.toBeInTheDocument();
+    });
+
+    // Neither homograph is linked, so the survivor inherits no usages to carry it up the listing
+    // and stays wherever its gloss sorts it — here past the end of the window's first chunk.
+    it('mounts a survivor the window would otherwise leave off', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-src', surfaceText: 'ἀρχῇ', gloss: { en: 'aaa' } },
+          ...Array.from({ length: 100 }, (_unused, index) => ({
+            ...FIXTURE_STAMPS,
+            id: `filler-${index}`,
+            surfaceText: `word${index}`,
+            gloss: { en: `g${String(index).padStart(3, '0')}` },
+          })),
+          { ...FIXTURE_STAMPS, id: 'ta-dst', surfaceText: 'ἀρχῇ', gloss: { en: 'zzz' } },
+        ],
+        tokenAnalysisLinks: [],
+      };
+      renderPanel({ analysis });
+
+      await userEvent.click(screen.getByTestId('catalog-sort-gloss'));
+      expect(listedAnalysisIds()).not.toContain('ta-dst');
+
+      await userEvent.click(within(rowFor('ta-src')).getByTestId('catalog-row-toggle'));
+      const input = within(rowFor('ta-src')).getByTestId('catalog-row-gloss-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, 'zzz');
+      await userEvent.tab();
+
+      expect(screen.getByTestId('catalog-merge-notice')).toBeInTheDocument();
+      expect(listedAnalysisIds()).toContain('ta-dst');
+    });
+
+    // The notice outlives the listing it was raised against, so a search narrowing the survivor
+    // away leaves it naming a row that is nowhere to be mounted.
+    it('holds the notice when a search excludes the survivor', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+      await editIntoEquality();
+
+      await userEvent.type(searchBox(), 'zzz');
+
+      expect(screen.queryAllByTestId('catalog-row')).toHaveLength(0);
+      expect(screen.getByTestId('catalog-merge-notice')).toBeInTheDocument();
+    });
+  });
+
+  describe('merging into another row', () => {
+    const TWO_HOMOGRAPHS: TextAnalysis = {
+      ...emptyAnalysis(),
+      tokenAnalyses: [
+        { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { en: 'start' } },
+        { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'ἀρχῇ', gloss: { en: 'beginning' } },
+      ],
+      tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0'), link('ta-2', 'GEN 1:3:4')],
+    };
+
+    it('offers the merge control to a row with pool peers', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      expect(within(rowFor('ta-1')).getByTestId('catalog-row-merge')).toBeInTheDocument();
+    });
+
+    it('withholds the merge control from a row with no pool peers', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [{ ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'λόγος' }],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0')],
+      };
+      renderPanel({ analysis });
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      expect(within(rowFor('ta-1')).queryByTestId('catalog-row-merge')).not.toBeInTheDocument();
+    });
+
+    it('moves every usage onto the chosen target', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+      await userEvent.click(mergeCheckFor('ta-2'));
+      await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+      expect(listedAnalysisIds()).toEqual(['ta-1']);
+      expect(within(rowFor('ta-1')).getByTestId('catalog-row-usage-count')).toHaveTextContent('2');
+    });
+
+    it('names the surface form both sides share', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      expect(screen.getByTestId('catalog-merge-form')).toHaveTextContent('ἀρχῇ');
+      expect(screen.getByTestId('catalog-merge-form-label')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_mergeForm%',
+      );
+    });
+
+    // The stub renders tooltip content as the trigger's `title`, clipping being unmeasurable here.
+
+    it('starts the row the panel was opened from as the surviving analysis', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS, analysisLanguage: 'en' });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      expect(mergeCandidateIds()[0]).toBe('ta-1');
+      expect(mergeCheckFor('ta-1')).toBeDisabled();
+    });
+
+    it('leaves every other analysis out so the merge is not defaulted into', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS, analysisLanguage: 'en' });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      expect(mergeCheckFor('ta-2')).not.toBeChecked();
+      expect(screen.getByTestId('catalog-merge-confirm')).toBeDisabled();
+    });
+
+    it('lists every homograph, the opened row included', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          ...TWO_HOMOGRAPHS.tokenAnalyses,
+          { ...FIXTURE_STAMPS, id: 'ta-3', surfaceText: 'ἀρχῇ', gloss: { en: 'origin' } },
+        ],
+        tokenAnalysisLinks: [...TWO_HOMOGRAPHS.tokenAnalysisLinks, link('ta-3', 'GEN 1:5:2')],
+      };
+      renderPanel({ analysis });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      expect(mergeCandidateIds()).toEqual(['ta-1', 'ta-2', 'ta-3']);
+    });
+
+    it('makes a promoted analysis the one the rest are merged into', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      await userEvent.click(mergePromoteFor('ta-2'));
+
+      expect(mergeCandidateIds()[0]).toBe('ta-2');
+      // The analysis it displaced was going to survive, so it stays in the merge.
+      expect(mergeCheckFor('ta-1')).toBeChecked();
+    });
+
+    it('refuses to merge while nothing but the survivor is selected', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      expect(screen.getByTestId('catalog-merge-confirm')).toBeDisabled();
+    });
+
+    it('offers the merge once another analysis is selected', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      await userEvent.click(mergeCheckFor('ta-2'));
+
+      expect(screen.getByTestId('catalog-merge-confirm')).toBeEnabled();
+    });
+
+    it('merges into the analysis the panel was pointed at, not the row it was opened from', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          ...TWO_HOMOGRAPHS.tokenAnalyses,
+          { ...FIXTURE_STAMPS, id: 'ta-3', surfaceText: 'ἀρχῇ', gloss: { en: 'origin' } },
+        ],
+        tokenAnalysisLinks: [...TWO_HOMOGRAPHS.tokenAnalysisLinks, link('ta-3', 'GEN 1:5:2')],
+      };
+      renderPanel({ analysis });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      // Opened from ta-1, but redirected: promoting ta-3 leaves ta-1 in the merge it was heading.
+      await userEvent.click(mergePromoteFor('ta-3'));
+      await userEvent.click(mergeCheckFor('ta-2'));
+      await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+      expect(listedAnalysisIds()).toEqual(['ta-3']);
+      expect(within(rowFor('ta-3')).getByTestId('catalog-row-usage-count')).toHaveTextContent('3');
+    });
+
+    it('shows the opened row its morpheme breakdown beside its gloss', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          {
+            ...FIXTURE_STAMPS,
+            id: 'ta-1',
+            surfaceText: 'ἀρχῇ',
+            gloss: { en: 'start' },
+            morphemes: [
+              {
+                ...FIXTURE_STAMPS,
+                id: 'm-1',
+                form: 'ἀρχ',
+                gloss: { en: 'begin' },
+                writingSystem: 'el',
+              },
+              {
+                ...FIXTURE_STAMPS,
+                id: 'm-2',
+                form: 'ῇ',
+                gloss: { en: 'DAT' },
+                writingSystem: 'el',
+              },
+            ],
+          },
+          { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'ἀρχῇ', gloss: { en: 'beginning' } },
+        ],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0'), link('ta-2', 'GEN 1:3:4')],
+      };
+      renderPanel({ analysis, analysisLanguage: 'en' });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      const breakdown = within(mergeCandidateFor('ta-1')).getByTestId('catalog-merge-breakdown');
+      expect(breakdown).toHaveTextContent('ἀρχ');
+      expect(breakdown).toHaveTextContent('DAT');
+    });
+
+    it('shows each candidate its morpheme breakdown beside its gloss', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { en: 'start' } },
+          {
+            ...FIXTURE_STAMPS,
+            id: 'ta-2',
+            surfaceText: 'ἀρχῇ',
+            gloss: { en: 'beginning' },
+            morphemes: [
+              {
+                ...FIXTURE_STAMPS,
+                id: 'm-1',
+                form: 'ἀρχ',
+                gloss: { en: 'begin' },
+                writingSystem: 'el',
+              },
+              {
+                ...FIXTURE_STAMPS,
+                id: 'm-2',
+                form: 'ῇ',
+                gloss: { en: 'DAT' },
+                writingSystem: 'el',
+              },
+            ],
+          },
+        ],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0'), link('ta-2', 'GEN 1:3:4')],
+      };
+      renderPanel({ analysis, analysisLanguage: 'en' });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      const breakdown = within(mergeCandidateFor('ta-2')).getByTestId('catalog-merge-breakdown');
+      expect(breakdown).toHaveTextContent('ἀρχ');
+      expect(breakdown).toHaveTextContent('DAT');
+    });
+
+    it('says so outright on a target that carries no breakdown', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS, analysisLanguage: 'en' });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      // Blank where a breakdown would be reads as a rendering fault rather than as an analysis
+      // that segments nothing, which is what the reader is choosing between.
+      expect(
+        within(mergeCandidateFor('ta-2')).getByTestId('catalog-merge-morpheme-none'),
+      ).toHaveTextContent('%interlinearizer_analysisCatalog_noBreakdown%');
+    });
+
+    it('leaves both analyses alone when the picker is canceled', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+      await userEvent.click(screen.getByTestId('catalog-merge-cancel'));
+
+      // Both still listed; the order is the default most-used-first, which the two tie on.
+      expect(listedAnalysisIds()).toHaveLength(2);
+      expect(listedAnalysisIds()).toContain('ta-1');
+      expect(listedAnalysisIds()).toContain('ta-2');
+    });
+
+    it('labels a candidate that carries no gloss rather than leaving it nameless', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { en: 'start' } },
+          {
+            ...FIXTURE_STAMPS,
+            id: 'ta-2',
+            surfaceText: 'ἀρχῇ',
+            morphemes: [{ ...FIXTURE_STAMPS, id: 'm-1', form: 'ἀρχ', writingSystem: 'el' }],
+          },
+        ],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0'), link('ta-2', 'GEN 1:3:4')],
+      };
+      renderPanel({ analysis });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      // The stub leaves every key unresolved, which stands in for the lookup not having landed —
+      // so the candidate falls back to the em dash rather than being offered as a blank choice.
+      expect(
+        within(mergeCandidateFor('ta-2')).getByTestId('catalog-merge-gloss'),
+      ).toHaveTextContent('—');
+    });
+
+    it('refuses to merge until a target is chosen', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      expect(screen.getByTestId('catalog-merge-confirm')).toBeDisabled();
+    });
+
+    // The merge is allowed to converge; the panel warns first, and the notice then names the record
+    // the collapse actually left standing rather than the one the merge was aimed at.
+    it('reports the analysis a converging merge left standing', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { en: 'start' } },
+          { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'ἀρχῇ', gloss: { en: 'beginning' } },
+          { ...FIXTURE_STAMPS, id: 'ta-3', surfaceText: 'ἀρχῇ', gloss: { en: 'origin' } },
+        ],
+        tokenAnalysisLinks: [
+          link('ta-1', 'GEN 1:1:0'),
+          link('ta-2', 'GEN 1:3:4'),
+          link('ta-3', 'GEN 2:7:2'),
+        ],
+      };
+      renderPanel({ analysis, analysisLanguage: 'en' });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+      await userEvent.click(mergeCheckFor('ta-2'));
+
+      // Edited to say what ta-3 says, which the merge leaves out — so the survivor collapses onto it.
+      const gloss = screen.getByTestId('catalog-merge-content-gloss');
+      await userEvent.clear(gloss);
+      await userEvent.type(gloss, 'origin');
+      expect(screen.getByTestId('catalog-merge-collapse-warning')).toBeInTheDocument();
+      await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+      expect(listedAnalysisIds()).toEqual(['ta-3']);
+      expect(within(rowFor('ta-3')).getByTestId('catalog-row-usage-count')).toHaveTextContent('3');
+      expect(screen.getByTestId('catalog-merge-notice')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_merged%',
+      );
+    });
+
+    // A notice would name a row the listing no longer has.
+    it('raises no notice when a merge settled on nothing takes every record away', async () => {
+      renderPanel({ analysis: TWO_HOMOGRAPHS });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+      await userEvent.click(mergeCheckFor('ta-2'));
+
+      await userEvent.clear(screen.getByTestId('catalog-merge-content-gloss'));
+      await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+      expect(screen.getByTestId('analysis-catalog-empty')).toBeInTheDocument();
+      expect(screen.queryByTestId('catalog-merge-notice')).not.toBeInTheDocument();
+    });
+
+    describe('over an unsaved breakdown', () => {
+      /** Expands `ta-1` and types a re-segmentation into it without saving. */
+      async function typeUnsavedBreakdown(analysisId = 'ta-1') {
+        await userEvent.click(within(rowFor(analysisId)).getByTestId('catalog-row-toggle'));
+        await openBreakdown(rowFor(analysisId));
+        const input = within(rowFor(analysisId)).getByTestId('morpheme-breakdown-input');
+        await userEvent.clear(input);
+        await userEvent.type(input, 'ἀρχ ῇ');
+      }
+
+      it('asks before merging away the analysis a breakdown draft is keyed to', async () => {
+        renderPanel({ analysis: TWO_HOMOGRAPHS });
+        await typeUnsavedBreakdown();
+
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+        expect(screen.getByTestId('catalog-close-title')).toBeInTheDocument();
+        expect(screen.queryByTestId('catalog-merge-confirm')).not.toBeInTheDocument();
+      });
+
+      it('keeps the draft and both analyses when the discard is declined', async () => {
+        renderPanel({ analysis: TWO_HOMOGRAPHS });
+        await typeUnsavedBreakdown();
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+        await userEvent.click(screen.getByTestId('catalog-close-cancel'));
+
+        expect(listedAnalysisIds()).toHaveLength(2);
+        expect(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input')).toHaveValue('ἀρχ ῇ');
+      });
+
+      it('opens the merge picker once the draft is given up', async () => {
+        renderPanel({ analysis: TWO_HOMOGRAPHS });
+        await typeUnsavedBreakdown();
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+        await userEvent.click(screen.getByTestId('catalog-close-discard'));
+
+        expect(screen.getByTestId('catalog-merge-confirm')).toBeInTheDocument();
+        expect(listedAnalysisIds()).toHaveLength(2);
+      });
+
+      // The opening ask covers only the row the picker was opened from.
+      it('asks before a confirmed merge spends an analysis a draft is keyed to', async () => {
+        const analysis: TextAnalysis = {
+          ...emptyAnalysis(),
+          tokenAnalyses: [
+            ...TWO_HOMOGRAPHS.tokenAnalyses,
+            { ...FIXTURE_STAMPS, id: 'ta-3', surfaceText: 'ἀρχῇ', gloss: { en: 'origin' } },
+          ],
+          tokenAnalysisLinks: [...TWO_HOMOGRAPHS.tokenAnalysisLinks, link('ta-3', 'GEN 1:5:2')],
+        };
+        renderPanel({ analysis });
+        await typeUnsavedBreakdown();
+
+        // Opened from ta-2, which carries no draft, then made to fold in ta-1, which does.
+        await userEvent.click(within(rowFor('ta-2')).getByTestId('catalog-row-toggle'));
+        await userEvent.click(within(rowFor('ta-2')).getByTestId('catalog-row-merge'));
+        await userEvent.click(mergeCheckFor('ta-1'));
+        await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+        expect(screen.getByTestId('catalog-close-title')).toBeInTheDocument();
+        expect(listedAnalysisIds()).toHaveLength(3);
+      });
+
+      it('merges the analysis whose draft was given up', async () => {
+        const analysis: TextAnalysis = {
+          ...emptyAnalysis(),
+          tokenAnalyses: [
+            ...TWO_HOMOGRAPHS.tokenAnalyses,
+            { ...FIXTURE_STAMPS, id: 'ta-3', surfaceText: 'ἀρχῇ', gloss: { en: 'origin' } },
+          ],
+          tokenAnalysisLinks: [...TWO_HOMOGRAPHS.tokenAnalysisLinks, link('ta-3', 'GEN 1:5:2')],
+        };
+        renderPanel({ analysis });
+        await typeUnsavedBreakdown();
+        await userEvent.click(within(rowFor('ta-2')).getByTestId('catalog-row-toggle'));
+        await userEvent.click(within(rowFor('ta-2')).getByTestId('catalog-row-merge'));
+        await userEvent.click(mergeCheckFor('ta-1'));
+        await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+        await userEvent.click(screen.getByTestId('catalog-close-discard'));
+
+        expect(listedAnalysisIds()).not.toContain('ta-1');
+        expect(within(rowFor('ta-2')).getByTestId('catalog-row-usage-count')).toHaveTextContent(
+          '2',
+        );
+      });
+
+      /** Three records of the one form, so a merge can be opened from a row carrying no draft. */
+      const THREE_HOMOGRAPHS: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          ...TWO_HOMOGRAPHS.tokenAnalyses,
+          { ...FIXTURE_STAMPS, id: 'ta-3', surfaceText: 'ἀρχῇ', gloss: { en: 'origin' } },
+        ],
+        tokenAnalysisLinks: [...TWO_HOMOGRAPHS.tokenAnalysisLinks, link('ta-3', 'GEN 1:5:2')],
+      };
+
+      /** Opens the picker on the undrafted `ta-3` and folds both drafted records into it. */
+      async function confirmMergeOfBothDrafts() {
+        await typeUnsavedBreakdown('ta-1');
+        await typeUnsavedBreakdown('ta-2');
+        await userEvent.click(within(rowFor('ta-3')).getByTestId('catalog-row-toggle'));
+        await userEvent.click(within(rowFor('ta-3')).getByTestId('catalog-row-merge'));
+        await userEvent.click(mergeCheckFor('ta-1'));
+        await userEvent.click(mergeCheckFor('ta-2'));
+        await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+      }
+
+      // One agreement is a decision about the draft it named, not about every other draft the same
+      // merge would spend.
+      it('asks once per draft when a merge would spend more than one', async () => {
+        renderPanel({ analysis: THREE_HOMOGRAPHS });
+        await confirmMergeOfBothDrafts();
+
+        await userEvent.click(screen.getByTestId('catalog-close-discard'));
+
+        expect(screen.getByTestId('catalog-close-title')).toBeInTheDocument();
+        expect(listedAnalysisIds()).toHaveLength(3);
+      });
+
+      it('merges once every draft it would spend has been given up', async () => {
+        renderPanel({ analysis: THREE_HOMOGRAPHS });
+        await confirmMergeOfBothDrafts();
+
+        await userEvent.click(screen.getByTestId('catalog-close-discard'));
+        await userEvent.click(screen.getByTestId('catalog-close-discard'));
+
+        expect(listedAnalysisIds()).toEqual(['ta-3']);
+      });
+
+      it('returns to the panel with the same analyses selected when the ask is declined', async () => {
+        const analysis: TextAnalysis = {
+          ...emptyAnalysis(),
+          tokenAnalyses: [
+            ...TWO_HOMOGRAPHS.tokenAnalyses,
+            { ...FIXTURE_STAMPS, id: 'ta-3', surfaceText: 'ἀρχῇ', gloss: { en: 'origin' } },
+          ],
+          tokenAnalysisLinks: [...TWO_HOMOGRAPHS.tokenAnalysisLinks, link('ta-3', 'GEN 1:5:2')],
+        };
+        renderPanel({ analysis });
+        await typeUnsavedBreakdown();
+        await userEvent.click(within(rowFor('ta-2')).getByTestId('catalog-row-toggle'));
+        await userEvent.click(within(rowFor('ta-2')).getByTestId('catalog-row-merge'));
+        await userEvent.click(mergeCheckFor('ta-1'));
+        await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+        await userEvent.click(screen.getByTestId('catalog-close-cancel'));
+
+        expect(mergeCheckFor('ta-1')).toBeChecked();
+        expect(listedAnalysisIds()).toHaveLength(3);
+      });
+
+      it('stops warning about a draft whose analysis the merge took with it', async () => {
+        const onClose = jest.fn();
+        renderPanel({ analysis: TWO_HOMOGRAPHS, onClose });
+        await typeUnsavedBreakdown();
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+        await userEvent.click(screen.getByTestId('catalog-close-discard'));
+        await userEvent.click(mergeCheckFor('ta-2'));
+        await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+        await userEvent.click(screen.getByTestId('analysis-catalog-close'));
+
+        expect(onClose).toHaveBeenCalled();
+      });
+    });
+
+    // The store refuses a merge into a record that is gone, so a picker left confirmable would
+    // close on a merge that never happened, reporting nothing.
+    it('withholds confirmation once an edit removes the only analysis selected', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          ...TWO_HOMOGRAPHS.tokenAnalyses,
+          { ...FIXTURE_STAMPS, id: 'ta-3', surfaceText: 'ἀρχῇ', gloss: { en: 'origin' } },
+        ],
+        tokenAnalysisLinks: [...TWO_HOMOGRAPHS.tokenAnalysisLinks, link('ta-3', 'GEN 1:5:2')],
+      };
+      renderPanelWithGlossEditing({ analysis, analysisLanguage: 'en' });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+      await userEvent.click(mergeCheckFor('ta-2'));
+
+      // Emptying its gloss removes the record, taking it out of the panel's candidates.
+      act(() => editGloss('GEN 1:3:4', 'word', ''));
+
+      expect(screen.getByTestId('catalog-merge-confirm')).toBeDisabled();
+    });
+
+    // A record left alone in its form has no homograph to merge with, so nothing to choose.
+    it('closes the picker once an edit leaves the opened row its form alone', async () => {
+      renderPanelWithGlossEditing({ analysis: TWO_HOMOGRAPHS, analysisLanguage: 'en' });
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-merge'));
+
+      act(() => editGloss('GEN 1:3:4', 'word', ''));
+
+      expect(screen.queryByTestId('catalog-merge-title')).not.toBeInTheDocument();
+      expect(listedAnalysisIds()).toEqual(['ta-1']);
+    });
+  });
+
+  describe('deleting a row', () => {
+    /** One analysis nothing else shares a form with, so deleting it leaves its token blank. */
+    const LONE: TextAnalysis = {
+      ...emptyAnalysis(),
+      tokenAnalyses: [
+        { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'λόγος', gloss: { en: 'word' } },
+      ],
+      tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0'), link('ta-1', 'GEN 1:3:4')],
+    };
+
+    /** Expands the row and opens its delete confirmation. */
+    async function openDeleteConfirm(analysisId: string): Promise<void> {
+      await userEvent.click(within(rowFor(analysisId)).getByTestId('catalog-row-toggle'));
+      await userEvent.click(within(rowFor(analysisId)).getByTestId('catalog-row-delete'));
+    }
+
+    it('states that the uses are left blank when no homograph survives', async () => {
+      renderPanel({ analysis: LONE });
+
+      await openDeleteConfirm('ta-1');
+
+      expect(screen.getByTestId('catalog-delete-outcome')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_deleteBlank%',
+      );
+    });
+
+    it('states the fallback the uses take when a homograph survives', async () => {
+      const analysis: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { en: 'start' } },
+          { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'ἀρχῇ', gloss: { en: 'beginning' } },
+        ],
+        tokenAnalysisLinks: [
+          link('ta-1', 'GEN 1:1:0'),
+          link('ta-1', 'GEN 1:3:4'),
+          link('ta-2', 'GEN 2:7:2'),
+        ],
+      };
+      renderPanel({ analysis, showSuggestions: true });
+
+      await openDeleteConfirm('ta-1');
+
+      // The two outcomes must be told apart: this copy is the only guard before an irreversible
+      // delete, and promising a fallback that does not exist is worse than no confirmation at all.
+      expect(screen.getByTestId('catalog-delete-outcome')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_deleteFallback%',
+      );
+    });
+
+    /** Two homographs, the first used twice, so deleting it falls back to the second. */
+    const TWO_HOMOGRAPHS: TextAnalysis = {
+      ...emptyAnalysis(),
+      tokenAnalyses: [
+        { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { en: 'start' } },
+        { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'ἀρχῇ', gloss: { en: 'beginning' } },
+      ],
+      tokenAnalysisLinks: [
+        link('ta-1', 'GEN 1:1:0'),
+        link('ta-1', 'GEN 1:3:4'),
+        link('ta-2', 'GEN 2:7:2'),
+      ],
+    };
+
+    it('describes rather than names the fallback when a use has drifted off its analyzed form', async () => {
+      renderPanel({
+        analysis: TWO_HOMOGRAPHS,
+        // Analyzed as "ἀρχῇ", but the baseline beneath it now reads otherwise.
+        liveSurfaceText: (ref) => (ref === 'GEN 1:3:4' ? 'ἀρχή' : 'ἀρχῇ'),
+        showSuggestions: true,
+      });
+
+      await openDeleteConfirm('ta-1');
+
+      expect(screen.getByTestId('catalog-delete-outcome')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_deleteFallbackDrifted%',
+      );
+    });
+
+    it('describes rather than names the fallback when a use sits in an unloaded book', async () => {
+      renderPanel({
+        analysis: TWO_HOMOGRAPHS,
+        liveSurfaceText: (ref) => (ref === 'GEN 1:3:4' ? undefined : 'ἀρχῇ'),
+        showSuggestions: true,
+      });
+
+      await openDeleteConfirm('ta-1');
+
+      expect(screen.getByTestId('catalog-delete-outcome')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_deleteFallbackDrifted%',
+      );
+    });
+
+    it('states that nothing else changes when the analysis is used nowhere', async () => {
+      const analysis: TextAnalysis = { ...LONE, tokenAnalysisLinks: [] };
+      renderPanel({ analysis });
+
+      await openDeleteConfirm('ta-1');
+
+      expect(screen.getByTestId('catalog-delete-outcome')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_deleteBlankNone%',
+      );
+    });
+
+    it('says nothing about unapplied assignments when there are none', async () => {
+      const analysis: TextAnalysis = { ...LONE, tokenAnalysisLinks: [] };
+      renderPanel({ analysis });
+
+      await openDeleteConfirm('ta-1');
+
+      expect(screen.queryByTestId('catalog-delete-unapplied')).not.toBeInTheDocument();
+    });
+
+    // An imported analysis no token approves still shows on screen nowhere, so the outcome line
+    // rightly says nothing changes — this second line is what tells the reader data goes with it.
+    it('warns that unapplied assignments are deleted too', async () => {
+      const analysis: TextAnalysis = {
+        ...LONE,
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0', 'candidate')],
+      };
+      renderPanel({ analysis });
+
+      await openDeleteConfirm('ta-1');
+
+      expect(screen.getByTestId('catalog-delete-outcome')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_deleteBlankNone%',
+      );
+      expect(screen.getByTestId('catalog-delete-unapplied')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_deleteUnapplied%',
+      );
+    });
+
+    /** Two homographs, the first used twice, so deleting it falls back to the second. */
+    const UNGLOSSED_FALLBACK: TextAnalysis = {
+      ...emptyAnalysis(),
+      tokenAnalyses: [
+        { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { en: 'start' } },
+        // A breakdown but no gloss: analyzed enough to win the fallback, with no word to quote.
+        {
+          ...FIXTURE_STAMPS,
+          id: 'ta-2',
+          surfaceText: 'ἀρχῇ',
+          morphemes: [{ ...FIXTURE_STAMPS, id: 'm-1', form: 'ἀρχ', writingSystem: 'el' }],
+        },
+      ],
+      tokenAnalysisLinks: [
+        link('ta-1', 'GEN 1:1:0'),
+        link('ta-1', 'GEN 1:3:4'),
+        link('ta-2', 'GEN 2:7:2'),
+      ],
+    };
+
+    it('describes a fallback that carries no gloss rather than naming it', async () => {
+      renderPanel({ analysis: UNGLOSSED_FALLBACK, showSuggestions: true });
+
+      await openDeleteConfirm('ta-1');
+
+      expect(screen.getByTestId('catalog-delete-outcome')).toHaveTextContent(
+        '%interlinearizer_analysisCatalog_deleteFallbackNoGloss%',
+      );
+    });
+
+    // Committing on the outcome the reader was shown would blank every affected use after
+    // promising them a word, which is the one mistake this irreversible copy exists to prevent.
+    describe('over a fallback an edit beside the panel withdrew', () => {
+      const FALLBACK: TextAnalysis = {
+        ...emptyAnalysis(),
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { en: 'start' } },
+          { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'ἀρχῇ', gloss: { en: 'beginning' } },
+        ],
+        tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0'), link('ta-2', 'GEN 1:3:4')],
+      };
+
+      it('restates the outcome rather than deleting on the withdrawn promise', async () => {
+        renderPanelWithGlossEditing({
+          analysis: FALLBACK,
+          analysisLanguage: 'en',
+          showSuggestions: true,
+        });
+        await openDeleteConfirm('ta-1');
+        expect(screen.getByTestId('catalog-delete-outcome')).toHaveTextContent(
+          '%interlinearizer_analysisCatalog_deleteFallback%',
+        );
+
+        act(() => editGloss('GEN 1:3:4', 'word', ''));
+        await userEvent.click(screen.getByTestId('catalog-delete-confirm'));
+
+        expect(screen.getByTestId('catalog-delete-outcome')).toHaveTextContent(
+          '%interlinearizer_analysisCatalog_deleteBlank%',
+        );
+      });
+
+      it('keeps the analysis until the restated outcome is confirmed', async () => {
+        const onSave = jest.fn();
+        renderPanelWithGlossEditing({
+          analysis: FALLBACK,
+          analysisLanguage: 'en',
+          showSuggestions: true,
+          onSave,
+        });
+        await openDeleteConfirm('ta-1');
+        act(() => editGloss('GEN 1:3:4', 'word', ''));
+
+        await userEvent.click(screen.getByTestId('catalog-delete-confirm'));
+
+        expect(listedAnalysisIds()).toContain('ta-1');
+      });
+
+      it('deletes once the restated outcome is confirmed in turn', async () => {
+        renderPanelWithGlossEditing({
+          analysis: FALLBACK,
+          analysisLanguage: 'en',
+          showSuggestions: true,
+        });
+        await openDeleteConfirm('ta-1');
+        act(() => editGloss('GEN 1:3:4', 'word', ''));
+        await userEvent.click(screen.getByTestId('catalog-delete-confirm'));
+
+        await userEvent.click(screen.getByTestId('catalog-delete-confirm'));
+
+        expect(screen.queryAllByTestId('catalog-row')).toHaveLength(0);
+      });
+    });
+
+    it('removes the analysis and its links when confirmed', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: LONE, onSave });
+      await openDeleteConfirm('ta-1');
+
+      await userEvent.click(screen.getByTestId('catalog-delete-confirm'));
+
+      const saved: TextAnalysis = onSave.mock.calls.at(-1)[0];
+      expect(saved.tokenAnalyses).toEqual([]);
+      expect(saved.tokenAnalysisLinks).toEqual([]);
+    });
+
+    it('leaves the analysis untouched when the confirmation is canceled', async () => {
+      const onSave = jest.fn();
+      renderPanel({ analysis: LONE, onSave });
+      await openDeleteConfirm('ta-1');
+
+      await userEvent.click(screen.getByTestId('catalog-delete-cancel'));
+
+      expect(onSave).not.toHaveBeenCalled();
+      expect(listedAnalysisIds()).toEqual(['ta-1']);
+    });
+
+    describe('over an unsaved breakdown', () => {
+      /** Expands the row and types a re-segmentation into it without saving. */
+      async function typeUnsavedBreakdown(analysisId: string) {
+        await userEvent.click(within(rowFor(analysisId)).getByTestId('catalog-row-toggle'));
+        await openBreakdown(rowFor(analysisId));
+        const input = within(rowFor(analysisId)).getByTestId('morpheme-breakdown-input');
+        await userEvent.clear(input);
+        await userEvent.type(input, 'λογ ος');
+      }
+
+      it('asks before deleting the analysis a breakdown draft is keyed to', async () => {
+        renderPanel({ analysis: LONE });
+        await typeUnsavedBreakdown('ta-1');
+
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-delete'));
+
+        // The draft is put to the reader before the deletion is, so declining costs them nothing.
+        expect(screen.getByTestId('catalog-close-title')).toBeInTheDocument();
+        expect(screen.queryByTestId('catalog-delete-confirm')).not.toBeInTheDocument();
+      });
+
+      it('keeps the draft and the analysis when the discard is declined', async () => {
+        const onSave = jest.fn();
+        renderPanel({ analysis: LONE, onSave });
+        await typeUnsavedBreakdown('ta-1');
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-delete'));
+
+        await userEvent.click(screen.getByTestId('catalog-close-cancel'));
+
+        expect(onSave).not.toHaveBeenCalled();
+        expect(within(rowFor('ta-1')).getByTestId('morpheme-breakdown-input')).toHaveValue(
+          'λογ ος',
+        );
+      });
+
+      it('puts the deletion itself to the reader once the draft is given up', async () => {
+        const onSave = jest.fn();
+        renderPanel({ analysis: LONE, onSave });
+        await typeUnsavedBreakdown('ta-1');
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-delete'));
+
+        await userEvent.click(screen.getByTestId('catalog-close-discard'));
+
+        // Giving up the draft is not consent to the deletion, which still has its own say.
+        expect(screen.getByTestId('catalog-delete-confirm')).toBeInTheDocument();
+        expect(onSave).not.toHaveBeenCalled();
+      });
+
+      it('deletes without asking about a draft that re-states the current breakdown', async () => {
+        renderPanel({ analysis: LONE });
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-toggle'));
+        await openBreakdown(rowFor('ta-1'));
+
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-delete'));
+
+        expect(screen.getByTestId('catalog-delete-confirm')).toBeInTheDocument();
+        expect(screen.queryByTestId('catalog-close-title')).not.toBeInTheDocument();
+      });
+
+      it('stops warning about a draft whose analysis the deletion took with it', async () => {
+        const onClose = jest.fn();
+        renderPanel({ analysis: LONE, onClose });
+        await typeUnsavedBreakdown('ta-1');
+        await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-delete'));
+        await userEvent.click(screen.getByTestId('catalog-close-discard'));
+        await userEvent.click(screen.getByTestId('catalog-delete-confirm'));
+
+        await userEvent.click(screen.getByTestId('analysis-catalog-close'));
+
+        expect(onClose).toHaveBeenCalled();
+      });
+    });
+  });
 });
diff --git a/src/__tests__/components/AnalysisStore.test.tsx b/src/__tests__/components/AnalysisStore.test.tsx
index 546cdf16d..e6fe412a9 100644
--- a/src/__tests__/components/AnalysisStore.test.tsx
+++ b/src/__tests__/components/AnalysisStore.test.tsx
@@ -5,11 +5,15 @@ import { act, render, renderHook, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import type { TextAnalysis, TokenAnalysis, TokenAnalysisLink } from 'interlinearizer';
 import type { ReactNode } from 'react';
+import { emptyAnalysis } from '../../types/empty-factories';
 import { FIXTURE_STAMPS } from '../test-helpers';
+import type { AnalysisEditOutcome } from '../../components/AnalysisStore';
 import {
   AnalysisStoreProvider,
   useAnalysis,
+  useAnalysisDeletionOutcome,
   useAnalysisLanguage,
+  useAnalysisRowDispatch,
   useApproveAnalysisDispatch,
   useGloss,
   useGlossDispatch,
@@ -137,6 +141,8 @@ function renderStoreHook<T>(
     initialAnalysis?: TextAnalysis;
     onSave?: (analysis: TextAnalysis) => void;
     onGlossChange?: (tokenRef: string, value: string) => void;
+    showSuggestions?: boolean;
+    readOnly?: boolean;
   }> = {},
 ) {
   const { analysisLanguage = 'und', ...rest } = options;
@@ -1536,3 +1542,229 @@ describe('useApproveAnalysisDispatch', () => {
     );
   });
 });
+
+function approvedLink(analysisId: string, tokenRef: string): TokenAnalysisLink {
+  return {
+    ...FIXTURE_STAMPS,
+    analysisId,
+    token: { tokenRef, surfaceText: 'ἀρχῇ' },
+    status: 'approved',
+  };
+}
+
+/** Two homographs glossed differently, so editing `ta-1` into `ta-2`'s gloss collapses them. */
+function twoHomographs(links: readonly TokenAnalysisLink[]): TextAnalysis {
+  return {
+    ...emptyAnalysis(),
+    tokenAnalyses: [
+      { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { und: 'start' } },
+      { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'ἀρχῇ', gloss: { und: 'beginning' } },
+    ],
+    tokenAnalysisLinks: [...links],
+  };
+}
+
+describe('useAnalysisRowDispatch', () => {
+  it('reports an ordinary edit as leaving the record standing', () => {
+    const { result } = renderStoreHook(() => useAnalysisRowDispatch(), {
+      initialAnalysis: twoHomographs([approvedLink('ta-1', 'tok-1')]),
+    });
+
+    let outcome: AnalysisEditOutcome | undefined;
+    act(() => {
+      outcome = result.current.writeGloss('ta-1', 'origin');
+    });
+
+    expect(outcome).toStrictEqual({ kind: 'edited' });
+  });
+
+  it('reports a collapse onto a sibling, naming the survivor', () => {
+    const { result } = renderStoreHook(() => useAnalysisRowDispatch(), {
+      initialAnalysis: twoHomographs([
+        approvedLink('ta-1', 'tok-1'),
+        approvedLink('ta-2', 'tok-2'),
+      ]),
+    });
+
+    let outcome: AnalysisEditOutcome | undefined;
+    act(() => {
+      outcome = result.current.writeGloss('ta-1', 'beginning');
+    });
+
+    expect(outcome).toStrictEqual({
+      kind: 'merged',
+      survivingAnalysisId: 'ta-2',
+      survivingGloss: 'beginning',
+      survivingUsageCount: 2,
+    });
+  });
+
+  // The case links cannot report: an unlinked record repoints nothing when it collapses.
+  it('reports a collapse of a record no token links to', () => {
+    const { result } = renderStoreHook(() => useAnalysisRowDispatch(), {
+      initialAnalysis: twoHomographs([approvedLink('ta-2', 'tok-2')]),
+    });
+
+    let outcome: AnalysisEditOutcome | undefined;
+    act(() => {
+      outcome = result.current.writeGloss('ta-1', 'beginning');
+    });
+
+    expect(outcome).toStrictEqual({
+      kind: 'merged',
+      survivingAnalysisId: 'ta-2',
+      survivingGloss: 'beginning',
+      survivingUsageCount: 1,
+    });
+  });
+
+  it('reports an edit that empties the record as a removal', () => {
+    const { result } = renderStoreHook(() => useAnalysisRowDispatch(), {
+      initialAnalysis: twoHomographs([approvedLink('ta-1', 'tok-1')]),
+    });
+
+    act(() => {
+      result.current.writeGloss('ta-1', 'beginning');
+    });
+
+    // ta-2 is the survivor the first write recorded, so this checks a stale one is not reported.
+    let outcome: AnalysisEditOutcome | undefined;
+    act(() => {
+      outcome = result.current.writeGloss('ta-2', '');
+    });
+
+    expect(outcome).toStrictEqual({ kind: 'removed' });
+  });
+
+  it('reports a collapse driven by a morpheme breakdown', () => {
+    const analysis = twoHomographs([approvedLink('ta-2', 'tok-2')]);
+    const { result } = renderStoreHook(() => useAnalysisRowDispatch(), {
+      initialAnalysis: {
+        ...analysis,
+        // Same gloss apiece, so the records differ only by breakdown.
+        tokenAnalyses: [
+          { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'ἀρχῇ', gloss: { und: 'beginning' } },
+          {
+            ...FIXTURE_STAMPS,
+            id: 'ta-2',
+            surfaceText: 'ἀρχῇ',
+            gloss: { und: 'beginning' },
+            morphemes: [{ ...FIXTURE_STAMPS, id: 'm-1', form: 'ἀρχ', writingSystem: 'el' }],
+          },
+        ],
+      },
+    });
+
+    let outcome: AnalysisEditOutcome | undefined;
+    act(() => {
+      outcome = result.current.writeMorphemes('ta-1', ['ἀρχ'], 'el');
+    });
+
+    expect(outcome?.kind).toBe('merged');
+  });
+
+  it('throws when called outside an AnalysisStoreProvider', () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    expect(() => renderHook(() => useAnalysisRowDispatch())).toThrow(
+      'useAnalysisRowDispatch must be used inside an AnalysisStoreProvider',
+    );
+  });
+});
+
+describe('useAnalysisDeletionOutcome', () => {
+  /** Reads every token as still carrying the form its analysis was recorded under. */
+  const liveArche = () => 'ἀρχῇ';
+
+  it('reports the surviving homograph the affected tokens fall back to', () => {
+    const { result } = renderStoreHook(() => useAnalysisDeletionOutcome(), {
+      initialAnalysis: twoHomographs([
+        approvedLink('ta-1', 'tok-1'),
+        approvedLink('ta-2', 'tok-2'),
+      ]),
+      showSuggestions: true,
+    });
+
+    expect(result.current('ta-1', liveArche)).toStrictEqual({
+      kind: 'fallback',
+      usageCount: 1,
+      unappliedCount: 0,
+      fallbackGloss: 'beginning',
+    });
+  });
+
+  it('reports that same fallback as blank while suggestions are hidden', () => {
+    const { result } = renderStoreHook(() => useAnalysisDeletionOutcome(), {
+      initialAnalysis: twoHomographs([
+        approvedLink('ta-1', 'tok-1'),
+        approvedLink('ta-2', 'tok-2'),
+      ]),
+      showSuggestions: false,
+    });
+
+    expect(result.current('ta-1', liveArche)).toStrictEqual({
+      kind: 'blank',
+      usageCount: 1,
+      unappliedCount: 0,
+    });
+  });
+
+  it('reports a fallback as blank while the analysis is read-only', () => {
+    const { result } = renderStoreHook(() => useAnalysisDeletionOutcome(), {
+      initialAnalysis: twoHomographs([
+        approvedLink('ta-1', 'tok-1'),
+        approvedLink('ta-2', 'tok-2'),
+      ]),
+      readOnly: true,
+      showSuggestions: true,
+    });
+
+    expect(result.current('ta-1', liveArche)).toStrictEqual({
+      kind: 'blank',
+      usageCount: 1,
+      unappliedCount: 0,
+    });
+  });
+
+  // The suggested link is the unapplied assignment; the two approvals make ta-2 the fallback.
+  it('keeps the unapplied count when a fallback is reported as blank', () => {
+    const { result } = renderStoreHook(() => useAnalysisDeletionOutcome(), {
+      initialAnalysis: twoHomographs([
+        approvedLink('ta-1', 'tok-1'),
+        approvedLink('ta-2', 'tok-2'),
+        { ...approvedLink('ta-1', 'tok-3'), status: 'suggested' },
+      ]),
+      showSuggestions: false,
+    });
+
+    expect(result.current('ta-1', liveArche)).toStrictEqual({
+      kind: 'blank',
+      usageCount: 1,
+      unappliedCount: 1,
+    });
+  });
+
+  it('reports a blank outcome when no homograph survives', () => {
+    const { result } = renderStoreHook(() => useAnalysisDeletionOutcome(), {
+      initialAnalysis: makeAnalysisWithGloss('tok-1', 'hello'),
+    });
+
+    expect(result.current('tok-1-analysis', liveArche)).toStrictEqual({
+      kind: 'blank',
+      usageCount: 1,
+      unappliedCount: 0,
+    });
+  });
+
+  it('returns undefined for an id that resolves to no record', () => {
+    const { result } = renderStoreHook(() => useAnalysisDeletionOutcome());
+
+    expect(result.current('ta-missing', liveArche)).toBeUndefined();
+  });
+
+  it('throws when called outside an AnalysisStoreProvider', () => {
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+    expect(() => renderHook(() => useAnalysisDeletionOutcome())).toThrow(
+      'useAnalysisDeletionOutcome must be used inside an AnalysisStoreProvider',
+    );
+  });
+});
diff --git a/src/__tests__/components/CatalogCloseModal.test.tsx b/src/__tests__/components/CatalogCloseModal.test.tsx
new file mode 100644
index 000000000..2ebd0be08
--- /dev/null
+++ b/src/__tests__/components/CatalogCloseModal.test.tsx
@@ -0,0 +1,60 @@
+/// <reference types="jest" />
+/// <reference types="@testing-library/jest-dom" />
+
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import CatalogCloseModal, { CLOSE_STRING_KEYS } from '../../components/CatalogCloseModal';
+
+/** Each key resolving to itself: the text arrives as a prop, so only key placement is assertable. */
+const STRINGS = Object.fromEntries(CLOSE_STRING_KEYS.map((k) => [k, k]));
+
+/** The modal with both callbacks stubbed, so a test asserts on which one the click reached. */
+function renderModal(overrides: { onConfirm?: jest.Mock; onCancel?: jest.Mock } = {}) {
+  const onConfirm = overrides.onConfirm ?? jest.fn();
+  const onCancel = overrides.onCancel ?? jest.fn();
+  render(
+    <CatalogCloseModal localizedStrings={STRINGS} onCancel={onCancel} onConfirm={onConfirm} />,
+  );
+  return { onConfirm, onCancel };
+}
+
+describe('CatalogCloseModal', () => {
+  it('names what closing would discard', () => {
+    renderModal();
+
+    expect(screen.getByTestId('catalog-close-title')).toHaveTextContent(
+      '%interlinearizer_analysisCatalog_closeConfirmTitle%',
+    );
+    expect(screen.getByTestId('catalog-close-prompt')).toHaveTextContent(
+      '%interlinearizer_analysisCatalog_closeConfirmPrompt%',
+    );
+  });
+
+  it('closes the panel when the discard is confirmed', async () => {
+    const { onConfirm, onCancel } = renderModal();
+
+    await userEvent.click(screen.getByTestId('catalog-close-discard'));
+
+    expect(onConfirm).toHaveBeenCalled();
+    expect(onCancel).not.toHaveBeenCalled();
+  });
+
+  it('backs out to the panel when the close is declined', async () => {
+    const { onConfirm, onCancel } = renderModal();
+
+    await userEvent.click(screen.getByTestId('catalog-close-cancel'));
+
+    expect(onCancel).toHaveBeenCalled();
+    expect(onConfirm).not.toHaveBeenCalled();
+  });
+
+  // Escape resolves to cancel, not discard, so the reflex that dismisses a dialog keeps the draft.
+  it('keeps the draft when dismissed by Escape', async () => {
+    const { onConfirm, onCancel } = renderModal();
+
+    await userEvent.keyboard('{Escape}');
+
+    expect(onCancel).toHaveBeenCalled();
+    expect(onConfirm).not.toHaveBeenCalled();
+  });
+});
diff --git a/src/__tests__/components/CatalogMergeModal.test.tsx b/src/__tests__/components/CatalogMergeModal.test.tsx
new file mode 100644
index 000000000..9fcca330c
--- /dev/null
+++ b/src/__tests__/components/CatalogMergeModal.test.tsx
@@ -0,0 +1,972 @@
+/// <reference types="jest" />
+/// <reference types="@testing-library/jest-dom" />
+
+import { useLocalizedStrings } from '@papi/frontend/react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import type { MorphemeAnalysis } from 'interlinearizer';
+import CatalogMergeModal, {
+  MERGE_STRING_KEYS,
+  dropIndex,
+} from '../../components/CatalogMergeModal';
+import type { CatalogRow } from '../../utils/analysis-query';
+
+/** Each key resolving to itself: the text arrives as a prop, so only key placement is assertable. */
+const STRINGS = Object.fromEntries(MERGE_STRING_KEYS.map((k) => [k, k]));
+
+beforeEach(() => {
+  // The breakdown editor looks its own strings up rather than taking them as props.
+  jest.mocked(useLocalizedStrings).mockReturnValue([{}, false]);
+});
+
+const analysisLanguage = 'en';
+
+/**
+ * Builds a catalog row of the one surface form these tests merge, carrying only what a case sets.
+ *
+ * The listed gloss also lands in `glosses` under the analysis language, as a row built from a
+ * stored analysis carries it; a case setting `glosses` outright is opting into a further language.
+ */
+function row(analysisId: string, overrides: Partial<CatalogRow> = {}): CatalogRow {
+  const gloss = overrides.gloss ?? '';
+  return {
+    analysisId,
+    surfaceText: 'λόγος',
+    gloss: '',
+    glosses: gloss ? { [analysisLanguage]: gloss } : undefined,
+    morphemes: [],
+    usageCount: 0,
+    usageCountInBook: 0,
+    usages: [],
+    books: new Set(),
+    searchText: '',
+    ...overrides,
+  };
+}
+
+/** Builds a morpheme of the source writing system, glossed only where a case says so. */
+function morpheme(id: string, form: string, gloss?: string): MorphemeAnalysis {
+  return {
+    id,
+    form,
+    writingSystem: 'grc',
+    gloss: gloss === undefined ? undefined : { [analysisLanguage]: gloss },
+  };
+}
+
+/** The modal over `candidates`, opened from the first of them unless told otherwise. */
+function renderModal(
+  candidates: readonly CatalogRow[],
+  overrides: {
+    onConfirm?: jest.Mock;
+    onCancel?: jest.Mock;
+    initialSurvivorId?: string;
+    showMorphology?: boolean;
+    strings?: Record<string, string>;
+  } = {},
+) {
+  const onConfirm = overrides.onConfirm ?? jest.fn();
+  const onCancel = overrides.onCancel ?? jest.fn();
+  const initialSurvivorId = overrides.initialSurvivorId ?? candidates[0].analysisId;
+  const modal = (over: readonly CatalogRow[]) => (
+    <CatalogMergeModal
+      analysisLanguage={analysisLanguage}
+      candidates={over}
+      initialSurvivorId={initialSurvivorId}
+      localizedStrings={overrides.strings ?? STRINGS}
+      showMorphology={overrides.showMorphology ?? true}
+      onCancel={onCancel}
+      onConfirm={onConfirm}
+      sourceLanguageTag="grc"
+      surfaceText="λόγος"
+    />
+  );
+  const { rerender } = render(modal(candidates));
+  /** Re-renders the mounted modal over a changed listing, as an edit beside the panel leaves it. */
+  const setCandidates = (next: readonly CatalogRow[]) => rerender(modal(next));
+  return { onConfirm, onCancel, setCandidates };
+}
+
+/**
+ * Re-splits the merged breakdown the way a reader does: open the editor from the breakdown box (or
+ * the define-breakdown control where there is none yet), type the forms, and save.
+ */
+async function setBreakdown(user: ReturnType<typeof userEvent.setup>, forms: string) {
+  const open = screen.queryByTestId('catalog-merge-breakdown-open');
+  await user.click(open ?? screen.getAllByTestId('catalog-merge-content-morpheme')[0]);
+  const input = screen.getByTestId('morpheme-breakdown-input');
+  await user.clear(input);
+  await user.type(input, forms);
+  await user.click(screen.getByTestId('morpheme-breakdown-save'));
+  // Dropping a glossed morpheme confirms before it commits, whether the breakdown is re-split or
+  // emptied back to the whole word.
+  const confirm =
+    screen.queryByTestId('morpheme-split-confirm-action') ??
+    screen.queryByTestId('morpheme-reset-confirm-action');
+  if (confirm) await user.click(confirm);
+}
+
+describe('CatalogMergeModal', () => {
+  it('fills the merged gloss from the analysis the merge was opened from', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    expect(screen.getByTestId('catalog-merge-content-gloss')).toHaveValue('word');
+  });
+
+  it('keeps what the reader types into the merged gloss', async () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    await userEvent.clear(screen.getByTestId('catalog-merge-content-gloss'));
+    await userEvent.type(screen.getByTestId('catalog-merge-content-gloss'), 'utterance');
+
+    expect(screen.getByTestId('catalog-merge-content-gloss')).toHaveValue('utterance');
+  });
+
+  it('lists every analysis of the form, the survivor first', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })], {
+      initialSurvivorId: 'ta-2',
+    });
+
+    expect(
+      screen.getAllByTestId('catalog-merge-candidate').map((el) => el.dataset.analysisId),
+    ).toEqual(['ta-2', 'ta-1']);
+  });
+
+  it('holds the survivor in the merge, its checkbox being no decision to make', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    const [survivorBox] = screen.getAllByTestId('catalog-merge-check');
+    expect(survivorBox).toBeChecked();
+    expect(survivorBox).toBeDisabled();
+  });
+
+  it('leaves every other analysis out of the merge until it is checked', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    expect(screen.getAllByTestId('catalog-merge-check')[1]).not.toBeChecked();
+  });
+
+  it('fills a field the survivor lacks once a lower analysis joins the merge', async () => {
+    renderModal([row('ta-1'), row('ta-2', { gloss: 'speech' })]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+
+    expect(screen.getByTestId('catalog-merge-content-gloss')).toHaveValue('speech');
+  });
+
+  it('empties a field again when the only analysis donating it leaves the merge', async () => {
+    renderModal([row('ta-1'), row('ta-2', { gloss: 'speech' })]);
+    const donorBox = screen.getAllByTestId('catalog-merge-check')[1];
+
+    await userEvent.click(donorBox);
+    await userEvent.click(donorBox);
+
+    expect(screen.getByTestId('catalog-merge-content-gloss')).toHaveValue('');
+  });
+
+  it('withholds the merge while the survivor is the only analysis in it', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    expect(screen.getByTestId('catalog-merge-confirm')).toBeDisabled();
+  });
+
+  it('offers the merge once another analysis joins it', async () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+
+    expect(screen.getByTestId('catalog-merge-confirm')).toBeEnabled();
+  });
+
+  it('commits the survivor and every analysis folded into it', async () => {
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+      row('ta-3', { gloss: 'account' }),
+    ]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[2]);
+    await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+    expect(onConfirm).toHaveBeenCalledWith(
+      'ta-1',
+      ['ta-3'],
+      {
+        gloss: 'word',
+        glossFromAnalysisId: 'ta-1',
+        morphemes: [],
+        pos: undefined,
+        features: undefined,
+        confidence: undefined,
+      },
+      'λόγος',
+    );
+  });
+
+  it('commits the content the panel settled rather than what the survivor said', async () => {
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+    await userEvent.clear(screen.getByTestId('catalog-merge-content-gloss'));
+    await userEvent.type(screen.getByTestId('catalog-merge-content-gloss'), 'utterance');
+    await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+    expect(onConfirm).toHaveBeenCalledWith(
+      'ta-1',
+      ['ta-2'],
+      expect.objectContaining({ gloss: 'utterance' }),
+      'λόγος',
+    );
+  });
+
+  it('makes a promoted analysis the survivor the rest merge into', async () => {
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-promote')[1]);
+    await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+    expect(onConfirm).toHaveBeenCalledWith('ta-2', ['ta-1'], expect.anything(), 'λόγος');
+  });
+
+  it('hands over the donors as the reader ranked them, not as they were checked', async () => {
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+      row('ta-3', { gloss: 'saying' }),
+    ]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[2]);
+    // Lifts the third analysis over the second, then restores the survivor the promotion displaced.
+    await userEvent.click(screen.getAllByTestId('catalog-merge-promote')[2]);
+    await userEvent.click(screen.getAllByTestId('catalog-merge-promote')[1]);
+    await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+    expect(onConfirm).toHaveBeenCalledWith('ta-1', ['ta-3', 'ta-2'], expect.anything(), 'λόγος');
+  });
+
+  it('lifts a promoted analysis to the top of the listing', async () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-promote')[1]);
+
+    expect(
+      screen.getAllByTestId('catalog-merge-candidate').map((el) => el.dataset.analysisId),
+    ).toEqual(['ta-2', 'ta-1']);
+  });
+
+  it('keeps the analysis a promotion displaced in the merge', async () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-promote')[1]);
+
+    expect(screen.getAllByTestId('catalog-merge-check')[1]).toBeChecked();
+  });
+
+  it('offers no promotion on the analysis already surviving', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    expect(screen.getAllByTestId('catalog-merge-promote')[0]).toBeDisabled();
+  });
+
+  it('refills the merged content from the analysis a promotion made survivor', async () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-promote')[1]);
+
+    expect(screen.getByTestId('catalog-merge-content-gloss')).toHaveValue('speech');
+  });
+
+  it('names each analysis by how many tokens carry it', () => {
+    renderModal([
+      row('ta-1', { gloss: 'word', usageCount: 12 }),
+      row('ta-2', { gloss: 'speech', usageCount: 3 }),
+    ]);
+
+    expect(screen.getAllByTestId('catalog-merge-usage-count')[0]).toHaveTextContent(
+      '%interlinearizer_analysisCatalog_mergeUsageCount%',
+    );
+  });
+
+  it('shows each analysis the fields the merged content could take from it', () => {
+    renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech', confidence: 'low' }),
+    ]);
+
+    expect(screen.getAllByTestId('catalog-merge-candidate')[1]).toHaveTextContent('low');
+  });
+
+  it('leaves a part of speech off an analysis, nothing offering to edit one', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech', pos: 'verb' })]);
+
+    expect(screen.getAllByTestId('catalog-merge-candidate')[1]).not.toHaveTextContent('verb');
+  });
+
+  it('says nothing about collapsing while every analysis left out stays distinct', async () => {
+    renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+      row('ta-3', { gloss: 'account' }),
+    ]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+
+    expect(screen.queryByTestId('catalog-merge-collapse-warning')).not.toBeInTheDocument();
+  });
+
+  it('warns that an analysis left out will be absorbed when the merged content comes to match it', async () => {
+    renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+      row('ta-3', { gloss: 'account' }),
+    ]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+    await userEvent.clear(screen.getByTestId('catalog-merge-content-gloss'));
+    await userEvent.type(screen.getByTestId('catalog-merge-content-gloss'), 'account');
+
+    expect(screen.getByTestId('catalog-merge-collapse-warning')).toHaveTextContent(
+      '%interlinearizer_analysisCatalog_mergeWillCollapse%',
+    );
+  });
+
+  it('still allows a merge that will collapse, the warning having said so', async () => {
+    renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+      row('ta-3', { gloss: 'account' }),
+    ]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+    await userEvent.clear(screen.getByTestId('catalog-merge-content-gloss'));
+    await userEvent.type(screen.getByTestId('catalog-merge-content-gloss'), 'account');
+
+    expect(screen.getByTestId('catalog-merge-confirm')).toBeEnabled();
+  });
+
+  // Resolved rather than echoed as its key, the substitution being the whole of what is asserted.
+  it('names a collapsing analysis by its form where it carries no gloss', async () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' }), row('ta-3')], {
+      strings: {
+        ...STRINGS,
+        '%interlinearizer_analysisCatalog_mergeWillCollapse%': 'also absorbs {gloss}',
+      },
+    });
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+    await userEvent.clear(screen.getByTestId('catalog-merge-content-gloss'));
+
+    expect(screen.getByTestId('catalog-merge-collapse-warning')).toHaveTextContent(
+      'also absorbs λόγος',
+    );
+  });
+
+  it('lists an analysis of the form an edit beside the panel raised while it was open', () => {
+    const { setCandidates } = renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    setCandidates([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+      row('ta-3', { gloss: 'account' }),
+    ]);
+
+    expect(
+      screen.getAllByTestId('catalog-merge-candidate').map((el) => el.dataset.analysisId),
+    ).toEqual(['ta-1', 'ta-2', 'ta-3']);
+  });
+
+  it('warns about an analysis raised while it was open that the merged content comes to match', async () => {
+    const { setCandidates } = renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    setCandidates([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+      row('ta-3', { gloss: 'account' }),
+    ]);
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+    await userEvent.clear(screen.getByTestId('catalog-merge-content-gloss'));
+    await userEvent.type(screen.getByTestId('catalog-merge-content-gloss'), 'account');
+
+    expect(screen.getByTestId('catalog-merge-collapse-warning')).toHaveTextContent(
+      '%interlinearizer_analysisCatalog_mergeWillCollapse%',
+    );
+  });
+
+  it('leaves an analysis raised while it was open out of the merge until it is checked', () => {
+    const { setCandidates } = renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    setCandidates([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+      row('ta-3', { gloss: 'account' }),
+    ]);
+
+    expect(screen.getAllByTestId('catalog-merge-check')[2]).not.toBeChecked();
+  });
+
+  it('carries a part of speech onto the survivor, having offered no way to change it', async () => {
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word', pos: 'noun' }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+    await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+    expect(onConfirm).toHaveBeenCalledWith(
+      'ta-1',
+      ['ta-2'],
+      expect.objectContaining({ pos: 'noun' }),
+      'λόγος',
+    );
+  });
+
+  it('carries a donor part of speech the survivor lacks', async () => {
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech', pos: 'verb' }),
+    ]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+    await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+    expect(onConfirm).toHaveBeenCalledWith(
+      'ta-1',
+      ['ta-2'],
+      expect.objectContaining({ pos: 'verb' }),
+      'λόγος',
+    );
+  });
+
+  it('offers no revert on a field the reader has not edited', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    expect(screen.queryByTestId('catalog-merge-revert-gloss')).not.toBeInTheDocument();
+  });
+
+  it('takes an edited field back to what the merged analyses derive', async () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    await userEvent.clear(screen.getByTestId('catalog-merge-content-gloss'));
+    await userEvent.type(screen.getByTestId('catalog-merge-content-gloss'), 'utterance');
+    await userEvent.click(screen.getByTestId('catalog-merge-revert-gloss'));
+
+    expect(screen.getByTestId('catalog-merge-content-gloss')).toHaveValue('word');
+  });
+
+  it('takes every edited field back at once', async () => {
+    renderModal([row('ta-1', { gloss: 'word', confidence: 'high' })]);
+
+    await userEvent.type(screen.getByTestId('catalog-merge-content-gloss'), 'ing');
+    await userEvent.click(screen.getByTestId('catalog-merge-content-confidence'));
+    await userEvent.click(screen.getByTestId('catalog-merge-confidence-low'));
+    await userEvent.click(screen.getByTestId('catalog-merge-reset'));
+
+    expect(screen.getByTestId('catalog-merge-content-gloss')).toHaveValue('word');
+    expect(screen.queryByTestId('catalog-merge-revert-confidence')).not.toBeInTheDocument();
+  });
+
+  it('offers no reset while nothing has been edited', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    expect(screen.queryByTestId('catalog-merge-reset')).not.toBeInTheDocument();
+  });
+
+  it('shows the breakdown of an analysis that has one', () => {
+    renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', {
+        gloss: 'speech',
+        morphemes: [
+          { id: 'm-1', form: 'λόγ', writingSystem: 'grc' },
+          { id: 'm-2', form: 'ος', writingSystem: 'grc' },
+        ],
+      }),
+    ]);
+
+    const breakdown = screen.getAllByTestId('catalog-merge-breakdown')[1];
+    expect(breakdown).toHaveTextContent('λόγ');
+    expect(breakdown).toHaveTextContent('ος');
+  });
+
+  it('says so outright for an analysis that segments nothing', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    // Both candidates, the notice standing in for a breakdown rather than the row falling blank.
+    expect(screen.getAllByTestId('catalog-merge-morpheme-none')).toHaveLength(2);
+  });
+
+  it('names no feature an analysis carries, nothing offering to edit one', () => {
+    renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech', features: { Case: 'Nom' } }),
+    ]);
+
+    expect(screen.getAllByTestId('catalog-merge-candidate')[1]).not.toHaveTextContent('Case');
+  });
+
+  it('offers every analysis a handle to reorder it by', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    expect(screen.getAllByTestId('catalog-merge-drag-handle')).toHaveLength(2);
+  });
+
+  it('fills the merged breakdown from the highest-ranked analysis in the merge that has one', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech', morphemes: [morpheme('m-1', 'λόγος')] }),
+      row('ta-3', { gloss: 'reason', morphemes: [morpheme('m-2', 'λόγ'), morpheme('m-3', 'ος')] }),
+    ]);
+
+    await user.click(screen.getAllByTestId('catalog-merge-check')[2]);
+
+    expect(
+      screen.getAllByTestId('catalog-merge-content-morpheme').map((c) => c.textContent),
+    ).toEqual(['λόγ', 'ος']);
+  });
+
+  it('offers a way to split the merged content when no analysis in the merge has a breakdown', () => {
+    renderModal([row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })]);
+
+    expect(screen.getByTestId('catalog-merge-breakdown-open')).toBeInTheDocument();
+  });
+
+  it('re-splits the merged content when the reader edits the breakdown', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγος')] }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    await setBreakdown(user, 'λόγ ος');
+
+    expect(
+      screen.getAllByTestId('catalog-merge-content-morpheme').map((c) => c.textContent),
+    ).toEqual(['λόγ', 'ος']);
+  });
+
+  it('reads a breakdown of the whole form as a single morpheme', async () => {
+    const user = userEvent.setup();
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+    await user.click(screen.getAllByTestId('catalog-merge-check')[1]);
+
+    await setBreakdown(user, 'λόγος');
+    await user.click(screen.getByTestId('catalog-merge-confirm'));
+
+    expect(onConfirm.mock.calls[0][2].morphemes.map((m: { form: string }) => m.form)).toEqual([
+      'λόγος',
+    ]);
+  });
+
+  it('empties the merged breakdown from the editor that offers to reset it', async () => {
+    const user = userEvent.setup();
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+    await user.click(screen.getAllByTestId('catalog-merge-check')[1]);
+
+    await user.click(screen.getAllByTestId('catalog-merge-content-morpheme')[0]);
+    await user.click(screen.getByTestId('morpheme-breakdown-reset'));
+    await user.click(screen.getByTestId('catalog-merge-confirm'));
+
+    expect(onConfirm.mock.calls[0][2].morphemes).toEqual([]);
+  });
+
+  it('takes an edited breakdown back to what the merged analyses derive', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    await setBreakdown(user, 'λόγο ς');
+    await user.click(screen.getByTestId('catalog-merge-revert-morphemeForms'));
+
+    expect(
+      screen.getAllByTestId('catalog-merge-content-morpheme').map((c) => c.textContent),
+    ).toEqual(['λόγ', 'ος']);
+  });
+
+  it('fills each morpheme gloss from the highest-ranked analysis in the merge carrying its form', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', {
+        gloss: 'word',
+        morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')],
+      }),
+      row('ta-2', {
+        gloss: 'speech',
+        morphemes: [morpheme('m-3', 'λόγ', 'say'), morpheme('m-4', 'ος', 'nom.sg')],
+      }),
+    ]);
+
+    await user.click(screen.getAllByTestId('catalog-merge-check')[1]);
+
+    const glosses = screen.getAllByTestId('catalog-merge-content-morpheme-gloss');
+    expect(glosses[0]).toHaveValue('say');
+    expect(glosses[1]).toHaveValue('nom.sg');
+  });
+
+  it('sends a click on the breakdown box to the field the forms are staged in', async () => {
+    // The box is the token strip's, where a form click opens the breakdown editor; here the forms
+    // are staged in a field whose pending value and revert button have to stay visible, so the click
+    // goes there instead.
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    await user.click(screen.getAllByTestId('catalog-merge-content-morpheme')[0]);
+
+    expect(screen.getByTestId('morpheme-breakdown-input')).toBeInTheDocument();
+  });
+
+  it('keeps what the reader types into a morpheme gloss', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    await user.type(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[0], 'say');
+
+    expect(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[0]).toHaveValue('say');
+  });
+
+  it('takes one morpheme gloss back to what the merged analyses derive', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', {
+        gloss: 'word',
+        morphemes: [morpheme('m-1', 'λόγ', 'say'), morpheme('m-2', 'ος', 'nom.sg')],
+      }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+    await user.type(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[0], '-stem');
+
+    await user.click(screen.getByTestId('catalog-merge-revert-morpheme-gloss'));
+
+    const glosses = screen.getAllByTestId('catalog-merge-content-morpheme-gloss');
+    expect(glosses[0]).toHaveValue('say');
+    expect(glosses[1]).toHaveValue('nom.sg');
+  });
+
+  it('offers no revert on a morpheme gloss the reader has not touched', () => {
+    renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ', 'say')] }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    expect(screen.queryByTestId('catalog-merge-revert-morpheme-gloss')).not.toBeInTheDocument();
+  });
+
+  it('offers one morpheme gloss field once the breakdown is collapsed to the whole word', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+    await user.type(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[1], 'nom.sg');
+
+    await setBreakdown(user, 'λόγος');
+
+    expect(screen.queryAllByTestId('catalog-merge-content-morpheme-gloss')).toHaveLength(1);
+  });
+
+  it('carries a typed morpheme gloss to the form it was typed on across a re-split', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+    await user.type(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[0], 'say');
+
+    // The re-split keeps λόγ, at the other index.
+    await setBreakdown(user, 'ο λόγ');
+
+    const glosses = screen.getAllByTestId('catalog-merge-content-morpheme-gloss');
+    expect(glosses[0]).toHaveValue('');
+    expect(glosses[1]).toHaveValue('say');
+  });
+
+  it('drops a typed morpheme gloss whose form the re-split leaves nothing of', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+    await user.type(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[0], 'say');
+
+    await setBreakdown(user, 'λό γος');
+
+    // The re-split leaves no λόγ for the gloss typed about it, and λό is a different form.
+    expect(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[0]).toHaveValue('');
+  });
+
+  it('keeps a typed morpheme gloss across a change of survivor', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', {
+        gloss: 'speech',
+        morphemes: [morpheme('m-3', 'λόγ', 'say'), morpheme('m-4', 'ος')],
+      }),
+    ]);
+    await user.type(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[0], 'word-stem');
+
+    await user.click(screen.getAllByTestId('catalog-merge-promote')[1]);
+
+    expect(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[0]).toHaveValue(
+      'word-stem',
+    );
+  });
+
+  it('carries a typed morpheme gloss to its form when promotion changes the breakdown', async () => {
+    const user = userEvent.setup();
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', {
+        gloss: 'speech',
+        morphemes: [morpheme('m-3', 'λόγο'), morpheme('m-4', 'ς')],
+      }),
+    ]);
+    await user.type(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[1], 'nom.sg');
+
+    // ta-2 reads the word a different way, so the breakdown it brings has no ος for the gloss.
+    await user.click(screen.getAllByTestId('catalog-merge-promote')[1]);
+
+    const glosses = screen.getAllByTestId('catalog-merge-content-morpheme-gloss');
+    expect(glosses[0]).toHaveValue('');
+    expect(glosses[1]).toHaveValue('');
+
+    await user.click(screen.getByTestId('catalog-merge-confirm'));
+    expect(onConfirm).toHaveBeenCalledWith(
+      'ta-2',
+      ['ta-1'],
+      expect.objectContaining({
+        morphemes: [
+          expect.objectContaining({ form: 'λόγο', gloss: undefined }),
+          expect.objectContaining({ form: 'ς', gloss: undefined }),
+        ],
+      }),
+      'λόγος',
+    );
+  });
+
+  it('carries a typed morpheme gloss to its form when unchecking changes the breakdown', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech', morphemes: [morpheme('m-1', 'λόγο'), morpheme('m-2', 'ς')] }),
+      row('ta-3', { gloss: 'account', morphemes: [morpheme('m-3', 'λόγ'), morpheme('m-4', 'ος')] }),
+    ]);
+    await user.click(screen.getAllByTestId('catalog-merge-check')[1]);
+    await user.click(screen.getAllByTestId('catalog-merge-check')[2]);
+    await user.type(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[1], 'nom.sg');
+
+    // Dropping ta-2 hands the breakdown to ta-3, which reads the word another way.
+    await user.click(screen.getAllByTestId('catalog-merge-check')[1]);
+
+    const glosses = screen.getAllByTestId('catalog-merge-content-morpheme-gloss');
+    expect(glosses[0]).toHaveValue('');
+    expect(glosses[1]).toHaveValue('');
+  });
+
+  it('leaves a re-split of the reader’s standing when promotion changes the breakdown', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', {
+        gloss: 'speech',
+        morphemes: [morpheme('m-3', 'λόγο'), morpheme('m-4', 'ς')],
+      }),
+    ]);
+    await setBreakdown(user, 'λό γος');
+    await user.type(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[1], 'the-rest');
+
+    // The re-split outranks the breakdown ta-2 would bring, so neither it nor the gloss moves.
+    await user.click(screen.getAllByTestId('catalog-merge-promote')[1]);
+
+    const glosses = screen.getAllByTestId('catalog-merge-content-morpheme-gloss');
+    expect(glosses).toHaveLength(2);
+    expect(glosses[1]).toHaveValue('the-rest');
+  });
+
+  it('carries a typed morpheme gloss to its form when a re-split is taken back', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word', morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+    await setBreakdown(user, 'λό γος');
+    await user.type(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[1], 'the-rest');
+
+    // Taking the re-split back returns λόγ|ος, which has no γος for the gloss typed about it.
+    await user.click(screen.getByTestId('catalog-merge-revert-morphemeForms'));
+
+    const glosses = screen.getAllByTestId('catalog-merge-content-morpheme-gloss');
+    expect(glosses).toHaveLength(2);
+    expect(glosses[0]).toHaveValue('');
+    expect(glosses[1]).toHaveValue('');
+  });
+
+  it('offers no way to author a feature, nothing rendering one back', () => {
+    renderModal([
+      row('ta-1', { gloss: 'word', features: { Case: 'Nom' } }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    expect(screen.queryByTestId('catalog-merge-feature-add')).not.toBeInTheDocument();
+    expect(
+      screen.queryByTestId('catalog-merge-content-feature-stored:Case'),
+    ).not.toBeInTheDocument();
+  });
+
+  it('carries the features an analysis arrived with onto the survivor', async () => {
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech', features: { Case: 'Nom' } }),
+    ]);
+
+    await userEvent.click(screen.getAllByTestId('catalog-merge-check')[1]);
+    await userEvent.click(screen.getByTestId('catalog-merge-confirm'));
+
+    expect(onConfirm).toHaveBeenCalledWith(
+      'ta-1',
+      ['ta-2'],
+      expect.objectContaining({ features: { Case: 'Nom' } }),
+      'λόγος',
+    );
+  });
+  it('fills the confidence from the highest-ranked analysis in the merge carrying one', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech', confidence: 'high' }),
+    ]);
+
+    await user.click(screen.getAllByTestId('catalog-merge-check')[1]);
+
+    expect(screen.getByTestId('catalog-merge-content-confidence')).toHaveTextContent('high');
+  });
+
+  it('records the confidence the reader picks', async () => {
+    const user = userEvent.setup();
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word', confidence: 'high' }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+    await user.click(screen.getAllByTestId('catalog-merge-check')[1]);
+
+    await user.click(screen.getByTestId('catalog-merge-confidence-guess'));
+    await user.click(screen.getByTestId('catalog-merge-confirm'));
+
+    expect(onConfirm.mock.calls[0][2].confidence).toBe('guess');
+  });
+
+  it('records no confidence once the reader takes it to none', async () => {
+    const user = userEvent.setup();
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word', confidence: 'high' }),
+      row('ta-2', { gloss: 'speech', confidence: 'low' }),
+    ]);
+    await user.click(screen.getAllByTestId('catalog-merge-check')[1]);
+
+    await user.click(screen.getByTestId('catalog-merge-confidence-none'));
+    await user.click(screen.getByTestId('catalog-merge-confirm'));
+
+    expect(onConfirm.mock.calls[0][2].confidence).toBeUndefined();
+  });
+
+  it('takes an edited confidence back to what the merged analyses derive', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', { gloss: 'word', confidence: 'high' }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+    await user.click(screen.getByTestId('catalog-merge-confidence-guess'));
+
+    await user.click(screen.getByTestId('catalog-merge-revert-confidence'));
+
+    expect(screen.getByTestId('catalog-merge-content-confidence')).toHaveTextContent('high');
+  });
+
+  it('commits the breakdown, morpheme glosses and confidence the panel settled', async () => {
+    const user = userEvent.setup();
+    const { onConfirm } = renderModal([
+      row('ta-1', { gloss: 'word' }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+    await user.click(screen.getAllByTestId('catalog-merge-check')[1]);
+
+    await setBreakdown(user, 'λόγ ος');
+    await user.type(screen.getAllByTestId('catalog-merge-content-morpheme-gloss')[0], 'say');
+    await user.click(screen.getByTestId('catalog-merge-confidence-medium'));
+    await user.click(screen.getByTestId('catalog-merge-confirm'));
+
+    const content = onConfirm.mock.calls[0][2];
+    expect(content.morphemes.map((m: MorphemeAnalysis) => m.form)).toEqual(['λόγ', 'ος']);
+    expect(content.morphemes[0].gloss).toEqual({ en: 'say' });
+    expect(content.confidence).toBe('medium');
+  });
+
+  it('takes the breakdown and confidence back with every other edited field', async () => {
+    const user = userEvent.setup();
+    renderModal([
+      row('ta-1', {
+        gloss: 'word',
+        morphemes: [morpheme('m-1', 'λόγος', 'word')],
+        confidence: 'high',
+      }),
+      row('ta-2', { gloss: 'speech' }),
+    ]);
+
+    await setBreakdown(user, 'λόγ ος');
+    await user.click(screen.getByTestId('catalog-merge-confidence-guess'));
+
+    await user.click(screen.getByTestId('catalog-merge-reset'));
+
+    expect(
+      screen.getAllByTestId('catalog-merge-content-morpheme').map((c) => c.textContent),
+    ).toEqual(['λόγος']);
+    expect(screen.getByTestId('catalog-merge-content-confidence')).toHaveTextContent('high');
+  });
+});
+
+describe('dropIndex', () => {
+  // Until the reader moves something, no analysis has been rearranged — so this is the state every
+  // first drag resolves against.
+  it('resolves a drop on an analysis the reader has not yet rearranged', () => {
+    expect(dropIndex(['ta-1', 'ta-2', 'ta-3', 'ta-4'], 'ta-4')).toBe(3);
+  });
+
+  it('resolves a drop on the analysis heading the listing', () => {
+    expect(dropIndex(['ta-1', 'ta-2', 'ta-3'], 'ta-1')).toBe(0);
+  });
+
+  it('reports no place for a drop on something the listing does not hold', () => {
+    expect(dropIndex(['ta-1', 'ta-2'], 'ta-9')).toBeUndefined();
+  });
+});
diff --git a/src/__tests__/components/MorphemeBox.test.tsx b/src/__tests__/components/MorphemeBox.test.tsx
index c42cee51b..31b144edd 100644
--- a/src/__tests__/components/MorphemeBox.test.tsx
+++ b/src/__tests__/components/MorphemeBox.test.tsx
@@ -4,6 +4,7 @@
 import { fireEvent, render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import type { MorphemeAnalysis } from 'interlinearizer';
+import { Popover } from 'platform-bible-react';
 import * as AnalysisStore from '../../components/AnalysisStore';
 import { MorphemeBox, MorphemeGlossInput } from '../../components/MorphemeBox';
 import { TOKEN_CHIP_LABEL_KEYS } from '../../components/PhraseStripContext';
@@ -33,21 +34,33 @@ const MORPHEMES: MorphemeAnalysis[] = [
  */
 function renderBox(props: Partial<Parameters<typeof MorphemeBox>[0]> = {}) {
   return render(
-    <MorphemeBox
-      analysisLanguage="en"
-      disabled={false}
-      labels={LABELS}
-      morphemes={MORPHEMES}
-      onEditBreakdown={jest.fn()}
-      onGlossFocus={jest.fn()}
-      popoverOpen={false}
-      token={WORD_TOKEN}
-      {...props}
-    />,
+    // Wrapped as TokenChip wraps it: the box anchors the breakdown editor's popover.
+    <Popover>
+      <MorphemeBox
+        analysisLanguage="en"
+        disabled={false}
+        labels={LABELS}
+        morphemes={MORPHEMES}
+        onEditBreakdown={jest.fn()}
+        onGlossFocus={jest.fn()}
+        popoverOpen={false}
+        token={WORD_TOKEN}
+        {...props}
+      />
+    </Popover>,
   );
 }
 
 describe('MorphemeBox', () => {
+  it('names no rows, the token strip labeling its breakdown by position alone', () => {
+    // The catalog and the merge panel label the two rows; on the strip the surrounding interlinear
+    // line already says what they are, and a label column there would inset every chip.
+    renderBox();
+
+    expect(screen.queryByTestId('morpheme-form-row-label')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('morpheme-gloss-row-label')).not.toBeInTheDocument();
+  });
+
   it('renders one form cell per morpheme', () => {
     renderBox();
     expect(screen.getByText('hel')).toBeInTheDocument();
@@ -99,7 +112,7 @@ describe('MorphemeBox', () => {
   it('sizes the column template to the morpheme count', () => {
     const { container } = renderBox();
     const box = container.querySelector('[style*="grid-template-columns"]');
-    expect(box).toHaveStyle({ gridTemplateColumns: 'repeat(2, minmax(1ch, auto))' });
+    expect(box).toHaveStyle({ gridTemplateColumns: 'repeat(2, minmax(4ch, auto))' });
   });
 
   it('takes its box metrics from the shared morphology-slot utility', () => {
@@ -143,16 +156,18 @@ describe('MorphemeBox', () => {
       // Stand-in for an ancestor React handler, not real UI.
       // eslint-disable-next-line jsx-a11y/no-static-element-interactions
       <div onMouseDown={onAncestorMouseDown}>
-        <MorphemeBox
-          analysisLanguage="en"
-          disabled={false}
-          labels={LABELS}
-          morphemes={MORPHEMES}
-          onEditBreakdown={jest.fn()}
-          onGlossFocus={jest.fn()}
-          popoverOpen={false}
-          token={WORD_TOKEN}
-        />
+        <Popover>
+          <MorphemeBox
+            analysisLanguage="en"
+            disabled={false}
+            labels={LABELS}
+            morphemes={MORPHEMES}
+            onEditBreakdown={jest.fn()}
+            onGlossFocus={jest.fn()}
+            popoverOpen={false}
+            token={WORD_TOKEN}
+          />
+        </Popover>
       </div>,
     );
     fireEvent.mouseDown(screen.getByText('-lo'));
@@ -168,16 +183,18 @@ describe('MorphemeBox', () => {
       // Stand-in for TokenChip's label, not real UI.
       // eslint-disable-next-line jsx-a11y/label-has-associated-control
       <label htmlFor="token-gloss">
-        <MorphemeBox
-          analysisLanguage="en"
-          disabled={false}
-          labels={LABELS}
-          morphemes={MORPHEMES}
-          onEditBreakdown={jest.fn()}
-          onGlossFocus={jest.fn()}
-          popoverOpen={false}
-          token={WORD_TOKEN}
-        />
+        <Popover>
+          <MorphemeBox
+            analysisLanguage="en"
+            disabled={false}
+            labels={LABELS}
+            morphemes={MORPHEMES}
+            onEditBreakdown={jest.fn()}
+            onGlossFocus={jest.fn()}
+            popoverOpen={false}
+            token={WORD_TOKEN}
+          />
+        </Popover>
         <input aria-label="Gloss for hello" id="token-gloss" />
       </label>,
     );
@@ -370,3 +387,203 @@ describe('MorphemeBox read-only', () => {
     expect(onEditBreakdown).not.toHaveBeenCalled();
   });
 });
+
+/** Renders a read-only box, whose cells are static text rather than controls. */
+function renderReadOnlyBox(
+  morphemes: readonly MorphemeAnalysis[],
+  props: Partial<Parameters<typeof MorphemeBox>[0]> = {},
+) {
+  setMockAnalysisReadOnly(true);
+  return render(
+    <Popover>
+      <MorphemeBox
+        analysisLanguage="en"
+        disabled
+        labels={LABELS}
+        morphemes={morphemes}
+        onEditBreakdown={jest.fn()}
+        popoverOpen={false}
+        readOnly
+        token={WORD_TOKEN}
+        {...props}
+      />
+    </Popover>,
+  );
+}
+
+/** Builds a morpheme, glossed only where a case says so. */
+function grcMorpheme(
+  id: string,
+  form: string,
+  gloss?: Readonly<Record<string, string>>,
+): MorphemeAnalysis {
+  return { id, form, writingSystem: 'grc', gloss };
+}
+
+describe('a read-only breakdown', () => {
+  it('shows each morpheme of a breakdown', () => {
+    renderReadOnlyBox([grcMorpheme('m-1', 'λόγ'), grcMorpheme('m-2', 'ος')]);
+
+    expect(screen.getAllByTestId('readonly-morpheme-form').map((cell) => cell.textContent)).toEqual(
+      ['λόγ', 'ος'],
+    );
+  });
+
+  it('keeps the morphemes in the order the breakdown records them', () => {
+    // A breakdown read out of order says the word is segmented other than it is, which is the one
+    // thing the forms are there to convey.
+    renderReadOnlyBox([
+      grcMorpheme('m-1', 'ἀπο'),
+      grcMorpheme('m-2', 'στελ'),
+      grcMorpheme('m-3', 'λω'),
+    ]);
+
+    expect(screen.getAllByTestId('readonly-morpheme-form').map((cell) => cell.textContent)).toEqual(
+      ['ἀπο', 'στελ', 'λω'],
+    );
+  });
+
+  it('sits each gloss in the grid column of the form it belongs to', () => {
+    // Form over gloss in a shared column is what the boxed grid is for; a gloss under the wrong
+    // form misreports the segmentation.
+    renderReadOnlyBox([
+      grcMorpheme('m-1', 'λόγ', { en: 'word' }),
+      grcMorpheme('m-2', 'ος', { en: 'NOM.SG' }),
+    ]);
+
+    expect(screen.getAllByTestId('readonly-morpheme-form')[1]).toHaveStyle({
+      gridColumn: '2',
+      gridRow: '1',
+    });
+    expect(screen.getAllByTestId('readonly-morpheme-gloss')[1]).toHaveStyle({
+      gridColumn: '2',
+      gridRow: '2',
+    });
+  });
+
+  it("shows a morpheme's gloss in the analysis language", () => {
+    renderReadOnlyBox([grcMorpheme('m-1', 'λόγ', { en: 'word' })]);
+
+    expect(screen.getByTestId('readonly-morpheme-gloss')).toHaveTextContent('word');
+  });
+
+  it('reads the glosses under the analysis language it is given', () => {
+    renderReadOnlyBox([grcMorpheme('m-1', 'λόγ', { en: 'word', fr: 'parole' })], {
+      analysisLanguage: 'fr',
+    });
+
+    expect(screen.getByTestId('readonly-morpheme-gloss')).toHaveTextContent('parole');
+  });
+
+  it('glosses each morpheme from its own record', () => {
+    renderReadOnlyBox([
+      grcMorpheme('m-1', 'λόγ', { en: 'word' }),
+      grcMorpheme('m-2', 'ος', { en: 'NOM.SG' }),
+    ]);
+
+    expect(screen.getAllByTestId('readonly-morpheme-gloss')[1]).toHaveTextContent('NOM.SG');
+  });
+
+  describe('a morpheme carrying no gloss', () => {
+    it('names the absence where the caller supplies a label', () => {
+      // A blank cell reads as a rendering gap in a view that offers no field to fill.
+      renderReadOnlyBox([grcMorpheme('m-1', 'λόγ')], { noGlossLabel: 'no gloss' });
+
+      expect(screen.getByTestId('readonly-morpheme-gloss')).toHaveTextContent('no gloss');
+    });
+
+    it('leaves the cell blank where the caller supplies no label', () => {
+      renderReadOnlyBox([grcMorpheme('m-1', 'λόγ')]);
+
+      expect(screen.getByTestId('readonly-morpheme-gloss')).toBeEmptyDOMElement();
+    });
+
+    it('names the absence where a morpheme is glossed only in another language', () => {
+      renderReadOnlyBox([grcMorpheme('m-1', 'λόγ', { fr: 'parole' })], {
+        noGlossLabel: 'no gloss',
+      });
+
+      const gloss = screen.getByTestId('readonly-morpheme-gloss');
+      expect(gloss).toHaveTextContent('no gloss');
+      expect(gloss).not.toHaveTextContent('parole');
+    });
+
+    it('names the absence where a morpheme is glossed to an empty string', () => {
+      // An emptied gloss is the same absence as an unset one, which a blank cell would not say.
+      renderReadOnlyBox([grcMorpheme('m-1', 'λόγ', { en: '' })], { noGlossLabel: 'no gloss' });
+
+      expect(screen.getByTestId('readonly-morpheme-gloss')).toHaveTextContent('no gloss');
+    });
+  });
+
+  describe('an analysis that segments nothing', () => {
+    it('says outright that it is not split where the caller supplies a label', () => {
+      renderReadOnlyBox([], { noBreakdownLabel: 'not split' });
+
+      expect(screen.getByTestId('readonly-morpheme-form-none')).toHaveTextContent('not split');
+    });
+
+    it('renders nothing where the caller supplies no label', () => {
+      // An unanalyzed token shows its "define breakdown" affordance instead, so a notice here
+      // would duplicate it.
+      renderReadOnlyBox([]);
+
+      expect(screen.queryByTestId('readonly-morpheme-form')).not.toBeInTheDocument();
+      expect(screen.queryByTestId('readonly-morpheme-form-none')).not.toBeInTheDocument();
+    });
+
+    it('shows no morpheme columns', () => {
+      renderReadOnlyBox([], { noBreakdownLabel: 'not split' });
+
+      expect(screen.queryByTestId('readonly-morpheme-form')).not.toBeInTheDocument();
+    });
+  });
+
+  it('shows no not-split notice for an analysis that has a breakdown', () => {
+    renderReadOnlyBox([grcMorpheme('m-1', 'λόγ')], { noBreakdownLabel: 'not split' });
+
+    expect(screen.queryByTestId('readonly-morpheme-form-none')).not.toBeInTheDocument();
+  });
+});
+
+describe('row labels', () => {
+  const ROW_LABELS = { forms: 'Morphemes', glosses: 'Glosses' };
+
+  beforeEach(() => {
+    setMockAnalysisReadOnly(false);
+  });
+
+  it('names each row alongside the cells it names', () => {
+    renderBox({ rowLabels: ROW_LABELS });
+
+    expect(screen.getByTestId('morpheme-form-row-label')).toHaveTextContent('Morphemes');
+    expect(screen.getByTestId('morpheme-gloss-row-label')).toHaveTextContent('Glosses');
+  });
+
+  it('puts each label in the row track of the cells it names', () => {
+    renderBox({ rowLabels: ROW_LABELS });
+
+    expect(screen.getByTestId('morpheme-form-row-label')).toHaveStyle({
+      gridColumn: '1',
+      gridRow: '1',
+    });
+    expect(screen.getByTestId('morpheme-gloss-row-label')).toHaveStyle({
+      gridColumn: '1',
+      gridRow: '2',
+    });
+  });
+
+  it('shifts the morpheme columns past the label track', () => {
+    renderBox({ rowLabels: ROW_LABELS });
+
+    expect(screen.getByText('hel')).toHaveStyle({ gridColumn: '2' });
+    expect(screen.getByText('-lo')).toHaveStyle({ gridColumn: '3' });
+  });
+
+  it('reserves no label track where the caller names no rows', () => {
+    // The token strip's breakdown is unlabeled; a track for absent labels would inset every chip.
+    renderBox();
+
+    expect(screen.getByText('hel')).toHaveStyle({ gridColumn: '1' });
+  });
+});
diff --git a/src/__tests__/components/MorphemeEditor.test.tsx b/src/__tests__/components/MorphemeEditor.test.tsx
index 9e550d346..cec4d4e39 100644
--- a/src/__tests__/components/MorphemeEditor.test.tsx
+++ b/src/__tests__/components/MorphemeEditor.test.tsx
@@ -4,6 +4,7 @@
 import { useLocalizedStrings } from '@papi/frontend/react';
 import { fireEvent, render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
+import type { MorphemeAnalysis } from 'interlinearizer';
 import type { ComponentProps } from 'react';
 import { MorphemeBreakdownPopover } from '../../components/MorphemeEditor';
 
@@ -17,9 +18,17 @@ const LOCALIZED = {
   '%interlinearizer_morphemeEditor_emptyHint%': 'Enter morpheme forms separated by spaces',
   '%interlinearizer_morphemeEditor_confirmResetPrompt%': 'Discard this breakdown and its glosses?',
   '%interlinearizer_morphemeEditor_confirmResetAction%': 'Reset',
+  '%interlinearizer_morphemeEditor_confirmResplitPrompt%':
+    'This breakdown drops {forms}, discarding the glosses on it. Save anyway?',
+  '%interlinearizer_morphemeEditor_confirmResplitAction%': 'Save and discard',
   '%interlinearizer_morphemeGloss_label%': 'Gloss for morpheme {form}',
 };
 
+/** A morpheme carrying a gloss, so dropping it is the loss a re-split confirms over. */
+function glossed(id: string, form: string): MorphemeAnalysis {
+  return { id, form, writingSystem: 'und', gloss: { und: form } };
+}
+
 beforeEach(() => {
   jest.mocked(useLocalizedStrings).mockReturnValue([LOCALIZED, false]);
 });
@@ -333,6 +342,25 @@ describe('MorphemeBreakdownPopover', () => {
     expect(screen.getByRole('textbox', { name: 'morpheme gloss' })).toHaveFocus();
   });
 
+  it('leaves the close-focus default alone when no gloss input is named', async () => {
+    // Opened from an ordinary tabbable trigger rather than a token chip, there is no gloss field
+    // to land in and the popover's own focus restoration is what belongs.
+    render(
+      <>
+        <input aria-label="elsewhere" />
+        <MorphemeBreakdownPopover initialValue="word" onClose={jest.fn()} onSave={jest.fn()} />
+      </>,
+    );
+    const elsewhere = screen.getByRole('textbox', { name: 'elsewhere' });
+    elsewhere.focus();
+
+    // The stub blurs the focused element for an unprevented close event, which is how it stands in
+    // for Radix moving focus itself — so an unprevented default is what this asserts.
+    await userEvent.click(screen.getByTestId('popover-close'));
+
+    expect(elsewhere).not.toHaveFocus();
+  });
+
   it('leaves focus alone when the popover was dismissed by a press outside it', async () => {
     // A press outside has already put focus where the user aimed it — typically another token they
     // clicked. Pulling focus back to this chip's first morpheme gloss would yank it out of that
@@ -445,6 +473,109 @@ describe('MorphemeBreakdownPopover', () => {
     });
   });
 
+  describe('re-split confirmation', () => {
+    /**
+     * Renders the popover over a glossed breakdown of "unbelievable" that this token solely owns,
+     * so a re-split dropping any of its forms destroys that form's gloss outright.
+     */
+    function renderResplitting(
+      props: Partial<ComponentProps<typeof MorphemeBreakdownPopover>> = {},
+    ) {
+      return renderPopover({
+        initialValue: 'un- believ -able',
+        morphemes: [glossed('m-1', 'un-'), glossed('m-2', 'believ'), glossed('m-3', '-able')],
+        onReset: jest.fn(),
+        ...props,
+      });
+    }
+
+    /** Replaces the draft with `value` and commits it. */
+    async function commit(value: string) {
+      await userEvent.clear(screen.getByRole('textbox'));
+      await userEvent.type(screen.getByRole('textbox'), value);
+      await userEvent.keyboard('{Enter}');
+    }
+
+    it('asks before a re-split that strands a glossed form', async () => {
+      const onSave = jest.fn();
+      const onClose = jest.fn();
+      renderResplitting({ onSave, onClose });
+      await commit('un- believe');
+      expect(screen.getByTestId('morpheme-split-confirm')).toBeInTheDocument();
+      expect(onSave).not.toHaveBeenCalled();
+      expect(onClose).not.toHaveBeenCalled();
+    });
+
+    it('names the stranded forms in the prompt', async () => {
+      renderResplitting();
+      await commit('un- believe');
+      expect(screen.getByTestId('morpheme-split-confirm')).toHaveTextContent(
+        'This breakdown drops believ, -able, discarding the glosses on it. Save anyway?',
+      );
+    });
+
+    it('saves and closes when the confirmation is accepted', async () => {
+      const onSave = jest.fn();
+      const onClose = jest.fn();
+      renderResplitting({ onSave, onClose });
+      await commit('un- believe');
+      await userEvent.click(screen.getByTestId('morpheme-split-confirm-action'));
+      expect(onSave).toHaveBeenCalledWith('un- believe');
+      expect(onClose).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns to the draft when the confirmation is canceled', async () => {
+      const onSave = jest.fn();
+      renderResplitting({ onSave });
+      await commit('un- believe');
+      await userEvent.click(screen.getByRole('button', { name: 'Cancel' }));
+      expect(screen.queryByTestId('morpheme-split-confirm')).not.toBeInTheDocument();
+      expect(screen.getByRole('textbox')).toHaveValue('un- believe');
+      expect(onSave).not.toHaveBeenCalled();
+    });
+
+    it('leaves a pending re-split unwritten when the user presses outside the panel', async () => {
+      // The same reasoning as the reset confirmation: the loss is irreversible, so a stray click
+      // must not answer the prompt, even though an outside press on an edited draft normally saves.
+      const onSave = jest.fn();
+      const onClose = jest.fn();
+      renderResplitting({ onSave, onClose });
+      await commit('un- believe');
+      await userEvent.click(screen.getByTestId('popover-outside'));
+      expect(onSave).not.toHaveBeenCalled();
+      expect(onClose).toHaveBeenCalledTimes(1);
+    });
+
+    it('saves without asking when the re-split keeps every glossed form', async () => {
+      const onSave = jest.fn();
+      renderResplitting({ onSave });
+      await commit('un- believ -able -ness');
+      expect(screen.queryByTestId('morpheme-split-confirm')).not.toBeInTheDocument();
+      expect(onSave).toHaveBeenCalledWith('un- believ -able -ness');
+    });
+
+    it('saves without asking when the stranded form carried no gloss', async () => {
+      const onSave = jest.fn();
+      renderResplitting({
+        morphemes: [glossed('m-1', 'un-'), { id: 'm-2', form: 'believ', writingSystem: 'und' }],
+        onSave,
+      });
+      await commit('un- believe');
+      expect(screen.queryByTestId('morpheme-split-confirm')).not.toBeInTheDocument();
+      expect(onSave).toHaveBeenCalledWith('un- believe');
+    });
+
+    it('saves without asking when the payload is shared, its morphemes withheld', async () => {
+      // A shared payload is forked rather than re-segmented in place, so the co-linked tokens keep
+      // the glosses this token drops and there is nothing to confirm.
+      const onSave = jest.fn();
+      renderResplitting({ morphemes: undefined, onSave });
+      await commit('un- believe');
+      expect(screen.queryByTestId('morpheme-split-confirm')).not.toBeInTheDocument();
+      expect(onSave).toHaveBeenCalledWith('un- believe');
+    });
+  });
+
   it('falls back to the token gloss input on close when the chip has no morpheme gloss field', async () => {
     render(
       <label>
diff --git a/src/__tests__/components/TokenChip.test.tsx b/src/__tests__/components/TokenChip.test.tsx
index 214bdf3d0..e4f2ed853 100644
--- a/src/__tests__/components/TokenChip.test.tsx
+++ b/src/__tests__/components/TokenChip.test.tsx
@@ -25,14 +25,21 @@ jest.mock('../../components/MorphemeEditor', () => ({
     onClose,
     onReset,
     needsResetConfirm,
+    morphemes,
   }: Readonly<{
     onSave: (v: string) => void;
     onClose: () => void;
     onReset?: () => void;
     needsResetConfirm?: boolean;
+    morphemes?: readonly { form: string }[];
   }>) {
     return (
-      <div data-testid="morpheme-popover" data-needs-reset-confirm={needsResetConfirm}>
+      <div
+        data-testid="morpheme-popover"
+        data-needs-reset-confirm={needsResetConfirm}
+        // Absent entirely when the chip withholds them, which is how a shared payload reads.
+        data-resplit-morphemes={morphemes?.map((m) => m.form).join(' ')}
+      >
         <button onClick={() => onSave('hel -lo')} type="button">
           mock-save
         </button>
@@ -703,7 +710,7 @@ describe('TokenChip', () => {
     });
 
     it('tells the popover to confirm when a reset would lose glosses', async () => {
-      jest.spyOn(AnalysisStore, 'useMorphemeResetLosesGlosses').mockReturnValue(true);
+      jest.spyOn(AnalysisStore, 'useMorphemeResetLosesAnnotation').mockReturnValue(true);
 
       render(
         <AnalysisStoreProvider analysisLanguage="und">
@@ -720,7 +727,7 @@ describe('TokenChip', () => {
     });
 
     it('tells the popover not to confirm when a reset would lose nothing', async () => {
-      jest.spyOn(AnalysisStore, 'useMorphemeResetLosesGlosses').mockReturnValue(false);
+      jest.spyOn(AnalysisStore, 'useMorphemeResetLosesAnnotation').mockReturnValue(false);
 
       render(
         <AnalysisStoreProvider analysisLanguage="und">
@@ -736,6 +743,41 @@ describe('TokenChip', () => {
       );
     });
 
+    it('hands the popover the morphemes to weigh a re-split against when this token owns them', async () => {
+      jest.spyOn(AnalysisStore, 'useMorphemePayloadIsSolelyOwned').mockReturnValue(true);
+      jest
+        .spyOn(AnalysisStore, 'useMorphemes')
+        .mockReturnValue([{ id: 'm-1', form: 'hel', writingSystem: 'und' }]);
+
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      await userEvent.click(screen.getByRole('button', { name: 'mock-edit-breakdown' }));
+      expect(screen.getByTestId('morpheme-popover')).toHaveAttribute(
+        'data-resplit-morphemes',
+        'hel',
+      );
+    });
+
+    it('withholds the morphemes when the payload is shared, so a re-split loses nothing', async () => {
+      // The write forks a shared payload rather than re-segmenting it, so the co-linked tokens keep
+      // whatever this one drops and there is nothing for the popover to confirm.
+      jest.spyOn(AnalysisStore, 'useMorphemePayloadIsSolelyOwned').mockReturnValue(false);
+      jest
+        .spyOn(AnalysisStore, 'useMorphemes')
+        .mockReturnValue([{ id: 'm-1', form: 'hel', writingSystem: 'und' }]);
+
+      render(
+        <AnalysisStoreProvider analysisLanguage="und">
+          <TokenChip {...requiredProps()} showMorphology />
+        </AnalysisStoreProvider>,
+      );
+      await userEvent.click(screen.getByRole('button', { name: 'mock-edit-breakdown' }));
+      expect(screen.getByTestId('morpheme-popover')).not.toHaveAttribute('data-resplit-morphemes');
+    });
+
     it('focuses the main gloss input on a surface-text mouse-down when the box precedes it', () => {
       jest
         .spyOn(AnalysisStore, 'useMorphemes')
diff --git a/src/__tests__/components/modals/ModalShell.test.tsx b/src/__tests__/components/modals/ModalShell.test.tsx
index 4ce67b116..6a2a69429 100644
--- a/src/__tests__/components/modals/ModalShell.test.tsx
+++ b/src/__tests__/components/modals/ModalShell.test.tsx
@@ -3,6 +3,7 @@
 
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
+import { Popover, PopoverContent } from 'platform-bible-react';
 import { ModalShell } from '../../../components/modals/ModalShell';
 
 // Popovers carry the dialog role too, so the modal surface is reached by the slot that is its own.
@@ -68,6 +69,39 @@ describe('ModalShell', () => {
     expect(document.querySelector(DIALOG_SELECTOR)).toBeInTheDocument();
   });
 
+  it('calls onClose when the user clicks outside the modal', async () => {
+    const onClose = jest.fn();
+    render(<ModalShell {...defaultProps} onClose={onClose} />);
+
+    await userEvent.click(screen.getByTestId('dialog-outside'));
+
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it('ignores an outside click when no onClose is supplied, so a busy modal cannot be abandoned', async () => {
+    render(<ModalShell {...defaultProps} />);
+
+    await userEvent.click(screen.getByTestId('dialog-outside'));
+
+    expect(document.querySelector(DIALOG_SELECTOR)).toBeInTheDocument();
+  });
+
+  // Dismissing both at once discards the work the popover was opened over.
+  it('ignores an outside click while a popover is open inside the modal', async () => {
+    const onClose = jest.fn();
+    render(
+      <ModalShell {...defaultProps} onClose={onClose}>
+        <Popover open>
+          <PopoverContent>Panel</PopoverContent>
+        </Popover>
+      </ModalShell>,
+    );
+
+    await userEvent.click(screen.getByTestId('dialog-outside'));
+
+    expect(onClose).not.toHaveBeenCalled();
+  });
+
   it('dismisses only the topmost modal on Escape when one overlays another', async () => {
     const onCloseUnder = jest.fn();
     const onCloseOver = jest.fn();
diff --git a/src/__tests__/store/analysisSlice.test.ts b/src/__tests__/store/analysisSlice.test.ts
index 5ed45b5be..1f11d393f 100644
--- a/src/__tests__/store/analysisSlice.test.ts
+++ b/src/__tests__/store/analysisSlice.test.ts
@@ -1,6 +1,9 @@
 /// <reference types="jest" />
 
 import type {
+  AssignmentStatus,
+  Confidence,
+  MorphemeAnalysis,
   PhraseAnalysisLink,
   SegmentAnalysis,
   SegmentAnalysisLink,
@@ -13,13 +16,18 @@ import { createAnalysisStore } from '../../store';
 import {
   approveAnalysisForToken,
   createPhrase,
+  deleteAnalysis,
   deleteMorphemes,
   deletePhrase,
+  mergeAnalysesInto,
   mergePhrases,
+  morphemeFormsLostByResplit,
+  selectAnalysisDeletionOutcome,
   selectApprovedGloss,
   selectApprovedMorphemes,
   selectCatalogRows,
-  selectMorphemeResetLosesGlosses,
+  selectMorphemePayloadIsSolelyOwned,
+  selectMorphemeResetLosesAnnotation,
   selectPhraseLinkByTokenRef,
   selectPhraseGloss,
   selectPhraseLinks,
@@ -29,6 +37,9 @@ import {
   selectSegmentFreeTranslation,
   selectFreeTranslationsBySegment,
   updatePhrase,
+  writeAnalysisGloss,
+  writeAnalysisMorphemeGloss,
+  writeAnalysisMorphemes,
   writeGloss,
   writeMorphemeGloss,
   writeMorphemes,
@@ -37,6 +48,7 @@ import {
   type AnalysisState,
 } from '../../store/analysisSlice';
 import { emptyAnalysis } from '../../types/empty-factories';
+import { deriveMergeContent } from '../../utils/merge-content';
 import { makePhraseLink, FIXTURE_STAMPS } from '../test-helpers';
 
 /**
@@ -140,6 +152,115 @@ describe('writeGloss', () => {
     expect(tokenAnalyses[0].gloss).toStrictEqual({ und: 'hello' });
   });
 
+  it('drops the sense reference when the reader rewrites the gloss', () => {
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: makeAnalysis({
+          ...FIXTURE_STAMPS,
+          id: 'ta-1',
+          surfaceText: 'word',
+          gloss: { und: 'run' },
+          glossSenseRef: { authority: 'x-test', senseId: 'sense-run' },
+        }),
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeGloss('tok-1', 'word', 'race'));
+
+    const { tokenAnalyses } = store.getState().analysis.analysis;
+    expect(tokenAnalyses[0].gloss).toStrictEqual({ und: 'race' });
+    expect(tokenAnalyses[0].glossSenseRef).toBeUndefined();
+  });
+
+  it('drops the sense reference when the reader clears the gloss', () => {
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: makeAnalysis({
+          ...FIXTURE_STAMPS,
+          id: 'ta-1',
+          surfaceText: 'word',
+          gloss: { und: 'run' },
+          glossSenseRef: { authority: 'x-test', senseId: 'sense-run' },
+          morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'und' }],
+        }),
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeGloss('tok-1', 'word', ''));
+
+    const { tokenAnalyses } = store.getState().analysis.analysis;
+    expect(tokenAnalyses[0].glossSenseRef).toBeUndefined();
+  });
+
+  it('keeps the sense reference when clearing one language leaves another glossed', () => {
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: makeAnalysis({
+          ...FIXTURE_STAMPS,
+          id: 'ta-1',
+          surfaceText: 'word',
+          gloss: { und: 'run', fr: 'courir' },
+          glossSenseRef: { authority: 'x-test', senseId: 'sense-run' },
+        }),
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeGloss('tok-1', 'word', ''));
+
+    const { tokenAnalyses } = store.getState().analysis.analysis;
+    expect(tokenAnalyses[0].gloss).toStrictEqual({ fr: 'courir' });
+    expect(tokenAnalyses[0].glossSenseRef).toStrictEqual({
+      authority: 'x-test',
+      senseId: 'sense-run',
+    });
+  });
+
+  it('drops the sense reference when clearing one language leaves only a blank gloss', () => {
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: makeAnalysis({
+          ...FIXTURE_STAMPS,
+          id: 'ta-1',
+          surfaceText: 'word',
+          gloss: { und: 'run', fr: '  ' },
+          glossSenseRef: { authority: 'x-test', senseId: 'sense-run' },
+          morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'und' }],
+        }),
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeGloss('tok-1', 'word', ''));
+
+    const { tokenAnalyses } = store.getState().analysis.analysis;
+    expect(tokenAnalyses[0].gloss).toBeUndefined();
+    expect(tokenAnalyses[0].glossSenseRef).toBeUndefined();
+  });
+
+  it('removes a record a blank-gloss clear leaves with nothing but its sense reference', () => {
+    const store = createAnalysisStore({
+      analysis: {
+        analysis: makeAnalysis({
+          ...FIXTURE_STAMPS,
+          id: 'ta-1',
+          surfaceText: 'word',
+          gloss: { und: 'run', fr: '  ' },
+          glossSenseRef: { authority: 'x-test', senseId: 'sense-run' },
+        }),
+        analysisLanguage: 'und',
+      },
+    });
+
+    store.dispatch(writeGloss('tok-1', 'word', ''));
+
+    const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+    expect(tokenAnalyses).toHaveLength(0);
+    expect(tokenAnalysisLinks).toHaveLength(0);
+  });
+
   it('refreshes the surface text on the analysis and the link snapshot when the token text changed', () => {
     const store = createAnalysisStore({
       analysis: {
@@ -2354,7 +2475,7 @@ describe('approveAnalysisForToken', () => {
   });
 });
 
-describe('selectMorphemeResetLosesGlosses', () => {
+describe('selectMorphemeResetLosesAnnotation', () => {
   /**
    * Writes a two-morpheme breakdown for `tokenRef` and returns the id of its first morpheme, so
    * tests can gloss a morpheme whose id the reducer generated.
@@ -2366,21 +2487,42 @@ describe('selectMorphemeResetLosesGlosses', () => {
 
   it('reports no loss when the token has no approved analysis', () => {
     const store = createAnalysisStore();
-    expect(selectMorphemeResetLosesGlosses(store.getState().analysis, 'tok-1')).toBe(false);
+    expect(selectMorphemeResetLosesAnnotation(store.getState().analysis, 'tok-1')).toBe(false);
   });
 
-  it('reports no loss when the breakdown carries no morpheme glosses', () => {
+  it('reports no loss when the breakdown carries no morpheme annotation', () => {
     // Bare segmentation is cheap to retype, so removing it needs no confirmation.
     const store = createAnalysisStore();
     breakDown(store, 'tok-1');
-    expect(selectMorphemeResetLosesGlosses(store.getState().analysis, 'tok-1')).toBe(false);
+    expect(selectMorphemeResetLosesAnnotation(store.getState().analysis, 'tok-1')).toBe(false);
   });
 
   it('reports a loss when a glossed breakdown is linked only by this token', () => {
     const store = createAnalysisStore();
     const morphemeId = breakDown(store, 'tok-1');
     store.dispatch(writeMorphemeGloss({ tokenRef: 'tok-1', morphemeId, value: 'feline' }));
-    expect(selectMorphemeResetLosesGlosses(store.getState().analysis, 'tok-1')).toBe(true);
+    expect(selectMorphemeResetLosesAnnotation(store.getState().analysis, 'tok-1')).toBe(true);
+  });
+
+  it('reports a loss when an unglossed breakdown carries a lexicon reference', () => {
+    // An imported morpheme can hold an entry with no gloss beside it, and the reset discards it.
+    const ta: TokenAnalysis = {
+      ...FIXTURE_STAMPS,
+      id: 'ta-1',
+      surfaceText: 'cats',
+      morphemes: [
+        {
+          id: 'm-1',
+          form: 'cat',
+          writingSystem: 'en',
+          senseRef: { authority: 'lexicon', senseId: 's-1' },
+        },
+      ],
+    };
+    const store = createAnalysisStore({
+      analysis: { analysis: makeAnalysis(ta), analysisLanguage: 'und' },
+    });
+    expect(selectMorphemeResetLosesAnnotation(store.getState().analysis, 'tok-1')).toBe(true);
   });
 
   it('reports no loss when a glossed breakdown is shared with another token', () => {
@@ -2394,7 +2536,101 @@ describe('selectMorphemeResetLosesGlosses', () => {
       (l) => l.token.tokenRef === 'tok-1',
     );
     store.dispatch(approveAnalysisForToken({ tokenRef: 'tok-2', surfaceText: 'cats', analysisId }));
-    expect(selectMorphemeResetLosesGlosses(store.getState().analysis, 'tok-2')).toBe(false);
+    expect(selectMorphemeResetLosesAnnotation(store.getState().analysis, 'tok-2')).toBe(false);
+  });
+});
+
+describe('selectMorphemePayloadIsSolelyOwned', () => {
+  it('reports not solely owned when the token has no approved analysis', () => {
+    const store = createAnalysisStore();
+    expect(selectMorphemePayloadIsSolelyOwned(store.getState().analysis, 'tok-1')).toBe(false);
+  });
+
+  it('reports solely owned when this token is the only approved link', () => {
+    const store = createAnalysisStore();
+    store.dispatch(writeMorphemes('tok-1', 'cats', ['cat', '-s'], 'en'));
+    expect(selectMorphemePayloadIsSolelyOwned(store.getState().analysis, 'tok-1')).toBe(true);
+  });
+
+  it('reports not solely owned when another token shares the payload', () => {
+    const store = createAnalysisStore();
+    store.dispatch(writeMorphemes('tok-1', 'cats', ['cat', '-s'], 'en'));
+    const [{ analysisId }] = store
+      .getState()
+      .analysis.analysis.tokenAnalysisLinks.filter((l) => l.token.tokenRef === 'tok-1');
+    store.dispatch(approveAnalysisForToken({ tokenRef: 'tok-2', surfaceText: 'cats', analysisId }));
+    expect(selectMorphemePayloadIsSolelyOwned(store.getState().analysis, 'tok-2')).toBe(false);
+  });
+});
+
+describe('morphemeFormsLostByResplit', () => {
+  /** A morpheme carrying a gloss, so a re-split dropping it destroys something. */
+  function glossed(id: string, form: string): MorphemeAnalysis {
+    return { id, form, writingSystem: 'en', gloss: { und: form } };
+  }
+
+  it('reports nothing lost when every glossed form survives the re-split', () => {
+    const old = [glossed('m-1', 'un-'), glossed('m-2', 'believ')];
+    expect(morphemeFormsLostByResplit(old, ['un-', 'believ', '-able'])).toEqual([]);
+  });
+
+  it('reports a glossed form the new breakdown has no morpheme for', () => {
+    const old = [glossed('m-1', 'un-'), glossed('m-2', 'believ'), glossed('m-3', '-able')];
+    expect(morphemeFormsLostByResplit(old, ['un-', 'believe'])).toEqual(['believ', '-able']);
+  });
+
+  it('leaves out a stranded form that carried nothing but its segmentation', () => {
+    // Losing bare segmentation costs only what the reader is retyping anyway.
+    const old = [glossed('m-1', 'un-'), { id: 'm-2', form: 'believ', writingSystem: 'en' }];
+    expect(morphemeFormsLostByResplit(old, ['un-', 'believe'])).toEqual([]);
+  });
+
+  it('reports an unglossed form whose morpheme carries a lexicon reference', () => {
+    // A PT9 import resolves the lexeme key and the gloss column independently, so a morpheme can
+    // arrive with an entry to fall back on and no gloss — a loss no retyping restores.
+    const old: MorphemeAnalysis[] = [
+      glossed('m-1', 'un-'),
+      {
+        id: 'm-2',
+        form: 'believ',
+        writingSystem: 'en',
+        entryRef: { authority: 'lexicon', entryId: 'e-1' },
+      },
+    ];
+    expect(morphemeFormsLostByResplit(old, ['un-', 'believe'])).toEqual(['believ']);
+  });
+
+  it('reports an unglossed form whose morpheme carries only a grammar reference', () => {
+    const old: MorphemeAnalysis[] = [
+      {
+        id: 'm-1',
+        form: 'believ',
+        writingSystem: 'en',
+        grammarRef: { authority: 'lexicon', msaId: 'msa-1' },
+      },
+    ];
+    expect(morphemeFormsLostByResplit(old, ['believe'])).toEqual(['believ']);
+  });
+
+  it('counts a repeated form once per occurrence the re-split drops', () => {
+    // The surviving "ba" takes the first old morpheme, as a re-split itself would, so the second is
+    // what goes.
+    const old = [glossed('m-1', 'ba'), glossed('m-2', 'ba')];
+    expect(morphemeFormsLostByResplit(old, ['ba'])).toEqual(['ba']);
+  });
+
+  it('reports nothing lost when a repeated form keeps every occurrence', () => {
+    const old = [glossed('m-1', 'ba'), glossed('m-2', 'ba')];
+    expect(morphemeFormsLostByResplit(old, ['ba', 'ba'])).toEqual([]);
+  });
+
+  it('reports every glossed form lost when the breakdown is cleared', () => {
+    const old = [glossed('m-1', 'un-'), glossed('m-2', 'believ')];
+    expect(morphemeFormsLostByResplit(old, [])).toEqual(['un-', 'believ']);
+  });
+
+  it('reports nothing lost when there was no breakdown to begin with', () => {
+    expect(morphemeFormsLostByResplit(undefined, ['un-', 'believ'])).toEqual([]);
   });
 });
 
@@ -2503,6 +2739,48 @@ describe('analysis timestamps', () => {
     expect(approved.link).toMatchObject({ createdAt: SECOND_WRITE, updatedAt: SECOND_WRITE });
   });
 
+  it('stamps every link a merge moves onto the target', () => {
+    const store = createAnalysisStore();
+    store.dispatch(writeGloss('tok-1', 'cat', 'feline'));
+    store.dispatch(writeGloss('tok-2', 'cat', 'tomcat'));
+    const source = approvedPair(store.getState().analysis, 'tok-1');
+    const target = approvedPair(store.getState().analysis, 'tok-2');
+
+    setClock(SECOND_WRITE);
+    store.dispatch(
+      mergeAnalysesInto({
+        survivorAnalysisId: target.analysis?.id ?? '',
+        mergedAnalysisIds: [source.analysis?.id ?? ''],
+        content: { gloss: 'tomcat', morphemes: [] },
+      }),
+    );
+
+    const moved = approvedPair(store.getState().analysis, 'tok-1');
+    expect(moved.link).toMatchObject({ createdAt: FIRST_WRITE, updatedAt: SECOND_WRITE });
+  });
+
+  // The survivor is written to, unlike its own links, which no annotation of theirs changed.
+  it('stamps the survivor of a merge but leaves its own links dated by their content', () => {
+    const store = createAnalysisStore();
+    store.dispatch(writeGloss('tok-1', 'cat', 'feline'));
+    store.dispatch(writeGloss('tok-2', 'cat', 'tomcat'));
+    const source = approvedPair(store.getState().analysis, 'tok-1');
+    const target = approvedPair(store.getState().analysis, 'tok-2');
+
+    setClock(SECOND_WRITE);
+    store.dispatch(
+      mergeAnalysesInto({
+        survivorAnalysisId: target.analysis?.id ?? '',
+        mergedAnalysisIds: [source.analysis?.id ?? ''],
+        content: { gloss: 'tomcat', morphemes: [] },
+      }),
+    );
+
+    const survivor = approvedPair(store.getState().analysis, 'tok-2');
+    expect(survivor.analysis).toMatchObject({ createdAt: FIRST_WRITE, updatedAt: SECOND_WRITE });
+    expect(survivor.link).toMatchObject({ createdAt: FIRST_WRITE, updatedAt: FIRST_WRITE });
+  });
+
   it('stamps a morpheme gloss edit on the payload and the link', () => {
     const store = createAnalysisStore();
     store.dispatch(writeMorphemes('tok-1', 'cats', ['cat', 's'], 'en'));
@@ -2593,3 +2871,1657 @@ describe('analysis timestamps', () => {
     });
   });
 });
+
+describe('analysis-keyed reducers', () => {
+  /**
+   * Builds a store where one payload is shared by two approved tokens, the shape the catalog's
+   * whole reason for existing rests on: one row, many usages.
+   */
+  function makeSharedStore(overrides?: Partial<TokenAnalysis>) {
+    const shared: TokenAnalysis = {
+      ...FIXTURE_STAMPS,
+      id: 'ta-shared',
+      surfaceText: 'word',
+      gloss: { und: 'first' },
+      ...overrides,
+    };
+    const links: TokenAnalysisLink[] = ['tok-1', 'tok-2'].map((tokenRef) => ({
+      ...FIXTURE_STAMPS,
+      analysisId: shared.id,
+      status: 'approved',
+      token: { tokenRef, surfaceText: 'word' },
+    }));
+    return createAnalysisStore({
+      analysis: {
+        analysis: { ...emptyAnalysis(), tokenAnalyses: [shared], tokenAnalysisLinks: links },
+        analysisLanguage: 'und',
+      },
+    });
+  }
+
+  /**
+   * Builds a store where one token links both payloads at once — the state a PT9 import leaves
+   * behind, and the one a merge has to collapse rather than repoint blind. Splitting the two links
+   * across tokens with `sourceTokenRef` gives the merge nothing to collapse.
+   */
+  function makeBothLinkedStore(
+    sourceStatus: AssignmentStatus,
+    targetStatus: AssignmentStatus = 'approved',
+    sourceTokenRef = 'tok-1',
+    provenance: {
+      source?: { createdAt?: string; confidence?: Confidence };
+      target?: { createdAt?: string; confidence?: Confidence };
+    } = {},
+  ) {
+    const payloads: TokenAnalysis[] = [
+      { ...FIXTURE_STAMPS, id: 'ta-source', surfaceText: 'word', gloss: { und: 'first' } },
+      { ...FIXTURE_STAMPS, id: 'ta-target', surfaceText: 'word', gloss: { und: 'second' } },
+    ];
+    const links: TokenAnalysisLink[] = [
+      {
+        ...FIXTURE_STAMPS,
+        analysisId: 'ta-source',
+        status: sourceStatus,
+        token: { tokenRef: sourceTokenRef, surfaceText: 'word' },
+        ...provenance.source,
+      },
+      {
+        ...FIXTURE_STAMPS,
+        analysisId: 'ta-target',
+        status: targetStatus,
+        token: { tokenRef: 'tok-1', surfaceText: 'word' },
+        ...provenance.target,
+      },
+    ];
+    return createAnalysisStore({
+      analysis: {
+        analysis: { ...emptyAnalysis(), tokenAnalyses: payloads, tokenAnalysisLinks: links },
+        analysisLanguage: 'und',
+      },
+    });
+  }
+
+  describe('writeAnalysisGloss', () => {
+    it('rewrites the gloss for every token linked to the payload', () => {
+      const store = makeSharedStore();
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: 'second' }));
+
+      const state = store.getState().analysis;
+      expect(selectApprovedGloss(state, 'tok-1')).toBe('second');
+      expect(selectApprovedGloss(state, 'tok-2')).toBe('second');
+    });
+
+    it('does not fork the shared payload', () => {
+      const store = makeSharedStore();
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: 'second' }));
+
+      expect(store.getState().analysis.analysis.tokenAnalyses).toHaveLength(1);
+    });
+
+    it('removes the record entirely when the edit empties it', () => {
+      const store = makeSharedStore();
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: '  ' }));
+
+      const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+      expect(tokenAnalyses).toHaveLength(0);
+      expect(tokenAnalysisLinks).toHaveLength(0);
+    });
+
+    it('keeps the record when clearing the gloss leaves other content behind', () => {
+      const store = makeSharedStore({
+        morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'en' }],
+      });
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: '' }));
+
+      const { tokenAnalyses } = store.getState().analysis.analysis;
+      expect(tokenAnalyses).toHaveLength(1);
+      expect(tokenAnalyses[0].gloss).toBeUndefined();
+    });
+
+    it('drops the sense reference when the reader rewrites the gloss', () => {
+      const store = makeSharedStore({
+        glossSenseRef: { authority: 'x-test', senseId: 'sense-run' },
+        morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'en' }],
+      });
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: 'race' }));
+
+      const { tokenAnalyses } = store.getState().analysis.analysis;
+      expect(tokenAnalyses[0].gloss).toEqual({ und: 'race' });
+      expect(tokenAnalyses[0].glossSenseRef).toBeUndefined();
+    });
+
+    it('drops the sense reference when the reader clears the gloss', () => {
+      const store = makeSharedStore({
+        glossSenseRef: { authority: 'x-test', senseId: 'sense-run' },
+        morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'en' }],
+      });
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: '' }));
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].glossSenseRef).toBeUndefined();
+    });
+
+    it('keeps the sense reference when clearing one language leaves another glossed', () => {
+      const store = makeSharedStore({
+        gloss: { und: 'run', fr: 'courir' },
+        glossSenseRef: { authority: 'x-test', senseId: 'sense-run' },
+      });
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: '' }));
+
+      const { tokenAnalyses } = store.getState().analysis.analysis;
+      expect(tokenAnalyses[0].gloss).toStrictEqual({ fr: 'courir' });
+      expect(tokenAnalyses[0].glossSenseRef).toStrictEqual({
+        authority: 'x-test',
+        senseId: 'sense-run',
+      });
+    });
+
+    it('drops the sense reference when clearing one language leaves only a blank gloss', () => {
+      const store = makeSharedStore({
+        gloss: { und: 'run', fr: '  ' },
+        glossSenseRef: { authority: 'x-test', senseId: 'sense-run' },
+        morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'en' }],
+      });
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: '' }));
+
+      const { tokenAnalyses } = store.getState().analysis.analysis;
+      expect(tokenAnalyses[0].gloss).toBeUndefined();
+      expect(tokenAnalyses[0].glossSenseRef).toBeUndefined();
+    });
+
+    it('removes a record a blank-gloss clear leaves with nothing but its sense reference', () => {
+      const store = makeSharedStore({
+        gloss: { und: 'run', fr: '  ' },
+        glossSenseRef: { authority: 'x-test', senseId: 'sense-run' },
+      });
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: '' }));
+
+      const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+      expect(tokenAnalyses).toHaveLength(0);
+      expect(tokenAnalysisLinks).toHaveLength(0);
+    });
+
+    it('glosses a record that carried none, a breakdown having been entered first', () => {
+      const store = makeSharedStore({
+        gloss: undefined,
+        morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'en' }],
+      });
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: 'first' }));
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].gloss).toEqual({ und: 'first' });
+    });
+
+    it('leaves a record that never carried a gloss alone when the gloss is cleared', () => {
+      // Analyzed by its breakdown alone, which is the state a breakdown entered before its glosses
+      // sits in — so clearing the gloss it does not have must not disturb the record.
+      const store = makeSharedStore({
+        gloss: undefined,
+        morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'en' }],
+      });
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: '' }));
+
+      const { tokenAnalyses } = store.getState().analysis.analysis;
+      expect(tokenAnalyses).toHaveLength(1);
+      expect(tokenAnalyses[0].gloss).toBeUndefined();
+      expect(tokenAnalyses[0].morphemes).toHaveLength(1);
+    });
+
+    it('collapses onto a content-identical sibling, leaving the sibling as the survivor', () => {
+      const store = makeSharedStore();
+      // A second payload for the same word, glossed differently — a homograph the edit will match.
+      store.dispatch(writeGloss('tok-3', 'word', 'second'));
+      const sibling = store
+        .getState()
+        .analysis.analysis.tokenAnalyses.find((ta) => ta.id !== 'ta-shared');
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: 'second' }));
+
+      const { tokenAnalyses } = store.getState().analysis.analysis;
+      expect(tokenAnalyses).toHaveLength(1);
+      expect(tokenAnalyses[0].id).toBe(sibling?.id);
+    });
+
+    it('moves the collapsed payload’s links onto the surviving sibling', () => {
+      const store = makeSharedStore();
+      store.dispatch(writeGloss('tok-3', 'word', 'second'));
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-shared', value: 'second' }));
+
+      const state = store.getState().analysis;
+      expect(selectApprovedGloss(state, 'tok-1')).toBe('second');
+      expect(selectApprovedGloss(state, 'tok-2')).toBe('second');
+      expect(selectApprovedGloss(state, 'tok-3')).toBe('second');
+    });
+
+    it('leaves one link on a token that linked both payloads when the edit converges them', () => {
+      // The PT9 import shape: tok-1 approves one payload and holds the demoted homograph as a
+      // candidate.
+      const store = makeBothLinkedStore('candidate');
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-source', value: 'second' }));
+
+      const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+      expect(tokenAnalyses).toHaveLength(1);
+      expect(tokenAnalysisLinks).toHaveLength(1);
+      expect(tokenAnalysisLinks[0].analysisId).toBe('ta-target');
+    });
+
+    it('keeps the surviving link approved when the converged token had approved either payload', () => {
+      const store = makeBothLinkedStore('approved', 'candidate');
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-source', value: 'second' }));
+
+      const { tokenAnalysisLinks } = store.getState().analysis.analysis;
+      expect(tokenAnalysisLinks).toHaveLength(1);
+      expect(tokenAnalysisLinks[0].status).toBe('approved');
+    });
+
+    it('leaves both links when the converging payloads sit on different tokens', () => {
+      const store = makeBothLinkedStore('approved', 'approved', 'tok-2');
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'ta-source', value: 'second' }));
+
+      const { tokenAnalysisLinks } = store.getState().analysis.analysis;
+      expect(tokenAnalysisLinks).toHaveLength(2);
+      expect(tokenAnalysisLinks.map((l) => l.token.tokenRef).sort()).toEqual(['tok-1', 'tok-2']);
+    });
+
+    it('ignores an analysisId that resolves to no payload', () => {
+      const store = makeSharedStore();
+
+      store.dispatch(writeAnalysisGloss({ analysisId: 'nope', value: 'second' }));
+
+      expect(selectApprovedGloss(store.getState().analysis, 'tok-1')).toBe('first');
+    });
+  });
+
+  describe('writeAnalysisMorphemes', () => {
+    it('rewrites the breakdown for every token linked to the payload', () => {
+      const store = makeSharedStore();
+
+      store.dispatch(
+        writeAnalysisMorphemes({
+          analysisId: 'ta-shared',
+          forms: ['wor', 'd'],
+          writingSystem: 'en',
+        }),
+      );
+
+      const state = store.getState().analysis;
+      expect(selectApprovedMorphemes(state, 'tok-1').map((m) => m.form)).toEqual(['wor', 'd']);
+      expect(selectApprovedMorphemes(state, 'tok-2').map((m) => m.form)).toEqual(['wor', 'd']);
+    });
+
+    it('does not fork the shared payload', () => {
+      const store = makeSharedStore();
+
+      store.dispatch(
+        writeAnalysisMorphemes({
+          analysisId: 'ta-shared',
+          forms: ['wor', 'd'],
+          writingSystem: 'en',
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses).toHaveLength(1);
+    });
+
+    it('removes the breakdown when given no forms', () => {
+      const store = makeSharedStore({
+        morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'en' }],
+      });
+
+      store.dispatch(
+        writeAnalysisMorphemes({ analysisId: 'ta-shared', forms: [], writingSystem: 'en' }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].morphemes).toBeUndefined();
+    });
+
+    it('removes a record whose only content was the breakdown it just lost', () => {
+      const store = makeSharedStore({
+        gloss: undefined,
+        morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'en' }],
+      });
+
+      store.dispatch(
+        writeAnalysisMorphemes({ analysisId: 'ta-shared', forms: [], writingSystem: 'en' }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses).toHaveLength(0);
+    });
+
+    it('ignores an analysisId that resolves to no payload', () => {
+      const store = makeSharedStore();
+
+      store.dispatch(
+        writeAnalysisMorphemes({ analysisId: 'nope', forms: ['x'], writingSystem: 'en' }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].morphemes).toBeUndefined();
+    });
+
+    /** A shared payload broken down into a prefix and a stem, each carrying what it was analyzed as. */
+    function makeAnnotatedStore() {
+      return makeSharedStore({
+        surfaceText: 'unhappy',
+        morphemes: [
+          {
+            id: 'm-un',
+            form: 'un',
+            writingSystem: 'en',
+            gloss: { und: 'NEG' },
+            entryRef: { authority: 'lexicon', entryId: 'e-un' },
+          },
+          { id: 'm-happy', form: 'happy', writingSystem: 'en', gloss: { und: 'glad' } },
+        ],
+      });
+    }
+
+    it('keeps an unchanged morpheme whole when a neighbor is re-split', () => {
+      const store = makeAnnotatedStore();
+
+      store.dispatch(
+        writeAnalysisMorphemes({
+          analysisId: 'ta-shared',
+          forms: ['un', 'happi'],
+          writingSystem: 'en',
+        }),
+      );
+
+      const [kept] = store.getState().analysis.analysis.tokenAnalyses[0].morphemes ?? [];
+      expect(kept).toEqual({
+        id: 'm-un',
+        form: 'un',
+        writingSystem: 'en',
+        gloss: { und: 'NEG' },
+        entryRef: { authority: 'lexicon', entryId: 'e-un' },
+      });
+    });
+
+    it('mints a morpheme for a form the old breakdown cannot account for', () => {
+      const store = makeAnnotatedStore();
+
+      store.dispatch(
+        writeAnalysisMorphemes({
+          analysisId: 'ta-shared',
+          forms: ['un', 'happi'],
+          writingSystem: 'en',
+        }),
+      );
+
+      const morphemes = store.getState().analysis.analysis.tokenAnalyses[0].morphemes ?? [];
+      expect(morphemes[1]).toEqual({
+        id: expect.any(String),
+        form: 'happi',
+        writingSystem: 'en',
+      });
+      expect(morphemes[1].id).not.toBe('m-happy');
+    });
+
+    it('matches a repeated form against a distinct morpheme each time', () => {
+      const store = makeSharedStore({
+        surfaceText: 'ba ba',
+        morphemes: [
+          { id: 'm-1', form: 'ba', writingSystem: 'en', gloss: { und: 'first' } },
+          { id: 'm-2', form: 'ba', writingSystem: 'en', gloss: { und: 'second' } },
+        ],
+      });
+
+      store.dispatch(
+        writeAnalysisMorphemes({
+          analysisId: 'ta-shared',
+          forms: ['ba', 'ba'],
+          writingSystem: 'en',
+        }),
+      );
+
+      const morphemes = store.getState().analysis.analysis.tokenAnalyses[0].morphemes ?? [];
+      expect(morphemes.map((m) => m.id)).toEqual(['m-1', 'm-2']);
+    });
+
+    it('refreshes the writing system on a morpheme it keeps', () => {
+      const store = makeAnnotatedStore();
+
+      store.dispatch(
+        writeAnalysisMorphemes({
+          analysisId: 'ta-shared',
+          forms: ['un', 'happy'],
+          writingSystem: 'fr',
+        }),
+      );
+
+      const morphemes = store.getState().analysis.analysis.tokenAnalyses[0].morphemes ?? [];
+      expect(morphemes.map((m) => m.writingSystem)).toEqual(['fr', 'fr']);
+    });
+
+    it('drops what a form carried when the re-split leaves no morpheme holding it', () => {
+      const store = makeAnnotatedStore();
+
+      store.dispatch(
+        writeAnalysisMorphemes({
+          analysisId: 'ta-shared',
+          forms: ['unhappy'],
+          writingSystem: 'en',
+        }),
+      );
+
+      const morphemes = store.getState().analysis.analysis.tokenAnalyses[0].morphemes ?? [];
+      expect(morphemes).toEqual([{ id: expect.any(String), form: 'unhappy', writingSystem: 'en' }]);
+    });
+  });
+
+  describe('writeAnalysisMorphemeGloss', () => {
+    /** A shared payload carrying a two-morpheme breakdown, the unit this reducer edits. */
+    function makeMorphemeStore() {
+      return makeSharedStore({
+        morphemes: [
+          { id: 'm-1', form: 'wor', writingSystem: 'en' },
+          { id: 'm-2', form: 'd', writingSystem: 'en' },
+        ],
+      });
+    }
+
+    it('writes a morpheme gloss for every token linked to the payload', () => {
+      const store = makeMorphemeStore();
+
+      store.dispatch(
+        writeAnalysisMorphemeGloss({ analysisId: 'ta-shared', morphemeId: 'm-1', value: 'WORD' }),
+      );
+
+      const state = store.getState().analysis;
+      expect(selectApprovedMorphemes(state, 'tok-1')[0].gloss?.und).toBe('WORD');
+      expect(selectApprovedMorphemes(state, 'tok-2')[0].gloss?.und).toBe('WORD');
+    });
+
+    it('keeps the morpheme when its gloss is cleared', () => {
+      const store = makeMorphemeStore();
+      store.dispatch(
+        writeAnalysisMorphemeGloss({ analysisId: 'ta-shared', morphemeId: 'm-1', value: 'WORD' }),
+      );
+
+      store.dispatch(
+        writeAnalysisMorphemeGloss({ analysisId: 'ta-shared', morphemeId: 'm-1', value: '' }),
+      );
+
+      const morphemes = selectApprovedMorphemes(store.getState().analysis, 'tok-1');
+      expect(morphemes).toHaveLength(2);
+      expect(morphemes[0].gloss).toBeUndefined();
+    });
+
+    it('ignores a morphemeId the payload does not carry', () => {
+      const store = makeMorphemeStore();
+
+      store.dispatch(
+        writeAnalysisMorphemeGloss({ analysisId: 'ta-shared', morphemeId: 'nope', value: 'WORD' }),
+      );
+
+      expect(selectApprovedMorphemes(store.getState().analysis, 'tok-1')[0].gloss).toBeUndefined();
+    });
+  });
+
+  describe('deleteAnalysis', () => {
+    it('removes the payload and every link to it', () => {
+      const store = makeSharedStore();
+
+      store.dispatch(deleteAnalysis({ analysisId: 'ta-shared' }));
+
+      const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+      expect(tokenAnalyses).toHaveLength(0);
+      expect(tokenAnalysisLinks).toHaveLength(0);
+    });
+
+    it('leaves the affected tokens reading as blank', () => {
+      const store = makeSharedStore();
+
+      store.dispatch(deleteAnalysis({ analysisId: 'ta-shared' }));
+
+      const state = store.getState().analysis;
+      expect(selectApprovedGloss(state, 'tok-1')).toBe('');
+      expect(selectApprovedGloss(state, 'tok-2')).toBe('');
+    });
+
+    it('leaves a surviving homograph untouched', () => {
+      const store = makeSharedStore();
+      store.dispatch(writeGloss('tok-3', 'word', 'second'));
+
+      store.dispatch(deleteAnalysis({ analysisId: 'ta-shared' }));
+
+      expect(selectApprovedGloss(store.getState().analysis, 'tok-3')).toBe('second');
+    });
+
+    it('removes a candidate-only analysis with its unapproved link', () => {
+      const store = createAnalysisStore({
+        analysis: {
+          analysis: {
+            ...emptyAnalysis(),
+            tokenAnalyses: [
+              { ...FIXTURE_STAMPS, id: 'ta-unused', surfaceText: 'word', gloss: { und: 'first' } },
+            ],
+            tokenAnalysisLinks: [
+              {
+                ...FIXTURE_STAMPS,
+                analysisId: 'ta-unused',
+                status: 'candidate',
+                token: { tokenRef: 'tok-1', surfaceText: 'word' },
+              },
+            ],
+          },
+          analysisLanguage: 'und',
+        },
+      });
+
+      store.dispatch(deleteAnalysis({ analysisId: 'ta-unused' }));
+
+      const { tokenAnalyses, tokenAnalysisLinks } = store.getState().analysis.analysis;
+      expect(tokenAnalyses).toHaveLength(0);
+      expect(tokenAnalysisLinks).toHaveLength(0);
+    });
+  });
+
+  describe('mergeAnalysesInto', () => {
+    /**
+     * Builds a store of three homographs, one approved link each, so a merge has both records to
+     * fold in and one to leave standing. Each override re-shapes the payload whose id it names.
+     */
+    function makeHomographStore(...overrides: (Partial<TokenAnalysis> & { id: string })[]) {
+      const payloads: TokenAnalysis[] = ['a', 'b', 'c'].map((key) => {
+        const payload: TokenAnalysis = {
+          ...FIXTURE_STAMPS,
+          id: `ta-${key}`,
+          surfaceText: 'word',
+          gloss: { und: key },
+        };
+        const override = overrides.find((o) => o.id === payload.id);
+        return override ? { ...payload, ...override } : payload;
+      });
+      const links: TokenAnalysisLink[] = payloads.map((ta, index) => ({
+        ...FIXTURE_STAMPS,
+        analysisId: ta.id,
+        status: 'approved',
+        token: { tokenRef: `tok-${index + 1}`, surfaceText: 'word' },
+      }));
+      return createAnalysisStore({
+        analysis: {
+          analysis: { ...emptyAnalysis(), tokenAnalyses: payloads, tokenAnalysisLinks: links },
+          analysisLanguage: 'und',
+        },
+      });
+    }
+
+    it('writes the given content onto the survivor and moves every merged link to it', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      const state = store.getState().analysis;
+      expect(state.analysis.tokenAnalyses.map((ta) => ta.id)).toEqual(['ta-a', 'ta-c']);
+      expect(selectApprovedGloss(state, 'tok-1')).toBe('agreed');
+      expect(selectApprovedGloss(state, 'tok-2')).toBe('agreed');
+      // Left out of the merge, so it keeps saying what it said.
+      expect(selectApprovedGloss(state, 'tok-3')).toBe('c');
+    });
+
+    it('removes a survivor the merge settled to no content at all, releasing its tokens', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: '', morphemes: [] },
+        }),
+      );
+
+      const state = store.getState().analysis;
+      expect(state.analysis.tokenAnalyses.map((ta) => ta.id)).toEqual(['ta-c']);
+      expect(state.analysis.tokenAnalysisLinks.map((l) => l.token.tokenRef)).toEqual(['tok-3']);
+      expect(selectApprovedGloss(state, 'tok-1')).toBe('');
+      expect(selectApprovedGloss(state, 'tok-2')).toBe('');
+    });
+
+    it('keeps a survivor the merge left holding content besides the gloss', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: '', morphemes: [], pos: 'noun' },
+        }),
+      );
+
+      const state = store.getState().analysis;
+      expect(state.analysis.tokenAnalyses.map((ta) => ta.id)).toEqual(['ta-a', 'ta-c']);
+    });
+
+    it('writes every content field the merge settled', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: {
+            gloss: 'agreed',
+            morphemes: [
+              { id: 'm-1', form: 'wor', writingSystem: 'grc' },
+              { id: 'm-2', form: 'd', writingSystem: 'grc' },
+            ],
+            pos: 'noun',
+            features: { Case: 'Nom' },
+            confidence: 'high',
+          },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0]).toMatchObject({
+        gloss: { und: 'agreed' },
+        morphemes: [{ form: 'wor' }, { form: 'd' }],
+        pos: 'noun',
+        features: { Case: 'Nom' },
+        confidence: 'high',
+      });
+    });
+
+    it('leaves a morpheme unglossed when the merge settled on whitespace for it', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: {
+            gloss: 'agreed',
+            morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'grc', gloss: { und: ' ' } }],
+          },
+        }),
+      );
+
+      expect(
+        store.getState().analysis.analysis.tokenAnalyses[0].morphemes?.[0].gloss,
+      ).toBeUndefined();
+    });
+
+    it('keeps a morpheme its other languages when the merge settled on whitespace for one', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: {
+            gloss: 'agreed',
+            morphemes: [
+              { id: 'm-1', form: 'word', writingSystem: 'grc', gloss: { und: ' ', fr: 'mot' } },
+            ],
+          },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].morphemes?.[0].gloss).toEqual({
+        fr: 'mot',
+      });
+    });
+
+    it('converges a whitespace-glossed morpheme onto an identical unglossed homograph', () => {
+      const store = makeHomographStore({
+        id: 'ta-c',
+        gloss: { und: 'agreed' },
+        morphemes: [{ id: 'm-9', form: 'word', writingSystem: 'grc' }],
+      });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: {
+            gloss: 'agreed',
+            morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'grc', gloss: { und: ' ' } }],
+          },
+        }),
+      );
+
+      // The whitespace renders as nothing, so the merge settled on what 'ta-c' already says.
+      const state = store.getState().analysis;
+      expect(state.analysis.tokenAnalyses.map((ta) => ta.id)).toEqual(['ta-c']);
+      expect(selectApprovedGloss(state, 'tok-1')).toBe('agreed');
+      expect(selectApprovedGloss(state, 'tok-2')).toBe('agreed');
+    });
+
+    it('clears a field the survivor held that the merge settled nothing for', () => {
+      const store = makeHomographStore();
+      store.dispatch(
+        writeAnalysisMorphemes({ analysisId: 'ta-a', forms: ['wor', 'd'], writingSystem: 'grc' }),
+      );
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      const survivor = store.getState().analysis.analysis.tokenAnalyses[0];
+      expect(survivor.morphemes).toBeUndefined();
+    });
+
+    it('gives a survivor that carried no gloss the one the merge settled', () => {
+      const store = makeHomographStore({ id: 'ta-a', gloss: undefined, pos: 'noun' });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].gloss).toEqual({ und: 'agreed' });
+    });
+
+    it('clears the survivor gloss when the merge settled on none', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: '', morphemes: [], pos: 'noun' },
+        }),
+      );
+
+      const survivor = store.getState().analysis.analysis.tokenAnalyses[0];
+      expect(survivor.gloss).toBeUndefined();
+    });
+
+    it('leaves a gloss in another language standing when the merge cleared this one', () => {
+      const store = makeHomographStore({ id: 'ta-a', gloss: { und: 'a', fr: 'mot' } });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: '', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].gloss).toEqual({ fr: 'mot' });
+    });
+
+    it('carries a gloss in an unsettled language off a record the merge drops', () => {
+      const store = makeHomographStore({ id: 'ta-b', gloss: { und: 'b', fr: 'mot' } });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].gloss).toEqual({
+        und: 'agreed',
+        fr: 'mot',
+      });
+    });
+
+    it('leaves the survivor its own gloss in a language a dropped record also carried', () => {
+      const store = makeHomographStore(
+        { id: 'ta-a', gloss: { und: 'a', fr: 'survivor' } },
+        { id: 'ta-b', gloss: { und: 'b', fr: 'donor' } },
+      );
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].gloss).toEqual({
+        und: 'agreed',
+        fr: 'survivor',
+      });
+    });
+
+    it('gives a survivor the merge left no gloss the one a dropped record carried', () => {
+      const store = makeHomographStore({ id: 'ta-b', gloss: { und: 'b', fr: 'mot' } });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: '', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].gloss).toEqual({ fr: 'mot' });
+    });
+
+    it('carries nothing off a dropped record that held no gloss', () => {
+      const store = makeHomographStore({ id: 'ta-b', gloss: undefined, pos: 'noun' });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].gloss).toEqual({ und: 'agreed' });
+    });
+
+    it('carries the sense reference off a record the merge drops', () => {
+      const senseRef = { authority: 'x-test', senseId: 'sense-42' };
+      const store = makeHomographStore({ id: 'ta-b', glossSenseRef: senseRef });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'b', morphemes: [], glossFromAnalysisId: 'ta-b' },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].glossSenseRef).toStrictEqual(
+        senseRef,
+      );
+    });
+
+    it('keeps the morpheme annotation of a dropped record that the merged content carried across', () => {
+      const store = makeHomographStore(
+        {
+          id: 'ta-a',
+          morphemes: [{ id: 'm-1', form: 'word', writingSystem: 'grc' }],
+        },
+        {
+          id: 'ta-b',
+          morphemes: [
+            {
+              id: 'm-2',
+              form: 'word',
+              writingSystem: 'grc',
+              entryRef: { authority: 'x-test', entryId: 'e-word' },
+              gloss: { fr: 'mot' },
+            },
+          ],
+        },
+      );
+
+      const rows = ['ta-a', 'ta-b'].map((analysisId) => {
+        const payload = store
+          .getState()
+          .analysis.analysis.tokenAnalyses.find((ta) => ta.id === analysisId);
+        return {
+          analysisId,
+          surfaceText: 'word',
+          gloss: '',
+          morphemes: payload?.morphemes ?? [],
+          usageCount: 1,
+          usageCountInBook: 1,
+          usages: [],
+          books: new Set<string>(),
+          searchText: '',
+        };
+      });
+
+      const { content } = deriveMergeContent({
+        order: rows,
+        checked: new Set(['ta-a', 'ta-b']),
+        edits: {},
+        analysisLanguage: 'und',
+        sourceLanguageTag: 'grc',
+      });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content,
+        }),
+      );
+
+      const [survivor] = store.getState().analysis.analysis.tokenAnalyses;
+      expect(survivor.morphemes?.[0]).toMatchObject({
+        form: 'word',
+        entryRef: { authority: 'x-test', entryId: 'e-word' },
+        gloss: { fr: 'mot' },
+      });
+    });
+
+    it('carries the gloss off the donor the merge ranked first, not the one stored first', () => {
+      const store = makeHomographStore(
+        { id: 'ta-b', gloss: { und: 'b', fr: 'from-b' } },
+        { id: 'ta-c', gloss: { und: 'c', fr: 'from-c' } },
+      );
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-c', 'ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].gloss).toEqual({
+        und: 'agreed',
+        fr: 'from-c',
+      });
+    });
+
+    it('carries the sense reference off the donor the merge ranked first', () => {
+      const store = makeHomographStore(
+        { id: 'ta-b', glossSenseRef: { authority: 'x-test', senseId: 'sense-b' } },
+        { id: 'ta-c', glossSenseRef: { authority: 'x-test', senseId: 'sense-c' } },
+      );
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-c', 'ta-b'],
+          content: { gloss: 'c', morphemes: [], glossFromAnalysisId: 'ta-c' },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].glossSenseRef).toStrictEqual({
+        authority: 'x-test',
+        senseId: 'sense-c',
+      });
+    });
+
+    it('leaves the survivor its own sense reference when it supplied the gloss', () => {
+      const store = makeHomographStore(
+        { id: 'ta-a', glossSenseRef: { authority: 'x-test', senseId: 'survivor-sense' } },
+        { id: 'ta-b', glossSenseRef: { authority: 'x-test', senseId: 'donor-sense' } },
+      );
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'a', morphemes: [], glossFromAnalysisId: 'ta-a' },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].glossSenseRef).toStrictEqual({
+        authority: 'x-test',
+        senseId: 'survivor-sense',
+      });
+    });
+
+    it('drops the survivor’s sense when the merge settled on another record’s gloss', () => {
+      const store = makeHomographStore(
+        { id: 'ta-a', glossSenseRef: { authority: 'x-test', senseId: 'survivor-sense' } },
+        { id: 'ta-b', glossSenseRef: { authority: 'x-test', senseId: 'donor-sense' } },
+      );
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'b', morphemes: [], glossFromAnalysisId: 'ta-b' },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].glossSenseRef).toStrictEqual({
+        authority: 'x-test',
+        senseId: 'donor-sense',
+      });
+    });
+
+    it('drops the survivor’s sense when the reader typed the gloss', () => {
+      const store = makeHomographStore(
+        { id: 'ta-a', glossSenseRef: { authority: 'x-test', senseId: 'survivor-sense' } },
+        { id: 'ta-b', glossSenseRef: { authority: 'x-test', senseId: 'donor-sense' } },
+      );
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'typed', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].glossSenseRef).toBeUndefined();
+    });
+
+    it('takes nothing off a record the merge left standing', () => {
+      const store = makeHomographStore({
+        id: 'ta-c',
+        glossSenseRef: { authority: 'x-test', senseId: 'unmerged-sense' },
+      });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].glossSenseRef).toBeUndefined();
+    });
+
+    it('drops a survivor the merge emptied, a sense alone resolving nothing', () => {
+      const store = makeHomographStore({
+        id: 'ta-b',
+        glossSenseRef: { authority: 'x-test', senseId: 'sense-42' },
+      });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: '', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses.map((ta) => ta.id)).toEqual(['ta-c']);
+    });
+
+    it('keeps a survivor the merge emptied that a dropped record left a gloss of another language', () => {
+      const store = makeHomographStore({ id: 'ta-b', gloss: { und: 'b', fr: 'from-b' } });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: '', morphemes: [] },
+        }),
+      );
+
+      const state = store.getState().analysis;
+      expect(state.analysis.tokenAnalyses.map((ta) => ta.id)).toEqual(['ta-a', 'ta-c']);
+      expect(state.analysis.tokenAnalyses[0].gloss).toEqual({ fr: 'from-b' });
+    });
+
+    it('stamps the survivor, content having been written onto it', () => {
+      const MERGE_TIME = '2026-04-02T10:30:00.000Z';
+      jest.useFakeTimers().setSystemTime(new Date(MERGE_TIME));
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses[0].updatedAt).toBe(MERGE_TIME);
+      jest.useRealTimers();
+    });
+
+    it('ignores a survivor that resolves to no payload', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'nope',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses).toHaveLength(3);
+    });
+
+    it('skips a merged id that resolves to no payload', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['nope', 'ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalyses.map((ta) => ta.id)).toEqual([
+        'ta-a',
+        'ta-c',
+      ]);
+    });
+
+    it('keeps the survivor when it is named among the analyses to merge', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-a', 'ta-b'],
+          content: { gloss: 'agreed', morphemes: [] },
+        }),
+      );
+
+      const state = store.getState().analysis;
+      expect(state.analysis.tokenAnalyses.map((ta) => ta.id)).toEqual(['ta-a', 'ta-c']);
+      expect(selectApprovedGloss(state, 'tok-1')).toBe('agreed');
+    });
+
+    it('leaves one link on a token that linked both a merged analysis and the survivor', () => {
+      const store = makeBothLinkedStore('candidate');
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-target',
+          mergedAnalysisIds: ['ta-source'],
+          content: { gloss: 'second', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalysisLinks).toHaveLength(1);
+    });
+
+    it('dates a collapsed link by the earlier of the two it replaces', () => {
+      const FIRST_ANNOTATION = '2025-11-02T08:00:00.000Z';
+      const store = makeBothLinkedStore('approved', 'candidate', 'tok-1', {
+        source: { createdAt: FIRST_ANNOTATION },
+        target: { createdAt: '2026-02-14T09:00:00.000Z' },
+      });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-target',
+          mergedAnalysisIds: ['ta-source'],
+          content: { gloss: 'second', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalysisLinks).toEqual([
+        expect.objectContaining({ createdAt: FIRST_ANNOTATION }),
+      ]);
+    });
+
+    it('leaves a collapsed link dated by itself when it is the earlier of the two', () => {
+      const FIRST_ANNOTATION = '2025-11-02T08:00:00.000Z';
+      const store = makeBothLinkedStore('approved', 'candidate', 'tok-1', {
+        source: { createdAt: '2026-02-14T09:00:00.000Z' },
+        target: { createdAt: FIRST_ANNOTATION },
+      });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-target',
+          mergedAnalysisIds: ['ta-source'],
+          content: { gloss: 'second', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalysisLinks).toEqual([
+        expect.objectContaining({ createdAt: FIRST_ANNOTATION }),
+      ]);
+    });
+
+    it('rates a link the collapse raised by the approval it supersedes', () => {
+      const store = makeBothLinkedStore('approved', 'candidate', 'tok-1', {
+        source: { confidence: 'high' },
+        target: { confidence: 'low' },
+      });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-target',
+          mergedAnalysisIds: ['ta-source'],
+          content: { gloss: 'second', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.analysis.tokenAnalysisLinks).toEqual([
+        expect.objectContaining({ status: 'approved', confidence: 'high' }),
+      ]);
+    });
+
+    it('drops a raised link confidence when the approval it supersedes carried none', () => {
+      const store = makeBothLinkedStore('approved', 'candidate', 'tok-1', {
+        target: { confidence: 'low' },
+      });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-target',
+          mergedAnalysisIds: ['ta-source'],
+          content: { gloss: 'second', morphemes: [] },
+        }),
+      );
+
+      const [link] = store.getState().analysis.analysis.tokenAnalysisLinks;
+      expect(link.confidence).toBeUndefined();
+    });
+
+    it('collapses the survivor onto an analysis the merge did not fold in but now matches', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'c', morphemes: [] },
+        }),
+      );
+
+      const state = store.getState().analysis;
+      expect(state.analysis.tokenAnalyses.map((ta) => ta.id)).toEqual(['ta-c']);
+      // Every token of all three now reads as the record that was left standing.
+      expect(['tok-1', 'tok-2', 'tok-3'].map((t) => selectApprovedGloss(state, t))).toEqual([
+        'c',
+        'c',
+        'c',
+      ]);
+    });
+
+    it('reports the record a converging merge left standing', () => {
+      const store = makeHomographStore();
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'c', morphemes: [] },
+        }),
+      );
+
+      expect(store.getState().analysis.lastCollapseSurvivorId).toBe('ta-c');
+    });
+
+    // Identity excludes confidence, so the record the collapse keeps arrives still saying its own.
+    it('carries the confidence a converging merge settled onto the record it collapses onto', () => {
+      const store = makeHomographStore(
+        { id: 'ta-a', confidence: 'high' },
+        { id: 'ta-c', confidence: 'guess' },
+      );
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'c', morphemes: [], confidence: 'medium' },
+        }),
+      );
+
+      const { tokenAnalyses } = store.getState().analysis.analysis;
+      expect(tokenAnalyses).toHaveLength(1);
+      expect(tokenAnalyses[0]).toMatchObject({ id: 'ta-c', confidence: 'medium' });
+    });
+
+    it('clears the confidence of the record a merge settling on none collapses onto', () => {
+      const store = makeHomographStore({ id: 'ta-c', confidence: 'guess' });
+
+      store.dispatch(
+        mergeAnalysesInto({
+          survivorAnalysisId: 'ta-a',
+          mergedAnalysisIds: ['ta-b'],
+          content: { gloss: 'c', morphemes: [] },
+        }),
+      );
+
+      const { tokenAnalyses } = store.getState().analysis.analysis;
+      expect(tokenAnalyses).toHaveLength(1);
+      expect(tokenAnalyses[0].confidence).toBeUndefined();
+    });
+  });
+
+  describe('selectAnalysisDeletionOutcome', () => {
+    /** Reads every fixture token as still carrying the form its analysis was recorded under. */
+    const undrifted = () => 'word';
+
+    /** Reads `tokenRef` as having been re-typed since, every other token as standing as analyzed. */
+    const movedOff = (tokenRef: string) => (ref: string) => (ref === tokenRef ? 'wordes' : 'word');
+
+    /** Reads `tokenRef` as belonging to a book this view has not loaded. */
+    const unloaded = (tokenRef: string) => (ref: string) => (ref === tokenRef ? undefined : 'word');
+
+    it('reports a blank outcome when no homograph survives the deletion', () => {
+      const store = makeSharedStore();
+
+      const outcome = selectAnalysisDeletionOutcome(
+        store.getState().analysis,
+        'ta-shared',
+        undrifted,
+      );
+
+      expect(outcome).toEqual({ kind: 'blank', usageCount: 2, unappliedCount: 0 });
+    });
+
+    it('reports a fallback outcome naming the gloss the tokens will read', () => {
+      const store = makeSharedStore();
+      store.dispatch(writeGloss('tok-3', 'word', 'second'));
+
+      const outcome = selectAnalysisDeletionOutcome(
+        store.getState().analysis,
+        'ta-shared',
+        undrifted,
+      );
+
+      expect(outcome).toEqual({
+        kind: 'fallback',
+        usageCount: 2,
+        unappliedCount: 0,
+        fallbackGloss: 'second',
+      });
+    });
+
+    it('flags a fallback as drifted when a token no longer carries the form it was analyzed under', () => {
+      // The pool is matched by the analysis's own form, but the renderer matches this token by its
+      // live one, so the named peer is not what it will necessarily come to read.
+      const store = makeSharedStore();
+      store.dispatch(writeGloss('tok-3', 'word', 'second'));
+
+      expect(
+        selectAnalysisDeletionOutcome(store.getState().analysis, 'ta-shared', movedOff('tok-2')),
+      ).toEqual({
+        kind: 'fallback',
+        usageCount: 2,
+        unappliedCount: 0,
+        drifted: true,
+        fallbackGloss: 'second',
+      });
+    });
+
+    // A use that cannot be read is no more a promise the confirmation can keep than one whose text
+    // has moved.
+    it('flags a fallback as drifted when a use sits in a book that is not loaded', () => {
+      const store = makeSharedStore();
+      store.dispatch(writeGloss('tok-3', 'word', 'second'));
+
+      expect(
+        selectAnalysisDeletionOutcome(store.getState().analysis, 'ta-shared', unloaded('tok-2')),
+      ).toEqual({
+        kind: 'fallback',
+        usageCount: 2,
+        unappliedCount: 0,
+        drifted: true,
+        fallbackGloss: 'second',
+      });
+    });
+
+    // Non-approved links are not places the analysis is applied, so one on drifted text says nothing
+    // about what the affected tokens come to read.
+    it('leaves a fallback unflagged when only a non-approved link has moved off the form', () => {
+      const store = makeSharedStore();
+      store.dispatch(writeGloss('tok-3', 'word', 'second'));
+      const state = store.getState().analysis;
+      const withCandidate: AnalysisState = {
+        ...state,
+        analysis: {
+          ...state.analysis,
+          tokenAnalysisLinks: [
+            ...state.analysis.tokenAnalysisLinks,
+            {
+              ...FIXTURE_STAMPS,
+              analysisId: 'ta-shared',
+              status: 'candidate',
+              token: { tokenRef: 'tok-9', surfaceText: 'word' },
+            },
+          ],
+        },
+      };
+
+      expect(selectAnalysisDeletionOutcome(withCandidate, 'ta-shared', movedOff('tok-9'))).toEqual({
+        kind: 'fallback',
+        usageCount: 2,
+        unappliedCount: 1,
+        fallbackGloss: 'second',
+      });
+    });
+
+    it('omits the fallback gloss when the surviving peer has none in the analysis language', () => {
+      const store = makeSharedStore();
+      store.dispatch(writeMorphemes('tok-3', 'word', ['wor', 'd'], 'en'));
+
+      const outcome = selectAnalysisDeletionOutcome(
+        store.getState().analysis,
+        'ta-shared',
+        undrifted,
+      );
+
+      expect(outcome).toMatchObject({ kind: 'fallback', usageCount: 2 });
+      expect(outcome?.fallbackGloss).toBeUndefined();
+    });
+
+    it('returns undefined for an analysisId that resolves to no payload', () => {
+      const store = makeSharedStore();
+
+      expect(
+        selectAnalysisDeletionOutcome(store.getState().analysis, 'nope', undrifted),
+      ).toBeUndefined();
+    });
+
+    // The catalog offers a zero-usages filter for exactly this row, so the confirmation it opens
+    // has to have a number for one: an analysis nothing approves affects no token at all.
+    it('reports no usages for an analysis no token approves', () => {
+      const unapproved: TokenAnalysis = {
+        ...FIXTURE_STAMPS,
+        id: 'ta-unused',
+        surfaceText: 'word',
+        gloss: { und: 'first' },
+      };
+      const store = createAnalysisStore({
+        analysis: {
+          analysis: {
+            ...emptyAnalysis(),
+            tokenAnalyses: [unapproved],
+            tokenAnalysisLinks: [
+              {
+                ...FIXTURE_STAMPS,
+                analysisId: unapproved.id,
+                status: 'candidate',
+                token: { tokenRef: 'tok-1', surfaceText: 'word' },
+              },
+            ],
+          },
+          analysisLanguage: 'und',
+        },
+      });
+
+      const outcome = selectAnalysisDeletionOutcome(
+        store.getState().analysis,
+        'ta-unused',
+        undrifted,
+      );
+
+      expect(outcome).toEqual({ kind: 'blank', usageCount: 0, unappliedCount: 1 });
+    });
+
+    // A surviving homograph is exactly what makes this look like a fallback, so the unused row the
+    // catalog's zero-usages filter surfaces is the one that must not promise one.
+    it('reports no fallback for an unused analysis an approved homograph survives', () => {
+      const unused: TokenAnalysis = {
+        ...FIXTURE_STAMPS,
+        id: 'ta-unused',
+        surfaceText: 'word',
+        gloss: { und: 'first' },
+      };
+      const approved: TokenAnalysis = {
+        ...FIXTURE_STAMPS,
+        id: 'ta-approved',
+        surfaceText: 'word',
+        gloss: { und: 'second' },
+      };
+      const store = createAnalysisStore({
+        analysis: {
+          analysis: {
+            ...emptyAnalysis(),
+            tokenAnalyses: [unused, approved],
+            tokenAnalysisLinks: [
+              {
+                ...FIXTURE_STAMPS,
+                analysisId: unused.id,
+                status: 'candidate',
+                token: { tokenRef: 'tok-1', surfaceText: 'word' },
+              },
+              {
+                ...FIXTURE_STAMPS,
+                analysisId: approved.id,
+                status: 'approved',
+                token: { tokenRef: 'tok-2', surfaceText: 'word' },
+              },
+            ],
+          },
+          analysisLanguage: 'und',
+        },
+      });
+
+      const outcome = selectAnalysisDeletionOutcome(
+        store.getState().analysis,
+        'ta-unused',
+        undrifted,
+      );
+
+      expect(outcome).toEqual({ kind: 'blank', usageCount: 0, unappliedCount: 1 });
+    });
+
+    // The confirmation opens from a catalog row, which counts a token once however many approved
+    // links carry it to the same analysis. No write path builds a duplicate, so this is the shape
+    // imported or hand-edited data arrives in; the two numbers must still agree.
+    it('counts a token carrying the same approval twice as one usage', () => {
+      const shared: TokenAnalysis = {
+        ...FIXTURE_STAMPS,
+        id: 'ta-shared',
+        surfaceText: 'word',
+        gloss: { und: 'first' },
+      };
+      const duplicated: TokenAnalysisLink[] = ['tok-1', 'tok-1', 'tok-2'].map((tokenRef) => ({
+        ...FIXTURE_STAMPS,
+        analysisId: shared.id,
+        status: 'approved',
+        token: { tokenRef, surfaceText: 'word' },
+      }));
+      const store = createAnalysisStore({
+        analysis: {
+          analysis: {
+            ...emptyAnalysis(),
+            tokenAnalyses: [shared],
+            tokenAnalysisLinks: duplicated,
+          },
+          analysisLanguage: 'und',
+        },
+      });
+
+      const outcome = selectAnalysisDeletionOutcome(
+        store.getState().analysis,
+        'ta-shared',
+        undrifted,
+      );
+
+      expect(outcome).toEqual({ kind: 'blank', usageCount: 2, unappliedCount: 0 });
+    });
+
+    // An import records rejected and stale assignments the same way it records candidates, and the
+    // deletion takes all of them, so none may be left out of the number that warns about the loss.
+    it('counts every non-approved status among the unapplied assignments', () => {
+      const store = createAnalysisStore({
+        analysis: {
+          analysis: {
+            ...emptyAnalysis(),
+            tokenAnalyses: [
+              { ...FIXTURE_STAMPS, id: 'ta-mixed', surfaceText: 'word', gloss: { und: 'first' } },
+            ],
+            tokenAnalysisLinks: (['candidate', 'rejected', 'stale', 'suggested'] as const).map(
+              (status, i) => ({
+                ...FIXTURE_STAMPS,
+                analysisId: 'ta-mixed',
+                status,
+                token: { tokenRef: `tok-${i}`, surfaceText: 'word' },
+              }),
+            ),
+          },
+          analysisLanguage: 'und',
+        },
+      });
+
+      const outcome = selectAnalysisDeletionOutcome(
+        store.getState().analysis,
+        'ta-mixed',
+        undrifted,
+      );
+
+      expect(outcome).toEqual({ kind: 'blank', usageCount: 0, unappliedCount: 4 });
+    });
+
+    // Counted by token like the usages are, so the two numbers in one sentence are counting the
+    // same kind of thing.
+    it('counts a token recording the same analysis twice as one unapplied assignment', () => {
+      const store = createAnalysisStore({
+        analysis: {
+          analysis: {
+            ...emptyAnalysis(),
+            tokenAnalyses: [
+              { ...FIXTURE_STAMPS, id: 'ta-dup', surfaceText: 'word', gloss: { und: 'first' } },
+            ],
+            tokenAnalysisLinks: ['tok-1', 'tok-1'].map((tokenRef) => ({
+              ...FIXTURE_STAMPS,
+              analysisId: 'ta-dup',
+              status: 'candidate' as const,
+              token: { tokenRef, surfaceText: 'word' },
+            })),
+          },
+          analysisLanguage: 'und',
+        },
+      });
+
+      const outcome = selectAnalysisDeletionOutcome(store.getState().analysis, 'ta-dup', undrifted);
+
+      expect(outcome).toEqual({ kind: 'blank', usageCount: 0, unappliedCount: 1 });
+    });
+
+    // A token approving the analysis is a use, not an unapplied assignment; a record carrying both
+    // kinds must not have the approved token counted on both sides.
+    it('leaves an approved token out of the unapplied count', () => {
+      const store = createAnalysisStore({
+        analysis: {
+          analysis: {
+            ...emptyAnalysis(),
+            tokenAnalyses: [
+              { ...FIXTURE_STAMPS, id: 'ta-both', surfaceText: 'word', gloss: { und: 'first' } },
+            ],
+            tokenAnalysisLinks: [
+              {
+                ...FIXTURE_STAMPS,
+                analysisId: 'ta-both',
+                status: 'approved',
+                token: { tokenRef: 'tok-1', surfaceText: 'word' },
+              },
+              {
+                ...FIXTURE_STAMPS,
+                analysisId: 'ta-both',
+                status: 'candidate',
+                token: { tokenRef: 'tok-2', surfaceText: 'word' },
+              },
+            ],
+          },
+          analysisLanguage: 'und',
+        },
+      });
+
+      const outcome = selectAnalysisDeletionOutcome(
+        store.getState().analysis,
+        'ta-both',
+        undrifted,
+      );
+
+      expect(outcome).toEqual({ kind: 'blank', usageCount: 1, unappliedCount: 1 });
+    });
+  });
+});
diff --git a/src/__tests__/utils/analysis-query.test.ts b/src/__tests__/utils/analysis-query.test.ts
index 0689d4924..0b7a2b1b4 100644
--- a/src/__tests__/utils/analysis-query.test.ts
+++ b/src/__tests__/utils/analysis-query.test.ts
@@ -8,6 +8,8 @@ import {
   applyCatalogQuery,
   buildCatalogRows,
   deriveFacets,
+  reconcileFilters,
+  type CatalogFilters,
   type CatalogQuery,
   type CatalogScope,
 } from '../../utils/analysis-query';
@@ -833,3 +835,85 @@ describe('deriveFacets', () => {
     expect(facets.books).toEqual(['GEN', 'JHN']);
   });
 });
+
+describe('reconcileFilters', () => {
+  it('drops a selection whose facet is no longer offered', () => {
+    const filters = reconcileFilters({ books: ['EXO'] }, { books: undefined });
+
+    expect(filters.books).toBeUndefined();
+  });
+
+  it('drops only the chosen values the facet stopped offering', () => {
+    const filters = reconcileFilters({ books: ['GEN', 'EXO'] }, { books: ['GEN', 'JHN'] });
+
+    expect(filters.books).toEqual(['GEN']);
+  });
+
+  it('drops a selection whose every choice the facet stopped offering', () => {
+    const filters = reconcileFilters({ books: ['EXO'] }, { books: ['GEN', 'JHN'] });
+
+    expect(filters.books).toBeUndefined();
+  });
+
+  it('keeps a selection the facet still offers whole', () => {
+    const filters = reconcileFilters({ books: ['GEN'] }, { books: ['GEN', 'JHN'] });
+
+    expect(filters.books).toEqual(['GEN']);
+  });
+
+  it('returns the same object when every selection survives', () => {
+    const chosen: CatalogFilters = { books: ['GEN'], missingGloss: true };
+
+    expect(reconcileFilters(chosen, { books: ['GEN', 'JHN'] })).toBe(chosen);
+  });
+
+  it('leaves the filters no facet governs untouched', () => {
+    const filters = reconcileFilters(
+      { books: ['EXO'], missingGloss: true, zeroUsages: true, morphemes: 'has' },
+      { books: undefined },
+    );
+
+    expect(filters.missingGloss).toBe(true);
+    expect(filters.zeroUsages).toBe(true);
+    expect(filters.morphemes).toBe('has');
+  });
+
+  it('drops a feature selection whose name lost its facet', () => {
+    const filters = reconcileFilters(
+      { features: { case: ['nom'], number: ['sg'] } },
+      { features: { number: ['sg', 'pl'] } },
+    );
+
+    expect(filters.features).toEqual({ number: ['sg'] });
+  });
+
+  it('drops the feature filter entirely once no name survives', () => {
+    const filters = reconcileFilters({ features: { case: ['nom'] } }, { features: undefined });
+
+    expect(filters.features).toBeUndefined();
+  });
+
+  it('keeps the untagged choice while its facet still offers it', () => {
+    const filters = reconcileFilters({ pos: [undefined] }, { pos: ['noun', undefined] });
+
+    expect(filters.pos).toEqual([undefined]);
+  });
+
+  // Reconciliation withdraws choices; it does not re-interpret the ones it keeps.
+  it('leaves a surviving selection narrowing the same rows', () => {
+    const analysis: TextAnalysis = {
+      ...emptyAnalysis(),
+      tokenAnalyses: [
+        { ...FIXTURE_STAMPS, id: 'ta-1', surfaceText: 'a' },
+        { ...FIXTURE_STAMPS, id: 'ta-2', surfaceText: 'b' },
+      ],
+      tokenAnalysisLinks: [link('ta-1', 'GEN 1:1:0'), link('ta-2', 'JHN 1:1:0')],
+    };
+    const rows = buildCatalogRows(analysis, scope);
+    const filters = reconcileFilters({ books: ['GEN'] }, deriveFacets(rows));
+
+    expect(applyCatalogQuery(rows, makeQuery({ filters })).map((row) => row.analysisId)).toEqual([
+      'ta-1',
+    ]);
+  });
+});
diff --git a/src/__tests__/utils/merge-content.test.ts b/src/__tests__/utils/merge-content.test.ts
new file mode 100644
index 000000000..d633d2bac
--- /dev/null
+++ b/src/__tests__/utils/merge-content.test.ts
@@ -0,0 +1,903 @@
+/// <reference types="jest" />
+
+import type { MorphemeAnalysis } from 'interlinearizer';
+import type { CatalogRow } from '../../utils/analysis-query';
+import {
+  deriveMergeContent,
+  remapMorphemeGlossEdits,
+  reorderForMerge,
+} from '../../utils/merge-content';
+
+const analysisLanguage = 'en';
+const sourceLanguageTag = 'grc';
+
+/** Builds a morpheme, glossed in the analysis language when a gloss is given. */
+function morpheme(id: string, form: string, gloss?: string): MorphemeAnalysis {
+  const base = { id, form, writingSystem: sourceLanguageTag };
+  return gloss === undefined ? base : { ...base, gloss: { [analysisLanguage]: gloss } };
+}
+
+/**
+ * Builds a catalog row of the one surface form these tests merge, carrying only what a case sets.
+ *
+ * The listed gloss also lands in `glosses` under the analysis language, as a row built from a
+ * stored analysis carries it; a case setting `glosses` outright is opting into a further language.
+ */
+function row(analysisId: string, overrides: Partial<CatalogRow> = {}): CatalogRow {
+  const gloss = overrides.gloss ?? '';
+  return {
+    analysisId,
+    surfaceText: 'λόγος',
+    gloss: '',
+    glosses: gloss ? { [analysisLanguage]: gloss } : undefined,
+    morphemes: [],
+    usageCount: 0,
+    usageCountInBook: 0,
+    usages: [],
+    books: new Set(),
+    searchText: '',
+    ...overrides,
+  };
+}
+
+describe('deriveMergeContent', () => {
+  it('takes every field from the top analysis when nothing has been edited', () => {
+    const top = row('ta-1', {
+      gloss: 'word',
+      morphemes: [morpheme('m-1', 'λόγ', 'word'), morpheme('m-2', 'ος', 'NOM.SG')],
+      pos: 'noun',
+      features: { Case: 'Nom' },
+      confidence: 'high',
+    });
+
+    const { content } = deriveMergeContent({
+      order: [top, row('ta-2', { gloss: 'speech' })],
+      checked: new Set(['ta-1']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content).toEqual({
+      gloss: 'word',
+      glossFromAnalysisId: 'ta-1',
+      morphemes: top.morphemes,
+      pos: 'noun',
+      features: { Case: 'Nom' },
+      confidence: 'high',
+    });
+  });
+
+  it('fills a field the top lacks from the next checked analysis below that has one', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', { gloss: 'word' }),
+        row('ta-2', { pos: 'noun' }),
+        row('ta-3', { pos: 'verb', features: { Case: 'Nom' } }),
+      ],
+      checked: new Set(['ta-1', 'ta-2', 'ta-3']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.pos).toBe('noun');
+    expect(content.features).toEqual({ Case: 'Nom' });
+  });
+
+  it('leaves a field absent when only an unchecked analysis has a value for it', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { gloss: 'word' }), row('ta-2', { pos: 'noun' })],
+      checked: new Set(['ta-1']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.pos).toBeUndefined();
+  });
+
+  it('fills a field from an analysis once it is checked', () => {
+    const order = [row('ta-1', { gloss: 'word' }), row('ta-2', { pos: 'noun' })];
+
+    const { content } = deriveMergeContent({
+      order,
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.pos).toBe('noun');
+  });
+
+  it('takes the whole breakdown from the first checked analysis that has one', () => {
+    const donor = row('ta-2', { morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] });
+
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', { gloss: 'word' }),
+        donor,
+        row('ta-3', { morphemes: [morpheme('m-3', 'λόγος')] }),
+      ],
+      checked: new Set(['ta-1', 'ta-2', 'ta-3']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes).toEqual(donor.morphemes);
+  });
+
+  it('fills an unglossed morpheme from a lower analysis whose breakdown has the same form', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', { morphemes: [morpheme('m-1', 'λόγ', 'word'), morpheme('m-2', 'ος')] }),
+        row('ta-2', {
+          morphemes: [morpheme('m-3', 'λόγ', 'speech'), morpheme('m-4', 'ος', 'NOM.SG')],
+        }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes.map((m) => [m.form, m.gloss?.[analysisLanguage]])).toEqual([
+      ['λόγ', 'word'],
+      ['ος', 'NOM.SG'],
+    ]);
+  });
+
+  it('leaves a morpheme unglossed when no lower analysis has that form', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', { morphemes: [morpheme('m-1', 'λόγ')] }),
+        row('ta-2', { morphemes: [morpheme('m-2', 'ος', 'NOM.SG')] }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0].gloss).toBeUndefined();
+  });
+
+  it('takes an edited field from the edit rather than from any analysis', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: { gloss: 'utterance' },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.gloss).toBe('utterance');
+  });
+
+  it('keeps a blanked field empty rather than falling back to a lower analysis', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { gloss: 'dog' }), row('ta-2', { gloss: 'hound' })],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: { gloss: '' },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.gloss).toBe('');
+  });
+
+  it('keeps an edited field across a change of survivor', () => {
+    const first = row('ta-1', { gloss: 'word', pos: 'noun' });
+    const second = row('ta-2', { gloss: 'speech', pos: 'verb' });
+    const edits = { gloss: 'utterance' };
+    const checked = new Set(['ta-1', 'ta-2']);
+
+    const { content } = deriveMergeContent({
+      order: [second, first],
+      checked,
+      edits,
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    // The edit stands where it was typed; the untouched field refills from the new survivor.
+    expect([content.gloss, content.pos]).toEqual(['utterance', 'verb']);
+  });
+
+  it('takes the confidence from its edit when one has been made', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { confidence: 'low' })],
+      checked: new Set(['ta-1']),
+      edits: { confidence: 'high' },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.confidence).toBe('high');
+  });
+
+  it('carries a part of speech and features off a donor with no edit able to reach them', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', { gloss: 'word' }),
+        row('ta-2', { pos: 'noun', features: { Case: 'Nom' } }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect([content.pos, content.features]).toEqual(['noun', { Case: 'Nom' }]);
+  });
+
+  it('takes the breakdown from its edit when one has been made', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { morphemes: [morpheme('m-1', 'λόγος')] })],
+      checked: new Set(['ta-1']),
+      edits: { morphemeForms: ['λόγ', 'ος'] },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes.map((m) => m.form)).toEqual(['λόγ', 'ος']);
+  });
+
+  it('keeps a morpheme gloss edit whose place the breakdown still reaches', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] })],
+      checked: new Set(['ta-1']),
+      edits: { morphemeForms: ['λόγ', 'ου'], morphemeGlosses: { 0: 'word' } },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0].gloss?.[analysisLanguage]).toBe('word');
+  });
+
+  it('empties a morpheme gloss the reader cleared', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { morphemes: [morpheme('m-1', 'λόγ', 'word')] })],
+      checked: new Set(['ta-1']),
+      edits: { morphemeGlosses: { 0: '' } },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0].gloss).toBeUndefined();
+  });
+
+  it('empties a morpheme gloss the reader blanked with whitespace', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { morphemes: [morpheme('m-1', 'λόγ', 'word')] })],
+      checked: new Set(['ta-1']),
+      edits: { morphemeGlosses: { 0: '  ' } },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0].gloss).toBeUndefined();
+  });
+
+  it('leaves a re-split morpheme unglossed when the reader clears the field it never filled', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { morphemes: [morpheme('m-1', 'λόγος')] })],
+      checked: new Set(['ta-1']),
+      // A re-split mints morphemes carrying no gloss at all, which is what is cleared here.
+      edits: { morphemeForms: ['λόγ', 'ος'], morphemeGlosses: { 0: '' } },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0].gloss).toBeUndefined();
+  });
+
+  it('leaves a cleared morpheme gloss its other analysis languages', () => {
+    const glossed: MorphemeAnalysis = {
+      id: 'm-1',
+      form: 'λόγ',
+      writingSystem: sourceLanguageTag,
+      gloss: { [analysisLanguage]: 'word', fr: 'mot' },
+    };
+
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { morphemes: [glossed] })],
+      checked: new Set(['ta-1']),
+      edits: { morphemeGlosses: { 0: '' } },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0].gloss).toEqual({ fr: 'mot' });
+  });
+
+  it('drops a morpheme gloss edit whose place the breakdown no longer reaches', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { morphemes: [morpheme('m-1', 'λόγ'), morpheme('m-2', 'ος')] })],
+      checked: new Set(['ta-1']),
+      edits: { morphemeForms: ['λόγος'], morphemeGlosses: { 1: 'NOM.SG' } },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes.map((m) => m.gloss?.[analysisLanguage])).toEqual([undefined]);
+  });
+
+  it('gives each occurrence of a repeated form the gloss its own donor morpheme carries', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', {
+          morphemes: [morpheme('m-1', 'ba', 'first'), morpheme('m-2', 'ba', 'second')],
+        }),
+        row('ta-2', {}),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes.map((m) => m.gloss?.[analysisLanguage])).toEqual(['first', 'second']);
+  });
+
+  it('draws a repeated form its own donation where an earlier occurrence kept its gloss', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', { morphemes: [morpheme('m-1', 'ba', 'first'), morpheme('m-2', 'ba')] }),
+        row('ta-2', {
+          morphemes: [morpheme('m-3', 'ba', 'first'), morpheme('m-4', 'ba', 'second')],
+        }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes.map((m) => m.gloss?.[analysisLanguage])).toEqual(['first', 'second']);
+  });
+
+  it('keeps a lexicon reference on a form a re-split leaves standing', () => {
+    const referenced: MorphemeAnalysis = {
+      id: 'm-1',
+      form: 'λόγ',
+      writingSystem: sourceLanguageTag,
+      entryRef: { authority: 'pt9', entryId: 'e-log' },
+    };
+
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { morphemes: [referenced, morpheme('m-2', 'ος')] })],
+      checked: new Set(['ta-1']),
+      edits: { morphemeForms: ['λόγ', 'ου'] },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0].entryRef).toEqual({ authority: 'pt9', entryId: 'e-log' });
+    expect(content.morphemes[1].entryRef).toBeUndefined();
+  });
+
+  it('takes a lexicon reference from a lower analysis whose breakdown has the same form', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', { morphemes: [morpheme('m-1', 'λόγ', 'word')] }),
+        row('ta-2', {
+          morphemes: [
+            {
+              id: 'm-2',
+              form: 'λόγ',
+              writingSystem: sourceLanguageTag,
+              entryRef: { authority: 'pt9', entryId: 'e-log' },
+              senseRef: { authority: 'pt9', senseId: 's-1' },
+              allomorphRef: { authority: 'pt9', allomorphId: 'a-1' },
+              grammarRef: { authority: 'pt9', msaId: 'g-1' },
+            },
+          ],
+        }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0]).toMatchObject({
+      entryRef: { authority: 'pt9', entryId: 'e-log' },
+      senseRef: { authority: 'pt9', senseId: 's-1' },
+      allomorphRef: { authority: 'pt9', allomorphId: 'a-1' },
+      grammarRef: { authority: 'pt9', msaId: 'g-1' },
+    });
+  });
+
+  it('keeps its own lexicon reference over one a lower analysis gives the same form', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', {
+          morphemes: [
+            {
+              id: 'm-1',
+              form: 'λόγ',
+              writingSystem: sourceLanguageTag,
+              entryRef: { authority: 'pt9', entryId: 'e-own' },
+            },
+          ],
+        }),
+        row('ta-2', {
+          morphemes: [
+            {
+              id: 'm-2',
+              form: 'λόγ',
+              writingSystem: sourceLanguageTag,
+              entryRef: { authority: 'pt9', entryId: 'e-lower' },
+            },
+          ],
+        }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0].entryRef).toEqual({ authority: 'pt9', entryId: 'e-own' });
+  });
+
+  it('leaves a sense behind when it belongs to an entry other than the settled one', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', {
+          morphemes: [
+            {
+              id: 'm-1',
+              form: 'λόγ',
+              writingSystem: sourceLanguageTag,
+              entryRef: { authority: 'pt9', entryId: 'e-own' },
+            },
+          ],
+        }),
+        row('ta-2', {
+          morphemes: [
+            {
+              id: 'm-2',
+              form: 'λόγ',
+              writingSystem: sourceLanguageTag,
+              entryRef: { authority: 'pt9', entryId: 'e-other' },
+              senseRef: { authority: 'pt9', senseId: 's-other' },
+              allomorphRef: { authority: 'pt9', allomorphId: 'a-other' },
+              grammarRef: { authority: 'pt9', msaId: 'g-other' },
+            },
+          ],
+        }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0]).toMatchObject({ entryRef: { entryId: 'e-own' } });
+    expect(content.morphemes[0].senseRef).toBeUndefined();
+    expect(content.morphemes[0].allomorphRef).toBeUndefined();
+    expect(content.morphemes[0].grammarRef).toBeUndefined();
+  });
+
+  it('fills a sense in from a lower analysis resolving to the same entry', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', {
+          morphemes: [
+            {
+              id: 'm-1',
+              form: 'λόγ',
+              writingSystem: sourceLanguageTag,
+              entryRef: { authority: 'pt9', entryId: 'e-log' },
+            },
+          ],
+        }),
+        row('ta-2', {
+          morphemes: [
+            {
+              id: 'm-2',
+              form: 'λόγ',
+              writingSystem: sourceLanguageTag,
+              entryRef: { authority: 'pt9', entryId: 'e-log' },
+              senseRef: { authority: 'pt9', senseId: 's-1' },
+            },
+          ],
+        }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0]).toMatchObject({
+      entryRef: { entryId: 'e-log' },
+      senseRef: { senseId: 's-1' },
+    });
+  });
+
+  it('takes a morpheme gloss in another language from a lower analysis with the same form', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', { morphemes: [morpheme('m-1', 'λόγ', 'word')] }),
+        row('ta-2', {
+          morphemes: [
+            {
+              id: 'm-2',
+              form: 'λόγ',
+              writingSystem: sourceLanguageTag,
+              gloss: { [analysisLanguage]: 'speech', fr: 'mot' },
+            },
+          ],
+        }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0].gloss).toEqual({ [analysisLanguage]: 'word', fr: 'mot' });
+  });
+
+  it('leaves a morpheme the annotation of an unchecked analysis carrying the same form', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', { morphemes: [morpheme('m-1', 'λόγ', 'word')] }),
+        row('ta-2', {
+          morphemes: [
+            {
+              id: 'm-2',
+              form: 'λόγ',
+              writingSystem: sourceLanguageTag,
+              entryRef: { authority: 'pt9', entryId: 'e-log' },
+              gloss: { fr: 'mot' },
+            },
+          ],
+        }),
+      ],
+      checked: new Set(['ta-1']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0].entryRef).toBeUndefined();
+    expect(content.morphemes[0].gloss).toEqual({ [analysisLanguage]: 'word' });
+  });
+
+  it('keeps donated annotation on a morpheme whose gloss the reader cleared', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', { morphemes: [morpheme('m-1', 'λόγ', 'word')] }),
+        row('ta-2', {
+          morphemes: [
+            {
+              id: 'm-2',
+              form: 'λόγ',
+              writingSystem: sourceLanguageTag,
+              entryRef: { authority: 'pt9', entryId: 'e-log' },
+              gloss: { fr: 'mot' },
+            },
+          ],
+        }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: { morphemeGlosses: { 0: '' } },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes[0].entryRef).toEqual({ authority: 'pt9', entryId: 'e-log' });
+    expect(content.morphemes[0].gloss).toEqual({ fr: 'mot' });
+  });
+
+  it('gives each occurrence of a repeated form the annotation its own donor morpheme carries', () => {
+    const { content } = deriveMergeContent({
+      order: [
+        row('ta-1', { morphemes: [morpheme('m-1', 'ba'), morpheme('m-2', 'ba')] }),
+        row('ta-2', {
+          morphemes: [
+            {
+              id: 'm-3',
+              form: 'ba',
+              writingSystem: sourceLanguageTag,
+              entryRef: { authority: 'pt9', entryId: 'e-first' },
+            },
+            {
+              id: 'm-4',
+              form: 'ba',
+              writingSystem: sourceLanguageTag,
+              entryRef: { authority: 'pt9', entryId: 'e-second' },
+            },
+          ],
+        }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.morphemes.map((m) => m.entryRef?.entryId)).toEqual(['e-first', 'e-second']);
+  });
+});
+
+describe('deriveMergeContent verdict', () => {
+  it('withholds confirmation while the survivor is the only analysis checked', () => {
+    const { verdict } = deriveMergeContent({
+      order: [row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })],
+      checked: new Set(['ta-1']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(verdict).toEqual({ canConfirm: false, reason: 'nothing-checked' });
+  });
+
+  it('allows confirmation once another analysis is checked', () => {
+    const { verdict } = deriveMergeContent({
+      order: [row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(verdict).toEqual({ canConfirm: true });
+  });
+
+  it('warns that an unchecked analysis the merged content matches will be collapsed into it', () => {
+    const { verdict } = deriveMergeContent({
+      order: [
+        row('ta-1', { gloss: 'word' }),
+        row('ta-2', { gloss: 'speech' }),
+        row('ta-3', { gloss: 'word' }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(verdict).toEqual({
+      canConfirm: true,
+      reason: 'will-collapse',
+      collapsingAnalysisId: 'ta-3',
+    });
+  });
+
+  it('raises no collapse warning while every unchecked analysis still says something different', () => {
+    const { verdict } = deriveMergeContent({
+      order: [
+        row('ta-1', { gloss: 'word' }),
+        row('ta-2', { gloss: 'speech' }),
+        row('ta-3', { gloss: 'account' }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(verdict).toEqual({ canConfirm: true });
+  });
+
+  // Confidence is provenance, which analysis identity excludes, so it cannot keep two records apart.
+  it('warns about an unchecked analysis differing from the merged content only in confidence', () => {
+    const { verdict } = deriveMergeContent({
+      order: [
+        row('ta-1', { gloss: 'word', confidence: 'high' }),
+        row('ta-2', { gloss: 'speech' }),
+        row('ta-3', { gloss: 'word', confidence: 'guess' }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(verdict).toEqual({
+      canConfirm: true,
+      reason: 'will-collapse',
+      collapsingAnalysisId: 'ta-3',
+    });
+  });
+
+  // The listed gloss is one language of several, and the store counts them all.
+  it('raises no collapse warning against an analysis differing in another language', () => {
+    const { verdict } = deriveMergeContent({
+      order: [
+        row('ta-1', { gloss: 'word', glosses: { en: 'word', fr: 'mot' } }),
+        row('ta-2', { gloss: 'word' }),
+        row('ta-3', { gloss: 'word', glosses: { en: 'word', fr: 'parole' } }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(verdict).toEqual({ canConfirm: true });
+  });
+
+  it('names the donor the settled gloss was taken from', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { gloss: '' }), row('ta-2', { gloss: 'speech' })],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.glossFromAnalysisId).toBe('ta-2');
+  });
+
+  it('names no donor for a typed gloss that happens to match one', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: { gloss: 'word' },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.glossFromAnalysisId).toBeUndefined();
+  });
+
+  it('names no donor for a gloss the reader typed', () => {
+    const { content } = deriveMergeContent({
+      order: [row('ta-1', { gloss: 'word' }), row('ta-2', { gloss: 'speech' })],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: { gloss: 'utterance' },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(content.glossFromAnalysisId).toBeUndefined();
+  });
+
+  it('warns of a collapse onto the sense the settled gloss brings with it', () => {
+    const senseRef = { authority: 'pt9', senseId: 's-2' };
+    const { verdict } = deriveMergeContent({
+      order: [
+        row('ta-1', { gloss: '', glossSenseRef: { authority: 'pt9', senseId: 's-1' } }),
+        row('ta-2', { gloss: 'speech', glossSenseRef: senseRef }),
+        row('ta-3', { gloss: 'speech', glossSenseRef: senseRef }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(verdict).toEqual({
+      canConfirm: true,
+      reason: 'will-collapse',
+      collapsingAnalysisId: 'ta-3',
+    });
+  });
+
+  it('raises no collapse warning against an analysis resolving to another sense', () => {
+    const { verdict } = deriveMergeContent({
+      order: [
+        row('ta-1', { gloss: 'word', glossSenseRef: { authority: 'pt9', senseId: 's-1' } }),
+        row('ta-2', { gloss: 'word' }),
+        row('ta-3', { gloss: 'word', glossSenseRef: { authority: 'pt9', senseId: 's-2' } }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(verdict).toEqual({ canConfirm: true });
+  });
+
+  it('warns about an analysis matching in every language the merge would leave standing', () => {
+    const { verdict } = deriveMergeContent({
+      order: [
+        row('ta-1', { gloss: 'word', glosses: { en: 'word', fr: 'mot' } }),
+        row('ta-2', { gloss: 'word' }),
+        row('ta-3', { gloss: 'word', glosses: { en: 'word', fr: 'mot' } }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: {},
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(verdict).toEqual({
+      canConfirm: true,
+      reason: 'will-collapse',
+      collapsingAnalysisId: 'ta-3',
+    });
+  });
+
+  it('warns about an analysis the merged content converges on only after an edit', () => {
+    const { verdict } = deriveMergeContent({
+      order: [
+        row('ta-1', { gloss: 'word' }),
+        row('ta-2', { gloss: 'speech' }),
+        row('ta-3', { gloss: 'utterance' }),
+      ],
+      checked: new Set(['ta-1', 'ta-2']),
+      edits: { gloss: 'utterance' },
+      analysisLanguage,
+      sourceLanguageTag,
+    });
+
+    expect(verdict).toEqual({
+      canConfirm: true,
+      reason: 'will-collapse',
+      collapsingAnalysisId: 'ta-3',
+    });
+  });
+});
+
+describe('reorderForMerge', () => {
+  const current = { orderedIds: ['ta-1', 'ta-2', 'ta-3'], mergedIds: new Set(['ta-2']) };
+
+  it('moves an analysis to where it was dropped', () => {
+    expect(reorderForMerge(current, 'ta-3', 0).orderedIds).toEqual(['ta-3', 'ta-1', 'ta-2']);
+  });
+
+  it('keeps an analysis a move displaced from the head in the merge', () => {
+    expect(reorderForMerge(current, 'ta-3', 0).mergedIds).toEqual(new Set(['ta-2', 'ta-1']));
+  });
+
+  it('takes the analysis a move made survivor out of the merge set it now heads', () => {
+    expect(reorderForMerge(current, 'ta-2', 0).mergedIds).toEqual(new Set(['ta-1']));
+  });
+
+  it('leaves the merge set alone for a move that does not change the survivor', () => {
+    const moved = reorderForMerge(current, 'ta-3', 1);
+
+    expect(moved.orderedIds).toEqual(['ta-1', 'ta-3', 'ta-2']);
+    expect(moved.mergedIds).toBe(current.mergedIds);
+  });
+
+  it('changes nothing when an analysis is moved to where it already sits', () => {
+    expect(reorderForMerge(current, 'ta-2', 1)).toBe(current);
+  });
+
+  it('changes nothing when the analysis moved is not in the arrangement', () => {
+    expect(reorderForMerge(current, 'nope', 0)).toBe(current);
+  });
+});
+
+describe('remapMorphemeGlossEdits', () => {
+  const from = [morpheme('m-1', 'un'), morpheme('m-2', 'happy')];
+
+  it('moves an edit to the index its form now sits at', () => {
+    expect(remapMorphemeGlossEdits({ 1: 'glad' }, from, ['happy', 'ness'])).toEqual({ 0: 'glad' });
+  });
+
+  it('drops an edit whose form the new breakdown does not reach', () => {
+    expect(remapMorphemeGlossEdits({ 0: 'not' }, from, ['happy', 'ness'])).toBeUndefined();
+  });
+
+  it('draws one edit per occurrence of a repeated form', () => {
+    const repeated = [morpheme('m-1', 'a'), morpheme('m-2', 'a')];
+
+    expect(remapMorphemeGlossEdits({ 0: 'first', 1: 'second' }, repeated, ['a', 'b', 'a'])).toEqual(
+      {
+        0: 'first',
+        2: 'second',
+      },
+    );
+  });
+
+  it('keeps an emptied gloss, which is a decision the morpheme should carry none', () => {
+    expect(remapMorphemeGlossEdits({ 1: '' }, from, ['happy'])).toEqual({ 0: '' });
+  });
+
+  it('has nothing to remap when no gloss was edited', () => {
+    expect(remapMorphemeGlossEdits(undefined, from, ['happy'])).toBeUndefined();
+  });
+});
diff --git a/src/components/AnalysisCatalogPanel.tsx b/src/components/AnalysisCatalogPanel.tsx
index 48d5c5cdf..76c045c37 100644
--- a/src/components/AnalysisCatalogPanel.tsx
+++ b/src/components/AnalysisCatalogPanel.tsx
@@ -3,17 +3,39 @@ import { Canon } from '@sillsdev/scripture';
 import { X } from 'lucide-react';
 import { Button, EmptyState, TooltipProvider } from 'platform-bible-react';
 import { formatReplacementString, isPlatformError } from 'platform-bible-utils';
-import { useCallback, useMemo, useState } from 'react';
-import { useAnalysisLanguage, useCatalogRows } from './AnalysisStore';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import {
+  useAnalysisDeletionOutcome,
+  useAnalysisLanguage,
+  useAnalysisRowDispatch,
+  useCatalogRows,
+  useReportGlossEditing,
+  type AnalysisEditOutcome,
+} from './AnalysisStore';
+import { breakdownDraftForms } from './CatalogRowEditor';
+import CatalogCloseModal, { CLOSE_STRING_KEYS } from './CatalogCloseModal';
+import CatalogDeleteModal, { DELETE_STRING_KEYS } from './CatalogDeleteModal';
+import CatalogMergeModal, { MERGE_STRING_KEYS } from './CatalogMergeModal';
+import type { MergedContentDraft } from '../utils/merge-content';
+import CatalogMergeNotice, {
+  CatalogStrandedDraftNotice,
+  MERGE_NOTICE_STRING_KEYS,
+  type MergeNotice,
+  type StrandedDraftNotice,
+} from './CatalogMergeNotice';
 import CatalogQueryControls, { QUERY_CONTROL_STRING_KEYS } from './CatalogQueryControls';
 import CatalogRowView, { ROW_STRING_KEYS } from './CatalogRowView';
 import { useInterlinearNav } from './InterlinearNavContext';
 import useRowWindow from '../hooks/useRowWindow';
+import type { AnalysisDeletionOutcome } from '../store/analysisSlice';
+import { normalizeSurfaceForm } from '../utils/analysis-identity';
 import {
   applyCatalogQuery,
   deriveFacets,
+  reconcileFilters,
   type CatalogFilters,
   type CatalogQuery,
+  type CatalogRow,
   type CatalogSort,
   type CatalogUsage,
 } from '../utils/analysis-query';
@@ -34,14 +56,28 @@ const STRING_KEYS = [
   '%interlinearizer_analysisCatalog_noMatches%',
   ...QUERY_CONTROL_STRING_KEYS,
   ...ROW_STRING_KEYS,
+  ...MERGE_NOTICE_STRING_KEYS,
+  ...MERGE_STRING_KEYS,
+  ...DELETE_STRING_KEYS,
+  ...CLOSE_STRING_KEYS,
 ] as const satisfies `%${string}%`[];
 
+/** A breakdown a row is holding, with the form it was typed against. */
+type BreakdownDraft = Readonly<{
+  /** The breakdown as a line of space-separated forms. */
+  text: string;
+  /** The analysis's surface form when the draft was opened, which names it once the record is gone. */
+  surfaceText: string;
+}>;
+
 /** Props for {@link AnalysisCatalogPanel}. */
 type AnalysisCatalogPanelProps = Readonly<{
   /** Dismisses the panel. */
   onClose: () => void;
   /** Book code each row's per-book usage count is taken against. */
   currentBook: string;
+  /** Reads the loaded book's current text for a token ref, `undefined` for one in any other book. */
+  liveSurfaceText: (tokenRef: string) => string | undefined;
   /** Whether this project breaks words into morphemes, which the breakdown filter is offered for. */
   showMorphology: boolean;
   /** BCP 47 tag of the source text, so surface forms collate by their own language. */
@@ -50,7 +86,12 @@ type AnalysisCatalogPanelProps = Readonly<{
 
 /**
  * The analysis catalog: every analysis the draft records, listed with the usage data the catalog
- * lists it by. Read-only — nothing here writes to the analysis.
+ * lists it by, and editable in place.
+ *
+ * Every write from here is keyed by the analysis rather than by a token, so it changes what a
+ * record says for every token linked to it — one correction fixes a mis-split word across all its
+ * occurrences. That is the opposite of an edit made in the interlinear view, which forks a shared
+ * payload to keep itself local to one token.
  *
  * Sits beside the interlinear view rather than over it, so a jump to a usage can move the view
  * while the list the jump came from stays on screen.
@@ -58,6 +99,7 @@ type AnalysisCatalogPanelProps = Readonly<{
 export default function AnalysisCatalogPanel({
   onClose,
   currentBook,
+  liveSurfaceText,
   showMorphology,
   sourceLanguageTag,
 }: AnalysisCatalogPanelProps) {
@@ -75,14 +117,45 @@ export default function AnalysisCatalogPanel({
   /** How the listing is ordered. Most-used first, the question the catalog is opened to answer. */
   const [sort, setSort] = useState<CatalogSort>('usageCount');
 
-  /** Which rows the listing keeps. Nothing narrowed until the reader chooses something. */
-  const [filters, setFilters] = useState<CatalogFilters>({});
+  /**
+   * Which rows the listing keeps, as the reader last chose them. A choice here can be withdrawn by
+   * an edit made beside the panel, so it is the reconciled set below that narrows the listing until
+   * the withdrawal is committed back over these.
+   */
+  const [chosenFilters, setFilters] = useState<CatalogFilters>({});
 
   // Each rebuilt only when its own tag changes: the query around them turns over on every keystroke
   // in the search box, and a collator is expensive enough to be worth not rebuilding that often.
   const surfaceCollator = useMemo(() => collatorForTag(sourceLanguageTag), [sourceLanguageTag]);
   const glossCollator = useMemo(() => collatorForTag(analysisLanguage), [analysisLanguage]);
 
+  /**
+   * The choices worth offering as filters, taken against every row the draft holds rather than the
+   * rows a filter left standing: a facet judged against its own selection's survivors would
+   * collapse to that selection, leaving no choice on screen to widen it back by.
+   */
+  const facets = useMemo(() => deriveFacets(catalogRows), [catalogRows]);
+
+  /**
+   * The filters actually narrowing the listing: the reader's choices less any the facets have since
+   * withdrawn. An edit beside the panel can remove the last row carrying a chosen value, which
+   * takes that facet's control off screen; keeping the choice would narrow the list to nothing with
+   * no control left to widen it back by.
+   */
+  const filters = useMemo(() => reconcileFilters(chosenFilters, facets), [chosenFilters, facets]);
+
+  /**
+   * Commits a withdrawal back over the choices it narrowed, so a value the facets dropped is spent
+   * rather than merely unused. Left recorded it would return with its facet, narrowing the listing
+   * by a filter the reader had watched release.
+   *
+   * Settles after one withdrawal, {@link reconcileFilters} yielding the very set it was given once
+   * every choice survives.
+   */
+  useEffect(() => {
+    if (filters !== chosenFilters) setFilters(filters);
+  }, [filters, chosenFilters]);
+
   /** How the listing is narrowed and ordered, from the controls above the list. */
   const query = useMemo<CatalogQuery>(
     () => ({ search, sort, filters, surfaceCollator, glossCollator }),
@@ -129,8 +202,6 @@ export default function AnalysisCatalogPanel({
     [localizedStrings, currentBookName],
   );
 
-  const facets = useMemo(() => deriveFacets(catalogRows), [catalogRows]);
-
   const [interfaceLanguages] = useSetting('platform.interfaceLanguage', ['und']);
 
   /**
@@ -155,12 +226,30 @@ export default function AnalysisCatalogPanel({
    */
   const listing = useMemo(() => ({ query, currentBook }), [query, currentBook]);
 
+  /**
+   * What the last edit's collapse left standing, or `undefined` when no edit has collapsed one.
+   * Kept until dismissed or superseded: the reader may be looking anywhere in the list when an edit
+   * commits, and a row that vanishes unexplained reads as data loss.
+   */
+  const [mergeNotice, setMergeNotice] = useState<MergeNotice | undefined>(undefined);
+
+  /**
+   * Where the row a merge notice names sits in the listing, or `undefined` when no notice stands. A
+   * collapse can leave the survivor anywhere — an unused record inherits no usages to carry it up a
+   * listing ordered by them — so it is not otherwise guaranteed to be within the mounted window.
+   */
+  const noticedRowIndex = useMemo(() => {
+    if (!mergeNotice) return undefined;
+    const index = rows.findIndex((r) => r.analysisId === mergeNotice.survivingAnalysisId);
+    return index === -1 ? undefined : index;
+  }, [rows, mergeNotice]);
+
   /**
    * The slice of the listing that is actually mounted. A draft accumulates analyses without bound
    * and every row carries its own expander and usage list, so the list grows as it is scrolled
    * rather than rendering whole.
    */
-  const { windowRows, scrollRef, sentinelRef } = useRowWindow(rows, listing);
+  const { windowRows, scrollRef, sentinelRef } = useRowWindow(rows, listing, noticedRowIndex);
 
   const { navigate, requestFocusToken } = useInterlinearNav();
 
@@ -191,6 +280,443 @@ export default function AnalysisCatalogPanel({
     [navigate, requestFocusToken],
   );
 
+  const rowDispatch = useAnalysisRowDispatch();
+  const readDeletionOutcome = useAnalysisDeletionOutcome();
+
+  /**
+   * The row whose merge picker or delete confirmation is open, or `undefined` when neither is. The
+   * picker's names the form whose analyses it lists and the source it opens on.
+   *
+   * Held as ids rather than as rows, so a listing that turns over beneath an open modal cannot
+   * leave it holding a stale copy of what it is about to act on.
+   */
+  const [mergeSourceId, setMergeSourceId] = useState<string | undefined>(undefined);
+  const [deletingId, setDeletingId] = useState<string | undefined>(undefined);
+
+  /**
+   * The breakdown draft each row is holding, keyed by analysis id, for the rows holding one. Kept
+   * here rather than in the row because a row unmounts whenever it is collapsed or a query stops
+   * listing it, and the breakdown commits on neither blur nor unmount — so a draft left in the row
+   * would go with it, taking a re-segmentation the reader typed but had not saved.
+   *
+   * Each entry carries the form it was typed against, so a draft outliving its record can still be
+   * reported by the word the reader was working on.
+   */
+  const [breakdownDrafts, setBreakdownDrafts] = useState<ReadonlyMap<string, BreakdownDraft>>(
+    new Map(),
+  );
+
+  const handleBreakdownDraftChange = useCallback(
+    (analysisId: string, draft: string | undefined, surfaceText: string) => {
+      setBreakdownDrafts((drafts) => {
+        const next = new Map(drafts);
+        if (draft === undefined) next.delete(analysisId);
+        else next.set(analysisId, { text: draft, surfaceText });
+        return next;
+      });
+    },
+    [],
+  );
+
+  /** Drops a row's breakdown draft, for the paths that end one without the row reporting it. */
+  const discardBreakdownDraft = useCallback((analysisId: string) => {
+    setBreakdownDrafts((drafts) => {
+      if (!drafts.has(analysisId)) return drafts;
+      const next = new Map(drafts);
+      next.delete(analysisId);
+      return next;
+    });
+  }, []);
+
+  /**
+   * Whether one row is holding a breakdown the reader has changed but not saved. Measured against
+   * what the editor pre-filled, so a draft left untouched is not unsaved work.
+   */
+  const rowHasUnsavedBreakdown = useCallback(
+    (analysisId: string) => {
+      const row = catalogRows.find((r) => r.analysisId === analysisId);
+      const draft = row && breakdownDrafts.get(analysisId);
+      if (row === undefined || draft === undefined) return false;
+      const prefilled = row.morphemes.map((m) => m.form).join(' ') || row.surfaceText;
+      return breakdownDraftForms(draft.text).join(' ') !== breakdownDraftForms(prefilled).join(' ');
+    },
+    [catalogRows, breakdownDrafts],
+  );
+
+  /** Whether any row is holding a breakdown the reader has changed but not saved. */
+  const hasUnsavedBreakdown = useMemo(
+    () => catalogRows.some((r) => rowHasUnsavedBreakdown(r.analysisId)),
+    [catalogRows, rowHasUnsavedBreakdown],
+  );
+
+  // No flush on unmount: a breakdown draft is saved or discarded explicitly, never on the way out.
+  useReportGlossEditing(hasUnsavedBreakdown, () => {});
+
+  /**
+   * The draft an edit made outside the panel stranded, or `undefined` when none has been. Kept
+   * until dismissed or superseded, as the merge notice is: the reader may be looking anywhere when
+   * the row they were typing into goes.
+   */
+  const [strandedDraft, setStrandedDraft] = useState<StrandedDraftNotice | undefined>(undefined);
+
+  /**
+   * Reports and clears any draft whose analysis is no longer in the listing.
+   *
+   * An edit in the view beside the panel can drop the very record a draft is keyed to, taking the
+   * row out from under the reader mid-edit. Left in hand the draft would strand under an id that
+   * can never return, counting as no unsaved work: the tab's unsaved mark would clear and closing
+   * would stop asking.
+   */
+  useEffect(() => {
+    const stranded = [...breakdownDrafts].find(
+      ([analysisId]) => !catalogRows.some((r) => r.analysisId === analysisId),
+    );
+    if (!stranded) return;
+    const [analysisId, draft] = stranded;
+    setStrandedDraft({ surfaceText: draft.surfaceText });
+    discardBreakdownDraft(analysisId);
+  }, [breakdownDrafts, catalogRows, discardBreakdownDraft]);
+
+  /** Whether the reader is being asked to confirm closing over a breakdown they have not saved. */
+  const [confirmingClose, setConfirmingClose] = useState(false);
+
+  /**
+   * Closes the panel, or asks first when a breakdown draft would go with it.
+   *
+   * A breakdown commits on neither blur nor unmount, so closing is the one route that can drop
+   * typed text the reader never asked to discard.
+   */
+  const handleCloseRequest = useCallback(() => {
+    if (hasUnsavedBreakdown) setConfirmingClose(true);
+    else onClose();
+  }, [hasUnsavedBreakdown, onClose]);
+
+  /**
+   * Records what an edit did, so a collapse is reported rather than left to look like a vanished
+   * row. An ordinary edit clears whatever the last one said, the notice naming the edit just made
+   * rather than an older one.
+   */
+  const reportEditOutcome = useCallback((outcome: AnalysisEditOutcome, surfaceText: string) => {
+    setMergeNotice(
+      outcome.kind === 'merged'
+        ? {
+            survivingAnalysisId: outcome.survivingAnalysisId,
+            survivingGloss: outcome.survivingGloss,
+            surfaceText,
+            usageCount: outcome.survivingUsageCount,
+          }
+        : undefined,
+    );
+  }, []);
+
+  /**
+   * The surface form of the row an edit came from, for a merge notice to name the survivor by when
+   * it carries no gloss. The two share a form — a collapse only ever happens between homographs —
+   * so the edited row's own is the survivor's too.
+   */
+  const surfaceTextOf = useCallback(
+    (analysisId: string) =>
+      /* v8 ignore next -- the id came from a row of this very listing, so it always resolves */
+      catalogRows.find((r) => r.analysisId === analysisId)?.surfaceText ?? '',
+    [catalogRows],
+  );
+
+  const handleGlossCommit = useCallback(
+    (analysisId: string, value: string) => {
+      reportEditOutcome(rowDispatch.writeGloss(analysisId, value), surfaceTextOf(analysisId));
+    },
+    [reportEditOutcome, rowDispatch, surfaceTextOf],
+  );
+
+  const handleMorphemesCommit = useCallback(
+    (analysisId: string, forms: readonly string[]) => {
+      reportEditOutcome(
+        rowDispatch.writeMorphemes(analysisId, forms, sourceLanguageTag),
+        surfaceTextOf(analysisId),
+      );
+    },
+    [reportEditOutcome, rowDispatch, sourceLanguageTag, surfaceTextOf],
+  );
+
+  const handleMorphemeGlossCommit = useCallback(
+    (analysisId: string, morphemeId: string, value: string) => {
+      reportEditOutcome(
+        rowDispatch.writeMorphemeGloss(analysisId, morphemeId, value),
+        surfaceTextOf(analysisId),
+      );
+    },
+    [reportEditOutcome, rowDispatch, surfaceTextOf],
+  );
+
+  /**
+   * The outcome the open confirmation is stating, held still rather than subscribed: a fallback
+   * rewriting itself under the reader mid-decision would be worse than one that waits. A deletion
+   * is therefore never committed against this without checking it still holds.
+   */
+  const [deletionOutcome, setDeletionOutcome] = useState<AnalysisDeletionOutcome | undefined>(
+    undefined,
+  );
+
+  /**
+   * The edit a row is waiting to make once the reader agrees to lose the breakdown they typed
+   * against it, or `undefined` when none is waiting.
+   *
+   * Merging and deleting both drop the record a draft is keyed to, which takes the draft with it —
+   * so like closing, they ask first.
+   *
+   * A merge asks once for the row it is opened from, and again at confirmation for every other
+   * record it would fold in — a draft apiece, none of them covered by the opening ask.
+   */
+  const [discardingFor, setDiscardingFor] = useState<
+    | { kind: 'merge' | 'delete'; analysisId: string }
+    | {
+        kind: 'merge-confirm';
+        analysisId: string;
+        /** The merge the ask is standing between, held so agreeing commits what was settled. */
+        merge: {
+          survivorAnalysisId: string;
+          mergedAnalysisIds: readonly string[];
+          content: MergedContentDraft;
+          surfaceText: string;
+        };
+        /** The records this merge's earlier asks settled, which it does not ask about again. */
+        confirmedIds: readonly string[];
+      }
+    | undefined
+  >(undefined);
+
+  const openDelete = useCallback(
+    (analysisId: string) => {
+      const outcome = readDeletionOutcome(analysisId, liveSurfaceText);
+      // No outcome means the record is already gone, so there is nothing left to confirm deleting.
+      /* v8 ignore next -- the id came from a row of this very listing, so it always resolves */
+      if (!outcome) return;
+      setDeletionOutcome(outcome);
+      setDeletingId(analysisId);
+    },
+    [liveSurfaceText, readDeletionOutcome],
+  );
+
+  const handleDeleteRequest = useCallback(
+    (analysisId: string) => {
+      if (rowHasUnsavedBreakdown(analysisId)) setDiscardingFor({ kind: 'delete', analysisId });
+      else openDelete(analysisId);
+    },
+    [openDelete, rowHasUnsavedBreakdown],
+  );
+
+  const handleMergeRequest = useCallback(
+    (analysisId: string) => {
+      if (rowHasUnsavedBreakdown(analysisId)) setDiscardingFor({ kind: 'merge', analysisId });
+      else setMergeSourceId(analysisId);
+    },
+    [rowHasUnsavedBreakdown],
+  );
+
+  /**
+   * What the survivor will count once it holds the tokens of everything folded into it. Counted
+   * over the tokens rather than by summing the rows, so a token that carried two of the merged
+   * analyses counts once, as it will when their links collapse onto one.
+   */
+  const mergedUsageCount = useCallback(
+    (survivorAnalysisId: string, mergedAnalysisIds: readonly string[]) => {
+      const merging = new Set([survivorAnalysisId, ...mergedAnalysisIds]);
+      return new Set(
+        catalogRows
+          .filter((r) => merging.has(r.analysisId))
+          .flatMap((r) => r.usages.map((u) => u.tokenRef)),
+      ).size;
+    },
+    [catalogRows],
+  );
+
+  const commitMerge = useCallback(
+    (
+      survivorAnalysisId: string,
+      mergedAnalysisIds: readonly string[],
+      content: MergedContentDraft,
+      surfaceText: string,
+    ) => {
+      // Every record the merge drops takes any draft typed against it, and so does a survivor a
+      // converging merge folds into another record.
+      [survivorAnalysisId, ...mergedAnalysisIds].forEach(discardBreakdownDraft);
+
+      const outcome = rowDispatch.mergeAll(survivorAnalysisId, mergedAnalysisIds, {
+        gloss: content.gloss,
+        glossFromAnalysisId: content.glossFromAnalysisId,
+        morphemes: content.morphemes,
+        pos: content.pos,
+        features: content.features,
+        confidence: content.confidence,
+      });
+      setMergeSourceId(undefined);
+
+      // Reported against the record the merge left standing rather than the one it was aimed at:
+      // content matching an unmerged homograph moves the survivor, which the reader was warned of.
+      // A merge settled on nothing leaves no record at all, so there is no survivor to name.
+      if (outcome.kind === 'merged')
+        setMergeNotice({
+          survivingAnalysisId: outcome.survivingAnalysisId,
+          survivingGloss: outcome.survivingGloss,
+          surfaceText,
+          usageCount: outcome.survivingUsageCount,
+        });
+      else if (outcome.kind === 'removed') setMergeNotice(undefined);
+      else
+        setMergeNotice({
+          survivingAnalysisId: survivorAnalysisId,
+          survivingGloss: content.gloss,
+          surfaceText,
+          usageCount: mergedUsageCount(survivorAnalysisId, mergedAnalysisIds),
+        });
+    },
+    [discardBreakdownDraft, mergedUsageCount, rowDispatch],
+  );
+
+  /**
+   * Asks about the next unsaved breakdown a settled merge would drop, or commits it once every one
+   * has been agreed to — a discard being a decision per draft rather than one taken for all of
+   * them.
+   */
+  const askOrCommitMerge = useCallback(
+    (
+      merge: {
+        survivorAnalysisId: string;
+        mergedAnalysisIds: readonly string[];
+        content: MergedContentDraft;
+        surfaceText: string;
+      },
+      confirmedIds: readonly string[],
+    ) => {
+      const { survivorAnalysisId, mergedAnalysisIds, content, surfaceText } = merge;
+      const discarding = [survivorAnalysisId, ...mergedAnalysisIds]
+        .filter((id) => !confirmedIds.includes(id))
+        .find(rowHasUnsavedBreakdown);
+      if (discarding)
+        setDiscardingFor({ kind: 'merge-confirm', analysisId: discarding, merge, confirmedIds });
+      else commitMerge(survivorAnalysisId, mergedAnalysisIds, content, surfaceText);
+    },
+    [commitMerge, rowHasUnsavedBreakdown],
+  );
+
+  /**
+   * Gives up the draft, leaving the edit itself still to be confirmed — except for a merge the
+   * picker has already settled, which the ask was the last thing standing between.
+   */
+  const handleDiscardConfirm = useCallback(() => {
+    /* v8 ignore next -- unreachable: the modal that calls this mounts only on a set ask */
+    if (!discardingFor) return;
+    const { kind, analysisId } = discardingFor;
+    discardBreakdownDraft(analysisId);
+    setDiscardingFor(undefined);
+    if (kind === 'delete') openDelete(analysisId);
+    else if (kind === 'merge-confirm')
+      askOrCommitMerge(discardingFor.merge, [...discardingFor.confirmedIds, analysisId]);
+    else setMergeSourceId(analysisId);
+  }, [askOrCommitMerge, discardingFor, discardBreakdownDraft, openDelete]);
+
+  const handleDeleteConfirm = useCallback(() => {
+    /* v8 ignore next -- unreachable: the modal that calls this mounts only on a set id */
+    if (!deletingId) return;
+
+    // The fallback a confirmation names is another record, which an edit beside the panel can drop
+    // while the reader is deciding.
+    const current = readDeletionOutcome(deletingId, liveSurfaceText);
+    if (
+      current &&
+      (current.kind !== deletionOutcome?.kind ||
+        current.usageCount !== deletionOutcome.usageCount ||
+        current.fallbackGloss !== deletionOutcome.fallbackGloss ||
+        current.drifted !== deletionOutcome.drifted)
+    ) {
+      setDeletionOutcome(current);
+      return;
+    }
+
+    // Cleared before the record goes, so this removal is not reported back to the reader who
+    // asked for it.
+    discardBreakdownDraft(deletingId);
+    rowDispatch.deleteAnalysis(deletingId);
+    setDeletingId(undefined);
+    // A deleted row cannot be the one a merge notice points at, and leaving the notice up would
+    // send the reader to a row that is no longer there.
+    setMergeNotice(undefined);
+  }, [
+    deletingId,
+    deletionOutcome,
+    discardBreakdownDraft,
+    liveSurfaceText,
+    readDeletionOutcome,
+    rowDispatch,
+  ]);
+
+  /**
+   * Commits the merge the panel settled, which names its own survivor and content, once any draft
+   * on a record it would drop has been asked about.
+   */
+  const handleMergeConfirm = useCallback(
+    (
+      survivorAnalysisId: string,
+      mergedAnalysisIds: readonly string[],
+      content: MergedContentDraft,
+      surfaceText: string,
+    ) => {
+      askOrCommitMerge(
+        { survivorAnalysisId, mergedAnalysisIds, content, surfaceText },
+        /* confirmedIds */ [],
+      );
+    },
+    [askOrCommitMerge],
+  );
+
+  const deletingRow = useMemo(
+    () => catalogRows.find((row) => row.analysisId === deletingId),
+    [catalogRows, deletingId],
+  );
+
+  /**
+   * The rows sharing each surface form, most-used first, bucketed by the same normalized form the
+   * suggestion pool buckets by — so a merge is offered exactly among the records the store treats
+   * as homographs, rather than withheld from ones differing only in case or Unicode form.
+   */
+  const homographRowsByForm = useMemo(() => {
+    const byForm = new Map<string, CatalogRow[]>();
+    catalogRows.forEach((row) => {
+      const key = normalizeSurfaceForm(row.surfaceText);
+      const bucket = byForm.get(key) ?? [];
+      bucket.push(row);
+      byForm.set(key, bucket);
+    });
+    byForm.forEach((bucket) => bucket.sort((a, b) => b.usageCount - a.usageCount));
+    return byForm;
+  }, [catalogRows]);
+
+  /** Which rows have a homograph, and so are offered a merge control at all. */
+  const idsWithMergePeers = useMemo(
+    () =>
+      new Set(
+        [...homographRowsByForm.values()]
+          .filter((bucket) => bucket.length > 1)
+          .flat()
+          .map((row) => row.analysisId),
+      ),
+    [homographRowsByForm],
+  );
+
+  /**
+   * The analyses the open picker is choosing a merge's two ends between — every record of the form
+   * the picker was opened on — or `undefined` once that form is down to a single record, which is
+   * how a picker an edit beside the panel left with nothing to choose closes rather than
+   * lingering.
+   */
+  const openMerge = useMemo(() => {
+    const openedFrom = catalogRows.find((r) => r.analysisId === mergeSourceId);
+    if (!openedFrom) return undefined;
+    /* v8 ignore next -- unreachable: every row is filed, so a resolved one is in its own bucket */
+    const candidates = homographRowsByForm.get(normalizeSurfaceForm(openedFrom.surfaceText)) ?? [];
+    return candidates.length > 1 ? { openedFrom, candidates } : undefined;
+  }, [catalogRows, homographRowsByForm, mergeSourceId]);
+
   return (
     // The panel sits beside the interlinear view rather than within it, so the row tooltips have no
     // enclosing provider to inherit, and a Tooltip without one throws. The delay is irrelevant here:
@@ -207,7 +733,7 @@ export default function AnalysisCatalogPanel({
           <Button
             aria-label={localizedStrings['%interlinearizer_analysisCatalog_close%']}
             data-testid="analysis-catalog-close"
-            onClick={onClose}
+            onClick={handleCloseRequest}
             size="icon"
             variant="ghost"
           >
@@ -237,6 +763,22 @@ export default function AnalysisCatalogPanel({
           />
         )}
 
+        {mergeNotice && (
+          <CatalogMergeNotice
+            localizedStrings={localizedStrings}
+            notice={mergeNotice}
+            onDismiss={() => setMergeNotice(undefined)}
+          />
+        )}
+
+        {strandedDraft && (
+          <CatalogStrandedDraftNotice
+            localizedStrings={localizedStrings}
+            notice={strandedDraft}
+            onDismiss={() => setStrandedDraft(undefined)}
+          />
+        )}
+
         {rows.length === 0 ? (
           // Two ways to have nothing to list, and they call for different answers: a draft that has
           // recorded nothing yet, and a query that kept none of what it did. Telling a reader the
@@ -259,10 +801,21 @@ export default function AnalysisCatalogPanel({
               <CatalogRowView
                 key={row.analysisId}
                 analysisLanguage={analysisLanguage}
+                showMorphology={showMorphology}
+                breakdownDraft={breakdownDrafts.get(row.analysisId)?.text}
                 isSelected={row.analysisId === selectedAnalysisId}
                 localizedStrings={localizedStrings}
+                onBreakdownDraftChange={handleBreakdownDraftChange}
+                onDeleteRequest={handleDeleteRequest}
+                onGlossCommit={handleGlossCommit}
+                onMergeRequest={
+                  idsWithMergePeers.has(row.analysisId) ? handleMergeRequest : undefined
+                }
+                onMorphemeGlossCommit={handleMorphemeGlossCommit}
+                onMorphemesCommit={handleMorphemesCommit}
                 onUsageSelect={handleUsageSelect}
                 row={row}
+                shouldRevealSelf={row.analysisId === mergeNotice?.survivingAnalysisId}
                 usageCountInBookLabel={usageCountInBookLabel}
               />
             ))}
@@ -274,6 +827,60 @@ export default function AnalysisCatalogPanel({
             <li aria-hidden data-testid="catalog-rows-sentinel" ref={sentinelRef} />
           </ul>
         )}
+
+        {/*
+          Both modals are mounted against what they still have to act on rather than against the id
+          alone, so a listing that turns over beneath one — an edit made in the view beside the
+          panel — closes it instead of leaving it acting on a record that is no longer there. The
+          merge panel stays mounted behind the draft ask it raises, holding the arrangement and the
+          edits the reader made so that declining the ask returns to them.
+        */}
+        {openMerge && (
+          <CatalogMergeModal
+            analysisLanguage={analysisLanguage}
+            showMorphology={showMorphology}
+            candidates={openMerge.candidates}
+            initialSurvivorId={openMerge.openedFrom.analysisId}
+            localizedStrings={localizedStrings}
+            onCancel={() => setMergeSourceId(undefined)}
+            onConfirm={handleMergeConfirm}
+            sourceLanguageTag={sourceLanguageTag}
+            surfaceText={openMerge.openedFrom.surfaceText}
+          />
+        )}
+
+        {deletingRow && deletionOutcome && (
+          <CatalogDeleteModal
+            localizedStrings={localizedStrings}
+            onCancel={() => setDeletingId(undefined)}
+            onConfirm={handleDeleteConfirm}
+            outcome={deletionOutcome}
+            surfaceText={deletingRow.surfaceText}
+          />
+        )}
+
+        {/*
+          Both asks are mounted on the draft still standing as well as on the ask itself, so saving
+          or canceling it from the row beneath takes the question away rather than leaving the
+          reader answering about work that is no longer unsaved.
+        */}
+        {confirmingClose && hasUnsavedBreakdown && (
+          <CatalogCloseModal
+            localizedStrings={localizedStrings}
+            onCancel={() => setConfirmingClose(false)}
+            onConfirm={onClose}
+          />
+        )}
+
+        {discardingFor && rowHasUnsavedBreakdown(discardingFor.analysisId) && (
+          <CatalogCloseModal
+            // Both merge asks give the draft up for the same thing, so they read the same.
+            action={discardingFor.kind === 'delete' ? 'delete' : 'merge'}
+            localizedStrings={localizedStrings}
+            onCancel={() => setDiscardingFor(undefined)}
+            onConfirm={handleDiscardConfirm}
+          />
+        )}
       </div>
     </TooltipProvider>
   );
diff --git a/src/components/AnalysisStore.tsx b/src/components/AnalysisStore.tsx
index 2f495562f..0929216e7 100644
--- a/src/components/AnalysisStore.tsx
+++ b/src/components/AnalysisStore.tsx
@@ -11,15 +11,19 @@ import { createAnalysisStore, type AnalysisDispatch, type AnalysisRootState } fr
 import {
   approveAnalysisForToken,
   createPhrase,
+  deleteAnalysis,
   deleteMorphemes,
   deletePhrase,
+  mergeAnalysesInto,
   mergePhrases,
   selectAnalysis,
   selectAnalysisLanguage,
+  selectAnalysisDeletionOutcome,
   selectApprovedGloss,
   selectApprovedMorphemes,
   selectCatalogRows,
-  selectMorphemeResetLosesGlosses,
+  selectMorphemePayloadIsSolelyOwned,
+  selectMorphemeResetLosesAnnotation,
   selectPhraseLinkByAnalysisId,
   selectPhraseLinkByTokenRef,
   selectPhraseGloss,
@@ -28,11 +32,16 @@ import {
   selectSegmentFreeTranslation,
   selectFreeTranslationsBySegment,
   updatePhrase,
+  writeAnalysisGloss,
+  writeAnalysisMorphemeGloss,
+  writeAnalysisMorphemes,
   writeGloss,
   writeMorphemeGloss,
   writeMorphemes,
   writePhraseGloss,
   writeSegmentFreeTranslation,
+  type AnalysisDeletionOutcome,
+  type MergedContent,
 } from '../store/analysisSlice';
 import useLatestRef from '../hooks/useLatestRef';
 import { emptyAnalysis } from '../types/empty-factories';
@@ -393,17 +402,33 @@ export function useMorphemes(tokenRef: string): readonly MorphemeAnalysis[] {
 }
 
 /**
- * Returns whether resetting `tokenRef`'s morpheme breakdown would discard glosses no other token
- * still holds, so the morpheme editor can confirm before an irreversible loss (the app has no
- * undo). See {@link selectMorphemeResetLosesGlosses} for why a shared payload does not qualify.
+ * Returns whether resetting `tokenRef`'s morpheme breakdown would discard glosses or lexicon
+ * references no other token still holds, so the morpheme editor can confirm before an irreversible
+ * loss (the app has no undo). A payload shared with other tokens does not qualify: it is forked
+ * rather than emptied, leaving the co-linked tokens their morphemes.
  *
  * @throws When called outside an {@link AnalysisStoreProvider}.
  */
-export function useMorphemeResetLosesGlosses(tokenRef: string): boolean {
-  useRequiredCallbacks('useMorphemeResetLosesGlosses');
+export function useMorphemeResetLosesAnnotation(tokenRef: string): boolean {
+  useRequiredCallbacks('useMorphemeResetLosesAnnotation');
 
   return useSelector((state: AnalysisRootState) =>
-    selectMorphemeResetLosesGlosses(state.analysis, tokenRef),
+    selectMorphemeResetLosesAnnotation(state.analysis, tokenRef),
+  );
+}
+
+/**
+ * Returns whether `tokenRef` alone holds its analysis payload, so a breakdown edit destroys the
+ * glosses it strands rather than leaving them with co-linked tokens. See
+ * {@link selectMorphemePayloadIsSolelyOwned} for what counts as sharing.
+ *
+ * @throws When called outside an {@link AnalysisStoreProvider}.
+ */
+export function useMorphemePayloadIsSolelyOwned(tokenRef: string): boolean {
+  useRequiredCallbacks('useMorphemePayloadIsSolelyOwned');
+
+  return useSelector((state: AnalysisRootState) =>
+    selectMorphemePayloadIsSolelyOwned(state.analysis, tokenRef),
   );
 }
 
@@ -424,6 +449,225 @@ export function useCatalogRows(currentBook: string): readonly CatalogRow[] {
   return useSelector((state: AnalysisRootState) => selectCatalogRows(state.analysis, currentBook));
 }
 
+/**
+ * Where a catalog row's edit left the record it was aimed at.
+ *
+ * A write that makes a row content-identical to a sibling collapses the two, so the row the reader
+ * edited is gone from the listing and another's usage count has grown by its tokens. That reads as
+ * data loss unless it is reported, hence this rather than a bare `void`.
+ */
+export type AnalysisEditOutcome =
+  | {
+      /** The record survived the edit under its own id, which is the ordinary case. */
+      kind: 'edited';
+    }
+  | {
+      /** The record collapsed onto a content-identical sibling and no longer exists. */
+      kind: 'merged';
+      /** The surviving record's id, which the listing should now point the reader at. */
+      survivingAnalysisId: string;
+      /** What the survivor now reads as in the active analysis language, `''` when it has none. */
+      survivingGloss: string;
+      /** The survivor's usage count once the collapsed record's tokens joined it. */
+      survivingUsageCount: number;
+    }
+  | {
+      /** The edit emptied the record, which removed it and every link to it. */
+      kind: 'removed';
+    };
+
+/**
+ * Reports where an edit left the record `analysisId` named, so a row that vanishes can be explained
+ * rather than read as lost work. Only the survivor the write recorded tells a collapse from a
+ * removal; the state they leave is the same.
+ */
+function readEditOutcome(
+  after: TextAnalysis,
+  survivingAnalysisId: string | undefined,
+  analysisId: string,
+  analysisLanguage: string,
+): AnalysisEditOutcome {
+  if (after.tokenAnalyses.some((ta) => ta.id === analysisId)) return { kind: 'edited' };
+  if (survivingAnalysisId === undefined) return { kind: 'removed' };
+
+  const survivingAnalysis = after.tokenAnalyses.find((ta) => ta.id === survivingAnalysisId);
+  return {
+    kind: 'merged',
+    survivingAnalysisId,
+    /* v8 ignore next -- the survivor was just written into the state this reads */
+    survivingGloss: survivingAnalysis?.gloss?.[analysisLanguage] ?? '',
+    survivingUsageCount: new Set(
+      after.tokenAnalysisLinks
+        .filter((l) => l.analysisId === survivingAnalysisId && l.status === 'approved')
+        .map((l) => l.token.tokenRef),
+    ).size,
+  };
+}
+
+/** The catalog's write callbacks, each keyed by `analysisId` and so global to that record. */
+export type AnalysisRowDispatch = {
+  /**
+   * Writes a gloss onto the record itself, changing what it says for every token linked to it. A
+   * blank value clears it.
+   */
+  writeGloss: (analysisId: string, value: string) => AnalysisEditOutcome;
+  /**
+   * Re-segments the record's morpheme breakdown for every token linked to it, keeping the glosses
+   * and lexicon links on every form the re-split does not drop.
+   */
+  writeMorphemes: (
+    analysisId: string,
+    forms: readonly string[],
+    writingSystem: string,
+  ) => AnalysisEditOutcome;
+  /** Writes a gloss onto one morpheme of the record, for every token linked to it. */
+  writeMorphemeGloss: (
+    analysisId: string,
+    morphemeId: string,
+    value: string,
+  ) => AnalysisEditOutcome;
+  /**
+   * Removes the record and every link to it, leaving its tokens on whatever the suggestion pool
+   * still offers. Irreversible — see {@link useAnalysisDeletionOutcome} for what it will cost.
+   */
+  deleteAnalysis: (analysisId: string) => void;
+  /**
+   * Folds several records into one, writing the content the merge settled onto the survivor.
+   * Reports where it left the survivor, which a merge whose content converges on an unmerged record
+   * moves.
+   */
+  mergeAll: (
+    survivorAnalysisId: string,
+    mergedAnalysisIds: readonly string[],
+    content: MergedContent,
+  ) => AnalysisEditOutcome;
+};
+
+/**
+ * Returns stable callbacks for editing the analysis records the catalog lists. Every callback here
+ * is keyed by `analysisId` and so rewrites the record for all its tokens at once — the opposite of
+ * the `tokenRef`-keyed hooks above, which fork a shared payload to keep an edit local to one token.
+ * The key is the whole of the distinction; neither family takes a scope flag.
+ *
+ * Each write reports where it left the record, so the caller can tell the reader that an edit
+ * collapsed the row onto a sibling rather than letting it vanish unexplained.
+ *
+ * @throws When called outside an {@link AnalysisStoreProvider}.
+ */
+export function useAnalysisRowDispatch(): AnalysisRowDispatch {
+  const { dispatch, save } = useAnalysisSave('useAnalysisRowDispatch');
+  const store = useStore<AnalysisRootState>();
+
+  /**
+   * Dispatches one write and reports where it left the record, persisting once afterwards. Every
+   * write path shares it, so they cannot disagree about what counts as a merge.
+   */
+  const writeAndReport = useCallback(
+    (analysisId: string, action: Parameters<AnalysisDispatch>[0]): AnalysisEditOutcome => {
+      dispatch(action);
+      const { analysis, analysisLanguage, lastCollapseSurvivorId } = store.getState().analysis;
+      save();
+      return readEditOutcome(analysis, lastCollapseSurvivorId, analysisId, analysisLanguage);
+    },
+    [dispatch, save, store],
+  );
+
+  const handleWriteGloss = useCallback(
+    (analysisId: string, value: string) =>
+      writeAndReport(analysisId, writeAnalysisGloss({ analysisId, value })),
+    [writeAndReport],
+  );
+
+  const handleWriteMorphemes = useCallback(
+    (analysisId: string, forms: readonly string[], writingSystem: string) =>
+      writeAndReport(analysisId, writeAnalysisMorphemes({ analysisId, forms, writingSystem })),
+    [writeAndReport],
+  );
+
+  const handleWriteMorphemeGloss = useCallback(
+    (analysisId: string, morphemeId: string, value: string) =>
+      writeAndReport(analysisId, writeAnalysisMorphemeGloss({ analysisId, morphemeId, value })),
+    [writeAndReport],
+  );
+
+  const handleDelete = useCallback(
+    (analysisId: string) => {
+      dispatch(deleteAnalysis({ analysisId }));
+      save();
+    },
+    [dispatch, save],
+  );
+
+  const handleMergeAll = useCallback(
+    (survivorAnalysisId: string, mergedAnalysisIds: readonly string[], content: MergedContent) =>
+      writeAndReport(
+        survivorAnalysisId,
+        mergeAnalysesInto({ survivorAnalysisId, mergedAnalysisIds, content }),
+      ),
+    [writeAndReport],
+  );
+
+  return useMemo(
+    () => ({
+      writeGloss: handleWriteGloss,
+      writeMorphemes: handleWriteMorphemes,
+      writeMorphemeGloss: handleWriteMorphemeGloss,
+      deleteAnalysis: handleDelete,
+      mergeAll: handleMergeAll,
+    }),
+    [
+      handleWriteGloss,
+      handleWriteMorphemes,
+      handleWriteMorphemeGloss,
+      handleDelete,
+      handleMergeAll,
+    ],
+  );
+}
+
+/**
+ * Returns a stable getter for what deleting a record would do to the tokens that approve it — left
+ * blank, or falling back to a surviving homograph — so a confirmation can name the concrete
+ * consequence. Returns `undefined` for an id that resolves to no record.
+ *
+ * A getter rather than a subscription: the outcome is read once, when the confirmation opens, and
+ * subscribing every row to it would recompute the suggestion pool per row on every store change.
+ *
+ * A fallback is reported as a blank while suggestions are hidden: the surviving homograph reaches a
+ * token only as a suggestion, so the affected tokens read blank whatever the pool still offers.
+ *
+ * The getter is given the live-text lookup per call, so it reads the book as it stands at the
+ * moment the confirmation opens.
+ *
+ * @throws When called outside an {@link AnalysisStoreProvider}.
+ */
+export function useAnalysisDeletionOutcome(): (
+  analysisId: string,
+  liveSurfaceText: (tokenRef: string) => string | undefined,
+) => AnalysisDeletionOutcome | undefined {
+  const { showSuggestions, readOnly } = useRequiredCallbacks('useAnalysisDeletionOutcome');
+  const store = useStore<AnalysisRootState>();
+  const suggestionsVisible = showSuggestions && !readOnly;
+
+  return useCallback(
+    (analysisId: string, liveSurfaceText: (tokenRef: string) => string | undefined) => {
+      const outcome = selectAnalysisDeletionOutcome(
+        store.getState().analysis,
+        analysisId,
+        liveSurfaceText,
+      );
+      if (suggestionsVisible || outcome?.kind !== 'fallback') return outcome;
+      // Hiding the pool changes what the tokens will read, not what the deletion takes.
+      return {
+        kind: 'blank',
+        usageCount: outcome.usageCount,
+        unappliedCount: outcome.unappliedCount,
+      };
+    },
+    [store, suggestionsVisible],
+  );
+}
+
 /**
  * Returns the active BCP 47 analysis-language tag from the nearest {@link AnalysisStoreProvider}.
  *
diff --git a/src/components/CatalogCloseModal.tsx b/src/components/CatalogCloseModal.tsx
new file mode 100644
index 000000000..7492a8347
--- /dev/null
+++ b/src/components/CatalogCloseModal.tsx
@@ -0,0 +1,86 @@
+import { Button } from 'platform-bible-react';
+import type { LanguageStrings } from 'platform-bible-utils';
+import { ModalShell } from './modals/ModalShell';
+
+/** Localized string keys the discard confirmation renders. */
+export const CLOSE_STRING_KEYS = [
+  '%interlinearizer_analysisCatalog_closeConfirmTitle%',
+  '%interlinearizer_analysisCatalog_closeConfirmPrompt%',
+  '%interlinearizer_analysisCatalog_closeConfirmCancel%',
+  '%interlinearizer_analysisCatalog_closeConfirmDiscard%',
+  '%interlinearizer_analysisCatalog_discardForDeletePrompt%',
+  '%interlinearizer_analysisCatalog_discardForDeleteConfirm%',
+  '%interlinearizer_analysisCatalog_discardForMergePrompt%',
+  '%interlinearizer_analysisCatalog_discardForMergeConfirm%',
+] as const satisfies `%${string}%`[];
+
+/** Props for {@link CatalogCloseModal}. */
+type CatalogCloseModalProps = Readonly<{
+  /** Goes ahead with the action, discarding the breakdown draft. */
+  onConfirm: () => void;
+  /** Backs out, leaving the draft in hand. */
+  onCancel: () => void;
+  /** Resolved localizations covering at least {@link CLOSE_STRING_KEYS}. */
+  localizedStrings: LanguageStrings;
+  /** What the draft is being given up for; closing the panel when absent. */
+  action?: 'merge' | 'delete';
+}>;
+
+/** The prompt and confirm-button keys naming what the draft is being given up for. */
+const ACTION_KEYS = {
+  close: [
+    '%interlinearizer_analysisCatalog_closeConfirmPrompt%',
+    '%interlinearizer_analysisCatalog_closeConfirmDiscard%',
+  ],
+  delete: [
+    '%interlinearizer_analysisCatalog_discardForDeletePrompt%',
+    '%interlinearizer_analysisCatalog_discardForDeleteConfirm%',
+  ],
+  merge: [
+    '%interlinearizer_analysisCatalog_discardForMergePrompt%',
+    '%interlinearizer_analysisCatalog_discardForMergeConfirm%',
+  ],
+} as const;
+
+/**
+ * Confirms giving up an unsaved breakdown draft — to close the catalog over it, or to merge or
+ * delete the very analysis it is keyed to.
+ *
+ * Discarding is the only offer: saving would commit a re-segmentation that drops the old morphemes'
+ * glosses for every token the record holds, which carries a confirmation of its own. Consenting
+ * here settles only the draft, never the merge or delete it clears the way for.
+ */
+export default function CatalogCloseModal({
+  onConfirm,
+  onCancel,
+  localizedStrings,
+  action,
+}: CatalogCloseModalProps) {
+  const [promptKey, confirmKey] = ACTION_KEYS[action ?? 'close'];
+
+  return (
+    <ModalShell
+      onClose={onCancel}
+      title={localizedStrings['%interlinearizer_analysisCatalog_closeConfirmTitle%']}
+      titleTestId="catalog-close-title"
+      width="tw:w-96"
+    >
+      <p className="tw:text-sm" data-testid="catalog-close-prompt">
+        {localizedStrings[promptKey]}
+      </p>
+      <div className="tw:mt-4 tw:flex tw:justify-end tw:gap-2">
+        <Button data-testid="catalog-close-cancel" onClick={onCancel} variant="outline">
+          {localizedStrings['%interlinearizer_analysisCatalog_closeConfirmCancel%']}
+        </Button>
+        <Button
+          className="tw:text-destructive"
+          data-testid="catalog-close-discard"
+          onClick={onConfirm}
+          variant="outline"
+        >
+          {localizedStrings[confirmKey]}
+        </Button>
+      </div>
+    </ModalShell>
+  );
+}
diff --git a/src/components/CatalogDeleteModal.tsx b/src/components/CatalogDeleteModal.tsx
new file mode 100644
index 000000000..321e922ac
--- /dev/null
+++ b/src/components/CatalogDeleteModal.tsx
@@ -0,0 +1,149 @@
+import { Button } from 'platform-bible-react';
+import { formatReplacementString, type LanguageStrings } from 'platform-bible-utils';
+import { ModalShell } from './modals/ModalShell';
+import type { AnalysisDeletionOutcome } from '../store/analysisSlice';
+
+/** Localized string keys the delete confirmation renders. */
+export const DELETE_STRING_KEYS = [
+  '%interlinearizer_analysisCatalog_deleteTitle%',
+  '%interlinearizer_analysisCatalog_deleteBlank%',
+  '%interlinearizer_analysisCatalog_deleteBlankNone%',
+  '%interlinearizer_analysisCatalog_deleteFallback%',
+  '%interlinearizer_analysisCatalog_deleteFallbackNoGloss%',
+  '%interlinearizer_analysisCatalog_deleteFallbackDrifted%',
+  '%interlinearizer_analysisCatalog_deleteUnapplied%',
+  '%interlinearizer_analysisCatalog_deleteUndoWarning%',
+  '%interlinearizer_analysisCatalog_deleteCancel%',
+  '%interlinearizer_analysisCatalog_deleteConfirm%',
+] as const satisfies `%${string}%`[];
+
+/**
+ * States the concrete consequence of the deletion in the reader's own terms — how many uses are
+ * affected and what they will read as afterwards — rather than asking a generic "are you sure".
+ *
+ * The cases are the outcomes the store distinguishes, plus whether there is a word to quote: a
+ * fallback whose peer carries no gloss in the active language can only be described, not named.
+ *
+ * Zero uses is a sentence of its own rather than "0 uses will be left with no analysis", which
+ * invites the reader to wonder which nothing it means. Only the blank outcome can be reached with
+ * no uses, {@link selectAnalysisDeletionOutcome} reporting an unused record as blank however many
+ * homographs survive it.
+ *
+ * An uncertain fallback is described rather than named, quoting a word the affected token may not
+ * read being worse than quoting none.
+ */
+function outcomeMessage(
+  outcome: AnalysisDeletionOutcome,
+  localizedStrings: LanguageStrings,
+): string {
+  const { kind, usageCount, fallbackGloss, drifted } = outcome;
+
+  if (kind === 'blank') {
+    if (usageCount === 0)
+      return localizedStrings['%interlinearizer_analysisCatalog_deleteBlankNone%'];
+    return formatReplacementString(
+      localizedStrings['%interlinearizer_analysisCatalog_deleteBlank%'],
+      { count: usageCount },
+    );
+  }
+
+  if (drifted)
+    return formatReplacementString(
+      localizedStrings['%interlinearizer_analysisCatalog_deleteFallbackDrifted%'],
+      { count: usageCount },
+    );
+
+  if (!fallbackGloss)
+    return formatReplacementString(
+      localizedStrings['%interlinearizer_analysisCatalog_deleteFallbackNoGloss%'],
+      { count: usageCount },
+    );
+
+  return formatReplacementString(
+    localizedStrings['%interlinearizer_analysisCatalog_deleteFallback%'],
+    { count: usageCount, gloss: fallbackGloss },
+  );
+}
+
+/**
+ * Names the recorded-but-unapproved assignments the deletion also destroys, or `undefined` when
+ * there are none.
+ */
+function unappliedMessage(
+  unappliedCount: number,
+  localizedStrings: LanguageStrings,
+): string | undefined {
+  if (unappliedCount === 0) return undefined;
+  return formatReplacementString(
+    localizedStrings['%interlinearizer_analysisCatalog_deleteUnapplied%'],
+    { count: unappliedCount },
+  );
+}
+
+/** Props for {@link CatalogDeleteModal}. */
+type CatalogDeleteModalProps = Readonly<{
+  /** Surface form of the analysis being deleted, named in the title. */
+  surfaceText: string;
+  /** What the deletion will do to the tokens that approve the analysis. */
+  outcome: AnalysisDeletionOutcome;
+  /** Commits the deletion. */
+  onConfirm: () => void;
+  /** Backs out, leaving the analysis untouched. */
+  onCancel: () => void;
+  /** Resolved localizations covering at least {@link DELETE_STRING_KEYS}. */
+  localizedStrings: LanguageStrings;
+}>;
+
+/**
+ * Confirms deleting an analysis, naming what the deletion costs.
+ *
+ * Delete ships before undo, so this copy is the only guard: the analysis and every link to it go at
+ * once — approved and not — and the tokens that carried it are left on whatever the suggestion pool
+ * still offers. The modal is dismissable by Escape and by clicking outside — nothing is in flight
+ * to abandon, and a confirmation that traps the reader is worse than one they can back out of.
+ */
+export default function CatalogDeleteModal({
+  surfaceText,
+  outcome,
+  onConfirm,
+  onCancel,
+  localizedStrings,
+}: CatalogDeleteModalProps) {
+  const unapplied = unappliedMessage(outcome.unappliedCount, localizedStrings);
+  return (
+    <ModalShell
+      onClose={onCancel}
+      title={formatReplacementString(
+        localizedStrings['%interlinearizer_analysisCatalog_deleteTitle%'],
+        { form: surfaceText },
+      )}
+      titleTestId="catalog-delete-title"
+      width="tw:w-96"
+    >
+      <p className="tw:text-sm" data-testid="catalog-delete-outcome">
+        {outcomeMessage(outcome, localizedStrings)}
+      </p>
+      {unapplied && (
+        <p className="tw:mt-2 tw:text-sm" data-testid="catalog-delete-unapplied">
+          {unapplied}
+        </p>
+      )}
+      <p className="tw:mt-2 tw:text-xs tw:text-muted-foreground">
+        {localizedStrings['%interlinearizer_analysisCatalog_deleteUndoWarning%']}
+      </p>
+      <div className="tw:mt-4 tw:flex tw:justify-end tw:gap-2">
+        <Button data-testid="catalog-delete-cancel" onClick={onCancel} variant="outline">
+          {localizedStrings['%interlinearizer_analysisCatalog_deleteCancel%']}
+        </Button>
+        <Button
+          className="tw:text-destructive"
+          data-testid="catalog-delete-confirm"
+          onClick={onConfirm}
+          variant="outline"
+        >
+          {localizedStrings['%interlinearizer_analysisCatalog_deleteConfirm%']}
+        </Button>
+      </div>
+    </ModalShell>
+  );
+}
diff --git a/src/components/CatalogFilterPopover.tsx b/src/components/CatalogFilterPopover.tsx
index 3ab980ea6..9345fd0b9 100644
--- a/src/components/CatalogFilterPopover.tsx
+++ b/src/components/CatalogFilterPopover.tsx
@@ -69,19 +69,6 @@ function valueOf(choice: string | undefined): string {
   return choice === '' ? EMPTY_VALUE : choice;
 }
 
-/**
- * Whether a field earns a control: one the rows offer a choice for, or one still narrowing the list
- * by a selection its choices no longer cover. A field can stop offering choices while a reader is
- * filtered to one of them, and a selection with no control left is one nothing on screen can
- * clear.
- */
-function isFilterable(
-  choices: readonly unknown[] | undefined,
-  selected: readonly unknown[] | undefined,
-): boolean {
-  return choices !== undefined || (selected?.length ?? 0) > 0;
-}
-
 /**
  * The breakdown filter's inactive choice, spelled out because {@link CatalogFilters} spells it
  * `undefined` while the platform select needs a value for every choice it offers.
@@ -98,10 +85,10 @@ function morphemeChoice(value: string): CatalogFilters['morphemes'] {
 /** Props for {@link FacetFilter}. */
 type FacetFilterProps<T extends string> = Readonly<{
   /**
-   * The choices the rows offer for this field, `undefined` standing for carrying no value. Absent
-   * where the rows have stopped offering any, which leaves only what is still selected to offer.
+   * The choices the rows offer for this field, `undefined` among them standing for carrying no
+   * value. Raised only for a field the rows still offer choices for.
    */
-  choices: readonly (T | undefined)[] | undefined;
+  choices: readonly (T | undefined)[];
   /** The choices currently selected; absent or empty means the field narrows nothing. */
   selected: readonly (T | undefined)[] | undefined;
   /** Records a new selection, in the field's own terms rather than the control's. */
@@ -141,19 +128,13 @@ function FacetFilter<T extends string>({
     localizedStrings['%interlinearizer_analysisCatalog_filter_untagged%'].trim();
   const emptyLabel = localizedStrings['%interlinearizer_analysisCatalog_filter_empty%'].trim();
 
-  /** The choices to offer: the field's own, plus any still selected that it no longer lists. */
-  const offered = [
-    ...(choices ?? []),
-    ...(selected ?? []).filter((choice) => !(choices ?? []).includes(choice)),
-  ];
-
   /**
    * Each control value read back to the choice it stands for. Held as a map rather than compared
    * against the sentinels so that a choice the field spells as absence or as the empty string is
    * recovered as the choice it is.
    */
   const choiceByValue = new Map<string, T | undefined>(
-    offered.map((choice) => [valueOf(choice), choice]),
+    choices.map((choice) => [valueOf(choice), choice]),
   );
 
   /**
@@ -165,16 +146,19 @@ function FacetFilter<T extends string>({
   const nameOfValue = (choice: T) => (labelFor ? labelFor(choice) : choice).trim() || emptyLabel;
 
   /**
-   * What each offered choice is called, no two alike: the platform control cannot tell two options
-   * sharing a label apart, so only a distinctly named choice can be filtered by.
+   * What each choice is called, no two alike: the platform control cannot tell two options sharing
+   * a label apart, so only a distinctly named choice can be filtered by.
+   *
+   * A value reading as a label another choice holds is marked as recorded repeatedly, since a value
+   * can be spelled like the marking itself.
    */
   const labelByChoice = new Map<T | undefined, string>();
   const claimed = new Set<string>();
-  offered.forEach((choice) => {
+  choices.forEach((choice) => {
     if (choice === undefined) claimed.add(untaggedLabel);
     if (choice === '') claimed.add(emptyLabel);
   });
-  offered.forEach((choice) => {
+  choices.forEach((choice) => {
     if (choice === undefined) return labelByChoice.set(choice, untaggedLabel);
     if (choice === '') return labelByChoice.set(choice, emptyLabel);
     let name = nameOfValue(choice);
@@ -189,6 +173,10 @@ function FacetFilter<T extends string>({
         { value: name },
       ).trim();
     }
+    // Numbered where the marking never moved the name, a translation dropping or merely echoing
+    // what it was given: an ugly name can still be picked, where a repeated one cannot.
+    for (let ordinal = 2; claimed.has(name); ordinal += 1)
+      name = `${nameOfValue(choice)} (${ordinal})`;
     claimed.add(name);
     return labelByChoice.set(choice, name);
   });
@@ -268,6 +256,9 @@ type CatalogFilterPopoverProps = Readonly<{
  *
  * A facet offering fewer than two choices raises no control at all: {@link CatalogFacets} omits it,
  * because a lone choice is the state every row is already in, so choosing it would narrow nothing.
+ * That covers the facet-backed filters alone. The controls below them stand on a state every row
+ * has rather than on a facet, so there is nothing for {@link CatalogFacets} to omit and they are
+ * always raised — inert though one is against data that is uniform in what it asks about.
  */
 export default function CatalogFilterPopover({
   facets,
@@ -281,18 +272,8 @@ export default function CatalogFilterPopover({
 
   const filtersLabel = localizedStrings['%interlinearizer_analysisCatalog_filters%'];
 
-  /**
-   * The feature names to raise a control for: those the rows offer choices for, and any a selection
-   * still narrows by.
-   */
-  const featureNames = [
-    ...new Set([
-      ...Object.keys(facets.features ?? {}),
-      ...Object.entries(filters.features ?? {})
-        .filter(([, values]) => values?.length)
-        .map(([name]) => name),
-    ]),
-  ];
+  /** Each feature to raise a control for with its choices, being those the rows offer. */
+  const featureFacets = Object.entries(facets.features ?? {});
 
   /**
    * How many of the filter groups are narrowing anything. Each named feature counts on its own, as
@@ -335,7 +316,7 @@ export default function CatalogFilterPopover({
           className="tw:flex tw:w-auto tw:min-w-56 tw:flex-col tw:gap-3"
           data-testid="catalog-filters-panel"
         >
-          {isFilterable(facets.books, filters.books) && (
+          {facets.books !== undefined && (
             <FacetFilter
               choices={facets.books}
               id="catalog-filter-books"
@@ -353,7 +334,7 @@ export default function CatalogFilterPopover({
             />
           )}
 
-          {isFilterable(facets.pos, filters.pos) && (
+          {facets.pos !== undefined && (
             <FacetFilter
               choices={facets.pos}
               id="catalog-filter-pos"
@@ -364,7 +345,7 @@ export default function CatalogFilterPopover({
             />
           )}
 
-          {isFilterable(facets.confidence, filters.confidence) && (
+          {facets.confidence !== undefined && (
             <FacetFilter
               choices={facets.confidence}
               id="catalog-filter-confidence"
@@ -381,9 +362,9 @@ export default function CatalogFilterPopover({
             selection only by satisfying every named feature in it. Feature names come out of the
             data, so each is shown as it was recorded rather than under a localized name.
           */}
-          {featureNames.map((name) => (
+          {featureFacets.map(([name, choices]) => (
             <FacetFilter
-              choices={facets.features?.[name]}
+              choices={choices}
               id={`catalog-filter-feature-${name}`}
               key={name}
               label={name}
diff --git a/src/components/CatalogMergeModal.tsx b/src/components/CatalogMergeModal.tsx
new file mode 100644
index 000000000..a27103e91
--- /dev/null
+++ b/src/components/CatalogMergeModal.tsx
@@ -0,0 +1,834 @@
+import {
+  closestCenter,
+  DndContext,
+  KeyboardSensor,
+  PointerSensor,
+  useSensor,
+  useSensors,
+  type DragEndEvent,
+} from '@dnd-kit/core';
+import {
+  SortableContext,
+  sortableKeyboardCoordinates,
+  useSortable,
+  verticalListSortingStrategy,
+} from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+import { ArrowUpToLine, GripVertical, X } from 'lucide-react';
+import {
+  Button,
+  Checkbox,
+  Input,
+  Label,
+  Popover,
+  PopoverAnchor,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from 'platform-bible-react';
+import { formatReplacementString, type LanguageStrings } from 'platform-bible-utils';
+import { useId, useState, type ReactNode } from 'react';
+import type { Confidence } from 'interlinearizer';
+import { breakdownDraftForms } from './CatalogRowEditor';
+import { morphemeCarriesAnnotation } from '../utils/analysis-identity';
+import { MorphemeBox } from './MorphemeBox';
+import { MorphemeBreakdownPopover, type MorphemeEditorLabels } from './MorphemeEditor';
+import { ModalShell } from './modals/ModalShell';
+import type { CatalogRow } from '../utils/analysis-query';
+import { resolvedOrEmpty } from '../utils/localized-strings';
+import {
+  deriveBreakdown,
+  deriveMergeContent,
+  remapMorphemeGlossEdits,
+  reorderForMerge,
+  CLEARED,
+  type MergedContentDraft,
+  type MergeContentEdits,
+  type MergeReorder,
+} from '../utils/merge-content';
+
+/**
+ * The name each confidence level is offered under. Confidence is a closed vocabulary, so it is
+ * named rather than shown as the record stores it.
+ */
+const CONFIDENCE_LABEL_KEYS = {
+  high: '%interlinearizer_analysisCatalog_confidence_high%',
+  medium: '%interlinearizer_analysisCatalog_confidence_medium%',
+  low: '%interlinearizer_analysisCatalog_confidence_low%',
+  guess: '%interlinearizer_analysisCatalog_confidence_guess%',
+} as const satisfies Record<Confidence, `%${string}%`>;
+
+/** The levels the select offers, ordered as confidence descends. */
+const CONFIDENCE_LEVELS: readonly Confidence[] = ['high', 'medium', 'low', 'guess'];
+
+/**
+ * One width for every field's label, so the fields themselves start on a line down the panel rather
+ * than each one wherever its own label happens to end.
+ */
+const FIELD_LABEL_CLASS = 'tw:w-24 tw:shrink-0 tw:text-xs tw:text-muted-foreground';
+
+/**
+ * The choice of recording no confidence, which the platform select needs a string for. A leading
+ * NUL collides with no level, and with nothing the analysis layer reads.
+ */
+const NO_CONFIDENCE = '\u0000none';
+
+/** The level a select's value names, or `undefined` where it names none. */
+function confidenceChoice(value: string): Confidence | undefined {
+  return CONFIDENCE_LEVELS.find((level) => level === value);
+}
+
+/** Localized string keys the merge panel renders. */
+export const MERGE_STRING_KEYS = [
+  '%interlinearizer_analysisCatalog_mergeTitle%',
+  '%interlinearizer_analysisCatalog_mergeForm%',
+  '%interlinearizer_analysisCatalog_editGloss%',
+  '%interlinearizer_analysisCatalog_editMorphemes%',
+  '%interlinearizer_analysisCatalog_editMorphemesHint%',
+  '%interlinearizer_analysisCatalog_editMorphemesOpen%',
+  '%interlinearizer_analysisCatalog_editMorphemesSave%',
+  '%interlinearizer_analysisCatalog_editMorphemesCancel%',
+  '%interlinearizer_analysisCatalog_editMorphemesReset%',
+  '%interlinearizer_analysisCatalog_confirmResetPrompt%',
+  '%interlinearizer_analysisCatalog_confirmResetAction%',
+  '%interlinearizer_analysisCatalog_confirmResplitPrompt%',
+  '%interlinearizer_analysisCatalog_confirmResplitAction%',
+  '%interlinearizer_analysisCatalog_morphemeNoGloss%',
+  '%interlinearizer_analysisCatalog_noBreakdown%',
+  '%interlinearizer_analysisCatalog_mergeMorphemeGlosses%',
+  '%interlinearizer_analysisCatalog_mergeClearMorphemeGloss%',
+  '%interlinearizer_analysisCatalog_morphemeGloss%',
+  '%interlinearizer_analysisCatalog_mergeConfidence%',
+  '%interlinearizer_analysisCatalog_mergeConfidenceNone%',
+  ...Object.values(CONFIDENCE_LABEL_KEYS),
+  '%interlinearizer_analysisCatalog_mergeUsageCount%',
+  '%interlinearizer_analysisCatalog_mergePromote%',
+  '%interlinearizer_analysisCatalog_mergeReorder%',
+  '%interlinearizer_analysisCatalog_mergeRevertField%',
+  '%interlinearizer_analysisCatalog_mergeReset%',
+  '%interlinearizer_analysisCatalog_mergeWillCollapse%',
+  '%interlinearizer_analysisCatalog_noGloss%',
+  '%interlinearizer_analysisCatalog_mergeCancel%',
+  '%interlinearizer_analysisCatalog_mergeConfirm%',
+] as const satisfies `%${string}%`[];
+
+/** Props for {@link CatalogMergeModal}. */
+type CatalogMergeModalProps = Readonly<{
+  /** The surface form every listed analysis shares, shown above them. */
+  surfaceText: string;
+  /** Every analysis of the form — the survivor, the ones it may absorb, and the rest. */
+  candidates: readonly CatalogRow[];
+  /** The analysis the panel was opened from, which starts as the survivor. */
+  initialSurvivorId: string;
+  /** BCP 47 tag the glosses are read and written under. */
+  analysisLanguage: string;
+  /** When false, the breakdown fields are not shown, as the view option hides them on the strip. */
+  showMorphology: boolean;
+  /** Writing system a re-split breakdown's minted morphemes are recorded under. */
+  sourceLanguageTag: string;
+  /**
+   * Commits the merge, folding the checked analyses into the survivor under the settled content,
+   * most-preferred first as the reader arranged them.
+   */
+  onConfirm: (
+    survivorAnalysisId: string,
+    mergedAnalysisIds: readonly string[],
+    content: MergedContentDraft,
+    surfaceText: string,
+  ) => void;
+  /** Backs out, leaving every analysis untouched. */
+  onCancel: () => void;
+  /** Resolved localizations covering at least {@link MERGE_STRING_KEYS}. */
+  localizedStrings: LanguageStrings;
+}>;
+
+/** Props for {@link SortableCandidate}. */
+type SortableCandidateProps = Readonly<{
+  candidate: CatalogRow;
+  /** Whether the merge is folding this analysis in, which the survivor always is. */
+  merged: boolean;
+  isSurvivor: boolean;
+  surfaceText: string;
+  /** Text shown where the analysis has no gloss in the analysis language. */
+  noGloss: string;
+  /** BCP 47 tag the morpheme glosses are read under. */
+  analysisLanguage: string;
+  onMergedChange: (merged: boolean) => void;
+  onPromote: () => void;
+  localizedStrings: LanguageStrings;
+}>;
+
+/**
+ * One analysis in the listing: whether the merge folds it in, everything the merged content could
+ * take from it, and the controls that move it.
+ */
+function SortableCandidate({
+  candidate,
+  merged,
+  isSurvivor,
+  surfaceText,
+  noGloss,
+  analysisLanguage,
+  onMergedChange,
+  onPromote,
+  localizedStrings,
+}: SortableCandidateProps) {
+  const { attributes, listeners, setNodeRef, transform, transition } = useSortable({
+    id: candidate.analysisId,
+  });
+
+  return (
+    <li
+      className="tw:flex tw:min-w-0 tw:items-center tw:gap-2 tw:rounded tw:border tw:border-border tw:px-2 tw:py-1.5"
+      data-analysis-id={candidate.analysisId}
+      data-testid="catalog-merge-candidate"
+      ref={setNodeRef}
+      style={{ transform: CSS.Transform.toString(transform), transition }}
+    >
+      <Button
+        aria-label={formatReplacementString(
+          localizedStrings['%interlinearizer_analysisCatalog_mergeReorder%'],
+          { gloss: candidate.gloss || surfaceText },
+        )}
+        className="tw:cursor-grab"
+        data-testid="catalog-merge-drag-handle"
+        size="icon"
+        type="button"
+        variant="ghost"
+        {...attributes}
+        {...listeners}
+      >
+        <GripVertical aria-hidden className="tw:size-5" />
+      </Button>
+
+      <Checkbox
+        // The survivor is what the others merge into, so its membership is not a choice.
+        checked={merged}
+        className="tw:size-5"
+        data-testid="catalog-merge-check"
+        disabled={isSurvivor}
+        onCheckedChange={onMergedChange}
+      />
+
+      {/* Everything the merged content can take from this analysis, so a row that is about to donate a
+          field says so on its face. */}
+      <div className="tw:flex tw:min-w-0 tw:flex-1 tw:flex-col tw:gap-0.5">
+        <div className="tw:flex tw:items-baseline tw:gap-2">
+          <span className="tw:min-w-0 tw:flex-1 tw:truncate" data-testid="catalog-merge-gloss">
+            {candidate.gloss || noGloss}
+          </span>
+          <span
+            className="tw:text-xs tw:tabular-nums tw:text-muted-foreground"
+            data-testid="catalog-merge-usage-count"
+          >
+            {formatReplacementString(
+              localizedStrings['%interlinearizer_analysisCatalog_mergeUsageCount%'],
+              { count: candidate.usageCount },
+            )}
+          </span>
+        </div>
+
+        {/* Each morpheme over its gloss, which is what tells apart two analyses their own glosses
+            cannot. Laid out inline rather than in the boxed grid the content panel edits: a card is
+            a summary in a drag list, where a box per candidate would read as another panel. */}
+        <div
+          className="tw:flex tw:flex-wrap tw:gap-x-3 tw:gap-y-0.5"
+          data-testid="catalog-merge-breakdown"
+        >
+          {candidate.morphemes.length === 0 ? (
+            <span
+              className="tw:text-xs tw:italic tw:text-muted-foreground"
+              data-testid="catalog-merge-morpheme-none"
+            >
+              {localizedStrings['%interlinearizer_analysisCatalog_noBreakdown%']}
+            </span>
+          ) : (
+            candidate.morphemes.map((morpheme) => {
+              const gloss = morpheme.gloss?.[analysisLanguage];
+              return (
+                <div
+                  className="tw:flex tw:min-w-0 tw:flex-col"
+                  data-testid="catalog-merge-morpheme"
+                  key={morpheme.id}
+                >
+                  <span className="tw:truncate tw:font-mono tw:text-xs">{morpheme.form}</span>
+                  <span
+                    className={`tw:truncate tw:text-xs tw:text-muted-foreground${gloss ? '' : ' tw:italic'}`}
+                    data-testid="catalog-merge-morpheme-gloss"
+                  >
+                    {gloss || localizedStrings['%interlinearizer_analysisCatalog_morphemeNoGloss%']}
+                  </span>
+                </div>
+              );
+            })
+          )}
+        </div>
+
+        <div className="tw:flex tw:flex-wrap tw:gap-x-3 tw:text-xs tw:text-muted-foreground">
+          {candidate.confidence && (
+            <span>{localizedStrings[CONFIDENCE_LABEL_KEYS[candidate.confidence]]}</span>
+          )}
+        </div>
+      </div>
+
+      <Button
+        aria-label={formatReplacementString(
+          localizedStrings['%interlinearizer_analysisCatalog_mergePromote%'],
+          { gloss: candidate.gloss || surfaceText },
+        )}
+        data-testid="catalog-merge-promote"
+        disabled={isSurvivor}
+        onClick={onPromote}
+        size="icon"
+        type="button"
+        variant="ghost"
+      >
+        <ArrowUpToLine aria-hidden className="tw:size-5" />
+      </Button>
+    </li>
+  );
+}
+
+/**
+ * An X over the end of a field, taking back what the reader typed into it. Shown only where there
+ * is an edit to take back, a control that undoes nothing reading as a way to clear the field.
+ *
+ * The field it sits over must hold end padding for it unconditionally, so text never runs under it
+ * and the field does not widen as it appears.
+ */
+function InlineRevertButton({
+  edited,
+  label,
+  onRevert,
+  testId,
+}: Readonly<{ edited: boolean; label: string; onRevert: () => void; testId: string }>) {
+  if (!edited) return undefined;
+  return (
+    <Button
+      aria-label={label}
+      className="tw:absolute tw:inset-y-0 tw:end-1 tw:my-auto tw:size-5 tw:text-muted-foreground"
+      data-testid={testId}
+      onClick={onRevert}
+      size="icon"
+      type="button"
+      variant="ghost"
+    >
+      <X aria-hidden className="tw:size-3.5" />
+    </Button>
+  );
+}
+
+/** A field with the control that takes its edit back sitting inside it, at the end of the field. */
+function RevertableField({
+  edited,
+  field,
+  label,
+  onRevert,
+  children,
+}: Readonly<{
+  edited: boolean;
+  field: keyof MergeContentEdits;
+  label: string;
+  onRevert: () => void;
+  children: ReactNode;
+}>) {
+  return (
+    <div className="tw:relative tw:min-w-0">
+      {children}
+      <InlineRevertButton
+        edited={edited}
+        label={label}
+        onRevert={onRevert}
+        testId={`catalog-merge-revert-${field}`}
+      />
+    </div>
+  );
+}
+
+/**
+ * Where a drop on `overId` lands in `listedIds`, or `undefined` when the listing does not hold it —
+ * a place of its own, which an index cannot express without reading as one counted from the end.
+ */
+export function dropIndex(listedIds: readonly string[], overId: string): number | undefined {
+  const index = listedIds.indexOf(overId);
+  return index === -1 ? undefined : index;
+}
+
+/**
+ * Settles what one surface form's analyses should say and which of them should say it: editable
+ * merged content over the listing of its homographs, each of which the merge either folds in or
+ * leaves standing.
+ */
+export default function CatalogMergeModal({
+  surfaceText,
+  candidates,
+  initialSurvivorId,
+  analysisLanguage,
+  showMorphology,
+  sourceLanguageTag,
+  onConfirm,
+  onCancel,
+  localizedStrings,
+}: CatalogMergeModalProps) {
+  const breakdownLabels: MorphemeEditorLabels = {
+    splitLabel: localizedStrings['%interlinearizer_analysisCatalog_editMorphemes%'],
+    reset: localizedStrings['%interlinearizer_analysisCatalog_editMorphemesReset%'],
+    cancel: localizedStrings['%interlinearizer_analysisCatalog_editMorphemesCancel%'],
+    done: localizedStrings['%interlinearizer_analysisCatalog_editMorphemesSave%'],
+    emptyHint: localizedStrings['%interlinearizer_analysisCatalog_editMorphemesHint%'],
+    confirmResetPrompt: formatReplacementString(
+      localizedStrings['%interlinearizer_analysisCatalog_confirmResetPrompt%'],
+      { form: surfaceText },
+    ),
+    confirmResetAction: localizedStrings['%interlinearizer_analysisCatalog_confirmResetAction%'],
+    confirmResplitPrompt:
+      localizedStrings['%interlinearizer_analysisCatalog_confirmResplitPrompt%'],
+    confirmResplitAction:
+      localizedStrings['%interlinearizer_analysisCatalog_confirmResplitAction%'],
+  };
+
+  // Visible cell text, so an unresolved key would leave an analysis nameless in a list the reader
+  // chooses from. The em dash reads as "no gloss" in any language, as it does in the listing.
+  const noGloss =
+    resolvedOrEmpty(localizedStrings['%interlinearizer_analysisCatalog_noGloss%']) || '—';
+
+  const glossFieldId = useId();
+  const [breakdownDraft, setBreakdownDraft] = useState<string | undefined>(undefined);
+  const [edits, setEdits] = useState<MergeContentEdits>({});
+
+  /**
+   * The analyses the merge would fold in, the survivor excluded — it is always in the merge, so
+   * holding it here would be a second place its membership could be said to change.
+   */
+  const [mergedIds, setMergedIds] = useState<ReadonlySet<string>>(new Set());
+
+  /** Records one field's edit, or drops it back to what the merged analyses derive. */
+  const editField = <K extends keyof MergeContentEdits>(
+    field: K,
+    value: MergeContentEdits[K] | undefined,
+  ) =>
+    setEdits((previous) => {
+      const next = { ...previous };
+      if (value === undefined) delete next[field];
+      else next[field] = value;
+      return next;
+    });
+
+  /**
+   * The analyses the reader has arranged, most-preferred first. Held as ids so the listing follows
+   * an edit made beside the panel rather than pinning the rows as they were opened.
+   */
+  const [orderedIds, setOrderedIds] = useState<readonly string[]>(() => [initialSurvivorId]);
+
+  // An analysis of the form the arrangement has nothing to say about — one an edit beside the panel
+  // raised — lands at the foot, unchecked, rather than going unlisted.
+  const order = [
+    ...orderedIds
+      .map((id) => candidates.find((r) => r.analysisId === id))
+      .filter((r) => r !== undefined),
+    ...candidates.filter((r) => !orderedIds.includes(r.analysisId)),
+  ];
+  const [survivor] = order;
+
+  // Every listed analysis, not only those the reader has rearranged: a drop resolves against what is
+  // on screen.
+  const listedIds = order.map((r) => r.analysisId);
+
+  const checked = new Set([survivor.analysisId, ...mergedIds]);
+
+  const { content, verdict } = deriveMergeContent({
+    order,
+    checked,
+    edits,
+    analysisLanguage,
+    sourceLanguageTag,
+  });
+
+  /**
+   * Restages the gloss edits against `nextForms`, each staying on the form it was typed about. A
+   * `resplit` stages those forms as the reader's own breakdown; otherwise they are what the
+   * analyses derive and no breakdown of the reader's is left standing.
+   */
+  const restageGlossEdits = (nextForms: readonly string[], resplit: boolean) =>
+    setEdits((previous) => {
+      const morphemeGlosses = remapMorphemeGlossEdits(
+        previous.morphemeGlosses,
+        content.morphemes,
+        nextForms,
+      );
+      const next = { ...previous };
+      if (resplit) next.morphemeForms = nextForms;
+      else delete next.morphemeForms;
+      if (morphemeGlosses) next.morphemeGlosses = morphemeGlosses;
+      else delete next.morphemeGlosses;
+      return next;
+    });
+
+  /** Stages a re-split, keeping each gloss edit on the form it was typed about. */
+  const resplitTo = (forms: readonly string[]) => restageGlossEdits(forms, true);
+
+  /**
+   * Keeps each gloss edit on the form it was typed about when a change of survivor or of membership
+   * would swap the derived breakdown. A re-split of the reader's outranks what the analyses derive,
+   * so it stands through the change and the edits stay where it put them.
+   */
+  const restageForSelection = (next: MergeReorder) => {
+    if (edits.morphemeForms) return;
+    const nextOrder = next.orderedIds
+      .map((id) => candidates.find((r) => r.analysisId === id))
+      .filter((r) => r !== undefined);
+    const nextChecked = new Set([next.orderedIds[0], ...next.mergedIds]);
+    restageGlossEdits(
+      deriveBreakdown(nextOrder, nextChecked).map((m) => m.form),
+      false,
+    );
+  };
+
+  /** Moves one analysis, keeping the arrangement and the merge set in step. */
+  const applyReorder = (analysisId: string, toIndex: number) => {
+    const next = reorderForMerge({ orderedIds: listedIds, mergedIds }, analysisId, toIndex);
+    restageForSelection(next);
+    setOrderedIds(next.orderedIds);
+    setMergedIds(next.mergedIds);
+  };
+
+  // Named by its form where it carries no gloss, a warning that named neither leaving nothing to
+  // recognize the analysis by.
+  const collapsingGloss =
+    verdict.reason === 'will-collapse'
+      ? candidates.find((r) => r.analysisId === verdict.collapsingAnalysisId)?.gloss || surfaceText
+      : '';
+
+  // The keyboard sensor is registered so a drag is not the only way to rearrange the listing.
+  const sensors = useSensors(
+    useSensor(PointerSensor),
+    useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates }),
+  );
+
+  /* v8 ignore start -- a drop resolves against element rects, which jsdom reports as zero-sized, so
+     no drag can complete under test; the rule it hands to is covered directly */
+  /** Lands a dragged analysis where it was dropped; a drop outside the listing moves nothing. */
+  const handleDragEnd = ({ active, over }: DragEndEvent) => {
+    if (!over) return;
+    const toIndex = dropIndex(listedIds, String(over.id));
+    if (toIndex !== undefined) applyReorder(String(active.id), toIndex);
+  };
+  /* v8 ignore stop */
+
+  /** Puts one analysis into the merge or takes it out; the survivor's membership never moves. */
+  const setMerged = (analysisId: string, merged: boolean) => {
+    const next = new Set(mergedIds);
+    if (merged) next.add(analysisId);
+    else next.delete(analysisId);
+    restageForSelection({ orderedIds: listedIds, mergedIds: next });
+    setMergedIds(next);
+  };
+
+  return (
+    <ModalShell
+      onClose={onCancel}
+      title={localizedStrings['%interlinearizer_analysisCatalog_mergeTitle%']}
+      titleTestId="catalog-merge-title"
+      width="tw:w-fit tw:max-w-2xl"
+    >
+      {/* The form is what the whole decision is about, so it is centered over the panel. */}
+      <div className="tw:flex tw:flex-col tw:items-center tw:gap-1">
+        <span
+          className="tw:text-xs tw:text-muted-foreground"
+          data-testid="catalog-merge-form-label"
+        >
+          {localizedStrings['%interlinearizer_analysisCatalog_mergeForm%']}
+        </span>
+        <p className="tw:text-lg tw:font-semibold" data-testid="catalog-merge-form">
+          {surfaceText}
+        </p>
+      </div>
+
+      {/* Bordered as an analysis in the listing is, the merged content being what they all merge into. */}
+      <div className="tw:mt-4 tw:flex tw:flex-col tw:gap-3 tw:rounded tw:border tw:border-border tw:p-3">
+        <div className="tw:flex tw:items-center tw:gap-3">
+          <Label className={FIELD_LABEL_CLASS} htmlFor={glossFieldId}>
+            {localizedStrings['%interlinearizer_analysisCatalog_editGloss%']}
+          </Label>
+          <div className="tw:min-w-0 tw:flex-1">
+            <RevertableField
+              edited={edits.gloss !== undefined}
+              field="gloss"
+              label={localizedStrings['%interlinearizer_analysisCatalog_mergeRevertField%']}
+              onRevert={() => editField('gloss', undefined)}
+            >
+              <Input
+                className="tw:h-7 tw:w-full tw:min-w-0 tw:pe-7 tw:text-sm"
+                data-testid="catalog-merge-content-gloss"
+                id={glossFieldId}
+                onChange={(e) => editField('gloss', e.target.value)}
+                type="text"
+                value={content.gloss}
+              />
+            </RevertableField>
+          </div>
+        </div>
+
+        {/* Boxed as the row editor's breakdown is, so the forms and their glosses read as one unit
+            wherever a breakdown is edited. */}
+        {showMorphology && (
+          <div className="tw:flex tw:w-fit tw:max-w-full tw:flex-col tw:gap-1.5">
+            {/* The breakdown is edited where it is shown: clicking a form opens the editor, rather
+                than a separate field naming the same rows again. */}
+            <div className="tw:flex tw:items-center tw:gap-1">
+              <Popover open={breakdownDraft !== undefined}>
+                {content.morphemes.length === 0 ? (
+                  // Nothing split yet, so there is no forms row to click.
+                  <PopoverAnchor asChild>
+                    <Button
+                      aria-label={formatReplacementString(
+                        localizedStrings['%interlinearizer_analysisCatalog_editMorphemesOpen%'],
+                        { form: surfaceText },
+                      )}
+                      className="tw:h-auto tw:w-fit tw:px-1 tw:py-0 tw:font-mono tw:text-xs"
+                      data-testid="catalog-merge-breakdown-open"
+                      onClick={() => setBreakdownDraft(surfaceText)}
+                      size="sm"
+                      type="button"
+                      variant="link"
+                    >
+                      {surfaceText}
+                    </Button>
+                  </PopoverAnchor>
+                ) : (
+                  <MorphemeBox
+                    analysisLanguage={analysisLanguage}
+                    disabled={false}
+                    glossTestId="catalog-merge-content-morpheme-gloss"
+                    morphemeTestId="catalog-merge-content-morpheme"
+                    readOnly={false}
+                    morphemes={content.morphemes}
+                    onEditBreakdown={() =>
+                      setBreakdownDraft(content.morphemes.map((m) => m.form).join(' '))
+                    }
+                    popoverOpen={breakdownDraft !== undefined}
+                    rowLabels={{
+                      forms: localizedStrings['%interlinearizer_analysisCatalog_editMorphemes%'],
+                      glosses:
+                        localizedStrings['%interlinearizer_analysisCatalog_mergeMorphemeGlosses%'],
+                    }}
+                    surfaceText={surfaceText}
+                    renderGloss={(morpheme, index) => {
+                      const glossEdits = edits.morphemeGlosses ?? {};
+                      return (
+                        <div className="tw:relative">
+                          <Input
+                            aria-label={
+                              resolvedOrEmpty(
+                                formatReplacementString(
+                                  localizedStrings[
+                                    '%interlinearizer_analysisCatalog_morphemeGloss%'
+                                  ],
+                                  { form: morpheme.form },
+                                ),
+                              ) || undefined
+                            }
+                            className="tw:h-7 tw:pe-7 tw:text-sm"
+                            data-testid="catalog-merge-content-morpheme-gloss"
+                            onChange={(e) =>
+                              editField('morphemeGlosses', {
+                                ...glossEdits,
+                                [index]: e.target.value,
+                              })
+                            }
+                            // Sized to the gloss it holds, so a row of them is as wide as its contents
+                            // rather than sharing out room none asked for; the floor keeps an empty
+                            // field clickable.
+                            style={{ fieldSizing: 'content', minWidth: '6ch' }}
+                            type="text"
+                            value={morpheme.gloss?.[analysisLanguage] ?? ''}
+                          />
+                          <InlineRevertButton
+                            edited={glossEdits[index] !== undefined}
+                            label={formatReplacementString(
+                              localizedStrings[
+                                '%interlinearizer_analysisCatalog_mergeClearMorphemeGloss%'
+                              ],
+                              { form: morpheme.form },
+                            )}
+                            onRevert={() =>
+                              editField(
+                                'morphemeGlosses',
+                                // The one morpheme's edit dropped, the rest of them standing; emptied
+                                // of every edit the field is untouched again.
+                                Object.fromEntries(
+                                  Object.entries(glossEdits).filter(([at]) => Number(at) !== index),
+                                ),
+                              )
+                            }
+                            testId="catalog-merge-revert-morpheme-gloss"
+                          />
+                        </div>
+                      );
+                    }}
+                  />
+                )}
+                {breakdownDraft !== undefined && (
+                  <MorphemeBreakdownPopover
+                    draft={breakdownDraft}
+                    initialValue={content.morphemes.map((m) => m.form).join(' ') || surfaceText}
+                    labels={breakdownLabels}
+                    morphemes={content.morphemes}
+                    needsResetConfirm={content.morphemes.some(morphemeCarriesAnnotation)}
+                    onClose={() => setBreakdownDraft(undefined)}
+                    onDraftChange={(draft) => setBreakdownDraft(draft)}
+                    onReset={content.morphemes.length > 0 ? () => resplitTo([]) : undefined}
+                    // Staged like every other field here; the merge commits it.
+                    onSave={(value) => resplitTo(breakdownDraftForms(value))}
+                  />
+                )}
+              </Popover>
+              {edits.morphemeForms !== undefined && (
+                <Button
+                  aria-label={
+                    localizedStrings['%interlinearizer_analysisCatalog_mergeRevertField%']
+                  }
+                  className="tw:size-5 tw:shrink-0 tw:text-muted-foreground"
+                  data-testid="catalog-merge-revert-morphemeForms"
+                  // Taking the re-split back returns the derived breakdown, so the gloss edits move
+                  // with it rather than staying at the places the re-split gave them.
+                  onClick={() =>
+                    restageGlossEdits(
+                      deriveBreakdown(order, checked).map((m) => m.form),
+                      false,
+                    )
+                  }
+                  size="icon"
+                  type="button"
+                  variant="ghost"
+                >
+                  <X aria-hidden className="tw:size-3.5" />
+                </Button>
+              )}
+            </div>
+          </div>
+        )}
+
+        {/* The field a reader settles after the gloss and its breakdown, set smaller so it does not
+            read as the decision the panel is about. */}
+        <div className="tw:flex tw:items-center tw:gap-3">
+          <span className={FIELD_LABEL_CLASS}>
+            {localizedStrings['%interlinearizer_analysisCatalog_mergeConfidence%']}
+          </span>
+          <Select
+            onValueChange={(value) => editField('confidence', confidenceChoice(value) ?? CLEARED)}
+            value={content.confidence ?? NO_CONFIDENCE}
+          >
+            <SelectTrigger
+              aria-label={localizedStrings['%interlinearizer_analysisCatalog_mergeConfidence%']}
+              className="tw:h-6 tw:text-xs"
+              data-testid="catalog-merge-content-confidence"
+              size="sm"
+            >
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem data-testid="catalog-merge-confidence-none" value={NO_CONFIDENCE}>
+                {localizedStrings['%interlinearizer_analysisCatalog_mergeConfidenceNone%']}
+              </SelectItem>
+              {CONFIDENCE_LEVELS.map((level) => (
+                <SelectItem
+                  data-testid={`catalog-merge-confidence-${level}`}
+                  key={level}
+                  value={level}
+                >
+                  {localizedStrings[CONFIDENCE_LABEL_KEYS[level]]}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+          {/* Beside the select rather than inside it, a select having no room to overlay one. */}
+          {edits.confidence !== undefined && (
+            <Button
+              aria-label={localizedStrings['%interlinearizer_analysisCatalog_mergeRevertField%']}
+              className="tw:size-7 tw:shrink-0 tw:text-muted-foreground"
+              data-testid="catalog-merge-revert-confidence"
+              onClick={() => editField('confidence', undefined)}
+              size="icon"
+              type="button"
+              variant="ghost"
+            >
+              <X aria-hidden className="tw:size-3.5" />
+            </Button>
+          )}
+        </div>
+      </div>
+
+      {verdict.reason === 'will-collapse' && (
+        <p
+          className="tw:mt-3 tw:text-xs tw:text-muted-foreground"
+          data-testid="catalog-merge-collapse-warning"
+        >
+          {formatReplacementString(
+            localizedStrings['%interlinearizer_analysisCatalog_mergeWillCollapse%'],
+            { gloss: collapsingGloss },
+          )}
+        </p>
+      )}
+
+      <DndContext collisionDetection={closestCenter} onDragEnd={handleDragEnd} sensors={sensors}>
+        <SortableContext items={listedIds} strategy={verticalListSortingStrategy}>
+          <ul className="tw:mt-4 tw:flex tw:max-h-[40vh] tw:flex-col tw:gap-1.5 tw:overflow-y-auto">
+            {order.map((candidate) => (
+              <SortableCandidate
+                key={candidate.analysisId}
+                candidate={candidate}
+                isSurvivor={candidate.analysisId === survivor.analysisId}
+                localizedStrings={localizedStrings}
+                analysisLanguage={analysisLanguage}
+                merged={checked.has(candidate.analysisId)}
+                noGloss={noGloss}
+                onMergedChange={(value) => setMerged(candidate.analysisId, value)}
+                onPromote={() => applyReorder(candidate.analysisId, 0)}
+                surfaceText={surfaceText}
+              />
+            ))}
+          </ul>
+        </SortableContext>
+      </DndContext>
+
+      <div className="tw:mt-4 tw:flex tw:justify-end tw:gap-2">
+        {/* Offered only once there is something to undo, beside the buttons that end the whole
+            decision rather than among the fields it takes back. */}
+        {Object.keys(edits).length > 0 && (
+          <Button
+            className="tw:me-auto"
+            data-testid="catalog-merge-reset"
+            onClick={() => setEdits({})}
+            size="sm"
+            type="button"
+            variant="ghost"
+          >
+            {localizedStrings['%interlinearizer_analysisCatalog_mergeReset%']}
+          </Button>
+        )}
+        <Button data-testid="catalog-merge-cancel" onClick={onCancel} variant="outline">
+          {localizedStrings['%interlinearizer_analysisCatalog_mergeCancel%']}
+        </Button>
+        <Button
+          data-testid="catalog-merge-confirm"
+          disabled={!verdict.canConfirm}
+          onClick={() =>
+            onConfirm(
+              survivor.analysisId,
+              order
+                .filter((r) => r !== survivor && mergedIds.has(r.analysisId))
+                .map((r) => r.analysisId),
+              content,
+              surfaceText,
+            )
+          }
+        >
+          {localizedStrings['%interlinearizer_analysisCatalog_mergeConfirm%']}
+        </Button>
+      </div>
+    </ModalShell>
+  );
+}
diff --git a/src/components/CatalogMergeNotice.tsx b/src/components/CatalogMergeNotice.tsx
new file mode 100644
index 000000000..f906b640b
--- /dev/null
+++ b/src/components/CatalogMergeNotice.tsx
@@ -0,0 +1,148 @@
+import { X } from 'lucide-react';
+import { Button } from 'platform-bible-react';
+import { formatReplacementString, type LanguageStrings } from 'platform-bible-utils';
+
+/** Localized string keys the merge notice renders. */
+export const MERGE_NOTICE_STRING_KEYS = [
+  '%interlinearizer_analysisCatalog_merged%',
+  '%interlinearizer_analysisCatalog_mergedNoGloss%',
+  '%interlinearizer_analysisCatalog_mergedDismiss%',
+  '%interlinearizer_analysisCatalog_draftStranded%',
+] as const satisfies `%${string}%`[];
+
+/** What a merge-on-edit left standing, for the notice to name. */
+export interface MergeNotice {
+  /** The surviving analysis's id, which the listing scrolls to. */
+  survivingAnalysisId: string;
+  /** What the survivor reads as, `''` when it carries no gloss in the active language. */
+  survivingGloss: string;
+  /** The survivor's surface form, named in place of the gloss when it has none. */
+  surfaceText: string;
+  /** The survivor's usage count once the collapsed record's tokens joined it. */
+  usageCount: number;
+}
+
+/**
+ * A breakdown draft whose analysis was removed by an edit made outside the panel, for the notice to
+ * report. Carries the form rather than the id, the record it was keyed to being gone.
+ */
+export interface StrandedDraftNotice {
+  /** The removed analysis's surface form, which the notice names it by. */
+  surfaceText: string;
+}
+
+/** Props for {@link CatalogMergeNotice}. */
+type CatalogMergeNoticeProps = Readonly<{
+  notice: MergeNotice;
+  /** Dismisses the notice. */
+  onDismiss: () => void;
+  /** Resolved localizations covering at least {@link MERGE_NOTICE_STRING_KEYS}. */
+  localizedStrings: LanguageStrings;
+}>;
+
+/** Props for {@link NoticeBanner}. */
+type NoticeBannerProps = Readonly<{
+  message: string;
+  /** Dismisses the notice. */
+  onDismiss: () => void;
+  /** Accessible name of the dismiss control. */
+  dismissLabel: string;
+  testId: string;
+}>;
+
+/**
+ * The banner every catalog notice is shown in: a dismissable strip above the listing, announced
+ * after the edit it explains rather than interrupting the field the reader is still in.
+ */
+function NoticeBanner({ message, onDismiss, dismissLabel, testId }: NoticeBannerProps) {
+  return (
+    <div
+      aria-live="polite"
+      className="tw:flex tw:items-center tw:gap-2 tw:border-b tw:border-border tw:bg-accent/50 tw:px-3 tw:py-2"
+      data-testid={testId}
+    >
+      <p className="tw:flex-1 tw:min-w-0 tw:text-xs">{message}</p>
+      <Button
+        aria-label={dismissLabel}
+        data-testid={`${testId}-dismiss`}
+        onClick={onDismiss}
+        size="icon"
+        variant="ghost"
+      >
+        <X className="tw:size-3" />
+      </Button>
+    </div>
+  );
+}
+
+/**
+ * Reports that an edit made outside the panel removed the analysis a breakdown draft was keyed to,
+ * taking the draft with it.
+ *
+ * Reports the loss rather than offering to restore it: nothing else on screen would say where the
+ * work the reader was typing went, and there is no record left to save it against.
+ */
+export function CatalogStrandedDraftNotice({
+  notice,
+  onDismiss,
+  localizedStrings,
+}: Readonly<{
+  notice: StrandedDraftNotice;
+  /** Dismisses the notice. */
+  onDismiss: () => void;
+  /** Resolved localizations covering at least {@link MERGE_NOTICE_STRING_KEYS}. */
+  localizedStrings: LanguageStrings;
+}>) {
+  return (
+    <NoticeBanner
+      dismissLabel={localizedStrings['%interlinearizer_analysisCatalog_mergedDismiss%']}
+      message={formatReplacementString(
+        localizedStrings['%interlinearizer_analysisCatalog_draftStranded%'],
+        { form: notice.surfaceText },
+      )}
+      onDismiss={onDismiss}
+      testId="catalog-stranded-draft-notice"
+    />
+  );
+}
+
+/**
+ * Reports that an edit collapsed one row into another, naming where the edit went and what the
+ * surviving row now counts.
+ *
+ * Without this the row the reader was editing simply disappears while an unrelated row's count
+ * jumps, which reads as data loss rather than as the convergence it is. It persists until dismissed
+ * or superseded rather than fading, because the reader may be looking anywhere in the list when
+ * their edit commits.
+ *
+ * Reaches a screen reader after the edit it explains rather than interrupting the field the reader
+ * is still in.
+ */
+export default function CatalogMergeNotice({
+  notice,
+  onDismiss,
+  localizedStrings,
+}: CatalogMergeNoticeProps) {
+  const { survivingGloss, surfaceText, usageCount } = notice;
+
+  // Named by its gloss where it has one, since that is what the reader was editing toward; by its
+  // form otherwise, a notice that named neither leaving nothing to recognize the row by.
+  const message = survivingGloss
+    ? formatReplacementString(localizedStrings['%interlinearizer_analysisCatalog_merged%'], {
+        gloss: survivingGloss,
+        count: usageCount,
+      })
+    : formatReplacementString(localizedStrings['%interlinearizer_analysisCatalog_mergedNoGloss%'], {
+        form: surfaceText,
+        count: usageCount,
+      });
+
+  return (
+    <NoticeBanner
+      dismissLabel={localizedStrings['%interlinearizer_analysisCatalog_mergedDismiss%']}
+      message={message}
+      onDismiss={onDismiss}
+      testId="catalog-merge-notice"
+    />
+  );
+}
diff --git a/src/components/CatalogRowEditor.tsx b/src/components/CatalogRowEditor.tsx
new file mode 100644
index 000000000..0f6772d65
--- /dev/null
+++ b/src/components/CatalogRowEditor.tsx
@@ -0,0 +1,417 @@
+import type { MorphemeAnalysis } from 'interlinearizer';
+import { Button, Input, Label, Popover, PopoverAnchor } from 'platform-bible-react';
+import { formatReplacementString, type LanguageStrings } from 'platform-bible-utils';
+import { useId, useState } from 'react';
+import { MorphemeBox } from './MorphemeBox';
+import { MorphemeBreakdownPopover, type MorphemeEditorLabels } from './MorphemeEditor';
+import { morphemeCarriesAnnotation } from '../utils/analysis-identity';
+import { resolvedOrEmpty } from '../utils/localized-strings';
+import { useAnalysisReadOnly, useReportGlossEditing } from './AnalysisStore';
+
+/** Localized string keys the row editor renders. */
+export const ROW_EDITOR_STRING_KEYS = [
+  '%interlinearizer_analysisCatalog_editGloss%',
+  '%interlinearizer_analysisCatalog_editMorphemes%',
+  '%interlinearizer_analysisCatalog_editMorphemesHint%',
+  '%interlinearizer_analysisCatalog_editMorphemesSave%',
+  '%interlinearizer_analysisCatalog_editMorphemesCancel%',
+  '%interlinearizer_analysisCatalog_editMorphemesReset%',
+  '%interlinearizer_analysisCatalog_editMorphemesOpen%',
+  '%interlinearizer_analysisCatalog_confirmResetPrompt%',
+  '%interlinearizer_analysisCatalog_confirmResetAction%',
+  '%interlinearizer_analysisCatalog_confirmResplitPrompt%',
+  '%interlinearizer_analysisCatalog_confirmResplitAction%',
+  '%interlinearizer_analysisCatalog_morphemeGloss%',
+  '%interlinearizer_analysisCatalog_morphemeNoGloss%',
+  '%interlinearizer_analysisCatalog_noGloss%',
+  '%interlinearizer_analysisCatalog_appliesToAll%',
+  '%interlinearizer_analysisCatalog_merge%',
+  '%interlinearizer_analysisCatalog_delete%',
+] as const satisfies `%${string}%`[];
+
+/** Props for {@link CatalogRowEditor}. */
+type CatalogRowEditorProps = Readonly<{
+  analysisId: string;
+  /** Surface form of the analysis, which the breakdown editor pre-fills from when there is none. */
+  surfaceText: string;
+  /** The analysis's gloss in the active language, `''` when it has none. */
+  gloss: string;
+  /** How many tokens this analysis is applied to, which every edit here rewrites at once. */
+  usageCount: number;
+  morphemes: readonly MorphemeAnalysis[];
+  /** BCP 47 tag the morpheme glosses are read and written under. */
+  analysisLanguage: string;
+  /** When false, the breakdown is not shown at all, as the view option hides it on the strip. */
+  showMorphology: boolean;
+  /** Writes the analysis's gloss for every token linked to it. */
+  onGlossCommit: (value: string) => void;
+  /** Replaces the analysis's morpheme breakdown for every token linked to it. */
+  onMorphemesCommit: (forms: readonly string[]) => void;
+  /** Writes one morpheme's gloss for every token linked to the analysis. */
+  onMorphemeGlossCommit: (morphemeId: string, value: string) => void;
+  /**
+   * The breakdown draft, or `undefined` while the breakdown editor is closed. Held by the caller,
+   * which outlives this editor's own mounting.
+   */
+  breakdownDraft: string | undefined;
+  /** Records the breakdown draft, `undefined` closing the breakdown editor. */
+  onBreakdownDraftChange: (draft: string | undefined) => void;
+  /** Resolved localizations covering at least {@link ROW_EDITOR_STRING_KEYS}. */
+  localizedStrings: LanguageStrings;
+}>;
+
+/** Collapses leading, trailing, and repeated internal whitespace to single spaces. */
+function normalize(value: string): string {
+  return value.trim().replace(/\s+/g, ' ');
+}
+
+/**
+ * The forms a breakdown draft reads as, empty for a draft with nothing in it. A lone form equal to
+ * the whole word is a one-morpheme analysis, not a request for the unsegmented state, which has its
+ * own control.
+ */
+export function breakdownDraftForms(draft: string): string[] {
+  const normalized = normalize(draft);
+  return normalized === '' ? [] : normalized.split(' ');
+}
+
+/**
+ * The note above the fields, naming how many tokens an edit here rewrites — the count being the one
+ * thing a row gives no other clue about. Absent below two uses, which an edit reaches no further
+ * than the row it is made on.
+ */
+function appliesToAllMessage(
+  usageCount: number,
+  localizedStrings: LanguageStrings,
+): string | undefined {
+  if (usageCount < 2) return undefined;
+  return formatReplacementString(
+    localizedStrings['%interlinearizer_analysisCatalog_appliesToAll%'],
+    { count: usageCount },
+  );
+}
+
+/**
+ * A text field whose edit commits on blur and on Enter, and reverts on Escape, holding its draft
+ * locally until then.
+ *
+ * Committing on blur rather than per keystroke is what the gloss inputs in the interlinear view do,
+ * and it matters more here: every keystroke would be a write across every token the analysis holds,
+ * and an edit passing through a state identical to a sibling would collapse the row mid-word.
+ *
+ * The draft is keyed on the committed value, so a row re-rendered under a different analysis — the
+ * listing reorders under an edit — refills rather than showing the previous row's text.
+ */
+function CommitOnBlurInput({
+  ariaLabel,
+  committedValue,
+  id,
+  onCommit,
+  testId,
+}: Readonly<{
+  ariaLabel?: string;
+  committedValue: string;
+  id?: string;
+  onCommit: (value: string) => void;
+  testId: string;
+}>) {
+  const [draft, setDraft] = useState(committedValue);
+  const [draftOf, setDraftOf] = useState(committedValue);
+
+  // Adjusted during render rather than in an effect, so the field never paints one frame holding
+  // the previous value.
+  if (committedValue !== draftOf) {
+    setDraftOf(committedValue);
+    setDraft(committedValue);
+  }
+
+  const commit = () => {
+    if (draft !== committedValue) onCommit(draft);
+  };
+
+  // Surface uncommitted typing to the unsaved indicator before the edit commits on blur, and flush
+  // the draft if the field unmounts mid-edit.
+  useReportGlossEditing(draft !== committedValue, commit);
+
+  return (
+    <Input
+      aria-label={ariaLabel}
+      // Overrides the platform input's intrinsic minimum width, which a long gloss would otherwise
+      // push past its column and over the neighboring field.
+      className="tw:h-7 tw:w-full tw:min-w-0 tw:text-sm"
+      data-testid={testId}
+      id={id}
+      onBlur={commit}
+      onChange={(e) => setDraft(e.target.value)}
+      onKeyDown={(e) => {
+        if (e.key === 'Enter') {
+          e.preventDefault();
+          commit();
+        } else if (e.key === 'Escape') {
+          e.preventDefault();
+          setDraft(committedValue);
+        }
+      }}
+      type="text"
+      value={draft}
+    />
+  );
+}
+
+/**
+ * The editable half of an expanded catalog row: the analysis's gloss, its morpheme breakdown and
+ * each morpheme's gloss. The controls acting on the analysis as a whole are
+ * {@link CatalogRowActions}.
+ *
+ * Every write here is keyed by the analysis rather than by a token, so it changes what the record
+ * says everywhere it is used — which the note above the fields says outright once more than one
+ * token is holding it.
+ *
+ * The breakdown is edited as a line of space-separated forms, as the interlinear view's morpheme
+ * editor does, so the same input reads the same in both places. It is behind its own toggle because
+ * committing it discards the old morphemes' annotation, which is not an edit to make by tabbing
+ * past.
+ *
+ * A read-only analysis renders the same fields as static text, matching what the interlinear view
+ * does with the same store.
+ */
+export default function CatalogRowEditor({
+  analysisId,
+  surfaceText,
+  gloss,
+  usageCount,
+  morphemes,
+  analysisLanguage,
+  showMorphology,
+  onGlossCommit,
+  onMorphemesCommit,
+  onMorphemeGlossCommit,
+  breakdownDraft,
+  onBreakdownDraftChange,
+  localizedStrings,
+}: CatalogRowEditorProps) {
+  const glossFieldId = useId();
+  const readOnly = useAnalysisReadOnly();
+
+  const morphemeForms = morphemes.map((m) => m.form).join(' ');
+
+  const appliesToAll = appliesToAllMessage(usageCount, localizedStrings);
+
+  // Wording for the shared breakdown editor: every prompt here speaks of the analysis and its
+  // uses, where the token chip's speaks of the one word in hand.
+  const breakdownLabels: MorphemeEditorLabels = {
+    splitLabel: localizedStrings['%interlinearizer_analysisCatalog_editMorphemes%'],
+    reset: localizedStrings['%interlinearizer_analysisCatalog_editMorphemesReset%'],
+    cancel: localizedStrings['%interlinearizer_analysisCatalog_editMorphemesCancel%'],
+    done: localizedStrings['%interlinearizer_analysisCatalog_editMorphemesSave%'],
+    emptyHint: localizedStrings['%interlinearizer_analysisCatalog_editMorphemesHint%'],
+    confirmResetPrompt: formatReplacementString(
+      localizedStrings['%interlinearizer_analysisCatalog_confirmResetPrompt%'],
+      { form: surfaceText },
+    ),
+    confirmResetAction: localizedStrings['%interlinearizer_analysisCatalog_confirmResetAction%'],
+    confirmResplitPrompt:
+      localizedStrings['%interlinearizer_analysisCatalog_confirmResplitPrompt%'],
+    confirmResplitAction:
+      localizedStrings['%interlinearizer_analysisCatalog_confirmResplitAction%'],
+  };
+
+  // A read-only analysis shows what the record says and nothing that would rewrite it, the note
+  // about an edit reaching every use included.
+  if (readOnly)
+    return (
+      <div className="tw:flex tw:flex-col tw:gap-3 tw:pt-1" data-testid="catalog-row-editor">
+        <div className="tw:flex tw:items-center tw:gap-2">
+          <span className="tw:text-xs tw:text-muted-foreground">
+            {localizedStrings['%interlinearizer_analysisCatalog_editGloss%']}
+          </span>
+          <span className="tw:flex-1 tw:min-w-0 tw:text-sm" data-testid="readonly-catalog-gloss">
+            {gloss ||
+              resolvedOrEmpty(localizedStrings['%interlinearizer_analysisCatalog_noGloss%']) ||
+              '—'}
+          </span>
+        </div>
+
+        {/* The same labeled box the editable row shows, so switching between a read-only and an
+            editable analysis does not rearrange the breakdown. */}
+        {showMorphology && morphemes.length > 0 && (
+          <div className="tw:flex tw:max-w-fit tw:flex-col tw:gap-1.5 tw:overflow-x-auto">
+            <Popover>
+              <MorphemeBox
+                analysisLanguage={analysisLanguage}
+                disabled
+                glossTestId="readonly-catalog-morpheme-gloss"
+                morphemeTestId="catalog-row-morpheme"
+                morphemes={morphemes}
+                noGlossLabel={localizedStrings['%interlinearizer_analysisCatalog_morphemeNoGloss%']}
+                popoverOpen={false}
+                readOnly
+                rowLabels={{
+                  forms: localizedStrings['%interlinearizer_analysisCatalog_editMorphemes%'],
+                  glosses:
+                    localizedStrings['%interlinearizer_analysisCatalog_mergeMorphemeGlosses%'],
+                }}
+                surfaceText={surfaceText}
+              />
+            </Popover>
+          </div>
+        )}
+      </div>
+    );
+
+  return (
+    <div className="tw:flex tw:flex-col tw:gap-3 tw:pt-1" data-testid="catalog-row-editor">
+      {appliesToAll && (
+        <p className="tw:text-xs tw:text-muted-foreground" data-testid="catalog-row-applies-to-all">
+          {appliesToAll}
+        </p>
+      )}
+
+      <div className="tw:flex tw:items-center tw:gap-2">
+        <Label className="tw:text-xs tw:text-muted-foreground" htmlFor={glossFieldId}>
+          {localizedStrings['%interlinearizer_analysisCatalog_editGloss%']}
+        </Label>
+        <div className="tw:flex-1 tw:min-w-0">
+          <CommitOnBlurInput
+            committedValue={gloss}
+            id={glossFieldId}
+            key={`${analysisId}-gloss`}
+            onCommit={onGlossCommit}
+            testId="catalog-row-gloss-input"
+          />
+        </div>
+      </div>
+
+      {/* The forms row is the control that opens the editor. Labeled, there being no surrounding
+          interlinear line here to say what the two rows are. */}
+      {showMorphology && (
+        <Popover open={breakdownDraft !== undefined}>
+          {morphemes.length === 0 ? (
+            // Nothing split yet, so there is no forms row to click; the chip's define-breakdown
+            // affordance stands in, naming the word it would split.
+            <PopoverAnchor asChild>
+              <Button
+                aria-label={formatReplacementString(
+                  localizedStrings['%interlinearizer_analysisCatalog_editMorphemesOpen%'],
+                  { form: surfaceText },
+                )}
+                className="tw:h-auto tw:px-1 tw:py-0 tw:font-mono tw:text-xs"
+                data-testid="catalog-row-breakdown-open"
+                onClick={() => onBreakdownDraftChange(morphemeForms || surfaceText)}
+                size="sm"
+                type="button"
+                variant="link"
+              >
+                {surfaceText}
+              </Button>
+            </PopoverAnchor>
+          ) : (
+            // The box has a width it will not go below, which a narrow panel cannot always afford.
+            <div className="tw:overflow-x-auto">
+              <MorphemeBox
+                analysisLanguage={analysisLanguage}
+                disabled={false}
+                glossTestId="catalog-row-morpheme-gloss-input"
+                morphemeTestId="catalog-row-morpheme"
+                readOnly={false}
+                morphemes={morphemes}
+                // The box renders only with a breakdown, so the forms are never the empty string the
+                // define-breakdown control has to fall back from.
+                onEditBreakdown={() => onBreakdownDraftChange(morphemeForms)}
+                popoverOpen={breakdownDraft !== undefined}
+                renderGloss={(morpheme) => (
+                  <CommitOnBlurInput
+                    ariaLabel={
+                      resolvedOrEmpty(
+                        formatReplacementString(
+                          localizedStrings['%interlinearizer_analysisCatalog_morphemeGloss%'],
+                          { form: morpheme.form },
+                        ),
+                      ) || undefined
+                    }
+                    committedValue={morpheme.gloss?.[analysisLanguage] ?? ''}
+                    key={`${analysisId}-${morpheme.id}`}
+                    onCommit={(value) => onMorphemeGlossCommit(morpheme.id, value)}
+                    testId="catalog-row-morpheme-gloss-input"
+                  />
+                )}
+                rowLabels={{
+                  forms: localizedStrings['%interlinearizer_analysisCatalog_editMorphemes%'],
+                  glosses:
+                    localizedStrings['%interlinearizer_analysisCatalog_mergeMorphemeGlosses%'],
+                }}
+                surfaceText={surfaceText}
+              />
+            </div>
+          )}
+          {breakdownDraft !== undefined && (
+            <MorphemeBreakdownPopover
+              draft={breakdownDraft}
+              initialValue={morphemeForms || surfaceText}
+              labels={breakdownLabels}
+              // Never withheld, unlike the token chip's: the record is rewritten in place for every
+              // token holding it, so a form this drops has no copy left to survive on.
+              morphemes={morphemes}
+              needsResetConfirm={morphemes.some(morphemeCarriesAnnotation)}
+              onClose={() => onBreakdownDraftChange(undefined)}
+              onDraftChange={(draft) => onBreakdownDraftChange(draft)}
+              onReset={morphemes.length > 0 ? () => onMorphemesCommit([]) : undefined}
+              onSave={(value) => onMorphemesCommit(breakdownDraftForms(value))}
+            />
+          )}
+        </Popover>
+      )}
+    </div>
+  );
+}
+
+/**
+ * The controls that act on a whole analysis rather than on one of its fields.
+ *
+ * Renders nothing for a read-only analysis, which neither control applies to.
+ */
+export function CatalogRowActions({
+  onMergeRequest,
+  onDeleteRequest,
+  localizedStrings,
+}: Readonly<{
+  /** Opens the merge picker. Absent when the analysis shares its form with no other record. */
+  onMergeRequest?: () => void;
+  /** Opens the delete confirmation. */
+  onDeleteRequest: () => void;
+  /** Resolved localizations covering at least {@link ROW_EDITOR_STRING_KEYS}. */
+  localizedStrings: LanguageStrings;
+}>) {
+  const readOnly = useAnalysisReadOnly();
+  if (readOnly) return undefined;
+
+  return (
+    <div className="tw:flex tw:gap-1.5">
+      {/*
+        Offered only when the analysis has homographs: with none there is nothing a merge could
+        reassign its tokens to, and a control that opens an empty picker is worse than no control.
+      */}
+      {onMergeRequest && (
+        <Button
+          data-testid="catalog-row-merge"
+          onClick={onMergeRequest}
+          size="sm"
+          type="button"
+          variant="outline"
+        >
+          {localizedStrings['%interlinearizer_analysisCatalog_merge%']}
+        </Button>
+      )}
+      <Button
+        className="tw:ms-auto tw:text-destructive"
+        data-testid="catalog-row-delete"
+        onClick={onDeleteRequest}
+        size="sm"
+        type="button"
+        variant="outline"
+      >
+        {localizedStrings['%interlinearizer_analysisCatalog_delete%']}
+      </Button>
+    </div>
+  );
+}
diff --git a/src/components/CatalogRowView.tsx b/src/components/CatalogRowView.tsx
index bd77dfe97..ac44ba93e 100644
--- a/src/components/CatalogRowView.tsx
+++ b/src/components/CatalogRowView.tsx
@@ -8,6 +8,7 @@ import {
 } from 'platform-bible-react';
 import { formatReplacementString, formatScrRef, type LanguageStrings } from 'platform-bible-utils';
 import { memo, useCallback, useState } from 'react';
+import CatalogRowEditor, { CatalogRowActions, ROW_EDITOR_STRING_KEYS } from './CatalogRowEditor';
 import type { CatalogRow, CatalogUsage } from '../utils/analysis-query';
 import { resolvedOrEmpty } from '../utils/localized-strings';
 
@@ -21,6 +22,7 @@ export const ROW_STRING_KEYS = [
   '%interlinearizer_analysisCatalog_usageCount%',
   '%interlinearizer_analysisCatalog_noUsages%',
   '%interlinearizer_analysisCatalog_showAllUsages%',
+  ...ROW_EDITOR_STRING_KEYS,
 ] as const satisfies `%${string}%`[];
 
 /**
@@ -43,6 +45,37 @@ type CatalogRowViewProps = Readonly<{
   localizedStrings: LanguageStrings;
   /** BCP 47 tag the morpheme glosses are read under. */
   analysisLanguage: string;
+  /** When false, the row's breakdown is not shown, as the view option hides it on the strip. */
+  showMorphology: boolean;
+  /** Writes this row's gloss for every token linked to it. */
+  onGlossCommit: (analysisId: string, value: string) => void;
+  /** Replaces this row's morpheme breakdown for every token linked to it. */
+  onMorphemesCommit: (analysisId: string, forms: readonly string[]) => void;
+  /** Writes one of this row's morpheme glosses for every token linked to it. */
+  onMorphemeGlossCommit: (analysisId: string, morphemeId: string, value: string) => void;
+  /**
+   * Opens the merge picker for this row. Absent when the analysis shares its form with no other
+   * record, which is how the merge control is withheld from a row with nothing to merge with.
+   */
+  onMergeRequest?: (analysisId: string) => void;
+  /** Opens the delete confirmation for this row. */
+  onDeleteRequest: (analysisId: string) => void;
+  /**
+   * Whether the row should be scrolled into view. Set on the row a merge-on-edit left standing, so
+   * the reader is taken to where their edit went rather than left where it vanished from.
+   */
+  shouldRevealSelf?: boolean;
+  /** This row's breakdown draft, or `undefined` while its breakdown editor is closed. */
+  breakdownDraft: string | undefined;
+  /**
+   * Records this row's breakdown draft, `undefined` closing its breakdown editor. Reports the
+   * analysis's surface form alongside it, which names the draft once its record is gone.
+   */
+  onBreakdownDraftChange: (
+    analysisId: string,
+    draft: string | undefined,
+    surfaceText: string,
+  ) => void;
 }>;
 
 /** Renders a usage's location the way scripture references are written, e.g. `GEN 1:1`. */
@@ -56,8 +89,8 @@ function usageLabel(usage: CatalogUsage): string {
 
 /**
  * One analysis in the catalog: its surface form and gloss, and how much of the draft it accounts
- * for — the whole draft's usage count beside the current book's. Expanding it reveals the morpheme
- * breakdown and the places the analysis is applied.
+ * for — the whole draft's usage count beside the current book's. Expanding it reveals the controls
+ * for editing the analysis and the places it is applied.
  *
  * Each row owns its own layout so that its detail can be nested inside it.
  */
@@ -68,6 +101,15 @@ function CatalogRowView({
   onUsageSelect,
   localizedStrings,
   analysisLanguage,
+  showMorphology,
+  onGlossCommit,
+  onMorphemesCommit,
+  onMorphemeGlossCommit,
+  onMergeRequest,
+  onDeleteRequest,
+  shouldRevealSelf = false,
+  breakdownDraft,
+  onBreakdownDraftChange,
 }: CatalogRowViewProps) {
   const [isExpanded, setIsExpanded] = useState(false);
 
@@ -81,6 +123,35 @@ function CatalogRowView({
     setShowsAllUsages(false);
   }, []);
 
+  // The editor is handed callbacks already carrying this row's id, so it never needs the id itself
+  // to report an edit.
+  const { analysisId } = row;
+  const handleGlossCommit = useCallback(
+    (value: string) => onGlossCommit(analysisId, value),
+    [analysisId, onGlossCommit],
+  );
+  const handleMorphemesCommit = useCallback(
+    (forms: readonly string[]) => onMorphemesCommit(analysisId, forms),
+    [analysisId, onMorphemesCommit],
+  );
+  const handleMorphemeGlossCommit = useCallback(
+    (morphemeId: string, value: string) => onMorphemeGlossCommit(analysisId, morphemeId, value),
+    [analysisId, onMorphemeGlossCommit],
+  );
+  const handleMergeRequest = useCallback(
+    () => onMergeRequest?.(analysisId),
+    [analysisId, onMergeRequest],
+  );
+  const handleDeleteRequest = useCallback(
+    () => onDeleteRequest(analysisId),
+    [analysisId, onDeleteRequest],
+  );
+  const { surfaceText } = row;
+  const handleBreakdownDraftChange = useCallback(
+    (draft: string | undefined) => onBreakdownDraftChange(analysisId, draft, surfaceText),
+    [analysisId, onBreakdownDraftChange, surfaceText],
+  );
+
   const visibleUsages = showsAllUsages ? row.usages : row.usages.slice(0, INLINE_USAGE_LIMIT);
   const hiddenUsageCount = row.usages.length - visibleUsages.length;
 
@@ -98,8 +169,22 @@ function CatalogRowView({
   const surfaceTooltip = useTruncationTooltip<HTMLSpanElement>();
   const glossTooltip = useTruncationTooltip<HTMLSpanElement>();
 
+  /**
+   * Brings the row into view once the panel asks for it, which it does for the row a merge-on-edit
+   * left standing. Runs on the flag turning true rather than on every render, so a reader who then
+   * scrolls away is not dragged back by an unrelated re-render.
+   */
+  const revealRef = useCallback(
+    (el: HTMLLIElement | null) => {
+      /* v8 ignore next -- jsdom implements no layout, so scrollIntoView is absent on the element */
+      if (shouldRevealSelf) el?.scrollIntoView?.({ block: 'nearest' });
+    },
+    [shouldRevealSelf],
+  );
+
   return (
     <li
+      ref={revealRef}
       className={`tw:flex tw:flex-col tw:border-b tw:border-border ${
         isSelected ? 'tw:bg-accent/50' : ''
       }`}
@@ -182,24 +267,21 @@ function CatalogRowView({
           className="tw:flex tw:flex-col tw:gap-2 tw:px-3 tw:pb-2 tw:ps-8"
           data-testid="catalog-row-detail"
         >
-          {row.morphemes.length > 0 && (
-            <div className="tw:flex tw:flex-wrap tw:gap-x-3 tw:gap-y-1">
-              {row.morphemes.map((morpheme) => (
-                // Form above gloss, as the interlinear view arranges them, so a breakdown reads the
-                // same in both places.
-                <div
-                  className="tw:flex tw:flex-col"
-                  data-testid="catalog-row-morpheme"
-                  key={morpheme.id}
-                >
-                  <span className="tw:text-sm">{morpheme.form}</span>
-                  <span className="tw:text-xs tw:text-muted-foreground">
-                    {morpheme.gloss?.[analysisLanguage] ?? ''}
-                  </span>
-                </div>
-              ))}
-            </div>
-          )}
+          <CatalogRowEditor
+            analysisId={row.analysisId}
+            analysisLanguage={analysisLanguage}
+            breakdownDraft={breakdownDraft}
+            gloss={row.gloss}
+            localizedStrings={localizedStrings}
+            morphemes={row.morphemes}
+            showMorphology={showMorphology}
+            onBreakdownDraftChange={handleBreakdownDraftChange}
+            onGlossCommit={handleGlossCommit}
+            onMorphemeGlossCommit={handleMorphemeGlossCommit}
+            onMorphemesCommit={handleMorphemesCommit}
+            surfaceText={row.surfaceText}
+            usageCount={row.usageCount}
+          />
 
           {row.usages.length === 0 ? (
             <p className="tw:text-xs tw:text-muted-foreground">
@@ -235,6 +317,14 @@ function CatalogRowView({
               )}
             </div>
           )}
+
+          {/* Below the usages, so what a merge or delete is about to take is in view above the
+              button taking it. */}
+          <CatalogRowActions
+            localizedStrings={localizedStrings}
+            onDeleteRequest={handleDeleteRequest}
+            onMergeRequest={onMergeRequest ? handleMergeRequest : undefined}
+          />
         </div>
       )}
     </li>
diff --git a/src/components/InterlinearizerLoader.tsx b/src/components/InterlinearizerLoader.tsx
index 0dd80f1a5..8881c63b2 100644
--- a/src/components/InterlinearizerLoader.tsx
+++ b/src/components/InterlinearizerLoader.tsx
@@ -546,6 +546,21 @@ function InterlinearizerLoaderInner({
     [verseBook, segmentationVersion, draftVersion, isDraftLoading, isImportView],
   );
 
+  /** The loaded book's current token text, by ref. */
+  const liveTokensByRef = useMemo(() => {
+    const byRef = new Map<string, string>();
+    book?.segments.forEach((segment) =>
+      segment.tokens.forEach((token) => byRef.set(token.ref, token.surfaceText)),
+    );
+    return byRef;
+  }, [book]);
+
+  /** Reads the loaded book's current text for a ref, `undefined` for one in any other book. */
+  const liveSurfaceText = useCallback(
+    (tokenRef: string) => liveTokensByRef.get(tokenRef),
+    [liveTokensByRef],
+  );
+
   const { undismissedLostBoundaries, onDismiss: handleDismissLostBoundaries } =
     useLostBoundaryDismissal({
       verseBook,
@@ -1258,6 +1273,7 @@ function InterlinearizerLoaderInner({
               // mid-load, and counting against the book being left would relabel every row for
               // the duration.
               currentBook={scrRef.book}
+              liveSurfaceText={liveSurfaceText}
               onClose={handleCatalogClose}
               showMorphology={showMorphology}
               sourceLanguageTag={writingSystem}
diff --git a/src/components/MorphemeBox.tsx b/src/components/MorphemeBox.tsx
index 7f0634a69..6453e7f0b 100644
--- a/src/components/MorphemeBox.tsx
+++ b/src/components/MorphemeBox.tsx
@@ -1,6 +1,14 @@
 import type { MorphemeAnalysis, Token } from 'interlinearizer';
 import { PopoverAnchor } from 'platform-bible-react';
-import { type MouseEvent, useEffect, useState } from 'react';
+import {
+  cloneElement,
+  isValidElement,
+  type CSSProperties,
+  type MouseEvent,
+  type ReactNode,
+  useEffect,
+  useState,
+} from 'react';
 import {
   useAnalysisReadOnly,
   useMorphemeGlossDispatch,
@@ -9,6 +17,9 @@ import {
 import { TOKEN_CHIP_LABEL_KEYS, type TokenChipLabels } from './PhraseStripContext';
 import { formatTemplate } from '../utils/format-template';
 
+/** The narrowest a morpheme column goes, below which its form and gloss stop being legible. */
+const MIN_MORPHEME_COLUMN = '4ch';
+
 /**
  * Inline _display_ of an analyzed token's morpheme breakdown. The popover where forms are actually
  * entered lives separately.
@@ -28,19 +39,33 @@ import { formatTemplate } from '../utils/format-template';
  * Renders the {@link PopoverAnchor} the editor popover is positioned from; the caller owns the
  * `Popover` root and the popover content.
  */
-export function MorphemeBox({
+function MorphemeBoxInner({
   token,
+  surfaceText,
   morphemes,
   analysisLanguage,
   disabled,
   popoverOpen,
   onEditBreakdown,
   onGlossFocus,
+  renderGloss,
+  rowLabels,
+  readOnly,
+  morphemeTestId,
+  glossTestId,
+  noGlossLabel,
+  noBreakdownLabel,
   labels = TOKEN_CHIP_LABEL_KEYS,
 }: Readonly<{
-  /** The analyzed word token whose breakdown is shown. */
-  token: Token & { type: 'word' };
-  /** The token's ordered morpheme breakdown; one grid column per entry. */
+  /**
+   * The analyzed word token whose breakdown is shown, and whose ref each gloss commits against.
+   * Omitted where the breakdown belongs to an analysis rather than to one token, which supplies
+   * `surfaceText` and its own `renderGloss` instead.
+   */
+  token?: Token & { type: 'word' };
+  /** The word the breakdown splits, naming it in the edit control. Defaults to the token's. */
+  surfaceText?: string;
+  /** The ordered morpheme breakdown; one grid column per entry. */
   morphemes: readonly MorphemeAnalysis[];
   /** BCP 47 tag for reading and writing each morpheme gloss. */
   analysisLanguage: string;
@@ -48,14 +73,37 @@ export function MorphemeBox({
   disabled: boolean;
   /** When true, the editor popover is open; the box renders its active look. */
   popoverOpen: boolean;
-  /** Called when a form cell is clicked (while enabled) to open the whole-breakdown editor. */
-  onEditBreakdown: () => void;
+  /**
+   * Called when a form cell is clicked (while enabled) to open the whole-breakdown editor. A
+   * read-only box renders no such control, so it needs none.
+   */
+  onEditBreakdown?: () => void;
   /**
    * Called when any morpheme gloss input receives focus, so the chip can report the token as
    * focused; these fields are gloss fields of the same token as the chip's own gloss input, so
    * focusing one must move the view's focus just as focusing that input does.
    */
-  onGlossFocus: () => void;
+  onGlossFocus?: () => void;
+  /**
+   * Renders the gloss cell for one morpheme. Omitted, each gloss is a token-keyed input committing
+   * through the analysis store; supplying one commits against the analysis instead.
+   */
+  renderGloss?: (morpheme: MorphemeAnalysis, index: number) => ReactNode;
+  /** Names the two rows. Omitted, neither is labeled. */
+  rowLabels?: Readonly<{ forms: string; glosses: string }>;
+  /** Whether the breakdown is shown without the affordances that edit it. */
+  readOnly: boolean;
+  /** `data-testid` marking each morpheme's form cell. */
+  morphemeTestId?: string;
+  /** `data-testid` marking each column's gloss cell. */
+  glossTestId?: string;
+  /**
+   * Stands in for a morpheme carrying no gloss, where the breakdown is read-only. An editable one
+   * shows a field there, which reads as waiting to be filled rather than as a gap.
+   */
+  noGlossLabel?: string;
+  /** Shown where the analysis segments nothing. Omitted, nothing renders in that case. */
+  noBreakdownLabel?: string;
   /**
    * Accessible labels for this box and its gloss inputs, resolved once per strip. Defaults to the
    * unresolved keys, which is what they show until the strip's lookup lands.
@@ -67,112 +115,192 @@ export function MorphemeBox({
   // on the container (rather than per cell) avoids a one-frame un-tint as the pointer crosses the
   // gap between adjacent form cells.
   const [isFormsHovered, setIsFormsHovered] = useState(false);
-  const readOnly = useAnalysisReadOnly();
-  // Read-only renders the same grid without the editor affordance: no edit-breakdown control,
-  // no hover tint, and static gloss text under each form.
   const inert = disabled || readOnly;
 
-  const editLabel = formatTemplate(labels.editMorphemes, { token: token.surfaceText });
+  /* v8 ignore next -- a token or a surface text is always supplied */
+  const word = surfaceText ?? token?.surfaceText ?? '';
+  const editLabel = formatTemplate(labels.editMorphemes, { token: word });
+
+  const formTestId = morphemeTestId ?? (readOnly ? 'readonly-morpheme-form' : 'morpheme-form');
+  const cellGlossTestId = glossTestId ?? (readOnly ? 'readonly-morpheme-gloss' : 'morpheme-gloss');
+
+  if (morphemes.length === 0)
+    return noBreakdownLabel ? (
+      <span
+        className="tw:text-sm tw:italic tw:text-muted-foreground"
+        data-testid={`${formTestId}-none`}
+      >
+        {noBreakdownLabel}
+      </span>
+    ) : undefined;
+
+  // Labels are the grid's first column, each sharing a row track with the cells it names so the two
+  // line up by construction. The token strip passes none and gets the bare box.
+  const labelTrack = rowLabels ? 'auto ' : '';
+  const firstCell = rowLabels ? 2 : 1;
+
+  /** One morpheme's form cell, which read-only renders as static text. */
+  const formCell = (m: MorphemeAnalysis, i: number) => {
+    const placement = { gridColumn: firstCell + i, gridRow: 1 };
+    if (readOnly)
+      return (
+        <span
+          className="tw:flex tw:items-center tw:justify-center tw:truncate tw:whitespace-nowrap tw:px-0.5 tw:font-mono tw:text-xs tw:text-muted-foreground"
+          data-testid={formTestId}
+          key={m.id}
+          style={placement}
+        >
+          {m.form}
+        </span>
+      );
+
+    const formClassName = `tw:flex tw:items-center tw:justify-center tw:whitespace-nowrap tw:rounded tw:px-0.5 tw:font-mono tw:text-xs tw:text-muted-foreground tw:transition-colors${inert ? '' : ' tw:cursor-pointer'}${isFormsHovered && !inert ? ' tw:bg-accent' : ''}`;
+    // preventDefault stops the ancestor label from forwarding the click to the gloss input, where
+    // the focus would dismiss the editor this same click opens.
+    const handleClick = (e: MouseEvent) => {
+      e.preventDefault();
+      if (!inert) onEditBreakdown?.();
+    };
+
+    // The first cell is the single accessible "edit breakdown" control (a real button); the rest
+    // share its click and hover behavior but carry no button semantics, so assistive tech sees one
+    // control for the whole breakdown.
+    if (i === 0)
+      return (
+        <button
+          aria-label={editLabel}
+          className={formClassName}
+          data-testid={formTestId}
+          key={m.id}
+          style={placement}
+          tabIndex={-1}
+          type="button"
+          onClick={handleClick}
+        >
+          {m.form}
+        </button>
+      );
+
+    return (
+      <span
+        aria-hidden="true"
+        className={formClassName}
+        data-testid={formTestId}
+        key={m.id}
+        onClick={handleClick}
+        // A span, unlike the first cell's button, is subject to two mouse-down focus moves that
+        // would land outside the just-opened editor and dismiss it: the browser's label-to-control
+        // forwarding, and the ancestor label's own handler.
+        onMouseDown={(e) => {
+          e.preventDefault();
+          e.stopPropagation();
+        }}
+        style={placement}
+      >
+        {m.form}
+      </span>
+    );
+  };
+
+  /**
+   * One morpheme's gloss cell: the caller's own where it owns the commit path, otherwise the
+   * token-keyed input that writes through the analysis store, or static text when read-only.
+   */
+  const glossCell = (m: MorphemeAnalysis, i: number) => {
+    const placement = { gridColumn: firstCell + i, gridRow: 2 };
+    if (renderGloss) {
+      const cell = renderGloss(m, i);
+      /* v8 ignore next -- every caller returns an element; the guard satisfies cloneElement's type */
+      if (!isValidElement<{ style?: CSSProperties }>(cell)) return cell;
+      // Placed on the caller's own element rather than a wrapper: a wrapper between a cell and the
+      // grid takes the click first, reintroducing the label forwarding the form cells cancel.
+      return cloneElement(cell, { key: m.id, style: { ...cell.props.style, ...placement } });
+    }
+
+    if (readOnly) {
+      const gloss = m.gloss?.[analysisLanguage];
+      return (
+        <span
+          className={`tw:truncate tw:px-1 tw:text-center tw:text-xs tw:text-foreground${gloss ? '' : ' tw:italic tw:text-muted-foreground'}`}
+          data-testid={cellGlossTestId}
+          key={m.id}
+          style={{ ...placement, minWidth: '2ch' }}
+        >
+          {gloss || noGlossLabel || ''}
+        </span>
+      );
+    }
+
+    return (
+      <MorphemeGlossInput
+        analysisLanguage={analysisLanguage}
+        column={firstCell + i}
+        disabled={disabled}
+        glossLabelTemplate={labels.morphemeGloss}
+        key={m.id}
+        morpheme={m}
+        /* v8 ignore next 2 -- both are supplied wherever this input renders */
+        onFocus={onGlossFocus ?? (() => {})}
+        tokenRef={token?.ref ?? ''}
+      />
+    );
+  };
 
   return (
     <PopoverAnchor asChild>
       <div
         className={`tw:morphology-slot tw:border-border tw:bg-background${popoverOpen ? ' tw:ring-1 tw:ring-ring' : ''}`}
-        style={{ gridTemplateColumns: `repeat(${morphemes.length}, minmax(1ch, auto))` }}
-        onMouseEnter={() => setIsFormsHovered(true)}
-        onMouseLeave={() => setIsFormsHovered(false)}
+        onMouseEnter={readOnly ? undefined : () => setIsFormsHovered(true)}
+        onMouseLeave={readOnly ? undefined : () => setIsFormsHovered(false)}
+        style={{
+          // The label column will not shrink, so without a floor the morpheme columns absorb the
+          // whole of a narrow container's shortfall.
+          gridTemplateColumns: `${labelTrack}repeat(${morphemes.length}, minmax(${MIN_MORPHEME_COLUMN}, auto))`,
+        }}
       >
-        {/* Forms row. The first cell is the single accessible "edit breakdown" control (a real
-            button); the rest are presentational form cells that share its click and hover behavior
-            but carry no button semantics, so assistive tech sees one control for the whole
-            breakdown. The cells share grid columns with the gloss inputs below so each form sits
-            directly above its gloss. */}
-        {morphemes.map((m, i) => {
-          const formClassName = `tw:flex tw:items-center tw:justify-center tw:whitespace-nowrap tw:rounded tw:px-0.5 tw:font-mono tw:text-xs tw:text-muted-foreground tw:transition-colors${inert ? '' : ' tw:cursor-pointer'}${isFormsHovered && !inert ? ' tw:bg-accent' : ''}`;
-          const formStyle = { gridColumn: i + 1, gridRow: 1 };
-          // preventDefault stops the ancestor <label> (see TokenChip) from forwarding the click to
-          // the gloss input; that focus would land outside the just-opened modal editor and dismiss
-          // it. The label skips the real first-cell button, but the span cells need it explicit.
-          const handleClick = (e: MouseEvent) => {
-            e.preventDefault();
-            if (!inert) onEditBreakdown();
-          };
-
-          // Read-only replaces the edit-breakdown button with a plain first cell: the control
-          // does not render at all rather than rendering unclickable.
-          if (i === 0 && readOnly)
-            return (
-              <span key={m.id} className={formClassName} style={formStyle}>
-                {m.form}
-              </span>
-            );
-
-          if (i === 0)
-            return (
-              <button
-                key={m.id}
-                aria-label={editLabel}
-                className={formClassName}
-                style={formStyle}
-                tabIndex={-1}
-                type="button"
-                onClick={handleClick}
-              >
-                {m.form}
-              </button>
-            );
-
-          return (
+        {rowLabels && (
+          <>
             <span
-              key={m.id}
-              aria-hidden="true"
-              className={formClassName}
-              onClick={handleClick}
-              // Not a button, so this cell is subject to focus moves the first cell is exempt from,
-              // in two ways that both have to be shut off or the editor loses focus the moment it
-              // opens: the browser forwards mouse-down on a label to the labeled control (canceled
-              // with preventDefault), and TokenChip's own label handler does the same deliberately
-              // (kept away by not letting the event reach it).
-              onMouseDown={(e) => {
-                e.preventDefault();
-                e.stopPropagation();
-              }}
-              style={formStyle}
+              className="tw:whitespace-nowrap tw:pe-1 tw:text-xs tw:text-muted-foreground"
+              data-testid={`${formTestId}-row-label`}
+              style={{ gridColumn: 1, gridRow: 1 }}
             >
-              {m.form}
+              {rowLabels.forms}
             </span>
-          );
-        })}
-        {/* Gloss row: each input fills its column and sits directly under its morpheme form. A
-            read-only analysis shows each gloss as plain text instead of an input. */}
-        {morphemes.map((m, i) =>
-          readOnly ? (
             <span
-              key={m.id}
-              className="tw:px-1 tw:text-center tw:text-xs tw:text-foreground"
-              data-testid="readonly-morpheme-gloss"
-              style={{ gridColumn: i + 1, gridRow: 2, minWidth: '2ch' }}
+              className="tw:whitespace-nowrap tw:pe-1 tw:text-xs tw:text-muted-foreground"
+              data-testid={`${cellGlossTestId}-row-label`}
+              style={{ gridColumn: 1, gridRow: 2 }}
             >
-              {m.gloss?.[analysisLanguage] ?? ''}
+              {rowLabels.glosses}
             </span>
-          ) : (
-            <MorphemeGlossInput
-              key={m.id}
-              analysisLanguage={analysisLanguage}
-              column={i + 1}
-              disabled={disabled}
-              glossLabelTemplate={labels.morphemeGloss}
-              morpheme={m}
-              onFocus={onGlossFocus}
-              tokenRef={token.ref}
-            />
-          ),
+          </>
         )}
+        {morphemes.map(formCell)}
+        {morphemes.map(glossCell)}
       </div>
     </PopoverAnchor>
   );
 }
 
+/** Props {@link MorphemeBox} takes, with the read-only state it may instead read from the store. */
+type MorphemeBoxProps = Omit<Parameters<typeof MorphemeBoxInner>[0], 'readOnly'> &
+  Readonly<{ readOnly?: boolean }>;
+
+/** The box with its read-only state taken from the analysis store. */
+function StoreMorphemeBox(props: Omit<MorphemeBoxProps, 'readOnly'>) {
+  return <MorphemeBoxInner {...props} readOnly={useAnalysisReadOnly()} />;
+}
+
+/**
+ * The breakdown box. Reads its read-only state from the analysis store unless the caller says, so
+ * it renders outside that store too.
+ */
+export function MorphemeBox({ readOnly, ...props }: MorphemeBoxProps) {
+  if (readOnly === undefined) return <StoreMorphemeBox {...props} />;
+  return <MorphemeBoxInner {...props} readOnly={readOnly} />;
+}
+
 /**
  * Renders a single morpheme's gloss as an editable input filling its grid column, directly under
  * the morpheme's form. Writes to the store on blur when the draft differs from the committed value.
diff --git a/src/components/MorphemeEditor.tsx b/src/components/MorphemeEditor.tsx
index 93bd14bef..8abc7d83b 100644
--- a/src/components/MorphemeEditor.tsx
+++ b/src/components/MorphemeEditor.tsx
@@ -1,7 +1,10 @@
 import { useLocalizedStrings } from '@papi/frontend/react';
+import type { MorphemeAnalysis } from 'interlinearizer';
 import { Button, Input, Label, PopoverContent } from 'platform-bible-react';
+import { formatReplacementString, type LanguageStrings } from 'platform-bible-utils';
 import { useId, useRef, useState } from 'react';
 import type { KeyboardEvent, MouseEvent } from 'react';
+import { morphemeFormsLostByResplit } from '../store/analysisSlice';
 
 const POPOVER_STRING_KEYS = [
   '%interlinearizer_morphemeEditor_splitLabel%',
@@ -11,8 +14,39 @@ const POPOVER_STRING_KEYS = [
   '%interlinearizer_morphemeEditor_emptyHint%',
   '%interlinearizer_morphemeEditor_confirmResetPrompt%',
   '%interlinearizer_morphemeEditor_confirmResetAction%',
+  '%interlinearizer_morphemeEditor_confirmResplitPrompt%',
+  '%interlinearizer_morphemeEditor_confirmResplitAction%',
 ] as const satisfies `%${string}%`[];
 
+/** The wording the panel renders, so an edit carrying different consequences can say so. */
+export type MorphemeEditorLabels = Readonly<{
+  splitLabel: string;
+  reset: string;
+  cancel: string;
+  done: string;
+  emptyHint: string;
+  confirmResetPrompt: string;
+  confirmResetAction: string;
+  /** Takes a `{forms}` replacement naming the annotated forms the save would strand. */
+  confirmResplitPrompt: string;
+  confirmResplitAction: string;
+}>;
+
+/** The panel's own wording, for a caller that overrides none of it. */
+function defaultLabels(strings: LanguageStrings): MorphemeEditorLabels {
+  return {
+    splitLabel: strings['%interlinearizer_morphemeEditor_splitLabel%'],
+    reset: strings['%interlinearizer_morphemeEditor_reset%'],
+    cancel: strings['%interlinearizer_morphemeEditor_cancel%'],
+    done: strings['%interlinearizer_morphemeEditor_done%'],
+    emptyHint: strings['%interlinearizer_morphemeEditor_emptyHint%'],
+    confirmResetPrompt: strings['%interlinearizer_morphemeEditor_confirmResetPrompt%'],
+    confirmResetAction: strings['%interlinearizer_morphemeEditor_confirmResetAction%'],
+    confirmResplitPrompt: strings['%interlinearizer_morphemeEditor_confirmResplitPrompt%'],
+    confirmResplitAction: strings['%interlinearizer_morphemeEditor_confirmResplitAction%'],
+  };
+}
+
 /**
  * Inline popover for defining or re-splitting a token's morpheme breakdown. This is the _editor_
  * only; the inline display of a breakdown lives separately.
@@ -37,29 +71,44 @@ const POPOVER_STRING_KEYS = [
  *   carry no offsets and need not reconstruct the surface text.
  *
  * Clicking Reset swaps the panel into a confirmation when `needsResetConfirm` says the reset would
- * destroy glosses this token solely owns. The confirmation replaces the panel's own content rather
- * than opening a second surface: the panel is portaled to `document.body`, so it floats over the
- * token chip and cannot reflow it, and nesting a modal inside this already-modal popover would
- * stack two focus traps.
+ * destroy annotation this token solely owns. A re-split that strands an annotated form confirms on
+ * the same terms, naming the forms it is about to drop, since losing some of a breakdown is as
+ * irreversible as losing all of it. The confirmation replaces the panel's own content rather than
+ * opening a second surface: the panel is portaled to `document.body`, so it floats over the token
+ * chip and cannot reflow it, and nesting a modal inside this already-modal popover would stack two
+ * focus traps.
  *
  * Renders the content of a `platform-bible-react` `Popover`; the caller owns the `Popover` root and
  * the `PopoverAnchor` the panel is positioned from, and must render this component only while the
  * popover is open so the draft state re-initializes from `initialValue` on every open. The popover
  * is modal, so interactions outside the panel are blocked while it is open.
+ *
+ * The draft is held here unless the caller passes `draft` and `onDraftChange`, which hand it up
+ * instead — for a caller that outlives this panel and must keep an unsaved re-segmentation across
+ * its own unmounting, since the draft commits on neither blur nor unmount.
  */
 export function MorphemeBreakdownPopover({
   initialValue,
+  draft: controlledDraft,
+  onDraftChange,
   onSave,
   onClose,
   onReset,
   needsResetConfirm = false,
+  morphemes = [],
   glossInputId,
+  labels,
 }: Readonly<{
   /**
    * Pre-filled text for the input (current morpheme forms joined by spaces, or the full surface
-   * text when no breakdown exists yet).
+   * text when no breakdown exists yet). Ignored while the draft is controlled, the caller having
+   * seeded its own.
    */
   initialValue: string;
+  /** The draft text, when the caller holds it. Omit to let the editor hold its own. */
+  draft?: string;
+  /** Records an edit to a controlled draft. Required with `draft`, ignored without it. */
+  onDraftChange?: (draft: string) => void;
   /** Called with the raw input string when the user commits. */
   onSave: (value: string) => void;
   /** Called to dismiss the popover. */
@@ -72,22 +121,42 @@ export function MorphemeBreakdownPopover({
    */
   onReset?: () => void;
   /**
-   * Whether a reset would irreversibly discard morpheme glosses no other token still holds, in
-   * which case the Reset button confirms first. Ignored when `onReset` is absent, since there is
-   * then no breakdown to lose.
+   * Whether a reset would irreversibly discard morpheme glosses or lexicon references no other
+   * token still holds, in which case the Reset button confirms first. Ignored when `onReset` is
+   * absent, since there is then no breakdown to lose.
    */
   needsResetConfirm?: boolean;
+  /**
+   * The token's current morphemes, which a re-split is weighed against to find the annotated forms
+   * it would strand. Pass them only when this token solely owns its payload; a shared payload is
+   * forked rather than re-segmented in place, so nothing it drops is lost project-wide and the
+   * default empty list correctly reports no loss.
+   */
+  morphemes?: readonly MorphemeAnalysis[];
   /**
    * Id of the token's gloss input; used to locate the chip on close so focus lands on its first
    * morpheme gloss field (falling back to the gloss input itself), rather than on the non-tabbable
-   * morpheme trigger.
+   * morpheme trigger. Omit where the panel opens from no such chip, leaving focus restoration to
+   * the popover's own default.
    */
-  glossInputId: string;
+  glossInputId?: string;
+  /**
+   * Overrides for the panel's wording, for a caller whose edit means something other than
+   * re-splitting the one token in hand. Defaults to the panel's own.
+   */
+  labels?: MorphemeEditorLabels;
 }>) {
-  const [localizedStrings] = useLocalizedStrings(POPOVER_STRING_KEYS);
+  const [defaultStrings] = useLocalizedStrings(POPOVER_STRING_KEYS);
   const inputId = useId();
-  const [draft, setDraft] = useState(initialValue);
-  const [confirmingReset, setConfirmingReset] = useState(false);
+  const [uncontrolledDraft, setUncontrolledDraft] = useState(initialValue);
+  const draft = controlledDraft ?? uncontrolledDraft;
+  const setDraft = (value: string) => {
+    if (onDraftChange) onDraftChange(value);
+    else setUncontrolledDraft(value);
+  };
+  const localizedStrings = labels ?? defaultLabels(defaultStrings);
+  /** Which loss the reader is being asked to confirm, or `undefined` while the editor is showing. */
+  const [confirming, setConfirming] = useState<'reset' | 'resplit' | undefined>(undefined);
   // Whether the panel is closing because the user pressed the pointer outside it, so the close
   // handling can leave focus where that press put it instead of pulling it back to this chip.
   const dismissedByOutsidePointerRef = useRef(false);
@@ -114,21 +183,31 @@ export function MorphemeBreakdownPopover({
 
   /**
    * Removes the breakdown and closes, or swaps the panel into the confirmation first when the reset
-   * would discard glosses no other token holds.
+   * would discard annotation no other token holds.
    */
   const requestReset = () => {
     if (needsResetConfirm) {
-      setConfirmingReset(true);
+      setConfirming('reset');
       return;
     }
     onReset?.();
     onClose();
   };
 
+  // The annotated forms this draft would strand. Empty for a shared payload, whose morphemes are
+  // withheld, because the write forks it rather than re-segmenting what the others read.
+  const lostForms = morphemeFormsLostByResplit(morphemes, forms);
+
+  const writeResplit = () => {
+    onSave(draft.trim());
+    onClose();
+  };
+
   /**
    * Resolves the current draft: an empty draft does nothing, an unedited draft over an existing
    * breakdown dismisses without rewriting it, and anything else saves — including an unedited
-   * pre-fill when there is no existing breakdown to leave unchanged.
+   * pre-fill when there is no existing breakdown to leave unchanged, and first confirming when the
+   * save would strand an annotated form.
    */
   const handleSave = () => {
     if (isEmpty) return;
@@ -136,8 +215,11 @@ export function MorphemeBreakdownPopover({
       onClose();
       return;
     }
-    onSave(draft.trim());
-    onClose();
+    if (lostForms.length > 0) {
+      setConfirming('resplit');
+      return;
+    }
+    writeResplit();
   };
 
   /** Handles Enter to commit. Escape is handled by the popover itself (`onEscapeKeyDown`). */
@@ -153,9 +235,9 @@ export function MorphemeBreakdownPopover({
    * was not edited — then the interaction acts like Cancel, because an accidental outside click is
    * not a deliberate commit. An empty draft is likewise dismissed without writing: the commit path
    * refuses to interpret it and would otherwise leave the panel open, but an outside click on a
-   * modal popover must always dismiss. While the reset confirmation is showing, an outside click
-   * dismisses it without resetting: the confirmation exists precisely because the loss is
-   * irreversible, so it must not be answered by a stray click.
+   * modal popover must always dismiss. While either confirmation is showing, an outside click
+   * dismisses it without writing: a confirmation exists precisely because the loss is irreversible,
+   * so it must not be answered by a stray click.
    *
    * Wired to `onPointerDownOutside` rather than the broader `onInteractOutside`, which also fires
    * when focus merely moves outside the panel. A modal popover is not supposed to dismiss on that
@@ -165,7 +247,7 @@ export function MorphemeBreakdownPopover({
    */
   const handlePointerDownOutside = () => {
     dismissedByOutsidePointerRef.current = true;
-    if (confirmingReset || isUnedited || isEmpty) {
+    if (confirming || isUnedited || isEmpty) {
       onClose();
       return;
     }
@@ -195,8 +277,12 @@ export function MorphemeBreakdownPopover({
    * where the user aimed it (typically another token), so pulling focus back to this chip would
    * yank it out of whatever they just clicked. The default is still prevented, so Radix does not
    * restore focus to the pre-open element either — the click's own focus stands.
+   *
+   * With no gloss input named there is no chip to land in, so the popover's own focus restoration
+   * is left alone.
    */
   const handleCloseAutoFocus = (e: Event) => {
+    if (glossInputId === undefined) return;
     e.preventDefault();
     if (dismissedByOutsidePointerRef.current) return;
     const glossInput = document.getElementById(glossInputId);
@@ -217,42 +303,65 @@ export function MorphemeBreakdownPopover({
       onPointerDownOutside={handlePointerDownOutside}
       onMouseDown={stopMouseEvents}
     >
-      {confirmingReset ? (
+      {confirming ? (
         <>
-          <p className="tw:text-xs tw:text-muted-foreground" data-testid="morpheme-reset-confirm">
-            {localizedStrings['%interlinearizer_morphemeEditor_confirmResetPrompt%']}
+          {/* Capped so the prompt wraps: the popover sizes to its content, and an unbounded
+              sentence widens it past the panel. */}
+          <p
+            className="tw:max-w-72 tw:text-xs tw:text-muted-foreground"
+            data-testid={
+              confirming === 'reset' ? 'morpheme-reset-confirm' : 'morpheme-split-confirm'
+            }
+          >
+            {confirming === 'reset'
+              ? localizedStrings.confirmResetPrompt
+              : formatReplacementString(localizedStrings.confirmResplitPrompt, {
+                  forms: lostForms.join(', '),
+                })}
           </p>
           <div className="tw:flex tw:justify-end tw:gap-1.5">
             <Button
-              onClick={() => setConfirmingReset(false)}
+              data-testid="morpheme-breakdown-confirm-cancel"
+              onClick={() => setConfirming(undefined)}
               size="sm"
               type="button"
               variant="outline"
             >
-              {localizedStrings['%interlinearizer_morphemeEditor_cancel%']}
+              {localizedStrings.cancel}
             </Button>
             <Button
               className="tw:text-destructive"
-              data-testid="morpheme-reset-confirm-action"
-              onClick={() => {
-                onReset?.();
-                onClose();
-              }}
+              data-testid={
+                confirming === 'reset'
+                  ? 'morpheme-reset-confirm-action'
+                  : 'morpheme-split-confirm-action'
+              }
+              onClick={
+                confirming === 'reset'
+                  ? () => {
+                      onReset?.();
+                      onClose();
+                    }
+                  : writeResplit
+              }
               size="sm"
               type="button"
               variant="outline"
             >
-              {localizedStrings['%interlinearizer_morphemeEditor_confirmResetAction%']}
+              {confirming === 'reset'
+                ? localizedStrings.confirmResetAction
+                : localizedStrings.confirmResplitAction}
             </Button>
           </div>
         </>
       ) : (
         <>
           <Label className="tw:text-xs tw:text-muted-foreground" htmlFor={inputId}>
-            {localizedStrings['%interlinearizer_morphemeEditor_splitLabel%']}
+            {localizedStrings.splitLabel}
           </Label>
           <Input
             className="tw:w-full tw:font-mono"
+            data-testid="morpheme-breakdown-input"
             id={inputId}
             value={draft}
             onChange={(e) => setDraft(e.target.value)}
@@ -261,26 +370,39 @@ export function MorphemeBreakdownPopover({
           />
           {isEmpty && (
             <p className="tw:text-xs tw:text-muted-foreground" data-testid="morpheme-empty-hint">
-              {localizedStrings['%interlinearizer_morphemeEditor_emptyHint%']}
+              {localizedStrings.emptyHint}
             </p>
           )}
           <div className="tw:flex tw:justify-end tw:gap-1.5">
             {onReset && (
               <Button
                 className="tw:me-auto tw:text-destructive"
+                data-testid="morpheme-breakdown-reset"
                 onClick={requestReset}
                 size="sm"
                 type="button"
                 variant="outline"
               >
-                {localizedStrings['%interlinearizer_morphemeEditor_reset%']}
+                {localizedStrings.reset}
               </Button>
             )}
-            <Button onClick={onClose} size="sm" type="button" variant="outline">
-              {localizedStrings['%interlinearizer_morphemeEditor_cancel%']}
+            <Button
+              data-testid="morpheme-breakdown-cancel"
+              onClick={onClose}
+              size="sm"
+              type="button"
+              variant="outline"
+            >
+              {localizedStrings.cancel}
             </Button>
-            <Button disabled={isEmpty} onClick={handleSave} size="sm" type="button">
-              {localizedStrings['%interlinearizer_morphemeEditor_done%']}
+            <Button
+              data-testid="morpheme-breakdown-save"
+              disabled={isEmpty}
+              onClick={handleSave}
+              size="sm"
+              type="button"
+            >
+              {localizedStrings.done}
             </Button>
           </div>
         </>
diff --git a/src/components/TokenChip.tsx b/src/components/TokenChip.tsx
index 25250df99..01c87483d 100644
--- a/src/components/TokenChip.tsx
+++ b/src/components/TokenChip.tsx
@@ -29,7 +29,8 @@ import {
   useGlossDispatch,
   useMorphemeBreakdownDispatch,
   useMorphemeDeleteDispatch,
-  useMorphemeResetLosesGlosses,
+  useMorphemePayloadIsSolelyOwned,
+  useMorphemeResetLosesAnnotation,
   useMorphemes,
   useReportGlossEditing,
   useResolvedTokenAnalysis,
@@ -114,7 +115,8 @@ export function TokenChip({
   const analysisLanguage = useAnalysisLanguage();
   const dispatchMorphemeBreakdown = useMorphemeBreakdownDispatch();
   const dispatchMorphemeDelete = useMorphemeDeleteDispatch();
-  const resetLosesGlosses = useMorphemeResetLosesGlosses(token.ref);
+  const resetLosesAnnotation = useMorphemeResetLosesAnnotation(token.ref);
+  const payloadIsSolelyOwned = useMorphemePayloadIsSolelyOwned(token.ref);
   const showSuggestions = useShowSuggestions();
   const readOnly = useAnalysisReadOnly();
   // Only resolve the pool when suggestions are actually shown; off (or read-only, which never
@@ -491,7 +493,11 @@ export function TokenChip({
                 initialValue={
                   hasMorphemes ? morphemes.map((m) => m.form).join(' ') : token.surfaceText
                 }
-                needsResetConfirm={resetLosesGlosses}
+                // Withheld for a shared payload, which the write forks rather than re-segmenting in
+                // place, so a form this token drops survives on the tokens still reading the
+                // original and there is nothing to confirm.
+                morphemes={payloadIsSolelyOwned ? morphemes : undefined}
+                needsResetConfirm={resetLosesAnnotation}
                 onClose={() => setPopoverOpen(false)}
                 onReset={hasMorphemes ? () => dispatchMorphemeDelete(token.ref) : undefined}
                 onSave={handleMorphemeSave}
diff --git a/src/components/__mocks__/AnalysisStore.tsx b/src/components/__mocks__/AnalysisStore.tsx
index 492f63dbc..13ea8c4d8 100644
--- a/src/components/__mocks__/AnalysisStore.tsx
+++ b/src/components/__mocks__/AnalysisStore.tsx
@@ -112,10 +112,18 @@ export function useMorphemeDeleteDispatch(): (tokenRef: string) => void {
 }
 
 /**
- * Reports that a morpheme reset never loses glosses in mock context, so the editor takes its
+ * Reports that a morpheme reset never loses annotation in mock context, so the editor takes its
  * unconfirmed path by default. Tests covering the confirm step mock this module member directly.
  */
-export function useMorphemeResetLosesGlosses(): boolean {
+export function useMorphemeResetLosesAnnotation(): boolean {
+  return false;
+}
+
+/**
+ * Reports the payload as shared in mock context, so a breakdown edit takes its unconfirmed path by
+ * default. Tests covering the confirm step mock this module member directly.
+ */
+export function useMorphemePayloadIsSolelyOwned(): boolean {
   return false;
 }
 
diff --git a/src/components/modals/ModalShell.tsx b/src/components/modals/ModalShell.tsx
index fac5d5f2e..d96d4eea0 100644
--- a/src/components/modals/ModalShell.tsx
+++ b/src/components/modals/ModalShell.tsx
@@ -1,5 +1,10 @@
-import { Dialog, DialogContent, DialogTitle } from 'platform-bible-react';
-import type { ReactNode } from 'react';
+import {
+  Dialog,
+  DialogContent,
+  DialogTitle,
+  PopoverPortalContainerProvider,
+} from 'platform-bible-react';
+import { useState, type ReactNode } from 'react';
 
 /**
  * Shared chrome for the project modals: the platform dialog surface, its accessibility wiring, and
@@ -8,6 +13,10 @@ import type { ReactNode } from 'react';
  * The platform dialog supplies a focus trap, scroll lock, and focus restore on close, so a modal
  * genuinely blocks the view behind it rather than merely covering it.
  *
+ * A popover opened inside a modal portals into the dialog rather than to `document.body`, where the
+ * focus trap would pull focus straight back out of it and the dismiss layer would read a click in
+ * it as a click outside the modal.
+ *
  * @param props.titleTestId - Test id tagged onto the title heading, which is how a modal is
  *   identified from outside. The heading's `id` belongs to the platform dialog, which generates it
  *   and points its own `aria-labelledby` there.
@@ -16,24 +25,32 @@ import type { ReactNode } from 'react';
  * @param props.onClose - Called when the user dismisses the modal, by pressing Escape or by
  *   clicking outside it; a caller with an inline confirmation of its own may instead back out of
  *   that first. Omit to make the modal undismissable, which callers do while a submission is in
- *   flight so neither route can abandon work the user has already committed to.
+ *   flight so neither route can abandon work the user has already committed to. An outside click is
+ *   withheld while a popover is open inside the modal.
  * @param props.children - Modal body content rendered below the title. Omitted while a modal is
  *   still resolving its localized content, so the blocking overlay can show before the body
  *   exists.
+ * @param props.titleAdornment - Rendered inline after the title text, for a control that qualifies
+ *   the whole modal rather than any one field in it.
  */
 export function ModalShell({
   titleTestId,
   title,
+  titleAdornment,
   width,
   onClose,
   children,
 }: Readonly<{
   titleTestId: string;
   title: string;
+  titleAdornment?: ReactNode;
   width: string;
   onClose?: () => void;
   children?: ReactNode;
 }>) {
+  // eslint-disable-next-line no-null/no-null -- the platform's container prop takes null until the dialog mounts
+  const [dialogEl, setDialogEl] = useState<HTMLDivElement | null>(null);
+
   return (
     <Dialog
       open
@@ -51,15 +68,25 @@ export function ModalShell({
         className={`tw:gap-0 tw:sm:max-w-none ${width}`}
         // A busy modal withholds `onClose`, and blocking the click then keeps a stray one outside
         // from discarding work already in flight — its Cancel control is disabled for the same
-        // reason. An idle modal has nothing to abandon, so the click dismisses it as Escape does.
-        /* v8 ignore next -- platform-component wiring; the test double has no outside region */
-        onInteractOutside={onClose ? undefined : (event) => event.preventDefault()}
+        // reason. An idle modal has nothing to abandon, so the click dismisses it as Escape does,
+        // except while a popover is open inside it — that press belongs to the popover.
+        onInteractOutside={(event) => {
+          if (!onClose || dialogEl?.querySelector('[data-slot="popover-content"]'))
+            event.preventDefault();
+        }}
+        ref={setDialogEl}
         showCloseButton={false}
       >
-        <DialogTitle className="tw:mb-4" data-testid={titleTestId}>
-          {title}
-        </DialogTitle>
-        {children}
+        <PopoverPortalContainerProvider container={dialogEl}>
+          <DialogTitle
+            className="tw:mb-4 tw:flex tw:items-center tw:gap-1.5"
+            data-testid={titleTestId}
+          >
+            {title}
+            {titleAdornment}
+          </DialogTitle>
+          {children}
+        </PopoverPortalContainerProvider>
       </DialogContent>
     </Dialog>
   );
diff --git a/src/hooks/useRowWindow.ts b/src/hooks/useRowWindow.ts
index ee1bbca53..0eb44ccf3 100644
--- a/src/hooks/useRowWindow.ts
+++ b/src/hooks/useRowWindow.ts
@@ -39,11 +39,17 @@ export interface UseRowWindowResult<T> {
  * compared by reference: a reader who has scrolled deep into one listing and then narrows it is
  * looking at a new list, not further down the old one. A caller passes everything that decides
  * which listing it is showing, and one whose listing never changes passes nothing. Keyed on that
- * rather than on `rows`, which turns over on any edit to the underlying analysis as well.
+ * rather than on `rows`, which turns over on any edit to the underlying analysis as well — a gloss
+ * approved in the view beside an open catalog would otherwise collapse a deeply scrolled list back
+ * to its first chunk.
+ *
+ * A caller with a row it must be able to point the reader at passes that row's index as
+ * `mustMount`, which the window covers however far down the listing it falls.
  */
 export default function useRowWindow<T>(
   rows: readonly T[],
   listing?: unknown,
+  mustMount?: number,
 ): UseRowWindowResult<T> {
   const [count, setCount] = useState(INITIAL_ROW_COUNT);
 
@@ -91,7 +97,13 @@ export default function useRowWindow<T>(
     return () => observer.disconnect();
   }, [scrollEl, sentinelEl, count, rows.length]);
 
-  const windowRows = useMemo(() => rows.slice(0, count), [rows, count]);
+  // Applied over the count rather than into it, so the window still shrinks back to its first chunk
+  // when the listing changes: a row held mounted for one notice must not raise the floor for the
+  // listing after it.
+  const windowRows = useMemo(
+    () => rows.slice(0, mustMount === undefined ? count : Math.max(count, mustMount + 1)),
+    [rows, count, mustMount],
+  );
 
   return { windowRows, scrollRef, sentinelRef };
 }
diff --git a/src/store/analysisSlice.ts b/src/store/analysisSlice.ts
index 42cbeaf27..968098790 100644
--- a/src/store/analysisSlice.ts
+++ b/src/store/analysisSlice.ts
@@ -1,5 +1,6 @@
 import { createSelector, createSlice, current, type PayloadAction } from '@reduxjs/toolkit';
 import type {
+  Confidence,
   MorphemeAnalysis,
   PhraseAnalysis,
   PhraseAnalysisLink,
@@ -11,7 +12,12 @@ import type {
   TokenSnapshot,
 } from 'interlinearizer';
 import { emptyAnalysis } from '../types/empty-factories';
-import { analysesAreIdentical } from '../utils/analysis-identity';
+import {
+  analysesAreIdentical,
+  morphemeCarriesAnnotation,
+  normalizeSurfaceForm,
+  reconcileMorphemes,
+} from '../utils/analysis-identity';
 import { buildCatalogRows } from '../utils/analysis-query';
 import { isEmptyMultiString } from '../utils/multi-string';
 import {
@@ -28,6 +34,12 @@ export type AnalysisState = {
   analysis: TextAnalysis;
   /** BCP 47 tag identifying the language used when reading and writing gloss values. */
   analysisLanguage: string;
+  /**
+   * The record the last write's collapse left standing. Reports a collapse the state cannot show: a
+   * record holding no links — how an imported wordform inventory arrives — repoints nothing when it
+   * collapses, leaving what its removal would leave. Never reaches storage.
+   */
+  lastCollapseSurvivorId?: string;
 };
 
 /** Payload for the {@link writeGloss} action, extended with a pre-generated UUID. */
@@ -331,6 +343,37 @@ function forkSharedAnalysis(
   return state.analysis.tokenAnalyses[state.analysis.tokenAnalyses.length - 1];
 }
 
+/**
+ * Leaves a token holding one link to `analysisId` where it held several, keeping the link the read
+ * selectors surface and approving it if any it supersedes was, so the "at most one approved link
+ * per token" invariant holds across the collapse.
+ *
+ * The survivor keeps the token's first annotation date and, where it is raised to approved, the
+ * superseded approval's `confidence` — so a collapse retires a link without retiring what it
+ * recorded.
+ */
+function coalesceLinksPerToken(state: AnalysisState, analysisId: string, now: string): void {
+  const survivorByToken = new Map<string, TokenAnalysisLink>();
+  state.analysis.tokenAnalysisLinks.forEach((l) => {
+    if (l.analysisId !== analysisId) return;
+    const superseded = survivorByToken.get(l.token.tokenRef);
+    if (superseded) {
+      if (superseded.createdAt < l.createdAt) l.createdAt = superseded.createdAt;
+      if (superseded.status === 'approved' && l.status !== 'approved') {
+        l.status = 'approved';
+        l.updatedAt = now;
+        if (superseded.confidence === undefined) delete l.confidence;
+        else l.confidence = superseded.confidence;
+      }
+    }
+    survivorByToken.set(l.token.tokenRef, l);
+  });
+  const survivors = new Set(survivorByToken.values());
+  state.analysis.tokenAnalysisLinks = state.analysis.tokenAnalysisLinks.filter(
+    (l) => l.analysisId !== analysisId || survivors.has(l),
+  );
+}
+
 /**
  * Re-converges a just-edited payload onto an existing content-identical one, so an in-place edit
  * can never leave two identical payloads the way the create path's find-or-create prevents on first
@@ -339,18 +382,137 @@ function forkSharedAnalysis(
  * homograph instance that was edited to match a sibling back onto one shared payload (frequency
  * re-merged, no duplicate suggestion). A no-op when the edit left the payload unique.
  *
+ * A token that linked both payloads is left holding one link, the two having come to name the same
+ * record, dated by the earlier of the two.
+ *
  * The surviving payload keeps its own timestamps and the repointed links keep theirs: no write was
  * aimed at the survivor or at any token's annotation, only at which record holds the content.
+ *
+ * `settleProvenance` moves that boundary for a write that chose the survivor's confidence, which
+ * identity excludes and the collapse would otherwise leave saying whatever it already said. An edit
+ * that converged incidentally chose nothing and leaves it alone.
+ *
+ * Leaves the survivor in {@link AnalysisState.lastCollapseSurvivorId}.
  */
-function mergeIntoIdenticalPayload(state: AnalysisState, analysis: TokenAnalysis): void {
+function mergeIntoIdenticalPayload(
+  state: AnalysisState,
+  analysis: TokenAnalysis,
+  now: string,
+  settleProvenance = false,
+): void {
   const other = state.analysis.tokenAnalyses.find(
     (ta) => ta !== analysis && analysesAreIdentical(ta, analysis),
   );
   if (!other) return;
+  if (settleProvenance) {
+    if (analysis.confidence === undefined) delete other.confidence;
+    else other.confidence = analysis.confidence;
+    other.updatedAt = now;
+  }
   state.analysis.tokenAnalysisLinks.forEach((l) => {
     if (l.analysisId === analysis.id) l.analysisId = other.id;
   });
+  coalesceLinksPerToken(state, other.id, now);
   state.analysis.tokenAnalyses = state.analysis.tokenAnalyses.filter((ta) => ta !== analysis);
+  state.lastCollapseSurvivorId = other.id;
+}
+
+/**
+ * What a merge settles the surviving analysis says. Every field is written as given and absence
+ * clears what the record held, a missing value being one the merge decided against rather than one
+ * it had nothing to say about.
+ */
+export interface MergedContent {
+  /** Gloss in the store's analysis language, blank clearing it. */
+  gloss: string;
+  /**
+   * Analysis `gloss` was taken from, whose sense the survivor keeps resolving it through. Absent
+   * when the reader typed the gloss, which leaves the survivor no sense.
+   */
+  glossFromAnalysisId?: string;
+  morphemes: readonly MorphemeAnalysis[];
+  pos?: string;
+  features?: Readonly<Record<string, string>>;
+  confidence?: Confidence;
+}
+
+/**
+ * Carries the glosses outside `lang` off the donors onto the survivor, which keeps its own wherever
+ * it has them, and settles the sense the survivor's gloss resolves through.
+ *
+ * @param survivor Mutated in place.
+ * @param donors The records being dropped, most-preferred first.
+ * @param lang BCP 47 tag the merge was conducted in, the one gloss this leaves alone.
+ * @param glossFrom The analysis the settled gloss came from, whose sense the survivor takes;
+ *   `undefined` for a gloss answering to no record, which leaves the survivor without one.
+ */
+function carryOverUnsettledContent(
+  survivor: TokenAnalysis,
+  donors: readonly TokenAnalysis[],
+  lang: string,
+  glossFrom: TokenAnalysis | undefined,
+): void {
+  survivor.glossSenseRef = glossFrom?.glossSenseRef;
+
+  donors.forEach((donor) => {
+    Object.entries(donor.gloss ?? {}).forEach(([tag, gloss]) => {
+      if (tag === lang) return;
+      if (!survivor.gloss) survivor.gloss = {};
+      if (survivor.gloss[tag] === undefined) survivor.gloss[tag] = gloss;
+    });
+  });
+}
+
+/**
+ * Copies a merged morpheme, leaving it unglossed in `lang` where the gloss holds nothing that
+ * renders — analysis identity must not see a difference the reader cannot.
+ */
+function copyMergedMorpheme(morpheme: MorphemeAnalysis, lang: string): MorphemeAnalysis {
+  const copy = { ...morpheme };
+  const gloss = copy.gloss?.[lang];
+  if (gloss !== undefined && gloss.trim() === '') {
+    copy.gloss = { ...copy.gloss };
+    delete copy.gloss[lang];
+    if (Object.keys(copy.gloss).length === 0) delete copy.gloss;
+  }
+  return copy;
+}
+
+/** Writes merged content onto an analysis, clearing each field the merge settled on nothing for. */
+function applyMergedContent(analysis: TokenAnalysis, content: MergedContent, lang: string): void {
+  if (content.gloss.trim() === '') {
+    if (analysis.gloss) {
+      delete analysis.gloss[lang];
+      if (Object.keys(analysis.gloss).length === 0) delete analysis.gloss;
+    }
+  } else {
+    if (!analysis.gloss) analysis.gloss = {};
+    analysis.gloss[lang] = content.gloss;
+  }
+
+  if (content.morphemes.length === 0) delete analysis.morphemes;
+  else analysis.morphemes = content.morphemes.map((m) => copyMergedMorpheme(m, lang));
+
+  if (content.pos === undefined) delete analysis.pos;
+  else analysis.pos = content.pos;
+
+  if (content.features === undefined) delete analysis.features;
+  else analysis.features = { ...content.features };
+
+  if (content.confidence === undefined) delete analysis.confidence;
+  else analysis.confidence = content.confidence;
+}
+
+/**
+ * Drops a `TokenAnalysis` and every link pointing at it, addressed by id alone — so the record goes
+ * on its own terms and takes every token with it, rather than being retired as one token lets go of
+ * it. A no-op when the id resolves to no payload.
+ */
+function removeAnalysisAndLinks(state: AnalysisState, analysisId: string): void {
+  state.analysis.tokenAnalyses = state.analysis.tokenAnalyses.filter((ta) => ta.id !== analysisId);
+  state.analysis.tokenAnalysisLinks = state.analysis.tokenAnalysisLinks.filter(
+    (l) => l.analysisId !== analysisId,
+  );
 }
 
 /**
@@ -380,6 +542,47 @@ function isEmptyTokenAnalysis(analysis: TokenAnalysis): boolean {
   );
 }
 
+/**
+ * Empties one language's gloss, dropping the gloss and the analysis-wide `glossSenseRef` once no
+ * language is left holding usable text — a sibling left holding only whitespace counts for neither,
+ * so the sense is never stranded on a gloss nothing renders.
+ */
+function clearAnalysisGloss(analysis: TokenAnalysis, lang: string): void {
+  if (analysis.gloss) {
+    delete analysis.gloss[lang];
+    if (isEmptyMultiString(analysis.gloss)) delete analysis.gloss;
+  }
+  if (!analysis.gloss) delete analysis.glossSenseRef;
+}
+
+/**
+ * The annotated forms a re-split to `forms` would strand: those whose morpheme carries a gloss or a
+ * lexicon reference and which the new breakdown leaves no morpheme to hold, in the order the old
+ * breakdown listed them. Empty when the re-split keeps every annotated form, which is the common
+ * case.
+ *
+ * Forms are matched as a re-split itself matches them — by form, first-come-first-served within a
+ * repeated form — so the answer can never disagree with what the write goes on to drop. A form is
+ * counted once per occurrence: re-splitting "ba ba" to a single "ba" strands the second.
+ *
+ * Bare forms are left out. Losing one costs only the segmentation, which the reader is retyping
+ * anyway, and prompting about it would train them to click through the prompt that does carry a
+ * loss.
+ */
+export function morphemeFormsLostByResplit(
+  old: readonly MorphemeAnalysis[] | undefined,
+  forms: readonly string[],
+): string[] {
+  const remaining = new Map<string, number>();
+  forms.forEach((form) => remaining.set(form, (remaining.get(form) ?? 0) + 1));
+  return (old ?? []).reduce<string[]>((lost, morpheme) => {
+    const spare = remaining.get(morpheme.form) ?? 0;
+    if (spare > 0) remaining.set(morpheme.form, spare - 1);
+    else if (morphemeCarriesAnnotation(morpheme)) lost.push(morpheme.form);
+    return lost;
+  }, []);
+}
+
 const analysisSlice = createSlice({
   name: 'analysis',
   initialState: defaultState,
@@ -414,6 +617,10 @@ const analysisSlice = createSlice({
        * just as an edit does, so the co-linked tokens keep the shared gloss rather than being
        * stranded on an emptied payload. A blank write to a token with no approved analysis is a
        * no-op, so a focus/blur cycle on an empty gloss never creates a record.
+       *
+       * A gloss the reader typed resolves through no lexicon sense of theirs, so a rewrite drops
+       * the payload's `glossSenseRef`. A clear drops it only once no language still holds usable
+       * gloss text, the sense belonging to the analysis rather than to the emptied language.
        */
       reducer(state, action: PayloadAction<WriteGlossPayload>) {
         const { tokenRef, surfaceText, value, id, now } = action.payload;
@@ -437,24 +644,22 @@ const analysisSlice = createSlice({
           link.token.surfaceText = surfaceText;
           link.updatedAt = now;
           if (isBlank) {
-            if (target.gloss) {
-              delete target.gloss[lang];
-              if (Object.keys(target.gloss).length === 0) delete target.gloss;
-            }
+            clearAnalysisGloss(target, lang);
             // When the clear empties the analysis, detach it; otherwise the cleared payload (e.g. one
             // left holding only morphemes) can be identical to an existing sibling, so re-converge —
             // mirroring writeMorphemeGloss's clear path so a clear never leaves a duplicate the
             // suggestion pool would double-count.
             if (isEmptyTokenAnalysis(target)) detachTokenAnalysisLink(state, target, link);
-            else mergeIntoIdenticalPayload(state, target);
+            else mergeIntoIdenticalPayload(state, target, now);
             return;
           }
           if (!target.gloss) target.gloss = {};
           target.gloss[lang] = value;
+          delete target.glossSenseRef;
           // An in-place edit can make this payload identical to an existing one (e.g. a homograph
           // instance re-glossed to match its sibling); re-converge so the dedupe the create path
           // guarantees on first write also holds after edits.
-          mergeIntoIdenticalPayload(state, target);
+          mergeIntoIdenticalPayload(state, target, now);
           return;
         }
 
@@ -529,25 +734,11 @@ const analysisSlice = createSlice({
           target.updatedAt = now;
           link.token.surfaceText = surfaceText;
           link.updatedAt = now;
-          // Multimap with consumed entries so duplicate forms (e.g. reduplication "ba ba") each
-          // match a distinct old morpheme in order, instead of all inheriting the last one.
-          const oldByForm = new Map<string, MorphemeAnalysis[]>();
-          (target.morphemes ?? []).forEach((m) => {
-            const bucket = oldByForm.get(m.form);
-            if (bucket) bucket.push(m);
-            else oldByForm.set(m.form, [m]);
-          });
-          target.morphemes = morphemes.map(({ id, form }) => {
-            const old = oldByForm.get(form)?.shift();
-            // Keep the preserved morpheme's id (the prepared id is discarded) so external
-            // references to it stay valid; only the writing system is refreshed.
-            if (old) return { ...old, writingSystem };
-            return { id, form, writingSystem };
-          });
+          target.morphemes = reconcileMorphemes(target.morphemes, morphemes, writingSystem);
           // An in-place breakdown edit can make this payload identical to an existing one (e.g. a
           // homograph re-segmented to match a sibling); re-converge so the dedupe the create path
           // guarantees on first write also holds after morpheme edits (mirrors writeGloss).
-          mergeIntoIdenticalPayload(state, target);
+          mergeIntoIdenticalPayload(state, target, now);
           return;
         }
 
@@ -601,7 +792,7 @@ const analysisSlice = createSlice({
         }
         // Removing the breakdown can leave this payload identical to an existing one; re-converge so
         // dedupe holds after morphology-only edits, the same way writeGloss does after a gloss edit.
-        mergeIntoIdenticalPayload(state, target);
+        mergeIntoIdenticalPayload(state, target, now);
       },
     },
     /**
@@ -674,7 +865,250 @@ const analysisSlice = createSlice({
         // A morpheme gloss is part of analysis identity (see analysesAreIdentical), so editing or
         // clearing one can make this payload identical to an existing one (e.g. a homograph whose
         // only difference was this morpheme's gloss); re-converge so dedupe holds after edits too.
-        mergeIntoIdenticalPayload(state, target);
+        mergeIntoIdenticalPayload(state, target, now);
+      },
+    },
+    // The reducers below are keyed by `analysisId` rather than `tokenRef`, and the key is the whole
+    // of the scope distinction: a `tokenRef` edit changes what one token means and forks a shared
+    // payload to do it, an `analysisId` edit changes what the record says everywhere. Neither
+    // family takes a scope flag, because the address the caller can supply already says which act
+    // it is.
+    /**
+     * Writes a gloss onto a `TokenAnalysis` addressed by its own id, changing what that record says
+     * for every token linked to it.
+     *
+     * A blank `value` clears the active language's gloss, and an edit that empties the record
+     * removes it and every link to it. An edit that makes the record identical to a sibling
+     * collapses it into that sibling, so the edited row disappears from the catalog.
+     *
+     * A gloss the reader typed resolves through no lexicon sense of theirs, so a rewrite drops the
+     * record's `glossSenseRef`. A clear drops it only once no language still holds usable gloss
+     * text, the sense belonging to the analysis rather than to the emptied language.
+     */
+    writeAnalysisGloss: {
+      /** Reads the clock before the action reaches the reducer, keeping the reducer pure. */
+      prepare(arg: { analysisId: string; value: string }) {
+        return { payload: { ...arg, now: nowIso() } };
+      },
+      reducer(state, action: PayloadAction<{ analysisId: string; value: string; now: string }>) {
+        const { analysisId, value, now } = action.payload;
+        const lang = state.analysisLanguage;
+
+        const analysis = state.analysis.tokenAnalyses.find((ta) => ta.id === analysisId);
+        if (!analysis) return;
+        state.lastCollapseSurvivorId = undefined;
+
+        if (value.trim() === '') {
+          clearAnalysisGloss(analysis, lang);
+        } else {
+          if (!analysis.gloss) analysis.gloss = {};
+          analysis.gloss[lang] = value;
+          delete analysis.glossSenseRef;
+        }
+        analysis.updatedAt = now;
+
+        // Removed outright rather than left as an empty payload the pool would still carry.
+        if (isEmptyTokenAnalysis(analysis)) {
+          removeAnalysisAndLinks(state, analysisId);
+          return;
+        }
+        mergeIntoIdenticalPayload(state, analysis, now);
+      },
+    },
+    /**
+     * Re-segments the morpheme breakdown on a `TokenAnalysis` addressed by its own id, for every
+     * token linked to it, so one correction fixes a mis-split word across all its occurrences.
+     *
+     * A form the breakdown already carried keeps its morpheme whole — its id, so
+     * `MorphemeLink.morphemeId` stays valid, along with its gloss and lexicon references — while a
+     * form with no counterpart is minted fresh. A re-split that drops a form drops what it carried
+     * with it, there being no morpheme left to hold it. An empty `forms` removes the breakdown, and
+     * removes the record when nothing else remains on it.
+     */
+    writeAnalysisMorphemes: {
+      /**
+       * Mints an id per form and reads the clock before the action reaches the reducer, keeping the
+       * reducer pure. Only a form the breakdown cannot already account for spends the id offered
+       * for it.
+       */
+      prepare(arg: { analysisId: string; forms: readonly string[]; writingSystem: string }) {
+        return {
+          payload: {
+            analysisId: arg.analysisId,
+            writingSystem: arg.writingSystem,
+            morphemes: arg.forms.map((form) => ({ id: crypto.randomUUID(), form })),
+            now: nowIso(),
+          },
+        };
+      },
+      reducer(
+        state,
+        action: PayloadAction<{
+          analysisId: string;
+          writingSystem: string;
+          morphemes: readonly { id: string; form: string }[];
+          now: string;
+        }>,
+      ) {
+        const { analysisId, writingSystem, morphemes, now } = action.payload;
+
+        const analysis = state.analysis.tokenAnalyses.find((ta) => ta.id === analysisId);
+        if (!analysis) return;
+        state.lastCollapseSurvivorId = undefined;
+
+        if (morphemes.length === 0) delete analysis.morphemes;
+        else analysis.morphemes = reconcileMorphemes(analysis.morphemes, morphemes, writingSystem);
+        analysis.updatedAt = now;
+
+        if (isEmptyTokenAnalysis(analysis)) {
+          removeAnalysisAndLinks(state, analysisId);
+          return;
+        }
+        mergeIntoIdenticalPayload(state, analysis, now);
+      },
+    },
+    /**
+     * Writes a gloss onto one morpheme of a `TokenAnalysis` addressed by its own id, for every
+     * token linked to it. Clearing the gloss keeps the morpheme, a breakdown being content in its
+     * own right, so this never empties the enclosing record.
+     */
+    writeAnalysisMorphemeGloss: {
+      /** Reads the clock before the action reaches the reducer, keeping the reducer pure. */
+      prepare(arg: { analysisId: string; morphemeId: string; value: string }) {
+        return { payload: { ...arg, now: nowIso() } };
+      },
+      reducer(
+        state,
+        action: PayloadAction<{
+          analysisId: string;
+          morphemeId: string;
+          value: string;
+          now: string;
+        }>,
+      ) {
+        const { analysisId, morphemeId, value, now } = action.payload;
+        const lang = state.analysisLanguage;
+
+        const analysis = state.analysis.tokenAnalyses.find((ta) => ta.id === analysisId);
+        const morpheme = analysis?.morphemes?.find((m) => m.id === morphemeId);
+        if (!analysis || !morpheme) return;
+        state.lastCollapseSurvivorId = undefined;
+
+        if (value.trim() === '') {
+          if (morpheme.gloss) {
+            delete morpheme.gloss[lang];
+            if (Object.keys(morpheme.gloss).length === 0) delete morpheme.gloss;
+          }
+        } else {
+          if (!morpheme.gloss) morpheme.gloss = {};
+          morpheme.gloss[lang] = value;
+        }
+        analysis.updatedAt = now;
+        // A morpheme gloss is part of analysis identity, so this edit can collapse onto a sibling.
+        mergeIntoIdenticalPayload(state, analysis, now);
+      },
+    },
+    /**
+     * Removes a `TokenAnalysis` and every link to it. Its tokens fall back to whatever the
+     * suggestion pool still offers for their surface form — a surviving homograph, or nothing, in
+     * which case they read as blank; {@link selectAnalysisDeletionOutcome} reports which.
+     *
+     * Irreversible, and the only reducer that drops a record the user never emptied.
+     */
+    deleteAnalysis(state, action: PayloadAction<{ analysisId: string }>) {
+      removeAnalysisAndLinks(state, action.payload.analysisId);
+    },
+    /**
+     * Folds several `TokenAnalysis` records into one and writes the content they agreed on onto it,
+     * so a reader consolidating a form's homographs settles what the survivor says in the same
+     * stroke that gathers the tokens onto it.
+     *
+     * Settling the content and gathering the links is indivisible: no state is reachable in which
+     * the survivor has been rewritten but the records it is absorbing still hold their tokens.
+     *
+     * The survivor is stamped, content having been written to it. A merged id that resolves to no
+     * payload is skipped, and one naming the survivor is ignored rather than dropping the record
+     * the merge is keeping. No-ops entirely when the survivor resolves to no payload, there being
+     * nothing to write onto.
+     *
+     * Where a token held links to both a merged record and the survivor it is left holding one,
+     * approved if either was and keeping that approval's `confidence` and the earlier `createdAt`.
+     * A survivor whose settled content matches a record the merge did not fold in collapses onto
+     * it, so consolidating can never leave two payloads saying the same thing.
+     *
+     * Glosses in languages besides the one the merge was conducted in are carried off the records
+     * being dropped rather than going with them, the survivor's own standing where it holds them.
+     * `mergedAnalysisIds` ranks the donors most-preferred first, deciding which of them a carried
+     * value comes from. The sense reference instead follows the settled gloss, resting with
+     * whichever record supplied it and clearing for a gloss the reader typed.
+     *
+     * A merge settling on no content at all takes the survivor with it, releasing every gathered
+     * token to the suggestion pool rather than leaving them approved against a blank record. A
+     * survivor left holding only carried-over content is content enough to keep.
+     */
+    mergeAnalysesInto: {
+      /** Reads the clock before the action reaches the reducer, keeping the reducer pure. */
+      prepare(arg: {
+        survivorAnalysisId: string;
+        mergedAnalysisIds: readonly string[];
+        content: MergedContent;
+      }) {
+        return { payload: { ...arg, now: nowIso() } };
+      },
+      reducer(
+        state,
+        action: PayloadAction<{
+          survivorAnalysisId: string;
+          mergedAnalysisIds: readonly string[];
+          content: MergedContent;
+          now: string;
+        }>,
+      ) {
+        const { survivorAnalysisId, mergedAnalysisIds, content, now } = action.payload;
+        const survivor = state.analysis.tokenAnalyses.find((ta) => ta.id === survivorAnalysisId);
+        if (!survivor) return;
+        state.lastCollapseSurvivorId = undefined;
+
+        const merged = new Set(
+          mergedAnalysisIds.filter(
+            (id) =>
+              id !== survivorAnalysisId && state.analysis.tokenAnalyses.some((ta) => ta.id === id),
+          ),
+        );
+
+        // Resolved while the donors are still standing.
+        const donors = [...merged]
+          .map((id) => state.analysis.tokenAnalyses.find((ta) => ta.id === id))
+          .filter((ta) => ta !== undefined);
+
+        const glossFrom =
+          content.glossFromAnalysisId === undefined
+            ? undefined
+            : state.analysis.tokenAnalyses.find((ta) => ta.id === content.glossFromAnalysisId);
+
+        applyMergedContent(survivor, content, state.analysisLanguage);
+        carryOverUnsettledContent(survivor, donors, state.analysisLanguage, glossFrom);
+        survivor.updatedAt = now;
+
+        state.analysis.tokenAnalysisLinks.forEach((l) => {
+          if (merged.has(l.analysisId)) {
+            l.analysisId = survivorAnalysisId;
+            l.updatedAt = now;
+          }
+        });
+        coalesceLinksPerToken(state, survivorAnalysisId, now);
+        state.analysis.tokenAnalyses = state.analysis.tokenAnalyses.filter(
+          (ta) => !merged.has(ta.id),
+        );
+
+        // Merged away to nothing, the record goes rather than holding every gathered token at a
+        // blank approval, which would render as no gloss and block the pool from offering one.
+        if (isEmptyTokenAnalysis(survivor)) {
+          removeAnalysisAndLinks(state, survivorAnalysisId);
+          return;
+        }
+
+        mergeIntoIdenticalPayload(state, survivor, now, true);
       },
     },
     /**
@@ -941,6 +1375,11 @@ export const {
   writeMorphemes,
   deleteMorphemes,
   writeMorphemeGloss,
+  writeAnalysisGloss,
+  writeAnalysisMorphemes,
+  writeAnalysisMorphemeGloss,
+  deleteAnalysis,
+  mergeAnalysesInto,
   approveAnalysisForToken,
   createPhrase,
   updatePhrase,
@@ -1054,6 +1493,104 @@ export const selectCatalogRows = createSelector(
     buildCatalogRows({ tokenAnalyses, tokenAnalysisLinks }, { analysisLanguage, currentBook }),
 );
 
+/**
+ * What deleting a `TokenAnalysis` would do to the tokens that approve it, so an irreversible delete
+ * can be confirmed with its concrete consequence rather than a generic "are you sure".
+ */
+export interface AnalysisDeletionOutcome {
+  /**
+   * `'blank'` when the affected tokens are left reading as unanalyzed, `'fallback'` when a
+   * surviving homograph takes over and they read as that instead.
+   */
+  kind: 'blank' | 'fallback';
+  /** How many tokens the deletion affects. */
+  usageCount: number;
+  /**
+   * What the affected tokens will read once the deletion commits. Absent when the surviving peer
+   * carries no gloss in the active analysis language, leaving no word to quote at the user.
+   */
+  fallbackGloss?: string;
+  /**
+   * Whether `fallbackGloss` is uncertain — some affected token cannot be shown to still carry the
+   * form the fallback was derived from, so it may come to read something else.
+   */
+  drifted?: boolean;
+  /**
+   * How many tokens record this analysis without approving it — assignments an import wrote that no
+   * surface displays. They go with the deletion like the approvals do.
+   */
+  unappliedCount: number;
+}
+
+/**
+ * Reports what {@link deleteAnalysis} would do to the given row, for the confirmation to name.
+ * Returns `undefined` when the id resolves to no payload, so a stale row cannot open a confirmation
+ * for a record that is already gone.
+ *
+ * Judges the fallback against the text as it now stands, read through `liveSurfaceText` — which
+ * covers the loaded book alone, giving `undefined` for a ref in any other.
+ */
+export function selectAnalysisDeletionOutcome(
+  state: AnalysisState,
+  analysisId: string,
+  liveSurfaceText: (tokenRef: string) => string | undefined,
+): AnalysisDeletionOutcome | undefined {
+  const analysis = state.analysis.tokenAnalyses.find((ta) => ta.id === analysisId);
+  if (!analysis) return undefined;
+
+  const approvedTokenCounts = selectApprovedTokenCountByAnalysisId(state);
+
+  // Counted off the same index the catalog row counts by, so the confirmation and the row it opened
+  // from cannot name two different numbers: both count the tokens an approval sits on rather than
+  // the approvals themselves.
+  //
+  // Non-approved links are left out of this number though the deletion drops them too: they are not
+  // places the analysis is applied, so counting one here would name a consequence no token displays.
+  const usageCount = approvedTokenCounts.get(analysisId) ?? 0;
+
+  // Counted by distinct token, matching usageCount, so a token an import recorded twice reads as the
+  // one place it is that the deletion touches.
+  const unappliedCount = new Set(
+    state.analysis.tokenAnalysisLinks
+      .filter((l) => l.analysisId === analysisId && l.status !== 'approved')
+      .map((l) => l.token.tokenRef),
+  ).size;
+
+  // The fallback is what the affected tokens come to read, so a record nothing approves has none
+  // however many homographs the pool still offers for its form.
+  if (usageCount === 0) return { kind: 'blank', usageCount, unappliedCount };
+
+  // Ask the engine, so the confirmation names the peer that actually wins. The payload is dropped
+  // from the pool outright rather than discounted by one approval: a deletion removes all of its
+  // approvals at once, and a discounted multi-token payload would compete to replace itself.
+  const survivingPool = buildPoolIndex(
+    selectAnalysisById(state),
+    new Map([...approvedTokenCounts].filter(([id]) => id !== analysisId)),
+  );
+
+  const fallback = deriveTokenSuggestion(survivingPool, analysis.surfaceText);
+  if (!fallback) return { kind: 'blank', usageCount, unappliedCount };
+
+  // A token lands on whatever its own live form leads to, not on the fallback derived above, so a
+  // token that has moved off that form — or that cannot be read to check — is one the confirmation
+  // must hedge over rather than promise a word to.
+  const analyzedForm = normalizeSurfaceForm(analysis.surfaceText);
+  const drifted = state.analysis.tokenAnalysisLinks.some((l) => {
+    if (l.analysisId !== analysisId || l.status !== 'approved') return false;
+    const live = liveSurfaceText(l.token.tokenRef);
+    return live === undefined || normalizeSurfaceForm(live) !== analyzedForm;
+  });
+
+  const gloss = fallback.suggested.gloss?.[state.analysisLanguage];
+  return {
+    kind: 'fallback',
+    usageCount,
+    unappliedCount,
+    ...(drifted ? { drifted } : {}),
+    ...(gloss ? { fallbackGloss: gloss } : {}),
+  };
+}
+
 /**
  * Returns the merged analysis the renderer shows for a token: its approved decision when one
  * exists, otherwise the engine's suggestion derived live from the approved-analysis pool, or
@@ -1106,21 +1643,24 @@ export function selectSuggestionAfterClearing(
 }
 
 /**
- * Reports whether removing `tokenRef`'s morpheme breakdown would destroy gloss data no other token
+ * Reports whether removing `tokenRef`'s morpheme breakdown would destroy annotation no other token
  * still holds — the condition under which the morpheme editor confirms before resetting. True only
- * when at least one morpheme carries a gloss AND this token is the sole approved link to its
- * payload. A payload shared with other tokens is forked rather than emptied by `deleteMorphemes`,
- * so the co-linked tokens keep their morphemes and nothing is lost project-wide; a breakdown with
- * no glosses is bare segmentation that is cheap to retype. Sharing is judged by the same
+ * when at least one morpheme carries a gloss or a lexicon reference AND this token is the sole
+ * approved link to its payload. A payload shared with other tokens is forked rather than emptied,
+ * so the co-linked tokens keep their morphemes and nothing is lost project-wide; an unannotated
+ * breakdown is bare segmentation that is cheap to retype. Sharing is judged by the same
  * approved-link count the write path tests before it forks, so the two can never disagree about
  * what "shared" means.
  */
-export function selectMorphemeResetLosesGlosses(state: AnalysisState, tokenRef: string): boolean {
+export function selectMorphemeResetLosesAnnotation(
+  state: AnalysisState,
+  tokenRef: string,
+): boolean {
   const approvedId = selectApprovedIdByTokenRef(state).get(tokenRef);
   if (approvedId === undefined) return false;
   const analysis = selectAnalysisById(state).get(approvedId);
-  const hasGlossedMorpheme = analysis?.morphemes?.some((m) => m.gloss !== undefined) ?? false;
-  if (!hasGlossedMorpheme) return false;
+  const hasAnnotatedMorpheme = analysis?.morphemes?.some(morphemeCarriesAnnotation) ?? false;
+  if (!hasAnnotatedMorpheme) return false;
   // A payload referenced by more than one approved link is forked rather than emptied, so only a
   // sole link loses anything.
   /* v8 ignore next -- approvedId comes from the map the counts are built from, so it is always present */
@@ -1128,6 +1668,25 @@ export function selectMorphemeResetLosesGlosses(state: AnalysisState, tokenRef:
   return approvedTokenCount <= 1;
 }
 
+/**
+ * Reports whether `tokenRef` is the only approved holder of its payload, so a breakdown edit here
+ * destroys what it drops instead of leaving it with co-linked tokens. False when the token has no
+ * approval at all.
+ *
+ * Sharing is judged by the same approved-link count a breakdown write forks on, so the two can
+ * never disagree about which edits are recoverable.
+ */
+export function selectMorphemePayloadIsSolelyOwned(
+  state: AnalysisState,
+  tokenRef: string,
+): boolean {
+  const approvedId = selectApprovedIdByTokenRef(state).get(tokenRef);
+  if (approvedId === undefined) return false;
+  /* v8 ignore next -- approvedId comes from the map the counts are built from, so it is always present */
+  const approvedTokenCount = selectApprovedTokenCountByAnalysisId(state).get(approvedId) ?? 0;
+  return approvedTokenCount <= 1;
+}
+
 const EMPTY_MORPHEMES: readonly MorphemeAnalysis[] = [];
 
 /**
diff --git a/src/utils/analysis-identity.ts b/src/utils/analysis-identity.ts
index 519a9a4ae..decbe62de 100644
--- a/src/utils/analysis-identity.ts
+++ b/src/utils/analysis-identity.ts
@@ -78,6 +78,44 @@ function morphemeIdentity(morpheme: MorphemeAnalysis) {
   return { form, gloss, entryRef, senseRef, allomorphRef, grammarRef };
 }
 
+/**
+ * Reports whether a morpheme carries annotation that only a person could restore — what an
+ * irreversible breakdown edit confirms before destroying. Its segmentation does not count, being
+ * cheap to retype and already on screen in the draft the reader is editing.
+ */
+export function morphemeCarriesAnnotation(morpheme: MorphemeAnalysis): boolean {
+  return (
+    morpheme.gloss !== undefined ||
+    morpheme.entryRef !== undefined ||
+    morpheme.senseRef !== undefined ||
+    morpheme.allomorphRef !== undefined ||
+    morpheme.grammarRef !== undefined
+  );
+}
+
+/**
+ * Re-segments a breakdown to `morphemes`, keeping a form the old breakdown already carried whole —
+ * its id, and everything a person put on it — so only a form with no counterpart there is minted
+ * fresh under `writingSystem`. A form repeated within one breakdown keeps a distinct old morpheme
+ * per occurrence rather than every occurrence collapsing onto the first.
+ */
+export function reconcileMorphemes(
+  old: readonly MorphemeAnalysis[] | undefined,
+  morphemes: readonly { id: string; form: string }[],
+  writingSystem: string,
+): MorphemeAnalysis[] {
+  const oldByForm = new Map<string, MorphemeAnalysis[]>();
+  (old ?? []).forEach((m) => {
+    const bucket = oldByForm.get(m.form);
+    if (bucket) bucket.push(m);
+    else oldByForm.set(m.form, [m]);
+  });
+  return morphemes.map(({ id, form }) => {
+    const kept = oldByForm.get(form)?.shift();
+    return kept ? { ...kept, writingSystem } : { id, form, writingSystem };
+  });
+}
+
 /**
  * Reports whether two token analyses carry the same meaning and so should share one stored payload
  * rather than being duplicated.
diff --git a/src/utils/analysis-query.ts b/src/utils/analysis-query.ts
index d80d3d823..9bf5f7f97 100644
--- a/src/utils/analysis-query.ts
+++ b/src/utils/analysis-query.ts
@@ -2,6 +2,8 @@ import { Canon } from '@sillsdev/scripture';
 import type {
   Confidence,
   MorphemeAnalysis,
+  MultiString,
+  SenseRef,
   TextAnalysis,
   TokenAnalysis,
   TokenAnalysisLink,
@@ -28,6 +30,10 @@ export interface CatalogRow {
    * none.
    */
   gloss: string;
+  /** Every gloss the analysis carries, the scope's analysis language among them. */
+  glosses?: MultiString;
+  /** Lexicon sense the whole analysis resolves to. */
+  glossSenseRef?: SenseRef;
   morphemes: readonly MorphemeAnalysis[];
   pos?: string;
   /** Morphosyntactic features, each feature name mapped to the analysis's value for it. */
@@ -234,6 +240,8 @@ export function buildCatalogRows(
       analysisId: ta.id,
       surfaceText: ta.surfaceText,
       gloss: glossForScope(ta, scope.analysisLanguage),
+      glosses: ta.gloss,
+      glossSenseRef: ta.glossSenseRef,
       morphemes: ta.morphemes ?? [],
       pos: ta.pos,
       features: ta.features,
@@ -400,6 +408,83 @@ function isActive<T>(selected: readonly T[] | undefined): selected is readonly T
   return selected !== undefined && selected.length > 0;
 }
 
+/**
+ * Drops from a selection every choice its facet no longer offers, or the whole selection when the
+ * facet is gone.
+ *
+ * @returns The selection itself when every choice survives; `undefined` where nothing is left to
+ *   keep, so an emptied selection reads as no filter rather than as one nothing satisfies.
+ */
+function retainOffered<T>(
+  selected: readonly T[] | undefined,
+  offered: readonly T[] | undefined,
+): readonly T[] | undefined {
+  if (!isActive(selected)) return undefined;
+  if (!offered) return undefined;
+  const kept = selected.filter((choice) => offered.includes(choice));
+  if (kept.length === selected.length) return selected;
+  return kept.length === 0 ? undefined : kept;
+}
+
+/** Whether two feature selections name the same values for the same features. */
+function sameFeatureSelections(
+  a: CatalogFilters['features'],
+  b: CatalogFilters['features'],
+): boolean {
+  const namesA = Object.keys(a ?? {});
+  const namesB = Object.keys(b ?? {});
+  if (namesA.length !== namesB.length) return false;
+  return namesA.every((name) => a?.[name] === b?.[name]);
+}
+
+/**
+ * Narrows a set of filters to the choices the facets still offer, so a selection cannot outlive the
+ * choice it names.
+ *
+ * A facet collapses as the rows behind it change — an edit that removes the last row in the only
+ * other book leaves {@link deriveFacets} offering no books facet at all — while the selection naming
+ * that book lives on. Left alone the pair strands the reader: the listing is narrowed to nothing by
+ * a filter whose control is no longer on screen to widen it back by.
+ *
+ * @returns The given filters unchanged when every selection is still offered, so storing the result
+ *   back over them settles rather than looping.
+ */
+export function reconcileFilters(filters: CatalogFilters, facets: CatalogFacets): CatalogFilters {
+  const features = Object.entries(filters.features ?? {}).reduce<
+    Record<string, readonly (string | undefined)[]>
+  >((acc, [name, values]) => {
+    const kept = retainOffered(values, facets.features?.[name]);
+    if (kept) acc[name] = kept;
+    return acc;
+  }, {});
+
+  const books = retainOffered(filters.books, facets.books);
+  const pos = retainOffered(filters.pos, facets.pos);
+  const confidence = retainOffered(filters.confidence, facets.confidence);
+  const keptFeatures = Object.keys(features).length === 0 ? undefined : features;
+
+  // Built field by field rather than by overriding a spread of `filters`: a withdrawn selection is
+  // absent rather than `undefined`, and spreading the original first would keep the stale key.
+  const reconciled: CatalogFilters = {
+    ...(filters.zeroUsages !== undefined && { zeroUsages: filters.zeroUsages }),
+    ...(filters.missingGloss !== undefined && { missingGloss: filters.missingGloss }),
+    ...(filters.morphemes !== undefined && { morphemes: filters.morphemes }),
+    ...(books && { books }),
+    ...(pos && { pos }),
+    ...(confidence && { confidence }),
+    ...(keptFeatures && { features: keptFeatures }),
+  };
+
+  // The value filters are the only ones a facet can withdraw: the remaining three are offered
+  // unconditionally, so nothing can strand them.
+  const isUnchanged =
+    books === filters.books &&
+    pos === filters.pos &&
+    confidence === filters.confidence &&
+    sameFeatureSelections(keptFeatures, filters.features);
+  return isUnchanged ? filters : reconciled;
+}
+
 /**
  * Whether a field holding one value at a time is in a state its selection accepts, carrying no
  * value being the state the selection's `undefined` choice accepts.
diff --git a/src/utils/merge-content.ts b/src/utils/merge-content.ts
new file mode 100644
index 000000000..2dba6ade4
--- /dev/null
+++ b/src/utils/merge-content.ts
@@ -0,0 +1,411 @@
+import type {
+  Confidence,
+  EntryRef,
+  MorphemeAnalysis,
+  MultiString,
+  TokenAnalysis,
+} from 'interlinearizer';
+import { analysesAreIdentical, reconcileMorphemes } from './analysis-identity';
+import type { CatalogRow } from './analysis-query';
+
+/**
+ * What a merge would write onto the surviving analysis, assembled from the ordered analyses and
+ * whatever the reader has typed over them.
+ */
+export interface MergedContentDraft {
+  /** Gloss in the analysis language, `''` when the merge would leave the survivor without one. */
+  gloss: string;
+  /**
+   * Analysis `gloss` was taken from, whose sense the survivor keeps resolving it through. Absent
+   * when the reader typed the gloss or the merge settled on none.
+   */
+  glossFromAnalysisId?: string;
+  morphemes: readonly MorphemeAnalysis[];
+  /** Settled from the merged analyses alone, no edit reaching it. */
+  pos?: string;
+  /** Settled from the merged analyses alone, no edit reaching them. */
+  features?: Readonly<Record<string, string>>;
+  confidence?: Confidence;
+}
+
+/**
+ * Stands for a field the reader emptied, which an optional field cannot say by holding `undefined`
+ * — that is how {@link MergeContentEdits} says the field was never touched. Emptying one is a
+ * decision that the merge should write nothing there, and no analysis may fill it back in.
+ */
+export const CLEARED = Symbol('cleared');
+
+/** A field's edit: what to write, or {@link CLEARED} to write nothing. */
+type Edited<T> = T | typeof CLEARED;
+
+/** What the reader has typed over the derived content, each field absent until they touch it. */
+export interface MergeContentEdits {
+  gloss?: string;
+  /**
+   * The breakdown as a list of forms alone — a form this leaves standing keeps the morpheme it had,
+   * gloss and lexicon references included.
+   */
+  morphemeForms?: readonly string[];
+  /**
+   * Each morpheme's gloss by its place in the breakdown, so two occurrences of one repeated form
+   * are edited apart. A blank entry records that the morpheme should carry no gloss, which no donor
+   * may fill in.
+   */
+  morphemeGlosses?: Readonly<Record<number, string>>;
+  confidence?: Edited<Confidence>;
+}
+
+/**
+ * Carries the gloss edits typed against the breakdown `from` over to the forms of `to`, so an edit
+ * stays on the form it was made about. An edit whose form `to` does not reach is dropped, there
+ * being no morpheme left for it to be about, and a repeated form's occurrences stay distinct.
+ */
+export function remapMorphemeGlossEdits(
+  glossEdits: Readonly<Record<number, string>> | undefined,
+  from: readonly MorphemeAnalysis[],
+  to: readonly string[],
+): Readonly<Record<number, string>> | undefined {
+  if (!glossEdits) return undefined;
+
+  const editsOfForm = new Map<string, string[]>();
+  from.forEach((m, index) => {
+    const edit = glossEdits[index];
+    if (edit === undefined) return;
+    const bucket = editsOfForm.get(m.form);
+    if (bucket) bucket.push(edit);
+    else editsOfForm.set(m.form, [edit]);
+  });
+
+  const remapped: Record<number, string> = {};
+  to.forEach((form, index) => {
+    const edit = editsOfForm.get(form)?.shift();
+    if (edit !== undefined) remapped[index] = edit;
+  });
+  return Object.keys(remapped).length > 0 ? remapped : undefined;
+}
+
+/** The state a merge panel derives its content from. */
+export interface MergeContentInput {
+  /** The analyses of the form, the survivor first — the order fallback reads down. */
+  order: readonly CatalogRow[];
+  /** Which analyses the merge would fold in, the survivor always among them. */
+  checked: ReadonlySet<string>;
+  edits: MergeContentEdits;
+  /** BCP 47 tag the glosses are read and written under. */
+  analysisLanguage: string;
+  /** Writing system a re-split breakdown's minted morphemes are recorded under. */
+  sourceLanguageTag: string;
+}
+
+/**
+ * Whether the merge may be confirmed, and what stands in its way or awaits it.
+ *
+ * A merge that would converge is allowed rather than refused — the collapse is what the store does
+ * with two records saying the same thing, and the reader can mean it — and names the record it
+ * would absorb.
+ */
+export type MergeVerdict =
+  | { canConfirm: false; reason: 'nothing-checked'; collapsingAnalysisId?: undefined }
+  | { canConfirm: true; reason: 'will-collapse'; collapsingAnalysisId: string }
+  | { canConfirm: true; reason?: undefined; collapsingAnalysisId?: undefined };
+
+/** What the panel shows and what confirming it would do. */
+export interface MergeContentDerivation {
+  /** The content the merge would write, which is what the editable fields are filled from. */
+  content: MergedContentDraft;
+  verdict: MergeVerdict;
+}
+
+/** How a reorder leaves the arrangement and the merge set. */
+export interface MergeReorder {
+  /** The analyses most-preferred first, the survivor at its head. */
+  orderedIds: readonly string[];
+  /** The analyses folded in besides the survivor. */
+  mergedIds: ReadonlySet<string>;
+}
+
+/**
+ * Moves one analysis to a new place in the arrangement, keeping the merge set honest about what the
+ * move did: an analysis displaced from the head was going to survive, so it stays in the merge
+ * rather than dropping out of it, and the one taking its place leaves the set it now heads.
+ *
+ * Moving an analysis to where it already sits changes nothing.
+ */
+export function reorderForMerge(
+  current: MergeReorder,
+  analysisId: string,
+  toIndex: number,
+): MergeReorder {
+  const from = current.orderedIds.indexOf(analysisId);
+  if (from === -1 || from === toIndex) return current;
+
+  const orderedIds = [...current.orderedIds];
+  orderedIds.splice(from, 1);
+  orderedIds.splice(toIndex, 0, analysisId);
+
+  const [survivor] = current.orderedIds;
+  const [nextSurvivor] = orderedIds;
+  if (nextSurvivor === survivor) return { orderedIds, mergedIds: current.mergedIds };
+
+  const mergedIds = new Set(current.mergedIds);
+  mergedIds.add(survivor);
+  mergedIds.delete(nextSurvivor);
+  return { orderedIds, mergedIds };
+}
+
+/** Whether two references name one lexicon entry. */
+function sameEntry(a: EntryRef | undefined, b: EntryRef | undefined): boolean {
+  return (
+    a !== undefined &&
+    b !== undefined &&
+    a.authority === b.authority &&
+    a.projectId === b.projectId &&
+    a.entryId === b.entryId
+  );
+}
+
+/**
+ * A row read as the stored analysis it stands for, so convergence is judged by the same rule the
+ * store dedupes by rather than by a second definition of sameness that could drift from it.
+ *
+ * The id and timestamps are placeholders, sameness resting on content alone.
+ */
+function asAnalysis(
+  content: Pick<CatalogRow, 'glosses' | 'glossSenseRef' | 'morphemes' | 'pos' | 'features'>,
+  surfaceText: string,
+): TokenAnalysis {
+  return {
+    id: '',
+    createdAt: '',
+    updatedAt: '',
+    surfaceText,
+    gloss: content.glosses,
+    glossSenseRef: content.glossSenseRef,
+    morphemes: [...content.morphemes],
+    pos: content.pos,
+    features: content.features ? { ...content.features } : undefined,
+  };
+}
+
+/**
+ * The glosses and sense the merge would leave the survivor holding: only the analysis language is
+ * the reader's to settle, and what rides along untouched is what tells the survivor apart from a
+ * record reading the same in the listed language.
+ */
+function settledGlossContent(
+  content: MergedContentDraft,
+  survivor: CatalogRow,
+  donors: readonly CatalogRow[],
+  analysisLanguage: string,
+): Pick<CatalogRow, 'glosses' | 'glossSenseRef'> {
+  const glosses: MultiString = {};
+  [...donors].reverse().forEach((d) => Object.assign(glosses, d.glosses));
+  Object.assign(glosses, survivor.glosses);
+
+  if (content.gloss) glosses[analysisLanguage] = content.gloss;
+  else delete glosses[analysisLanguage];
+
+  return {
+    glosses: Object.keys(glosses).length > 0 ? glosses : undefined,
+    glossSenseRef: donors.find((d) => d.analysisId === content.glossFromAnalysisId)?.glossSenseRef,
+  };
+}
+
+/**
+ * Whether the merge may go ahead, and what qualifies it: a merge needs something to fold in beyond
+ * the survivor, an edit on its own being no merge at all, and one that would converge is allowed
+ * but named so it can be said what is about to be absorbed.
+ */
+function verdictFor(
+  donors: readonly CatalogRow[],
+  collapsingAnalysisId: string | undefined,
+): MergeVerdict {
+  if (donors.length < 2) return { canConfirm: false, reason: 'nothing-checked' };
+  if (collapsingAnalysisId)
+    return { canConfirm: true, reason: 'will-collapse', collapsingAnalysisId };
+  return { canConfirm: true };
+}
+
+/**
+ * The breakdown the checked analyses derive, before any re-split of the reader's stands over it.
+ *
+ * Taken whole rather than assembled morpheme by morpheme: a breakdown is one reading of the word,
+ * and forms drawn from two of them would segment it a way no analysis actually claims.
+ */
+export function deriveBreakdown(
+  order: readonly CatalogRow[],
+  checked: ReadonlySet<string>,
+): readonly MorphemeAnalysis[] {
+  return (
+    order
+      .filter((r) => checked.has(r.analysisId))
+      .map((r) => r.morphemes)
+      .find((forms) => forms.length > 0) ?? []
+  );
+}
+
+/**
+ * Assembles the content a merge would write from the ordered analyses, the reader's edits over
+ * them, and which analyses are being folded in.
+ *
+ * A field the survivor lacks is filled from the next analysis down that has one, which is why the
+ * order is the reader's to arrange: it ranks the donors. Only analyses being folded in may donate —
+ * one left unchecked survives on its own and has no business putting content into another record.
+ */
+export function deriveMergeContent({
+  order,
+  checked,
+  edits,
+  analysisLanguage,
+  sourceLanguageTag,
+}: MergeContentInput): MergeContentDerivation {
+  const donors = order.filter((r) => checked.has(r.analysisId));
+
+  /** The first donor's value for a field, the survivor's own coming first among them. */
+  const donated = <T>(read: (r: CatalogRow) => T | undefined): T | undefined =>
+    donors.map(read).find((value) => value !== undefined);
+
+  const derivedBreakdown = deriveBreakdown(order, checked);
+
+  // A breakdown edit supplies forms alone, so a form it leaves standing keeps the morpheme it had,
+  // lexicon references and all, rather than being rebuilt as a bare form.
+  const breakdown: readonly MorphemeAnalysis[] = edits.morphemeForms
+    ? reconcileMorphemes(
+        derivedBreakdown,
+        edits.morphemeForms.map((form, index) => ({ id: `merged-${index}`, form })),
+        sourceLanguageTag,
+      )
+    : derivedBreakdown;
+
+  /**
+   * What the checked analyses say about each occurrence of each form, the highest-ranked donor's
+   * first — keyed by the occurrence and not the form alone, so a repeated form's second occurrence
+   * draws what a donor said about _its_ second, rather than an annotation already spoken for.
+   */
+  const donatedMorphemes = new Map<string, MorphemeAnalysis[]>();
+  donors.forEach((r) => {
+    const seenOfForm = new Map<string, number>();
+    r.morphemes.forEach((m) => {
+      const occurrence = seenOfForm.get(m.form) ?? 0;
+      seenOfForm.set(m.form, occurrence + 1);
+      const key = `${occurrence}${m.form}`;
+      const bucket = donatedMorphemes.get(key);
+      if (bucket) bucket.push(m);
+      else donatedMorphemes.set(key, [m]);
+    });
+  });
+
+  /** The first donation of one morpheme field, the morpheme's own value coming first. */
+  const donatedField = <T>(
+    own: T | undefined,
+    donations: readonly MorphemeAnalysis[],
+    read: (m: MorphemeAnalysis) => T | undefined,
+  ): T | undefined => own ?? donations.map(read).find((value) => value !== undefined);
+
+  /**
+   * A morpheme's lexicon references, always describing one entry: a sense, an allomorph and a
+   * grammar reference are scoped by their entry, so drawn from whichever donor happened to define
+   * each they would name parts of entries the morpheme does not resolve to.
+   *
+   * A morpheme resolving to no entry keeps its own references, which are all the merge can say when
+   * nothing names an entry to scope them.
+   */
+  const donatedLexicon = (
+    m: MorphemeAnalysis,
+    donations: readonly MorphemeAnalysis[],
+  ): Pick<MorphemeAnalysis, 'entryRef' | 'senseRef' | 'allomorphRef' | 'grammarRef'> => {
+    const entryRef = donatedField(m.entryRef, donations, (d) => d.entryRef);
+    if (entryRef === undefined)
+      return {
+        entryRef,
+        senseRef: m.senseRef,
+        allomorphRef: m.allomorphRef,
+        grammarRef: m.grammarRef,
+      };
+
+    const ofEntry = sameEntry(m.entryRef, entryRef) ? m : undefined;
+    const scoped = donations.filter((d) => sameEntry(d.entryRef, entryRef));
+    return {
+      entryRef,
+      senseRef: donatedField(ofEntry?.senseRef, scoped, (d) => d.senseRef),
+      allomorphRef: donatedField(ofEntry?.allomorphRef, scoped, (d) => d.allomorphRef),
+      grammarRef: donatedField(ofEntry?.grammarRef, scoped, (d) => d.grammarRef),
+    };
+  };
+
+  /** How many of each form the breakdown has reached, which picks the donation it draws. */
+  const seenOfForm = new Map<string, number>();
+
+  // Annotation fills in per morpheme, matched by form: unlike the segmentation, what a morpheme
+  // means and what it resolves to in the lexicon is said of the morpheme itself, which a donor that
+  // reached the same form is saying about the same thing. Only a morpheme still lacking a value
+  // takes a donation, the reader's own edits outranking both.
+  const morphemes = breakdown.map((m, index) => {
+    const occurrence = seenOfForm.get(m.form) ?? 0;
+    seenOfForm.set(m.form, occurrence + 1);
+    const donations = donatedMorphemes.get(`${occurrence}${m.form}`) ?? [];
+
+    // Every tag but the analysis language settles here, that one alone being the reader's to edit.
+    const otherGlosses: Record<string, string> = {};
+    [...donations].reverse().forEach((d) => Object.assign(otherGlosses, d.gloss));
+    Object.assign(otherGlosses, m.gloss);
+    delete otherGlosses[analysisLanguage];
+
+    const carried: MorphemeAnalysis = {
+      ...m,
+      ...donatedLexicon(m, donations),
+      gloss: Object.keys(otherGlosses).length > 0 ? otherGlosses : undefined,
+    };
+
+    const settledGloss = donatedField(
+      m.gloss?.[analysisLanguage],
+      donations,
+      (d) => d.gloss?.[analysisLanguage],
+    );
+    const gloss = edits.morphemeGlosses?.[index] ?? settledGloss;
+    // A blank edit empties the gloss rather than leaving whatever the morpheme arrived carrying:
+    // emptying one is a decision that it should carry none, which is what no gloss at all says.
+    if (gloss === undefined || gloss.trim() === '') return carried;
+    return { ...carried, gloss: { ...carried.gloss, [analysisLanguage]: gloss } };
+  });
+
+  /** One optional field's settled value: its edit where there is one, else what a donor gives. */
+  const settled = <T>(edit: Edited<T> | undefined, read: (r: CatalogRow) => T | undefined) => {
+    if (edit === CLEARED) return undefined;
+    return edit ?? donated(read);
+  };
+
+  /** The highest-ranked donor carrying a gloss, which is the one an unedited merge settles on. */
+  const glossDonor = donors.find((r) => r.gloss !== '');
+
+  // An edit stands whatever the analyses say, a blank one included: emptying a field is a decision
+  // about what the merge should write, not an absence for a lower analysis to fill.
+  const gloss = edits.gloss ?? glossDonor?.gloss ?? '';
+
+  const content: MergedContentDraft = {
+    gloss,
+    // Named only where a donor supplied the settled text: a gloss the reader composed resolves
+    // through no lexicon sense of theirs.
+    glossFromAnalysisId:
+      edits.gloss === undefined && gloss !== '' ? glossDonor?.analysisId : undefined,
+    morphemes,
+    pos: donated((r) => r.pos),
+    features: donated((r) => r.features),
+    confidence: settled(edits.confidence, (r) => r.confidence),
+  };
+
+  const [survivor] = order;
+
+  // Judged against what the merge would leave standing, so a record being folded in is not read as
+  // a record the survivor is about to collide with.
+  const written = asAnalysis(
+    { ...content, ...settledGlossContent(content, survivor, donors, analysisLanguage) },
+    survivor.surfaceText,
+  );
+  const collapsing = order.find(
+    (r) =>
+      !checked.has(r.analysisId) && analysesAreIdentical(written, asAnalysis(r, r.surfaceText)),
+  );
+
+  return { content, verdict: verdictFor(donors, collapsing?.analysisId) };
+}