vibedate 0.1.1 → 0.2.1

package/dist/chunk-6NWF2VD7.js

@@ -0,0 +1,744 @@
+// src/index.ts
+import { createConsentLedger as createConsentLedger2 } from "@pooriaarab/vibe-core";
+
+// src/p2p.ts
+import { createHash, randomBytes } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import path3 from "path";
+import { makeEvent, notify as vibeCoreNotify } from "@pooriaarab/vibe-core";
+
+// src/frame.ts
+var MAX_TEXT_LEN = 4e3;
+var MAX_ID_LEN = 64;
+var MAX_B64_CHUNK_LEN = 16 * 1024;
+var MAX_MEDIA_SIZE = 25 * 1024 * 1024;
+var MAX_MIME_LEN = 128;
+var MAX_NAME_LEN = 256;
+var MAX_SDP_LEN = 64 * 1024;
+var MAX_CANDIDATE_LEN = 4 * 1024;
+var MAX_FRAME_LEN = Math.max(MAX_B64_CHUNK_LEN, 2 * MAX_SDP_LEN) + 2048;
+function serializeFrame(f) {
+  return JSON.stringify(f);
+}
+function parseFrame(raw) {
+  const text = typeof raw === "string" ? raw : raw.toString("utf8");
+  if (text.length > MAX_FRAME_LEN) return null;
+  let d;
+  try {
+    d = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof d !== "object" || d === null || Array.isArray(d)) return null;
+  const r = d;
+  switch (r["t"]) {
+    case "bye":
+      return { t: "bye" };
+    case "typing":
+      return { t: "typing" };
+    case "hello": {
+      const { handle, league: league2, harness } = r;
+      if (typeof handle !== "string" || typeof league2 !== "string") return null;
+      return { t: "hello", handle, league: league2, harness: typeof harness === "string" ? harness : "unknown" };
+    }
+    case "msg": {
+      const id = r["id"];
+      const txt = r["text"];
+      const at = r["at"];
+      if (typeof id !== "string" || id.length === 0 || id.length > MAX_ID_LEN) return null;
+      if (typeof txt !== "string" || txt.length === 0 || txt.length > MAX_TEXT_LEN) return null;
+      if (typeof at !== "number" || !Number.isFinite(at)) return null;
+      return { t: "msg", id, text: txt, at };
+    }
+    case "media-start": {
+      const id = r["id"];
+      const mime = r["mime"];
+      const size = r["size"];
+      const name = r["name"];
+      if (typeof id !== "string" || id.length === 0 || id.length > MAX_ID_LEN) return null;
+      if (typeof mime !== "string" || mime.length > MAX_MIME_LEN) return null;
+      if (typeof name !== "string" || name.length > MAX_NAME_LEN) return null;
+      if (typeof size !== "number" || !Number.isFinite(size) || !Number.isInteger(size) || size < 0 || size > MAX_MEDIA_SIZE)
+        return null;
+      return { t: "media-start", id, mime, size, name };
+    }
+    case "media-chunk": {
+      const id = r["id"];
+      const seq = r["seq"];
+      const b64 = r["b64"];
+      if (typeof id !== "string" || id.length === 0 || id.length > MAX_ID_LEN) return null;
+      if (typeof seq !== "number" || !Number.isFinite(seq) || !Number.isInteger(seq) || seq < 0)
+        return null;
+      if (typeof b64 !== "string" || b64.length === 0 || b64.length > MAX_B64_CHUNK_LEN) return null;
+      return { t: "media-chunk", id, seq, b64 };
+    }
+    case "media-end": {
+      const id = r["id"];
+      if (typeof id !== "string" || id.length === 0 || id.length > MAX_ID_LEN) return null;
+      return { t: "media-end", id };
+    }
+    case "rtc-offer": {
+      const sdp = r["sdp"];
+      if (typeof sdp !== "string" || sdp.length === 0 || sdp.length > MAX_SDP_LEN) return null;
+      return { t: "rtc-offer", sdp };
+    }
+    case "rtc-answer": {
+      const sdp = r["sdp"];
+      if (typeof sdp !== "string" || sdp.length === 0 || sdp.length > MAX_SDP_LEN) return null;
+      return { t: "rtc-answer", sdp };
+    }
+    case "rtc-ice": {
+      const candidate = r["candidate"];
+      if (typeof candidate !== "string" || candidate.length > MAX_CANDIDATE_LEN) return null;
+      return { t: "rtc-ice", candidate };
+    }
+    default:
+      return null;
+  }
+}
+
+// src/link.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/media.ts
+import { randomUUID } from "crypto";
+import { readFile } from "fs/promises";
+import { writeFileSync } from "fs";
+import os from "os";
+import path from "path";
+var DEFAULT_CHUNK_BYTES = Math.floor(MAX_B64_CHUNK_LEN * 3 / 4);
+var MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm"
+};
+function inferMime(name) {
+  return MIME_BY_EXT[path.extname(name).toLowerCase()] ?? "application/octet-stream";
+}
+function writeFrame(socket, line) {
+  return new Promise((resolve) => {
+    const ok = socket.write(line);
+    if (ok) resolve();
+    else socket.once("drain", () => resolve());
+  });
+}
+async function sendMedia(opts) {
+  const { socket, data, mime, name } = opts;
+  const id = opts.id ?? randomUUID();
+  const size = data.length;
+  if (size > MAX_MEDIA_SIZE) {
+    throw new Error(`media too large: ${size} bytes exceeds ${MAX_MEDIA_SIZE} byte cap`);
+  }
+  if (mime.length > MAX_MIME_LEN) throw new Error(`mime too long: ${mime.length} > ${MAX_MIME_LEN}`);
+  if (name.length > MAX_NAME_LEN) throw new Error(`name too long: ${name.length} > ${MAX_NAME_LEN}`);
+  await writeFrame(socket, serializeFrame({ t: "media-start", id, mime, size, name }) + "\n");
+  const chunkBytes = opts.chunkBytes ?? DEFAULT_CHUNK_BYTES;
+  let seq = 0;
+  for (let off = 0; off < size; off += chunkBytes) {
+    const b64 = data.subarray(off, off + chunkBytes).toString("base64");
+    await writeFrame(socket, serializeFrame({ t: "media-chunk", id, seq, b64 }) + "\n");
+    seq++;
+  }
+  await writeFrame(socket, serializeFrame({ t: "media-end", id }) + "\n");
+  return { id, size };
+}
+async function sendMediaFile(opts) {
+  const data = await readFile(opts.path);
+  const name = opts.name ?? path.basename(opts.path);
+  const mime = opts.mime ?? inferMime(name);
+  return sendMedia({
+    socket: opts.socket,
+    data,
+    mime,
+    name,
+    id: opts.id,
+    chunkBytes: opts.chunkBytes
+  });
+}
+function safeName(id, name) {
+  const ext = path.extname(name);
+  return ext && /^\.[A-Za-z0-9]{1,16}$/.test(ext) ? `${id}${ext}` : id;
+}
+var MediaReceiver = class {
+  constructor(onMedia, opts = {}) {
+    this.onMedia = onMedia;
+    this.opts = opts;
+  }
+  onMedia;
+  opts;
+  transfers = /* @__PURE__ */ new Map();
+  /** Abort a transfer (drop all state for `id`) without delivering. */
+  abort(id) {
+    this.transfers.delete(id);
+  }
+  /** Feed one parsed media frame. Never throws. */
+  handle(frame) {
+    switch (frame.t) {
+      case "media-start": {
+        this.transfers.set(frame.id, {
+          mime: frame.mime,
+          name: frame.name,
+          size: frame.size,
+          nextSeq: 0,
+          chunks: [],
+          received: 0
+        });
+        return;
+      }
+      case "media-chunk": {
+        const tx = this.transfers.get(frame.id);
+        if (!tx) return;
+        if (frame.seq !== tx.nextSeq) {
+          this.abort(frame.id);
+          return;
+        }
+        let bytes;
+        try {
+          bytes = Buffer.from(frame.b64, "base64");
+        } catch {
+          this.abort(frame.id);
+          return;
+        }
+        const received = tx.received + bytes.length;
+        if (received > tx.size || received > MAX_MEDIA_SIZE) {
+          this.abort(frame.id);
+          return;
+        }
+        tx.chunks.push(bytes);
+        tx.received = received;
+        tx.nextSeq += 1;
+        return;
+      }
+      case "media-end": {
+        const tx = this.transfers.get(frame.id);
+        if (!tx) return;
+        this.transfers.delete(frame.id);
+        if (tx.received !== tx.size) return;
+        const buf = Buffer.concat(tx.chunks, tx.received);
+        const filePath = path.join(this.opts.tmpDir ?? os.tmpdir(), safeName(frame.id, tx.name));
+        try {
+          writeFileSync(filePath, buf);
+        } catch {
+          return;
+        }
+        this.onMedia({ mime: tx.mime, name: tx.name, path: filePath, size: tx.received });
+        return;
+      }
+      default:
+        return;
+    }
+  }
+};
+
+// src/link.ts
+function createPeerLink(socket, hello, initialBuffer = "", linkOpts = {}) {
+  const messageCbs = /* @__PURE__ */ new Set();
+  const mediaCbs = /* @__PURE__ */ new Set();
+  const signalCbs = /* @__PURE__ */ new Set();
+  const closeCbs = /* @__PURE__ */ new Set();
+  let buf = initialBuffer;
+  let closed = false;
+  let mediaReceiver;
+  const ensureMediaReceiver = () => {
+    if (!mediaReceiver) {
+      mediaReceiver = new MediaReceiver(
+        (m) => {
+          for (const cb of mediaCbs) cb(m);
+        },
+        { tmpDir: linkOpts.mediaTmpDir }
+      );
+    }
+    return mediaReceiver;
+  };
+  const dispatch = (frame) => {
+    switch (frame.t) {
+      case "msg": {
+        const m = { id: frame.id, text: frame.text, at: frame.at };
+        for (const cb of messageCbs) cb(m);
+        break;
+      }
+      case "media-start":
+      case "media-chunk":
+      case "media-end": {
+        mediaReceiver?.handle(frame);
+        break;
+      }
+      case "rtc-offer":
+      case "rtc-answer":
+      case "rtc-ice": {
+        const f = frame;
+        for (const cb of signalCbs) cb(f);
+        break;
+      }
+      case "bye": {
+        if (!closed) {
+          closed = true;
+          for (const cb of closeCbs) cb();
+        }
+        break;
+      }
+      // 'hello' / 'typing' have no meaning at the link layer — hello already
+      // happened; typing is a future affordance. Ignore silently.
+      default:
+        break;
+    }
+  };
+  const pump = () => {
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl);
+      buf = buf.slice(nl + 1);
+      if (line.trim() === "") continue;
+      const frame = parseFrame(line);
+      if (frame === null) continue;
+      dispatch(frame);
+    }
+  };
+  pump();
+  socket.on("data", (chunk) => {
+    buf += chunk.toString("utf8");
+    pump();
+  });
+  socket.on("end", () => {
+    if (!closed) {
+      closed = true;
+      for (const cb of closeCbs) cb();
+    }
+  });
+  socket.on("close", () => {
+    if (!closed) {
+      closed = true;
+      for (const cb of closeCbs) cb();
+    }
+  });
+  socket.on("error", () => {
+    if (!closed) {
+      closed = true;
+      for (const cb of closeCbs) cb();
+    }
+  });
+  return {
+    hello,
+    send(text) {
+      if (closed) return;
+      const frame = { t: "msg", id: randomUUID2(), text, at: Date.now() };
+      socket.write(serializeFrame(frame) + "\n");
+    },
+    async sendMedia(filePath, opts = {}) {
+      if (closed) return { id: "", size: 0 };
+      return sendMediaFile({ socket, path: filePath, mime: opts.mime, name: opts.name });
+    },
+    sendSignal(frame) {
+      if (closed) return;
+      socket.write(serializeFrame(frame) + "\n");
+    },
+    onMessage(cb) {
+      messageCbs.add(cb);
+    },
+    onMedia(cb) {
+      ensureMediaReceiver();
+      mediaCbs.add(cb);
+    },
+    onSignal(cb) {
+      signalCbs.add(cb);
+    },
+    onClose(cb) {
+      closeCbs.add(cb);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      try {
+        socket.write(serializeFrame({ t: "bye" }) + "\n");
+      } catch {
+      }
+      try {
+        socket.end();
+      } catch {
+      }
+    }
+  };
+}
+
+// src/state.ts
+import { mkdirSync, readFileSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import os2 from "os";
+import path2 from "path";
+import { createConsentLedger } from "@pooriaarab/vibe-core";
+var CONSENT_SCOPE = "share:league";
+var LIVE_CONSENT_SCOPE = "share:live";
+function defaultStateDir() {
+  return path2.join(os2.homedir(), ".vibedating");
+}
+var FileConsentStore = class {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  load() {
+    try {
+      const raw = readFileSync(this.file, "utf8");
+      const data = JSON.parse(raw);
+      return data.grants ?? [];
+    } catch {
+      return [];
+    }
+  }
+  save(grants) {
+    mkdirSync(path2.dirname(this.file), { recursive: true });
+    writeFileSync2(this.file, JSON.stringify({ grants }, null, 2) + "\n", "utf8");
+  }
+};
+function createLedger(dir = defaultStateDir()) {
+  return createConsentLedger(new FileConsentStore(path2.join(dir, "consent.json")));
+}
+function profilePath(dir) {
+  return path2.join(dir, "state.json");
+}
+function connectProfile(snapshot, handle, dir = defaultStateDir()) {
+  const lg = league(snapshot.totalTokens);
+  createLedger(dir).grant(CONSENT_SCOPE, "connect: league bucket only; raw usage stays local");
+  const state = {
+    handle,
+    harness: snapshot.harness,
+    league: lg.name,
+    leagueMin: lg.min,
+    totalTokens: snapshot.totalTokens,
+    verified: snapshot.verified,
+    connectedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  mkdirSync(dir, { recursive: true });
+  writeFileSync2(profilePath(dir), JSON.stringify(state, null, 2) + "\n", "utf8");
+  return state;
+}
+function loadProfile(dir = defaultStateDir()) {
+  try {
+    const raw = readFileSync(profilePath(dir), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function grantLiveConsent(dir = defaultStateDir()) {
+  createLedger(dir).grant(
+    LIVE_CONSENT_SCOPE,
+    "discover --live: share handle+league+harness (never raw usage) with same-league peers on the public DHT"
+  );
+}
+function canShareLive(dir = defaultStateDir()) {
+  return createLedger(dir).allows(LIVE_CONSENT_SCOPE);
+}
+
+// src/p2p.ts
+var TOPIC_PREFIX = "vibedate:";
+function leagueTopic(leagueName) {
+  return createHash("sha256").update(`${TOPIC_PREFIX}${leagueName}`, "utf8").digest();
+}
+var LIVE_NOTICE = "live discovery: sharing only your handle + league + harness (never raw usage) with same-league peers on the public DHT";
+var MAX_HANDLE_LEN = 64;
+var MAX_LEAGUE_LEN = 32;
+var MAX_HARNESS_LEN = 64;
+var MAX_HANDSHAKE_LEN = 4096;
+var REFRESH_INTERVAL_MS = 5e3;
+function serializeHandshake(hello) {
+  return JSON.stringify({
+    handle: hello.handle,
+    league: hello.league,
+    harness: hello.harness
+  });
+}
+function parseHandshake(raw) {
+  const text = typeof raw === "string" ? raw : raw.toString("utf8");
+  if (text.length > MAX_HANDSHAKE_LEN) return null;
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return null;
+  const rec = data;
+  const handle = rec["handle"];
+  const league2 = rec["league"];
+  if (typeof handle !== "string" || handle.length === 0 || handle.length > MAX_HANDLE_LEN) {
+    return null;
+  }
+  if (typeof league2 !== "string" || league2.length === 0 || league2.length > MAX_LEAGUE_LEN) {
+    return null;
+  }
+  const harness = rec["harness"];
+  return {
+    handle,
+    league: league2,
+    harness: typeof harness === "string" && harness.length > 0 && harness.length <= MAX_HARNESS_LEN ? harness : "unknown"
+  };
+}
+function peersPath(dir) {
+  return path3.join(dir, "peers.json");
+}
+function loadPeers(dir = defaultStateDir()) {
+  try {
+    const raw = readFileSync2(peersPath(dir), "utf8");
+    const data = JSON.parse(raw);
+    return Array.isArray(data.peers) ? data.peers : [];
+  } catch {
+    return [];
+  }
+}
+function recordPeer(hello, dir = defaultStateDir(), now = /* @__PURE__ */ new Date()) {
+  const peers = loadPeers(dir);
+  const at = now.toISOString();
+  const clean = { handle: hello.handle, league: hello.league, harness: hello.harness };
+  const existing = peers.findIndex((p) => p.handle === clean.handle);
+  let isNew;
+  let peer;
+  if (existing >= 0) {
+    isNew = false;
+    peer = { ...peers[existing], ...clean, lastSeenAt: at };
+    peers[existing] = peer;
+  } else {
+    isNew = true;
+    peer = { ...clean, firstSeenAt: at, lastSeenAt: at };
+    peers.push(peer);
+  }
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync3(peersPath(dir), JSON.stringify({ peers }, null, 2) + "\n", "utf8");
+  return { peer, isNew };
+}
+async function startDiscovery(opts) {
+  const { hello, stateDir = defaultStateDir(), onPeer, onLink, notify = vibeCoreNotify } = opts;
+  const topic = opts.topic ?? leagueTopic(hello.league);
+  const { default: Hyperswarm } = await import("hyperswarm");
+  const swarm = new Hyperswarm(opts.bootstrap === void 0 ? {} : { bootstrap: opts.bootstrap });
+  await swarm.dht.fullyBootstrapped();
+  const peers = /* @__PURE__ */ new Map();
+  swarm.on("connection", (socket, info) => {
+    const remoteKey = info.publicKey.toString("hex");
+    socket.write(
+      serializeFrame({ t: "hello", handle: hello.handle, league: hello.league, harness: hello.harness }) + "\n"
+    );
+    let buf = "";
+    let handedOff = false;
+    const onData = (chunk) => {
+      if (handedOff) return;
+      buf += chunk.toString("utf8");
+      let nl;
+      while ((nl = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        if (line.trim() === "") continue;
+        const frame = parseFrame(line);
+        if (frame === null) continue;
+        if (frame.t !== "hello") continue;
+        const peer = {
+          handle: frame.handle,
+          league: frame.league,
+          harness: frame.harness
+        };
+        if (peer.league !== hello.league) continue;
+        peers.set(remoteKey, peer);
+        const { isNew } = recordPeer(peer, stateDir);
+        if (isNew) {
+          try {
+            notify(
+              makeEvent("match", hello.harness, process.cwd(), {
+                summary: `matched with ${peer.handle} - LIVE SAME LEAGUE`,
+                handle: peer.handle,
+                league: peer.league,
+                harness: peer.harness
+              })
+            );
+          } catch {
+          }
+        }
+        onPeer?.(peer, isNew);
+        handedOff = true;
+        socket.off("data", onData);
+        if (onLink !== void 0) {
+          const link = createPeerLink(socket, peer, buf);
+          onLink(link);
+        }
+        buf = "";
+        return;
+      }
+    };
+    socket.on("data", onData);
+    socket.on("error", () => {
+    });
+  });
+  const discovery = swarm.join(topic, { server: true, client: true });
+  const ready = discovery.flushed().catch(() => void 0);
+  await ready;
+  const refresher = setInterval(() => {
+    void discovery.refresh({ server: true, client: true }).catch(() => {
+    });
+  }, REFRESH_INTERVAL_MS);
+  refresher.unref();
+  let closed = false;
+  return {
+    topic,
+    hello,
+    peers,
+    ready,
+    async close() {
+      if (closed) return;
+      closed = true;
+      clearInterval(refresher);
+      try {
+        await swarm.leave(topic);
+      } catch {
+      }
+      await swarm.destroy();
+    }
+  };
+}
+
+// src/index.ts
+var LEAGUES = [
+  { name: "1M", min: 1e6, max: 4999999 },
+  { name: "5M", min: 5e6, max: 9999999 },
+  { name: "10M", min: 1e7, max: 99999999 },
+  { name: "100M", min: 1e8, max: 999999999 },
+  { name: "1B+", min: 1e9, max: Number.POSITIVE_INFINITY }
+];
+var BELOW_LEAGUE = "below-1M";
+function league(totalTokens) {
+  const n = Math.max(0, Math.floor(totalTokens));
+  for (const l of LEAGUES) {
+    if (n >= l.min && n <= l.max) {
+      return { name: l.name, min: l.min };
+    }
+  }
+  return { name: BELOW_LEAGUE, min: 0 };
+}
+function leagueIndex(name) {
+  if (name === BELOW_LEAGUE) return -1;
+  return LEAGUES.findIndex((l) => l.name === name);
+}
+var TOKENS_ENV = "VIBEDATING_TOKENS";
+var DEMO_TOTAL_TOKENS = 234e5;
+var MS_PER_DAY = 864e5;
+async function readUsage(harness = "claude-code") {
+  const verified = await tryReadVerifiedUsage(harness);
+  if (verified) return verified;
+  const injected = parseTokensEnv(process.env[TOKENS_ENV]);
+  const totalTokens = injected ?? DEMO_TOTAL_TOKENS;
+  const now = /* @__PURE__ */ new Date();
+  return {
+    harness,
+    totalTokens,
+    verified: false,
+    windowStart: new Date(now.getTime() - 30 * MS_PER_DAY).toISOString(),
+    windowEnd: now.toISOString()
+  };
+}
+async function tryReadVerifiedUsage(_harness) {
+  return null;
+}
+var TOKEN_MULT = {
+  "": 1,
+  k: 1e3,
+  K: 1e3,
+  m: 1e6,
+  M: 1e6,
+  b: 1e9,
+  B: 1e9
+};
+function parseTokensEnv(raw) {
+  if (raw === void 0) return void 0;
+  const trimmed = raw.trim();
+  if (trimmed === "") return void 0;
+  const match = /^([0-9]*\.?[0-9]+)\s*([kKmMbB]?)$/.exec(trimmed);
+  if (!match) return void 0;
+  const num = Number(match[1]);
+  if (!Number.isFinite(num) || num < 0) return void 0;
+  const mult = TOKEN_MULT[match[2] ?? ""] ?? 1;
+  return Math.floor(num * mult);
+}
+var CANDIDATES = [
+  {
+    handle: "@merge_conflict_therapist",
+    league: "10M",
+    bio: ["Resolves conflicts for a living \u2014 code and otherwise.", "Currently: 47 tabs open, 3 are Stack Overflow."]
+  },
+  {
+    handle: "@rebase_romantic",
+    league: "5M",
+    bio: ["Rewrites history for a living, git and otherwise.", "Looking for someone who squashes commits and grudges."]
+  },
+  {
+    handle: "@0xInsomniac",
+    league: "1B+",
+    bio: ["Token count is classified. Ask my therapist.", "Has never once respected a rate limit."]
+  },
+  {
+    handle: "@yolo_to_main",
+    league: "1M",
+    bio: ["No branches, no regrets, no CI.", "A green checkmark is a state of mind."]
+  },
+  {
+    handle: "@async_awaits_you",
+    league: "10M",
+    bio: ["Promises kept, unlike my sleep schedule.", "DMs are non-blocking. Replies eventually resolve."]
+  },
+  {
+    handle: "@nullish_and_void",
+    league: "5M",
+    bio: ["Coalescing since 2019.", "My love language is optional chaining."]
+  },
+  {
+    handle: "@ctrl_z_daddy",
+    league: "100M",
+    bio: ["Undo is my safe word.", "Refactors everything, including this bio, twice."]
+  },
+  {
+    handle: "@segfault_sonnet",
+    league: "1M",
+    bio: ["Writes poetry in stack traces.", "Core dumped. Heart, mostly, open."]
+  },
+  {
+    handle: "@the_lint_whisperer",
+    league: "10M",
+    bio: ["Zero warnings, zero regrets, zero chill.", "Will fix your semicolons without being asked."]
+  }
+];
+function matches(myLeague, candidates = CANDIDATES) {
+  const myIdx = leagueIndex(myLeague);
+  return candidates.filter((c) => {
+    const idx = leagueIndex(c.league);
+    if (idx < 0) return false;
+    return Math.abs(idx - myIdx) <= 1;
+  });
+}
+
+export {
+  parseFrame,
+  connectProfile,
+  loadProfile,
+  grantLiveConsent,
+  canShareLive,
+  TOPIC_PREFIX,
+  leagueTopic,
+  LIVE_NOTICE,
+  serializeHandshake,
+  parseHandshake,
+  loadPeers,
+  recordPeer,
+  startDiscovery,
+  LEAGUES,
+  BELOW_LEAGUE,
+  league,
+  leagueIndex,
+  TOKENS_ENV,
+  DEMO_TOTAL_TOKENS,
+  readUsage,
+  tryReadVerifiedUsage,
+  parseTokensEnv,
+  CANDIDATES,
+  matches,
+  createConsentLedger2 as createConsentLedger
+};