nervur 0.19.1 → 0.19.2

package/dist/being/lent.js

@@ -53,7 +53,16 @@ export class Lent extends Being {
             return bp;
         return { ...bp, asks: [...bp.asks, LENT_ASKS.offer, LENT_ASKS.retract] };
     }
+    // An offer is open until it is taken or retracted. The taker's knock is the
+    // first word she hears from the occupant she minted for it, so hearing
+    // from that id closes the offer, and `open` holds only offers still
+    // waiting and not every lend she ever made.
     async answer(asker, method, args = {}) {
+        const open = this.cells.open;
+        if (open && asker.id !== undefined && asker.id !== BOX)
+            for (const [heir, id] of Object.entries(open))
+                if (id === asker.id)
+                    delete open[heir];
         if (asker.id === BOX && method === 'offer')
             return this.offer();
         if (asker.id === BOX && method === 'retract')

package/dist/conformance/store.js

@@ -22,7 +22,6 @@ export function conformStore(label, make, { test }) {
         assert.deepEqual(await s.list(), []);
         assert.equal(await s.load('main'), undefined);
         assert.equal(await s.take('main'), undefined);
-        assert.deepEqual(await s.hints(), {});
     });
     t('put, then load: seed, partition and record come back as they went in', async () => {
         const s = await make();
@@ -111,13 +110,4 @@ export function conformStore(label, make, { test }) {
         await s.put('main', kept(9));
         assert.deepEqual((await s.load('main')).seed, seed(9));
     });
-    t('hints are kept by pk and the last one wins', async () => {
-        const s = await make();
-        const pk = 'cd'.repeat(64);
-        await s.hint(pk, 'https://quo.acme.com/quo');
-        await s.hint('ef'.repeat(64), 'http://127.0.0.1:1/quo');
-        assert.deepEqual(await s.hints(), { [pk]: 'https://quo.acme.com/quo', ['ef'.repeat(64)]: 'http://127.0.0.1:1/quo' });
-        await s.hint(pk, 'https://quo.other.com/quo');
-        assert.equal((await s.hints())[pk], 'https://quo.other.com/quo');
-    });
 }

package/dist/harbor/core.d.ts

