nervur 0.19.2 → 0.20.0

package/dist/conformance/index.js

@@ -1,819 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The ward conformance suite. The beings are fixed; the ward is under test.
-//
-// A ward is handed in as a probe:
-//
-//   make({ lends })                               -> world. `lends` maps a name the box lends to the
-//                                                    class of the being it lends under it; the probe
-//                                                    stands one of each in a ward its harbor roots,
-//                                                    and every ward it boots is grounded to lend them
-//   world.boot(key, Class, cells?, { isPublic })  -> handle
-//   world.heir(invitation)                        -> { current, announced, fresh } | undefined
-//                                                    what the inviting ward holds for that heir
-//   world.oneWard                                 true when every being shares one ward
-//   handle.pk                                     the ward pk she lives behind
-//   handle.being                                  the object, as the test drives it
-//   handle.cells                                  her cells, as the ward keeps them
-//   handle.down = true | false                    her door is unreachable (needs canDown)
-//   handle.minted.has(pk)                         the last eight pks her side minted
-//   handle.forgeKnock(invitation)                 make her side knock with a key of its own, unannounced
-//   world.census()                                every partition in the world, as values
-//   world.migrate(key)                            her ward moves to another harbor, same seed, same pk
-//
-// Every assertion here is the truth's. Nothing here knows how a ward is built.
-import { assert } from './assert.js';
-import { silence, answered, isSilence, isUnreached, told } from '../being/silence.js';
-import { digest } from '../being/digest.js';
-import { Printer, Shop, Customer, Echo, Maker, Member } from './beings.js';
-import { estate } from './estate.js';
-export { Printer, Shop, Customer, Echo, Maker, Member };
-// The two shapes the suite asserts, spelled here for the whole folder. They
-// are spelled again in `src/ward/seal.ts`, and that is the point: this suite
-// is what a second kit runs against its own ward, so it states the shapes it
-// expects instead of importing ours, and nothing under `src/conformance`
-// reaches into `src/ward` for anything.
-export const HEX64 = /^[0-9a-f]{64}$/; // one key, one secret, one digest
-const HEX128 = /^[0-9a-f]{128}$/; // a ward pk: the signing pk then the padlock
-// Her ward's word, as she receives it.
-const said = (x, w) => told(x) === w;
-// A world whose harness stands a ward up again. The two members are optional
-// on the probe and required of a harness that says it can, so a chapter that
-// needs them says so here rather than reaching past a maybe at every line.
-const able = (w) => w;
-// The same, for a world whose store can be made to refuse one row.
-const picky = (w) => w;
-// `canRefuse` is the one flag that is off unless a harness says otherwise. A
-// harness whose store cannot be made to say no is the common case, and a
-// harbor that leaves `keep` out of its ground is a harbor for which no store
-// can refuse: both skip the chapter rather than fail it, and both say so at
-// the call.
-export function conform(label, make, { canDown = true, canLend = true, canRestart = true, canRefuse = false, test }) {
-    const t = (name, fn) => test(`[${label}] ${name}`, {}, fn);
-    const down = (name, fn) => test(`[${label}] ${name}`, { skip: !canDown && 'nothing to cut inside one ward' }, fn);
-    const lends = (name, fn) => test(`[${label}] ${name}`, { skip: !canLend && 'this harness stands no ward of its harbor to lend from' }, fn);
-    const kept = (name, fn) => test(`[${label}] ${name}`, { skip: !canRestart && 'this harness cannot hand a ward a partition and stand it up again' }, fn);
-    const refused = (name, fn) => test(`[${label}] ${name}`, { skip: !canRefuse && 'this harness has no store that can be made to refuse a row' }, fn);
-    async function world({ printerInvitesShop = true } = {}) {
-        const w = await make();
-        const printer = await w.boot('P', Printer);
-        const shop = await w.boot('S', Shop);
-        const alice = await w.boot('A', Customer);
-        const bob = await w.boot('B', Customer);
-        if (printerInvitesShop)
-            await shop.being.keepPrinter((await printer.being.invite('shop')));
-        return { w, printer, shop, alice, bob };
-    }
-    const bp = (x) => x;
-    // ---- invite
-    t('invite mints the occupant and a heir: the invitation is the far ward pk, the heir pk, and the heir secret. nothing of her.', async () => {
-        const { w, shop } = await world();
-        const inv = await shop.being.invite('gold');
-        assert.deepEqual(Object.keys(shop.cells.occupants), ['cust1']);
-        assert.deepEqual(Object.keys(inv).sort(), ['heir', 'secret', 'ward']);
-        assert.match(inv.ward, HEX128);
-        assert.match(inv.heir, HEX64);
-        assert.match(inv.secret, HEX64);
-        assert.equal(inv.ward, shop.pk);
-        assert.ok(shop.minted.has(inv.heir)); // rotation one: her ward minted the occupant's first key
-        assert.deepEqual(w.heir(inv), { current: inv.heir, announced: null, fresh: true }); // and keeps only its pk
-        for (const word of [inv.heir, inv.secret])
-            assert.ok(!JSON.stringify(shop.cells).includes(word)); // never in her cells
-    });
-    t('two invites, two heirs, nothing shared', async () => {
-        const { shop } = await world();
-        const i1 = await shop.being.invite();
-        const i2 = await shop.being.invite();
-        assert.notEqual(i1.heir, i2.heir);
-        assert.notEqual(i1.secret, i2.secret);
-        assert.equal(i1.ward, i2.ward);
-    });
-    t('remove before any knock: the heir is forgotten, and a knock on it by whoever holds it hears removed', async () => {
-        const { w, shop, alice } = await world();
-        const inv = await shop.being.invite();
-        shop.being.occupants.remove('cust1');
-        assert.equal(w.heir(inv), undefined);
-        assert.ok(said(await alice.being.join(inv), 'removed'));
-        assert.deepEqual(alice.cells.standings, {});
-    });
-    // ---- consume, the knock
-    t('a valid knock binds the id to her own key and spends the heir; the asker is { id }', async () => {
-        const { w, shop, alice } = await world();
-        const inv = await shop.being.invite('gold');
-        assert.deepEqual(await alice.being.join(inv), { welcome: true });
-        const h = w.heir(inv);
-        assert.equal(h.fresh, false);
-        assert.notEqual(h.current, inv.heir); // rotation two: the heir is spent
-        assert.ok(alice.minted.has(h.current)); // her own key speaks now
-        assert.ok(!shop.minted.has(h.current)); // which the inviter never held
-        assert.equal(shop.cells.occupants.cust1.notes.asks, 1);
-    });
-    t('a second knock with the same invitation, from another: silence, nothing rebinds', async () => {
-        const { w, shop, alice, bob } = await world();
-        const inv = await shop.being.invite();
-        await alice.being.join(inv);
-        const bound = w.heir(inv).current;
-        assert.ok(isSilence(await bob.being.join(inv)));
-        assert.equal(w.heir(inv).current, bound); // still alice's
-        assert.deepEqual(bob.cells.standings, {});
-    });
-    t('a knock with the wrong secret, or a forged heir, is silence and never reaches her', async () => {
-        const { w, shop, alice } = await world();
-        let reached = 0;
-        const real = shop.being.answer.bind(shop.being);
-        shop.being.answer = (...a) => (reached++, real(...a));
-        const inv = await shop.being.invite();
-        const other = await shop.being.invite();
-        assert.ok(isSilence(await alice.being.knock({ ward: inv.ward, heir: 'f'.repeat(64), secret: inv.secret }, 'hello')));
-        assert.ok(isSilence(await alice.being.knock({ ward: inv.ward, heir: inv.heir, secret: other.secret }, 'hello'))); // a real secret, the wrong heir
-        assert.ok(isSilence(await alice.being.knock({ ward: inv.ward, heir: inv.heir, secret: '0'.repeat(64) }, 'hello')));
-        assert.equal(reached, 0);
-        assert.equal(w.heir(inv).fresh, true); // still unbound
-    });
-    t('the same knocker may knock again: her key is bound, no heir needed, it is an ask, and it announces her next key', async () => {
-        const { w, shop, alice } = await world();
-        const inv = await shop.being.invite();
-        assert.deepEqual(await alice.being.join(inv), { welcome: true });
-        const k1 = w.heir(inv).current;
-        assert.equal(w.heir(inv).announced, null); // a knock announces her key and dies; nothing further yet
-        assert.deepEqual(await alice.being.knock(inv, 'hello'), { welcome: true });
-        assert.equal(shop.cells.occupants.cust1.notes.asks, 2);
-        const h = w.heir(inv);
-        assert.equal(h.current, k1); // k1 spoke
-        assert.ok(h.announced && alice.minted.has(h.announced) && h.announced !== k1); // and vouched for the next
-    });
-    t('a knocker who presents a key of her own, unannounced, on a bound heir: silence', async () => {
-        const { w, shop, alice, bob } = await world();
-        const inv = await shop.being.invite();
-        await alice.being.join(inv);
-        const bound = w.heir(inv).current;
-        bob.forgeKnock(inv);
-        assert.ok(isSilence(await bob.being.knock(inv, 'hello')));
-        assert.equal(w.heir(inv).current, bound);
-        assert.equal(shop.cells.occupants.cust1.notes.asks, 1);
-    });
-    t('ids never cross: hers for me and mine for her are unrelated', async () => {
-        const { shop, alice } = await world();
-        await alice.being.join(await shop.being.invite());
-        assert.deepEqual(Object.keys(alice.cells.standings), ['shop']);
-        assert.deepEqual(Object.keys(shop.cells.occupants), ['cust1']);
-    });
-    down('a standing is born only after an answer; silence or unreached births nothing; an unreached knock does not spend the heir', async () => {
-        const { w, shop, alice } = await world();
-        const inv = await shop.being.invite();
-        shop.down = true;
-        assert.ok(isUnreached(await alice.being.join(inv)));
-        assert.deepEqual(alice.cells.standings, {});
-        assert.equal(w.heir(inv).fresh, true);
-        shop.down = false;
-        assert.deepEqual(await alice.being.join(inv), { welcome: true }); // the same invitation still works
-        const inv2 = await shop.being.invite();
-        shop.being.occupants.remove('cust2'); // she changed her mind before the knock
-        assert.ok(said(await alice.being.join(inv2), 'removed'));
-        assert.deepEqual(Object.keys(alice.cells.standings), ['shop']);
-    });
-    // ---- the names that are nobody's to take
-    //
-    // Two lists, refused at both ends of the same namespace. The ward speaks
-    // under its own words, so a being who could mint one would be a being whose
-    // ward is indistinguishable from an occupant of hers. And standings are
-    // reached by name, so a relation taken as one of the calls on them would be
-    // a relation nothing can reach. A kit that ported invite without either
-    // list passes every other scene in this file.
-    t('the reserved ids and the calls on standings are refused at invite and at take, and nothing is written for them', async () => {
-        // alice hosts here rather than the shop, because the shop's own `invite`
-        // takes a tier and mints the id itself. This one is the stance's, which
-        // is where the rule lives.
-        const { w, alice, bob } = await world();
-        // `__proto__` is in the list because a partition cannot hold it. A kit
-        // that refuses it only where it writes her cells writes the ward's half
-        // first and then throws, which leaves one relation in two standings and a
-        // throw where this table promises a null.
-        for (const id of ['OWNER', 'PUBLIC', 'knock', 'take', 'remove', '__proto__']) {
-            assert.equal(await alice.being.invite(id), null, `${id} is not hers to mint`);
-            assert.equal(Object.hasOwn(alice.cells.occupants, id), false, `and nothing was written for ${id}`);
-            // The other end: a guest is answered and then refused the name.
-            const inv = (await alice.being.invite(`for-${id}`));
-            assert.deepEqual(await bob.being.knock(inv, 'hi'), { heard: 'hi' }, `the knock for ${id} was answered`);
-            assert.equal(await bob.being.take(id, inv), null, `take refuses ${id} for the same reason`);
-            assert.equal(Object.hasOwn(bob.cells.standings, id), false, `and nothing was written for ${id}`);
-            // The ward's half too, and not only hers: a standing filed here with no
-            // record of it in her cells is a lane nobody can see and nobody removes.
-            assert.equal(Object.hasOwn(w.census().binds.B.standings, id), false, `and the ward wrote no keys for ${id}`);
-            assert.equal(await bob.being.take(`as-${id}`, inv), `as-${id}`, 'and an ordinary id takes the same invitation');
-        }
-        // And the three calls are still the calls, not records that shadowed them.
-        for (const call of ['knock', 'take', 'remove'])
-            assert.equal(typeof bob.being.standings[call], 'function', `standings.${call} is the call`);
-    });
-    // ---- the owner
-    //
-    // The second pointer a ward hands back. Every ask below answers an object,
-    // because the owner hears objects and never a word: a refusal is `{ error }`
-    // with its reason, which is what a side renders.
-    t('the owner boots, marks one public being, invites, knocks, removes and unboots, and refuses each in an object', async () => {
-        const { w, shop, alice } = await world();
-        const ask = w.owner('S');
-        const bp = (await ask());
-        assert.deepEqual(bp.asks.map((a) => a.name), ['boot', 'public', 'invite', 'knock', 'remove', 'unboot', 'ask'], 'seven asks, in this order');
-        for (const a of bp.asks) {
-            assert.equal(typeof a.description, 'string', `${a.name} says what it is for`);
-            assert.equal(a.input.type, 'object', `${a.name} takes one object`);
-        }
-        assert.match(bp.notes.pk, HEX128);
-        assert.equal(typeof bp.notes.beings, 'object');
-        assert.deepEqual(await ask('nosuch'), { error: 'unknown ask' });
-        // boot: a key already taken is refused, and so is a class nobody holds.
-        assert.deepEqual(await ask('boot', { key: 'S', class: 'Shop' }), { error: 'no such class, or key taken' });
-        assert.deepEqual(await ask('boot', { key: 'fresh', class: 'NoSuchClass' }), { error: 'no such class, or key taken' });
-        assert.deepEqual(await ask('boot', { key: 42, class: 'Shop' }), { error: 'no such class, or key taken' }, 'a name is a string or it is nothing');
-        // public: one per ward, null takes the mark off, and the ward is nobody's
-        // public being.
-        assert.deepEqual(await ask('public', { key: 'nobody' }), { error: 'no such being' });
-        assert.deepEqual(await ask('public', { key: bp.notes.pk }), { error: 'no such being' }, 'the ward is a being to nobody outside');
-        // invite and remove, on a being of the ward, by id.
-        assert.deepEqual(await ask('invite', { being: 'nobody', id: 'x' }), { error: 'no such being' });
-        const inv = (await ask('invite', { being: 'S', id: 'by-owner', notes: { tier: 'gold' } }));
-        assert.match(inv.heir, HEX64);
-        assert.deepEqual(shop.cells.occupants['by-owner'].notes, { tier: 'gold' }, 'the notes she minted under are hers to read');
-        assert.deepEqual(await ask('remove', { being: 'S', id: 'nothing-of-hers' }), { error: 'nothing to remove' });
-        assert.deepEqual(await ask('remove', { being: 'S', id: 'by-owner' }), { removed: 'by-owner' });
-        assert.equal(Object.hasOwn(shop.cells.occupants, 'by-owner'), false);
-        // knock: the owner knocks for a being of hers and takes the standing.
-        const forA = (await ask('invite', { being: 'S', id: 'for-alice' }));
-        const knocked = (await w.owner('A'))('knock', { being: 'A', id: 'via-owner', invitation: forA, method: 'hello' });
-        assert.deepEqual(await knocked, { taken: 'via-owner', answer: { welcome: true } });
-        assert.deepEqual(Object.keys(alice.cells.standings), ['via-owner']);
-        assert.deepEqual(await alice.being.standings['via-owner'].ask('hello'), { welcome: true }, 'and it is an ordinary standing');
-        // unboot: the inverse of boot, and the ward refuses itself.
-        assert.deepEqual(await ask('unboot', { being: bp.notes.pk }), { error: 'no such being' });
-        assert.deepEqual(await ask('unboot', { being: 'nobody' }), { error: 'no such being' });
-        const gone = (await ask('unboot', { being: 'S' }));
-        assert.equal(gone.unbooted, 'S');
-        assert.ok(gone.removed.includes('for-alice'), 'her relations went with her, and the owner is told which');
-        assert.ok(said(await alice.being.standings['via-owner'].ask('hello'), 'removed'), 'and her occupant hears removed at the door');
-    });
-    // The owner's seventh ask: reaching into a being and asking her. It is the
-    // third asker of the ward-to-being edge, and the ward is the only one who
-    // fills it in: nothing outside a ward names OWNER, and no side holds a
-    // being's answer to judge it again. Strictly less than the unboot beside
-    // it, which takes her out with every relation she holds.
-    t('the owner asks a being of the ward, as owner or, with no being named, as nobody at the public being', async () => {
-        const { w } = await world();
-        const ask = w.owner('S');
-        const echo = w.owner('E');
-        await w.boot('E', Echo);
-        // Named: she is asked as the owner, and hears the owner's name.
-        assert.deepEqual(await echo('ask', { being: 'E', method: 'echo', args: { x: 1 } }), { from: 'OWNER', x: 1 }, 'the ward names the asker, and the name is the owner');
-        assert.deepEqual(bp(await ask('ask', { being: 'S' })).asks.map((a) => a.name), ['hello', 'buy'], 'no method is her describe, and a gate that reads an occupant record shows the owner nothing: refund is hers to nobody here');
-        assert.deepEqual(await ask('ask', { being: 'S', method: 'hello' }), { welcome: true });
-        assert.deepEqual(await ask('ask', { being: 'S', method: 'nosuch' }), { error: 'unknown ask' }, 'her own answer, as any asker gets it');
-        // Nobody named, and nobody home: one refusal, and never a fourth word.
-        assert.deepEqual(await echo('ask', {}), { error: 'no such being' }, 'a ward with no public being has nobody to ask as nobody');
-        assert.deepEqual(await echo('public', { key: 'E' }), { public: 'E' });
-        assert.deepEqual(await echo('ask', { method: 'echo', args: { x: 2 } }), { from: null, x: 2 }, 'with no being named it is the public being, asked as nobody');
-        // What it refuses, each in an object, because the owner hears objects.
-        const pk = bp(await ask()).notes.pk;
-        assert.deepEqual(await ask('ask', { being: 'nobody' }), { error: 'no such being' });
-        assert.deepEqual(await ask('ask', { being: pk }), { error: 'no such being' }, 'the ward is a being to nobody outside, here as at invite and unboot');
-        assert.deepEqual(await ask('ask', { being: 42 }), { error: 'no such being' }, 'a name is a string or it is nothing');
-        assert.deepEqual(await ask('ask', { being: 'S', method: 42 }), { error: 'an ask is named by a word' }, 'and so is an ask');
-    });
-    // The one public being, marked and unmarked through the owner. A second
-    // one would leave the first holding every relation she had, reachable by
-    // nobody at the bare pk and told by nobody that she had been replaced.
-    t('a ward has one public being: a second is refused, null takes the mark off, and she keeps everything she held', async () => {
-        const { w, alice } = await world();
-        const ask = w.owner('A');
-        assert.deepEqual(await ask('public', { key: 'A' }), { public: 'A' });
-        assert.deepEqual(await ask('public', { key: 'A' }), { public: 'A' }, 'marking the same one again is not a second');
-        const bp = (await ask());
-        assert.equal(bp.notes.beings.A.public, true, 'and the owner sees which one she is');
-        const inv = (await alice.being.invite('kept'));
-        assert.deepEqual(await ask('public', { key: null }), { public: null }, 'null takes the mark off');
-        const off = (await ask());
-        assert.equal(off.notes.beings.A.public, false);
-        assert.ok(Object.hasOwn(alice.cells.occupants, 'kept'), 'retiring her is not destroying her: every relation she held is still hers');
-        assert.equal(inv.ward, alice.pk);
-    });
-    // A relation she dropped is nobody's. The word is her own ward's, said to
-    // her and never crossing a door, because there is no door left to ask.
-    t('a standing she dropped is dropped: the word is hers, nothing crosses, and the far side is never told', async () => {
-        const { shop, alice } = await world();
-        await alice.being.join(await shop.being.invite());
-        const standing = alice.being.standings.shop;
-        alice.being.standings.remove('shop');
-        assert.deepEqual(alice.cells.standings, {}, 'gone from her cells');
-        assert.equal(alice.being.standings.shop, undefined, 'and gone from her stance');
-        assert.ok(said(await standing.ask('hello'), 'dropped'), 'a handle she kept over the drop reaches nothing, and says so');
-        assert.ok(Object.hasOwn(shop.cells.occupants, 'cust1'), 'the far side holds her seat still: dropping is hers alone and she tells nobody');
-    });
-    // ---- a being may make
-    //
-    // `boot` is on every stance, so a kit that never wired it hands its beings a
-    // call that answers null for ever and nothing else here would notice.
-    t('a being boots one of her ward s classes from inside her own answer, and may ask for a way back to what she made', async () => {
-        const { w } = await world();
-        const maker = await w.boot('MK', Maker);
-        // A harbor holds the classes its device gave it, so one Member is booted
-        // to put the class there. What the maker does after that is the ward's.
-        await w.boot('MEM', Member);
-        assert.deepEqual(await maker.being.open({ class: 'Member', key: 'made-1' }), { made: 'made-1' });
-        assert.deepEqual(await maker.being.open({ class: 'Member', key: 'made-1' }), { made: null }, 'a key already taken makes nobody');
-        assert.deepEqual(await maker.being.open({ class: 'NoSuchClass', key: 'made-2' }), { made: null }, 'a class the harbor does not hold makes nobody');
-        assert.deepEqual(maker.cells.made, ['made-1']);
-        // With an id she holds a standing to what she made, and the being made
-        // knows her by her own key and by nothing else.
-        assert.deepEqual(await maker.being.open({ class: 'Member', key: 'made-3', id: 'mine' }), { made: 'made-3' });
-        assert.deepEqual(await maker.being.say({ id: 'mine' }), { said: { pong: 'MK' } }, 'she asks through the relation, and arrives under her own key');
-        assert.deepEqual(await maker.being.say({ id: 'nothing' }), { said: null });
-    });
-    // The count, reached the one way a suite that owns no bytes can reach it:
-    // a caller's numbers are in her own partition, so winding them back and
-    // standing her ward up again makes her next ask carry a number the far
-    // door has already honoured. A kit with no once-only delivery answers it
-    // and passes every other chapter here clean.
-    kept('a number already honoured is repeated: the far being is not asked twice, and nothing is written for it', async () => {
-        const { w, shop, alice } = await world();
-        const inv = await shop.being.invite();
-        assert.deepEqual(await alice.being.join(inv), { welcome: true });
-        assert.deepEqual(await alice.being.buy('a hat'), { ok: true, receipt: 'receipt for a hat' });
-        const sold = shop.cells.sales.length;
-        // Her keys for the shop, wound back to the number she has just spent.
-        const kept = able(w);
-        const p = kept.partition('A');
-        const keys = p.bind.A.standings;
-        const mine = keys.shop;
-        const back = mine.seq - 1;
-        mine.seq = back;
-        await kept.restart('A', p);
-        const again = await alice.being.buy('a second hat');
-        assert.ok(said(again, 'repeated'), `a number already honoured is repeated, not ${JSON.stringify(again)}`);
-        assert.equal(shop.cells.sales.length, sold, 'and she was never asked');
-        // The count carries on from where it was: the next number is fresh.
-        assert.deepEqual(await alice.being.buy('a third hat'), { ok: true, receipt: 'receipt for a third hat' });
-    });
-    // A restart is silent by construction: the ward comes back on the same
-    // seed with the same pk, and every relation it holds still points at it.
-    // What must survive with it is what the door has honoured, or a restart is
-    // a stretch of time in which every number can be replayed.
-    kept('a restart is silent: same pk, every relation still stands, and the far door still refuses what it spent', async () => {
-        const { w, shop, alice } = await world();
-        const inv = await shop.being.invite();
-        assert.deepEqual(await alice.being.join(inv), { welcome: true });
-        assert.deepEqual(await alice.being.buy('a hat'), { ok: true, receipt: 'receipt for a hat' });
-        const pk = shop.pk;
-        const able2 = able(w);
-        const mark = JSON.stringify(able2.partition('S').heirs);
-        await able2.restart('S');
-        assert.equal(shop.pk, pk, 'a ward that came back changed its pk');
-        assert.equal(JSON.stringify(able2.partition('S').heirs), mark, 'and it came back holding what it had honoured');
-        assert.deepEqual(await alice.being.buy('a second hat'), { ok: true, receipt: 'receipt for a second hat' }, 'the relation goes on, and she was never told');
-        assert.deepEqual(alice.cells.standings.shop.id, 'shop', 'her side was not told either');
-    });
-    // Notes are the one thing on a record that a being seeds and a ward keeps
-    // without ever reading. A kit that files what it was handed rather than a
-    // copy of it leaves the seeder a hand inside her cells: it writes without
-    // the ward being told, so what a restart brings back is not what she read.
-    t('notes are values and are kept as a copy: what the seeder still holds is not what the record holds', async () => {
-        const { alice } = await world();
-        const seeded = { tier: { deep: 'gold' } };
-        assert.ok((await alice.being.invite('noted', seeded)) !== null, 'she minted with notes');
-        seeded.tier.deep = 'moved';
-        assert.deepEqual(alice.cells.occupants.noted.notes, { tier: { deep: 'gold' } }, 'the record is the copy, all the way down');
-        // And notes no harbor could write back are no invitation, for the reason
-        // every other write is refused: a record it could not keep.
-        assert.equal(await alice.being.invite('bad-notes', { n: 0 / 0 }), null);
-        assert.equal(Object.hasOwn(alice.cells.occupants, 'bad-notes'), false, 'and nothing was written for it');
-    });
-    // The wait, and the one thing a kit can get wrong that nothing else here
-    // would notice. A ward bounds every ask itself, so a relation cycle ends:
-    // A asks B, B asking back holds A's lane, and the third ask can never be
-    // answered. A kit with no bound waits for ever and hangs, and every other
-    // chapter in this suite would still pass it. The word is `late`, which
-    // promises nothing either way, and the relation lives afterwards.
-    t('the wait is bounded, so a cycle ends: the ask that cannot be answered is late, and the relation lives', async () => {
-        const { w } = await world();
-        const a = await w.boot('MA', Member);
-        const b = await w.boot('MB', Member);
-        const toB = (await b.being.invite('from-a'));
-        const toA = (await a.being.invite('from-b'));
-        assert.ok(answered(await a.being.knock(toB, 'ping')), 'a knocks b');
-        assert.equal(await a.being.take('b', toB), 'b');
-        assert.ok(answered(await b.being.knock(toA, 'ping')), 'b knocks a');
-        assert.equal(await b.being.take('a', toA), 'a');
-        // A asks B; B, answering, asks A back; A, answering that, asks B on the
-        // lane the first ask still holds. Every link is a legal ask.
-        const out = (await a.being.relay({ id: 'b', method: 'relay', args: { id: 'a', method: 'relay', args: { id: 'b', method: 'ping' }, time: 200 } }));
-        assert.equal(out.said, null, 'the outer ask was answered');
-        assert.equal(out.out?.said, 'late', 'and what it carries is the ask that could not be, said as late');
-        // The relation is not the worse for it: the lane is free again and the
-        // count moved on, which is what a bound is for.
-        const after = (await a.being.relay({ id: 'b', method: 'ping' }));
-        assert.equal(after.said, null, 'and she asks again on the same standing');
-    });
-    // Lend is boot's other half: what the device already has, reached the one
-    // way anything is reached. The device is one standing the ward holds at
-    // the box's being, and a lend is an ask on it; the being lent stands in
-    // a ward the harbor roots, so nothing here can look at her from the
-    // outside, and what the ward owes is what is asserted. She is handed an
-    // id, the standing is an ordinary one, and the invitation is nowhere she
-    // can read.
-    lends('what the device lends is a being: she is handed an id, asks on an ordinary standing, and never sees the invitation', async () => {
-        const w = await make({ lends: { pen: 'Member' } });
-        const maker = await w.boot('MK', Maker);
-        assert.deepEqual(await maker.being.borrow({ name: 'pen', id: 'pen' }), { lent: 'pen' }, 'the id she gave is the id she gets');
-        // An ordinary standing from there on: she asks on it, and arrives at that
-        // being's door as somebody the far side named.
-        const said = (await maker.being.say({ id: 'pen' }));
-        assert.equal(typeof said.said?.pong, 'string', 'she arrived under an id the far being minted');
-        // The keys are the ward's. Nothing of the relation is in her cells, which
-        // is the whole difference between this standing and one she gave away.
-        const c = w.census();
-        const heir = c.binds.MK.standings.pen.heir;
-        assert.equal(typeof heir, 'string', 'the ward bound a heir for it');
-        assert.equal(JSON.stringify(c.cells.MK).includes(heir), false, 'and the invitation reached her nowhere');
-        // Null is every kind of no, and she cannot tell them apart.
-        assert.deepEqual(await maker.being.borrow({ name: 'gps', id: 'x' }), { lent: null }, 'a name this box does not lend');
-        assert.deepEqual(await maker.being.borrow({ name: 'pen', id: 'pen' }), { lent: null }, 'an id she already holds');
-        assert.deepEqual(await maker.being.borrow({ name: 'pen', id: 'OWNER' }), { lent: null }, 'a word the ward reserves');
-    });
-    lends('a harbor with nothing to lend lends nothing, and says so the same way', async () => {
-        const w = await make();
-        const maker = await w.boot('MK', Maker);
-        assert.deepEqual(await maker.being.borrow({ name: 'pen', id: 'pen' }), { lent: null });
-        assert.equal(w.census().binds.MK.standings.pen, undefined, 'and nothing was written for it');
-    });
-    // The case the estate's walk reaches by weight and this reaches by hand: a
-    // seat kicked after it answered and before it was taken. She holds a key
-    // the door bound for her, so she is the one person who hears why, and she
-    // hears it every time. A kit that forgot to keep the last keys of a
-    // forgotten heir answers her silence, which is what it says to a stranger,
-    // and she cannot tell being kicked from never having been let in.
-    t('a relation kicked between the knock and the take: she hears removed, every time, and the take births nothing', async () => {
-        const { shop, alice, bob } = await world();
-        const inv = await shop.being.invite();
-        assert.deepEqual(await alice.being.knock(inv, 'hello'), { welcome: true }, 'she knocked and was answered');
-        shop.being.occupants.remove('cust1'); // kicked, and she is not told
-        for (let i = 0; i < 3; i++)
-            assert.ok(said(await alice.being.knock(inv, 'hello'), 'removed'), `knock ${i}: a spent heir stays spent, and she hears why every time`);
-        // And the take still births one: it reads the knock record, which says
-        // she was answered, and the far side kicking her afterwards is not
-        // something her side can know or should guess at. The standing is hers,
-        // and it is the standing that hears removed from then on. A kit that
-        // refused the take here would leave her with no record to read the
-        // refusal through, and nothing to drop.
-        assert.equal(await alice.being.take('shop', inv), 'shop', 'the take reads the knock record, and the knock was answered');
-        assert.ok(said(await alice.being.standings.shop.ask('hello'), 'removed'), 'and the standing is where she hears it now');
-        alice.being.standings.remove('shop');
-        assert.deepEqual(alice.cells.standings, {}, 'hers to drop, like any other');
-        // And only to her: the same invitation in anyone else's hand is silence,
-        // because the keys the door kept are hers and nobody else's.
-        assert.ok(isSilence(await bob.being.knock(inv, 'hello')), 'a stranger holding the same invitation learns nothing at all');
-    });
-    t('take without a knock, or after a knock that was not answered, births nothing', async () => {
-        const { shop, alice } = await world();
-        const inv = await shop.being.invite();
-        assert.equal(await alice.being.take('shop', inv), null);
-        shop.being.occupants.remove('cust1');
-        assert.ok(said(await alice.being.knock(inv, 'hello'), 'removed'));
-        assert.equal(await alice.being.take('shop', inv), null);
-        assert.deepEqual(alice.cells.standings, {});
-    });
-    // ---- asks
-    t('an occupant asks, a standing is asked, an object comes back', async () => {
-        const { alice, printer, shop } = await world();
-        await alice.being.join(await shop.being.invite());
-        assert.deepEqual(await alice.being.buy('hat'), { ok: true, receipt: 'receipt for hat' });
-        assert.equal(printer.cells.jobs.length, 1);
-        assert.equal(shop.cells.sales[0].by, 'cust1');
-    });
-    t('every answered ask rotates: each call speaks as the key the last one announced, and announces a fresh one, all minted by her side', async () => {
-        const { w, shop, alice } = await world();
-        const inv = await shop.being.invite();
-        await alice.being.join(inv);
-        const seen = new Set([w.heir(inv).current]);
-        let expectNext = w.heir(inv).current; // after the knock, her key is current and nothing is announced
-        for (let i = 0; i < 3; i++) {
-            await alice.being.buy('hat');
-            const h = w.heir(inv);
-            assert.equal(h.current, expectNext); // this call spoke as what was announced before
-            assert.ok(h.announced && alice.minted.has(h.announced) && !seen.has(h.announced)); // and announced a fresh key
-            seen.add(h.announced);
-            expectNext = h.announced;
-        }
-        assert.equal(shop.cells.sales.length, 3);
-        assert.equal(seen.size, 4);
-    });
-    t('asks in flight together on one standing: every one is answered, the rotation stays a single line, and the relation lives', async () => {
-        const { w, shop, alice } = await world();
-        const inv = await shop.being.invite();
-        await alice.being.join(inv);
-        const bound = w.heir(inv).current; // the key her side bound at the knock
-        const out = await Promise.all(Array.from({ length: 5 }, (_, i) => alice.being.buy(`hat${i}`)));
-        for (const [i, o] of out.entries())
-            assert.deepEqual(o, { ok: true, receipt: `receipt for hat${i}` }, `ask ${i} was answered`);
-        assert.equal(shop.cells.sales.length, 5); // each arrived once. none was lost, none was doubled
-        // five asks, five rotations, one line: the door's key is the fifth her
-        // side minted, and the side that did not mint it never held it.
-        const h = w.heir(inv);
-        assert.notEqual(h.current, bound);
-        assert.ok(alice.minted.has(h.current));
-        assert.ok(!shop.minted.has(h.current));
-        // and the two sides still agree, which is the whole of it: a relation
-        // that survived the crowd is a relation that still answers.
-        assert.deepEqual(await alice.being.buy('after'), { ok: true, receipt: 'receipt for after' });
-    });
-    t('two knocks in flight on one invitation: one heir, one binding, and she may still ask', async () => {
-        const { w, shop, alice } = await world();
-        const inv = await shop.being.invite();
-        const [a, b] = await Promise.all([alice.being.join(inv), alice.being.join(inv)]);
-        // the same knocker knocking twice at once is not two occupants: the heir
-        // is spent once, and both calls speak for the one relation she is building.
-        assert.deepEqual(Object.keys(shop.cells.occupants), ['cust1']);
-        for (const r of [a, b])
-            assert.ok(!isSilence(r) && !isUnreached(r), 'both knocks were answered');
-        const h = w.heir(inv);
-        assert.equal(h.fresh, false);
-        assert.ok(alice.minted.has(h.current)); // her own key speaks, exactly as after one knock
-        // What she does with the standing afterwards is not this test's. A take
-        // reads the relation where the knock left it, and a knock still in flight
-        // has not left it anywhere yet: the standing is born a step behind the
-        // door, and its first ask speaks under a number already honoured.
-    });
-    t('an inherited name is not an ask through a ward either: her cells do not come back for the asking', async () => {
-        const { shop, alice } = await world();
-        await alice.being.join(await shop.being.invite()); // plain: refund is hidden from her
-        shop.cells.ledger = { swiss: 'CH-99' };
-        for (const name of ['valueOf', 'toString', 'constructor', '__proto__', 'hasOwnProperty']) {
-            const out = await alice.being.standings.shop.ask(name);
-            assert.deepEqual(out, { error: 'unknown ask' }, name);
-            assert.ok(!JSON.stringify(out).includes('CH-99'), `${name} carried her cells out`);
-        }
-        // the blueprint never named one of them, and the gate is the same gate
-        const blueprint = bp(await alice.being.learn());
-        for (const ask of blueprint.asks)
-            assert.ok(!['valueOf', 'toString', 'constructor'].includes(ask.name));
-        assert.deepEqual(await alice.being.standings.shop.ask('refund'), { error: 'unknown ask' }); // still hidden, still the same answer
-    });
-    t('symmetry: the customer offers a way back inside args; the shop takes a gold one', async () => {
-        const { shop, alice, bob } = await world();
-        await alice.being.join(await shop.being.invite('gold'));
-        await bob.being.join(await shop.being.invite('plain'));
-        assert.deepEqual(Object.keys(shop.cells.standings), ['prn', 'vip-cust1']);
-        assert.deepEqual(alice.cells.heard, [{ from: 'shop-back', method: 'hi' }]);
-        assert.deepEqual(bob.cells.heard, []);
-        assert.deepEqual(await shop.being.standings['vip-cust1'].ask('hi'), { heard: 'hi' });
-    });
-    t('the printer never invited the shop: no standing, an error object, no throw', async () => {
-        const { alice, shop } = await world({ printerInvitesShop: false });
-        await alice.being.join(await shop.being.invite());
-        assert.deepEqual(await alice.being.buy('hat'), { error: 'no printer' });
-    });
-    t('the empty ask is describe; shaped per asker', async () => {
-        const { shop, alice, bob } = await world();
-        await alice.being.join(await shop.being.invite('gold'));
-        await bob.being.join(await shop.being.invite());
-        const names = (x) => bp(x).asks.map((a) => a.name);
-        assert.deepEqual(names(await alice.being.learn()), ['hello', 'buy', 'refund']);
-        assert.deepEqual(names(await bob.being.learn()), ['hello', 'buy']);
-        assert.deepEqual(await alice.being.standings.shop.ask('refund'), { ok: true }, 'and what she is shown she can ask');
-    });
-    t('the digest is per relation: two occupants, two digests of one being, both true', async () => {
-        const { shop, alice, bob } = await world();
-        await alice.being.join(await shop.being.invite('gold'));
-        await bob.being.join(await shop.being.invite());
-        await alice.being.learn();
-        await bob.being.learn();
-        assert.notEqual(alice.cells.standings.shop.digest, bob.cells.standings.shop.digest);
-    });
-    t('describe caches blueprint and digest in the asker cells', async () => {
-        const { shop, alice } = await world();
-        await alice.being.join(await shop.being.invite());
-        const out = await alice.being.learn();
-        assert.deepEqual(alice.cells.standings.shop.blueprint, out);
-        assert.equal(alice.cells.standings.shop.digest, await digest(out));
-    });
-    t('a changed standing is noticed by digest, without carrying the blueprint', async () => {
-        const { alice, printer, shop } = await world();
-        await alice.being.join(await shop.being.invite());
-        await shop.being.standings.prn.ask();
-        printer.cells.asks.push({ name: 'scan', input: {} }); // she changed
-        await alice.being.buy('hat');
-        const st = shop.cells.standings.prn;
-        assert.notEqual(st.seen, st.digest);
-        assert.equal(shop.cells.occupants.cust1.notes.printerChanged, true);
-    });
-    t('the digest rides on every answer: seen updates without a describe from her side', async () => {
-        const { alice, printer, shop } = await world();
-        await alice.being.join(await shop.being.invite());
-        let describes = 0;
-        const real = printer.being.answer.bind(printer.being);
-        printer.being.answer = (a, m, x) => (m === undefined && describes++, real(a, m, x));
-        await alice.being.buy('hat'); // shop asks printer once
-        const st = shop.cells.standings.prn;
-        assert.equal(st.seen, await digest((await real({ id: 'shop' }))));
-        assert.equal(describes, 1); // the far ward ran her describe, in process, once per answer
-        assert.equal(st.digest, null); // she never fetched it herself
-    });
-    t('a silent refresh leaves seen untouched', async () => {
-        const { alice, printer, shop } = await world();
-        await alice.being.join(await shop.being.invite());
-        await shop.being.standings.prn.ask();
-        const before = shop.cells.standings.prn.seen;
-        const real = printer.being.answer.bind(printer.being);
-        printer.being.answer = async (a, m, x) => (m === undefined ? silence : real(a, m, x));
-        await alice.being.buy('hat');
-        assert.equal(shop.cells.standings.prn.seen, before);
-    });
-    down('unreached is the ward word, distinct from silence, carries nothing, safe to retry', async () => {
-        const { alice, printer, shop } = await world();
-        await alice.being.join(await shop.being.invite());
-        printer.down = true;
-        assert.deepEqual(await alice.being.buy('hat'), { error: 'printer unreachable', retry: true });
-        const out = await shop.being.standings.prn.ask('print', { doc: 'x' });
-        assert.ok(isUnreached(out) && !isSilence(out));
-        assert.deepEqual(Object.keys(out), []);
-        printer.down = false;
-        assert.deepEqual(await alice.being.buy('hat'), { ok: true, receipt: 'receipt for hat' });
-    });
-    t('a removed occupant hears removed under the key the door bound, her heir is forgotten; a dropped standing is gone', async () => {
-        const { w, alice, shop } = await world();
-        const inv = await shop.being.invite();
-        await alice.being.join(inv);
-        shop.being.occupants.remove('cust1');
-        assert.equal(w.heir(inv), undefined);
-        assert.ok(said(await alice.being.buy('hat'), 'removed'));
-        alice.being.standings.remove('shop');
-        assert.equal(alice.being.standings.shop, undefined);
-        assert.ok(isSilence(await alice.being.knock(inv, 'hello'))); // her bound key went with the standing: a re-knock is as the heir, which is spent, a stranger
-        const again = await shop.being.invite(); // cust2. a new heir
-        assert.notEqual(again.heir, inv.heir);
-        assert.deepEqual(await alice.being.knock(again, 'hello'), { welcome: true });
-    });
-    t('dropping a standing while an ask on it is in flight does not crash', async () => {
-        const { alice, shop } = await world();
-        await alice.being.join(await shop.being.invite());
-        const p = alice.being.buy('hat');
-        alice.being.standings.remove('shop');
-        assert.deepEqual(await p, { ok: true, receipt: 'receipt for hat' });
-        assert.equal(shop.cells.sales.length, 1);
-    });
-    t('a being that throws is the word threw to whom the door has bound; the ward stays up', async () => {
-        const w = await make();
-        class Bomb {
-            s;
-            constructor(s) {
-                this.s = s;
-            }
-            answer(_, m) {
-                if (m === undefined)
-                    return { asks: [], notes: {} };
-                throw new Error('boom');
-            }
-        }
-        const x = await w.boot('X', Bomb);
-        const a = await w.boot('A', Customer);
-        const inv = (await x.being.s.occupants.invite('a'));
-        assert.ok(said(await a.being.knock(inv, 'any'), 'threw'));
-        assert.deepEqual(await a.being.knock(inv), { asks: [], notes: {} });
-    });
-    t('null is an answer, silence is not', async () => {
-        const w = await make();
-        class Nul {
-            s;
-            constructor(s) {
-                this.s = s;
-            }
-            answer(_, m) {
-                return m === undefined ? { asks: [], notes: {} } : null;
-            }
-        }
-        const n = await w.boot('N', Nul);
-        const a = await w.boot('A', Customer);
-        const out = await a.being.knock((await n.being.s.occupants.invite('a')), 'x');
-        assert.equal(out, null);
-        assert.ok(!isSilence(out));
-    });
-    t('the raw shape is a being through a ward, exactly like one on the base class', async () => {
-        const w = await make();
-        const e = await w.boot('E', Echo);
-        const a = await w.boot('A', Customer);
-        const inv = (await e.being.s.occupants.invite('a'));
-        assert.deepEqual(await a.being.knock(inv, 'echo', { x: 1 }), { from: 'a', x: 1 });
-        assert.equal(await a.being.take('echo', inv), 'echo');
-        assert.deepEqual(await a.being.standings.echo.ask('echo', { y: 2 }), { from: 'a', y: 2 });
-        assert.equal(a.cells.standings.echo.seen, await digest({ asks: [{ name: 'echo', input: {} }], notes: {} }));
-    });
-    // ---- a save the store refuses
-    // The door has already said yes by the time a store says no, so the answer
-    // is the last thing that can still carry the refusal. A being whose row was
-    // not kept has a memory running ahead of what is on the device, and every
-    // door that kept answering success would be telling an asker about writes
-    // that are gone at the next reload.
-    refused('a save the store refuses is the answer of the arrival that wrote it: threw at the door, silence at the ask pointer', async () => {
-        const w = await make();
-        const no = picky(w);
-        const printer = await w.boot('P', Printer);
-        const alice = await w.boot('A', Customer);
-        const inv = (await printer.being.invite('a'));
-        assert.deepEqual(await alice.being.knock(inv, 'print', { doc: 'one' }), { printed: 'one' });
-        no.refuse('P', true);
-        const out = await alice.being.knock(inv, 'print', { doc: 'two' });
-        assert.ok(said(out, 'threw'), `a refused save is threw to a key the door holds, not ${JSON.stringify(out)}`);
-        const owned = await no.owner('P')('invite', { being: 'P', id: 'later' });
-        assert.ok(isSilence(owned), `a refused save is silence at the ask pointer, not ${JSON.stringify(owned)}`);
-        // The ward is up, and a stranger hears nothing about the store either.
-        assert.ok(isSilence(await alice.being.knock({ ward: printer.pk, heir: 'f'.repeat(64), secret: 'f'.repeat(64) }, 'print')));
-        no.refuse('P', false);
-        assert.deepEqual(await alice.being.knock(inv, 'print', { doc: 'three' }), { printed: 'three' }, 'the store took it, so the arrival is answered');
-    });
-    // The caller's own row, refused while she is in the middle of a call. A
-    // knock is one call and two halves: she writes her side before the bytes go
-    // out and again when they come back, and the far door writes the heir it
-    // spent. What a refusal puts back is what she wrote and never what the
-    // relation stands on, because her keys and the door's rotate at different
-    // moments and neither holds the seed of a key it has moved past: a kit that
-    // rolls back either speaks under a key the other will not admit, and that
-    // relation never speaks again. The proof is that she is still heard
-    // afterwards, and it holds wherever the far half lives, because a kit that
-    // put the relation back would fail here with both beings of one ward and
-    // with the far one on another device alike.
-    refused('a refusal under a call puts back the whole call, and the relation speaks again after it', async () => {
-        const w = await make();
-        const no = picky(w);
-        const printer = await w.boot('P', Printer);
-        const alice = await w.boot('A', Customer);
-        const inv = (await printer.being.invite('a'));
-        assert.deepEqual(await alice.being.knock(inv, 'print', { doc: 'one' }), { printed: 'one' });
-        no.refuse('A', true);
-        await alice.being.knock(inv, 'print', { doc: 'two' });
-        no.refuse('A', false);
-        assert.deepEqual(await alice.being.knock(inv, 'print', { doc: 'three' }), { printed: 'three' }, 'the relation is whole: a half put back would never be heard again');
-    });
-    // ---- public
-    t('a public being is asked by anyone as {}; a knock on her needs no heir and may be taken; a ward with none is silence; an unknown pk is unreached', async () => {
-        const w = await make();
-        // A being written by hand: no base class, one answer, and the stance is
-        // all she is handed. She is a being to the ward on those terms alone.
-        class Pub {
-            s;
-            constructor(s) {
-                this.s = s;
-                this.s.cells.askers ??= [];
-            }
-            answer(asker, m, args) {
-                if (m === undefined)
-                    return { asks: [{ name: 'time', input: {} }], notes: {} };
-                this.s.cells.askers.push(asker);
-                return { time: 12, got: args ?? {} };
-            }
-        }
-        const pub = await w.boot('PUB', Pub, {}, { isPublic: true });
-        const priv = await w.boot('PRIV', Pub); // same class, not public
-        const a = await w.boot('A', Customer);
-        const b = await w.boot('B', Customer);
-        const at = (h) => ({ ward: h.pk });
-        assert.deepEqual(await a.being.knock(at(pub), 'time', { x: 1 }), { time: 12, got: { x: 1 } });
-        assert.deepEqual(await b.being.knock(at(pub), 'time'), { time: 12, got: {} });
-        assert.deepEqual(pub.cells.askers, [{}, {}]);
-        assert.deepEqual(pub.cells.occupants, {}); // she never invited anyone
-        if (!w.oneWard)
-            assert.ok(isSilence(await a.being.knock(at(priv), 'time'))); // a ward with no public being: silence
-        assert.ok(isUnreached(await a.being.knock({ ward: 'a'.repeat(128) }, 'time'))); // no door anywhere: unreached
-        assert.ok(said(await a.being.knock({ ward: 'not a pk' }, 'time'), 'invitation')); // not even an address
-        assert.equal(await a.being.take('clock', at(pub)), 'clock');
-        assert.deepEqual(await a.being.standings.clock.ask('time'), { time: 12, got: {} });
-        assert.equal(a.cells.standings.clock.seen, await digest((await a.being.standings.clock.ask())));
-    });
-    // ---- keys stay where they belong
-    t("two rotations: the heir is the inviter's, the bound key is the knocker's, and neither side minted the other's", async () => {
-        const { w, shop, alice, bob } = await world();
-        const i1 = await shop.being.invite('gold');
-        const i2 = await shop.being.invite();
-        assert.ok(shop.minted.has(i1.heir) && shop.minted.has(i2.heir));
-        await alice.being.join(i1);
-        await bob.being.join(i2);
-        const h1 = w.heir(i1), h2 = w.heir(i2);
-        assert.ok(alice.minted.has(h1.current) && !shop.minted.has(h1.current) && !bob.minted.has(h1.current));
-        assert.ok(bob.minted.has(h2.current) && !shop.minted.has(h2.current) && !alice.minted.has(h2.current));
-        assert.notEqual(h1.current, h2.current); // no key serves two relations
-        assert.ok(!alice.minted.has(i1.heir)); // alice never minted anything of the shop's
-    });
-    t('her cells carry no key: heir, secret, and bound key live in the bind table only', async () => {
-        const { w, shop, alice } = await world();
-        const inv = await shop.being.invite();
-        await alice.being.join(inv);
-        await alice.being.learn();
-        const words = [inv.heir, inv.secret, w.heir(inv).current];
-        for (const cells of [shop.cells, alice.cells])
-            for (const word of words)
-                assert.ok(!JSON.stringify(cells).includes(word), `${word} in cells`);
-    });
-    // ---- the estate
-    estate(label, make, { canDown, test });
-}
-// The store and reach suites, beside the ward's: every store a harbor keeps
-// wards in and every reach it carries bytes by passes its own, on the
-// terrain it is written for.
-export { conformStore } from './store.js';
-export { conformReach } from './reach.js';