nervur 0.22.2-7 → 0.22.2-8

package/AUTHORING.md

@@ -11,8 +11,8 @@ The shop has three classes and one faculty.
 - `Order` is one order, from its first item to its shipping.
 - `Shop` is the steward, the being that runs the house.
 - `Lobby` is the public being, which strangers may ask.
-- `Payments` is a faculty that charges money, which a maker in
-  `recipe.ts` makes.
+- `Payments` is a faculty that charges money, which `recipe.ts` holds
+  by name.
 
 ## Words
 
@@ -32,7 +32,8 @@ The shop has three classes and one faculty.
 | state | a name read from her cells that decides which asks exist |
 | house | what holds beings, keeps their cells, and seals every ask |
 | ground | the process houses run in, holding one key and sealing their seeds, faculties and secrets under it |
-| registry | code that makes faculties and bodies by name, for the ground to stand |
+| registry | code that holds faculties by name, for the ground to stand |
+| body | a faculty stood: the living instance houses and bodies use |
 
 ## A being
 
@@ -588,8 +589,8 @@ type Answer = { result: { pending: boolean } } | { error: { message: string } };
 /**
  * A payment provider in the ground's process. It answers a call id it has
  * seen with the answer it gave, so an effect sent twice charges once. A
- * provider that changes the world keeps these in the memory its maker
- * receives, where a restart and a move keep them.
+ * provider that changes the world keeps these in the memory its faculty's
+ * `up` receives, where a restart and a move keep them.
  */
 export class Payments {
   readonly #answered = new Map<string, Answer>();
@@ -619,19 +620,19 @@ export const paymentsOffer = (payments: Payments): Offer => ({ blueprint: Paymen
 
 An offer is `{ blueprint, object, kinds?, window? }`. The object answers
 each call with its call id, and one that changes the world answers a
-call id it has seen with the answer it gave. A registry holds a maker
-for each faculty by name. The ground stands a faculty when an entry names
-its maker, and the entry's `kinds` grants it to the classes it names.
-[Writing a faculty](FACULTIES.md) teaches the craft whole, with a faculty
-written in Python.
+call id it has seen with the answer it gave. A registry holds each
+faculty by name, as `{ up, install? }`. The ground raises a faculty by
+its `up` when an entry names it, and the entry's `kinds` grants it to
+the classes it names. [Writing a faculty](FACULTIES.md) teaches the
+craft whole, with a faculty written in Python.
 
 ```ts
 // recipe.ts
 import { Payments, paymentsOffer } from './payments.ts';
 
-// A registry: the ground makes each faculty an entry names, by its maker here.
+// A registry: the ground raises each faculty an entry names by its `up` here.
 export const faculties = {
-  payments: () => paymentsOffer(new Payments()),
+  payments: { up: () => paymentsOffer(new Payments()) },
 };
 ```
 
@@ -681,14 +682,16 @@ The ground boots in one order, and a stop is that order reversed, on an
 interrupt and on `SIGTERM`.
 
 1. **Lock.** One ground to its state.
-2. **Key.** Its key is read from `state/key`, drawn there on the first
-   start.
-3. **Drawer.** Its ledger opens, and the key opens its drawer.
-4. **Ladder.** Each faculty its drawer names stands on its registry. One
-   that fails stays down, and says why.
-5. **Houses.** Each house of the drawer opens on its bodies.
-6. **Hook.** The listeners, then the hand on its socket.
-7. **Ready.** It tells systemd it is up, where systemd waits.
+2. **Primordial.** Its unlock, its ledger, crypto and tools go up. Its
+   key is read from `state/key`, drawn there on the first start.
+3. **Drawer.** The key opens its drawer in the ledger.
+4. **Entries.** The drawer's entries join the defaults its environment
+   gives, the drawer's winning by name.
+5. **Ladder.** Each body is installed where its entry is new, and goes
+   up. One that fails stays down, and says why.
+6. **Houses.** Each house of the drawer opens on its bodies, and its
+   door joins the carry.
+7. **Ready.** The hand takes its socket, and it tells systemd it is up.
 
 It is set by its environment.
 
@@ -714,7 +717,7 @@ lost key is a lost ground.
 
 The ladder stands once, and the ground stands it again at every start.
 The first entry stands the folder's `recipe.ts` as a registry, by the
-ground's own maker `module`. The second makes the payments from it.
+ground's own faculty `module`. The second raises the payments from it.
 
 ```bash
 npx nervur faculties add name=recipe make=module args='{"at":"recipe.ts"}'
@@ -727,19 +730,21 @@ npx nervur faculties add name=payments from=recipe make=payments
 A house is added once, and the ground opens it again at every start.
 
 ```bash
-npx nervur houses add name=shop classes='{"body":"folder","at":"classes"}' faculties='["payments"]'
+npx nervur houses add name=shop classes='{"faculty":"folder","at":"classes"}' faculties='["payments"]'
 ```
 
-`classes` names the body of the house's code. `folder` is the ground's
-own, and a registry may add more, a git repository among them. A house
-keeps its rows in the ground's ledger unless its entry names a `memory`
-body. `faculties` names what the house receives, and within it each
-faculty's entry names in `kinds` the classes that hold it.
+`classes` names the faculty whose body serves the house's code. `folder`
+is the ground's own, and a registry may add more, a git repository among
+them. A house keeps its rows in the ground's ledger unless its entry
+names a `memory` faculty. `faculties` names what the house receives, and
+within it each faculty's entry names in `kinds` the classes that hold
+it. `houses update` and `faculties update` land a new entry in one
+write, and `faculties restart` takes a body down and up again.
 
 A secret reaches a faculty the same way, and never through the
 environment. `npx nervur secrets set -` reads `{ name, value }` from
 standard input into the ground's sealed drawer. A faculty's entry names
-the secrets its maker receives in `secrets`.
+the secrets its `up` receives in `secrets`.
 
 ### The hand
 
@@ -811,10 +816,10 @@ in a named house.
 
 Its bodies are the browser's. The ground's key is sealed under an AES
 key that IndexedDB holds unextractable, and its memory is IndexedDB.
-Classes load from the page's own origin through the `origin` body, `{
-body: 'origin', at: '/house/index.js' }`, and a path off the origin is
-refused. The registry is the object you pass: makers of faculties, and
-of any custom body, beside the terrain's own.
+Classes load from the page's own origin through the `origin` faculty, `{
+faculty: 'origin', at: '/house/index.js' }`, and a path off the origin
+is refused. The registry is the object you pass: faculties by name,
+foundation and custom alike, beside the terrain's own.
 
 Any script on the origin can use the ground's keys, so the ground is
 whoever serves the origin's script. Give it an origin of its own, serve
@@ -841,7 +846,7 @@ app's web view, on two interfaces the shell fills in native code:
 The library holds the rest. The ground's key goes into the secret store,
 and its memory into the native store, which the system never evicts as
 it may a web view's storage. A push token reaches the ground through a
-faculty your registry makes.
+faculty your registry holds.
 
 ## What the house guarantees
 
@@ -899,7 +904,8 @@ at her call, or where an ask arrives.
 - A call on the house beside `House.open`, `door` and `ask`.
 - A faculty in a house's code. Faculties are the ground's.
 - A drawer opened with a key that did not seal it.
-- A secret read by a being, a describe or anyone but a maker its entry
-  names.
+- A secret read by a being, a describe or anyone but a faculty whose
+  entry names it.
+- A faculty raised any way but its `up`, foundation or custom.
 - A faculty entry for `secrets` or `moves`, which the hand alone reaches.
 - A ground an owner must write. Each terrain's ships.

package/COMMAND.md

@@ -71,13 +71,15 @@ npx nervur help
 
 A faculty is called by its name and a method. Named alone, it prints its
 methods. Four faculties are the ground's own. `secrets` keeps a secret
-in the ground's sealed drawer. `faculties` stands a faculty on the maker
-its entry names, and `houses` opens a house on its entry.
+in the ground's sealed drawer. `faculties` raises a faculty by the `up`
+its entry names, and `houses` opens a house on its entry. Each takes
+`update` to land a new entry in one write, and `faculties restart`
+takes a body down and up again.
 
 ```bash
 npx nervur faculties add name=recipe make=module args='{"at":"recipe.ts"}'
 npx nervur faculties add name=payments from=recipe make=payments secrets='["stripe-key"]'
-npx nervur houses add name=main classes='{"body":"folder","at":"house"}' faculties='["payments"]'
+npx nervur houses add name=main classes='{"faculty":"folder","at":"house"}' faculties='["payments"]'
 ```
 
 `ask` asks a being of a house, as the house's owner. `--id <being>` names

package/FACES.md

@@ -106,11 +106,12 @@ tries again acts once.
 
 ```ts
 // api.ts
-import type { Faculty, FacultyContext, Handler } from 'nervur';
+import type { Body, FacultyContext, Handler } from 'nervur';
 import { need, s, type Json } from 'nervur/being';
 
 type Answer = Awaited<ReturnType<FacultyContext['call']>>;
 type Entry = { method: string; description?: string; args?: Json; hints?: Json };
+type Calls = Pick<FacultyContext, 'call' | 'describe'>;
 
 /** What the steward arms the face with. */
 export const FaceBlueprint = need('face', {
@@ -124,7 +125,7 @@ export const FaceBlueprint = need('face', {
  * asks to an agent as tools.
  */
 export class Api {
-  #context: FacultyContext | undefined;
+  #context: Calls | undefined;
   #signup = '';
   #calls = 0;
 
@@ -134,7 +135,12 @@ export class Api {
     return Promise.resolve({ result: null });
   }
 
-  #held(): FacultyContext {
+  // Told its house opened: every door's token answers from the first request, after any restart.
+  opened(context: Calls): void {
+    this.#context = context;
+  }
+
+  #held(): Calls {
     if (this.#context === undefined) throw new Error('the face is not armed');
     return this.#context;
   }
@@ -179,8 +185,8 @@ export class Api {
   };
 }
 
-/** The offer a ground hands: the blueprint, the object, and its handler on the ground's listener. */
-export const apiOffer = (api: Api): Faculty => ({ blueprint: FaceBlueprint, object: api, handler: api.handler });
+/** The face as a body. */
+export const apiOffer = (api: Api): Body => ({ blueprint: FaceBlueprint, object: api, handler: api.handler, opened: (context) => api.opened(context) });
 ```
 
 **The describe maps onto tools by renaming.** An ask is a tool, its
@@ -190,19 +196,19 @@ tools.
 
 ## The registry
 
-The ground makes the face from a registry, as it makes any faculty. A
-NodeGround stands the module below with the maker `module`, and the
-face from it by an entry that names `from`. The house's entry names
-`face` among its faculties, and the steward's `arm` hands the face its
-signup.
+The ground raises the face from a registry by its `up`, as it raises any
+faculty. A NodeGround stands the module below with the faculty
+`module`, and the face from it by an entry that names `from`. The
+house's entry names `face` among its faculties, and the steward's `arm`
+hands the face its signup.
 
 ```ts
 // recipe.ts
 import { Api, apiOffer } from './api.ts';
 
-// A registry: the ground makes the face when an entry names its maker.
+// A registry: the ground raises the face by its `up` when an entry names it.
 export const faculties = {
-  face: () => apiOffer(new Api()),
+  face: { up: () => apiOffer(new Api()) },
 };
 ```
 

package/FACULTIES.md

@@ -15,11 +15,13 @@ the package's own tests run.
 ## What a faculty owes
 
 A faculty answers a blueprint: a name, and methods with their schemas.
-A maker in a registry makes it, and the ground hands it to its houses as
-an offer, with the kinds its entry grants.
+A registry holds it by name as `{ up, install? }`. The ground raises it
+by its `up` into a body, and hands the body to its houses as an offer,
+with the kinds its entry grants.
 
 ```text
-faculty = { blueprint?, object?, window?, handler?, stop?, registry? }
+faculty = { install?, up }
+body    = { blueprint?, object?, window?, handler?, registry?, down? }
 offer   = { blueprint, object, kinds?, window? }
 ```
 
@@ -45,7 +47,7 @@ answered, with the same call id every time.
 So one call arrives more than once. A reply lost on its way back brings
 it again, and so does a program that died before it answered. A faculty
 that changes the world keeps each call id with the answer it gave, in
-the memory its maker receives, where a restart and a move keep it. It
+the memory its `up` receives, where a restart and a move keep it. It
 answers a call id it has seen with that answer, and acts once.
 
 It keeps them for its `window`, seven days where the offer names none.
@@ -84,10 +86,10 @@ reaches her through a standing, so policy is written as a being.
 
 ### It lives in the ground
 
-The object arrives living. The ground stands each faculty its entries
-name, awaiting its maker, and the house never starts, stops or restarts
-it. Every being whose need it covers holds the same object. A maker
-receives three things beside the faculty's name.
+The object arrives living. The ground raises each faculty its entries
+name, awaiting its `up`, and the house never starts, stops or restarts
+it. Every being whose need it covers holds the same object. Its `up`
+receives four things beside the faculty's name.
 
 - **`args`** are its entry's, as the owner wrote them.
 - **`secrets`** are the secrets its entry names, set through the hand
@@ -95,20 +97,31 @@ receives three things beside the faculty's name.
 - **`memory`** is the faculty's own, a view of the ground's memory
   sealed under a key the ground derives for it. Its call ids live there,
   so they move with the ground.
+- **`faculties`** holds the object of each body its entry names in
+  `faculties`, so one body calls another directly. It goes up after
+  each of them.
 
-A faculty answers four things beside its methods, each where it has
-one.
+`install` receives the same, and does the slow work once for each entry.
+A program's packages and a repository's checkout are installed there, so
+going up again installs nothing.
+
+A body answers four things beside its methods, each where it has one.
 
 - **`handler`** answers HTTP on the ground's one listener. It takes a
   `Request` and answers a `Response`, or `null` where the request is not
-  its own. A site, an API or an MCP server is a faculty with a handler.
-- **`stop`** is called when the ground stops, faculties in the reverse
-  of the order they stood.
-- **`registry`** makes more faculties and bodies, for every entry that
-  names this faculty in `from`. A module of code, a git repository and a
-  program's catalogue are each a registry.
+  its own. A site, an API or an MCP server is a body with a handler.
+- **`down`** lets go of what its `up` opened. The ground calls it when
+  the body is updated, restarted or removed, and when the ground stops,
+  bodies in the reverse of the order they stood.
+- **`registry`** holds more faculties, for every entry that names this
+  body in `from`. A module of code, a git repository and a program's
+  catalogue are each a registry.
 - **`window`** is how long it remembers a call id.
 
+The hand changes a body. `faculties update` lands a new entry, and the
+body goes down and up on it. `faculties restart` takes it down and up on
+the same entry. Each house that names it opens again.
+
 ## Three ways to wrap a program
 
 | Way | What the object is | What a crash takes |
@@ -120,7 +133,7 @@ one.
 ## The bridge
 
 `bridge({ command, args, env, cwd, memory })` from `nervur/node` starts
-a program and answers a faculty. A NodeGround makes one by the maker
+a program and answers a body. A NodeGround raises one by its faculty
 `bridge`, from its entry alone. The program may be written in any
 language. It speaks one JSON value a line on its standard streams.
 
@@ -143,7 +156,7 @@ in   { id, result } | { id, error }      the ground's answer to that
   the same every time that call is sent, in every life of the program.
   A handle called with no `call` is refused.
 - **It starts with an empty environment.** It holds only what `env`
-  names, so it never reads the ground's key. The maker `bridge` names
+  names, so it never reads the ground's key. The faculty `bridge` names
   there the secrets of its entry, each under its name.
 - **It keeps its state in the faculty's memory.** A memory line names
   `read`, `list` or `write` and the memory's args, every entry's bytes
@@ -365,8 +378,8 @@ it later, once.
 
 The Pi's folder holds the program and a folder of classes for its
 house, and no code of the ground's. The relay stands from its entry,
-made by the NodeGround's own maker `bridge`, and granted to the twin's
-class alone.
+raised by the NodeGround's own faculty `bridge`, and granted to the
+twin's class alone.
 
 ```bash
 npx nervur faculties add name=relay make=bridge args='{"command":"python3","args":["relay.py"]}' kinds='["org.example.garage"]'
@@ -376,7 +389,7 @@ The house is added once, and names the relay among the faculties it
 receives.
 
 ```bash
-npx nervur houses add name=garage classes='{"body":"folder","at":"classes"}' faculties='["relay"]'
+npx nervur houses add name=garage classes='{"faculty":"folder","at":"classes"}' faculties='["relay"]'
 ```
 
 Both entries rest sealed in the ground's drawer, so the ground stands
@@ -423,16 +436,16 @@ serve(Doorbell, {
 });
 ```
 
-Its entry makes it with the maker `bridge`, its command `node` and its
-args `["doorbell.js"]`. A faculty that needs no process of its own is a
-plain object a registry's maker answers instead, as the shop's payments
+Its entry raises it with the faculty `bridge`, its command `node` and
+its args `["doorbell.js"]`. A faculty that needs no process of its own
+is a plain object its `up` answers instead, as the shop's payments
 are in [Writing for nervur](AUTHORING.md).
 
 ## Testing a faculty
 
 A faculty is tested on BenchGround, the ground in memory from
 `nervur/bench`, with the program itself behind the bridge. The test
-hands the bench a registry whose maker bridges the program, as a
+hands the bench a registry whose `bridge` faculty bridges the program, as a
 NodeGround's own does, and stands the relay through the ground's hand,
 as an owner does. A `FakeNetwork` joins
 grounds and loses what the test tells it to lose, and its one clock
@@ -476,7 +489,7 @@ test('Each tap on the phone pulses the relay once, whatever fails between', { ti
     host: 'pi',
     names: ['garage.local'],
     modules: { pi },
-    registry: { faculties: { bridge: ({ memory }) => bridge({ command: 'python3', args: [relay], cwd: pin, memory }) } },
+    registry: { faculties: { bridge: { up: ({ memory }) => bridge({ command: 'python3', args: [relay], cwd: pin, memory }) } } },
   });
   t.after(() => garage.down());
   // The relay, granted to the twin's class alone.

package/GROUNDS.md

@@ -26,35 +26,52 @@ house seals its own rows, and the ground seals each faculty's. So what
 rests on the disk is ciphertext, and copying the key, the memory and the
 code moves the whole ground.
 
-**It stands its faculties on a ladder.** A registry is code that makes
-faculties and bodies by name. The ground's own registry is its
-terrain's. A faculty may carry a registry of its own, and the faculties
-an entry makes `from` it stand after it. A faculty that fails to stand
-stays down and says why, and the ground boots beside it.
+**Every faculty has one lifecycle.** A registry holds faculties by name,
+each an object `{ up, install? }`. Standing a faculty raises it by its
+`up` into a body, the living instance houses and other bodies use.
+`install` does the slow work once for each entry. A body's `down` lets
+go of what its `up` opened. A foundation body says what it `serves`: a
+carry, the clock, or each house's memory or code.
+
+**It stands its bodies on a ladder.** The ground's own registry is its
+terrain's. A body may carry a registry of its own, and the faculties an
+entry raises `from` it stand after it. A body stands after each body its
+entry names in `faculties`, whose objects its `up` receives. A body that
+fails to stand stays down and says why, and the ground boots beside it.
+
+**Its terrain names default entries, and the drawer's win.** Each ground
+stands its clock, its carries and its bodies of code from entries of its
+own. An entry of the same name in the drawer stands in its place.
 
 ```text
 recipe    { make: 'module', args: { at: 'recipe.ts' } }
 payments  { from: 'recipe', make: 'payments', secrets: ['stripe-key'], kinds: ['com.acme.order'] }
 ```
 
-**It opens each house on its entry.** An entry names the body of the
-house's code, the custom faculties it may use, and the longest any of
-its asks may run. It names a body of memory only where the house keeps
-its places apart from the ground's memory.
+**It opens each house on its entry.** An entry names the body that
+serves the house's code, the custom faculties it may use, and the
+longest any of its asks may run. It names a body serving memory only
+where the house keeps its places apart from the ground's memory. Beside
+each body's name, it holds the args that body hands this house.
 
 ```text
-shop  { classes: { body: 'folder', at: 'shop' }, faculties: ['payments'], wait: 60000 }
+shop  { classes: { faculty: 'folder', at: 'shop' }, faculties: ['payments'], wait: 60000 }
 ```
 
+**It updates an entry in one write.** `update` lands the new entry over
+the old. A house closes and opens again on it, as the same ward. A body
+goes down, installs where its entry moved, and goes up, and each house
+naming it opens again. `restart` takes a body down and up on its entry.
+
 **It grants a faculty in two steps.** A house uses only the faculties its
 entry names. Inside it, a being holds one only where the faculty's entry
 names her class in `kinds`, or where it names none. So a raw shell
 reaches one house and one class inside it.
 
-**It hands each maker its secrets.** A secret is set through the hand
-and kept in the drawer. A faculty's entry names the secrets its maker
+**It hands each faculty its secrets.** A secret is set through the hand
+and kept in the drawer. A faculty's entry names the secrets its `up`
 receives, and no other code reads one. The hand lists their names, and
-never a value.
+never a value. A changed secret reaches a body when it goes up again.
 
 **It hooks every door and runs one listener.** Each house's door goes to
 the ground's carry, which also delivers between the ground's own houses
@@ -68,8 +85,8 @@ as the house's owner. Four faculties are the ground's own.
 
 | Faculty | Its methods | Who reaches it |
 | --- | --- | --- |
-| `houses` | `add`, `remove`, `list` | the hand, and the kinds its entry grants |
-| `faculties` | `add`, `remove`, `list` | the hand, and the kinds its entry grants |
+| `houses` | `add`, `update`, `remove`, `list` | the hand, and the kinds its entry grants |
+| `faculties` | `add`, `update`, `restart`, `remove`, `list` | the hand, and the kinds its entry grants |
 | `secrets` | `set`, `remove`, `list` | the hand alone |
 | `moves` | `out`, `in` | the hand alone |
 
@@ -108,11 +125,18 @@ shows. The ground's folder is an ES module package, so its
 port is set, on the web. [The command](COMMAND.md) lists its settings
 and runs its hand.
 
-**Its registry makes three things.** The body `folder` loads a house's
-classes from a folder inside it. The maker `module` imports a module
-inside it as a registry, whose `faculties`, `memory` and `classes` are
-maps of makers. The maker `bridge` starts a program, in any language,
-and hands it the secrets its entry names as its environment.
+**Its registry holds its terrain's faculties.** `folder` serves each
+house its classes from a folder inside it. `module` imports a module
+inside it as a registry, whose `faculties` export holds `{ up, install? }`
+by name. `bridge` starts a program, in any language, and hands it the
+secrets its entry names as its environment. `tcp` and `web` are its
+carries, and `clock` its clock.
+
+**Its environment gives the default entries.** `clock`, `folder`, `tcp`
+and `web` stand from entries its settings write. An entry of the same
+name in the drawer stands in their place, so a port changes through the
+hand. A `tcp` entry whose args name no port only dials, and its
+invitations name no TCP address.
 
 **Its key rests in `state/key`, its owner's alone.** A key file others
 may read is refused, as ssh refuses a key. On macOS,
@@ -151,9 +175,9 @@ export default EdgeGround.worker();
 ```
 
 The Worker binds the object's class as `GROUND`, with SQLite storage.
-`registry` joins the terrain's own, so an entry makes `payments` with no
-`from`. A house's entry names its code with `classes: { body: 'bundle',
-at: 'shop' }`.
+`registry` joins the terrain's own, so an entry raises `payments` with
+no `from`. A house's entry names its code with `classes: { faculty:
+'bundle', at: 'shop' }`.
 
 **Its settings are the Worker's.**
 
@@ -167,8 +191,9 @@ at: 'shop' }`.
 | `NERVUR_WAIT` | the longest any ask may run, a minute where unset |
 
 A Worker learns no name it is reached by, so it writes only the
-addresses `NERVUR_ADDRESSES` names. Its faculties take their secrets
-from its drawer, as on every ground.
+addresses `NERVUR_ADDRESSES` names. These settings give the default
+entry of its web carry, and an entry in the drawer stands in its place.
+Its faculties take their secrets from its drawer, as on every ground.
 
 **Its hand answers its key alone.** The hand is `POST /nervur/hand`, with
 the key as a bearer token and one request as the body. Every other
@@ -196,8 +221,8 @@ ground, so its origin serves nothing else.
 [The package's start](README.md) opens one in a page.
 
 **Its registry is the one the page hands.** `BrowserGround.open({
-registry })` joins it to the terrain's own, whose body `origin` loads a
-house's classes from the origin.
+registry })` joins it to the terrain's own, whose faculty `origin`
+serves each house its classes from the origin.
 
 **An AppGround is a BrowserGround with the shell's bodies.** The shell
 hands in two small interfaces, one for secrets and one for a store, and

package/README.md

@@ -100,7 +100,7 @@ In a second shell, add the house once. The ground keeps its entry in its
 sealed drawer, and opens it again at every start.
 
 ```bash
-npx nervur houses add name=main classes='{"body":"folder","at":"house"}'
+npx nervur houses add name=main classes='{"faculty":"folder","at":"house"}'
 ```
 
 Then ask the steward through the ground's hand.
@@ -132,7 +132,7 @@ const ground = await BrowserGround.open();
 await ground.hand({
   faculty: 'houses',
   method: 'add',
-  args: { name: 'main', classes: { body: 'origin', at: '/house/index.js' } },
+  args: { name: 'main', classes: { faculty: 'origin', at: '/house/index.js' } },
 });
 
 console.log(await ground.hand({ house: 'main', method: 'hello', args: { name: 'Ada' } }));

package/dist/bench/bench-ground.d.ts

@@ -1,4 +1,4 @@
-import { ClassList, Ground, type Faculty, type Registry } from '../index.ts';
+import { ClassList, Ground, type Body, type Registry } from '../index.ts';
 import { FakeMemory } from './fake-memory.ts';
 import { type FakeNetwork } from './fake-network.ts';
 import { FakeUnlock } from './fake-unlock.ts';
@@ -13,8 +13,8 @@ export interface HouseModule {
     readonly public?: BeingClass;
     readonly beings?: readonly BeingClass[];
 }
-/** A faculty the test writes, living, with the kinds it is granted. */
-export type Living = Faculty & {
+/** A body the test writes, living, with the kinds it is granted. */
+export type Living = Body & {
     readonly kinds?: readonly string[];
 };
 /** What a ground keeps across its lives: its key, its randomness, its memory, and each house's own where it names the `fake` body. */