@quo-systems/quo 0.2.9 → 0.2.10

package/dist/ward/stance.js

@@ -1,12 +1,13 @@
 // SPDX-License-Identifier: Apache-2.0
 // The one stance builder. Used for every being the ward boots. Nothing
 // outer is in what she holds: ids in, values out, keys in the bind table.
-import { silence, isSilence, isUnreached, isWord, word } from '../being/silence.js';
+import { silence, isSilence, isWord, word, wordOf } from '../being/silence.js';
 import { digest } from '../being/digest.js';
 import { RESERVED_IDS } from '../being/types.js';
 import { at, put, drop } from './partition.js';
 import { allow, within, LATE } from './allowance.js';
 import { isWardPk } from './seal.js';
+import { cellFault } from './cells.js';
 // The three calls on `standings` share the object with the ids she takes, so
 // a standing named after one of them would be unreachable: `standings.knock`
 // is the call, whatever record sits under that name. One namespace means one
@@ -51,9 +52,9 @@ export function buildStance(inside, key, cells, bind) {
     // Every ask a being makes, bounded. The bound is outside the lane on
     // purpose: an ask that waits its turn behind a relation that comes back
     // round never reaches a send, and a bound that only watched the wire would
-    // never see it hang. A bound that ran out is silence, never unreached:
-    // unreached promises nothing was delivered and is safe to ask again, and a
-    // wait that gave up knows no such thing.
+    // never see it hang. A bound that ran out is the word late, never
+    // unreached: unreached promises nothing was delivered and is safe to ask
+    // again, and a wait that gave up knows no such thing.
     //
     // The bell rings before the work is reached, too: an ask that was still
     // waiting its turn when the wait ran out is never sent. Sent then, it would
@@ -67,56 +68,88 @@ export function buildStance(inside, key, cells, bind) {
         });
         return out === LATE ? word('late') : out;
     };
