nervur 0.21.5 → 0.22.0

package/README.md

@@ -21,42 +21,62 @@ a disk and needs Node's file system.
 ## A harbor where you run
 
 ```js
+import { readFile } from 'node:fs/promises';
 import { Harbor } from 'nervur';
-import * as greetings from './greetings.js';
 
-const harbor = await Harbor.open({ modules: [greetings] });
+const harbor = await Harbor.open();
+await harbor.ask({ method: 'stand' });
+const source = await readFile('./greetings.js', 'utf8');
+await harbor.ask({ method: 'ask', args: { being: 'catalogue', method: 'add', args: { source } } });
 ```
 
+A harbor is asked and nothing else. `harbor.ask` takes one root request,
+`{ ward?, method?, args? }`, asks the box ward, or the hosted ward named,
+as its root, and answers one plain JSON value. `arrive`, `holds` and
+`close` are the rest of what a program holds of a harbor.
+
 With no terrain, the harbor picks its ground's bodies itself. In Node it
 keeps itself in a folder, `where` if you name one, else `$NERVUR_DIR`,
-else `~/.nervur`, speaks TCP and, where you open them, the web and Web
-Push, and serves its root line, so the `nervur` command below asks it
-while it stands. A folder opens in one run at a time. Bundled for a
-browser, in a page or a worker, it keeps itself in the IndexedDB
-database `where` names, else `nervur`, its seed sealed under a key the
-browser never hands out, speaks the web, and opens in one run at a time.
+else `~/.nervur`, speaks TCP and the web where you open them,
+and serves its root line, so the `nervur` command below asks it while it
+stands. A folder opens in one run at a time. Bundled for a browser, in a
+page or a worker, it keeps itself in the IndexedDB database `where`
+names, else `nervur`, its seed sealed under a key the browser never hands
+out, speaks the web where you open it, and opens in one run at a time.
 On Cloudflare Workers it is one Durable Object of many a worker carries,
+running in a child worker the object loads for the commit `live` names,
 answering Quo at `/<name>/quo` on whatever host reaches it, and asking
-over TCP and the web. Anywhere
-else it lives as long as its process and speaks the web. Hand in a
-terrain, as below, and that one is used.
+over TCP and the web. Anywhere else it lives as long as its process and
+speaks the web where you open it. Hand in a terrain, as below, and that
+one is used.
+
+Nothing enters a harbor unasked. A new harbor holds its catalogue alone,
+and a carrier stands only once the root opens it:
+
+```js
+await harbor.ask({ method: 'open', args: { key: 'web', class: 'org.nervur.web' } });
+```
 
 ## A harbor on the edge
 
 An edge harbor is born on your machine and carried there, so you pilot it
-from your own harbor, as you pilot one on a server. One worker carries as
-many harbors as you pack into it, each a Durable Object by its name,
-answering at `/<name>/quo`. The worker is a folder of its own, an ES
-module project (`"type": "module"` in its `package.json`), holding the
-worker and its `wrangler.toml`:
+from your own harbor, as you pilot one on a server, and you move its code
+the same way, with no deploy. One worker carries as many harbors as you
+pack into it, each a Durable Object by its name, answering at
+`/<name>/quo`. The worker is a shell: it keeps each harbor's storage and
+its web door, and runs the harbor, the kit and the modules its `live`
+commit holds, in a child worker Cloudflare's Worker Loader makes of them.
+The worker is a folder of its own, an ES module project (`"type":
+"module"` in its `package.json`), holding the worker and its
+`wrangler.toml`:
 
 ```js
 // worker.js
-import { harborObject, harborWorker } from 'nervur/edge';
+import { harborShell, harborWorker } from 'nervur/edge';
+import kit from 'nervur/edge/kit';
 import pack from './pack.edge.json';
-import * as greetings from './greetings.js';
 
-export const Harbor = harborObject({ modules: [greetings], pack });
+export const Harbor = harborShell({ kit, pack });
 export default harborWorker();
 ```
 
@@ -73,8 +93,14 @@ class_name = "Harbor"
 [[migrations]]
 tag = "v1"
 new_sqlite_classes = ["Harbor"]