@@ -39,10 +39,12 @@ export declare class Harbor {
     protected boxFor(name: string, _record: WardRecord): Promise<Invitation | undefined>;
     boot(): Promise<void>;
     partitionOf(name: string): Record<string, unknown> | undefined;
+    quiet(): Promise<void>;
     carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | undefined>;
     deliver(pk: string, bytes: Uint8Array): Promise<Uint8Array | undefined>;
     hint(pk: string, url: string): void;
-    remember(pk: string, url: string): Promise<void>;
+    learn(pk: string, url: string): Promise<boolean>;
+    forget(pk: string): void;
     prove(pk: string, reach: Reach): Promise<boolean>;
     bind(pks: string[], reach: Reach, held: boolean): Promise<void>;
     unbind(reach: Reach): void;

package/dist/harbor/core.js

@@ -12,8 +12,10 @@
 // doors; a socket a dialer holds to it, bound once the door behind the
 // dialer's claim has proved it holds the key, and unbound at close; the
 // claims of a listener this harbor dialed, proved the same way and reached
-// through that line; and a hint, a pk at a URL, kept in the store. A hint
-// never displaces a reach proved at a door. And one fallback: a dialer with nothing in its
+// through that line; and a hint, a pk at a URL. A hint never displaces a
+// reach proved at a door. The directory lives in memory and is kept by no
+// store: whoever learns a hint keeps it where it keeps everything, in a
+// being's cells, and hands it back at every boot. And one fallback: a dialer with nothing in its
 // directory for a pk sends down the socket it holds, because the listener
 // it dialed is the rendezvous and may hold that pk on another socket. Bytes
 // that arrive from the wire go to an own door or a held socket and never
@@ -40,6 +42,9 @@ const PROVING = 8;
 // How many times each reach has announced: a proof from an older announce
 // binds nothing when it lands.
 const announces = new WeakMap();
+// The reaches that are hints, so a hint can be replaced and put down without
+// touching a reach a door proved.
+const hinted = new WeakSet();
 export class Harbor {
     store;
     loader;
@@ -92,9 +97,9 @@ export class Harbor {
     boxFor(name, _record) {
         return this.offering?.(name) ?? Promise.resolve(undefined);
     }
-    // Boot every ward the store keeps, and learn the hints. One ward that will
-    // not host, a partition this kit cannot read or a loader that throws, is
-    // named in `unbooted` and takes nobody else down with it.
+    // Boot every ward the store keeps. One ward that will not host, a
+    // partition this kit cannot read or a loader that throws, is named in
+    // `unbooted` and takes nobody else down with it.
     async boot() {
         for (const name of await this.store.list()) {
             // A ward this harbor already hosts is not booted twice. A terrain that
@@ -111,8 +116,6 @@ export class Harbor {
                 this.unbooted.push(name);
             }
         }
-        for (const [pk, url] of Object.entries(await this.store.hints()))
-            this.hint(pk, url);
     }
     // The object a ward writes into, by the name it is kept under: the
     // partition the harbor was handed at boot and keeps so it can save it.
@@ -126,6 +129,19 @@ export class Harbor {
         return this.#saving.get(name)?.memory;
     }
     // ---- saving
+    // Every ward's writes kept and none waiting: no row named, no save armed
+    // and none in flight. A write can name a row while another ward is being
+    // saved, so this goes round until a pass finds nothing. A process about to
+    // exit waits here, since its exit is not a turn the timer is given.
+    async quiet() {
+        for (;;) {
+            const busy = [...this.#saving].filter(([, s]) => !s.gone && (s.dirty.size > 0 || s.timer !== undefined || s.running !== null));
+            if (busy.length === 0)
+                return;
+            for (const [name, s] of busy)
+                await (s.running ?? this.#flush(name));
+        }
+    }
     // The ward wrote one row. Its partition is saved once the line is free, and
     // once for every burst of writes, with every row named in that burst.
     #wrote(name, row) {
@@ -362,14 +378,38 @@ export class Harbor {
         const bound = this.reaches.get(pk);
         return bound?.held ? bound.reach.carry(pk, bytes) : undefined;
     }
+    // A hint, taken on the word of whoever gives it. A hint already standing
+    // for the pk is replaced, since a URL is the one part of a ward that moves;
+    // a reach proven at a door is never displaced by one.
     hint(pk, url) {
-        if (this.reaches.has(pk))
+        const standing = this.reaches.get(pk);
+        if (standing && !hinted.has(standing.reach))
             return; // a reach proven at a door beats a hint, held or reached through a dialed line
-        this.reaches.set(pk, { reach: request(url), held: false });
+        const reach = request(url);
+        hinted.add(reach);
+        this.reaches.set(pk, { reach, held: false });
     }
-    async remember(pk, url) {
+    // A hint kept only once the door behind it has proven it holds the pk's
+    // key, the same probe an announce is proven by. A URL that answers for
+    // another ward, or for nobody, is refused and nothing is kept: whoever
+    // hands a harbor a hint could otherwise point one ward's asks at a place
+    // that drops them. True is kept.
+    async learn(pk, url) {
+        const standing = this.reaches.get(pk);
+        if (standing && !hinted.has(standing.reach))
+            return true; // already reached, and proven at a door
+        const reach = request(url);
+        if (!(await this.prove(pk, reach)))
+            return false;
         this.hint(pk, url);
-        await this.store.hint(pk, url);
+        return true;
+    }
+    // A hint put down. A reach proven at a door is the line's, and goes when
+    // the line does, never by a word from here.
+    forget(pk) {
+        const standing = this.reaches.get(pk);
+        if (standing && hinted.has(standing.reach))
+            this.reaches.delete(pk);
     }
     // An announce is a claim, and a claim binds nothing until proven: anyone
     // who can reach a listener could otherwise name a pk that is not theirs and

package/dist/harbor/store.d.ts

@@ -15,8 +15,6 @@ export type Store = {
     save(name: string, partition: Record<string, unknown>, rows: readonly string[]): Promise<void>;
     record(name: string, record: WardRecord): Promise<void>;
     take(name: string): Promise<Kept | undefined>;
-    hints(): Promise<Record<string, string>>;
-    hint(pk: string, url: string): Promise<void>;
 };
 export declare const values: (p: Record<string, unknown>) => Record<string, unknown>;
 export declare const rowsOf: (partition: Record<string, unknown>, rows: readonly string[]) => [string, Record<string, unknown> | undefined][];
@@ -27,14 +25,11 @@ type Row = {
 };
 export declare class MemoryStore implements Store {
     readonly rows: Map<string, Row>;
-    readonly reach: Map<string, string>;
     list(): Promise<string[]>;
     load(name: string): Promise<Kept | undefined>;
     put(name: string, kept: Kept): Promise<void>;
     save(name: string, partition: Record<string, unknown>, rows: readonly string[]): Promise<void>;
     record(name: string, record: WardRecord): Promise<void>;
     take(name: string): Promise<Kept | undefined>;
-    hints(): Promise<Record<string, string>>;
-    hint(pk: string, url: string): Promise<void>;
 }
 export {};

package/dist/harbor/store.js

@@ -2,8 +2,7 @@
 // The store: keeping wards by name. A ward is three things and the store
 // keeps all three under one name: the seed, the partition and the ward
 // record, which says where the class bodies come from and which being is
-// the user's. Plus the directory's hints, which are the harbor's and
-// survive a restart. The store reads nothing it keeps; the partition is
+// the user's. The store reads nothing it keeps; the partition is
 // values the ward wrote, and the seed is bytes only the ward derives from.
 // Every terrain has one: files on a disk, IndexedDB in a tab, an object's
 // storage on the edge; the memory store below is the library's own, for a
@@ -31,7 +30,6 @@ const keep = (row, partition, rows) => {
 };
 export class MemoryStore {
     rows = new Map();
-    reach = new Map();
     async list() {
         return [...this.rows.keys()];
     }
@@ -61,10 +59,4 @@ export class MemoryStore {
         this.rows.delete(name);
         return kept;
     }
-    async hints() {
-        return Object.fromEntries(this.reach);
-    }
-    async hint(pk, url) {
-        this.reach.set(pk, url);
-    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervur",
-  "version": "0.19.1",
+  "version": "0.19.2",
   "description": "Nervur's kit of Quo: an object asks another object and gets an answer, without knowing where it is. Being, Ward, Harbor.",
   "keywords": [
     "quo",

package/src/being/lent.ts

@@ -58,7 +58,13 @@ export class Lent extends Being {
     return { ...bp, asks: [...bp.asks, LENT_ASKS.offer, LENT_ASKS.retract] };
   }
 
+  // An offer is open until it is taken or retracted. The taker's knock is the
+  // first word she hears from the occupant she minted for it, so hearing
+  // from that id closes the offer, and `open` holds only offers still
+  // waiting and not every lend she ever made.
   override async answer(asker: Asker, method?: string, args: JsonObject = {}): Promise<Reply> {
+    const open = this.cells.open as Record<string, string> | undefined;
+    if (open && asker.id !== undefined && asker.id !== BOX) for (const [heir, id] of Object.entries(open)) if (id === asker.id) delete open[heir];
     if (asker.id === BOX && method === 'offer') return this.offer();
     if (asker.id === BOX && method === 'retract') return this.retract(args);
     return super.answer(asker, method, args);

package/src/conformance/store.ts

@@ -27,7 +27,6 @@ export function conformStore(label: string, make: () => Promise<Store>, { test }
     assert.deepEqual(await s.list(), []);
     assert.equal(await s.load('main'), undefined);
     assert.equal(await s.take('main'), undefined);
-    assert.deepEqual(await s.hints(), {});
   });
 
   t('put, then load: seed, partition and record come back as they went in', async () => {
@@ -123,14 +122,4 @@ export function conformStore(label: string, make: () => Promise<Store>, { test }
     await s.put('main', kept(9));
     assert.deepEqual((await s.load('main'))!.seed, seed(9));
   });
-
-  t('hints are kept by pk and the last one wins', async () => {
-    const s = await make();
-    const pk = 'cd'.repeat(64);
-    await s.hint(pk, 'https://quo.acme.com/quo');
-    await s.hint('ef'.repeat(64), 'http://127.0.0.1:1/quo');
-    assert.deepEqual(await s.hints(), { [pk]: 'https://quo.acme.com/quo', ['ef'.repeat(64)]: 'http://127.0.0.1:1/quo' });
-    await s.hint(pk, 'https://quo.other.com/quo');
-    assert.equal((await s.hints())[pk], 'https://quo.other.com/quo');
-  });
 }

package/src/harbor/core.ts

@@ -12,8 +12,10 @@
 // doors; a socket a dialer holds to it, bound once the door behind the
 // dialer's claim has proved it holds the key, and unbound at close; the
 // claims of a listener this harbor dialed, proved the same way and reached
-// through that line; and a hint, a pk at a URL, kept in the store. A hint
-// never displaces a reach proved at a door. And one fallback: a dialer with nothing in its
+// through that line; and a hint, a pk at a URL. A hint never displaces a
+// reach proved at a door. The directory lives in memory and is kept by no
+// store: whoever learns a hint keeps it where it keeps everything, in a
+// being's cells, and hands it back at every boot. And one fallback: a dialer with nothing in its
 // directory for a pk sends down the socket it holds, because the listener
 // it dialed is the rendezvous and may hold that pk on another socket. Bytes
 // that arrive from the wire go to an own door or a held socket and never
@@ -110,6 +112,9 @@ const PROVING = 8;
 // How many times each reach has announced: a proof from an older announce
 // binds nothing when it lands.
 const announces = new WeakMap<Reach, number>();
+// The reaches that are hints, so a hint can be replaced and put down without
+// touching a reach a door proved.
+const hinted = new WeakSet<Reach>();
 
 export class Harbor {
   readonly store: Store;
@@ -166,9 +171,9 @@ export class Harbor {
     return this.offering?.(name) ?? Promise.resolve(undefined);
   }
 
-  // Boot every ward the store keeps, and learn the hints. One ward that will
-  // not host, a partition this kit cannot read or a loader that throws, is
-  // named in `unbooted` and takes nobody else down with it.
+  // Boot every ward the store keeps. One ward that will not host, a
+  // partition this kit cannot read or a loader that throws, is named in
+  // `unbooted` and takes nobody else down with it.
   async boot(): Promise<void> {
     for (const name of await this.store.list()) {
       // A ward this harbor already hosts is not booted twice. A terrain that
@@ -182,7 +187,6 @@ export class Harbor {
         this.unbooted.push(name);
       }
     }
-    for (const [pk, url] of Object.entries(await this.store.hints())) this.hint(pk, url);
   }
 
   // The object a ward writes into, by the name it is kept under: the
@@ -199,6 +203,18 @@ export class Harbor {
 
   // ---- saving
 
+  // Every ward's writes kept and none waiting: no row named, no save armed
+  // and none in flight. A write can name a row while another ward is being
+  // saved, so this goes round until a pass finds nothing. A process about to
+  // exit waits here, since its exit is not a turn the timer is given.
+  async quiet(): Promise<void> {
+    for (;;) {
+      const busy = [...this.#saving].filter(([, s]) => !s.gone && (s.dirty.size > 0 || s.timer !== undefined || s.running !== null));
+      if (busy.length === 0) return;
+      for (const [name, s] of busy) await (s.running ?? this.#flush(name));
+    }
+  }
+
   // The ward wrote one row. Its partition is saved once the line is free, and
   // once for every burst of writes, with every row named in that burst.
   #wrote(name: string, row: string): void {
@@ -418,14 +434,36 @@ export class Harbor {
     return bound?.held ? bound.reach.carry(pk, bytes) : undefined;
   }
 
+  // A hint, taken on the word of whoever gives it. A hint already standing
+  // for the pk is replaced, since a URL is the one part of a ward that moves;
+  // a reach proven at a door is never displaced by one.
   hint(pk: string, url: string): void {
-    if (this.reaches.has(pk)) return; // a reach proven at a door beats a hint, held or reached through a dialed line
-    this.reaches.set(pk, { reach: request(url), held: false });
+    const standing = this.reaches.get(pk);
+    if (standing && !hinted.has(standing.reach)) return; // a reach proven at a door beats a hint, held or reached through a dialed line
+    const reach = request(url);
+    hinted.add(reach);
+    this.reaches.set(pk, { reach, held: false });
   }
 
-  async remember(pk: string, url: string): Promise<void> {
+  // A hint kept only once the door behind it has proven it holds the pk's
+  // key, the same probe an announce is proven by. A URL that answers for
+  // another ward, or for nobody, is refused and nothing is kept: whoever
+  // hands a harbor a hint could otherwise point one ward's asks at a place
+  // that drops them. True is kept.
+  async learn(pk: string, url: string): Promise<boolean> {
+    const standing = this.reaches.get(pk);
+    if (standing && !hinted.has(standing.reach)) return true; // already reached, and proven at a door
+    const reach = request(url);
+    if (!(await this.prove(pk, reach))) return false;
     this.hint(pk, url);
-    await this.store.hint(pk, url);
+    return true;
+  }
+
+  // A hint put down. A reach proven at a door is the line's, and goes when
+  // the line does, never by a word from here.
+  forget(pk: string): void {
+    const standing = this.reaches.get(pk);
+    if (standing && hinted.has(standing.reach)) this.reaches.delete(pk);
   }
 
   // An announce is a claim, and a claim binds nothing until proven: anyone

package/src/harbor/store.ts

@@ -2,8 +2,7 @@
 // The store: keeping wards by name. A ward is three things and the store
 // keeps all three under one name: the seed, the partition and the ward
 // record, which says where the class bodies come from and which being is
-// the user's. Plus the directory's hints, which are the harbor's and
-// survive a restart. The store reads nothing it keeps; the partition is
+// the user's. The store reads nothing it keeps; the partition is
 // values the ward wrote, and the seed is bytes only the ward derives from.
 // Every terrain has one: files on a disk, IndexedDB in a tab, an object's
 // storage on the edge; the memory store below is the library's own, for a
@@ -32,8 +31,6 @@ export type Store = {
   record(name: string, record: WardRecord): Promise<void>;
   // Take a ward out: the first move of a migration. What was kept comes back.
   take(name: string): Promise<Kept | undefined>;
-  hints(): Promise<Record<string, string>>;
-  hint(pk: string, url: string): Promise<void>;
 };
 
 // The partition is values only, and the ward hands it out through a guard,
@@ -64,7 +61,6 @@ type Row = { seed: Uint8Array; parts: Map<string, Record<string, unknown>>; reco
 
 export class MemoryStore implements Store {
   readonly rows = new Map<string, Row>();
-  readonly reach = new Map<string, string>();
 
   async list(): Promise<string[]> {
     return [...this.rows.keys()];
@@ -92,10 +88,4 @@ export class MemoryStore implements Store {
     this.rows.delete(name);
     return kept;
   }
-  async hints(): Promise<Record<string, string>> {
-    return Object.fromEntries(this.reach);
-  }
-  async hint(pk: string, url: string): Promise<void> {
-    this.reach.set(pk, url);
-  }
 }