| Advice | A wrapper around a function (advice-add): before, after, around, override, filter-args, filter-return. A layer owned by where it is written. |
as-caller | The core form a provider’s verb uses so that the entries it makes belong to its caller. |
| Break before make | The reload rule: stop the old version, then try the new one; if it fails, start the old code again. |
| Build (plugin build) | The step that reads a plugin’s files, expands them, checks names against contracts, compiles workers apart, and makes the plugin’s Chez library. Cached by a hash of the source. |
| Caller | The plugin, init.ss line or session whose code contains a contract call. |
| Chez Scheme | The language Tuna is written in: version 10.4.1, the threaded build. |
| Command | What a key or M-x runs, defined with commands:define; run as a task. |
| Command loop | The editor thread’s loop: input first, then worker results, then at most one frame; sleeps when idle. |
| Continuation | “The rest of a computation” captured as a value. Chez’s call/cc makes one; the core uses it to pause a command at a prompt and resume it later. |
| Continuation mark | A value attached to a point in a running computation. The core uses marks for each command’s dynamic values and to know which code made a call. |
| Contract | A plugin’s public interface: its contract.ss, or else its export list. Named like a library, (buffers). Not a runtime contract in Racket’s sense. |
| Core | The part of Tuna that runs plugins, keeps their state, runs the command loop and workers, and supports live change. Knows no editor features. |
| Current buffer | The buffer text procedures act on; a dynamic value, buffers:current, set for each command and by buffers:with. |
| Due | A plugin listed in init.ss that has not started yet; it starts at its line or on first need. |
| Dynamic value | A value each command sees its own binding of, declared with define-dynamic and bound with dynamic-let. |
| Editor thread | The one thread that runs plugin code. Nothing else touches editor state. |
| Entry | One key and value in a table or hook, owned by whoever added it. |
| Extraction | Reading, on the editor thread, what a browser tab’s windows show, as plain data for its drawing worker. |
| Face | A named look for text (colour, weight, underline), declared with faces:define and set with faces:set!. |
| First need | Starting a due plugin early, when another plugin’s file (or an init.ss line) first calls it. |
| Frame | One new picture of the screen, sent to each browser tab. |
| Helper process | A separate operating-system process that owns a resource that must outlive reloads and crashes, such as a shell’s pipes. |
| Hook | A list of procedures others add entries to, run at a moment its definer chooses. |
| Id | A number naming a thing another plugin owns. From new-id; never reused. |
| Input hand-over | The core’s entry point for input from other threads (the browser’s): it takes plain data and wakes the editor thread. |
| Job | One run of a worker on its own thread, started by start-job. |
| Layer | One owner’s value for an option or function. The newest wins; removing an owner removes its layer. |
| Option | A setting declared with define-option, with layers per owner, possibly scoped. |
| Owner | Whoever made a change: a plugin’s run, an init.ss line, or the session. |
| Persistent map | A map that is never changed in place; “changing” it gives a new map sharing most of the old one. |
| Plain data | Numbers, characters, symbols, booleans, strings, bytevectors, vectors, persistent maps, and lists of these. |
| Plain record | A fixed shape of plain data, declared with define-plain-record: a read-only vector with a tag, never changed in place. |
| Plugin | A folder with plugin.ss (and maybe contract.ss) that does one job. |
| Post | A worker handing one result back to the editor thread. |
| Provider | The plugin currently filling a contract. |
| Read-only | An immutable string, bytevector or vector, or a persistent map. Shared with workers without a copy. |
| Receipt | The core’s list of everything one owner changed, undone newest first when the owner ends. |
| Reload | Ending a plugin’s run and starting a new one from its file. |
| Rerun | A reload the core does by itself because something a plugin used while starting changed. |
| Run | One turning-on of a plugin: its file ran once from the top. |
| Run ending | Why a run ends: reload, off or shutdown. |
| Save point | After every command and at every pause: the core hands changed saved data to storage. |
| Saved data | The user’s data, declared with define-saved: plain, checked, saved, kept across everything. |
| Scope | Where an option layer or hook entry applies: everywhere, one buffer (buffer . 7), or one mode (mode . scheme-mode). |
| Session | The owner of what you do in M-: and your C-M-x edits. Ending it undoes them. |
| Set aside | Saved data that failed its check is moved aside, not deleted; restore-saved! brings it back. |
| Storage | The (storage) contract, filled by journal-store, which writes saved data to disk and reads it at start. |
| Swap | Replacing a contract’s provider with another implementing the same contract. |
| Table | A named set of entries others add to through a provider’s verbs, each owned by its adder. |
| Task | A unit of work on the editor thread (a command, a worker result, a timer’s action); it may pause. |
| Tie | A note on a caller’s receipt: “when you end, make this contract call”. Moves to the next run on a reload; saved with the session. |
| Turning off | Ending a plugin so Tuna is as if it had never been on, except the user’s data. |
| User’s buffer | A buffer made with buffers:create (a file, a shell): no plugin closes it. |
| Verb | A contract procedure or form that says what the caller means (keys:bind!) and makes its entries for the caller. |
| View | A buffer a plugin makes for its own output with buffers:view; it goes when the plugin turns off. |
| Worker | Heavy work declared with define-worker, compiled apart from its plugin, run on its own thread on plain data. |