@joe-broadhead/messaging 0.0.0-stage → 0.7.1

package/dist/lib/modules/core/schema/relay.js

@@ -0,0 +1,112 @@
+/**
+ * Relay binding (urn:messaging:binding:relay:v1): JSON text frames over one WebSocket per machine.
+ * Each frame is one JSON object of at most LIMITS.frameBytes, discriminated by `t`.
+ * Receivers ignore frames with an unknown `t` (forward compatibility); they never drop the link for it.
+ *
+ * Connection:
+ *   relay  → challenge {nonce}
+ *   client → [pre-auth, optional] join {team, inviteId, proof} → relay: roster {entries}   (only for an open invite)
+ *            proof = Ed25519(invite seed, DOMAIN.inviteJoin + JCS({relay, team, inviteId, nonce})), verified under invitePub
+ *   client → [pre-auth, optional] roster.append {entry}  (genesis to create a team, or invite.redeem to join)
+ *   client → hello {team, machine, ts, sig}   sig = Ed25519(DOMAIN.relayAuth + JCS({proto, relay, team, machine, nonce, ts}))
+ *   relay  → welcome {head, online}, then the latest presence envelope of every member, then queued deliveries
+ *
+ * After welcome:
+ *   send {env}          relay checks header + signature + membership, stores, forwards; replies ack|nack by env.id
+ *   deliver {env}       relay → recipient. Recipient replies recv.ack {id} after storing durably; the relay then drops it
+ *   presence {env}      relay keeps the latest per machine and fans it out to online team members as deliver
+ *   roster.append       admin entries; relay validates against its head, appends, replies roster.ok, broadcasts roster
+ *   roster.sync {after} relay replies roster {entries with seq > after}
+ *   peer {machine, online} relay → members on connect/disconnect
+ * When a member is removed, the relay closes its connection with code 4003.
+ */
+import { z } from "../../vendor/zod/index.js";
+import { Base64Url, MachineId, Millis, RELAY_PROTOCOL, TeamId, Ulid } from "./common.js";
+import { Envelope } from "./envelope.js";
+import { ErrorCode } from "./errors.js";
+import { RosterEntry, RosterHead } from "./roster.js";
+const Req = z.string().min(1).max(64);
+// ---- relay → client ----
+export const ChallengeFrame = z.object({
+    t: z.literal("challenge"),
+    proto: z.literal(RELAY_PROTOCOL),
+    relay: z.string().min(1).describe("relay id the client signs, e.g. its public origin"),
+    nonce: Base64Url,
+});
+export const WelcomeFrame = z.object({ t: z.literal("welcome"), head: RosterHead, online: z.array(MachineId) });
+/**
+ * Deliveries are parsed loosely so a v1 client can still ack (and answer with a rejected receipt) an
+ * envelope type added later and forwarded by a newer relay. The daemon verifies the raw envelope itself.
+ */
+export const DeliverFrame = z.object({
+    t: z.literal("deliver"),
+    env: z.looseObject({ v: z.string(), id: Ulid, type: z.string() }),
+});
+export const AckFrame = z.object({ t: z.literal("ack"), id: Ulid, stage: z.literal("relayed") });
+/** `retryAfterMs`: with `rate_limited` from a directory frame (spec §7, "Directory frames"), when to ask again. */
+export const NackFrame = z.object({
+    t: z.literal("nack"),
+    id: z.string(),
+    code: ErrorCode,
+    message: z.string().max(500),
+    retryAfterMs: z.number().int().positive().optional(),
+});
+/** `more`: the reply was paged; ask again with `after` = the last entry's seq. */
+export const RosterFrame = z.object({
+    t: z.literal("roster"),
+    req: Req.optional(),
+    entries: z.array(RosterEntry),
+    more: z.boolean().optional(),
+});
+export const RosterOkFrame = z.object({ t: z.literal("roster.ok"), req: Req, head: RosterHead });
+export const PeerFrame = z.object({ t: z.literal("peer"), machine: MachineId, online: z.boolean() });
+export const ErrorFrame = z.object({ t: z.literal("error"), code: ErrorCode, message: z.string().max(500) });
+export const PongFrame = z.object({ t: z.literal("pong") });
+export const RelayToClient = z.discriminatedUnion("t", [
+    ChallengeFrame,
+    WelcomeFrame,
+    DeliverFrame,
+    AckFrame,
+    NackFrame,
+    RosterFrame,
+    RosterOkFrame,
+    PeerFrame,
+    ErrorFrame,
+    PongFrame,
+]);
+// ---- client → relay ----
+export const JoinFrame = z.object({
+    t: z.literal("join"),
+    req: Req,
+    team: TeamId,
+    inviteId: Ulid,
+    /** Ed25519(invite seed, DOMAIN.inviteJoin + JCS({relay, team, inviteId, nonce})) for this connection's challenge; see `inviteJoinProof`. */
+    proof: Base64Url,
+    after: z.number().int().min(-1).optional().describe("page: entries with seq > after"),
+});
+export const RosterAppendFrame = z.object({ t: z.literal("roster.append"), req: Req, entry: RosterEntry });
+export const HelloFrame = z.object({ t: z.literal("hello"), team: TeamId, machine: MachineId, ts: Millis, sig: Base64Url });
+export const SendFrame = z.object({ t: z.literal("send"), env: Envelope });
+export const RecvAckFrame = z.object({ t: z.literal("recv.ack"), id: Ulid });
+export const PresenceFrame = z.object({ t: z.literal("presence"), env: Envelope });
+export const RosterSyncFrame = z.object({ t: z.literal("roster.sync"), req: Req, after: z.number().int().min(-1) });
+export const PingFrame = z.object({ t: z.literal("ping") });
+export const ClientToRelay = z.discriminatedUnion("t", [
+    JoinFrame,
+    RosterAppendFrame,
+    HelloFrame,
+    SendFrame,
+    RecvAckFrame,
+    PresenceFrame,
+    RosterSyncFrame,
+    PingFrame,
+]);
+/** WebSocket close codes used by the relay. */
+export const RELAY_CLOSE = {
+    authFailed: 4001,
+    protocolError: 4002,
+    removed: 4003,
+    replaced: 4004, // the same machine connected again; the older socket is closed
+    full: 1013, // RFC 6455 "try again later": the relay holds as many authenticated connections as it accepts
+    tooLarge: 1009, // RFC 6455 "message too big", sent by the transport library itself
+};

