@quo-systems/quo 0.1.1 → 0.2.1

package/dist/ward/door.js

@@ -1,29 +1,39 @@
 // SPDX-License-Identifier: Apache-2.0
-// Judgment at the door. Sealed bytes in, sealed bytes out. Every failure is
-// one silence, sealed to whoever asked so that a stranger learns nothing,
-// not even which case they hit. What passes is named and dispatched to her
-// answer, and her digest for that asker rides back with the object.
-import { isSilence, isUnreached } from '../being/silence.js';
+// Judgment at the door. Sealed bytes in, sealed bytes out, and one bit for
+// the harbor: whether a key this door holds spoke. A stranger, bytes the
+// door cannot admit, meets one silence whatever the case, so that it learns
+// nothing, not even which case it hit. A key the door has bound hears the
+// ward's word for what happened, sealed to its own lid, because it has
+// already proven who it is and a reason to it is an oracle to nobody. What
+// passes is named and dispatched to her answer, and her digest for that
+// asker rides back with the object.
+import { isSilence, isWord } from '../being/silence.js';
 import { digest } from '../being/digest.js';
 import { at } from './partition.js';
 import { openAsk, sealReply, verifyAsk } from './seal.js';
 import { spent } from './allowance.js';
 import { KEY, sealingPair } from './arithmetic.js';
 const SILENCE = { silence: true };