+
+[[worker_loaders]]
+binding = "LOADER"
 ```
 
+The Worker Loader is in beta, and on Cloudflare it needs the Workers Paid
+plan. `wrangler dev` runs it on your machine at no cost.
+
 Make the harbor and set it up with the command, from that folder, naming
 where the edge will reach it:
 
@@ -95,44 +121,43 @@ nervur edge dev ./pack.edge.json main --dir ./harbor
 `edge dev` packs the harbor as `main` into `pack.edge.json`, beside any
 harbor packed there before, and runs your `wrangler dev`, keeping the
 objects' storage and a secret of its own in `.nervur-edge`, so the
-harbor stands again each time you run it. The first time its object
-starts, the harbor lands in its storage; after that the storage is the
-harbor, and a new deploy leaves it be. Then, from your own harbor:
+harbor stands again each time you run it. The harbor's code travels in
+its package, as its DNA. The first time its object starts, the harbor
+lands in its storage; after that the storage is the harbor, and a new
+deploy leaves it be. Then, from your own harbor:
 
 ```sh
 nervur pilot edge '<the owner invitation>' --dir ./mine
 nervur host shop --via edge --dir ./mine
+nervur module add ./greetings.js --via edge --dir ./mine
 ```
 
+A module added, or `live` moved back, runs on the edge at once: the
+worker loads the next child for the commit `live` names, with no deploy.
+A module that does not load there is refused with its reason, and `live`
+stays where it was.
+
 For Cloudflare, keep one secret for the worker, `wrangler secret put
 NERVUR_SECRET`, and hold the same one as `NERVUR_SECRET` in your shell.
 Name each harbor's address with `reach`, pack each with
 `nervur edge pack ./pack.edge.json <name> --dir <its folder>`, and
 `wrangler deploy`. A pack holds every seed sealed under that secret, so
 it ships in the bundle and opens nowhere else, and a new harbor is a new
-deploy, never a new secret.
-
-`pilot` opens the web carrier where the invitation names a web address.
-A harbor may also be born on the edge, under a name `born` allows, with
-a seed of its own sealed the same way, and `stood` runs the worker's own
-code on it as root. A name the pack does not hold and `born` does not
-allow answers 404, so a stranger's request mints nothing:
-
-```js
-export const Harbor = harborObject({
-  modules: [greetings],
-  pack,
-  born: (name) => name === 'shop',
-  stood: async (harbor, name) => {
-    // runs once the harbor stands
-  },
-});
-```
+deploy, never a new secret. `pilot` opens the web carrier where the
+invitation names a web address. A name the pack does not hold answers
+404, so a stranger's request mints nothing.
 
 ## A world in one process
 
+A module is one file of JavaScript that imports nothing but `nervur`:
+
 ```js
-import { Being, Faculty, World } from 'nervur';
+// greetings.js
+import { Being, Faculty } from 'nervur';
+
+// Its name, as a kind is named, and its version.
+export const module = 'org.example.greetings';
+export const version = '1.0.0';
 
 // A contract, and a faculty that fulfils it. Every class names its kind.
 class Clock extends Faculty {
@@ -157,16 +182,22 @@ class Greeter extends Being {
   }
 }
 
