nervur 0.19.2 → 0.20.0

package/src/harbor/dial.ts

@@ -1,112 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// A harbor as a dialer: one held socket to a listener's URL, its own
-// pks announced, the listener's bound, and a reconnect with backoff from a
-// second to thirty when the line drops. Seed, partition and keys are here;
-// only the reach comes and goes. While the socket is open it is also the
-// harbor's fallback: a pk nobody here knows is sent to the listener, which
-// is the rendezvous, and it is the fallback from the moment it is dialed,
-// because a ward asks the instant it boots and a socket's carry waits for
-// the handshake itself. Terrain-free: a daemon on a Mac and a tab dial alike,
-// on the WebSocket every terrain has.
-import type { Harbor } from './core.ts';
-import { REFUSED, Socket, type Line } from './reach.ts';
-
-// `wake` is the device saying it is back: a phone out of a pocket, a
-// laptop's lid opened. A device that slept comes back with its timer frozen
-// and, often, its socket closed under it by the system without a word. So
-// nothing in hand is trusted: whatever line there is, open or still opening,
-// is put down and a new one is dialed now.
-//
-// Nothing here can tell a line the system dropped from a live one, and
-// asking is worse than dialing. An announce written into a dead line is
-// taken into the send buffer and the error comes when TCP gives up
-// retransmitting, one to two minutes on a Mac and up to fifteen on Linux,
-// and for all of it every ask to a pk bound behind that line hears `late`.
-// A probe with a bound would want a round trip the wire does not have: four
-// words, none of them a ping, and making one out of an ask would give a
-// second kit's listener a meaning to reproduce. Dialing costs one handshake
-// when the line was fine, and an ask made meanwhile waits on the new socket
-// rather than being lost, because a socket is a fallback from the moment it
-// is dialed.
-export type Dialer = { url: string; socket: Socket | null; wake(): void; close(): void };
-
-export function dial(harbor: Harbor, url: string): Dialer {
-  const d: Dialer = { url, socket: null, wake: () => {}, close: () => {} };
-  let stopped = false,
-    wait = 1000,
-    timer: ReturnType<typeof setTimeout> | undefined,
-    line: Line | undefined, // the line in hand, open or still opening: close() closes it either way
-    held: { socket: Socket; shed: () => void } | undefined; // the one this dialer owns now, and how it gives back what the line took
-  const connect = () => {
-    timer = undefined; // no wait pending: this is the dial it was waiting for
-    if (stopped) return;
-    line = new WebSocket(url.replace(/\/$/, '').replace(/^http/, 'ws')) as unknown as Line;
-    const s: Socket = new Socket(
-      line,
-      (pk, bytes) => harbor.deliver(pk, bytes),
-      (far) => {
-        // A line that opened is not a line that works. The wait goes back to
-        // a second here, where the far side has answered and been taken, and
-        // not at the handshake: a listener that opens and then refuses every
-        // time would otherwise be dialed at a fixed two seconds for good.
-        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) => {
-        shed();
-        // A line this dialer already put down. Its close arrives whenever the
-        // system gets round to noticing, which on a socket that died under a
-        // sleeping device is minutes; by then the line dialed in its place is
-        // the one in hand, so this one gives back what it took and dials
-        // nothing. Only the line the dialer still holds dials again.
-        if (held?.socket !== s) return;
-        held = undefined;
-        // A suite this listener will not speak is not a line that dropped. It
-        // will not become speakable by asking again sooner, so the wait goes
-        // straight to the ceiling and stays there until it changes its mind.
-        if (why.code === REFUSED) wait = 30000;
-        if (!stopped) timer = setTimeout(connect, wait);
-        wait = Math.min(wait * 2, 30000);
-      },
-    );
-    // Everything this line took from the harbor, given back. Said when it
-    // closes, and when the dialer puts it down without waiting for that.
-    const shed = () => {
-      harbor.announcers.delete(say);
-      harbor.unbind(s);
-      if (d.socket === s) d.socket = null;
-      const at = harbor.fallbacks.indexOf(s);
-      if (at !== -1) harbor.fallbacks.splice(at, 1); // this line only: another dialer's stays
-    };
-    held = { socket: s, shed };
-    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', () => {
-      if (stopped) return s.close(); // closed while it was opening: it opens into nothing
-      d.socket = s;
-      harbor.announcers.add(say);
-      say();
-    });
-  };
-  d.wake = () => {
-    if (stopped) return;
-    clearTimeout(timer);
-    timer = undefined;
-    wait = 1000; // the device is back, and the wait it froze belongs to the sleep, not to this line
-    const old = held;
-    held = undefined; // put down before the new one is dialed, so a fallback list never holds the dead line ahead of the live one
-    old?.shed();
-    old?.socket.close();
-    connect();
-  };
-  d.close = () => {
-    stopped = true;
-    clearTimeout(timer);
-    line?.close(); // open or opening: a line closed while connecting fires close and never open
-  };
-  connect();
-  return d;
-}

