rechrome 1.47.0 → 1.48.1

package/rtc-channel.js

@@ -0,0 +1,303 @@
+// @bun
+// token.ts
+var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var B58 = "[1-9A-HJ-NP-Za-km-z]";
+var BODY_LEN = 22;
+var SUM_LEN = 6;
+var SECRET_BYTES = 16;
+var TOKEN_PATTERN = new RegExp(`\\brech1_${B58}{${BODY_LEN + SUM_LEN}}\\b`, "g");
+var EXACT = new RegExp(`^rech1_(${B58}{${BODY_LEN}})(${B58}{${SUM_LEN}})$`);
+function unbase58(text, length) {
+  let n = 0n;
+  for (const c of text) {
+    const i = ALPHABET.indexOf(c);
+    if (i < 0)
+      return null;
+    n = n * 58n + BigInt(i);
+  }
+  const out = new Uint8Array(length);
+  for (let i = length - 1;i >= 0; i--) {
+    out[i] = Number(n & 0xffn);
+    n >>= 8n;
+  }
+  return n === 0n ? out : null;
+}
+var CRC_TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let i = 0;i < 256; i++) {
+    let c = i;
+    for (let k = 0;k < 8; k++)
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[i] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(bytes) {
+  let c = 4294967295;
+  for (const b of bytes)
+    c = CRC_TABLE[(c ^ b) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+var u32 = (n) => new Uint8Array([n >>> 24, n >>> 16 & 255, n >>> 8 & 255, n & 255]);
+function parseToken(token) {
+  const m = EXACT.exec(token.trim());
+  if (!m)
+    return { ok: false, reason: "format" };
+  const secret = unbase58(m[1], SECRET_BYTES), sum = unbase58(m[2], 4);
+  if (!secret || !sum)
+    return { ok: false, reason: "format" };
+  const expected = u32(crc32(secret));
+  return sum.every((b, i) => b === expected[i]) ? { ok: true, secret } : { ok: false, reason: "checksum" };
+}
+
+// e2e.ts
+var PROTO = "rech-e2e-1";
+var CONFIRM_TIMEOUT_MS = 5000;
+var FLAG_CONFIRM = 1;
+var VER = 1;
+var HEADER_LEN = 14;
+var NONCE_LEN = 12;
+var TAG_LEN = 16;
+var COUNTER_MAX = (1n << 64n) - 1n;
+var subtle = globalThis.crypto.subtle;
+var enc = new TextEncoder;
+var dec = new TextDecoder;
+var concat = (...parts) => {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+};
+function ikmOf(token) {
+  const parsed = parseToken(token);
+  if (!parsed.ok)
+    throw new Error("e2e: invalid share secret");
+  return parsed.secret;
+}
+async function hkdfKey(ikm, salt, info) {
+  const base = await subtle.importKey("raw", ikm, "HKDF", false, ["deriveBits"]);
+  const bits = await subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt, info: enc.encode(info) }, base, 256);
+  return subtle.importKey("raw", bits, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+}
+async function deriveDirKeys(token, transcriptHash) {
+  const ikm = ikmOf(token);
+  return {
+    h2c: await hkdfKey(ikm, transcriptHash, `rech/${PROTO}/key/host->client`),
+    c2h: await hkdfKey(ikm, transcriptHash, `rech/${PROTO}/key/client->host`)
+  };
+}
+var newSendState = () => ({ ctr: 0n });
+var newRecvState = () => ({ last: -1n });
+function nonceOf(ctr) {
+  const n = new Uint8Array(NONCE_LEN);
+  new DataView(n.buffer).setBigUint64(4, ctr, false);
+  return n;
+}
+async function seal(key, state, flags, th, plaintext) {
+  const ctr = state.ctr;
+  if (ctr >= COUNTER_MAX)
+    throw new Error("e2e: nonce counter overflow");
+  state.ctr = ctr + 1n;
+  const nonce = nonceOf(ctr);
+  const header = new Uint8Array(HEADER_LEN);
+  header[0] = VER;
+  header[1] = flags & 255;
+  header.set(nonce, 2);
+  const sealed = new Uint8Array(await subtle.encrypt({ name: "AES-GCM", iv: nonce, additionalData: concat(header, th), tagLength: 128 }, key, plaintext));
+  return concat(header, sealed).buffer;
+}
+async function open(key, frame, th, state) {
+  const buf = frame instanceof Uint8Array ? frame : new Uint8Array(frame);
+  if (buf.length < HEADER_LEN + TAG_LEN)
+    throw new Error("e2e: short frame");
+  if (buf[0] !== VER)
+    throw new Error("e2e: bad version");
+  const header = buf.subarray(0, HEADER_LEN), nonce = buf.subarray(2, HEADER_LEN);
+  const view = new DataView(nonce.buffer, nonce.byteOffset, NONCE_LEN);
+  if (view.getUint32(0, false) !== 0)
+    throw new Error("e2e: bad epoch");
+  const ctr = view.getBigUint64(4, false);
+  const plain = await subtle.decrypt({ name: "AES-GCM", iv: nonce, additionalData: concat(header, th), tagLength: 128 }, key, buf.subarray(HEADER_LEN));
+  if (state.last === -1n && ctr !== 0n)
+    throw new Error("e2e: first frame must be counter-0");
+  if (ctr <= state.last)
+    throw new Error("e2e: replay/reorder");
+  state.last = ctr;
+  return { flags: header[1], plaintext: new Uint8Array(plain) };
+}
+var pack = (obj) => enc.encode(JSON.stringify(obj));
+var unpack = (bytes) => JSON.parse(dec.decode(bytes));
+function randomHex(n) {
+  return Array.from(globalThis.crypto.getRandomValues(new Uint8Array(n)), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// rtc-channel.ts
+var SIGNAL_PROTO = "rech-signal-1";
+var PING = '{"type":"ping"}';
+var KEEPALIVE_MS = 25000;
+function signalSocketUrl(signal, room) {
+  const u = new URL(signal);
+  u.protocol = u.protocol === "https:" ? "wss:" : "ws:";
+  u.pathname = `${u.pathname.replace(/\/+$/, "")}/${room}`;
+  u.search = "";
+  u.hash = "";
+  return u.toString();
+}
+
+class SealedChannel {
+  dc;
+  role;
+  send = newSendState();
+  recv = newRecvState();
+  sendChain = Promise.resolve();
+  recvChain = Promise.resolve();
+  keys;
+  keysSet;
+  keysReady = new Promise((r) => this.keysSet = r);
+  confirmed = false;
+  confirmWaiters = [];
+  onFrame = () => {};
+  onClose = () => {};
+  closed = false;
+  constructor(dc, role) {
+    this.dc = dc;
+    this.role = role;
+    dc.binaryType = "arraybuffer";
+    dc.onmessage = (e) => {
+      this.recvChain = this.recvChain.then(() => this.receive(e.data)).catch(() => this.close());
+    };
+    dc.onclose = () => this.close();
+  }
+  async setKeys(token, th) {
+    const { h2c, c2h } = await deriveDirKeys(token, th);
+    this.keys = this.role === "host" ? { mine: h2c, theirs: c2h, th } : { mine: c2h, theirs: h2c, th };
+    this.keysSet();
+  }
+  confirm() {
+    if (this.closed)
+      return Promise.resolve(false);
+    const done = new Promise((resolve) => {
+      this.confirmWaiters.push(resolve);
+      setTimeout(() => resolve(false), CONFIRM_TIMEOUT_MS);
+    });
+    this.sendFrame({ t: "confirm", nonce: randomHex(16), proto: "rech-e2e-1" }, FLAG_CONFIRM);
+    return done;
+  }
+  sendFrame(obj, flags = 0) {
+    this.sendChain = this.sendChain.then(async () => {
+      if (this.closed || !this.keys || this.dc.readyState !== "open")
+        return;
+      const frame = await seal(this.keys.mine, this.send, flags, this.keys.th, pack(obj));
+      while (this.dc.bufferedAmount > 4 * 1024 * 1024 && this.dc.readyState === "open")
+        await new Promise((r) => setTimeout(r, 10));
+      try {
+        this.dc.send(new Uint8Array(frame));
+      } catch {
+        this.close();
+      }
+    }).catch(() => this.close());
+    return this.sendChain;
+  }
+  async receive(data) {
+    if (this.closed)
+      return;
+    if (typeof data === "string")
+      return this.close();
+    await Promise.race([this.keysReady, new Promise((r) => setTimeout(r, CONFIRM_TIMEOUT_MS))]);
+    if (!this.keys)
+      return this.close();
+    const { plaintext } = await open(this.keys.theirs, data, this.keys.th, this.recv);
+    const frame = unpack(plaintext);
+    if (!this.confirmed) {
+      if (frame?.t !== "confirm")
+        return this.close();
+      this.confirmed = true;
+      for (const w of this.confirmWaiters.splice(0))
+        w(true);
+      return;
+    }
+    if (frame?.t === "confirm")
+      return;
+    this.onFrame(frame);
+  }
+  get open() {
+    return !this.closed && this.dc.readyState === "open";
+  }
+  close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    for (const w of this.confirmWaiters.splice(0))
+      w(false);
+    try {
+      this.dc.close();
+    } catch {}
+    this.onClose();
+  }
+}
+
+class SignalSocket {
+  url;
+  hello;
+  onMessage;
+  onClose;
+  ws;
+  timer;
+  constructor(url, hello, onMessage, onClose) {
+    this.url = url;
+    this.hello = hello;
+    this.onMessage = onMessage;
+    this.onClose = onClose;
+  }
+  open() {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.url, [SIGNAL_PROTO]);
+      this.ws = ws;
+      let opened = false;
+      ws.onopen = () => {
+        opened = true;
+        ws.send(JSON.stringify({ type: "hello", ...this.hello }));
+        this.timer = setInterval(() => {
+          try {
+            ws.send(PING);
+          } catch {}
+        }, KEEPALIVE_MS);
+        resolve();
+      };
+      ws.onmessage = (e) => {
+        try {
+          const m = JSON.parse(String(e.data));
+          if (m?.type !== "pong")
+            this.onMessage(m);
+        } catch {}
+      };
+      ws.onclose = (e) => {
+        clearInterval(this.timer);
+        if (!opened)
+          reject(new Error(`signal server ${new URL(this.url).host}: ${e.reason || `closed (${e.code})`}`));
+        this.onClose(e.code, e.reason);
+      };
+      ws.onerror = () => {};
+    });
+  }
+  send(obj) {
+    try {
+      this.ws?.send(JSON.stringify(obj));
+    } catch {}
+  }
+  close() {
+    clearInterval(this.timer);
+    try {
+      this.ws?.close();
+    } catch {}
+  }
+}
+export {
+  SIGNAL_PROTO,
+  SealedChannel,
+  SignalSocket,
+  signalSocketUrl
+};

