@quo-systems/quo 0.1.0 → 0.1.1

package/README.md

@@ -18,8 +18,10 @@ assumes nothing from any other document, this README included. Read it first.
 
 ## This package
 
-A TypeScript implementation, run directly on Node's own type stripping. No
-build step, no dependencies.
+A TypeScript implementation, run directly on Node's own type stripping, with
+no dependencies. The package ships JavaScript with declarations, emitted by
+`npm run build` before every gate and every publish, because Node strips
+types nowhere under `node_modules`.
 
 ```
 src/being/        the Being side: what a being author imports, if anything
@@ -80,10 +82,11 @@ a TypeScript ward. `SPEC.md` "The tree" says the whole of it.
 
 Published from 0.1.0, the first version under this name, with no
 compatibility promise before 1.0.0: the words may still move. `npm pack
---dry-run` shows what ships: the source, the vectors, the spec, and the
-licence — no tests, no configs. The spec ships because it is the truth the
-source and the vectors are read against. `npm publish` runs both gates
-first, `check` and `check:terrain`, and refuses on a failure.
+--dry-run` shows what ships: the emitted `dist/`, the source, the vectors,
+the spec, and the licence — no tests, no configs. The spec ships because it
+is the truth the source and the vectors are read against. `npm publish`
+runs both gates first, `check` and `check:terrain`, and refuses on a
+failure.
 
 ## License
 

package/SPEC.md

@@ -1057,7 +1057,8 @@ byte, a four-byte id, the 64-byte pk and the bytes; a reply is the kind, the
 id and the bytes; and nothing delivered is the kind and the id alone. Both
 kinds are written on the standard surface every terrain carries, fetch and
 WebSocket, and this tree holds either end of a line and never a listener:
-who accepts a socket is the terrain's business. A reach reads nothing.
+who accepts a socket is the terrain's business. A reach reads nothing; a
+harbor opens no box but its own probe's.
 Nothing comes back only where the reach knows nothing was delivered: no such
 pk at the far end, a connection that would not open, a line already gone. A
 reach that sent the bytes and lost the line after answers nothing at all,
@@ -1099,8 +1100,24 @@ ward the store keeps, keeps the map of ward pk to door for its own wards
 and the **directory**, pk to reach, for foreign ones, carries bytes to a
 pk and delivers bytes from the wire to one door. The directory is filled
 three ways, in this order: its own doors; a socket a dialer holds to it,
-bound at the dialer's announce and unbound when the line closes; and a
-hint, a pk at a URL, kept in the store. One rule makes a **rendezvous** of
+bound once the door behind the dialer's claim has proved it, and unbound
+when the line closes; and a hint, a pk at a URL, kept in the store.
+
+An announce is a claim, and a claim binds nothing until proven: anyone who
+can reach a listener could otherwise name a pk that is not theirs and take
+its reachability, the one thing a rendezvous exists to give. The proof is
+the door as it already is. The harbor mints a lid and sends it down the
+line with noise after it, an ask for the claimed pk; that is a box that
+does not open, D1, and the door answers it with silence sealed to the lid
+and signed by the ward key. Only the holder of that seed writes that reply,
+the lid is fresh so nothing replays, and a box that does not open writes
+nothing at the ward. Each claimed pk is proven on its own, both ways: the
+listener proves the dialer's claims and the dialer the listener's. What a
+relay that genuinely reaches a ward elsewhere can still do is forward the
+probe and pass, and then it is a rendezvous for that ward like any other,
+able to drop and nothing more. This is the one box a harbor ever opens,
+the one it sealed itself, and it reads nothing from it but whose key
+signed. One rule makes a **rendezvous** of
 any listener: bytes that arrive from the wire go to an own door or to a
 socket this harbor holds for that pk, and never onward by request. So a
 harbor that cannot be dialed is reached through the one it dialed, by
