Canonical domain terms for this project. Code and docs use these terms;
_Avoid_ synonyms are banned in new names. Conceptual terms are defined here;
code-backed terms are defined at their code home and linked from here; principles
and invariants are defined in their prose home and pointed at from here. Every
other document uses a term and points at its home, and never redefines it.
This glossary describes what is: an entry is written when the thing its term names is real. That is why it is short — the node's vocabulary grows as the node does.
A
acceptance
Defined in YmerNode — the app map's Scripts section stating that a script runs
only while its accepted hash equals its code hash, and which doors accept.
Avoid: approval (the client's act is the door; acceptance is the node's
record), trust, enable, activate, install (for a script)
B
backup
YmerNode.Notebook.Backup
Avoid: snapshot
battery
A capability the node carries for every script, so no script declares or
vendors it — in two shapes: what the context hands a run,
YmerNode.Script.Context.t/0, and a promised package.
Avoid: SDK, runtime, helper, stdlib (for it); context stays the word for
the struct itself and never becomes a term of its own
browser call
YmerNode.Script.Context.playwright/3
Avoid: run (the Runner's word), session, execution
browser service
YmerNode.Scripts.BrowserService
Avoid: runner (the run's word), Playwright server, browser runner, sidecar
C
cache
The node's set of fetched content: the cache entries in the node database and
the files in the cache directory. A cache entry is filled by a script, never
by the node; how far it may lag its target is YmerNode.References § The
membrane's. How it is filled and served is YmerNode.References.Cache's.
Avoid: mirror, content store, index (the table is cache_entries); Typst's
font cache and a token cache stay compound-qualified
cache directory
YmerNode.References.Cache.dir/0
Avoid: cache folder, references folder, files directory (for it)
cache entry
YmerNode.References.CacheEntry
Avoid: entry (bare, for a reference), cached copy, snapshot
CLI
The node's operator verbs, YmerNode.Scripts.CLI.main/1, reached through an
rpc overlay that the release carrying ymer_node provides — run by a human on
the machine the node runs on; the node's own human door, beside the client's
approval.
Avoid: console, command line (as the term)
D
deadline
Defined in YmerNode.Scripts.Runner — the @moduledoc section The
deadline, stating the bound on one run and that a run past it is killed.
Avoid: timeout (for the bound — an action's timeout key is its request,
:timeout the answer a killed run gives), time limit, cap (bare)
declaration
YmerNode.Script.declarations/0
A source declaration is what references derive from an accepted script's
declaration.
Avoid: manifest, capabilities, permissions, config
durability rule
Defined in YmerNode — the app map's opening paragraph on what the node
keeps.
Avoid: one precious file, single-store rule, one-database rule, backup
rule
E
example script
A script the package ships and a fresh node holds — Script.Hex and
Script.Webpage — each planted once, by a migration of its own, on a fresh
node database; present to be read as much as run; removable, and removal
sticks.
Avoid: sample, default script, built-in script (built-in is the reference sources' word), template, seed (for it)
extra CA certificates
YmerNode.ExtraCaCertificates
Avoid: root, root CA; CA bundle, trust store (for the extra CA certificates
or the combined set — the platform's own Mozilla bundle keeps its word); custom
CA; proxy certificate
F
fetch recipe
YmerNode.References.Sources.classify/2
Avoid: resolver, resolve, handler, fetcher
files directory
YmerNode.Script.Context.files_dir/1
Avoid: folder, files folder (the human word, never the term); node
files (the node's own things take that head — these files are the
user's); inbox, outbox, drop folder, gateway, share, exchange
directory; mount, volume (for it)
firing
The moment a schedule comes due in the node time zone; it starts a run, or is skipped when the node was not up or the schedule's previous run is still in flight. Avoid: occurrence, tick, run (for the moment), trigger
G
guide
The text scripts guide renders from the docs of YmerNode.Script and
YmerNode.Script.Context — each moduledoc and the documented types, callbacks
and functions beneath it: the script contract, the batteries, what a script
may call, the loop, the secrets and sharing flows — the same bytes the
published docs show, followed by one section the node computes at render: the
applications the running release carries. Rendered by YmerNode.Scripts.Guide.
Avoid: tutorial, manual, docs (for it), instructions (the MCP field), notes (the action key), help (the tool that names it)
H
handle
The name a session gives itself on a thread, passed as as; opaque to the
node, which keeps one read mark per handle and thread. By convention
<client>/<short role>, the client being the application the session runs
in, such as claude_code or cowork.
Avoid: participant (ymer's), sender, as (the field, not the term), identity
I
import
YmerNode.Scripts.import/1
Avoid: push (the verb before the rename — the CLI accepts it as a
synonym only), load (the loader's word for compiling a script into the
VM), upload, install (for a script)
interactive window
A headed Chromium the browser service opens on a storage state for a person, which owns that state's name while open and writes it back on a timer and on close. Avoid: headed browser, profile window, workbench, session
L
lifetime
How far into the future a schedule keeps firing — an end the node sets at add
or update, never more than 90 days ahead; past it the schedule is expired.
Read by YmerNode.Schedules.Lifetime.
Avoid: deadline (the one-run bound), expiry, TTL, duration (for it)
live output
YmerNodeDev.LiveOutput
Avoid: streamed output, streaming output, progress output, console
output, relay, sink, echo
M
membrane
Defined in YmerNode.References — the @moduledoc section stating that a
reference is a pointer, and that its content lives only in the cache.
Avoid: find-don't-re-document, pointer rule
message
YmerNode.Messages.Message
Avoid: store, mailbox, inbox (for what holds messages); post, note
N
node
A running Ymer Node: the application started from a release that carries
ymer_node.
Four other compounds stay qualified wherever they are meant: a BEAM node, a Mermaid node and an AST node, which are three other senses of the word, and the node database, which is this sense's own and is always named in full so it never reads as a bare node. Bare "node" in this repository's prose is always this entry.
node database
node.db, with its -wal/-shm companions beside it — the node's own
mix-managed database beside the store, whose schema this codebase owns and
migrates at boot. Rebuildable and never backed up: delete it and the next boot
recreates it empty. Until registry sync lands it holds the only copy of every
reference added on this node, and of every script authored here. The cache
entries live here too — the node database is not the cache, which is those
cache entries and the cache directory's files together.
Avoid: cache, node store, second store, node db
node time zone
YmerNode.Script.Context.time_zone/1
Avoid: timezone, time-zone; local zone, operator's zone, machine
zone, this node's zone (as terms — prose says "the node's time zone");
local time (a wall-clock reading, not a zone)
notebook
O
origin
YmerNode.Scripts.Script.origin/0
Avoid: provenance, source, door (the informal word in prose)
P
policy
The options the node merges underneath a script's own when a battery is called through the context — facts of the machine and the run a script never learns — so a script passes nothing and may override anything. A call that goes around the context carries none. Avoid: seam (for it — seam stays this repo's word for a join point, the references seam), wrapper, facade, defaults (bare — a package's own default is the package's), node defaults; client policy is ymer's term and stays qualified
promised package
A battery a script calls as a package: one the table in YmerNode.Script
§ What a script may call promises for one job, at the line its last column
names, whose own docs scripts info <name> renders from the release. What
the release carries beyond them is reachable and not promised.
Avoid: dependency (for it — every package in mix.exs is one; a promised
package is the subset the table names), library (the standing doc's word
for shared script code), battery (bare, for it)
R
read mark
Where one handle has read up to on one thread, kept by the node; check
returns what lies past it and moves it, read never does.
Avoid: cursor (read's next_cursor), offset, seen flag, bookmark
reference
YmerNode.References.Reference
Avoid: entry, bookmark, link; pointer (as the entity name — "pointer" stays
the informal concept word in membrane prose)
reference validator
Defined in YmerNode.Script — the moduledoc section on a URL action and the
cache: the string a script answers with a fetch and is handed back on the next.
Avoid: version (for it), etag, hash, stamp
references
YmerNode.References
Avoid: knowledge index, information router, reference layer
registry
The node's set of references: the rows in the node database the references
tool serves. Until registry sync lands, this registry is the only copy of them.
Avoid: index, knowledge index, catalog, reference layer. A process
registry — Elixir's Registry, or the name a supervised process is
registered under — stays compound-qualified wherever it is meant.
run
YmerNode.Scripts.Runner
Avoid: job
run tree
YmerNode.Script.Harness.run_tree/0
Avoid: throttle tree (it holds more than throttles), node processes,
script-run process subset; registry unqualified — a process registry stays
compound-qualified
S
safety backup
YmerNode.Notebook.Backup.restore/1
Avoid: undo anchor, regret button
schedule
YmerNode.Schedules.Schedule
Avoid: scheduling (bare), trigger, job, timer, cron (for the schedule — the
field is its cron expression)
script
YmerNode.Scripts.Script
Avoid: extension, plugin, program, integration (as the thing); tool (a script
is served by the scripts tool, it is not one)
script contract
YmerNode.Script
Avoid: behaviour (bare — the word for any Elixir behaviour), extension
contract, API
secret
YmerNode.Secrets
Avoid: credential, token (for it — a bucket's token is the throttle's word), env var, api key
serverInfo
Defined by wymcp; its definition lives there, not here. This node's
name and version on it come from application config, never from the
router option.
Avoid: server info, server identity
serving
Defined in YmerNode.Notebook — the @moduledoc section stating the serving
rule.
Avoid: ready, readiness, healthy, up (for serving), running (for serving —
YmerNode.Notebook.Repo.running?/0 keeps its structural meaning)
source
YmerNode.References.Sources.source/0
Avoid: system, kind, provider, classification (as the term — it is the
definition's word); origin (for the classification — the word names a script
row's provenance); source code, source file and open-source stay
compound-qualified, and a script's Elixir text is its code, never its
source
source declaration
YmerNode.References.Sources.declaration/0
Derived from an accepted script's declaration, which is the wider term.
Avoid: source config, host mapping, URL pattern
storage state
A browser session — cookies and localStorage per origin, Playwright's
storageState — that the browser service keeps by name for browser calls and
interactive windows to load and save; never a secret.
Avoid: named storage state, profile, session file, cookie jar, credential
store
The notebook's database file — notebook.db, with its -wal/-shm
companions beside it — the one thing the node keeps. A backup is a
single-file copy of it; a restore replaces it whole. Not the node database,
which sits beside it and is rebuildable.
Avoid: database file, db file, notebook file, the sqlite, the data (for the file). Never store as the verb for landing a script: a script is created, updated or imported, and the node holds it.
T
thread
The opaque key a message is posted to and read by, which the node compares and
never interprets; both sides know it before either session exists — by
convention a task's name or a table/row reference.
Avoid: topic, subject, tag, channel, room
thread header
The block opening a read {thread: …} answer: the thread's message count, last
activity, and each handle with its last send and last check.
Avoid: participants list
thread index
The answer to read {}: one row per thread with its message count, last
activity and handles; no bodies.
Avoid: thread list, inbox
throttle
YmerNode.Script.throttle/0
Avoid: gate, rate limiter, limiter, rate limit (the class, never the thing)
W
watch
Defined in YmerNode.Schedules — the @moduledoc section on watches: a
reference's own schedule, keeping its cache entry current for a bounded time.
Avoid: owned schedule, automatic refresh, auto-refresh, subscription
web fallback
YmerNode.Script.declarations/0, its web_fallback key
Avoid: default script, catch-all, wildcard host
what a row cannot say
A sentence the node writes beneath the table in YmerNode.Script § What a
script may call, stating a fact about a promised package that the package's
own docs do not — the node's knowledge, never library teaching.
Avoid: warning (a compiler's and a logger's word here), gotcha, caveat,
note
Y
Ymer Node
The open-source, headless local companion to ymer: an MCP node providing local capability — the notebook, the references registry and the scripts it accepts — to LLM workers whose coordination lives in ymer. One product together with ymer, and no UI of its own.
Avoid: Ymer Desktop, Ymer Local, Ymer Dev (all rejected as names); desktop app (it is headless, and has no window to show anyone).