nervur 0.20.0 → 0.20.1

package/dist/cli/harbor.js

@@ -0,0 +1,141 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+// SPDX-License-Identifier: Apache-2.0
+// A harbor on this machine, as the `nervur` command stands it: its seed and
+// sealed memory in a folder, its code imported from the files its
+// catalogue names, Quo over TCP as its carrier, and the root line on a
+// local socket beside them.
+//
+//   <dir>/seed        the harbor's seed
+//   <dir>/<place>/    its sealed memory
+//   <dir>/root.sock   the root line while the harbor is served, open to
+//                     this user alone, or in the temporary folder for a
+//                     folder too deep for a socket path
+//
+// A root request goes to a served harbor over its socket. With none served,
+// the command unpacks the harbor from its folder, asks, and closes it, so
+// one process at a time writes the folder.
+import { createHash } from 'node:crypto';
+import { chmod, rm } from 'node:fs/promises';
+import { connect, createServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { Loader } from '../contract/index.js';
+import { FolderCustody, FolderMemory } from '../folder/index.js';
+import { Harbor, rootLine } from '../harbor/index.js';
+import { CryptoEntropy, PointerTerrain } from '../pointer/index.js';
+import { TcpCarrier, TcpListener } from '../tcp/index.js';
+// A socket path has a hundred bytes or so on every system, so a folder too
+// deep for one puts its socket in this user's temporary folder, under a
+// name drawn from the folder's own path.
+const SOCKET_PATH = 100;
+export const socketOf = (dir) => {
+    const beside = join(resolve(dir), 'root.sock');
+    if (Buffer.byteLength(beside) <= SOCKET_PATH)
+        return beside;
+    return join(tmpdir(), `nervur-${createHash('sha256').update(resolve(dir)).digest('hex').slice(0, 32)}.sock`);
+};
+// Code from a file: a module that exports `module`, `version` and
+// `classes`, found again by its absolute path. A file that cannot be
+// imported, or exports no module, is none.
+export class ImportLoader extends Loader {
+    async load(from) {
+        const path = resolve(from);
+        let exported;
+        try {
+            exported = (await import(__rewriteRelativeImportExtension(pathToFileURL(path).href)));
+        }
+        catch {
+            return null;
+        }
+        const { module, version, classes } = exported;
+        if (typeof module !== 'string' || typeof version !== 'string' || !Array.isArray(classes))
+            return null;
+        return { module, version, classes, from: path };
+    }
+}
+export const open = async (dir) => {
+    const entropy = new CryptoEntropy();
+    const carrier = new TcpCarrier();
+    const harbor = await Harbor.open(new PointerTerrain({ entropy, carrier, loader: new ImportLoader(), custody: new FolderCustody(dir, entropy), memory: new FolderMemory(dir) }));
+    return { harbor, carrier };
+};
+// One root request over a served harbor's socket, or undefined where none
+// is served.
+const overSocket = (dir, request) => new Promise((done, fail) => {
+    const socket = connect(socketOf(dir));
+    let text = '';
+    socket.once('connect', () => socket.write(`${JSON.stringify(request)}\n`));
+    socket.on('data', (chunk) => {
+        text += chunk.toString('utf8');
+        const end = text.indexOf('\n');
+        if (end < 0)
+            return;
+        socket.end();
+        done(JSON.parse(text.slice(0, end)));
+    });
+    socket.once('error', (e) => (e.code === 'ENOENT' || e.code === 'ECONNREFUSED' ? done(undefined) : fail(e)));
+});
+export const request = async (dir, req) => {
+    const served = await overSocket(dir, req);
+    if (served !== undefined)
+        return served;
+    const { harbor, carrier } = await open(dir);
+    try {
+        return await rootLine(harbor, req);
+    }
+    finally {
+        await carrier.close();
+    }
+};
+// The harbor served: Quo over TCP on host and port, the root line on the
+// socket. A socket file nobody answers on is a stale one, and is replaced.
+export const serve = async (dir, host, port) => {
+    if ((await overSocket(dir, {})) !== undefined)
+        throw new Error(`a harbor is already served from ${dir}`);
+    const { harbor, carrier } = await open(dir);
+    const listener = await TcpListener.listen(harbor, host, port);
+    const root = socketOf(dir);
+    await rm(root, { force: true });
+    const server = createServer((socket) => {
+        let text = '';
+        socket.on('data', (chunk) => {
+            text += chunk.toString('utf8');
+            for (let end = text.indexOf('\n'); end >= 0; end = text.indexOf('\n')) {
+                const line = text.slice(0, end);
+                text = text.slice(end + 1);
+                let value;
+                try {
+                    value = JSON.parse(line);
+                }
+                catch {
+                    value = undefined;
+                }
+                void rootLine(harbor, value)
+                    .catch(() => ({ error: 'the harbor threw' }))
+                    .then((answer) => socket.write(`${JSON.stringify(answer)}\n`));
+            }
+        });
+        socket.on('error', () => socket.destroy());
+    });
+    await new Promise((done) => server.listen(root, done));
+    await chmod(root, 0o600);
+    return {
+        pk: harbor.box.pk,
+        at: listener.at,
+        root,
+        close: async () => {
+            await new Promise((done) => server.close(done));
+            await rm(root, { force: true });
+            await listener.close();
+            await carrier.close();
+        },
+    };
+};

package/dist/cli/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/main.js

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

package/dist/contract/index.d.ts

@@ -16,11 +16,24 @@ export interface Rows {
     kept(): Promise<boolean>;
 }
 export declare abstract class Memory {
-    abstract open(name: string): Promise<Rows>;
+    abstract read(place: string): Promise<Map<string, Uint8Array>>;
+    abstract write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
 }
 export declare abstract class Custody {
-    abstract seed(name: string): Promise<Uint8Array>;
+    abstract seed(): Promise<Uint8Array>;
+}
+export type Module = {
+    readonly module: string;
+    readonly version: string;
+    readonly classes: readonly unknown[];
+};
+export type Loaded = Module & {
+    readonly from: string;
+};
+export declare abstract class Loader {
+    abstract load(from: string): Promise<Loaded | null>;
 }
 export declare abstract class Carrier {
     abstract carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
+    route(_pk: string, _at: string | null): boolean;
 }

package/dist/contract/index.js

@@ -8,12 +8,26 @@ export class Entropy {
 // The moment, and a wait that ends.
 export class Clock {
 }
+// A harbor's memory as a terrain keeps it: sealed entries it cannot read,
+// in places, each entry by name. Every name is lowercase hex the kit
+// chose, so a body may use it as a file name as it stands.
 export class Memory {
 }
-// A ward's seed by the harbor's name for it: thirty-two bytes, the same
-// every time that name is asked.
+// The harbor's seed: thirty-two bytes, the same every time. It is the one
+// secret a terrain holds.
 export class Custody {
 }
+// Code, by the name a harbor keeps for it, or null where this loader has
+// none. Code never crosses a door and never lives in a cell, so it is the
+// one thing beside the seed a terrain hands in: a map, an import, a bundle.
+export class Loader {
+}
 // Bytes to a ward pk in; bytes, or null for nothing, out.
 export class Carrier {
+    // Where a ward pk is reached, or null to forget it: true when this
+    // carrier dials by address and took it. The addresses live in the dock's
+    // cells, and the harbor hands them here as it unpacks.
+    route(_pk, _at) {
+        return false;
+    }
 }

package/dist/folder/index.d.ts

@@ -1,13 +1,14 @@
-import { Custody, Memory, type Entropy, type Rows } from '../contract/index.ts';
-export declare const folderName: (name: string) => string;
+import { Custody, Memory, type Entropy } from '../contract/index.ts';
 export declare class FolderMemory extends Memory {
+    #private;
     readonly root: string;
     constructor(root: string);
-    open(name: string): Promise<Rows>;
+    read(place: string): Promise<Map<string, Uint8Array>>;
+    write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
 }
 export declare class FolderCustody extends Custody {
     #private;
     readonly root: string;
     constructor(root: string, entropy: Entropy);
-    seed(name: string): Promise<Uint8Array>;
+    seed(): Promise<Uint8Array>;
 }

package/dist/folder/index.js

@@ -1,102 +1,64 @@
 // SPDX-License-Identifier: Apache-2.0
-// A harbor on a disk, for local proof: `nervur/folder`, the one entry that
+// A harbor on a disk, for local proof: `nervur/folder`, an entry that
 // names a platform.
 //
-//   <root>/<ward>/seed               the ward's seed, as hex
-//   <root>/<ward>/ward.json          the ward's head
-//   <root>/<ward>/<key>/being.json   one being: class, cells, relations
+//   <root>/seed              the harbor's seed, as hex
+//   <root>/<place>/<entry>   one sealed entry of the harbor's memory
 //
-// A folder name is the ward's name or the being's key, escaped, so no name
-// reaches outside its folder. A file is written whole, beside itself and
-// then renamed over, so a crash leaves the last kept copy. Seeds are plain
-// files: custody that seals them is a terrain's, in the dock.
+// Places and entries are the hex names the kit chose, so no name reaches
+// outside its folder, and the disk shows no ward's name. A file is written
+// whole, beside itself and then renamed over, so a crash leaves the last
+// kept copy. The seed is a plain file: custody that seals it is a
+// terrain's, in the dock.
 import { mkdir, readdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { hex, isHex, unhex } from '../crypto/index.js';
 import { Custody, Memory } from '../contract/index.js';
-import { HEAD_ROW } from '../ward/index.js';
-const HEAD = 'ward.json';
-const BEING = 'being.json';
-export const folderName = (name) => encodeURIComponent(name).replaceAll('.', '%2E').replaceAll('*', '%2A') || '%';
-const nameOf = (folder) => (folder === '%' ? '' : decodeURIComponent(folder));
 const missing = (e) => e.code === 'ENOENT';
-const readJson = async (path) => {
-    try {
-        return JSON.parse(await readFile(path, 'utf8'));
-    }
-    catch (e) {
-        if (missing(e))
-            return undefined;
-        throw e;
-    }
+const named = (name) => {
+    if (!isHex(name) || name === '')
+        throw new Error(`${name} is not a name the kit chose`);
+    return name;
 };
-const writeWhole = async (path, text) => {
-    await writeFile(`${path}.next`, text, { mode: 0o600 });
+const writeWhole = async (path, bytes) => {
+    await writeFile(`${path}.next`, bytes, { mode: 0o600 });
     await rename(`${path}.next`, path);
 };
-class FolderRows {
-    rows;
-    #dir;
-    #told = new Set();
-    #line = Promise.resolve(true);
-    constructor(dir, rows) {
-        this.#dir = dir;
-        this.rows = rows;
-    }
-    told(row) {
-        this.#told.add(row);
-    }
-    // Every row told since the last keep, written in order, one keep at a time.
-    kept() {
-        const rows = [...this.#told];
-        this.#told.clear();
-        this.#line = this.#line.then(() => this.#write(rows)).catch(() => false);
-        return this.#line;
-    }
-    async #write(told) {
-        await mkdir(this.#dir, { recursive: true, mode: 0o700 });
-        const beings = (this.rows.beings ?? {});
-        for (const row of told) {
-            if (row === HEAD_ROW) {
-                await writeWhole(join(this.#dir, HEAD), JSON.stringify(this.rows.ward ?? null));
-                continue;
-            }
-            const dir = join(this.#dir, folderName(row));
-            if (!Object.hasOwn(beings, row)) {
-                await rm(dir, { recursive: true, force: true });
-                continue;
-            }
-            await mkdir(dir, { recursive: true, mode: 0o700 });
-            await writeWhole(join(dir, BEING), JSON.stringify(beings[row]));
-        }
-        return true;
-    }
-}
 export class FolderMemory extends Memory {
     root;
+    #line = Promise.resolve();
     constructor(root) {
         super();
         this.root = root;
     }
-    // The rows as the disk holds them now.
-    async open(name) {
-        const dir = join(this.root, folderName(name));
-        const rows = {};
-        const head = await readJson(join(dir, HEAD));
-        if (head !== undefined)
-            rows.ward = head;
-        const beings = {};
-        const entries = await readdir(dir, { withFileTypes: true }).catch((e) => (missing(e) ? [] : Promise.reject(e)));
-        for (const entry of entries) {
-            if (!entry.isDirectory())
+    // The entries as the disk holds them now. A file that is not an entry,
+    // one still being written among them, is not read.
+    async read(place) {
+        const dir = join(this.root, named(place));
+        const out = new Map();
+        const files = await readdir(dir, { withFileTypes: true }).catch((e) => (missing(e) ? [] : Promise.reject(e)));
+        for (const file of files) {
+            if (!file.isFile() || !isHex(file.name) || file.name === '')
                 continue;
-            const row = await readJson(join(dir, entry.name, BEING));
-            if (row !== undefined)
-                beings[nameOf(entry.name)] = row;
+            out.set(file.name, new Uint8Array(await readFile(join(dir, file.name))));
         }
-        if (head !== undefined || Object.keys(beings).length > 0)
-            rows.beings = beings;
-        return new FolderRows(dir, rows);
+        return out;
+    }
+    // One keep at a time, each entry in the order given.
+    async write(place, entries) {
+        const dir = join(this.root, named(place));
+        const kept = this.#line.then(async () => {
+            await mkdir(dir, { recursive: true, mode: 0o700 });
+            for (const [name, bytes] of entries) {
+                const path = join(dir, named(name));
+                if (bytes === null)
+                    await rm(path, { force: true });
+                else
+                    await writeWhole(path, bytes);
+            }
+        });
+        this.#line = kept.catch(() => undefined);
+        await kept;
     }
 }
 export class FolderCustody extends Custody {
@@ -107,9 +69,9 @@ export class FolderCustody extends Custody {
         this.root = root;
         this.#entropy = entropy;
     }
-    async seed(name) {
-        const dir = join(this.root, folderName(name));
-        const path = join(dir, 'seed');
+    // The seed the folder holds, or a drawn one written there the first time.
+    async seed() {
+        const path = join(this.root, 'seed');
         const kept = await readFile(path, 'utf8').catch((e) => (missing(e) ? undefined : Promise.reject(e)));
         if (kept !== undefined) {
             const text = kept.trim();
@@ -118,7 +80,7 @@ export class FolderCustody extends Custody {
             return unhex(text);
         }
         const seed = this.#entropy.draw(32);
-        await mkdir(dir, { recursive: true, mode: 0o700 });
+        await mkdir(this.root, { recursive: true, mode: 0o700 });
         await writeFile(path, `${hex(seed)}\n`, { mode: 0o600, flag: 'wx' });
         return seed;
     }

package/dist/harbor/catalogue.d.ts

@@ -0,0 +1,25 @@
+import { Faculty, type AskSpec, type BeingClass, type JsonObject, type Stance } from '../being/index.ts';
+import type { Loaded } from '../contract/index.ts';
+export declare const CATALOGUE = "catalogue";
+export type ModuleRow = {
+    version: string;
+    from: string;
+};
+export interface Cataloguing {
+    load(from: string): Promise<Loaded | null>;
+    run(modules: readonly Loaded[]): string | null;
+    stands(kinds: readonly string[]): boolean;
+    kindsOf(module: string): string[];
+}
+export declare class Catalogue extends Faculty {
+    #private;
+    static readonly kind: string;
+    static cells: JsonObject;
+    static asks: Record<string, AskSpec>;
+    constructor(stance: Stance, harbor: Cataloguing);
+    wake(): Promise<void>;
+    add(args: JsonObject): Promise<JsonObject>;
+    remove(args: JsonObject): JsonObject;
+    modules(): JsonObject;
+}
+export declare const catalogueFor: (harbor: Cataloguing) => BeingClass;

package/dist/harbor/catalogue.js

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: Apache-2.0
+// The catalogue: the dock's first faculty, the code a harbor runs. Her
+// cells name each module by the name it declares, its version, and where
+// the terrain's loader finds it. The harbor wakes her before any other
+// faculty, loads every module she names, and refuses to stand when one is
+// missing.
+//
+//   add     { from }      the module the loader finds there, run from now
+//                         on; the same module again takes its new version
+//   remove  { module }    a module no being stands on, run no more
+//   modules               what she names, each with the version running
+//
+// She is the kit's, of kind `org.nervur.catalogue`, and answers the root
+// and an owner alone.
+import { Faculty } from '../being/index.js';
+import { ownerAsk } from '../ward/index.js';
+export const CATALOGUE = 'catalogue';
+const text = (v) => typeof v === 'string';
+export class Catalogue extends Faculty {
+    static kind = 'org.nervur.catalogue';
+    static cells = { modules: {} };
+    static asks = {
+        add: ownerAsk('a module run from now on', { required: ['from'] }),
+        remove: ownerAsk('a module run no more', { required: ['module'] }),
+        modules: ownerAsk('the modules this harbor runs'),
+    };
+    #harbor;
+    #running = new Map();
+    constructor(stance, harbor) {
+        super(stance);
+        this.#harbor = harbor;
+    }
+    get #rows() {
+        return this.cells.modules;
+    }
+    // Every module her cells name, loaded and run, or a throw naming the one
+    // that cannot be.
+    async wake() {
+        for (const [module, row] of Object.entries(this.#rows)) {
+            const loaded = await this.#harbor.load(row.from);
+            if (loaded === null)
+                throw new Error(`module ${module} is not found at ${row.from}`);
+            if (loaded.module !== module)
+                throw new Error(`${row.from} is module ${loaded.module}, not ${module}`);
+            this.#running.set(module, loaded);
+        }
+        const refused = this.#harbor.run([...this.#running.values()]);
+        if (refused !== null)
+            throw new Error(refused);
+    }
+    async add(args) {
+        if (!text(args.from))
+            return { error: 'from is text' };
+        const loaded = await this.#harbor.load(args.from);
+        if (loaded === null)
+            return { error: 'no such module' };
+        const running = new Map(this.#running);
+        running.set(loaded.module, loaded);
+        const refused = this.#harbor.run([...running.values()]);
+        if (refused !== null)
+            return { error: refused };
+        this.#running.set(loaded.module, loaded);
+        this.#rows[loaded.module] = { version: loaded.version, from: loaded.from };
+        return { added: loaded.module, version: loaded.version };
+    }
+    remove(args) {
+        const module = args.module;
+        if (!text(module) || !this.#running.has(module))
+            return { error: 'no such module' };
+        if (this.#harbor.stands(this.#harbor.kindsOf(module)))
+            return { error: 'a being stands on this module' };
+        const running = new Map(this.#running);
+        running.delete(module);
+        this.#harbor.run([...running.values()]);
+        this.#running.delete(module);
+        delete this.#rows[module];
+        return { removed: module };
+    }
+    modules() {
+        const out = {};
+        for (const [module, row] of Object.entries(this.#rows))
+            out[module] = { version: row.version, running: this.#running.get(module)?.version ?? null, from: row.from };
+        return out;
+    }
+}
+// The catalogue class one harbor stands: a being is born of her class and
+// her stance alone, so the class holds its harbor.
+export const catalogueFor = (harbor) => class extends Catalogue {
+    static kind = Catalogue.kind;
+    constructor(stance) {
+        super(stance, harbor);
+    }
+};

package/dist/harbor/dock.d.ts

@@ -1,15 +1,25 @@
 import { type AskSpec, type Invitation, type JsonObject } from '../being/index.ts';
 import { WardBeing, type Lender, type WardBeingStance } from '../ward/index.ts';
 export interface Hosting {
-    host(name: string, invitation: Invitation): Promise<boolean>;
+    host(name: string, invitation: Invitation, seed?: string): Promise<string | null>;
+    route(pk: string, at: string | null): boolean;
+    keep(): Promise<boolean>;
 }
+export type Hosted = {
+    ward: string;
+    seed: string;
+};
 export declare const BOX = "box";
 export declare class Dock extends WardBeing implements Lender {
     #private;
+    static readonly kind: string;
     static cells: JsonObject;
     static asks: Record<string, AskSpec>;
     constructor(stance: WardBeingStance, hosting: Hosting);
-    get hosted(): string[];
+    get hosted(): Hosted[];
+    get routes(): Record<string, string>;
+    route(args: JsonObject): JsonObject;
+    standCatalogue(): Promise<void>;
     open(args: JsonObject): Promise<JsonObject>;
     host(args: JsonObject): Promise<JsonObject>;
     lend(args: JsonObject): Promise<JsonObject>;

package/dist/harbor/dock.js

@@ -5,23 +5,30 @@
 //
 //   open    { key, class }      a faculty stands in the box ward, and the
 //                               dock holds a standing on her under her key
-//   host    { ward }            a hosted ward stands, holding a standing on
-//                               the dock
+//   host    { ward, seed? }     a hosted ward stands under the seed named,
+//                               or a drawn one, holding a standing on the
+//                               dock; the dock keeps its name and seed
 //   lend    { contract }        asked by a hosted ward: an offer from a
 //                               faculty that fulfils the contract
 //   retract { contract, heir }  an offer that was not taken
-import { Faculty } from '../being/index.js';
+//   route   { ward, at }        where a ward pk is reached, `host:port`, or
+//                               null to forget it; the dock keeps it and
+//                               the harbor hands it to its carrier
+import { Faculty, KIT } from '../being/index.js';
+import { CATALOGUE } from './catalogue.js';
 import { readInvitation } from '../quo/index.js';
 import { ownerAsk, WardBeing } from '../ward/index.js';
 export const BOX = 'box';
 const text = (v) => typeof v === 'string';
 const hosted = (_, notes) => notes?.hosted === true;
 export class Dock extends WardBeing {
-    static cells = { hosted: [] };
+    static kind = 'org.nervur.dock';
+    static cells = { hosted: [], routes: {} };
     static asks = {
         ...WardBeing.asks,
         open: ownerAsk('a faculty of this harbor', { required: ['key', 'class'] }),
         host: ownerAsk('a ward this harbor hosts', { required: ['ward'] }),
+        route: ownerAsk('where a ward is reached, or null', { required: ['ward', 'at'] }),
         lend: { description: 'an offer from a faculty fulfilling a contract', input: { type: 'object', required: ['contract'] }, for: hosted },
         retract: { description: 'an offer that was not taken', input: { type: 'object', required: ['contract', 'heir'] }, for: hosted },
     };
@@ -31,28 +38,51 @@ export class Dock extends WardBeing {
         this.#hosting = hosting;
     }
     get hosted() {
-        return [...this.cells.hosted];
+        return this.cells.hosted.map(({ ward, seed }) => ({ ward, seed }));
+    }
+    get routes() {
+        return { ...this.cells.routes };
+    }
+    route(args) {
+        const { ward, at } = args;
+        if (!text(ward) || (at !== null && !text(at)) || !this.#hosting.route(ward, at))
+            return { error: 'not routed' };
+        const routes = this.cells.routes;
+        if (at === null)
+            delete routes[ward];
+        else
+            routes[ward] = at;
+        return { routed: ward };
+    }
+    // Genesis: the catalogue stands first, and is kept at once.
+    async standCatalogue() {
+        const kind = 'org.nervur.catalogue';
+        if ((await this.stance.boot(kind, CATALOGUE, CATALOGUE)) === null || !(await this.#hosting.keep()))
+            throw new Error('the catalogue did not stand');
     }
     async open(args) {
         if (!text(args.key) || !text(args.class))
             return { error: 'key and class are text' };
-        if (!Faculty.fulfils(this.steward.classOf(args.class)))
+        if (args.class.startsWith(KIT) || !Faculty.fulfils(this.steward.classOf(args.class)))
             return { error: 'no such faculty' };
         const opened = await this.stance.boot(args.class, args.key, args.key);
         return opened === null ? { error: 'not opened' } : { opened };
     }
     async host(args) {
         const name = args.ward;
-        if (!text(name) || name === BOX || this.hosted.includes(name))
+        if (!text(name) || name === BOX || this.hosted.some((h) => h.ward === name))
             return { error: 'no such ward to host' };
+        if (args.seed !== undefined && !text(args.seed))
+            return { error: 'seed is text' };
         const invitation = await this.stance.occupants.invite(name, { hosted: true });
         if (invitation === null)
             return { error: 'not hosted' };
-        if (!(await this.#hosting.host(name, invitation))) {
+        const seed = await this.#hosting.host(name, invitation, args.seed);
+        if (seed === null) {
             this.stance.occupants.remove(name);
             return { error: 'not hosted' };
         }
-        this.cells.hosted.push(name);
+        this.cells.hosted.push({ ward: name, seed });
         return { hosted: name };
     }
     async lend(args) {