@quo-systems/quo 0.1.0

package/src/ward/ward.ts

@@ -0,0 +1,209 @@
+// SPDX-License-Identifier: Apache-2.0
+// A ward that is its own ward. Booted by a harbor with one object, the
+// ground, and hands back two pointers: the door and the ask. Boots itself as
+// the first being in its own map, and every being it later instantiates gets
+// a stance built by the same code. Mints every key, seals every ask that
+// leaves, opens every one that arrives.
+import { silence, isSilence, unreached, isUnreached } from '../being/silence.ts';
+import { OWNER } from '../being/types.ts';
+import type { Asker, BeingLike, Cells, JsonObject, Reply, Stance, Wanted } from '../being/types.ts';
+import type { Ground, WardPointers } from './ground.ts';
+import { at, open, put, emptyBind, emptyCells, type Bind, type Partition, type StandingKeys } from './partition.ts';
+import { Heirs } from './heirs.ts';
+import { makeDoor, type Door } from './door.ts';
+import { buildStance } from './stance.ts';
+import { ownerAnswer } from './owner.ts';
+import { allow, within, LATE } from './allowance.ts';
+import { beingKey, openReply, sealAsk, wardKey, wardPadlock, wardSignPk, type ReplyPayload, type WardKey } from './seal.ts';
+import { unhex } from './arithmetic.ts';
+import { guardCells, cellFault } from './cells.ts';
+
+type Booted = Door & { bind: Bind; stance: Stance; cells: Cells & { class?: string } };
+
+// 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: Ground): Promise<WardPointers> {
+  const w = await Self.boot(ground);
+  return { door: w.door, ask: w.ask };
+}
+
+class Self implements BeingLike {
+  readonly key: WardKey;
+  readonly pk: string;
+  readonly g: Ground;
+  readonly p: Partition;
+  readonly heirs: Heirs;
+  readonly doors = new Map<string, Booted>();
+  readonly door: WardPointers['door'];
+  readonly ask: WardPointers['ask'];
+
+  static async boot(ground: Ground): Promise<Self> {
+    return new Self(ground, await wardKey(ground.seed));
+  }
+
+  private constructor(ground: Ground, key: WardKey) {
+    this.g = ground;
+    this.key = key;
+    this.pk = key.pk;
+    this.p = open(ground.memory); // the partition IS the ward's cells
+    this.heirs = new Heirs(this.p);
+    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
+    // 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 answer: silence,
+    // and nothing half-lives. This boot nobody asked for, and there is nobody
+    // to hand a silence to. Any constructor may throw — a default that is not
+    // a value, an author's mistake, a shape she no longer recognises after an
+    // upgrade — and let through here it is one being taking down the ward and
+    // every other being in it, on a restart. She is absent instead: no door,
+    // so silence at the door, and her cells sit untouched, waiting for the
+    // run that can read them.
+    for (const [k, c] of Object.entries(this.p.beings)) {
+      if (k === this.pk || !c.class) continue;
+      try {
+        this.#instantiate(k, c.class);
+      } catch {
+        /* she is not here this run. the ward is, and so is everyone else. */
+      }
+    }
+    // pointer two. the owner. the same answer every named asker gets, asker filled in as owner.
+    this.ask = async (method, args = {}) => {
+      try {
+        const out = await this.answer({ id: OWNER }, method, args as JsonObject);
+        return isSilence(out) || isUnreached(out) ? silence : out;
+      } catch {
+        return silence;
+      }
+    };
+  }
+
+  // ---- the ward as a being. asked only by its owners: the root, through
+  // the ask pointer, and its occupants, through the door, whom only the root
+  // can invite. A stranger cannot be a named asker here, because the door
+  // names nobody the ward did not bind.
+  async answer(asker: Asker, method?: string, args: JsonObject = {}): Promise<Reply> {
+    if (asker.id === undefined) return { error: 'unknown ask' };
+    return ownerAnswer(
+      {
+        pk: this.pk,
+        doors: this.doors,
+        publicKey: () => this.p.public,
+        instantiate: (key, className, isPublic) => this.#instantiate(key, className, isPublic),
+      },
+      asker,
+      method,
+      args,
+    );
+  }
+
+  // ---- ward functions. on the object. no stance reaches them.
+  #instantiate(key: string, className: string, isPublic = false): Booted | null {
+    if (!key || this.doors.has(key)) return null;
+    const door = this.#boot(key, className);
+    if (!door) return null;
+    door.cells.class = className; // so a restart finds her
+    if (isPublic) this.p.public = key;
+    return door;
+  }
+
+  // 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: string, classNameOrSelf: string | Self): Booted | null {
+    const cells = guardCells(at(this.p.beings, key) ?? emptyCells());
+    const bind = at(this.p.bind, key) ?? emptyBind();
+    const stance = buildStance(
+      {
+        pk: this.pk,
+        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),
+      },
+      key,
+      cells,
+      bind,
+    );
+    const being = classNameOrSelf === this ? this : this.g.instantiate(classNameOrSelf as string, stance);
+    if (!being) return null;
+    put(this.p.beings, key, cells);
+    put(this.p.bind, key, bind);
+    const door: Booted = { key, cells, bind, stance, being };
+    this.doors.set(key, door);
+    return door;
+  }
+
+  async #mintKey(bind: Bind): Promise<{ seed: string; pk: string }> {
+    const k = await beingKey(this.g.random(32));
+    // The last few she 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. Nothing is read from this
+    // but the keys of the moment.
+    bind.minted.push(k.pk);
+    if (bind.minted.length > MINTED) bind.minted.splice(0, bind.minted.length - MINTED);
+    return k;
+  }
+
+  // One send for every door, the ward's own included. Mine: never leaves.
+  // Not mine: carry. Signs as the standing's current key, announces its
+  // 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: Bind, keys: StandingKeys, announce: boolean, method: string | undefined, args: JsonObject, wanted?: Wanted): Promise<ReplyPayload | typeof silence | ReturnType<typeof unreached>> {
+    // 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.
+    const budget = allow(wanted);
+    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) 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
+    // far door honours each number once. One relation sends one at a time, so
+    // the numbers leave in the order they were taken.
+    const seq = (keys.seq += 1);
+    // Args that will not go through the seal are args that never left. A
+    // being holds three answers and a throw is not one of them, so an ask
+    // that cannot be sealed is told what is true of it: no door was reached.
+    // Values only, by the same rule her cells keep: a Date would arrive as a
+    // string, a function would not arrive at all, and she would never know
+    // the far being was asked something other than what she said.
+    if (cellFault(args, 'args') !== null) return unreached();
+    let sealed;
+    try {
+      sealed = await sealAsk(keys.heir, { by, next, seq, time: budget.time, method, args }, unhex(keys.current), wardPadlock(keys.ward), this.g.random(32));
+    } catch {
+      return unreached();
+    }
+    const { bytes, ephemeral } = sealed;
+    // The wait is bounded, and this is the one thing the ward times. A being
+    // holds three answers and a wait that does not end is none of them: a
+    // relation that comes back round holds a lane the answer needs, and only a
+    // bound on the wait can break that. What comes back late is not read.
+    //
+    // A wait that ran out is silence, never unreached. Unreached promises
+    // nothing was delivered and is safe to retry; a bound that expired knows
+    // no such thing, because the far door may have heard and be working still.
+    //
+    // A harbor answers bytes or nothing. One that throws instead has answered
+    // nothing in a louder voice, and is read as nothing: no door was reached.
+    const carried = (keys.ward === this.pk ? this.door(new Uint8Array(bytes)) : this.g.carry(keys.ward, bytes)).then(
+      (b) => b,
+      () => undefined,
+    );
+    const out = await within(budget.time, carried);
+    if (out === LATE) return silence;
+    if (out === undefined) return unreached(); // nothing came back. no door was reached.
+    const reply = await openReply(out, ephemeral, wardSignPk(keys.ward));
+    if (!reply) return silence; // did not open, or not from that ward
+    if (!('silence' in reply) && keys.next !== null) {
+      keys.current = keys.next; // the far door holds `next` as announced. move to it.
+      keys.next = null;
+    }
+    return reply;
+  }
+}