@@ -1296,17 +1313,30 @@ class Watcher {
 ## The tree
 
 The repository is one TypeScript implementation of this document, run
-directly on Node's type stripping, no build step, no dependencies. Node 22.18
+directly on Node's type stripping, no dependencies. Node 22.18
 or later. The package is `@quo-systems/quo`, published from 0.1.0, the
 first version under this name, and it starts over: nothing before it under
 any other name is this protocol. Before 1.0.0 every version may change the
-words, and nothing is kept for a holder of an earlier one. `npm pack
---dry-run` shows what ships: the four source folders, the vectors, this
-document, the README and the licence, and nothing else. This document
-ships, decided here: it is the truth the source and the vectors are read
-against, and a kit in another language is written against it and nothing
-else. Publishing runs both gates first, `npm run check` and
-`npm run check:terrain`, and refuses on a failure.
+words, and nothing is kept for a holder of an earlier one.
+
+The tree runs as TypeScript and the package ships as JavaScript. Node
+strips types nowhere under `node_modules`, so a consumer cannot load the
+source, and 0.1.0, which shipped it, imported nowhere; 0.1.1 is the first
+version a stranger can import. `npm run build` emits `dist/` from `src`
+alone, one JavaScript file and one declaration file per source file with
+every relative import rewritten, and the exports map points there, types
+beside default. The
+build runs before every gate and every publish and is never tracked;
+nothing under `test/` or `estate/` imports it except through the package
+name, which is how a consumer does. `test/package.test.ts` is the one
+suite that meets the package as a stranger: it packs the tarball,
+installs it into an empty folder, and imports every entry point under
+plain Node. `npm pack --dry-run` shows what ships: `dist/`, the four
+source folders, the vectors, this document, the README and the licence,
+and nothing else. This document ships, decided here: it is the truth the
+source and the vectors are read against, and a kit in another language is
+written against it and nothing else. Publishing runs both gates first,
+`npm run check` and `npm run check:terrain`, and refuses on a failure.
 
 ```
 src/being/        the Being side. types, the base class, silence, the digest.
@@ -1435,8 +1465,9 @@ passes the same suite. Those tests are the checklist, not the mock.
   the frames are asserted with no network under them; the conformance
   suite against two harbor cores over memory stores reaching each other
   in-process, drop and adopt as the migration; a restart from the store
-  with the hints; the dialer over a stubbed line, announce, bind, fallback,
-  unbind and the wait before it dials again; and the frames against
+  with the hints; the dialer over a stubbed line, announce, a claim proven
+  at a real door before it binds and a claim nobody there holds left
+  unbound, fallback, unbind and the wait before it dials again; and the frames against
   `vectors/wire.json`, the ask, the reply, nothing delivered and the
   announce, so a kit reproduces the bytes on a socket; and the request
   reach against the request record in the same file, over a fetch that
@@ -1457,6 +1488,12 @@ passes the same suite. Those tests are the checklist, not the mock.
   one by one; that the arithmetic spends every one of them; and the two ways
   a terrain can be short -- no `crypto.subtle` at all, and a subtle without
   the curves -- each failing at the first call, in one sentence.
+- `test/package.test.ts`: the package as a stranger meets it. The tarball
+  is packed, installed into an empty folder with nothing but Node, and
+  every entry point the exports map names is imported. Every other suite
+  reaches the source through a path or a workspace link, which resolves
+  outside `node_modules`, where Node strips types; this is the one that
+  cannot.
 - `test/bundle.test.ts`: the three words bundled as a consumer must bundle
   them, the artefact read for anything a terrain cannot provide, and then the
   whole conformance suite run out of the bundle.
@@ -1492,17 +1529,7 @@ passes the same suite. Those tests are the checklist, not the mock.
 The only place this document may name a gap between itself and the tree.
 Each line is a debt to close, not a note to keep.
 
-- **An announce is believed.** A side that opens a socket to a listener and
-  announces a ward pk is bound to it, and nothing asks whether it holds that
-  ward. So anyone who can reach a rendezvous can announce a pk that is not
-  theirs, and asks for that pk are carried to them instead of to the harbor
-  that holds it. They learn nothing by it: what arrives is sealed to a ward
-  key they do not have, and they cannot answer, because a reply is signed by
-  that ward. What they take is reachability, which is the one thing a
-  rendezvous exists to give. Measured on the lab, 2026-09-04. The shape of
-  the answer is a proof at the announce, the ward signing something the
-  listener chose, so that binding a pk needs the key behind it; that is a
-  decision this document has not taken.
+None today.
 
 ## Open
 

package/dist/being/being.d.ts

@@ -0,0 +1,22 @@
+import type { Asker, Blueprint, Cells, Invitation, JsonObject, Wanted, OccupantRecord, Occupants, Reply, Schema, Stance, Standings, Answer } from './types.ts';
+export type AskSpec = {
+    description?: string;
+    input?: Schema;
+    output?: Schema;
+    for?: (occupant: OccupantRecord | undefined, asker: Asker) => boolean;
+};
+export declare class Being {
+    static cells: JsonObject;
+    static asks: Record<string, AskSpec>;
+    readonly stance: Stance;
+    constructor(stance: Stance);
+    get cells(): Cells;
+    get standings(): Standings;
+    get occupants(): Occupants;
+    invite(id: string): Promise<Invitation | null>;
+    knock(invitation: Invitation, method?: string, args?: JsonObject, wanted?: Wanted): Promise<Answer>;
+    take(id: string, invitation: Invitation): Promise<string | null>;
+    occupant(asker: Asker): OccupantRecord | undefined;
+    describe(asker: Asker): Blueprint;
+    answer(asker: Asker, method?: string, args?: JsonObject): Promise<Reply>;
+}

package/dist/being/being.js

@@ -0,0 +1,78 @@
+// Names a subclass may not use for an ask, because they are the base's own.
+const RESERVED = new Set(['answer', 'describe', 'stance', 'cells', 'standings', 'occupants', 'occupant', 'invite', 'knock', 'take', 'constructor']);
+export class Being {
+    // Her cells' defaults. Merged in at birth, only where a key is missing, so
+    // a restart keeps what she wrote.
+    static cells = {};
+    // What she can be asked. Declaration order is blueprint order.
+    static asks = {};
+    stance;
+    constructor(stance) {
+        this.stance = stance;
+        const C = this.constructor;
+        for (const name of Object.keys(C.asks)) {
+            if (RESERVED.has(name))
+                throw new Error(`ask '${name}' is a reserved name`);
+            if (typeof this[name] !== 'function')
+                throw new Error(`ask '${name}' has no method`);
+        }
+        for (const [k, v] of Object.entries(C.cells))
+            if (!(k in stance.cells))
+                stance.cells[k] = structuredClone(v);
+    }
+    get cells() {
+        return this.stance.cells;
+    }
+    get standings() {
+        return this.stance.standings;
+    }
+    get occupants() {
+        return this.stance.occupants;
+    }
+    invite(id) {
+        return this.stance.occupants.invite(id);
+    }
+    knock(invitation, method, args, wanted) {
+        return this.stance.standings.knock(invitation, method, args, wanted);
+    }
+    take(id, invitation) {
+        return this.stance.standings.take(id, invitation);
+    }
+    // The occupant record for whoever is at the door. Undefined at a public being.
+    occupant(asker) {
+        return asker.id === undefined ? undefined : this.cells.occupants[asker.id];
+    }
+    // Her blueprint for this asker. Override to shape it by hand.
+    describe(asker) {
+        const C = this.constructor;
+        const rec = this.occupant(asker);
+        const asks = [];
+        for (const [name, spec] of Object.entries(C.asks)) {
+            if (spec.for && !spec.for(rec, asker))
+                continue;
+            const ask = { name, input: spec.input ?? { type: 'object' } };
+            if (spec.description !== undefined)
+                ask.description = spec.description;
+            if (spec.output !== undefined)
+                ask.output = spec.output;
+            asks.push(ask);
+        }
+        return { asks, notes: {} };
+    }
+    // The one function. Override to wrap it; call super to keep the dispatch.
+    async answer(asker, method, args = {}) {
+        if (method === undefined)
+            return this.describe(asker);
+        const C = this.constructor;
+        // Declared, by her, on purpose. `asks` is an ordinary object, so a bare
+        // lookup would also find every name on Object's prototype: `valueOf`
+        // 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
+        // has always shown. What she shows is what she can be asked.
+        const spec = typeof method === 'string' && 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[method];
+        return fn.call(this, args ?? {}, asker);
+    }
+}

package/dist/being/digest.d.ts

@@ -0,0 +1,3 @@
+import type { Json } from './types.ts';
+export declare const canonical: (v: Json) => string;
+export declare const digest: (blueprint: Json) => Promise<string>;

package/dist/being/digest.js

@@ -0,0 +1,19 @@
+// A value I-JSON has no room for: a key left empty, a function, a symbol.
+// None of them cross an edge, so none of them may reach a digest. A key
+// carrying one is dropped and a slot carrying one is null, which is what
+// crossing does to them, so the digest names what arrived and not what she
+// happened to be holding.
+const absent = (v) => v === undefined || typeof v === 'function' || typeof v === 'symbol';
+// JCS for I-JSON values: sorted keys, no whitespace, JSON escaping. Numbers
+// are serialized as ES does, which is what RFC 8785 specifies.
+export const canonical = (v) => Array.isArray(v)
+    ? `[${v.map((slot) => (absent(slot) ? 'null' : canonical(slot))).join(',')}]`
+    : v !== null && typeof v === 'object'
+        ? `{${Object.keys(v)
+            .filter((k) => !absent(v[k]))
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${canonical(v[k])}`)
+            .join(',')}}`
+        : JSON.stringify(v);
+const hex = (bytes) => Array.from(new Uint8Array(bytes), (b) => b.toString(16).padStart(2, '0')).join('');
+export const digest = async (blueprint) => hex(await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(canonical(blueprint))));

package/dist/being/index.d.ts

@@ -0,0 +1,5 @@
+export { Being, type AskSpec } from './being.ts';
+export { silence, isSilence, unreached, isUnreached } from './silence.ts';
+export { digest, canonical } from './digest.ts';
+export { OWNER, PUBLIC, RESERVED_IDS } from './types.ts';
+export type * from './types.ts';

package/dist/being/index.js

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: Apache-2.0
+// @quo-systems/quo — the Being side. What a being author imports, if anything.
+export { Being } from './being.js';
+export { silence, isSilence, unreached, isUnreached } from './silence.js';
+export { digest, canonical } from './digest.js';
+export { OWNER, PUBLIC, RESERVED_IDS } from './types.js';

package/dist/being/silence.d.ts

@@ -0,0 +1,5 @@
+import { type Unreached } from './types.ts';
+export declare const silence: unique symbol;
+export declare const isSilence: (x: unknown) => x is typeof silence;
+export declare const unreached: () => Unreached;
+export declare const isUnreached: (x: unknown) => x is Unreached;

package/dist/being/silence.js

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: Apache-2.0
+// Silence is one distinguished value. Null is an answer. Silence is no answer.
+import { UNREACHED_KEY } from './types.js';
+export const silence = Symbol.for('quo.silence');
+export const isSilence = (x) => x === silence;
+// Unreached is the ward's own word: no far door was reached. It carries no
+// reason. Safe to retry, because nothing was delivered. A being cannot
+// produce it: a ward that sees it come out of a being treats it as silence.
+const UNREACHED = Object.freeze({ [UNREACHED_KEY]: true });
+export const unreached = () => UNREACHED;
+export const isUnreached = (x) => x !== null && typeof x === 'object' && x[UNREACHED_KEY] === true;

package/dist/being/types.d.ts

@@ -0,0 +1,80 @@
+import type { silence } from './silence.ts';
+export type Json = null | boolean | number | string | Json[] | {
+    [key: string]: Json;
+};
+export type JsonObject = {
+    [key: string]: Json;
+};
+export type Asker = {
+    id: string;
+} | {
+    id?: undefined;
+};
+export declare const OWNER = "OWNER";
+export declare const PUBLIC = "PUBLIC";
+export declare const RESERVED_IDS: readonly string[];
+export type Invitation = {
+    ward: string;
+    heir?: string;
+    secret?: string;
+};
+export type Schema = JsonObject;
+export type Ask = {
+    name: string;
+    description?: string;
+    input: Schema;
+    output?: Schema;
+};
+export type Blueprint = {
+    asks: Ask[];
+    notes: Json;
+};
+export type StandingRecord = {
+    id: string;
+    digest: string | null;
+    blueprint: Blueprint | null;
+    seen: string | null;
+};
+export type OccupantRecord = {
+    id: string;
+    notes: JsonObject;
+};
+export type Cells = {
+    standings: Record<string, StandingRecord>;
+    occupants: Record<string, OccupantRecord>;
+    [hers: string]: Json;
+};
+export type Silence = typeof silence;
+export type Unreached = {
+    readonly [K in typeof UNREACHED_KEY]: true;
+};
+export declare const UNREACHED_KEY: unique symbol;
+export type Answer = Json | Silence | Unreached;
+export type Reply = Json | Silence;
+export type Wanted = {
+    time?: number;
+};
+export type Standing = {
+    readonly id: string;
+    ask(method?: string, args?: JsonObject, wanted?: Wanted): Promise<Answer>;
+};
+export type Standings = {
+    knock(invitation: Invitation, method?: string, args?: JsonObject, wanted?: Wanted): Promise<Answer>;
+    take(id: string, invitation: Invitation): Promise<string | null>;
+    remove(id: string): void;
+} & {
+    readonly [id: string]: Standing | undefined;
+};
+export type Occupants = {
+    invite(id: string): Promise<Invitation | null>;
+    remove(id: string): void;
+};
+export type Stance = {
+    readonly cells: Cells;
+    readonly occupants: Occupants;
+    readonly standings: Standings;
+};
+export interface BeingLike {
+    answer(asker: Asker, method?: string, args?: JsonObject): Reply | Promise<Reply>;
+}
+export type BeingClass = new (stance: Stance) => BeingLike;

package/dist/being/types.js

@@ -0,0 +1,16 @@
+// The ids the ward speaks under, and no being may mint. An asker id is hers:
+// she chooses the strings, and the ward has no business in her namespace. But
+// the ward must sometimes stand at her door itself — its describe asks every
+// being under OWNER — and an id it shares with one of her occupants is two
+// different parties wearing one name. She could not tell them apart, and the
+// ward would shape its describe through an occupant's gate.
+//
+// So the ward's words are shouted, and refused at the mint. A word can only
+// be reserved before anyone has used it: a partition already holding an
+// occupant of that name could never have it taken back. PUBLIC guards nothing
+// today — a public asker is {} and carries no id at all — and that is exactly
+// why it is claimed now, while claiming it is free.
+export const OWNER = 'OWNER';
+export const PUBLIC = 'PUBLIC';
+export const RESERVED_IDS = [OWNER, PUBLIC];
+export const UNREACHED_KEY = Symbol.for('quo.unreached');

package/dist/conformance/assert.d.ts

@@ -0,0 +1,11 @@
+export declare class Failed extends Error {
+}
+export declare function same(a: unknown, b: unknown): boolean;
+export type Assert = {
+    ok(value: unknown, message?: string): asserts value;
+    equal(actual: unknown, expected: unknown, message?: string): void;
+    notEqual(actual: unknown, expected: unknown, message?: string): void;
+    deepEqual(actual: unknown, expected: unknown, message?: string): void;
+    match(actual: string, re: RegExp, message?: string): void;
+};
+export declare const assert: Assert;

package/dist/conformance/assert.js

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: Apache-2.0
+// The five assertions the conformance suite makes, and no more. Node has all
+// five in `node:assert/strict`, and naming that module would tie the suite to
+// one terrain -- the suite is the ward's truth, and the ward's truth has to be
+// checkable wherever a ward runs. So they are written here, in the language
+// alone, and `test/assert.test.ts` holds them to Node's own behaviour.
+export class Failed extends Error {
+}
+const show = (v) => {
+    if (typeof v === 'symbol')
+        return v.toString();
+    if (typeof v === 'bigint')
+        return `${v}n`;
+    if (v === undefined)
+        return 'undefined';
+    if (typeof v === 'function')
+        return `[function ${v.name}]`;
+    try {
+        return JSON.stringify(v) ?? Object.prototype.toString.call(v);
+    }
+    catch {
+        return Object.prototype.toString.call(v); // a cycle, or a null prototype
+    }
+};
+const fail = (why, message) => {
+    throw new Failed(message ? `${message}: ${why}` : why);
+};
+// 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.
+export function same(a, b) {
+    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;
+    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);
+    if (ka.length !== kb.length)
+        return false;
+    return ka.every((k) => kb.includes(k) && same(a[k], b[k]));
+}
+export const assert = {
+    ok(value, message) {
+        if (!value)
+            fail(`${show(value)} is not truthy`, message);
+    },
+    equal(actual, expected, message) {
+        if (!Object.is(actual, expected))
+            fail(`${show(actual)} !== ${show(expected)}`, message);
+    },
+    notEqual(actual, expected, message) {
+        if (Object.is(actual, expected))
+            fail(`${show(actual)} === ${show(expected)}`, message);
+    },
+    deepEqual(actual, expected, message) {
+        if (!same(actual, expected))
+            fail(`${show(actual)} is not ${show(expected)}`, message);
+    },
+    match(actual, re, message) {
+        if (typeof actual !== 'string' || !re.test(actual))
+            fail(`${show(actual)} does not match ${String(re)}`, message);
+    },
+};

package/dist/conformance/beings.d.ts

@@ -0,0 +1,114 @@
+import { Being } from '../being/being.ts';
+import type { Asker, Blueprint, Invitation, JsonObject, OccupantRecord, Reply, Stance } from '../being/types.ts';
+export declare class Printer extends Being {
+    static cells: {
+        jobs: JsonObject[];
+        asks: JsonObject[];
+    };
+    static asks: {
+        print: {
+            input: {
+                type: string;
+            };
+        };
+    };
+    describe(): Blueprint;
+    print({ doc }: JsonObject, asker: Asker): {
+        printed: string | number | boolean | import("../being/types.ts").Json[] | {
+            [key: string]: import("../being/types.ts").Json;
+        } | null;
+    };
+}
+export declare class Shop extends Being {
+    static cells: {
+        printerId: string | null;
+        sales: JsonObject[];
+        minted: number;
+    };
+    static asks: {
+        hello: {
+            input: {
+                type: string;
+            };
+        };
+        buy: {
+            input: {
+                type: string;
+                properties: {
+                    item: {
+                        type: string;
+                    };
+                };
+            };
+        };
+        refund: {
+            input: {
+                type: string;
+            };
+            for: (rec: OccupantRecord | undefined) => boolean;
+        };
+    };
+    answer(asker: Asker, method?: string, args?: JsonObject): Promise<Reply>;
+    invite(tier?: string): Promise<Invitation>;
+    keepPrinter(invitation: Invitation): Promise<boolean>;
+    hello({ invitation }: JsonObject, asker: Asker): Promise<{
+        welcome: boolean;
+    }>;
+    buy({ item }: JsonObject, asker: Asker): Promise<{
+        error: string;
+        retry?: undefined;
+        ok?: undefined;
+        receipt?: undefined;
+    } | {
+        error: string;
+        retry: boolean;
+        ok?: undefined;
+        receipt?: undefined;
+    } | {
+        error?: undefined;
+        retry?: undefined;
+        ok: boolean;
+        receipt: import("../being/types.ts").Json;
+    }>;
+    refund(): {
+        ok: boolean;
+    };
+}
+export declare class Customer extends Being {
+    static cells: {
+        heard: JsonObject[];
+    };
+    static asks: {
+        hi: {
+            input: {
+                type: string;
+            };
+        };
+    };
+    join(invitation: Invitation): Promise<typeof import("../being/silence.ts").silence | import("../being/types.ts").Unreached | import("../being/types.ts").Json>;
+    buy(item: string): Promise<import("../being/types.ts").Answer>;
+    learn(): Promise<import("../being/types.ts").Answer>;
+    hi(_args: JsonObject, asker: Asker): {
+        heard: string;
+    };
+}
+export declare class Echo {
+    s: Stance;
+    constructor(stance: Stance);
+    answer(asker: Asker, method?: string, args?: JsonObject): Reply;
+}
+export declare class Member extends Being {
+    static cells: {
+        heard: JsonObject[];
+    };
+    static asks: {
+        ping: {
+            input: {
+                type: string;
+            };
+        };
+    };
+    ping(_args: JsonObject, asker: Asker): {
+        pong: string | null;
+    };
+}