nervur 0.21.1 → 0.21.2

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);
@@ -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.1",
+  "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/harbor/dock.ts

@@ -5,9 +5,14 @@
 //
 //   open    { key, class }      a faculty stands in the box ward, and the
 //                               dock holds a standing on her under her key
-//   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
+//   host    { ward, seed?,      a hosted ward stands under the seed named,
+//             store? }          or a drawn one, holding a standing on the
+//                               dock; the dock keeps its name, its seed and
+//                               the store faculty that keeps its place, or
+//                               none for the root memory
+//   move    { ward, store }     a hosted ward's place carried whole to
+//                               another keeper, a store's key or null for
+//                               the root memory, and forgotten where it was
 //   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
@@ -22,13 +27,19 @@
 // route, where the root set none.
 import { Faculty, KIT, type Asker, type AskSpec, type Blueprint, type Invitation, type JsonObject } from '../being/index.ts';
 import { CATALOGUE } from './catalogue.ts';
+import { STORE } from './store.ts';
 import { readAt, readInvitation } from '../quo/index.ts';
 import { ownerAsk, pilots, rootAsk, WardBeing, type Lender, type WardBeingStance } from '../ward/index.ts';
 
 // What the dock asks of her harbor: a ward standing, and the seed, as hex,
 // it stands under.
 export interface Hosting {
-  host(name: string, invitation: Invitation, seed?: string): Promise<string | null>;
+  host(name: string, invitation: Invitation, seed?: string, store?: string): Promise<string | null>;
+  // A standing ward's place, carried to another keeper and standing from
+  // there: null, or why not. Where it was stays until `release`.
+  move(name: string, seed: string, from: string | undefined, to: string | undefined): Promise<string | null>;
+  // A ward's place, forgotten by the keeper named.
+  release(name: string, store: string | undefined): Promise<void>;
   // Whether the harbor's carrier took the route.
   route(pk: string, at: readonly string[] | null): boolean;
   // Whether the box ward's partition was kept.
@@ -45,8 +56,9 @@ export interface Hosting {
   lull(key: string): Promise<void>;
 }
 
-// One hosted ward, as the dock's cells keep it.
-export type Hosted = { ward: string; seed: string };
+// One hosted ward, as the dock's cells keep it, with the key of the store
+// that keeps its place where the root memory does not.
+export type Hosted = { ward: string; seed: string; store?: string };
 
 // Each hosted ward that did not unpack and each route the carrier did not
 // take, with the reason, by name and by ward pk.
@@ -64,7 +76,8 @@ export class Dock extends WardBeing implements Lender {
   static override asks: Record<string, AskSpec> = {
     ...WardBeing.asks,
     open: ownerAsk('a faculty of this harbor', { required: ['key', 'class'] }),
-    host: ownerAsk('a ward this harbor hosts', { required: ['ward'] }),
+    host: ownerAsk('a ward this harbor hosts, kept by the root memory or by the store named', { required: ['ward'] }),
+    move: ownerAsk('a hosted ward carried to a store, or to the root memory with null', { required: ['ward', 'store'] }),
     route: ownerAsk('where a ward is reached, addresses in order, or null', { required: ['ward', 'at'] }),
     reach: ownerAsk('where this harbor is reached, the addresses every invitation carries', { required: ['at'] }),
     sweep: rootAsk('every place of the memory this harbor does not name, gone'),
@@ -87,7 +100,12 @@ export class Dock extends WardBeing implements Lender {
   }
 
   get hosted(): Hosted[] {
-    return (this.cells.hosted as Hosted[]).map(({ ward, seed }) => ({ ward, seed }));
+    return (this.cells.hosted as Hosted[]).map(({ ward, seed, store }) => ({ ward, seed, ...(store === undefined ? {} : { store }) }));
+  }
+
+  // Whether a key names a store faculty the dock opened.
+  #store(key: unknown): key is string {
+    return text(key) && this.#fulfilling(STORE).includes(key);
   }
 
   get routes(): Record<string, string[]> {
@@ -130,8 +148,10 @@ export class Dock extends WardBeing implements Lender {
     if ((await this.stance.boot(kind, CATALOGUE, CATALOGUE)) === null || !(await this.#hosting.keep())) throw new Error('the catalogue did not stand');
   }
 
-  // A faculty that goes stops listening first.
+  // A faculty that goes stops listening first, and a store keeping a
+  // ward's place does not go.
   override async unboot(args: JsonObject): Promise<JsonObject> {
+    if (this.hosted.some((h) => h.store !== undefined && h.store === args.being)) return { error: 'a ward is kept by this store' };
     if (typeof args.being === 'string') await this.#hosting.lull(args.being);
     return super.unboot(args);
   }
@@ -162,17 +182,46 @@ export class Dock extends WardBeing implements Lender {
     if (name === BOX) return { error: 'box is the box ward' };
     if (this.hosted.some((h) => h.ward === name)) return { error: `${name} is hosted already` };
     if (args.seed !== undefined && !text(args.seed)) return { error: 'seed is text' };
+    const store = args.store ?? undefined;
+    if (store !== undefined && !this.#store(store)) return { error: 'no such store' };
     const invitation = await this.stance.occupants.invite(name, { hosted: true });
     if (invitation === null) return { error: 'not hosted' };
-    const seed = await this.#hosting.host(name, invitation, args.seed);
+    const seed = await this.#hosting.host(name, invitation, args.seed, store);
     if (seed === null) {
       this.stance.occupants.remove(name);
       return { error: 'not hosted' };
     }
-    (this.cells.hosted as Hosted[]).push({ ward: name, seed });
+    (this.cells.hosted as Hosted[]).push({ ward: name, seed, ...(store === undefined ? {} : { store }) });
     return { hosted: name };
   }
 
+  // The place is written where it goes before the dock's cells say so, and
+  // forgotten where it was only once they are kept, so a cut at any step
+  // leaves the ward whole under the keeper the cells name.
+  async move(args: JsonObject): Promise<JsonObject> {
+    const rows = this.cells.hosted as Hosted[];
+    const row = rows.find((h) => h.ward === args.ward);
+    if (!row) return { error: 'no such ward' };
+    const to = args.store ?? undefined;
+    if (to !== undefined && !this.#store(to)) return { error: 'no such store' };
+    const from = row.store;
+    if (from === to) return { error: `${row.ward} is kept there already` };
+    const refused = await this.#hosting.move(row.ward, row.seed, from, to);
+    if (refused !== null) return { error: refused };
+    const set = (store: string | undefined): void => {
+      if (store === undefined) delete row.store;
+      else row.store = store;
+    };
+    set(to);
+    if (!(await this.#hosting.keep())) {
+      set(from);
+      await this.#hosting.move(row.ward, row.seed, to, from);
+      return { error: 'not kept' };
+    }
+    await this.#hosting.release(row.ward, from);
+    return { moved: row.ward, store: to ?? null };
+  }
+
   async lend(args: JsonObject): Promise<JsonObject> {
     if (!text(args.contract)) return { error: 'contract is text' };
     const invitation = await this.offer(args.contract);