package/dist/lib/modules/core/schema/roster.js

@@ -0,0 +1,126 @@
+/**
+ * The team roster: an append-only, hash-chained log of signed entries.
+ * The relay sequences appends; every machine verifies the whole chain itself.
+ *
+ *   hash(entry) = SHA-256(UTF-8(JCS(entry))), base64url, over the full entry including sig
+ *   sig         = Ed25519(by, DOMAIN.roster + JCS(entry without sig))
+ *   team id     = hash(genesis)
+ *   proof       = Ed25519(invite seed, DOMAIN.invite + JCS({team, inviteId, member}))   (invite.redeem)
+ *
+ * Authority rules (enforced by `Roster.apply`):
+ *   genesis        seq 0, prev null, by = founder.machine, founder.role = admin
+ *   member.add     by a current admin; machine not already a member; (person, label) not used by a current member
+ *   member.remove  by a current admin, or by the member itself (leave); never the last admin
+ *   member.role    by a current admin; never demotes the last admin
+ *   member.rekey   by the member itself or a current admin; the machine is a current member (never a
+ *                  removed one); replaces only that member's `enc`
+ *   invite.create  by a current admin; expires − ts ≤ LIMITS.ttlMs
+ *   invite.redeem  by the joining machine (by = member.machine); invite open and unexpired at entry ts;
+ *                  proof verifies under the invite's invitePub; member.person and role match the invite;
+ *                  (person, label) not used by a current member. Single use.
+ *   invite.revoke  by a current admin
+ * Every admitted member key (genesis founder, member.add, redeem member) and every invitePub must be a
+ * canonical Ed25519 encoding of a point that is not of small order.
+ * A removed machine can never rejoin with the same key; it must generate a new identity.
+ * Inviting or adding an existing person adds another machine for that person, under another label.
+ */
+import { z } from "../../vendor/zod/index.js";
+import { Base64Url, EncKey, Hash, Key32, MachineId, MachineLabel, MemberRole, Millis, PersonName, PROTOCOL, RelayUrl, TeamId, TeamName, Ulid, } from "./common.js";
+export const Member = z.object({
+    machine: MachineId,
+    enc: EncKey,
+    person: PersonName,
+    role: MemberRole,
+    label: MachineLabel,
+});
+const base = {
+    v: z.literal(PROTOCOL),
+    seq: z.number().int().nonnegative(),
+    ts: Millis,
+    by: MachineId,
+    sig: Base64Url,
+};
+const chained = { ...base, team: TeamId, prev: Hash };
+export const GenesisEntry = z.object({
+    ...base,
+    prev: z.null(),
+    kind: z.literal("genesis"),
+    body: z.object({ name: TeamName, founder: Member }),
+});
+export const MemberAddEntry = z.object({ ...chained, kind: z.literal("member.add"), body: Member });
+export const MemberRemoveEntry = z.object({
+    ...chained,
+    kind: z.literal("member.remove"),
+    body: z.object({ machine: MachineId, reason: z.string().max(200).optional() }),
+});
+export const MemberRoleEntry = z.object({
+    ...chained,
+    kind: z.literal("member.role"),
+    body: z.object({ machine: MachineId, role: MemberRole }),
+});
+/**
+ * Replaces a member's X25519 encryption key. Senders seal to the new `enc` once they have
+ * applied this entry; the member keeps its previous key long enough to open what was sealed before (spec §4).
+ */
+export const MemberRekeyEntry = z.object({
+    ...chained,
+    kind: z.literal("member.rekey"),
+    body: z.object({ machine: MachineId, enc: EncKey }),
+});
+export const InviteCreateEntry = z.object({
+    ...chained,
+    kind: z.literal("invite.create"),
+    body: z.object({
+        inviteId: Ulid,
+        /** Ed25519 public key of the invite seed (the ticket `secret`). Only the seed can make a redeem proof. */
+        invitePub: Key32,
+        person: PersonName,
+        expires: Millis,
+    }),
+});
+export const InviteRedeemEntry = z.object({
+    ...chained,
+    kind: z.literal("invite.redeem"),
+    body: z.object({
+        inviteId: Ulid,
+        /**
+         * Ed25519(invite seed, DOMAIN.invite + JCS({team, inviteId, member})), verified under the invite's
+         * `invitePub`. It binds the redeem to this member's keys, person, role and label; the seed itself
+         * never appears in the roster or on the wire.
+         */
+        proof: Base64Url,
+        member: Member,
+    }),
+});
+export const InviteRevokeEntry = z.object({
+    ...chained,
+    kind: z.literal("invite.revoke"),
+    body: z.object({ inviteId: Ulid }),
+});
+export const RosterEntry = z.discriminatedUnion("kind", [
+    GenesisEntry,
+    MemberAddEntry,
+    MemberRemoveEntry,
+    MemberRoleEntry,
+    MemberRekeyEntry,
+    InviteCreateEntry,
+    InviteRedeemEntry,
+    InviteRevokeEntry,
+]);
+export const RosterHead = z.object({ seq: z.number().int().nonnegative(), hash: Hash });
+/**
+ * Invite ticket, shared out of band. Encoded as `messaging1.` + base64url(UTF-8(JCS(ticket))).
+ * `secret` is the invite seed: a 32-byte Ed25519 private key (RFC 8032 seed) whose public key is the
+ * invite's `invitePub`. The joiner signs its redeem proof with it; the seed never leaves the ticket.
+ */
+export const InviteTicket = z.object({
+    v: z.literal(PROTOCOL),
+    team: TeamId,
+    name: TeamName,
+    relay: RelayUrl,
+    inviteId: Ulid,
+    secret: Key32,
+    person: PersonName,
+    expires: Millis,
+});
+export const TICKET_PREFIX = "messaging1.";

