From e11048c20a50b67841e648a4d5ddd7490bc9c9b7 Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Mon, 28 Sep 2026 13:24:06 -0300
Subject: Paint into a target Surface instead of swapping the frame's out

The painters of a pane's body and tag (renderBody and its selection,
gutter, syntax, ANSI and wrap-marker passes; paintPaneTag; paintHeaders;
renderPane; the image and PDF grid paths) take the Surface they paint as a
parameter. The body layer and the tag layers paint straight into their own
temporary surfaces, and the std.mem.swap of p.surface around those calls is
gone. No behaviour change.
---
 src/Terminal.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/Terminal.zig')

diff --git a/src/Terminal.zig b/src/Terminal.zig
index cd292e5f..62a77ca8 100644
--- a/src/Terminal.zig
+++ b/src/Terminal.zig
@@ -5,6 +5,7 @@ const std = @import("std");
 const pardes = @import("pardes.zig");
 const config = @import("config.zig");
 const Pardes = pardes.Pardes;
+const Surface = pardes.Surface;
 const modal = @import("modal.zig");
 const tracy = @import("tracy.zig");
 const dump = @import("dump.zig");
@@ -1756,11 +1757,10 @@ const Anchor = struct {
     }
 };
 
-pub fn recolorAnsi(p: *Pardes, pane: *Pane, r: pardes.Rect, tx: u16, tw: u16, body_h: u16, body: []const u8) void {
+pub fn recolorAnsi(p: *Pardes, s: *Surface, pane: *Pane, r: pardes.Rect, tx: u16, tw: u16, body_h: u16, body: []const u8) void {
     // No emulator, no ANSI cells: the whole pass — and the 256-colour theme
     // projection behind it — is compiled out.
     if (comptime !enabled) return;
-    const s = &p.surface;
     if (pane.terminal == null) return;
     const body_y = p.bodyTop(pane, r);
     var filtered_storage: FilteredColors = undefined;
-- 
cgit v1.3


From c811c34ed3bcd23954414125b45c7cac67307d5d Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Mon, 28 Sep 2026 16:04:12 -0300
Subject: Every range lives through insert mode, carried through each edit

Insert mode dropped the selection on the first key and restored only the
primary's appended-over span on Esc. Now each insert-mode edit is made at the
bare cursor as before, and the range is then carried through it with helix's
Range::map rules: typing slides an i range and stretches an a range, Enter
(which now also drops the blanks before the cursor, as helix does) slides or
stretches by what the cursor moved, and an arrow collapses. The replay gives
every other range the same. Esc after a pulls each range's end back by one
(helix restore_cursor), which replaces Text.append_at. The wiX-edit-drops-sel
and msel-append waivers are gone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/helix-keys.md         |  36 ++++++++-----
 docs/selections.md         |  22 +++++---
 src/Output.zig             |   2 +-
 src/Terminal.zig           |   8 +--
 src/Text.zig               |   4 +-
 src/edit.zig               | 127 ++++++++++++++++++++++++++++++++++++---------
 src/look.zig               |   2 +-
 src/mouse.zig              |   4 +-
 src/normal.zig             |   6 +--
 src/tagline.zig            |   4 +-
 test/hxcases/cases.jsonl   |  15 ++++++
 test/hxcases/goldens.jsonl |  15 ++++++
 test/hxcases/waivers.jsonl |   2 -
 test/mode.zig              |   6 +--
 test/panes.zig             |   4 +-
 transactions.txt           |  15 ++----
 16 files changed, 194 insertions(+), 78 deletions(-)

(limited to 'src/Terminal.zig')

diff --git a/docs/helix-keys.md b/docs/helix-keys.md
index 90efc463..35f62765 100644
--- a/docs/helix-keys.md
+++ b/docs/helix-keys.md
@@ -7,10 +7,17 @@ checkout (`~/05-genizah/helix`); that checkout now sits on the local
 `pardes-harness` branch, whose three commits add only the harness, so
 `book/src/keymap.md` is byte-identical at its tip (694e7dfd). As of phase 5
 every helix-equivalent row in A and B is differentially verified against real
-helix (see "Differential testing" at the bottom). Five of the six waivers are
-named in the row they belong to; the sixth, `wiX-edit-drops-sel`, belongs to no
-single key — it is the anchor-only divergence every insert-mode edit shares —
-and is described in the Files list at the bottom instead.
+helix (see "Differential testing" at the bottom). Every waiver is named in the
+row it belongs to.
+
+**The reference helix is fixed at one commit:** the `hx-harness` built from
+`694e7dfdd` on the genizah checkout's `pardes-harness` branch, which is upstream
+`278b24389` (2026-06-29, `25.07-905`) plus the three harness commits. "helix"
+in this document means that build, not the 25.07.1 release, which differs on
+counted `Alt-(`/`Alt-)` and on `&`. Upstream master was 82 commits further on
+2026-09-28 (`079a789e`); of those only `416a0e09` (continuing a comment in an
+injected `comment` layer) touches the editing code, and it needs tree-sitter,
+which the harness runs without.
 
 Code map, by SYMBOL — line numbers rot, names do not. Body-normal key
 RECOGNITION is `modal.Normal` in `src/modal.zig`: a state machine over `Role` (one
@@ -227,7 +234,7 @@ grew `sels` + `primary`, emitted only when there is more than one range.
 | `y` with several ranges | one value per range, pasted back value i at range i by `p`/`P`/`R` and insert `Ctrl-r`; the acme cut/paste chords and a paste into a terminal take the values joined by newlines | `Registers.zig` | helix-verified |
 | `"<reg>` | the next command's register: any character names one of its own. Computed ones: `_` swallows writes and reads nothing (`"_d`), `#` is each range's number from 1, `.` each range's text, `%` the file's name, `/` the last `s`/`S` pattern; `+`/`*` the system clipboard. A count typed before `"` stays the command's | helix `select_register` | helix-verified |
 | insert `Ctrl-r <reg>` | type this range's value of the register (`Ctrl-r #` numbers the cursors). Esc after `Ctrl-r` only cancels it. `Ctrl-r +` reads what pardes last put on the clipboard, not the desktop's | helix `insert_register` | helix-verified |
-| `a` … `Esc` with several ranges | the primary's appended-over span is restored; the others collapse to bare cursors | `Pane.append_at` is a single field. Waived (`msel-append`) | waived |
+| insert mode with a selection | every range is carried through each edit as helix maps it (`Range::map`): typing at the head of an `i` range slides it, typing at the end of an `a` range stretches it, Enter slides or stretches it by what the cursor moved, and an arrow key collapses it. Esc after `a` pulls each range's end back one character (helix `restore_cursor`) | `edit.insertKey`, `Text.restore_cursor` | helix-verified |
 | `&` | align selections into columns: the k-th range of each line is column k, and spaces go in before each range until its head reaches the column's widest head, in display cells (`File.rawDisplayCol`) | helix `align_selections` as of the harness's helix (25.07.1 grouped columns differently). A range over several lines refuses. A TAB counts as `tab_width` cells, not up to the next stop | helix-verified |
 | `Alt-)` / `Alt-(` / `<n>Alt-)` | rotate the CONTENTS of the selections forward / back by one range (n ranges), in one edit; each range comes back over the text it now holds and the primary moves with its text | helix `rotate_selection_contents_*` as of the harness's helix: 25.07.1 read the count as a GROUP size instead (rotate by one within each run of n ranges) and left the primary where it was, which is what helix-golf's `invert_dictionary_2` relies on | helix-verified |
 
@@ -389,11 +396,11 @@ Files (all in `test/hxcases/`):
   (runs the `hx-harness` binary from the helix checkout; override with
   `$HX_HARNESS`). Only needed when cases change — the diff itself runs
   offline.
-- `waivers.jsonl` — named exemptions, each with a reason. Three live ones:
-  `wiX-edit-drops-sel` and `msel-append` (helix maps selections through
-  insert-mode edits, pardes does not) and `alt-c-window-op` (the pardes
-  window op deliberately shadows helix change-noyank). `msel-yank-paste`
-  went with registers of one value per range; `sel-regex-caret` and
+- `waivers.jsonl` — named exemptions, each with a reason. One live one:
+  `alt-c-window-op` (the pardes window op deliberately shadows helix
+  change-noyank). `wiX-edit-drops-sel` and `msel-append` went when insert
+  mode began carrying every range through its edits, `msel-yank-paste` with
+  registers of one value per range, `sel-regex-caret` and
   `sel-regex-dot-newline` when `s`/`S` began searching line by line.
 - `parity.jsonl` — 80 further cases, used only by the parity gate below.
 - `parity-waivers.jsonl` — 14 named exemptions for the parity gate, in three
@@ -412,10 +419,11 @@ Files (all in `test/hxcases/`):
   tested when an earlier one misses. The goldens are
   `hx-harness test/hxcases/golf.jsonl`; `zig build hxgolf` runs them. All ten examples reproduce their published result in hx 25.07.1 under
   the site's own conditions (a file of the example's language, auto-pairs
-  on). Under the harness pins two do not: `csv_to_sql` needs auto-pairs to
-  close its `VALUES (`, and `invert_dictionary_2` needs 25.07's
-  `<count>Alt-(` (rotate within groups of count) where the harness's newer
-  helix rotates by count.
+  on). Under the harness two do not, and their goldens are the harness's
+  anyway, which pardes follows: `csv_to_sql` needs auto-pairs (off in the
+  harness and absent in pardes) to close its `VALUES (`, and
+  `invert_dictionary_2` needs 25.07.1's `<count>Alt-(` (rotate within groups
+  of count) where the reference helix rotates by count.
 - `smoke.jsonl` — 20 cases referenced by nothing in the tree: no build step,
   no script. Either wire it up or delete it.
 
diff --git a/docs/selections.md b/docs/selections.md
index 0f000e2c..c08ccb14 100644
--- a/docs/selections.md
+++ b/docs/selections.md
@@ -3,6 +3,8 @@
 How normal mode holds and changes its selections, and where that differs from
 helix's `Selection` (a list of ranges over gap offsets, with a primary index).
 Key-by-key behaviour is in docs/helix-keys.md; this is the model underneath.
+"helix" here is the reference build docs/helix-keys.md names: `hx-harness`
+at `694e7dfdd`, upstream `278b24389`.
 
 ## What a selection is
 
@@ -25,8 +27,9 @@ plus up to 63 others.
   `s`, `n`/`N`, ...) rather than left behind by a motion. Only pardes reads
   it: the look (Enter) and execute (Tab) chords act on explicit selections
   and on the word under the cursor otherwise.
-- `select` is `v` extend mode. `append_at` remembers where an `a` began, so
-  Esc can give back the range it appended over.
+- `select` is `v` extend mode. `restore_cursor` says the insert session
+  began with `a`, so Esc gives each range back the character it was
+  stretched by.
 
 `Text.setRanges` is the one writer of a whole selection: it sorts by start,
 merges ranges that overlap or share a start (helix `normalize`), follows the
@@ -67,6 +70,17 @@ A parsed action has a scope (`modal.Normal.Action.scope`).
   look) runs once from the primary and drops back to one cursor
   (`normal.multiOnce`).
 
+## Insert mode
+
+Each range lives on through insert mode. Every insert-mode edit happens at
+the cursor, so `edit.insertKey` runs it on the bare cursor and then carries
+the range through what it did to the text, with helix's `Range::map` rules:
+at an insertion, a backward range's head and an empty range move past it
+and a forward range's head stays before it, so typing slides an `i` range
+and stretches an `a` range. Enter slides or stretches the range by what the
+cursor moved; an arrow key collapses it. The other ranges get the same by
+the replay.
+
 ## Undo, registers, repeat
 
 - One keystroke is one undo step however many ranges it edited: only the
@@ -86,10 +100,6 @@ A parsed action has a scope (`modal.Normal.Action.scope`).
 
 ## Where it differs from helix
 
-- Insert mode: helix maps every range through each keystroke's edit, so a
-  range an `i`/`a` started from stretches over what is typed and keeps its
-  anchor. Here only the cursor cells move, and after Esc only the primary's
-  `append_at` span comes back (waivers `wiX-edit-drops-sel`, `msel-append`).
 - Direction of a one-character range: both of its cells are the same cell,
   so it has none. helix can flip one (`Alt-;`) and the commands that read
   the head (`&`, the next extend) see the difference.