-    const send = async (keys, method, args, wanted, rec) => {
-        const r = await inside.send(bind, keys, true, method, args, wanted);
+    const read = (r) => {
         if (isSilence(r) || isWord(r))
-            return r;
+            return { answer: r, door: false, seen: null };
         if ('silence' in r)
-            return silence;
+            return { answer: silence, door: true, seen: null };
         if ('quo' in r)
-            return word(r.quo); // the far door's word for her, sealed to her lid
+            return { answer: word(r.quo), door: true, seen: null }; // the far door's word for her, sealed to her lid
+        return { answer: r.object, door: true, seen: r.seen };
+    };
+    // Whether the door spent the heir this send spoke under. An object, the
+    // door's silence and threw all mean it was honoured. A refusal word wrote
+    // nothing and says so. Anything that is not the door speaking says nothing.
+    const honoured = (r) => r.door && !(isWord(r.answer) && wordOf(r.answer) !== 'threw');
+    const answered = (r) => r.door && !isSilence(r.answer) && !isWord(r.answer);
+    const send = async (keys, method, args, wanted, rec) => {
+        const r = read(await inside.send(bind, keys, true, method, args, wanted));
         if (rec && method !== undefined && r.seen !== null)
             rec.seen = r.seen; // the digest rode along
-        return r.object;
+        return r.answer;
     };
     const knocking = async (inv, method, args, wanted) => {
         const name = nameOf(inv);
+        // Taken while this knock waited its turn: the relation lives in the
+        // standing now and speaks on its lane, under its keys and its count.
+        const taken = takenAs(name);
+        if (taken !== undefined) {
+            const keys = at(bind.standings, taken);
+            if (!keys)
+                return word('dropped');
+            return lane(`ask:${taken}`, () => asking(taken, keys, at(cells.standings, taken), method, args, wanted));
+        }
         // her own key for this relation, minted once: rotation two. reused if she knocks again.
         const k = (bind.knocks[name] ??= { current: (await inside.mintKey(bind)).seed, next: null, spoke: false, sent: false, seq: 0 });
-        // the first knock on a heir speaks as the heir, the key the inviter handed out, and announces her own.
-        // once bytes have come back, the heir is spent whatever they said, and her own key speaks.
-        // She sent once as the heir and nothing came back. Either the door heard,
-        // spent the heir and rotated to the key she announced, or nothing arrived
-        // and the heir still stands. Only the far door knows, and it will not say.
+        // The first knock on a heir speaks as the heir, the key the inviter
+        // handed out, and announces her own. Once the door has honoured it the
+        // heir is spent, whatever she then said, and her own key speaks; a heir
+        // spent once stays spent.
+        //
+        // She sent once as the heir and the door did not speak: nothing came
+        // back, or bytes that were not Quo's, or the wait ran out. Either the
+        // door heard, spent the heir and rotated to the key she announced, or
+        // nothing arrived and the heir still stands. Only the far door knows,
+        // and it will not say.
         //
         // So she asks, and the asking tells her. Under her own key: if the door
-        // heard, that key is the one it admits, and she is answered. If it did
-        // not, the key means nothing there, the ask is refused, and a refusal at
-        // that door writes nothing — the heir is untouched and still speaks. Then
-        // she knocks as the heir, as she would have. One extra round trip in the
-        // one case where a reply was lost, and the relation is not stranded.
+        // heard, that key is the one it admits, and she is answered, or told the
+        // door's word. If it did not, the key means nothing there, the ask is
+        // refused, and a refusal at that door writes nothing: the heir is
+        // untouched and still speaks. Then she knocks as the heir, as she would
+        // have. One extra round trip in the one case where a reply was lost, and
+        // the relation is not stranded.
         //
         // No stranger gains anything by it: whoever holds the invitation could
         // always knock as the heir, and her own key is admitted only where the
         // door already bound it to her.
         if (inv.heir !== undefined && !k.spoke && k.sent) {
             const own = { ward: inv.ward, heir: inv.heir, current: k.current, next: k.next, seq: k.seq };
-            const r = await inside.send(bind, own, true, method, args, wanted);
+            const r = read(await inside.send(bind, own, true, method, args, wanted));
             k.seq = own.seq;
             k.current = own.current;
             k.next = own.next;
-            if (isUnreached(r))
-                return r; // still nothing. she knows no more than before.
-            if (!isSilence(r) && !isWord(r) && 'object' in r) {
-                k.spoke = true; // it was heard the first time, and this is the answer
-                bind.answered[name] = true;
-                return r.object;
+            inside.wrote();
+            if (!r.door) {
+                // Nothing the door said. Unreached and late are hers to hear now; bytes
+                // that were not Quo's leave her where she was, and the heir is tried.
+                if (!isSilence(r.answer))
+                    return r.answer;
+            }
+            else if (!isSilence(r.answer)) {
+                // The door spoke to her own key, so it heard the first knock: this is
+                // the answer, or the door's word for her. Its silence alone cannot be
+                // told from a refusal, so silence is followed by the knock as the heir,
+                // which the door then refuses if it had heard, and she hears silence.
+                k.spoke = true;
+                if (answered(r))
+                    bind.answered[name] = true;
+                return r.answer;
             }
-            // Refused. The door never heard her, so the heir is still hers to spend.
         }
         const first = inv.heir !== undefined && !k.spoke;
         const keys = first ? { ward: inv.ward, heir: inv.heir, current: inv.secret, next: k.current, seq: k.seq } : { ward: inv.ward, heir: inv.heir ?? null, current: k.current, next: k.next, seq: k.seq };
-        const r = await inside.send(bind, keys, true, method, args, wanted);
+        const r = read(await inside.send(bind, keys, true, method, args, wanted));
         k.sent = true; // bytes went out. whether they arrived is the far door's to know.
         // The number she spoke under, and the key she announced, kept whoever
         // answered and kept when nobody did. A reply lost on the way back is a
@@ -127,20 +160,12 @@ export function buildStance(inside, key, cells, bind) {
             k.current = keys.current;
             k.next = keys.next;
         }
-        if (isUnreached(r))
-            return r; // nothing came back. she does not know whether it was heard.
-        // The heir is spent once the door honoured it, whatever she then said: an
-        // object, silence, or that she threw. A refusal wrote nothing, and says
-        // so by its word, so the heir still speaks and the next knock is as it.
-        k.spoke = !(!isSilence(r) && !isWord(r) && 'quo' in r && r.quo !== 'threw');
-        if (isSilence(r) || isWord(r))
-            return r;
-        if ('silence' in r)
-            return silence;
-        if ('quo' in r)
-            return word(r.quo);
-        bind.answered[name] = true;
-        return r.object;
+        if (honoured(r))
+            k.spoke = true;
+        if (answered(r))
+            bind.answered[name] = true;
+        inside.wrote();
+        return r.answer;
     };
     // The id she took this relation under, if she took it. One relation is one
     // ward and one heir whichever door it is reached by, so the standing and the
@@ -157,7 +182,7 @@ export function buildStance(inside, key, cells, bind) {
             // same relation, and the two would refuse each other.
             const id = takenAs(nameOf(inv));
             if (id !== undefined)
-                return bounded(wanted, (live) => lane(`ask:${id}`, () => (live() ? asking(id, bind.standings[id], cells.standings[id], method, args, wanted) : Promise.resolve(word('late')))));
+                return standingAt(id).ask(method, args, wanted);
             return bounded(wanted, (live) => lane(`knock:${nameOf(inv)}`, () => (live() ? knocking(inv, method, args, wanted) : Promise.resolve(word('late')))));
         },
         // Take consumes. Until now the relation lived in the knock record, under
@@ -194,12 +219,14 @@ export function buildStance(inside, key, cells, bind) {
                 put(cells.standings, id, { id, digest: null, blueprint: null, seen: null });
                 delete bind.knocks[name];
                 delete bind.answered[name];
+                inside.wrote();
                 return Promise.resolve(id);
             });
         },
         remove: (id) => {
             drop(cells.standings, id);
             drop(bind.standings, id);
+            inside.wrote();
         },
     };
     const standingAt = (id) => ({
@@ -215,13 +242,19 @@ export function buildStance(inside, key, cells, bind) {
             return bounded(wanted, (live) => lane(`ask:${id}`, () => (live() ? asking(id, keys, rec, method, args, wanted) : Promise.resolve(word('late')))));
         },
     });
