fix(tui): keep a repeated kill on the caret hole

The longest common prefix of a repeated span is the other copy, and
parking the caret there yanks into the wrong hole. Prefer the span the
native caret already sits on, and fall back to that prefix only when a
snapped wide cell left the caret on none of them.

Refs CL-10644

Author: TheGreatAxios

src/tui/prompt-kill-ring.test.ts

@@ -60,6 +60,27 @@ describe("removedByDelete", () => {
   test("a replacement that is not a pure deletion records nothing", () => {
     expect(removedByDelete("abcd", "abXd")).toEqual({ text: "", at: 0 });
   });
+
+  test("a repeated prefix uses the caret hole, not the other copy", () => {
+    const hole = {
+      caret: 0,
+      measure: (text: string) => text.length,
+    };
+    expect(removedByDelete("hello hello", "hello", hole)).toEqual({
+      text: "hello ",
+      at: 0,
+    });
+    expect(removedByDelete("aaa", "aa", hole)).toEqual({ text: "a", at: 0 });
+  });
+
+  test("a caret that sits on no hole keeps the longest common prefix", () => {
+    expect(
+      removedByDelete("hello hello", "hello", {
+        caret: 7,
+        measure: (text: string) => text.length,
+      }),
+    ).toEqual({ text: " hello", at: 5 });
+  });
 });
 
 describe("rotateYank", () => {
@@ -192,6 +213,56 @@ describe("prompt kill ring chords", () => {
     });
   });
 
+  test("ctrl+u on a repeated prefix kills the span at the caret", async () => {
+    await withTestRenderer(async (h) => {
+      const shell = createAppShell(h.renderer, {
+        terminal: { columns: 80, rows: 24 },
+        run: "idle",
+      });
+      shell.prompt.value = "hello hello";
+      shell.prompt.cursorOffset = 6;
+      h.pressKey("u", { ctrl: true });
+      expect(shell.prompt.value).toBe("hello");
+      expect(shell.prompt.cursorOffset).toBe(0);
+      expect(shell.promptKillRing.entries[0]).toBe("hello ");
+      h.pressKey("y", { ctrl: true });
+      expect(shell.prompt.value).toBe("hello hello");
+    });
+  });
+
+  test("ctrl+u inside a run of the same character leaves the caret at the hole", async () => {
+    await withTestRenderer(async (h) => {
+      const shell = createAppShell(h.renderer, {
+        terminal: { columns: 80, rows: 24 },
+        run: "idle",
+      });
+      shell.prompt.value = "aaa";
+      shell.prompt.cursorOffset = 1;
+      h.pressKey("u", { ctrl: true });
+      expect(shell.prompt.value).toBe("aa");
+      expect(shell.prompt.cursorOffset).toBe(0);
+      h.pressKey("x");
+      expect(shell.prompt.value).toBe("xaa");
+    });
+  });
+
+  test("ctrl+u on a unique prefix still kills that prefix", async () => {
+    await withTestRenderer(async (h) => {
+      const shell = createAppShell(h.renderer, {
+        terminal: { columns: 80, rows: 24 },
+        run: "idle",
+      });
+      shell.prompt.value = "hello world";
+      shell.prompt.cursorOffset = 6;
+      h.pressKey("u", { ctrl: true });
+      expect(shell.prompt.value).toBe("world");
+      expect(shell.prompt.cursorOffset).toBe(0);
+      expect(shell.promptKillRing.entries[0]).toBe("hello ");
+      h.pressKey("z", { shift: true });
+      expect(shell.prompt.value).toBe("Zworld");
+    });
+  });
+
   test("ctrl+k then ctrl+y on a parked wide glyph leaves it unchanged", async () => {
     await withTestRenderer(async (h) => {
       const shell = createAppShell(h.renderer, {

src/tui/prompt-kill-ring.ts

@@ -123,10 +123,17 @@ export function rotateYank(
  * prediction yanks text the buffer never lost. `text` is empty when nothing
  * was deleted or the change is not a pure deletion. `at` is the code-unit
  * index of the span in `before` (and where it splices back into `after`).
+ *
+ * A repeated span has more than one such index. The longest common prefix
+ * is the rightmost, which is the other copy. `hole` is the native caret in
+ * `after` (display cells, via `measure`). The span whose splice point lands
+ * on that caret wins; if the caret sits on none of them, the longest common
+ * prefix stands so a snapped wide cell can still be parked.
  */
 export function removedByDelete(
   before: string,
   after: string,
+  hole?: { caret: number; measure: (text: string) => number },
 ): { text: string; at: number } {
   if (after.length > before.length || before === after)
     return { text: "", at: 0 };
@@ -146,5 +153,22 @@ export function removedByDelete(
   if (after !== `${before.slice(0, at)}${before.slice(beforeEnd)}`) {
     return { text: "", at: 0 };
   }
-  return { text: before.slice(at, beforeEnd), at };
+  const removedLen = beforeEnd - at;
+  let chosen = at;
+  if (hole !== undefined && removedLen > 0) {
+    let min = at;
+    while (
+      min > 0 &&
+      before.charCodeAt(min - 1) === before.charCodeAt(min - 1 + removedLen)
+    ) {
+      min -= 1;
+    }
+    for (let candidate = min; candidate < at; candidate += 1) {
+      if (hole.measure(after.slice(0, candidate)) === hole.caret) {
+        chosen = candidate;
+        break;
+      }
+    }
+  }
+  return { text: before.slice(chosen, chosen + removedLen), at: chosen };
 }

src/tui/shell/keys.ts

@@ -318,13 +318,18 @@ function killThenRecord(
   const before = shell.prompt.value;
   remove(shell.prompt);
   const after = shell.prompt.value;
-  const removal = removedByDelete(before, after);
-  // deleteRange can leave the caret past a grapheme it snapped off. Yank
+  const measure = (prefix: string): number =>
+    shell.prompt.editBuffer.measureText(prefix);
+  const removal = removedByDelete(before, after, {
+    caret: shell.prompt.cursorOffset,
+    measure,
+  });
+  // A snapped wide cell leaves the caret off the grapheme it dropped. Yank
   // inserts at the caret, so park it where the lost span splices back in.
+  // When the native caret already sits on that hole, this is a no-op and
+  // does not slide it onto the other copy of a repeated prefix.
   if (removal.text.length > 0) {
-    shell.prompt.cursorOffset = shell.prompt.editBuffer.measureText(
-      after.slice(0, removal.at),
-    );
+    shell.prompt.cursorOffset = measure(after.slice(0, removal.at));
   }
   shell.promptKillRing = recordKill(
     shell.promptKillRing,