An open's writes in a row to one place go in as one edit: a 10 MB body write is linear

Each body or data write copied and hashed the whole buffer, so a write the mount cut in 8 KB pieces was quadratic: 10 MB took 50 s and a 1 MB insert into 10 MB 11 s, holding the editor's turn. An open's appends to body, or inserts going on at data's address, are now held and put in as one splice (one copy, one undo step, one line-starts pass) before any other request, the close, or the editor's step once the writes pause 20 ms. fs.py-driven: 2 MB 2.19 -> 0.16 s, 10 MB 50.17 -> 0.78 s, 1 MB data into 10 MB 11.49 -> 0.26 s. A body-2m case (2 MB in 256 KB writes on one open) joins the perf gate: 84023 -> 15785 us; baselines re-recorded.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

1 files changed, 14 insertions, 0 deletions

diff --git a/src/fs.zig b/src/fs.zig
index 845e6424..2487ffee 100644
--- a/src/fs.zig
+++ b/src/fs.zig
@@ -1330,6 +1330,20 @@ pub const Namespace = struct {
     /// its header), 0 when unknown: a write shorter than it is the whole of
     /// what its client wrote, one that fills it may be cut and go on.
     write_room: u32 = 0,
+    /// Writes one open made in a row into one place of a pane's body (an
+    /// append to `body`, an insert at `data`'s address), held and put in
+    /// as one edit when anything else comes (ninep/pane.zig flushBatch): a
+    /// 10 MB write in 8 KB pieces is one copy and one undo step, not 1280.
+    batch: struct {
+        serial: u32 = 0,
+        node: u64 = 0,
+        handle: u32 = 0,
+        at: usize = 0,
+        bytes: std.ArrayList(u8) = .empty,
+        /// The editor's clock at the last write held: its step puts them in
+        /// once the writes have paused (`batch_pause_ns`).
+        last_ns: u64 = 0,
+    } = .{},
     /// The serial of the pane the root's exec or look last ran a line at
     /// (the keyboard's), 0 before one: its err record names that pane.
     ran_at: u32 = 0,