package/src/harbor/memory.ts

@@ -1,123 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// A memory harbor. One process, no wire. Owns what a device owns: the code
-// half, the memory half, the routing. Boots a ward by passing ONE object and
-// keeping TWO pointers. Routes one ward pk to one door. Knows no being,
-// reads no partition, opens no byte. Several memory harbors may be linked,
-// which stands in for a wire, and cut, which stands in for weather.
-//
-// It works in acts, as every harbor does. `up` is act one: the box's own
-// ward on the plain ground, the box's being and the lent beings in it.
-// `host` is act two for one ward: on the roll, and handed one invitation
-// on the box's being. A
-// ward booted with `boot` alone is handed no box and lends nothing, which is
-// what a suite of the ward wants.
-import type { BeingClass, BeingLike, Invitation } from '../being/types.ts';
-import { maker, entropy, learnPk, volatile, type Ground, type WardPointers } from '../ward/ground.ts';
-import { hex } from '../ward/arithmetic.ts';
-import { Box, BOX_SEED, stand, offerTo, roll } from './box.ts';
-
-export type Booted = WardPointers & { pk: string };
-export type WardFactory = (ground: Ground) => Promise<WardPointers>;
-
-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
-  readonly wards = new Map<string, Booted>(); // seed -> pointers
-  readonly objects = new WeakMap<object, BeingLike>(); // cells -> being object. what instantiate constructed. a hand for tests, never the ward's; it follows the cells out when she is unbooted
-  // Where the wards this harbor boots draw their entropy. The device's own
-  // by default. A harbor may hand a fixed stream instead, which is what pins
-  // bytes: every key a ward mints and every nonce it seals under comes from
-  // here, so a ward on a known seed with a known stream answers the same
-  // bytes every run, and a corpus of them is a corpus and not a sample.
-  random: Ground['random'] = entropy;
-
-  // the directory: its own doors, else a peer it is linked to. Quo says nothing about how.
-  async route(farPk: string, bytes: Uint8Array): Promise<Uint8Array | undefined> {
-    if (this.down.has(farPk)) return undefined;
-    const door = this.doors.get(farPk);
-    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);
-  }
-
-  link(harbor: MemoryHarbor): void {
-    this.peers.add(harbor);
-    harbor.peers.add(this);
-  }
-
-  // boot by seed. the harbor gets a door and an ask, and learns the pk by
-  // asking. `box` is the invitation on this device's box being, for this
-  // ward: left out, the ward holds no box and every lend is null.
-  async boot(seed: string, Ward: WardFactory, classes: Record<string, BeingClass>, box?: Invitation): Promise<Booted> {
-    this.partitions.set(seed, {});
-    return this.reboot(seed, Ward, classes, box);
-  }
-
-  // a restart: same seed, same partition, fresh ward. the ward's files are the harbor's to keep.
-  async reboot(seed: string, Ward: WardFactory, classes: Record<string, BeingClass>, box?: Invitation): Promise<Booted> {
-    const rows = this.partitions.get(seed);
-    if (!rows) throw new Error(`no partition for ${seed}`);
-    const ground: Ground = {
-      seed,
-      memory: volatile(rows),
-      ...(box ? { box } : {}),
-      // One objects map for the whole harbor, not one per ward: every ward
-      // here is in this process and a test reaches any being of any of them.
-      instantiate: maker(this.objects, classes),
-      // bytes cross, copied, never a reference. both ways.
-      carry: async (farPk, bytes) => {
-        this.wire.push(hex(bytes));
-        const back = await this.route(farPk, new Uint8Array(bytes));
-        return back === undefined ? undefined : new Uint8Array(back);
-      },
-      random: (n) => this.random(n),
-    };
-    const w = await Ward(ground);
-    const booted: Booted = { ...w, pk: await learnPk(w) };
-    this.doors.set(booted.pk, booted.door);
-    this.wards.set(seed, booted);
-    return booted;
-  }
-
-  // Act one. The box's own ward, the box's being and the lent beings named,
-  // each booted under its name and held by her under it. Run again on a
-  // harbor whose box ward stands, it changes nothing.
-  async up(Ward: WardFactory, lent: Record<string, BeingClass> = {}): Promise<Booted> {
-    const classes: Record<string, BeingClass> = { Box };
-    for (const C of Object.values(lent)) classes[C.name] = C;
-    const box = this.wards.get(BOX_SEED) ?? (await this.boot(BOX_SEED, Ward, classes));
-    await stand(box, lent);
-    return box;
-  }
-
-  get box(): Booted | undefined {
-    return this.wards.get(BOX_SEED);
-  }
-
-  // Act two, one ward: on the roll and handed one invitation on the box's being.
-  // A harbor with no box ward up hosts as `boot` does, with nothing.
-  async host(seed: string, Ward: WardFactory, classes: Record<string, BeingClass>): Promise<Booted> {
-    const box = this.box;
-    const inv = box ? await offerTo(box, seed) : undefined;
-    return this.partitions.has(seed) ? this.reboot(seed, Ward, classes, inv) : this.boot(seed, Ward, classes, inv);
-  }
-
-  // Act two, whole: the box's being says who is hosted, and each comes up.
-  async hosted(Ward: WardFactory, classes: Record<string, BeingClass>): Promise<string[]> {
-    const box = this.box;
-    if (!box) return [];
-    const seeds = await roll(box);
-    for (const seed of seeds) await this.host(seed, Ward, classes);
-    return seeds;
-  }
-}

