nervur 0.18.0 → 0.19.0

package/src/ward/index.ts

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
 // nervur/ward — one function. Every ward is the same ward.
 export { Ward } from './ward.ts';
-export type { Ground, WardPointers, Lend } from './ground.ts';
+export type { Ground, WardPointers, Memory } from './ground.ts';
+export { BOX, OFFER, RETRACT, volatile } from './ground.ts';
 export type { Partition, Heir, Bind, StandingKeys } from './partition.ts';
 // The three bounds on what a partition may hold, for a kit that must keep
 // the same ones and for a test that pins them.

package/src/ward/partition.ts

@@ -312,7 +312,7 @@ export const restoreRow = (p: Partition, row: string, value: Record<string, unkn
     drop(p.beings ?? {}, row);
     // Her bind goes with her: a being the store never kept has no relation
     // anybody is standing on, so there is nothing to leave forward.
-    drop((p.bind ?? {}) as unknown as Record<string, unknown>, row);
+    drop(p.bind ?? {}, row);
     return;
   }
   // Behind the guard and never through it: a being's cells in a partition
@@ -326,7 +326,7 @@ export const restoreRow = (p: Partition, row: string, value: Record<string, unkn
     for (const k of Object.keys(held)) drop(held, k);
     for (const [k, v] of Object.entries(kept)) put(held, k, v);
   };
-  into((p.beings ?? {}) as unknown as Record<string, unknown>, (value.cells ?? emptyCells()) as unknown as Record<string, unknown>);
+  into(p.beings ?? {}, (value.cells ?? emptyCells()) as unknown as Record<string, unknown>);
 };
 
 // The partition back from its rows. A head that is absent is a partition

package/src/ward/seal.ts

@@ -54,7 +54,7 @@ export const SIZE = 1024 * 1024;
 // designs and no separation at all: one secret would be doing two jobs with
 // nothing said about it, and a second kit would have to reproduce a
 // construction nobody named. HKDF-SHA-256 under a label is the separation
-// said out loud, and it is what `protocol/vectors/framing.json` pins.
+// said out loud, and it is what `quo/vectors/framing.json` pins.
 //
 // Bytes are key material and text is not. A seed handed in as bytes of the
 // key length is taken as it stands, which is what a harbor mints; anything

package/src/ward/stance.ts

@@ -41,7 +41,7 @@ export type Inside = {
 };
 
 // An invitation as it travels: the far ward's pk, the heir pk, the heir's secret seed. Or just the ward, for its public being.
-export type SealedInvitation = { ward: string; heir?: string; secret?: string };
+type SealedInvitation ={ ward: string; heir?: string; secret?: string };
 
 // The three calls on `standings` share the object with the ids she takes, so
 // a standing named after one of them would be unreachable: `standings.knock`

package/src/ward/ward.ts

@@ -5,9 +5,9 @@
 // a stance built by the same code. Mints every key, seals every ask that
 // leaves, opens every one that arrives.
 import { silence, isSilence, unreached, isWord, word } from '../being/silence.ts';
-import { OWNER } from '../being/types.ts';
-import type { Asker, BeingLike, Cells, JsonObject, Reply, Stance, Wanted, Word } from '../being/types.ts';
-import type { Ground, WardPointers } from './ground.ts';
+import { OWNER, isInvitation } from '../being/types.ts';
+import type { Asker, BeingLike, Cells, Invitation, JsonObject, Reply, Stance, Wanted, Word } from '../being/types.ts';
+import { BOX, OFFER, RETRACT, type Ground, type WardPointers } from './ground.ts';
 import { at, drop, open, put, emptyBind, emptyCells, HEAD, MINTED, type Bind, type Partition, type StandingKeys } from './partition.ts';
 import { Heirs } from './heirs.ts';
 import { makeDoor, type Door } from './door.ts';