package/vectors/arithmetic.json

@@ -0,0 +1,110 @@
+{
+  "corpus": "@quo-systems/quo",
+  "encoding": "hex",
+  "area": "arithmetic",
+  "vectors": [
+    {
+      "name": "SHA-256 of nothing",
+      "input": "",
+      "hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    },
+    {
+      "name": "SHA-256 of three bytes",
+      "input": "616263",
+      "hash": "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+    },
+    {
+      "name": "an Ed25519 pair from a fixed secret",
+      "secret": "2ebd74bd564a8771fa628b28308c588588f5c0d0db17ae06b045b896d8218ad7",
+      "pk": "be6615086e715c9cea8856a892c7e363cc2401b5edccadb49b347a8bee22c6e2"
+    },
+    {
+      "name": "an X25519 pair from a fixed secret",
+      "secret": "7dbcdb3088339c02378f46525bff3fe2b84515973e28f5814301a99f386e20b1",
+      "pk": "bb0109e1147cb2b716f9407f947b0c47a8c3c18ce00339dc02df47c54fd1e202"
+    },
+    {
+      "name": "a signature over nothing",
+      "secret": "2ebd74bd564a8771fa628b28308c588588f5c0d0db17ae06b045b896d8218ad7",
+      "voice": "be6615086e715c9cea8856a892c7e363cc2401b5edccadb49b347a8bee22c6e2",
+      "message": "",
+      "signature": "6e5517c3c92afd95e6956d974a2c39045677472c8736cf13f7e400dd9d843d7d161334c55166383bd2f33eea2312953778ecf7180a70868c4802350f1a896006"
+    },
+    {
+      "name": "a signature over a message",
+      "secret": "2ebd74bd564a8771fa628b28308c588588f5c0d0db17ae06b045b896d8218ad7",
+      "voice": "be6615086e715c9cea8856a892c7e363cc2401b5edccadb49b347a8bee22c6e2",
+      "message": "62792077686f736520617574686f72697479",
+      "signature": "60aa62f7129c8fdeba710872fa10016dae1aa12df0f31969a6baabf60b2ebc3d0822cc9a8b1eb12246076b2eea69d381a03c2f581c05ba6bcca3b4ba80c2f504"
+    },
+    {
+      "name": "a signature under the wrong voice does not verify",
+      "voice": "efc15f8742c6c2755887d9e83884dd30b69d25548ef299cdd296053be9c0df99",
+      "message": "62792077686f736520617574686f72697479",
+      "signature": "60aa62f7129c8fdeba710872fa10016dae1aa12df0f31969a6baabf60b2ebc3d0822cc9a8b1eb12246076b2eea69d381a03c2f581c05ba6bcca3b4ba80c2f504",
+      "refuses": true
+    },
+    {
+      "name": "a signature over other bytes does not verify",
+      "voice": "be6615086e715c9cea8856a892c7e363cc2401b5edccadb49b347a8bee22c6e2",
+      "message": "62792077686f736520617574686f7269747920",
+      "signature": "60aa62f7129c8fdeba710872fa10016dae1aa12df0f31969a6baabf60b2ebc3d0822cc9a8b1eb12246076b2eea69d381a03c2f581c05ba6bcca3b4ba80c2f504",
+      "refuses": true
+    },
+    {
+      "name": "a signature under an all-zero public key is silence",
+      "voice": "0000000000000000000000000000000000000000000000000000000000000000",
+      "message": "62792077686f736520617574686f72697479",
+      "signature": "60aa62f7129c8fdeba710872fa10016dae1aa12df0f31969a6baabf60b2ebc3d0822cc9a8b1eb12246076b2eea69d381a03c2f581c05ba6bcca3b4ba80c2f504",
+      "refuses": true
+    },
+    {
+      "name": "a signature under a small-order public key is silence",
+      "voice": "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05",
+      "message": "62792077686f736520617574686f72697479",
+      "signature": "60aa62f7129c8fdeba710872fa10016dae1aa12df0f31969a6baabf60b2ebc3d0822cc9a8b1eb12246076b2eea69d381a03c2f581c05ba6bcca3b4ba80c2f504",
+      "refuses": true
+    },
+    {
+      "name": "an X25519 agreement",
+      "secret": "fcfabee71b7a33993cca5579e6a273ffd1c62cc1749cbf1c9049f599e44f6477",
+      "pk": "bb0109e1147cb2b716f9407f947b0c47a8c3c18ce00339dc02df47c54fd1e202",
+      "shared": "3d33d3f6044552ecd30503ba772b3d4f69544da0b3a4a46bfa63b056bb191833"
+    },
+    {
+      "name": "the agreement is the same from either side",
+      "secret": "7dbcdb3088339c02378f46525bff3fe2b84515973e28f5814301a99f386e20b1",
+      "pk": "17ff733c9cffec197551af9aaf710b7b07a4d7aeffc9894d6e89b10df3d2d011",
+      "shared": "3d33d3f6044552ecd30503ba772b3d4f69544da0b3a4a46bfa63b056bb191833"
+    },
+    {
+      "name": "forty-four bytes drawn under the fixed info, key then nonce",
+      "info": "71756f2d7365616c",
+      "salt": "",
+      "shared": "3d33d3f6044552ecd30503ba772b3d4f69544da0b3a4a46bfa63b056bb191833",
+      "key": "c55777b57b5a972030441a03e03f9ed5bfcaadcccb1511c853afcc2547a451f5",
+      "nonce": "b3a7c637499e0d3ee8606dc2"
+    },
+    {
+      "name": "AES-256-GCM with the ephemeral pk as the additional data",
+      "shared": "3d33d3f6044552ecd30503ba772b3d4f69544da0b3a4a46bfa63b056bb191833",
+      "additional": "17ff733c9cffec197551af9aaf710b7b07a4d7aeffc9894d6e89b10df3d2d011",
+      "plaintext": "62792077686f736520617574686f72697479",
+      "ciphertext": "94eaa19e94fa885635d4a863c94240629cce6573a9109c0c445cade99fea551ff366"
+    },
+    {
+      "name": "a ciphertext with one byte turned does not open",
+      "shared": "3d33d3f6044552ecd30503ba772b3d4f69544da0b3a4a46bfa63b056bb191833",
+      "additional": "17ff733c9cffec197551af9aaf710b7b07a4d7aeffc9894d6e89b10df3d2d011",
+      "ciphertext": "95eaa19e94fa885635d4a863c94240629cce6573a9109c0c445cade99fea551ff366",
+      "refuses": true
+    },
+    {
+      "name": "a ciphertext under other additional data does not open",
+      "shared": "3d33d3f6044552ecd30503ba772b3d4f69544da0b3a4a46bfa63b056bb191833",
+      "additional": "bb0109e1147cb2b716f9407f947b0c47a8c3c18ce00339dc02df47c54fd1e202",
+      "ciphertext": "94eaa19e94fa885635d4a863c94240629cce6573a9109c0c445cade99fea551ff366",
+      "refuses": true
+    }
+  ]
+}

package/vectors/framing.json

@@ -0,0 +1,71 @@
+{
+  "corpus": "@quo-systems/quo",
+  "encoding": "hex",
+  "area": "framing",
+  "note": "The formats a second kit must reproduce byte for byte: the ward pk, the digest, the signed ask body, the sealed ask, the sealed reply, the invitation and the knock. Every random input is fixed here, so every output is fixed. The ask body is JSON.stringify of the payload, which is not canonical: these vectors pin the key order sealAsk writes, to, by, next, seq, time, method, args; hops is in no vector, because nothing sets it. A kit that emits another order still interoperates, because a door verifies the bytes it received, but it will not reproduce these vectors. An invitation is JSON too, ward, heir, secret, and a heir secret is the seed of a being key. A knock is an ask whose by is the heir pk, signed with the heir secret, whose next is the knocker's own key, and whose to is the heir; its answer is an ordinary reply, and the heir is spent by it. The ward here is the one from the ward pk vector, and the heir secret is the first entropy it draws, so the invitation it mints and the knock its door binds are these bytes.",
+  "vectors": [
+    {
+      "name": "a ward pk from a fixed seed",
+      "seed": "1111111111111111111111111111111111111111111111111111111111111111",
+      "pk": "d04ab232742bb4ab3a1368bd4615e4e6d0224ab71a016baf8520a332c97787377b4e909bbe7ffe44c465a220037d608ee35897d31ef972f07f74892cb0f73f13",
+      "signPk": "d04ab232742bb4ab3a1368bd4615e4e6d0224ab71a016baf8520a332c9778737",
+      "padlockPk": "7b4e909bbe7ffe44c465a220037d608ee35897d31ef972f07f74892cb0f73f13"
+    },
+    {
+      "name": "a being key from a fixed secret",
+      "secret": "2222222222222222222222222222222222222222222222222222222222222222",
+      "pk": "a09aa5f47a6759802ff955f8dc2d2a14a5c99d23be97f864127ff9383455a4f0"
+    },
+    {
+      "name": "the digest is SHA-256 of the canonical form",
+      "blueprint": "{\"asks\":{\"hello\":{\"note\":\"z\"}},\"note\":null,\"list\":[1,2]}",
+      "canonical": "{\"asks\":{\"hello\":{\"note\":\"z\"}},\"list\":[1,2],\"note\":null}",
+      "digest": "269c9e90f39f6fcae9deab916e3a4148788dec5ba0d06023edc8e52180c773db"
+    },
+    {
+      "name": "the signed ask body, and its signature",
+      "payload": "{\"by\":\"a09aa5f47a6759802ff955f8dc2d2a14a5c99d23be97f864127ff9383455a4f0\",\"next\":null,\"seq\":1,\"time\":30000,\"method\":\"hello\",\"args\":{\"name\":\"quo\"}}",
+      "body": "7b226279223a2261303961613566343761363735393830326666393535663864633264326131346135633939643233626539376638363431323766663933383334353561346630222c226e657874223a6e756c6c2c22736571223a312c2274696d65223a33303030302c226d6574686f64223a2268656c6c6f222c2261726773223a7b226e616d65223a2271756f227d7d",
+      "secret": "2222222222222222222222222222222222222222222222222222222222222222",
+      "signature": "21fae42dc81de4a1983ac9dd457338043e3e69ba76331cb5616f3106e007de228fee0f19c49035b90789799667bc7de4d4212618790b2b449e5a26c299134c0b"
+    },
+    {
+      "name": "a sealed ask to a heir: the ephemeral pk, then the box, and nothing outside it",
+      "to": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "ephemeralSeed": "3333333333333333333333333333333333333333333333333333333333333333",
+      "bytes": "7b0d47d93427f8311160781c7c733fd89f88970aef490d8aa0ee19a4cb8a1b14ed97840c789fc01f8b362dff17c11793d230bc13c4f56401abbbd7c4d26ac0379164fc07794e29b8c9330328f8ae2b3b6280d1fb1ced6ef44c54478381be4834444d3c7c4c7258d7653f481e9bc5cc78394fc9d6742edef6a13e3273f24ab212205f83ca25640d301110062940e3bf2cde21dd1707111e240a6de0674a98ef941decb3e0112bcb444576485a180437b1d2ddb5e0773a527c12d781bc669572bafe8d0f1c31396b5e25e354309d9cd8584c8eaa7c6b0ffc97ca3963a997a289254e498dc597b196720a0a70860815f474c56aee9e0d6a1bd2949d314819e9ea7565e379f8d4d8f60bc4243b117ba9b39ab74ef949f7c916843da444c5387118697317ab720ffd10e9954db6e766664e4e7f9e9e09f05df2dc1ff7f47a4fbd419964db60f395043f6a3a"
+    },
+    {
+      "name": "a sealed ask for nobody: the same shape, with to null inside",
+      "to": "",
+      "ephemeralSeed": "3333333333333333333333333333333333333333333333333333333333333333",
+      "bytes": "7b0d47d93427f8311160781c7c733fd89f88970aef490d8aa0ee19a4cb8a1b14ed97840c789f8c0b863b60bc14d954c89130ed4bc4f53006feedd793843e986ec037fb00211a7dbf9036017bfdfd2b6b378085f944b56ba71e5743dbd7b91163111d6f2a4b7500c6712e1e528c9eda7f395484952f2d92b5e2326b33a71eae02355ccbdd2a331976064b0f7e03e8b87ddb72d402414e4832073bb323488cb3c043b7baa4043a920516305f01574069f2939af9bf2d3f05295edf908316e73499bd7932d14673cfb6e89f68b52b6e7edebb44f36a03b7f4c87b723eb601f2142d97d94ad2ae07b44d1a9ab7f1e0c91bf2e210d66d85a298c9509b39a652868391296be1e21fcc909f97305b"
+    },
+    {
+      "name": "the sealed silence reply",
+      "reply": "{\"silence\":true}",
+      "replySeed": "4444444444444444444444444444444444444444444444444444444444444444",
+      "bytes": "ff2ee45601ec1b67310c7790404585ae697331eee1c1f8cf2419731c1fff3e6b76ec8fe27c6573176a8974f1235379842eeabe08f92c8aae00e383195ff41cbb2124de81119eb83326fbb9b8ab00a149ce41ea21f6c056a324333cc76b82c93ac93fbcc3fc74f57a1bff4a07a0c7824ed5516b7fb8a14006a25f6c28d95e4e64"
+    },
+    {
+      "name": "a sealed object reply",
+      "reply": "{\"object\":{\"hi\":\"quo\"},\"seen\":null}",
+      "replySeed": "4444444444444444444444444444444444444444444444444444444444444444",
+      "bytes": "ff2ee45601ec1b67310c7790404585ae697331eee1c1f8cf2419731c1fff3e6b76ec93e97a657e002d9135a7394f3ec33bcd723c9d8947909f4cc659d8dfeed743f5b64bfa87b4ac79074219c1032037de444400b509f31559331b7995f9dfbadbe7fb0f6d46db2257db70f248b7739b3baa2ca79b07b66b29ea680faf79340f2309163c9e3c65fcdb33297c419d1cd8517647"
+    },
+    {
+      "name": "an invitation for a heir: the ward pk, the heir pk, the heir secret, and nothing else",
+      "wardSeed": "1111111111111111111111111111111111111111111111111111111111111111",
+      "heirSecret": "4444444444444444444444444444444444444444444444444444444444444444",
+      "invitation": "{\"ward\":\"d04ab232742bb4ab3a1368bd4615e4e6d0224ab71a016baf8520a332c97787377b4e909bbe7ffe44c465a220037d608ee35897d31ef972f07f74892cb0f73f13\",\"heir\":\"d759793bbc13a2819a827c76adb6fba8a49aee007f49f2d0992d99b825ad2c48\",\"secret\":\"4444444444444444444444444444444444444444444444444444444444444444\"}"
+    },
+    {
+      "name": "a sealed knock: the first ask under a heir, by the heir, announcing her own key, to the heir",
+      "heirSecret": "4444444444444444444444444444444444444444444444444444444444444444",
+      "ownSecret": "5555555555555555555555555555555555555555555555555555555555555555",
+      "ephemeralSeed": "6666666666666666666666666666666666666666666666666666666666666666",
+      "payload": "{\"to\":\"d759793bbc13a2819a827c76adb6fba8a49aee007f49f2d0992d99b825ad2c48\",\"by\":\"d759793bbc13a2819a827c76adb6fba8a49aee007f49f2d0992d99b825ad2c48\",\"next\":\"c6822637c7d310ec57627be00ba259d253749f4aaf644470cffbe53a35f73242\",\"seq\":1,\"time\":30000,\"method\":\"hello\",\"args\":{\"name\":\"quo\"}}",
+      "bytes": "219e4d800da968d2a5fcb009c784f4746c7138edb9ee4844b739e830b05cf424263fd9388d350e13808f15e9297f753dd517db9f8eeca10de0708fd81a3b3c1b5444da304de91ae98fa4b94a62dae0673bdc0a7c6d97e445f8e08c5c3094b9facda3fa828caced7992ed8989f85a05dbe67da08c06b47b4e56174fe60e8169fc56c78d0966281c47c9b5300cca473e57d43e954b9d424ceb5a49eba9a4a79cd8b5973d21cdeb70f35b988314f68dcb5736003eb1a56c9be4087005fb5ae7d719eb39860ffb4220871161b76395054ab09ee5a323b6eea9a01f31d436b2a12983d5c32d887377e9d9ea845ecd4690660336e5e3e34d1c46f7e648e5a0d81f7a28ae2a52cc3021d10fe29de5c67b9f487b42f34a3e0149856ce8ee8cc8a90860daf624e0ffc758cd3600f069218abe5abdaa3041783add308fa4110899d216831e0016f5357a194344eb3551e48f0cb70f86b51fa68815c51660615034d2abdf3078c649bcca47fd769001b31928108e3ec9f0c1108e6ceec9a32c5ddd542c4543a1b8260936b3e5"
+    }
+  ]
+}

package/vectors/wire.json

@@ -0,0 +1,48 @@
+{
+  "corpus": "@quo-systems/quo",
+  "encoding": "hex",
+  "area": "wire",
+  "note": "The frames on a socket reach, which a second kit reproduces byte for byte: an ask is one kind byte 00, a four-byte big-endian frame id, the 64-byte ward pk and the sealed bytes; a reply is kind 01, the id and the bytes; nothing delivered is kind 02 and the id alone. The one text frame is JSON, {\"announce\":[pk,...],\"suite\":1}, the ward pks a side holds and the wire suite it speaks, sent when the line opens and whenever the pks change. The suite is which frames these are and which four algorithms seal what they carry; it is one value, never negotiated, and it rides in the handshake and never on an ask, so an ask stays bytes nobody can tell from noise. A side meeting a suite it does not know carries nothing for it and closes with code 4001, which names the refusal so the far side is not left reconnecting without ever being told why. A request reach has no frame: the sealed bytes are the body of a POST to the URL with the pk as its last segment, carrying the suite as the header quo-suite, the sealed reply is the body of a 200, and a 404 is nothing delivered, which is what a door answers a suite it does not speak. The ids here are the first a socket mints, one, and the sealed bytes are stand-ins, since the frame reads nothing.",
+  "vectors": [
+    {
+      "name": "an ask frame: kind, id, pk, bytes",
+      "id": 1,
+      "pk": "d04ab232742bb4ab3a1368bd4615e4e6d0224ab71a016baf8520a332c97787377b4e909bbe7ffe44c465a220037d608ee35897d31ef972f07f74892cb0f73f13",
+      "bytes": "010203",
+      "frame": "0000000001d04ab232742bb4ab3a1368bd4615e4e6d0224ab71a016baf8520a332c97787377b4e909bbe7ffe44c465a220037d608ee35897d31ef972f07f74892cb0f73f13010203"
+    },
+    {
+      "name": "a reply frame: kind, id, bytes",
+      "id": 1,
+      "bytes": "2a",
+      "frame": "01000000012a"
+    },
+    {
+      "name": "a none frame: kind and id, nothing delivered",
+      "id": 1,
+      "frame": "0200000001"
+    },
+    {
+      "name": "the announce frame, text",
+      "pks": [
+        "d04ab232742bb4ab3a1368bd4615e4e6d0224ab71a016baf8520a332c97787377b4e909bbe7ffe44c465a220037d608ee35897d31ef972f07f74892cb0f73f13"
+      ],
+      "frame": "{\"announce\":[\"d04ab232742bb4ab3a1368bd4615e4e6d0224ab71a016baf8520a332c97787377b4e909bbe7ffe44c465a220037d608ee35897d31ef972f07f74892cb0f73f13\"],\"suite\":1}",
+      "suite": 1
+    },
+    {
+      "name": "the request door: no frame, one POST, the suite in a header, 200 and 404",
+      "method": "POST",
+      "url": "<base>/<pk>",
+      "headers": {
+        "content-type": "application/octet-stream",
+        "quo-suite": "1"
+      },
+      "body": "the sealed ask bytes",
+      "replies": {
+        "200": "the sealed reply bytes",
+        "404": "nothing delivered"
+      }
+    }
+  ]
+}