nervur 0.19.0 → 0.19.1

package/dist/harbor/reach.js

@@ -20,6 +20,7 @@
 // A reach that sent the bytes and lost the line afterwards answers nothing
 // at all, and the ward's own bound ends the ask.
 import { concat, hex, unhex } from '../ward/arithmetic.js';
+import { readJson } from '../ward/json.js';
 const never = () => new Promise(() => { }); // sent, and no word since: the ward's bound decides
 // A request reach to one listener.
 export function request(url) {
@@ -111,7 +112,9 @@ export class Socket {
         line.addEventListener('message', (e) => {
             if (typeof e.data === 'string') {
                 try {
-                    const m = JSON.parse(e.data);
+                    const m = readJson(e.data);
+                    if (m === null || typeof m !== 'object')
+                        return;
                     // Absent is this suite: a side that says nothing says one.
                     if (m.suite !== undefined && m.suite !== SUITE) {
                         this.far = [];
@@ -129,9 +132,14 @@ export class Socket {
                 return;
             }
             const buf = e.data instanceof ArrayBuffer ? new Uint8Array(e.data) : ArrayBuffer.isView(e.data) ? new Uint8Array(e.data.buffer, e.data.byteOffset, e.data.byteLength) : undefined;
+            // A frame that is none of the three is not a frame: an unknown kind, an
+            // ask too short to hold a pk, a nothing with bytes after its id. It is
+            // dropped, and tells no ask waiting on its id that nothing was delivered.
             if (!buf || buf.length < 5)
                 return;
             const kind = buf[0], id = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(1);
+            if (kind > NONE || (kind === ASK && buf.length < 69) || (kind === NONE && buf.length !== 5))
+                return;
             if (kind === ASK) {
                 const pk = hex(buf.subarray(5, 69));
                 // A deliver that rejects has delivered nothing this side can vouch

package/dist/vector/stand.js

@@ -18,6 +18,7 @@
 // world runs on.
 import { SUITE } from '../harbor/reach.js';
 import { hex } from '../ward/arithmetic.js';
+import { readJson } from '../ward/json.js';
 import { caseNamed, stand } from './cases.js';
 import { partitionDigest } from './world.js';
 const CORS = {
@@ -39,7 +40,7 @@ export class Stand {
         if (method === 'POST' && p === '/stand') {
             let named;
             try {
-                named = JSON.parse(new TextDecoder().decode(body));
+                named = readJson(body);
             }
             catch {
                 return NONE;

package/dist/ward/arithmetic.js

@@ -59,8 +59,10 @@ export function sameBytes(a, b) {
         diff |= a[at] ^ b[at];
     return diff === 0;
 }
-// The eight small-order points of Ed25519, in their canonical encoding. A
-// public key among them verifies nothing. An encoding whose y coordinate is
+// The eight small-order points of Ed25519, in their canonical encoding, and
+// the two points with x = 0 spelled with the sign bit set, which a decoder
+// that ignores the bit reads as the same point. A public key among them
+// verifies nothing. An encoding whose y coordinate is
 // not reduced, y at or above the field's prime p, names one of the same
 // points under another spelling, and a terrain's verify may accept a zero
 // signature under it; the field has room for the spelling, so it is refused
@@ -74,6 +76,8 @@ const SMALL_ORDER = [
     'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a',
     '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85',
     'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa',
+    '0100000000000000000000000000000000000000000000000000000000000080',
+    'ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
 ].map(unhex);
 // y >= p, read little-endian with the sign bit masked off: the top byte is
 // 0x7f under the mask, every middle byte is 0xff, and the low byte is at

package/dist/ward/json.d.ts

@@ -0,0 +1,2 @@
+export declare function numberFault(literal: string): string | null;
+export declare function readJson(input: Uint8Array | string): unknown;

package/dist/ward/json.js

@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: Apache-2.0
+// The one reader of JSON that crossed an edge. A runtime's own parser is
+// where two kits stop agreeing: it keeps the last of two keys of one name,
+// rounds a whole number no double holds, reads a number past the doubles as
+// infinity, and mends bytes that are not UTF-8 into a replacement character.
+// Each of those is text two kits read two ways, so each is refused here, where
+// it is read, with a throw the caller already turns into what bytes that said
+// nothing are.
+//
+// What a value is beyond its text, a lone surrogate, a key named `__proto__`,
+// a nesting past the bound, is the value rule's, and `cellFault` in cells.ts
+// is its one reader. This file holds the rules that live only in the text.
+const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+const fail = (at, why) => {
+    throw new Error(`JSON at ${at}: ${why}`);
+};
+// A number text, held to the Values chapter. A text naming a whole number
+// stands only if that number is exactly a double, or if the text is how
+// ECMAScript writes the double it reads as. A text past the largest double,
+// or naming a value other than zero that rounds to zero, is refused, and so
+// is minus zero in any spelling.
+export function numberFault(literal) {
+    const m = /^(-?)(0|[1-9]\d*)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(literal);
+    if (!m)
+        return 'not a number';
+    const [, sign, whole, frac = '', exp = '0'] = m;
+    const v = Number(literal);
+    if (!Number.isFinite(v))
+        return 'past the largest double';
+    let digits = (whole + frac).replace(/^0+/, '');
+    if (v === 0) {
+        if (digits !== '')
+            return 'a value other than zero that rounds to zero';
+        return sign ? 'minus zero' : null;
+    }
+    // The exact value is digits times ten to e. A finite double bounds e from
+    // above, so the power below is never larger than the double's own width.
+    let e = BigInt(exp) - BigInt(frac.length);
+    const trimmed = digits.replace(/0+$/, '');
+    e += BigInt(digits.length - trimmed.length);
+    digits = trimmed;
+    if (e < 0n)
+        return null; // a fraction: the double nearest it, as every reader takes it
+    const exact = BigInt(digits) * 10n ** e;
+    if (exact === (v < 0 ? -BigInt(v) : BigInt(v)))
+        return null;
+    return literal === String(v) ? null : 'a whole number that is not exactly a double';
+}
+// Bytes to a value, or a throw.
+export function readJson(input) {
+    const s = typeof input === 'string' ? input : utf8.decode(input);
+    let at = 0;
+    const space = () => {
+        for (;;) {
+            const c = s.charCodeAt(at);
+            if (c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d)
+                at += 1;
+            else
+                return;
+        }
+    };
+    const string = () => {
+        const start = at;
+        at += 1;
+        for (;;) {
+            const c = s.charCodeAt(at);
+            if (Number.isNaN(c))
+                fail(start, 'an unterminated string');
+            if (c === 0x22)
+                break;
+            if (c < 0x20)
+                fail(at, 'a control character in a string');
+            at += c === 0x5c ? 2 : 1;
+        }
+        at += 1;
+        // The escapes are JSON's own, and the runtime reads them the one way.
+        return JSON.parse(s.slice(start, at));
+    };
+    const value = () => {
+        space();
+        const c = s[at];
+        if (c === '{') {
+            at += 1;
+            const out = {};
+            const keys = new Set();
+            space();
+            if (s[at] === '}') {
+                at += 1;
+                return out;
+            }
+            for (;;) {
+                space();
+                if (s[at] !== '"')
+                    fail(at, 'a key that is not a string');
+                const where = at;
+                const k = string();
+                if (keys.has(k))
+                    fail(where, `two keys named ${JSON.stringify(k)}`);
+                keys.add(k);
+                space();
+                if (s[at] !== ':')
+                    fail(at, 'a key with no colon');
+                at += 1;
+                // Defined, never assigned: a key named `__proto__` is an own key here
+                // as it is in JSON.parse, and the value rule refuses it after.
+                Object.defineProperty(out, k, { value: value(), enumerable: true, writable: true, configurable: true });
+                space();
+                if (s[at] === ',')
+                    at += 1;
+                else if (s[at] === '}') {
+                    at += 1;
+                    return out;
+                }
+                else
+                    fail(at, 'an object not closed');
+            }
+        }
+        if (c === '[') {
+            at += 1;
+            const out = [];
+            space();
+            if (s[at] === ']') {
+                at += 1;
+                return out;
+            }
+            for (;;) {
+                out.push(value());
+                space();
+                if (s[at] === ',')
+                    at += 1;
+                else if (s[at] === ']') {
+                    at += 1;
+                    return out;
+                }
+                else
+                    fail(at, 'a list not closed');
+            }
+        }
+        if (c === '"')
+            return string();
+        for (const [word, v] of [['true', true], ['false', false], ['null', null]]) {
+            if (s.startsWith(word, at)) {
+                at += word.length;
+                return v;
+            }
+        }
+        const m = /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+        m.lastIndex = at;
+        const hit = m.exec(s);
+        if (!hit)
+            return fail(at, 'no value');
+        const why = numberFault(hit[0]);
+        if (why !== null)
+            fail(at, `${hit[0]} is ${why}`);
+        at += hit[0].length;
+        return Number(hit[0]);
+    };
+    const out = value();
+    space();
+    if (at !== s.length)
+        fail(at, 'text after the value');
+    return out;
+}

package/dist/ward/seal.js

@@ -1,8 +1,8 @@
 import { isDoorWord } from '../being/silence.js';
 import { KEY, SIGNATURE, box, concat, derive, hex, sha256, sign, signingPair, sealingPair, unbox, unhex, verify } from './arithmetic.js';
 import { cellFault } from './cells.js';
+import { readJson } from './json.js';
 const utf8 = new TextEncoder();
-const text = new TextDecoder();
 // 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
@@ -70,7 +70,7 @@ export async function openAsk(bytes, padlockSecret) {
             return null;
         const body = inside.subarray(0, inside.length - SIGNATURE);
         const signature = inside.subarray(inside.length - SIGNATURE);
-        const payload = JSON.parse(text.decode(body));
+        const payload = readJson(body);
         // 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;
@@ -112,7 +112,9 @@ export async function sealReply(reply, ephemeralPk, wardSign, seed) {
 // lied, or it is not a reply. Every ward on the wire is somebody else's code,
 // so the shape is checked here and nowhere later: a reply is `{ silence }`,
 // `{ quo: word }` with a word the door may say, or `{ object, seen }` with an
-// object present and seen a digest or null.
+// object that is a value and seen a digest or null. A field beside a shape's
+// own makes it none of the three, since a kit that dropped the field would
+// hand her an answer where this one hands her silence.
 // Anything else is bytes that said nothing, and her ward never hands her a
 // throw or an absent value for what a stranger wrote.
 export async function openReply(bytes, ephemeralSecret, signPk) {
@@ -125,18 +127,21 @@ export async function openReply(bytes, ephemeralSecret, signPk) {
         const body = inside.subarray(0, inside.length - SIGNATURE);
         if (!(await verify(body, inside.subarray(inside.length - SIGNATURE), signPk)))
             return null;
-        const reply = JSON.parse(text.decode(body));
+        const reply = readJson(body);
         if (reply === null || typeof reply !== 'object' || Array.isArray(reply))
             return null;
         const r = reply;
-        if (r.silence === true)
-            return { silence: true };
-        if (Object.hasOwn(r, 'quo'))
+        const keys = Object.keys(r).sort().join(',');
+        if (keys === 'silence')
+            return r.silence === true ? { silence: true } : null;
+        if (keys === 'quo')
             return isDoorWord(r.quo) ? { quo: r.quo } : null;
-        if (!Object.hasOwn(r, 'object') || r.object === undefined)
+        if (keys !== 'object,seen')
             return null;
         if (r.seen !== null && !isHex(r.seen))
             return null;
+        if (cellFault(r.object, 'object') !== null)
+            return null; // values in both directions: nested past the bound is none of the shapes
         return { object: r.object, seen: r.seen };
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nervur",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "description": "Nervur's kit of Quo: an object asks another object and gets an answer, without knowing where it is. Being, Ward, Harbor.",
   "keywords": [
     "quo",

package/src/harbor/reach.ts

@@ -20,6 +20,7 @@
 // A reach that sent the bytes and lost the line afterwards answers nothing
 // at all, and the ward's own bound ends the ask.
 import { concat, hex, unhex } from '../ward/arithmetic.ts';
+import { readJson } from '../ward/json.ts';
 
 export type Carry = (pk: string, bytes: Uint8Array) => Promise<Uint8Array | undefined>;
 export type Reach = { carry: Carry; close(): void };
@@ -136,7 +137,8 @@ export class Socket implements Reach {
     line.addEventListener('message', (e) => {
       if (typeof e.data === 'string') {
         try {
-          const m = JSON.parse(e.data) as { announce?: unknown; suite?: unknown };
+          const m = readJson(e.data) as { announce?: unknown; suite?: unknown };
+          if (m === null || typeof m !== 'object') return;
           // Absent is this suite: a side that says nothing says one.
           if (m.suite !== undefined && m.suite !== SUITE) {
             this.far = [];
@@ -153,9 +155,13 @@ export class Socket implements Reach {
         return;
       }
       const buf = e.data instanceof ArrayBuffer ? new Uint8Array(e.data) : ArrayBuffer.isView(e.data) ? new Uint8Array(e.data.buffer, e.data.byteOffset, e.data.byteLength) : undefined;
+      // A frame that is none of the three is not a frame: an unknown kind, an
+      // ask too short to hold a pk, a nothing with bytes after its id. It is
+      // dropped, and tells no ask waiting on its id that nothing was delivered.
       if (!buf || buf.length < 5) return;
       const kind = buf[0],
         id = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(1);
+      if (kind > NONE || (kind === ASK && buf.length < 69) || (kind === NONE && buf.length !== 5)) return;
       if (kind === ASK) {
         const pk = hex(buf.subarray(5, 69));
         // A deliver that rejects has delivered nothing this side can vouch

package/src/vector/stand.ts

@@ -18,6 +18,7 @@
 // world runs on.
 import { SUITE } from '../harbor/reach.ts';
 import { hex } from '../ward/arithmetic.ts';
+import { readJson } from '../ward/json.ts';
 import { caseNamed, stand } from './cases.ts';
 import type { World } from './world.ts';
 import { partitionDigest } from './world.ts';
@@ -44,7 +45,7 @@ export class Stand {
     if (method === 'POST' && p === '/stand') {
       let named: { case?: unknown; name?: unknown };
       try {
-        named = JSON.parse(new TextDecoder().decode(body)) as typeof named;
+        named = readJson(body) as typeof named;
       } catch {
         return NONE;
       }

package/src/ward/arithmetic.ts

@@ -58,8 +58,10 @@ export function sameBytes(a: Uint8Array, b: Uint8Array): boolean {
   return diff === 0;
 }
 
-// The eight small-order points of Ed25519, in their canonical encoding. A
-// public key among them verifies nothing. An encoding whose y coordinate is
+// The eight small-order points of Ed25519, in their canonical encoding, and
+// the two points with x = 0 spelled with the sign bit set, which a decoder
+// that ignores the bit reads as the same point. A public key among them
+// verifies nothing. An encoding whose y coordinate is
 // not reduced, y at or above the field's prime p, names one of the same
 // points under another spelling, and a terrain's verify may accept a zero
 // signature under it; the field has room for the spelling, so it is refused
@@ -73,6 +75,8 @@ const SMALL_ORDER = [
   'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a',
   '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85',
   'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa',
+  '0100000000000000000000000000000000000000000000000000000000000080',
+  'ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
 ].map(unhex);
 // y >= p, read little-endian with the sign bit masked off: the top byte is
 // 0x7f under the mask, every middle byte is 0xff, and the low byte is at

package/src/ward/json.ts

@@ -0,0 +1,144 @@
+// SPDX-License-Identifier: Apache-2.0
+// The one reader of JSON that crossed an edge. A runtime's own parser is
+// where two kits stop agreeing: it keeps the last of two keys of one name,
+// rounds a whole number no double holds, reads a number past the doubles as
+// infinity, and mends bytes that are not UTF-8 into a replacement character.
+// Each of those is text two kits read two ways, so each is refused here, where
+// it is read, with a throw the caller already turns into what bytes that said
+// nothing are.
+//
+// What a value is beyond its text, a lone surrogate, a key named `__proto__`,
+// a nesting past the bound, is the value rule's, and `cellFault` in cells.ts
+// is its one reader. This file holds the rules that live only in the text.
+
+const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+
+const fail = (at: number, why: string): never => {
+  throw new Error(`JSON at ${at}: ${why}`);
+};
+
+// A number text, held to the Values chapter. A text naming a whole number
+// stands only if that number is exactly a double, or if the text is how
+// ECMAScript writes the double it reads as. A text past the largest double,
+// or naming a value other than zero that rounds to zero, is refused, and so
+// is minus zero in any spelling.
+export function numberFault(literal: string): string | null {
+  const m = /^(-?)(0|[1-9]\d*)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/.exec(literal);
+  if (!m) return 'not a number';
+  const [, sign, whole, frac = '', exp = '0'] = m;
+  const v = Number(literal);
+  if (!Number.isFinite(v)) return 'past the largest double';
+  let digits = (whole + frac).replace(/^0+/, '');
+  if (v === 0) {
+    if (digits !== '') return 'a value other than zero that rounds to zero';
+    return sign ? 'minus zero' : null;
+  }
+  // The exact value is digits times ten to e. A finite double bounds e from
+  // above, so the power below is never larger than the double's own width.
+  let e = BigInt(exp) - BigInt(frac.length);
+  const trimmed = digits.replace(/0+$/, '');
+  e += BigInt(digits.length - trimmed.length);
+  digits = trimmed;
+  if (e < 0n) return null; // a fraction: the double nearest it, as every reader takes it
+  const exact = BigInt(digits) * 10n ** e;
+  if (exact === (v < 0 ? -BigInt(v) : BigInt(v))) return null;
+  return literal === String(v) ? null : 'a whole number that is not exactly a double';
+}
+
+// Bytes to a value, or a throw.
+export function readJson(input: Uint8Array | string): unknown {
+  const s = typeof input === 'string' ? input : utf8.decode(input);
+  let at = 0;
+  const space = () => {
+    for (;;) {
+      const c = s.charCodeAt(at);
+      if (c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d) at += 1;
+      else return;
+    }
+  };
+  const string = (): string => {
+    const start = at;
+    at += 1;
+    for (;;) {
+      const c = s.charCodeAt(at);
+      if (Number.isNaN(c)) fail(start, 'an unterminated string');
+      if (c === 0x22) break;
+      if (c < 0x20) fail(at, 'a control character in a string');
+      at += c === 0x5c ? 2 : 1;
+    }
+    at += 1;
+    // The escapes are JSON's own, and the runtime reads them the one way.
+    return JSON.parse(s.slice(start, at)) as string;
+  };
+  const value = (): unknown => {
+    space();
+    const c = s[at];
+    if (c === '{') {
+      at += 1;
+      const out: Record<string, unknown> = {};
+      const keys = new Set<string>();
+      space();
+      if (s[at] === '}') {
+        at += 1;
+        return out;
+      }
+      for (;;) {
+        space();
+        if (s[at] !== '"') fail(at, 'a key that is not a string');
+        const where = at;
+        const k = string();
+        if (keys.has(k)) fail(where, `two keys named ${JSON.stringify(k)}`);
+        keys.add(k);
+        space();
+        if (s[at] !== ':') fail(at, 'a key with no colon');
+        at += 1;
+        // Defined, never assigned: a key named `__proto__` is an own key here
+        // as it is in JSON.parse, and the value rule refuses it after.
+        Object.defineProperty(out, k, { value: value(), enumerable: true, writable: true, configurable: true });
+        space();
+        if (s[at] === ',') at += 1;
+        else if (s[at] === '}') {
+          at += 1;
+          return out;
+        } else fail(at, 'an object not closed');
+      }
+    }
+    if (c === '[') {
+      at += 1;
+      const out: unknown[] = [];
+      space();
+      if (s[at] === ']') {
+        at += 1;
+        return out;
+      }
+      for (;;) {
+        out.push(value());
+        space();
+        if (s[at] === ',') at += 1;
+        else if (s[at] === ']') {
+          at += 1;
+          return out;
+        } else fail(at, 'a list not closed');
+      }
+    }
+    if (c === '"') return string();
+    for (const [word, v] of [['true', true], ['false', false], ['null', null]] as const) {
+      if (s.startsWith(word, at)) {
+        at += word.length;
+        return v;
+      }
+    }
+    const m = /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+    m.lastIndex = at;
+    const hit = m.exec(s);
+    if (!hit) return fail(at, 'no value');
+    const why = numberFault(hit[0]);
+    if (why !== null) fail(at, `${hit[0]} is ${why}`);
+    at += hit[0].length;
+    return Number(hit[0]);
+  };
+  const out = value();
+  space();
+  if (at !== s.length) fail(at, 'text after the value');
+  return out;
+}

package/src/ward/seal.ts

@@ -23,9 +23,9 @@ import type { DoorWord, Json, JsonObject } from '../being/types.ts';
 import { isDoorWord } from '../being/silence.ts';
 import { KEY, SIGNATURE, box, concat, derive, hex, sha256, sign, signingPair, sealingPair, unbox, unhex, verify } from './arithmetic.ts';
 import { cellFault } from './cells.ts';
+import { readJson } from './json.ts';
 
 const utf8 = new TextEncoder();
-const text = new TextDecoder();
 
 export type WardKey = { sign: Uint8Array; padlock: Uint8Array; signPk: Uint8Array; padlockPk: Uint8Array; pk: string };
 
@@ -115,7 +115,7 @@ export async function openAsk(bytes: Uint8Array, padlockSecret: Uint8Array): Pro
     if (inside.length <= SIGNATURE) return null;
     const body = inside.subarray(0, inside.length - SIGNATURE);
     const signature = inside.subarray(inside.length - SIGNATURE);
-    const payload = JSON.parse(text.decode(body)) as Sealed;
+    const payload = readJson(body) as Sealed;
     // 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;
@@ -150,7 +150,9 @@ export async function sealReply(reply: ReplyPayload, ephemeralPk: Uint8Array, wa
 // lied, or it is not a reply. Every ward on the wire is somebody else's code,
 // so the shape is checked here and nowhere later: a reply is `{ silence }`,
 // `{ quo: word }` with a word the door may say, or `{ object, seen }` with an
-// object present and seen a digest or null.
+// object that is a value and seen a digest or null. A field beside a shape's
+// own makes it none of the three, since a kit that dropped the field would
+// hand her an answer where this one hands her silence.
 // Anything else is bytes that said nothing, and her ward never hands her a
 // throw or an absent value for what a stranger wrote.
 export async function openReply(bytes: unknown, ephemeralSecret: Uint8Array, signPk: Uint8Array): Promise<ReplyPayload | null> {
@@ -160,13 +162,15 @@ export async function openReply(bytes: unknown, ephemeralSecret: Uint8Array, sig
     if (inside.length <= SIGNATURE) return null;
     const body = inside.subarray(0, inside.length - SIGNATURE);
     if (!(await verify(body, inside.subarray(inside.length - SIGNATURE), signPk))) return null;
-    const reply = JSON.parse(text.decode(body)) as unknown;
+    const reply = readJson(body);
     if (reply === null || typeof reply !== 'object' || Array.isArray(reply)) return null;
     const r = reply as Record<string, unknown>;
-    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;
+    const keys = Object.keys(r).sort().join(',');
+    if (keys === 'silence') return r.silence === true ? { silence: true } : null;
+    if (keys === 'quo') return isDoorWord(r.quo) ? { quo: r.quo } : null;
+    if (keys !== 'object,seen') return null;
     if (r.seen !== null && !isHex(r.seen)) return null;
+    if (cellFault(r.object, 'object') !== null) return null; // values in both directions: nested past the bound is none of the shapes
     return { object: r.object as Json, seen: r.seen };
   } catch {
     return null;