@quo-systems/quo 0.1.1 → 0.2.1

package/dist/being/index.d.ts

@@ -1,5 +1,5 @@
 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/dist/being/index.js

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

package/dist/being/silence.d.ts

@@ -1,5 +1,10 @@
-import { type Unreached } from './types.ts';
+import { type DoorWord, type Unreached, type Word, type WordName } from './types.ts';
 export declare const silence: unique symbol;
 export declare const isSilence: (x: unknown) => x is typeof silence;
+export declare const DOOR_WORDS: readonly DoorWord[];
+export declare const isDoorWord: (s: unknown) => s is DoorWord;
+export declare const word: <W extends WordName>(name: W) => Word<W>;
+export declare const isWord: (x: unknown) => x is Word;
+export declare const wordOf: (x: Word) => WordName;
 export declare const unreached: () => Unreached;
 export declare const isUnreached: (x: unknown) => x is Unreached;

package/dist/being/silence.js

@@ -1,11 +1,29 @@
 // SPDX-License-Identifier: Apache-2.0
 // Silence is one distinguished value. Null is an answer. Silence is no answer.
-import { UNREACHED_KEY } from './types.js';
+//
+// 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 } from './types.js';
 export const silence = Symbol.for('quo.silence');
 export const isSilence = (x) => 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 = Object.freeze({ [UNREACHED_KEY]: true });