package/src/harbor/reach.ts

@@ -1,221 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Reach: carrying bytes to a pk off the device. One interface, two
-// implementations:
-//
-//   request   a URL. POST the bytes to `<url>/<pk>`, get bytes back.
-//             Listener to listener.
-//   socket    a held WebSocket at `<url>`, opened by whichever side can
-//             dial, used in both directions with a frame id. Each side
-//             announces the ward pks it holds when the socket opens, and the
-//             other binds them.
-//
-// Both are written on what every terrain has: fetch, and the standard
-// WebSocket surface, which a browser, Node, an edge worker's pair and the
-// `ws` server all offer. The listener half of a socket is the terrain's
-// own and stays outside this tree; what is here is the framing, either end
-// of a line, and the request. Nothing here names a runtime, and
-// `src/conformance/reach.ts` is what every reach passes. A reach carries and returns; it reads
-// nothing. `undefined` is a promise that nothing was delivered: no such pk
-// at the far end, a connection that would not open, a socket that is gone.
-// A reach that sent the bytes and lost the line afterwards answers nothing
-// at all, and the ward's own bound ends the ask.
-import { concat, hex, unhex } from '../ward/arithmetic.ts';
-import { readJson } from '../ward/json.ts';
-
-export type Carry = (pk: string, bytes: Uint8Array) => Promise<Uint8Array | undefined>;
-export type Reach = { carry: Carry; close(): void };
-
-const never = () => new Promise<undefined>(() => {}); // sent, and no word since: the ward's bound decides
-
-// A request reach to one listener.
-export function request(url: string): Reach {
-  const base = url.replace(/\/$/, '');
-  return {
-    close: () => {},
-    carry: async (pk, bytes) => {
-      let res: Response;
-      // A body of its own, not the caller's view: fetch reads it after this
-      // line returns, and a buffer somebody else may write is not a body. The
-      // copy is its own ArrayBuffer, which is what a body is; the bytes handed
-      // in are typed as backed by anything, shared memory included.
-      const body = new Uint8Array(bytes.length);
-      body.set(bytes);
-      try {
-        res = await fetch(`${base}/${pk}`, { method: 'POST', headers: { 'content-type': 'application/octet-stream', 'quo-suite': String(SUITE) }, body });
-      } catch {
-        return undefined; // the connection never opened: nothing was delivered
-      }
-      // A status that says the listener did not take the bytes is nothing
-      // delivered: no reach for that pk, a request it refused on its face, a
-      // gateway with nobody behind it. Any other failure is a listener that
-      // took them and failed after, which is sent and no word since.
-      if (res.status === 404 || (res.status >= 400 && res.status < 500) || res.status === 502 || res.status === 503 || res.status === 504) return undefined;
-      if (!res.ok) return never();
-      return new Uint8Array(await res.arrayBuffer());
-    },
-  };
-}
-
-// The frames on a socket. Binary, one byte of kind first.
-//   ask    [0][id: 4 bytes][pk: 64 bytes][bytes]
-//   reply  [1][id: 4 bytes][bytes]
-//   none   [2][id: 4 bytes]                    nothing was delivered
-// And one text frame, JSON: { announce: [pk, ...], suite }, the ward pks this
-// side holds and the wire suite it speaks, sent when the socket opens and
-// whenever the pks change.
-const ASK = 0,
-  REPLY = 1,
-  NONE = 2;
-
-// The wire suite: which frames these are and which five algorithms seal what
-// they carry. One value, and it is not negotiated. It rides in the handshake
-// and never on an ask, so an ask stays bytes nobody can tell from noise, and
-// a line still learns before it carries anything whether the far side speaks
-// what this side speaks. A side meeting a suite it does not know carries
-// nothing for it and closes: the alternative is bytes that will never open,
-// answered by a silence that says nothing about why, forever. Nothing
-// changes this number before 1.0.0. After it, this is the one place a second
-// suite can be told from a first without guessing.
-export const SUITE = 1;
-
-// The close a side sends when it refuses a suite, in the range a protocol
-// may spend on itself. A line that just closes tells the far side nothing,
-// and a dialer that learns nothing dials again on its backoff for good: the
-// whole reason this number exists is that a kit which cannot be understood
-// should be told so instead of meeting a silence that names no reason. So
-// the refusal names itself on the way out, and the far side may read it.
-export const REFUSED = 4001;
-const OPEN = 1; // WebSocket.OPEN, on every terrain
-// How many asks a socket keeps a resolver for. An ask the far side never
-// answers is ended by the ward's bound, and its resolver stays until the
-// line closes; a far side that answers nothing for long enough would grow
-// the map for as long as this side asks, so the oldest goes when it is full.
-const PENDING = 4096;
-
-// The standard surface, and no more of it: what a browser WebSocket, Node's
-// WebSocket and a `ws` server socket all have.
-export type Line = {
-  readyState: number;
-  binaryType: string;
-  send(data: string | Uint8Array): void;
-  close(code?: number, reason?: string): void;
-  addEventListener(type: 'open' | 'error', fn: () => void): void;
-  // A close carries why, where the terrain gives it: the code and the reason
-  // the far side named. A line that just ends names neither.
-  addEventListener(type: 'close', fn: (e?: { code?: number; reason?: string }) => void): void;
-  addEventListener(type: 'message', fn: (e: { data: unknown }) => void): void;
-};
-
-export type Announce = (pks: string[]) => void;
-
-// One held socket, either side of it. `deliver` is what this side does with
-// an ask that arrives for a pk: its own door, or a socket it holds for that
-// pk, and nothing else. `onAnnounce` learns the far side's pks; `onClose`
-// forgets them.
-export class Socket implements Reach {
-  readonly line: Line;
-  readonly pending = new Map<number, (bytes: Uint8Array | undefined) => void>();
-  far: string[] = []; // the pks the far side announced
-  #id = 1;
-  #open: Promise<void>;
-
-  constructor(line: Line, deliver: Carry, onAnnounce: Announce, onClose: (why: { code?: number; reason?: string }) => void) {
-    this.line = line;
-    line.binaryType = 'arraybuffer';
-    // A line that opens is a reach; one that errors, or closes before it
-    // opened, is a reach that failed, and an ask waiting on the handshake is
-    // nothing delivered.
-    this.#open =
-      line.readyState === OPEN
-        ? Promise.resolve()
-        : new Promise((ok, no) => {
-            line.addEventListener('open', ok);
-            line.addEventListener('error', no);
-            line.addEventListener('close', () => no(new Error('closed before it opened')));
-          });
-    this.#open.catch(() => {}); // a handshake refused is a reach that failed, not a process that dies
-    line.addEventListener('message', (e) => {
-      if (typeof e.data === 'string') {
-        try {
-          const m = readJson(e.data) as { announce?: unknown; suite?: unknown };
-          if (m === null || typeof m !== 'object') return;
-          // Absent is this suite: a side that says nothing says one.
-          if (m.suite !== undefined && m.suite !== SUITE) {
-            this.far = [];
-            line.close(REFUSED, 'suite');
-            return;
-          }
-          if (Array.isArray(m.announce)) {
-            this.far = m.announce.filter((x): x is string => typeof x === 'string');
-            onAnnounce(this.far);
-          }
-        } catch {
-          /* not for us */
-        }
-        return;
-      }
-      const buf = e.data instanceof ArrayBuffer ? new Uint8Array(e.data) : ArrayBuffer.isView(e.data) ? new Uint8Array(e.data.buffer, e.data.byteOffset, e.data.byteLength) : undefined;
-      // A frame that is none of the three is not a frame: an unknown kind, an
-      // ask too short to hold a pk, a nothing with bytes after its id. It is
-      // dropped, and tells no ask waiting on its id that nothing was delivered.
-      if (!buf || buf.length < 5) return;
-      const kind = buf[0],
-        id = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(1);
-      if (kind > NONE || (kind === ASK && buf.length < 69) || (kind === NONE && buf.length !== 5)) return;
-      if (kind === ASK) {
-        const pk = hex(buf.subarray(5, 69));
-        // A deliver that rejects has delivered nothing this side can vouch
-        // for, and a listener does not die of it: the far side hears none.
-        void deliver(pk, new Uint8Array(buf.subarray(69)))
-          .then(
-            (back) => back,
-            () => undefined,
-          )
-          .then((back) => {
-            const head = new Uint8Array(5);
-            head[0] = back === undefined ? NONE : REPLY;
-            new DataView(head.buffer).setUint32(1, id);
-            if (line.readyState === OPEN) line.send(back === undefined ? head : concat([head, back]));
-          });
-        return;
-      }
-      const waiting = this.pending.get(id);
-      if (!waiting) return;
-      this.pending.delete(id);
-      waiting(kind === REPLY ? new Uint8Array(buf.subarray(5)) : undefined);
-    });
-    line.addEventListener('error', () => {});
-    line.addEventListener('close', (e) => {
-      this.pending.clear(); // in flight and no word since: nothing is answered
-      onClose({ code: e?.code, reason: e?.reason });
-    });
-  }
-
-  // Say which ward pks this side holds.
-  announce(pks: string[]): void {
-    if (this.line.readyState === OPEN) this.line.send(JSON.stringify({ announce: pks, suite: SUITE }));
-  }
-
-  async carry(pk: string, bytes: Uint8Array): Promise<Uint8Array | undefined> {
-    try {
-      await this.#open;
-    } catch {
-      return undefined;
-    }
-    if (this.line.readyState !== OPEN) return undefined;
-    const id = this.#id++;
-    const head = new Uint8Array(69);
-    head[0] = ASK;
-    new DataView(head.buffer).setUint32(1, id);
-    head.set(unhex(pk), 5);
-    return new Promise((ok) => {
-      if (this.pending.size >= PENDING) this.pending.delete(this.pending.keys().next().value!); // the oldest, which the ward's bound ended long ago
-      this.pending.set(id, ok);
-      this.line.send(concat([head, bytes]));
-    });
-  }
-
-  close(): void {
-    this.line.close();
-  }
-}

