@quo-systems/quo 0.2.10 → 0.2.12

package/dist/ward/ward.js

@@ -6,7 +6,7 @@
 // leaves, opens every one that arrives.
 import { silence, isSilence, unreached, isWord, word } from '../being/silence.js';
 import { OWNER } from '../being/types.js';
-import { at, drop, open, put, emptyBind, emptyCells } from './partition.js';
+import { at, drop, open, put, emptyBind, emptyCells, MINTED } from './partition.js';
 import { Heirs } from './heirs.js';
 import { makeDoor } from './door.js';
 import { buildStance } from './stance.js';
@@ -15,8 +15,6 @@ import { allow, within, LATE } from './allowance.js';
 import { beingKey, openReply, sealAsk, wardKey, wardPadlock, wardSignPk } from './seal.js';
 import { unhex } from './arithmetic.js';
 import { guardCells, unguarded, cellFault } from './cells.js';
-// How many minted pks she keeps behind her. Enough to name the keys in play.
-const MINTED = 8;
 // The ward. One call in, two pointers out. Async because keys are derived.
 export async function Ward(ground) {
     const w = await Self.boot(ground);
@@ -29,6 +27,7 @@ class Self {
     p;
     heirs;
     doors = new Map();
+    #birthing = new Set(); // keys whose constructor is running: taken, though no door and no row say so yet
     door;
     ask;
     static async boot(ground) {
@@ -41,7 +40,7 @@ class Self {
         this.p = open(ground.memory); // the partition: the ward's own state, and every being's row
         this.heirs = new Heirs(this.p, () => this.#wrote());
         this.door = makeDoor(key, this.heirs, this.doors, () => this.p.public, (n) => ground.random(n)); // pointer one
-        this.#boot(this.pk, this); // the ward's ward is itself
+        this.#boot(this.pk, () => this); // the ward's ward is itself
         // 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
@@ -53,10 +52,11 @@ class Self {
         // read them. Her row stays hers: nobody boots another class over it, the
         // owner sees her as absent, and the owner may unboot her.
         for (const [k, c] of Object.entries(this.p.beings)) {
-            if (k === this.pk || !c.class)
+            const className = c.class;
+            if (k === this.pk || !className)
                 continue;
             try {
-                this.#boot(k, c.class);
+                this.#boot(k, (stance) => this.g.instantiate(className, stance));
             }
             catch {
                 /* she is not here this run. the ward is, and so is everyone else. */
@@ -78,14 +78,18 @@ class Self {
     // can invite. A stranger cannot be a named asker here, because the door
     // names nobody the ward did not bind.
     async answer(asker, method, args = {}) {
+        // Nobody is not an owner. The door names nobody the ward did not bind, so
+        // the only way here unnamed is a partition that says the ward is its own
+        // public being, which no owner ask will write. Silence, not an error
+        // object: an unnamed asker is a stranger, and a stranger hears one thing.
         if (asker.id === undefined)
-            return { error: 'unknown ask' };
+            return silence;
         return ownerAnswer({
             pk: this.pk,
             doors: this.doors,
             absent: () => this.#absent(),
             publicKey: () => this.p.public,
-            instantiate: (key, className) => this.#instantiate(key, className),
+            instantiate: (className, key) => this.#instantiate(className, key),
             unboot: (key) => this.#unboot(key),
             setPublic: (key) => {
                 this.p.public = key;
@@ -113,16 +117,25 @@ class Self {
     // row is hers, with every relation in it, and no class is booted over it.
     // A throw at birth is that boot's refusal and nothing half-lives; the
     // ward says which, since the owner hears objects.
-    #instantiate(key, className) {
-        if (typeof key !== 'string' || typeof className !== 'string' || !key || this.doors.has(key) || at(this.p.beings, key))
+    #instantiate(className, key) {
+        // The three refusals are read before the constructor runs, and the
+        // constructor can reach the stance and boot: a class that boots its own
+        // key from inside itself would pass all three, since neither its door nor
+        // its row exists yet, and the two objects would then share one row. A key
+        // being born is a key taken, for as long as the birth lasts.
+        if (typeof key !== 'string' || typeof className !== 'string' || !key || this.doors.has(key) || at(this.p.beings, key) || this.#birthing.has(key))
             return null;
         let door;
+        this.#birthing.add(key);
         try {
-            door = this.#boot(key, className);
+            door = this.#boot(key, (stance) => this.g.instantiate(className, stance));
         }
         catch {
             return 'threw';
         }
+        finally {
+            this.#birthing.delete(key);
+        }
         if (!door)
             return null;
         unguarded(door.cells).class = className; // so a restart finds her. the ward's key, written behind her guard
@@ -170,19 +183,26 @@ class Self {
     // Nothing is written until there is somebody to write it for: a class the
     // harbor does not know makes no being, and a boot that made nobody must
     // leave the partition as it found it.
-    #boot(key, classNameOrSelf) {
+    //
+    // `make` is who to build with the stance this raises. Two callers and two
+    // makers: the ground's `instantiate` for a being of the ward, and the ward
+    // itself, which is the first being in its own map and is already made.
+    #boot(key, make) {
         const cells = guardCells(at(this.p.beings, key) ?? emptyCells(), () => this.#wrote());
         const bind = at(this.p.bind, key) ?? emptyBind();
         const stance = buildStance({
             pk: this.pk,
+            // This stance, not merely this key: unboot and boot again under the
+            // same key makes a new being, and the old stance is not hers.
+            live: () => this.doors.get(key)?.stance === stance,
             mintKey: (b) => this.#mintKey(b),
             openHeir: (heir, being, id) => this.heirs.open(heir, being, id),
             closeHeir: (heir) => this.heirs.close(heir),
-            send: (b, keys, announce, method, args, wanted) => this.#send(b, keys, announce, method, args, wanted),
+            send: (b, keys, method, args, wanted) => this.#send(b, keys, method, args, wanted),
             // A throw at birth is null to her, not a throw in her method: she asked
             // for a being and got none, and her own answer is still hers to give.
-            instantiate: (k, className) => {
-                const made = this.#instantiate(k, className);
+            instantiate: (className, k) => {
+                const made = this.#instantiate(className, k);
                 return made && made !== 'threw' ? made.key : null;
             },
             // The two halves of a maker's way back, each the ward's own call: the
@@ -192,7 +212,7 @@ class Self {
             unmake: (k) => void this.#unboot(k),
             wrote: () => this.#wrote(),
         }, key, cells, bind);
-        const being = classNameOrSelf === this ? this : this.g.instantiate(classNameOrSelf, stance);
+        const being = make(stance);
         if (!being || typeof being.answer !== 'function')
             return null; // a being is anything with an answer, and nothing without one
         put(this.p.beings, key, cells);
@@ -219,7 +239,7 @@ class Self {
     // next, seals to the far ward, opens the reply with the ephemeral secret,
     // and rotates to the announced key once the far door has answered under
     // the current one.
-    async #send(bind, keys, announce, method, args, wanted) {
+    async #send(bind, keys, method, args, wanted) {
         // What she asked for, held to what this ward allows. Asking for nothing is
         // the default, and asking for more than the ceiling is the ceiling: budget
         // is granted by a ward, never minted by a being.
@@ -227,8 +247,9 @@ class Self {
         const by = (await beingKey(unhex(keys.current))).pk;
         // A public being is reached without a heir, and the door keeps nothing for
         // whoever asked: no key it vouched for, so nothing to announce and nothing
-        // to rotate to. A standing on her signs with one key for life.
-        if (announce && keys.next === null && keys.heir !== null)
+        // to rotate to. A standing on her signs with one key for life. Every other
+        // ask announces its next: there is no send that does not.
+        if (keys.next === null && keys.heir !== null)
             keys.next = (await this.#mintKey(bind)).seed;
         const next = keys.next === null ? null : (await beingKey(unhex(keys.next))).pk;
         // Her count for this relation, one higher every call and never reused. The

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quo-systems/quo",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Quo: an object asks another object and gets an answer, without knowing where it is. Being, Ward, Harbor.",
   "keywords": [
     "quo",

package/src/being/being.ts

@@ -30,6 +30,12 @@ const method = (self: object, name: string): boolean => {
   return false;
 };
 
+// Both statics below are read off the class the object was made from, so a
+// subclass declaring either replaces its parent's rather than adding to it.
+// That is the rule: her blueprint is exactly what the class in front of you
+// declares, in the order she chose, and merging down a chain would hand her
+// asks she may mean to drop and an order she did not write. A subclass that
+// means to extend says so, `static override asks = { ...Parent.asks, mine: {} }`.
 export class Being {
   // Her cells' defaults. Merged in at birth, only where a key is missing, so
   // a restart keeps what she wrote.
@@ -104,7 +110,7 @@ export class Being {
     // would answer with her stance, `toString` with a string, and neither is
     // an ask she wrote. Only her own keys are asks, which is what describe
     // shows. What she shows is what she can be asked.
-    const spec = typeof method === 'string' && Object.hasOwn(C.asks, method) ? C.asks[method] : undefined;
+    const spec = Object.hasOwn(C.asks, method) ? C.asks[method] : undefined;
     if (!spec || (spec.for && !spec.for(this.occupant(asker), asker))) return { error: 'unknown ask' };
     const fn = (this as unknown as Record<string, (args: JsonObject, asker: Asker) => Reply | Promise<Reply>>)[method];
     return fn.call(this, args ?? {}, asker);

package/src/being/digest.ts

@@ -26,8 +26,21 @@ export const canonical = (v: Json): string => {
   return JSON.stringify(v);
 };
 
+// Hex and the guard are spelled here and again in `src/ward/arithmetic.ts`,
+// which is the price of the boundary: nothing under `src/being` imports
+// anything above it, because this is the whole world a being's own code sees
+// and a being reaching the ward is the thing the shape is against.
 const hex = (bytes: ArrayBuffer): string =>
   Array.from(new Uint8Array(bytes), (b) => b.toString(16).padStart(2, '0')).join('');
 
-export const digest = async (blueprint: Json): Promise<string> =>
-  hex(await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(canonical(blueprint))));
+// `crypto.subtle` is read at the call and never captured at load. A browser
+// on a plain http:// origin has `crypto` without `subtle`, and a terrain may
+// install one after this module is first imported; either way the failure is
+// one sentence and not a TypeError from inside a digest nobody can read.
+const subtle = (): SubtleCrypto => {
+  const s = globalThis.crypto?.subtle;
+  if (!s) throw new Error('this terrain has no crypto.subtle: a being needs a secure context to be described');
+  return s;
+};
+
+export const digest = async (blueprint: Json): Promise<string> => hex(await subtle().digest('SHA-256', new TextEncoder().encode(canonical(blueprint))));

package/src/being/index.ts

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

package/src/being/silence.ts

@@ -25,6 +25,20 @@ export const word = <W extends WordName>(name: W): Word<W> => {
 export const isWord = (x: unknown): x is Word => x !== null && typeof x === 'object' && typeof (x as Record<symbol, unknown>)[WORD_KEY] === 'string';
 export const wordOf = (x: Word): WordName => x[WORD_KEY];
 
+// What came back is an answer and not one of the two things that are not
+// answers. A being who only wants the object writes one test instead of
+// three, and the three shapes stay three shapes: silence is no answer, a word
+// is her ward telling her why there is none.
+export const answered = <T>(x: T): x is Exclude<T, typeof silence | Word> => !isSilence(x) && !isWord(x);
+
+// What she was told, with a word given its name and everything else left
+// exactly as it came. One value to compare against, so asking which word came
+// back is one test and not two joined by an and: `told(out) === 'late'` says
+// what `isWord(out) && wordOf(out) === 'late'` says, and says which answer
+// arrived instead when it is wrong, where the pair collapses to false and
+// names nothing. Silence stays the symbol it is, and an object stays itself.
+export const told = (x: unknown): unknown => (isWord(x) ? wordOf(x) : x);
+
 // 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.

package/src/being/types.ts

@@ -30,11 +30,36 @@ export const RESERVED_IDS: readonly string[] = [OWNER, PUBLIC];
 // and the heir's secret. Without a heir it addresses a ward's public being.
 export type Invitation = { ward: string; heir?: string; secret?: string };
 
+// An invitation as one object of values, which is what it already is. A being
+// who hands one on sends it as args, and args are values; this is the one
+// place that is spelled, so nobody spells it with a cast. Absent stays absent:
+// an invitation to a public being carries no heir and no secret, and a key
+// present and undefined is not the same object once JSON has been through it.
+export const invitationArgs = (inv: Invitation): JsonObject => ({
+  ward: inv.ward,
+  ...(inv.heir !== undefined ? { heir: inv.heir } : {}),
+  ...(inv.secret !== undefined ? { secret: inv.secret } : {}),
+});
+
 // A blueprint is an MCP tool list plus notes.
 export type Schema = JsonObject;
 export type Ask = { name: string; description?: string; input: Schema; output?: Schema };
 export type Blueprint = { asks: Ask[]; notes: Json };
 
+// Whether what came back from an empty ask is a blueprint. Every describe on
+// the far side of a door is somebody else's code, so nothing may be written
+// into a standing's record as a blueprint without being read as one first: a
+// side walks `asks` by name, and a list of anything else, or no list at all,
+// is a side that breaks on a far ward's answer. The asks are checked to the
+// depth a side reads them, a name and an input each, and no further: what a
+// far being puts beside those is hers.
+export const isBlueprint = (v: unknown): v is Blueprint => {
+  if (v === null || typeof v !== 'object' || Array.isArray(v)) return false;
+  const { asks, notes } = v as { asks?: unknown; notes?: unknown };
+  if (!Array.isArray(asks) || notes === undefined) return false;
+  return asks.every((a) => a !== null && typeof a === 'object' && !Array.isArray(a) && typeof (a as Ask).name === 'string' && (a as Ask).input !== null && typeof (a as Ask).input === 'object' && !Array.isArray((a as Ask).input));
+};
+
 export type StandingRecord = { id: string; digest: string | null; blueprint: Blueprint | null; seen: string | null };
 export type OccupantRecord = { id: string; notes: JsonObject };
 export type Cells = {
@@ -49,7 +74,10 @@ export type Silence = typeof silence;
 // why. A door says the first five to a key it has bound, and rides them on
 // the wire as `{ quo: word }`; her own ward says the last four to her and
 // they never leave the ward. Each is one frozen object under one symbol key,
-// so no being makes one and none crosses an edge as a value.
+// so no being makes one by accident and none crosses an edge as a value. A
+// being who reaches for the symbol on purpose makes an object her ward reads
+// as her having thrown, which is what a being who returns nonsense gets: the
+// key is a guard against collision, never against her.
 export type DoorWord = 'removed' | 'absent' | 'unannounced' | 'repeated' | 'threw';
 export type WardWord = 'unreached' | 'late' | 'invitation' | 'dropped';
 export type WordName = DoorWord | WardWord;

package/src/conformance/assert.ts

@@ -11,6 +11,14 @@ const show = (v: unknown): string => {
   if (typeof v === 'bigint') return `${v}n`;
   if (v === undefined) return 'undefined';
   if (typeof v === 'function') return `[function ${v.name}]`;
+  // A ward's word is a frozen object under one symbol key, and JSON shows it
+  // as `{}`. A red estate chapter saying `{} is not {}` names nothing, so a
+  // value whose own keys are all symbols is shown by its keys.
+  if (v !== null && typeof v === 'object') {
+    const keys = Object.keys(v);
+    const syms = Object.getOwnPropertySymbols(v).filter((s) => Object.getOwnPropertyDescriptor(v, s)!.enumerable);
+    if (keys.length === 0 && syms.length > 0) return `{ ${syms.map((s) => `${s.toString()}: ${show((v as Record<symbol, unknown>)[s])}`).join(', ')} }`;
+  }
   try {
     return JSON.stringify(v) ?? Object.prototype.toString.call(v);
   } catch {
@@ -24,15 +32,40 @@ const fail = (why: string, message?: string): never => {
 // Structural, and strict about shape the way `node:assert/strict` is: a value
 // is not equal to one of another kind, and an array is not equal to an object
 // that happens to hold the same keys.
+// The four kinds this compares, and every other object is refused rather than
+// guessed at. A Date, a RegExp, a boxed primitive and a class instance each
+// carry state no key walk can see, so two of them with the same keys are
+// equal here and unequal in node, which is a wrong yes: the one answer a
+// suite must never give. A refusal is a red test that says so.
+const KNOWN: readonly (object | null)[] = [Object.prototype, null, Array.prototype, Uint8Array.prototype];
+
+// What node compares: own enumerable keys, strings then enumerable symbols.
+// Not `Reflect.ownKeys`, which also lists what a definition hid.
+const keysOf = (v: object): PropertyKey[] => [...Object.keys(v), ...Object.getOwnPropertySymbols(v).filter((s) => Object.getOwnPropertyDescriptor(v, s)!.enumerable)];
+
 export function same(a: unknown, b: unknown): boolean {
   if (Object.is(a, b)) return true;
   if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false;
-  if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) return false;
+  const proto = Object.getPrototypeOf(a) as object | null;
+  if (proto !== (Object.getPrototypeOf(b) as object | null)) return false;
+  if (!KNOWN.includes(proto)) return false; // a Date, a RegExp, a boxed number, a class of hers
   if (Array.isArray(a) !== Array.isArray(b)) return false;
-  if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((x, i) => same(x, b[i]));
   if (a instanceof Uint8Array && b instanceof Uint8Array) return a.length === b.length && a.every((x, i) => x === b[i]);
-  if (a instanceof Map || b instanceof Map || a instanceof Set || b instanceof Set) return false; // the suite has none, and a wrong yes is worse than a refusal
-  const ka = Reflect.ownKeys(a), kb = Reflect.ownKeys(b);
+  // An array is its indices and whatever else was hung on it, and a hole is
+  // not a present undefined: `[, 1]` and `[undefined, 1]` differ in node and
+  // must differ here. `every` skips holes, so the loop is written out.
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i += 1) {
+      if (i in a !== i in b) return false;
+      if (i in a && !same(a[i], b[i])) return false;
+    }
+    const extra = (v: unknown[]) => keysOf(v).filter((k) => typeof k !== 'string' || !/^(?:0|[1-9]\d*)$/.test(k));
+    const xa = extra(a), xb = extra(b);
+    const at = (v: unknown[], k: PropertyKey) => (v as unknown as Record<PropertyKey, unknown>)[k];
+    return xa.length === xb.length && xa.every((k) => xb.includes(k) && same(at(a, k), at(b, k)));
+  }
+  const ka = keysOf(a), kb = keysOf(b);
   if (ka.length !== kb.length) return false;
   return ka.every((k) => kb.includes(k) && same((a as Record<PropertyKey, unknown>)[k], (b as Record<PropertyKey, unknown>)[k]));
 }

package/src/conformance/beings.ts

@@ -1,9 +1,11 @@
 // SPDX-License-Identifier: Apache-2.0
 // 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.
+// shop, a customer on the base class, a maker, a member, and one raw being
+// with no base at all.
 import { Being } from '../being/being.ts';
-import { isSilence, isUnreached, isWord } from '../being/silence.ts';
-import type { Asker, Blueprint, Invitation, JsonObject, OccupantRecord, Reply, Stance } from '../being/types.ts';
+import { answered, isUnreached } from '../being/silence.ts';
+import { invitationArgs } from '../being/types.ts';
+import type { Ask, Asker, Blueprint, Invitation, Json, JsonObject, OccupantRecord, Reply, Stance } from '../being/types.ts';
 
 // 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.
@@ -11,7 +13,9 @@ export class Printer extends Being {
   static override cells = { jobs: [] as JsonObject[], asks: [{ name: 'print', input: { type: 'object' } }] as JsonObject[] };
   static override asks = { print: { input: { type: 'object' } } };
   override describe(): Blueprint {
-    return { asks: this.cells.asks as never, notes: { model: 'LX-2' } };
+    // Her own cells, which a test writes to change her shape. Cells are Json
+    // to the ward, so the asks are named for what she keeps in them.
+    return { asks: this.cells.asks as Ask[], notes: { model: 'LX-2' } };
   }
   print({ doc }: JsonObject, asker: Asker) {
     (this.cells.jobs as JsonObject[]).push({ by: asker.id ?? null, doc: doc ?? null });
@@ -46,7 +50,7 @@ export class Shop extends Being {
 
   async keepPrinter(invitation: Invitation): Promise<boolean> {
     const bp = await this.knock(invitation);
-    if (isSilence(bp) || isWord(bp)) return false;
+    if (!answered(bp)) return false;
     this.cells.printerId = await this.take('prn', invitation);
     return true;
   }
@@ -55,7 +59,7 @@ export class Shop extends Being {
     const rec = this.occupant(asker);
     if (rec?.notes.tier === 'gold' && invitation) {
       const back = await this.knock(invitation as Invitation, 'hi');
-      if (!isSilence(back) && !isWord(back)) await this.take(`vip-${asker.id}`, invitation as Invitation);
+      if (answered(back)) await this.take(`vip-${asker.id}`, invitation as Invitation);
     }
     return { welcome: true };
   }
@@ -67,7 +71,7 @@ export class Shop extends Being {
     if (!printer) return { error: 'no printer' };
     const out = await printer.ask('print', { doc: `receipt for ${item}` });
     if (isUnreached(out)) return { error: 'printer unreachable', retry: true };
-    if (isSilence(out) || isWord(out)) return { error: 'printer refused' };
+    if (!answered(out)) return { error: 'printer refused' };
     const st = this.cells.standings[id!];
     if (st.seen !== st.digest) this.occupant(asker)!.notes.printerChanged = true;
     (this.cells.sales as JsonObject[]).push({ item: item ?? null, by: asker.id ?? null });
@@ -86,9 +90,13 @@ export class Customer extends Being {
   static override asks = { hi: { input: { type: 'object' } } };
 
   async join(invitation: Invitation) {
-    const mine = (await this.invite('shop-back'))!;
-    const out = await this.knock(invitation, 'hello', { invitation: mine as never });
-    if (isSilence(out) || isWord(out)) return out; // nothing was born
+    // A way back for the shop, if she can mint one. She may not: two joins on
+    // one invitation race, and the second finds the id taken. Then she offers
+    // nothing and knocks all the same, which is what the shop is asked to
+    // survive. The old shape said `!` here and was wrong about it.
+    const mine = await this.invite('shop-back');
+    const out = await this.knock(invitation, 'hello', { invitation: mine === null ? null : invitationArgs(mine) });
+    if (!answered(out)) return out; // nothing was born
     await this.take('shop', invitation); // now, and only now
     return out;
   }
@@ -119,6 +127,29 @@ export class Echo {
 // A member of an estate. Nothing scripted: she invites whom she is told to,
 // knocks where she is told to, and answers `ping` with the asker's own name.
 // The estate chapter drives her, and what it drives is the graph, not her.
+// A being who makes beings. `boot` is on every stance, so it is the ward's
+// promise and not this kit's, and a second kit that never wired it hands its
+// beings a call that answers null for ever. She says what came of it: the key
+// back, or null for a key already taken, a class the harbor does not hold, or
+// a constructor that threw. With an id she also asks for a way back, and then
+// she holds a standing to what she made like any other.
+export class Maker extends Being {
+  static override cells = { made: [] as string[] };
+  static override asks = {
+    open: { input: { type: 'object', properties: { class: { type: 'string' }, key: { type: 'string' }, id: { type: 'string' } }, required: ['class', 'key'] } },
+    say: { input: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } },
+  };
+  async open({ class: className, key, id }: JsonObject) {
+    const made = await this.boot(className as string, key as string, id as string | undefined);
+    if (made !== null) (this.cells.made as string[]).push(made);
+    return { made };
+  }
+  async say({ id }: JsonObject) {
+    const standing = this.standings[id as string];
+    return { said: standing === undefined ? null : ((await standing.ask('ping')) as Json) };
+  }
+}
+
 export class Member extends Being {
   static override cells = { heard: [] as JsonObject[] };
   static override asks = { ping: { input: { type: 'object' } } };