-export const unreached = () => UNREACHED;
-export const isUnreached = (x) => x !== null && typeof x === 'object' && x[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 = ['removed', 'absent', 'unannounced', 'repeated', 'threw'];
+export const isDoorWord = (s) => typeof s === 'string' && DOOR_WORDS.includes(s);
+const WORDS = new Map();
+export const word = (name) => {
+    let w = WORDS.get(name);
+    if (!w)
+        WORDS.set(name, (w = Object.freeze({ [WORD_KEY]: name })));
+    return w;
+};
+export const isWord = (x) => x !== null && typeof x === 'object' && typeof x[WORD_KEY] === 'string';
+export const wordOf = (x) => 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 = () => word('unreached');
+export const isUnreached = (x) => isWord(x) && wordOf(x) === 'unreached';

package/dist/being/types.d.ts

@@ -45,11 +45,15 @@ export type Cells = {
     [hers: string]: Json;
 };
 export type Silence = typeof silence;
-export type Unreached = {
-    readonly [K in typeof UNREACHED_KEY]: true;
+export type DoorWord = 'removed' | 'absent' | 'unannounced' | 'repeated' | 'threw';
+export type WardWord = 'unreached' | 'late' | 'invitation' | 'dropped';
+export type WordName = DoorWord | WardWord;
+export declare const WORD_KEY: unique symbol;
+export type Word<W extends WordName = WordName> = {
+    readonly [K in typeof WORD_KEY]: W;
 };
-export declare const UNREACHED_KEY: unique symbol;
-export type Answer = Json | Silence | Unreached;
+export type Unreached = Word<'unreached'>;
+export type Answer = Json | Silence | Word;
 export type Reply = Json | Silence;
 export type Wanted = {
     time?: number;

package/dist/being/types.js

@@ -13,4 +13,4 @@
 export const OWNER = 'OWNER';
 export const PUBLIC = 'PUBLIC';
 export const RESERVED_IDS = [OWNER, PUBLIC];
-export const UNREACHED_KEY = Symbol.for('quo.unreached');
+export const WORD_KEY = Symbol.for('quo.word');

package/dist/conformance/beings.d.ts

@@ -85,7 +85,7 @@ export declare class Customer extends Being {
             };
         };
     };
-    join(invitation: Invitation): Promise<typeof import("../being/silence.ts").silence | import("../being/types.ts").Unreached | import("../being/types.ts").Json>;
+    join(invitation: Invitation): Promise<typeof import("../being/silence.ts").silence | import("../being/types.ts").Word | import("../being/types.ts").Json>;
     buy(item: string): Promise<import("../being/types.ts").Answer>;
     learn(): Promise<import("../being/types.ts").Answer>;
     hi(_args: JsonObject, asker: Asker): {

package/dist/conformance/beings.js

@@ -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.js';
-import { isSilence, isUnreached } from '../being/silence.js';
+import { isSilence, isUnreached, isWord } from '../being/silence.js';
 // A printer. Invites whom she is told to, prints for her occupants. Her
 // blueprint lives in her cells so a test can change her shape.
 export class Printer extends Being {
@@ -41,7 +41,7 @@ export class Shop extends Being {
     }
     async keepPrinter(invitation) {
         const bp = await this.knock(invitation);
-        if (isSilence(bp) || isUnreached(bp))
+        if (isSilence(bp) || isWord(bp))
             return false;
         this.cells.printerId = await this.take('prn', invitation);
         return true;
@@ -50,7 +50,7 @@ export class Shop extends Being {
         const rec = this.occupant(asker);
         if (rec?.notes.tier === 'gold' && invitation) {
             const back = await this.knock(invitation, 'hi');
-            if (!isSilence(back) && !isUnreached(back))
+            if (!isSilence(back) && !isWord(back))
                 await this.take(`vip-${asker.id}`, invitation);
         }
         return { welcome: true };
@@ -65,7 +65,7 @@ export class Shop extends Being {
         const out = await printer.ask('print', { doc: `receipt for ${item}` });
         if (isUnreached(out))
             return { error: 'printer unreachable', retry: true };
-        if (isSilence(out))
+        if (isSilence(out) || isWord(out))
             return { error: 'printer refused' };
         const st = this.cells.standings[id];
         if (st.seen !== st.digest)
@@ -85,7 +85,7 @@ export class Customer extends Being {
     async join(invitation) {
         const mine = (await this.invite('shop-back'));
         const out = await this.knock(invitation, 'hello', { invitation: mine });
-        if (isSilence(out) || isUnreached(out))
+        if (isSilence(out) || isWord(out))
             return out; // nothing was born
         await this.take('shop', invitation); // now, and only now
         return out;

package/dist/conformance/estate.js

@@ -12,20 +12,22 @@
 //
 // So this chapter does not write the sequence. It keeps a model of the graph,
 // plays legal moves against it from three fixed seeds, and after every move
-// asks three things:
+// asks two things:
 //
 //   the ledger is a graph          every arc the wards hold closes on both ends
 //   the ledger is what it can do   every arc in the model is asked, and answers
 //                                  exactly what being that arc means it answers
-//   the graph is not the topology  the same seed, played under one ward, under
-//                                  a ward per being, and under two harbors,
-//                                  ends in the same graph
 //
-// The third is the one that matters most here. A being never learns where the
-// other one is, so a script that is topology-invariant at forty moves is the
-// promise of Quo held at a scale a scene cannot reach -- and it is what makes
-// a migration honest: if nobody can tell the topology apart, moving a ward
-// between harbors cannot be felt.
+// The second is asked under one ward, under a ward per being, and under two
+// harbors, and that is where the promise of Quo is held: a being never learns
+// where the other one is, so every answer, after every move, under every
+// topology, is the answer the model wrote without knowing the topology
+// either. Held forty times a run, it is the promise at a scale a scene
+// cannot reach, and it is what makes a migration honest: if no answer can
+// tell the topology apart, moving a ward between harbors cannot be felt.
+// The model itself is the script's own bookkeeping and takes nothing from a
+// ward, so it is never compared with itself across topologies: that would
+// hold by construction and prove nothing.
 //
 // A relation is two arcs and never one edge. The occupant arc is the host's,
 // born at invite; the standing arc is the guest's, born at take, and only
@@ -33,9 +35,10 @@
 // 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.js';
-import { isSilence, isUnreached } from '../being/silence.js';
+import { isSilence, isUnreached, isWord, wordOf } from '../being/silence.js';
 import { Member } from './beings.js';
 const HEX64 = /^[0-9a-f]{64}$/;
+const said = (x, w) => isWord(x) && wordOf(x) === w;
 // A pseudo-random source in the language alone: the estate must replay, on
 // every terrain, from a number a failure can print.
 const rolls = (seed) => () => {
@@ -44,17 +47,6 @@ const rolls = (seed) => () => {
     t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
     return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
 };
-// The graph, with nothing of the world in it: no key, no ward pk, no harbor.
-// Two runs under two topologies are the same estate when these agree.
-const abc = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
-const fingerprint = (g) => JSON.stringify({
-    seats: g.seats.map((s) => JSON.stringify([s.host, s.id, s.guest, s.answered, s.live, s.taken])).sort(abc),
-    holds: g.holds.map((h) => JSON.stringify([h.owner, h.id, h.seat.host, h.seat.id, h.live])).sort(abc),
-});
-// Every run of one seed, under every topology, must land on the same graph.
-// The topologies run in one process, so the first to finish records and the
-// rest are held to it.
-const landed = new Map();
 // ---- the ledger is a graph
 // Held after every move. Each line is a way the bookkeeping could stop being
 // a graph: an arc with one end, an arc with two owners, a relation filed in
@@ -136,10 +128,11 @@ export function estate(label, make, { canDown, test }) {
         const back = (await partner.being.invite('acme'));
         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
         // 6. and back, as somebody else: a second invitation is a second relation,
@@ -148,7 +141,7 @@ export function estate(label, make, { canDown, test }) {
         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');
     });
     for (const seed of [1, 2, 3]) {
@@ -193,6 +186,10 @@ export function estate(label, make, { canDown, test }) {
                             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}`;
@@ -274,7 +271,7 @@ export function estate(label, make, { canDown, test }) {
                     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`);
+                        assert.ok(said(out, 'removed'), `step ${step}: ${h.owner}/${h.id} is kicked and should hear removed`);
                 }
             };
             // The trace is the seed's own account of itself: a red run prints the
@@ -297,14 +294,6 @@ export function estate(label, make, { canDown, test }) {
                     throw new Error(`${at(step)}\n  -> ${e.message}`, { cause: e });
                 });
             }
-            // and the estate that came out is the estate every topology comes out with
-            const print = fingerprint(g);
-            const key = `seed ${seed}`;
-            const first = landed.get(key);
-            if (!first)
-                landed.set(key, { by: label, print });
-            else
-                assert.equal(print, first.print, `the estate under ${label} is not the estate under ${first.by}: a being learned the topology`);
         });
     }
 }

package/dist/conformance/index.js

@@ -19,12 +19,14 @@
 //
 // Every assertion here is the truth's. Nothing here knows how a ward is built.
 import { assert } from './assert.js';
-import { silence, isSilence, isUnreached } from '../being/silence.js';
+import { silence, isSilence, isUnreached, isWord, wordOf } from '../being/silence.js';
 import { digest } from '../being/digest.js';
 import { Printer, Shop, Customer, Echo, Member } from './beings.js';
 import { estate } from './estate.js';
 export { Printer, Shop, Customer, Echo, Member };
 const HEX64 = /^[0-9a-f]{64}$/;
+// Her ward's word, as she receives it.
+const said = (x, w) => isWord(x) && wordOf(x) === w;
 export function conform(label, make, { canDown = true, test }) {
     const t = (name, fn) => test(`[${label}] ${name}`, {}, fn);
     const down = (name, fn) => test(`[${label}] ${name}`, { skip: !canDown && 'nothing to cut inside one ward' }, fn);
@@ -62,12 +64,12 @@ export function conform(label, make, { canDown = true, test }) {
         assert.notEqual(i1.secret, i2.secret);
         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, {});
     });
     // ---- consume, the knock
