@quo-systems/quo 0.2.10 → 0.2.12

package/src/ward/heirs.ts

@@ -40,9 +40,6 @@ export class Heirs {
     const g = this.#p.gone[heir];
     return !!g && (by === g.current || by === g.announced);
   }
-  get(heir: string): Heir | undefined {
-    return this.#p.heirs[heir];
-  }
   // May `by` speak for this heir? Returns the record if so, null if not.
   // Does not write: the caller verifies the signature first, then settles.
   admits(heir: string, by: string): Heir | null {
@@ -82,28 +79,30 @@ export class Heirs {
   // neither: a call that binds nothing must not burn a number on its way to
   // being refused, or a stranger who cannot be heard would still leave a mark
   // behind her. Every write below this line is one that is going to hold.
+  // This is where a knock is judged and where `unannounced` is said. settle
+  // below is the writing alone, and it judges nothing: one owner for the
+  // question, one for the answer.
   honour(h: Heir, by: string, next: string | null, seq: number): true | DoorWord {
     if (h.fresh && (next === null || next === h.current)) return 'unannounced'; // a knock without a key of her own binds nothing, and the heir is not a key of her own
     if (!this.spend(h, seq)) return 'repeated';
-    const settled = this.settle(h, by, next);
-    this.#wrote(); // the number is spent whether or not the keys settled
-    return settled ? true : 'unannounced';
+    this.settle(h, by, next);
+    this.#wrote(); // the number and the keys moved together
+    return true;
   }
 
-  // The signature checked out. Settle the keys: a fresh heir rotates at once
-  // to what it announced and must announce something that is not itself, so
-  // that the heir dies as it speaks; a current key replaces its
-  // announcement; an announced key becomes current.
-  settle(h: Heir, by: string, next: string | null): boolean {
+  // The signature checked out and honour has judged. Settle the keys: a fresh
+  // heir rotates at once to what it announced, which honour has already held
+  // to being something other than itself, so that the heir dies as it speaks;
+  // a current key replaces its announcement; an announced key becomes current.
+  settle(h: Heir, by: string, next: string | null): void {
     if (h.fresh) {
-      if (next === null || next === h.current) return false;
+      if (next === null) return; // honour judged this. the compiler has not read it, so the narrowing stays.
       h.current = next;
       h.announced = null;
       h.fresh = false;
-      return true;
+      return;
     }
     if (by === h.announced) h.current = by;
     h.announced = next;
-    return true;
   }
 }

package/src/ward/index.ts

@@ -3,6 +3,9 @@
 export { Ward } from './ward.ts';
 export type { Ground, WardPointers } from './ground.ts';
 export type { Partition, Heir, Bind, StandingKeys } from './partition.ts';
+// The two bounds on what a partition may hold, for a kit that must keep the
+// same ones and for a test that pins them.
+export { GONE, MINTED } from './partition.ts';
 export type { AskPayload, ReplyPayload } from './seal.ts';
 // The seal and the arithmetic, for a kit in another language to check its
 // bytes against, and for tests that speak to a door directly.

package/src/ward/owner.ts

@@ -13,22 +13,24 @@ import { OWNER } from '../being/types.ts';
 import type { Ask, Asker, Invitation, Json, JsonObject, Wanted } from '../being/types.ts';
 import { put } from './partition.ts';
 import { seen } from './door.ts';
-import type { Booted } from './ward.ts';
+import { within, DEFAULT, LATE } from './allowance.ts';
+import type { Resident } from './ward.ts';
 
 export type OwnerSide = {
   pk: string;
-  doors: Map<string, Booted>;
+  doors: Map<string, Resident>;
   absent(): Record<string, string | null>; // the rows no door holds this run: key to class
   publicKey(): string | null;
-  instantiate(key: string, className: string): Booted | 'threw' | null;
+  // Class first, then key, as the ground and a being's own boot both say it.
+  instantiate(className: string, key: string): Resident | 'threw' | null;
   unboot(key: string): string[] | null;
-  setPublic(key: string): void;
+  setPublic(key: string | null): void; // null takes the mark off, and the being stays
 };
 
 const str = { type: 'string' };
 export const OWNER_ASKS: Ask[] = [
   { name: 'boot', description: 'boot a being by class name, under a key the owner chooses', input: { type: 'object', properties: { key: str, class: str }, required: ['key', 'class'] } },
-  { name: 'public', description: 'mark a booted being as the one public being of the ward, reached by anyone at the bare pk', input: { type: 'object', properties: { key: str }, required: ['key'] } },
+  { name: 'public', description: 'mark a booted being as the one public being of the ward, reached by anyone at the bare pk; null takes the mark off and leaves her booted', input: { type: 'object', properties: { key: str }, required: ['key'] } },
   { name: 'invite', description: 'mint an invitation on a being of the ward, under the id she will know the occupant by, with the notes she will read on it; on the ward pk it mints an owner, and only the root may', input: { type: 'object', properties: { being: str, id: str, notes: { type: 'object' } }, required: ['being', 'id'] } },
   {
     name: 'knock',
@@ -40,17 +42,19 @@ export const OWNER_ASKS: Ask[] = [
 ];
 
 export async function ownerAnswer(w: OwnerSide, asker: Asker, method: string | undefined, args: JsonObject): Promise<Json> {
-  // Every name the owner gives is a word. Coerced instead of checked, an
-  // object passed where a name belongs becomes the string "[object Object]",
-  // and two owners who each got the shape wrong would be handed one being.
-  const word = (v: unknown): string | null => (typeof v === 'string' ? v : null);
+  // Every name the owner gives is a string, or it is nothing. Coerced instead
+  // of checked, an object passed where a name belongs becomes the string
+  // "[object Object]", and two owners who each got the shape wrong would be
+  // handed one being. Not `word`: a word in this tree is what a ward says when
+  // no object came back, and this file imports those.
+  const named = (v: unknown): string | null => (typeof v === 'string' ? v : null);
 
   if (method === undefined) return describe(w);
   if (method === 'boot') {
-    const key = word(args.key),
-      className = word(args.class);
+    const key = named(args.key),
+      className = named(args.class);
     if (key === null || className === null) return { error: 'no such class, or key taken' };
-    const door = w.instantiate(key, className);
+    const door = w.instantiate(className, key);
     if (door === 'threw') return { error: 'threw at birth' };
     return door ? { booted: door.key } : { error: 'no such class, or key taken' };
   }
@@ -59,7 +63,14 @@ export async function ownerAnswer(w: OwnerSide, asker: Asker, method: string | u
     // leave the first holding every relation she had, reachable by nobody at
     // the bare pk, and told by nobody that she had been replaced. One absent
     // this run is reachable by nobody already, so the mark may move off her.
-    const key = word(args.key);
+    // Null takes the mark off: the being stays and keeps every relation she
+    // holds, and the ward answers arrivals for no heir with silence, as one
+    // that never had a public being does. Retiring her is not destroying her.
+    if (args.key === null) {
+      w.setPublic(null);
+      return { public: null };
+    }
+    const key = named(args.key);
     if (key === null || key === w.pk || !w.doors.has(key)) return { error: 'no such being' };
     const standing = w.publicKey();
     if (standing !== null && standing !== key && w.doors.has(standing)) return { error: 'a ward has one public being' };
@@ -71,8 +82,8 @@ export async function ownerAnswer(w: OwnerSide, asker: Asker, method: string | u
     // is an owner, and ownership is minted by the ask pointer alone. An owner
     // at the door asking to invite on the ward is refused, so that a carried
     // key can pilot but never hand piloting on.
-    const being = word(args.being),
-      id = word(args.id);
+    const being = named(args.being),
+      id = named(args.id);
     if (being === null || id === null) return { error: 'no such being' };
     if (being === w.pk && asker.id !== OWNER) return { error: 'no such being' };
     // The notes are the terms the owner mints under, and the being reads them
@@ -89,14 +100,16 @@ export async function ownerAnswer(w: OwnerSide, asker: Asker, method: string | u
     if (!door && b && typeof b === 'object') {
       // new or existing: the owner names a being of theirs, and a key already
       // booted is a being of theirs, not a class that failed to instantiate.
-      const key = word(b.key),
-        className = word(b.boot);
+      const key = named(b.key),
+        className = named(b.boot);
       if (key === null || className === null) return { error: 'no such being' };
-      const made = w.instantiate(key, className);
+      const made = w.instantiate(className, key);
       if (made === 'threw') return { error: 'threw at birth' };
-      door = made ? w.doors.get(made.key) : w.doors.get(key);
+      // Made or already there, the door is the one under the key she named:
+      // instantiate boots under that key or refuses, and never another.
+      door = w.doors.get(key);
     }
-    const id = word(args.id);
+    const id = named(args.id);
     // Never for the ward itself, for the reason invite refuses it: the ward
     // is a being to nobody outside, and holds no relation of its own. A
     // standing written into its cells would be the owner's reach dressed as
@@ -115,8 +128,8 @@ export async function ownerAnswer(w: OwnerSide, asker: Asker, method: string | u
     // standing, since the two share one namespace. On the ward itself the
     // id is an owner, and only the root may unseat one, for the reason only
     // the root may invite one: ownership moves by the root alone.
-    const being = word(args.being),
-      id = word(args.id);
+    const being = named(args.being),
+      id = named(args.id);
     if (being === null || id === null) return { error: 'no such being' };
     if (being === w.pk && asker.id !== OWNER) return { error: 'no such being' };
     const door = w.doors.get(being);
@@ -134,7 +147,7 @@ export async function ownerAnswer(w: OwnerSide, asker: Asker, method: string | u
     // refused, for the reason knock is: it is a being to nobody outside, and
     // unbooting it would be a ward deleting itself from inside its own map,
     // leaving its owners bound to a door that is gone.
-    const being = word(args.being);
+    const being = named(args.being);
     if (being === null || being === w.pk) return { error: 'no such being' };
     const removed = w.unboot(being);
     return removed === null ? { error: 'no such being' } : { unbooted: being, removed };
@@ -148,9 +161,15 @@ export async function ownerAnswer(w: OwnerSide, asker: Asker, method: string | u
 // and take her out.
 async function describe(w: OwnerSide): Promise<Json> {
   const beings: Record<string, Json> = {};
-  for (const [key, door] of w.doors) {
-    if (key === w.pk) continue;
-    put(beings, key, { class: door.cells.class ?? null, public: w.publicKey() === key, digest: await seen(door, { id: OWNER }) });
+  // Every being is asked at once and each is bounded on her own. One being
+  // whose describe never settles is one null digest, not a ward that never
+  // answers its owner: the harbor learns the pk by this very ask at boot, so
+  // an unbounded wait here is a ward no restart can bring back.
+  const asked = [...w.doors].filter(([key]) => key !== w.pk);
+  const digests = await Promise.all(asked.map(async ([, door]) => (await within(DEFAULT.time, seen(door, { id: OWNER }))) as string | null | typeof LATE));
+  for (const [i, [key, door]] of asked.entries()) {
+    const d = digests[i];
+    put(beings, key, { class: door.cells.class ?? null, public: w.publicKey() === key, digest: d === LATE ? null : d });
   }
   for (const [key, cls] of Object.entries(w.absent())) put(beings, key, { class: cls, public: w.publicKey() === key, digest: null, absent: true });
   return {

package/src/ward/partition.ts

@@ -75,7 +75,7 @@ export type Bind = {
   occupants: Record<string, string>; // id -> heir pk
   knocks: Record<string, { current: string; next: string | null; spoke: boolean; sent: boolean; seq: number }>; // <ward pk>:<heir pk>, or public:<ward pk> -> her keys for a knock, before take. spoke: bytes came back once. sent: bytes went out once, answered or not
   answered: Record<string, true>; // <ward pk>:<heir pk>, or public:<ward pk>: knocked and answered
-  minted: string[]; // the last eight pks her side minted. inner. a test reads it
+  minted: string[]; // the last eight pks her side minted. nothing in the ward reads it: it is there to be looked at, and a kit that keeps it empty holds the same ward
 };
 
 // A relation she removed, as the door remembers it: the keys that may still
@@ -86,6 +86,30 @@ export type Bind = {
 export type Gone = { current: string; announced: string | null };
 export const GONE = 256;
 
+// The last few pks a relation minted, and no more. A relation rotates on
+// every ask, so a list of all of them is a partition that grows for as long
+// as she keeps talking and can never be written down. It lives here, beside
+// the other bound on the durable shape, because it is a fact about what a
+// partition may hold and not about how a ward mints.
+export const MINTED = 8;
+
+// A knock record is a key she minted for one invitation, kept until she takes
+// it. Only take deletes one, so a being who knocks and never takes would grow
+// her bind table for the life of the ward, one secret seed at a time. The
+// list is bounded like `gone`: past the count the oldest go, and a relation
+// that answered outlives one that never did, since an answered knock is one
+// she may still take.
+export const KNOCKS = 64;
+export const prune = (knocks: Record<string, unknown>, answered: Record<string, true>): void => {
+  const names = Object.keys(knocks);
+  if (names.length <= KNOCKS) return;
+  const order = [...names.filter((n) => !answered[n]), ...names.filter((n) => answered[n])];
+  for (const old of order.slice(0, names.length - KNOCKS)) {
+    delete knocks[old];
+    delete answered[old];
+  }
+};
+
 export type Partition = {
   version: string;
   beings: Record<string, Cells & { class?: string }>; // key -> her cells
@@ -95,11 +119,91 @@ export type Partition = {
   public: string | null; // the one public being's key
 };
 
+// The shape, read before anything acts on it. A partition this ward wrote is
+// this shape by construction; one it adopted was written by a hand, another
+// kit, or a file that was cut short, and every field below is one the ward,
+// the door or the heirs then act on without looking again. A `spent` that is
+// not an array rejects the door's promise on the first bound ask, a `mark`
+// that is not a number honours every number ever sent and grows without
+// bound, a being row that is null refuses the whole ward at birth by
+// accident and says nothing about why. So the shape is read once, here, and
+// what is not it throws with the path that failed, which names the trouble
+// to whoever is holding the file.
+//
+// The rule, so the reader does not grow into a schema: read every field the
+// ward acts on, and refuse only what would make it act wrongly. So `minted`
+// must be a list, because she pushes to it, and the truth in `answered` is
+// not read, because anything there says answered and nothing else follows.
+// `last` is reserved and nobody reads it, so nobody reads its shape either;
+// the run that gives it a reader gives it a line here. A being's own cells
+// are hers, of any shape JSON carries, and only the two records the ward
+// keeps inside them are read.
+const fault = (path: string, want: string): never => {
+  throw new Error(`partition ${path} is not ${want}`);
+};
+const table = (v: unknown, path: string): Record<string, unknown> => (typeof v === 'object' && v !== null && !Array.isArray(v) ? (v as Record<string, unknown>) : fault(path, 'an object'));
+const list = (v: unknown, path: string): unknown[] => (Array.isArray(v) ? (v as unknown[]) : fault(path, 'an array'));
+const text = (v: unknown, path: string): void => void (typeof v === 'string' || fault(path, 'a string'));
+const orNull = (v: unknown, path: string): void => void (v === null || typeof v === 'string' || fault(path, 'a string or null'));
+const whole = (v: unknown, path: string): void => void (Number.isSafeInteger(v) || fault(path, 'a whole number'));
+const flag = (v: unknown, path: string): void => void (typeof v === 'boolean' || fault(path, 'true or false'));
+
+function read(p: Partition): Partition {
+  for (const [key, cells] of Object.entries(table(p.beings, 'beings'))) {
+    const c = table(cells, `beings.${key}`);
+    table(c.standings, `beings.${key}.standings`);
+    table(c.occupants, `beings.${key}.occupants`);
+    if (c.class !== undefined) text(c.class, `beings.${key}.class`);
+  }
+  for (const [key, bind] of Object.entries(table(p.bind, 'bind'))) {
+    const b = table(bind, `bind.${key}`);
+    for (const [id, keys] of Object.entries(table(b.standings, `bind.${key}.standings`))) {
+      const w = `bind.${key}.standings.${id}`;
+      const s = table(keys, w);
+      text(s.ward, `${w}.ward`);
+      orNull(s.heir, `${w}.heir`);
+      text(s.current, `${w}.current`);
+      orNull(s.next, `${w}.next`);
+      whole(s.seq, `${w}.seq`);
+    }
+    for (const [id, pk] of Object.entries(table(b.occupants, `bind.${key}.occupants`))) text(pk, `bind.${key}.occupants.${id}`);
+    for (const [name, keys] of Object.entries(table(b.knocks, `bind.${key}.knocks`))) {
+      const w = `bind.${key}.knocks.${name}`;
+      const k = table(keys, w);
+      text(k.current, `${w}.current`);
+      orNull(k.next, `${w}.next`);
+      flag(k.spoke, `${w}.spoke`);
+      flag(k.sent, `${w}.sent`);
+      whole(k.seq, `${w}.seq`);
+    }
+    table(b.answered, `bind.${key}.answered`);
+    for (const [i, pk] of list(b.minted, `bind.${key}.minted`).entries()) text(pk, `bind.${key}.minted[${i}]`);
+  }
+  for (const [pk, heir] of Object.entries(table(p.heirs, 'heirs'))) {
+    const h = table(heir, `heirs.${pk}`);
+    text(h.being, `heirs.${pk}.being`);
+    text(h.id, `heirs.${pk}.id`);
+    text(h.current, `heirs.${pk}.current`);
+    orNull(h.announced, `heirs.${pk}.announced`);
+    flag(h.fresh, `heirs.${pk}.fresh`);
+    whole(h.mark, `heirs.${pk}.mark`);
+    for (const [i, n] of list(h.spent, `heirs.${pk}.spent`).entries()) whole(n, `heirs.${pk}.spent[${i}]`);
+  }
+  for (const [pk, gone] of Object.entries(table(p.gone, 'gone'))) {
+    const g = table(gone, `gone.${pk}`);
+    text(g.current, `gone.${pk}.current`);
+    orNull(g.announced, `gone.${pk}.announced`);
+  }
+  orNull(p.public, 'public');
+  return p;
+}
+
 // The one place a ward reads state that another ward wrote. A fresh
 // memory becomes a partition of this version; anything already written must
-// say it is this version, and a ward that cannot read it does not boot. Birth is
-// where a ward is allowed to be loud: silence is the door's word, for asks
-// that were made, and no ask has been made yet.
+// say it is this version and be the shape this version names, and a ward that
+// cannot read it does not boot. Birth is where a ward is allowed to be loud:
+// silence is the door's word, for asks that were made, and no ask has been
+// made yet.
 export function open(memory: Record<string, unknown>): Partition {
   const p = memory as Partition;
   if (Object.keys(memory).length > 0 && p.version !== VERSION) {
@@ -112,7 +216,7 @@ export function open(memory: Record<string, unknown>): Partition {
   p.heirs ??= {};
   p.gone ??= {};
   p.public ??= null;
-  return p;
+  return read(p);
 }
 
 // One record, reached by a key a being or an owner chose. A bare lookup finds

package/src/ward/seal.ts

@@ -21,7 +21,7 @@
 //                       reply = JSON { object, seen } | { silence: true } | { quo: word }    signed by the ward key
 import type { DoorWord, Json, JsonObject } from '../being/types.ts';
 import { isDoorWord } from '../being/silence.ts';
-import { KEY, SIGNATURE, box, concat, hex, sha256, sign, signingPair, sealingPair, unbox, unhex, verify } from './arithmetic.ts';
+import { KEY, SIGNATURE, box, concat, derive, hex, sha256, sign, signingPair, sealingPair, unbox, unhex, verify } from './arithmetic.ts';
 import { cellFault } from './cells.ts';
 
 const utf8 = new TextEncoder();
@@ -29,17 +29,44 @@ const text = new TextDecoder();
 
 export type WardKey = { sign: Uint8Array; padlock: Uint8Array; signPk: Uint8Array; padlockPk: Uint8Array; pk: string };
 
+// The two labels a ward's keys are derived under. They are here and not in
+// arithmetic.ts because a label is a decision and that file is arithmetic.
+// `quo-seal` is taken: it is the label the message cipher derives its key and
+// nonce under, from an agreement rather than from a seed, and two derivations
+// answering to one name is how a kit is read wrong.
+const WARD_SIGN = new TextEncoder().encode('quo-ward-sign');
+const WARD_SEAL = new TextEncoder().encode('quo-ward-seal');
+
 // The ward's key from its seed. Its pk on the wire is the signing pk then the padlock, 128 hex.
+//
+// One seed, two curves, and each secret derived from it under its own label.
+// Fed the seed straight, the two scalars differ only because Ed25519 hashes
+// what it is given and X25519 clamps it raw, which is an accident of the two
+// 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 `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
+// else, of any length, is hashed to that length first. So a thirty-two
+// character name is a name like any other, and not a key because it happened
+// to be the right size.
 export async function wardKey(seed: string | Uint8Array): Promise<WardKey> {
-  const raw = typeof seed === 'string' ? utf8.encode(seed) : seed;
-  const seed32 = raw.length === KEY ? raw : await sha256(raw);
-  const s = await signingPair(seed32);
-  const p = await sealingPair(seed32);
+  const seed32 = typeof seed === 'string' ? await sha256(utf8.encode(seed)) : seed.length === KEY ? seed : await sha256(seed);
+  const s = await signingPair(await derive(seed32, WARD_SIGN, KEY));
+  const p = await sealingPair(await derive(seed32, WARD_SEAL, KEY));
   return { sign: s.secret, padlock: p.secret, signPk: s.pk, padlockPk: p.pk, pk: hex(s.pk) + hex(p.pk) };
 }
 export const wardSignPk = (pk: string): Uint8Array => unhex(pk.slice(0, KEY * 2));
 export const wardPadlock = (pk: string): Uint8Array => unhex(pk.slice(KEY * 2));
 export const isWardPk = (pk: unknown): pk is string => typeof pk === 'string' && /^[0-9a-f]{128}$/.test(pk);
+// Thirty-two bytes as hex, which is how this kit writes every single key: a
+// heir pk, a heir secret, a being's own key, and a digest, which is the same
+// thirty-two bytes of SHA-256. A ward pk is two of these and has its own
+// shape above. The two are spelled here and nowhere else, so a door, a
+// stance, a harbor and a conformance suite all refuse the same string.
+export const isHex = (v: unknown): v is string => typeof v === 'string' && /^[0-9a-f]{64}$/.test(v);
 
 // A being's relation key: a seed, and the pk it signs as.
 export async function beingKey(seed: Uint8Array): Promise<{ seed: string; pk: string }> {
@@ -83,16 +110,16 @@ export async function openAsk(bytes: Uint8Array, padlockSecret: Uint8Array): Pro
     // The heir, or null for the public being. Absent is not null: a payload
     // that never named one is malformed, like any other missing field.
     const to = payload.to;
-    if (to !== null && !(typeof to === 'string' && /^[0-9a-f]{64}$/.test(to))) return null;
-    if (typeof payload.by !== 'string' || !/^[0-9a-f]{64}$/.test(payload.by)) return null;
-    if (payload.next !== null && !(typeof payload.next === 'string' && /^[0-9a-f]{64}$/.test(payload.next))) return null;
+    if (to !== null && !isHex(to)) return null;
+    if (!isHex(payload.by)) return null;
+    if (payload.next !== null && !isHex(payload.next)) return null;
     if (payload.method !== undefined && typeof payload.method !== 'string') return null; // a name, or the empty ask. never a number, never an object.
     if (payload.args !== undefined && (payload.args === null || typeof payload.args !== 'object' || Array.isArray(payload.args))) return null; // args are one object, or absent. a string or a list is not an ask.
     if (payload.args !== undefined && cellFault(payload.args, 'args') !== null) return null; // and values all the way down: no key named __proto__, no nesting past the bound
     if (!Number.isSafeInteger(payload.seq) || payload.seq < 1) return null; // her count for this relation. one and up, and a whole number.
-    // The allowance. A whole number, and one that has already run out is not an
-    // ask this door will open: it is refused as the bytes it is, above.
-    if (!Number.isSafeInteger(payload.time) || payload.time <= 0) return null;
+    // The allowance is not read here. It is the door's, D2, and the door is
+    // its one reader: `spent` in allowance.ts says what a budget is and what
+    // is left of it, in one sentence, for a payload that opened like any other.
     // The hop count, if this ask carries one: a whole number, never below
     // zero. Absent is the ordinary ask and always will be.
     if (payload.hops !== undefined && (!Number.isSafeInteger(payload.hops) || payload.hops < 0)) return null;
@@ -130,7 +157,7 @@ export async function openReply(bytes: unknown, ephemeralSecret: Uint8Array, sig
     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))) return null;
+    if (r.seen !== null && !isHex(r.seen)) return null;
     return { object: r.object as Json, seen: r.seen };
   } catch {
     return null;