diff options
Diffstat (limited to 'src/Core.zig')
| -rw-r--r-- | src/Core.zig | 4032 |
1 files changed, 4032 insertions, 0 deletions
diff --git a/src/Core.zig b/src/Core.zig new file mode 100644 index 00000000..fa39f884 --- /dev/null +++ b/src/Core.zig @@ -0,0 +1,4032 @@ +//! The session: its state and its one dispatch. A step takes an event +//! (update), serves the 9P tree's requests (serveFs) and drains its effects +//! into the host (pump, settle, step); the host's replies come back as the +//! calls below (setCwd, acknowledgeShell, saveFailed, the views' and fonts' +//! answers); the clock is its deadlines alone (nextWake, advance). Its nouns +//! live in their own files (panes.zig, layout.zig, keys.zig, Jump.zig, +//! Effect.zig, lsp/Ask.zig, colors.zig), a few called from everywhere kept +//! here as declaration aliases. +const std = @import("std"); +const pardes = @import("pardes.zig"); +const BOX_H = pardes.BOX_H; +const Builtin = pardes.Builtin; +const COLBAR_H = pardes.COLBAR_H; +const CellPixels = pardes.CellPixels; +const ChromeTheme = pardes.ChromeTheme; +const Color = pardes.Color; +const Effect = pardes.Effect; +const Event = pardes.Event; +const Finder = pardes.Finder; +const FontRole = pardes.FontRole; +const FrameStats = pardes.FrameStats; +const Handover = pardes.Handover; +const Host = pardes.Host; +const ImagePlace = pardes.ImagePlace; +const Jump = pardes.Jump; +const Key = pardes.Key; +const Loc = Jump.Loc; +const MAX_COLS = pardes.MAX_COLS; +const MAX_JUMPS = pardes.MAX_JUMPS; +const MAX_PANES = pardes.MAX_PANES; +const MAX_TAG_ROWS = pardes.MAX_TAG_ROWS; +const Macro = pardes.Macro; +const Messages = pardes.Messages; +const Mouse = pardes.Mouse; +const Pane = pardes.Pane; +const Pipe = pardes.Pipe; +const PtySignal = pardes.PtySignal; +const Rect = pardes.Rect; +const Registers = pardes.Registers; +const RowMetrics = pardes.RowMetrics; +const Store = @import("Store.zig"); +const Db = pardes.Db; +const Stream = pardes.Stream; +const Surface = pardes.Surface; +const TAG_TEXT_INSET = pardes.TAG_TEXT_INSET; +const TOPBAR_H = pardes.TOPBAR_H; +const TagHit = pardes.TagHit; +const Text = pardes.panes.Text; +const Theme = pardes.Theme; +const builtins = pardes.builtins; +const colors = pardes.colors; +const column_weight_unit = layout.column_weight_unit; +const config = pardes.config; +const ctlfs = pardes.ctlfs; +const draw = pardes.draw; +const dump = pardes.dump; +const edit = pardes.edit; +const effect_path_cap = pardes.effect_path_cap; +const effect_write_cap = pardes.effect_write_cap; +const exec = pardes.exec; +const filesystem = pardes.filesystem; +const font_picker = pardes.font_picker; +const fonts = pardes.fonts; +const frame_ns = pardes.frame_ns; +const host_io = pardes.host_io; +const image = pardes.image; +const layout = pardes.layout; +const limits = memory.limits; +const locations = @import("locations.zig"); +const look = pardes.look; +const lsp = pardes.lsp; +const memory = pardes.memory; +const modal = pardes.modal; +const mouse = pardes.mouse; +const newer_build_words = pardes.newer_build_words; +const pager = pardes.pager; +const pdf_enabled = pardes.pdf_enabled; +const platform = pardes.platform; +const recent_files = @import("recent.zig"); +const sel_slot = pardes.sel_slot; +const syntax = pardes.syntax; +const tagline = pardes.tagline; +const tape = pardes.tape; +const test_api = pardes.test_api; +const themes = pardes.themes; +const turn = &pardes.turn; +const views = pardes.views; + +const Pardes = @This(); + +gpa: std.mem.Allocator, +image_gpa: std.mem.Allocator, +pdf_gpa: std.mem.Allocator, +tree_sitter_gpa: std.mem.Allocator, +opts: Options, +screen_w: u16, +screen_h: u16, +cell_pixels: CellPixels = .{}, +row_metrics: RowMetrics = .{}, +resize_count: usize = 0, + +panes: [MAX_PANES]?*Pane = @splat(null), +reserved_slots: [MAX_PANES]bool = @splat(false), +/// Deferred teardown of dropped panes (see RetiredPanes). +retired_panes: RetiredPanes = .{}, +// layout: columns own x by weight; panes own y by vweight within a column. +ncol: usize = 0, +col_weight: [MAX_COLS]u64 = @splat(column_weight_unit), +// Zeroed, not undefined: a digest takes the whole of it, a release +// build's heap leaves its unused slots whatever was there before, and +// two replicas must agree on them (src/replica.zig). +col_panes: [MAX_COLS][MAX_PANES]usize = @splat(@splat(0)), +col_n: [MAX_COLS]usize = @splat(0), +/// Each column's tag and the workspace's: Texts like a pane's tag, with +/// no prefix, showing a default until someone edits them. +col_tags: [MAX_COLS]Text = @splat(.{ .what = .column }), +col_serial: [MAX_COLS]u32 = @splat(0), +next_column_serial: u32 = 1, +/// The finder column, where query panes stack with SearchPlace column +/// (Finder.zig). +finder: Finder = .{}, +/// A pane or column on its way to another window (Handover.zig). +handover: Handover = .{}, +global_tag: Text = .{ .what = .workspace }, +// derived each sync +rects: [MAX_PANES]Rect = @splat(.{}), +col_x: [MAX_COLS]u16 = undefined, +col_w: [MAX_COLS]u16 = undefined, + +active: usize = 0, +/// The files opened lately, closed ones too (recent.zig): `Recent`, +/// /recent, and the jumplist's way back to a closed pane. +recent: recent_files.List = .{}, +/// The panes this session closed, which Panes brings back (Store.zig). +store: Store = .{}, +/// The user's state file, which every session shares: Recent's (Db.zig). +db: Db = .{}, +/// acme's Incl: the directories a look at a name that is nowhere else +/// (`stdio.h`, `<foo.h>`) is tried in, in order. The session's, seeded +/// with C's (/usr/include, /usr/local/include), kept in a dump. +incl: std.ArrayList([]u8) = .empty, +/// Zerox's groups of panes on one buffer (File.syncTwins), and the id +/// the next takes. +twin_groups: std.ArrayList(pardes.panes.File.TwinGroup) = .empty, +/// The buttons held as the 9P mousein file last said (Plan 9's bits: +/// 1 left, 2 middle, 4 right): its next line presses and releases +/// what changed. +mousein_buttons: u8 = 0, +next_twin: u32 = 1, +jumps: [MAX_JUMPS]Loc = undefined, +njumps: usize = 0, +jcur: usize = 0, +/// The next place tracked is an entry of its own however near the last +/// (a query answered: Ctrl-o goes back to where it was asked). +jump_force: bool = false, +look_src: [MAX_PANES]u32 = undefined, +n_look_src: usize = 0, +look_walk_owner: ?u32 = null, +/// hands out Pane.serial; monotonic, never reused +next_serial: u32 = 0, +/// The column whose tag the running command came from, while it runs: +/// the column acme's commands take from their Text's col. +exec_column: ?usize = null, +/// Panes made this step that found no room in their column +/// (exec.placeNew): closed at the step's end, once whatever made them +/// is done with them. +unplaced: std.StaticBitSet(MAX_PANES) = .empty, +/// A look's word search is running (look.lookUnresolved): from a +/// terminal its rows refill the directory's one +Search (Output). +word_look: bool = false, +/// The running word came from the workspace's or a column's tag, which +/// have no directory of their own: it runs in the session's +/// (`sessionDir`), as acme's row and column tags do. +exec_header: bool = false, +session_dir: [limits.host_path_cap]u8 = undefined, +/// A spawn's directory too long for the effect's inline buffer, by pane +/// slot: the effect then carries none, and perform gives the host this. +spawn_dirs: [MAX_PANES]?[]u8 = @splat(null), +session_dir_len: ?u16 = null, +/// acme's activecol (dat.c:37), by column serial, 0 for none: the +/// column last typed in (acme.c:487), clicked in with the select button +/// (acme.c:659), dropped into by a grip (acme.c:640), or given a new +/// pane (util.c:467). Where the acme placement puts new panes +/// (exec.placeNew). A Look click moves the keyboard but not this. +active_column: u32 = 0, +settings: config.Runtime = .{ .font = .{ .tagline_percent = config.gui_tagline_font_percent } }, +locations_config: locations.Config = .{}, +locations_cache: locations.Cache = .{}, +tty_filter_palette: pardes.panes.terminal.FilterPalette = .{}, +font_request_taken: bool = false, +custom_theme: ?Theme = null, +/// bodyChrome's: the theme it was worked out for, and it. +body_chrome: ?struct { theme: Theme, chrome: ChromeTheme } = null, +theme_file_path: config.Runtime.Text(limits.host_path_cap) = .{}, +/// The ThemeFile last loaded whole: what /ctl and DumpConfig name, and +/// what a failed ThemeFile goes back to (colors.revertThemeFile). +theme_file_loaded: config.Runtime.Text(limits.host_path_cap) = .{}, +theme_file_generation: u32 = 0, +theme_file_pane: u8 = 0, +chrome: colors.ChromeTheme = colors.initial_chrome, +/// Every drawn frame's timings (FrameStats: the Debug box, PARDES_FRAMES). +frames: FrameStats = .{}, +native_images: bool = false, +/// The shell can take a changed image a few rows at a time (a texture row +/// upload, a shared-memory hand-off), so a PDF selection is repainted as +/// it is dragged instead of once on release. +native_image_patches: bool = false, +quit: bool = false, +/// A detached session with no frontend attached: nothing renders, so +/// no input ever dismisses a message (Messages.expireUnattended). +unattended: bool = false, +haptic: HapticSlot = if (platform == .macos) .none else {}, +drag: mouse.Drag = .none, +/// A press a terminal's program took (mouse.programMouse): its drags +/// and release are the program's too, wherever the pointer goes. +mouse_grab: ?mouse.Grab = null, +/// Whether the host window has the keyboard (Event.focus), and the pane +/// whose program was last told it has it (reportFocus). +window_focused: bool = true, +focus_told: ?struct { id: usize, serial: u32 } = null, +hover_col: u16 = 0, +hover_row: u16 = 0, +pointer_raw_col: u16 = 0, +pointer_raw_row: u16 = 0, +pointer_body_hit: ?Mouse.BodyHit = null, +pointer_tag_hit: ?TagHit = null, +raw_hover_intent: bool = false, +pointer_inside: bool = false, +/// A pixel shell's window, which hears the pointer leave it: only then +/// does /status say whether the pointer is over it (a terminal's mouse +/// reports never say it left, so a tty would claim it for ever). +/// The live view's frontend is a window (Event.frontend): what it draws, +/// and the words it takes (builtins.zig `here`). It starts as +/// `Options.windowed` says. +windowed: bool = false, +/// The last plain B1 click, for acme's double-click (text.c:881, +/// textselect: a second click at the same point within 500 ms). +last_click: ?struct { id: usize, on_tag: bool, row: i32, col: i32, ms: i64 } = null, +/// The button an Alt- or Super-click of button 1 stands for, from its +/// press through its release (mouse.emulateButton). +click_as: ?Mouse.Button = null, +/// A B1 chord's edits share the undo point it took (mouse.zig). +chord_hold: bool = false, +/// The look just run found nothing (look.zig missed). +look_missed: bool = false, +/// The look being run opens a .diff or .patch as text, not its +Diff: +/// Diff going back from a +Diff, Edit's B (it edits the file). +look_text: bool = false, +look_hover_wait: ?look.LookHoverWait = null, +/// The place a look-hover last found nothing to open: the pointer +/// resting there does not ask again every frame (look.noteLookHover). +look_hover_refused: ?look.LookHoverWait = null, +look_hover_preview: ?look.LookHoverPreview = null, +pdf_hover_preview: if (pdf_enabled) ?look.PdfWordPreview else void = if (pdf_enabled) null else {}, +wheel_guard: u8 = 0, +ctrl_w_pending: bool = false, +/// While a key is replayed across the ranges (normal.replaySels): which +/// range this pass is, in document order, how many there are, and +/// whether this is the first pass; outside a replay, the one range and +/// its first pass. A register value belongs to its range by this index. +multi_first: bool = true, +multi_stop: bool = false, +multi_index: usize = 0, +multi_count: usize = 1, +/// The register the running normal command names (`"<reg>`); 0 for the +/// default one. +register: u21 = 0, +leader_on: bool = false, +/// Window mode's outlined pane (layout.windowKey); null outside it. +window_pick: ?usize = null, +leader_keys: [4]u8 = undefined, +leader_n: u8 = 0, +/// The keyboard is on a header: the column tag `header_column` names, or +/// the workspace's when that is null. +header_focus: bool = false, +header_column: ?usize = null, +/// A mouse sweep is extending the focused header's selection. +header_drag: bool = false, +/// A middle or right sweep held over a column's or the workspace's tag. +header_sweep: ?mouse.HeaderSweep = null, +header_scroll: usize = 0, +/// The focused header's first line on screen, which follows its caret +/// when it has more lines than rows. +header_top: usize = 0, +/// middle+left chord argument: a kept left selection captured by a left +/// press during an active middle select-drag; consumed on middle release +chord_arg: ?[]u8 = null, +/// how many `execute` calls are on the stack — see max_exec_depth +exec_depth: u8 = 0, +/// An exec waiting on the REPL question (`Pane.Prompt.repl_choice`): +/// the pane it came from, the language, and the text, owned. +/// `offered` holds, by letter, the serial of the pane each answer named +/// when asked: a letter answered later is that pane or nothing. +repl_ask: ?struct { from: u32, lang: u8, text: []u8, offered: [26]u32 = @splat(0) } = null, +/// A key press is being handled: someone is at the keyboard to answer, +/// so a builtin may ask rather than guess. Nothing else sets it -- not +/// a click, a 9P write, a startup line or a pane's shell exiting. +can_ask: bool = false, + +lsp_seq: u32 = 0, +/// The last query asked (Lspwhy explains it): its kind, argument, and +/// the pane and place it was asked at. +lsp_last: ?struct { kind: lsp.Kind, arg: Effect.Buf(128), serial: u32, offset: u32 } = null, +lsp_wait: ?struct { + id: u32, + kind: lsp.Kind, + pane: usize, + serial: u32, + revision: u32, + arg: Effect.Buf(128), + row: i32 = 0, + col: i32 = 0, +} = null, + +pipe: Pipe = .{}, +/// A query pane's Grep, and its Find's listing, on a worker (Stream.zig). +stream: Stream = .{}, + +fs: filesystem.Namespace = .{}, +boot: Boot = .shell, +/// Is there a frame worth drawing? Cleared once one is presented, set by +/// anything that can change what is on screen. The first frame always is. +needs_frame: bool = true, +/// Set by a shell whose present was skipped (no swapchain image): the +/// frame is still owed, and the next pump draws it again. +present_skipped: bool = false, +/// Core time. `now_ns` is the shell's monotonic clock as `advance` was +/// last given it; `stepped_ns` is how far its timings have been +/// stepped along it, in whole frames of `frame_ns`. Idle, the two are +/// the same instant. +now_ns: u64 = 0, +stepped_ns: u64 = 0, +clock_started: bool = false, +/// Builtins announce themselves on the message row. Off while startup +/// configuration is applied: those lines are nobody clicking, and should +/// not leave the row holding the name of the last one. +announce: bool = true, + +// Reject overflow: evicting an older effect would reorder a byte stream. +effects: [limits.effect_cap]Effect = undefined, +effects_head: usize = 0, +effects_len: usize = 0, + +// Each pty retains its own overflow tail until earlier effects drain. +pending_write: [MAX_PANES]?PendingWrite = @splat(null), +/// Total bytes parked above, so the drain path costs one comparison when +/// nothing is waiting — which is every frame that is not a large paste. +pending_write_bytes: usize = 0, + +/// WHO SERVES THIS CORE. Every method optional; a null one is answered by +/// `fallback` below, so a `Host{}` is a complete in-process pardes. +host: Host = .{}, +/// The in-program answers behind every unimplemented host method. Per +/// instance, so several cores behind one fan-out host stay independent. +fallback: host_io.Fallback, +/// The message-row log (see Messages.zig). +messages: Messages = .{}, +in_q: [64]Event = undefined, +in_head: usize = 0, +in_len: usize = 0, + +registers: Registers = .{}, +macro: Macro = .{}, +/// 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, +/// Where the last Dump goes as a file of its own (`Dump export`; gpa- +/// owned), else the state file. +dump_export: ?[]u8 = null, +/// where the shell wrote the last dump (shell reports back after +/// write_dump); shown in the topbar as `Restore <path>` +last_dump: ?[]const u8 = null, +/// What a session word (Newcol, New, Exit) runs with when no pane is +/// there to run it: the window Delcol emptied. Never installed, made the +/// first time it is wanted. +stand_in: ?*Pane = null, +/// a Restore builtin wants this dump loaded into the live session; the +/// shell consumes it via takeRestore each frame (restore contents stay host-fed) +restore_req: ?[]const u8 = null, +restore_buf: [1024]u8 = @splat(0), + +surface: Surface = .{}, +/// A replica's predicted echo (src/echo.zig), drawn over its terminals: +/// presentation, its own, in no digest and no rollback copy. Null on a +/// session's own core. +echo: ?*pardes.echo.Echo = null, +/// The view the fields above are of: whose layout, focus, pointer and +/// panes' cursors and scroll (views.zig). `views_open` says which views +/// there are, one a window or terminal; each not live is in `parked`. +view: u8 = 0, +views_open: u8 = 1, +/// The open views kept for their clients' rejoin (views.away). +views_away: u8 = 0, +parked: [views.max]?*views.Parked = @splat(null), +/// The views no frontend here draws: a replica client's, which its own +/// process draws (src/replica.zig). A pump skips them. +undrawn: u8 = 0, +/// The Ctrl key into a terminal's tty mode and out (`--tty-toggle`): the +/// session's, taken from its options when it is made, so a dump carries +/// it to a replica, whose own options are its process's. +tty_toggle: u21 = config.tty_toggle_default, +/// per-update scratch (paneCursorLines, selection text); reset each update +scratch: std.heap.ArenaAllocator, +/// The arena each frame's Surface text is built in, reset by `pump`. Hosts +/// that still own their loop pass their own arena to `render` instead. +frame_arena: std.heap.ArenaAllocator, +/// the terminal motion surface, memoized against the pane it was built +/// for — see panes.terminal.RowsCache for the lifetime rule +shell_rows: pardes.panes.terminal.RowsCache = .{}, +/// Finished command panes' output, and whether it is a diff +/// (File.DiffOutput). +diff_output: pardes.panes.File.DiffOutput = .{}, + +/// What the replay digest leaves out (src/walk.zig): what drawing +/// keeps, what is recomputed, and what only the session that performs +/// effects has. +pub const replica = .{ + .local = .{ + // A frame, and the timings that make it. + "surface", "frames", "chrome", + "frame_arena", "scratch", + "needs_frame", "present_skipped", "native_image_patches", + "echo", + // Drained by every pump before its digest; a replica's queues + // are its own. + "effects", "effects_head", "effects_len", "in_q", "in_head", "in_len", + // The views not live: written whenever one goes out, so the + // live one's slot is stale (views.zig). + "parked", "undrawn", + // How this process was started, and the last dump it made for + // its host to write: a session loaded elsewhere has its own. + "opts", "dump_out", "dump_export", + }, + .derived = .{ "shell_rows", "diff_output", "locations_cache", "retired_panes", "tty_filter_palette", "body_chrome" }, + // The host's handles, the 9P server's fids and log, the state file + // every session of the user shares (and Recent read from it), this + // session's closed panes, and the files of a host with no file + // system of its own. + .authority = .{ "host", "fs", "store", "recent", "db", "fallback" }, + .len = .{ .{ "jumps", "njumps" }, .{ "look_src", "n_look_src" }, .{ "leader_keys", "leader_n" }, .{ "col_x", "ncol" }, .{ "col_w", "ncol" }, .{ "session_dir", "session_dir_len" } }, +}; + +/// The message row's entry points, called from everywhere as +/// `p.setMessage(...)`; they live with the rest of it in Messages.zig. +pub const setStatus = Messages.setStatus; +pub const setMessage = Messages.setMessage; +pub const reportError = Messages.reportError; +pub const reportFailure = Messages.reportFailure; + +/// Running a builtin line, called from everywhere as +/// `p.executeBuiltinLine(...)`; it lives with the rest of exec in exec.zig. +pub const executeBuiltinLine = exec.executeBuiltinLine; + +/// Geometry, called from everywhere as `p.bodyTop(pane, r)` and the rest +/// (setActiveColumn and tagTop by Store.zig and Handover.zig); it lives with the +/// columns in layout.zig. +pub const topBarHeight = layout.topBarHeight; +pub const bodyTop = layout.bodyTop; +pub const tagTop = layout.tagTop; +pub const setActiveColumn = layout.setActiveColumn; + +/// Pane slots, called from everywhere as `p.freeSlot()` and the rest +/// (emitSpawn and installPane by dump.zig); they live with the panes +/// in panes.zig. +pub const emitSpawn = pardes.panes.emitSpawn; +pub const installPane = pardes.panes.installPane; +pub const newShell = pardes.panes.newShell; +pub const newDocPane = pardes.panes.newDocPane; +pub const newScratchBelow = pardes.panes.newScratchBelow; +pub const freeSlot = pardes.panes.freeSlot; +pub const paneBySerial = pardes.panes.paneBySerial; +pub const setTestFile = pardes.panes.setTestFile; +pub const paneDir = pardes.panes.paneDir; +pub const removePane = pardes.panes.removePane; + +/// A language word's request, called from every word and test as +/// `p.lspRequest(...)`; it lives with its answer in lsp/Ask.zig. +pub const lspRequest = @import("lsp/Ask.zig").lspRequest; + +/// Performing an effect, called from every host and test as +/// `p.perform(e)`; it lives with the effects in Effect.zig. +pub const perform = @import("Effect.zig").perform; + +/// The one construction of a session, empty: its allocators, its column +/// and workspace tags, the 9P tree's clock and its mounts. `init` boots +/// a layout into it and a dump's restore (dump.initDump) its panes; a +/// second copy of this drifted once, leaving restored tags without an +/// allocator and every 9P mtime 0. +pub fn create(gpa: std.mem.Allocator, opts: Options) !*Pardes { + const p = try gpa.create(Pardes); + p.* = .{ + .gpa = gpa, + .image_gpa = opts.image_allocator orelse gpa, + .pdf_gpa = opts.pdf_allocator orelse gpa, + .tree_sitter_gpa = opts.tree_sitter_allocator orelse gpa, + .opts = opts, + .windowed = opts.windowed, + .tty_toggle = opts.tty_toggle, + .col_tags = @splat(.{ .what = .column, .gpa = gpa }), + .global_tag = .{ .what = .workspace, .gpa = gpa }, + .fs = .{}, + .screen_w = opts.cols, + .screen_h = opts.rows, + .scratch = .init(gpa), + .frame_arena = .init(opts.frame_allocator orelse gpa), + .fallback = .{ .gpa = gpa }, + .db = .{ .kind = opts.state }, + }; + errdefer p.deinit(); + p.fs.started = ctlfs.events.now(); + for (opts.mounts) |mount| try p.fs.mount(gpa, mount.name, mount.dial); + p.opts.mounts = &.{}; + return p; +} + +/// A new session, its tape written from here when PARDES_RECORD asks. +pub fn init(gpa: std.mem.Allocator, opts: Options) !*Pardes { + tape.startFromEnv(); + const taped = tape.enter(null, .{ .init = opts }); + const p = initSession(gpa, opts) catch |err| { + tape.leave(null, taped); + return err; + }; + tape.leave(p, taped); + return p; +} + +fn initSession(gpa: std.mem.Allocator, opts: Options) !*Pardes { + // A new session draws a tab at the default until `Tab` says otherwise. + config.tab_now = config.tab_width; + const p = try create(gpa, opts); + errdefer p.deinit(); + p.boot = Boot.of(opts); + // Asked once, at the start, whoever asks first after. + _ = p.sessionDir(); + switch (p.boot) { + .document => { + const path = opts.file.?; + const opened = initial_doc: { + if (comptime pdf_enabled) if (look.isPdfPath(path)) + break :initial_doc pardes.panes.Pdf.openPane(p, 0, path, opts.file_line, .last); + if (look.isImagePath(path)) + break :initial_doc pardes.panes.Image.create(p, 0, path, &.{}); + break :initial_doc pardes.panes.File.open(p, 0, path, opts.file_line); + }; + if (opened) |_| {} else |err| { + if (err == error.OutOfMemory) return err; + const why = switch (@as(anyerror, err)) { + error.PermissionDenied => "permission denied", + error.FileNotFound => "no file of that name", + error.IsDirectory => "that is a directory, and not one that could be read", + error.PathTooLong => "that path is too long", + error.FileTooLarge => "that file is too large to open", + error.NotAFile => "that is a pipe or a device, not a document", + else => @errorName(err), + }; + const content = try std.fmt.allocPrint(gpa, "cannot open\n\n\t{s}\n\n{s}\n", .{ path, why }); + errdefer gpa.free(content); + _ = try pardes.panes.Output.open(p, 0, std.fs.path.dirname(path) orelse "/", .errors, "", content); + } + p.oneColumn(); + }, + .missing => { + const missing = opts.missing.?; + const content = try std.fmt.allocPrint( + gpa, + "file or directory not found\n\n\t{s}\n", + .{missing.word}, + ); + errdefer gpa.free(content); + _ = try pardes.panes.Output.open(p, 0, missing.dir, .errors, "", content); + p.oneColumn(); + }, + .stdin => { + const page = try pager.parse(gpa, opts.stdin_text.?, p.settings.pager_color); + errdefer gpa.free(page.spans); + const content = page.text; + errdefer gpa.free(content); + const dir = p.sessionDir(); + const shown = try pardes.panes.Output.open(p, 0, dir, .{ .cmd = .New }, "", content); + // Named +Pager, as `pardes -` inside a session names its pane. + const named = try std.fs.path.join(gpa, &.{ dir, "+Pager" }); + gpa.free(shown.file.?.path); + shown.file.?.path = named; + shown.file.?.pager = true; + shown.tty_filter = true; + shown.file.?.pager_diff = pardes.panes.File.looksLikeDiff(content[0..@min(content.len, 64 * 1024)]); + shown.file.?.pager_spans = page.spans; + p.oneColumn(); + }, + .tty, .tty_shell => { + _ = try p.newShell(0, ""); + p.panes[0].?.body.mode = .tty; + p.oneColumn(); + // A bare tty is still an editor: it opens with somewhere to put + // text under the shell. The shell keeps the keyboard. A boot + // layout, like .classic's, not a placement. + if (p.boot == .tty) { + const np = try pardes.panes.newScratch(p, 0, 1, .scratch); + layout.insert(p, 0, 1, 1); + layout.splitBelow(p, 0, np); + } + }, + .classic => { + _ = try p.newShell(0, ""); + _ = try p.newShell(1, ""); + _ = try p.newShell(2, ""); + for (p.panes[0..3]) |slot| slot.?.greet = true; + p.ncol = 2; + p.col_n[0] = 2; + p.col_panes[0][0] = 0; + p.col_panes[0][1] = 1; + p.col_n[1] = 1; + p.col_panes[1][0] = 2; + }, + .shell => { + _ = try p.newShell(0, ""); + p.panes[0].?.greet = true; + p.oneColumn(); + }, + } + p.sync(); + for (config.default_incl) |dir| { + const copy = try gpa.dupe(u8, dir); + p.incl.append(gpa, copy) catch |err| { + gpa.free(copy); + return err; + }; + } + exec.applyStartupConfig(p); + // After the startup config, whose DumpDir says where the state file is. + p.loadRecent(); + colors.finishThemeInitialization(p); + p.sync(); + // A config init that opens a file with `Look …` armed the pulse before + // anyone touched anything. Nobody asked for that, so boot is silent. + _ = p.takeHaptic(); + // The ring is reserved whole now, so recording never allocates later. + try p.fs.log.buf.ensureTotalCapacityPrecise(p.gpa, p.fs.log.cap); + ctlfs.events.announce(p); // /log starts with the panes it booted with + return p; +} + +/// The layout every single-pane boot starts from. +fn oneColumn(p: *Pardes) void { + p.ncol = 1; + p.col_n[0] = 1; + p.col_panes[0][0] = 0; +} + +/// The recent list's own allocator: it is kept best effort (a file not +/// remembered for want of memory is no failure of what opened it), so +/// on a host it takes from the process heap, not the editor's, whose +/// every failure must be answered. +// ponytail: a host heap for a best-effort list. +pub fn recentGpa(_: *const Pardes) std.mem.Allocator { + return std.heap.smp_allocator; +} + +/// Recent read from the state file once at start: a new session's. +pub fn loadRecent(p: *Pardes) void { + // A replica's Recent is its own, in memory: the recording session's + // state file is every session's of its user (src/tape.zig). + if (tape.replaying()) p.db.kind = .off; + p.db.readRecent(p); +} + +/// What changed written out, at the end of a step and at the end. +pub fn saveRecent(p: *Pardes) void { + p.db.writeRecent(p, false); +} + +/// Whether `path` is one Recent keeps: a file on this host's disk, not +/// the served tree's (`/virtual/`) nor a name never saved. +pub fn recentKeeps(path: []const u8) bool { + const local = filesystem.localPath(path) orelse return false; + return exec.kindOf(local) == .file; +} + +/// A file, PDF or image pane closing: its place noted in Recent, when +/// Recent keeps it. +pub fn noteClosed(p: *Pardes, pane: *const Pane) void { + const d = recentPlace(pane) orelse return; + // The host asked first, always: what Recent holds is the + // authority's, and a step that asked only when it did not know the + // file would ask on one side and not the other. + if (!recentKeeps(d.path) and p.recent.get(d.path) == null) return; + p.recent.closed(p.recentGpa(), d.path, d.line, d.col, d.aline, d.acol); +} + +pub const RecentPlace = struct { path: []const u8, line: u32, col: u32, aline: u32 = 0, acol: u32 = 0 }; + +/// Where a pane is, as Recent keeps it: a file's dot, a PDF's page +/// (`:page:1`), an image's path alone (line 0). Null for any other. +pub fn recentPlace(pane: *const Pane) ?RecentPlace { + if (recentDot(pane)) |d| return .{ .path = d.path, .line = d.line, .col = d.col, .aline = d.aline, .acol = d.acol }; + if (pane.pdfPath()) |path| return .{ .path = path, .line = @intCast(pane.pdfPage().? + 1), .col = 1 }; + if (pane.image) |iv| return .{ .path = iv.path, .line = 0, .col = 0 }; + return null; +} + +/// A file pane's path and dot, for the recent list (0 when none). +pub fn recentDot(pane: *const Pane) ?struct { path: []const u8, line: u32, col: u32, aline: u32 = 0, acol: u32 = 0 } { + const f = pane.file orelse return null; + if (f.output != null) return null; + // The selection's anchor too, so a reopen restores both its ends. + const sel = pane.body.vsel.active; + return .{ + .path = f.path, + .line = @intCast(@max(0, pane.body.cur_row) + 1), + .col = @intCast(@max(0, pane.body.cur_col) + 1), + .aline = if (sel) @intCast(@max(0, pane.body.vsel.row) + 1) else 0, + .acol = if (sel) @intCast(@max(0, pane.body.vsel.col) + 1) else 0, + }; +} + +/// The session's configuration directory and startup file, as a step +/// reads them: its process's options, so the authority's +/// (`tape.authority`); a replica's are its own process's. +pub fn configDir(p: *Pardes) ?[]const u8 { + return tape.authority(optsConfigDir, .{p}); +} + +pub fn startupPath(p: *Pardes) ?[]const u8 { + return tape.authority(optsStartupPath, .{p}); +} + +fn optsConfigDir(p: *Pardes) ?[]const u8 { + return p.opts.config_dir; +} + +fn optsStartupPath(p: *Pardes) ?[]const u8 { + return p.opts.startup_config_path; +} + +/// The recent entry a closed jump names, by its path's hash, its path +/// in scratch. Recent is the authority's (every window of its user +/// writes it): a replica has its answer (`tape.authority`). +pub fn recentByHash(p: *Pardes, hash: u64) ?recent_files.Entry { + return tape.authority(recentFound, .{ p, hash }); +} + +fn recentFound(p: *Pardes, hash: u64) ?recent_files.Entry { + for (p.recent.entries.items) |e| if (std.hash.Wyhash.hash(0, e.path) == hash) { + var found = e; + found.path = p.scratch.allocator().dupe(u8, e.path) catch return null; + return found; + }; + return null; +} + +pub fn deinit(p: *Pardes) void { + const taped = tape.enter(p, .{ .deinit = tape.current(p) }); + tape.forget(p); + defer tape.leave(null, taped); + if (std.c.getenv("PARDES_FRAMES")) |path| p.frames.dump(std.mem.span(path)); + // Every file open now is closed with its dot, and the list kept. + for (p.panes) |slot| if (slot) |pane| p.noteClosed(pane); + p.db.writeRecent(p, true); + // The state file compacted once it is mostly what no moment holds. + p.db.compact(p); + p.db.deinit(); + p.store.deinit(p.recentGpa()); + p.recent.deinit(p.recentGpa()); + for (p.incl.items) |dir| p.gpa.free(dir); + p.incl.deinit(p.gpa); + for (p.twin_groups.items) |group| p.gpa.free(group.path); + p.twin_groups.deinit(p.gpa); + p.fs.batch.bytes.deinit(p.gpa); + if (p.stand_in) |pane| pardes.panes.teardownPane(p, pane); + look.cancelLookHover(p); + if (p.repl_ask) |ask| p.gpa.free(ask.text); + for (0..MAX_PANES) |id| p.dropPendingWrite(id); + // The panes, then those retired these last two frames. + inline for (.{ &p.panes, &p.retired_panes.previous, &p.retired_panes.current }) |slots| for (slots) |*slot| if (slot.*) |pane| { + pardes.panes.teardownPane(p, pane); + slot.* = null; + }; + const gpa = p.gpa; + views.deinit(p); + for (&p.col_tags) |*t| t.deinit(gpa); + p.global_tag.deinit(gpa); + p.registers.deinit(gpa); + p.macro.deinit(gpa); + if (p.retired_edit) |r| gpa.free(r); + if (p.dump_out) |d| gpa.free(d); + if (p.dump_export) |d| gpa.free(d); + p.fallback.deinit(); + if (p.last_dump) |d| gpa.free(d); + if (p.custom_theme) |theme_value| gpa.free(theme_value.name); + if (p.chord_arg) |a| gpa.free(a); + for (p.spawn_dirs) |d| if (d) |dir| gpa.free(dir); + p.pipe.deinit(gpa); + p.stream.deinit(gpa); + p.handover.deinit(gpa); + if (p.stream.ahead.len > 0) p.tree_sitter_gpa.free(p.stream.ahead); + p.locations_cache.deinit(p.tree_sitter_gpa); + p.fs.deinit(gpa); + p.shell_rows.reset(gpa); + p.diff_output.reset(gpa); + p.scratch.deinit(); + p.frame_arena.deinit(); + gpa.free(p.surface.cells); + for (&p.surface.body_layers) |*layer| gpa.free(layer.cells); + for (&p.surface.tag_layers) |*layer| gpa.free(layer.cells); + p.surface.images.deinit(gpa); + gpa.destroy(p); +} + +/// shell feedback after write_dump: remember where the dump landed (the +/// topbar grows a `Restore <path>` word pointing at it) +pub fn setLastDump(p: *Pardes, path: []const u8) void { + const taped = tape.enter(p, .{ .set_last_dump = path }); + defer tape.leave(p, taped); + p.pointRestoreAt(path); + ctlfs.events.notePath(p, "dump", path); +} + +/// The workspace tag's `Restore <path>` names `path` from now on: the +/// default's does by itself, and one the tag was edited around (its own +/// text) has the old path swapped, never left pointing at a dump that is +/// not the last. +pub fn pointRestoreAt(p: *Pardes, path: []const u8) void { + const copy = p.gpa.dupe(u8, path) catch return; + if (p.last_dump) |old| { + if (p.global_tag.own) |own| swap: { + const a = p.scratch.allocator(); + const was = std.fmt.allocPrint(a, "Restore {s}", .{old}) catch break :swap; + if (std.mem.indexOf(u8, own, was) == null) break :swap; + const now = std.fmt.allocPrint(a, "Restore {s}", .{path}) catch break :swap; + const swapped = std.mem.replaceOwned(u8, p.gpa, own, was, now) catch break :swap; + p.gpa.free(own); + p.global_tag.own = swapped; + } + p.gpa.free(old); + } + p.last_dump = copy; +} + +/// the shell polls this each frame: a pending Restore's dump path, or null +pub fn takeRestore(p: *Pardes) ?[]const u8 { + const taped = tape.enter(p, .take_restore); + defer tape.leave(p, taped); + const r = p.restore_req; + p.restore_req = null; + return r; +} + +/// DECSET 1004: a program that asked is told `CSI I` when its pane +/// takes the keyboard (the active pane, its body, the window focused) +/// and `CSI O` when it gives it up, to another pane, a tag or header, +/// or another window. +fn reportFocus(p: *Pardes) void { + const want: @FieldType(Pardes, "focus_told") = blk: { + if (!p.window_focused or p.header_focus) break :blk null; + const pane = p.panes[p.active] orelse break :blk null; + if (pane.focus != .body) break :blk null; + break :blk .{ .id = p.active, .serial = pane.serial }; + }; + if (std.meta.eql(want, p.focus_told)) return; + if (p.focus_told) |old| if (p.panes[old.id]) |pane| { + if (pane.serial == old.serial and pardes.panes.terminal.reportsFocus(pane)) p.emitWrite(old.id, "\x1b[O"); + }; + if (want) |new| if (pardes.panes.terminal.reportsFocus(p.panes[new.id].?)) p.emitWrite(new.id, "\x1b[I"); + p.focus_told = want; +} + +pub fn emitWrite(p: *Pardes, id: usize, bytes: []const u8) void { + var off: usize = 0; + // Anything already parked for this pane owns the stream's position, so + // new bytes queue BEHIND it — emitting them now would reorder the pty. + if (p.pending_write[id] == null) { + while (off < bytes.len and p.effects_len < p.effects.len) { + const n = @min(bytes.len - off, effect_write_cap); + p.emit(.{ .write = .{ .pane = @intCast(id), .bytes = .from(bytes[off .. off + n]) } }); + off += n; + } + } + if (off < bytes.len) p.parkPendingWrite(id, bytes[off..]); +} + +/// How many bytes `emitWrite` can take for pane `id` now without +/// dropping any: the effects left, then what the pending buffer holds. +pub fn writeRoom(p: *const Pardes, id: usize) usize { + const pending = limits.pending_write_cap -| p.pending_write_bytes; + if (p.pending_write[id] != null) return pending; + return (p.effects.len - p.effects_len) * effect_write_cap + pending; +} + +pub fn parkPendingWrite(p: *Pardes, id: usize, bytes: []const u8) void { + if (p.pending_write_bytes + bytes.len > limits.pending_write_cap) return; + if (p.pending_write[id]) |*pw| { + // Compact what the drain already sent before growing: a burst that + // arrives in pieces must not keep re-copying bytes nobody wants. + const keep = pw.bytes.len - pw.off; + const grown = p.gpa.alloc(u8, keep + bytes.len) catch return; + @memcpy(grown[0..keep], pw.bytes[pw.off..]); + @memcpy(grown[keep..], bytes); + p.gpa.free(pw.bytes); + pw.* = .{ .bytes = grown }; + } else { + p.pending_write[id] = .{ .bytes = p.gpa.dupe(u8, bytes) catch return }; + } + p.pending_write_bytes += bytes.len; +} + +/// The shell reports the spawned pane's working directory (and later cwd +/// changes it observes, e.g. via /proc/<pid>/cwd before each frame). +pub fn setCwd(p: *Pardes, id: usize, cwd: []const u8) void { + const taped = tape.enter(p, .{ .set_cwd = .{ .id = id, .cwd = cwd } }); + defer tape.leave(p, taped); + const pane = p.panes[id] orelse return; + // A command pane stays the directory's it was run for (newCommand). + if (pane.command != null) return; + const cur = switch (pane.cwd) { + .owned => |dir| dir, + else => "", + }; + if (std.mem.eql(u8, cur, cwd)) return; + // A shell started in a directory is asked where it is before it has + // said anything: its chdir may not have happened yet, and the answer + // is this process's directory, a rename to undo. That answer, then, + // is not taken. + if (pane.isTerminal() and !pane.shell_spoke and pane.cwd == .owned and std.mem.eql(u8, cwd, p.sessionDir())) return; + // One with no directory yet is named by the session's (nameOf): its + // shell saying it is there is no new name. + const same_name = cur.len == 0 and std.mem.eql(u8, cwd, p.sessionDir()); + pane.setOwnedCwd(cwd) catch |err| return p.reportError(id, "directory", err); + if (look.lookHoverPane(p) == id) look.cancelLookHover(p); + // A terminal is named by its directory, so /log hears it renamed; one + // not announced yet is announced under the new name. + if (pane.isTerminal() and !same_name) ctlfs.events.noteLog(p, .rename, pane); +} + +pub fn shellBin(p: *const Pardes) []const u8 { + const selected = p.settings.shell.requested.get(); + return if (selected.len == 0) config.defaultShell() else selected; +} + +/// A shell a dead session left, taken in (Adopt): a terminal pane made +/// for it as the Term word makes one, its greeting off (the shell is up +/// already), whose spawn the host answers with that shell's pty. Its id, +/// or null with no room. An input, as every host write into the core +/// is: a replica of the session makes the same pane. +pub fn adoptShell(p: *Pardes) ?u8 { + const taped = tape.enter(p, .adopt_shell); + defer tape.leave(p, taped); + var newest: u32 = 0; + for (p.panes) |slot| if (slot) |pn| { + newest = @max(newest, pn.serial); + }; + _ = p.executeBuiltinLine(p.active, "Term"); + for (p.panes, 0..) |slot, id| if (slot) |pn| if (pn.serial > newest and pn.isTerminal()) { + pn.greet = false; + return @intCast(id); + }; + return null; +} + +/// A terminal's reader failed (no end of file: the host closed its pty): +/// its pane takes keys again, and why is said. +pub fn readerFailed(p: *Pardes, id: u8, err: anyerror) void { + const taped = tape.enter(p, .{ .reader_failed = .{ .id = id, .err = err } }); + defer tape.leave(p, taped); + const pane = p.panes[id] orelse return; + pane.body.mode = .normal; + p.reportError(id, "terminal reader", err); +} + +pub fn acknowledgeShell(p: *Pardes, id: usize, executable: []const u8, prompt_marks: bool) void { + const taped = tape.enter(p, .{ .acknowledge_shell = .{ .id = id, .executable = executable, .prompt_marks = prompt_marks } }); + defer tape.leave(p, taped); + if (id < MAX_PANES) if (p.panes[id]) |pane| { + ctlfs.pty.shellGone(p, pane, true); // a respawn replaced whatever ran + pane.shell_failed = false; + pane.had_shell = true; + pane.fs.unmarked = !prompt_marks; + // The tag's Term word names the shell the host ran, and a click + // on it (`Term+fish`) opens another of the same. + if (pane.command == null) { + // A shell given as a path keeps it: its bare name would find + // nothing, or another program, on the usual paths. + const base = if (pane.shell) |given| (if (std.mem.indexOfScalar(u8, given, '/') != null) given else std.fs.path.basename(executable)) else std.fs.path.basename(executable); + const rest = tagline.terminal_pane_tail[" Term".len..]; + if (std.fmt.bufPrint(&pane.shell_tail, " Term+{s}{s}", .{ base, rest })) |tail| { + pane.shell_tail_len = @intCast(tail.len); + } else |_| {} + } + }; + if (id < MAX_PANES) pardes.panes.terminal.shellSpawned(p, id, prompt_marks); + if (p.settings.shell.effective.set(executable)) + p.settings.shell.pending = false; +} + +/// A window's font, asked and told (this and the three below): in every +/// build, not only a window's, as only a window's host calls +/// them and a terminal's replica of a window's session must step as +/// the window does. +pub fn takeFontRequest(p: *Pardes) ?[]const u8 { + const taped = tape.enter(p, .take_font_request); + defer tape.leave(p, taped); + if (!p.settings.font.pending or p.font_request_taken) return null; + const path = p.settings.font.requested_path.get(); + if (path.len == 0) return null; + p.font_request_taken = true; + return path; +} + +pub fn observeFont( + p: *Pardes, + effective_name: []const u8, + effective_size_hundredths: u16, + unit: config.Runtime.FontSizeUnit, +) bool { + const taped = tape.enter(p, .{ .observe_font = .{ .name = effective_name, .size = effective_size_hundredths, .unit = unit } }); + defer tape.leave(p, taped); + if (!p.settings.font.effective_name.set(effective_name)) return false; + p.settings.font.effective_size_hundredths = effective_size_hundredths; + p.settings.font.effective_size_unit = unit; + return true; +} + +/// Resolve the request already handed to the GUI host. Requested and +/// effective tuples deliberately remain separate so DumpConfig can show both. +pub fn acknowledgeFont( + p: *Pardes, + effective_name: []const u8, + effective_size_hundredths: u16, + unit: config.Runtime.FontSizeUnit, +) bool { + const taped = tape.enter(p, .{ .acknowledge_font = .{ .name = effective_name, .size = effective_size_hundredths, .unit = unit } }); + defer tape.leave(p, taped); + if (!p.settings.font.pending or !p.font_request_taken) return false; + const changed = !std.mem.eql( + u8, + p.settings.font.effective_name.get(), + effective_name, + ) or p.settings.font.effective_size_hundredths != effective_size_hundredths or + p.settings.font.effective_size_unit != unit; + if (!p.observeFont(effective_name, effective_size_hundredths, unit)) return false; + p.settings.font.pending = false; + p.font_request_taken = false; + if (changed) look.cancelLookHover(p); + return true; +} + +pub fn rejectFont(p: *Pardes) void { + const taped = tape.enter(p, .reject_font); + defer tape.leave(p, taped); + if (!p.settings.font.pending or !p.font_request_taken) return; + p.settings.font.pending = false; + p.font_request_taken = false; +} + +fn applyWatchedFileChanged(p: *Pardes, id: u8, bytes: []const u8) bool { + if (id >= MAX_PANES) return false; + const pane = p.panes[id] orelse return false; + if (comptime pdf_enabled) if (pane.pdf != null) { + pardes.panes.Pdf.reloadWatched(p, pane) catch |err| { + p.reportError(id, "PDF reload", err); + return false; + }; + return true; + }; + if (pane.file == null) return false; + pardes.panes.File.changed(p, id, bytes); + return if (p.panes[id]) |current| + if (current.file) |file| std.mem.eql(u8, file.content, bytes) else false + else + false; +} + +/// A view of its own for a new client (a second window, a terminal +/// `pardes --attach`ed), as the live one is laid out; null at +/// views.max. Not live until `toView`. +pub fn openView(p: *Pardes) ?u8 { + const taped = tape.enter(p, .open_view); + defer tape.leave(p, taped); + // Every view taken: one kept for a client that has not come back + // for it (views.away) goes first. ponytail: no timer lets one go; + // until its place is wanted it costs a parked slot, and a terminal + // it sized last keeps that size until another view types into it. + if (@popCount(p.views_open) == views.max and p.views_away != 0) { + views.close(p, @ctz(p.views_away)); + p.sync(); + } + // What was queued since the last pump (a leaving client's view + // closed, a 9P request's step) done first, as every client of the + // tape does it here: a join dumps the session next, and a core + // loaded from a dump has no queue (Replica.initDump). + p.settle(); + p.needs_frame = true; + return views.open(p); +} + +/// The client of view `k` gone: its view goes, the others stay. The +/// last one stays the session's own. +pub fn closeView(p: *Pardes, k: u8) void { + const taped = tape.enter(p, .{ .close_view = k }); + defer tape.leave(p, taped); + views.close(p, k); + p.sync(); + // What its sync queued (a terminal it sized, sized again) done here, + // in its own unit on every side: the session's next pump is another + // unit, and a replica takes a copy only of a core with nothing + // queued (rollback.Copy.take). + p.settle(); +} + +/// The last client of a session no one else watches gone: its view +/// goes, and the session's own is laid out as it was (views.closeKeeping), +/// which the client's rejoin copies. Settled as `closeView` is. +pub fn leaveView(p: *Pardes, k: u8) void { + const taped = tape.enter(p, .{ .leave_view = k }); + defer tape.leave(p, taped); + views.closeKeeping(p, k); + p.sync(); + p.settle(); +} + +/// The client of view `k` gone, to join again for it (an Upgrade's +/// rejoin, a divergence's): its view kept as it is (views.away). +pub fn awayView(p: *Pardes, k: u8) void { + const taped = tape.enter(p, .{ .away_view = k }); + defer tape.leave(p, taped); + views.away(p, k); +} + +/// A client back for view `k`, kept for it (`awayView`): its own again, +/// as it left it; false when it was let go meanwhile. Settled as +/// `openView` is, for the join's dump next. +pub fn rejoinView(p: *Pardes, k: u8) bool { + const taped = tape.enter(p, .{ .rejoin_view = k }); + defer tape.leave(p, taped); + if (!views.isAway(p, k)) return false; + p.views_away &= ~(@as(u8, 1) << @intCast(k)); + p.settle(); + p.needs_frame = true; + return true; +} + +/// Into view `k`, before the input its client sent. +pub fn toView(p: *Pardes, k: u8) void { + if (k == p.view) return; + const taped = tape.enter(p, .{ .to_view = k }); + defer tape.leave(p, taped); + views.to(p, k); +} + +/// Something changed the core without going through `update` -- a watched +/// file reloading under it, a theme file rewritten on disk. `pump` draws +/// only when it has a reason to, and this is the reason. +pub fn invalidate(p: *Pardes) void { + const taped = tape.enter(p, .invalidate); + defer tape.leave(p, taped); + p.needs_frame = true; +} + +pub fn reloadWatchedFile(p: *Pardes, id: u8, bytes: []const u8) bool { + const taped = tape.enter(p, .{ .reload_watched_file = .{ .id = id, .bytes = bytes } }); + defer tape.leave(p, taped); + p.invalidate(); + look.invalidateLookHover(p, id); + const applied = p.applyWatchedFileChanged(id, bytes); + _ = p.scratch.reset(.{ .retain_with_limit = memory.limits.scratch_kept }); + p.sync(); + return applied; +} + +pub fn emit(p: *Pardes, e: Effect) void { + if (p.effects_len == p.effects.len) return; + const tail = (p.effects_head + p.effects_len) % p.effects.len; + p.effects[tail] = e; + p.effects_len += 1; +} + +pub fn nextEffect(p: *Pardes) ?Effect { + const taped = tape.enter(p, .next_effect); + defer tape.leave(p, taped); + p.refillPendingWrites(); + if (p.effects_len == 0) { + p.effects_head = 0; + return null; + } + const e = p.effects[p.effects_head]; + p.effects_head = (p.effects_head + 1) % p.effects.len; + p.effects_len -= 1; + return e; +} + +/// Move parked pty bytes into whatever room the ring now has, oldest pane +/// slot first. Costs one comparison when nothing is parked. +fn refillPendingWrites(p: *Pardes) void { + if (p.pending_write_bytes == 0) return; + for (&p.pending_write, 0..) |*slot, id| { + while (p.effects_len < p.effects.len) { + // `|*pw|` points INTO the slot: capturing by value would advance + // a copy's cursor and re-send the same chunk for ever. + const pw = if (slot.*) |*live| live else break; + const n = @min(pw.bytes.len - pw.off, effect_write_cap); + p.emit(.{ .write = .{ .pane = @intCast(id), .bytes = .from(pw.bytes[pw.off..][0..n]) } }); + pw.off += n; + p.pending_write_bytes -= n; + if (pw.off == pw.bytes.len) { + p.gpa.free(pw.bytes); + slot.* = null; + break; + } + } + if (p.effects_len == p.effects.len) return; + } +} + +/// Drop a pane's parked bytes: its pty is gone, and the slot it occupied +/// may be handed to a different pane next frame. +pub fn dropPendingWrite(p: *Pardes, id: usize) void { + const pw = p.pending_write[id] orelse return; + p.pending_write_bytes -= pw.bytes.len - pw.off; + p.gpa.free(pw.bytes); + p.pending_write[id] = null; +} + +pub fn postEvent(p: *Pardes, ev: Event) void { + switch (ev) { + .key => |k| std.debug.assert(k.text.len == 0), + .output, .paste, .lsp_resp, .pipe_resp, .search, .file_changed, .command => unreachable, + else => {}, + } + if (p.in_len == p.in_q.len) return; + p.in_q[(p.in_head + p.in_len) % p.in_q.len] = ev; + p.in_len += 1; +} + +fn nextQueued(p: *Pardes) ?Event { + if (p.in_len == 0) { + p.in_head = 0; + return null; + } + const ev = p.in_q[p.in_head]; + p.in_head = (p.in_head + 1) % p.in_q.len; + p.in_len -= 1; + return ev; +} + +pub fn hostForegroundName(p: *const Pardes, id: usize, buf: []u8) ?[]const u8 { + const f = p.host.vtable.fg_name orelse return null; + return f(p.host.ctx, @intCast(id), buf); +} + +pub fn hostTtyTaken(p: *const Pardes, id: usize) bool { + const f = p.host.vtable.tty_taken orelse return false; + return f(p.host.ctx, @intCast(id)); +} + +pub fn hostKillJob(p: *const Pardes, id: usize) bool { + const f = p.host.vtable.kill_job orelse return false; + return f(p.host.ctx, @intCast(id)); +} + +/// A terminal whose shell could not be started: said, and a run waiting +/// on it, or written to it from now on, hears `error shell gone` +/// rather than wait for a prompt that never comes. +pub fn shellFailed(p: *Pardes, id: u8, err: anyerror) void { + const taped = tape.enter(p, .{ .shell_failed = .{ .id = id, .err = err } }); + defer tape.leave(p, taped); + const pane = p.panes[id] orelse return; + pane.shell_failed = true; + ctlfs.pty.shellGone(p, pane, false); + p.sayShellFailure(id, err); + // A command that never started ended: `exit 127`, as a shell says of + // a command it could not run, so a follower waiting on its exit + // hears one, its tag stops saying it runs, and Kill finds nothing. + if (pane.command != null and !pane.command_done) { + pane.command_pty = false; + exec.commandDone(p, id, 127); + } else if (pane.command == null and !pane.had_shell) { + // A Term whose shell never ran: no dead pane left behind; the + // write that asked for it has failed with why. A terminal whose + // shell was started again (pty/ctl exec) keeps its pane. + p.unplaced.set(id); + } +} + +/// A shell started again in a terminal whose shell runs (pty/ctl's +/// exec) did not start: the host kept the running one, so only said. +pub fn restartFailed(p: *Pardes, id: u8, err: anyerror) void { + const taped = tape.enter(p, .{ .restart_failed = .{ .id = id, .err = err } }); + defer tape.leave(p, taped); + if (p.panes[id] == null) return; + p.sayShellFailure(id, err); +} + +fn sayShellFailure(p: *Pardes, id: u8, err: anyerror) void { + const pane = p.panes[id] orelse return; + if (err == error.FileNotFound or err == error.NotDir) { + p.reportFailure(id, "shell: directory missing (no such directory)"); + } else if (err == error.InterpreterNotFound) { + // The script is there; the program its `#!` names is not. + var said: [320]u8 = undefined; + var interp: [256]u8 = undefined; + const name = tape.value(.interpreter, missingInterpreter, .{ pane.shell orelse p.shellBin(), &interp }); + p.reportFailure(id, if (name) |n| std.fmt.bufPrint(&said, "shell: interpreter {s} not found", .{n}) catch "shell: interpreter not found" else "shell: interpreter not found"); + } else { + p.reportError(id, "shell", err); + } + // A 9P write that asked for the shell (pty/ctl's exec), waiting on + // it, fails with what was said, as a failed Save's does. + p.noteLateFailure(id); +} + +/// The program the shell's `#!` names that is not there, in `out`. +fn missingInterpreter(bin: []const u8, out: []u8) ?[]const u8 { + const Shell = @import("host_io.zig").Shell; + var buf: [std.fs.max_path_bytes]u8 = undefined; + return Shell.missingInterpreter(Shell.find(bin, &buf) orelse return null, out); +} + +/// The directory a write of `path` that failed with `err` went into: +/// what is there (a directory when it is no local path), whether it is +/// missing, and whether that is because one above refuses (EACCES). +fn parentTrouble(path: []const u8, err: anyerror) struct { dir: []const u8, kind: ?std.Io.File.Kind, missing: bool, denied: bool } { + const dir = std.fs.path.dirname(path) orelse "/"; + const local = filesystem.localPath(dir); + const kind: ?std.Io.File.Kind = if (local) |l| exec.kindOf(l) else .directory; + const missing = err == error.FileNotFound or err == error.NotDir or kind != .directory; + const denied = missing and (if (local) |l| tape.value(.denied, filesystem.deniedAbove, .{l}) else false); + return .{ .dir = dir, .kind = kind, .missing = missing, .denied = denied }; +} + +pub fn saveFailed(p: *Pardes, id: u8, path: []const u8, err: anyerror) void { + const taped = tape.enter(p, .{ .save_failed = .{ .id = id, .path = path, .err = err } }); + defer tape.leave(p, taped); + if (p.panes[id]) |pane| if (pane.file) |*f| { + // The `-%` spelling fs.zig already uses for "make this dirty". + f.saved_revision = f.revision -% 1; + }; + var what: [limits.host_path_cap + 32]u8 = undefined; + // A write into a directory that is not there: said so, in the words + // a mount reads as ENOENT; EACCES when one above refuses. + const parent = parentTrouble(path, err); + if (parent.denied) + p.reportFailure(id, std.fmt.bufPrint(&what, "Save {s}: permission denied", .{path}) catch "Save: permission denied") + else if (parent.missing) + p.reportFailure(id, std.fmt.bufPrint(&what, "Save {s}: no such directory", .{path}) catch "Save: no such directory") + else + p.reportError(id, std.fmt.bufPrint(&what, "Save {s}", .{path}) catch "Save", err); + p.noteLateFailure(id); +} + +/// A Dump the host could not write: said on the message row and in the +/// log, and the 9P write that asked for it fails with it, as a failed +/// Save's does. +pub fn dumpFailed(p: *Pardes, path: []const u8, err: anyerror) void { + const taped = tape.enter(p, .{ .dump_failed = .{ .path = path, .err = err } }); + defer tape.leave(p, taped); + var what: [limits.host_path_cap + 8]u8 = undefined; + const operation = std.fmt.bufPrint(&what, "Dump {s}", .{path}) catch "Dump"; + // Into a DumpDir that is not there: said so, ENOENT, as a Save is; + // one that is there but no directory (`/dev/null`) says that. + const parent = parentTrouble(path, err); + var said: [limits.host_path_cap + 48]u8 = undefined; + if (parent.denied and parent.kind == null) + p.reportFailure(p.active, std.fmt.bufPrint(&said, "{s}: permission denied", .{operation}) catch "Dump: permission denied") + else if (parent.kind != null and parent.kind != .directory) + p.reportFailure(p.active, std.fmt.bufPrint(&said, "{s}: {s} is not a directory", .{ operation, parent.dir }) catch "Dump: not a directory") + else if (parent.missing) + p.reportFailure(p.active, std.fmt.bufPrint(&said, "{s}: no such directory", .{operation}) catch "Dump: no such directory") + else + p.reportError(p.active, operation, err); + // In the words the message row has, so the write's err is the one + // record of it (its msg goes: 9p_io, dropMessage). + p.noteLateFailure(p.active); +} + +pub fn fsPayload(p: *const Pardes, r: ctlfs.Reply) []const u8 { + return switch (r.payload) { + .none => &.{}, + .staged => |n| p.fs.out.items[0..@min(n, p.fs.out.items.len)], + .region => |g| region: { + const pane = p.panes[g.pane] orelse break :region &.{}; + if (pane.serial != g.serial) break :region &.{}; + const text = if (pane.file) |*f| f.content else break :region &.{}; + const lo = @min(g.off, text.len); + break :region text[lo..@min(lo + g.len, text.len)]; + }, + }; +} + +pub fn pump(p: *Pardes, host: Host) !void { + p.host = host; + const taped = tape.enter(p, .pump); + defer tape.leave(p, taped); + // The host as the tape sees it, while it records. + const h = p.host; + const v = h.vtable; + if (v.wait_input) |f| { + // Asleep until input or until the core's next deadline + // (nextWake); 0 is no timeout at all. + // The clock read whether or not it is wanted: what a replica + // waits on is its own (a picture decoding wakes only a frame + // that draws it), and the tape has the same calls either way. + const now = if (v.now) |clock| clock(h.ctx) else p.now_ns; + const timeout: u32 = if (p.nextWake()) |due| wake: { + const ms = ((due -| now) + std.time.ns_per_ms - 1) / std.time.ns_per_ms; + break :wake @intCast(std.math.clamp(ms, 1, std.math.maxInt(u32))); + } else 0; + f(h.ctx, timeout); + } + // Detached, nobody's key dismisses a message: they go on the clock, + // here in the step, where the clock read is taped (the host's wait + // did it, untaped, and a replay kept a message its session had let + // go). + Messages.expireUnattended(p); + p.frames.mark_start = FrameStats.nowNs(); + if (v.now) |clock| p.advance(clock(h.ctx)); + p.settle(); + // A quitting frame has already freed what it would draw. + if (p.quit) return; + if (v.poll_frame) |f| f(h.ctx); + // Nothing to draw: do not spend a frame, and above all do not block on + // the display for one. This is what keeps the frame rate governing + // rendering and nothing else. + // A shell with a clock draws what `advance` stepped; one without + // steps its own `.tick`s and draws while a deadline is due. + if (!p.needs_frame and (v.now != null or !p.animationActive())) return p.frames.idle(); + // No one to see it: the frame stays owed (needs_frame), not drawn. + // A pty streaming into an unwatched session spent most of its time + // drawing what nobody looked at. + if (v.watched) |f| if (!f(h.ctx)) return; + // The other views first, each into its own window or terminal. + if (views.several(p)) try views.drawOthers(p, h); + // A replica client's view live (its input the last): its own + // process draws it. + if (p.undrawn & (@as(u8, 1) << @intCast(p.view)) == 0) { + _ = p.frame_arena.reset(.{ .retain_with_limit = memory.limits.frame_kept }); + p.frames.mark_update = FrameStats.nowNs(); + p.frames.view = if (p.panes[p.active]) |pane| pane.scroll() else 0; + const surface = try p.render(p.frame_arena.allocator()); + p.frames.mark_render = FrameStats.nowNs(); + if (v.present) |f| f(h.ctx, surface); + Stream.askAhead(p); + } + // Settled before post_present: a shell ticks there, and what that + // tick moves owes the next frame. + const skipped = p.present_skipped; + p.needs_frame = p.present_skipped; + p.present_skipped = false; + if (v.post_present) |f| f(h.ctx); + // Still moving: the next frame is owed a period from now. + const owed = if (p.nextWake()) |due| due <= p.stepped_ns + frame_ns else false; + p.frames.record(FrameStats.nowNs(), owed, skipped); +} + +/// What a pump does between its wait and its frame: the queued inputs +/// and the effects. Also the session at a step boundary, taken now (an +/// Upgrade's dump, upgrade.zig). +pub fn settle(p: *Pardes) void { + // What a 9P open wrote in a row goes in once the writes pause. + ctlfs.pane.flushPausedBatch(p); + // ...and what a /pager open was written before its close. + ctlfs.ctl.fillClosedPagers(p); + // ...and the last line of an open closed with no newline after it. + ctlfs.runClosedLines(p); + while (p.nextQueued()) |ev| p.update(ev); + while (p.nextEffect()) |e| p.perform(e); + turn.bump(&turn.epoch); +} + +/// A replica client's input settled on the authority (src/replica.zig): +/// a pump that waits on nothing, reads no clock and draws nothing, so +/// the client's own core can apply the same at once and expect the +/// authority's tape of it to read the same. The session's own pump +/// draws it after. +pub fn step(p: *Pardes) void { + const taped = tape.enter(p, .step); + defer tape.leave(p, taped); + p.settle(); +} + +/// One request of the control filesystem, from whichever thread has the +/// turn (`pardes.turn`). Not an event: it neither sweeps nor resets +/// anything the editor's own step may be in the middle of using, so it +/// can be answered while that step is out in a syscall. Only a request +/// that changes a pane costs a frame, which is why a round trip on a +/// local socket costs microseconds and not a vsync. +pub fn serveFs(p: *Pardes, req: ctlfs.Req) ctlfs.Reply { + const taped = tape.enter(p, .{ .serve_fs = req }); + defer tape.leave(p, taped); + // The held write of an Edit whose commands run, asked again by a + // retry of its park: still waiting, or its answer, never run twice. + if (p.fs.edit_hold) |*h| if (h.names(req)) { + if (!h.done) return .{ .tag = req.tag, .status = .again }; + return filesystem.EditHold.answer(&p.fs); + }; + defer pardes.panes.File.syncTwins(p); + if (!ctlfs.changesPane(p, req)) return ctlfs.handle(p, req); + // An address, a limit or the mark flag is nothing drawn: a script's + // addr write then its close costs no frame between them. + const drawn = if (ctlfs.Node.target(req.node)) |t| !(t == .pane and (t.pane.file == .addr or t.pane.file == .limit or t.pane.file == .mark)) else true; + if (drawn) p.needs_frame = true; + p.raw_hover_intent = false; + look.cancelLookHover(p); + p.fs.serving = true; + p.fs.lsp_answer_at = null; + p.fs.edit_started = false; + const reply = ctlfs.handle(p, req); + p.fs.serving = false; + // The one-failure rule is a write's: a refused open (its OTRUNC's + // truncation, a setattr, too), create or remove is its Rerror alone, + // no err, as is a write to pane/new, which is only ever read. + const ruled = req.op == .write and req.node != @backingInt(ctlfs.TopFile.new); + if (reply.status == .err and ruled) ctlfs.events.noteError(p, req, reply); + // The request was a whole step of its own, so it settles the way a + // step does: the cursor and scroll reconciled, the scripted panes + // told, and the panes it made announced to /log now rather than at + // the end of whatever the editor does next. + p.sync(); + p.fsReport(); + // A /focus write moves the keyboard as a click does: the programs + // that asked (DECSET 1004) hear it now, as after update(). + p.reportFocus(); + ctlfs.events.announce(p); + return reply; +} + +pub fn update(p: *Pardes, ev: Event) void { + const taped = tape.enter(p, .{ .update = ev }); + defer tape.leave(p, taped); + defer pardes.panes.File.syncTwins(p); + defer p.reportFocus(); + // A tick with no deadline due is the one event that cannot change + // the screen. + p.needs_frame = p.needs_frame or ev != .tick; + p.shell_rows.sweep(p.gpa); + Messages.expireUnattended(p); + // An announcement stands in only until its own step says more. + for (p.panes) |slot| if (slot) |pane| { + pane.msg_announcement = false; + }; + // A Look's hover outlives a tick, a batch of rows coming in (no + // gesture), a move with no button, and a change to another pane. + const hover_stays = switch (ev) { + .tick, .search => true, + .mouse => |m| m.button == .none and m.kind == .motion, + .output => |o| look.lookHoverPane(p) != o.pane, + .file_changed => |changed| look.lookHoverPane(p) != changed.pane, + .pdf_scroll => |scroll| look.lookHoverPane(p) != scroll.pane, + else => false, + }; + if (!hover_stays) { + p.raw_hover_intent = false; + look.cancelLookHover(p); + } + switch (ev) { + .key, .mouse => { + for (p.panes) |slot| { + if (slot) |pane| Messages.dismissMessage(p, pane); + } + p.clip_pending = null; + }, + .tick => { + Stream.step(p); + Messages.advanceMessages(p); + for (p.panes) |slot| if (slot) |pane| if (pane.file) |*f| f.tables.step(pane.gpa, f); + for (0..p.panes.len) |id| exec.flushReplEnter(p, id, false); + }, + else => {}, + } + if (p.fs.listeners != 0) p.fs.origin = switch (ev) { + .key => 'K', + .mouse => 'M', + else => p.fs.origin, + }; + switch (ev) { + .resize => |sz| { + if (sz.row_metrics) |metrics| p.row_metrics = metrics; + if (comptime pdf_enabled) { + var before: [MAX_PANES]?pardes.panes.Pdf.Viewport = @splat(null); + for (p.panes, 0..) |slot, id| { + const pane = slot orelse continue; + if (pane.pdf != null) before[id] = pardes.panes.Pdf.paneViewport(p, pane); + } + p.screen_w = sz.cols; + p.screen_h = sz.rows; + p.cell_pixels.w = @max(1, sz.cell_pixels.w); + p.cell_pixels.h = @max(1, sz.cell_pixels.h); + layout.compute(p); + for (p.panes, 0..) |slot, id| { + const pane = slot orelse continue; + if (pane.pdf) |pv| { + if (!std.meta.eql(before[id], pardes.panes.Pdf.paneViewport(p, pane))) { + pardes.panes.Pdf.captureLayoutAnchor(pv); + pv.layout_valid = false; + pv.search_reveal_pending = pv.search_query.len > 0; + } + } + } + } else { + p.screen_w = sz.cols; + p.screen_h = sz.rows; + } + p.resize_count += 1; + }, + .output => |o| { + const pane = p.panes[o.pane] orelse return; + pane.shell_spoke = true; + ctlfs.events.notePtyOutput(p, o.pane, o.bytes); + pardes.panes.terminal.feedOutput(p, pane, o.bytes); + ctlfs.pty.noteMarks(p, o.pane, pane); + exec.flushReplEnter(p, o.pane, true); + }, + .exited => |e| if (p.panes[e.pane]) |pane| { + if (pane.command == null) + ctlfs.pty.shellExited(p, pane, e.status) + else if (!pane.command_done) + exec.commandDone(p, e.pane, e.status); + }, + .eof => |e| if (p.panes[e.pane]) |pane| if (pane.command != null) { + // Output is over; the command is over when its child exits. + pane.command_pty = false; + } else p.removePane(e.pane, null) catch |err| { + pane.body.mode = .normal; + p.reportError(e.pane, "terminal exited; Del retries close", err); + }, + .lsp_resp => |r| @import("lsp/Ask.zig").lspResponse(p, r.id, r.rows), + .pipe_resp => |r| Pipe.pipeResponse(p, r.id, r.success, r.outputs, r.failure), + .search => |b| Stream.receive(p, &b), + .file_changed => |fc| _ = p.applyWatchedFileChanged(fc.pane, fc.bytes), + .key => |key| { + p.can_ask = true; + defer p.can_ask = false; + p.typedInto(); + @import("keys.zig").handleKey(p, key); + }, + .mouse => |m| mouse.handleMouse(p, m), + .pdf_scroll => |scroll| { + if (comptime pdf_enabled) { + if (scroll.pane < MAX_PANES) { + if (p.panes[scroll.pane]) |pane| { + if (pane.hasPdf() and p.native_images) + _ = pardes.panes.Pdf.scrollPane(p, pane, @floatCast(scroll.delta_pixels), scroll.glide); + } + } + } + }, + .paste => |bytes| { + p.typedInto(); + edit.applyPaste(p, bytes); + }, + .command => |line| _ = p.executeBuiltinLine(p.active, line), + .focus => |focused| { + p.window_focused = focused; + if (focused) if (p.host.vtable.newer_build) |f| if (f(p.host.ctx)) p.setMessage(p.active, newer_build_words); + }, + .handed => |h| p.handover.finish(p, h.seq, h.to, h.failure), + .frontend => |f| { + p.windowed = f.windowed; + p.native_images = f.native_images; + p.native_image_patches = f.native_image_patches; + }, + .pointer_leave => { + p.pointer_inside = false; + p.pointer_body_hit = null; + p.pointer_tag_hit = null; + }, + .tick => { + mouse.edgeScroll(p); + look.advanceLookHover(p); + }, + } + // Each pane's places find a frame's more on a tick, and on any other + // step the ones an edit or a scroll left unfound in the view. + for (p.panes) |slot| if (slot) |pane| pane.places.settle(p, pane, ev == .tick); + // Each live query pane's rows, made from what changed this step. + pardes.panes.Query.produceAll(p, ev == .tick, ev == .key); + _ = p.scratch.reset(.{ .retain_with_limit = memory.limits.scratch_kept }); + p.sync(); + p.fsReport(); + ctlfs.events.announce(p); +} + +fn fsReport(p: *Pardes) void { + if (p.fs.listeners == 0) return; + for (p.panes, 0..) |slot, id| { + const pane = slot orelse continue; + if (pane.fs.readers == 0) continue; + const tag = tagline.tagText(p, p.scratch.allocator(), pane) catch continue; + const snap = &pane.fs.tag_snap; + if (std.mem.eql(u8, snap.items, tag)) continue; + if (snap.capacity != 0 or snap.items.len != 0) + ctlfs.events.noteReplace(p, id, true, snap.items, tag); + snap.clearRetainingCapacity(); + snap.appendSlice(p.gpa, tag) catch {}; + } +} + +/// Where pardes started: the directory of what runs from a header. +pub fn sessionDir(p: *Pardes) []const u8 { + if (p.session_dir_len) |n| return p.session_dir[0..n]; + // The directory the session that recorded was started in. + const dir = tape.value(.cwd, processDir, .{&p.session_dir}) orelse return "/"; + std.mem.copyForwards(u8, &p.session_dir, dir); + p.session_dir_len = @intCast(dir.len); + return p.session_dir[0..dir.len]; +} + +fn processDir(buf: *[limits.host_path_cap]u8) ?[]const u8 { + if (std.c.getcwd(buf, buf.len) == null) return null; + return buf[0 .. std.mem.indexOfScalar(u8, buf, 0) orelse return null]; +} + +/// The directory a word run from pane `id`'s text or tag runs in, or, +/// from a header, the session's. +pub fn execDir(p: *Pardes, id: usize) []const u8 { + if (p.exec_header) return p.sessionDir(); + return paneDir(p.panes[id] orelse return p.sessionDir()); +} + +pub const SavePath = Effect.Buf(effect_path_cap); + +/// What was said of a failure just now on pane `id` is also the waiting +/// 9P write's (9p_io, `fs.late_failure`). +pub fn noteLateFailure(p: *Pardes, id: usize) void { + const taped = tape.enter(p, .{ .note_late_failure = id }); + defer tape.leave(p, taped); + // Said by reportFailure just now: its words fitted whole, the + // reason kept; else what the message row has. + const said = if (p.fs.said_at == p.fs.failures and p.fs.said_len > 0) + p.fs.said[0..p.fs.said_len] + else if (p.panes[id]) |pane| pane.msg[0..pane.msg_len] else return; + const kept = @import("Messages.zig").clip(said, p.fs.late_failure.len); + @memcpy(p.fs.late_failure[0..kept.len], kept); + p.fs.late_failure_len = @intCast(kept.len); +} + +/// The frontend drew a frame: a pointer resting on it follows what is +/// under it now, a drag's moving end and a look-hover's word. +pub fn presented(p: *Pardes) void { + const taped = tape.enter(p, .presented); + defer tape.leave(p, taped); + if (p.pointer_inside and p.drag != .none) { + p.hover_col = p.pointer_raw_col; + p.hover_row = p.pointer_raw_row; + mouse.dragUpdate(p, p.pointer_raw_col, p.pointer_raw_row, p.pointer_body_hit); + } + look.refreshLookHoverFromRaw(p); +} + +/// The window's answer to a WindowOpacity: done, or `failure` says why +/// not, `applied` the opacity it keeps. +pub fn windowOpacityDone(p: *Pardes, applied: u8, failure: ?[]const u8) void { + const taped = tape.enter(p, .{ .window_opacity_done = .{ .applied = applied, .failure = failure } }); + defer tape.leave(p, taped); + p.settings.window_opacity_pending = false; + const reason = failure orelse return; + // Do not claim a value the compositor refused; an explicit retry of + // the same command will arm a new request. + p.settings.window_opacity = applied; + var buf: [256]u8 = undefined; + p.setMessage(p.active, std.fmt.bufPrint(&buf, "WindowOpacity: {s}", .{reason[0..@min(reason.len, 240)]}) catch "WindowOpacity: compositor rejected the request"); +} + +/// Recompute geometry, push grid-size changes to each emulator and pty, +/// fire deferred greetings. +pub fn sync(p: *Pardes) void { + while (p.unplaced.findFirstSet()) |id| { + p.unplaced.unset(id); + // Refused, it was never there. Its serial is not handed out + // again: one logged or answered names this pane for good. Its + // rows, if it had any, go where a closed pane's go; no other + // pane moves (a pane dragged short keeps its rows). + if (p.panes[id] != null) p.removePane(id, null) catch {}; + } + // A file opened or closed this step: the kept list follows. + p.saveRecent(); + tagline.flattenHeaders(p); + if (p.header_column != null and layout.columnBarHeight(p) == 0) { + tagline.exitHeader(p); + } + pardes.panes.reapPanes(p); + if (views.several(p)) views.show(p); + layout.compute(p); + Jump.trackJump(p); + for (&p.panes, 0..) |*slot, id| { + const pane = slot.* orelse continue; + // The keyboard is on one pane, or on a header: a tag it has left + // hands it back to its body, and a name drafted there is dropped. + if (id != p.active or p.header_focus) { + pane.focus = .body; + if (pane.prompt == .name and pane.prompt_view == p.view) pane.closePrompt(); + } + // A sweep over the tag is the tag's while it has the keyboard. + const swept = pane.sel[sel_slot]; + if (pane.focus == .body and swept.state == .done and @min(swept.r0, swept.r1) < pane.tag_rows) { + pane.clearPointerSelection(sel_slot); + pane.sel[sel_slot].state = .none; + } + // What the terminal answers its program (a cursor report, its + // attributes) goes as typed bytes go: behind whatever is still + // queued for its pty, never ahead of it nor dropped. + if (pane.terminal) |state| { + p.emitWrite(id, state.reply[0..state.reply_len]); + state.reply_len = 0; + } + const r = p.rects[id]; + // The session's part of the pane's view geometry (File.geometry), + // and its context declarations. + if (pane.file) |*f| pardes.panes.File.refreshContext(p, pane, f); + pane.view = .{ .wrap = p.settings.wrap, .layered = p.settings.tree_context_tag_style, .body_h = p.row_metrics.body_h, .tagline_h = p.row_metrics.tagline_h, .rect_h = r.h }; + // The tag takes a row per line, leaving the body one row if it + // had any; a folded pane shows its first line only. Its prefix + // is made once, on the stack: this runs on every event, and not + // every event may take from the scratch arena. + var wrap_room: [32 * 1024]u8 = undefined; + var wrap_fba = std.heap.FixedBufferAllocator.init(&wrap_room); + const wa = wrap_fba.allocator(); + const prefix: ?[]const u8 = tagline.prefixIn(p, wa, pane) catch null; + const lead = if (prefix) |made| made.len else pane.tag_lead; + if (lead != pane.tag_lead) { + const t = &pane.tag; + const old: i32 = @intCast(pane.tag_lead); + const new: i32 = @intCast(lead); + if (t.cur_row == 0 and t.cur_col >= old) t.cur_col += new - old; + if (t.vsel.row == 0 and t.vsel.col >= old) t.vsel.col += new - old; + for (t.sels[0..t.nsel]) |*sel| { + if (sel.row == 0 and sel.col >= old) sel.col += new - old; + if (sel.arow == 0 and sel.acol >= old) sel.acol += new - old; + } + pane.tag_lead = lead; + } + // A row per shown row: the tag's lines wrapped at its width. + var lines = std.mem.count(u8, tagline.curTail(pane), "\n") + 1; + var wanted = lines; + var caret_row: usize = @intCast(@max(0, pane.tag.cur_row)); + if (prefix) |made| wrap: { + const whole = std.mem.concat(wa, u8, &.{ made, tagline.curTail(pane) }) catch break :wrap; + const shown = tagline.wrapTag(wa, whole, tagline.tagWidth(p, id)) catch break :wrap; + lines = shown.rows(); + // Collapsed, one row, as acme's Tagup sets taglines to 1 + // (plan9port text.c:786). + wanted = if (pane.tag_expanded) lines else 1; + const cur = modal.offsetAt(whole, .{ .row = caret_row, .col = @intCast(@max(0, pane.tag.cur_col)) }); + caret_row = std.mem.count(u8, shown.text[0..@min(shown.fromReal(cur), shown.text.len)], "\n"); + } + if (!pane.tag_expanded) wanted = 1; + pane.tag_rows = @intCast(@min(wanted, MAX_TAG_ROWS, @max(BOX_H, r.h -| 1))); + if (pane.collapsed) pane.tag_rows = BOX_H; + if (pane.focus == .tag and pane.prompt != .name) { + const cur: usize = caret_row; + var top: usize = pane.tag_top; + if (cur < top) top = cur; + if (cur >= top + pane.tag_rows) top = cur + 1 - pane.tag_rows; + pane.tag_top = @intCast(@min(top, lines - pane.tag_rows)); + } else pane.tag_top = 0; + const cols = @max(1, r.w -| config.GUTTER); + // The tag steals the top rows. The pty is what the pane shows + // (layout keeps a terminal two body rows where the window has + // them): a taller pty would put its cursor below the pane. + const rows = @max(1, r.h -| pane.tag_rows); + // A terminal's pty follows its pane down to a row, whatever the + // resize; only a folded one keeps the size it had, and one not + // placed yet the grid it was made with. + if ((cols != pane.cols or rows != pane.rows) and (r.h > pane.tag_rows or (pane.isTerminal() and !pane.collapsed and r.h > 0)) and + (!pane.isTerminal() or p.sizes(pane))) + { + // doc panes have no pty/emulator grid to reflow; just record + // the size so bodyText renders the right number of rows + if (pane.isTerminal()) { + pardes.panes.terminal.resizeGrid(pane, cols, rows); + p.shell_rows.markStale(pane); // reflow moved every row + p.emit(.{ .resize_pty = .{ .pane = @intCast(id), .cols = cols, .rows = rows } }); + pane.fs.winsize = null; + } + pane.cols = cols; + pane.rows = rows; + if (pane.file) |*file| file.syntax_dirty = true; + } + pane.pan = pardes.panes.terminal.panFor(p, pane, r); + // A directory pane's entries follow its width, as acme's + // columns do (Dir.fit). + if (pane.file) |file| if (file.listing != null and r.h > pane.tag_rows) pardes.panes.Dir.fit(p, pane, pane.cols); + pardes.panes.terminal.releasePendingCommandIfReady(p, id, pane); + // Which bands a pane shows is the step's, as its geometry is: + // what is drawn under them, and where a click lands, read it. + Messages.collectNotices(p, pane, r, id); + // The greeting `ls` of a new terminal in a directory is typed at + // its shell's FIRST prompt, or never: typed later it would land + // in whatever runs then, or in the middle of a line someone + // typed (panes.terminal.greeting). + if (pane.greet and pane.isTerminal() and p.resize_count > 0) switch (tape.value(.prompt, pardes.panes.terminal.greeting, .{pane})) { + .wait => {}, + .never => pane.greet = false, + .now => { + p.emit(.{ .resize_pty = .{ .pane = @intCast(id), .cols = pane.cols, .rows = pane.rows } }); + p.emitWrite(id, "ls\r"); + pane.greet = false; + }, + }; + } + // A header's caret kept in its view, as a pane's is: the step's, not + // the frame's (paintHeaders draws what this leaves). + tagline.revealHeader(p); +} + +/// The view typing goes into is the one its terminal is sized for +/// (`sizes`). +fn typedInto(p: *Pardes) void { + if (p.panes[p.active]) |pane| pane.sized_by = p.view; +} + +/// Whether the live view sizes terminal `pane`: a terminal shown at two +/// sizes takes the size of the view that typed into it last, and any +/// view's once that one is gone. The others show it at that size, a +/// shorter one passed down to its cursor (`Pane.pan`, terminal.panFor). +// ponytail: a panned view's pointer reports to a terminal's program and +// its kitty images are placed as the unpanned rows are. +fn sizes(p: *Pardes, pane: *Pane) bool { + if (pane.sized_by == p.view) return true; + if (views.isOpen(p, pane.sized_by)) return false; + pane.sized_by = p.view; + return true; +} + +pub fn theme(p: *const Pardes) *const Theme { + if (p.custom_theme) |*custom| return custom; + return &themes[p.settings.theme]; +} + +/// The colours of the chrome: the theme's, set as it changes. +pub fn chromeTheme(p: *const Pardes) *const ChromeTheme { + return &p.chrome; +} + +/// The theme's own chrome, not a fade's (`theme()`'s, worked out once +/// per theme: its contrast searches take pow calls, too many for a +/// grapheme or a row). +pub fn bodyChrome(p: *Pardes) *const ChromeTheme { + const th = p.theme(); + if (p.body_chrome) |*cached| if (std.meta.eql(cached.theme, th.*)) return &cached.chrome; + p.body_chrome = .{ .theme = th.*, .chrome = ChromeTheme.fromTheme(th) }; + return &p.body_chrome.?.chrome; +} + +/// When the core next needs a frame, on the `stepped_ns` timeline: a +/// frame from now while work goes on (places to find, a picture +/// decoding, a PDF page on a lane), the end of the wait while something +/// only waits (a message lingering, a look-hover delay), null when +/// nothing is due. Every deadline the core owns is in this one list, +/// which is what lets every shell sleep exactly as long as nothing +/// changes; what moves on the screen is the frontends' own. +pub fn nextWake(p: *const Pardes) ?u64 { + const next = p.stepped_ns + frame_ns; + // Held 9P writes go in when they pause: wake for it, never before + // the next frame (writes served before the shell's clock was first + // seen are stamped 0, which `advance` would count back from). + if (p.fs.batch.bytes.items.len > 0) return @max(next, p.fs.batch.last_ns + ctlfs.pane.batch_pause_ns); + // Places still to find resume on the next frame; a picture being + // decoded is looked for. + for (p.panes) |slot| if (slot) |pane| if (pane.places.busy(pane)) return next; + for (p.panes) |slot| if (slot) |pane| if (pane.image) |iv| if (iv.decoder != null) return next; + // A PDF page being rendered on a lane lands on the frame after it is done. + if (comptime pdf_enabled) for (p.panes) |slot| if (slot) |pane| if (pane.pdf) |st| if (pardes.panes.Pdf.rendering(st)) return next; + // A markdown text's tables still being read from the top (Tables.zig). + for (p.panes) |slot| if (slot) |pane| if (pane.file) |f| if (f.tables.busy()) return next; + if (pardes.panes.Query.busy(p)) return next; + // A typed Grep waiting out its pause. + const streaming = p.stream.wake(next); + if (streaming) |due| if (due <= next) return next; + var frames: ?u64 = null; + if (streaming) |due| frames = @max(1, (due -| p.stepped_ns + frame_ns - 1) / frame_ns); + if (p.look_hover_wait) |waiting| { + const delay = config.look_preview_delay_frames; + frames = @max(1, delay -| waiting.frames); + } + for (p.panes) |slot| if (slot) |pane| { + const wait = Messages.messageWake(p, pane) orelse continue; + frames = if (frames) |soonest| @min(soonest, wait) else wait; + }; + // Del's question goes up at the end of its delay: a frame then, and + // none after (stepped time has reached it). + for (p.panes) |slot| if (slot) |pane| if (pane.prompt == .del_side and pane.question_due_ns > p.stepped_ns) { + const wait = @max(1, (pane.question_due_ns - p.stepped_ns + frame_ns - 1) / frame_ns); + frames = if (frames) |soonest| @min(soonest, wait) else wait; + }; + // A paste's Enter waiting on its REPL goes at the end of its wait, + // a time on the clock: the frames from `stepped_ns` that reach it. + for (p.panes) |slot| if (slot) |pane| if (pane.repl_enter > 0) { + const wait = @max(1, (pane.repl_enter_due_ns -| p.stepped_ns + frame_ns - 1) / frame_ns); + frames = if (frames) |soonest| @min(soonest, wait) else wait; + }; + // A terminal's kitty animation, at its next frame. Only a time still + // ahead counts: a pane not drawn keeps the last one it was given, + // and a past one would wake every frame for nothing. + for (p.panes) |slot| if (slot) |pane| if (pardes.panes.terminal.animationDueMs(pane)) |due_ms| { + const due = due_ms *| std.time.ns_per_ms; + if (due > p.stepped_ns) { + const wait = @max(1, (due - p.stepped_ns + frame_ns - 1) / frame_ns); + frames = if (frames) |soonest| @min(soonest, wait) else wait; + } + }; + return if (frames) |n| p.stepped_ns + n * frame_ns else null; +} + +/// For shells that only need a yes or no: macOS, which keeps its own +/// frame bank. +pub fn animationActive(p: *const Pardes) bool { + return p.nextWake() != null; +} + +/// Bring core time up to `now_ns`, the shell's monotonic clock: one +/// `.tick` for every whole frame that has passed since it last stood +/// still, so a timing lasts as long on a 144 Hz display, over ssh or +/// after a slow frame as it does anywhere. A wait (a message lingering, +/// the look-hover delay) is jumped to its end in one step and drawn +/// once. Idle, time is not banked: the next wait starts from now. +pub fn advance(p: *Pardes, now_ns: u64) void { + const taped = tape.enter(p, .{ .advance = now_ns }); + defer tape.leave(p, taped); + // The first time a shell's clock is seen, core time starts there. + const started = p.clock_started; + p.clock_started = true; + p.now_ns = now_ns; + if (!started) p.stepped_ns = now_ns; + const frame = frame_ns; + var moving: u32 = 0; + // The session's ticks are the recording session's: a picture still + // decoding or a fade still moving asks for frames the way a message + // waiting to go does, and a replica that draws nothing has none. + while (tape.value(.wake, nextWake, .{p})) |due| { + if (due > now_ns) break; + // Only waiting until `due`: its counters move there at once. + const held = (due - p.stepped_ns) / frame; + if (held > 1) { + Messages.holdMessages(p, held - 1); + if (p.look_hover_wait) |*waiting| waiting.frames +|= @intCast(@min(held - 1, std.math.maxInt(u16))); + p.stepped_ns += (held - 1) * frame; + } + // Back from a stall, the moving frames it missed are not all + // run at once: the rest are stepped from now, at their pace. + if (moving == max_catch_up_frames) { + p.stepped_ns = now_ns; + return; + } + moving += 1; + p.stepped_ns += frame; + p.update(.tick); + // A stepped frame is a frame to draw. (A `.tick` does not ask + // for one itself: the last frame of a fade used never to be + // drawn.) + p.needs_frame = true; + } else { + p.stepped_ns = now_ns; + return; + } + // A 60 Hz display frame is 16.67 ms and ours 16: without this, every + // 24th display frame would take two steps, a hitch in every fade. + // An overshoot this small is let go; a larger one (144 Hz lands 4.8 + // ms past) is kept, so the average rate stays right. + if (moving > 0 and now_ns - p.stepped_ns < vsync_slack_ns) p.stepped_ns = now_ns; +} + +pub const vsync_slack_ns = 1500 * std.time.ns_per_us; +pub const max_catch_up_frames = 240; + +pub fn noteHaptic(p: *Pardes, pulse: Haptic) void { + if (comptime platform != .macos) return; + if (p.haptic == .look) return; + p.haptic = pulse; +} + +/// Take the armed pulse and disarm. The shell calls this once per pump, +/// after the tick that may have set it. +pub fn takeHaptic(p: *Pardes) Haptic { + if (comptime platform != .macos) return .none; + defer p.haptic = .none; + return p.haptic; +} + +pub const render = draw.render; + +pub fn appendImagePlace(p: *Pardes, place: ImagePlace) bool { + p.surface.images.append(p.gpa, place) catch return false; + return true; +} + +pub const PendingWrite = struct { bytes: []u8, off: usize = 0 }; + +/// The session layouts `init` can put on screen. One name each, so choosing +/// between them reads as a choice instead of a chain of ifs over four options. +pub const Boot = enum { + /// the document named on the command line, or the pane explaining why not + document, + /// a Look that found nothing: reported, not opened + missing, + /// `pardes -`: stdin's text in a +Pager pane, as `vim -` shows it + stdin, + /// the bare tty startup: one shell in raw tty mode, with an empty text + /// pane under it so the editor half is there before you want it + tty, + /// that raw shell by itself, which is all a core booted for a test wants + tty_shell, + /// acme's boot: two columns, the left one split in two + classic, + /// one greeted shell + shell, + + pub fn of(opts: Options) Boot { + if (opts.boot) |named| return named; + if (opts.file != null) return .document; + if (opts.missing != null) return .missing; + if (opts.stdin_text != null) return .stdin; + if (opts.tty_only) return .tty_shell; + // ponytail: 1 and 3 are the only shell counts anyone asked for + return if (opts.shells >= 3) .classic else .shell; + } +}; + +pub const Options = struct { + tty_only: bool = false, + /// The first view's frontend is a window (`Pardes.windowed`), as a + /// window's build says: an option, taped with the rest, so that a + /// window's build replaying a terminal's session starts as it did. + windowed: bool = platform == .gui, + /// The layout to boot, when a host means one outright rather than leaving + /// it to be read off the options below. `--tty` names `.tty`; a core + /// booted for a test names nothing and gets `.tty_shell`. + boot: ?Boot = null, + /// initial shell panes: 1 (default) or 3 for the classic two-column boot. + /// A `file` outranks this — see there. + shells: u8 = 1, + file: ?[]const u8 = null, + file_line: usize = 0, + missing: ?struct { word: []const u8, dir: []const u8 } = null, + /// `pardes -`: stdin as it came, for a +Pager pane at boot (pager.zig + /// parses it). + stdin_text: ?[]const u8 = null, + tty_toggle: u21 = config.tty_toggle_default, + /// load a dump of another instance instead of spawning shells (acme -l) + load_path: ?[]const u8 = null, + /// `--geometry=WxH[+X+Y]`: a pixel shell's window size, and where it + /// goes when the display lets it say (a pane carried out of another + /// window opens one as big as that, Handover.zig). + geometry: ?[]const u8 = null, + nested: bool = false, + startup_config: ?[]const u8 = null, + ninep_name: []const u8 = "", + ninep_tcp: ?[]const u8 = null, + mounts: []const filesystem.Mount = &.{}, + config_dir: ?[]const u8 = null, + /// Where what outlives the session is kept (Db.zig): the user's state + /// file, set by a host that has one; none, Recent lasts as long as the + /// session; memory, the test host's. + state: Db.Kind = .off, + /// Where Recent's files were before the state file (0.24's `recent`, the + /// `store` before it): a state file that holds no Recent yet reads them + /// once (Db.zig). Set by a host that had them. + recent_import: ?[]const u8 = null, + startup_config_path: ?[]const u8 = null, + image_allocator: ?std.mem.Allocator = null, + pdf_allocator: ?std.mem.Allocator = null, + tree_sitter_allocator: ?std.mem.Allocator = null, + /// Where each frame's Surface text is built. Hosts pass a purpose-built + /// stack-fallback arena; null means the general allocator. + frame_allocator: ?std.mem.Allocator = null, + cols: u16 = 80, + rows: u16 = 24, +}; + +pub const Haptic = enum { none, exec, look }; + +/// Zero-sized off macOS, the way PdfSlot is off -Dmupdf: no other shell reads +/// the field, so no other shell carries it. +const HapticSlot = if (platform == .macos) Haptic else void; + +pub const RetiredPanes = struct { + current: [2 * MAX_PANES]?*Pane = @splat(null), + previous: [2 * MAX_PANES]?*Pane = @splat(null), + + pub fn retire(a: *RetiredPanes, pane: *Pane) void { + for (&a.current) |*slot| if (slot.* == null) { + slot.* = pane; + return; + }; + // One update runs one builtin, and the widest drop is a whole column; + // 2*MAX_PANES cannot fill in a single frame. + unreachable; + } +}; + +const FakeTtyQuery = struct { + taken: [MAX_PANES]bool = @splat(false), + asked: usize = 0, + + const vtable: Host.VTable = .{ .tty_taken = answer }; + + fn install(f: *FakeTtyQuery, p: *Pardes) void { + p.host = .{ .ctx = f, .vtable = &vtable }; + } + + fn answer(ctx: ?*anyopaque, pane: u8) bool { + const f: *FakeTtyQuery = @ptrCast(@alignCast(ctx.?)); + f.asked += 1; + return f.taken[pane]; + } +}; + +fn bootAndTearDown(gpa: std.mem.Allocator) !void { + const p = try Pardes.init(gpa, .{ .cols = 56, .rows = 14, .tty_only = true, .frame_allocator = gpa, .image_allocator = gpa, .pdf_allocator = gpa, .tree_sitter_allocator = gpa }); + p.deinit(); +} + +test "startup config runs builtin lines in order and isolates bad lines" { + const p = try Pardes.init(std.testing.allocator, .{ + .startup_config = + \\Theme dark + \\DefinitelyNotABuiltin + \\Exit trailing-garbage + \\Theme no-such-theme + \\Theme acme + , + }); + defer p.deinit(); + + try std.testing.expectEqualStrings("acme", p.theme().name); + // The theme lands without a tween (the chrome is the theme's at once); + // the bad lines are said, so a notice may be up. + try std.testing.expectEqual(ChromeTheme.fromTheme(p.theme()), p.chromeTheme().*); + try std.testing.expect(!p.quit); + for (0..p.effects_len) |i| switch (p.effects[(p.effects_head + i) % p.effects.len]) { + .write => |w| { + try std.testing.expect(std.mem.indexOf(u8, w.bytes.slice(), "DefinitelyNotABuiltin") == null); + try std.testing.expect(std.mem.indexOf(u8, w.bytes.slice(), "Exit") == null); + }, + else => {}, + }; +} + +test "topbar hover highlights exactly the executable word" { + const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 40, .rows = 12 }); + defer p.deinit(); + var frame = std.heap.ArenaAllocator.init(std.testing.allocator); + defer frame.deinit(); + + _ = try p.render(frame.allocator()); + p.update(.{ .mouse = .{ .button = .none, .kind = .motion, .col = TAG_TEXT_INSET + 1, .row = 0 } }); + _ = frame.reset(.retain_capacity); + const hovered = try p.render(frame.allocator()); + for (0.."Newcol".len) |col| { + const cell = hovered.at(TAG_TEXT_INSET + @as(u16, @intCast(col)), 0); + try std.testing.expectEqual(Color{ .rgb = p.theme().sel_bg }, cell.style.bg); + try std.testing.expectEqual(Color{ .rgb = p.theme().sel_fg }, cell.style.fg); + } + try std.testing.expectEqual(Color{ .rgb = p.chromeTheme().tag_bg }, hovered.at(TAG_TEXT_INSET + 6, 0).style.bg); + + p.update(.{ .mouse = .{ .button = .none, .kind = .motion, .col = TAG_TEXT_INSET + 6, .row = 0 } }); + _ = frame.reset(.retain_capacity); + const whitespace = try p.render(frame.allocator()); + try std.testing.expectEqual(Color{ .rgb = p.chromeTheme().tag_bg }, whitespace.at(TAG_TEXT_INSET + 1, 0).style.bg); + + p.update(.pointer_leave); + _ = frame.reset(.retain_capacity); + const left = try p.render(frame.allocator()); + try std.testing.expectEqual(Color{ .rgb = p.chromeTheme().tag_bg }, left.at(TAG_TEXT_INSET + 1, 0).style.bg); +} + +test "pane-tag Exec prefers Term and argument builtins before shell fallback" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .cols = 100, .rows = 30 }); + defer p.deinit(); + while (p.nextEffect()) |_| {} // initial shell spawn/geometry + p.acknowledgeShell(0, "/bin/sh", false); + + // The Term word names the shell the host ran, and opens another of it. + const pane = p.panes[0].?; + try std.testing.expectEqualStrings(" Term+sh" ++ tagline.terminal_pane_tail[" Term".len..], tagline.curTail(pane)); + const tag_x = p.rects[0].x + TAG_TEXT_INSET; + const tag_y = p.rects[0].y; + + const rendered = try tagline.tagText(p, p.scratch.allocator(), pane); + const new_x = tag_x + @as(u16, @intCast(std.mem.indexOf(u8, rendered, "Term").?)) + 1; + var panes_before: usize = 0; + for (p.panes) |s| if (s != null) { + panes_before += 1; + }; + p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .press, .col = new_x, .row = tag_y } }); + p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .release, .col = new_x, .row = tag_y } }); + while (p.nextEffect()) |effect| switch (effect) { + .write => return error.NewFellThroughToPty, + else => {}, + }; + var panes_after: usize = 0; + for (p.panes) |s| if (s != null) { + panes_after += 1; + }; + try std.testing.expectEqual(panes_before + 1, panes_after); + try std.testing.expect(p.panes[p.active].?.isTerminal()); + try std.testing.expectEqualStrings("sh", p.panes[p.active].?.shell.?); + + // Argument-taking builtins use the same gesture path: a tag sweep is the + // complete command line, and Theme consumes its tail without a PTY write. + if (pane.tag.own) |own| p.gpa.free(own); + pane.tag.own = try p.gpa.dupe(u8, " Theme dark"); + p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .press, .col = tag_x + 1, .row = tag_y } }); + p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .drag, .col = tag_x + 10, .row = tag_y } }); + p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .release, .col = tag_x + 10, .row = tag_y } }); + try std.testing.expectEqualStrings("dark", p.theme().name); + while (p.nextEffect()) |effect| switch (effect) { + .write => return error.ArgumentBuiltinFellThroughToPty, + else => {}, + }; + + // Fixed-name builtins remain exact: a tail does not turn New or Exit into + // a match (especially important for the destructive one). + try std.testing.expect(!p.executeBuiltinLine(0, "New argument")); + try std.testing.expect(!p.executeBuiltinLine(0, "Exit trailing-garbage")); + try std.testing.expect(!p.quit); + + // A word absent from the builtin vocabulary takes the fallback, including + // the terminating carriage return expected by the shell prompt. + if (pane.tag.own) |own| p.gpa.free(own); + pane.tag.own = try p.gpa.dupe(u8, " DefinitelyNotABuiltin"); + p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .press, .col = tag_x + 1, .row = tag_y } }); + p.update(.{ .mouse = .{ .button = config.exec_button, .kind = .release, .col = tag_x + 1, .row = tag_y } }); + var sent: [256]u8 = undefined; + var sent_len: usize = 0; + while (p.nextEffect()) |effect| switch (effect) { + .write => |w| { + try std.testing.expectEqual(@as(u8, 0), w.pane); + try std.testing.expect(w.bytes.slice().len <= sent.len - sent_len); + @memcpy(sent[sent_len..][0..w.bytes.slice().len], w.bytes.slice()); + sent_len += w.bytes.slice().len; + }, + else => {}, + }; + try std.testing.expectEqualStrings("DefinitelyNotABuiltin\r", sent[0..sent_len]); +} + +test "LocationsConfig command reports partial updates and survives restore" { + const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); + defer p.deinit(); + _ = try p.setTestFile("source\n"); + try std.testing.expect(p.executeBuiltinLine(0, "LocationsConfig context:5 tscontext:on")); + try std.testing.expect(p.executeBuiltinLine(0, "LocationsConfig tslocations:off")); + const expected: locations.Config = .{ .context = 5, .tscontext = true, .tslocations = false }; + try std.testing.expectEqual(expected, p.locations_config); + try std.testing.expect(p.executeBuiltinLine(0, "LocationsConfig context:2 unknown:on")); + try std.testing.expectEqual(expected, p.locations_config); + // Setting it is silent; asking bare is what opens the window. + try std.testing.expect(p.executeBuiltinLine(0, "LocationsConfig")); + var reports: usize = 0; + for (p.panes) |slot| { + const pane = slot orelse continue; + const file = pane.file orelse continue; + const out = file.output orelse continue; + if (!std.meta.eql(out.from, pardes.panes.Output.Origin{ .cmd = .LocationsConfig })) continue; + reports += 1; + try std.testing.expectEqualStrings("LocationsConfig context:5 tscontext:on tslocations:off layout:stacked\n", file.content); + } + try std.testing.expectEqual(@as(usize, 1), reports); + try dump.dumpState(p); + const restored = try dump.initFromDump(p.gpa, .{ .tty_only = true }, p.dump_out.?); + defer restored.deinit(); + try std.testing.expectEqual(expected, restored.locations_config); +} + +test "TreeContext tag style preserves message rows and its opt-out survives restore" { + if (comptime !syntax.enabled) return error.SkipZigTest; + const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 60, .rows = 16 }); + defer p.deinit(); + const pane = try p.setTestFile("pub const Box = struct {\n pub fn run() void {\n" ++ (std.mem.asBytes(&@as([30][16]u8, @splat(" // body\n".*)))) ++ " }\n};\n"); + p.gpa.free(pane.file.?.path); + pane.file.?.path = try p.gpa.dupe(u8, "/test.zig"); + if (!pardes.panes.File.supportsContext(pane)) return error.SkipZigTest; + p.update(.{ .resize = .{ .cols = 60, .rows = 16, .row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 6, .tagline_h = 12 } } }); + pane.file.?.tree_context = true; + pane.file.?.scroll = 8; + pane.msg_len = 0; + p.sync(); + _ = try p.render(p.scratch.allocator()); + try std.testing.expect(p.settings.tree_context_tag_style); + const full_height = p.surface.body_layers[0].viewport.h; + try std.testing.expect(p.surface.body_layers[0].rows > full_height); + try std.testing.expectEqual(FontRole.tagline, p.surface.body_layers[0].cells[0].style.font_role); + pane.msg[0] = '!'; + pane.msg_len = 1; + p.sync(); + _ = try p.render(p.scratch.allocator()); + // An overlay takes nothing: the message is a chip OVER the body's first + // row, so the viewport keeps every row it had. + try std.testing.expectEqual(full_height, p.surface.body_layers[0].viewport.h); + const r = p.rects[0]; + const band = for (p.surface.tagLayers()) |*layer| { + if (layer.rows != 0 and layer.kind == .notice) break layer; + } else return error.NoNoticeBand; + try std.testing.expectEqual(p.bodyTop(pane, r), band.viewport.y); + try std.testing.expectEqual(p.surface.body_layers[0].viewport.y, band.viewport.y); + // Sized to its message, flush with the pane's right edge, and the text + // right aligned a cell short of that edge. + try std.testing.expectEqual(r.x + r.w, band.viewport.x + band.viewport.w); + try std.testing.expect(band.viewport.w < r.w - config.GUTTER); + try std.testing.expectEqualStrings("!", band.cells[layout.tagCapacity(p, band.viewport.w) - 2].grapheme()); + pane.msg_len = 0; + p.leader_on = true; + p.sync(); + _ = try p.render(p.scratch.allocator()); + try std.testing.expectEqual(full_height, p.surface.body_layers[0].viewport.h); + p.leader_on = false; + try std.testing.expect(p.executeBuiltinLine(0, "TreeContextTagStyle")); + p.sync(); + _ = try p.render(p.scratch.allocator()); + try std.testing.expectEqual(@as(u16, 0), p.surface.body_layers[0].rows); + try std.testing.expectEqual(@as(u16, 0), pane.body_rows); + try std.testing.expectEqual(FontRole.body, p.surface.at(r.x + config.GUTTER, p.bodyTop(pane, r)).style.font_role); + try dump.dumpState(p); + const restored = try dump.initFromDump(p.gpa, .{ .tty_only = true }, p.dump_out.?); + defer restored.deinit(); + try std.testing.expect(!restored.settings.tree_context_tag_style); +} + +test "TreeContext command and custom tag survive a workspace round trip" { + if (comptime !syntax.enabled) return error.SkipZigTest; + const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); + defer p.deinit(); + const pane = try p.setTestFile("pub fn main() void {}\n"); + try std.testing.expect(!pardes.panes.File.supportsContext(pane)); + try std.testing.expectEqualStrings(tagline.file_pane_tail, tagline.curTail(pane)); + const path = try p.gpa.dupe(u8, "/test.zig"); + p.gpa.free(pane.file.?.path); + pane.file.?.path = path; + if (!pardes.panes.File.supportsContext(pane)) return error.SkipZigTest; + try std.testing.expectEqualStrings(if (lsp.speaks("/test.zig")) tagline.lsp_context_pane_tail else tagline.context_pane_tail, tagline.curTail(pane)); + try std.testing.expect(!pane.file.?.tree_context); + try std.testing.expect(p.executeBuiltinLine(0, "TreeContext on")); + try std.testing.expect(pane.file.?.tree_context); + try std.testing.expect(p.executeBuiltinLine(0, "TreeContext off")); + try std.testing.expect(!pane.file.?.tree_context); + try std.testing.expect(p.executeBuiltinLine(0, "TreeContext")); + try std.testing.expect(pane.file.?.tree_context); + try std.testing.expect(p.executeBuiltinLine(0, "TreeContext invalid")); + try std.testing.expect(pane.file.?.tree_context); + if (pane.tag.own) |own| p.gpa.free(own); + pane.tag.own = try p.gpa.dupe(u8, " Save Keep Del"); + try dump.dumpState(p); + const restored = try dump.initFromDump(p.gpa, .{ .tty_only = true }, p.dump_out.?); + defer restored.deinit(); + const saved = restored.panes[0].?; + try std.testing.expect(saved.file.?.tree_context); + try std.testing.expectEqualStrings(" Save Keep Del", tagline.curTail(saved)); +} + +test "Filter is ordered after Del and toggles only its terminal or +Pager pane" { + const testing = std.testing; + const del = std.meta.stringToEnum(Builtin, "Del") orelse return error.MissingDelBuiltin; + const filter = std.meta.stringToEnum(Builtin, "Filter") orelse return error.MissingFilterBuiltin; + try testing.expectEqual(@backingInt(del) + 1, @backingInt(filter)); + + const p = try Pardes.init(testing.allocator, .{ .tty_only = true }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + const first = p.panes[0].?; + const palette_before = first.terminal.?.vt.colorForXterm(.{ .palette = 1 }).?; + + try testing.expect(first.tty_filter); + try testing.expect(p.executeBuiltinLine(0, "Filter")); + try testing.expect(!first.tty_filter); + try testing.expect(palette_before.eql(first.terminal.?.vt.colorForXterm(.{ .palette = 1 }).?)); + + const second_id = p.freeSlot().?; + const second = try p.newShell(second_id, ""); + try testing.expect(second.tty_filter); + try testing.expect(p.executeBuiltinLine(second_id, "Filter")); + try testing.expect(!second.tty_filter); + try testing.expect(!first.tty_filter); + + const doc_id = p.freeSlot().?; + const doc = try pardes.panes.Image.create(p, doc_id, "/tmp/filter-inert.ppm", &.{}); + try testing.expect(!doc.tty_filter); + try testing.expect(p.executeBuiltinLine(doc_id, "Filter")); + try testing.expect(!doc.tty_filter); + try testing.expect(!first.tty_filter); + + try testing.expect(p.executeBuiltinLine(0, "Filter")); + try testing.expect(first.tty_filter); + try testing.expect(!second.tty_filter); + + // A +Pager opens filtered, with Filter on its tag and no line numbers; + // a second is a pane of its own. + const pager_id = try pardes.panes.Output.openPager(p, 0, "/tmp"); + const pager_pane = p.panes[pager_id].?; + try testing.expect(pager_pane.tty_filter); + try testing.expectEqualStrings(tagline.pager_pane_tail, tagline.curTail(pager_pane)); + try testing.expectEqual(@as(u16, 0), pardes.panes.File.gutterWidth(pager_pane)); + try testing.expect(p.executeBuiltinLine(pager_id, "Filter")); + try testing.expect(!pager_pane.tty_filter); + try testing.expect(try pardes.panes.Output.openPager(p, 0, "/tmp") != pager_id); +} + +test "compact tag commands stay beside their own prefix across layout changes" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .cols = 100, .rows = 30 }); + defer p.deinit(); + while (p.nextEffect()) |_| {} // initial shell spawn/geometry + + // A longer sibling never introduces invisible padding into this tag. + const below_id = p.freeSlot().?; + const below = try p.newShell(below_id, ""); + const f = layout.findPane(p, p.active).?; + layout.insert(p, f.col, f.idx + 1, below_id); + layout.splitBelow(p, p.active, below); + p.setCwd(below_id, "/a/deep/dir/whose/name/eats/the/right/pad/the/end/of/its/own/tagline"); + p.sync(); + while (p.nextEffect()) |_| {} + + const above = p.panes[0].?; + try std.testing.expectEqual(p.rects[0].x, p.rects[below_id].x); + const above_tag = try tagline.tagText(p, gpa, above); + defer gpa.free(above_tag); + const below_tag = try tagline.tagText(p, p.scratch.allocator(), below); + try std.testing.expect(below_tag.len > above_tag.len); + const tail = tagline.terminal_pane_tail; + try std.testing.expectEqualStrings(tail, above_tag[above_tag.len - tail.len ..]); + try std.testing.expectEqual(above.cwdSlice().len + tail.len, above_tag.len); + + p.update(.{ .resize = .{ .cols = 88, .rows = 30 } }); + while (p.nextEffect()) |_| {} + try std.testing.expectEqualStrings(above_tag, try tagline.tagText(p, p.scratch.allocator(), above)); + p.update(.{ .resize = .{ .cols = 87, .rows = 30 } }); + while (p.nextEffect()) |_| {} + try std.testing.expectEqualStrings(above_tag, try tagline.tagText(p, p.scratch.allocator(), above)); + p.update(.{ .resize = .{ .cols = 100, .rows = 30 } }); + while (p.nextEffect()) |_| {} + try std.testing.expectEqualStrings(tail, tagline.curTail(below)); + try below.appendTag(" lots and lots of typing out here"); + try std.testing.expectEqual(above_tag.len, (try tagline.tagText(p, p.scratch.allocator(), above)).len); + + p.update(.{ .resize = .{ .cols = 100, .rows = 2 } }); + while (p.nextEffect()) |_| {} + try std.testing.expectEqual(@as(u16, 0), p.rects[below_id].h); + try std.testing.expectEqualStrings(above_tag, try tagline.tagText(p, p.scratch.allocator(), above)); +} + +test "Term spawns a raw shell in the caller's directory" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 100, .rows = 30 }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + p.setCwd(0, "/tmp/newtty-dir"); + + try std.testing.expect(p.executeBuiltinLine(0, "Term")); + const free = p.active; + try std.testing.expect(free != 0); + const nt = p.panes[free] orelse return error.NoNewPane; + try std.testing.expect(nt.isTerminal()); + try std.testing.expect(nt.body.mode == .tty); + + var found = false; + while (p.nextEffect()) |effect| switch (effect) { + .spawn => |s| if (@as(usize, s.pane) == free) { + try std.testing.expectEqualStrings("/tmp/newtty-dir", s.cwd.slice()); + found = true; + }, + else => {}, + }; + try std.testing.expect(found); +} + +test "a terminal respawned into a closed pane's slot hangs the old shell up first" { + // Hosts keep a shell per slot: were the spawn first, the close would + // end the new shell and leave the old one running. + const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 30 }); + defer p.deinit(); + try std.testing.expect(p.executeBuiltinLine(0, "Term")); + const slot = p.active; + while (p.nextEffect()) |_| {} + try p.removePane(slot, null); + try std.testing.expect(p.executeBuiltinLine(0, "Term")); + try std.testing.expectEqual(slot, p.active); + var closed = false; + var spawned = false; + while (p.nextEffect()) |effect| switch (effect) { + .close_pty => |c| if (c.pane == slot) { + try std.testing.expect(!spawned); + closed = true; + }, + .spawn => |s| if (s.pane == slot) { + spawned = true; + }, + else => {}, + }; + try std.testing.expect(closed and spawned); +} + +test "a frame no one watches is not drawn, and is drawn once someone does" { + const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + const Watch = struct { + var presents: usize = 0; + var seen = false; + const vtable: Host.VTable = .{ .present = present, .watched = watched }; + fn present(_: ?*anyopaque, _: *const Surface) void { + presents += 1; + } + fn watched(_: ?*anyopaque) bool { + return seen; + } + }; + Watch.presents = 0; + Watch.seen = false; + p.needs_frame = true; + try p.pump(.{ .vtable = &Watch.vtable }); + try std.testing.expectEqual(@as(usize, 0), Watch.presents); + try std.testing.expect(p.needs_frame); // still owed + Watch.seen = true; + try p.pump(.{ .vtable = &Watch.vtable }); + try std.testing.expectEqual(@as(usize, 1), Watch.presents); +} + +test "an empty column shows its theme's empty_col under its tag: acme's white, else the border" { + const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 120, .rows = 20 }); + defer p.deinit(); + layout.newColumn(p, 0); + tagline.exitHeader(p); + inline for (.{ "acme", "dark" }) |name| { + try std.testing.expect(p.executeBuiltinLine(0, "Theme " ++ name)); + p.sync(); + var arena: std.heap.ArenaAllocator = .init(std.testing.allocator); + defer arena.deinit(); + const s = try p.render(arena.allocator()); + const cell = s.at(p.col_x[1] + 3, p.screen_h - 2); + const want = p.chromeTheme().empty_col; + try std.testing.expectEqual(want, cell.style.bg.rgb); + if (std.mem.eql(u8, name, "acme")) try std.testing.expectEqual([3]u8{ 0xff, 0xff, 0xff }, want) else try std.testing.expectEqual(p.chromeTheme().border, want); + } +} + +test "unknown Exec from a document runs as a command pane in its directory, typed into no terminal" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{}); + defer p.deinit(); + while (p.nextEffect()) |_| {} + p.acknowledgeShell(0, "/bin/sh", false); + + // A terminal free at a prompt in the same directory is not borrowed. + p.setCwd(0, "/tmp/pardes-image-dir"); + const image_doc = try p.newDocPane(1); + image_doc.image = .{ .path = try gpa.dupe(u8, "/tmp/pardes-image-dir/pic.ppm") }; + try std.testing.expectEqualStrings("/tmp/pardes-image-dir", Pardes.paneDir(image_doc)); + const dst = exec.execute(p, 1, "echo image-fallback") orelse return error.ExecFoundNowhereToRun; + try std.testing.expect(dst != 0 and dst != 1); + try std.testing.expectEqualStrings("echo image-fallback", p.panes[dst].?.command.?); + + var spawned = false; + while (p.nextEffect()) |effect| switch (effect) { + .write => return error.TypedIntoATerminal, + .spawn => |sp| if (sp.pane == dst) { + try std.testing.expectEqualStrings("/tmp/pardes-image-dir", sp.cwd.slice()); + spawned = true; + }, + else => {}, + }; + try std.testing.expect(spawned); +} + +test "Exec in a terminal whose tty is taken runs as a command pane instead of typing at the program" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{}); + defer p.deinit(); + while (p.nextEffect()) |_| {} + + p.setCwd(0, "/tmp/pardes-taken"); + // vim, a pager, an agent: the host answers that this pane's tty is no + // longer the prompt pardes forked + var host: FakeTtyQuery = .{}; + host.install(p); + host.taken[0] = true; + const dst = exec.execute(p, 0, "echo taken-fallback") orelse return error.ExecFoundNowhereToRun; + // somewhere ELSE -- and still without moving focus, which is execute's + // contract and the whole difference between it and a look + try std.testing.expect(dst != 0); + try std.testing.expectEqual(@as(usize, 0), p.active); + try std.testing.expectEqualStrings("echo taken-fallback", p.panes[dst].?.command.?); + var spawned = false; + while (p.nextEffect()) |effect| switch (effect) { + .write => return error.WroteACommandLineIntoATerminal, + .spawn => |sp| if (sp.pane == dst) { + // ...in the directory the command was about, the taken pane's own + try std.testing.expectEqualStrings("/tmp/pardes-taken", sp.cwd.slice()); + spawned = true; + }, + else => {}, + }; + try std.testing.expect(spawned); +} + +test "a command of several lines keeps its tag one row, and its echo does not staircase" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 100, .rows = 30 }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + const doc = try p.newDocPane(1); + doc.image = .{ .path = try gpa.dupe(u8, "/tmp/pic.ppm") }; + const two = "def greet(name):\n return name\n\nprint(greet(\"x\"))\n"; + const dst = exec.execute(p, 1, two) orelse return error.NoCommandPane; + while (p.nextEffect()) |_| {} + const pane = p.panes[dst].?; + const prefix = try tagline.tagPrefix(p, pane); + try std.testing.expect(std.mem.indexOfScalar(u8, prefix, '\n') == null); + try std.testing.expect(std.mem.indexOf(u8, prefix, "(def greet(name):...) running") != null); + // Rendered without a panic, however the tag wraps. + var frame = std.heap.ArenaAllocator.init(gpa); + defer frame.deinit(); + _ = try p.render(frame.allocator()); + p.update(.{ .exited = .{ .pane = @intCast(dst), .status = 0 } }); + _ = exec.execute(p, 1, two); + while (p.nextEffect()) |_| {} + _ = try p.render(frame.allocator()); + const body = try pardes.panes.terminal.screenTextAlloc(pane, gpa); + defer gpa.free(body); + try std.testing.expect(std.mem.indexOf(u8, body, "% def greet(name):\n return name") != null); +} + +test "a spawn is for the pane it was made for, not whatever took the slot since" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + const Count = struct { + var spawns: usize = 0; + var command: [32]u8 = undefined; + var core: *Pardes = undefined; + const vtable: Host.VTable = .{ .spawn = spawn }; + fn spawn(_: ?*anyopaque, pane: u8, _: []const u8) void { + spawns += 1; + const line = core.panes[pane].?.command.?; + @memcpy(command[0..line.len], line); + } + }; + Count.core = p; + p.host = .{ .vtable = &Count.vtable }; + // A command pane closed and its slot taken, in one step, before the + // effects run: only the second's spawn is performed. + const slot = p.freeSlot().?; + _ = try pardes.panes.newCommand(p, slot, "", "first"); + try p.removePane(slot, null); + try std.testing.expectEqual(slot, p.freeSlot().?); + _ = try pardes.panes.newCommand(p, slot, "", "second"); + while (p.nextEffect()) |effect| p.perform(effect); + try std.testing.expectEqual(@as(usize, 1), Count.spawns); + try std.testing.expectEqualStrings("second", Count.command[0.."second".len]); +} + +test "a REPL bound for a language takes the exec made on a body in it; tags, Exec by name and command words still run" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .shells = 3, .cols = 100, .rows = 30 }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + const file = try p.setTestFile("print(1)\nls\n"); + gpa.free(file.file.?.path); + file.file.?.path = try gpa.dupe(u8, "/x.py"); + const Sent = struct { + var to: [MAX_PANES][128]u8 = undefined; + var len: [MAX_PANES]usize = @splat(0); + var spawned: bool = false; + fn drain(pp: *Pardes) void { + len = @splat(0); + spawned = false; + while (pp.nextEffect()) |effect| switch (effect) { + .write => |w| { + @memcpy(to[w.pane][len[w.pane]..][0..w.bytes.slice().len], w.bytes.slice()); + len[w.pane] += w.bytes.slice().len; + }, + .spawn => spawned = true, + else => {}, + }; + } + fn said(pane: usize) []const u8 { + return to[pane][0..len[pane]]; + } + }; + // The programs the REPLs run hold their terminals' ttys. + var host: FakeTtyQuery = .{}; + host.install(p); + host.taken[1] = true; + host.taken[2] = true; + // Only a terminal is a REPL; a language's name is the syntax table's. + try std.testing.expect(p.executeBuiltinLine(0, "Repl python")); + try std.testing.expect(file.repl == null); + try std.testing.expect(p.executeBuiltinLine(1, "Repl pithon")); + try std.testing.expect(p.panes[1].?.repl == null); + try std.testing.expect(std.mem.indexOf(u8, p.panes[1].?.msg[0..p.panes[1].?.msg_len], "python") != null); + try std.testing.expect(p.executeBuiltinLine(1, "Repl python")); + // again, as a code fence may name it: no change + try std.testing.expect(p.executeBuiltinLine(1, "Repl PY")); + var idbuf: [48]u8 = undefined; + try std.testing.expectEqualStrings("python-a", exec.replId(&idbuf, p.panes[1].?)); + try std.testing.expect(std.mem.endsWith(u8, try tagline.tagPrefix(p, p.panes[1].?), " python-a")); + Sent.drain(p); + + // A click on the file's body, a single word: typed into the REPL. + try std.testing.expectEqual(@as(?usize, 1), exec.executeFrom(p, 0, "ls", true)); + Sent.drain(p); + try std.testing.expectEqualStrings("ls\r", Sent.said(1)); + try std.testing.expect(!Sent.spawned); + try std.testing.expect(file.msg_sent); + try std.testing.expectEqualStrings("\u{2192} python-a", file.msg[0..file.msg_len]); + // A body's click written back to event is done as the click: sent. A + // line written to exec came back as F and runs as the command it was. + { + const th = @import("ninep/testing.zig"); + const event = ctlfs.Node.of(file.serial, .event); + const h = th.call(p, .{ .tag = 1, .op = .open, .node = event }).reply.handle; + defer _ = th.call(p, .{ .tag = 2, .op = .release, .node = event, .handle = h }); + // The 9P harness performs the effects: what it wrote is its answer's. + const sent = th.wr(p, event, "MX0 8\n"); + try std.testing.expectEqualStrings("print(1)\r", sent.pty_buf[0..sent.pty_len]); + const ran = th.wr(p, event, "FX0 0 2 2 ls\n"); + try std.testing.expect(ran.pty_len == 0 and ran.spawned); + // The pane's ctl line ends with the id it is bound as. + var line: [ctlfs.ctl.pane_text_cap]u8 = undefined; + try std.testing.expect(std.mem.indexOf(u8, ctlfs.ctl.paneText(p, p.panes[1].?, &line), " python-a ") != null); + } + // What is sent is plain text: CRLF is LF, no ESC or other control. + _ = exec.executeFrom(p, 0, "a = 1\r\nb = \x1b[201~2", true); + Sent.drain(p); + try std.testing.expectEqualStrings("a = 1\rb = [201~2\r", Sent.said(1)); + // Into a REPL that takes a bracketed paste (3.13's), the Enter waits + // for the REPL to answer the paste: read with it, it would be part of it. + p.update(.{ .output = .{ .pane = 1, .bytes = "\x1b[?2004h" } }); + Sent.drain(p); + _ = exec.executeFrom(p, 0, "print(1)", true); + Sent.drain(p); + try std.testing.expectEqualStrings("\x1b[200~print(1)\x1b[201~", Sent.said(1)); + p.update(.{ .output = .{ .pane = 1, .bytes = "print(1)" } }); + Sent.drain(p); + // Python's echo only restarts a short wait: the Enter goes once the + // echo of the whole paste has gone quiet. + try std.testing.expectEqualStrings("", Sent.said(1)); + p.now_ns = p.panes[1].?.repl_enter_due_ns; + p.update(.tick); + Sent.drain(p); + try std.testing.expectEqualStrings("\r", Sent.said(1)); + // A paste of more than one line gets the blank line a block gets. + _ = exec.executeFrom(p, 0, "print(11)\nprint(22)", true); + Sent.drain(p); + try std.testing.expectEqualStrings("\x1b[200~print(11)\nprint(22)\x1b[201~", Sent.said(1)); + p.now_ns = p.panes[1].?.repl_enter_due_ns; + p.update(.tick); + Sent.drain(p); + try std.testing.expectEqualStrings("\r\r", Sent.said(1)); + // Nothing answering, it goes when its wait is up. + _ = exec.executeFrom(p, 0, "print(2)", true); + p.update(.tick); // on the clock: not yet, however old core time is + Sent.drain(p); + try std.testing.expect(std.mem.endsWith(u8, Sent.said(1), "\x1b[200~print(2)\x1b[201~")); + p.now_ns = p.panes[1].?.repl_enter_due_ns; // the clock reaches its wait + p.update(.tick); + Sent.drain(p); + try std.testing.expectEqualStrings("\r", Sent.said(1)); + p.update(.{ .output = .{ .pane = 1, .bytes = "\x1b[?2004l" } }); + Sent.len[1] = 0; + // A block left open by its indented last line gets the blank line that + // ends it: a second Enter. + _ = exec.executeFrom(p, 0, "def f():\n return 1", true); + Sent.drain(p); + try std.testing.expectEqualStrings("def f():\r return 1\r\r", Sent.said(1)); + // Several selections executed at once: each is sent, not the first. + { + const text = try edit.flatSurface(p, &file.body); + file.body.setRanges(text, &.{ .{ .anchor = 0, .head = 8 }, .{ .anchor = 9, .head = 11 } }, &.{}, 0, true); + try std.testing.expect(exec.chordEachSel(p, file, .Exec)); + Sent.drain(p); + try std.testing.expectEqualStrings("print(1)\rls\r", Sent.said(1)); + } + // Its own body too. + try std.testing.expectEqual(@as(?usize, 1), exec.executeFrom(p, 1, "x = 1", true)); + Sent.drain(p); + try std.testing.expectEqualStrings("x = 1\r", Sent.said(1)); + + // Escapes: a tag's word, Exec by name, a command word. Each a command. + _ = exec.execute(p, 0, "ls"); + Sent.drain(p); + try std.testing.expect(Sent.spawned and Sent.len[1] == 0); + try std.testing.expect(p.executeBuiltinLine(0, "Exec ls")); + Sent.drain(p); + try std.testing.expect(Sent.spawned and Sent.len[1] == 0); + _ = exec.executeFrom(p, 0, "@`ls`", true); + Sent.drain(p); + try std.testing.expect(Sent.spawned and Sent.len[1] == 0); + + // Two bound: it asks, one key answers, Esc sends nowhere. + try std.testing.expect(p.executeBuiltinLine(2, "Repl python")); + try std.testing.expectEqualStrings("python-b", exec.replId(&idbuf, p.panes[2].?)); + Sent.drain(p); + try std.testing.expectEqual(@as(?usize, null), exec.executeFrom(p, 0, "print(2)", true)); + try std.testing.expectEqual(Pane.Prompt.repl_choice, file.prompt); + try std.testing.expect(std.mem.indexOf(u8, file.promptText().?, "a b") != null); + p.update(.{ .key = .{ .cp = 'b' } }); + Sent.drain(p); + try std.testing.expectEqualStrings("print(2)\r", Sent.said(2)); + try std.testing.expect(Sent.len[1] == 0 and file.prompt == .none); + // The question is in the log, and a script answers it on the ctl. + { + const th = @import("ninep/testing.zig"); + _ = exec.executeFrom(p, 0, "print(5)", true); + var want: [32]u8 = undefined; + try std.testing.expect(th.logHas(p, try std.fmt.bufPrint(&want, "ask {d} repl a b\n", .{file.serial}))); + // A choice not offered is refused, and the question stands. + const refused = th.wr(p, ctlfs.Node.of(file.serial, .ctl), "answer z\n"); + try std.testing.expectEqual(ctlfs.E.INVAL, refused.errno()); + try std.testing.expect(std.mem.endsWith(u8, refused.reply.ename, " \"z\"")); + try std.testing.expectEqual(Pane.Prompt.repl_choice, file.prompt); + const answered = th.wr(p, ctlfs.Node.of(file.serial, .ctl), "answer a\n"); + try std.testing.expectEqual(ctlfs.Status.ok, answered.reply.status); + try std.testing.expectEqualStrings("print(5)\r", answered.pty()); + try std.testing.expect(th.logHas(p, try std.fmt.bufPrint(&want, "answer {d} a\n", .{file.serial}))); + } + _ = exec.executeFrom(p, 0, "print(3)", true); + p.update(.{ .key = .{ .cp = Key.escape } }); + Sent.drain(p); + try std.testing.expect(Sent.len[1] == 0 and Sent.len[2] == 0); + // The pane a letter offered is the one it answers for: unbound while + // the question stood, it is sent nothing, and that is said. + _ = exec.executeFrom(p, 0, "print(4)", true); + try std.testing.expect(p.executeBuiltinLine(2, "Repl -")); + p.update(.{ .key = .{ .cp = 'b' } }); + Sent.drain(p); + try std.testing.expect(Sent.len[1] == 0 and Sent.len[2] == 0); + try std.testing.expectEqualStrings("Repl: the REPL chosen is gone; nothing sent", file.msg[0..file.msg_len]); + try std.testing.expect(p.executeBuiltinLine(2, "Repl python")); + try std.testing.expectEqualStrings("python-b", exec.replId(&idbuf, p.panes[2].?)); + + // A bound REPL whose program exited (Ctrl-D: the shell has the tty) is + // skipped: the one still running takes the text, no question asked; + // with none running, nothing runs and that is said. + host.taken[1] = false; + _ = exec.executeFrom(p, 0, "import os", true); + try std.testing.expectEqual(Pane.Prompt.none, file.prompt); + Sent.drain(p); + try std.testing.expectEqualStrings("import os\r", Sent.said(2)); + host.taken[2] = false; + _ = exec.executeFrom(p, 0, "import os", true); + try std.testing.expectEqual(Pane.Prompt.none, file.prompt); + Sent.drain(p); + try std.testing.expect(Sent.len[1] == 0 and Sent.len[2] == 0 and !Sent.spawned); + try std.testing.expect(std.mem.indexOf(u8, file.msg[0..file.msg_len], "no program running") != null); + host.taken[1] = true; + host.taken[2] = true; + + // Unbound, its letter is free again; bare, it says what it is. + try std.testing.expect(p.executeBuiltinLine(1, "Repl -")); + try std.testing.expect(p.panes[1].?.repl == null); + try std.testing.expect(p.executeBuiltinLine(1, "Repl python")); + try std.testing.expectEqualStrings("python-a", exec.replId(&idbuf, p.panes[1].?)); + try std.testing.expect(p.executeBuiltinLine(2, "Repl")); + try std.testing.expectEqualStrings("Repl: python-b", p.panes[2].?.msg[0..p.panes[2].?.msg_len]); + + // A command pane is a REPL while its command runs: done, it is none, + // and a done one cannot be bound. A document pane is no terminal. + const cmd = p.freeSlot().?; + _ = try pardes.panes.newCommand(p, cmd, "", "python3"); + try std.testing.expect(p.executeBuiltinLine(cmd, "Repl python")); + try std.testing.expect(p.panes[cmd].?.repl != null); + p.update(.{ .exited = .{ .pane = @intCast(cmd), .status = 0 } }); + try std.testing.expect(p.panes[cmd].?.repl == null); + try std.testing.expect(p.executeBuiltinLine(cmd, "Repl python")); + try std.testing.expect(p.panes[cmd].?.repl == null); + const doc_slot = p.freeSlot().?; + const doc = try p.newDocPane(doc_slot); + try std.testing.expect(p.executeBuiltinLine(doc_slot, "Repl python")); + try std.testing.expect(doc.repl == null); +} + +test "a restored terminal's tag names neither the REPL it was nor the shell it had" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + p.acknowledgeShell(0, "/usr/bin/fish", true); + var host: FakeTtyQuery = .{}; + host.install(p); + try std.testing.expect(p.executeBuiltinLine(0, "Repl python")); + try dump.dumpState(p); + const restored = try dump.restore(p, p.dump_out.?, "test"); + defer restored.deinit(); + const pane = restored.panes[0].?; + try std.testing.expect(pane.repl == null and pane.tag.own == null); + const shown = try tagline.tagText(restored, restored.scratch.allocator(), pane); + try std.testing.expect(std.mem.indexOf(u8, shown, "python-a") == null); + try std.testing.expect(std.mem.indexOf(u8, shown, "Term+fish") == null); +} + +test "a Term started by a shell's path keeps the path in its Term+ word" { + const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + try std.testing.expect(p.executeBuiltinLine(0, "Term /bin/sh")); + try std.testing.expect(p.active != 0); + p.acknowledgeShell(p.active, "/bin/sh", false); + try std.testing.expect(std.mem.startsWith(u8, tagline.curTail(p.panes[p.active].?), " Term+/bin/sh ")); +} + +test "Tty, Term's old name in saved tags, runs as Term, bare and with its +shell" { + const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + try std.testing.expect(p.executeBuiltinLine(0, "Tty+sh")); + try std.testing.expectEqualStrings("sh", p.panes[p.active].?.shell.?); + const first = p.active; + p.active = 0; + try std.testing.expect(p.executeBuiltinLine(0, "Tty")); + try std.testing.expect(p.active != 0 and p.active != first); +} + +test "Term+fish, one word a tag can hold, opens a terminal on that shell" { + const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + // sh, the one shell every host has. + try std.testing.expect(p.executeBuiltinLine(0, "Term+sh")); + try std.testing.expect(p.active != 0); + try std.testing.expectEqualStrings("sh", p.panes[p.active].?.shell.?); + p.acknowledgeShell(p.active, "/bin/sh", false); + try std.testing.expect(std.mem.startsWith(u8, tagline.curTail(p.panes[p.active].?), " Term+sh ")); + p.active = 0; + // A shell that is not there is said, not quietly replaced, and the + // pane that asked gets no shell of its own. + const before = p.active; + const caller = p.panes[0].?; + try std.testing.expect(p.executeBuiltinLine(0, "Term /nonexistent")); + try std.testing.expect(p.active == before and caller.shell == null); + try std.testing.expect(std.mem.indexOf(u8, caller.msg[0..caller.msg_len], "shell \"/nonexistent\" not found") != null); + try std.testing.expect(p.executeBuiltinLine(0, "Term fsh-not-a-shell")); + try std.testing.expect(caller.shell == null); + // A directory passes access(X_OK); it is no shell either. + try std.testing.expect(p.executeBuiltinLine(0, "Term /etc")); + try std.testing.expect(p.active == before); + try std.testing.expect(std.mem.indexOf(u8, caller.msg[0..caller.msg_len], "Term: not a shell: /etc is a directory") != null); + // Only a word that says so splits at `+`: `Dump+x.zon` is no Dump. + try std.testing.expect(!p.executeBuiltinLine(0, "Dump+x.zon")); + try std.testing.expect(!p.executeBuiltinLine(0, "Msg+hello")); +} + +test "a command pane shows how its command ended, and the next command there runs below it" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{}); + defer p.deinit(); + while (p.nextEffect()) |_| {} + p.setCwd(0, "/tmp/pardes-cmd"); + const doc = try p.newDocPane(1); + doc.image = .{ .path = try gpa.dupe(u8, "/tmp/pardes-cmd/pic.ppm") }; + + const dst = exec.execute(p, 1, "make -j8") orelse return error.NoCommandPane; + while (p.nextEffect()) |_| {} + const pane = p.panes[dst].?; + // Its first command is echoed as every later one is. + { + const first = try pardes.panes.terminal.screenTextAlloc(pane, gpa); + defer gpa.free(first); + try std.testing.expect(std.mem.startsWith(u8, first, "% make -j8")); + } + var frame = std.heap.ArenaAllocator.init(gpa); + defer frame.deinit(); + try std.testing.expect(std.mem.endsWith(u8, try tagline.tagPrefix(p, pane), "(make -j8) running")); + // Running, a second command goes to a pane of its own. + const other = exec.execute(p, 1, "ls") orelse return error.NoCommandPane; + try std.testing.expect(other != dst); + while (p.nextEffect()) |_| {} + p.update(.{ .output = .{ .pane = @intCast(dst), .bytes = "compiled\r\n" } }); + // Its exit comes first, a job it left still printing: done, and not + // the next command's until its pty closes. + p.update(.{ .exited = .{ .pane = @intCast(dst), .status = 2 } }); + try std.testing.expect(pane.command_done and pane.command_pty); + const busy = exec.execute(p, 1, "true") orelse return error.NoCommandPane; + try std.testing.expect(busy != dst); + while (p.nextEffect()) |_| {} + // Its output ending: now it may be reused. + p.update(.{ .eof = .{ .pane = @intCast(dst) } }); + try std.testing.expect(p.panes[dst] == pane and !pane.command_pty); + try std.testing.expect(p.panes[dst] == pane); + try std.testing.expect(pane.command_done); + try std.testing.expect(std.mem.endsWith(u8, try tagline.tagPrefix(p, pane), "(make -j8) exit 2")); + // Kill leaves a finished one be. + try std.testing.expect(p.executeBuiltinLine(0, "Kill make")); + while (p.nextEffect()) |effect| if (effect == .signal_pty and effect.signal_pty.pane == dst) return error.SignalledAFinishedCommand; + // A program that crashed out of its full screen leaves the emulator + // in its modes; the next command starts clear of them. + p.update(.{ .output = .{ .pane = @intCast(dst), .bytes = "\x1b[?1049h\x1b[?2004h\x1b[?1000h" } }); + try std.testing.expect(pardes.panes.terminal.bracketedPaste(pane)); + // Done, the directory's next command runs there, below what it showed. + try std.testing.expectEqual(@as(?usize, dst), exec.execute(p, 1, "make test")); + try std.testing.expect(!pardes.panes.terminal.bracketedPaste(pane)); + var respawned = false; + while (p.nextEffect()) |effect| if (effect == .spawn and effect.spawn.pane == dst) { + respawned = true; + }; + try std.testing.expect(respawned); + const body = try pardes.panes.terminal.screenTextAlloc(pane, gpa); + defer gpa.free(body); + const said = std.mem.indexOf(u8, body, "compiled") orelse return error.OutputLost; + const ended = std.mem.indexOf(u8, body, "exit 2") orelse return error.ExitLost; + const next = std.mem.indexOf(u8, body, "% make test") orelse return error.NoSeparator; + try std.testing.expect(said < ended and ended < next); + try std.testing.expect(std.mem.endsWith(u8, try tagline.tagPrefix(p, pane), "(make test) running")); + // Kill stops a running one: its whole process group, SIGTERM. + try std.testing.expect(p.executeBuiltinLine(0, "Kill make")); + var signalled = false; + while (p.nextEffect()) |effect| if (effect == .signal_pty and effect.signal_pty.pane == dst) { + try std.testing.expectEqual(PtySignal.term, effect.signal_pty.sig); + signalled = true; + }; + try std.testing.expect(signalled); + // The log says what ran and how it ended. + const log = try ctlfs.events.freezeLog(p); + defer gpa.free(log.bytes); + var want: [64]u8 = undefined; + // The whole line, after the `new` of the pane it runs in. + const ran = std.mem.indexOf(u8, log.bytes, try std.fmt.bufPrint(&want, "run {d} make -j8\n", .{pane.serial})) orelse return error.NoRunRecord; + const made = std.mem.indexOf(u8, log.bytes, try std.fmt.bufPrint(&want, "new {d} ", .{pane.serial})) orelse return error.NoNewRecord; + try std.testing.expect(made < ran); + try std.testing.expect(std.mem.indexOf(u8, log.bytes, try std.fmt.bufPrint(&want, "exit {d} 2\n", .{pane.serial})) != null); + // A signal for a pane is not performed on whoever takes its slot. + const Count = struct { + var signals: usize = 0; + const vtable: Host.VTable = .{ .pty_signal = signal }; + fn signal(_: ?*anyopaque, _: u8, _: PtySignal) void { + signals += 1; + } + }; + const host_before = p.host; + p.host = .{ .vtable = &Count.vtable }; + try std.testing.expect(p.executeBuiltinLine(0, "Kill make")); + try p.removePane(dst, null); + _ = try pardes.panes.newCommand(p, dst, "", "other"); + while (p.nextEffect()) |effect| if (effect == .signal_pty) p.perform(effect); + try std.testing.expectEqual(@as(usize, 0), Count.signals); + p.host = host_before; + // A command line longer than a command pane takes is refused. + const long = &@as([exec.command_max + 1]u8, @splat('x')); + try std.testing.expectEqual(@as(?usize, null), exec.execute(p, 1, long)); +} + +test "image dump restores source bytes renderer choices and exact custom tail" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true }); + defer p.deinit(); + try pardes.panes.deinitPane(p, p.panes[0].?); + p.panes[0] = null; + + const source = "\x00embedded image bytes\xff"; + const raw = try p.image_gpa.dupe(u8, source); + const pane = pardes.panes.Image.create(p, 0, "/missing/restored-image.ppm", raw) catch |err| { + p.image_gpa.free(raw); + return err; + }; + pane.image.?.glyph_art = true; + pane.image.?.pmode = .terminal; + pane.image.?.ascii = false; + if (pane.tag.own) |own| p.gpa.free(own); + pane.tag.own = try p.gpa.dupe(u8, " Keep Del"); + try dump.dumpState(p); + + const restored = try dump.initFromDump(gpa, .{ .tty_only = true }, p.dump_out.?); + defer restored.deinit(); + const restored_pane = restored.panes[0].?; + try std.testing.expect(restored_pane.image.?.glyph_art); + try std.testing.expectEqual(image.PaletteMode.terminal, restored_pane.image.?.pmode); + try std.testing.expect(!restored_pane.image.?.ascii); + try std.testing.expect(restored_pane.tag.own != null); + try std.testing.expectEqualStrings(" Keep Del", tagline.curTail(restored_pane)); + try std.testing.expectEqualSlices(u8, source, restored_pane.image.?.raw); + + // And dumped again, its bytes still there. + try dump.dumpState(restored); + const again = try dump.load(gpa, .{ .tty_only = true }, restored.dump_out.?, null); + defer again.deinit(); + try std.testing.expectEqualSlices(u8, source, again.panes[0].?.image.?.raw); +} + +test "a terminal its program gave back takes command lines again" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{}); + defer p.deinit(); + while (p.nextEffect()) |_| {} + p.acknowledgeShell(0, "/bin/sh", false); + + p.setCwd(0, "/tmp/pardes-taken-flip"); + var host: FakeTtyQuery = .{}; + host.install(p); + host.taken[0] = true; + try std.testing.expect(exec.execute(p, 0, "echo while-taken") != 0); + while (p.nextEffect()) |_| {} + + // the program exited, so the host's answer changes — and the core asks + // again, because it never cached the old one + host.taken[0] = false; + try std.testing.expectEqual(@as(?usize, 0), exec.execute(p, 0, "echo after")); + var sent: [64]u8 = undefined; + var sent_len: usize = 0; + while (p.nextEffect()) |effect| switch (effect) { + .write => |w| { + try std.testing.expectEqual(@as(u8, 0), w.pane); + try std.testing.expect(w.bytes.slice().len <= sent.len - sent_len); + @memcpy(sent[sent_len..][0..w.bytes.slice().len], w.bytes.slice()); + sent_len += w.bytes.slice().len; + }, + .spawn => return error.SpawnedDespiteAPromptOfItsOwn, + else => {}, + }; + try std.testing.expectEqualStrings("echo after\r", sent[0..sent_len]); +} + +test "the host is asked about a tty only where a command line is about to go" { + const p = try Pardes.init(std.testing.allocator, .{ .shells = 3, .cols = 100, .rows = 30 }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + var frame = std.heap.ArenaAllocator.init(std.testing.allocator); + defer frame.deinit(); + + var host: FakeTtyQuery = .{}; + host.install(p); + p.setCwd(0, "/tmp/pardes-lazy-a"); + p.setCwd(1, "/tmp/pardes-lazy-b"); + p.setCwd(2, "/tmp/pardes-lazy-c"); + + _ = try p.render(frame.allocator()); + p.update(.{ .key = .{ .cp = 'x' } }); + p.update(.{ .mouse = .{ .button = .none, .kind = .motion, .col = 4, .row = 4 } }); + p.update(.{ .resize = .{ .cols = 90, .rows = 28 } }); + while (p.nextEffect()) |_| {} + _ = try p.render(frame.allocator()); + try std.testing.expectEqual(@as(usize, 0), host.asked); + + // The pane an Exec is typed into is one question, asked once... + _ = exec.execute(p, 0, "echo lazy"); + while (p.nextEffect()) |_| {} + try std.testing.expectEqual(@as(usize, 1), host.asked); + + // ...and a taken one is asked once too: the line then runs as a command + // pane, with no other terminal to ask about. + host.taken[0] = true; + host.asked = 0; + _ = exec.execute(p, 0, "echo lazy-again"); + while (p.nextEffect()) |_| {} + try std.testing.expectEqual(@as(usize, 1), host.asked); +} + +test "a host with no methods at all is a complete in-process pardes" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 10 }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + + // A pump against the empty host renders a frame and blocks on nothing. + try p.pump(.{}); + try std.testing.expect(!p.quit); + + // the absent child is SILENT: the bytes are dropped, and nothing appears + // on the pane's screen to suggest a program answered + const before = p.panes[0].?.terminal.?.vt.screens.active.cursor.y; + p.perform(.{ .write = .{ .pane = 0, .bytes = .from("ls\r") } }); + try std.testing.expectEqual(before, p.panes[0].?.terminal.?.vt.screens.active.cursor.y); + + // the clipboard round-trips through the in-process one + p.registers.put(gpa, '+', "copied", 0, 1, true); + p.perform(.set_clipboard); + try std.testing.expectEqualStrings("copied", p.fallback.clipboard.items); + + // ...and a save with no filesystem lands in the virtual one + const doc = try p.setTestFile("body\n"); + var doc_id: u8 = 0; + for (p.panes, 0..) |slot, i| if (slot == doc) { + doc_id = @intCast(i); + }; + p.perform(.{ .save_file = .{ .pane = doc_id } }); + try std.testing.expectEqualStrings("body\n", p.fallback.files.get(doc.file.?.path).?); + + // a language backend nobody supplied answers nothing rather than hanging + p.perform(.{ .lsp = .{ .id = 7, .kind = .hover, .pane = doc_id, .offset = 0, .arg = .{} } }); + + p.perform(.quit); + try std.testing.expect(p.quit); +} + +test "Font keeps requested and acknowledged faces as separate plain state" { + if (comptime !font_picker) return; // there is no Font builtin on the tty + const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 }); + defer p.deinit(); + var arena: std.heap.ArenaAllocator = .init(std.testing.allocator); + defer arena.deinit(); + const installed = fonts.list(arena.allocator(), null); + if (installed.len == 0) return; // a machine with no monospace face at all + + var line: [512]u8 = undefined; + const cmd = try std.fmt.bufPrint(&line, "Font {s}", .{installed[0].name}); + try std.testing.expect(p.executeBuiltinLine(p.active, cmd)); + try std.testing.expect(p.settings.font.pending); + try std.testing.expectEqualStrings(installed[0].name, p.settings.font.requested_name.get()); + try std.testing.expectEqualStrings(installed[0].path, p.settings.font.requested_path.get()); + try std.testing.expectEqual(@as(u16, 0), p.settings.font.requested_size_hundredths); + try std.testing.expectEqualStrings("", p.settings.font.effective_name.get()); + + // Boot/zoom/display-scale reports describe the face already being drawn; + // they must neither answer nor reject the new request waiting beside it. + try std.testing.expect(p.observeFont("Embedded Mono", 1200, .pixels)); + try std.testing.expectEqualStrings("Embedded Mono", p.settings.font.effective_name.get()); + try std.testing.expect(p.settings.font.pending); + try std.testing.expect(!p.acknowledgeFont("Stray Ack", 1250, .pixels)); + p.rejectFont(); + try std.testing.expect(p.settings.font.pending); + + const request = p.takeFontRequest() orelse return error.MissingFontRequest; + try std.testing.expectEqualStrings(installed[0].path, request); + try std.testing.expect(p.settings.font.pending); + try std.testing.expect(p.takeFontRequest() == null); + try std.testing.expect(p.acknowledgeFont(installed[0].name, 1375, .pixels)); + try std.testing.expect(!p.settings.font.pending); + try std.testing.expectEqualStrings(installed[0].name, p.settings.font.effective_name.get()); + try std.testing.expectEqual(@as(u16, 1375), p.settings.font.effective_size_hundredths); + try std.testing.expectEqual(config.Runtime.FontSizeUnit.pixels, p.settings.font.effective_size_unit); + try std.testing.expect(!p.acknowledgeFont("Duplicate Ack", 1400, .pixels)); + + try std.testing.expect(p.executeBuiltinLine(p.active, cmd)); + _ = p.takeFontRequest() orelse return error.MissingRepeatedFontRequest; + try std.testing.expect(p.acknowledgeFont(installed[0].name, 1375, .pixels)); + + // A name nothing answers to changes neither request nor effective state. + try std.testing.expect(p.executeBuiltinLine(p.active, "Font zzz-no-such-face")); + try std.testing.expectEqualStrings(installed[0].name, p.settings.font.requested_name.get()); + try std.testing.expectEqualStrings(installed[0].name, p.settings.font.effective_name.get()); +} + +test "Font size suffix reaches native request and invalid input leaves it intact" { + if (comptime !font_picker) return; + const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 }); + defer p.deinit(); + var arena: std.heap.ArenaAllocator = .init(std.testing.allocator); + defer arena.deinit(); + const installed = fonts.list(arena.allocator(), null); + if (installed.len == 0) return; + var line: [512]u8 = undefined; + try std.testing.expect(p.executeBuiltinLine(p.active, try std.fmt.bufPrint(&line, "Font {s}:18.5", .{installed[0].name}))); + try std.testing.expectEqual(@as(u16, 1850), p.settings.font.requested_size_hundredths); + try std.testing.expectEqualStrings(installed[0].path, p.takeFontRequest().?); + try std.testing.expect(p.acknowledgeFont(installed[0].name, 1850, .pixels)); + try std.testing.expect(p.executeBuiltinLine(p.active, try std.fmt.bufPrint(&line, "Font {s}:nan", .{installed[0].name}))); + try std.testing.expectEqual(@as(u16, 1850), p.settings.font.requested_size_hundredths); + try std.testing.expect(p.takeFontRequest() == null); + try std.testing.expect(p.executeBuiltinLine(p.active, "Font zzz-no-such-face:20")); + try std.testing.expectEqual(@as(u16, 1850), p.settings.font.requested_size_hundredths); + try std.testing.expect(p.takeFontRequest() == null); + try std.testing.expect(p.executeBuiltinLine(p.active, try std.fmt.bufPrint(&line, "Font {s}", .{installed[0].name}))); + try std.testing.expectEqual(@as(u16, 0), p.settings.font.requested_size_hundredths); + try std.testing.expectEqual(@as(u16, 1850), p.settings.font.effective_size_hundredths); +} + +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(); + try std.testing.expectEqualStrings("dark", source.theme().name); + try dump.dumpState(source); + + const restored = try dump.initFromDump( + std.testing.allocator, + .{ .startup_config = "Theme acme\n" }, + source.dump_out.?, + ); + defer restored.deinit(); + try std.testing.expectEqualStrings("acme", restored.theme().name); + try std.testing.expect(!source.animationActive()); + try std.testing.expect(!restored.animationActive()); + try std.testing.expectEqual(ChromeTheme.fromTheme(source.theme()), source.chromeTheme().*); + try std.testing.expectEqual(ChromeTheme.fromTheme(restored.theme()), restored.chromeTheme().*); +} + +test "restored terminals keep monotonic nonzero pane identities" { + const gpa = std.testing.allocator; + const source = try Pardes.init(gpa, .{ .shells = 3 }); + defer source.deinit(); + // Filter is the pane's, and a dump keeps it: one toggled off comes back off. + source.panes[1].?.tty_filter = false; + try dump.dumpState(source); + + const restored = try dump.initFromDump(gpa, .{}, source.dump_out.?); + defer restored.deinit(); + + var ids: [MAX_PANES]usize = undefined; + var serials: [MAX_PANES]u32 = undefined; + var n: usize = 0; + for (restored.panes, 0..) |slot, id| { + const pane = slot orelse continue; + if (!pane.isTerminal()) continue; + try std.testing.expectEqual(id != 1, pane.tty_filter); + try std.testing.expect(pane.serial != 0); + for (serials[0..n]) |seen| try std.testing.expect(pane.serial != seen); + ids[n] = id; + serials[n] = pane.serial; + n += 1; + } + try std.testing.expectEqual(@as(usize, 3), n); + for (ids[0..n], serials[0..n]) |id, serial| + try std.testing.expectEqual(id, restored.paneBySerial(serial).?); + + const before = restored.next_serial; + const free = restored.freeSlot() orelse return error.NoFreePane; + const fresh = try restored.newShell(free, ""); + try std.testing.expect(fresh.tty_filter); + try std.testing.expectEqual(before + 1, fresh.serial); + try std.testing.expectEqual(fresh.serial, restored.next_serial); +} + +test "Tab N draws every pane's tab N cells wide and clicks count past it; bare Tab says the width; the ctl read and a Dump keep it" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .cols = 60, .rows = 12 }); + defer p.deinit(); + // The width is the process's: the next test starts from the default. + defer config.tab_now = config.tab_width; + const pane = try p.setTestFile("\tx = 1\n"); + try std.testing.expect(p.executeBuiltinLine(0, "Tab 8")); + try std.testing.expectEqual(@as(u16, 8), config.tab_now); + var frame = std.heap.ArenaAllocator.init(gpa); + defer frame.deinit(); + const surface = try p.render(frame.allocator()); + const rect = p.rects[0]; + const text_x = rect.x + config.GUTTER + config.PREFIX_W; + const body_y = rect.y + BOX_H; + try std.testing.expectEqualStrings("x", surface.at(text_x + 8, body_y).grapheme()); + // A click on the x is on its byte, past the tab. + p.update(.{ .mouse = .{ .button = config.select_button, .kind = .press, .col = text_x + 8, .row = body_y } }); + p.update(.{ .mouse = .{ .button = config.select_button, .kind = .release, .col = text_x + 8, .row = body_y } }); + try std.testing.expectEqual(@as(i32, 1), pane.body.cur_col); + // Bare, it says the width. + try std.testing.expect(p.executeBuiltinLine(0, "Tab")); + try std.testing.expectEqualStrings("Tab 8", pane.msg[0..pane.msg_len]); + // Out of range: refused, the width kept. + try std.testing.expect(p.executeBuiltinLine(0, "Tab 0")); + try std.testing.expectEqual(@as(u16, 8), config.tab_now); + // The ctl read's tab column, and a Dump's settings. + const ctl_text = @import("ninep/testing.zig").rd(p, ctlfs.Node.of(pane.serial, .ctl), 0, 4096).bytes; + try std.testing.expect(std.mem.indexOf(u8, ctl_text, " 8 ") != null); + try dump.dumpState(p); + const restored = try dump.restore(p, p.dump_out.?, "/tmp/pardes.dump.zon"); + defer restored.deinit(); + try std.testing.expectEqual(@as(u16, 8), restored.settings.tab); + try std.testing.expectEqual(@as(u16, 8), config.tab_now); +} + +test "tabbed file aligns syntax cursor and mouse at the nearest insertion gap" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .cols = 60, .rows = 12 }); + defer p.deinit(); + // Bold is an explicit preference; use it to expose the glyph boundaries. + try std.testing.expect(p.executeBuiltinLine(0, "SyntaxBold")); + const pane = try p.setTestFile("\treturn x\n"); + const f = &pane.file.?; + f.highlights = try p.tree_sitter_gpa.alloc(u8, f.content.len); + @memset(f.highlights, @backingInt(syntax.Syn.none)); + @memset(f.highlights[1..7], @backingInt(syntax.Syn.keyword)); + f.syntax_dirty = false; + pane.body.cur_row = 0; + pane.body.cur_col = 1; + + var frame = std.heap.ArenaAllocator.init(gpa); + defer frame.deinit(); + const surface = try p.render(frame.allocator()); + const rect = p.rects[0]; + const text_x = rect.x + config.GUTTER + config.PREFIX_W; + const body_y = rect.y + BOX_H; + for (0..config.tab_width) |col| + try std.testing.expect(!surface.at(text_x + @as(u16, @intCast(col)), body_y).style.bold); + for (0.."return".len) |col| + try std.testing.expect(surface.at(text_x + config.tab_width + @as(u16, @intCast(col)), body_y).style.bold); + try std.testing.expectEqual(text_x + config.tab_width, surface.cursor.?.x); + + const click_x = text_x + config.tab_width + 2; + p.update(.{ .mouse = .{ .button = config.select_button, .kind = .press, .col = click_x, .row = body_y } }); + p.update(.{ .mouse = .{ .button = config.select_button, .kind = .release, .col = click_x, .row = body_y } }); + try std.testing.expectEqual(@as(i32, 3), pane.body.cur_col); + + const line = modal.lineSlice(f.content, 0); + const virtual: u16 = 3; + const blank_x = text_x + @as(u16, @intCast(pardes.panes.File.displayWidth(line))) + virtual; + p.update(.{ .mouse = .{ .button = config.select_button, .kind = .press, .col = blank_x, .row = body_y } }); + p.update(.{ .mouse = .{ .button = config.select_button, .kind = .release, .col = blank_x, .row = body_y } }); + try std.testing.expectEqual(@as(i32, @intCast(line.len)), pane.body.cur_col); + + _ = frame.reset(.retain_capacity); + const virtual_surface = try p.render(frame.allocator()); + try std.testing.expectEqual(blank_x - virtual, virtual_surface.cursor.?.x); + + const local_blank: i32 = @intCast(blank_x - rect.x - config.GUTTER); + try std.testing.expect(look.expandedSel(p, pane, .{ .state = .dragging, .c0 = local_blank, .c1 = local_blank, .r0 = BOX_H, .r1 = BOX_H }) == null); + + // The immediately-adjacent EOL cell and an in-line separator are blank + // too. Pointer expansion must not lean left into the preceding word. + const adjacent: i32 = @intCast(config.PREFIX_W + pardes.panes.File.displayWidth(line)); + try std.testing.expect(look.expandedSel(p, pane, .{ .state = .dragging, .c0 = adjacent, .c1 = adjacent, .r0 = BOX_H, .r1 = BOX_H }) == null); + const separator: i32 = @intCast(config.PREFIX_W + config.tab_width + "return".len); + try std.testing.expect(look.expandedSel(p, pane, .{ .state = .dragging, .c0 = separator, .c1 = separator, .r0 = BOX_H, .r1 = BOX_H }) == null); +} + +test "the workspace tag's Restore word names the last dump, the tag edited around it or not, across a Restore too" { + const p = try Pardes.init(std.testing.allocator, .{ .cols = 100, .rows = 20, .tty_only = true }); + defer p.deinit(); + p.setLastDump("/tmp/a.zon"); + // The tag edited: its own text holds the Restore word as it was then. + p.global_tag.own = try p.gpa.dupe(u8, try std.fmt.allocPrint(p.scratch.allocator(), "{s} Mine", .{tagline.headerDefault(p, .workspace)})); + p.setLastDump("/tmp/b.zon"); + try std.testing.expect(std.mem.indexOf(u8, p.global_tag.own.?, "Restore /tmp/b.zon Mine") != null); + try dump.dumpState(p); + const restored = try dump.restore(p, p.dump_out.?, "/tmp/c.zon"); + defer restored.deinit(); + try std.testing.expect(std.mem.indexOf(u8, restored.global_tag.own.?, "Restore /tmp/c.zon Mine") != null); + try std.testing.expectEqualStrings("/tmp/c.zon", restored.last_dump.?); +} + +test "editable workspace and column tags are typed into and persist" { + const p = try Pardes.init(std.testing.allocator, .{ .cols = 100, .rows = 20, .tty_only = true }); + defer p.deinit(); + _ = try p.setTestFile("untouched\n"); + p.presented(); + try std.testing.expectEqual(TOPBAR_H + COLBAR_H, p.rects[0].y); + // a sweep over a header is its selection, the caret where it ended + p.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = TAG_TEXT_INSET, .row = 0 } }); + p.update(.{ .mouse = .{ .button = .left, .kind = .drag, .col = TAG_TEXT_INSET + 6, .row = 0 } }); + p.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = TAG_TEXT_INSET + 6, .row = 0 } }); + try std.testing.expect(p.global_tag.vsel.active and p.global_tag.vsel.col == 0 and p.global_tag.cur_col == 6); + // A clicked header is in normal mode: `a` types after the sweep's + // last character, the blank it ended on. + p.update(.{ .key = .{ .cp = 'a', .text = "a" } }); + p.update(.{ .key = .{ .cp = 'H', .text = "Help " } }); + try std.testing.expect(std.mem.startsWith(u8, p.global_tag.own.?, "Newcol Help Joincol")); + p.update(.{ .key = .{ .cp = Key.escape } }); + p.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = TAG_TEXT_INSET, .row = TOPBAR_H } }); + p.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = TAG_TEXT_INSET, .row = TOPBAR_H } }); + p.update(.{ .key = .{ .cp = 'i', .text = "i" } }); + p.update(.{ .key = .{ .cp = 'é', .text = "é" } }); + try std.testing.expect(std.mem.startsWith(u8, tagline.columnTag(p, 0), "éNew")); + p.update(.{ .key = .{ .cp = Key.backspace } }); + try std.testing.expect(std.mem.startsWith(u8, tagline.columnTag(p, 0), "New")); + p.update(.{ .paste = "Grep " }); + try std.testing.expect(std.mem.startsWith(u8, tagline.columnTag(p, 0), "Grep New")); + try std.testing.expectEqualStrings("untouched\n", p.panes[0].?.file.?.content); + try dump.dumpState(p); + const restored = try dump.restore(p, p.dump_out.?, "test"); + defer restored.deinit(); + try std.testing.expectEqualStrings(p.global_tag.own.?, restored.global_tag.own.?); + try std.testing.expectEqualStrings(tagline.columnTag(p, 0), tagline.columnTag(restored, 0)); + p.gpa.free(p.col_tags[0].own.?); + p.col_tags[0].own = try p.gpa.dupe(u8, ""); + try dump.dumpState(p); + const empty = try dump.restore(p, p.dump_out.?, "test"); + defer empty.deinit(); + try std.testing.expectEqualStrings("", tagline.columnTag(empty, 0)); +} + +test "column tag first-cell execution keeps New local to the clicked column" { + const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 20, .tty_only = true }); + defer p.deinit(); + _ = try p.setTestFile("untouched\n"); + layout.newColumn(p, 0); + layout.newScratchIn(p, 0, layout.activeColumn(p).?); + p.sync(); + for (0..2) |column| { + p.active = p.col_panes[1 - column][0]; + p.presented(); + const before = p.col_n; + p.update(.{ .mouse = .{ .button = .middle, .kind = .press, .col = p.col_x[column] + TAG_TEXT_INSET, .row = TOPBAR_H } }); + p.update(.{ .mouse = .{ .button = .middle, .kind = .release, .col = p.col_x[column] + TAG_TEXT_INSET, .row = TOPBAR_H } }); + try std.testing.expectEqual(before[column] + 1, p.col_n[column]); + try std.testing.expectEqual(before[1 - column], p.col_n[1 - column]); + try std.testing.expectEqual(column, layout.findPane(p, p.active).?.col); + } + try std.testing.expectEqualStrings("untouched\n", p.panes[0].?.file.?.content); +} + +test "a screen too short for the column row releases a column tag's focus without losing its commands" { + const p = try Pardes.init(std.testing.allocator, .{ .cols = 60, .rows = 12, .tty_only = true }); + defer p.deinit(); + const pane = try p.setTestFile("unchanged body\n"); + p.col_tags[0].own = try p.gpa.dupe(u8, "New Help"); + p.presented(); + const shown = p.rects[0]; + try std.testing.expectEqual(TOPBAR_H + COLBAR_H, shown.y); + p.update(.{ .mouse = .{ .button = .left, .kind = .press, .col = TAG_TEXT_INSET, .row = TOPBAR_H } }); + p.update(.{ .mouse = .{ .button = .left, .kind = .release, .col = TAG_TEXT_INSET, .row = TOPBAR_H } }); + try std.testing.expect(p.header_focus and p.header_column != null); + + p.update(.{ .resize = .{ .cols = 60, .rows = 2 } }); + try std.testing.expectEqual(@as(u16, 0), layout.columnBarHeight(p)); + try std.testing.expectEqual(TOPBAR_H, p.rects[0].y); + try std.testing.expect(!p.header_focus and p.header_column == null); + p.update(.{ .resize = .{ .cols = 60, .rows = 12 } }); + try std.testing.expectEqual(shown, p.rects[0]); + try std.testing.expectEqualStrings("New Help", tagline.columnTag(p, 0)); + try std.testing.expectEqualStrings("unchanged body\n", pane.file.?.content); +} + +test "screen resize keeps its previous storage until allocation succeeds" { + var failing: std.testing.FailingAllocator = .init(std.testing.allocator, .{}); + const p = try Pardes.init(failing.allocator(), .{ .cols = 80, .rows = 24, .tty_only = true }); + defer p.deinit(); + var frame: std.heap.ArenaAllocator = .init(std.testing.allocator); + defer frame.deinit(); + const surface = try p.render(frame.allocator()); + const cells = surface.cells; + p.update(.{ .resize = .{ .cols = 81, .rows = 25 } }); + failing.fail_index = failing.alloc_index; + try std.testing.expectError(error.OutOfMemory, p.render(frame.allocator())); + try std.testing.expectEqual(cells.ptr, surface.cells.ptr); + try std.testing.expectEqual(cells.len, surface.cells.len); + try std.testing.expectEqual(@as(u16, 80), surface.cols); + try std.testing.expectEqual(@as(u16, 24), surface.rows); + failing.fail_index = std.math.maxInt(usize); + const resized = try p.render(frame.allocator()); + try std.testing.expectEqual(@as(u16, 81), resized.cols); + try std.testing.expectEqual(@as(u16, 25), resized.rows); + try std.testing.expectEqual(@as(usize, 81 * 25), resized.cells.len); +} + +test "a boot file that will not open boots an errors pane rather than failing the launch" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ + .cols = 80, + .rows = 24, + .file = "/definitely/not/here/notes.md", + }); + defer p.deinit(); + p.update(.{ .resize = .{ .cols = 80, .rows = 24 } }); + + const pane = p.panes[0].?; + const f = pane.file.?; + try std.testing.expectEqual(pardes.panes.Output.Origin.errors, f.output.?.from); + // The reason IN WORDS, not an error name: `PermissionDenied` on a screen + // is jargon, and the whole point of this pane is that a human reads it. + try std.testing.expect(std.mem.indexOf(u8, f.content, "cannot open") != null); + try std.testing.expect(std.mem.indexOf(u8, f.content, "no file of that name") != null); + try std.testing.expect(std.mem.indexOf(u8, f.content, "/definitely/not/here/notes.md") != null); +} + +test "argv naming nothing boots an errors pane rather than failing the launch" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ + .cols = 80, + .rows = 24, + .missing = .{ .word = "notes/tdoo.md", .dir = "/home/pardes-test/work" }, + }); + defer p.deinit(); + p.update(.{ .resize = .{ .cols = 80, .rows = 24 } }); + + // One pane, filling the window, and it is an OUTPUT pane rather than the + // shell a bare `pardes` boots: the answer is the whole screen. + try std.testing.expectEqual(@as(u8, 1), p.ncol); + try std.testing.expectEqual(@as(usize, 1), p.col_n[0]); + try std.testing.expectEqual(@as(usize, 0), p.col_panes[0][0]); + try std.testing.expectEqual(@as(usize, 0), p.active); + for (p.panes[1..]) |slot| try std.testing.expect(slot == null); + const pane = p.panes[0].?; + try std.testing.expect(!pane.isTerminal()); + const f = pane.file.?; + try std.testing.expectEqual(pardes.panes.Output.Origin.errors, f.output.?.from); + // ...and it says what happened AND what was asked for. The word as typed, + // which is the half a bare "not found" leaves out. + try std.testing.expect(std.mem.indexOf(u8, f.content, "not found") != null); + try std.testing.expect(std.mem.indexOf(u8, f.content, "notes/tdoo.md") != null); + + try std.testing.expectEqualStrings("/home/pardes-test/work/+Errors", f.path); +} + +test "raw terminal cursor obeys visibility without hiding modal and tag cursors" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + const pane = p.panes[0].?; + pane.body.mode = .tty; + p.update(.{ .output = .{ .pane = 0, .bytes = "abc" } }); + var frame = std.heap.ArenaAllocator.init(gpa); + defer frame.deinit(); + const visible = (try p.render(frame.allocator())).cursor orelse return error.MissingCursor; + const rect = p.rects[0]; + const body_y = if (p.settings.tag_bottom) rect.y else rect.y + BOX_H; + try std.testing.expectEqual(rect.x + config.GUTTER + 3, visible.x); + try std.testing.expectEqual(body_y, visible.y); + + p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?25l" } }); + try std.testing.expect((try p.render(frame.allocator())).cursor == null); + pane.body.mode = .normal; + pane.body.cur_pinned = true; + pane.body.cur_row = 0; + pane.body.cur_col = 1; + const modal_cursor = (try p.render(frame.allocator())).cursor orelse return error.MissingCursor; + try std.testing.expectEqual(rect.x + config.GUTTER + 1, modal_cursor.x); + try std.testing.expectEqual(body_y, modal_cursor.y); + tagline.enterTag(p, pane); + const tag_cursor = (try p.render(frame.allocator())).cursor orelse return error.MissingCursor; + try std.testing.expectEqual(if (p.settings.tag_bottom) rect.y + rect.h - BOX_H else rect.y, tag_cursor.y); + pane.focus = .body; + pane.body.mode = .tty; + try std.testing.expect((try p.render(frame.allocator())).cursor == null); + + p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?25h\x1b[?1049h\x1b[2;5H" } }); + const alternate = (try p.render(frame.allocator())).cursor orelse return error.MissingCursor; + try std.testing.expectEqual(rect.x + config.GUTTER + 4, alternate.x); + try std.testing.expectEqual(body_y + 1, alternate.y); + p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?25l" } }); + try std.testing.expect((try p.render(frame.allocator())).cursor == null); + p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?1049l\x1b[?25h" } }); + const returned = (try p.render(frame.allocator())).cursor orelse return error.MissingCursor; + try std.testing.expectEqual(visible.x, returned.x); + try std.testing.expectEqual(visible.y, returned.y); +} + +test "raw terminal cursor follows its active row only while that row is visible" { + const gpa = std.testing.allocator; + for ([_]bool{ false, true }) |tag_bottom| { + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 }); + defer p.deinit(); + while (p.nextEffect()) |_| {} + p.settings.tag_bottom = tag_bottom; + const pane = p.panes[0].?; + pane.body.mode = .tty; + for (0..60) |_| p.update(.{ .output = .{ .pane = 0, .bytes = "row\r\n" } }); + p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[3;4H" } }); + var frame = std.heap.ArenaAllocator.init(gpa); + defer frame.deinit(); + const live = (try p.render(frame.allocator())).cursor orelse return error.MissingCursor; + const rect = p.rects[0]; + const body_y = if (tag_bottom) rect.y else rect.y + BOX_H; + try std.testing.expectEqual(rect.x + config.GUTTER + 3, live.x); + try std.testing.expectEqual(body_y + 2, live.y); + + pardes.panes.terminal.scrollGrid(pane, -1); + const scrolled = (try p.render(frame.allocator())).cursor orelse return error.MissingCursor; + try std.testing.expectEqual(live.x, scrolled.x); + try std.testing.expectEqual(live.y + 1, scrolled.y); + pardes.panes.terminal.scrollGrid(pane, -@as(i32, pane.rows)); + try std.testing.expect((try p.render(frame.allocator())).cursor == null); + pardes.panes.terminal.followOutput(pane); + const returned = (try p.render(frame.allocator())).cursor orelse return error.MissingCursor; + try std.testing.expectEqual(live.x, returned.x); + try std.testing.expectEqual(live.y, returned.y); + } +} + +test "the bare tty startup opens a text pane under the shell, unfocused" { + const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .boot = .tty }); + defer p.deinit(); + try std.testing.expectEqual(Boot.tty, p.boot); + + // One column, shell on top in raw mode, an empty text pane under it. + try std.testing.expectEqual(@as(usize, 1), p.ncol); + try std.testing.expectEqual(@as(usize, 2), p.col_n[0]); + const shell = p.panes[p.col_panes[0][0]].?; + const scratch = p.panes[p.col_panes[0][1]].?; + try std.testing.expect(shell.isTerminal()); + try std.testing.expectEqual(Text.Mode.tty, shell.body.mode); + try std.testing.expect(!scratch.isTerminal()); + try std.testing.expectEqualStrings("", scratch.file.?.content); + + // ...and the shell keeps the keyboard. + try std.testing.expectEqual(p.col_panes[0][0], p.active); + + // Unnamed, it is the bare shell every test asks for. + const plain = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); + defer plain.deinit(); + try std.testing.expectEqual(Boot.tty_shell, plain.boot); + try std.testing.expectEqual(@as(usize, 1), plain.col_n[0]); +} + +test "tty output follows only from the bottom" { + const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24, .file = "mise.toml" }); + defer p.deinit(); + p.update(.{ .resize = .{ .cols = 80, .rows = 24 } }); + p.update(.{ .key = .{ .cp = 'n', .alt = true } }); // a shell under the doc + const shell = p.active; + const sp = p.panes[shell].?; + p.update(.{ .key = .{ .cp = 'b', .ctrl = true } }); + try std.testing.expectEqual(Text.Mode.tty, sp.body.mode); + + for (0..60) |i| { + var buf: [32]u8 = undefined; + p.update(.{ .output = .{ .pane = @intCast(shell), .bytes = std.fmt.bufPrint(&buf, "line {d}\r\n", .{i}) catch unreachable } }); + } + p.sync(); + const bottom = pardes.panes.terminal.scrollbar(sp).offset; + try std.testing.expect(bottom > 0); + + // Scrolled back, the reader stays put however much the shell prints. + sp.scrollBy(-10); + p.sync(); + const parked = pardes.panes.terminal.scrollbar(sp).offset; + try std.testing.expect(parked < bottom); + for (60..70) |i| { + var buf: [32]u8 = undefined; + p.update(.{ .output = .{ .pane = @intCast(shell), .bytes = std.fmt.bufPrint(&buf, "line {d}\r\n", .{i}) catch unreachable } }); + } + p.sync(); + try std.testing.expectEqual(parked, pardes.panes.terminal.scrollbar(sp).offset); + + // Typing snaps back to live output, so nobody types blind. + p.update(.{ .key = .{ .cp = 'x', .text = "x" } }); + p.sync(); + try std.testing.expect(pardes.panes.terminal.scrollbar(sp).offset > parked); + + // ...and from there output follows again. + const live = pardes.panes.terminal.scrollbar(sp).offset; + p.update(.{ .output = .{ .pane = @intCast(shell), .bytes = "tail\r\n" } }); + p.sync(); + try std.testing.expect(pardes.panes.terminal.scrollbar(sp).offset > live); +} + +test "an unasked desktop paste reaches a tty pane's program, not its buffer" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 }); + defer p.deinit(); + p.update(.{ .resize = .{ .cols = 80, .rows = 24 } }); + var buf: [256]u8 = undefined; + _ = test_api.ptyBytes(p, null, &buf); + + const pane = p.panes[0].?; + pardes.panes.terminal.enterTty(p, 0); + // No request behind it: the window manager's own paste, or SDL answering a + // Ctrl-Shift-V the desktop handled. It still has to reach the shell. + p.update(.{ .paste = "ls -la" }); + try std.testing.expectEqualStrings("ls -la", test_api.ptyBytes(p, null, &buf)); + // and nothing was typed into an overlay the pty does not know about + try std.testing.expect(pane.ovl == null); +} + +test "a paste larger than the effect ring reaches the program whole and in order" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 }); + defer p.deinit(); + p.update(.{ .resize = .{ .cols = 80, .rows = 24 } }); + const buf = try gpa.alloc(u8, 2 << 20); + defer gpa.free(buf); + _ = test_api.ptyBytes(p, null, buf); + pardes.panes.terminal.enterTty(p, 0); + + const text = try gpa.alloc(u8, 1536 * 1024); + defer gpa.free(text); + for (text, 0..) |*c, i| c.* = 'a' + @as(u8, @intCast(i % 26)); + p.update(.{ .paste = text }); + try std.testing.expectEqualSlices(u8, text, test_api.ptyBytes(p, null, buf)); + // ...and the core is not still holding a copy afterwards + try std.testing.expectEqual(@as(usize, 0), p.pending_write_bytes); +} + +test "a bracketed paste larger than the ring still closes its bracket" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 }); + defer p.deinit(); + p.update(.{ .resize = .{ .cols = 80, .rows = 24 } }); + const buf = try gpa.alloc(u8, 2 << 20); + defer gpa.free(buf); + _ = test_api.ptyBytes(p, null, buf); + pardes.panes.terminal.enterTty(p, 0); + + p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?2004h" } }); + try std.testing.expect(pardes.panes.terminal.bracketedPaste(p.panes[0].?)); + const text = try gpa.alloc(u8, 1536 * 1024); + defer gpa.free(text); + @memset(text, 'z'); + p.update(.{ .paste = text }); + const got = test_api.ptyBytes(p, null, buf); + try std.testing.expect(std.mem.startsWith(u8, got, "\x1b[200~")); + try std.testing.expect(std.mem.endsWith(u8, got, "\x1b[201~")); + try std.testing.expectEqualSlices(u8, text, got["\x1b[200~".len .. got.len - "\x1b[201~".len]); +} + +test "a terminal's answer to its program waits behind the paste still queued for its pty" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 }); + defer p.deinit(); + p.update(.{ .resize = .{ .cols = 80, .rows = 24 } }); + const buf = try gpa.alloc(u8, 2 << 20); + defer gpa.free(buf); + _ = test_api.ptyBytes(p, null, buf); + pardes.panes.terminal.enterTty(p, 0); + + const text = try gpa.alloc(u8, 1536 * 1024); + defer gpa.free(text); + @memset(text, 'p'); + p.update(.{ .paste = text }); + // The ring is full and the rest of the paste waits for room in it. A + // host takes one write off, and the program asks where its cursor is. + const taken = p.nextEffect().?; + const off = if (taken == .write) taken.write.bytes.len else 0; + p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[6n" } }); + const got = test_api.ptyBytes(p, null, buf); + // The whole paste first, then the answer, `CSI row ; col R`, whole. + try std.testing.expectEqualSlices(u8, text[off..], got[0 .. text.len - off]); + const answer = got[text.len - off ..]; + try std.testing.expect(std.mem.startsWith(u8, answer, "\x1b[") and std.mem.endsWith(u8, answer, "R")); +} + +test "pasted bytes still queued at shutdown are freed, not leaked" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 }); + defer p.deinit(); + p.update(.{ .resize = .{ .cols = 80, .rows = 24 } }); + const buf = try gpa.alloc(u8, 2 << 20); + defer gpa.free(buf); + _ = test_api.ptyBytes(p, null, buf); + pardes.panes.terminal.enterTty(p, 0); + + const text = try gpa.alloc(u8, 1536 * 1024); + defer gpa.free(text); + @memset(text, 'q'); + p.update(.{ .paste = text }); + try std.testing.expect(p.pending_write_bytes > 0); +} + +test "leaving tty hides the prompt and keeps the command typed at it" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }); + defer p.deinit(); + p.update(.{ .resize = .{ .cols = 80, .rows = 24 } }); + p.update(.{ .key = .{ .cp = 'n', .alt = true } }); // a shell under the doc + const shell = p.active; + const sp = p.panes[shell].?; + try std.testing.expect(sp.isTerminal()); + + // Exactly what an OSC 133 shell draws: prompt, then the marker that says + // the rest of this row is the user's, then what they typed. One grid row. + p.update(.{ .output = .{ + .pane = @intCast(shell), + .bytes = "\x1b]133;A\x1b\\user@box ~/src $ \x1b]133;B\x1b\\grep -rn TODO src/", + } }); + p.sync(); + + const rowOf = struct { + fn at(pp: *Pardes, pane: *Pane, needle: []const u8) ?[]const u8 { + const rows = pardes.panes.terminal.shellRows(pp, pane) catch return null; + for (rows) |r| if (std.mem.indexOf(u8, r, needle) != null) return r; + return null; + } + }.at; + const bodyRowOf = struct { + fn at(pp: *Pardes, pane: *Pane, needle: []const u8) ?[]const u8 { + const body = pardes.panes.terminal.bodyText(pp.scratch.allocator(), pane) catch return null; + var it = std.mem.splitScalar(u8, body, '\n'); + while (it.next()) |r| if (std.mem.indexOf(u8, r, needle) != null) return r; + return null; + } + }.at; + + // The BODY is what you look at, and it follows the mode: in tty the pane + // is the program's own screen, so the prompt is there. + sp.body.mode = .tty; + try std.testing.expectEqualStrings( + "user@box ~/src $ grep -rn TODO src/", + bodyRowOf(p, sp, "grep") orelse return error.MissingPromptRow, + ); + + sp.body.mode = .normal; + try std.testing.expectEqualStrings( + "grep -rn TODO src/", + bodyRowOf(p, sp, "grep") orelse return error.MissingPromptRow, + ); + + p.shell_rows.stale = true; + try std.testing.expectEqualStrings( + "grep -rn TODO src/", + rowOf(p, sp, "grep") orelse return error.MissingPromptRow, + ); + + // ...and a prompt with nothing typed at it yet is all chrome, so the whole + // row goes, which is what it has always done. + p.update(.{ .output = .{ + .pane = @intCast(shell), + .bytes = "\r\n\x1b]133;A\x1b\\user@box ~/src $ \x1b]133;B\x1b\\", + } }); + p.sync(); + p.shell_rows.stale = true; + try std.testing.expect(rowOf(p, sp, "user@box") == null); +} + +test "entering tty walks the shell cursor to the column clicked past the prompt" { + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }); + defer p.deinit(); + p.update(.{ .resize = .{ .cols = 80, .rows = 24 } }); + p.update(.{ .key = .{ .cp = 'n', .alt = true } }); + const shell = p.active; + const sp = p.panes[shell].?; + p.update(.{ .output = .{ + .pane = @intCast(shell), + .bytes = "\x1b]133;A;cl=line\x1b\\prompt> \x1b]133;B\x1b\\0123456789", + } }); + p.sync(); + sp.body.mode = .normal; + p.shell_rows.stale = true; + + // The command shows LEFT-HUGGED, so its column 3 is the '3'... + const rows = try pardes.panes.terminal.shellRows(p, sp); + var row: i32 = 0; + const at = for (rows, 0..) |r, i| { + if (std.mem.indexOf(u8, r, "0123456789") != null) break i; + } else return error.MissingInputRow; + row = @intCast(at); + try std.testing.expectEqualStrings("0123456789", rows[at]); + + // ...but the shell's own cursor lives on the real grid, eight cells + // further right, behind the prompt this pane is not showing. + sp.body.cur_row = row; + sp.body.cur_col = 3; + sp.body.cur_pinned = true; + while (p.nextEffect()) |_| {} + pardes.panes.terminal.enterTty(p, shell); + + // The walk is arrow keys the shell understands. Seven lefts: readline's + // cursor sits past the '9' and the click was on the '3'. + var lefts: usize = 0; + var rights: usize = 0; + while (p.nextEffect()) |effect| switch (effect) { + .write => |wr| { + if (std.mem.eql(u8, wr.bytes.slice(), "\x1b[D")) lefts += 1; + if (std.mem.eql(u8, wr.bytes.slice(), "\x1b[C")) rights += 1; + }, + else => {}, + }; + try std.testing.expectEqual(@as(usize, 0), rights); + try std.testing.expectEqual(@as(usize, 7), lefts); +} + +test "every allocation failure during boot is a clean OutOfMemory" { + try std.testing.checkAllAllocationFailures(std.testing.allocator, bootAndTearDown, .{}); +} |
