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
bind marker
The empty file the node's image writes at build, at a fixed path the release checks at boot; its presence is what makes the release bind all interfaces inside the container, and nothing else does.
Avoid: bind flag, wide-bind switch, bind env (there is no variable)
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 release's operator verbs — bin/ymer-node, the overlay beside the release's
own launcher — run by a human on the machine the node runs on; the node's own
human door, beside the client's approval. Implemented by
YmerNode.Scripts.CLI.
Avoid: shell (the distribution's menubar app), 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
deploy
Mix.Tasks.YmerNode.Deploy
Avoid: upgrade, redeploy
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 image ships and a fresh install 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)
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 — the mount is /data, which holds
it); FILES_PATH names the variable that sets it, never the directory
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)
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)
install
The kept copy of the node on a machine: the directory holding its store, its
secrets.env and the compose file, and the container compose runs from there.
Stopped or removed, the container leaves the install in place; the checkout's
smoke on its own port is not one — nothing there is kept.
Avoid: install dir (as a term of its own — the install's directory is the install), the directory you keep, runner compose, prod (as a noun for it)
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
Mix.Tasks.YmerNode.Build.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
N
node
A running Ymer Node install.
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");
TZ names the variable that sets it, never the fact; 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
reference
YmerNode.References.Reference
Avoid: entry, bookmark, link; pointer (as the entity name — "pointer" stays
the informal concept word in membrane prose); image reference stays
compound-qualified for the Docker sense in Mix.Tasks.YmerNode.Deploy
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.
revision
The git commit a build was made from, as its short sha, marked when the tree
was dirty. An image built from a git checkout carries it three ways: as the
OCI revision label, as the ymer-node:<revision> tag, and inside
serverInfo.version as <version>+<revision>. A build that could name none —
no git, or no work tree — carries it nowhere and answers the bare version.
Avoid: stamp, sha stamp, build id
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 — data/ is the install's directory, which holds the store).
Never store as the verb for landing a script: a script is created,
updated or imported, and the node holds it.
T
tag invariant
Defined in Mix.Tasks.YmerNode.Build — the @moduledoc section on what moves
ymer-node:latest.
Avoid: latest invariant, tag rule
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, Docker-shipped, 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).