-// The module these classes are: its name, its version, its classes.
-const greetings = { module: 'org.example.greetings', version: '1.0.0', classes: [SystemTime, Greeter] };
+export const classes = [SystemTime, Greeter];
+```
 
-// A harbor whose terrain can load that module, and whose catalogue runs it.
-const world = new World();
-const harbor = await world.harbor('home', [greetings]);
-await harbor.root('ask', { being: 'catalogue', method: 'add', args: { from: 'org.example.greetings' } });
-await harbor.root('open', { key: 'clock', class: 'org.example.system-time' });
-await harbor.root('host', { ward: 'alice' });
-await harbor.ward('alice').root('boot', { key: 'greeter', class: 'org.example.greeter' });
+A harbor's catalogue takes its source, commits it, and runs it:
+
+```js
+import { readFile } from 'node:fs/promises';
+import { DEFAULTS, World } from 'nervur';
+
+const world = new World(DEFAULTS);
+const harbor = await world.harbor('home');
+const source = await readFile('./greetings.js', 'utf8');
+await harbor.ask({ method: 'ask', args: { being: 'catalogue', method: 'add', args: { source } } });
+await harbor.ask({ method: 'open', args: { key: 'clock', class: 'org.example.system-time' } });
+await harbor.ask({ method: 'host', args: { ward: 'alice' } });
+await harbor.ask({ ward: 'alice', method: 'boot', args: { key: 'greeter', class: 'org.example.greeter' } });
 ```
 
 A second harbor in the same world takes an invitation on the greeter and
@@ -187,57 +218,117 @@ domain: `com.acme.shop` stands `com.acme.*` kinds. A harbor refuses a
 module in which one kind names two classes or two contracts, or names a
 class and a contract.
 
-## Modules
-
-Your classes come in modules: `{ module, version, classes }`, a module
-named as a kind is. A harbor's catalogue is a faculty of its own, and her
-cells name the modules the harbor runs. `add { from }` runs the module
-the terrain's loader finds there, and `remove { module }` stops one no
-being stands on. A restart loads every module she names and refuses to
-stand when one is missing. A module found at a new version wakes, and
-`modules` shows the version kept and the version running.
+## The DNA
+
+Your classes come in modules, each one file exporting `module`, `version`
+and `classes`, a module named as a kind is. A harbor's catalogue keeps
+its code as a git repository, its DNA, from its first moment: a commit
+holds `modules/<module>.js` for every module the harbor runs, and `live`
+names the commit that stands. Her asks, the root's and an owner's:
+
+- `add { source, name? }` commits a module's source on `live` and moves
+  `live` to it; the same module again takes its new version.
+- `remove { module }` commits its file away, refused while a being or a
+  ward stands on its kinds.
+- `live { commit? }` moves `live` to a commit or a fetched ref, or, with
+  none, names the commit that stands. Moving `live` back is a rollback.
+- `log` walks back from `live`. `modules` shows what `live` runs, and why
+  a module does not.
+- `origin { url }` names a git repository over HTTP, and `fetch` reads
+  every ref it has and all they reach into the harbor, touching nothing
+  there.
+
+Moving `live` runs the commit's modules together, or refuses them with
+the reason and leaves `live` where it was. Once they run, every being a
+new class resolves is born again of it, on the cells she keeps. A
+restart stands `live` from what the harbor keeps, with no network. The
+objects live in the harbor's memory, sealed as everything else is, so a
+harbor carried to another ground carries its DNA. Real `git` reads a
+harbor's objects, and a harbor reads what `git` serves.
 
 ## The onion
 
 A harbor is one package. Only the seed and the terrain's bodies, its
-loader among them, stand outside it.
+loader among them, stand outside it. It stands in three levels, and each
+level stands the next and leaves it alone.
+
+1. **The boot**, the harbor's own, from the library's core alone. The
+   terrain gives the seed, which opens its memory; the terrain keeps that
+   memory as sealed bytes and reads none of it. The box ward unpacks, the
+   catalogue stands and runs every module `live` holds, every registry the
+   catalogue resolves stands, and then the dock, of her class. The door is
+   hers from here, and `Harbor.open()` returns. It is one call, and no ask
+   makes it.
+2. **The dock's**, on her `stand` ask. She stands every other faculty,
+   registries first, then memory faculties, then the rest; hands her
+   routes to the carrier; and stands every ward she hosts, under the seed
+   she keeps for it.
+3. **Each ward's beings**, stood by nothing. A being's cells, occupants
+   and standings are her ward's rows, so she is born from her row when an
+   ask reaches her, once for the asks in flight on her, and dropped after.
+   A harbor holds in memory its faculties, its wards and the beings
+   answering now.
+
+After the boot a harbor takes asks alone. Whoever holds it asks `stand`:
+
+```js
+const harbor = await Harbor.open();
+await harbor.ask({ method: 'stand' });
+```
 
-1. The terrain gives the harbor's seed, which opens its memory. The
-   terrain keeps that memory as sealed bytes and reads none of it.
-2. The box ward unpacks under the seed, its ward-being the dock.
-3. The catalogue wakes, and loads every module she names.
-4. The other faculties are born from their rows.
-5. The routes the dock keeps are handed to the carrier.
-6. Every ward the dock hosts unpacks, under the seed the dock keeps for it.
-7. In every ward, the ward-being first, then each being from her row.
+`stand` answers what stood, or silence where everything already stands.
+The command asks it of every harbor it opens.
 
 Cells decide what stands. The modules only resolve a kind a row keeps.
-Opening a harbor on empty memory is its genesis: the dock stands the
-catalogue, and the root's asks write the rest: `add` on the catalogue,
-`open`, `host`, `route`, and `boot` on a ward. `host { ward, seed? }`
-stands a ward under a seed you name, or a drawn one.
-
-A ward's place is kept by the root memory unless you name a store.
-`open { key: 'vault', class: 'org.nervur.ground-store' }` opens the
-store every ground ships, and `host { ward, store: 'vault' }` keeps the
-ward there. A class of yours extending `Store` keeps a ward in a bucket
-or a database the same way, and `move { ward, store }` carries a ward
-between keepers whole.
+Opening a harbor on empty memory is its genesis: the harbor writes the
+catalogue and the default dock, and the root's asks write the rest: `add`
+on the catalogue, `open`, `host`, `route`, and `boot` on a ward.
+`host { ward, seed? }` stands a ward under a seed you name, or a drawn
+one.
+
+A ward is a being too, and her row keeps her class's kind. `Ward` and
+`Dock` are contracts, and `DefaultWard` and `DefaultDock` the library's
+defaults of them. A class of yours extending either, in a module the
+catalogue runs, is a ward of your own: `host { ward, class }` stands a
+hosted ward of it, and `become { class }` on any ward, the box ward's
+dock among them, has her born again of it on the same cells and
+relations. A dock of yours stands on every open, since she stands once
+the catalogue runs.
+
+Every class comes from a registry. The catalogue is the library's, and a
+class of yours extending `RegistryFaculty` is another: open it as any
+faculty, and name it where a class is named. `open { key, class,
+registry }` stands a faculty through it, `host { ward, registry }` stands
+a ward and every class of it through it, and `become { class, registry }`
+stands the dock through it, where the catalogue stands that registry. A
+registry may stand through another.
+
+A ward's place is kept by the root memory unless you name a memory
+faculty. `open { key: 'vault', class: 'org.nervur.ground-memory' }` opens
+the memory faculty every ground ships, and `host { ward, memory: 'vault' }`
+keeps the ward there. A class of yours extending `MemoryFaculty` keeps a
+ward in a bucket or a database the same way, and `move { ward, memory }`
+carries a ward between keepers whole.
 
 ## What it holds
 
-- **Being, Faculty.** What you extend. A faculty's contract is its class
-  and every class between it and `Faculty`.
+- **Being, Faculty, Ward, Dock.** What you extend, each a contract.
+  A faculty's contract is its class and every class between it and
+  `Faculty`. `DefaultWard` and `DefaultDock` are the kit's ward and dock.
 - **Entropy, Clock, Custody, Memory, Carrier, Loader.** The contracts a
   terrain fulfils. Each has one suite, and every body that fulfils it
   passes it. `nervur/proof` hands you those suites and the unpacking
   law's as scenes, a title and a function each, so a body of your own,
-  a store in a cloud or a secret of your platform's, runs them under
+  a memory in a cloud or a secret of your platform's, runs them under
   your own runner: `for (const [title, scene] of memoryScenes('Mine',
   make, expect)) test(title, scene)`. `@nervur-org/s3` is one such body.
-- **Harbor, Terrain, Dock, Catalogue, Registry, WardBeing.** The onion.
-- **World, PointerTerrain** and the pointer bodies, `HeldLoader` among
-  them. A whole world with this package alone.
+- **Harbor, Terrain, Catalogue, Registry.** The onion.
+- **World, PointerTerrain** and the pointer bodies. A whole world with
+  this package alone.
+- **SourceLoader, BundleLoader.** A module's source run by the engine's
+  own import, its `nervur` linked to the kit running, and the modules a
+  bundle carries, found by their git blob, for a service worker, which
+  imports nothing once it runs.
 - **addGround, grounds**: the grounds `Harbor.open()` tries, and a way to
   add your own.
 - **NodeTerrain**, from `nervur/node`: the Node ground's terrain, for a
@@ -246,24 +337,26 @@ between keepers whole.
   browser ground's terrain and bodies. `serveWorker(Harbor.open())` at
   the top of a shared or service worker holds one harbor for every tab,
   each tab asks it with `rootOf(worker)`, and a push the service worker
-  hears makes every relay client `ring`.
+  hears is the dock's `heard`, told to every carrier.
+- **harborShell, harborWorker, EdgeMemory, EdgeCustody, EdgeLoader**,
+  from `nervur/edge`, and the kit as one module's text, from
+  `nervur/edge/kit`: the edge's shell and the bodies its children stand
+  on.
 - **FolderMemory, FolderCustody**, from `nervur/folder`.
-- **TcpCarrier, TcpListener**, from `nervur/tcp`: Quo over TCP. Route a
-  ward pk to its `tcp://host:port` addresses on the carrier, hand the
-  listener your harbor, and harbors in two processes, or a harbor and
-  another kit, speak. `tcpFaculty` is the same carrier as a faculty of a
-  harbor.
-- **WebDialer, webFaculty**: Quo over the web, a post to `https://` or a
+- **TcpCarrier, TcpListener, NodeSockets**, from `nervur/tcp`: Quo over
+  TCP. Route a ward pk to its `tcp://host:port` addresses on the carrier,
+  hand the listener your harbor, and harbors in two processes, or a
+  harbor and another kit, speak. `TcpFaculty` is the same carrier as a
+  faculty of a harbor, on the sockets its terrain hands it:
+  `NodeSockets` on Node, a worker's own on the edge.
+- **WebDialer, WebFaculty**: Quo over the web, a post to `https://` or a
   held line to `wss://`, in any engine with `fetch` and WebSocket.
