A suite's test: a test definition that runs a package's command (its `bin`) as a program, as the people using it would. The package's manifest declares them (`suites`: command → namespaces), and the test finds the command in the environment variable named for it (`binVariable`).
The code a build of a command has (a package packed from the codebase): its modules, by their components' hashes. A result kept for code a test ran holds against the build if the build has all of that code; an older tcm.js, or a build that isn't the codebase's, has none of it, and the test runs.
The codebase's definitions a run executed, from the V8 coverage its processes wrote to `dir`: each one's own code, by name. A component's module counts as executed if a function in it ran, or if loading it does something. A class counts by the methods that ran (`Class#method`, each its own code: memberCode) and the rest of it (`Class#`), so a change to a method a run didn't use leaves its result. A constant whose value is written out (isLiteralValue), or computed doing nothing on load but make it (quietLoad), counts only when what ran refers to it, with what its value names: a change to it matters only to the code that reads it. A computed one also counts if a function in it ran, or if state its computation could change counts.
A class's own code as a suite's result depends on part of it: one of its methods (`member`, by name: what that method does), or, for `""`, the rest of it (its fields, constructor and what it extends, its methods but their bodies), which every use of it depends on. Undefined if it has no such method. Referring to other definitions by name, as `ownCode` does (`nameOf` as it takes it).
A definition's own code, as a suite's result depends on it: its IR, referring to other definitions by name rather than hash. A definition the suite didn't run changing re-hashes the ones using it, but leaves what the suite did as it was. Named as they're named now, or by `nameOf` (as a run started: executed); one with no name, by hash.
Whether loading a computed constant does nothing anyone could see but make its value; if so, the state computing it could change: by hash, what holds state (an object, an array, a `let`, a class, a computed value) among the definitions its computation uses, through what they use, and any it assigns to. Its computation is its initializer less what it only holds: a function or a definition written into its value (`run: (a) => …` in an object in an array), not passed to anything, isn't called or used by loading it. Loading it does something (undefined) if that code reaches outside (`reaches`: the clock, files, the network, the environment, output), uses an npm package not known to be pure, uses a global other than JavaScript's own (QUIET_GLOBALS: not `globalThis`, `process` or timers), assigns to one or a built-in's prototype, imports a module, or waits; and, to be sure, if it isn't a `const` of one name alone in its component.
Run a suite's test as a program of its own (passing if it returns), its command being `entry`: its result, and what it executed (named as `names` had it when the run started: executed).
Run suites against the codebase's own build of their commands (or `builds`, by command), reusing results. A test's result holds until it changes, or the code of a definition it executed does: one it didn't run can't change what it does without one it ran changing too. Each suite keeps its passing runs for several versions of that code (KEPT_RUNS), so a result holds again when the code it ran is back as it was (another branch's tests having run between). A test that executed nothing of the codebase always runs, and so does one that failed: a program can fail for what's around it (its environment, a machine's state), not its code, and a failure kept would outlive that. `fresh` runs them all.
The apps the package at `namespace` ships (`apps` in its manifest), packed as `tcm pack` packs them, for its command run from this codebase (as suites run it, not from a package): a directory holding `<name>/codebase.sqlite` for each, made once for those apps' hashes, which the command finds by `TCM_APPS`. Undefined if it ships none.
The tcm libraries the package at `namespace` ships (`libraries` in its manifest), packed as `tcm pack` packs them, for its command run from this codebase (as suites run it, not from a package): a directory holding their `codebase.sqlite`, made once for those releases, which the command finds by `TCM_SHIPPED_LIBRARIES`. Undefined if it ships none.
Whether every tcm a suite ran has ended, waiting up to `ms` for them: each says it ran (`tcm-pid-<pid>` in the suite's coverage directory), and writes the code it ran there as it ends. One still running, its test having stopped it without waiting, would be missed; one that won't end means what ran isn't known.
How many runs each suite keeps, newest first: one for each version of the code it ran, so that branches tested by turns (sessions side by side on one codebase) don't each run again what the other ran.
How kept runs record what they ran (SuiteRun's `format`); unpackRuns drops runs recorded another way. 2: each definition by the name it had when the run started, and a run that executed code nothing follows not kept (executed). Runs from before (no format) named what ran as it was named when the run ended, so one a save replaced meanwhile went unrecorded, and the run held for every later version of it.
JavaScript's own globals, which do nothing for being used: a computed constant may use them and still do nothing on load. (Members of them that do are effects, as `reaches` has them: `Date.now()`, `Math.random()`.)
A constant whose value is written out (a string, a template, an object or array of such, functions in it included), not computed: loading it calls nothing, so it does nothing but be there. What a run did depends on it only through the code that ran reading it.
This branch's definitions' names, by hash (the first, as `pathsOf` has it): one query, to name what a run executes as it was when the run started (executed).
Kept runs, by suite, as the codebase keeps them (its `suites` setting): each name a run executed is written once, and runs name them by index, since suites run much of the same code.
The kept runs packRuns wrote; none from anything else (runs kept by an earlier tcm, another way), nor runs recording what they ran another way than this tcm does (KEPT_RUN_FORMAT): they're dropped when runs are next kept.