package/rtc-channel.ts

@@ -0,0 +1,130 @@
+// What both ends of a WebRTC connection share, with no Node imports: the invite page
+// (public/invite.js) runs this too. See webrtc.ts for the overall design.
+import { CONFIRM_TIMEOUT_MS, FLAG_CONFIRM, deriveDirKeys, newRecvState, newSendState, open, pack, randomHex, seal, unpack, type RecvState, type SendState } from "./e2e.ts";
+
+export const SIGNAL_PROTO = "rech-signal-1";
+const PING = '{"type":"ping"}';
+const KEEPALIVE_MS = 25_000;
+
+export function signalSocketUrl(signal: string, room: string): string {
+  const u = new URL(signal);
+  u.protocol = u.protocol === "https:" ? "wss:" : "ws:";
+  u.pathname = `${u.pathname.replace(/\/+$/, "")}/${room}`;
+  u.search = ""; u.hash = "";
+  return u.toString();
+}
+
+// ---- sealed channel (shared by both ends) -------------------------------------------------
+export type Role = "host" | "client";
+
+/** A DataChannel with the e2e seal/open and confirmation handshake on top. */
+export class SealedChannel {
+  private send = newSendState() as SendState;
+  private recv = newRecvState() as RecvState;
+  private sendChain = Promise.resolve();
+  private recvChain = Promise.resolve();
+  private keys?: { mine: CryptoKey; theirs: CryptoKey; th: Uint8Array };
+  // Frames can arrive the moment the channel opens, before this side has derived its keys
+  // (an async HKDF): hold them until then rather than dropping the connection.
+  private keysSet!: () => void;
+  private keysReady = new Promise<void>(r => (this.keysSet = r));
+  confirmed = false;
+  private confirmWaiters: Array<(ok: boolean) => void> = [];
+  onFrame: (frame: any) => void = () => {};
+  onClose: () => void = () => {};
+  private closed = false;
+
+  constructor(private dc: any, private role: Role) {
+    dc.binaryType = "arraybuffer";
+    dc.onmessage = (e: { data: ArrayBuffer | Uint8Array | string }) => {
+      this.recvChain = this.recvChain.then(() => this.receive(e.data)).catch(() => this.close());
+    };
+    dc.onclose = () => this.close();
+  }
+
+  async setKeys(token: string, th: Uint8Array): Promise<void> {
+    const { h2c, c2h } = await deriveDirKeys(token, th);
+    this.keys = this.role === "host" ? { mine: h2c, theirs: c2h, th } : { mine: c2h, theirs: h2c, th };
+    this.keysSet();
+  }
+
+  /** Send our confirm frame (counter 0) and wait for the peer's; false on timeout or failure. */
+  confirm(): Promise<boolean> {
+    if (this.closed) return Promise.resolve(false);
+    const done = new Promise<boolean>(resolve => {
+      this.confirmWaiters.push(resolve);
+      setTimeout(() => resolve(false), CONFIRM_TIMEOUT_MS);
+    });
+    void this.sendFrame({ t: "confirm", nonce: randomHex(16), proto: "rech-e2e-1" }, FLAG_CONFIRM);
+    return done;
+  }
+
+  sendFrame(obj: unknown, flags = 0): Promise<void> {
+    this.sendChain = this.sendChain.then(async () => {
+      if (this.closed || !this.keys || this.dc.readyState !== "open") return;
+      const frame = await seal(this.keys.mine, this.send, flags, this.keys.th, pack(obj));
+      // A DataChannel queues without bound; wait out a large backlog (screenshots) instead.
+      while (this.dc.bufferedAmount > 4 * 1024 * 1024 && this.dc.readyState === "open") await new Promise(r => setTimeout(r, 10));
+      try { this.dc.send(new Uint8Array(frame)); } catch { this.close(); }
+    }).catch(() => this.close());
+    return this.sendChain;
+  }
+
+  private async receive(data: ArrayBuffer | Uint8Array | string): Promise<void> {
+    if (this.closed) return;
+    if (typeof data === "string") return this.close(); // plaintext is never accepted
+    await Promise.race([this.keysReady, new Promise(r => setTimeout(r, CONFIRM_TIMEOUT_MS))]);
+    if (!this.keys) return this.close();
+    const { plaintext } = await open(this.keys.theirs, data, this.keys.th, this.recv);
+    const frame = unpack(plaintext);
+    if (!this.confirmed) {
+      // The first frame must be the peer's confirm: decrypting it proves the same secret and the
+      // same DTLS transcript (no relay in the middle); the transcript makes it unreplayable.
+      if (frame?.t !== "confirm") return this.close();
+      this.confirmed = true;
+      for (const w of this.confirmWaiters.splice(0)) w(true);
+      return;
+    }
+    if (frame?.t === "confirm") return;
+    this.onFrame(frame);
+  }
+
+  get open(): boolean { return !this.closed && this.dc.readyState === "open"; }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    for (const w of this.confirmWaiters.splice(0)) w(false);
+    try { this.dc.close(); } catch {}
+    this.onClose();
+  }
+}
+
+// Wire frames inside the sealed channel:
+//   client → host : {t:"req", id, method, path, ct?, body?} | {t:"abort", id}
+//   host → client : {t:"res", id, status, ct} | {t:"data", id, b64} | {t:"end", id, error?}
+
+// ---- signal socket ---------------------------------------------------------------------
+export class SignalSocket {
+  ws?: WebSocket;
+  private timer?: ReturnType<typeof setInterval>;
+  constructor(private url: string, private hello: { role: Role; auth: string }, private onMessage: (m: any) => void, private onClose: (code: number, reason: string) => void) {}
+  open(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.url, [SIGNAL_PROTO]);
+      this.ws = ws;
+      let opened = false;
+      ws.onopen = () => {
+        opened = true;
+        ws.send(JSON.stringify({ type: "hello", ...this.hello }));
+        this.timer = setInterval(() => { try { ws.send(PING); } catch {} }, KEEPALIVE_MS);
+        resolve();
+      };
+      ws.onmessage = e => { try { const m = JSON.parse(String(e.data)); if (m?.type !== "pong") this.onMessage(m); } catch {} };
+      ws.onclose = e => { clearInterval(this.timer); if (!opened) reject(new Error(`signal server ${new URL(this.url).host}: ${e.reason || `closed (${e.code})`}`)); this.onClose(e.code, e.reason); };
+      ws.onerror = () => {};
+    });
+  }
+  send(obj: unknown): void { try { this.ws?.send(JSON.stringify(obj)); } catch {} }
+  close(): void { clearInterval(this.timer); try { this.ws?.close(); } catch {} }
+}

