Ask before a re-split strands a glossed morpheme

Both breakdown editors now name the forms whose glosses a re-split would
drop
and confirm first, matching the prompt each already showed for clearing
a
breakdown outright. The token editor skips the prompt for a shared
payload,
which the write forks rather than re-segmenting in place.

Author: alex-rawlings-yyc

contributions/localizedStrings.json

@@ -60,6 +60,8 @@
       "%interlinearizer_analysisCatalog_editMorphemesOpen%": "Edit breakdown for {form}",
       "%interlinearizer_analysisCatalog_confirmResetPrompt%": "Discard this breakdown and its glosses everywhere {form} is used?",
       "%interlinearizer_analysisCatalog_confirmResetAction%": "Discard breakdown",
+      "%interlinearizer_analysisCatalog_confirmResplitPrompt%": "This breakdown drops {forms}, discarding the glosses on it 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 every use of this analysis.",
       "%interlinearizer_analysisCatalog_merge%": "Merge…",
@@ -118,6 +120,8 @@
       "%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}",
       "%interlinearizer_tokenChip_editMorphemes%": "Edit morpheme breakdown for {token}",
       "%interlinearizer_tokenChip_defineMorphemes%": "Define morpheme breakdown for {token}",

src/__tests__/components/AnalysisCatalogPanel.test.tsx

@@ -1712,6 +1712,63 @@ describe('AnalysisCatalogPanel', () => {
       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 userEvent.click(within(row).getByTestId('catalog-row-breakdown-open'));
+      const input = within(rowFor('ta-1')).getByTestId('catalog-row-breakdown-input');
+      await userEvent.clear(input);
+      await userEvent.type(input, forms);
+      await userEvent.click(within(rowFor('ta-1')).getByTestId('catalog-row-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('catalog-row-breakdown-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('catalog-row-breakdown-save'));
+
+      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('catalog-row-breakdown-cancel'));
+
+      expect(onSave).not.toHaveBeenCalled();
+      expect(within(rowFor('ta-1')).getByTestId('catalog-row-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 });
 

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]);
 });
@@ -450,6 +459,110 @@ 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(),
+        surfaceText: 'unbelievable',
+        ...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>

src/__tests__/components/TokenChip.test.tsx

@@ -23,14 +23,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>
@@ -689,6 +696,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')

src/__tests__/store/analysisSlice.test.ts

@@ -1,6 +1,7 @@
 /// <reference types="jest" />
 
 import type {
+  MorphemeAnalysis,
   PhraseAnalysisLink,
   SegmentAnalysis,
   SegmentAnalysisLink,
@@ -18,11 +19,13 @@ import {
   deletePhrase,
   mergeAnalysisInto,
   mergePhrases,
+  morphemeFormsLostByResplit,
   selectAnalysisDeletionOutcome,
   selectAnalysisMergePeers,
   selectApprovedGloss,
   selectApprovedMorphemes,
   selectCatalogRows,
+  selectMorphemePayloadIsSolelyOwned,
   selectMorphemeResetLosesGlosses,
   selectPhraseLinkByTokenRef,
   selectPhraseGloss,
@@ -2337,6 +2340,73 @@ describe('selectMorphemeResetLosesGlosses', () => {
   });
 });
 
+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 no gloss', () => {
+    // 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('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([]);
+  });
+});
+
 describe('analysis timestamps', () => {
   const FIRST_WRITE = '2026-04-01T09:00:00.000Z';
   const SECOND_WRITE = '2026-04-02T10:30:00.000Z';