+    // The record an ask writes into is the one it was issued on. A standing
+    // dropped and re-taken under the same id while the ask was in flight is
+    // another relation, and the blueprint that came back is not hers.
     const asking = async (id, keys, rec, method, args, wanted) => {
         const out = await send(keys, method, args, wanted, rec);
         if (method === undefined && !isSilence(out) && !isWord(out)) {
-            const here = at(cells.standings, id);
-            if (here) {
-                here.blueprint = out;
-                here.digest = here.seen = await digest(out);
+            // A blueprint her cells cannot keep, nested past the bound or carrying
+            // a key no harbor writes, is not Quo's bytes: silence, and nothing written.
+            if (cellFault(out, 'blueprint') !== null)
+                return silence;
+            if (rec && at(cells.standings, id) === rec) {
+                rec.blueprint = out;
+                rec.digest = rec.seen = await digest(out);
             }
         }
         return out;
@@ -236,20 +269,48 @@ export function buildStance(inside, key, cells, bind) {
         cells,
         // A being may make. The ward refuses what it refuses the owner: a key
         // already booted, a class the harbor does not hold, and a throw at birth
-        // leaves the partition as it was. Reaching into the being made is not
-        // offered here: that is the owner's, and she has no relation to her
-        // until one is invited and taken like any other.
-        boot: (className, key) => inside.instantiate(key, className),
+        // leaves the partition as it was. Reaching into another is still the
+        // owner's alone: what a maker may have is a relation to what she made,
+        // by naming an id, and it is made the way every relation is. The being
+        // made mints an occupant for her maker under the maker's own key, so she
+        // knows who made her by that name and by nothing else; her maker knocks,
+        // takes it under the id she gave, and holds one standing like any other.
+        // Nothing half-lives: a relation that could not be made unmakes the
+        // being, who is a moment old and known to nobody.
+        boot: async (className, made, id) => {
+            if (id !== undefined && (reserved(id) || at(cells.standings, id) || at(cells.occupants, id)))
+                return null;
+            const born = inside.instantiate(made, className);
+            if (born === null || id === undefined)
+                return born;
+            const inv = await inside.relate(born, key);
+            if (inv) {
+                const out = await calls.knock(inv);
+                if (!isSilence(out) && !isWord(out) && (await calls.take(id, inv)) === id)
+                    return born;
+            }
+            inside.unmake(born);
+            return null;
+        },
         occupants: {
             // rotation one: the ward mints the occupant's first key and gives the secret away.
             // it keeps the pk beside the id and nothing else. the invitation IS the key.
-            invite: async (id) => {
+            invite: async (id, notes) => {
                 if (reserved(id) || at(cells.occupants, id) || at(cells.standings, id))
                     return null;
-                put(cells.occupants, id, { id, notes: {} });
+                // The key first, and nothing written until it exists: a record put
+                // before the mint would be a record a remove in the meantime drops
+                // with no heir to close, and the heir opened after it would name an
+                // id nobody holds, for a later invite under that id to resurrect.
                 const k = await inside.mintKey(bind);
+                if (reserved(id) || at(cells.occupants, id) || at(cells.standings, id))
+                    return null; // taken while the key was minted
+                // The notes are the terms the inviter minted under, hers to read on her
+                // gate. She may write more later; nobody outside ever writes them.
+                put(cells.occupants, id, { id, notes: notes ? { ...notes } : {} });
                 inside.openHeir(k.pk, key, id);
                 put(bind.occupants, id, k.pk);
+                inside.wrote();
                 return { ward: inside.pk, heir: k.pk, secret: k.seed };
             },
             remove: (id) => {
@@ -258,6 +319,7 @@ export function buildStance(inside, key, cells, bind) {
                 drop(bind.occupants, id);
                 if (heir)
                     inside.closeHeir(heir); // the heir dies with the id
+                inside.wrote();
             },
         },
         standings,

package/dist/ward/ward.d.ts

@@ -1,2 +1,12 @@
+import type { Cells, Stance } from '../being/types.ts';
 import type { Ground, WardPointers } from './ground.ts';
+import { type Bind } from './partition.ts';
+import { type Door } from './door.ts';
+export type Booted = Door & {
+    bind: Bind;
+    stance: Stance;
+    cells: Cells & {
+        class?: string;
+    };
+};
 export declare function Ward(ground: Ground): Promise<WardPointers>;

package/dist/ward/ward.js

@@ -14,7 +14,7 @@ import { ownerAnswer } from './owner.js';
 import { allow, within, LATE } from './allowance.js';
 import { beingKey, openReply, sealAsk, wardKey, wardPadlock, wardSignPk } from './seal.js';
 import { unhex } from './arithmetic.js';
-import { guardCells, cellFault } from './cells.js';
+import { guardCells, unguarded, cellFault } from './cells.js';
 // How many minted pks she keeps behind her. Enough to name the keys in play.
 const MINTED = 8;
 // The ward. One call in, two pointers out. Async because keys are derived.
@@ -38,24 +38,25 @@ class Self {
         this.g = ground;
         this.key = key;
         this.pk = key.pk;
-        this.p = open(ground.memory); // the partition IS the ward's cells
-        this.heirs = new Heirs(this.p);
+        this.p = open(ground.memory); // the partition: the ward's own state, and every being's row
+        this.heirs = new Heirs(this.p, () => this.#wrote());
         this.door = makeDoor(key, this.heirs, this.doors, () => this.p.public, (n) => ground.random(n)); // pointer one
         this.#boot(this.pk, this); // the ward's ward is itself
         // a restart is silent: every being in the cells is constructed again, unasked.
-        // A throw on a boot the owner asked for is that boot's answer: silence,
-        // and nothing half-lives. This boot nobody asked for, and there is nobody
-        // to hand a silence to. Any constructor may throw — a default that is not
-        // a value, an author's mistake, a shape she no longer recognises after an
-        // upgrade — and let through here it is one being taking down the ward and
-        // every other being in it, on a restart. She is absent instead: no door,
-        // so silence at the door, and her cells sit untouched, waiting for the
-        // run that can read them.
+        // A throw on a boot the owner asked for is that boot's error, and nothing
+        // half-lives. This boot nobody asked for, and there is nobody to hand an
+        // error to. Any constructor may throw, a default that is not a value, an
+        // author's mistake, a shape she does not recognise after an upgrade, and
+        // let through here it is one being taking down the ward and every other
+        // being in it, on a restart. She is absent instead: no door, so silence
+        // at the door, and her cells sit untouched, waiting for the run that can
+        // read them. Her row stays hers: nobody boots another class over it, the
+        // owner sees her as absent, and the owner may unboot her.
         for (const [k, c] of Object.entries(this.p.beings)) {
             if (k === this.pk || !c.class)
                 continue;
             try {
-                this.#instantiate(k, c.class);
+                this.#boot(k, c.class);
             }
             catch {
                 /* she is not here this run. the ward is, and so is everyone else. */
@@ -82,20 +83,50 @@ class Self {
         return ownerAnswer({
             pk: this.pk,
             doors: this.doors,
+            absent: () => this.#absent(),
             publicKey: () => this.p.public,
             instantiate: (key, className) => this.#instantiate(key, className),
             unboot: (key) => this.#unboot(key),
-            setPublic: (key) => void (this.p.public = key),
+            setPublic: (key) => {
+                this.p.public = key;
+                this.#wrote();
+            },
         }, asker, method, args);
     }
     // ---- ward functions. on the object. no stance reaches them.
+    // The partition was written. The harbor is told, and nothing more: what it
+    // does with the word is its own, and the ward never learns.
+    #wrote() {
+        this.g.wrote?.();
+    }
+    // The rows no door holds this run: beings whose class threw at birth or
+    // is not the harbor's to give. Key to class.
+    #absent() {
+        const out = {};
+        for (const [k, c] of Object.entries(this.p.beings))
+            if (k !== this.pk && !this.doors.has(k))
+                put(out, k, c.class ?? null);
+        return out;
+    }
+    // A new being under a key nobody holds. A key with a row in the partition
+    // is booted, whether a door holds it this run or not: an absent being's
+    // row is hers, with every relation in it, and no class is booted over it.
+    // A throw at birth is that boot's refusal and nothing half-lives; the
+    // ward says which, since the owner hears objects.
     #instantiate(key, className) {
-        if (!key || this.doors.has(key))
+        if (typeof key !== 'string' || typeof className !== 'string' || !key || this.doors.has(key) || at(this.p.beings, key))
             return null;
-        const door = this.#boot(key, className);
+        let door;
+        try {
+            door = this.#boot(key, className);
+        }
+        catch {
+            return 'threw';
+        }
         if (!door)
             return null;
-        door.cells.class = className; // so a restart finds her
+        unguarded(door.cells).class = className; // so a restart finds her. the ward's key, written behind her guard
+        this.#wrote();
         return door;
     }
     // The inverse of boot, and the only way a being leaves a ward. Her
@@ -104,16 +135,28 @@ class Self {
     // rather than meeting a being who is simply not there any more. What is
     // left after that is her cells and her bind table, and they go with her:
     // a row naming a being no door holds would be read on the next restart
-    // and boot her again.
+    // and boot her again. An absent being leaves the same way: she has no
+    // stance to speak for her, so the ward closes her heirs itself.
     #unboot(key) {
+        if (key === this.pk)
+            return null;
         const door = this.doors.get(key);
-        if (!door || key === this.pk)
+        const cells = door?.cells ?? at(this.p.beings, key);
+        if (!cells)
             return null;
-        const occupants = Object.keys(door.cells.occupants), standings = Object.keys(door.cells.standings);
-        for (const id of occupants)
-            door.stance.occupants.remove(id);
-        for (const id of standings)
-            door.stance.standings.remove(id);
+        const ids = (r) => (r !== null && typeof r === 'object' ? Object.keys(r) : []);
+        const occupants = ids(cells.occupants), standings = ids(cells.standings);
+        if (door) {
+            for (const id of occupants)
+                door.stance.occupants.remove(id);
+            for (const id of standings)
+                door.stance.standings.remove(id);
+        }
+        else {
+            const bind = at(this.p.bind, key);
+            for (const heir of Object.values(bind?.occupants ?? {}))
+                this.heirs.close(heir);
+        }
         // A ward whose public being is gone answers arrivals for no heir with
         // silence, as a ward that never had one does.
         if (this.p.public === key)
@@ -121,13 +164,14 @@ class Self {
         drop(this.p.beings, key);
         drop(this.p.bind, key);
         this.doors.delete(key);
+        this.#wrote();
         return [...occupants, ...standings];
     }
     // Nothing is written until there is somebody to write it for: a class the
     // harbor does not know makes no being, and a boot that made nobody must
     // leave the partition as it found it.
     #boot(key, classNameOrSelf) {
-        const cells = guardCells(at(this.p.beings, key) ?? emptyCells());
+        const cells = guardCells(at(this.p.beings, key) ?? emptyCells(), () => this.#wrote());
         const bind = at(this.p.bind, key) ?? emptyBind();
         const stance = buildStance({
             pk: this.pk,
@@ -138,21 +182,24 @@ class Self {
             // A throw at birth is null to her, not a throw in her method: she asked
             // for a being and got none, and her own answer is still hers to give.
             instantiate: (k, className) => {
-                try {
-                    return this.#instantiate(k, className)?.key ?? null;
-                }
-                catch {
-                    return null;
-                }
+                const made = this.#instantiate(k, className);
+                return made && made !== 'threw' ? made.key : null;
             },
+            // The two halves of a maker's way back, each the ward's own call: the
+            // being made mints an occupant for her maker, and a relation that
+            // never came about takes her out again.
+            relate: async (k, id) => (await this.doors.get(k)?.stance.occupants.invite(id)) ?? null,
+            unmake: (k) => void this.#unboot(k),
+            wrote: () => this.#wrote(),
         }, key, cells, bind);
         const being = classNameOrSelf === this ? this : this.g.instantiate(classNameOrSelf, stance);
-        if (!being)
-            return null;
+        if (!being || typeof being.answer !== 'function')
+            return null; // a being is anything with an answer, and nothing without one
         put(this.p.beings, key, cells);
         put(this.p.bind, key, bind);
         const door = { key, cells, bind, stance, being };
         this.doors.set(key, door);
+        this.#wrote();
         return door;
     }
     async #mintKey(bind) {
@@ -164,6 +211,7 @@ class Self {
         bind.minted.push(k.pk);
         if (bind.minted.length > MINTED)
             bind.minted.splice(0, bind.minted.length - MINTED);
+        this.#wrote();
         return k;
     }
     // One send for every door, the ward's own included. Mine: never leaves.
@@ -190,10 +238,12 @@ class Self {
         // Args that will not go through the seal are args that never left. A
         // being holds three answers and a throw is not one of them, so an ask
         // that cannot be sealed is told what is true of it: no door was reached.
-        // Values only, by the same rule her cells keep: a Date would arrive as a
-        // string, a function would not arrive at all, and she would never know
-        // the far being was asked something other than what she said.
-        if (cellFault(args, 'args') !== null)
+        // One object of values, by the rule her cells keep and the far door
+        // reads: a Date would arrive as a string, a function would not arrive at
+        // all, a list or a string would be refused as a stranger's bytes, and
+        // she would never know the far being was asked something other than
+        // what she said.
+        if (args === null || typeof args !== 'object' || Array.isArray(args) || cellFault(args, 'args') !== null)
             return unreached();
         let sealed;
         try {
@@ -227,6 +277,7 @@ class Self {
             keys.current = keys.next; // the far door holds `next` as announced. move to it.
             keys.next = null;
         }
+        this.#wrote(); // the count moved, and the keys may have
         return reply;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quo-systems/quo",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "Quo: an object asks another object and gets an answer, without knowing where it is. Being, Ward, Harbor.",
   "keywords": [
     "quo",
@@ -33,7 +33,9 @@
     "./conformance": {
       "types": "./dist/conformance/index.d.ts",
       "default": "./dist/conformance/index.js"
-    }
+    },
+    "./vectors/*": "./vectors/*",
+    "./package.json": "./package.json"
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json",

package/src/being/being.ts

@@ -18,11 +18,24 @@ export type AskSpec = {
 // Names a subclass may not use for an ask, because they are the base's own.
 const RESERVED = new Set(['answer', 'describe', 'stance', 'cells', 'standings', 'occupants', 'occupant', 'invite', 'knock', 'take', 'boot', 'constructor']);
 
+// Whether she has a method of that name, written on her own prototype chain
+// below Object's. A name Object lends every object, `hasOwnProperty` or
+// `toString`, is not a method she wrote; and a field she assigns in her own
+// constructor is not there yet when the base checks, so an ask is a method
+// on the prototype and nothing else.
+const method = (self: object, name: string): boolean => {
+  for (let p = Object.getPrototypeOf(self); p !== null && p !== Object.prototype; p = Object.getPrototypeOf(p)) {
+    if (Object.hasOwn(p, name)) return typeof (p as Record<string, unknown>)[name] === 'function';
+  }
+  return false;
+};
+
 export class Being {
   // Her cells' defaults. Merged in at birth, only where a key is missing, so
   // a restart keeps what she wrote.
   static cells: JsonObject = {};
-  // What she can be asked. Declaration order is blueprint order.
+  // What she can be asked. Declaration order is blueprint order, except a
+  // name that reads as an array index, which the language lists first.
   static asks: Record<string, AskSpec> = {};
 
   readonly stance: Stance;
@@ -32,9 +45,11 @@ export class Being {
     const C = this.constructor as typeof Being;
     for (const name of Object.keys(C.asks)) {
       if (RESERVED.has(name)) throw new Error(`ask '${name}' is a reserved name`);
-      if (typeof (this as unknown as Record<string, unknown>)[name] !== 'function') throw new Error(`ask '${name}' has no method`);
+      if (!method(this, name)) throw new Error(`ask '${name}' has no method on the prototype`);
     }
-    for (const [k, v] of Object.entries(C.cells)) if (!(k in stance.cells)) stance.cells[k] = structuredClone(v);
+    // Own keys only: a default named after a member of Object's prototype is
+    // still hers, and still missing until she writes it.
+    for (const [k, v] of Object.entries(C.cells)) if (!Object.hasOwn(stance.cells, k)) stance.cells[k] = structuredClone(v);
   }
 
   get cells(): Cells {
@@ -46,8 +61,8 @@ export class Being {
   get occupants(): Occupants {
     return this.stance.occupants;
   }
-  invite(id: string): Promise<Invitation | null> {
-    return this.stance.occupants.invite(id);
+  invite(id: string, notes?: JsonObject): Promise<Invitation | null> {
+    return this.stance.occupants.invite(id, notes);
   }
   knock(invitation: Invitation, method?: string, args?: JsonObject, wanted?: Wanted): Promise<Answer> {
     return this.stance.standings.knock(invitation, method, args, wanted);
@@ -55,13 +70,14 @@ export class Being {
   take(id: string, invitation: Invitation): Promise<string | null> {
     return this.stance.standings.take(id, invitation);
   }
-  // A new being of her ward, by class name, under a key she chooses.
-  boot(className: string, key: string): string | null {
-    return this.stance.boot(className, key);
+  // A new being of her ward, by class name, under a key she chooses. With an
+  // id, she holds a standing to the being she made, who knows her by her key.
+  boot(className: string, key: string, id?: string): Promise<string | null> {
+    return this.stance.boot(className, key, id);
   }
   // The occupant record for whoever is at the door. Undefined at a public being.
   occupant(asker: Asker): OccupantRecord | undefined {
-    return asker.id === undefined ? undefined : this.cells.occupants[asker.id];
+    return asker.id !== undefined && Object.hasOwn(this.cells.occupants, asker.id) ? this.cells.occupants[asker.id] : undefined;
   }
 
   // Her blueprint for this asker. Override to shape it by hand.
@@ -87,7 +103,7 @@ export class Being {
     // lookup would also find every name on Object's prototype: `valueOf`
     // would answer with her stance, `toString` with a string, and neither is
     // an ask she wrote. Only her own keys are asks, which is what describe
-    // has always shown. What she shows is what she can be asked.
+    // shows. What she shows is what she can be asked.
     const spec = typeof method === 'string' && Object.hasOwn(C.asks, method) ? C.asks[method] : undefined;
     if (!spec || (spec.for && !spec.for(this.occupant(asker), asker))) return { error: 'unknown ask' };
     const fn = (this as unknown as Record<string, (args: JsonObject, asker: Asker) => Reply | Promise<Reply>>)[method];

package/src/being/digest.ts

@@ -12,17 +12,19 @@ import type { Json } from './types.ts';
 const absent = (v: unknown): boolean => v === undefined || typeof v === 'function' || typeof v === 'symbol';
 
 // JCS for I-JSON values: sorted keys, no whitespace, JSON escaping. Numbers
-// are serialized as ES does, which is what RFC 8785 specifies.
-export const canonical = (v: Json): string =>
-  Array.isArray(v)
-    ? `[${v.map((slot) => (absent(slot) ? 'null' : canonical(slot))).join(',')}]`
-    : v !== null && typeof v === 'object'
-      ? `{${Object.keys(v)
-          .filter((k) => !absent(v[k]))
-          .sort()
-          .map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`)
-          .join(',')}}`
-      : JSON.stringify(v);
+// are serialized as ES does, which is what RFC 8785 specifies. A hole in a
+// list is null, as JSON writes it.
+export const canonical = (v: Json): string => {
+  if (Array.isArray(v)) return `[${Array.from(v, (slot) => (absent(slot) ? 'null' : canonical(slot))).join(',')}]`;
+  if (v !== null && typeof v === 'object') {
+    return `{${Object.keys(v)
+      .filter((k) => !absent(v[k]))
+      .sort()
+      .map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`)
+      .join(',')}}`;
+  }
+  return JSON.stringify(v);
+};
 
 const hex = (bytes: ArrayBuffer): string =>
   Array.from(new Uint8Array(bytes), (b) => b.toString(16).padStart(2, '0')).join('');