@quo-systems/quo 0.1.1 → 0.2.0

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;

package/dist/ward/ward.js

@@ -4,7 +4,7 @@
 // the first being in its own map, and every being it later instantiates gets
 // a stance built by the same code. Mints every key, seals every ask that
 // leaves, opens every one that arrives.
-import { silence, isSilence, unreached, isUnreached } from '../being/silence.js';
+import { silence, isSilence, unreached, isWord, word } from '../being/silence.js';
 import { OWNER } from '../being/types.js';
 import { at, open, put, emptyBind, emptyCells } from './partition.js';
 import { Heirs } from './heirs.js';
@@ -65,7 +65,7 @@ class Self {
         this.ask = async (method, args = {}) => {
             try {
                 const out = await this.answer({ id: OWNER }, method, args);
-                return isSilence(out) || isUnreached(out) ? silence : out;
+                return isSilence(out) || isWord(out) ? silence : out;
             }
             catch {
                 return silence;
@@ -173,22 +173,22 @@ class Self {
         // relation that comes back round holds a lane the answer needs, and only a
         // bound on the wait can break that. What comes back late is not read.
         //
-        // A wait that ran out is silence, never unreached. Unreached promises
+        // A wait that ran out is `late`, never unreached. Unreached promises
         // nothing was delivered and is safe to retry; a bound that expired knows
         // no such thing, because the far door may have heard and be working still.
         //
         // A harbor answers bytes or nothing. One that throws instead has answered
         // nothing in a louder voice, and is read as nothing: no door was reached.
-        const carried = (keys.ward === this.pk ? this.door(new Uint8Array(bytes)) : this.g.carry(keys.ward, bytes)).then((b) => b, () => undefined);
+        const carried = (keys.ward === this.pk ? this.door(new Uint8Array(bytes)).then((r) => r.bytes) : this.g.carry(keys.ward, bytes)).then((b) => b, () => undefined);
         const out = await within(budget.time, carried);
         if (out === LATE)
-            return silence;
+            return word('late');
         if (out === undefined)
             return unreached(); // nothing came back. no door was reached.
         const reply = await openReply(out, ephemeral, wardSignPk(keys.ward));
         if (!reply)
-            return silence; // did not open, or not from that ward
-        if (!('silence' in reply) && keys.next !== null) {
+            return silence; // did not open, or not from that ward: not Quo's bytes
+        if ('object' in reply && keys.next !== null) {
             keys.current = keys.next; // the far door holds `next` as announced. move to it.
             keys.next = null;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quo-systems/quo",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Quo: an object asks another object and gets an answer, without knowing where it is. Being, Ward, Harbor.",
   "keywords": [
     "quo",
@@ -18,40 +18,28 @@
     "node": ">=22.18"
   },
   "exports": {
-    ".": { "types": "./dist/being/index.d.ts", "default": "./dist/being/index.js" },
-    "./ward": { "types": "./dist/ward/index.d.ts", "default": "./dist/ward/index.js" },
-    "./harbor": { "types": "./dist/harbor/index.d.ts", "default": "./dist/harbor/index.js" },
-    "./conformance": { "types": "./dist/conformance/index.d.ts", "default": "./dist/conformance/index.js" }
+    ".": {
+      "types": "./dist/being/index.d.ts",
+      "default": "./dist/being/index.js"
+    },
+    "./ward": {
+      "types": "./dist/ward/index.d.ts",
+      "default": "./dist/ward/index.js"
+    },
+    "./harbor": {
+      "types": "./dist/harbor/index.d.ts",
+      "default": "./dist/harbor/index.js"
+    },
+    "./conformance": {
+      "types": "./dist/conformance/index.d.ts",
+      "default": "./dist/conformance/index.js"
+    }
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.build.json",
-    "check": "npm run build && npm run typecheck && npm run lint && npm test && npm run check:estate",
-    "check:estate": "node --test \"estate/test/*.test.ts\"",
-    "pretypecheck": "npm run build",
-    "typecheck": "tsc",
-    "typecheck:watch": "tsc --watch",
-    "lint": "npm run lint:ts && npm run lint:md",
-    "lint:ts": "oxlint --type-aware",
-    "lint:md": "markdownlint-cli2",
-    "lint:fix": "oxlint --type-aware --fix && markdownlint-cli2 --fix",
-    "pretest": "npm run build",
     "test": "node --test \"test/*.test.ts\"",
-    "check:terrain": "node --test \"test/terrain/*.test.ts\" \"estate/test/terrain/*.test.ts\"",
-    "test:being": "node --test test/being.test.ts",
-    "test:ward": "node --test test/ward.test.ts",
-    "prepublishOnly": "npm run check && npm run check:terrain"
-  },
-  "devDependencies": {
-    "@types/node": "^26.4.1",
-    "bun": "^1.4.0",
-    "deno": "^2.9.6",
-    "esbuild": "^0.28.2",
-    "markdownlint-cli2": "^0.23.2",
-    "oxlint": "^1.81.0",
-    "oxlint-tsgolint": "^7.0.2001",
-    "playwright": "^1.62.1",
-    "typescript": "^7.0.2",
-    "workerd": "^1.20260904.1"
+    "check:terrain": "node --test \"test/terrain/*.test.ts\"",
+    "prepublishOnly": "cd ../.. && npm run check && npm run check:terrain"
   },
   "publishConfig": {
     "access": "public"

package/src/being/index.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // @quo-systems/quo — the Being side. What a being author imports, if anything.
 export { Being, type AskSpec } from './being.ts';
-export { silence, isSilence, unreached, isUnreached } from './silence.ts';
+export { silence, isSilence, unreached, isUnreached, word, isWord, wordOf, DOOR_WORDS, isDoorWord } from './silence.ts';
 export { digest, canonical } from './digest.ts';
 export { OWNER, PUBLIC, RESERVED_IDS } from './types.ts';
 export type * from './types.ts';

package/src/being/silence.ts

@@ -1,14 +1,32 @@
 // SPDX-License-Identifier: Apache-2.0
 // Silence is one distinguished value. Null is an answer. Silence is no answer.
-import { UNREACHED_KEY, type Unreached } from './types.ts';
+//
+// The ward's words are the other distinguished values: what her ward tells
+// her when no object came back and it knows why. Each is one frozen object
+// under one symbol key, so a being cannot make one by accident, none of them
+// crosses an edge as a value, and a being who compares against them needs
+// no fourth shape. `unreached` is one of them.
+import { WORD_KEY, type DoorWord, type Unreached, type Word, type WordName } from './types.ts';
 
 export const silence: unique symbol = Symbol.for('quo.silence');
 export const isSilence = (x: unknown): x is typeof silence => x === silence;
 
-// Unreached is the ward's own word: no far door was reached. It carries no
-// reason. Safe to retry, because nothing was delivered. A being cannot
-// produce it: a ward that sees it come out of a being treats it as silence.
-const UNREACHED: Unreached = Object.freeze({ [UNREACHED_KEY]: true });
-export const unreached = (): Unreached => UNREACHED;
-export const isUnreached = (x: unknown): x is Unreached =>
-  x !== null && typeof x === 'object' && (x as Record<symbol, unknown>)[UNREACHED_KEY] === true;
+// The words a door says to a key it has bound, and no other. They ride on
+// the wire as `{ quo: word }`, so a reply is checked against this list.
+export const DOOR_WORDS: readonly DoorWord[] = ['removed', 'absent', 'unannounced', 'repeated', 'threw'];
+export const isDoorWord = (s: unknown): s is DoorWord => typeof s === 'string' && (DOOR_WORDS as readonly string[]).includes(s);
+
+const WORDS = new Map<WordName, Word>();
+export const word = <W extends WordName>(name: W): Word<W> => {
+  let w = WORDS.get(name);
+  if (!w) WORDS.set(name, (w = Object.freeze({ [WORD_KEY]: name })));
+  return w as Word<W>;
+};
+export const isWord = (x: unknown): x is Word => x !== null && typeof x === 'object' && typeof (x as Record<symbol, unknown>)[WORD_KEY] === 'string';
+export const wordOf = (x: Word): WordName => x[WORD_KEY];
+
+// Unreached: no far door was reached. Nothing is known to have been
+// delivered, so asking again is safe. A being cannot produce it: a ward that
+// sees a word come out of a being reads it as her having thrown.
+export const unreached = (): Unreached => word('unreached');
+export const isUnreached = (x: unknown): x is Unreached => isWord(x) && wordOf(x) === 'unreached';

package/src/being/types.ts

@@ -44,11 +44,21 @@ export type Cells = {
 };
 
 export type Silence = typeof silence;
-export type Unreached = { readonly [K in typeof UNREACHED_KEY]: true };
-export const UNREACHED_KEY: unique symbol = Symbol.for('quo.unreached');
+
+// The ward's words: what her ward says when no object came back and it knows
+// why. A door says the first five to a key it has bound, and rides them on
+// the wire as `{ quo: word }`; her own ward says the last four to her and
+// they never leave the ward. Each is one frozen object under one symbol key,
+// so no being makes one and none crosses an edge as a value.
+export type DoorWord = 'removed' | 'absent' | 'unannounced' | 'repeated' | 'threw';
+export type WardWord = 'unreached' | 'late' | 'invitation' | 'dropped';
+export type WordName = DoorWord | WardWord;
+export const WORD_KEY: unique symbol = Symbol.for('quo.word');
+export type Word<W extends WordName = WordName> = { readonly [K in typeof WORD_KEY]: W };
+export type Unreached = Word<'unreached'>;
 
 // What comes back from an ask or a knock.
-export type Answer = Json | Silence | Unreached;
+export type Answer = Json | Silence | Word;
 // What a being answers.
 export type Reply = Json | Silence;
 

package/src/conformance/beings.ts

@@ -2,7 +2,7 @@
 // The fixture beings. Fixed, so that the ward is what varies. A printer, a
 // shop, a customer on the base class, and one raw being with no base at all.
 import { Being } from '../being/being.ts';
-import { isSilence, isUnreached } from '../being/silence.ts';
+import { isSilence, isUnreached, isWord } from '../being/silence.ts';
 import type { Asker, Blueprint, Invitation, JsonObject, OccupantRecord, Reply, Stance } from '../being/types.ts';
 
 // A printer. Invites whom she is told to, prints for her occupants. Her
@@ -46,7 +46,7 @@ export class Shop extends Being {
 
   async keepPrinter(invitation: Invitation): Promise<boolean> {
     const bp = await this.knock(invitation);
-    if (isSilence(bp) || isUnreached(bp)) return false;
+    if (isSilence(bp) || isWord(bp)) return false;
     this.cells.printerId = await this.take('prn', invitation);
     return true;
   }
@@ -55,7 +55,7 @@ export class Shop extends Being {
     const rec = this.occupant(asker);
     if (rec?.notes.tier === 'gold' && invitation) {
       const back = await this.knock(invitation as Invitation, 'hi');
-      if (!isSilence(back) && !isUnreached(back)) await this.take(`vip-${asker.id}`, invitation as Invitation);
+      if (!isSilence(back) && !isWord(back)) await this.take(`vip-${asker.id}`, invitation as Invitation);
     }
     return { welcome: true };
   }
@@ -67,7 +67,7 @@ export class Shop extends Being {
     if (!printer) return { error: 'no printer' };
     const out = await printer.ask('print', { doc: `receipt for ${item}` });
     if (isUnreached(out)) return { error: 'printer unreachable', retry: true };
-    if (isSilence(out)) return { error: 'printer refused' };
+    if (isSilence(out) || isWord(out)) return { error: 'printer refused' };
     const st = this.cells.standings[id!];
     if (st.seen !== st.digest) this.occupant(asker)!.notes.printerChanged = true;
     (this.cells.sales as JsonObject[]).push({ item: item ?? null, by: asker.id ?? null });
@@ -88,7 +88,7 @@ export class Customer extends Being {
   async join(invitation: Invitation) {
     const mine = (await this.invite('shop-back'))!;
     const out = await this.knock(invitation, 'hello', { invitation: mine as never });
-    if (isSilence(out) || isUnreached(out)) return out; // nothing was born
+    if (isSilence(out) || isWord(out)) return out; // nothing was born
     await this.take('shop', invitation); // now, and only now
     return out;
   }

package/src/conformance/estate.ts

@@ -33,12 +33,13 @@
 // A model that kept one symmetric edge would be a wrong model, and would
 // agree happily with a ward that had drifted.
 import { assert } from './assert.ts';
-import { isSilence, isUnreached } from '../being/silence.ts';
+import { isSilence, isUnreached, isWord, wordOf } from '../being/silence.ts';
 import type { Invitation } from '../being/types.ts';
 import { Member } from './beings.ts';
 import type { Census, Handle, Runner, World } from './index.ts';
 
 const HEX64 = /^[0-9a-f]{64}$/;
+const said = (x: unknown, w: string): boolean => isWord(x) && wordOf(x) === w;
 
 // One occupant arc, as the host holds it. `guest` is null until somebody
 // knocks; `live` goes false when she is kicked. Both are the host's business
@@ -161,10 +162,11 @@ export function estate(label: string, make: () => Promise<World>, { canDown, tes
     assert.deepEqual(await acme.being.knock(back, 'ping'), { pong: 'acme' });
     assert.equal(await acme.being.take('them', back), 'them');
 
-    // 5. acme kicks her. her standing is still hers to hold -- she is never
-    //    told -- and it is silence from here on.
+    // 5. acme kicks her. her standing is still hers to hold, and she is not
+    //    told until she asks: then the door, under the key it bound for her,
+    //    says removed, and only to her.
     acme.being.occupants.remove('partner-1');
-    assert.ok(isSilence(await partner.being.standings['the-client']!.ask('ping')));
+    assert.ok(said(await partner.being.standings['the-client']!.ask('ping'), 'removed'));
     assert.deepEqual(Object.keys(partner.cells.standings), ['the-client']); // she never learns
     assert.deepEqual(await acme.being.standings.them!.ask('ping'), { pong: 'acme' }); // the other arc never moved
 
@@ -174,7 +176,7 @@ export function estate(label: string, make: () => Promise<World>, { canDown, tes
     assert.notEqual(second.heir, first.heir);
     assert.deepEqual(await partner.being.knock(second, 'ping'), { pong: 'partner-2' });
     assert.equal(await partner.being.take('the-client-again', second), 'the-client-again');
-    assert.ok(isSilence(await partner.being.standings['the-client']!.ask('ping')));
+    assert.ok(said(await partner.being.standings['the-client']!.ask('ping'), 'removed'));
     ledger(w.census(), undefined, 'the story');
   });
 
@@ -221,6 +223,9 @@ export function estate(label: string, make: () => Promise<World>, { canDown, tes
               assert.deepEqual(back, { pong: s.id }, `${guest} knocking ${s.host}/${s.id}`);
               s.guest = guest;
               s.answered = true;
+            } else if (!s.live && (s.guest === null || (s.guest === guest && (hold === undefined || hold.live)))) {
+              // kicked, and she speaks under a key the door bound for this seat: she hears why
+              assert.ok(said(back, 'removed'), `${guest} knocking kicked ${s.host}/${s.id} should hear removed`);
             } else assert.ok(isSilence(back), `${guest} knocking ${s.host}/${s.id} should be silence`);
             return `${guest} knocks ${s.host}/${s.id}`;
           });
@@ -304,7 +309,7 @@ export function estate(label: string, make: () => Promise<World>, { canDown, tes
           }
           const out = await standing!.ask('ping');
           if (h.seat.live) assert.deepEqual(out, { pong: h.seat.id }, `step ${step}: ${h.owner}/${h.id} -> ${h.seat.host}/${h.seat.id}`);
-          else assert.ok(isSilence(out), `step ${step}: ${h.owner}/${h.id} is kicked and should be silence`);
+          else assert.ok(said(out, 'removed'), `step ${step}: ${h.owner}/${h.id} is kicked and should hear removed`);
         }
       };
 

package/src/conformance/index.ts

@@ -19,7 +19,7 @@
 //
 // Every assertion here is the truth's. Nothing here knows how a ward is built.
 import { assert } from './assert.ts';
-import { silence, isSilence, isUnreached } from '../being/silence.ts';
+import { silence, isSilence, isUnreached, isWord, wordOf } from '../being/silence.ts';
 import { digest } from '../being/digest.ts';
 import type { Asker, BeingClass, Cells, Invitation, Json, JsonObject } from '../being/types.ts';
 import { Printer, Shop, Customer, Echo, Member } from './beings.ts';
@@ -54,6 +54,8 @@ export type World = {
 export { Printer, Shop, Customer, Echo, Member };
 
 const HEX64 = /^[0-9a-f]{64}$/;
+// Her ward's word, as she receives it.
+const said = (x: unknown, w: string): boolean => isWord(x) && wordOf(x) === w;
 
 // The runner is handed in. Node passes `node:test`; a browser and an edge
 // worker pass a shim of their own. The suite is the ward's truth, and the
@@ -100,12 +102,12 @@ export function conform(label: string, make: () => Promise<World>, { canDown = t
     assert.equal(i1.ward, i2.ward);
   });
 
-  t('remove before any knock: the heir is forgotten, a knock on it is silence', async () => {
+  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(isSilence(await alice.being.join(inv)));
+    assert.ok(said(await alice.being.join(inv), 'removed'));
     assert.deepEqual(alice.cells.standings, {});
   });
 
@@ -189,16 +191,16 @@ export function conform(label: string, make: () => Promise<World>, { canDown = t
     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(isSilence(await alice.being.join(inv2)));
+    assert.ok(said(await alice.being.join(inv2), 'removed'));
     assert.deepEqual(Object.keys(alice.cells.standings), ['shop']);
   });
 
-  t('take without a knock, or after a silent knock, births nothing', async () => {
+  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(isSilence(await alice.being.knock(inv, 'hello')));
+    assert.ok(said(await alice.being.knock(inv, 'hello'), 'removed'));
     assert.equal(await alice.being.take('shop', inv), null);
     assert.deepEqual(alice.cells.standings, {});
   });
@@ -374,16 +376,16 @@ export function conform(label: string, make: () => Promise<World>, { canDown = t
     assert.deepEqual(await alice.being.buy('hat'), { ok: true, receipt: 'receipt for hat' });
   });
 
-  t('a removed occupant is silence to the far side and her heir is forgotten; a dropped standing is gone', async () => {
+  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(isSilence(await alice.being.buy('hat')));
+    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'))); // and a re-knock finds no heir
+    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 });
@@ -398,7 +400,7 @@ export function conform(label: string, make: () => Promise<World>, { canDown = t
     assert.equal((shop.cells.sales as unknown[]).length, 1);
   });
 
-  t('a being that throws is silence outside; the ward stays up', async () => {
+  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: unknown;
@@ -413,7 +415,7 @@ export function conform(label: string, make: () => Promise<World>, { canDown = t
     const x = await w.boot<Bomb>('X', Bomb);
     const a = await w.boot<Customer>('A', Customer);
     const inv = (await (x.being.s as Customer['stance']).occupants.invite('a'))!;
-    assert.ok(isSilence(await a.being.knock(inv, 'any')));
+    assert.ok(said(await a.being.knock(inv, 'any'), 'threw'));
     assert.deepEqual(await a.being.knock(inv), { asks: [], notes: {} });
   });
 
@@ -473,7 +475,7 @@ export function conform(label: string, make: () => Promise<World>, { canDown = t
     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(isSilence(await a.being.knock({ ward: 'not a pk' }, 'time'))); // not even an address
+    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()) as Json));

package/src/harbor/core.ts

@@ -45,6 +45,7 @@ export class Harbor {
   readonly doors = new Map<string, WardPointers['door']>(); // ward pk -> door
   readonly reaches = new Map<string, Bound>(); // the directory: foreign ward pk -> reach
   readonly down = new Set<string>(); // pks this harbor will not reach right now: weather, for a test
+  readonly refused = new Map<string, number>(); // own ward pk -> arrivals its door would not admit. what a terrain does with it is its own
   readonly classes: Record<string, BeingClass> = {}; // classes handed in-process, beside the loader's
   // The dialers' sockets, in the order they were dialed: where a pk nobody
   // here knows is sent, because the listener a harbor dialed is a rendezvous
@@ -71,10 +72,18 @@ export class Harbor {
 
   // ---- the directory
 
+  // Bytes to one of this harbor's own doors, and the one bit the door says
+  // beside its reply, counted.
+  async #own(pk: string, door: WardPointers['door'], bytes: Uint8Array): Promise<Uint8Array> {
+    const r = await door(bytes);
+    if (!r.heard) this.refused.set(pk, (this.refused.get(pk) ?? 0) + 1);
+    return new Uint8Array(r.bytes);
+  }
+
   async carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | undefined> {
     if (this.down.has(pk)) return undefined;
     const door = this.doors.get(pk);
-    if (door) return new Uint8Array(await door(bytes));
+    if (door) return this.#own(pk, door, bytes);
     const bound = this.reaches.get(pk);
     if (bound) return bound.reach.carry(pk, bytes);
     for (const reach of this.fallbacks) {
@@ -87,7 +96,7 @@ export class Harbor {
   async deliver(pk: string, bytes: Uint8Array): Promise<Uint8Array | undefined> {
     if (this.down.has(pk)) return undefined;
     const door = this.doors.get(pk);
-    if (door) return new Uint8Array(await door(bytes));
+    if (door) return this.#own(pk, door, bytes);
     const bound = this.reaches.get(pk);
     return bound?.held ? bound.reach.carry(pk, bytes) : undefined;
   }

package/src/harbor/memory.ts

@@ -15,6 +15,7 @@ export class MemoryHarbor {
   readonly doors = new Map<string, WardPointers['door']>(); // ward pk -> door
   readonly down = new Set<string>(); // ward pks this harbor cannot reach right now
   readonly wire: string[] = []; // every byte string that ever crossed, as hex. for inspection
+  readonly refused = new Map<string, number>(); // ward pk -> arrivals its door would not admit: strangers, counted
   readonly peers = new Set<MemoryHarbor>();
   cut = false;
   readonly partitions = new Map<string, Record<string, unknown>>(); // seed -> memory. the harbor keeps it and reads nothing
@@ -25,7 +26,11 @@ export class MemoryHarbor {
   async route(farPk: string, bytes: Uint8Array): Promise<Uint8Array | undefined> {
     if (this.down.has(farPk)) return undefined;
     const door = this.doors.get(farPk);
-    if (door) return door(bytes);
+    if (door) {
+      const r = await door(bytes);
+      if (!r.heard) this.refused.set(farPk, (this.refused.get(farPk) ?? 0) + 1);
+      return r.bytes;
+    }
     const peer = [...this.peers].find((h) => h.doors.has(farPk) && !h.down.has(farPk));
     if (!peer || this.cut) return undefined; // nothing. the harbor has no word silence
     return peer.route(farPk, bytes);