package/secret.js

@@ -1,6 +1,8 @@
 // @bun
 // secret.ts
 import { hkdfSync, randomBytes, timingSafeEqual } from "crypto";
+
+// token.ts
 var TOKEN_PREFIX = "rech1_";
 var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 var B58 = "[1-9A-HJ-NP-Za-km-z]";
@@ -59,9 +61,6 @@ function formatToken(secret) {
     throw new Error(`a share secret is ${SECRET_BYTES} bytes`);
   return `${TOKEN_PREFIX}${base58(secret, BODY_LEN)}${base58(u32(crc32(secret)), SUM_LEN)}`;
 }
-function newToken() {
-  return formatToken(new Uint8Array(randomBytes(SECRET_BYTES)));
-}
 function parseToken(token) {
   const m = EXACT.exec(token.trim());
   if (!m)
@@ -78,17 +77,22 @@ function isToken(text) {
 function looksLikeToken(text) {
   return EXACT.test(text.trim());
 }
-function secretOf(token) {
-  const parsed = parseToken(token);
+
+// secret.ts
+function newToken() {
+  return formatToken(new Uint8Array(randomBytes(SECRET_BYTES)));
+}
+function secretOf(token2) {
+  const parsed = parseToken(token2);
   if (!parsed.ok)
     throw new Error(parsed.reason === "checksum" ? "This rech1_ link is damaged (checksum mismatch): it was copied incompletely or mistyped." : "Not a rech1_ link.");
   return parsed.secret;
 }
-var derive = (token, label, bytes) => new Uint8Array(hkdfSync("sha256", secretOf(token), new Uint8Array(0), `rech/${label}`, bytes));
-var roomOf = (token) => base58(derive(token, "room", 12), 17);
-var roomAuthOf = (token) => Buffer.from(derive(token, "auth", 32)).toString("hex");
-var bearerOf = (token) => `rb_${base58(derive(token, "bearer", 24), 33)}`;
-var credentialIdOf = (token) => base58(derive(token, "id", 6), 9);
+var derive = (token2, label, bytes) => new Uint8Array(hkdfSync("sha256", secretOf(token2), new Uint8Array(0), `rech/${label}`, bytes));
+var roomOf = (token2) => base58(derive(token2, "room", 12), 17);
+var roomAuthOf = (token2) => Buffer.from(derive(token2, "auth", 32)).toString("hex");
+var bearerOf = (token2) => `rb_${base58(derive(token2, "bearer", 24), 33)}`;
+var credentialIdOf = (token2) => base58(derive(token2, "id", 6), 9);
 function safeEqual(a, b) {
   const x = Buffer.from(a), y = Buffer.from(b);
   return x.length === y.length && timingSafeEqual(x, y);
@@ -97,6 +101,7 @@ function redactSecrets(text) {
   return text.replace(TOKEN_PATTERN, (t) => `${t.slice(0, TOKEN_PREFIX.length + 4)}\u2026`).replace(/([#&?]key=)[^&\s"]*/g, "$1\u2026");
 }
 export {
+  SECRET_BYTES,
   TOKEN_PATTERN,
   TOKEN_PREFIX,
   base58,

package/secret.ts

@@ -6,82 +6,14 @@
 // Everything a party needs is derived one-way from the secret with HKDF, so a signal server or
 // HTTP proxy never holds anything that would let it derive another value or the secret itself.
 import { hkdfSync, randomBytes, timingSafeEqual } from "crypto";
+import { SECRET_BYTES, TOKEN_PATTERN, TOKEN_PREFIX, base58, formatToken, parseToken } from "./token.ts";
 
-export const TOKEN_PREFIX = "rech1_";
-const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-const B58 = "[1-9A-HJ-NP-Za-km-z]";
-const BODY_LEN = 22, SUM_LEN = 6, SECRET_BYTES = 16;
-/** Matches a token anywhere in text (logs, files); for scanners and redaction. */
-export const TOKEN_PATTERN = new RegExp(`\\brech1_${B58}{${BODY_LEN + SUM_LEN}}\\b`, "g");
-const EXACT = new RegExp(`^rech1_(${B58}{${BODY_LEN}})(${B58}{${SUM_LEN}})$`);
-
-export function base58(bytes: Uint8Array, width: number): string {
-  let n = 0n;
-  for (const b of bytes) n = (n << 8n) | BigInt(b);
-  let s = "";
-  while (n > 0n) { s = ALPHABET[Number(n % 58n)] + s; n /= 58n; }
-  if (s.length > width) throw new Error("base58 value wider than its field");
-  return s.padStart(width, "1");
-}
-
-export function unbase58(text: string, length: number): Uint8Array | null {
-  let n = 0n;
-  for (const c of text) {
-    const i = ALPHABET.indexOf(c);
-    if (i < 0) return null;
-    n = n * 58n + BigInt(i);
-  }
-  const out = new Uint8Array(length);
-  for (let i = length - 1; i >= 0; i--) { out[i] = Number(n & 0xffn); n >>= 8n; }
-  return n === 0n ? out : null; // leftover bits: not a fixed-width encoding of `length` bytes
-}
-
-const CRC_TABLE = (() => {
-  const t = new Uint32Array(256);
-  for (let i = 0; i < 256; i++) {
-    let c = i;
-    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
-    t[i] = c >>> 0;
-  }
-  return t;
-})();
-export function crc32(bytes: Uint8Array): number {
-  let c = 0xffffffff;
-  for (const b of bytes) c = CRC_TABLE[(c ^ b) & 0xff] ^ (c >>> 8);
-  return (c ^ 0xffffffff) >>> 0;
-}
-const u32 = (n: number) => new Uint8Array([n >>> 24, (n >>> 16) & 255, (n >>> 8) & 255, n & 255]);
-
-export function formatToken(secret: Uint8Array): string {
-  if (secret.length !== SECRET_BYTES) throw new Error(`a share secret is ${SECRET_BYTES} bytes`);
-  return `${TOKEN_PREFIX}${base58(secret, BODY_LEN)}${base58(u32(crc32(secret)), SUM_LEN)}`;
-}
+export * from "./token.ts";
 
 export function newToken(): string {
   return formatToken(new Uint8Array(randomBytes(SECRET_BYTES)));
 }
 
-export type ParsedToken = { ok: true; secret: Uint8Array } | { ok: false; reason: "format" | "checksum" };
-
-/** Parse a token, telling a non-token apart from a damaged one (a truncated paste, a typo). */
-export function parseToken(token: string): ParsedToken {
-  const m = EXACT.exec(token.trim());
-  if (!m) return { ok: false, reason: "format" };
-  const secret = unbase58(m[1], SECRET_BYTES), sum = unbase58(m[2], 4);
-  if (!secret || !sum) return { ok: false, reason: "format" };
-  const expected = u32(crc32(secret));
-  return sum.every((b, i) => b === expected[i]) ? { ok: true, secret } : { ok: false, reason: "checksum" };
-}
-
-export function isToken(text: string): boolean {
-  return parseToken(text).ok;
-}
-
-/** Looks like a token (prefix and shape) whether or not its checksum holds. */
-export function looksLikeToken(text: string): boolean {
-  return EXACT.test(text.trim());
-}
-
 function secretOf(token: string): Uint8Array {
   const parsed = parseToken(token);
   if (!parsed.ok) throw new Error(parsed.reason === "checksum"