nervur 0.20.0 → 0.20.1

package/dist/pointer/world.d.ts

@@ -1,5 +1,4 @@
-import type { BeingClass } from '../being/index.ts';
-import { Carrier, type Clock, type Custody, type Entropy, type Memory } from '../contract/index.ts';
+import { Carrier, type Clock, type Custody, type Entropy, type Loader, type Memory, type Module } from '../contract/index.ts';
 import { Harbor, Terrain } from '../harbor/index.ts';
 export declare class NoCarrier extends Carrier {
     carry(): Promise<Uint8Array | null>;
@@ -15,6 +14,7 @@ export type PointerParts = {
     custody?: Custody;
     memory?: Memory;
     carrier?: Carrier;
+    loader?: Loader;
 };
 export declare class PointerTerrain extends Terrain {
     readonly entropy: Entropy;
@@ -22,13 +22,14 @@ export declare class PointerTerrain extends Terrain {
     readonly custody: Custody;
     readonly memory: Memory;
     readonly carrier: Carrier;
+    readonly loader: Loader;
     constructor(parts?: PointerParts);
 }
 export declare class World {
     #private;
     readonly cut: Set<string>;
-    harbor(name: string, classes: readonly BeingClass[], parts?: Omit<PointerParts, 'carrier'>): Promise<Harbor>;
+    harbor(name: string, modules?: readonly Module[], parts?: Omit<PointerParts, 'carrier'>): Promise<Harbor>;
     get(name: string): Harbor;
-    restart(name: string, classes?: readonly BeingClass[], parts?: Omit<PointerParts, 'carrier'>): Promise<Harbor>;
+    restart(name: string, parts?: Omit<PointerParts, 'carrier'>): Promise<Harbor>;
     carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
 }

package/dist/pointer/world.js

@@ -1,6 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+// The pointer world: harbors in one process, an address book from ward pk
+// to harbor that stands in for the internet, and weather between them. A
+// restart drops a harbor and opens a new one on the terrain the world
+// keeps for it, so only what its memory kept comes back.
 import { Carrier } from '../contract/index.js';
 import { Harbor, Terrain } from '../harbor/index.js';
-import { CryptoEntropy, HeldCustody, SystemClock, VolatileMemory } from './bodies.js';
+import { CryptoEntropy, HeldCustody, HeldLoader, SystemClock, VolatileMemory } from './bodies.js';
 // A carrier that reaches no one: a harbor alone.
 export class NoCarrier extends Carrier {
     carry() {
@@ -24,6 +29,7 @@ export class PointerTerrain extends Terrain {
     custody;
     memory;
     carrier;
+    loader;
     constructor(parts = {}) {
         super();
         this.entropy = parts.entropy ?? new CryptoEntropy();
@@ -31,20 +37,23 @@ export class PointerTerrain extends Terrain {
         this.custody = parts.custody ?? new HeldCustody(this.entropy);
         this.memory = parts.memory ?? new VolatileMemory();
         this.carrier = parts.carrier ?? new NoCarrier();
+        this.loader = parts.loader ?? new HeldLoader();
     }
 }
 export class World {
     #places = new Map();
     // Harbors the world reaches no one in, nor anyone out of.
     cut = new Set();
-    // A harbor of this world. `parts` replaces the pointer bodies, a folder's
-    // memory and custody among them.
-    async harbor(name, classes, parts = {}) {
+    // A harbor of this world, whose loader holds `modules` unless `parts`
+    // names a loader. `parts` replaces the pointer bodies, a folder's memory
+    // and custody among them. The harbor runs only the modules its catalogue
+    // was told to add.
+    async harbor(name, modules = [], parts = {}) {
         if (this.#places.has(name))
             throw new Error(`a harbor named ${name} stands`);
-        const terrain = new PointerTerrain({ ...parts, carrier: new PointerCarrier(this) });
-        const harbor = await Harbor.open(terrain, classes);
-        this.#places.set(name, { harbor, terrain, classes });
+        const terrain = new PointerTerrain({ loader: new HeldLoader(modules), ...parts, carrier: new PointerCarrier(this) });
+        const harbor = await Harbor.open(terrain);
+        this.#places.set(name, { harbor, terrain });
         return harbor;
     }
     get(name) {
@@ -53,17 +62,17 @@ export class World {
             throw new Error(`no harbor named ${name}`);
         return place.harbor;
     }
-    // The harbor opened again on its own terrain, with the classes it was
-    // made with unless others are named. `parts` replaces bodies of the
-    // terrain, as a new process would build them over the same disk.
-    async restart(name, classes, parts) {
+    // The harbor opened again on its own terrain. `parts` replaces bodies of
+    // the terrain, as a new process would build them over the same disk, or
+    // with other code.
+    async restart(name, parts) {
         const place = this.#places.get(name);
         if (!place)
             throw new Error(`no harbor named ${name}`);
         const t = place.terrain;
-        const terrain = parts ? new PointerTerrain({ entropy: t.entropy, clock: t.clock, custody: t.custody, memory: t.memory, ...parts, carrier: t.carrier }) : t;
-        const harbor = await Harbor.open(terrain, classes ?? place.classes);
-        this.#places.set(name, { ...place, harbor, terrain });
+        const terrain = parts ? new PointerTerrain({ entropy: t.entropy, clock: t.clock, custody: t.custody, memory: t.memory, loader: t.loader, ...parts, carrier: t.carrier }) : t;
+        const harbor = await Harbor.open(terrain);
+        this.#places.set(name, { harbor, terrain });
         return harbor;
     }
     carry(pk, bytes) {

package/dist/quo/door.js

@@ -23,7 +23,7 @@ export class Door {
         this.draw = draw;
     }
     // A new heir, held fresh, and its invitation. The lock is drawn at the
-    // first invitation that names a heir, before the heir's secret.
+    // first invitation that names an heir, before the heir's secret.
     async invite() {
         let lock = this.relations.lock();
         if (!lock)
@@ -32,7 +32,7 @@ export class Door {
         this.relations.set(heir.id, { state: 'fresh' });
         return { heir: heir.id, invitation: { ward: this.key.pk, heir: heir.id, secret: hex(heir.secret), lock: hex(lock.ek) } };
     }
-    // The door stops holding a heir. A fresh one leaves nothing, a spent one
+    // The door stops holding an heir. A fresh one leaves nothing, a spent one
     // leaves the keys kept at removal.
     remove(heir) {
         const record = this.relations.get(heir);

package/dist/quo/keys.js

@@ -10,7 +10,7 @@ export const LABEL = {
     wardSign: utf8('quo-ward-sign'),
     wardSeal: utf8('quo-ward-seal'),
 };
-// An Ed25519 pair: a heir, or a standing's own key.
+// An Ed25519 pair: an heir, or a standing's own key.
 export class SigningKey {
     secret;
     pk;

package/dist/tcp/frame.d.ts

@@ -0,0 +1,29 @@
+export declare const ASK = 0;
+export declare const REPLY = 1;
+export declare const NOTHING = 2;
+export declare const MAX_BODY = 1048645;
+export type Frame = {
+    kind: 'ask';
+    id: number;
+    pk: Uint8Array;
+    box: Uint8Array;
+} | {
+    kind: 'reply';
+    id: number;
+    box: Uint8Array;
+} | {
+    kind: 'nothing';
+    id: number;
+};
+export declare const askFrame: (id: number, pk: Uint8Array, box: Uint8Array) => Uint8Array;
+export declare const replyFrame: (id: number, box: Uint8Array) => Uint8Array;
+export declare const nothingFrame: (id: number) => Uint8Array;
+export declare class FrameReader {
+    #private;
+    get bad(): boolean;
+    push(chunk: Uint8Array): Frame[];
+}
+export declare const parseAt: (at: unknown) => {
+    host: string;
+    port: number;
+} | null;

package/dist/tcp/frame.js

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+// The frames of Quo over TCP, `quo/CARRIER-TCP.md`:
+//
+//   frame = length (4, big-endian) || kind (1) || id (4, big-endian) || rest
+//   00 ask      rest = ward pk (64) || box
+//   01 reply    rest = box
+//   02 nothing  rest = empty
+//
+// A reader says a stream is not a frame as soon as its bytes say so, and
+// reads nothing after it.
+import { concat } from '../crypto/index.js';
+export const ASK = 0;
+export const REPLY = 1;
+export const NOTHING = 2;
+export const MAX_BODY = 1_048_645;
+const PK = 64;
+const frame = (kind, id, ...rest) => {
+    const head = new Uint8Array(9);
+    const view = new DataView(head.buffer);
+    view.setUint32(0, 5 + rest.reduce((n, r) => n + r.length, 0));
+    head[4] = kind;
+    view.setUint32(5, id >>> 0);
+    return concat(head, ...rest);
+};
+export const askFrame = (id, pk, box) => frame(ASK, id, pk, box);
+export const replyFrame = (id, box) => frame(REPLY, id, box);
+export const nothingFrame = (id) => frame(NOTHING, id);
+// Whether a body of this length, and this first byte when known, is no frame.
+const notAFrame = (length, kind) => length > MAX_BODY || length < 5 || (kind !== undefined && (kind > NOTHING || (kind === ASK && length < 5 + PK) || (kind === NOTHING && length !== 5)));
+export class FrameReader {
+    #buffer = new Uint8Array(0);
+    #bad = false;
+    // True once bytes that are not a frame arrived; nothing is read after.
+    get bad() {
+        return this.#bad;
+    }
+    push(chunk) {
+        if (this.#bad)
+            return [];
+        this.#buffer = this.#buffer.length === 0 ? chunk.slice() : concat(this.#buffer, chunk);
+        const out = [];
+        while (this.#buffer.length >= 4) {
+            const view = new DataView(this.#buffer.buffer, this.#buffer.byteOffset);
+            const length = view.getUint32(0);
+            if (notAFrame(length, this.#buffer.length > 4 ? this.#buffer[4] : undefined)) {
+                this.#bad = true;
+                this.#buffer = new Uint8Array(0);
+                return out;
+            }
+            if (this.#buffer.length < 4 + length)
+                break;
+            const body = this.#buffer.subarray(4, 4 + length);
+            this.#buffer = this.#buffer.slice(4 + length);
+            const id = new DataView(body.buffer, body.byteOffset).getUint32(1);
+            if (body[0] === ASK)
+                out.push({ kind: 'ask', id, pk: body.slice(5, 5 + PK), box: body.slice(5 + PK) });
+            else if (body[0] === REPLY)
+                out.push({ kind: 'reply', id, box: body.slice(5) });
+            else
+                out.push({ kind: 'nothing', id });
+        }
+        return out;
+    }
+}
+// "host:port" to its parts, or null. A host in brackets is an IPv6 address.
+export const parseAt = (at) => {
+    if (typeof at !== 'string')
+        return null;
+    const m = /^(?:\[([^\]]+)\]|([^:[\]]+)):(\d{1,5})$/.exec(at);
+    if (!m)
+        return null;
+    const port = Number(m[3]);
+    return port > 0 && port < 65_536 ? { host: m[1] ?? m[2], port } : null;
+};

package/dist/tcp/index.d.ts

@@ -0,0 +1,18 @@
+import { Carrier } from '../contract/index.ts';
+export { parseAt } from './frame.ts';
+export interface Doors {
+    arrive(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
+}
+export declare class TcpCarrier extends Carrier {
+    #private;
+    route(pk: string, at: string | null): boolean;
+    carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
+    close(): Promise<void>;
+}
+export declare class TcpListener {
+    #private;
+    private constructor();
+    static listen(doors: Doors, host?: string, port?: number): Promise<TcpListener>;
+    get at(): string;
+    close(): Promise<void>;
+}

package/dist/tcp/index.js

@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: Apache-2.0
+// Quo over TCP: `nervur/tcp`, an entry that names a platform, Node's
+// sockets.
+//
+//   TcpCarrier    a Carrier that dials: bytes to a ward pk go in an ask
+//                 frame to the address its book holds for that pk
+//   TcpListener   answers ask frames for the doors it is handed, a harbor
+//                 among them
+//
+// Where a ward is reached is the carrier's own, and never on the wire. A
+// connection is opened per address, carries many asks at once, and is
+// dropped when either side closes it; the next ask dials again.
+import { connect, createServer } from 'node:net';
+import { hex, isHex, unhex } from '../crypto/index.js';
+import { Carrier } from '../contract/index.js';
+import { askFrame, FrameReader, nothingFrame, parseAt, replyFrame } from './frame.js';
+export { parseAt } from './frame.js';
+const MAX_ID = 0xffff_ffff;
+class Dialed {
+    #socket;
+    #reader = new FrameReader();
+    #waiting = new Map();
+    #next = 1;
+    closed = false;
+    constructor(socket, onClose) {
+        this.#socket = socket;
+        socket.on('data', (chunk) => {
+            for (const f of this.#reader.push(new Uint8Array(chunk))) {
+                if (f.kind === 'ask')
+                    continue;
+                const resolve = this.#waiting.get(f.id);
+                this.#waiting.delete(f.id);
+                resolve?.(f.kind === 'reply' ? f.box : null);
+            }
+            if (this.#reader.bad)
+                socket.destroy();
+        });
+        socket.on('error', () => socket.destroy());
+        socket.on('close', () => {
+            this.closed = true;
+            onClose();
+            for (const resolve of this.#waiting.values())
+                resolve(null);
+            this.#waiting.clear();
+        });
+    }
+    static open(host, port, onClose) {
+        return new Promise((resolve) => {
+            const socket = connect({ host, port });
+            socket.once('connect', () => resolve(new Dialed(socket, onClose)));
+            socket.once('error', () => {
+                socket.destroy();
+                resolve(null);
+            });
+        });
+    }
+    ask(pk, box) {
+        if (this.closed)
+            return Promise.resolve(null);
+        const id = this.#next;
+        this.#next = this.#next === MAX_ID ? 1 : this.#next + 1;
+        return new Promise((resolve) => {
+            this.#waiting.set(id, resolve);
+            this.#socket.write(askFrame(id, pk, box));
+        });
+    }
+    close() {
+        this.#socket.destroy();
+    }
+}
+export class TcpCarrier extends Carrier {
+    #routes = new Map();
+    #lines = new Map();
+    // The address a ward pk is reached at, replacing any before, or null to
+    // forget it.
+    route(pk, at) {
+        if (!isHex(pk, 64) || (at !== null && parseAt(at) === null))
+            return false;
+        if (at === null)
+            this.#routes.delete(pk);
+        else
+            this.#routes.set(pk, at);
+        return true;
+    }
+    // Nothing where the pk has no route, the address is not reached, or the
+    // connection closed before an answer.
+    async carry(pk, bytes) {
+        const at = this.#routes.get(pk);
+        if (at === undefined)
+            return null;
+        const line = await this.#line(at);
+        return line ? line.ask(unhex(pk), bytes) : null;
+    }
+    #line(at) {
+        let line = this.#lines.get(at);
+        if (!line) {
+            const { host, port } = parseAt(at);
+            line = Dialed.open(host, port, () => this.#lines.delete(at)).then((dialed) => {
+                if (!dialed)
+                    this.#lines.delete(at);
+                return dialed;
+            });
+            this.#lines.set(at, line);
+        }
+        return line;
+    }
+    async close() {
+        const lines = [...this.#lines.values()];
+        this.#lines.clear();
+        for (const line of await Promise.all(lines))
+            line?.close();
+    }
+}
+export class TcpListener {
+    #server;
+    #doors;
+    #sockets = new Set();
+    constructor(doors) {
+        this.#doors = doors;
+        this.#server = createServer((socket) => this.#serve(socket));
+    }
+    // A listener on `host` and `port`, 127.0.0.1 and a free port unless named.
+    static listen(doors, host = '127.0.0.1', port = 0) {
+        const listener = new TcpListener(doors);
+        return new Promise((resolve, reject) => {
+            listener.#server.once('error', reject);
+            listener.#server.listen(port, host, () => resolve(listener));
+        });
+    }
+    get at() {
+        const address = this.#server.address();
+        return address.family === 'IPv6' ? `[${address.address}]:${address.port}` : `${address.address}:${address.port}`;
+    }
+    #serve(socket) {
+        this.#sockets.add(socket);
+        const reader = new FrameReader();
+        socket.on('data', (chunk) => {
+            for (const f of reader.push(new Uint8Array(chunk))) {
+                if (f.kind === 'ask')
+                    void this.#answer(socket, f.id, f.pk, f.box);
+            }
+            if (reader.bad)
+                socket.destroy();
+        });
+        socket.on('error', () => socket.destroy());
+        socket.on('close', () => this.#sockets.delete(socket));
+    }
+    async #answer(socket, id, pk, box) {
+        let reply = null;
+        try {
+            reply = await this.#doors.arrive(hex(pk), box);
+        }
+        catch {
+            reply = null;
+        }
+        if (!socket.destroyed)
+            socket.write(reply === null ? nothingFrame(id) : replyFrame(id, reply));
+    }
+    close() {
+        for (const socket of this.#sockets)
+            socket.destroy();
+        return new Promise((resolve) => this.#server.close(() => resolve()));
+    }
+}

package/dist/ward/index.d.ts

@@ -3,3 +3,4 @@ export { HEAD_ROW, Partition, type BeingRow, type Head, type StandingRow } from
 export { DEPTH } from './stance.ts';
 export { DOCK, Ward, type Catalogue, type Lender, type WardParts } from './ward.ts';
 export { ownerAsk, pilots, WardBeing, type Steward, type WardBeingStance } from './ward-being.ts';
+export { Pilot } from './pilot.ts';

package/dist/ward/index.js

@@ -5,3 +5,4 @@ export { HEAD_ROW, Partition } from './partition.js';
 export { DEPTH } from './stance.js';
 export { DOCK, Ward } from './ward.js';
 export { ownerAsk, pilots, WardBeing } from './ward-being.js';
+export { Pilot } from './pilot.js';

package/dist/ward/pilot.d.ts

@@ -0,0 +1,8 @@
+import { Being, type AskSpec, type JsonObject } from '../being/index.ts';
+export declare class Pilot extends Being {
+    static readonly kind: string;
+    static asks: Record<string, AskSpec>;
+    hold(args: JsonObject): Promise<JsonObject>;
+    pilot(args: JsonObject): Promise<JsonObject>;
+    drop(): JsonObject;
+}

package/dist/ward/pilot.js

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: Apache-2.0
+// The pilot: a kit being that holds an owner's relation on another ward's
+// ward-being, so whoever pilots her ward pilots that ward from afar. The
+// relation is an ordinary standing, kept in her ward's partition, so it
+// moves its keys and survives a restart like any other.
+//
+//   hold   { invitation }        the owner invitation taken, under `far`
+//   pilot  { method?, args? }    the far ward-being asked, as its owner
+//   drop                         the relation let go
+//
+// She is the kit's, of kind `org.nervur.pilot`, and answers whoever pilots
+// her own ward alone.
+import { Being, isSilence, isWord, told } from '../being/index.js';
+import { readInvitation } from '../quo/index.js';
+import { ownerAsk, PILOT } from './ward-being.js';
+// The standing id the far ward-being is held under.
+const FAR = 'far';
+const object = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+export class Pilot extends Being {
+    static kind = PILOT;
+    static asks = {
+        hold: ownerAsk('an owner invitation on a far ward, held from now on', { required: ['invitation'] }),
+        pilot: ownerAsk('the far ward-being, asked as its owner'),
+        drop: ownerAsk('the far ward let go'),
+    };
+    async hold(args) {
+        const invitation = readInvitation(args.invitation);
+        if (invitation === null)
+            return { error: 'no invitation' };
+        if (this.stance.standings.get(FAR))
+            return { error: 'a ward is held' };
+        return (await this.stance.standings.take(FAR, invitation)) === null ? { error: 'not taken' } : { held: invitation.ward };
+    }
+    async pilot(args) {
+        if ((args.method !== undefined && typeof args.method !== 'string') || (args.args !== undefined && !object(args.args)))
+            return { error: 'method is text, args an object' };
+        const standing = this.stance.standings.get(FAR);
+        if (!standing)
+            return { error: 'no ward is held' };
+        const out = await standing.ask(args.method, args.args ?? {});
+        if (isSilence(out))
+            return { error: 'silence' };
+        if (isWord(out))
+            return { error: told(out) };
+        return { answer: out };
+    }
+    drop() {
+        return this.stance.standings.remove(FAR) ? { dropped: true } : { error: 'no ward is held' };
+    }
+}

package/dist/ward/stance.d.ts

@@ -22,8 +22,6 @@ export declare class WardStance implements Stance {
     readonly standings: Standings;
     constructor(inside: Inside, key: string, row: BeingRow);
     get cells(): JsonObject;
-    boot(className: string, key: string, id?: string): Promise<string | null>;
-    lend(contract: {
-        readonly name: string;
-    }, id: string): Promise<string | null>;
+    boot(kind: string, key: string, id?: string): Promise<string | null>;
+    lend(contract: abstract new (...args: never[]) => unknown, id: string): Promise<string | null>;
 }

package/dist/ward/stance.js

@@ -4,7 +4,7 @@
 // standing, one send at a time, inside her allowance.
 import { readValue, writeValue } from '../crypto/index.js';
 import { readInvitation, Standing as Wire, freshStanding } from '../quo/index.js';
-import { OWNER, silence, word } from '../being/index.js';
+import { OWNER, ownKind, silence, word } from '../being/index.js';
 import { allow, Bell, LATE } from './allowance.js';
 import { Cells, DEPTH } from './cells.js';
 export { DEPTH };
@@ -65,18 +65,19 @@ export class WardStance {
     get #live() {
         return this.#inside.live(this.key, this.#row);
     }
-    boot(className, key, id) {
-        return this.#live ? this.#inside.boot(this.key, className, key, id) : Promise.resolve(null);
+    boot(kind, key, id) {
+        return this.#live ? this.#inside.boot(this.key, kind, key, id) : Promise.resolve(null);
     }
     async lend(contract, id) {
-        if (!this.#free(id, this.#row.standings))
+        const kind = ownKind(contract);
+        if (kind === undefined || !this.#free(id, this.#row.standings))
             return null;
-        const invitation = await this.#inside.offer(contract.name);
+        const invitation = await this.#inside.offer(kind);
         if (invitation === null)
             return null;
         const taken = await this.#take(id, invitation);
         if (taken === null)
-            await this.#inside.retract(contract.name, invitation.heir);
+            await this.#inside.retract(kind, invitation.heir);
         return taken;
     }
     #free(id, of) {

package/dist/ward/ward-being.d.ts

@@ -18,7 +18,9 @@ export type WardBeingStance = Stance & {
 };
 export declare const pilots: (asker: Asker, notes: JsonObject | undefined) => boolean;
 export declare const ownerAsk: (description: string, input?: JsonObject) => AskSpec;
+export declare const PILOT = "org.nervur.pilot";
 export declare class WardBeing extends Being {
+    static readonly kind: string;
     static asks: Record<string, AskSpec>;
     readonly steward: Steward;
     constructor(stance: WardBeingStance);

package/dist/ward/ward-being.js

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // The ward-being: the first being of every ward, the ward itself. Her asks
 // are the root's, shown and answered to `OWNER` alone.
-import { Being, isSilence, isWord, OWNER, told } from '../being/index.js';
+import { Being, isSilence, isWord, KIT, OWNER, told } from '../being/index.js';
 // Whoever pilots a ward: the root, holding its unsealed ask, or an owner,
 // an occupant of the ward-being the root invited as one.
 export const pilots = (asker, notes) => asker.id === OWNER || notes?.owner === true;
@@ -10,9 +10,13 @@ export const ownerAsk = (description, input = {}) => ({ description, input: { ty
 // An ask the root alone may make, so a carried key pilots but never hands
 // piloting on.
 const rootAsk = (description, input = {}) => ({ description, input: { type: 'object', ...input }, for: (asker) => asker.id === OWNER });
+// The one kit kind the root boots: every other kit class stands where the
+// kit puts it.
+export const PILOT = 'org.nervur.pilot';
 const text = (v) => typeof v === 'string';
 const object = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 export class WardBeing extends Being {
+    static kind = 'org.nervur.ward-being';
     static asks = {
         boot: ownerAsk('a new being of this ward', { required: ['key', 'class'] }),
         unboot: ownerAsk('a being out, with every relation she holds', { required: ['being'] }),
@@ -45,6 +49,8 @@ export class WardBeing extends Being {
     async boot(args) {
         if (!text(args.key) || !text(args.class))
             return { error: 'key and class are text' };
+        if (args.class.startsWith(KIT) && args.class !== PILOT)
+            return { error: 'no such class' };
         const out = await this.steward.boot(args.key, args.class);
         return out === 'booted' ? { booted: args.key } : { error: out };
     }

package/dist/ward/ward.d.ts

@@ -1,11 +1,11 @@
 import { Door, WardKey, type Behind, type Choice, type Invitation, type Payload } from '../quo/index.ts';
 import type { Carrier, Clock, Entropy, Rows } from '../contract/index.ts';
-import { type Answer, type BeingClass, type JsonObject } from '../being/index.ts';
+import { type Answer, type BeingClass, type BeingLike, type JsonObject } from '../being/index.ts';
 import { Partition, type BeingRow } from './partition.ts';
 import { type Inside } from './stance.ts';
 import { WardBeing, type WardBeingStance } from './ward-being.ts';
 export interface Catalogue {
-    classOf(name: string): BeingClass | undefined;
+    classOf(kind: string): BeingClass | undefined;
 }
 export type WardParts = {
     readonly seed: Uint8Array | string;
@@ -33,6 +33,8 @@ export declare class Ward implements Behind, Inside {
     get pk(): string;
     get draw(): import("../quo/keys.ts").Draw;
     get wardBeing(): WardBeing;
+    being(key: string): BeingLike | undefined;
+    bearAnew(): void;
     root(method?: string, args?: JsonObject): Promise<Answer>;
     get zero(): boolean;
     answer(heir: string | null, p: Payload): Promise<Choice>;