Skip to content
Get in touch

House Architecture: House Lifecycle

Six verbs a component exposes so that downstreams assemble it, feed it and read it: install and uninstall, load and commit, busy and idle. Where each already lives in the code and what it folds.

By Bogdan Vladoiu, 2026-11-17

Six verbs that a component exposes so that downstreams assemble it, feed it and read it, instead of each one inventing a named type, a flag or a registry. Written from what recent ports actually needed, with the places in code where each verb already lives and the named things it would fold.

The contract

install { } / uninstall { } The seam for a constituent that can ship with or without. If a main can run without a piece, the piece arrives by install and leaves by uninstall; nothing else names its presence. Re-install is the reload.

load { } / commit { } Overloads per store: a component installed over several files or stores reads with load(from) and writes with commit(to). Separate from install, which only decides presence. Assignable to a dispatcher: commit { } = io { }.

busy() / idle() Status as a query of what is going on inside, never a copy that can drift. Backed by the real thing (a running job's isActive, a held trigger, a timer), not a flag set beside it. busy(what, until) only where the state is a timed claim.

Where the verbs already live

  • install / uninstall: 215 and 25 call sites. The core seam is apis/Api.kt (owner-keyed install(owner, key, …) / uninstall(owner, key)), with Settings.install(fs | store), the gun, body and hover rosters' install(fs), and each main's library game_install.
  • load / keep: apis/settings/Settings.kt carries load and keep as installed lambdas over Fs or Store. keep is the commit verb under another name; the only other keep is in Log.
  • commit: 97 sites, but most are the containers API (Kodman image commit), a different meaning. Models use .commit() as the update decoration from CLAUDE.md.
  • busy / idle / state: apis/execution/State.kt (state(word), busy(what, until), idle() on a props map) and C++ Game::Busy / Idle / State (10 and 4 uses, pfa's case hand first). These store the state in props with since and until, which is the copy the new rule warns can go out of sync; it fits timed claims, not running work.

Fold map: named things the verbs absorb

Verb Today (named or ad hoc) Where Folds to
install Each main lists the body sets one by one: notice, squad, enemy, trauma, cloak, throw, melee (six or seven lines in pfa and rounds) ue/pfa/…/Lib.kt, rounds/Declared.kt one core install(brain) that installs the combat sets; pfa and rounds call it once
install Texture generation behind the -textures commandlet flag; scans passed through an extra export KitBuild.cpp Textures(), Scanned(), game_scans the surface generators install into the mint on request; scans are a load of the generator's inputs
install Stale daemon: ue.shack kept the old palette and core until killed and respawned ue.kexe residency, Kit.measured uninstall then install of the library is the reload; no restart by pid to refresh data
uninstall Retiring a mesh needed four separate moves: palette row drop line, content delete, daemon restart, maps re-lay Palette.kt palette drop, build_run maps one uninstall(prop.van.fence) on the palette that commits the row and re-lays what referenced it
load Brain::Dialed(library) returns an FDials record from dial rows Brain.h/.cpp load of the brain's dials; same record, verb name
load JSON manifests read by the mint (surfaces, signs, cat2) and moved to rows or lists KitBuild.cpp a row kind is installed; the mint loads it; no per-file readers
commit Write-only-if-changed done by hand three times: PNG compare in Saved(), the input mint's match check, Brush.written() for chunks KitBuild.cpp, Brush.kt one commit contract: commit writes only a delta, so callers stop re-implementing it
commit A set during a test persisted immediately into tracked settings (wear tiers and deputy skin leaked into guard.bin, operator.bin, companion.bin) Settings.keep on every set set edits the loaded state; commit persists; a bench session that never commits leaves files untouched
busy / idle Flags and words kept beside the truth: bDocked, bSetDown, bSaddle, guard State and Duty, ally Refusal and bTold, operator bGunHeld Hover.cpp, Guard.cpp, AllyBrain.cpp, Operator.cpp queries over the source (is a seat filled, is the settle within range, is a trigger held); busy(what, until) only for timed claims
busy Texture mint idempotence, round running, package colliding with a live session proofs and build tools busy() on the tool answers "a session holds the stage" instead of a failed package

Rules

  • A piece a main can ship without is installed and uninstalled; its presence is never a flag, an enum or a list in the main.
  • Load and commit are the only verbs that touch a store; commit writes only what changed and can be pinned to a dispatcher (commit { } = io { }).
  • A set or dial edit is not a commit. Tests and benches edit loaded state; only an explicit commit persists.
  • Status is queried from what runs, not mirrored. A stored busy(what, until) is for a claim with a deadline; anything with a live source answers busy() from that source.
  • A reload is uninstall then install, never a process restart.

Open choices

  • Settings.keep is the commit verb; whether to rename it is open.
  • Whether the queried status verb is busy() / idle() alone or also a status() that returns the word.
  • Whether State.kt's stored form stays for timed claims only, with running work answering from its job.
  • Order: a fold pass at the end of the port versus folding the install bundle and the commit-only-on-change contract now, since both are small and touch no in-progress port.

ComputeShack

Small, good solutions.

[email protected]

Privacy policy · © 2026 ComputeShack