package/dist/lib/modules/core/sign.js

@@ -0,0 +1,43 @@
+import { sign as ed25519Sign, verify as ed25519Verify } from "node:crypto";
+import { b64u, utf8 } from "./b64u.js";
+import { asMessagingError } from "./check.js";
+import { canonicalize } from "./jcs.js";
+import { publicKeyFromRaw } from "./keys.js";
+/** The exact bytes signed: UTF-8(domain) || UTF-8(JCS(value)). Throws `invalid_request` for non-I-JSON. */
+export function signingInput(domain, value) {
+    return Buffer.concat([utf8(domain), utf8(canonicalize(value))]);
+}
+/** Ed25519 signature (base64url) over `domain` + JCS(value). Use a `DOMAIN` prefix. Throws only MessagingError. */
+export function sign(identity, domain, value) {
+    return signWith(identity.signingKey, domain, value);
+}
+/** `sign` with a bare Ed25519 private key, such as an invite seed. */
+export function signWith(key, domain, value) {
+    try {
+        return b64u.encode(ed25519Sign(null, signingInput(domain, value), key));
+    }
+    catch (error) {
+        throw asMessagingError(error, "signing input");
+    }
+}
+/** True only for a valid signature by `machine`. Never throws: malformed keys, values or signatures are false. */
+export function verify(machine, domain, value, sig) {
+    try {
+        return verifyInput(machine, signingInput(domain, value), sig);
+    }
+    catch {
+        return false;
+    }
+}
+/** `verify` over bytes from `signingInput`. Never throws. */
+export function verifyInput(machine, input, sig) {
+    try {
+        const signature = b64u.decode(sig);
+        if (signature.length !== 64)
+            return false;
+        return ed25519Verify(null, input, publicKeyFromRaw("ed25519", machine), signature);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/modules/core/task.js

@@ -0,0 +1,37 @@
+import { INTERRUPTED_STATES, TERMINAL_STATES } from "./schema/a2a.js";
+const NEXT = {
+    TASK_STATE_SUBMITTED: [
+        "TASK_STATE_WORKING",
+        "TASK_STATE_INPUT_REQUIRED",
+        "TASK_STATE_AUTH_REQUIRED",
+        "TASK_STATE_COMPLETED",
+        "TASK_STATE_FAILED",
+        "TASK_STATE_REJECTED",
+        "TASK_STATE_CANCELED",
+    ],
+    TASK_STATE_WORKING: [
+        "TASK_STATE_WORKING",
+        "TASK_STATE_INPUT_REQUIRED",
+        "TASK_STATE_AUTH_REQUIRED",
+        "TASK_STATE_COMPLETED",
+        "TASK_STATE_FAILED",
+        "TASK_STATE_CANCELED",
+    ],
+    TASK_STATE_INPUT_REQUIRED: ["TASK_STATE_WORKING", "TASK_STATE_COMPLETED", "TASK_STATE_FAILED", "TASK_STATE_CANCELED"],
+    TASK_STATE_AUTH_REQUIRED: ["TASK_STATE_WORKING", "TASK_STATE_COMPLETED", "TASK_STATE_FAILED", "TASK_STATE_CANCELED"],
+    TASK_STATE_COMPLETED: [],
+    TASK_STATE_FAILED: [],
+    TASK_STATE_CANCELED: [],
+    TASK_STATE_REJECTED: [],
+};
+/** The task state machine in spec §6.3. Unknown states never transition. */
+export function canTransition(from, to) {
+    return Object.hasOwn(NEXT, from) && NEXT[from].includes(to);
+}
+export function isTerminal(state) {
+    return TERMINAL_STATES.includes(state);
+}
+/** INPUT_REQUIRED or AUTH_REQUIRED: waiting on the requester. */
+export function isInterrupted(state) {
+    return INTERRUPTED_STATES.includes(state);
+}

package/dist/lib/modules/core/testing.js

@@ -0,0 +1,21 @@
+/**
+ * `@messaging/core/testing`: helpers for test vectors and tests that need fixed randomness or envelopes a
+ * conforming sender never makes. Never import this from production code.
+ */
+export { sealEnvelopeWith, sealPlaintext } from "./envelope.js";
+export { encodeTicket } from "./roster.js";
+export { grantHash } from "./delegation.js";
+export { signJellyToken } from "./directory/jelly-issuer.js";
+export { jellyHostDouble } from "./jelly-host-double.js";
+export { sealConvMetaWith, sealConvMsgWith, sealKeySharesWith } from "./conversation/seal.js";
+/**
+ * Narrows a result whose `kind` tells its shape (`item.read`, `conv.read`) to the expected kind, and
+ * throws with both kinds named otherwise: `client.call("item.read", p).then(asKind("received"))`.
+ */
+export function asKind(kind) {
+    return (result) => {
+        if (result.kind !== kind)
+            throw new Error(`expected a ${kind} result, got ${result.kind}`);
+        return result;
+    };
+}

package/dist/lib/modules/core/ulid.js

@@ -0,0 +1,36 @@
+import { randomBytes } from "node:crypto";
+import { MessagingError } from "./schema/errors.js";
+const ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const MAX_TIME = 2 ** 48 - 1;
+/**
+ * A ULID for `now` (default `Date.now()`), with 80 fresh random bits per id. Ids sort by millisecond,
+ * but ids from one millisecond are in random order, so no id predicts another (spec §2).
+ */
+export function ulid(now = Date.now()) {
+    if (!Number.isInteger(now) || now < 0 || now > MAX_TIME)
+        throw new MessagingError("invalid_request", "ulid time out of range");
+    return encodeTime(now) + encodeRandom(randomBytes(10));
+}
+function encodeTime(time) {
+    let out = "";
+    for (let i = 0; i < 10; i++) {
+        out = ALPHABET[time % 32] + out;
+        time = Math.floor(time / 32);
+    }
+    return out;
+}
+function encodeRandom(bytes) {
+    let out = "";
+    let buffer = 0;
+    let bits = 0;
+    for (const byte of bytes) {
+        buffer = (buffer << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            bits -= 5;
+            out += ALPHABET[(buffer >> bits) & 31];
+        }
+        buffer &= (1 << bits) - 1;
+    }
+    return out;
+}

package/dist/lib/modules/core/version.js

@@ -0,0 +1,6 @@
+/**
+ * The release version every Messaging package ships at (they release together). A daemon names it in
+ * its IPC hello and a client compares it with its own (spec §8.2). A test keeps it equal to the
+ * root package.json.
+ */
+export const VERSION = "0.7.1";

package/dist/lib/modules/core/wire.js

@@ -0,0 +1,255 @@
+import { LIMITS } from "./schema/common.js";
+import { MessagingError } from "./schema/errors.js";
+// What the scanner expects next.
+const VALUE = 0; // a value
+const FIRST_VALUE = 1; // a value or `]`, right after `[`
+const NAME = 2; // a member name
+const FIRST_NAME = 3; // a member name or `}`, right after `{`
+const AFTER = 4; // `,`, a closing bracket, or the end of the text
+const ESCAPED = new Map([
+    [0x22, 0x22], // \"
+    [0x5c, 0x5c], // \\
+    [0x2f, 0x2f], // \/
+    [0x62, 0x08], // \b
+    [0x66, 0x0c], // \f
+    [0x6e, 0x0a], // \n
+    [0x72, 0x0d], // \r
+    [0x74, 0x09], // \t
+]);
+/**
+ * Parses JSON text that came from outside the process: a relay frame, an IPC line, a decrypted body,
+ * an invite ticket. It returns exactly what `JSON.parse` returns, after a single linear, iterative
+ * (never recursive) scan that throws `invalid_request` for:
+ * - text that is not RFC 8259 JSON;
+ * - an object with two members of the same name, compared after unescaping;
+ * - arrays and objects nested deeper than `LIMITS.jsonDepth`, before anything is built;
+ * - a string or member name with a lone surrogate, raw or escaped;
+ * - more than `maxBytes` UTF-8 bytes, when `maxBytes` is given.
+ * Error messages give the reason and an offset, never the text, and chain no `cause`.
+ */
+export function parseWire(text, options = {}) {
+    if (typeof text !== "string")
+        throw invalid("wire input must be text");
+    const { maxBytes } = options;
+    if (maxBytes !== undefined) {
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
+            throw invalid("maxBytes must be a non-negative integer");
+        // A UTF-16 code unit is at least one UTF-8 byte, so the length is a cheap first bound.
+        if (text.length > maxBytes || Buffer.byteLength(text, "utf8") > maxBytes)
+            throw invalid(`input exceeds ${maxBytes} bytes`);
+    }
+    scan(text);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        // Not reached: scan accepts only RFC 8259 JSON. A SyntaxError message would quote the text.
+        throw invalid("not JSON");
+    }
+}
+function scan(text) {
+    // One entry per open container: the member names seen so far for an object, null for an array.
+    const open = [];
+    let state = VALUE;
+    let i = 0;
+    for (;;) {
+        let c = text.charCodeAt(i);
+        while (c === 0x20 || c === 0x0a || c === 0x0d || c === 0x09)
+            c = text.charCodeAt(++i);
+        switch (state) {
+            case VALUE:
+            case FIRST_VALUE:
+                if (c === 0x5d && state === FIRST_VALUE) {
+                    open.pop();
+                    i++;
+                    state = AFTER;
+                }
+                else if (c === 0x5b || c === 0x7b) {
+                    if (open.length >= LIMITS.jsonDepth)
+                        throw invalid(`nested deeper than ${LIMITS.jsonDepth}`, i);
+                    open.push(c === 0x7b ? new Set() : null);
+                    i++;
+                    state = c === 0x7b ? FIRST_NAME : FIRST_VALUE;
+                }
+                else {
+                    i = scalar(text, i, c);
+                    state = AFTER;
+                }
+                break;
+            case NAME:
+            case FIRST_NAME: {
+                if (c === 0x7d && state === FIRST_NAME) {
+                    open.pop();
+                    i++;
+                    state = AFTER;
+                    break;
+                }
+                if (c !== 0x22)
+                    throw invalid("expected a member name", i);
+                const name = memberName(text, i);
+                const names = open[open.length - 1];
+                if (names.has(name.value))
+                    throw invalid("duplicate member name", i);
+                names.add(name.value);
+                i = name.end;
+                c = text.charCodeAt(i);
+                while (c === 0x20 || c === 0x0a || c === 0x0d || c === 0x09)
+                    c = text.charCodeAt(++i);
+                if (c !== 0x3a)
+                    throw invalid("expected a colon", i);
+                i++;
+                state = VALUE;
+                break;
+            }
+            default: {
+                if (open.length === 0) {
+                    if (i !== text.length)
+                        throw invalid("unexpected text after the value", i);
+                    return;
+                }
+                const names = open[open.length - 1];
+                if (c === 0x2c) {
+                    i++;
+                    state = names ? NAME : VALUE;
+                }
+                else if (c === (names ? 0x7d : 0x5d)) {
+                    open.pop();
+                    i++;
+                }
+                else {
+                    throw invalid("expected a comma or a closing bracket", i);
+                }
+            }
+        }
+    }
+}
+/** Skips a string, number or literal starting at `i` (whose code unit is `c`) and returns the offset after it. */
+function scalar(text, i, c) {
+    if (c === 0x22)
+        return stringEnd(text, i);
+    if (c === 0x74 && text.startsWith("true", i))
+        return i + 4;
+    if (c === 0x66 && text.startsWith("false", i))
+        return i + 5;
+    if (c === 0x6e && text.startsWith("null", i))
+        return i + 4;
+    const start = i;
+    if (c === 0x2d)
+        c = text.charCodeAt(++i);
+    if (c === 0x30) {
+        c = text.charCodeAt(++i);
+    }
+    else if (c >= 0x31 && c <= 0x39) {
+        do
+            c = text.charCodeAt(++i);
+        while (c >= 0x30 && c <= 0x39);
+    }
+    else {
+        throw invalid("expected a value", start);
+    }
+    if (c === 0x2e)
+        i = digits(text, i + 1, start);
+    c = text.charCodeAt(i);
+    if (c === 0x65 || c === 0x45) {
+        c = text.charCodeAt(++i);
+        if (c === 0x2b || c === 0x2d)
+            i++;
+        i = digits(text, i, start);
+    }
+    return i;
+}
+/** One or more digits from `i`; returns the offset after them. */
+function digits(text, i, start) {
+    let c = text.charCodeAt(i);
+    if (!(c >= 0x30 && c <= 0x39))
+        throw invalid("bad number", start);
+    do
+        c = text.charCodeAt(++i);
+    while (c >= 0x30 && c <= 0x39);
+    return i;
+}
+/** Checks a string value from its opening quote and returns the offset after its closing quote, without building it. */
+function stringEnd(text, start) {
+    let i = start + 1;
+    let high = false; // the last code unit was a high surrogate still waiting for its low half
+    for (;;) {
+        let c = text.charCodeAt(i);
+        if (c >= 0x20 && c !== 0x22 && c !== 0x5c && (c < 0xd800 || c > 0xdfff)) {
+            if (high)
+                throw invalid("lone surrogate", start);
+            i++;
+            continue;
+        }
+        if (c === 0x22) {
+            if (high)
+                throw invalid("lone surrogate", start);
+            return i + 1;
+        }
+        if (c === 0x5c) {
+            const escape = escapeAt(text, i);
+            c = escape.unit;
+            i = escape.end;
+        }
+        else if (c < 0x20 || Number.isNaN(c)) {
+            throw invalid(Number.isNaN(c) ? "unterminated string" : "control character in a string", i);
+        }
+        else {
+            i++;
+        }
+        if (c >= 0xd800 && c <= 0xdbff) {
+            if (high)
+                throw invalid("lone surrogate", start);
+            high = true;
+        }
+        else if (c >= 0xdc00 && c <= 0xdfff) {
+            if (!high)
+                throw invalid("lone surrogate", start);
+            high = false;
+        }
+        else if (high) {
+            throw invalid("lone surrogate", start);
+        }
+    }
+}
+/** A member name, decoded (names are compared after unescaping), and the offset after it. */
+function memberName(text, start) {
+    const end = stringEnd(text, start);
+    const raw = text.slice(start + 1, end - 1);
+    if (!raw.includes("\\"))
+        return { value: raw, end };
+    let value = "";
+    for (let i = start + 1; i < end - 1;) {
+        if (text.charCodeAt(i) === 0x5c) {
+            const escape = escapeAt(text, i);
+            value += String.fromCharCode(escape.unit);
+            i = escape.end;
+        }
+        else {
+            value += text[i];
+            i++;
+        }
+    }
+    return { value, end };
+}
+/** The code unit of the escape at `i` (a backslash) and the offset after it. */
+function escapeAt(text, i) {
+    const e = text.charCodeAt(i + 1);
+    if (e === 0x75) {
+        let unit = 0;
+        for (let k = i + 2; k < i + 6; k++) {
+            const h = text.charCodeAt(k);
+            const nibble = h >= 0x30 && h <= 0x39 ? h - 0x30 : h >= 0x61 && h <= 0x66 ? h - 0x57 : h >= 0x41 && h <= 0x46 ? h - 0x37 : -1;
+            if (nibble < 0)
+                throw invalid("bad \\u escape", i);
+            unit = unit * 16 + nibble;
+        }
+        return { unit, end: i + 6 };
+    }
+    const unit = ESCAPED.get(e);
+    if (unit === undefined)
+        throw invalid("bad escape", i);
+    return { unit, end: i + 2 };
+}
+function invalid(reason, offset) {
+    return new MessagingError("invalid_request", `invalid JSON${offset === undefined ? "" : ` at offset ${offset}`}: ${reason}`);
+}