@openvole/volenet 1.0.0 → 1.1.0

package/dist/index.js

@@ -1,8 +1,8 @@
 // src/index.ts
-import { randomUUID as randomUUID5 } from "crypto";
-import * as fs8 from "fs/promises";
+import { randomUUID as randomUUID6 } from "crypto";
+import * as fs9 from "fs/promises";
 import * as os from "os";
-import * as path7 from "path";
+import * as path8 from "path";
 
 // src/chat-outbox.ts
 import * as crypto from "crypto";
@@ -1525,8 +1525,8 @@ var ChunkDecryptStream = class extends Transform {
 };
 async function scanFrameOffset(filePath, fromChunk, chunkBytes = CHUNK_BYTES_DEFAULT) {
   if (fromChunk <= 0) return 0;
-  const fs9 = await import("fs/promises");
-  const fd = await fs9.open(filePath, "r");
+  const fs10 = await import("fs/promises");
+  const fd = await fs10.open(filePath, "r");
   try {
     const len = Buffer.alloc(LEN_BYTES);
     let offset = 0;
@@ -3202,6 +3202,95 @@ var ResultOutbox = class {
   }
 };
 
+// src/rooms.ts
+import * as crypto9 from "crypto";
+import * as fs7 from "fs/promises";
+import * as path7 from "path";
+var MAX_ROOM_MEMBERS = 64;
+var EMPTY_ROOM_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var RoomStore = class {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  rooms = /* @__PURE__ */ new Map();
+  writing = Promise.resolve();
+  async load(now = Date.now()) {
+    try {
+      const raw = JSON.parse(await fs7.readFile(this.file, "utf-8"));
+      for (const r of Array.isArray(raw) ? raw : []) {
+        if (r?.id && typeof r.name === "string" && Array.isArray(r.members)) {
+          this.rooms.set(r.id, { ...r, lastOccupied: r.lastOccupied ?? now });
+        }
+      }
+    } catch {
+    }
+    await this.sweep(now);
+  }
+  get(id) {
+    return this.rooms.get(id);
+  }
+  list() {
+    return [...this.rooms.values()];
+  }
+  /** Rooms this member belongs to. */
+  forMember(instanceId) {
+    return this.list().filter((r) => r.members.includes(instanceId));
+  }
+  async create(name, creator, topic) {
+    const room = {
+      id: crypto9.randomUUID(),
+      name: name.slice(0, 64) || "room",
+      ...topic ? { topic: topic.slice(0, 200) } : {},
+      members: [creator],
+      createdAt: Date.now(),
+      lastOccupied: Date.now()
+    };
+    this.rooms.set(room.id, room);
+    await this.persist();
+    return room;
+  }
+  /** Add a member. The ceiling is the design's edge, so it is refused rather than stretched. */
+  async join(id, instanceId) {
+    const room = this.rooms.get(id);
+    if (!room) return "no-such-room";
+    if (room.members.includes(instanceId)) return room;
+    if (room.members.length >= MAX_ROOM_MEMBERS) return "full";
+    room.members.push(instanceId);
+    room.lastOccupied = Date.now();
+    await this.persist();
+    return room;
+  }
+  async leave(id, instanceId) {
+    const room = this.rooms.get(id);
+    if (!room) return "no-such-room";
+    if (!room.members.includes(instanceId)) return "not-a-member";
+    room.members = room.members.filter((m) => m !== instanceId);
+    if (room.members.length > 0) room.lastOccupied = Date.now();
+    await this.persist();
+    return room;
+  }
+  /** Drop rooms nobody has been in for the TTL. */
+  async sweep(now = Date.now()) {
+    const gone = this.list().filter(
+      (r) => r.members.length === 0 && now - r.lastOccupied > EMPTY_ROOM_TTL_MS
+    );
+    if (gone.length === 0) return [];
+    for (const r of gone) this.rooms.delete(r.id);
+    await this.persist();
+    return gone;
+  }
+  persist() {
+    this.writing = this.writing.then(async () => {
+      await fs7.mkdir(path7.dirname(this.file), { recursive: true });
+      const tmp = `${this.file}.tmp`;
+      await fs7.writeFile(tmp, JSON.stringify(this.list(), null, 2), "utf-8");
+      await fs7.rename(tmp, this.file);
+    });
+    return this.writing;
+  }
+};
+
 // src/sync.ts
 var logger7 = createLogger("volenet-sync");
 var VoleNetSync = class {
@@ -3458,7 +3547,7 @@ function isControlPlanePaw(pawName) {
 }
 
 // src/transport.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as http from "http";
 import * as https from "https";
 import { WebSocket, WebSocketServer } from "ws";
@@ -3758,8 +3847,8 @@ var VoleNetTransport = class {
     if (this.config.tls) {
       this.server = https.createServer(
         {
-          cert: fs7.readFileSync(this.config.tls.cert),
-          key: fs7.readFileSync(this.config.tls.key)
+          cert: fs8.readFileSync(this.config.tls.cert),
+          key: fs8.readFileSync(this.config.tls.key)
         },
         requestHandler
       );
@@ -3851,6 +3940,14 @@ var VoleNetTransport = class {
     this.startPinging();
   }
   /** Bind the listening port, retrying briefly on EADDRINUSE (covers restart races). */
+  /**
+   * The port actually bound, which is not always the one configured — a host may pass 0 and let
+   * the OS choose. Null before the server is listening.
+   */
+  getPort() {
+    const addr = this.server?.address();
+    return addr && typeof addr === "object" ? addr.port : null;
+  }
   async listen() {
     const maxAttempts = 5;
     const retryDelayMs = 300;
@@ -4286,6 +4383,10 @@ var VoleNetManager = class {
   relayNotices = null;
   /** Brain answers whose asker had gone by the time they were ready — see result-outbox.ts. */
   resultOutbox = null;
+  /** Hub side: who is in which room (§7c). Only a relay hub keeps these. */
+  roomStore = null;
+  /** Member side: rooms this node is in, as the hub last described them. */
+  rooms = /* @__PURE__ */ new Map();
   /** Peers a flush is already running for, so a burst of pings does not send an answer twice. */
   flushingResults = /* @__PURE__ */ new Set();
   /** The polling timers waiting on delegated tasks, so stopping cancels them. */
@@ -4336,18 +4437,22 @@ var VoleNetManager = class {
     }
     const hoursToMs = (h, fallback) => typeof h === "number" && h > 0 ? h * 60 * 60 * 1e3 : fallback;
     this.chatOutbox = new ChatOutbox(
-      path7.join(netDir, "chat_outbox.json"),
+      path8.join(netDir, "chat_outbox.json"),
       hoursToMs(this.config.relay?.outboxTtlHours, DEFAULT_OUTBOX_TTL_MS)
     );
     await this.chatOutbox.load().catch(() => void 0);
     this.resultOutbox = new ResultOutbox(
-      path7.join(netDir, "result_outbox.json"),
+      path8.join(netDir, "result_outbox.json"),
       hoursToMs(this.config.relay?.outboxTtlHours, DEFAULT_RESULT_TTL_MS)
     );
     await this.resultOutbox.load().catch(() => void 0);
+    if (this.config.relay?.enabled) {
+      this.roomStore = new RoomStore(path8.join(netDir, "rooms.json"));
+      await this.roomStore.load().catch(() => void 0);
+    }
     if (this.config.relay?.enabled) {
       this.relayNotices = new RelayNotices(
-        path7.join(netDir, "relay_notices.json"),
+        path8.join(netDir, "relay_notices.json"),
         hoursToMs(this.config.relay?.noticeTtlHours, DEFAULT_NOTICE_TTL_MS)
       );
       await this.relayNotices.load().catch(() => void 0);
@@ -4803,6 +4908,49 @@ var VoleNetManager = class {
       if (!payload?.from || !payload.box) return;
       this.deliverSealed(payload.from, payload.box, messageBus, message.from);
     });
+    this.transport.onMessage((message) => {
+      if (!message.type.startsWith("room:") || !this.roomStore || !this.keyPair) return;
+      if (message.type === "room:info" || message.type === "room:members") return;
+      if (message.type === "room:list:response" || message.type === "room:error") return;
+      if (!this.discovery?.verifyMessageFrom(message)) return;
+      void this.handleRoomCommand(message);
+    });
+    this.transport.onMessage((message) => {
+      if (message.type !== "room:info" && message.type !== "room:members") return;
+      if (!this.discovery?.verifyMessageFrom(message)) return;
+      const info = message.payload;
+      if (!info?.room || !Array.isArray(info.members)) return;
+      const mine = this.keyPair?.instanceId;
+      if (mine && !info.members.some((m) => m.instanceId === mine)) {
+        this.rooms.delete(info.room);
+        messageBus?.emit("volenet:room:members", {
+          room: info.room,
+          name: info.name,
+          members: []
+        });
+        return;
+      }
+      this.rooms.set(info.room, info);
+      const roster = this.hubRosters.get(message.from) ?? /* @__PURE__ */ new Map();
+      for (const m of info.members) {
+        if (!m?.instanceId || m.instanceId === mine) continue;
+        if (roster.has(m.instanceId)) continue;
+        roster.set(m.instanceId, {
+          instanceId: m.instanceId,
+          name: m.name,
+          publicKey: m.publicKey,
+          xPublicKey: m.xPublicKey,
+          mlkemPublicKey: m.mlkemPublicKey,
+          connected: false
+        });
+      }
+      this.hubRosters.set(message.from, roster);
+      messageBus?.emit("volenet:room:members", {
+        room: info.room,
+        name: info.name,
+        members: info.members.map((m) => ({ instanceId: m.instanceId, name: m.name }))
+      });
+    });
     this.transport.onMessage((message) => {
       if (message.type !== "roster") return;
       if (!this.discovery?.verifyMessageFrom(message)) return;
@@ -4916,7 +5064,7 @@ var VoleNetManager = class {
       syncConfig
     );
     this.sync.setSessionWriteHandler(async (entry) => {
-      const fs9 = await import("fs/promises");
+      const fs10 = await import("fs/promises");
       const pathMod = await import("path");
       const sessionDir = pathMod.resolve(
         this.projectRoot,
@@ -4925,12 +5073,12 @@ var VoleNetManager = class {
         "paw-session",
         entry.sessionId.replace(/[/\\]/g, "_")
       );
-      await fs9.mkdir(sessionDir, { recursive: true });
+      await fs10.mkdir(sessionDir, { recursive: true });
       const transcriptPath = pathMod.join(sessionDir, "transcript.md");
       const timestamp = new Date(entry.timestamp).toTimeString().slice(0, 8);
       const line = `[${timestamp}] ${entry.role}: ${entry.content.replace(/\n/g, " ").substring(0, 2e3)}
 `;
-      await fs9.appendFile(transcriptPath, line, "utf-8");
+      await fs10.appendFile(transcriptPath, line, "utf-8");
       logger9.info(
         `Session sync received: ${entry.sessionId} \u2014 ${entry.role} from ${entry.instanceId.substring(0, 8)}`
       );
@@ -5290,16 +5438,16 @@ var VoleNetManager = class {
    * outbox and leaves when the member reappears in a roster. A hub too old to give a verdict
    * is treated the way it always was — the write to the hub counts as the delivery.
    */
-  async sendChatViaRelay(peerRef, text) {
+  async sendChatViaRelay(peerRef, text, opts) {
     const fromName = this.getInstanceName();
     const sentAt = Date.now();
-    const ref = randomUUID5();
+    const ref = randomUUID6();
     const member = this.resolveRelayPeer(peerRef);
     const verdict = this.awaitRelayVerdict(ref, member?.instanceId ?? peerRef);
     const r = await this.sealToMemberViaRelay(
       peerRef,
       "chat:message",
-      { text, fromName, sentAt },
+      { text, fromName, sentAt, ...opts?.room ? { room: opts.room } : {} },
       ref
     );
     if (!r.ok || !r.member || !r.inner) {
@@ -5391,7 +5539,7 @@ var VoleNetManager = class {
         if (stillAway.has(entry.to)) continue;
         const member = this.resolveRelayPeer(entry.to);
         if (!member?.connected) continue;
-        const ref = randomUUID5();
+        const ref = randomUUID6();
         const verdict = this.awaitRelayVerdict(ref, entry.to);
         const kind = entry.kind ?? "chat";
         const fromName = this.getInstanceName();
@@ -5496,7 +5644,7 @@ var VoleNetManager = class {
    */
   async sendConsentViaRelay(peerRef, kind, payload, note) {
     const member = this.resolveRelayPeer(peerRef);
-    const ref = randomUUID5();
+    const ref = randomUUID6();
     const verdict = this.awaitRelayVerdict(ref, member?.instanceId ?? peerRef);
     const r = await this.sealToMemberViaRelay(peerRef, `relay:${kind}`, payload, ref);
     if (!r.ok || !r.member) {
@@ -5662,7 +5810,11 @@ var VoleNetManager = class {
       text: payload.text,
       messageId: inner.id,
       timestamp: sentAt,
-      relayed: true
+      relayed: true,
+      // Present when this was a room post, so a client files it under the room rather than
+      // as a private conversation. A client that ignores it sees a direct message from
+      // someone it has already consented to — degraded, never silently dropped.
+      ...payload.room ? { room: payload.room } : {}
     });
   }
   /** True when a relay sender may reach me: '*' policy, an acceptFrom match, or a prior approval. */
@@ -5711,6 +5863,152 @@ var VoleNetManager = class {
     return void 0;
   }
   /** Hub: push the current member directory to every connected member. */
+  // ── Rooms: a member's side ───────────────────────────────────────────────────────────
+  /** Rooms this node is in, as its hub last described them. */
+  getRooms() {
+    return [...this.rooms.values()];
+  }
+  /** Ask a hub to make a room, join one, leave one, invite to one, or list what it has. */
+  async roomCommand(hubRef, type, payload) {
+    if (!this.keyPair || !this.transport) return { ok: false, error: "VoleNet not started" };
+    const hub = this.getInstances().find(
+      (i) => i.id === hubRef || i.name === hubRef || i.id.startsWith(hubRef)
+    );
+    if (!hub) return { ok: false, error: `no hub found: "${hubRef}"` };
+    const sent = await this.transport.sendToPeer(
+      hub.id,
+      createMessage(
+        type,
+        this.keyPair.instanceId,
+        hub.id,
+        payload,
+        this.keyPair.privateKey,
+        this.keyPair.pqPrivateKey
+      )
+    );
+    return sent ? { ok: true } : { ok: false, error: "could not reach that hub" };
+  }
+  /**
+   * Post to a room: one sealed copy per member.
+   *
+   * There is no room key, so this is the fan-out itself — the same `chat:message` sealed to each
+   * member in turn (§7c). Everything §7 gives a private message therefore applies to each copy:
+   * a member who is away has theirs held in this node's outbox and delivered when they return,
+   * and consent still gates whether they accept anything from us at all.
+   */
+  async postToRoom(roomId, text) {
+    const room = this.rooms.get(roomId);
+    if (!room) return { ok: false, sent: 0, held: 0, skipped: 0, error: "not in that room" };
+    if (room.members.length > MAX_ROOM_MEMBERS) {
+      return { ok: false, sent: 0, held: 0, skipped: 0, error: "room is over the member limit" };
+    }
+    let sent = 0;
+    let held = 0;
+    let skipped = 0;
+    for (const m of room.members) {
+      if (m.instanceId === this.keyPair?.instanceId) continue;
+      const res = await this.sendChatViaRelay(m.instanceId, text, { room: roomId });
+      if (!res.ok) skipped++;
+      else if (res.queued) held++;
+      else sent++;
+    }
+    return { ok: true, sent, held, skipped };
+  }
+  // ── Rooms: the hub's side ────────────────────────────────────────────────────────────
+  /** Act on a member's room command and answer it. */
+  async handleRoomCommand(message) {
+    const store = this.roomStore;
+    if (!store || !this.keyPair) return;
+    const from = message.from;
+    const p = message.payload ?? {};
+    const fail = (reason, room) => this.sendToMember(from, "room:error", { ...room ? { room } : {}, reason });
+    switch (message.type) {
+      case "room:create": {
+        const room = await store.create(p.name ?? "room", from, p.topic);
+        this.sendToMember(from, "room:info", this.describeRoom(room));
+        return;
+      }
+      case "room:list": {
+        this.sendToMember(from, "room:list:response", {
+          rooms: store.list().map((r) => ({
+            room: r.id,
+            name: r.name,
+            topic: r.topic,
+            members: r.members.length,
+            joined: r.members.includes(from)
+          }))
+        });
+        return;
+      }
+      case "room:join": {
+        if (!p.room) return fail("no-such-room");
+        const res = await store.join(p.room, from);
+        if (typeof res === "string") return fail(res, p.room);
+        this.sendToMember(from, "room:info", this.describeRoom(res));
+        this.pushRoomMembers(res);
+        return;
+      }
+      case "room:leave": {
+        if (!p.room) return fail("no-such-room");
+        const res = await store.leave(p.room, from);
+        if (typeof res === "string") return fail(res, p.room);
+        this.sendToMember(from, "room:info", this.describeRoom(res));
+        this.pushRoomMembers(res);
+        return;
+      }
+      case "room:invite": {
+        if (!p.room || !p.member) return fail("no-such-room", p.room);
+        const room = store.get(p.room);
+        if (!room) return fail("no-such-room", p.room);
+        if (!room.members.includes(from)) return fail("not-a-member", p.room);
+        const res = await store.join(p.room, p.member);
+        if (typeof res === "string") return fail(res, p.room);
+        this.sendToMember(from, "room:info", this.describeRoom(res));
+        this.sendToMember(p.member, "room:info", this.describeRoom(res));
+        this.pushRoomMembers(res);
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  /** A room as its members need to see it: ids *and keys*, since a sender fans out itself. */
+  describeRoom(room) {
+    const known = new Map(this.discovery?.getInstances().map((i) => [i.id, i]) ?? []);
+    const members = [];
+    for (const id of room.members) {
+      const i = known.get(id);
+      if (!i) continue;
+      members.push({
+        instanceId: i.id,
+        name: i.name,
+        publicKey: i.publicKey,
+        xPublicKey: i.xPublicKey,
+        mlkemPublicKey: i.mlkemPublicKey
+      });
+    }
+    return { room: room.id, name: room.name, topic: room.topic, members };
+  }
+  /** Tell everyone in a room who is in it now. */
+  pushRoomMembers(room) {
+    const info = this.describeRoom(room);
+    for (const id of room.members) this.sendToMember(id, "room:members", info);
+  }
+  /** Signed, unsealed, straight to one member. Room control is hub business, not private. */
+  sendToMember(to, type, payload) {
+    if (!this.keyPair || !this.transport) return;
+    void this.transport.sendToPeer(
+      to,
+      createMessage(
+        type,
+        this.keyPair.instanceId,
+        to,
+        payload,
+        this.keyPair.privateKey,
+        this.keyPair.pqPrivateKey
+      )
+    );
+  }
   broadcastRoster() {
     if (!this.keyPair || !this.transport || !this.discovery) return;
     const connected = new Set(
@@ -5896,11 +6194,11 @@ var VoleNetManager = class {
     recent.push(now);
     this.joinTimestamps.set(ip, recent);
     const netDir = this.getNetDir();
-    await fs8.mkdir(netDir, { recursive: true });
+    await fs9.mkdir(netDir, { recursive: true });
     const safeName = (name ?? "guest").slice(0, 64);
     if (pj.requireApproval) {
-      await fs8.appendFile(
-        path7.join(netDir, "pending_joins.jsonl"),
+      await fs9.appendFile(
+        path8.join(netDir, "pending_joins.jsonl"),
         `${JSON.stringify({ publicKey, name: safeName, ip, at: (/* @__PURE__ */ new Date()).toISOString() })}
 `,
         "utf-8"
@@ -5929,18 +6227,18 @@ var VoleNetManager = class {
   }
   // ── Consent-based pairing (vole net pair) ─────────────────────────────────
   pairRequestsPath() {
-    return path7.join(this.getNetDir(), "pair_requests.json");
+    return path8.join(this.getNetDir(), "pair_requests.json");
   }
   async loadPairRequests() {
     try {
-      const raw = JSON.parse(await fs8.readFile(this.pairRequestsPath(), "utf-8"));
+      const raw = JSON.parse(await fs9.readFile(this.pairRequestsPath(), "utf-8"));
       for (const r of raw) if (r?.id && r.publicKey) this.pairRequests.set(r.id, r);
     } catch {
     }
   }
   async persistPairRequests() {
     try {
-      await fs8.writeFile(
+      await fs9.writeFile(
         this.pairRequestsPath(),
         JSON.stringify([...this.pairRequests.values()], null, 2)
       );
@@ -5950,7 +6248,7 @@ var VoleNetManager = class {
   }
   /** Handle POST /volenet/pair — queue the introduction; trust NOTHING until acceptPair. */
   async handlePairRequest(body, ip, bus) {
-    const { publicKey, name, note, endpoint } = body ?? {};
+    const { publicKey, name, note, endpoint, wants } = body ?? {};
     if (!publicKey || !parsePublicKey(publicKey)) {
       return { status: 400, json: { error: "invalid public key" } };
     }
@@ -5979,6 +6277,9 @@ var VoleNetManager = class {
       publicKey,
       endpoint: typeof endpoint === "string" ? endpoint.slice(0, 200) : void 0,
       note: typeof note === "string" ? note.slice(0, 200) : void 0,
+      // Only what this node understands: an unknown ask is dropped rather than stored, so a
+      // request cannot smuggle a permission past an operator who never saw it named.
+      wants: Array.isArray(wants) ? wants.filter((w) => w === "brain").slice(0, 4) : void 0,
       ts: now
     });
     await this.persistPairRequests();
@@ -6001,7 +6302,15 @@ var VoleNetManager = class {
     return [...this.pairRequests.values()].map(({ publicKey: _pk, ...rest }) => rest);
   }
   /** Operator consent: trust the requester's pinned key, live-reload, dial back if possible. */
-  async acceptPair(ref) {
+  /**
+   * Accept a pair request, and optionally grant what it asked for in the same act.
+   *
+   * Trusting a key and saying what that key may do were two steps in two places — the second a
+   * hand-edited config file and a restart — which is why a paired peer so often sat there unable
+   * to do the thing it was paired for. A grant writes a `net.peers` entry naming the peer's
+   * identity, live, so it applies without a restart, and asks the host to remember it.
+   */
+  async acceptPair(ref, grant) {
     const req = [...this.pairRequests.values()].find(
       (r) => r.id === ref || r.name === ref || r.id.startsWith(ref)
     );
@@ -6013,10 +6322,27 @@ var VoleNetManager = class {
     if (req.endpoint) {
       await this.addPeerEntry(req.endpoint);
     }
+    if (grant && (grant.trust || grant.allowBrain)) {
+      const entry = {
+        id: req.id,
+        name: req.name,
+        trust: grant.trust ?? "read",
+        ...grant.allowBrain ? { allowBrain: true } : {}
+      };
+      this.config.peers = this.config.peers ?? [];
+      const at = this.config.peers.findIndex((p) => p.id === req.id);
+      if (at >= 0) this.config.peers[at] = { ...this.config.peers[at], ...entry };
+      else this.config.peers.push(entry);
+      try {
+        await this.config.persistPeerEntry?.(entry);
+      } catch (err) {
+        logger9.warn(`Could not persist peer entry: ${err instanceof Error ? err.message : err}`);
+      }
+    }
     logger9.info(
       `Pair accepted: "${req.name}" (${req.id.substring(0, 8)}) is now trusted${req.endpoint ? ` and saved as a peer (${req.endpoint})` : " (no endpoint advertised \u2014 it must connect to us)"}`
     );
-    return { ok: true, name: req.name };
+    return { ok: true, name: req.name, ...grant ? { granted: grant } : {} };
   }
   async denyPair(ref) {
     const req = [...this.pairRequests.values()].find(
@@ -6090,7 +6416,7 @@ var VoleNetManager = class {
    * fingerprint client-side), persist + dial the peer, and file the pair request for
    * the other operator. Fully live — no restart needed on this side.
    */
-  async initiatePair(url, publicKey, note) {
+  async initiatePair(url, publicKey, note, wants) {
     if (!this.keyPair) return { ok: false, error: "VoleNet not started" };
     const base = url.replace(/\/$/, "");
     if (!parsePublicKey(publicKey)) return { ok: false, error: "invalid public key" };
@@ -6105,6 +6431,7 @@ var VoleNetManager = class {
           publicKey: this.keyPair.publicKeyString,
           name: this.config.instanceName ?? "vole",
           note,
+          ...wants?.length ? { wants } : {},
           endpoint: this.transport ? buildAdvertisedEndpoint({
             publicUrl: this.config.publicUrl ?? process.env.VOLE_NET_PUBLIC_URL,
             tls: !!this.config.tls,
@@ -6265,7 +6592,7 @@ var VoleNetManager = class {
   }
   getNetDir() {
     const keyPath = this.config.keyPath ?? ".openvole/net/vole_key";
-    return path7.resolve(this.projectRoot, path7.dirname(keyPath));
+    return path8.resolve(this.projectRoot, path8.dirname(keyPath));
   }
   getHostname() {
     const override = this.config.hostname ?? process.env.VOLE_NET_HOSTNAME;
@@ -6326,10 +6653,13 @@ export {
   DEFAULT_NOTICE_TTL_MS,
   DEFAULT_OUTBOX_TTL_MS,
   DEFAULT_RESULT_TTL_MS,
+  EMPTY_ROOM_TTL_MS,
   MAX_RESULTS_PER_PEER,
+  MAX_ROOM_MEMBERS,
   RelayNotices,
   RemoteTaskManager,
   ResultOutbox,
+  RoomStore,
   VoleNetDiscovery,
   VoleNetLeader,
   VoleNetManager,