vibedate 0.6.0 → 0.7.0

package/dist/{chunk-VZXPYU2C.js → chunk-HDHJLZZG.js}

@@ -1145,6 +1145,103 @@ async function createNostrPoolTransport(urls = DEFAULT_RELAYS) {
   };
 }
 
+// src/room.ts
+import { createHash as createHash3 } from "crypto";
+var ROOM_TOPIC_PREFIX = "vibedate-room:";
+function roomTopic(name) {
+  return createHash3("sha256").update(`${ROOM_TOPIC_PREFIX}${name}`, "utf8").digest();
+}
+async function startRoom(opts) {
+  const topic = roomTopic(opts.room);
+  const entries = /* @__PURE__ */ new Map();
+  const memberHellos = /* @__PURE__ */ new Map();
+  const messageCbs = /* @__PURE__ */ new Set();
+  const rosterCbs = /* @__PURE__ */ new Set();
+  const signalCbs = /* @__PURE__ */ new Set();
+  const fireRoster = () => {
+    const snapshot = [...memberHellos.values()];
+    for (const cb of rosterCbs) cb(snapshot);
+  };
+  let discovery;
+  const ready = startDiscovery({
+    hello: opts.hello,
+    // ONE topic — the room's own. Rooms are intentionally cross-league, so
+    // every member of the room is accepted regardless of advertised league.
+    topics: [topic],
+    acceptLeague: () => true,
+    ...opts.isBlocked === void 0 ? {} : { isBlocked: opts.isBlocked },
+    ...opts.bootstrap === void 0 ? {} : { bootstrap: opts.bootstrap },
+    ...opts.stateDir === void 0 ? {} : { stateDir: opts.stateDir },
+    ...opts.notify === void 0 ? {} : { notify: opts.notify },
+    onLink: (link) => {
+      const handle = link.hello.handle;
+      entries.set(handle, { hello: link.hello, link });
+      memberHellos.set(handle, link.hello);
+      fireRoster();
+      link.onMessage((m) => {
+        for (const cb of messageCbs) cb({ from: handle, ...m });
+      });
+      link.onSignal((frame) => {
+        for (const cb of signalCbs) cb(handle, frame);
+      });
+      link.onClose(() => {
+        const cur = entries.get(handle);
+        if (cur && cur.link === link) {
+          entries.delete(handle);
+          memberHellos.delete(handle);
+          fireRoster();
+        }
+      });
+    }
+  }).then((s) => {
+    discovery = s;
+    return s.ready;
+  });
+  const session = {
+    room: opts.room,
+    topic,
+    hello: opts.hello,
+    members: memberHellos,
+    ready,
+    broadcast(text) {
+      const reached = [];
+      for (const [handle, entry] of entries) {
+        entry.link.send(text);
+        reached.push(handle);
+      }
+      return reached;
+    },
+    onMessage(cb) {
+      messageCbs.add(cb);
+    },
+    onRoster(cb) {
+      rosterCbs.add(cb);
+    },
+    onSignal(cb) {
+      signalCbs.add(cb);
+    },
+    sendSignal(handle, frame) {
+      entries.get(handle)?.link.sendSignal(frame);
+    },
+    linkFor(handle) {
+      return entries.get(handle)?.link;
+    },
+    async close() {
+      await ready.catch(() => void 0);
+      for (const entry of entries.values()) {
+        try {
+          entry.link.close();
+        } catch {
+        }
+      }
+      entries.clear();
+      memberHellos.clear();
+      if (discovery !== void 0) await discovery.close();
+    }
+  };
+  return session;
+}
+
 // src/index.ts
 var LEAGUES = [
   { name: "1M", min: 1e6, max: 4999999 },
@@ -1320,6 +1417,9 @@ export {
   conversationTag,
   createNostrRelayLink,
   createNostrPoolTransport,
+  ROOM_TOPIC_PREFIX,
+  roomTopic,
+  startRoom,
   LEAGUES,
   BELOW_LEAGUE,
   league,

package/dist/{chunk-JIBC3OHV.js → chunk-ZD6JBWEW.js}

@@ -2,7 +2,7 @@ import {
   CANDIDATES,
   loadProfile,
   matches
-} from "./chunk-VZXPYU2C.js";
+} from "./chunk-HDHJLZZG.js";
 
 // src/mcp.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/dist/cli.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /** Recognized top-level commands, plus the synthetic help/version. */
-type Command = 'connect' | 'matches' | 'discover' | 'open' | 'live' | 'find' | 'handle' | 'block' | 'unblock' | 'blocklist' | 'daemon' | 'mcp' | 'help' | 'version' | null;
+type Command = 'connect' | 'matches' | 'discover' | 'open' | 'live' | 'find' | 'handle' | 'block' | 'unblock' | 'blocklist' | 'daemon' | 'mcp' | 'room' | 'help' | 'version' | null;
 interface ParsedArgs {
     readonly command: Command;
     /** Port for `open --port`; undefined means "let the OS pick". */
@@ -23,6 +23,8 @@ interface ParsedArgs {
      * auto-fallback-on-timeout is a follow-up. Default false.
      */
     readonly viaRelay: boolean;
+    /** `room <name>` positional, or `--room <name>`: join/create a named room. */
+    readonly room: string | undefined;
 }
 /**
  * Parse argv (the slice AFTER the program name) into a command + options.

package/dist/cli.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import {
   runMcp
-} from "./chunk-JIBC3OHV.js";
+} from "./chunk-ZD6JBWEW.js";
 import {
   CANDIDATES,
   DEFAULT_HANDLE,
   LIVE_NOTICE,
   MAX_HANDLE_LEN,
+  ROOM_TOPIC_PREFIX,
   TOPIC_PREFIX,
   addBlock,
   allLeagueNames,
@@ -37,8 +38,9 @@ import {
   sanitizePeerText,
   saveHandle,
   signHelloClaims,
-  startDiscovery
-} from "./chunk-VZXPYU2C.js";
+  startDiscovery,
+  startRoom
+} from "./chunk-HDHJLZZG.js";
 
 // src/cli.ts
 import readline from "readline";
@@ -1891,6 +1893,111 @@ function createLiveBridge() {
   };
   return bridge;
 }
+var MAX_QUEUED_ROOM_SIGNALS = 200;
+function createRoomBridge(name) {
+  let session;
+  const messageQueue = [];
+  const messageWaiters = [];
+  const signalBoxes = /* @__PURE__ */ new Map();
+  const signalWaiters = /* @__PURE__ */ new Map();
+  const drainMessage = (m) => {
+    const safe = { ...m, text: sanitizePeerText(m.text) };
+    const waiter = messageWaiters.shift();
+    if (waiter !== void 0) {
+      waiter(safe);
+      return;
+    }
+    messageQueue.push(safe);
+    if (messageQueue.length > MAX_QUEUED_MESSAGES) {
+      messageQueue.splice(0, messageQueue.length - MAX_QUEUED_MESSAGES);
+    }
+  };
+  const drainSignal = (from, frame) => {
+    const waiters = signalWaiters.get(from);
+    if (waiters !== void 0 && waiters.length > 0) {
+      const w = waiters.shift();
+      if (w !== void 0) {
+        if (waiters.length === 0) signalWaiters.delete(from);
+        w(frame);
+        return;
+      }
+    }
+    let box = signalBoxes.get(from);
+    if (box === void 0) {
+      box = [];
+      signalBoxes.set(from, box);
+    }
+    box.push(frame);
+    if (box.length > MAX_QUEUED_ROOM_SIGNALS) {
+      box.splice(0, box.length - MAX_QUEUED_ROOM_SIGNALS);
+    }
+  };
+  return {
+    name,
+    get self() {
+      return session?.hello.handle;
+    },
+    get members() {
+      if (session === void 0) return [];
+      return [...session.members.values()].map((h) => ({
+        handle: h.handle,
+        league: h.league,
+        harness: h.harness,
+        ...h.verified !== void 0 ? { verified: h.verified } : {},
+        ...h.identityVerified !== void 0 ? { identityVerified: h.identityVerified } : {}
+      }));
+    },
+    attach(s) {
+      session = s;
+      s.onMessage(drainMessage);
+      s.onSignal((from, frame) => drainSignal(from, frame));
+    },
+    broadcast(text) {
+      session?.broadcast(text);
+    },
+    async pollMessage(timeoutMs) {
+      if (messageQueue.length > 0) return messageQueue.shift() ?? null;
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          const idx = messageWaiters.indexOf(resolve);
+          if (idx >= 0) messageWaiters.splice(idx, 1);
+          resolve(null);
+        }, timeoutMs);
+        messageWaiters.push((m) => {
+          clearTimeout(timer);
+          resolve(m);
+        });
+      });
+    },
+    sendSignal(handle2, frame) {
+      session?.sendSignal(handle2, frame);
+    },
+    async pollSignal(handle2, timeoutMs) {
+      const box = signalBoxes.get(handle2);
+      if (box !== void 0 && box.length > 0) return box.shift() ?? null;
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          const waiters2 = signalWaiters.get(handle2);
+          if (waiters2 !== void 0) {
+            const idx = waiters2.indexOf(resolve);
+            if (idx >= 0) waiters2.splice(idx, 1);
+            if (waiters2.length === 0) signalWaiters.delete(handle2);
+          }
+          resolve(null);
+        }, timeoutMs);
+        let waiters = signalWaiters.get(handle2);
+        if (waiters === void 0) {
+          waiters = [];
+          signalWaiters.set(handle2, waiters);
+        }
+        waiters.push((f) => {
+          clearTimeout(timer);
+          resolve(f);
+        });
+      });
+    }
+  };
+}
 function currentState(dir) {
   const p = loadProfile(dir);
   if (!p) return { connected: false, candidates: [] };
@@ -2111,11 +2218,101 @@ async function handle(req, res, opts) {
     sendJson(res, 200, { ok: true });
     return;
   }
+  if (req.method === "GET" && pathname === "/api/room") {
+    const room = opts.room;
+    sendJson(res, 200, room ? { room: room.name, self: room.self ?? null, members: room.members } : { room: null, self: null, members: [] });
+    return;
+  }
+  if (req.method === "GET" && pathname === "/room/message") {
+    const room = opts.room;
+    if (!room) {
+      sendJson(res, 200, { message: null, reason: "room-not-attached" });
+      return;
+    }
+    const message = await room.pollMessage(25e3);
+    if (req.destroyed || res.writableEnded) return;
+    sendJson(res, 200, { message });
+    return;
+  }
+  if (req.method === "POST" && pathname === "/room/message") {
+    const room = opts.room;
+    if (!room) {
+      sendJson(res, 400, { error: "room-not-attached" });
+      return;
+    }
+    const body = await readBody(req);
+    let parsed = {};
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      sendJson(res, 400, { error: "invalid JSON body" });
+      return;
+    }
+    const text = parsed["text"];
+    if (typeof text !== "string") {
+      sendJson(res, 400, { error: "missing text" });
+      return;
+    }
+    const reParsed = parseFrame(
+      JSON.stringify({ t: "msg", id: randomUUID(), text, at: Date.now() })
+    );
+    if (reParsed === null || reParsed.t !== "msg") {
+      sendJson(res, 400, { error: "invalid message text" });
+      return;
+    }
+    room.broadcast(reParsed.text);
+    sendJson(res, 200, { ok: true });
+    return;
+  }
+  if (req.method === "GET" && pathname === "/room/signal") {
+    const room = opts.room;
+    if (!room) {
+      sendJson(res, 200, { frame: null, reason: "room-not-attached" });
+      return;
+    }
+    const handle2 = url.searchParams.get("handle") ?? "";
+    if (handle2 === "") {
+      sendJson(res, 400, { error: "missing handle" });
+      return;
+    }
+    const frame = await room.pollSignal(handle2, 25e3);
+    if (req.destroyed || res.writableEnded) return;
+    sendJson(res, 200, { frame });
+    return;
+  }
+  if (req.method === "POST" && pathname === "/room/signal") {
+    const room = opts.room;
+    if (!room) {
+      sendJson(res, 400, { error: "room-not-attached" });
+      return;
+    }
+    const body = await readBody(req);
+    let parsed = {};
+    try {
+      parsed = JSON.parse(body);
+    } catch {
+      sendJson(res, 400, { error: "invalid JSON body" });
+      return;
+    }
+    const handle2 = typeof parsed["handle"] === "string" ? parsed["handle"] : "";
+    if (handle2 === "") {
+      sendJson(res, 400, { error: "missing handle" });
+      return;
+    }
+    const reParsed = parseFrame(JSON.stringify(parsed["frame"]));
+    if (reParsed === null || reParsed.t !== "rtc-offer" && reParsed.t !== "rtc-answer" && reParsed.t !== "rtc-ice") {
+      sendJson(res, 400, { error: "invalid rtc frame" });
+      return;
+    }
+    room.sendSignal(handle2, reParsed);
+    sendJson(res, 200, { ok: true });
+    return;
+  }
   sendJson(res, 404, { error: "not found" });
 }
 
 // src/cli.ts
