nervur 0.20.0 → 0.20.1

package/dist/harbor/harbor.d.ts

@@ -1,22 +1,31 @@
 import type { Answer, BeingClass, Invitation, JsonObject } from '../being/index.ts';
-import { Carrier } from '../contract/index.ts';
-import { Ward } from '../ward/index.ts';
+import { Carrier, type Loaded } from '../contract/index.ts';
+import { Ward, type Catalogue as Resolving } from '../ward/index.ts';
+import { Catalogue, type Cataloguing } from './catalogue.ts';
 import { Dock, type Hosting } from './dock.ts';
 import { Registry } from './registry.ts';
 import type { Terrain } from './terrain.ts';
-export declare class Harbor extends Carrier implements Hosting {
+export declare class Harbor extends Carrier implements Hosting, Cataloguing, Resolving {
     #private;
     readonly terrain: Terrain;
-    readonly registry: Registry;
     private constructor();
-    static open(terrain: Terrain, classes: readonly BeingClass[]): Promise<Harbor>;
+    static open(terrain: Terrain): Promise<Harbor>;
     get box(): Ward;
     get dock(): Dock;
+    get catalogue(): Catalogue;
+    get registry(): Registry;
     ward(name: string): Ward | undefined;
     get names(): string[];
     root(method?: string, args?: JsonObject): Promise<Answer>;
     holds(pk: string): boolean;
     arrive(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
     carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | null>;
-    host(name: string, invitation: Invitation): Promise<boolean>;
+    classOf(kind: string): BeingClass | undefined;
+    load(from: string): Promise<Loaded | null>;
+    run(modules: readonly Loaded[]): string | null;
+    stands(kinds: readonly string[]): boolean;
+    kindsOf(module: string): string[];
+    host(name: string, invitation: Invitation, seed?: string): Promise<string | null>;
+    keep(): Promise<boolean>;
+    route(pk: string, at: string | null): boolean;
 }

package/dist/harbor/harbor.js

@@ -1,21 +1,35 @@
 import { Carrier } from '../contract/index.js';
-import { DOCK, Ward } from '../ward/index.js';
+import { hex, isHex, unhex } from '../crypto/index.js';
+import { WardKey } from '../quo/index.js';
+import { DOCK, Pilot, Ward } from '../ward/index.js';
+import { Catalogue, CATALOGUE, catalogueFor } from './catalogue.js';
 import { BOX, Dock } from './dock.js';
+import { Package } from './package.js';
 import { Registry } from './registry.js';
 export class Harbor extends Carrier {
     terrain;
-    registry;
+    #package;
     #wards = new Map();
-    constructor(terrain, registry) {
+    #kit;
+    #registry;
+    constructor(terrain, pack) {
         super();
         this.terrain = terrain;
-        this.registry = registry;
+        this.#package = pack;
+        this.#kit = [catalogueFor(this), Pilot];
+        this.#registry = new Registry(this.#kit, []);
     }
-    static async open(terrain, classes) {
-        const harbor = new Harbor(terrain, new Registry(classes));
-        await harbor.#unpack(BOX, undefined, (stance) => new Dock(stance, harbor));
-        for (const name of harbor.dock.hosted)
-            await harbor.#unpack(name);
+    static async open(terrain) {
+        const seed = await terrain.custody.seed();
+        const harbor = new Harbor(terrain, await Package.open(terrain.memory, terrain.entropy, seed));
+        await harbor.#unpack(BOX, seed, undefined, (stance) => new Dock(stance, harbor));
+        if (!harbor.box.partition.being(CATALOGUE))
+            await harbor.dock.standCatalogue();
+        await harbor.catalogue.wake();
+        for (const [pk, at] of Object.entries(harbor.dock.routes))
+            terrain.carrier.route(pk, at);
+        for (const hosted of harbor.dock.hosted)
+            await harbor.#unpack(hosted.ward, unhex(hosted.seed));
         return harbor;
     }
     get box() {
@@ -24,6 +38,12 @@ export class Harbor extends Carrier {
     get dock() {
         return this.box.wardBeing;
     }
+    get catalogue() {
+        return this.box.being(CATALOGUE);
+    }
+    get registry() {
+        return this.#registry;
+    }
     ward(name) {
         return this.#wards.get(name);
     }
@@ -46,27 +66,69 @@ export class Harbor extends Carrier {
     carry(pk, bytes) {
         return this.holds(pk) ? this.arrive(pk, bytes) : this.terrain.carrier.carry(pk, bytes);
     }
-    // Hosting: a ward the dock hosts stands now.
-    async host(name, invitation) {
+    // Resolving: a kind, by the registry the catalogue runs.
+    classOf(kind) {
+        return this.#registry.classOf(kind);
+    }
+    // Cataloguing: code through the terrain, and the modules run.
+    load(from) {
+        return this.terrain.loader.load(from);
+    }
+    run(modules) {
+        try {
+            this.#registry = new Registry(this.#kit, modules);
+        }
+        catch (e) {
+            return e.message;
+        }
+        for (const ward of this.#wards.values())
+            ward.bearAnew();
+        return null;
+    }
+    stands(kinds) {
+        for (const ward of this.#wards.values()) {
+            for (const row of Object.values(ward.partition.beings))
+                if (kinds.includes(row.class))
+                    return true;
+        }
+        return false;
+    }
+    kindsOf(module) {
+        return this.#registry.kindsOf(module);
+    }
+    // Hosting: a ward the dock hosts stands now, under the seed named or a
+    // drawn one, and the seed it stands under comes back. A ward whose key
+    // another ward of this harbor already has does not stand.
+    async host(name, invitation, seed) {
         if (this.#wards.has(name))
-            return false;
+            return null;
+        const bytes = seed === undefined ? this.terrain.entropy.draw(32) : isHex(seed, 32) ? unhex(seed) : null;
+        if (bytes === null || this.holds((await WardKey.from(bytes)).pk))
+            return null;
         try {
-            await this.#unpack(name, invitation);
+            await this.#unpack(name, bytes, invitation);
         }
         catch {
-            return false;
+            return null;
         }
         if (this.#wards.get(name).wardBeing.stance.standings.get(DOCK))
-            return true;
+            return hex(bytes);
         this.#wards.delete(name);
-        return false;
+        return null;
+    }
+    keep() {
+        return this.box.partition.kept();
+    }
+    // Hosting: the terrain's carrier takes a route, or does not dial.
+    route(pk, at) {
+        return this.terrain.carrier.route(pk, at);
     }
-    async #unpack(name, dock, root) {
-        const { entropy, clock, custody, memory } = this.terrain;
+    async #unpack(name, seed, dock, root) {
+        const { entropy, clock } = this.terrain;
         const ward = await Ward.unpack({
-            seed: await custody.seed(name),
-            memory: await memory.open(name),
-            catalogue: this.registry,
+            seed,
+            memory: await this.#package.rows(name),
+            catalogue: this,
             entropy,
             clock,
             carrier: this,

package/dist/harbor/index.d.ts

@@ -1,4 +1,7 @@
-export { BOX, Dock, type Hosting } from './dock.ts';
+export { Catalogue, CATALOGUE, type Cataloguing, type ModuleRow } from './catalogue.ts';
+export { BOX, Dock, type Hosted, type Hosting } from './dock.ts';
 export { Harbor } from './harbor.ts';
+export { Package } from './package.ts';
+export { readRootRequest, rootLine, type RootRequest } from './root-line.ts';
 export { Registry } from './registry.ts';
 export { Terrain } from './terrain.ts';

package/dist/harbor/index.js

@@ -1,6 +1,10 @@
 // SPDX-License-Identifier: Apache-2.0
-// The onion: a terrain, a registry, the dock, and the harbor.
+// The onion: a terrain, the package, the dock, the catalogue and its
+// registry, and the harbor.
+export { Catalogue, CATALOGUE } from './catalogue.js';
 export { BOX, Dock } from './dock.js';
 export { Harbor } from './harbor.js';
+export { Package } from './package.js';
+export { readRootRequest, rootLine } from './root-line.js';
 export { Registry } from './registry.js';
 export { Terrain } from './terrain.js';

package/dist/harbor/package.d.ts

@@ -0,0 +1,10 @@
+import type { Entropy, Memory, Rows } from '../contract/index.ts';
+export declare class Package {
+    #private;
+    readonly memory: Memory;
+    readonly entropy: Entropy;
+    private constructor();
+    static open(memory: Memory, entropy: Entropy, seed: Uint8Array): Promise<Package>;
+    derive(info: string[], length: number): Promise<Uint8Array>;
+    rows(name: string): Promise<Rows>;
+}

package/dist/harbor/package.js

@@ -0,0 +1,115 @@
+// SPDX-License-Identifier: Apache-2.0
+// The package: a harbor's memory, sealed under the harbor's seed. The
+// terrain keeps its bytes and reads neither a ward's name, nor a being's
+// key, nor anything a row holds.
+//
+//   key            HKDF-SHA-256 of the seed under `nervur-package`
+//   place          16 bytes under ["place", ward], as hex
+//   entry          16 bytes under ["entry", ward, row], as hex
+//   seal           32 bytes under ["seal", ward]
+//   entry bytes    nonce (12) || AES-256-GCM( JSON { row, value } ),
+//                  the entry's name as additional data
+//
+// A row is the head, under the empty name, or one being, under her key. An
+// entry that does not open refuses the whole ward, so nothing unpacks from
+// bytes the package did not seal.
+import { concat, decrypt, encrypt, hex, hkdf, utf8 } from '../crypto/index.js';
+import { HEAD_ROW } from '../ward/index.js';
+const NONCE = 12;
+const LABEL = utf8('nervur-package');
+class PackageRows {
+    rows;
+    #ward;
+    #told = new Set();
+    #line = Promise.resolve(true);
+    constructor(ward, rows) {
+        this.#ward = ward;
+        this.rows = rows;
+    }
+    told(row) {
+        this.#told.add(row);
+    }
+    // Every row told since the last keep, sealed and written as one keep, 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) {
+        const beings = (this.rows.beings ?? {});
+        const entries = new Map();
+        for (const row of told) {
+            const value = row === HEAD_ROW ? (this.rows.ward ?? null) : Object.hasOwn(beings, row) ? beings[row] : undefined;
+            entries.set(await this.#ward.entry(row), value === undefined ? null : await this.#ward.seal(row, value));
+        }
+        await this.#ward.write(entries);
+        return true;
+    }
+}
+class Ward {
+    #pack;
+    #name;
+    #seal;
+    place;
+    constructor(pack, name, seal, place) {
+        this.#pack = pack;
+        this.#name = name;
+        this.#seal = seal;
+        this.place = place;
+    }
+    entry(row) {
+        return this.#pack.derive(['entry', this.#name, row], 16).then(hex);
+    }
+    async seal(row, value) {
+        const nonce = this.#pack.entropy.draw(NONCE);
+        const text = utf8(JSON.stringify({ row, value }));
+        return concat(nonce, await encrypt(this.#seal, nonce, utf8(await this.entry(row)), text));
+    }
+    // The name is the additional data, so an entry moved under another name
+    // does not open either.
+    async open(name, bytes) {
+        const text = bytes.length > NONCE ? await decrypt(this.#seal, bytes.subarray(0, NONCE), utf8(name), bytes.subarray(NONCE)) : null;
+        if (text === null)
+            throw new Error('an entry the package did not seal');
+        return JSON.parse(new TextDecoder().decode(text));
+    }
+    write(entries) {
+        return this.#pack.memory.write(this.place, entries);
+    }
+}
+export class Package {
+    memory;
+    entropy;
+    #key;
+    constructor(memory, entropy, key) {
+        this.memory = memory;
+        this.entropy = entropy;
+        this.#key = key;
+    }
+    static async open(memory, entropy, seed) {
+        return new Package(memory, entropy, await hkdf(seed, LABEL, 32));
+    }
+    derive(info, length) {
+        return hkdf(this.#key, utf8(JSON.stringify(info)), length);
+    }
+    // One ward's rows, as the package kept them.
+    async rows(name) {
+        const ward = new Ward(this, name, await this.derive(['seal', name], 32), hex(await this.derive(['place', name], 16)));
+        const rows = {};
+        const beings = {};
+        let any = false;
+        for (const [entry, bytes] of await this.memory.read(ward.place)) {
+            const { row, value } = await ward.open(entry, bytes);
+            any = true;
+            if (row === HEAD_ROW)
+                rows.ward = value;
+            else
+                beings[row] = value;
+        }
+        if (any)
+            rows.beings = beings;
+        return new PackageRows(ward, rows);
+    }
+}

package/dist/harbor/registry.d.ts

@@ -1,7 +1,9 @@
-import type { BeingClass } from '../being/index.ts';
+import { type BeingClass } from '../being/index.ts';
+import type { Module } from '../contract/index.ts';
 import type { Catalogue } from '../ward/index.ts';
 export declare class Registry implements Catalogue {
     #private;
-    constructor(classes: readonly BeingClass[]);
-    classOf(name: string): BeingClass | undefined;
+    constructor(kit: readonly BeingClass[], modules: readonly Module[]);
+    classOf(kind: string): BeingClass | undefined;
+    kindsOf(module: string): string[];
 }

package/dist/harbor/registry.js

@@ -1,13 +1,78 @@
+// SPDX-License-Identifier: Apache-2.0
+// The catalogue's index: every kind the harbor runs, from the kit's own
+// classes and the modules the catalogue loaded. It resolves a kind a row
+// keeps, and decides nothing about what stands. It refuses any set of
+// modules two readings could split:
+//
+//   a module whose name is no kind, or is the kit's, or two of one name
+//   a class with no kind of its own, or one outside its module's domain
+//   two classes of one kind, or one kind in two modules
+//   a contract with no kind of its own, or one kind for two contracts
+//   a kind that is a class and a contract
+//
+// A module's domain is its name's first two segments: `com.acme.shop`
+// stands classes under `com.acme.` alone. A contract may be any domain's,
+// so a faculty fulfils a contract another module declares. Two harbors hold
+// two registries, and nothing between them names a class.
+import { Faculty, isKind, KIT, kindOf } from '../being/index.js';
+const domainOf = (name) => `${name.split('.').slice(0, 2).join('.')}.`;
 export class Registry {
     #classes = new Map();
-    constructor(classes) {
-        for (const C of classes) {
-            if (this.#classes.has(C.name) && this.#classes.get(C.name) !== C)
-                throw new Error(`two classes are named ${C.name}`);
-            this.#classes.set(C.name, C);
+    #modules = new Map();
+    // `kit` holds the kit's own classes, which alone may be of its kinds.
+    constructor(kit, modules) {
+        const contracts = new Map();
+        const owners = new Map();
+        const add = (C, kind) => {
+            if (this.#classes.has(kind) && this.#classes.get(kind) !== C)
+                throw new Error(`two classes are of kind ${kind}`);
+            this.#classes.set(kind, C);
+        };
+        for (const C of kit)
+            add(C, kindOf(C));
+        for (const m of modules) {
+            if (!isKind(m.module) || m.module.startsWith(KIT))
+                throw new Error(`module ${String(m.module)} is no name a module may take`);
+            if (this.#modules.has(m.module))
+                throw new Error(`two modules are named ${m.module}`);
+            if (typeof m.version !== 'string' || m.version === '')
+                throw new Error(`module ${m.module} declares no version`);
+            const kinds = [];
+            for (const C of m.classes) {
+                if (typeof C !== 'function')
+                    throw new Error(`module ${m.module} holds something that is no class`);
+                const kind = kindOf(C);
+                if (!kind.startsWith(domainOf(m.module)))
+                    throw new Error(`kind ${kind} is outside module ${m.module}`);
+                const owner = owners.get(kind);
+                if (owner !== undefined && owner !== m.module)
+                    throw new Error(`kind ${kind} is in modules ${owner} and ${m.module}`);
+                owners.set(kind, m.module);
+                add(C, kind);
+                kinds.push(kind);
+                if (!Faculty.fulfils(C))
+                    continue;
+                for (let c = Object.getPrototypeOf(C); c !== Faculty; c = Object.getPrototypeOf(c)) {
+                    const contract = kindOf(c);
+                    if (contract.startsWith(KIT))
+                        throw new Error(`kind ${contract} is the kit's`);
+                    if (contracts.has(contract) && contracts.get(contract) !== c)
+                        throw new Error(`two contracts are of kind ${contract}`);
+                    contracts.set(contract, c);
+                }
+            }
+            this.#modules.set(m.module, kinds);
         }
+        for (const kind of contracts.keys()) {
+            if (this.#classes.has(kind))
+                throw new Error(`kind ${kind} is a class and a contract`);
+        }
+    }
+    classOf(kind) {
+        return this.#classes.get(kind);
     }
-    classOf(name) {
-        return this.#classes.get(name);
+    // The kinds a module stands, or none.
+    kindsOf(module) {
+        return [...(this.#modules.get(module) ?? [])];
     }
 }

package/dist/harbor/root-line.d.ts

@@ -0,0 +1,9 @@
+import { type JsonObject } from '../being/index.ts';
+import type { Harbor } from './harbor.ts';
+export type RootRequest = {
+    ward?: string;
+    method?: string;
+    args?: JsonObject;
+};
+export declare const readRootRequest: (value: unknown) => RootRequest | null;
+export declare const rootLine: (harbor: Harbor, value: unknown) => Promise<JsonObject>;

package/dist/harbor/root-line.js

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+// The root line: one request, one answer, both plain JSON, for whatever
+// carries the root's asks to a harbor in its own process. The command line
+// carries it over a local socket, and an edge route carries it the same way.
+//
+//   request  { ward?, method?, args? }    no ward is the box ward, no
+//                                         method the census
+//   answer   { answer }                   what the ward-being said
+//            { silence: true }            she said nothing
+//            { word }                     a kit word: unreached, late, ...
+//            { error }                    the request was not one, or the
+//                                         ward is none this harbor holds
+import { isSilence, isWord, told } from '../being/index.js';
+const object = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+export const readRootRequest = (value) => {
+    if (!object(value))
+        return null;
+    const { ward, method, args } = value;
+    if ((ward !== undefined && typeof ward !== 'string') || (method !== undefined && typeof method !== 'string') || (args !== undefined && !object(args)))
+        return null;
+    return { ...(ward === undefined ? {} : { ward }), ...(method === undefined ? {} : { method }), ...(args === undefined ? {} : { args }) };
+};
+export const rootLine = async (harbor, value) => {
+    const request = readRootRequest(value);
+    if (request === null)
+        return { error: 'not a root request' };
+    const ward = request.ward === undefined ? harbor.box : harbor.ward(request.ward);
+    if (ward === undefined)
+        return { error: 'no such ward' };
+    const out = await ward.root(request.method, request.args);
+    if (isSilence(out))
+        return { silence: true };
+    if (isWord(out))
+        return { word: told(out) };
+    return { answer: out };
+};

package/dist/harbor/terrain.d.ts

@@ -1,8 +1,9 @@
-import type { Carrier, Clock, Custody, Entropy, Memory } from '../contract/index.ts';
+import type { Carrier, Clock, Custody, Entropy, Loader, Memory } from '../contract/index.ts';
 export declare abstract class Terrain {
     abstract readonly entropy: Entropy;
     abstract readonly clock: Clock;
     abstract readonly custody: Custody;
     abstract readonly memory: Memory;
+    abstract readonly loader: Loader;
     abstract readonly carrier: Carrier;
 }

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { Being, canonical, digest, Faculty, isSilence, isWord, OWNER, silence, told, WARD, word } from './being/index.ts';
 export type { Answer, Ask, Asker, AskSpec, BeingClass, BeingLike, Blueprint, Invitation, Json, JsonObject, Occupants, Reply, Schema, Silence, Stance, Standing, Standings, Wanted, Word, WordName } from './being/index.ts';
 export { readInvitation } from './quo/index.ts';
-export { Carrier, Clock, Custody, Entropy, Memory, type Rows } from './contract/index.ts';
-export { CEILING, DEFAULT, DEPTH, ownerAsk, pilots, WardBeing, type Steward, type WardBeingStance } from './ward/index.ts';
-export { BOX, Dock, Harbor, Registry, Terrain } from './harbor/index.ts';
-export { CryptoEntropy, HeldCustody, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World, type PointerParts } from './pointer/index.ts';
+export { Carrier, Clock, Custody, Entropy, Loader, Memory, type Loaded, type Module, type Rows } from './contract/index.ts';
+export { CEILING, DEFAULT, DEPTH, ownerAsk, Pilot, pilots, WardBeing, type Steward, type WardBeingStance } from './ward/index.ts';
+export { BOX, Catalogue, Dock, Harbor, readRootRequest, Registry, rootLine, Terrain, type RootRequest } from './harbor/index.ts';
+export { CryptoEntropy, HeldCustody, HeldLoader, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World, type PointerParts } from './pointer/index.ts';

package/dist/index.js

@@ -5,10 +5,10 @@
 export { Being, canonical, digest, Faculty, isSilence, isWord, OWNER, silence, told, WARD, word } from './being/index.js';
 export { readInvitation } from './quo/index.js';
 // What a terrain gives a harbor.
-export { Carrier, Clock, Custody, Entropy, Memory } from './contract/index.js';
+export { Carrier, Clock, Custody, Entropy, Loader, Memory } from './contract/index.js';
 // Wards and the ward-being.
-export { CEILING, DEFAULT, DEPTH, ownerAsk, pilots, WardBeing } from './ward/index.js';
-// The onion.
-export { BOX, Dock, Harbor, Registry, Terrain } from './harbor/index.js';
+export { CEILING, DEFAULT, DEPTH, ownerAsk, Pilot, pilots, WardBeing } from './ward/index.js';
+// The onion, and the one line its root's asks cross from any front.
+export { BOX, Catalogue, Dock, Harbor, readRootRequest, Registry, rootLine, Terrain } from './harbor/index.js';
 // The pointer dock: a whole world in one process.
-export { CryptoEntropy, HeldCustody, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World } from './pointer/index.js';
+export { CryptoEntropy, HeldCustody, HeldLoader, NoCarrier, PointerCarrier, PointerTerrain, SystemClock, VolatileMemory, World } from './pointer/index.js';

package/dist/pointer/bodies.d.ts

@@ -1,4 +1,4 @@
-import { Clock, Custody, Entropy, Memory, type Rows } from '../contract/index.ts';
+import { Clock, Custody, Entropy, Loader, Memory, type Loaded, type Module } from '../contract/index.ts';
 export declare class CryptoEntropy extends Entropy {
     draw(length: number): Uint8Array;
 }
@@ -12,9 +12,15 @@ export declare class SystemClock extends Clock {
 export declare class HeldCustody extends Custody {
     #private;
     constructor(entropy: Entropy);
-    seed(name: string): Promise<Uint8Array>;
+    seed(): Promise<Uint8Array>;
+}
+export declare class HeldLoader extends Loader {
+    #private;
+    constructor(modules?: readonly Module[]);
+    load(from: string): Promise<Loaded | null>;
 }
 export declare class VolatileMemory extends Memory {
     #private;
-    open(name: string): Promise<Rows>;
+    read(place: string): Promise<Map<string, Uint8Array>>;
+    write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
 }

package/dist/pointer/bodies.js

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // The pointer terrain's bodies: each contract fulfilled in one process,
 // with nothing beyond JavaScript.
-import { Clock, Custody, Entropy, Memory } from '../contract/index.js';
+import { Clock, Custody, Entropy, Loader, Memory } from '../contract/index.js';
 export class CryptoEntropy extends Entropy {
     draw(length) {
         return globalThis.crypto.getRandomValues(new Uint8Array(length));
@@ -17,29 +17,48 @@ export class SystemClock extends Clock {
         return { done, cancel: () => clearTimeout(timer) };
     }
 }
-// Seeds drawn once per name and held by this object.
+// The harbor's seed, drawn once and held by this object.
 export class HeldCustody extends Custody {
-    #entropy;
-    #seeds = new Map();
+    #seed;
     constructor(entropy) {
         super();
-        this.#entropy = entropy;
+        this.#seed = entropy.draw(32);
     }
-    seed(name) {
-        let seed = this.#seeds.get(name);
-        if (!seed)
-            this.#seeds.set(name, (seed = this.#entropy.draw(32)));
-        return Promise.resolve(seed);
+    seed() {
+        return Promise.resolve(this.#seed.slice());
     }
 }
-// Rows that live as long as this object: opening a name again gives the
-// same rows, which is what a restart in one process finds.
+// Modules handed to this object, found by the name each declares.
+export class HeldLoader extends Loader {
+    #modules = new Map();
+    constructor(modules = []) {
+        super();
+        for (const m of modules)
+            this.#modules.set(m.module, m);
+    }
+    load(from) {
+        const m = this.#modules.get(from);
+        return Promise.resolve(m ? { module: m.module, version: m.version, classes: m.classes, from } : null);
+    }
+}
+// Entries that live as long as this object, copied in and out, which is
+// what a restart in one process finds.
 export class VolatileMemory extends Memory {
-    #wards = new Map();
-    open(name) {
-        let rows = this.#wards.get(name);
-        if (!rows)
-            this.#wards.set(name, (rows = { rows: {}, told: () => { }, kept: () => Promise.resolve(true) }));
-        return Promise.resolve(rows);
+    #places = new Map();
+    read(place) {
+        const entries = this.#places.get(place) ?? new Map();
+        return Promise.resolve(new Map([...entries].map(([name, bytes]) => [name, bytes.slice()])));
+    }
+    write(place, entries) {
+        let kept = this.#places.get(place);
+        if (!kept)
+            this.#places.set(place, (kept = new Map()));
+        for (const [name, bytes] of entries) {
+            if (bytes === null)
+                kept.delete(name);
+            else
+                kept.set(name, bytes.slice());
+        }
+        return Promise.resolve();
     }
 }

package/dist/pointer/index.d.ts

@@ -1,2 +1,2 @@
-export { CryptoEntropy, HeldCustody, SystemClock, VolatileMemory } from './bodies.ts';
+export { CryptoEntropy, HeldCustody, HeldLoader, SystemClock, VolatileMemory } from './bodies.ts';
 export { NoCarrier, PointerCarrier, PointerTerrain, World, type PointerParts } from './world.ts';

package/dist/pointer/index.js

@@ -1,4 +1,4 @@
 // SPDX-License-Identifier: Apache-2.0
 // The pointer dock: a whole world with `nervur` alone.
-export { CryptoEntropy, HeldCustody, SystemClock, VolatileMemory } from './bodies.js';
+export { CryptoEntropy, HeldCustody, HeldLoader, SystemClock, VolatileMemory } from './bodies.js';
 export { NoCarrier, PointerCarrier, PointerTerrain, World } from './world.js';