@@ -41,15 +41,48 @@ class Self implements BeingLike {
   readonly door: WardPointers['door'];
   readonly ask: WardPointers['ask'];
 
+  // Birth, in order: the ward as its own first being, the box taken, and
+  // only then every being the partition names constructed again. A being
+  // who takes what her box lends does it at her birth, so the box must be
+  // hers to ask before she is born, or a restart would be the one birth at
+  // which the device lends nothing.
   static async boot(ground: Ground): Promise<Self> {
-    return new Self(ground, await wardKey(ground.seed));
+    const w = new Self(ground, await wardKey(ground.seed));
+    await w.#takeBox();
+    w.#reborn();
+    return w;
+  }
+
+  // The device, taken as one standing under `BOX` by the ward's own being,
+  // once: a ward woken from its partition already holds it. A knock that is
+  // not answered leaves the ward up and lending nothing this run.
+  async #takeBox(): Promise<void> {
+    const inv = this.g.box;
+    const mine = this.doors.get(this.pk)?.stance;
+    if (!inv || !mine || mine.standings[BOX]) return;
+    const out = await mine.standings.knock(inv);
+    if (isSilence(out) || isWord(out)) return;
+    await mine.standings.take(BOX, inv);
+  }
+
+  // What this device lends this ward's beings: the box's being, asked to
+  // offer a name, answers the lent being's own invitation, and the taker knocks
+  // and takes it. The ward reads nothing in the value but that it is one.
+  async #lend(name: string, take: (inv: Invitation) => Promise<boolean>): Promise<boolean> {
+    const box = this.doors.get(this.pk)?.stance.standings[BOX];
+    if (!box) return false;
+    const inv = await box.ask(OFFER, { name });
+    if (!isInvitation(inv)) return false;
+    const took = await take(inv);
+    if (!took) await box.ask(RETRACT, { name, heir: inv.heir ?? null });
+    return took;
   }
 
   private constructor(ground: Ground, key: WardKey) {
     this.g = ground;
     this.key = key;
     this.pk = key.pk;
-    this.p = open(ground.memory); // the partition: the ward's own state, and every being's row
+    this.p = open(ground.memory.rows); // the partition: the ward's own state, and every being's row
     // Opening is itself a write: a memory nobody has written comes back with
     // a version stamped on it and the ward's own tables under it. A ward that
     // said nothing here would have every being of it kept and the head that
@@ -66,6 +99,23 @@ class Self implements BeingLike {
       () => this.#keep(),
     ); // pointer one
     this.#boot(this.pk, () => this); // the ward's ward is itself
+    // pointer two. the owner. the same answer every named asker gets, asker filled in as owner.
+    this.ask = async (method, args = {}) => {
+      try {
+        const out = await this.answer({ id: OWNER }, method, args as JsonObject);
+        // The same question the door asks, in the same place: after she has
+        // answered and before the owner holds the answer. Silence is what a
+        // failed ask says here, so a store that refused is silence, and the
+        // owner reads it as it reads every other ask that did not take.
+        if (!(await this.#keep().catch(() => false))) return silence;
+        return isSilence(out) || isWord(out) ? silence : out;
+      } catch {
+        return silence;
+      }
+    };
+  }
+
+  #reborn(): void {
     // a restart is silent: every being in the cells is constructed again, unasked.
     // A throw on a boot the owner asked for is that boot's error, and nothing
     // half-lives. This boot nobody asked for, and there is nobody to hand an
@@ -85,20 +135,6 @@ class Self implements BeingLike {
         /* she is not here this run. the ward is, and so is everyone else. */
       }
     }
-    // pointer two. the owner. the same answer every named asker gets, asker filled in as owner.
-    this.ask = async (method, args = {}) => {
-      try {
-        const out = await this.answer({ id: OWNER }, method, args as JsonObject);
-        // The same question the door asks, in the same place: after she has
-        // answered and before the owner holds the answer. Silence is what a
-        // failed ask says here, so a store that refused is silence, and the
-        // owner reads it as it reads every other ask that did not take.
-        if (!(await this.#keep().catch(() => false))) return silence;
-        return isSilence(out) || isWord(out) ? silence : out;
-      } catch {
-        return silence;
-      }
-    };
   }
 
   // ---- the ward as a being. asked only by its owners: the root, through
@@ -138,7 +174,7 @@ class Self implements BeingLike {
   // because a harbor told only that something moved must keep all of it, and
   // a being's row is the one part of a partition that grows without limit.
   #wrote(row: string): void {
-    this.g.wrote?.(row);
+    this.g.memory.told(row);
   }
 
   // Whether what was written is kept, asked once at the end of an arrival
@@ -146,7 +182,7 @@ class Self implements BeingLike {
   // refuse anything, so its silence here is yes: a ward driven with no store
   // under it answers exactly as it did before a harbor could say no.
   async #keep(): Promise<boolean> {
-    return this.g.keep ? await this.g.keep() : true;
+    return this.g.memory.kept();
   }
 
   // The rows no door holds this run: beings whose class threw at birth or
@@ -249,11 +285,7 @@ class Self implements BeingLike {
         // never came about takes her out again.
         relate: async (k, id) => (await this.doors.get(k)?.stance.occupants.invite(id)) ?? null,
         unmake: (k) => void this.#unboot(k),
-        // What this device lends this ward's beings. The ward knocks and takes
-        // inside the harbor's own call and reads nothing in the value: which
-        // names there are, which ward may ask for one, and what becomes of one
-        // she did not take, is the harbor's and no word of the ward.
-        lend: async (name, take) => (await this.g.lend?.(name, take)) ?? false,
+        lend: (name, take) => this.#lend(name, take),
         wrote: () => this.#wrote(key),
       },
       key,
@@ -294,7 +326,7 @@ class Self implements BeingLike {
     // the reply opens, and whatever the being writes on either side of her
     // own ask. A harbor may write those rows down; what it may not do is put
     // the ward back to them.
-    const lower = this.g.calling?.();
+    const lower = this.g.memory.during();
     try {
       return await this.#sent(bind, keys, method, args, wanted, row);
     } finally {