-  `webServe` and `webGround`, from `nervur/http`, listen for it on Node.
-  `answerPost(harbor, listen, request)` answers one post and nothing
-  more, for a function that opens a harbor per request and closes it.
-
-- **The relay**, `org.nervur.relay` and `org.nervur.relay-client`, in
-  every harbor: a harbor nobody can dial is reached through one that
-  can, by relations alone. See "A harbor nobody dials" below.
-- **Push, webPush**: a ring with no content, as Web Push sends it,
-  signed with VAPID, on fetch and Web Crypto.
+  `webServe`, from `nervur/http`, is the listener a Node terrain hands
+  the web carrier. `answerPost(harbor, listen, request)` answers one post
+  and nothing more, for a function that opens a harbor per request and
+  closes it.
+- **DEFAULTS**: the one list of beings and faculties every ground runs
+  where you write none, handed to a terrain as `defaults`.
 
 Quo crosses two carriers, TCP and the web, and no third. MCP, an HTTP API
 and every other outside protocol are gateway faculties: classes that
@@ -281,7 +374,7 @@ folder, Quo over TCP as its carrier. A module is a file that exports
 
 ```sh
 nervur init  --dir ./harbor
-nervur module add ./greetings.js --dir ./harbor   # or @acme/greetings, or its id
+nervur module add ./greetings.js --dir ./harbor
 nervur serve --dir ./harbor --port 7000
 nervur reach tcp://harbor.example:7000 --dir ./harbor
 nervur open web org.nervur.web --dir ./harbor
@@ -300,18 +393,20 @@ so nobody routes it by hand. Where an invitation carries no `at`,
 `nervur route <ward pk> tcp://host:port` names the route, and a route
 named this way is trusted first.
 