package/src/harbor/store.ts

@@ -1,91 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// 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. 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
-// harbor core with no device under it. `src/conformance/store.ts` is what
-// every one of them passes.
-import { fromRows, rowOf, rowsIn, type Partition } from '../ward/partition.ts';
-
-export type WardRecord = { pk: string; code: string; user: string };
-export type Kept = { seed: Uint8Array; partition: Record<string, unknown>; record: WardRecord };
-
-export type Store = {
-  list(): Promise<string[]>;
-  load(name: string): Promise<Kept | undefined>;
-  // Keep all three under the name; a name already kept is refused.
-  put(name: string, kept: Kept): Promise<void>;
-  // The partition back, after a call; the record back, after a boot learned
-  // the pk. A name not kept is nothing, on both.
-  //
-  // `rows` names what the ward wrote since the last save: a being by her key,
-  // or `HEAD`. A store may write only those, which is what `rowsOf` is for,
-  // and a store that writes the whole partition every time is correct and
-  // slower. A being's cells are the one part of a partition that grows
-  // without limit, so a store that keeps her apart lets her neighbour be
-  // asked without her being written down again.
-  save(name: string, partition: Record<string, unknown>, rows: readonly string[]): Promise<void>;
-  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>;
-};
-
-// The partition is values only, and the ward hands it out through a guard,
-// so a store takes a copy of the values the way a file would: through JSON.
-export const values = (p: Record<string, unknown>): Record<string, unknown> => JSON.parse(JSON.stringify(p)) as Record<string, unknown>;
-
-// The rows a store was told about, as values, ready to be written down. A row
-// whose key names nobody is a being who left, and comes back undefined, which
-// is the store dropping what it holds for her.
-export const rowsOf = (partition: Record<string, unknown>, rows: readonly string[]): [string, Record<string, unknown> | undefined][] =>
-  rows.map((row) => {
-    const value = rowOf(partition as unknown as Partition, row);
-    return [row, value === undefined ? undefined : (values(value))];
-  });
-
-// One store's copy, brought up to date with the rows it was told about.
-const keep = (row: Row, partition: Record<string, unknown>, rows: readonly string[]): void => {
-  for (const [id, value] of rowsOf(partition, rows)) {
-    if (value === undefined) row.parts.delete(id);
-    else row.parts.set(id, value);
-  }
-};
-
-// The store as a map, one process, nothing kept past it. It keeps a ward as
-// rows, the way a store on a device does, so what it costs to save is what a
-// device pays and the library's own measurements mean something.
-type Row = { seed: Uint8Array; parts: Map<string, Record<string, unknown>>; record: WardRecord };
-
-export class MemoryStore implements Store {
-  readonly rows = new Map<string, Row>();
-
-  async list(): Promise<string[]> {
-    return [...this.rows.keys()];
-  }
-  async load(name: string): Promise<Kept | undefined> {
-    const row = this.rows.get(name);
-    return row && { seed: new Uint8Array(row.seed), partition: fromRows(Object.fromEntries(row.parts)), record: { ...row.record } };
-  }
-  async put(name: string, kept: Kept): Promise<void> {
-    if (this.rows.has(name)) throw new Error(`ward ${name} already exists here`);
-    const row: Row = { seed: new Uint8Array(kept.seed), parts: new Map(), record: { ...kept.record } };
-    this.rows.set(name, row);
-    keep(row, kept.partition, rowsIn(kept.partition));
-  }
-  async save(name: string, partition: Record<string, unknown>, rows: readonly string[]): Promise<void> {
-    const row = this.rows.get(name);
-    if (row) keep(row, partition, rows);
-  }
-  async record(name: string, record: WardRecord): Promise<void> {
-    const row = this.rows.get(name);
-    if (row) row.record = { ...record };
-  }
-  async take(name: string): Promise<Kept | undefined> {
-    const kept = await this.load(name);
-    this.rows.delete(name);
-    return kept;
-  }
-}