-// One arrival at one being, already named. Catches every throw.
-export async function arrive(door, asker, method, args) {
+const said = (quo) => ({ quo });
+// One arrival at one being, already named. Catches every throw. `bound` says
+// whether the asker is a key this door holds: she hears `threw`; a stranger
+// at the public being hears silence, because her insides are hers.
+export async function arrive(door, asker, method, args, bound) {
+    const threw = bound ? said('threw') : SILENCE;
     let out;
     try {
         out = await door.being.answer(asker, method, args);
     }
     catch {
-        return SILENCE; // she threw where she was asked. there is no answer.
+        return threw; // she threw where she was asked. there is no answer.
     }
     // Nothing at all is not an answer either: a method that forgot to return
     // has said nothing, and nothing is silence, never a value that JSON drops
     // on the way out and the far side reads back as a fourth word.
-    if (out === undefined || isSilence(out) || isUnreached(out))
+    if (out === undefined || isSilence(out))
         return SILENCE;
+    if (isWord(out))
+        return threw; // a word is the ward's to say, never hers
     if (method === undefined)
         return { object: out, seen: null };
     // The digest rides along, it is not the answer. She has already answered:
@@ -33,7 +43,7 @@ export async function arrive(door, asker, method, args) {
 async function seen(door, asker) {
     try {
         const bp = await door.being.answer(asker);
-        return isSilence(bp) || isUnreached(bp) ? null : await digest(bp);
+        return isSilence(bp) || isWord(bp) ? null : await digest(bp);
     }
     catch {
         return null;
@@ -43,41 +53,50 @@ export function makeDoor(key, heirs, doors, publicKey, random) {
     const judge = async (bytes) => {
         const a = await openAsk(bytes, key.padlock);
         if (!a)
-            return null; // it did not open. there is nobody to answer.
+            return null; // D1. it did not open. there is nobody to answer.
         const { to, payload, ephemeralPk } = a;
-        // The allowance, read before anything is done under it. A budget already
-        // gone is one silence like every other refusal here: a stranger learns
-        // nothing, not even that what she ran out of was time. Nothing is spent
-        // and nothing rotates, because nothing was heard.
-        if (spent({ time: payload.time }))
-            return { reply: SILENCE, ephemeralPk };
-        // An ask with no doors left is one silence like a budget already gone.
-        // Nothing sets hops and nothing decrements it yet; this door refuses zero
-        // so that a relay chain invented later meets doors that already stop it.
-        if (payload.hops === 0)
-            return { reply: SILENCE, ephemeralPk };
+        const refuse = () => ({ reply: SILENCE, ephemeralPk, heard: false });
+        // D2, the rest of it. The allowance is read before anything is done under
+        // it, and hops at zero is refused so that a relay chain invented later
+        // meets doors that already stop it. Nothing sets hops.
+        if (spent({ time: payload.time }) || payload.hops === 0)
+            return refuse();
         const args = payload.args ?? {};
         if (to === null) {
+            // For nobody: the public being, or D3 nobody home; D4 the signature
+            // fails under the key the payload names. She is asked by strangers,
+            // and a stranger hears silence for whatever she then does.
             const pk = publicKey();
             const pub = pk !== null ? doors.get(pk) : undefined;
             if (!pub || !(await verifyAsk(a, payload.by)))
-                return { reply: SILENCE, ephemeralPk };
-            return { reply: await arrive(pub, {}, payload.method, args), ephemeralPk };
+                return refuse();
+            return { reply: await arrive(pub, {}, payload.method, args, false), ephemeralPk, heard: true };
         }
         const h = heirs.admits(to, payload.by);
-        if (!h)
-            return { reply: SILENCE, ephemeralPk };
-        const door = doors.get(h.being);
-        if (!door || !at(door.cells.occupants, h.id))
-            return { reply: SILENCE, ephemeralPk }; // she removed it, or she is gone
+        if (!h) {
+            // D5 a heir not held, D6 a key not admitted. One more case: the heir
+            // was held and the id removed. Its last keys are kept so that their
+            // holder, and only their holder, D7 checked, hears that she is gone.
+            if (!heirs.gone(to, payload.by) || !(await verifyAsk(a, payload.by)))
+                return refuse();
+            return { reply: said('removed'), ephemeralPk, heard: true };
+        }
         if (!(await verifyAsk(a, payload.by)))
-            return { reply: SILENCE, ephemeralPk };
+            return refuse(); // D7, under an admitted key
+        // From here the door has heard a key it holds. Every answer below is
+        // sealed to that key's lid; nothing below is a stranger's.
+        const door = doors.get(h.being);
+        if (!door)
+            return { reply: said('absent'), ephemeralPk, heard: true }; // D8. she did not come back this run
+        if (!at(door.cells.occupants, h.id))
+            return { reply: said('removed'), ephemeralPk, heard: true }; // D8. the record is gone
         // Once only, and only now: the number is spent after the signature, so a
         // stranger cannot burn a number she could not sign for, and together with
         // the keys, so the same bytes twice rotate nothing and refusal writes nothing.
-        if (!heirs.honour(h, payload.by, payload.next, payload.seq))
-            return { reply: SILENCE, ephemeralPk };
-        return { reply: await arrive(door, { id: h.id }, payload.method, args), ephemeralPk };
+        const honoured = heirs.honour(h, payload.by, payload.next, payload.seq); // D9, D10
+        if (honoured !== true)
+            return { reply: said(honoured), ephemeralPk, heard: true };
+        return { reply: await arrive(door, { id: h.id }, payload.method, args, true), ephemeralPk, heard: true };
     };
     // The door itself. Always answers bytes. When the ask did not open, the
     // reply is sealed to the ephemeral pk on its lid, which is all a stranger
@@ -89,11 +108,12 @@ export function makeDoor(key, heirs, doors, publicKey, random) {
     return async function door(bytes) {
         const out = await judge(bytes);
         const reply = out?.reply ?? SILENCE;
+        const heard = out?.heard ?? false;
         try {
-            return await sealReply(reply, out?.ephemeralPk ?? lid(bytes, random), key.sign, random(32));
+            return { bytes: await sealReply(reply, out?.ephemeralPk ?? lid(bytes, random), key.sign, random(32)), heard };
         }
         catch {
-            return sealReply(reply, (await sealingPair(random(32))).pk, key.sign, random(32));
+            return { bytes: await sealReply(reply, (await sealingPair(random(32))).pk, key.sign, random(32)), heard };
         }
     };
 }

package/dist/ward/ground.d.ts

@@ -7,6 +7,9 @@ export type Ground = {
     random(n: number): Uint8Array;
 };
 export type WardPointers = {
-    door(bytes: Uint8Array): Promise<Uint8Array>;
+    door(bytes: Uint8Array): Promise<{
+        bytes: Uint8Array;
+        heard: boolean;
+    }>;
     ask(method?: string, args?: Record<string, unknown>): Promise<unknown>;
 };

package/dist/ward/heirs.d.ts

@@ -1,12 +1,14 @@
-import type { Heir, Partition } from './partition.ts';
+import type { DoorWord } from '../being/types.ts';
+import { type Heir, type Partition } from './partition.ts';
 export declare class Heirs {
     #private;
     constructor(p: Partition);
     open(heir: string, being: string, id: string): void;
     close(heir: string): void;
+    gone(heir: string, by: string): boolean;
     get(heir: string): Heir | undefined;
     admits(heir: string, by: string): Heir | null;
     spend(h: Heir, seq: number): boolean;
-    honour(h: Heir, by: string, next: string | null, seq: number): boolean;
+    honour(h: Heir, by: string, next: string | null, seq: number): true | DoorWord;
     settle(h: Heir, by: string, next: string | null): boolean;
 }

package/dist/ward/heirs.js

@@ -1,3 +1,4 @@
+import { GONE } from './partition.js';
 // How wide the span is, is the ward's own — wider is more forgiving of a
 // rough road, and no peer can tell the difference except by being refused.
 const SPAN = 64;
@@ -9,8 +10,24 @@ export class Heirs {
     open(heir, being, id) {
         this.#p.heirs[heir] = { being, id, current: heir, announced: null, fresh: true, mark: 0, spent: [] };
     }
+    // The id was removed. The heir is forgotten, and its last keys are kept
+    // apart, bounded, so that whoever still holds them hears `removed` at the
+    // door, once they have signed as themselves, and nobody else hears a thing.
     close(heir) {
+        const h = this.#p.heirs[heir];
+        if (!h)
+            return;
         delete this.#p.heirs[heir];
+        this.#p.gone[heir] = { current: h.current, announced: h.announced };
+        const keys = Object.keys(this.#p.gone);
+        for (const old of keys.slice(0, Math.max(0, keys.length - GONE)))
+            delete this.#p.gone[old];
+    }
+    // May `by` speak for a relation she removed? True only for the keys the
+    // door held when the id went, which nobody but their holder has.
+    gone(heir, by) {
+        const g = this.#p.gone[heir];
+        return !!g && (by === g.current || by === g.announced);
     }
     get(heir) {
         return this.#p.heirs[heir];
@@ -60,10 +77,10 @@ export class Heirs {
     // behind her. Every write below this line is one that is going to hold.
     honour(h, by, next, seq) {
         if (h.fresh && next === null)
-            return false; // a knock without a key of her own binds nothing
+            return 'unannounced'; // a knock without a key of her own binds nothing
         if (!this.spend(h, seq))
-            return false;
-        return this.settle(h, by, next);
+            return 'repeated';
+        return this.settle(h, by, next) ? true : 'unannounced';
     }
     // The signature checked out. Settle the keys: a fresh heir rotates at once
     // to what it announced and must announce something; a current key replaces

package/dist/ward/owner.d.ts

@@ -1,4 +1,4 @@
-import type { Asker, Invitation, Json, JsonObject, Wanted } from '../being/types.ts';
+import type { Ask, Asker, Invitation, Json, JsonObject, Wanted } from '../being/types.ts';
 export type OwnerSide = {
     pk: string;
     doors: Map<string, {
@@ -24,9 +24,11 @@ export type OwnerSide = {
         };
     }>;
     publicKey(): string | null;
-    instantiate(key: string, className: string, isPublic?: boolean): {
+    instantiate(key: string, className: string): {
         key: string;
     } | null;
+    unboot(key: string): string[] | null;
+    setPublic(key: string): void;
 };
-export declare const OWNER_ASKS: readonly ['boot', 'invite', 'knock', 'remove'];
+export declare const OWNER_ASKS: Ask[];
 export declare function ownerAnswer(w: OwnerSide, asker: Asker, method: string | undefined, args: JsonObject): Promise<Json>;

package/dist/ward/owner.js

@@ -1,13 +1,29 @@
 // SPDX-License-Identifier: Apache-2.0
 // The owner's asks. The root owner holds the ask pointer; every other owner
-// is an occupant of the ward itself, invited by the root. Five asks:
-// describe, boot, invite, knock, remove. The knock is a being's knock made
-// for her, and the standing is written into her cells under the id the
-// owner gave; remove takes a relation out of her by id, the mirror of it.
-import { isSilence, isUnreached } from '../being/silence.js';
+// is an occupant of the ward itself, invited by the root. The ward is a
+// being to her owner: the empty ask is her describe, and it carries her asks
+// with a description and an input each, so a side renders them as it
+// renders any being's. Six asks: boot, public, invite, knock, remove and
+// unboot, which is boot's inverse and takes her relations with her. The
+// knock is a being's knock made for her, and the standing is written into
+// her cells under the id the owner gave; remove takes a relation out of her
+// by id, the mirror of it.
+import { isSilence, isWord, wordOf } from '../being/silence.js';
 import { digest } from '../being/digest.js';
 import { OWNER } from '../being/types.js';
-export const OWNER_ASKS = ['boot', 'invite', 'knock', 'remove'];
+const str = { type: 'string' };
+export const OWNER_ASKS = [
+    { name: 'boot', description: 'boot a being by class name, under a key the owner chooses', input: { type: 'object', properties: { key: str, class: str }, required: ['key', 'class'] } },
+    { name: 'public', description: 'mark a booted being as the one public being of the ward, reached by anyone at the bare pk', input: { type: 'object', properties: { key: str }, required: ['key'] } },
+    { name: 'invite', description: 'mint an invitation on a being of the ward, under the id she will know the occupant by; on the ward pk it mints an owner, and only the root may', input: { type: 'object', properties: { being: str, id: str }, required: ['being', 'id'] } },
+    {
+        name: 'knock',
+        description: 'knock for a being of the ward with an invitation, and take the standing under id if answered; being is a key booted, or { boot: class, key } to boot her first',
+        input: { type: 'object', properties: { being: { description: 'a key, or { boot, key }' }, id: str, invitation: { type: 'object' }, method: str, args: { type: 'object' }, wanted: { type: 'object', properties: { time: { type: 'number' } } } }, required: ['being', 'id', 'invitation'] },
+    },
+    { name: 'remove', description: 'take a relation out of a being of the ward by id, occupant or standing; on the ward pk it unseats an owner, and only the root may', input: { type: 'object', properties: { being: str, id: str }, required: ['being', 'id'] } },
+    { name: 'unboot', description: 'take a being out of the ward, with every relation she holds; her occupants hear removed, and the ward itself is refused', input: { type: 'object', properties: { being: str }, required: ['being'] } },
+];
 export async function ownerAnswer(w, asker, method, args) {
     // Every name the owner gives is a word. Coerced instead of checked, an
     // object passed where a name belongs becomes the string "[object Object]",
@@ -16,17 +32,24 @@ export async function ownerAnswer(w, asker, method, args) {
     if (method === undefined)
         return describe(w);
     if (method === 'boot') {
-        // A ward may have one public being, and no more. Marking a second 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.
-        if (args.public === true && w.publicKey() !== null)
-            return { error: 'a ward has one public being' };
         const key = word(args.key), className = word(args.class);
         if (key === null || className === null)
             return { error: 'no such class, or key taken' };
-        const door = w.instantiate(key, className, args.public === true);
+        const door = w.instantiate(key, className);
         return door ? { booted: door.key } : { error: 'no such class, or key taken' };
     }
+    if (method === 'public') {
+        // A ward may have one public being, and no more. Marking a second 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.
+        const key = word(args.key);
+        if (key === null || key === w.pk || !w.doors.has(key))
+            return { error: 'no such being' };
+        if (w.publicKey() !== null && w.publicKey() !== key)
+            return { error: 'a ward has one public being' };
+        w.setPublic(key);
+        return { public: key };
+    }
     if (method === 'invite') {
         // On the ward itself, only the root may invite: an occupant of the ward
         // is an owner, and ownership is minted by the ask pointer alone. An owner
@@ -63,8 +86,10 @@ export async function ownerAnswer(w, asker, method, args) {
         // The owner is a caller like any other and may say what this knock may
         // spend. Saying nothing is the ward's default, as it is for a being.
         const out = await door.stance.standings.knock(inv, args.method, args.args ?? {}, args.wanted);
-        if (isSilence(out) || isUnreached(out))
-            return { error: isUnreached(out) ? 'unreached' : 'silence' };
+        if (isSilence(out))
+            return { error: 'silence' };
+        if (isWord(out))
+            return { error: wordOf(out) }; // the owner hears objects: the word is the error's name
         return { taken: await door.stance.standings.take(id, inv), answer: out };
     }
     if (method === 'remove') {
@@ -88,6 +113,20 @@ export async function ownerAnswer(w, asker, method, args) {
             return { error: 'nothing to remove' };
         return { removed: id };
     }
+    if (method === 'unboot') {
+        // The inverse of boot, and the only way a being leaves a ward. Her
+        // relations go with her, so an occupant of hers hears `removed` from the
+        // keys the door kept, exactly as it would had the owner removed each id
+        // by hand; the owner hears which ids those were. The ward itself is
+        // refused, for the reason knock is: it is a being to nobody outside, and
+        // unbooting it would be a ward deleting itself from inside its own map,
+        // leaving its owners bound to a door that is gone.
+        const being = word(args.being);
+        if (being === null || being === w.pk)
+            return { error: 'no such being' };
+        const removed = w.unboot(being);
+        return removed === null ? { error: 'no such being' } : { unbooted: being, removed };
+    }
     return { error: 'unknown ask' };
 }
 // The ward's describe for its owner: its beings, their classes, a digest each,
@@ -100,7 +139,7 @@ async function describe(w) {
         let d = null;
         try {
             const bp = await door.being.answer({ id: OWNER });
-            d = isSilence(bp) || isUnreached(bp) ? null : await digest(bp);
+            d = isSilence(bp) || isWord(bp) ? null : await digest(bp);
         }
         catch {
             // she threw where she was asked. there is no blueprint, and d stays null.
@@ -108,7 +147,7 @@ async function describe(w) {
         beings[key] = { class: door.cells.class ?? null, public: w.publicKey() === key, digest: d };
     }
     return {
-        asks: OWNER_ASKS.map((name) => ({ name, input: { type: 'object' } })),
+        asks: OWNER_ASKS,
         notes: { pk: w.pk, beings },
     };
 }

package/dist/ward/partition.d.ts

@@ -34,6 +34,11 @@ export type Bind = {
     answered: Record<string, true>;
     minted: string[];
 };
+export type Gone = {
+    current: string;
+    announced: string | null;
+};
+export declare const GONE = 256;
 export type Partition = {
     version: string;
     beings: Record<string, Cells & {
@@ -41,6 +46,7 @@ export type Partition = {
     }>;
     bind: Record<string, Bind>;
     heirs: Record<string, Heir>;
+    gone: Record<string, Gone>;
     public: string | null;
 };
 export declare function open(memory: Record<string, unknown>): Partition;

package/dist/ward/partition.js

@@ -25,6 +25,7 @@ export const READS = [VERSION];
 function upgrade(p) {
     return p;
 }
+export const GONE = 256;
 // The one place a ward reads state that another ward wrote. A fresh
 // memory becomes a partition of this version; anything already written must
 // say it is this version, and a ward that cannot read it does not boot. Birth is
@@ -41,6 +42,7 @@ export function open(memory) {
     p.beings ??= {};
     p.bind ??= {};
     p.heirs ??= {};
+    p.gone ??= {};
     p.public ??= null;
     return p;
 }

package/dist/ward/seal.d.ts

@@ -1,4 +1,4 @@
-import type { Json, JsonObject } from '../being/types.ts';
+import type { DoorWord, Json, JsonObject } from '../being/types.ts';
 export type WardKey = {
     sign: Uint8Array;
     padlock: Uint8Array;
@@ -28,6 +28,8 @@ export type ReplyPayload = {
     seen: string | null;
 } | {
     silence: true;
+} | {
+    quo: DoorWord;
 };
 export declare function sealAsk(to: string | null, payload: AskPayload, signer: Uint8Array, padlock: Uint8Array, seed: Uint8Array): Promise<{
     bytes: Uint8Array;

package/dist/ward/seal.js

@@ -1,3 +1,4 @@
+import { isDoorWord } from '../being/silence.js';
 import { KEY, SIGNATURE, box, concat, hex, sha256, sign, signingPair, sealingPair, unbox, unhex, verify } from './arithmetic.js';
 const utf8 = new TextEncoder();
 const text = new TextDecoder();
@@ -73,8 +74,9 @@ export async function sealReply(reply, ephemeralPk, wardSign, seed) {
 // Open a reply with the ephemeral secret kept from the ask, and verify it
 // came from the ward it was sent to. Null is silence: it did not open, it
 // lied, or it is not a reply. Every ward on the wire is somebody else's code,
-// so the shape is checked here and nowhere later: a reply is `{ silence }`
-// or `{ object, seen }` with an object present and seen a digest or null.
+// so the shape is checked here and nowhere later: a reply is `{ silence }`,
+// `{ quo: word }` with a word the door may say, or `{ object, seen }` with an
+// object present and seen a digest or null.
 // Anything else is bytes that said nothing, and her ward never hands her a
 // throw or an absent value for what a stranger wrote.
 export async function openReply(bytes, ephemeralSecret, signPk) {
@@ -93,6 +95,8 @@ export async function openReply(bytes, ephemeralSecret, signPk) {
         const r = reply;
         if (r.silence === true)
             return { silence: true };
+        if (Object.hasOwn(r, 'quo'))
+            return isDoorWord(r.quo) ? { quo: r.quo } : null;
         if (!Object.hasOwn(r, 'object') || r.object === undefined)
             return null;
         if (r.seen !== null && !(typeof r.seen === 'string' && /^[0-9a-f]{64}$/.test(r.seen)))

package/dist/ward/stance.d.ts

@@ -1,4 +1,4 @@
-import type { Cells, JsonObject, Silence, Stance, Unreached, Wanted } from '../being/types.ts';
+import type { Cells, JsonObject, Silence, Stance, Wanted, Word } from '../being/types.ts';
 import { type Bind, type StandingKeys } from './partition.ts';
 import { type ReplyPayload } from './seal.ts';
 export type Inside = {
@@ -9,7 +9,7 @@ export type Inside = {
     }>;
     openHeir(heir: string, being: string, id: string): void;
     closeHeir(heir: string): void;
-    send(bind: Bind, keys: StandingKeys, announce: boolean, method: string | undefined, args: JsonObject, wanted: Wanted | undefined): Promise<ReplyPayload | Silence | Unreached>;
+    send(bind: Bind, keys: StandingKeys, announce: boolean, method: string | undefined, args: JsonObject, wanted: Wanted | undefined): Promise<ReplyPayload | Silence | Word>;
 };
 export type SealedInvitation = {
     ward: string;

package/dist/ward/stance.js

@@ -1,7 +1,7 @@
 // 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 } from '../being/silence.js';
+import { silence, isSilence, isUnreached, isWord, word } from '../being/silence.js';
 import { digest } from '../being/digest.js';
 import { RESERVED_IDS } from '../being/types.js';
 import { at, put, drop } from './partition.js';
@@ -65,14 +65,16 @@ export function buildStance(inside, key, cells, bind) {
         const out = await within(allow(wanted).time, work(() => !late), () => {
             late = true;
         });
-        return out === LATE ? silence : out;
+        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);
-        if (isSilence(r) || isUnreached(r))
+        if (isSilence(r) || isWord(r))
             return r;
         if ('silence' in r)
             return silence;
+        if ('quo' in r)
+            return word(r.quo); // the far door's word for her, sealed to her lid
         if (rec && method !== undefined && r.seen !== null)
             rec.seen = r.seen; // the digest rode along
         return r.object;
@@ -105,7 +107,7 @@ export function buildStance(inside, key, cells, bind) {
             k.next = own.next;
             if (isUnreached(r))
                 return r; // still nothing. she knows no more than before.
-            if (!isSilence(r) && !('silence' in r)) {
+            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;
@@ -127,9 +129,16 @@ export function buildStance(inside, key, cells, bind) {
         }
         if (isUnreached(r))
             return r; // nothing came back. she does not know whether it was heard.
-        k.spoke = true;
-        if (isSilence(r) || 'silence' in r)
+        // 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;
     };
@@ -141,15 +150,15 @@ export function buildStance(inside, key, cells, bind) {
     const calls = {
         knock: async (inv, method, args = {}, wanted) => {
             if (!valid(inv))
-                return silence;
+                return word('invitation'); // S1. nothing is sent
             // She may knock again, and after take that knock is an ask: the relation
             // has one home, so it answers on the standing's lane, under the
             // standing's keys and its count. A second lane here would speak for the
             // 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(silence))));
-            return bounded(wanted, (live) => lane(`knock:${nameOf(inv)}`, () => (live() ? knocking(inv, method, args, wanted) : Promise.resolve(silence))));
+                return bounded(wanted, (live) => lane(`ask:${id}`, () => (live() ? asking(id, bind.standings[id], cells.standings[id], method, args, wanted) : Promise.resolve(word('late')))));
+            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
         // the ward and the heir; from now it lives in the standing, under her id.
@@ -201,14 +210,14 @@ export function buildStance(inside, key, cells, bind) {
         ask: (method, args = {}, wanted) => {
             const keys = at(bind.standings, id);
             if (!keys)
-                return Promise.resolve(silence); // she dropped it between one line and the next
+                return Promise.resolve(word('dropped')); // S2. she dropped it between one line and the next
             const rec = at(cells.standings, id);
-            return bounded(wanted, (live) => lane(`ask:${id}`, () => (live() ? asking(id, keys, rec, method, args, wanted) : Promise.resolve(silence))));
+            return bounded(wanted, (live) => lane(`ask:${id}`, () => (live() ? asking(id, keys, rec, method, args, wanted) : Promise.resolve(word('late')))));
         },
     });
     const asking = async (id, keys, rec, method, args, wanted) => {
         const out = await send(keys, method, args, wanted, rec);
-        if (method === undefined && !isSilence(out) && !isUnreached(out)) {
+        if (method === undefined && !isSilence(out) && !isWord(out)) {
             const here = at(cells.standings, id);
             if (here) {
                 here.blueprint = out;