add New builtin for an empty temporary file in the calling column

8 files changed, 314 insertions, 12 deletions

diff --git a/src/builtins.zig b/src/builtins.zig
index 578a60dd..b89952cd 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -345,6 +345,17 @@ pub const Save = struct {
     }
 };
 
+/// Ask the native shell for an atomically-created empty temporary file. The
+/// pane and its lifetime serial are the placement token: by the time IO
+/// finishes another column may be active, or this slot may even have been
+/// reused, and neither is permission to put the document somewhere else.
+pub const New = struct {
+    pub fn run(c: Ctx) void {
+        if (c.p.freeSlot() == null) return;
+        c.p.emit(.{ .new_file = .{ .pane = @intCast(c.id), .serial = c.pane.serial } });
+    }
+};
+
 pub const Newcol = struct {
     pub fn run(c: Ctx) void {
         const free = c.p.freeSlot() orelse return;
diff --git a/src/config.zig b/src/config.zig
index 6748a438..dec4272c 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -109,9 +109,10 @@ pub const leader_path = paths: {
         .Lspwhy = "lw",
         .Del = "d",
         .Kill = "k",
-        // the `f` file group (spacemacs): Save left vim's `w` to join Find here,
-        // which frees `w` for the window group (SPC w h/j/k/l) to move into.
+        // the `f` file group (spacemacs): Save left vim's `w` to join Find and
+        // New here, which frees `w` for the window group (SPC w h/j/k/l).
         .Save = "fs",
+        .New = "fn",
         .Find = "ff",
         .Grep = "fg",
         .Tutor = "ht",
@@ -289,9 +290,11 @@ pub const tty_toggle_alt: []const Chord = &.{.{ .cp = Key.escape, .shift = true
 // reason it earns the width. Appended rather than inserted so every existing
 // word keeps its column and no golden's click coordinates move.
 //
-// The two searches go LAST (before the optional `Restore <path>`), and next to
-// each other: they are one pair — Find matches file NAMES, Grep their CONTENTS.
-pub const topbar_str = "Kill Newcol Tutor Debug NextColor Dump Find Grep Help";
+// New is appended with the late additions, immediately before Help: every
+// older action keeps its click column, and the roadmap's separate tagline-order
+// item owns the later reshuffle. The two searches stay next to each other:
+// Find matches file NAMES, Grep their CONTENTS.
+pub const topbar_str = "Kill Newcol Tutor Debug NextColor Dump Find Grep New Help";
 
 /// the default editable tail of a pane's tag, per kind (an output buffer has
 /// no file to Save, so it gets the plain one)
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index 7d2a8cf1..0069164d 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -25,6 +25,7 @@ const crt = @import("crt.zig");
 const fonts = @import("fonts.zig"); // the Font builtin's half of the seam
 
 const is_emscripten = builtin.os.tag == .emscripten;
+const temp_file = if (is_emscripten) struct {} else @import("../temp_file.zig");
 
 pub const c = @cImport({
     @cDefine("SDL_DISABLE_OLD_NAMES", "1");
@@ -2486,6 +2487,14 @@ fn drainEffects(
             // from the bytes we just put there so it reads as "no change"
             if (watches[sf.pane]) |*w| w.hash = std.hash.Wyhash.hash(0, f.content);
         },
+        .new_file => |request| {
+            var path_buf: [4096:0]u8 = undefined;
+            const made = temp_file.create(&path_buf) orelse continue;
+            if (core.openNewFile(request.pane, request.serial, made.path))
+                made.adopt()
+            else
+                made.discard();
+        },
         .write_dump => {
             const out = core.dump_out orelse continue;
             var pbuf: [1024:0]u8 = undefined;
@@ -2554,7 +2563,7 @@ fn drainEffectsWeb(core: *pardes.Pardes, gpa: std.mem.Allocator, g: *Gui) void {
         .open_link => |url| openLinkWeb(gpa, url.slice()),
         // nothing to spawn/write/resize/save/dump into, and no filesystem to
         // watch — all no-ops
-        .spawn, .write, .resize_pty, .save_file, .write_dump, .lsp, .watch, .quit => {},
+        .spawn, .write, .resize_pty, .save_file, .new_file, .write_dump, .lsp, .watch, .quit => {},
     };
 }
 
diff --git a/src/pardes.zig b/src/pardes.zig
index 6156c56f..8cf8d2e2 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -633,6 +633,142 @@ test "startup config runs builtin lines in order and isolates bad lines" {
     };
 }
 
+test "New completes as an empty watched file in the calling column and focuses it" {
+    const p = try Pardes.init(std.testing.allocator, .{ .shells = 3, .cols = 100, .rows = 30 });
+    defer p.deinit();
+    while (p.nextEffect()) |_| {} // initial shell spawns
+
+    const source: usize = 2; // the right column; active starts in the left
+    const source_col = p.layoutFindTerm(source).?.col;
+    try std.testing.expect(p.executeBuiltinLine(source, "New"));
+    var request: ?Effect = null;
+    while (p.nextEffect()) |effect| switch (effect) {
+        .new_file => request = effect,
+        else => {},
+    };
+    const new_effect = request orelse return error.MissingNewFileEffect;
+    const req = new_effect.new_file;
+    try std.testing.expectEqual(@as(u8, @intCast(source)), req.pane);
+    try std.testing.expectEqual(p.panes[source].?.serial, req.serial);
+
+    // Focus changes while the shell is doing IO. Placement must still use the
+    // effect's calling-pane token, never this later-active left column.
+    p.active = 0;
+    try std.testing.expect(p.openNewFile(req.pane, req.serial, "/tmp/pardes-test-new-a"));
+    const id = p.active;
+    try std.testing.expect(id != 0 and id != source);
+    try std.testing.expectEqual(source_col, p.layoutFindTerm(id).?.col);
+    const sf = p.layoutFindTerm(source).?;
+    try std.testing.expectEqual(id, p.col_terms[sf.col][sf.idx + 1]);
+
+    const file = p.panes[id].?.file orelse return error.NewIsNotAFile;
+    try std.testing.expectEqualStrings("/tmp/pardes-test-new-a", file.path);
+    try std.testing.expectEqual(@as(usize, 0), file.content.len);
+    try std.testing.expect(file.output == null);
+    try std.testing.expect(!p.panes[id].?.isTerminal());
+
+    var watched = false;
+    while (p.nextEffect()) |effect| switch (effect) {
+        .watch => |w| if (w.pane == id and w.on) {
+            watched = true;
+        },
+        else => {},
+    };
+    try std.testing.expect(watched);
+
+    // It is an ordinary file from here on: Save uses the normal file effect,
+    // and the dump contains its path and empty content.
+    try std.testing.expect(p.executeBuiltinLine(id, "Save"));
+    var saved = false;
+    while (p.nextEffect()) |effect| switch (effect) {
+        .save_file => |s| if (s.pane == id) {
+            saved = true;
+        },
+        else => {},
+    };
+    try std.testing.expect(saved);
+    try p.dumpState();
+    const state = try dump.readZon(std.testing.allocator, p.dump_out.?, "New-test");
+    defer dump.free(std.testing.allocator, state);
+    var dumped = false;
+    for (state.panes) |dp| if (dp.file) |df| {
+        if (std.mem.eql(u8, df.path, "/tmp/pardes-test-new-a")) {
+            try std.testing.expectEqual(@as(usize, 0), df.content.len);
+            dumped = true;
+        }
+    };
+    try std.testing.expect(dumped);
+    while (p.nextEffect()) |_| {} // write_dump
+
+    // Del closes and unwatches, but there is intentionally no unlink effect:
+    // adopted temporary documents preserve user data and dump restorability.
+    try std.testing.expect(p.executeBuiltinLine(id, "Del"));
+    try std.testing.expect(p.panes[id] == null);
+    var unwatched = false;
+    while (p.nextEffect()) |effect| switch (effect) {
+        .watch => |w| if (w.pane == id and !w.on) {
+            unwatched = true;
+        },
+        else => {},
+    };
+    try std.testing.expect(unwatched);
+}
+
+test "New requests repeat, stay anchored, and reject stale or full completions" {
+    const p = try Pardes.init(std.testing.allocator, .{ .shells = 3, .cols = 100, .rows = 30 });
+    defer p.deinit();
+    while (p.nextEffect()) |_| {}
+
+    const source: usize = 2;
+    const source_col = p.layoutFindTerm(source).?.col;
+    try std.testing.expect(p.executeBuiltinLine(source, "New"));
+    try std.testing.expect(p.executeBuiltinLine(source, "New"));
+    var requests: [2]Effect = undefined;
+    var n: usize = 0;
+    while (p.nextEffect()) |effect| switch (effect) {
+        .new_file => if (n < requests.len) {
+            requests[n] = effect;
+            n += 1;
+        },
+        else => {},
+    };
+    try std.testing.expectEqual(requests.len, n);
+
+    p.active = 0;
+    try std.testing.expect(p.openNewFile(requests[0].new_file.pane, requests[0].new_file.serial, "/tmp/pardes-test-new-1"));
+    const first = p.active;
+    p.active = 1; // change focus again before the second completion
+    try std.testing.expect(p.openNewFile(requests[1].new_file.pane, requests[1].new_file.serial, "/tmp/pardes-test-new-2"));
+    const second = p.active;
+    try std.testing.expect(first != second);
+    try std.testing.expectEqual(source_col, p.layoutFindTerm(first).?.col);
+    try std.testing.expectEqual(source_col, p.layoutFindTerm(second).?.col);
+    try std.testing.expect(!std.mem.eql(u8, p.panes[first].?.file.?.path, p.panes[second].?.file.?.path));
+    while (p.nextEffect()) |_| {}
+
+    // A reused pane slot cannot answer an old request, and a malformed shell
+    // answer cannot manufacture a nameless file.
+    const old_serial = p.panes[source].?.serial;
+    p.panes[source].?.serial +%= 1;
+    try std.testing.expect(!p.openNewFile(@intCast(source), old_serial, "/tmp/pardes-test-stale"));
+    try std.testing.expect(!p.openNewFile(@intCast(source), p.panes[source].?.serial, ""));
+
+    // Exhaust every remaining slot after a request was issued: completion
+    // rejects it, which tells the shell to unlink the just-created candidate.
+    const live_serial = p.panes[source].?.serial;
+    for (0..MAX_PANES) |id| {
+        if (p.panes[id] == null) _ = try p.newDocPane(id);
+    }
+    try std.testing.expect(!p.openNewFile(@intCast(source), live_serial, "/tmp/pardes-test-full"));
+    try std.testing.expect(p.executeBuiltinLine(source, "New"));
+    var emitted_when_full = false;
+    while (p.nextEffect()) |effect| switch (effect) {
+        .new_file => emitted_when_full = true,
+        else => {},
+    };
+    try std.testing.expect(!emitted_when_full);
+}
+
 test "startup config overrides restored styling before initFromDump returns" {
     const source = try Pardes.init(std.testing.allocator, .{ .startup_config = "Theme dark\n" });
     defer source.deinit();
@@ -1263,6 +1399,11 @@ pub const Effect = union(enum) {
     /// write this pane's file content to its path; the shell reads both off
     /// the core (content is unbounded, effects are fixed-size values)
     save_file: struct { pane: u8 },
+    /// Create an empty, uniquely-named temporary file. `pane` + `serial`
+    /// identify the pane/column that issued New even if focus moves before the
+    /// shell completes the IO. The shell calls openNewFile with the path and
+    /// unlinks it itself when that completion rejects the request.
+    new_file: struct { pane: u8, serial: u32 },
     /// a serialized state dump is ready in core.dump_out; write it to the
     /// path dump.outPath resolves (acme-style: another instance loads it
     /// with -l, or the Restore builtin loads it into this one)
@@ -2252,6 +2393,42 @@ pub const Pardes = struct {
         pane.cwd_len = @intCast(n);
     }
 
+    /// Complete a `new_file` effect without doing IO in the core. The shell
+    /// has already created `path` as an empty file; we model those known empty
+    /// bytes directly, insert immediately below the still-live calling pane in
+    /// ITS column (never whichever column became active), focus it, and start
+    /// the same watch every ordinary file pane has. False leaves ownership
+    /// with the shell, which closes and unlinks the unadopted file.
+    pub fn openNewFile(p: *Pardes, source: u8, serial: u32, path: []const u8) bool {
+        if (path.len == 0 or source >= MAX_PANES) return false;
+        const src = p.panes[source] orelse return false;
+        if (src.serial != serial) return false;
+        const sf = p.layoutFindTerm(source) orelse return false;
+        const free = p.freeSlot() orelse return false;
+
+        const path_copy = p.gpa.dupe(u8, path) catch return false;
+        const content = p.gpa.dupe(u8, "") catch {
+            p.gpa.free(path_copy);
+            return false;
+        };
+        const pane = p.newDocPane(free) catch {
+            p.gpa.free(content);
+            p.gpa.free(path_copy);
+            return false;
+        };
+        pane.file = .{ .path = path_copy, .content = content };
+        pane.cur_pinned = true;
+
+        // sf was captured from SOURCE, not active. Nothing above this point
+        // mutates layout, so it is still the exact calling column/index.
+        p.layoutInsert(sf.col, sf.idx + 1, free);
+        p.splitBelow(source, pane);
+        p.active = free;
+        p.emit(.{ .watch = .{ .pane = @intCast(free), .on = true } });
+        p.sync();
+        return true;
+    }
+
     pub fn emit(p: *Pardes, e: Effect) void {
         p.effects.append(p.gpa, e) catch {};
     }
diff --git a/src/temp_file.zig b/src/temp_file.zig
new file mode 100644
index 00000000..a6174efd
--- /dev/null
+++ b/src/temp_file.zig
@@ -0,0 +1,84 @@
+//! Native-shell ownership of `New`'s one filesystem operation.
+//!
+//! The core asks for a temporary file by effect and receives only its path.
+//! `mkstemp` creates and opens the name atomically with mode 0600, so there is
+//! no name-then-open race and repeated requests cannot collide. A file the
+//! core declines is unlinked here immediately; an adopted file becomes an
+//! ordinary Pardes document and is deliberately left on disk when its pane is
+//! closed, just like every other document (and so a dump remains restorable).
+const std = @import("std");
+const libc = std.c;
+
+extern "c" fn mkstemp(template: [*:0]u8) c_int;
+extern "c" fn lseek(fd: c_int, offset: libc.off_t, whence: c_int) libc.off_t;
+
+pub const Created = struct {
+    fd: c_int,
+    path: [:0]u8,
+
+    /// The core copied the path and now owns the document. Close our creation
+    /// handle; Save and watching reopen/use the pathname through their normal
+    /// seams.
+    pub fn adopt(f: Created) void {
+        _ = libc.close(f.fd);
+    }
+
+    /// Creation succeeded but the request became stale or the core could not
+    /// allocate a pane. Nothing user-visible owns this name, so remove it.
+    pub fn discard(f: Created) void {
+        _ = libc.close(f.fd);
+        _ = libc.unlink(f.path);
+    }
+};
+
+/// Create in the platform's conventional temporary directory. TMPDIR is a
+/// shell concern (environment + filesystem), intentionally outside the core.
+pub fn create(buf: *[4096:0]u8) ?Created {
+    const env = libc.getenv("TMPDIR");
+    const dir = if (env) |p| std.mem.span(p) else "/tmp";
+    return createIn(buf, if (dir.len > 0) dir else "/tmp");
+}
+
+/// Split out for a hermetic failure test and to keep template construction
+/// independently checkable. The six Xs are consumed by mkstemp itself.
+pub fn createIn(buf: *[4096:0]u8, dir_arg: []const u8) ?Created {
+    const dir = std.mem.trimEnd(u8, dir_arg, "/");
+    const path = std.fmt.bufPrintSentinel(
+        buf,
+        "{s}{s}pardes-XXXXXX",
+        .{ if (dir.len == 0) "/" else dir, if (dir.len == 0) "" else "/" },
+        0,
+    ) catch return null;
+    const fd = mkstemp(path.ptr);
+    if (fd < 0) return null;
+    return .{ .fd = fd, .path = path };
+}
+
+test "mkstemp creates distinct empty files and rejected files are removable" {
+    var abuf: [4096:0]u8 = undefined;
+    var bbuf: [4096:0]u8 = undefined;
+    const a = createIn(&abuf, "/tmp") orelse return error.TempCreateFailed;
+    const b = createIn(&bbuf, "/tmp") orelse return error.TempCreateFailed;
+    defer b.discard();
+
+    try std.testing.expect(!std.mem.eql(u8, a.path, b.path));
+    try std.testing.expectEqual(@as(libc.off_t, 0), lseek(a.fd, 0, 2)); // SEEK_END
+    try std.testing.expectEqual(@as(libc.off_t, 0), lseek(b.fd, 0, 2));
+
+    a.discard();
+    try std.testing.expect(libc.unlink(a.path) < 0); // already removed
+}
+
+test "an adopted tempfile remains named for the document" {
+    var buf: [4096:0]u8 = undefined;
+    const made = createIn(&buf, "/tmp") orelse return error.TempCreateFailed;
+    made.adopt();
+    // Adoption closes only the creation handle. The ordinary file document
+    // keeps this path for Save, watch, Del and dump/restore.
+    try std.testing.expectEqual(@as(c_int, 0), libc.unlink(made.path));
+}
+
+test "mkstemp failure creates no candidate file" {
+    var buf: [4096:0]u8 = undefined;
+    try std.testing.expect(createIn(&buf, "/definitely/not/a/pardes/temp/directory") == null);
+}
diff --git a/src/tty/tty.zig b/src/tty/tty.zig
index 60a2d958..6f7cc5ba 100644
--- a/src/tty/tty.zig
+++ b/src/tty/tty.zig
@@ -11,6 +11,7 @@ const vaxis = @import("vaxis");
 const pardes = @import("../pardes.zig");
 const tracy = @import("../tracy.zig");
 const look = @import("../look.zig");
+const temp_file = @import("../temp_file.zig");
 
 extern "c" fn forkpty(amaster: *c_int, name: ?[*:0]u8, termp: ?*const anyopaque, winp: ?*const posix.winsize) c_int;
 extern "c" fn execv(path: [*:0]const u8, argv: [*:null]const ?[*:0]const u8) c_int;
@@ -684,6 +685,14 @@ fn drainEffects(
             // from the bytes we just put there so it reads as "no change"
             if (watches[sf.pane]) |*w| w.hash = std.hash.Wyhash.hash(0, f.content);
         },
+        .new_file => |request| {
+            var path_buf: [4096:0]u8 = undefined;
+            const made = temp_file.create(&path_buf) orelse continue;
+            if (core.openNewFile(request.pane, request.serial, made.path))
+                made.adopt()
+            else
+                made.discard();
+        },
         .write_dump => {
             const out = core.dump_out orelse continue;
             var pbuf: [1024:0]u8 = undefined;
diff --git a/src/tutor.txt b/src/tutor.txt
index 6721e9e8..f13346fe 100644
--- a/src/tutor.txt
+++ b/src/tutor.txt
@@ -136,9 +136,10 @@
  "Delcol" still exists as a command: type it in
  a tag or body and execute it to close the whole column. A SEPARATE bar
  across the top of the screen holds the window-agnostic builtins:
-   Kill  Newcol  Tutor  Debug  NextColor  Dump
- Middle-click "Newcol" for a new column, "Tutor" to spawn this tutor,
- "Kill" to quit. From the KEYBOARD the bar is `k` off the topmost
+   Kill  Newcol  Tutor  Debug  NextColor  Dump  Find  Grep  New  Help
+ Middle-click "New" for an empty temporary file in this pane's column,
+ "Newcol" for a new column, "Tutor" to spawn this tutor, "Kill" to
+ quit. From the KEYBOARD the bar is `k` off the topmost
  tagline: it takes the cursor, h/l and the arrows move by character,
  w/b/e and 0/$ by word, Enter or Tab runs the word under the cursor
  exactly as a middle-click on it would, j drops back onto the tagline
@@ -512,7 +513,7 @@
 
    SPC ?            Help: every builtin and the keys that run it
    SPC k            Kill (quit)          SPC d   Del (close this pane)
-   SPC f s / f f    Save / Find          SPC h t Tutor (this file)
+   SPC f s/f f/f n  Save / Find / New    SPC h t Tutor (this file)
    SPC c n / c d    Newcol / Delcol
    SPC t d/c/n/r    Debug / Colors / NextColor / Crt toggles
    SPC t p/l/a      Petscii / Palette / Ascii: an image pane's
@@ -542,7 +543,7 @@
                 chords: 1-2 cut  1-3 paste  (both in one hold = snarf)
                 2-1 = middle-exec with the left selection as argument
                 file tag = mode + path + "Save Del"; other tags show Del
-                top bar = Kill Newcol Tutor Debug NextColor Dump
+                top bar = Kill Newcol Tutor Debug NextColor Dump ... New Help
                           (keyboard: k off the topmost tagline)
  WEB TOUCH:     one-finger tap = LOOK; drag = natural scroll
                 LOOK opens URLs or embedded tracked .zig source (read-only)
@@ -561,6 +562,7 @@
                 Esc = last document <-> last terminal (body normal)
                 SPC = the leader: a key path runs a builtin (SPC ? lists
                 them; SPC k Kill, SPC d Del, SPC f s Save, SPC f f Find,
+                SPC f n New,
                 SPC w hjkl focus, SPC w t file <-> terminal)
 
  vs Helix: no multi-cursor; selection is LINE-first (x), plus v chars.
@@ -570,7 +572,7 @@
           shell's own prompt to position you precisely.
 
  To spawn THIS tutor again from anywhere: middle-click "Tutor" in the
- top bar (next to Kill / Newcol), or press SPC h t.
+ top bar (next to New / Newcol), or press SPC h t.
 
  Quit the tutor: this is a file pane — `:q` isn't wired; close the
  window (middle-click "Del" in its tag), "Kill" (top bar) to quit
diff --git a/src/web.zig b/src/web.zig
index cebbeebf..6ceca904 100644
--- a/src/web.zig
+++ b/src/web.zig
@@ -375,6 +375,13 @@ export fn pardes_effect_next() u32 {
             if (e.on) if (s.core.panes[e.pane]) |pane| if (pane.file) |file| putEffect(s, file.path);
             break :blk 9;
         },
+        // Browser hosts cannot create this file, but surface the request like
+        // the other host-specific IO effects instead of performing IO here.
+        .new_file => |e| blk: {
+            effect_aux0 = e.pane;
+            effect_aux1 = e.serial;
+            break :blk 11;
+        },
         .quit => 10,
     };
 }