diff options
Diffstat (limited to 'docs/typ/guide.typ')
| -rw-r--r-- | docs/typ/guide.typ | 378 |
1 files changed, 119 insertions, 259 deletions
diff --git a/docs/typ/guide.typ b/docs/typ/guide.typ index 077484dc..087291a8 100644 --- a/docs/typ/guide.typ +++ b/docs/typ/guide.typ @@ -1,6 +1,6 @@ -// The guide: pardes day to day, read once in about ten minutes. The -// cheatsheet is the index of keys and words; the reference has every -// 9P file; scripting has the recipes. +// The guide: pardes day to day, the path a newcomer reads once. Edge cases +// live in the reference, the pager and the language servers in setup, the +// keys on the cheatsheet. #import "style.typ": key, keys, btn, chord, word, tag, addr, file, cmd, doc, pairs pardes is a screen of columns. Each column holds panes, and each pane is a @@ -9,326 +9,194 @@ Above the columns runs the workspace tag, and each column has a tag of its own. Any text anywhere can be clicked: #btn("B2") runs it, #btn("B3") looks at it. The keys are helix's, in modes. += Words you'll see <words> + +#pairs( + [tag], [the line of words over a pane, a column or the screen; every word in it can be clicked], + [the pane with the keyboard], [where your keys go; one pane at a time], + [active column], [where the next new pane goes (below)], + [command pane], [a terminal that runs one command line and shows its output], + [scratch], [a pane of text with no file yet, `+New`], + [listing], [a pane of places to visit: `+Search`, Recent, Jumplist, Themes], + [message row], [the line where pardes says what happened], + [grip], [the box left of a pane's tag: drag it, and it marks unsaved text], +) + = Modes <modes> -Each pane has its own mode and keeps it while you are elsewhere: leave a -terminal at its `$` and it is still `$` when you come back. The box at the -left of a pane's tag shows the mode. +Each pane has its own mode and keeps it while you are elsewhere. The box +at the left of a pane's tag shows it. #pairs( - [normal (box blank)], [keys move and select; an edit acts on the selection. File and PDF panes start here, and so does a terminal from #key("Alt-n").], + [normal (blank)], [keys move and select; an edit acts on the selection. File and PDF panes start here, and so does a terminal from #key("Alt-n").], [insert (`^`)], [keys type. #keys("i", "a", "o") and the rest enter it.], [raw (`$`), terminals only], [keys go to the program. A terminal from #word("Tty"), the shell a bare `pardes` starts with, and a command pane start here.], ) #key("Ctrl-b") switches a terminal between raw and normal; in normal mode -the shell's prompts are hidden and its text is a page to move over and -copy from. #word("Mode") in the tag steps raw, normal, insert. Esc and -Shift-Esc depend on the mode: +its prompts are hidden and its text is a page to move over and copy from. +#word("Mode") in the tag steps raw, normal, insert. #pairs( [normal], [#key("Esc"): back to the previous pane (#word("Last")). #key("Shift-Esc"): the same.], [insert], [#key("Esc"): back to normal. #key("Shift-Esc"): out of insert and back to the previous pane.], - [raw `$`], [#key("Esc"): to the program, except at a shell prompt with nothing typed on it, where it goes back to the previous pane. #key("Shift-Esc"): always back to the previous pane. Either way the terminal stays `$`.], + [raw `$`], [#key("Esc"): to the program, except at a shell prompt with nothing typed on it, where it goes back to the previous pane. #key("Shift-Esc"): always back. Either way the terminal stays `$`.], [a PDF], [#key("Esc"): clears the selection and the search highlights. #key("Shift-Esc"): back to the previous pane.], ) -In short, #key("Shift-Esc") is the Esc nothing swallows: in every mode and pane it goes back to the previous pane, as Esc does from normal, and a raw program never sees it. #key("Ctrl-b") alone switches a terminal between raw and normal. "A shell prompt with nothing -typed on it" is one pardes knows from the prompt marks it injects into bash -and fish (and, for other shells, from no program holding the terminal). -"The previous pane" is the last other pane on the jump list; with none, the -next pane down its column (wrapping), else any other pane. In raw mode -every key but #key("Ctrl-b"), Esc and the paste chords goes to the -program, so #key("Ctrl-w") and #key("Alt-n") need you out of raw mode -first (and #key("Ctrl-w") out of insert mode, where it deletes a word). +"The previous pane" is the last other pane on the jump list, else the next +pane down its column. In raw mode every key but #key("Ctrl-b"), Esc and the +paste chords goes to the program, so #key("Ctrl-w") and #key("Alt-n") need +you out of raw mode first. = The mouse <mouse> #pairs( - btn("B1"), [select; a plain click puts the cursor there and gives the pane the keyboard. In a tag it starts typing at the click, in insert mode. A double click selects the word, the line (at a line's start or end), or up to the matching bracket or quote.], + btn("B1"), [select; a click puts the cursor there and gives the pane the keyboard. In a tag it starts typing, in insert mode. A double click selects the word, the line, or up to the matching bracket or quote.], btn("B2"), [execute: a builtin word runs, anything else is a shell line.], - btn("B3"), [look: open the file, address, directory or URL, or else find the word's next place.], + btn("B3"), [look: open the file, address, directory or URL, else find the word's next place.], ) -A #btn("B2") or #btn("B3") click with no drag takes the word under it, -where a word is the run of letters, digits, non-ASCII and `. - + / : @ _ ~` -around the click; a trailing `:` is dropped. So #btn("B3") anywhere on -`src/bar.c:12:5:` in a compiler's `src/bar.c:12:5: error` opens -`src/bar.c` at line 12, byte column 5, while a click on `error` finds -`error`. Drag instead to say exactly what you mean. #key("Enter") and -#key("Tab") in normal mode look and execute the selection, or the word -under the cursor. The chords are on the cheatsheet. +A #btn("B2") or #btn("B3") click with no drag takes the word under it: the +run of letters, digits and `. - + / : @ _ ~`, a trailing `:` dropped. So +#btn("B3") on `src/bar.c:12:5:` in a compiler's error opens `src/bar.c` at +line 12, column 5. Drag to say exactly what you mean. #key("Enter") and +#key("Tab") in normal mode look and execute. The chords are on the +cheatsheet. = Tags <tags> -There are three kinds, and which directory a command runs in depends on -which one you click: - #tag("Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit") #tag("New Tty Find Grep Joincol Delcol") #tag("Save Tty Collapse Del", path: "/home/me/notes.txt") -- The workspace tag and the column tags run commands in the session's - directory (where pardes started). A column's own words (#word("New"), - #word("Tty"), #word("Delcol")) act on that column; a pane word - (#word("Save"), #word("Del")) acts on the column's pane with the - keyboard, or its first; from the workspace tag, on the pane with the - keyboard. -- A pane's tag runs commands in the pane's directory: a file's directory, a - terminal's current directory. - A tag is text with undo: type a word into it and click it, or delete the -defaults. #key(":") moves the keyboard between a body and its tag. A pane -tag may wrap onto several lines; column and workspace tags are one line. -The path at the start of a pane's tag is computed: typing into it, or -clicking it, drafts a new name, #key("Enter") confirms and the next -#word("Save") writes there; #key("Esc") cancels. #word("Collapse") folds a -pane to its tag. Unsaved text shows on the grip, the box left of the tag. -Drag the grip up or down to resize, or onto another column to move the -pane there. +defaults. #key(":") moves the keyboard between a body and its tag. The path +at the start of a pane's tag is computed: typing into it drafts a new name, +#key("Enter") confirms and the next #word("Save") writes there. +#word("Collapse") folds a pane to its tag. Drag the grip up or down to +resize, or onto another column to move the pane. + += Where commands run and panes go <command-panes> -= The active column and the keyboard <active-column> +#btn("B2") on a line that is no builtin (`make`, `git log`) runs it with +the #word("Shell") setting's `-c`. Where depends on where you clicked: -Two things are easy to confuse: +#pairs( + [a terminal's text or tag, at a prompt with nothing typed], [typed into that shell, in its current directory], + [any other pane's text or tag], [a command pane in that pane's directory, in the last column], + [a column's tag], [a command pane in the session's directory, in that column], + [the workspace tag], [a command pane in the session's directory, in the last column], +) -- *The pane with the keyboard* is where your keys go. -- *The active column* is where new panes go. It is the column you last - typed in, #btn("B1")-clicked in, dropped a pane into or gave the keyboard - to its tag, or the one that got the last new pane. A look does not move - it. +The keyboard stays where it was. A command pane's tag says `running`, then +`exit N`: -They usually agree. Here is how they split. You are typing in column 1, so -column 1 is active. You click #word("New") in column 2's tag: a scratch -pane opens in column 2 and takes the keyboard, and column 2 is now -active. In it you #btn("B3") `x.txt`, which is already open in column 1: -the keyboard jumps to that pane in column 1, but the active column stays -2, so the next pane a look opens lands in column 2, away from where you -are. Type or click in column 1 and it is active again. +#tag("Kill Save Collapse Del", path: "/home/me/src (make) exit 0") -== Where new panes go <new-panes> +The next command for that directory reuses a finished command pane. +#word("Kill") stops what pardes started (`Kill make`: those whose line +starts with `make`); #word("Exit") quits pardes. A pane word from a column +tag (#word("Save"), #word("Del")) acts on that column's pane with the +keyboard, or its first. -#word("Placement") picks the rules: `acme` (the default) or `pardes`. -Under `acme`, a new pane goes into the column whose tag asked, else the -active column, never into a new column. An empty column it takes whole; -#word("New") and 9P's #file("pane/new") take the bottom half of the -column's last pane; a pane opened from a pane's text (a look, #word("Tty"), -#key("Alt-n")) goes under the pane with the most blank rows, or halves the -biggest; a command pane goes to the last column. #word("New") in a pane's -tag opens a `+New` scratch named in that pane's directory, in that pane's -column; from a column tag, in that column and the session's directory. -Every new pane takes the keyboard, except a command pane and a listing -(`+Search`, #word("Recent"), #word("Jumplist"), #word("Themes"), `Fonts`), -which opens below the pane that asked and leaves it the keyboard, so -#keys("n", "N") walk the listing and #key("Tab") runs a row. No pane is made -shorter than its tag and two rows; where there is no room the pane is -refused. `Placement pardes` instead fills an empty column whose tag asked -or has the keyboard, puts a scratch or a shell under the pane that asked, -a document beside the last one read (or in a column of its own on a wide -screen), and a command pane at the foot of the last column. +Every other new pane goes into the *active column*: the column you last +typed or #btn("B1")-clicked in, or the one that got the last new pane. It +takes the keyboard, except a listing, which opens below the pane that +asked and leaves it the keyboard, so #keys("n", "N") walk the listing. A +look moves the keyboard but not the active column: #btn("B3") on a file +already open in another column jumps there, and the next new pane still +lands in the old column until you type or click. #word("Placement") +`pardes` picks other rules (#doc("reference", section: "placement")). -A column can be empty, as in acme: closing its last pane leaves it, its -tag over blank space. #word("Delcol") and #word("Joincol") take columns -away. Closing the session's last pane quits pardes. +A column can be empty: closing its last pane leaves it. #word("Delcol") +and #word("Joincol") take columns away. Closing the session's last pane +quits pardes. = Looking <looking> #btn("B3") (or #key("Enter")) on a path opens it, or goes to the pane that -already shows it; `file:12` goes to line 12. The address forms are on the -cheatsheet. A directory types `ls` into a terminal idle there, else opens -a terminal there. A URL opens in the browser. #word("Find") `name` lists the files -below the pane's directory whose names hold it; #word("Grep") `text` lists -the lines that contain that text, literally (ASCII case aside, no regular -expression), in files under every pane's directory. Both land in `+Search`, -a place per row for #btn("B3"). Grep reads at most 256 KiB of a file and -stops at 512 hits, Find at 512 names; the walk stops at 20000 files or -100000 entries, 16 deep, and passes over `.git`, `.jj`, `target`, -`node_modules`, `.venv`, `__pycache__`, `.zig-cache` and `zig-out`. A cap -hit, or a directory it could not open, is said at the end (`cut at 512 -hits`, `N files read only in part (first 256 KiB)`, `walk cut at N -entries`, `N directories skipped: permission denied`). A search that finds -nothing and skipped nothing fails, `Grep: text not found`, and leaves -the `+Search` as it was. - -A relative path is looked for where the click was, then where you have -been: first in the looking pane's own directory, then in the directory of -each pane on the jump list, most recent first. The first that names a -file, or a pane open on that path, wins. `./x` and `../x` look only in the -pane's own directory. - -= Command panes <command-panes> - -#btn("B2") on a line that is no builtin (`make`, `git log`) runs it with -the #word("Shell") setting's `-c`, in the directory of the tag or pane it -came from. In a terminal at a shell prompt with nothing typed on it, a line from that -terminal's own text is typed into its shell. Anywhere else it runs in a -command pane, a terminal of its own: - -#tag("Kill Save Collapse Del", path: "/home/me/src (make) exit 0") +already shows it; `file:12` goes to line 12, and the other address forms +are on the cheatsheet. A directory types `ls` into a terminal idle there, +else opens one there. A URL opens in the browser. A relative path is +looked for in the looking pane's directory, then in the directory of each +pane on the jump list, most recent first. -Its tag says `running`, then `exit N`. Its directory is the one it -started in, and relative looks in it resolve there, whatever the command -did with `cd`. The next command for the same -directory reuses a command pane that has finished (from a column tag, only -one in that column), below what it showed; a pane still running, or one a -background job still prints to, is never reused, so a second command -meanwhile gets a pane of its own. #word("Kill") stops what pardes started -(`Kill make`: those whose line starts with `make`); #word("Exit") quits -pardes. +#word("Find") `name` lists the files below the pane's directory whose +names hold it; #word("Grep") `text` lists the lines that hold the text, +literally (no regular expression), under every pane's directory. Both land +in a `+Search` listing; their limits are in the reference. = Unsaved panes <unsaved-panes> -A pane whose text is unsaved is marked on its grip. #word("Del") on it -refuses once: a notice says `1 unsaved pane — Del again to discard` and the -pane is listed in `+Unsaved`. The same #word("Del") again, with nothing -edited since, discards it. #word("Exit") and #word("Restore") refuse once -over unsaved panes the same way; #word("Delcol") refuses once too, but -lists them only in its notice and the log, opening no `+Unsaved`. A `+New` -scratch under 100 bytes and a command's output never hold anything up. - -From the keyboard (#key("SPC d")), #word("Del") on a pane with panes above -and below it also asks which neighbour takes its rows: #key("k") above, -#key("j") below, any other key keeps the pane. A click never asks, and -gives the rows to the pane above. +A pane with unsaved text is marked on its grip. #word("Del") on it refuses +once: the message row says `1 unsaved pane — Del again to discard` and the +pane is listed in `+Unsaved`. The same #word("Del") again discards it. +#word("Exit"), #word("Restore") and #word("Delcol") refuse once the same +way. From the keyboard (#key("SPC d")), #word("Del") between two panes +also asks which takes its rows: #key("k") above, #key("j") below. = Terminals <terminals> -A terminal is a pane like any other. - #tag("Tty+bash Save Mode Filter Collapse Del", path: "/home/me/src") -- `Tty+bash` opens another terminal on that shell; a bare #word("Tty") - runs the #word("Shell") setting, `$SHELL` when it is executable, else - `/bin/sh`. -- #word("Save") asks for a path on the pane's notice band and writes the - terminal's scrollback there as text; `Save path` writes it at once. +- `Tty+bash` opens another terminal on that shell; bare #word("Tty") runs + the #word("Shell") setting. +- #word("Save") writes the scrollback to a path it asks for. - #word("Filter") maps the program's colours through the theme. -- A terminal showing kitty graphics (yazi's previews) shows `petscii:on` or - `petscii:off` in its tag. #word("Petscii") toggles it: on draws the - program's images as glyph art instead of host pixels, off goes back to - pixels. A terminal with no images shows the word only while it is on. -- The `+New` scratch a bare `pardes` starts under its shell runs its - commands in that terminal's current directory, following its `cd`. -- A paging command in a terminal (`git log`, `man`) opens its text in a - `+Pager` pane: a terminal's `PAGER` and `GIT_PAGER` are `pardes -` unless - your environment sets them. `Pager off` keeps your own pager, for - terminals started after it. A diff paged into `+Pager` (`git diff`, - `git show`, `git log -p`) is drawn and looked at as a diff. -- In raw mode Ctrl-V types what you yanked into the program (with nothing - yanked, the program gets the key), and Ctrl-Shift-V the desktop - clipboard. -- A program that tracks the mouse (htop, vim with `mouse=a`) gets - #btn("B1")'s clicks and drags and the wheel over its grid; #btn("B2") and - #btn("B3") stay pardes's. Hold Shift to swap: #btn("B1", shift: true) - selects and Shift-wheel scrolls pardes's scrollback, while - #btn("B2", shift: true) and #btn("B3", shift: true) go to the program as - its buttons 2 and 3. A full-screen program that does not track the mouse - gets the wheel as arrow keys. Tags, grips and gutters stay pardes's. -- `Repl python` in a terminal's tag makes #btn("B2") on a `.py` pane send - the text to that REPL instead of running it. +- #word("Petscii") draws a program's images as glyph art instead of pixels. +- In raw mode Ctrl-V types what you yanked, Ctrl-Shift-V the clipboard. +- A program that tracks the mouse gets #btn("B1") and the wheel; + #btn("B2") and #btn("B3") stay pardes's. Hold Shift to swap. +- `Repl python` in its tag makes #btn("B2") on a `.py` pane send the text + to that REPL. +- Paged output (`git log`, `man`) opens in a `+Pager` pane (#doc("setup", section: "pager")). = Reviewing diffs <reviewing-diffs> -Open a `.diff` or `.patch`, or run `git diff` (or `git show`, `diff -u`) as -a command: once it has finished, output that starts as a diff is shown as -one, each hunk coloured in its file's language and its added and removed -rows tinted. Then #btn("B3") to jump, with the usual look resolution: - -- a `diff --git`, `---` or `+++` line opens the file (the new one, or the - old one on a `---` line unless the `+++` under it names another); -- a `@@ -a,b +c,d @@` line goes to line `c` of the new file; -- the `+`, `-` or space in a hunk line's first column goes to that line in - the new file (for a removed line, the line now standing where it was); -- the code after it is ordinary words. - -git's `a/` and `b/` prefixes are dropped (and `c/ i/ w/ o/` with -`diff.mnemonicPrefix`); a `--no-prefix` diff's paths are kept as written. +Open a `.diff` or `.patch`, or run `git diff` as a command: the output is +drawn as a diff, each hunk coloured in its file's language. #btn("B3") on a +`diff --git`, `---` or `+++` line opens the file; on `@@` the hunk's first +new line; on a hunk line's `+`, `-` or space, that line in the new file. = `pardes FILE` and `--wait` <editor> In a pane's shell, `pardes FILE` opens FILE in this session and returns at -once, as acme's `B` does. A FILE not there yet opens an empty pane named -for it; #word("Save") creates it, making its directories first. Something -the session refuses (a bad name; a name under a directory you may not -search or write, `permission denied`) is printed and the command exits 1. -`--` ends the options: `pardes -- -name` opens a file named `-name`. - -`pardes --wait FILE` (`-w`) returns when the pane showing FILE is closed -(exit 0) or the session goes away (exit 1), as acme's `E` does. With -`$PARDES_9P` set but no pane of its own (an agent's `EDITOR`) it opens FILE -in that session and waits there. Set -`EDITOR='pardes --wait'` (`GIT_EDITOR` follows it), and `git commit`, -`crontab -e` and fish's Alt-E open in a pane and read the file once you -close it. Bare `pardes` inside a pane refuses and names `--nested`, which -starts a separate session whose shells do not forward to it. +once, as acme's `B` does; a FILE not there yet opens an empty pane that +#word("Save") creates. `pardes --wait FILE` returns when that pane is +closed, as acme's `E` does, which makes it an `EDITOR` +(#doc("setup", section: "editor-setup")). Refusals and `--nested` are in +the reference. = Keys <keys> Motions select what they cross, and an edit acts on the selection: #key("w") -then #key("d") deletes a word. #key("x") selects lines, #key("v") extends -characters, #key(";") collapses to the cursor. #key("s") makes a cursor -per regex match inside the selection, and every edit then acts at each. -#key("/") is a case-insensitive substring search, one hit a line; the -regexes are on #key("s") and #key("S"). #keys("n", "N") step through -everything a look would open, across panes. Line end is #key("g l"), and -#key("$") is helix's keep-pipe. #key("SPC") starts the leader, -#key("SPC ?") lists every path, and #word("Help") lists every key and -builtin. #word("Tutor") (#key("SPC h t")) practises them. - -The language servers run as child processes, one per language when it is -on `PATH`: `zls`, `rust-analyzer`, `clangd`, `gopls`, -`typescript-language-server` and `pyright-langserver` -(`PARDES_LSP_ZIG`, `_RS`, `_C`, `_GO`, `_TS`, `_PY` name another, empty -turns one off): - -#pairs( - [#keys("g d", "g D", "g y", "g i", "g r")], [definition, declaration, type, implementation, references; Ctrl-#btn("B1") is a definition too], - [#keys("SPC l k", "SPC l r", "SPC l a", "SPC l h")], [hover, rename, code action, select the references], - [#keys("SPC l s", "SPC l S", "SPC l d", "SPC l D")], [symbols and diagnostics, of the file and the workspace], - [#keys("SPC l c", "SPC l C", "SPC l t", "SPC l T")], [incoming and outgoing calls, supertypes and subtypes], - [#keys("] d", "[ d")], [next and previous diagnostic], - [#key("=")], [format], - [#keys("SPC l i", "SPC l w")], [#word("Lspinfo"): the servers' state; #word("Lspwhy"): why the last query found what it did], -) - -One answer jumps; several open a list where #key("Enter") on a row goes -there. In insert mode #key("Tab") after a `.` lists the candidate -declarations and inserts nothing. A format or a rename within the file is -one undo step. A rename that reaches other files applies nothing: it opens -a `+Search` preview of the edits. So does one the server answers in this -file alone while another open file of its language still holds the old -name, with a row per such file (zls does this renaming at a declaration; -from a use it reaches every file). A server is `not started yet` -until its first query. +then #key("d") deletes a word. #key("x") selects lines, #key("v") extends, +#key(";") collapses to the cursor. #key("s") makes a cursor per regex match +and every edit acts at each. #key("/") is a substring search; the regexes +are on #key("s") and #key("S"). #keys("n", "N") step through everything a +look would open, across panes. Line end is #key("g l"). #key("SPC") starts +the leader, #key("SPC ?") lists every path, #word("Help") every key and +builtin, and #word("Tutor") (#key("SPC h t")) practises them. The language +keys (#keys("g d", "g r"), `SPC l`) work once a server is installed +(#doc("setup", section: "language-servers")). = Sessions <sessions> ``` pardes --detach=work & a session with no screen of its own pardes --attach=work show it here -pardes-gui --attach=work the SDL window can attach too ``` The session owns the panes, shells and files; frontends come and go. -#word("Attach") `work` (#key("SPC s a")) switches this window to that -session, and #word("Detach") (#key("SPC s D")) leaves it running, shells -and all. Bare `--detach` names the session after its pid; bare `--attach` -needs exactly one session; a second `--detach=NAME` while NAME runs says so -and exits 1. Every attached frontend sees the same screen, -at the smallest common size. With none attached, `size C R` on the root -ctl sets the screen and messages clear by the clock, and a pane's pty -reports its size in pixels at the last frontend's cell size (8×16 before -any frontend attached), so programs like yazi still size their images; -CSI 14, 16 and 18 t answer the same. A detached session -ends when its last pane closes, as any session does. +#word("Attach") `work` (#key("SPC s a")) switches this window to it, and +#word("Detach") (#key("SPC s D")) leaves it running. Every attached frontend +sees the same screen. = Config <config> #word("Config") (#key("SPC f c")) opens the startup file, -`~/.config/pardes/init` (`$XDG_CONFIG_HOME/pardes/init` when that is -absolute; on macOS `~/Library/Application Support/pardes/init`). Each line -is one builtin, run at start as if executed; `#` starts a comment, and a -line that fails is skipped silently. Text that is no builtin does not run -as a shell command. +`~/.config/pardes/init`: one builtin a line, run at start, `#` a comment. ``` Theme atelier @@ -336,15 +204,7 @@ Shell zsh Placement pardes ``` -#word("DumpConfig") opens every live setting as the line that sets it, so -it pastes back into `init` as is. The settings are listed with the root -ctl in the reference (#doc("fs", section: "settings")). Keys are -compile-time, in `src/config.zig`. - -#word("Dump") writes the workspace to `pardes-<date>-<time>.zon` in -#word("DumpDir"), and `Restore path` (or `pardes -l dump.zon`) brings it -back: panes, columns, tags, selections, theme and changed settings; a -terminal returns with its last MiB of output and a new shell in its old -directory. Undo history and REPL bindings are not kept. A crash appends -two lines (build, time, platform, pid; the panic message) to `crashes` -beside `init`. +#word("DumpConfig") opens every live setting as the line that sets it. +#word("Dump") saves the workspace and #word("Restore") brings it back; what +a dump keeps is in the reference. Keys are compile-time, in +`src/config.zig`. |