nervur 0.21.0 → 0.21.2

package/dist/node/index.js

@@ -53,8 +53,10 @@ export const isFile = (from) => /^(\.{1,2}[\\/]|[\\/]|[A-Za-z]:[\\/])/.test(from
 // Code from a file or an installed package: a module that exports
 // `module`, `version` and `classes`, found again by where it was found, a
 // file by its absolute path and a package by its name, resolved from each
-// folder of `bases` in order. What cannot be imported, or exports no
-// module, is none.
+// folder of `bases` in order. What is not there, or exports no module, is
+// none. Code that is there and does not import throws Node's reason, so
+// whoever added it learns why; an ES module read as CommonJS says which
+// field its package.json lacks.
 export class ImportLoader extends Loader {
     #bases;
     constructor(bases = [process.cwd()]) {
@@ -69,8 +71,14 @@ export class ImportLoader extends Loader {
         try {
             exported = (await import(__rewriteRelativeImportExtension(pathToFileURL(found).href)));
         }
-        catch {
-            return null;
+        catch (e) {
+            const said = e.message;
+            // The name itself is nowhere, as against code there that needs
+            // something that is not.
+            if (e.code === 'ERR_MODULE_NOT_FOUND' && said.includes(`'${found}'`))
+                return null;
+            const commonjs = e instanceof SyntaxError && /\b(export|import)\b/.test(said);
+            throw new Error(`${found} did not load: ${said}${commonjs ? '; it is an ES module read as CommonJS, so set "type": "module" in its package.json' : ''}`, { cause: e });
         }
         const { module, version, classes } = exported;
         if (typeof module !== 'string' || typeof version !== 'string' || !Array.isArray(classes))

package/dist/proof/index.d.ts

@@ -1,3 +1,3 @@
 export { entropyScenes, custodyScenes, loaderScenes, memoryScenes, type Cut, type Scene } from './contracts.ts';
 export { expect, type Expect } from './expect.ts';
-export { law, lawScenes, type Bodies, type Terrain } from './law.ts';
+export { keeperScenes, law, lawScenes, type Bodies, type Terrain } from './law.ts';

package/dist/proof/index.js

@@ -6,7 +6,9 @@
 //   for (const [title, scene] of memoryScenes('S3Memory', make, expect, half)) test(title, scene);
 //
 // `expect` throws on the first assertion that fails. The law's scenes stand
-// harbors on a stranger's bodies and hold the unpacking law over them.
+// harbors on a stranger's bodies and hold the unpacking law over them, and
+// the keeper's scenes hold a being's fields over the root memory and over
+// every store.
 export { entropyScenes, custodyScenes, loaderScenes, memoryScenes } from './contracts.js';
 export { expect } from './expect.js';
-export { law, lawScenes } from './law.js';
+export { keeperScenes, law, lawScenes } from './law.js';

package/dist/proof/law.d.ts

@@ -1,6 +1,6 @@
 import { Being, Faculty, type Asker, type JsonObject } from '../being/index.ts';
 import { Memory, type Custody, type Module } from '../contract/index.ts';
-import { type Harbor } from '../harbor/index.ts';
+import { Store, type Harbor } from '../harbor/index.ts';
 import { World } from '../pointer/index.ts';
 import type { Expect } from './expect.ts';
 export type Bodies = {
@@ -45,8 +45,46 @@ declare class Customer extends Being {
     buy(args: JsonObject): Promise<JsonObject>;
     echo(args: JsonObject): Promise<JsonObject>;
 }
-export declare const classes: (typeof Echo | typeof Shop | typeof Customer)[];
+declare class Profile extends Being {
+    static kind: string;
+    static cells: {
+        name: string;
+        age: number;
+    };
+    static asks: {
+        set: {};
+        get: {};
+    };
+    set(args: JsonObject): JsonObject;
+    get(): JsonObject;
+}
+declare class Shelf extends Store {
+    #private;
+    static kind: string;
+    static shelf(key: string): Watched;
+    static reset(): void;
+    read(place: string): Promise<Map<string, Uint8Array>>;
+    write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
+    places(): Promise<string[]>;
+    forget(place: string): Promise<void>;
+}
+export declare const classes: (typeof Echo | typeof Shop | typeof Customer | typeof Profile | typeof Shelf)[];
 export declare const law: Module;
 export declare const standOne: (world: World, name: string, parts?: Partial<Bodies>) => Promise<Harbor>;
+declare class Watched extends Memory {
+    readonly inner: Memory;
+    readonly seen: {
+        place: string;
+        name: string;
+        bytes: Uint8Array | null;
+    }[];
+    refuse: (place: string) => boolean;
+    constructor(inner: Memory);
+    read(place: string): Promise<Map<string, Uint8Array>>;
+    write(place: string, entries: ReadonlyMap<string, Uint8Array | null>): Promise<void>;
+    places(): Promise<string[]>;
+    forget(place: string): Promise<void>;
+}
 export declare const lawScenes: (t: Terrain, expect: Expect) => [string, () => Promise<void>][];
+export declare const keeperScenes: (t: Terrain, expect: Expect) => [string, () => Promise<void>][];
 export {};

package/dist/proof/law.js

@@ -7,8 +7,8 @@
 // It names no runtime, so it bundles.
 import { Being, Faculty } from '../being/index.js';
 import { Memory } from '../contract/index.js';
-import { copyPackage, rootLine } from '../harbor/index.js';
-import { CryptoEntropy, HeldLoader, World } from '../pointer/index.js';
+import { copyPackage, GROUND_STORE, rootLine, Store } from '../harbor/index.js';
+import { CryptoEntropy, HeldLoader, VolatileMemory, World } from '../pointer/index.js';
 class Echoes extends Faculty {
     static kind = 'org.example.echoes';
 }
@@ -52,9 +52,53 @@ class Customer extends Being {
         return { said: ((await this.stance.standings.get('echo')?.ask('echo', args)) ?? null) };
     }
 }
+// A being whose fields are her cells, and nothing else.
+class Profile extends Being {
+    static kind = 'org.example.profile';
+    static cells = { name: '', age: 0 };
+    static asks = { set: {}, get: {} };
+    set(args) {
+        if (typeof args.name === 'string')
+            this.cells.name = args.name;
+        if (typeof args.age === 'number')
+            this.cells.age = args.age;
+        return this.get();
+    }
+    get() {
+        return { name: this.cells.name ?? null, age: this.cells.age ?? null };
+    }
+}
+// A store a module brings: places on a shelf of this process, by the
+// faculty's key, which outlive a harbor as a database outlives its client.
+// A scene empties every shelf before it stands.
+class Shelf extends Store {
+    static kind = 'org.example.shelf';
+    static #shelves = new Map();
+    static shelf(key) {
+        let shelf = Shelf.#shelves.get(key);
+        if (!shelf)
+            Shelf.#shelves.set(key, (shelf = new Watched(new VolatileMemory())));
+        return shelf;
+    }
+    static reset() {
+        Shelf.#shelves.clear();
+    }
+    read(place) {
+        return Shelf.shelf(this.stance.key).read(place);
+    }
+    write(place, entries) {
+        return Shelf.shelf(this.stance.key).write(place, entries);
+    }
+    places() {
+        return Shelf.shelf(this.stance.key).places();
+    }
+    forget(place) {
+        return Shelf.shelf(this.stance.key).forget(place);
+    }
+}
 // One set of classes for every scene in a bundle, since a bundler renames
 // a second class of the same name and a row resolves a class by its name.
-export const classes = [Echo, Shop, Customer];
+export const classes = [Echo, Shop, Customer, Profile, Shelf];
 export const law = { module: 'org.example.law', version: '1', classes };
 // A harbor of the world whose catalogue runs the law's module.
 export const standOne = async (world, name, parts = {}) => {
@@ -64,10 +108,12 @@ export const standOne = async (world, name, parts = {}) => {
 };
 const CATALOGUE = { catalogue: { class: 'org.nervur.catalogue', public: false, absent: false } };
 const NONE = { wards: {}, routes: {} };
-// Every byte a memory is handed, seen from outside it.
+// Every byte a memory is handed, seen from outside it, and a keep it
+// refuses where `refuse` says.
 class Watched extends Memory {
     inner;
     seen = [];
+    refuse = () => false;
     constructor(inner) {
         super();
         this.inner = inner;
@@ -76,6 +122,8 @@ class Watched extends Memory {
         return this.inner.read(place);
     }
     write(place, entries) {
+        if (this.refuse(place))
+            return Promise.reject(new Error('refused'));
         for (const [name, bytes] of entries)
             this.seen.push({ place, name, bytes: bytes && bytes.slice() });
         return this.inner.write(place, entries);
@@ -210,7 +258,7 @@ export const lawScenes = (t, expect) => [
             expect.same(again.names, ['good']);
             expect.same((await census(again)).failed, { wards: { bad: 'an entry the package did not seal' }, routes: {} });
             expect.same(await rootLine(again, { ward: 'bad' }), { error: 'the ward did not stand', reason: 'an entry the package did not seal' });
-            expect.same(await again.root('host', { ward: 'bad' }), { error: 'no such ward to host' }, 'its name and seed stay kept');
+            expect.same(await again.root('host', { ward: 'bad' }), { error: 'bad is hosted already' }, 'its name and seed stay kept');
             await spoil(places[1]);
             let refused = '';
             await world.restart('h', t.again(bodies)).catch((e) => (refused = e.message));
@@ -343,3 +391,201 @@ export const lawScenes = (t, expect) => [
         },
     ],
 ];
+const KEEPERS = [{ name: 'the root memory' }, { name: 'a ground store', store: 'vault', kind: GROUND_STORE }, { name: 'a store of a module', store: 'shelf', kind: Shelf.kind }];
+const onKeeper = (k) => (k.store === undefined ? {} : { store: k.store });
+// The keeper opened in the box ward, where it is a store.
+const openKeeper = async (harbor, k, expect) => {
+    if (k.store !== undefined)
+        expect.same(await harbor.root('open', { key: k.store, class: k.kind }), { opened: k.store });
+};
+const profile = async (harbor, method, args = {}) => (await harbor.ward('ana').root('ask', { being: 'me', method, args })).answer;
+// Acme's shop kept by `k`, home's alice on the root memory, joined, and
+// every box that reaches the shop's door seen.
+const shopOn = async (world, t, k, expect) => {
+    const bodies = { acme: t.make(), home: t.make() };
+    const acme = await standOne(world, 'acme', bodies.acme);
+    const home = await standOne(world, 'home', bodies.home);
+    await openKeeper(acme, k, expect);
+    expect.same(await acme.root('host', { ward: 'shop', ...onKeeper(k) }), { hosted: 'shop' });
+    expect.same(await acme.ward('shop').root('boot', { key: 'shop', class: 'org.example.shop' }), { booted: 'shop' });
+    expect.same(await home.root('host', { ward: 'alice' }), { hosted: 'alice' });
+    expect.same(await home.ward('alice').root('boot', { key: 'me', class: 'org.example.customer' }), { booted: 'me' });
+    const invitation = (await acme.ward('shop').root('invite', { being: 'shop', id: 'alice' }));
+    const shop = acme.ward('shop').pk;
+    const boxes = [];
+    const carry = world.carry.bind(world);
+    world.carry = (pk, bytes) => {
+        if (pk === shop)
+            boxes.push(bytes.slice());
+        return carry(pk, bytes);
+    };
+    const me = async (method, args = {}) => (await world.get('home').ward('alice').root('ask', { being: 'me', method, args })).answer;
+    expect.same(await me('join', { invitation }), { joined: 'shop' });
+    return { acme: bodies.acme, boxes, me };
+};
+const sold = (harbor) => harbor.ward('shop').partition.being('shop')?.cells.sold;
+// A cell is a being's field made durable, whoever keeps it: the law's
+// scenes of a being's fields, run over every keeper a hosted ward's place
+// may live with.
+export const keeperScenes = (t, expect) => [
+    ...KEEPERS.flatMap((k) => [
+        [
+            `law on ${t.name}: a being's fields kept by ${k.name} come back at wake, sealed, where that keeper alone holds them`,
+            async () => {
+                Shelf.reset();
+                const bodies = t.make();
+                const watched = new Watched(bodies.memory);
+                const world = new World();
+                const harbor = await standOne(world, 'h', { custody: bodies.custody, memory: watched });
+                await openKeeper(harbor, k, expect);
+                expect.same(await harbor.root('host', { ward: 'ana', ...onKeeper(k) }), { hosted: 'ana' });
+                expect.same(await harbor.ward('ana').root('boot', { key: 'me', class: Profile.kind }), { booted: 'me' });
+                expect.same(await profile(harbor, 'set', { name: 'Anastasia', age: 31 }), { name: 'Anastasia', age: 31 });
+                const again = await world.restart('h', t.again(bodies));
+                expect.same(await profile(again, 'get'), { name: 'Anastasia', age: 31 });
+                expect.same((await census(again)).failed, NONE);
+                const root = await bodies.memory.places();
+                const shelf = await Shelf.shelf('shelf').places();
+                if (k.store === undefined)
+                    expect.same([root.length, shelf.length], [2, 0], 'the box ward and ana, on the root memory');
+                else if (k.kind === GROUND_STORE)
+                    expect.same([root.length, root.filter((p) => p.length > 32).length, shelf.length], [2, 1, 0], 'ana behind the ground store key');
+                else
+                    expect.same([root.length, shelf.length], [1, 1], 'the box ward on the root memory, ana on the shelf');
+                const seen = [...watched.seen, ...Shelf.shelf('shelf').seen];
+                for (const { bytes } of seen) {
+                    if (bytes === null)
+                        continue;
+                    for (const word of ['Anastasia', 'org.example', 'vault'].map(utf8))
+                        expect.ok(!holds(bytes, word), 'no field, kind or key in the clear');
+                }
+            },
+        ],
+        [
+            `law on ${t.name}: an answer whose keep ${k.name} refuses is silence, and the being keeps what she had`,
+            async () => {
+                Shelf.reset();
+                const bodies = t.make();
+                const watched = new Watched(bodies.memory);
+                const world = new World();
+                const harbor = await standOne(world, 'h', { custody: bodies.custody, memory: watched });
+                const box = watched.seen[0].place;
+                await openKeeper(harbor, k, expect);
+                expect.same(await harbor.root('host', { ward: 'ana', ...onKeeper(k) }), { hosted: 'ana' });
+                expect.same(await harbor.ward('ana').root('boot', { key: 'me', class: Profile.kind }), { booted: 'me' });
+                expect.same(await profile(harbor, 'set', { age: 31 }), { name: '', age: 31 });
+                // Only the keeper named refuses, so a keep that went elsewhere
+                // would answer.
+                if (k.store === undefined)
+                    watched.refuse = (place) => place !== box;
+                else if (k.kind === GROUND_STORE)
+                    watched.refuse = (place) => place.length > box.length;
+                else
+                    Shelf.shelf('shelf').refuse = () => true;
+                expect.ok(JSON.stringify(await profile(harbor, 'set', { age: 32 })) !== JSON.stringify({ name: '', age: 32 }), 'no answer leaves an unkept keep');
+                expect.equal(harbor.ward('ana').partition.being('me')?.cells.age, 31, 'what she wrote is put back');
+                watched.refuse = () => false;
+                Shelf.shelf('shelf').refuse = () => false;
+                const again = await world.restart('h', t.again(bodies));
+                expect.same(await profile(again, 'get'), { name: '', age: 31 });
+                expect.same(await profile(again, 'set', { age: 32 }), { name: '', age: 32 });
+            },
+        ],
+        [
+            `law on ${t.name}: the door's keys and the being's cells are one keep with ${k.name}, so a box replayed after a wake is answered once`,
+            async () => {
+                Shelf.reset();
+                const world = new World();
+                const { acme, boxes, me } = await shopOn(world, t, k, expect);
+                const from = boxes.length;
+                expect.same(await me('buy', { item: 'tea' }), { said: { bought: 'tea' } });
+                const replayed = boxes.slice(from);
+                expect.ok(replayed.length > 0, 'the buy crossed the door');
+                const again = await world.restart('acme', t.again(acme));
+                expect.same(sold(again), ['tea to alice']);
+                for (const bytes of replayed)
+                    await again.arrive(again.ward('shop').pk, bytes);
+                expect.same(sold(again), ['tea to alice'], 'a replayed box does not buy again');
+                expect.same(await me('buy', { item: 'cake' }), { said: { bought: 'cake' } });
+                expect.same(sold(world.get('acme')), ['tea to alice', 'cake to alice']);
+            },
+        ],
+    ]),
+    [
+        `law on ${t.name}: a ward whose store does not stand at wake fails alone, and stands whole once it returns`,
+        async () => {
+            Shelf.reset();
+            const bodies = t.make();
+            const world = new World();
+            const harbor = await standOne(world, 'h', bodies);
+            await openKeeper(harbor, KEEPERS[2], expect);
+            expect.same(await harbor.root('host', { ward: 'ana', store: 'shelf' }), { hosted: 'ana' });
+            expect.same(await harbor.root('host', { ward: 'bea' }), { hosted: 'bea' });
+            expect.same(await harbor.ward('ana').root('boot', { key: 'me', class: Profile.kind }), { booted: 'me' });
+            expect.same(await profile(harbor, 'set', { age: 31 }), { name: '', age: 31 });
+            const lost = await world.restart('h', { ...t.again(bodies), loader: new HeldLoader([]) });
+            expect.same(lost.names, ['bea'], 'the root and its own ward stand');
+            expect.same((await census(lost)).failed, { wards: { ana: 'the store shelf does not stand' }, routes: {} });
+            const back = await world.restart('h', { ...t.again(bodies), loader: new HeldLoader([law]) });
+            expect.same(back.names, ['ana', 'bea']);
+            expect.same(await profile(back, 'get'), { name: '', age: 31 });
+        },
+    ],
+    [
+        `law on ${t.name}: a ward carried between keepers keeps its fields, its door and its key, and leaves nothing where it was`,
+        async () => {
+            Shelf.reset();
+            const world = new World();
+            const { acme, me } = await shopOn(world, t, KEEPERS[0], expect);
+            const harbor = world.get('acme');
+            for (const k of KEEPERS.slice(1))
+                await openKeeper(harbor, k, expect);
+            const pk = harbor.ward('shop').pk;
+            const items = ['tea', 'cake', 'bread', 'milk'];
+            const vault = harbor.box.being('vault');
+            const counts = async () => [(await acme.memory.places()).filter((p) => p.length === 32).length, (await vault.places()).length, (await Shelf.shelf('shelf').places()).length];
+            expect.same(await me('buy', { item: items[0] }), { said: { bought: items[0] } });
+            const road = [
+                [KEEPERS[1], [1, 1, 0]],
+                [KEEPERS[2], [1, 0, 1]],
+                [KEEPERS[0], [2, 0, 0]],
+            ];
+            for (const [i, [k, want]] of road.entries()) {
+                expect.same(await world.get('acme').root('move', { ward: 'shop', store: k.store ?? null }), { moved: 'shop', store: k.store ?? null });
+                expect.same(await counts(), want, `only ${k.name} holds the shop`);
+                const again = await world.restart('acme', t.again(acme));
+                expect.equal(again.ward('shop').pk, pk, 'the key moves with the ward');
+                expect.same(await me('buy', { item: items[i + 1] }), { said: { bought: items[i + 1] } });
+                expect.same(sold(again), items.slice(0, i + 2).map((item) => `${item} to alice`));
+            }
+            expect.same(await world.get('acme').root('move', { ward: 'shop', store: null }), { error: 'shop is kept there already' });
+            expect.same(await world.get('acme').root('move', { ward: 'shop', store: 'echo' }), { error: 'no such store' });
+        },
+    ],
+    [
+        `law on ${t.name}: a store keeping a ward does not go, and the root sweeps what no keeper is named for`,
+        async () => {
+            Shelf.reset();
+            const bodies = t.make();
+            const world = new World();
+            const harbor = await standOne(world, 'h', bodies);
+            for (const k of KEEPERS.slice(1))
+                await openKeeper(harbor, k, expect);
+            expect.same(await harbor.root('host', { ward: 'ana', store: 'vault' }), { hosted: 'ana' });
+            expect.same(await harbor.root('host', { ward: 'bea', store: 'shelf' }), { hosted: 'bea' });
+            expect.same(await harbor.root('host', { ward: 'cy', store: 'nothing' }), { error: 'no such store' });
+            expect.same(await harbor.root('unboot', { being: 'vault' }), { error: 'a ward is kept by this store' });
+            const vault = harbor.box.being('vault');
+            const before = [(await bodies.memory.places()).sort(), await vault.places(), await Shelf.shelf('shelf').places()];
+            const stray = 'ee'.repeat(16);
+            await vault.write(stray, new Map([['ab', new Uint8Array([1])]]));
+            await Shelf.shelf('shelf').write(stray, new Map([['ab', new Uint8Array([2])]]));
+            expect.same(await harbor.root('sweep'), { swept: [stray, stray] });
+            expect.same([(await bodies.memory.places()).sort(), await vault.places(), await Shelf.shelf('shelf').places()], before, 'what the dock names stays');
+            expect.same(await harbor.root('move', { ward: 'bea', store: null }), { moved: 'bea', store: null });
+            expect.same(await harbor.root('unboot', { being: 'shelf' }), { unbooted: 'shelf' });
+            const again = await world.restart('h', t.again(bodies));
+            expect.same(again.names, ['ana', 'bea']);
+        },
+    ],
+];

package/dist/ward/ward.js

@@ -98,23 +98,29 @@ export class Ward {
         }
     }
     // The unsealed ask: the ward-being, asked by whoever holds this ward.
+    // It reaches every being of the ward through the ward-being, so every
+    // row is put back where the memory refuses.
     async root(method, args = {}) {
-        return this.#kept(WARD, () => this.#answer(WARD, { id: OWNER }, method, args));
+        return this.#kept(Object.keys(this.partition.beings), () => this.#answer(WARD, { id: OWNER }, method, args));
     }
-    // A being's answer, kept. Where the memory refuses, what she wrote is
-    // put back and her answer is silence. What her relations stand on is not
+    // An answer, kept. Where the memory refuses, what the beings wrote is put
+    // back and the answer is silence. What their relations stand on is not
     // put back: a relation's keys move only as far as its standing follows.
-    async #kept(key, work) {
-        const row = this.partition.being(key);
-        const before = row && JSON.stringify(row.cells);
+    async #kept(keys, work) {
+        const before = keys.flatMap((key) => {
+            const row = this.partition.being(key);
+            return row ? [[key, row.cells, JSON.stringify(row.cells)]] : [];
+        });
         const out = await work();
         if (await this.partition.kept())
             return out;
-        if (row && before !== undefined) {
-            for (const k of Object.keys(row.cells))
-                delete row.cells[k];
-            for (const [k, v] of Object.entries(JSON.parse(before)))
-                Object.defineProperty(row.cells, k, { value: v, enumerable: true, writable: true, configurable: true });
+        for (const [key, cells, was] of before) {
+            if (JSON.stringify(cells) === was)
+                continue;
+            for (const k of Object.keys(cells))
+                delete cells[k];
+            for (const [k, v] of Object.entries(JSON.parse(was)))
+                Object.defineProperty(cells, k, { value: v, enumerable: true, writable: true, configurable: true });
             this.partition.told(key);
         }
         return silence;
@@ -132,7 +138,7 @@ export class Ward {
         const args = p.args === undefined ? {} : readValue(p.args, DEPTH + 1);
         if (key === null || key === undefined || typeof args !== 'object' || args === null || Array.isArray(args))
             return { silence: true };
-        const out = await this.#kept(key, () => this.#answer(key, asker, p.method, args));
+        const out = await this.#kept([key], () => this.#answer(key, asker, p.method, args));
         const object = isSilence(out) || isWord(out) ? undefined : writeValue(out, DEPTH);
         if (object === undefined)
             return { silence: true };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervur",
-  "version": "0.21.0",
+  "version": "0.21.2",
   "description": "Nervur's kit of Quo: an object asks another object and gets an answer, without knowing where it is.",
   "keywords": [
     "quo",

package/src/cli/command.ts

@@ -28,7 +28,10 @@
 //                                                   dev, from this folder, at
 //                                                   http://127.0.0.1:P/quo
 //   nervur open   <key> <kind>                      a faculty stands in the box ward
-//   nervur host   <ward> [--seed S]                 a hosted ward stands
+//   nervur host   <ward> [--seed S] [--store K]     a hosted ward stands, kept by the
+//                                                   root memory or the store K
+//   nervur move   <ward> <store | root>             a hosted ward carried to a store,
+//                                                   or back to the root memory
 //   nervur route  <ward pk> <address... | none>     where a ward is reached, in order
 //   nervur reach  <address...>                      where this harbor is reached, as
 //                                                   every invitation it gives says
@@ -63,8 +66,8 @@ import { carry, isServed, land, open, pack, request, serve } from './harbor.ts';
 // Where `edge dev` answers unless --port names another, wrangler's own.
 const EDGE_PORT = 8787;
 
-const USAGE = 'usage: nervur <init|serve|module|modules|census|sweep|open|host|route|reach|boot|unboot|public|invite|ask|own|disown|pilot|export|import|edge> [args] [--dir D] [--ward W] [--via V] [--seed S] [--with-seed] [--host H] [--port P]';
-const FLAGS = new Set(['dir', 'ward', 'via', 'seed', 'host', 'port']);
+const USAGE = 'usage: nervur <init|serve|module|modules|census|sweep|open|host|move|route|reach|boot|unboot|public|invite|ask|own|disown|pilot|export|import|edge> [args] [--dir D] [--ward W] [--via V] [--seed S] [--store K] [--with-seed] [--host H] [--port P]';
+const FLAGS = new Set(['dir', 'ward', 'via', 'seed', 'store', 'host', 'port']);
 // The one flag that stands alone, since what it names is a yes.
 const ALONE = 'with-seed';
 
@@ -120,7 +123,11 @@ export const requestOf = (command: string, words: string[], flags: Record<string
     }
     case 'host': {
       const [ward] = need(1);
-      return { method: 'host', args: { ward: ward!, ...(flags.seed === undefined ? {} : { seed: flags.seed }) } };
+      return { method: 'host', args: { ward: ward!, ...(flags.seed === undefined ? {} : { seed: flags.seed }), ...(flags.store === undefined ? {} : { store: flags.store }) } };
+    }
+    case 'move': {
+      const [ward, store] = need(2);
+      return { method: 'move', args: { ward: ward!, store: store === 'root' ? null : store! } };
     }
     case 'route': {
       const [ward, ...where] = words;

package/src/contract/index.ts

@@ -62,7 +62,8 @@ export type Module = { readonly module: string; readonly version: string; readon
 export type Loaded = Module & { readonly from: string };
 
 // 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
+// none. Code it has that does not load throws, saying why. 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 abstract class Loader {
   abstract load(from: string): Promise<Loaded | null>;

package/src/harbor/catalogue.ts

@@ -67,10 +67,16 @@ export class Catalogue extends Faculty {
   // it. The rest stay out, each with its reason.
   async wake(): Promise<void> {
     for (const [module, row] of Object.entries(this.#rows)) {
-      const loaded = await this.#harbor.load(row.from).catch(() => null);
+      const loaded = await this.#harbor.load(row.from).catch((e: Error) => e);
       const refused =
-        loaded === null ? `not found at ${row.from}` : loaded.module !== module ? `${row.from} is module ${loaded.module}` : this.#harbor.check([...this.#running.values(), loaded]);
-      if (refused === null) this.#running.set(module, loaded!);
+        loaded instanceof Error
+          ? loaded.message
+          : loaded === null
+            ? `not found at ${row.from}`
+            : loaded.module !== module
+              ? `${row.from} is module ${loaded.module}`
+              : this.#harbor.check([...this.#running.values(), loaded]);
+      if (refused === null) this.#running.set(module, loaded as Loaded);
       else this.#failed.set(module, refused);
     }
     this.#harbor.run([...this.#running.values()]);
@@ -78,7 +84,8 @@ export class Catalogue extends Faculty {
 
   async add(args: JsonObject): Promise<JsonObject> {
     if (!text(args.from)) return { error: 'from is text' };
-    const loaded = await this.#harbor.load(args.from);
+    const loaded = await this.#harbor.load(args.from).catch((e: Error) => e);
+    if (loaded instanceof Error) return { error: loaded.message };
     if (loaded === null) return { error: 'no such module' };
     const running = new Map(this.#running);
     running.set(loaded.module, loaded);