-`init` makes the harbor and prints its pk and an owner invitation. `serve`
-listens for Quo on TCP and for the root's asks on a local socket, open to
-you alone. Every other command is one root ask, sent to the served
+`init` makes the harbor, opens its TCP carrier unless you pass
+`--no-tcp`, and prints its pk and an owner invitation. `serve` listens for
+Quo on that carrier and for the root's asks on a local socket, open to
+you alone, and adds nothing to the harbor: one with no TCP carrier is not
+served. Every other command is one root ask, sent to the served
 harbor, or answered from the folder when none is served. Each prints one
 JSON line. `--dir` defaults to `$NERVUR_DIR`, then `~/.nervur`.
-`module add` takes a file, an installed package, or a module's id, and
-the catalogue keeps the id the module declares, so the same harbor finds
-its code on any ground: on this machine through `modules.json` beside
-the harbor, which remembers where each id was found, and on an edge or
-in a browser in the bundle. Routes live in the harbor like everything
-else, so a restart finds both. `nervur
-modules` shows what runs, and `nervur module remove <module>` stops one.
+`module add` reads the file and commits its text into the harbor's DNA,
+so the harbor holds its own code on any ground. Routes live in the
+harbor like everything else, so a restart finds both. `nervur modules`
+shows what runs, `nervur module remove <module>` stops one, `nervur log`
+walks the commits, `nervur live <commit>` moves `live`, and `nervur
+origin <url>` with `nervur fetch` reads a git repository into the
+harbor.
 
 A harbor elsewhere is piloted with the owner invitation its `init`
 printed, from a harbor of your own:
