feat(input): atomic placeholder delete on backspace/deleteForward

Backspacing at the right edge of a paste placeholder used to chip off the
closing bracket, leaving a fragment that wouldn't re-expand on submit.
Detect a complete placeholder hugging the cursor and delete it as one
atomic unit, garbage-collecting the side-map entry at the same time.
deleteForward gets the symmetric treatment for the left edge.

Author: halfaipg

src/ui/input-state.test.ts

@@ -316,3 +316,70 @@ describe("insertPaste + expandPastes", () => {
 		expect(after).toEqual(before);
 	});
 });
+
+describe("atomic placeholder deletion", () => {
+	it("backspace at the right edge of a placeholder removes the whole placeholder", () => {
+		let s = insertPaste(initialInputState(), "abc\ndef\nghi");
+		const before = s.buffer; // "[Pasted #1 · 3 lines]"
+		s = backspace(s);
+		expect(s.buffer).toBe("");
+		expect(s.cursor).toBe(0);
+		expect(s.pastedContents[1]).toBeUndefined();
+		// Sanity: prior state actually held the placeholder
+		expect(before).toBe("[Pasted #1 · 3 lines]");
+	});
+
+	it("backspace garbage-collects the side entry for the deleted placeholder", () => {
+		let s = insertPaste(initialInputState(), "x".repeat(500));
+		expect(Object.keys(s.pastedContents)).toHaveLength(1);
+		s = backspace(s);
+		expect(Object.keys(s.pastedContents)).toHaveLength(0);
+	});
+
+	it("backspace deletes only the adjacent placeholder, leaving siblings intact", () => {
+		let s = insertPaste(initialInputState(), "first one");
+		for (const ch of " then ") s = insertChar(s, ch);
+		s = insertPaste(s, "second one is longer than the first paste here");
+		// Cursor is at the end, right after the second placeholder.
+		s = backspace(s);
+		// Second placeholder removed; first remains intact.
+		expect(s.buffer).toBe("[Pasted #1 · 9 chars] then ");
+		expect(s.pastedContents[1]).toBeDefined();
+		expect(s.pastedContents[2]).toBeUndefined();
+	});
+
+	it("deleteForward at the left edge of a placeholder removes the whole placeholder", () => {
+		let s = insertPaste(initialInputState(), "foo\nbar");
+		s = moveStart(s);
+		s = deleteForward(s);
+		expect(s.buffer).toBe("");
+		expect(s.pastedContents[1]).toBeUndefined();
+	});
+
+	it("backspace in the middle of a placeholder still chips one char (non-edge)", () => {
+		// Cursor inside the placeholder, not at the right edge — fall back
+		// to normal char-by-char behavior. The placeholder is now broken
+		// but expandPastes will leave the fragment as-is on submit.
+		let s = insertPaste(initialInputState(), "hello");
+		s = moveLeft(s); // cursor now between "]" and end? no, one before end
+		s = backspace(s);
+		// We removed one char from the middle, breaking the placeholder.
+		expect(s.buffer.length).toBe(s.buffer.length);
+		expect(s.buffer).not.toBe("[Pasted #1 · 5 chars]"); // broken
+		expect(s.pastedContents[1]).toBeDefined(); // entry NOT garbage-collected
+	});
+
+	it("backspace at a position where the buffer looks like a placeholder but isn't ours just chips a char", () => {
+		// User literally typed [Pasted #999 · 5 chars] — we have no id 999,
+		// but we still detect placeholder shape via the regex. Decision:
+		// trust the shape, garbage-collect won't find an entry to remove
+		// (no-op on the side map), but the visible delete is atomic.
+		// That's defensible: shape matches user intent.
+		let s = initialInputState();
+		for (const ch of "[Pasted #999 · 5 chars]") s = insertChar(s, ch);
+		s = backspace(s);
+		expect(s.buffer).toBe("");
+		// pastedContents was empty — nothing to drop.
+		expect(s.pastedContents).toEqual({});
+	});
+});

src/ui/input-state.ts

@@ -62,6 +62,39 @@ export function looksLikePaste(input: string): boolean {
 }
 
 const PASTE_PLACEHOLDER_RE = /\[Pasted #(\d+) · \d+ (?:lines|chars)\]/g;
+/** Anchored variants used to detect a placeholder hugging the cursor on either side. */
+const PASTE_PLACEHOLDER_RE_END = /\[Pasted #(\d+) · \d+ (?:lines|chars)\]$/;
+const PASTE_PLACEHOLDER_RE_START = /^\[Pasted #(\d+) · \d+ (?:lines|chars)\]/;
+
+/**
+ * If the buffer slice ending at `pos` finishes with a complete placeholder,
+ * return its start offset and id. Used by backspace to delete a whole
+ * placeholder atomically instead of chipping at the closing bracket.
+ */
+function placeholderEndingAt(buffer: string, pos: number): { start: number; id: number } | undefined {
+	const before = buffer.slice(0, pos);
+	const m = before.match(PASTE_PLACEHOLDER_RE_END);
+	if (!m) return undefined;
+	return { start: pos - m[0].length, id: Number.parseInt(m[1], 10) };
+}
+
+/**
+ * If the buffer slice starting at `pos` begins with a complete placeholder,
+ * return its end offset and id. Used by deleteForward.
+ */
+function placeholderStartingAt(buffer: string, pos: number): { end: number; id: number } | undefined {
+	const after = buffer.slice(pos);
+	const m = after.match(PASTE_PLACEHOLDER_RE_START);
+	if (!m) return undefined;
+	return { end: pos + m[0].length, id: Number.parseInt(m[1], 10) };
+}
+
+function dropPasteEntry(map: Record<number, PastedContent>, id: number): Record<number, PastedContent> {
+	if (!(id in map)) return map;
+	const next = { ...map };
+	delete next[id];
+	return next;
+}
 
 /**
  * Render the placeholder shown in the visible buffer when text is pasted.
@@ -136,6 +169,20 @@ export function insertChar(state: InputState, ch: string): InputState {
 
 export function backspace(state: InputState): InputState {
 	if (state.cursor === 0) return state;
+	// Atomic placeholder delete: backspacing at the right edge of a paste
+	// placeholder removes the whole placeholder instead of breaking off
+	// the closing bracket and leaving a fragment that won't re-expand.
+	const ph = placeholderEndingAt(state.buffer, state.cursor);
+	if (ph) {
+		return {
+			...state,
+			buffer: state.buffer.slice(0, ph.start) + state.buffer.slice(state.cursor),
+			cursor: ph.start,
+			pastedContents: dropPasteEntry(state.pastedContents, ph.id),
+			undoStack: pushUndo(state),
+			lastAction: "delete",
+		};
+	}
 	return {
 		...state,
 		buffer: state.buffer.slice(0, state.cursor - 1) + state.buffer.slice(state.cursor),
@@ -147,6 +194,17 @@ export function backspace(state: InputState): InputState {
 
 export function deleteForward(state: InputState): InputState {
 	if (state.cursor >= state.buffer.length) return state;
+	// Atomic placeholder delete on forward-delete from the left edge.
+	const ph = placeholderStartingAt(state.buffer, state.cursor);
+	if (ph) {
+		return {
+			...state,
+			buffer: state.buffer.slice(0, state.cursor) + state.buffer.slice(ph.end),
+			pastedContents: dropPasteEntry(state.pastedContents, ph.id),
+			undoStack: pushUndo(state),
+			lastAction: "delete",
+		};
+	}
 	return {
 		...state,
 		buffer: state.buffer.slice(0, state.cursor) + state.buffer.slice(state.cursor + 1),