diff --git a/src/Output.zig b/src/Output.zig
index 6e1765a7..201b5491 100644
--- a/src/Output.zig
+++ b/src/Output.zig
@@ -749,7 +749,7 @@ pub fn resetBody(p: *Pardes, pane: *Pane) void {
     pane.body.select = false;
     pane.sel = @splat(.{});
     pane.body.sticky_col = -1;
-    pane.body.append_at = null;
+    pane.body.restore_cursor = false;
     pane.body.normal.clear();
     pane.look_at = null;
     if (p.look_hover_wait) |wait| if (wait.serial == pane.serial) {
diff --git a/src/Terminal.zig b/src/Terminal.zig
index e204b44c..e3378007 100644
--- a/src/Terminal.zig
+++ b/src/Terminal.zig
@@ -717,7 +717,7 @@ pub fn feedOutput(p: *Pardes, pane: *Pane, bytes: []const u8) void {
     if (comptime !enabled) return;
     if (pane.terminal == null) return;
     const has_positions = pane.ovl != null or pane.body.cur_pinned or pane.body.vsel.active or
-        pane.body.msel.active or pane.body.nsel > 0 or pane.body.append_at != null or pane.look_at != null or
+        pane.body.msel.active or pane.body.nsel > 0 or pane.look_at != null or
         pane.body.ed_undo_len > 0 or pane.body.ed_redo_len > 0 or pointerRowCount(pane) > 0;
     // Sticky bottom, as every other terminal does it: output drags the
     // viewport down only when the viewport was already on the last row, so
@@ -843,10 +843,6 @@ fn ingestWithPositions(pane: *Pane, bytes: []const u8) void {
         extra[nextra + 1] = &selection.arow;
         nextra += 2;
     }
-    if (pane.body.append_at) |*at| {
-        extra[nextra] = &at.row;
-        nextra += 1;
-    }
     if (pane.look_at) |*at| {
         extra[nextra] = &at.row;
         nextra += 1;
@@ -1124,7 +1120,7 @@ pub fn enterTty(p: *Pardes, id: usize) void {
     // keeps its modal endpoint for the next return to editor mode.
     pane.body.cur_pinned = selected;
     pane.body.select = false;
-    pane.body.append_at = null;
+    pane.body.restore_cursor = false;
     pane.body.sticky_col = -1;
     pane.body.normal.clear();
 }
diff --git a/src/Text.zig b/src/Text.zig
index 7ad243a1..764b8a6a 100644
--- a/src/Text.zig
+++ b/src/Text.zig
@@ -65,7 +65,9 @@ select: bool = false,
 /// sticky goal column for j/k runs (helix old_visual_position): any
 /// non-vertical range write resets it to -1.
 sticky_col: i32 = -1,
-append_at: ?struct { row: i32, col: i32 } = null,
+/// The insert session began with `a`: on Esc every range gives back the
+/// one character it was stretched by (helix restore_cursor).
+restore_cursor: bool = false,
 /// insert `Ctrl-r` was pressed: the next key names the register to insert
 reg_wait: bool = false,
 normal: modal.Normal.State = .{},
diff --git a/src/edit.zig b/src/edit.zig
index 14d8b7ed..8f6f09c6 100644
--- a/src/edit.zig
+++ b/src/edit.zig
@@ -344,28 +344,20 @@ pub fn exitInsert(p: *Pardes, t: *Text) void {
     t.reg_wait = false;
     t.msel.active = false;
     t.normal.clear();
-    if (t.append_at) |aa| {
-        t.append_at = null;
-        const text = flatSurface(p, t) catch return;
-        const gap = modal.offsetAt(text, .{ .row = @intCast(@max(0, t.cur_row)), .col = @intCast(@max(0, t.cur_col)) });
-        const a_off = modal.offsetAt(text, .{ .row = @intCast(@max(0, aa.row)), .col = @intCast(@max(0, aa.col)) });
-        const back = @max(a_off, modal.prevGrapheme(text, gap));
-        const bc = modal.positionAt(text, back);
-        t.cur_row = @intCast(bc.row);
-        t.cur_col = @intCast(bc.col);
-        t.vsel = .{ .active = a_off != back, .row = aa.row, .col = aa.col, .explicit = false };
-        t.cur_pinned = true;
-        t.show();
-        for (t.sels[0..t.nsel]) |*s| {
-            const sgap = modal.offsetAt(text, .{ .row = @intCast(@max(0, s.row)), .col = @intCast(@max(0, s.col)) });
-            const b2 = if (back == gap) sgap else modal.prevGrapheme(text, sgap);
-            const bp = modal.positionAt(text, b2);
-            s.row = @intCast(bp.row);
-            s.col = @intCast(bp.col);
-            s.arow = s.row;
-            s.acol = s.col;
-        }
+    if (!t.restore_cursor) return;
+    t.restore_cursor = false;
+    // helix enter_normal_mode: every range, from its start to the char
+    // before its end when it points forward, else to its end
+    const expl = (t.vsel.active and t.vsel.explicit) or t.msel.active;
+    const text = flatSurface(p, t) catch return;
+    var rs: [Text.max_selections]modal.Selection = undefined;
+    const got = t.ranges(text, 0, &rs);
+    for (rs[0..got.n]) |*r| {
+        const from = @min(r.anchor, r.head);
+        const to = @max(r.anchor, r.head);
+        r.* = .{ .anchor = from, .head = if (r.head > r.anchor) @max(from, modal.prevGrapheme(text, to)) else to };
     }
+    t.setRanges(text, rs[0..got.n], &.{}, got.pri, expl);
 }
 
 pub fn paneCursorLines(p: *Pardes, t: *Text) ![]const []const u8 {
@@ -518,7 +510,7 @@ pub fn enterInsert(p: *Pardes, t: *Text, where: InsertAt, cnt: usize) void {
     // `u` undoes the whole session and restores what was selected
     pushUndo(p, t);
     t.select = false;
-    t.append_at = null;
+    t.restore_cursor = false;
     t.sticky_col = -1;
     const text = flatSurface(p, t) catch {
         t.mode = .insert;
@@ -544,12 +536,14 @@ pub fn enterInsert(p: *Pardes, t: *Text, where: InsertAt, cnt: usize) void {
             const lo_col = if (b) |bb| bb.lo_col else t.cur_col;
             const hi_row = if (b) |bb| bb.hi_row else t.cur_row;
             const hi_col = if (b) |bb| bb.hi_col else t.cur_col;
-            t.append_at = .{ .row = lo_row, .col = lo_col };
+            t.restore_cursor = true;
             const gap = modal.nextGrapheme(text, modal.offsetAt(text, .{ .row = @intCast(@max(0, hi_row)), .col = @intCast(@max(0, hi_col)) }));
             const gc = modal.positionAt(text, gap);
             t.cur_row = @intCast(gc.row);
             t.cur_col = @intCast(gc.col);
-            t.vsel = .{ .active = b != null, .row = lo_row, .col = lo_col, .explicit = false };
+            // helix append_mode: the range reaches one past its end, which
+            // is where typing goes; a bare cursor becomes a range too
+            t.vsel = .{ .active = true, .row = lo_row, .col = lo_col, .explicit = false };
             t.cur_pinned = true;
         },
         .line_start => {
@@ -634,6 +628,72 @@ pub fn insertKey(p: *Pardes, t: *Text, key: Key) void {
         t.reg_wait = true;
         return;
     }
+    // helix maps every range through each insert-mode edit (Range::map):
+    // the edits below work on the bare cursor, and the range the cursor
+    // heads is carried through what they did to the text afterwards
+    if (!t.vsel.active) return insertEdit(p, t, key);
+    const old = flatSurface(p, t) catch return insertEdit(p, t, key);
+    const r = t.primaryRange(old, 0);
+    const c = modal.selectionCursor(old, r);
+    const old_len = old.len;
+    const explicit = t.vsel.explicit;
+    t.vsel.active = false;
+    insertEdit(p, t, key);
+    if (t.mode != .insert) return;
+    const new = flatSurface(p, t) catch return;
+    const c2 = modal.offsetAt(new, .{ .row = @intCast(@max(0, t.cur_row)), .col = @intCast(@max(0, t.cur_col)) });
+    // every insert-mode edit happens at the cursor: an insertion there, or
+    // a deletion that ends there (backward) or starts there (forward)
+    if (key.cp == Key.enter) {
+        // helix insert_newline: an appending range stretches by what the
+        // cursor moved, any other slides by it
+        const d = @as(isize, @intCast(c2)) - @as(isize, @intCast(c));
+        const head: usize = @intCast(@as(isize, @intCast(r.head)) + d);
+        const anchor: usize = if (c > r.anchor) r.anchor else @intCast(@as(isize, @intCast(r.anchor)) + d);
+        return setInsertRange(t, new, .{ .anchor = anchor, .head = head }, explicit);
+    }
+    var at: usize = c;
+    var del: usize = 0;
+    var ins: usize = 0;
+    if (new.len > old_len and c2 == c + (new.len - old_len)) {
+        ins = new.len - old_len;
+    } else if (new.len < old_len and c2 + (old_len - new.len) == c) {
+        at = c2;
+        del = old_len - new.len;
+    } else if (new.len < old_len and c2 == c) {
+        del = old_len - new.len;
+    } else if (new.len != old_len or c2 != c) {
+        return; // a motion: the range collapses onto the cursor (helix)
+    }
+    // helix Assoc: the head sticks after an insertion at it when the range
+    // points backward or is empty, the anchor when it points forward
+    const fwd = r.anchor < r.head;
+    setInsertRange(t, new, .{
+        .anchor = mapThroughEdit(r.anchor, at, del, ins, !fwd and r.anchor != r.head),
+        .head = mapThroughEdit(r.head, at, del, ins, fwd),
+    }, explicit);
+}
+
+fn setInsertRange(t: *Text, new: []const u8, mapped: modal.Selection, explicit: bool) void {
+    const cells = Text.rangeCells(new, mapped);
+    const cc = modal.positionAt(new, cells.cur);
+    const ac = modal.positionAt(new, cells.anc);
+    t.cur_row = @intCast(cc.row);
+    t.cur_col = @intCast(cc.col);
+    t.vsel = .{ .active = cells.anc != cells.cur, .row = @intCast(ac.row), .col = @intCast(ac.col), .explicit = explicit };
+}
+
+/// A position through one edit at `at` that deleted `del` bytes and put
+/// `ins` in (one of the two is 0). A position exactly at an insertion stays
+/// before it when `before` is set, else moves past it.
+fn mapThroughEdit(pos: usize, at: usize, del: usize, ins: usize, before: bool) usize {
+    if (pos < at) return pos;
+    if (del > 0) return if (pos < at + del) at else pos - del;
+    if (pos == at and before) return pos;
+    return pos + ins;
+}
+
+fn insertEdit(p: *Pardes, t: *Text, key: Key) void {
     t.vsel.active = false;
     if (!t.cur_pinned) pinPaneCursor(p, t);
     _ = clampFileCursor(t);
@@ -748,12 +808,29 @@ pub fn insertKey(p: *Pardes, t: *Text, key: Key) void {
     switch (key.cp) {
         Key.enter => {
             const line = modal.lineSlice(text, c.row);
+            const before = line[0..@min(c.col, line.len)];
+            // helix insert_newline: after nothing but blanks, the line
+            // itself moves down, blanks and all; else the blanks before the
+            // cursor go and the new line takes the indent
+            if (std.mem.indexOfNone(u8, before, " \t") == null) {
+                const new = modal.insertAt(p.gpa, text, .{ .row = c.row, .col = 0 }, "\n") catch return;
+                setEditText(p, t, new);
+                t.cur_row += 1;
+                t.cur_pinned = true;
+                t.show();
+                return;
+            }
             const indent = modal.newlineIndentWidth(line, c.col);
             const arena = p.scratch.allocator();
             const block = arena.alloc(u8, 1 + indent) catch return;
             block[0] = '\n';
             @memset(block[1..], ' ');
-            const new = modal.insertAt(p.gpa, text, c, block) catch return;
+            // a tag keeps its blanks: they part its words, and the last
+            // may be its read-only prefix's
+            const kept = if (t.what == .body) std.mem.trimEnd(u8, before, " \t").len else c.col;
+            const cut = modal.deleteSpan(p.gpa, text, .{ .row = c.row, .col = kept }, c) catch return;
+            defer p.gpa.free(cut);
+            const new = modal.insertAt(p.gpa, cut, .{ .row = c.row, .col = kept }, block) catch return;
             setEditText(p, t, new);
             t.cur_row += 1;
             t.cur_col = @intCast(indent);
diff --git a/src/look.zig b/src/look.zig
index 5e2d6068..30fb0dab 100644
--- a/src/look.zig
+++ b/src/look.zig
@@ -1016,7 +1016,7 @@ pub fn clearNavigationSelection(p: *Pardes, pane: *Pane) void {
     pane.body.nsel = 0;
     pane.body.select = false;
     pane.body.normal.clear();
-    pane.body.append_at = null;
+    pane.body.restore_cursor = false;
     pane.body.sticky_col = -1;
     for (0..pane.sel.len) |slot| pane.clearPointerSelection(slot);
     pane.sel = @splat(.{});
diff --git a/src/mouse.zig b/src/mouse.zig
index 91ec41a6..d1c32b40 100644
--- a/src/mouse.zig
+++ b/src/mouse.zig
@@ -747,7 +747,7 @@ fn mirrorTtySelection(p: *Pardes, pane: *Pane) void {
     pane.body.vsel.active = false;
     pane.body.nsel = 0;
     pane.body.select = false;
-    pane.body.append_at = null;
+    pane.body.restore_cursor = false;
     pane.body.sticky_col = -1;
     pane.body.normal.clear();
     edit.setYank(p, text);
@@ -859,7 +859,7 @@ fn dragRelease(p: *Pardes, button: Mouse.Button) void {
                     pane.body.vsel.active = false;
                     pane.body.nsel = 0; // a click says WHERE the one cursor is
                     pane.body.select = false;
-                    pane.body.append_at = null;
+                    pane.body.restore_cursor = false;
                     pane.body.sticky_col = -1;
                     if (s.ctrl) p.lspRequest(s.id, .definition, "");
                 }
diff --git a/src/normal.zig b/src/normal.zig
index f5e868a4..53e416fd 100644
--- a/src/normal.zig
+++ b/src/normal.zig
@@ -149,7 +149,7 @@ const KeyState = struct {
     normal: modal.Normal.State,
     find_op: u8,
     find_ch: u21,
-    append_at: @FieldType(Text, "append_at"),
+    restore_cursor: bool,
     reg_wait: bool,
 
     fn of(t: *Text) KeyState {
@@ -159,7 +159,7 @@ const KeyState = struct {
             .normal = t.normal,
             .find_op = t.find_op,
             .find_ch = t.find_ch,
-            .append_at = t.append_at,
+            .restore_cursor = t.restore_cursor,
             .reg_wait = t.reg_wait,
         };
     }
@@ -170,7 +170,7 @@ const KeyState = struct {
         t.normal = s.normal;
         t.find_op = s.find_op;
         t.find_ch = s.find_ch;
-        t.append_at = s.append_at;
+        t.restore_cursor = s.restore_cursor;
         t.reg_wait = s.reg_wait;
     }
 };
diff --git a/src/tagline.zig b/src/tagline.zig
index 14bf5677..1c060a66 100644
--- a/src/tagline.zig
+++ b/src/tagline.zig
@@ -219,7 +219,7 @@ pub fn enterTag(p: *Pardes, pane: *Pane) void {
     t.msel.active = false;
     t.nsel = 0;
     t.select = false;
-    t.append_at = null;
+    t.restore_cursor = false;
     t.sticky_col = -1;
     t.mode = .normal;
     t.normal.clear();
@@ -325,7 +325,7 @@ pub fn enterHeader(p: *Pardes, column: ?usize) void {
     t.msel.active = false;
     t.nsel = 0;
     t.select = false;
-    t.append_at = null;
+    t.restore_cursor = false;
     t.mode = .normal;
     t.normal.clear();
 }
diff --git a/test/hxcases/cases.jsonl b/test/hxcases/cases.jsonl
index 7ba44f09..ba75c611 100644
--- a/test/hxcases/cases.jsonl
+++ b/test/hxcases/cases.jsonl
@@ -344,6 +344,21 @@
 {"name": "i-keeps-sel-start", "pane": "file", "text": "alpha beta\n", "keys": "wi"}
 {"name": "wa-sel-end", "pane": "file", "text": "alpha beta\n", "keys": "wa"}
 {"name": "wiX-edit-drops-sel", "pane": "file", "text": "alpha beta\n", "keys": "wiX<esc>"}
+{"name": "reg-selection-insert", "pane": "file", "text": "ab\n", "keys": "vli<C-r>.<esc>"}
+{"name": "ins-sel-backspace", "pane": "file", "text": "alpha beta\n", "keys": "wi<backspace><esc>"}
+{"name": "ins-append-enter", "pane": "file", "text": "ab cd\n", "keys": "wa<ret>x<esc>"}
+{"name": "ins-append-backspace", "pane": "file", "text": "ab cd\n", "keys": "ea<backspace><backspace><esc>"}
+{"name": "ins-sel-delete", "pane": "file", "text": "ab cd\n", "keys": "wi<del><esc>"}
+{"name": "ins-sel-arrow-collapses", "pane": "file", "text": "ab cd\n", "keys": "wi<right><esc>"}
+{"name": "msel-insert-keeps-ranges", "pane": "file", "text": "ab cd\nab cd\n", "keys": "wCiX<esc>"}
+{"name": "msel-append-lines", "pane": "file", "text": "aa\nbb\n", "keys": "%<A-s>a!<esc>"}
+{"name": "ins-append-bare", "pane": "file", "text": "ab\n", "keys": "axy<esc>"}
+{"name": "ins-change-then-type", "pane": "file", "text": "ab cd\n", "keys": "wcX<esc>"}
+{"name": "ins-open-below-sel", "pane": "file", "text": "ab\ncd\n", "keys": "xoX<esc>"}
+{"name": "ins-enter-trims-blanks", "pane": "file", "text": "ab   cd\n", "keys": "5li<ret><esc>"}
+{"name": "ins-enter-in-indent", "pane": "file", "text": "    ab\n", "keys": "2li<ret><esc>"}
+{"name": "ins-enter-after-open", "pane": "file", "text": "    ab\n", "keys": "o<ret>x<esc>"}
+{"name": "msel-ins-enter", "pane": "file", "text": "ab cd\nab cd\n", "keys": "wCa<ret><esc>"}
 {"name": "a-esc-restore", "pane": "file", "text": "abc\n", "keys": "a<esc>"}
 {"name": "ax-restore", "pane": "file", "text": "abc\n", "keys": "ax<esc>"}
 {"name": "lax-restore", "pane": "file", "text": "abc\n", "keys": "lax<esc>"}
diff --git a/test/hxcases/goldens.jsonl b/test/hxcases/goldens.jsonl
index f6a6aada..188b7ce4 100644
--- a/test/hxcases/goldens.jsonl
+++ b/test/hxcases/goldens.jsonl
@@ -344,6 +344,21 @@
 {"name":"i-keeps-sel-start","text":"alpha beta\n","mode":"insert","cursor":{"row":0,"col":0},"anchor":{"row":0,"col":5}}
 {"name":"wa-sel-end","text":"alpha beta\n","mode":"insert","cursor":{"row":0,"col":6},"anchor":{"row":0,"col":0}}
 {"name":"wiX-edit-drops-sel","text":"Xalpha beta\n","mode":"normal","cursor":{"row":0,"col":1},"anchor":{"row":0,"col":6}}
+{"name":"reg-selection-insert","text":"abab\n","mode":"normal","cursor":{"row":0,"col":2},"anchor":{"row":0,"col":3}}
+{"name":"ins-sel-backspace","text":"alpha beta\n","mode":"normal","cursor":{"row":0,"col":0},"anchor":{"row":0,"col":5}}
+{"name":"ins-append-enter","text":"ab\nxcd\n","mode":"normal","cursor":{"row":1,"col":0},"anchor":{"row":0,"col":0}}
+{"name":"ins-append-backspace","text":" cd\n","mode":"normal","cursor":{"row":0,"col":0},"anchor":{"row":0,"col":0}}
+{"name":"ins-sel-delete","text":"b cd\n","mode":"normal","cursor":{"row":0,"col":0},"anchor":{"row":0,"col":1}}
+{"name":"ins-sel-arrow-collapses","text":"ab cd\n","mode":"normal","cursor":{"row":0,"col":1},"anchor":{"row":0,"col":1}}
+{"name":"msel-insert-keeps-ranges","text":"Xab cd\nXab cd\n","mode":"normal","cursor":{"row":1,"col":1},"anchor":{"row":1,"col":3},"sels":[{"cursor":{"row":0,"col":1},"anchor":{"row":0,"col":3}},{"cursor":{"row":1,"col":1},"anchor":{"row":1,"col":3}}],"primary":1}
+{"name":"msel-append-lines","text":"aa!\nbb!\n","mode":"normal","cursor":{"row":0,"col":2},"anchor":{"row":0,"col":0},"sels":[{"cursor":{"row":0,"col":2},"anchor":{"row":0,"col":0}},{"cursor":{"row":1,"col":2},"anchor":{"row":1,"col":0}}],"primary":0}
+{"name":"ins-append-bare","text":"axyb\n","mode":"normal","cursor":{"row":0,"col":2},"anchor":{"row":0,"col":0}}
+{"name":"ins-change-then-type","text":"Xcd\n","mode":"normal","cursor":{"row":0,"col":1},"anchor":{"row":0,"col":1}}
+{"name":"ins-open-below-sel","text":"ab\nX\ncd\n","mode":"normal","cursor":{"row":1,"col":1},"anchor":{"row":1,"col":1}}
+{"name":"ins-enter-trims-blanks","text":"ab\ncd\n","mode":"normal","cursor":{"row":1,"col":0},"anchor":{"row":1,"col":0}}
+{"name":"ins-enter-in-indent","text":"\n    ab\n","mode":"normal","cursor":{"row":1,"col":2},"anchor":{"row":1,"col":2}}
+{"name":"ins-enter-after-open","text":"    ab\n\n    x\n","mode":"normal","cursor":{"row":2,"col":5},"anchor":{"row":2,"col":5}}
+{"name":"msel-ins-enter","text":"ab\ncd\nab\ncd\n","mode":"normal","cursor":{"row":2,"col":2},"anchor":{"row":2,"col":0},"sels":[{"cursor":{"row":0,"col":2},"anchor":{"row":0,"col":0}},{"cursor":{"row":2,"col":2},"anchor":{"row":2,"col":0}}],"primary":1}
 {"name":"a-esc-restore","text":"abc\n","mode":"normal","cursor":{"row":0,"col":0},"anchor":{"row":0,"col":0}}
 {"name":"ax-restore","text":"axbc\n","mode":"normal","cursor":{"row":0,"col":1},"anchor":{"row":0,"col":0}}
 {"name":"lax-restore","text":"abxc\n","mode":"normal","cursor":{"row":0,"col":2},"anchor":{"row":0,"col":1}}
diff --git a/test/hxcases/waivers.jsonl b/test/hxcases/waivers.jsonl
index 8ac3bd9c..2d74e346 100644
--- a/test/hxcases/waivers.jsonl
+++ b/test/hxcases/waivers.jsonl
@@ -1,3 +1 @@
-{"name":"wiX-edit-drops-sel","reason":"Insert edits clear the selection instead of tracking its anchor.","reference":{"name":"wiX-edit-drops-sel","text":"Xalpha beta\n","mode":"normal","cursor":{"row":0,"col":1},"anchor":{"row":0,"col":6}},"expected":{"name":"wiX-edit-drops-sel","text":"Xalpha beta\n","mode":"normal","cursor":{"row":0,"col":1},"anchor":{"row":0,"col":1}}}
 {"name":"alt-c-window-op","reason":"Alt-c moves a pane to a new column instead of Helix's change-noyank.","reference":{"name":"alt-c-window-op","text":"bc def\n","mode":"insert","cursor":{"row":0,"col":0},"anchor":{"row":0,"col":0}},"expected":{"name":"alt-c-window-op","text":"abc def\n","mode":"normal","cursor":{"row":0,"col":0},"anchor":{"row":0,"col":0}}}
-{"name":"msel-append","reason":"Append-mode selection origins are tracked only for the primary selection.","reference":{"name":"msel-append","text":"aza\nbzb\n","mode":"normal","cursor":{"row":1,"col":1},"anchor":{"row":1,"col":0},"sels":[{"cursor":{"row":0,"col":1},"anchor":{"row":0,"col":0}},{"cursor":{"row":1,"col":1},"anchor":{"row":1,"col":0}}],"primary":1},"expected":{"name":"msel-append","text":"aza\nbzb\n","mode":"normal","cursor":{"row":1,"col":1},"anchor":{"row":1,"col":0},"sels":[{"cursor":{"row":0,"col":1},"anchor":{"row":0,"col":1}},{"cursor":{"row":1,"col":1},"anchor":{"row":1,"col":0}}],"primary":1}}
diff --git a/test/mode.zig b/test/mode.zig
index c7d7d548..cba93c30 100644
--- a/test/mode.zig
+++ b/test/mode.zig
@@ -79,14 +79,14 @@ test "Mode from actual tag Exec preserves parked file and output insert transact
             p.update(.{ .key = .{ .cp = pardes.Key.tab } });
             try std.testing.expectEqual(panes.Text.Mode.normal, pane.body.mode);
             try std.testing.expect(pane.focus == .body);
-            try std.testing.expect(pane.body.append_at == null);
+            try std.testing.expect(!pane.body.restore_cursor);
             p.update(.{ .key = .{ .cp = 'u' } });
             try std.testing.expectEqualStrings("ab\n", pane.file.?.content);
             p.update(.{ .key = .{ .cp = 'a' } });
             p.update(.{ .key = .{ .cp = 'z', .text = "z" } });
-            try std.testing.expect(pane.body.append_at != null);
+            try std.testing.expect(pane.body.restore_cursor);
             try mode(p, 0, .normal);
-            try std.testing.expect(pane.body.append_at == null);
+            try std.testing.expect(!pane.body.restore_cursor);
             p.update(.{ .key = .{ .cp = 'u' } });
             try std.testing.expectEqualStrings("ab\n", pane.file.?.content);
         }
diff --git a/test/panes.zig b/test/panes.zig
index cbf9d097..4e98f449 100644
--- a/test/panes.zig
+++ b/test/panes.zig
@@ -4547,7 +4547,7 @@ const LookResetTests = struct {
         pane.body.nsel = 1;
         pane.body.select = true;
         pane.body.normal.count = 5;
-        pane.body.append_at = .{ .row = 0, .col = 3 };
+        pane.body.restore_cursor = true;
         pane.body.sticky_col = 7;
         for (0..pane.sel.len) |slot| {
             pane.clearPointerSelection(slot);
@@ -4567,7 +4567,7 @@ const LookResetTests = struct {
         try std.testing.expectEqual(@as(u8, 0), pane.body.nsel);
         try std.testing.expect(!pane.body.select);
         try std.testing.expectEqual(modal.Normal.State{}, pane.body.normal);
-        try std.testing.expect(pane.body.append_at == null);
+        try std.testing.expect(!pane.body.restore_cursor);
         try std.testing.expectEqual(@as(i32, -1), pane.body.sticky_col);
         for (pane.sel) |selection| try std.testing.expectEqual(.none, selection.state);
         for (pane.pointer_selections) |selection| try std.testing.expect(selection == null);
diff --git a/transactions.txt b/transactions.txt
index 6c2e7646..8d2fda3f 100644
--- a/transactions.txt
+++ b/transactions.txt
@@ -1,13 +1,8 @@
-Selection anchors through insert-mode edits, and the transaction model
-=======================================================================
-
-STATUS: still open. `wiX-edit-drops-sel` is line 1 of test/hxcases/waivers.jsonl,
-so the gap below describes the code as it stands rather than something already
-fixed. One correction to the sentence that follows: it is not quite "the one
-place". Line 3 of the same file, `msel-append`, says in its own words "Same
-family as wiX-edit-drops-sel: pardes does not map selections through insert-mode
-edits" — so the gap has two waivers, and what is singular is the CAUSE below,
-not the number of divergences it produces.
+STATUS: closed for the waivers. Insert mode now carries every range through
+each edit (edit.insertKey maps the range with helix's Range::map rules after
+the edit is made), so `wiX-edit-drops-sel` and `msel-append` are gone. What
+follows is the original analysis; the delta layer it proposes was not needed
+for that and stays unbuilt.
 
 The one place the helix differential suite shows a real structural gap
 (waiver "wiX-edit-drops-sel" in test/hxcases/waivers.jsonl): helix keeps a
-- 
cgit v1.3


From 07a3f53993a27c886ccb3ed665acb9c8b34a2873 Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Mon, 28 Sep 2026 16:12:29 -0300
Subject: A tag's edited text stays alive until the next edit, so ms and md in
 a tag read it whole

setEditText freed the text a tag edit was handed once it had copied the
tag's own part out of it, but every caller reads that text back to place the
cursor, and surround goes on to edit it again: ms and md in a tag read freed
memory. The same held for a terminal without an edit buffer and a text with
no pane. The text is now kept until the next such edit (edit.retireEditText),
which covers every caller at once; the callers the audit found reading it
back are surround's two, the paste and replace paths, the number adjust, and
the insert-mode Enter.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/Terminal.zig |  2 +-
 src/edit.zig     | 13 +++++++++++--
 src/pardes.zig   |  3 +++
 test/panes.zig   | 13 +++++++++++++
 4 files changed, 28 insertions(+), 3 deletions(-)

(limited to 'src/Terminal.zig')

diff --git a/src/Terminal.zig b/src/Terminal.zig
index e3378007..4f94533d 100644
--- a/src/Terminal.zig
+++ b/src/Terminal.zig
@@ -1382,7 +1382,7 @@ pub fn editText(p: *Pardes, pane: *Pane, lo: i32, hi: i32, col: i32) ?EditText {
 
 /// Consume a rewritten overlay, freeing the terminal edit text it replaces.
 pub fn setEditText(p: *Pardes, pane: *Pane, new: []u8) void {
-    const overlay = if (pane.ovl) |*value| value else return p.gpa.free(new);
+    const overlay = if (pane.ovl) |*value| value else return pardes.edit.retireEditText(p, new);
     for (0..pane.sel.len) |button| {
         pane.clearPointerSelection(button);
         pane.sel[button].state = .none;
diff --git a/src/edit.zig b/src/edit.zig
index 8f6f09c6..3e12f169 100644
--- a/src/edit.zig
+++ b/src/edit.zig
@@ -463,7 +463,9 @@ pub fn setEditText(p: *Pardes, t: *Text, new: []u8) void {
     if (t.what == .tag) {
         // A tag is edited as it is shown, but only what follows its
         // prefix is its own: an edit that changed the prefix is refused.
-        defer p.gpa.free(new);
+        // The shown text stays alive until the next such edit, since every
+        // caller reads the new text back, as a body's is kept.
+        defer retireEditText(p, new);
         const pane = t.pane() orelse return;
         const prefix = tagline.pathPrefix(p.scratch.allocator(), pane) catch return;
         if (!std.mem.startsWith(u8, new, prefix)) {
@@ -480,11 +482,18 @@ pub fn setEditText(p: *Pardes, t: *Text, new: []u8) void {
         t.own = new;
         return;
     }
-    const pane = t.pane() orelse return p.gpa.free(new);
+    const pane = t.pane() orelse return retireEditText(p, new);
     if (pane.file) |*f| return panes.File.setContent(p, f, new);
     panes.Terminal.setEditText(p, pane, new);
 }
 
+/// Take a text an edit made that nothing keeps, holding it until the next
+/// one: the edit's caller still reads it to place the cursor.
+pub fn retireEditText(p: *Pardes, new: []u8) void {
+    if (p.retired_edit) |old| p.gpa.free(old);
+    p.retired_edit = new;
+}
+
 pub const InsertAt = enum { at, append, line_start, line_end, open_below, open_above };
 
 /// Files insert only inside existing rows and at grapheme boundaries.
diff --git a/src/pardes.zig b/src/pardes.zig
index e4645d70..c9d93979 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -4096,6 +4096,8 @@ pub const Pardes = struct {
     in_len: usize = 0,
 
     registers: Registers = .{},
+    /// an edited text nothing kept (a tag's shown text): see edit.retireEditText
+    retired_edit: ?[]u8 = null,
     clip_pending: ?edit.ClipRequest = null,
     /// the last serialized dump (gpa-owned), read by the write_dump effect
     dump_out: ?[]u8 = null,
@@ -4267,6 +4269,7 @@ pub const Pardes = struct {
         for (&p.col_tags) |*t| t.deinit(gpa);
         p.global_tag.deinit(gpa);
         p.registers.deinit(gpa);
+        if (p.retired_edit) |r| gpa.free(r);
         if (p.dump_out) |d| gpa.free(d);
         p.fallback.deinit();
         if (p.last_dump) |d| gpa.free(d);
diff --git a/test/panes.zig b/test/panes.zig
index 4e98f449..0b9909ad 100644
--- a/test/panes.zig
+++ b/test/panes.zig
@@ -314,6 +314,19 @@ const TagNavigationTests = struct {
         try std.testing.expect(pane.prompt == .none and pane.focus == .body);
     }
 
+    test "ms and md edit a tag's own text, and the text the edit made is read back whole" {
+        const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
+        defer p.deinit();
+        const pane = try p.setTestFile("body\n");
+        p.update(.tick);
+        key(p, ':'); // the tag, on `Save` the first time
+        for ("miwms(") |cp| key(p, cp);
+        try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), "(Save)") != null);
+        for ("md(") |cp| key(p, cp);
+        try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), " Save ") != null);
+        try std.testing.expect(std.mem.indexOf(u8, pardes.tagline.curTail(pane), "(") == null);
+    }
+
     test "the keyboard reaches a tag's path, which it can select and yank but not edit" {
         const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 20 });
         defer p.deinit();
-- 
cgit v1.3


From 7ce5d94b5d48b68c86d015060ebcabe63e299e1a Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Mon, 28 Sep 2026 16:24:59 -0300
Subject: A selection holds up to 1024 ranges on the desktop, 64 on the board

The limit was 64 everywhere, which helix-golf's enumerate_and_align outgrows
(%s |\d+ makes 121 ranges). It is now memory.limits.selections, per platform,
and the counts that hold it are u16. The ranges stay inline in each Text, so a
pane grows by about 80 KiB on the desktop (three texts and the regex prompt's
snapshot); the Pane size budget in Terminal.zig moves from 128 to 160 KiB and
says why.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/helix-keys.md         |  2 +-
 docs/selections.md         |  8 +++++---
 src/Pipe.zig               |  6 +++---
 src/Terminal.zig           |  5 ++++-
 src/Text.zig               |  5 +++--
 src/exec.zig               |  4 ++--
 src/memory.zig             |  4 ++++
 src/normal.zig             |  2 +-
 src/panes.zig              |  4 ++--
 src/pardes.zig             |  4 ++--
 test/hxcases/cases.jsonl   |  2 ++
 test/hxcases/goldens.jsonl |  2 ++
 test/panes.zig             | 10 +++++-----
 13 files changed, 36 insertions(+), 22 deletions(-)

(limited to 'src/Terminal.zig')

diff --git a/docs/helix-keys.md b/docs/helix-keys.md
index 3d02893b..1c9e0763 100644
--- a/docs/helix-keys.md
+++ b/docs/helix-keys.md
@@ -276,7 +276,7 @@ keeps the matches it found so far.
 | an all-lowercase pattern | matches case-blind | helix's smart-case. mvzr has no such flag, so the surface is lowercased instead (ASCII folding is byte-for-byte, so the offsets are identical) | helix-verified |
 | `^` and `$` | hold at every line's start and end | helix compiles with `multi_line(true)`; pardes gets the same by searching each line as its own haystack (`src/regexp.zig`) | helix-verified |
 | `.` | never matches a newline | as the Rust regex crate: a pattern without `\n` searches line by line, and one that names `\n` has its `.`s made `[^\n]` (`src/regexp.zig`) | helix-verified |
-| more than 64 matches | the ones past `MAX_SELS` are dropped | the ceiling the whole selection model has, not this key's |
+| many matches | up to `memory.limits.selections` ranges: 1024 on the desktop, 64 on the board; matches past it are dropped | helix has no limit. The ranges are held inline in every `Text` (about 20 KiB each on the desktop) | helix-verified up to the limit |
 | `K` / `Alt-K` | keep / remove ranges matching a regex | **skipped**: the same prompt, filtering instead of splitting — worth adding next |
 
 ### `Ctrl-c` — toggle comments
diff --git a/docs/selections.md b/docs/selections.md
index 202ec3d9..59c4415b 100644
--- a/docs/selections.md
+++ b/docs/selections.md
@@ -10,7 +10,8 @@ at `694e7dfdd`, upstream `278b24389`.
 
 Every `Text` (src/Text.zig) has its own: a pane's body, its tag, a prompt's
 answer, a column's or the workspace's tag. A selection is one primary range
-plus up to 63 others.
+plus others, up to `memory.limits.selections` in all (1024 on the
+desktop, 64 on the board).
 
 - The PRIMARY is where the cursor always was: `cur_row`/`cur_col` is the
   head, `vsel.row`/`vsel.col` the anchor while `vsel.active`, and a bare
@@ -33,7 +34,7 @@ plus up to 63 others.
 
 `Text.setRanges` is the one writer of a whole selection: it sorts by start,
 merges ranges that overlap or share a start (helix `normalize`), follows the
-primary through the merges, and keeps the first 64. `setRange` writes one
+primary through the merges, and keeps the first `max_selections`. `setRange` writes one
 range and drops the others.
 
 ## Making, splitting, merging, rotating, removing
@@ -107,7 +108,8 @@ the replay.
 - Direction of a one-character range: both of its cells are the same cell,
   so it has none. helix can flip one (`Alt-;`) and the commands that read
   the head (`&`, the next extend) see the difference.
-- Count: at most 64 ranges; matches past that are dropped silently.
+- Count: at most `memory.limits.selections` ranges (1024 on the desktop, 64
+  on the board); matches past that are dropped silently.
 - `n`/`N` walk the look ring (acme), not regex search hits, and there is no
   `*`; helix-golf's `*`, `""N` and `n` do not apply.
 - `s`/`S` match as sam does (docs/helix-keys.md, "Regex selection"): each
diff --git a/src/Pipe.zig b/src/Pipe.zig
index 37145edf..48e98b7b 100644
--- a/src/Pipe.zig
+++ b/src/Pipe.zig
@@ -55,10 +55,10 @@ pub const PendingPipe = struct {
     cwd: []u8,
     inputs: []selection_pipe.Input,
     ranges: [panes.Text.max_selections]modal.Selection,
-    primary: u8,
+    primary: u16,
     explicit: bool,
     how: modal.Normal.PipeBehavior,
-    nranges: u8,
+    nranges: u16,
 
     pub fn deinit(wait: *PendingPipe, gpa: std.mem.Allocator) void {
         gpa.free(wait.command);
@@ -453,7 +453,7 @@ test "selection pipe replaces all ranges atomically and undo restores them" {
     p.update(.{ .pipe_resp = .{ .id = id, .success = true, .outputs = outputs } });
     try std.testing.expectEqualSlices(u8, "AA bb \n", pane.file.?.content);
     try std.testing.expectEqual(@as(usize, 1), pane.file.?.history.undo_len);
-    try std.testing.expectEqual(@as(u8, 1), pane.body.nsel);
+    try std.testing.expectEqual(@as(u16, 1), pane.body.nsel);
     try std.testing.expectEqual(@as(i32, 1), pane.body.cur_col);
     try std.testing.expectEqual(@as(i32, 6), pane.body.sels[0].col);
     try std.testing.expect(!denied.has_induced_failure);
diff --git a/src/Terminal.zig b/src/Terminal.zig
index 4f94533d..1ff561b1 100644
--- a/src/Terminal.zig
+++ b/src/Terminal.zig
@@ -545,7 +545,10 @@ test "replay ownership is terminal-only and construction rolls back on allocatio
             try std.testing.expectEqual(terminal and enabled, pane.terminal != null);
         }
     };
-    try std.testing.expect(@sizeOf(Pane) < 128 * 1024);
+    // Most of it is the three texts' selections, limits.selections ranges
+    // each held inline (about 20 KiB a text on the desktop), and the regex
+    // prompt's snapshot of them.
+    try std.testing.expect(@sizeOf(Pane) < 160 * 1024);
     try std.testing.checkAllAllocationFailures(std.testing.allocator, Case.run, .{false});
     try std.testing.checkAllAllocationFailures(std.testing.allocator, Case.run, .{true});
 }
diff --git a/src/Text.zig b/src/Text.zig
index 764b8a6a..56ee199b 100644
--- a/src/Text.zig
+++ b/src/Text.zig
@@ -11,6 +11,7 @@ const std = @import("std");
 const panes = @import("panes.zig");
 const modal = @import("modal.zig");
 const config = @import("config.zig");
+const memory = @import("memory.zig");
 const Pane = panes.Pane;
 const File = panes.File;
 const Terminal = panes.Terminal;
@@ -36,7 +37,7 @@ pub const CharSel = struct {
     explicit: bool = false,
 };
 
-pub const max_selections = 64;
+pub const max_selections = memory.limits.selections;
 
 pub const SelRange = struct {
     row: i32,
@@ -60,7 +61,7 @@ cur_col: i32 = 0,
 msel: LineSel = .{},
 vsel: CharSel = .{},
 sels: [max_selections - 1]SelRange = undefined,
-nsel: u8 = 0,
+nsel: u16 = 0,
 select: bool = false,
 /// sticky goal column for j/k runs (helix old_visual_position): any
 /// non-vertical range write resets it to -1.
diff --git a/src/exec.zig b/src/exec.zig
index 1b82d2a8..455a325e 100644
--- a/src/exec.zig
+++ b/src/exec.zig
@@ -752,7 +752,7 @@ test "the acme chords act once per selection, not once on the primary" {
         .{ .anchor = 7, .head = 13 },
     };
     pane.body.setRanges(pane.file.?.content, &ranges, &.{}, 0, true);
-    try std.testing.expectEqual(@as(u8, 1), pane.body.nsel);
+    try std.testing.expectEqual(@as(u16, 1), pane.body.nsel);
 
     const before = p.ncol;
     p.update(.{ .key = .{ .cp = Key.tab } }); // config.exec_key: Exec
@@ -760,7 +760,7 @@ test "the acme chords act once per selection, not once on the primary" {
     // other cursor, so one keystroke over two cursors made one column.
     try std.testing.expectEqual(before + 2, p.ncol);
     // ...and the chord consumed the selection exactly as it does with one.
-    try std.testing.expectEqual(@as(u8, 0), p.panes[0].?.body.nsel);
+    try std.testing.expectEqual(@as(u16, 0), p.panes[0].?.body.nsel);
 }
 
 test "a switch clicked with a selection held flips unless the selection says on or off" {
diff --git a/src/memory.zig b/src/memory.zig
index 7b6ee2c0..abfd40f6 100644
--- a/src/memory.zig
+++ b/src/memory.zig
@@ -17,6 +17,9 @@ pub const limits = struct {
     pub const wrap_rows = if (board) 128 else 256;
     pub const undo_max = if (board) 16 else 256;
     pub const message_log = if (board) 16 else 128;
+    /// ranges one selection holds; helix has no limit, and a `%s` over a
+    /// file's words wants hundreds
+    pub const selections = if (board) 64 else 1024;
     /// /log's ring, which records whether or not anyone reads it.
     pub const log_bytes: usize = if (board) 4 * KiB else 64 * KiB;
     pub const max_tag_tail: usize = if (board) 512 else 4096;
@@ -187,6 +190,7 @@ test "memory limits preserve desktop capacities" {
     try std.testing.expectEqual(256, limits.wrap_rows);
     try std.testing.expectEqual(256, limits.undo_max);
     try std.testing.expectEqual(128, limits.message_log);
+    try std.testing.expectEqual(1024, limits.selections);
     try std.testing.expectEqual(@as(usize, 4096), limits.max_tag_tail);
     try std.testing.expectEqual(@as(usize, 4095), limits.host_path_cap);
     try std.testing.expectEqual(config.embed_sources, limits.embedded_sources);
diff --git a/src/normal.zig b/src/normal.zig
index 542c9fb3..98ba80d6 100644
--- a/src/normal.zig
+++ b/src/normal.zig
@@ -771,7 +771,7 @@ test "flat text movement and selection replay need no scratch rows" {
     pane.body.sels[0] = .{ .row = 3072, .col = 0, .arow = 3072, .acol = 0 };
     handleNormal(p, &pane.body, .{ .cp = 'l' });
     handleNormal(p, &pane.body, .{ .cp = 'j' });
-    try std.testing.expectEqual(@as(u8, 1), pane.body.nsel);
+    try std.testing.expectEqual(@as(u16, 1), pane.body.nsel);
     try std.testing.expectEqual(@as(i32, 1025), pane.body.cur_row);
     try std.testing.expectEqual(@as(i32, 1), pane.body.cur_col);
     try std.testing.expectEqual(@as(i32, 3073), pane.body.sels[0].row);
diff --git a/src/panes.zig b/src/panes.zig
index 9234912f..67954abd 100644
--- a/src/panes.zig
+++ b/src/panes.zig
@@ -155,8 +155,8 @@ pub const Pane = struct {
     search_row: ?usize = null,
     look_at: ?LookSpot = null,
     sel_snap: [Text.max_selections]modal.Selection = undefined,
-    nsel_snap: u8 = 0,
-    sel_snap_pri: u8 = 0,
+    nsel_snap: u16 = 0,
+    sel_snap_pri: u16 = 0,
     sel_snap_expl: bool = false,
     /// The tag: what the user keeps after the computed prefix (the path, the
     /// dirty marker, a PDF's page), its cursor, selections and undo. The
diff --git a/src/pardes.zig b/src/pardes.zig
index 87041f39..a7bcb195 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -3123,7 +3123,7 @@ test "s in a header selects in the header's own text" {
     const text = try edit.flatSurface(p, &p.global_tag);
     const got = p.global_tag.ranges(text, 0, &ranges);
     try std.testing.expectEqual(@as(usize, 3), got.n); // Newcol, Joincol, NextColor
-    try std.testing.expectEqual(@as(u8, 0), pane.body.nsel);
+    try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
 }
 
 test "Enter in a header runs the word under its cursor, as the execute key does" {
@@ -7547,7 +7547,7 @@ test "jump history clears selections and lands at the recorded cursor" {
         try std.testing.expectEqual(@as(usize, 2), p.njumps);
         try std.testing.expectEqual(@as(u32, 3), p.jumps[0].line);
         try std.testing.expect(!pane.body.vsel.active and !pane.body.msel.active and !pane.body.select);
-        try std.testing.expectEqual(@as(u8, 0), pane.body.nsel);
+        try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
         try std.testing.expectEqual(.none, pane.sel[0].state);
         try std.testing.expect(pane.pointer_selections[0] == null);
         try std.testing.expectEqual(@as(i32, if (index == 0) 2 else 0), pane.body.cur_row);
diff --git a/test/hxcases/cases.jsonl b/test/hxcases/cases.jsonl
index 8d6b0e6e..7aeb12e8 100644
--- a/test/hxcases/cases.jsonl
+++ b/test/hxcases/cases.jsonl
@@ -430,6 +430,8 @@
 {"name": "msel-rotate-contents-lengths", "pane": "file", "text": "one to three\n", "keys": "%s\\w+<ret>)<A-(>"}
 {"name": "msel-rotate-contents-backward", "pane": "file", "text": "ab cde\n", "keys": "%s\\w+<ret><A-;><A-)>"}
 {"name": "msel-rotate-contents-lines", "pane": "file", "text": "aa\nbbb\n", "keys": "%<A-s><A-)>"}
+{"name": "sel-many-ranges", "pane": "file", "text": "w w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\n", "keys": "%sw<ret>"}
+{"name": "sel-many-ranges-edit", "pane": "file", "text": "w w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\n", "keys": "%sw<ret>cxy<esc>"}
 {"name": "msel-align-basic", "pane": "file", "text": "a=1\nbbb=2\n", "keys": "%s=<ret>&"}
 {"name": "msel-align-columns", "pane": "file", "text": "a,b,c\nccc,d,e\n", "keys": "%s,<ret>&"}
 {"name": "msel-align-uneven", "pane": "file", "text": "a,b\nccc,d,eee,f\n", "keys": "%s,<ret>&"}
diff --git a/test/hxcases/goldens.jsonl b/test/hxcases/goldens.jsonl
index d62cb633..b8221c4c 100644
--- a/test/hxcases/goldens.jsonl
+++ b/test/hxcases/goldens.jsonl
@@ -430,6 +430,8 @@
 {"name":"msel-rotate-contents-lengths","text":"to three one\n","mode":"normal","cursor":{"row":0,"col":1},"anchor":{"row":0,"col":0},"sels":[{"cursor":{"row":0,"col":1},"anchor":{"row":0,"col":0}},{"cursor":{"row":0,"col":7},"anchor":{"row":0,"col":3}},{"cursor":{"row":0,"col":11},"anchor":{"row":0,"col":9}}],"primary":0}
 {"name":"msel-rotate-contents-backward","text":"cde ab\n","mode":"normal","cursor":{"row":0,"col":4},"anchor":{"row":0,"col":5},"sels":[{"cursor":{"row":0,"col":0},"anchor":{"row":0,"col":2}},{"cursor":{"row":0,"col":4},"anchor":{"row":0,"col":5}}],"primary":1}
 {"name":"msel-rotate-contents-lines","text":"bbb\naa\n","mode":"normal","cursor":{"row":1,"col":1},"anchor":{"row":1,"col":0},"sels":[{"cursor":{"row":0,"col":2},"anchor":{"row":0,"col":0}},{"cursor":{"row":1,"col":1},"anchor":{"row":1,"col":0}}],"primary":1}
+{"name":"sel-many-ranges","text":"w w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\nw w w w w w w w w w w w w w w w w w w w\n","mode":"normal","cursor":{"row":0,"col":0},"anchor":{"row":0,"col":0},"sels":[{"cursor":{"row":0,"col":0},"anchor":{"row":0,"col":0}},{"cursor":{"row":0,"col":2},"anchor":{"row":0,"col":2}},{"cursor":{"row":0,"col":4},"anchor":{"row":0,"col":4}},{"cursor":{"row":0,"col":6},"anchor":{"row":0,"col":6}},{"cursor":{"row":0,"col":8},"anchor":{"row":0,"col":8}},{"cursor":{"row":0,"col":10},"anchor":{"row":0,"col":10}},{"cursor":{"row":0,"col":12},"anchor":{"row":0,"col":12}},{"cursor":{"row":0,"col":14},"anchor":{"row":0,"col":14}},{"cursor":{"row":0,"col":16},"anchor":{"row":0,"col":16}},{"cursor":{"row":0,"col":18},"anchor":{"row":0,"col":18}},{"cursor":{"row":0,"col":20},"anchor":{"row":0,"col":20}},{"cursor":{"row":0,"col":22},"anchor":{"row":0,"col":22}},{"cursor":{"row":0,"col":24},"anchor":{"row":0,"col":24}},{"cursor":{"row":0,"col":26},"anchor":{"row":0,"col":26}},{"cursor":{"row":0,"col":28},"anchor":{"row":0,"col":28}},{"cursor":{"row":0,"col":30},"anchor":{"row":0,"col":30}},{"cursor":{"row":0,"col":32},"anchor":{"row":0,"col":32}},{"cursor":{"row":0,"col":34},"anchor":{"row":0,"col":34}},{"cursor":{"row":0,"col":36},"anchor":{"row":0,"col":36}},{"cursor":{"row":0,"col":38},"anchor":{"row":0,"col":38}},{"cursor":{"row":1,"col":0},"anchor":{"row":1,"col":0}},{"cursor":{"row":1,"col":2},"anchor":{"row":1,"col":2}},{"cursor":{"row":1,"col":4},"anchor":{"row":1,"col":4}},{"cursor":{"row":1,"col":6},"anchor":{"row":1,"col":6}},{"cursor":{"row":1,"col":8},"anchor":{"row":1,"col":8}},{"cursor":{"row":1,"col":10},"anchor":{"row":1,"col":10}},{"cursor":{"row":1,"col":12},"anchor":{"row":1,"col":12}},{"cursor":{"row":1,"col":14},"anchor":{"row":1,"col":14}},{"cursor":{"row":1,"col":16},"anchor":{"row":1,"col":16}},{"cursor":{"row":1,"col":18},"anchor":{"row":1,"col":18}},{"cursor":{"row":1,"col":20},"anchor":{"row":1,"col":20}},{"cursor":{"row":1,"col":22},"anchor":{"row":1,"col":22}},{"cursor":{"row":1,"col":24},"anchor":{"row":1,"col":24}},{"cursor":{"row":1,"col":26},"anchor":{"row":1,"col":26}},{"cursor":{"row":1,"col":28},"anchor":{"row":1,"col":28}},{"cursor":{"row":1,"col":30},"anchor":{"row":1,"col":30}},{"cursor":{"row":1,"col":32},"anchor":{"row":1,"col":32}},{"cursor":{"row":1,"col":34},"anchor":{"row":1,"col":34}},{"cursor":{"row":1,"col":36},"anchor":{"row":1,"col":36}},{"cursor":{"row":1,"col":38},"anchor":{"row":1,"col":38}},{"cursor":{"row":2,"col":0},"anchor":{"row":2,"col":0}},{"cursor":{"row":2,"col":2},"anchor":{"row":2,"col":2}},{"cursor":{"row":2,"col":4},"anchor":{"row":2,"col":4}},{"cursor":{"row":2,"col":6},"anchor":{"row":2,"col":6}},{"cursor":{"row":2,"col":8},"anchor":{"row":2,"col":8}},{"cursor":{"row":2,"col":10},"anchor":{"row":2,"col":10}},{"cursor":{"row":2,"col":12},"anchor":{"row":2,"col":12}},{"cursor":{"row":2,"col":14},"anchor":{"row":2,"col":14}},{"cursor":{"row":2,"col":16},"anchor":{"row":2,"col":16}},{"cursor":{"row":2,"col":18},"anchor":{"row":2,"col":18}},{"cursor":{"row":2,"col":20},"anchor":{"row":2,"col":20}},{"cursor":{"row":2,"col":22},"anchor":{"row":2,"col":22}},{"cursor":{"row":2,"col":24},"anchor":{"row":2,"col":24}},{"cursor":{"row":2,"col":26},"anchor":{"row":2,"col":26}},{"cursor":{"row":2,"col":28},"anchor":{"row":2,"col":28}},{"cursor":{"row":2,"col":30},"anchor":{"row":2,"col":30}},{"cursor":{"row":2,"col":32},"anchor":{"row":2,"col":32}},{"cursor":{"row":2,"col":34},"anchor":{"row":2,"col":34}},{"cursor":{"row":2,"col":36},"anchor":{"row":2,"col":36}},{"cursor":{"row":2,"col":38},"anchor":{"row":2,"col":38}},{"cursor":{"row":3,"col":0},"anchor":{"row":3,"col":0}},{"cursor":{"row":3,"col":2},"anchor":{"row":3,"col":2}},{"cursor":{"row":3,"col":4},"anchor":{"row":3,"col":4}},{"cursor":{"row":3,"col":6},"anchor":{"row":3,"col":6}},{"cursor":{"row":3,"col":8},"anchor":{"row":3,"col":8}},{"cursor":{"row":3,"col":10},"anchor":{"row":3,"col":10}},{"cursor":{"row":3,"col":12},"anchor":{"row":3,"col":12}},{"cursor":{"row":3,"col":14},"anchor":{"row":3,"col":14}},{"cursor":{"row":3,"col":16},"anchor":{"row":3,"col":16}},{"cursor":{"row":3,"col":18},"anchor":{"row":3,"col":18}},{"cursor":{"row":3,"col":20},"anchor":{"row":3,"col":20}},{"cursor":{"row":3,"col":22},"anchor":{"row":3,"col":22}},{"cursor":{"row":3,"col":24},"anchor":{"row":3,"col":24}},{"cursor":{"row":3,"col":26},"anchor":{"row":3,"col":26}},{"cursor":{"row":3,"col":28},"anchor":{"row":3,"col":28}},{"cursor":{"row":3,"col":30},"anchor":{"row":3,"col":30}},{"cursor":{"row":3,"col":32},"anchor":{"row":3,"col":32}},{"cursor":{"row":3,"col":34},"anchor":{"row":3,"col":34}},{"cursor":{"row":3,"col":36},"anchor":{"row":3,"col":36}},{"cursor":{"row":3,"col":38},"anchor":{"row":3,"col":38}},{"cursor":{"row":4,"col":0},"anchor":{"row":4,"col":0}},{"cursor":{"row":4,"col":2},"anchor":{"row":4,"col":2}},{"cursor":{"row":4,"col":4},"anchor":{"row":4,"col":4}},{"cursor":{"row":4,"col":6},"anchor":{"row":4,"col":6}},{"cursor":{"row":4,"col":8},"anchor":{"row":4,"col":8}},{"cursor":{"row":4,"col":10},"anchor":{"row":4,"col":10}},{"cursor":{"row":4,"col":12},"anchor":{"row":4,"col":12}},{"cursor":{"row":4,"col":14},"anchor":{"row":4,"col":14}},{"cursor":{"row":4,"col":16},"anchor":{"row":4,"col":16}},{"cursor":{"row":4,"col":18},"anchor":{"row":4,"col":18}},{"cursor":{"row":4,"col":20},"anchor":{"row":4,"col":20}},{"cursor":{"row":4,"col":22},"anchor":{"row":4,"col":22}},{"cursor":{"row":4,"col":24},"anchor":{"row":4,"col":24}},{"cursor":{"row":4,"col":26},"anchor":{"row":4,"col":26}},{"cursor":{"row":4,"col":28},"anchor":{"row":4,"col":28}},{"cursor":{"row":4,"col":30},"anchor":{"row":4,"col":30}},{"cursor":{"row":4,"col":32},"anchor":{"row":4,"col":32}},{"cursor":{"row":4,"col":34},"anchor":{"row":4,"col":34}},{"cursor":{"row":4,"col":36},"anchor":{"row":4,"col":36}},{"cursor":{"row":4,"col":38},"anchor":{"row":4,"col":38}},{"cursor":{"row":5,"col":0},"anchor":{"row":5,"col":0}},{"cursor":{"row":5,"col":2},"anchor":{"row":5,"col":2}},{"cursor":{"row":5,"col":4},"anchor":{"row":5,"col":4}},{"cursor":{"row":5,"col":6},"anchor":{"row":5,"col":6}},{"cursor":{"row":5,"col":8},"anchor":{"row":5,"col":8}},{"cursor":{"row":5,"col":10},"anchor":{"row":5,"col":10}},{"cursor":{"row":5,"col":12},"anchor":{"row":5,"col":12}},{"cursor":{"row":5,"col":14},"anchor":{"row":5,"col":14}},{"cursor":{"row":5,"col":16},"anchor":{"row":5,"col":16}},{"cursor":{"row":5,"col":18},"anchor":{"row":5,"col":18}},{"cursor":{"row":5,"col":20},"anchor":{"row":5,"col":20}},{"cursor":{"row":5,"col":22},"anchor":{"row":5,"col":22}},{"cursor":{"row":5,"col":24},"anchor":{"row":5,"col":24}},{"cursor":{"row":5,"col":26},"anchor":{"row":5,"col":26}},{"cursor":{"row":5,"col":28},"anchor":{"row":5,"col":28}},{"cursor":{"row":5,"col":30},"anchor":{"row":5,"col":30}},{"cursor":{"row":5,"col":32},"anchor":{"row":5,"col":32}},{"cursor":{"row":5,"col":34},"anchor":{"row":5,"col":34}},{"cursor":{"row":5,"col":36},"anchor":{"row":5,"col":36}},{"cursor":{"row":5,"col":38},"anchor":{"row":5,"col":38}},{"cursor":{"row":6,"col":0},"anchor":{"row":6,"col":0}},{"cursor":{"row":6,"col":2},"anchor":{"row":6,"col":2}},{"cursor":{"row":6,"col":4},"anchor":{"row":6,"col":4}},{"cursor":{"row":6,"col":6},"anchor":{"row":6,"col":6}},{"cursor":{"row":6,"col":8},"anchor":{"row":6,"col":8}},{"cursor":{"row":6,"col":10},"anchor":{"row":6,"col":10}},{"cursor":{"row":6,"col":12},"anchor":{"row":6,"col":12}},{"cursor":{"row":6,"col":14},"anchor":{"row":6,"col":14}},{"cursor":{"row":6,"col":16},"anchor":{"row":6,"col":16}},{"cursor":{"row":6,"col":18},"anchor":{"row":6,"col":18}},{"cursor":{"row":6,"col":20},"anchor":{"row":6,"col":20}},{"cursor":{"row":6,"col":22},"anchor":{"row":6,"col":22}},{"cursor":{"row":6,"col":24},"anchor":{"row":6,"col":24}},{"cursor":{"row":6,"col":26},"anchor":{"row":6,"col":26}},{"cursor":{"row":6,"col":28},"anchor":{"row":6,"col":28}},{"cursor":{"row":6,"col":30},"anchor":{"row":6,"col":30}},{"cursor":{"row":6,"col":32},"anchor":{"row":6,"col":32}},{"cursor":{"row":6,"col":34},"anchor":{"row":6,"col":34}},{"cursor":{"row":6,"col":36},"anchor":{"row":6,"col":36}},{"cursor":{"row":6,"col":38},"anchor":{"row":6,"col":38}},{"cursor":{"row":7,"col":0},"anchor":{"row":7,"col":0}},{"cursor":{"row":7,"col":2},"anchor":{"row":7,"col":2}},{"cursor":{"row":7,"col":4},"anchor":{"row":7,"col":4}},{"cursor":{"row":7,"col":6},"anchor":{"row":7,"col":6}},{"cursor":{"row":7,"col":8},"anchor":{"row":7,"col":8}},{"cursor":{"row":7,"col":10},"anchor":{"row":7,"col":10}},{"cursor":{"row":7,"col":12},"anchor":{"row":7,"col":12}},{"cursor":{"row":7,"col":14},"anchor":{"row":7,"col":14}},{"cursor":{"row":7,"col":16},"anchor":{"row":7,"col":16}},{"cursor":{"row":7,"col":18},"anchor":{"row":7,"col":18}},{"cursor":{"row":7,"col":20},"anchor":{"row":7,"col":20}},{"cursor":{"row":7,"col":22},"anchor":{"row":7,"col":22}},{"cursor":{"row":7,"col":24},"anchor":{"row":7,"col":24}},{"cursor":{"row":7,"col":26},"anchor":{"row":7,"col":26}},{"cursor":{"row":7,"col":28},"anchor":{"row":7,"col":28}},{"cursor":{"row":7,"col":30},"anchor":{"row":7,"col":30}},{"cursor":{"row":7,"col":32},"anchor":{"row":7,"col":32}},{"cursor":{"row":7,"col":34},"anchor":{"row":7,"col":34}},{"cursor":{"row":7,"col":36},"anchor":{"row":7,"col":36}},{"cursor":{"row":7,"col":38},"anchor":{"row":7,"col":38}},{"cursor":{"row":8,"col":0},"anchor":{"row":8,"col":0}},{"cursor":{"row":8,"col":2},"anchor":{"row":8,"col":2}},{"cursor":{"row":8,"col":4},"anchor":{"row":8,"col":4}},{"cursor":{"row":8,"col":6},"anchor":{"row":8,"col":6}},{"cursor":{"row":8,"col":8},"anchor":{"row":8,"col":8}},{"cursor":{"row":8,"col":10},"anchor":{"row":8,"col":10}},{"cursor":{"row":8,"col":12},"anchor":{"row":8,"col":12}},{"cursor":{"row":8,"col":14},"anchor":{"row":8,"col":14}},{"cursor":{"row":8,"col":16},"anchor":{"row":8,"col":16}},{"cursor":{"row":8,"col":18},"anchor":{"row":8,"col":18}},{"cursor":{"row":8,"col":20},"anchor":{"row":8,"col":20}},{"cursor":{"row":8,"col":22},"anchor":{"row":8,"col":22}},{"cursor":{"row":8,"col":24},"anchor":{"row":8,"col":24}},{"cursor":{"row":8,"col":26},"anchor":{"row":8,"col":26}},{"cursor":{"row":8,"col":28},"anchor":{"row":8,"col":28}},{"cursor":{"row":8,"col":30},"anchor":{"row":8,"col":30}},{"cursor":{"row":8,"col":32},"anchor":{"row":8,"col":32}},{"cursor":{"row":8,"col":34},"anchor":{"row":8,"col":34}},{"cursor":{"row":8,"col":36},"anchor":{"row":8,"col":36}},{"cursor":{"row":8,"col":38},"anchor":{"row":8,"col":38}},{"cursor":{"row":9,"col":0},"anchor":{"row":9,"col":0}},{"cursor":{"row":9,"col":2},"anchor":{"row":9,"col":2}},{"cursor":{"row":9,"col":4},"anchor":{"row":9,"col":4}},{"cursor":{"row":9,"col":6},"anchor":{"row":9,"col":6}},{"cursor":{"row":9,"col":8},"anchor":{"row":9,"col":8}},{"cursor":{"row":9,"col":10},"anchor":{"row":9,"col":10}},{"cursor":{"row":9,"col":12},"anchor":{"row":9,"col":12}},{"cursor":{"row":9,"col":14},"anchor":{"row":9,"col":14}},{"cursor":{"row":9,"col":16},"anchor":{"row":9,"col":16}},{"cursor":{"row":9,"col":18},"anchor":{"row":9,"col":18}},{"cursor":{"row":9,"col":20},"anchor":{"row":9,"col":20}},{"cursor":{"row":9,"col":22},"anchor":{"row":9,"col":22}},{"cursor":{"row":9,"col":24},"anchor":{"row":9,"col":24}},{"cursor":{"row":9,"col":26},"anchor":{"row":9,"col":26}},{"cursor":{"row":9,"col":28},"anchor":{"row":9,"col":28}},{"cursor":{"row":9,"col":30},"anchor":{"row":9,"col":30}},{"cursor":{"row":9,"col":32},"anchor":{"row":9,"col":32}},{"cursor":{"row":9,"col":34},"anchor":{"row":9,"col":34}},{"cursor":{"row":9,"col":36},"anchor":{"row":9,"col":36}},{"cursor":{"row":9,"col":38},"anchor":{"row":9,"col":38}}],"primary":0}
+{"name":"sel-many-ranges-edit","text":"xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy\nxy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy\nxy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy\nxy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy\nxy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy\nxy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy\nxy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy\nxy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy\nxy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy\nxy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy xy\n","mode":"normal","cursor":{"row":0,"col":2},"anchor":{"row":0,"col":2},"sels":[{"cursor":{"row":0,"col":2},"anchor":{"row":0,"col":2}},{"cursor":{"row":0,"col":5},"anchor":{"row":0,"col":5}},{"cursor":{"row":0,"col":8},"anchor":{"row":0,"col":8}},{"cursor":{"row":0,"col":11},"anchor":{"row":0,"col":11}},{"cursor":{"row":0,"col":14},"anchor":{"row":0,"col":14}},{"cursor":{"row":0,"col":17},"anchor":{"row":0,"col":17}},{"cursor":{"row":0,"col":20},"anchor":{"row":0,"col":20}},{"cursor":{"row":0,"col":23},"anchor":{"row":0,"col":23}},{"cursor":{"row":0,"col":26},"anchor":{"row":0,"col":26}},{"cursor":{"row":0,"col":29},"anchor":{"row":0,"col":29}},{"cursor":{"row":0,"col":32},"anchor":{"row":0,"col":32}},{"cursor":{"row":0,"col":35},"anchor":{"row":0,"col":35}},{"cursor":{"row":0,"col":38},"anchor":{"row":0,"col":38}},{"cursor":{"row":0,"col":41},"anchor":{"row":0,"col":41}},{"cursor":{"row":0,"col":44},"anchor":{"row":0,"col":44}},{"cursor":{"row":0,"col":47},"anchor":{"row":0,"col":47}},{"cursor":{"row":0,"col":50},"anchor":{"row":0,"col":50}},{"cursor":{"row":0,"col":53},"anchor":{"row":0,"col":53}},{"cursor":{"row":0,"col":56},"anchor":{"row":0,"col":56}},{"cursor":{"row":0,"col":59},"anchor":{"row":0,"col":59}},{"cursor":{"row":1,"col":2},"anchor":{"row":1,"col":2}},{"cursor":{"row":1,"col":5},"anchor":{"row":1,"col":5}},{"cursor":{"row":1,"col":8},"anchor":{"row":1,"col":8}},{"cursor":{"row":1,"col":11},"anchor":{"row":1,"col":11}},{"cursor":{"row":1,"col":14},"anchor":{"row":1,"col":14}},{"cursor":{"row":1,"col":17},"anchor":{"row":1,"col":17}},{"cursor":{"row":1,"col":20},"anchor":{"row":1,"col":20}},{"cursor":{"row":1,"col":23},"anchor":{"row":1,"col":23}},{"cursor":{"row":1,"col":26},"anchor":{"row":1,"col":26}},{"cursor":{"row":1,"col":29},"anchor":{"row":1,"col":29}},{"cursor":{"row":1,"col":32},"anchor":{"row":1,"col":32}},{"cursor":{"row":1,"col":35},"anchor":{"row":1,"col":35}},{"cursor":{"row":1,"col":38},"anchor":{"row":1,"col":38}},{"cursor":{"row":1,"col":41},"anchor":{"row":1,"col":41}},{"cursor":{"row":1,"col":44},"anchor":{"row":1,"col":44}},{"cursor":{"row":1,"col":47},"anchor":{"row":1,"col":47}},{"cursor":{"row":1,"col":50},"anchor":{"row":1,"col":50}},{"cursor":{"row":1,"col":53},"anchor":{"row":1,"col":53}},{"cursor":{"row":1,"col":56},"anchor":{"row":1,"col":56}},{"cursor":{"row":1,"col":59},"anchor":{"row":1,"col":59}},{"cursor":{"row":2,"col":2},"anchor":{"row":2,"col":2}},{"cursor":{"row":2,"col":5},"anchor":{"row":2,"col":5}},{"cursor":{"row":2,"col":8},"anchor":{"row":2,"col":8}},{"cursor":{"row":2,"col":11},"anchor":{"row":2,"col":11}},{"cursor":{"row":2,"col":14},"anchor":{"row":2,"col":14}},{"cursor":{"row":2,"col":17},"anchor":{"row":2,"col":17}},{"cursor":{"row":2,"col":20},"anchor":{"row":2,"col":20}},{"cursor":{"row":2,"col":23},"anchor":{"row":2,"col":23}},{"cursor":{"row":2,"col":26},"anchor":{"row":2,"col":26}},{"cursor":{"row":2,"col":29},"anchor":{"row":2,"col":29}},{"cursor":{"row":2,"col":32},"anchor":{"row":2,"col":32}},{"cursor":{"row":2,"col":35},"anchor":{"row":2,"col":35}},{"cursor":{"row":2,"col":38},"anchor":{"row":2,"col":38}},{"cursor":{"row":2,"col":41},"anchor":{"row":2,"col":41}},{"cursor":{"row":2,"col":44},"anchor":{"row":2,"col":44}},{"cursor":{"row":2,"col":47},"anchor":{"row":2,"col":47}},{"cursor":{"row":2,"col":50},"anchor":{"row":2,"col":50}},{"cursor":{"row":2,"col":53},"anchor":{"row":2,"col":53}},{"cursor":{"row":2,"col":56},"anchor":{"row":2,"col":56}},{"cursor":{"row":2,"col":59},"anchor":{"row":2,"col":59}},{"cursor":{"row":3,"col":2},"anchor":{"row":3,"col":2}},{"cursor":{"row":3,"col":5},"anchor":{"row":3,"col":5}},{"cursor":{"row":3,"col":8},"anchor":{"row":3,"col":8}},{"cursor":{"row":3,"col":11},"anchor":{"row":3,"col":11}},{"cursor":{"row":3,"col":14},"anchor":{"row":3,"col":14}},{"cursor":{"row":3,"col":17},"anchor":{"row":3,"col":17}},{"cursor":{"row":3,"col":20},"anchor":{"row":3,"col":20}},{"cursor":{"row":3,"col":23},"anchor":{"row":3,"col":23}},{"cursor":{"row":3,"col":26},"anchor":{"row":3,"col":26}},{"cursor":{"row":3,"col":29},"anchor":{"row":3,"col":29}},{"cursor":{"row":3,"col":32},"anchor":{"row":3,"col":32}},{"cursor":{"row":3,"col":35},"anchor":{"row":3,"col":35}},{"cursor":{"row":3,"col":38},"anchor":{"row":3,"col":38}},{"cursor":{"row":3,"col":41},"anchor":{"row":3,"col":41}},{"cursor":{"row":3,"col":44},"anchor":{"row":3,"col":44}},{"cursor":{"row":3,"col":47},"anchor":{"row":3,"col":47}},{"cursor":{"row":3,"col":50},"anchor":{"row":3,"col":50}},{"cursor":{"row":3,"col":53},"anchor":{"row":3,"col":53}},{"cursor":{"row":3,"col":56},"anchor":{"row":3,"col":56}},{"cursor":{"row":3,"col":59},"anchor":{"row":3,"col":59}},{"cursor":{"row":4,"col":2},"anchor":{"row":4,"col":2}},{"cursor":{"row":4,"col":5},"anchor":{"row":4,"col":5}},{"cursor":{"row":4,"col":8},"anchor":{"row":4,"col":8}},{"cursor":{"row":4,"col":11},"anchor":{"row":4,"col":11}},{"cursor":{"row":4,"col":14},"anchor":{"row":4,"col":14}},{"cursor":{"row":4,"col":17},"anchor":{"row":4,"col":17}},{"cursor":{"row":4,"col":20},"anchor":{"row":4,"col":20}},{"cursor":{"row":4,"col":23},"anchor":{"row":4,"col":23}},{"cursor":{"row":4,"col":26},"anchor":{"row":4,"col":26}},{"cursor":{"row":4,"col":29},"anchor":{"row":4,"col":29}},{"cursor":{"row":4,"col":32},"anchor":{"row":4,"col":32}},{"cursor":{"row":4,"col":35},"anchor":{"row":4,"col":35}},{"cursor":{"row":4,"col":38},"anchor":{"row":4,"col":38}},{"cursor":{"row":4,"col":41},"anchor":{"row":4,"col":41}},{"cursor":{"row":4,"col":44},"anchor":{"row":4,"col":44}},{"cursor":{"row":4,"col":47},"anchor":{"row":4,"col":47}},{"cursor":{"row":4,"col":50},"anchor":{"row":4,"col":50}},{"cursor":{"row":4,"col":53},"anchor":{"row":4,"col":53}},{"cursor":{"row":4,"col":56},"anchor":{"row":4,"col":56}},{"cursor":{"row":4,"col":59},"anchor":{"row":4,"col":59}},{"cursor":{"row":5,"col":2},"anchor":{"row":5,"col":2}},{"cursor":{"row":5,"col":5},"anchor":{"row":5,"col":5}},{"cursor":{"row":5,"col":8},"anchor":{"row":5,"col":8}},{"cursor":{"row":5,"col":11},"anchor":{"row":5,"col":11}},{"cursor":{"row":5,"col":14},"anchor":{"row":5,"col":14}},{"cursor":{"row":5,"col":17},"anchor":{"row":5,"col":17}},{"cursor":{"row":5,"col":20},"anchor":{"row":5,"col":20}},{"cursor":{"row":5,"col":23},"anchor":{"row":5,"col":23}},{"cursor":{"row":5,"col":26},"anchor":{"row":5,"col":26}},{"cursor":{"row":5,"col":29},"anchor":{"row":5,"col":29}},{"cursor":{"row":5,"col":32},"anchor":{"row":5,"col":32}},{"cursor":{"row":5,"col":35},"anchor":{"row":5,"col":35}},{"cursor":{"row":5,"col":38},"anchor":{"row":5,"col":38}},{"cursor":{"row":5,"col":41},"anchor":{"row":5,"col":41}},{"cursor":{"row":5,"col":44},"anchor":{"row":5,"col":44}},{"cursor":{"row":5,"col":47},"anchor":{"row":5,"col":47}},{"cursor":{"row":5,"col":50},"anchor":{"row":5,"col":50}},{"cursor":{"row":5,"col":53},"anchor":{"row":5,"col":53}},{"cursor":{"row":5,"col":56},"anchor":{"row":5,"col":56}},{"cursor":{"row":5,"col":59},"anchor":{"row":5,"col":59}},{"cursor":{"row":6,"col":2},"anchor":{"row":6,"col":2}},{"cursor":{"row":6,"col":5},"anchor":{"row":6,"col":5}},{"cursor":{"row":6,"col":8},"anchor":{"row":6,"col":8}},{"cursor":{"row":6,"col":11},"anchor":{"row":6,"col":11}},{"cursor":{"row":6,"col":14},"anchor":{"row":6,"col":14}},{"cursor":{"row":6,"col":17},"anchor":{"row":6,"col":17}},{"cursor":{"row":6,"col":20},"anchor":{"row":6,"col":20}},{"cursor":{"row":6,"col":23},"anchor":{"row":6,"col":23}},{"cursor":{"row":6,"col":26},"anchor":{"row":6,"col":26}},{"cursor":{"row":6,"col":29},"anchor":{"row":6,"col":29}},{"cursor":{"row":6,"col":32},"anchor":{"row":6,"col":32}},{"cursor":{"row":6,"col":35},"anchor":{"row":6,"col":35}},{"cursor":{"row":6,"col":38},"anchor":{"row":6,"col":38}},{"cursor":{"row":6,"col":41},"anchor":{"row":6,"col":41}},{"cursor":{"row":6,"col":44},"anchor":{"row":6,"col":44}},{"cursor":{"row":6,"col":47},"anchor":{"row":6,"col":47}},{"cursor":{"row":6,"col":50},"anchor":{"row":6,"col":50}},{"cursor":{"row":6,"col":53},"anchor":{"row":6,"col":53}},{"cursor":{"row":6,"col":56},"anchor":{"row":6,"col":56}},{"cursor":{"row":6,"col":59},"anchor":{"row":6,"col":59}},{"cursor":{"row":7,"col":2},"anchor":{"row":7,"col":2}},{"cursor":{"row":7,"col":5},"anchor":{"row":7,"col":5}},{"cursor":{"row":7,"col":8},"anchor":{"row":7,"col":8}},{"cursor":{"row":7,"col":11},"anchor":{"row":7,"col":11}},{"cursor":{"row":7,"col":14},"anchor":{"row":7,"col":14}},{"cursor":{"row":7,"col":17},"anchor":{"row":7,"col":17}},{"cursor":{"row":7,"col":20},"anchor":{"row":7,"col":20}},{"cursor":{"row":7,"col":23},"anchor":{"row":7,"col":23}},{"cursor":{"row":7,"col":26},"anchor":{"row":7,"col":26}},{"cursor":{"row":7,"col":29},"anchor":{"row":7,"col":29}},{"cursor":{"row":7,"col":32},"anchor":{"row":7,"col":32}},{"cursor":{"row":7,"col":35},"anchor":{"row":7,"col":35}},{"cursor":{"row":7,"col":38},"anchor":{"row":7,"col":38}},{"cursor":{"row":7,"col":41},"anchor":{"row":7,"col":41}},{"cursor":{"row":7,"col":44},"anchor":{"row":7,"col":44}},{"cursor":{"row":7,"col":47},"anchor":{"row":7,"col":47}},{"cursor":{"row":7,"col":50},"anchor":{"row":7,"col":50}},{"cursor":{"row":7,"col":53},"anchor":{"row":7,"col":53}},{"cursor":{"row":7,"col":56},"anchor":{"row":7,"col":56}},{"cursor":{"row":7,"col":59},"anchor":{"row":7,"col":59}},{"cursor":{"row":8,"col":2},"anchor":{"row":8,"col":2}},{"cursor":{"row":8,"col":5},"anchor":{"row":8,"col":5}},{"cursor":{"row":8,"col":8},"anchor":{"row":8,"col":8}},{"cursor":{"row":8,"col":11},"anchor":{"row":8,"col":11}},{"cursor":{"row":8,"col":14},"anchor":{"row":8,"col":14}},{"cursor":{"row":8,"col":17},"anchor":{"row":8,"col":17}},{"cursor":{"row":8,"col":20},"anchor":{"row":8,"col":20}},{"cursor":{"row":8,"col":23},"anchor":{"row":8,"col":23}},{"cursor":{"row":8,"col":26},"anchor":{"row":8,"col":26}},{"cursor":{"row":8,"col":29},"anchor":{"row":8,"col":29}},{"cursor":{"row":8,"col":32},"anchor":{"row":8,"col":32}},{"cursor":{"row":8,"col":35},"anchor":{"row":8,"col":35}},{"cursor":{"row":8,"col":38},"anchor":{"row":8,"col":38}},{"cursor":{"row":8,"col":41},"anchor":{"row":8,"col":41}},{"cursor":{"row":8,"col":44},"anchor":{"row":8,"col":44}},{"cursor":{"row":8,"col":47},"anchor":{"row":8,"col":47}},{"cursor":{"row":8,"col":50},"anchor":{"row":8,"col":50}},{"cursor":{"row":8,"col":53},"anchor":{"row":8,"col":53}},{"cursor":{"row":8,"col":56},"anchor":{"row":8,"col":56}},{"cursor":{"row":8,"col":59},"anchor":{"row":8,"col":59}},{"cursor":{"row":9,"col":2},"anchor":{"row":9,"col":2}},{"cursor":{"row":9,"col":5},"anchor":{"row":9,"col":5}},{"cursor":{"row":9,"col":8},"anchor":{"row":9,"col":8}},{"cursor":{"row":9,"col":11},"anchor":{"row":9,"col":11}},{"cursor":{"row":9,"col":14},"anchor":{"row":9,"col":14}},{"cursor":{"row":9,"col":17},"anchor":{"row":9,"col":17}},{"cursor":{"row":9,"col":20},"anchor":{"row":9,"col":20}},{"cursor":{"row":9,"col":23},"anchor":{"row":9,"col":23}},{"cursor":{"row":9,"col":26},"anchor":{"row":9,"col":26}},{"cursor":{"row":9,"col":29},"anchor":{"row":9,"col":29}},{"cursor":{"row":9,"col":32},"anchor":{"row":9,"col":32}},{"cursor":{"row":9,"col":35},"anchor":{"row":9,"col":35}},{"cursor":{"row":9,"col":38},"anchor":{"row":9,"col":38}},{"cursor":{"row":9,"col":41},"anchor":{"row":9,"col":41}},{"cursor":{"row":9,"col":44},"anchor":{"row":9,"col":44}},{"cursor":{"row":9,"col":47},"anchor":{"row":9,"col":47}},{"cursor":{"row":9,"col":50},"anchor":{"row":9,"col":50}},{"cursor":{"row":9,"col":53},"anchor":{"row":9,"col":53}},{"cursor":{"row":9,"col":56},"anchor":{"row":9,"col":56}},{"cursor":{"row":9,"col":59},"anchor":{"row":9,"col":59}}],"primary":0}
 {"name":"msel-align-basic","text":"a  =1\nbbb=2\n","mode":"normal","cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3},"sels":[{"cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3}},{"cursor":{"row":1,"col":3},"anchor":{"row":1,"col":3}}],"primary":0}
 {"name":"msel-align-columns","text":"a  ,b,c\nccc,d,e\n","mode":"normal","cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3},"sels":[{"cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3}},{"cursor":{"row":0,"col":5},"anchor":{"row":0,"col":5}},{"cursor":{"row":1,"col":3},"anchor":{"row":1,"col":3}},{"cursor":{"row":1,"col":5},"anchor":{"row":1,"col":5}}],"primary":0}
 {"name":"msel-align-uneven","text":"a  ,b\nccc,d,eee,f\n","mode":"normal","cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3},"sels":[{"cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3}},{"cursor":{"row":1,"col":3},"anchor":{"row":1,"col":3}},{"cursor":{"row":1,"col":5},"anchor":{"row":1,"col":5}},{"cursor":{"row":1,"col":9},"anchor":{"row":1,"col":9}}],"primary":0}
diff --git a/test/panes.zig b/test/panes.zig
index f0e1ba3d..a56c07bf 100644
--- a/test/panes.zig
+++ b/test/panes.zig
@@ -305,7 +305,7 @@ const TagNavigationTests = struct {
         try std.testing.expectEqual(@as(usize, 2), got.n);
         for (ranges[0..got.n]) |range| try std.testing.expectEqualStrings("S", text[@min(range.anchor, range.head)..@max(range.anchor, range.head)]);
         // the body's selection is its own
-        try std.testing.expectEqual(@as(u8, 0), pane.body.nsel);
+        try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
         // `/` from the tag is the body's search, as acme's Look from a tag is
         key(p, ',');
         key(p, '/');
@@ -1984,8 +1984,8 @@ test "prompt cancellation restores the selection before regex previews" {
         p.update(.{ .key = .{ .cp = case.pattern[0], .text = case.pattern } });
         try std.testing.expectEqual(case.secondary, pane.body.nsel);
         p.update(.{ .key = .{ .cp = Key.escape } });
-        try std.testing.expectEqual(@as(u8, 0), pane.body.nsel);
-        try std.testing.expectEqual(@as(u8, 0), pane.nsel_snap);
+        try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
+        try std.testing.expectEqual(@as(u16, 0), pane.nsel_snap);
         try std.testing.expectEqual(@as(i32, 10), pane.body.cur_col);
         try std.testing.expectEqual(@as(i32, 0), pane.body.vsel.col);
         try std.testing.expect(pane.body.vsel.active and pane.body.vsel.explicit);
@@ -2761,7 +2761,7 @@ const OutputTests = struct {
         try fillResults(p, 0, "/", .{ .query = .hover }, "", try p.gpa.dupe(u8, "short\n"), null);
         try std.testing.expectEqualStrings("short\n", result.file.?.content);
         try std.testing.expect(!result.body.vsel.active and !result.body.msel.active and !result.body.select);
-        try std.testing.expectEqual(@as(u8, 0), result.body.nsel);
+        try std.testing.expectEqual(@as(u16, 0), result.body.nsel);
         try std.testing.expectEqual(@as(i32, 0), result.body.cur_row);
         try std.testing.expectEqual(@as(i32, 0), result.body.cur_col);
         try std.testing.expectEqual(@as(usize, 0), result.file.?.scroll);
@@ -4581,7 +4581,7 @@ const LookResetTests = struct {
 
     fn cleared(pane: *const Pane) !void {
         try std.testing.expect(!pane.body.msel.active);
-        try std.testing.expectEqual(@as(u8, 0), pane.body.nsel);
+        try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
         try std.testing.expect(!pane.body.select);
         try std.testing.expectEqual(modal.Normal.State{}, pane.body.normal);
         try std.testing.expect(!pane.body.restore_cursor);
-- 
cgit v1.3


From bdbab17204efdb785b6ab3cc2022484485c0ded2 Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Mon, 28 Sep 2026 16:38:06 -0300
Subject: g. goes to where the last edit ended

helix goto_last_modification: every range moves to the end of the last
change (the start of a deletion, the end of an insertion), extending in
select mode. The position is kept on the Text in surface rows, set where
setEditText hands a body its new text, so a terminal's typed text has one
too and moves with its scrollback.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/helix-keys.md         | 2 +-
 src/Terminal.zig           | 6 +++++-
 src/Text.zig               | 3 +++
 src/config.zig             | 1 +
 src/edit.zig               | 7 +++++++
 src/modal.zig              | 3 +++
 src/normal.zig             | 4 ++++
 test/hxcases/cases.jsonl   | 5 +++++
 test/hxcases/goldens.jsonl | 5 +++++
 9 files changed, 34 insertions(+), 2 deletions(-)

(limited to 'src/Terminal.zig')

diff --git a/docs/helix-keys.md b/docs/helix-keys.md
index f2901b92..2928d78e 100644
--- a/docs/helix-keys.md
+++ b/docs/helix-keys.md
@@ -184,6 +184,7 @@ found. Pure text math in `modal.zig`: `findChar`, `matchBracket`,
 | `Alt-.` | repeat last `f`/`t`/`F`/`T` motion (`Pane.find_op`/`find_ch`), takes a count | decision: repeats ONLY the find family, not `m`/`[`/`]` (helix extends it there; marginal) | helix-verified (phase 5) |
 | `g|`, `<n>g|` | goto column n (1 = line start), clamped to the line | | helix-verified (phase 5) |
 | `gs` | goto first non-whitespace | alias of the `^` handler | helix-verified (phase 5) |
+| `g.` | go to where the last edit ended (a deletion's start, an insertion's end), every range there, extending in select mode | helix `goto_last_modification`. The position is `Text.last_edit`, set by `edit.setEditText` from where the old and new texts part; helix's is the last history revision's, so with nothing edited yet pardes stays put where the harness's helix goes to the end of its setup text | helix-verified |
 | `gt` / `gc` / `gb` | goto screen top / center / bottom | view-relative (`pane.scroll()` + `pane.rows`), column kept (clamped) | helix-verified (phase 5) |
 | `gj` / `gk` | VISUAL line down / up (+ count) | follows the wrapped body's own breaks (`file_pane.visualRow`, the same walk `fillBody` renders), keeping the goal column INSIDE the row; the last row of a line steps into the next line's first. Wrap off = one row per line, and this IS `j`/`k`. helix assigns the pair the other way round (its `j` is the visual one) | pardes-specific |
 | `PageUp` / `PageDown` | FULL page (was half) | `Ctrl-u`/`Ctrl-d` stay the half-page pair | helix-verified (phase 5) |
@@ -351,7 +352,6 @@ text.
 | Picker table (all rows), Prompt table (all rows) | picker / prompt internals | pickers — pardes' tag line is its own one-line editor |
 | `gn` `gp` `ga` `gm` | next/prev/alternate buffer | buffer nav — pardes panes aren't a buffer list |
 | `gw` | word-label jump | label-jump overlay machinery, not core editing |
-| `g.` | goto last modification | jumplist/history position tracking |
 | Window mode table: `Ctrl-w` + `w v s t f F h j k l q o H J K L ns nv` (+ Ctrl variants) | splits/window management | window mode — pardes has its own Ctrl-w focus + Alt-n/Alt-c + mouse layout drags |
 | `]f [f ]t [t ]a [a ]c [c ]e [e ]T [T ]x [x` | TS unimpaired jumps | tree-sitter |
 | `]g [g ]G [G` | git change jumps | needs VCS diff state |
diff --git a/src/Terminal.zig b/src/Terminal.zig
index 1ff561b1..4c29e151 100644
--- a/src/Terminal.zig
+++ b/src/Terminal.zig
@@ -720,7 +720,7 @@ pub fn feedOutput(p: *Pardes, pane: *Pane, bytes: []const u8) void {
     if (comptime !enabled) return;
     if (pane.terminal == null) return;
     const has_positions = pane.ovl != null or pane.body.cur_pinned or pane.body.vsel.active or
-        pane.body.msel.active or pane.body.nsel > 0 or pane.look_at != null or
+        pane.body.msel.active or pane.body.nsel > 0 or pane.body.last_edit != null or pane.look_at != null or
         pane.body.ed_undo_len > 0 or pane.body.ed_redo_len > 0 or pointerRowCount(pane) > 0;
     // Sticky bottom, as every other terminal does it: output drags the
     // viewport down only when the viewport was already on the last row, so
@@ -846,6 +846,10 @@ fn ingestWithPositions(pane: *Pane, bytes: []const u8) void {
         extra[nextra + 1] = &selection.arow;
         nextra += 2;
     }
+    if (pane.body.last_edit) |*at| {
+        extra[nextra] = &at.row;
+        nextra += 1;
+    }
     if (pane.look_at) |*at| {
         extra[nextra] = &at.row;
         nextra += 1;
diff --git a/src/Text.zig b/src/Text.zig
index 411c2ec8..70ec5369 100644
--- a/src/Text.zig
+++ b/src/Text.zig
@@ -69,6 +69,9 @@ sticky_col: i32 = -1,
 /// The insert session began with `a`: on Esc every range gives back the
 /// one character it was stretched by (helix restore_cursor).
 restore_cursor: bool = false,
+/// Where the last edit ended, a deletion's start or an insertion's end, in
+/// surface rows: for `g.` (helix last_edit_pos).
+last_edit: ?struct { row: i32, col: i32 } = null,
 /// insert `Ctrl-r` was pressed: the next key names the register to insert
 reg_wait: bool = false,
 normal: modal.Normal.State = .{},
diff --git a/src/config.zig b/src/config.zig
index 959f4c4a..993b6fe0 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -487,6 +487,7 @@ pub const goto_column: []const Chord = &.{.{ .cp = '|' }};
 pub const goto_view_top: []const Chord = &.{.{ .cp = 't' }};
 pub const goto_view_center: []const Chord = &.{.{ .cp = 'c' }};
 pub const goto_view_bottom: []const Chord = &.{.{ .cp = 'b' }};
+pub const goto_last_modification: []const Chord = &.{.{ .cp = '.' }};
 pub const goto_definition: []const Chord = &.{.{ .cp = 'd' }};
 pub const goto_declaration: []const Chord = &.{.{ .cp = 'D' }};
 pub const goto_type_definition: []const Chord = &.{.{ .cp = 'y' }};
diff --git a/src/edit.zig b/src/edit.zig
index 5e0d20a4..9398674a 100644
--- a/src/edit.zig
+++ b/src/edit.zig
@@ -484,6 +484,13 @@ pub fn setEditText(p: *Pardes, t: *Text, new: []u8) void {
         return;
     }
     const pane = t.pane() orelse return retireEditText(p, new);
+    // what changed ended where the texts agree again from their ends
+    const old: []const u8, const row0: i32 = if (pane.file) |f| .{ f.content, 0 } else if (pane.ovl) |o| .{ o.text, o.row } else .{ "", 0 };
+    const front = std.mem.indexOfDiff(u8, old, new) orelse @min(old.len, new.len);
+    var back: usize = 0;
+    while (back < @min(old.len, new.len) - front and old[old.len - 1 - back] == new[new.len - 1 - back]) back += 1;
+    const end = modal.positionAt(new, new.len - back);
+    t.last_edit = .{ .row = @as(i32, @intCast(end.row)) + row0, .col = @intCast(end.col) };
     if (pane.file) |*f| return panes.File.setContent(p, f, new);
     panes.Terminal.setEditText(p, pane, new);
 }
diff --git a/src/modal.zig b/src/modal.zig
index ae008f60..0171da93 100644
--- a/src/modal.zig
+++ b/src/modal.zig
@@ -28,6 +28,7 @@ pub const Normal = struct {
         goto_view_top,
         goto_view_center,
         goto_view_bottom,
+        goto_last_modification,
         goto_definition,
         goto_declaration,
         goto_type_definition,
@@ -251,6 +252,7 @@ pub const Normal = struct {
         view_top,
         view_center,
         view_bottom,
+        last_modification,
     };
     pub const View = enum { top, center, bottom, scroll_down, scroll_up };
     pub const Find = enum { forward, backward, till_forward, till_backward };
@@ -437,6 +439,7 @@ pub const Normal = struct {
                 if (key.has(.goto_view_top)) return resultAction(.{ .goto = .{ .target = .view_top, .count = count, .explicit_count = counted.explicit } });
                 if (key.has(.goto_view_center)) return resultAction(.{ .goto = .{ .target = .view_center, .count = count, .explicit_count = counted.explicit } });
                 if (key.has(.goto_view_bottom)) return resultAction(.{ .goto = .{ .target = .view_bottom, .count = count, .explicit_count = counted.explicit } });
+                if (key.has(.goto_last_modification)) return resultAction(.{ .goto = .{ .target = .last_modification, .count = count, .explicit_count = counted.explicit } });
                 if (key.has(.goto_definition)) return resultAction(.{ .lsp = .definition });
                 if (key.has(.goto_declaration)) return resultAction(.{ .lsp = .declaration });
                 if (key.has(.goto_type_definition)) return resultAction(.{ .lsp = .type_definition });
diff --git a/src/normal.zig b/src/normal.zig
index bc450581..228c9c39 100644
--- a/src/normal.zig
+++ b/src/normal.zig
@@ -460,6 +460,10 @@ fn executeNormalAction(p: *Pardes, t: *Text, semantic: modal.Normal.Action) void
             .view_top => return t.gotoWindow(text, range, .top, go.count),
             .view_center => return t.gotoWindow(text, range, .center, go.count),
             .view_bottom => return t.gotoWindow(text, range, .bottom, go.count),
+            .last_modification => {
+                const at = t.last_edit orelse return;
+                return t.pointMove(text, range, modal.offsetAt(text, .{ .row = @intCast(@max(0, at.row)), .col = @intCast(@max(0, at.col)) }));
+            },
         },
         .view => |view| if (t.what == .body) switch (view) {
             .top => {
diff --git a/test/hxcases/cases.jsonl b/test/hxcases/cases.jsonl
index 8a8f8a94..03b20ff5 100644
--- a/test/hxcases/cases.jsonl
+++ b/test/hxcases/cases.jsonl
@@ -441,6 +441,11 @@
 {"name": "ensure-forward", "pane": "file", "text": "ab cd\n", "keys": "%s\\w+<ret><A-;><A-:>"}
 {"name": "ensure-forward-one", "pane": "file", "text": "abc\n", "keys": "vll<A-;><A-:>"}
 {"name": "node-keys-plain-text", "pane": "file", "text": "ab cd\n", "keys": "w<A-o><A-i><A-p><A-right><A-a><A-I><A-e><A-b>"}
+{"name": "goto-last-mod", "pane": "file", "text": "ab\ncd\nef\n", "keys": "jliXY<esc>gg"}
+{"name": "goto-last-mod-go", "pane": "file", "text": "ab\ncd\nef\n", "keys": "jliXY<esc>ggg."}
+{"name": "goto-last-mod-delete", "pane": "file", "text": "abc\ndef\n", "keys": "jlxdgg"}
+{"name": "goto-last-mod-delete-go", "pane": "file", "text": "abc\ndef\n", "keys": "jldggg."}
+{"name": "goto-last-mod-select", "pane": "file", "text": "ab\ncd\nef\n", "keys": "jjiX<esc>ggvg."}
 {"name": "msel-align-basic", "pane": "file", "text": "a=1\nbbb=2\n", "keys": "%s=<ret>&"}
 {"name": "msel-align-columns", "pane": "file", "text": "a,b,c\nccc,d,e\n", "keys": "%s,<ret>&"}
 {"name": "msel-align-uneven", "pane": "file", "text": "a,b\nccc,d,eee,f\n", "keys": "%s,<ret>&"}
diff --git a/test/hxcases/goldens.jsonl b/test/hxcases/goldens.jsonl
index f1df5c0a..8e642073 100644
--- a/test/hxcases/goldens.jsonl
+++ b/test/hxcases/goldens.jsonl
@@ -441,6 +441,11 @@
 {"name":"ensure-forward","text":"ab cd\n","mode":"normal","cursor":{"row":0,"col":1},"anchor":{"row":0,"col":0},"sels":[{"cursor":{"row":0,"col":1},"anchor":{"row":0,"col":0}},{"cursor":{"row":0,"col":4},"anchor":{"row":0,"col":3}}],"primary":0}
 {"name":"ensure-forward-one","text":"abc\n","mode":"select","cursor":{"row":0,"col":2},"anchor":{"row":0,"col":0}}
 {"name":"node-keys-plain-text","text":"ab cd\n","mode":"normal","cursor":{"row":0,"col":2},"anchor":{"row":0,"col":0}}
+{"name":"goto-last-mod","text":"ab\ncXYd\nef\n","mode":"normal","cursor":{"row":0,"col":0},"anchor":{"row":0,"col":0}}
+{"name":"goto-last-mod-go","text":"ab\ncXYd\nef\n","mode":"normal","cursor":{"row":1,"col":3},"anchor":{"row":1,"col":3}}
+{"name":"goto-last-mod-delete","text":"abc\n","mode":"normal","cursor":{"row":0,"col":0},"anchor":{"row":0,"col":0}}
+{"name":"goto-last-mod-delete-go","text":"abc\ndf\n","mode":"normal","cursor":{"row":1,"col":1},"anchor":{"row":1,"col":1}}
+{"name":"goto-last-mod-select","text":"ab\ncd\nXef\n","mode":"select","cursor":{"row":2,"col":1},"anchor":{"row":0,"col":0}}
 {"name":"msel-align-basic","text":"a  =1\nbbb=2\n","mode":"normal","cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3},"sels":[{"cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3}},{"cursor":{"row":1,"col":3},"anchor":{"row":1,"col":3}}],"primary":0}
 {"name":"msel-align-columns","text":"a  ,b,c\nccc,d,e\n","mode":"normal","cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3},"sels":[{"cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3}},{"cursor":{"row":0,"col":5},"anchor":{"row":0,"col":5}},{"cursor":{"row":1,"col":3},"anchor":{"row":1,"col":3}},{"cursor":{"row":1,"col":5},"anchor":{"row":1,"col":5}}],"primary":0}
 {"name":"msel-align-uneven","text":"a  ,b\nccc,d,eee,f\n","mode":"normal","cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3},"sels":[{"cursor":{"row":0,"col":3},"anchor":{"row":0,"col":3}},{"cursor":{"row":1,"col":3},"anchor":{"row":1,"col":3}},{"cursor":{"row":1,"col":5},"anchor":{"row":1,"col":5}},{"cursor":{"row":1,"col":9},"anchor":{"row":1,"col":9}}],"primary":0}
-- 
cgit v1.3


From 68e30f560e46bb9a30433eb23b4edb1b93d69f46 Mon Sep 17 00:00:00 2001
From: Gabriel Schneider <gbrls@0x4200.cafe>
Date: Mon, 28 Sep 2026 16:57:01 -0300
Subject: A selection's other ranges live out of line, made at the second range
 and freed at one

The ranges beside the primary were an inline array in every Text, which at
1024 grew each pane by about 60 KiB. They are now allocated when a second
range appears (Text.reserveSels) and given back when the selection is one
range again (Text.dropSels); a column's or the workspace's tag allocates from
Text.gpa, any other text from its pane's. A refused tag edit restores them by
copy. The Pane size budget is back to 128 KiB, and a test holds that a single
cursor allocates nothing for them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/helix-keys.md |  2 +-
 docs/selections.md |  5 ++++-
 src/Terminal.zig   |  5 +----
 src/Text.zig       | 42 +++++++++++++++++++++++++++++++++++++++---
 src/edit.zig       | 10 ++++++++--
 src/layout.zig     |  6 +++---
 src/normal.zig     | 28 ++++++++++++++++++++++++----
 src/pardes.zig     | 10 ++++++++--
 test/panes.zig     |  1 +
 9 files changed, 89 insertions(+), 20 deletions(-)

(limited to 'src/Terminal.zig')

diff --git a/docs/helix-keys.md b/docs/helix-keys.md
index 88aca887..1fb1c67a 100644
--- a/docs/helix-keys.md
+++ b/docs/helix-keys.md
@@ -282,7 +282,7 @@ keeps the matches it found so far.
 | an all-lowercase pattern | matches case-blind | helix's smart-case. mvzr has no such flag, so the surface is lowercased instead (ASCII folding is byte-for-byte, so the offsets are identical) | helix-verified |
 | `^` and `$` | hold at every line's start and end | helix compiles with `multi_line(true)`; pardes gets the same by searching each line as its own haystack (`src/regexp.zig`) | helix-verified |
 | `.` | never matches a newline | as the Rust regex crate: a pattern without `\n` searches line by line, and one that names `\n` has its `.`s made `[^\n]` (`src/regexp.zig`) | helix-verified |
-| many matches | up to `memory.limits.selections` ranges: 1024 on the desktop, 64 on the board; matches past it are dropped | helix has no limit. The ranges are held inline in every `Text` (about 20 KiB each on the desktop) | helix-verified up to the limit |
+| many matches | up to `memory.limits.selections` ranges: 1024 on the desktop, 64 on the board; matches past it are dropped | helix has no limit. The room for them is allocated when a second range appears and given back at one range, so a single cursor costs nothing | helix-verified up to the limit |
 | `K<pat>` / `Alt-K<pat>` Enter | keep only the ranges a match starts inside / only those none does; primary 0, and keeping none leaves the selection alone | helix `keep_selections` / `remove_selections`, on the same prompt as `s`/`S` (markers `Keep /`, `Remove /`). The range is searched as `s` searches it, line by line with its lines' context, where helix matches the range's text alone: a `^` right at a range that starts mid-line matches in helix and not here | helix-verified |
 
 ### `Ctrl-c` — toggle comments
diff --git a/docs/selections.md b/docs/selections.md
index 203cf1de..5cc1df1a 100644
--- a/docs/selections.md
+++ b/docs/selections.md
@@ -17,7 +17,10 @@ desktop, 64 on the board).
   head, `vsel.row`/`vsel.col` the anchor while `vsel.active`, and a bare
   cursor (inactive `vsel`) is the one-character range under it. `msel` is
   the older whole-line form (`r0`..`r1`), kept for search-result highlights.
-- The others are `sels[0..nsel]`, each a `SelRange` of head and anchor plus
+- The others are `sels[0..nsel]`, in room allocated when a second range
+  appears and given back when the selection is one range again (a column's
+  or the workspace's tag allocates from `Text.gpa`, any other text from its
+  pane's), each a `SelRange` of head and anchor plus
   its own `j`/`k` goal column, in document order. The primary is not in the
   list; `Text.ranges` slots it in and returns its index.
 - Ends are CELLS, the characters a block cursor sits on, where helix's are
diff --git a/src/Terminal.zig b/src/Terminal.zig
index 4c29e151..ba156ada 100644
--- a/src/Terminal.zig
+++ b/src/Terminal.zig
@@ -545,10 +545,7 @@ test "replay ownership is terminal-only and construction rolls back on allocatio
             try std.testing.expectEqual(terminal and enabled, pane.terminal != null);
         }
     };
-    // Most of it is the three texts' selections, limits.selections ranges
-    // each held inline (about 20 KiB a text on the desktop), and the regex
-    // prompt's snapshot of them.
-    try std.testing.expect(@sizeOf(Pane) < 160 * 1024);
+    try std.testing.expect(@sizeOf(Pane) < 128 * 1024);
     try std.testing.checkAllAllocationFailures(std.testing.allocator, Case.run, .{false});
     try std.testing.checkAllAllocationFailures(std.testing.allocator, Case.run, .{true});
 }
diff --git a/src/Text.zig b/src/Text.zig
index 70ec5369..a44241ca 100644
--- a/src/Text.zig
+++ b/src/Text.zig
@@ -60,8 +60,14 @@ cur_row: i32 = 0,
 cur_col: i32 = 0,
 msel: LineSel = .{},
 vsel: CharSel = .{},
-sels: [max_selections - 1]SelRange = undefined,
+/// The ranges beside the primary, `nsel` of them: room for max_selections - 1
+/// made when a second range appears and given back when the selection is one
+/// range again, so a single cursor holds nothing here.
+sels: []SelRange = &.{},
 nsel: u16 = 0,
+/// What a column's or the workspace's tag allocates its ranges from; a text
+/// with a pane uses the pane's.
+gpa: ?std.mem.Allocator = null,
 select: bool = false,
 /// sticky goal column for j/k runs (helix old_visual_position): any
 /// non-vertical range write resets it to -1.
@@ -101,10 +107,39 @@ pub fn pane(t: *Text) ?*Pane {
 
 /// Free what a text owns: its characters and the buffers its undo keeps.
 pub fn deinit(t: *Text, gpa: std.mem.Allocator) void {
+    if (t.sels.len > 0) gpa.free(t.sels);
     if (t.own) |own| gpa.free(own);
     for (t.ed_undo[0..t.ed_undo_len]) |item| if (item.ovl) |overlay| gpa.free(overlay.text);
     for (t.ed_redo[0..t.ed_redo_len]) |item| if (item.ovl) |overlay| gpa.free(overlay.text);
-    t.* = .{ .what = t.what };
+    t.* = .{ .what = t.what, .gpa = t.gpa };
+}
+
+fn allocator(t: *Text) ?std.mem.Allocator {
+    return if (t.pane()) |w| w.gpa else t.gpa;
+}
+
+/// Room for the ranges beside the primary; false when there is none to be had.
+pub fn reserveSels(t: *Text) bool {
+    if (t.sels.len > 0) return true;
+    const gpa = t.allocator() orelse return false;
+    t.sels = gpa.alloc(SelRange, max_selections - 1) catch return false;
+    return true;
+}
+
+/// The ranges beside the primary as they were (a refused edit's undoing).
+pub fn restoreSels(t: *Text, kept: []const SelRange) void {
+    if (kept.len == 0) return t.dropSels();
+    if (!t.reserveSels()) return;
+    @memcpy(t.sels[0..kept.len], kept);
+    t.nsel = @intCast(kept.len);
+}
+
+/// Back to one range: the room for the others goes.
+pub fn dropSels(t: *Text) void {
+    t.nsel = 0;
+    if (t.sels.len == 0) return;
+    if (t.allocator()) |gpa| gpa.free(t.sels);
+    t.sels = &.{};
 }
 
 /// Bring the cursor into view (acme's textshow). Only a body scrolls to it;
@@ -185,7 +220,7 @@ pub fn setRange(t: *Text, text: []const u8, row0: i32, r0: modal.Selection, expl
         .explicit = explicit or t.select,
     };
     t.msel.active = false;
-    t.nsel = 0; // writing ONE range means the selection IS that range
+    t.dropSels(); // writing ONE range means the selection IS that range
     t.cur_pinned = true;
     t.sticky_col = -1;
     t.normal.clear();
@@ -262,6 +297,7 @@ pub fn setRanges(t: *Text, text: []const u8, in: []const modal.Selection, sticky
     }
     n = k + 1;
     setRange(t, text, 0, r[pri], explicit);
+    if (n > 1 and !t.reserveSels()) return; // no room: the primary alone
     t.sticky_col = st[pri];
     var w: usize = 0;
     for (r[0..n], 0..) |x, idx| {
diff --git a/src/edit.zig b/src/edit.zig
index 01b34237..5437a67d 100644
--- a/src/edit.zig
+++ b/src/edit.zig
@@ -167,10 +167,16 @@ fn pasteInto(p: *Pardes, t: *Text, bytes: []const u8) void {
     if (bytes.len == 0) return;
     const typed: pardes.Key = .{ .cp = bytes[0], .text = bytes };
     if (t.what == .tag and t.mode == .insert) if (t.pane()) |pane| if (tagline.typedIntoName(p, pane, typed)) return;
-    const kept = .{ t.cur_row, t.cur_col, t.vsel, t.msel, t.sels, t.nsel };
+    const kept = .{ t.cur_row, t.cur_col, t.vsel, t.msel };
+    var kept_sels: [Text.max_selections - 1]Text.SelRange = undefined;
+    const kept_n = t.nsel;
+    @memcpy(kept_sels[0..kept_n], t.sels[0..kept_n]);
     t.refused = false;
     if (t.mode == .insert) insertKey(p, t, typed) else pasteText(p, t, bytes, false, 1);
-    if (t.refused) t.cur_row, t.cur_col, t.vsel, t.msel, t.sels, t.nsel = kept;
+    if (t.refused) {
+        t.cur_row, t.cur_col, t.vsel, t.msel = kept;
+        t.restoreSels(kept_sels[0..kept_n]);
+    }
 }
 
 pub fn clipYank(p: *Pardes, pane: *Pane, main_only: bool) void {
diff --git a/src/layout.zig b/src/layout.zig
index 8e44f1d9..be8bad67 100644
--- a/src/layout.zig
+++ b/src/layout.zig
@@ -947,7 +947,7 @@ pub fn removePane(p: *Pardes, id: usize) void {
             p.col_serial[j] = p.col_serial[j + 1];
         }
         p.ncol -= 1;
-        p.col_tags[p.ncol] = .{ .what = .column };
+        p.col_tags[p.ncol] = .{ .what = .column, .gpa = p.gpa };
         p.col_serial[p.ncol] = 0;
     }
 }
@@ -971,7 +971,7 @@ pub fn joinCol(p: *Pardes) void {
         p.col_serial[j] = p.col_serial[j + 1];
     }
     p.ncol -= 1;
-    p.col_tags[p.ncol] = .{ .what = .column };
+    p.col_tags[p.ncol] = .{ .what = .column, .gpa = p.gpa };
     p.col_serial[p.ncol] = 0;
 }
 
@@ -1021,7 +1021,7 @@ pub fn splitColumn(p: *Pardes, source_id: usize, id: usize, before: bool) bool {
         p.col_serial[j] = p.col_serial[j - 1];
     }
     p.col_weight[c] = new_weight;
-    p.col_tags[c] = .{ .what = .column };
+    p.col_tags[c] = .{ .what = .column, .gpa = p.gpa };
     p.col_serial[c] = 0;
     p.col_panes[c][0] = id;
     p.col_n[c] = 1;
diff --git a/src/normal.zig b/src/normal.zig
index 4459ab53..2aea2e54 100644
--- a/src/normal.zig
+++ b/src/normal.zig
@@ -686,10 +686,7 @@ fn executeNormalAction(p: *Pardes, t: *Text, semantic: modal.Normal.Action) void
             .all => return t.setRange(text, 0, .{ .anchor = 0, .head = text.len }, false),
         },
         .multi => |multi| {
-            if (multi.kind == .keep_primary) {
-                t.nsel = 0;
-                return;
-            }
+            if (multi.kind == .keep_primary) return t.dropSels();
             return t.multiSelAction(text, multi.kind, multi.count);
         },
         // s, S and | answer for the text they are pressed in; `/` searches
@@ -922,6 +919,7 @@ test "flat text movement and selection replay need no scratch rows" {
     pane.body.cur_row = 1024;
     pane.body.cur_col = 0;
     pane.body.nsel = 1;
+    _ = pane.body.reserveSels();
     pane.body.sels[0] = .{ .row = 3072, .col = 0, .arow = 3072, .acol = 0 };
     handleNormal(p, &pane.body, .{ .cp = 'l' });
     handleNormal(p, &pane.body, .{ .cp = 'j' });
@@ -1021,3 +1019,25 @@ test "tree-sitter selection keys do in a JSON file what hx 25.07.1 does" {
         };
     }
 }
+
+test "one cursor holds no room for other ranges; a second range makes it and one again gives it back" {
+    const gpa = std.testing.allocator;
+    const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 60, .rows = 12 });
+    defer p.deinit();
+    const pane = try p.setTestFile("alpha beta\nalpha beta\n");
+    for ("wxe%;gg") |cp| handleNormal(p, &pane.body, .{ .cp = cp });
+    try std.testing.expectEqual(@as(usize, 0), pane.body.sels.len);
+    handleNormal(p, &pane.body, .{ .cp = 'C' });
+    try std.testing.expectEqual(@as(u16, 1), pane.body.nsel);
+    try std.testing.expect(pane.body.sels.len > 0);
+    handleNormal(p, &pane.body, .{ .cp = 'l' }); // replayed at both, still two
+    try std.testing.expectEqual(@as(u16, 1), pane.body.nsel);
+    handleNormal(p, &pane.body, .{ .cp = ',' });
+    try std.testing.expectEqual(@as(usize, 0), pane.body.sels.len);
+    handleNormal(p, &pane.body, .{ .cp = 'C' });
+    handleNormal(p, &pane.body, .{ .cp = ';' });
+    handleNormal(p, &pane.body, .{ .cp = 'x' }); // x at both: still two lines
+    handleNormal(p, &pane.body, .{ .cp = '_', .alt = true }); // merged to one
+    try std.testing.expectEqual(@as(u16, 0), pane.body.nsel);
+    try std.testing.expectEqual(@as(usize, 0), pane.body.sels.len);
+}
diff --git a/src/pardes.zig b/src/pardes.zig
index 6b397017..187f3ed3 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -4146,6 +4146,8 @@ pub const Pardes = struct {
             .pdf_gpa = pdf_gpa,
             .tree_sitter_gpa = tree_sitter_gpa,
             .opts = opts,
+            .col_tags = @splat(.{ .what = .column, .gpa = gpa }),
+            .global_tag = .{ .what = .workspace, .gpa = gpa },
             .fs = .{},
             .screen_w = opts.cols,
             .screen_h = opts.rows,
@@ -5335,10 +5337,14 @@ pub const Pardes = struct {
         if (t.what == .tag and t.mode == .insert and tagline.typedIntoName(p, pane, key)) return;
         // A tag's prefix is read-only: a key whose edit reached into it
         // changes nothing, not even where the cursor is.
-        const kept = .{ t.cur_row, t.cur_col, t.vsel, t.msel, t.sels, t.nsel };
+        const kept = .{ t.cur_row, t.cur_col, t.vsel, t.msel };
+        var kept_sels: [Text.max_selections - 1]Text.SelRange = undefined;
+        const kept_n = t.nsel;
+        @memcpy(kept_sels[0..kept_n], t.sels[0..kept_n]);
         t.refused = false;
         defer if (t.refused) {
-            t.cur_row, t.cur_col, t.vsel, t.msel, t.sels, t.nsel = kept;
+            t.cur_row, t.cur_col, t.vsel, t.msel = kept;
+            t.restoreSels(kept_sels[0..kept_n]);
         };
         const was = t.mode;
         switch (t.mode) {
diff --git a/test/panes.zig b/test/panes.zig
index a56c07bf..181317ca 100644
--- a/test/panes.zig
+++ b/test/panes.zig
@@ -4560,6 +4560,7 @@ const LookResetTests = struct {
         pane.body.cur_col = 3;
         pane.body.vsel = .{ .active = true, .explicit = true, .row = 0, .col = 0 };
         pane.body.msel = .{ .active = true, .r0 = 0, .r1 = 1 };
+        _ = pane.body.reserveSels();
         pane.body.sels[0] = .{ .row = 1, .col = 2, .arow = 0, .acol = 1 };
         pane.body.nsel = 1;
         pane.body.select = true;
-- 
cgit v1.3