@@ -143,15 +145,15 @@ export function conform(label, make, { canDown = true, test }) {
         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, {});
     });
@@ -311,16 +313,16 @@ export function conform(label, make, { canDown = true, test }) {
         printer.down = false;
         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 });
@@ -333,7 +335,7 @@ export function conform(label, make, { canDown = true, test }) {
         assert.deepEqual(await p, { ok: true, receipt: 'receipt for hat' });
         assert.equal(shop.cells.sales.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;
@@ -349,7 +351,7 @@ export function conform(label, make, { canDown = true, test }) {
         const x = await w.boot('X', Bomb);
         const a = await w.boot('A', Customer);
         const inv = (await x.being.s.occupants.invite('a'));
-        assert.ok(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: {} });
     });
     t('null is an answer, silence is not', async () => {
@@ -407,7 +409,7 @@ export function conform(label, make, { canDown = true, test }) {
         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())));

package/dist/harbor/core.d.ts

@@ -17,14 +17,20 @@ export type Bound = {
 export type Loader = (record: WardRecord) => Promise<Record<string, BeingClass>>;
 export declare const DEFAULT_CODE = "classes/index.ts";
 export declare class Harbor {
+    #private;
     readonly store: Store;
     readonly loader: Loader;
     readonly wards: Map<string, Hosted>;
-    readonly doors: Map<string, (bytes: Uint8Array) => Promise<Uint8Array>>;
+    readonly doors: Map<string, (bytes: Uint8Array) => Promise<{
+        bytes: Uint8Array;
+        heard: boolean;
+    }>>;
     readonly reaches: Map<string, Bound>;
     readonly down: Set<string>;
+    readonly refused: Map<string, number>;
     readonly classes: Record<string, BeingClass>;
     readonly fallbacks: Reach[];
+    readonly announcers: Set<() => void>;
     constructor(store: Store, loader?: Loader);
     boot(): Promise<void>;
     carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | undefined>;

package/dist/harbor/core.js

@@ -32,6 +32,7 @@ export class Harbor {
     doors = new Map(); // ward pk -> door
     reaches = new Map(); // the directory: foreign ward pk -> reach
     down = new Set(); // pks this harbor will not reach right now: weather, for a test
+    refused = new Map(); // own ward pk -> arrivals its door would not admit. what a terrain does with it is its own
     classes = {}; // 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
@@ -41,6 +42,18 @@ export class Harbor {
     // carries it: with a single slot, a harbor holding two lines answered
     // unreached for a pk the other line could have reached.
     fallbacks = [];
+    // How a dialer says what this harbor holds now. An announce is a claim and
+    // a claim is worth nothing until the door behind it answers a probe, so
+    // saying it again costs a proof and buys nothing to an impostor. What is
+    // not free is never saying it again: a ward booted, adopted or dropped
+    // after a line opened would be announced only by the next line, and a line
+    // that does not drop never opens again, so it would be unreachable through
+    // that listener for as long as the socket stayed healthy.
+    announcers = new Set();
+    #announce() {
+        for (const say of this.announcers)
+            say();
+    }
     constructor(store, loader = async () => ({})) {
         this.store = store;
         this.loader = loader;
@@ -56,12 +69,20 @@ export class Harbor {
             this.hint(pk, url);
     }
     // ---- 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, door, bytes) {
+        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, bytes) {
         if (this.down.has(pk))
             return undefined;
         const door = this.doors.get(pk);
         if (door)
-            return new Uint8Array(await door(bytes));
+            return this.#own(pk, door, bytes);
         const bound = this.reaches.get(pk);
         if (bound)
             return bound.reach.carry(pk, bytes);
@@ -77,7 +98,7 @@ export class Harbor {
             return undefined;
         const door = this.doors.get(pk);
         if (door)
-            return new Uint8Array(await door(bytes));
+            return this.#own(pk, door, bytes);
         const bound = this.reaches.get(pk);
         return bound?.held ? bound.reach.carry(pk, bytes) : undefined;
     }
@@ -155,6 +176,7 @@ export class Harbor {
             await h.save();
             this.wards.delete(name);
             this.doors.delete(h.pk);
+            this.#announce(); // this harbor no longer claims it: a listener unbinds a pk an announce stops naming
         }
         return this.store.take(name);
     }
@@ -204,6 +226,7 @@ export class Harbor {
         this.wards.set(name, hosted);
         this.doors.set(hosted.pk, door);
         await save();
+        this.#announce(); // reachable through every line this harbor already holds, not only the next one
         return hosted;
     }
 }

package/dist/harbor/dial.js

@@ -14,6 +14,7 @@ export function dial(harbor, url) {
             wait = 1000;
             void harbor.bind(far, s, false); // the listener's claims, each proven at its door: reached through this socket, not held for others
         }, (why) => {
+            harbor.announcers.delete(say);
             harbor.unbind(s);
             if (d.socket === s)
                 d.socket = null;
@@ -30,9 +31,14 @@ export function dial(harbor, url) {
             wait = Math.min(wait * 2, 30000);
         });
         harbor.fallbacks.push(s); // from the moment it is dialed: an ask made before the handshake waits on the socket, and is not unreached
+        // What this harbor holds, said when the line opens and again whenever it
+        // changes. A ward booted or adopted after the handshake is announced on
+        // the line already in hand, and a dropped one stops being claimed at once.
+        const say = () => s.announce([...harbor.doors.keys()]);
         line.addEventListener('open', () => {
             d.socket = s;
-            s.announce([...harbor.doors.keys()]);
+            harbor.announcers.add(say);
+            say();
         });
     };
     d.close = () => {

package/dist/harbor/memory.d.ts

@@ -5,9 +5,13 @@ export type Booted = WardPointers & {
 };
 export type WardFactory = (ground: Ground) => Promise<WardPointers>;
 export declare class MemoryHarbor {
-    readonly doors: Map<string, (bytes: Uint8Array) => Promise<Uint8Array>>;
+    readonly doors: Map<string, (bytes: Uint8Array) => Promise<{
+        bytes: Uint8Array;
+        heard: boolean;
+    }>>;
     readonly down: Set<string>;
     readonly wire: string[];
+    readonly refused: Map<string, number>;
     readonly peers: Set<MemoryHarbor>;
     cut: boolean;
     readonly partitions: Map<string, Record<string, unknown>>;

package/dist/harbor/memory.js

@@ -3,6 +3,7 @@ export class MemoryHarbor {
     doors = new Map(); // ward pk -> door
     down = new Set(); // ward pks this harbor cannot reach right now
     wire = []; // every byte string that ever crossed, as hex. for inspection
+    refused = new Map(); // ward pk -> arrivals its door would not admit: strangers, counted
     peers = new Set();
     cut = false;
     partitions = new Map(); // seed -> memory. the harbor keeps it and reads nothing
@@ -13,8 +14,12 @@ export class MemoryHarbor {
         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

package/dist/ward/door.d.ts

@@ -8,5 +8,9 @@ export type Door = {
         occupants: Record<string, unknown>;
     };
 };
-export declare function arrive(door: Door, asker: Asker, method: string | undefined, args: JsonObject): Promise<ReplyPayload>;
-export declare function makeDoor(key: WardKey, heirs: Heirs, doors: Map<string, Door>, publicKey: () => string | null, random: (n: number) => Uint8Array): (bytes: Uint8Array) => Promise<Uint8Array>;
+export type Judged = {
+    bytes: Uint8Array;
+    heard: boolean;
+};
+export declare function arrive(door: Door, asker: Asker, method: string | undefined, args: JsonObject, bound: boolean): Promise<ReplyPayload>;
+export declare function makeDoor(key: WardKey, heirs: Heirs, doors: Map<string, Door>, publicKey: () => string | null, random: (n: number) => Uint8Array): (bytes: Uint8Array) => Promise<Judged>;