-var VERSION = "0.6.0";
+var VERSION = "0.7.0";
 function parsePort(raw) {
   const n = Number(raw);
   if (!Number.isInteger(n) || n < 1 || n > 65535) return void 0;
@@ -2131,7 +2328,8 @@ function parseArgs(argv) {
     arg: void 0,
     to: void 0,
     keepAlive: false,
-    viaRelay: false
+    viaRelay: false,
+    room: void 0
   };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -2145,7 +2343,8 @@ function parseArgs(argv) {
         arg: void 0,
         to: void 0,
         keepAlive: false,
-        viaRelay: false
+        viaRelay: false,
+        room: void 0
       };
     }
     if (a === "--help" || a === "-h") {
@@ -2158,7 +2357,8 @@ function parseArgs(argv) {
         arg: void 0,
         to: void 0,
         keepAlive: false,
-        viaRelay: false
+        viaRelay: false,
+        room: void 0
       };
     }
     if (a === "--live") {
@@ -2173,6 +2373,18 @@ function parseArgs(argv) {
       out = { ...out, viaRelay: true };
       continue;
     }
+    if (a === "--room") {
+      const next = argv[i + 1];
+      if (next !== void 0) {
+        out = { ...out, room: next };
+        i++;
+      }
+      continue;
+    }
+    if (a.startsWith("--room=")) {
+      out = { ...out, room: a.slice("--room=".length) };
+      continue;
+    }
     if (a === "--any") {
       out = { ...out, any: true };
       continue;
@@ -2208,7 +2420,7 @@ function parseArgs(argv) {
       continue;
     }
     if (a.startsWith("-")) continue;
-    const known = a === "connect" || a === "matches" || a === "discover" || a === "open" || a === "live" || a === "find" || a === "handle" || a === "block" || a === "unblock" || a === "blocklist" || a === "daemon" || a === "mcp" || a === "help" ? a : null;
+    const known = a === "connect" || a === "matches" || a === "discover" || a === "open" || a === "live" || a === "find" || a === "handle" || a === "block" || a === "unblock" || a === "blocklist" || a === "daemon" || a === "mcp" || a === "room" || a === "help" ? a : null;
     if (known !== null && out.command === null) {
       out = { ...out, command: known };
     } else if (out.arg === void 0) {
@@ -2452,36 +2664,59 @@ async function cmdDiscover(live, any, viaRelay) {
   );
   return 0;
 }
-async function cmdOpen(port, any) {
+async function cmdOpen(port, any, room) {
   const profile = loadProfile();
   let live;
+  let roomBridge;
   let session;
+  let roomSession;
   if (profile) {
     if (!canShareLive()) grantLiveConsent();
-    live = createLiveBridge();
+    if (room !== void 0) {
+      roomBridge = createRoomBridge(room);
+    } else {
+      live = createLiveBridge();
+    }
   }
-  const started = await startServer({ port, live });
-  if (profile && live) {
+  const started = await startServer({
+    port,
+    live,
+    ...roomBridge === void 0 ? {} : { room: roomBridge }
+  });
+  if (profile) {
     process2.stdout.write(`
   ${LIVE_NOTICE}
 `);
     const hello = buildHello(profile);
-    const { topics, acceptLeague } = discoveryScope(profile.league, any);
-    void startDiscovery({
-      hello,
-      topics,
-      acceptLeague,
-      isBlocked: blockedChecker(),
-      onLink: (link) => live.addLink(link)
-    }).then((s) => {
-      session = s;
-    }).catch(() => {
-    });
+    if (room !== void 0 && roomBridge !== void 0) {
+      void startRoom({ hello, room, isBlocked: blockedChecker() }).then((s) => {
+        roomSession = s;
+        roomBridge.attach(s);
+      }).catch(() => {
+      });
+    } else if (live) {
+      const { topics, acceptLeague } = discoveryScope(profile.league, any);
+      void startDiscovery({
+        hello,
+        topics,
+        acceptLeague,
+        isBlocked: blockedChecker(),
+        onLink: (link) => live.addLink(link)
+      }).then((s) => {
+        session = s;
+      }).catch(() => {
+      });
+    }
   }
   process2.stdout.write(`
   vibedating local web app \u2192 ${started.url}
 `);
-  if (live) {
+  if (room !== void 0) {
+    process2.stdout.write(
+      `  \u2022 room: ${room} \u2014 roster + group chat + full-mesh group video (~6 people; an SFU is the upgrade path for bigger rooms)
+`
+    );
+  } else if (live) {
     process2.stdout.write(
       any ? "  \u2022 live video + chat available for connected peers (ANY league \u2014 --any)\n" : "  \u2022 live video + chat available for connected peers (your league + adjacent; --any = everyone)\n"
     );
@@ -2495,6 +2730,7 @@ async function cmdOpen(port, any) {
     process2.once("SIGTERM", () => resolve());
   });
   process2.stdout.write("\n  shutting down\u2026\n");
+  if (roomSession) await roomSession.close();
   if (session) await session.close();
   await new Promise((resolve) => started.server.close(() => resolve()));
   return 0;
@@ -2717,6 +2953,104 @@ async function cmdLive(dating, any, to, keepAlive, viaRelay) {
   process2.stdout.write("\n");
   return 0;
 }
+async function cmdRoom(name, keepAlive) {
+  if (name === void 0 || name.trim() === "") {
+    process2.stderr.write("usage: vibedating room <name>\n");
+    return 1;
+  }
+  const profile = loadProfile();
+  if (!profile) {
+    process2.stderr.write("Not connected yet. Run `vibedating connect` first.\n");
+    return 1;
+  }
+  if (!canShareLive()) grantLiveConsent();
+  if (!canShareLive()) {
+    process2.stderr.write("Could not enable live discovery. Try `vibedating discover --live`.\n");
+    return 1;
+  }
+  const hello = buildHello(profile);
+  process2.stdout.write("\n");
+  process2.stdout.write(`  ${LIVE_NOTICE}
+`);
+  process2.stdout.write(`  ${MARKS_LEGEND}
+`);
+  process2.stdout.write(`  room: ${name}  (cross-league \u2014 everyone in the room is a member)
+`);
+  const session = await startRoom({
+    hello,
+    room: name,
+    isBlocked: blockedChecker()
+  });
+  session.onRoster((members) => {
+    if (members.length === 0) {
+      process2.stdout.write("  \xB7 room empty \u2014 waiting for members\u2026\n");
+      return;
+    }
+    const list = members.map(
+      (m) => `${sanitizePeerText(m.handle)} (${m.league} \xB7 ${m.harness}) ${usageMark(m)}${idMark(m)}`
+    ).join(", ");
+    process2.stdout.write(`  \xB7 room (${members.length}): ${list}
+`);
+  });
+  session.onMessage((m) => {
+    process2.stdout.write(`  <${sanitizePeerText(m.from)}> ${sanitizePeerText(m.text)}
+`);
+  });
+  process2.stdout.write(
+    `  topic: ${ROOM_TOPIC_PREFIX}${name} \u2192 ${session.topic.toString("hex").slice(0, 12)}\u2026
+`
+  );
+  process2.stdout.write("  type to broadcast to the whole room \xB7 /who \xB7 /quit\n");
+  process2.stdout.write(`  group video: run \`vibedating open --room ${name}\`
+
+`);
+  const rl = readline.createInterface({ input: process2.stdin, terminal: false });
+  const stop = () => {
+    rl.close();
+  };
+  process2.once("SIGINT", stop);
+  process2.once("SIGTERM", stop);
+  let quitRequested = false;
+  for await (const line of rl) {
+    const text = line.trim();
+    if (text === "/quit") {
+      quitRequested = true;
+      break;
+    }
+    if (text === "/who") {
+      const members = [...session.members.values()];
+      if (members.length === 0) {
+        process2.stdout.write("  \xB7 room empty\n");
+      } else {
+        for (const m of members) {
+          process2.stdout.write(
+            `  \xB7 ${sanitizePeerText(m.handle)} (${m.league} \xB7 ${m.harness}) ${usageMark(m)}${idMark(m)}
+`
+          );
+        }
+      }
+      continue;
+    }
+    if (text === "") continue;
+    const reached = session.broadcast(text);
+    if (reached.length === 0) {
+      process2.stdout.write("  \xB7 room empty \u2014 no one to hear you yet\n");
+    }
+  }
+  if (!quitRequested && shouldKeepAlive(keepAlive, process2.stdin.isTTY)) {
+    process2.stdout.write("  stdin closed \u2014 staying in the room (Ctrl+C / SIGTERM to leave)\n");
+    await new Promise((resolve) => {
+      process2.once("SIGINT", () => resolve());
+      process2.once("SIGTERM", () => resolve());
+    });
+  }
+  process2.removeListener("SIGINT", stop);
+  process2.removeListener("SIGTERM", stop);
+  process2.stdout.write("\n  leaving the room\u2026\n");
+  await session.close();
+  process2.stdout.write("\n");
+  return 0;
+}
 async function cmdFind(targetArg, any) {
   if (targetArg === void 0 || targetArg.trim() === "") {
     process2.stderr.write("usage: vibedating find <@handle> [--any]\n");
@@ -2968,9 +3302,15 @@ Usage:
                                 NEW matches, never opens chat/video. install adds a
                                 login service (launchd on macOS, systemd on Linux);
                                 uninstall removes it.
-  vibedating open [--port N] [--any]  Serve the local web app (default: random port)
-                                + live video + chat with connected peers
-                                (your league + adjacent; --any = every league)
+  vibedating room <name>        Join/create a named room (multi-peer): live roster
+                                + group text chat broadcast to all members.
+                                Consent-gated like live. /who lists members, /quit leaves.
+  vibedating open [--port N] [--any] [--room <name>]  Serve the local web app (default:
+                                random port) + live video + chat with connected peers
+                                (your league + adjacent; --any = every league).
+                                --room <name> opens the room view instead: roster +
+                                group chat + full-mesh group video (~6 people; an SFU
+                                is the upgrade path for bigger rooms).
   vibedating mcp                Run the stdio MCP server (profile, matches)
   vibedating --version
   vibedating --help
@@ -3022,11 +3362,13 @@ async function main(argv) {
     case "discover":
       return cmdDiscover(parsed.live, parsed.any, parsed.viaRelay);
     case "open":
-      return cmdOpen(parsed.port, parsed.any);
+      return cmdOpen(parsed.port, parsed.any, parsed.room);
     case "live":
       return cmdLive(parsed.dating, parsed.any, parsed.to, parsed.keepAlive, parsed.viaRelay);
     case "find":
       return cmdFind(parsed.arg, parsed.any);
+    case "room":
+      return cmdRoom(parsed.arg ?? parsed.room, parsed.keepAlive);
     case "mcp":
       await runMcp();
       return 0;

package/dist/index.d.ts

@@ -351,6 +351,87 @@ declare function createNostrRelayLink(opts: CreateNostrRelayLinkOptions): Promis
  */
 declare function createNostrPoolTransport(urls?: readonly string[]): Promise<RelayTransport>;
 
+/** Namespace prefix so room topics never collide with league topics (or anything
+ *  else on the DHT). Mirrors {@link p2p.TOPIC_PREFIX} for the 1:1 path. */
+declare const ROOM_TOPIC_PREFIX = "vibedate-room:";
+/**
+ * Derive the 32-byte DHT topic for a named room. Deterministic: everyone who
+ * joins the same room name anywhere in the world hashes to the same topic,
+ * which is the entire discovery mechanism. Pure (mirrors {@link p2p.leagueTopic}).
+ */
+declare function roomTopic(name: string): Buffer;
+/** A room member = a connected, handshaken peer. Same shape as a live peer. */
+type RoomMember = PeerHello;
+/** One group chat message: a `msg` frame's payload tagged with the sender. */
+interface RoomMessage {
+    /** Sender's handle (from the validated hello — UNTRUSTED display data). */
+    readonly from: string;
+    readonly id: string;
+    readonly text: string;
+    readonly at: number;
+}
+interface RoomOptions {
+    /** What we broadcast. Must already be consent-gated by the caller. */
+    readonly hello: PeerHello;
+    /** Room name → its own DHT topic (see {@link roomTopic}). */
+    readonly room: string;
+    /** DHT bootstrap nodes; omit for the public DHT. Tests pass a local testnet. */
+    readonly bootstrap?: ReadonlyArray<{
+        readonly host: string;
+        readonly port: number;
+    }>;
+    /** Where peers.json lives. Defaults to ~/.vibedating. */
+    readonly stateDir?: string;
+    /** Predicate over a blocked handle — a blocked peer's hello is dropped exactly
+     *  like in 1:1 discovery. Default: nothing blocked. */
+    readonly isBlocked?: (handle: string) => boolean;
+    /** Match-notification sink (tests capture with a fake). Best-effort. */
+    readonly notify?: NotifySink;
+}
+interface RoomSession {
+    /** The room name. */
+    readonly room: string;
+    /** The joined DHT topic (see {@link roomTopic}). */
+    readonly topic: Buffer;
+    /** What we broadcast. */
+    readonly hello: PeerHello;
+    /** Live member set, keyed by handle (excludes self). Mirrors the live view
+     *  semantics of {@link p2p.DiscoverySession.peers}. */
+    readonly members: ReadonlyMap<string, RoomMember>;
+    /** Resolves when the first DHT announce/lookup round completes. */
+    readonly ready: Promise<unknown>;
+    /**
+     * Broadcast a text message to ALL room members (fan-out: one `msg` frame per
+     * member's {@link PeerLink}). Returns the handles the message was sent to.
+     * Best-effort: a member whose link has just closed is skipped silently.
+     */
+    broadcast(text: string): readonly string[];
+    /** Register a callback fired for each incoming group message (with sender). */
+    onMessage(cb: (m: RoomMessage) => void): void;
+    /** Register a callback fired whenever the member roster changes (join/leave). */
+    onRoster(cb: (members: readonly RoomMember[]) => void): void;
+    /** Register a callback fired for each incoming `rtc-*` signaling frame,
+     *  tagged with the sender's handle (full-mesh video signaling). */
+    onSignal(cb: (from: string, frame: RtcFrame) => void): void;
+    /** Relay one `rtc-*` signaling frame to one member (by handle). */
+    sendSignal(handle: string, frame: RtcFrame): void;
+    /** The underlying {@link PeerLink} to a member (by handle), or undefined. */
+    linkFor(handle: string): PeerLink | undefined;
+    /** Leave the room and destroy the node. Idempotent. */
+    close(): Promise<void>;
+}
+/**
+ * Join (or create) a named room on the DHT and discover ALL members. CONSENT
+ * GATE LIVES WITH THE CALLER — never call this without the `share:live` grant
+ * (or an explicit opt-in in the same breath), exactly like
+ * {@link p2p.startDiscovery}.
+ *
+ * Resolves once the first DHT announce/lookup round completes; the returned
+ * session's {@link RoomSession.members} map + {@link RoomSession.onRoster}
+ * callback track every member that joins or leaves thereafter.
+ */
+declare function startRoom(opts: RoomOptions): Promise<RoomSession>;
+
 /**
  * Persistent ed25519 identity — binds a handle to a keypair so a peer cannot
  * impersonate it.
@@ -558,4 +639,4 @@ declare const CANDIDATES: readonly Candidate[];
  */
 declare function matches(myLeague: string, candidates?: readonly Candidate[]): Candidate[];
 
-export { BELOW_LEAGUE, CANDIDATES, type Candidate, type CreateNostrRelayLinkOptions, DEFAULT_RELAYS, DEMO_TOTAL_TOKENS, type DiscoveryOptions, type DiscoverySession, type HelloClaims, type Identity, type IdentityProof, type IdentityVerdict, LEAGUES, LIVE_NOTICE, type League, type LocalUsageSnapshot, type NostrKey, type NostrRelayLink, type PeerHello, type RelayEvent, type RelayFilter, type RelayTransport, type StoredPeer, TOKENS_ENV, TOPIC_PREFIX, VIBEDATE_MESSAGE_KIND, VIBEDATE_PRESENCE_KIND, allLeagueNames, canonicalHelloClaims, classifyHelloIdentity, conversationTag, createNostrPoolTransport, createNostrRelayLink, league, leagueIndex, leagueTopic, leaguesWithin, loadOrCreateIdentity, loadOrCreateNostrKey, loadPeers, matches, parseHandshake, parseTokensEnv, readUsage, recordPeer, recordPeerMessage, serializeHandshake, signHelloClaims, startDiscovery, verifyHelloClaims };
+export { BELOW_LEAGUE, CANDIDATES, type Candidate, type CreateNostrRelayLinkOptions, DEFAULT_RELAYS, DEMO_TOTAL_TOKENS, type DiscoveryOptions, type DiscoverySession, type HelloClaims, type Identity, type IdentityProof, type IdentityVerdict, LEAGUES, LIVE_NOTICE, type League, type LocalUsageSnapshot, type NostrKey, type NostrRelayLink, type PeerHello, ROOM_TOPIC_PREFIX, type RelayEvent, type RelayFilter, type RelayTransport, type RoomMember, type RoomMessage, type RoomOptions, type RoomSession, type StoredPeer, TOKENS_ENV, TOPIC_PREFIX, VIBEDATE_MESSAGE_KIND, VIBEDATE_PRESENCE_KIND, allLeagueNames, canonicalHelloClaims, classifyHelloIdentity, conversationTag, createNostrPoolTransport, createNostrRelayLink, league, leagueIndex, leagueTopic, leaguesWithin, loadOrCreateIdentity, loadOrCreateNostrKey, loadPeers, matches, parseHandshake, parseTokensEnv, readUsage, recordPeer, recordPeerMessage, roomTopic, serializeHandshake, signHelloClaims, startDiscovery, startRoom, verifyHelloClaims };

package/dist/index.js

@@ -5,6 +5,7 @@ import {
   DEMO_TOTAL_TOKENS,
   LEAGUES,
   LIVE_NOTICE,
+  ROOM_TOPIC_PREFIX,
   TOKENS_ENV,
   TOPIC_PREFIX,
   VIBEDATE_MESSAGE_KIND,
@@ -29,11 +30,13 @@ import {
   readUsage,
   recordPeer,
   recordPeerMessage,
+  roomTopic,
   serializeHandshake,
   signHelloClaims,
   startDiscovery,
+  startRoom,
   verifyHelloClaims
-} from "./chunk-VZXPYU2C.js";
+} from "./chunk-HDHJLZZG.js";
 export {
   BELOW_LEAGUE,
   CANDIDATES,
@@ -41,6 +44,7 @@ export {
   DEMO_TOTAL_TOKENS,
   LEAGUES,
   LIVE_NOTICE,
+  ROOM_TOPIC_PREFIX,
   TOKENS_ENV,
   TOPIC_PREFIX,
   VIBEDATE_MESSAGE_KIND,
@@ -65,8 +69,10 @@ export {
   readUsage,
   recordPeer,
   recordPeerMessage,
+  roomTopic,
   serializeHandshake,
   signHelloClaims,
   startDiscovery,
+  startRoom,
   verifyHelloClaims
 };

package/dist/mcp.js

@@ -1,7 +1,7 @@
 import {
   runMcp
-} from "./chunk-JIBC3OHV.js";
-import "./chunk-VZXPYU2C.js";
+} from "./chunk-ZD6JBWEW.js";
+import "./chunk-HDHJLZZG.js";
 export {
   runMcp
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibedate",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Dating by tokens — matched by usage league across agentic CLIs. Raw usage stays local; only your league is shared. CLI + local web app + MCP. Local-first.",
   "type": "module",
   "license": "MIT",