@@ -321,56 +416,18 @@ nervur pilot far '<owner invitation>' --dir ./mine
 nervur host shop --via far --dir ./mine
 ```
 
-`pilot` boots an `org.nervur.pilot` being in your harbor that holds the
-invitation as an ordinary Quo relation, kept in your harbor's memory, and
+`pilot` is your dock's `hold`: it keeps the invitation under the name
+`far` as an ordinary Quo relation, kept in your harbor's memory, and
 reaches the far harbor where its invitation's `at` says; where it says
 nothing, name the address after the invitation. With
 `--via far`, any command is asked of the far harbor as its owner, sealed
-over TCP, except `own` and `disown`, which stay the far root's.
-`nervur unboot far` lets it go.
-
-`rootLine(harbor, request)` is the same request in code, for any other
-front: `{ ward?, method?, args? }` in, one JSON answer out.
-
-## A harbor nobody dials
-
-A device behind a home router listens nowhere a caller can reach. A
-served harbor that can be reached relays for it. On the relay's harbor:
-
-```sh
-nervur open relay org.nervur.relay --dir ./relay
-nervur ask relay invite '{"id":"house","wards":["<camera ward pk>"]}' --dir ./relay
-```
-
-On the device, with the relay's address as its own reach:
-
-```sh
-nervur open client org.nervur.relay-client --dir ./house
-nervur ask client hold '{"invitation":<the invitation>,"line":true}' --dir ./house
-nervur reach tcp://relay.example:7000 --dir ./house
-nervur serve --dir ./house
-```
-
-Every invitation the device gives now sends callers to the relay. The
-relay holds each sealed box, the client collects it by an ordinary ask,
-hands it to the device's door, and returns the sealed reply in its next
-ask. Nothing is opened on the way. `line` keeps collecting, for a
-camera. Without it the client is a doorbell: `ring` collects what waits,
-and `"every": 60000` rings on a schedule, for a garage door.
-
-A doorbell can also be rung by a push with nothing in it. The relay's
-harbor opens Web Push and names who it is:
-
-```sh
-nervur open push org.nervur.web-push --dir ./relay
-nervur ask push subject '{"subject":"mailto:ops@example.org"}' --dir ./relay
-```
+over TCP, except `own` and `disown`, which stay the far root's. Every ward
+holds far beings this way, a ward or any other being whose invitation
+carries the notes `{ owner: true }`, each under a name, asked with
+`pilot { name, method, args }` and let go with `drop { name }`.
 
-The device asks its client for the key (`nervur ask client key`),
-subscribes to pushes with it, and hands the subscription's endpoint to
-`nervur ask client bell '{"endpoint":"https://..."}'`. When a box waits
-and no line collects, the relay rings that endpoint once. Whatever hears
-the push on the device asks the client's `ring`.
+`harbor.ask(request)` is the same request in code, for any other front:
+`{ ward?, method?, args? }` in, one JSON answer out.
 
 ## Moving a harbor
 

package/dist/browser.js

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // `nervur` as a browser bundle reads it: the main entry, with the browser
 // ground added, so `Harbor.open()` keeps a harbor in IndexedDB.
-import { browserGround } from './browser/index.js';
-import { addGround } from './harbor/index.js';
+import { browserGround } from './core/browser/index.js';
+import { addGround } from './core/harbor/index.js';
+import { DEFAULTS } from './index.js';
 export * from './index.js';
-addGround(browserGround);
+addGround(browserGround, DEFAULTS);

package/dist/cli.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+// The `nervur` program: `core/cli/command.ts` over this process's
+// arguments, its harbors running the defaults of the Node entry. A command
+// that cannot run exits 2 and says why on stderr.
+import { main, SERVING } from './core/cli/command.js';
+import { DEFAULTS } from './node.js';
+try {
+    const code = await main(process.argv.slice(2), process.env, (line) => process.stdout.write(`${line}\n`), DEFAULTS);
+    if (code !== SERVING)
+        process.exitCode = code;
+}
+catch (e) {
+    process.stderr.write(`nervur: ${e.message}\n`);
+    process.exitCode = 2;
+}

package/dist/{being → core/being}/being.js

@@ -1,3 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+// The base class most beings extend. It writes `answer`: the empty ask is
+// her blueprint for this asker, a named ask calls her method of that name,
+// and an ask she did not declare, or hides from this asker, is an error
+// object. A class that writes `answer` by hand is a being just the same.
+// What she acts through is `this.stance`.
+import { ships } from './kind.js';
 // Names a subclass may not declare as an ask, because they are the base's.
 const RESERVED = new Set(['answer', 'describe', 'stance', 'cells', 'notes', 'constructor']);
 // Whether she wrote a method of that name, below Object's prototype.
@@ -15,6 +22,9 @@ export class Being {
     // The name her row keeps for this class. Every class that stands declares
     // its own.
     static kind = 'org.nervur.being';
+    static {
+        ships(this);
+    }
     // Her cells' defaults, written at birth only where a key is missing.
     static cells = {};
     static asks = {};

package/dist/{being → core/being}/faculty.js

@@ -10,14 +10,17 @@
 // A being lends by the contract's kind and never learns the class. Every
 // class between the faculty and `Faculty` is a contract and declares its
 // own kind, and a faculty fulfils each of them and her own. Two asks are the
-// faculty's own and answered to the ward-being that opened her alone:
+// faculty's own and answered to the ward that opened her alone:
 // `offer`, an invitation on herself for a ward the dock vouches for, and
 // `retract`, an offer that was not taken.
 import { Being } from './being.js';
-import { kindOf } from './kind.js';
+import { kindOf, ships } from './kind.js';
 import { WARD } from './types.js';
 export class Faculty extends Being {
     static kind = 'org.nervur.faculty';
+    static {
+        ships(this);
+    }
     // The contracts a class fulfils: itself and every class between it and
     // `Faculty`, by kind. A class among them with no kind of its own throws.
     static contracts(C) {

package/dist/{being → core/being}/index.d.ts

@@ -1,6 +1,6 @@
 export { Being, type AskSpec } from './being.ts';
 export { canonical, digest } from './digest.ts';
 export { Faculty } from './faculty.ts';
-export { isKind, KIT, kindOf, ownKind } from './kind.ts';
+export { isKind, KIT, kindOf, ownKind, shipped, ships } from './kind.ts';
 export { OWNER, WARD, type Answer, type Ask, type Asker, type BeingClass, type BeingLike, type Blueprint, type Invitation, type Json, type JsonObject, type Occupants, type Reply, type Schema, type Stance, type Standing, type Standings, type Wanted } from './types.ts';
 export { isSilence, isWord, silence, told, word, type Silence, type Word, type WordName } from './words.ts';

package/dist/{being → core/being}/index.js

@@ -3,6 +3,6 @@
 export { Being } from './being.js';
 export { canonical, digest } from './digest.js';
 export { Faculty } from './faculty.js';
-export { isKind, KIT, kindOf, ownKind } from './kind.js';
+export { isKind, KIT, kindOf, ownKind, shipped, ships } from './kind.js';
 export { OWNER, WARD } from './types.js';
 export { isSilence, isWord, silence, told, word } from './words.js';

package/dist/{being → core/being}/kind.d.ts

@@ -1,4 +1,6 @@
 export declare const KIT = "org.nervur.";
 export declare const isKind: (text: unknown) => text is string;
 export declare const ownKind: (C: unknown) => string | undefined;
+export declare const ships: (C: object) => void;
+export declare const shipped: (C: unknown) => boolean;
 export declare const kindOf: (C: unknown) => string;

package/dist/{being → core/being}/kind.js

@@ -19,6 +19,12 @@ export const ownKind = (C) => {
     const kind = C.kind;
     return isKind(kind) ? kind : undefined;
 };
+// The classes the kit ships. Each is marked on itself as it is declared,
+// under a registered symbol, so the mark holds for a class of any copy of
+// the kit a module was built against, and a subclass inherits no mark.
+const SHIPS = Symbol.for('org.nervur.ships');
+export const ships = (C) => void Object.defineProperty(C, SHIPS, { value: true });
+export const shipped = (C) => typeof C === 'function' && Object.hasOwn(C, SHIPS);
 // The kind a class declares on itself, or a throw naming the class.
 export const kindOf = (C) => {
     const kind = ownKind(C);

package/dist/{being → core/being}/types.js

@@ -1,4 +1,4 @@
 export const OWNER = 'OWNER';
-// The ward-being's key in her ward, and so the id every being she makes
+// The ward's key in her house, and so the id every being she makes
 // knows her by.
 export const WARD = 'ward';