@muhkoo/connect 0.1.0-alpha.2 → 0.2.0-alpha.1

package/dist/server/index.js

@@ -4749,50 +4749,229 @@ async function toUint8Array(data) {
 }
 
 /**
- * `Room` — a client handle for one shared space (a chat-style room).
- *
- * A shared space carries two things, and `Room` exposes both:
- *   - **realtime E2E messaging** over a {@link BroadcastChannel} (group
- *     handshake, ratchet send/receive, roster frames);
- *   - **room-scoped file storage** via {@link FileStorage} over the room's
- *     shard endpoint.
- *
- * Obtained from `client.message.room(name)`. The websocket isn't opened until
- * `connect()` — and `putFile`/`getFile` don't need it at all (they're plain
- * shard HTTP), so reading a shared file never opens a socket. The upgrade
- * ticket + identity are resolved lazily inside `connect()`.
- *
- * `Room` intentionally mirrors the `BroadcastChannel` surface the chat hook
- * already uses (`on`/`off`/`send`/`sendRaw`/`announce`/`peers`/`isConnected`)
- * so adopting it is a drop-in swap for `new BroadcastChannel(...)`.
+ * SpaceCipher — pure crypto for the fan-out group-encryption layer.
+ *
+ * Everything here routes through the canonical primitives in
+ * `src/crypto/primitives` (AES-256-GCM, HKDF-SHA256, randomBytes) and the
+ * P-384 ECDH `deriveBits` call the Double Ratchet already uses. No new
+ * algorithms, no `crypto.subtle` reach-arounds beyond key gen / derive /
+ * import-export (which the primitive layer intentionally doesn't cover).
+ *
+ * Three concerns:
+ *   1. Space identity — a P-384 ECDH keypair; the encoded public key is the
+ *      space's id.
+ *   2. Group key distribution — ECIES wrap/unwrap of `K_space` to a member's
+ *      identity ECDH public key (ephemeral-static ECDH → HKDF → AES-GCM).
+ *   3. Message sealing — encrypt the serialized `Message` once under the
+ *      epoch's group key.
+ *
+ * Public keys are transported as base64url-encoded JWK, matching the JWK
+ * transport convention already used in `EncryptedSession`.
+ */
+/** HKDF label binding the wrap key to this protocol + version. */
+const WRAP_INFO = "muhkoo/space/keywrap/v1";
+/** Algorithm tag stamped into every WrappedKey. */
+const WRAP_ALG = "ECDH-P384/HKDF-SHA256/AES-256-GCM";
+/** Bits in a P-384 ECDH shared secret. */
+const P384_BITS = 384;
+const ECDH_PARAMS = { name: "ECDH", namedCurve: "P-384" };
+// ---------------------------------------------------------------------------
+// Public-key transport (base64url JWK)
+// ---------------------------------------------------------------------------
+/** Encode an ECDH public `CryptoKey` as a base64url JWK string. */
+async function exportEcdhPublicKey(key) {
+    const jwk = await getSubtle().exportKey("jwk", key);
+    return toBase64Url(utf8Encode(JSON.stringify(jwk)));
+}
+/** Decode a base64url JWK string back into an ECDH public `CryptoKey`. */
+async function importEcdhPublicKey(encoded) {
+    const jwk = JSON.parse(utf8Decode(fromBase64Url(encoded)));
+    // Public keys carry no usages.
+    return getSubtle().importKey("jwk", jwk, ECDH_PARAMS, true, []);
+}
+/** The space's id is just its encoded ECDH public key. */
+const encodeSpaceId = exportEcdhPublicKey;
+/** Generate a fresh space identity keypair (P-384 ECDH). */
+async function generateSpaceIdentity() {
+    const kp = await getSubtle().generateKey(ECDH_PARAMS, true, ["deriveBits"]);
+    const id = await encodeSpaceId(kp.publicKey);
+    return { id, publicKey: kp.publicKey, privateKey: kp.privateKey };
+}
+// ---------------------------------------------------------------------------
+// Group key
+// ---------------------------------------------------------------------------
+/** Mint a fresh 256-bit group key for an epoch. */
+function generateSpaceKey() {
+    return randomBytes(AES_GCM_KEY_BYTES);
+}
+// ---------------------------------------------------------------------------
+// ECIES wrap / unwrap of the group key
+// ---------------------------------------------------------------------------
+/**
+ * Wrap `kSpace` for `recipientEcdhPub` using an ephemeral ECDH keypair.
+ * The HKDF salt binds the wrap key to `epoch`, so a wrap minted for one epoch
+ * cannot be replayed to unwrap a different epoch's blob.
+ */
+async function wrapSpaceKey(kSpace, epoch, recipientEcdhPub) {
+    const eph = await getSubtle().generateKey(ECDH_PARAMS, true, ["deriveBits"]);
+    const shared = new Uint8Array(await getSubtle().deriveBits({ name: "ECDH", public: recipientEcdhPub }, eph.privateKey, P384_BITS));
+    const wrapKey = await deriveBitsHkdf(shared, WRAP_INFO, AES_GCM_KEY_BYTES, utf8Encode(`epoch:${epoch}`));
+    const iv = randomBytes(AES_GCM_IV_BYTES);
+    const ciphertext = await encryptAesGcm(wrapKey, iv, kSpace);
+    return {
+        epoch,
+        ephemeralPub: await exportEcdhPublicKey(eph.publicKey),
+        iv: toBase64(iv),
+        ciphertext: toBase64(ciphertext),
+        alg: WRAP_ALG,
+    };
+}
+/**
+ * Unwrap a {@link WrappedKey} using the recipient's identity ECDH private key.
+ * Throws (GCM tag failure) on the wrong private key or a tampered blob.
+ */
+async function unwrapSpaceKey(wrapped, ownEcdhPriv) {
+    const ephPub = await importEcdhPublicKey(wrapped.ephemeralPub);
+    const shared = new Uint8Array(await getSubtle().deriveBits({ name: "ECDH", public: ephPub }, ownEcdhPriv, P384_BITS));
+    const wrapKey = await deriveBitsHkdf(shared, WRAP_INFO, AES_GCM_KEY_BYTES, utf8Encode(`epoch:${wrapped.epoch}`));
+    return decryptAesGcm(wrapKey, fromBase64(wrapped.iv), fromBase64(wrapped.ciphertext));
+}
+// ---------------------------------------------------------------------------
+// Message sealing
+// ---------------------------------------------------------------------------
+/** Seal an already-serialized message string under the group key. */
+async function sealSerialized(kSpace, serialized) {
+    const iv = randomBytes(AES_GCM_IV_BYTES);
+    const ciphertext = await encryptAesGcm(kSpace, iv, utf8Encode(serialized));
+    return { iv: toBase64(iv), ciphertext: toBase64(ciphertext) };
+}
+/**
+ * Open a sealed payload back into its serialized message string. Throws (GCM
+ * tag failure) on the wrong group key or a tampered ciphertext.
  */
-class Room {
+async function openSerialized(kSpace, iv, ciphertext) {
+    const plaintext = await decryptAesGcm(kSpace, fromBase64(iv), fromBase64(ciphertext));
+    return utf8Decode(plaintext);
+}
+
+/**
+ * SpacePacketCipher — the {@link PacketCipher} that seals packets with a
+ * space's group key instead of a per-peer Double Ratchet.
+ *
+ * It pulls the active epoch's key from an {@link EpochKeyProvider} (the
+ * SpaceKeyring), so this adapter stays decoupled from the keyring's transport
+ * and caching concerns — it only needs "what key seals epoch N".
+ */
+class SpacePacketCipher {
+    keys;
+    contentType;
+    constructor(keys, contentType) {
+        this.keys = keys;
+        this.contentType = contentType;
+    }
+    async seal(serializedMessage) {
+        const epoch = this.keys.currentEpoch();
+        const key = this.keys.keyForEpoch(epoch);
+        if (!key) {
+            throw new Error(`SpacePacketCipher: no group key for epoch ${epoch}`);
+        }
+        const { iv, ciphertext } = await sealSerialized(key, serializedMessage);
+        const headers = { spaceSealed: true, epoch, iv, ciphertext };
+        if (this.contentType)
+            headers.contentType = this.contentType;
+        return headers;
+    }
+    handles(headers) {
+        return headers?.spaceSealed === true &&
+            typeof headers?.iv === "string" &&
+            typeof headers?.ciphertext === "string";
+    }
+    /** Returns null for epochs we don't hold (surfaced as undecryptable). */
+    async open(headers) {
+        if (!this.handles(headers))
+            return null;
+        const epoch = Number(headers.epoch);
+        const key = this.keys.keyForEpoch(epoch);
+        if (!key)
+            return null;
+        return openSerialized(key, headers.iv, headers.ciphertext);
+    }
+}
+
+/**
+ * `Space` — a client handle for one shared space.
+ *
+ * A space is the unit everything is built on. It carries:
+ *   - **realtime transport** over a {@link BroadcastChannel} (group handshake,
+ *     roster frames, raw-frame passthrough);
+ *   - **fan-out group messaging** — `Message`s sealed once with the space's
+ *     group key (via {@link SpacePacketCipher}), wrapped in a cleartext
+ *     {@link Packet} envelope, broadcast AND persisted by the server as
+ *     history (the `spaceMessage` frame);
+ *   - **room-scoped file storage** via {@link FileStorage} over the shard
+ *     endpoint;
+ *   - **legacy per-peer Double Ratchet messaging** (`send`/`announce`) for the
+ *     ephemeral, no-history path — unchanged so existing callers (the chat hook
+ *     reached via `client.message.room(name)`) keep working.
+ *
+ * `Space` was formerly `Room`; `Room` remains exported as an alias. The
+ * fan-out methods (`sendMessage`/`onMessage`/`history`/`join`/`admit`/`rotate`)
+ * require a {@link SpaceKeyring} dep; without one only the transport + DR +
+ * file surface is available.
+ */
+class Space {
     deps;
     name;
+    historyPolicy;
     channel = null;
     pending = [];
+    cipher;
+    /** Per-instance event bus for fan-out events (isolated across spaces). */
+    events = new EventTarget();
+    rawWired = false;
     constructor(deps) {
         this.deps = deps;
         this.name = deps.name;
+        this.historyPolicy = deps.historyPolicy ?? "static";
+        this.cipher = deps.keyring ? new SpacePacketCipher(deps.keyring) : null;
+    }
+    /** The encoded space id (same as the transport name for fan-out spaces). */
+    get id() {
+        return this.name;
     }
-    // -- messaging -------------------------------------------------------------
-    /** Open the room websocket (resolves the ticket + identity lazily). */
+    /** The keyring backing this space's group keys, if any. */
+    get keyring() {
+        return this.deps.keyring;
+    }
+    // -- transport -------------------------------------------------------------
+    /** Open the space websocket (resolves the ticket + identity lazily). */
     async connect() {
         if (!this.channel) {
             const ticket = await this.deps.fetchTicket();
             const url = `${this.deps.wsBaseUrl}/api/spaces/${encodeURIComponent(this.name)}/websocket` +
                 (ticket ? `?ticket=${encodeURIComponent(ticket)}` : "");
-            this.channel = new BroadcastChannel({ url, myId: this.deps.myId(), autoAnnounce: false });
+            this.channel = this.deps.createChannel
+                ? this.deps.createChannel(url, this.deps.myId())
+                : new BroadcastChannel({ url, myId: this.deps.myId(), autoAnnounce: false });
             for (const [event, handler] of this.pending)
                 this.channel.on(event, handler);
             this.pending.length = 0;
+            // Fan-out spaces drive their own `{name}` handshake + frame routing.
+            // Legacy (keyring-less) callers wire these themselves, so leave that
+            // path byte-for-byte unchanged.
+            if (this.deps.keyring) {
+                this.channel.on(BroadcastChannelEvents.CONNECTED, () => {
+                    this.channel?.sendRaw({ name: this.deps.myId() });
+                });
+                this.wireFanout();
+            }
         }
         await this.channel.connect();
     }
     disconnect() {
         this.channel?.disconnect();
     }
-    /** Subscribe to a channel event. Buffered until `connect()` if early. */
+    /** Subscribe to a raw channel event. Buffered until `connect()` if early. */
     on(event, handler) {
         if (this.channel)
             this.channel.on(event, handler);
@@ -4808,11 +4987,12 @@ class Room {
                 this.pending.splice(i, 1);
         }
     }
+    // -- legacy Double Ratchet path (unchanged) --------------------------------
     /** Advertise our keyExchange to the room (idempotent per connection). */
     announce() {
         return this.channel ? this.channel.announce() : Promise.resolve();
     }
-    /** E2E-encrypt `text` to every peer; returns the recipient count. */
+    /** E2E-encrypt `text` to every peer via the Double Ratchet (no history). */
     send(text) {
         return this.channel ? this.channel.send(text) : Promise.resolve(0);
     }
@@ -4821,21 +5001,113 @@ class Room {
         this.channel?.sendRaw(frame);
     }
     peers() {
-        return this.channel ? this.channel.peers() : [];
+        return this.channel?.peers ? this.channel.peers() : [];
     }
     isConnected() {
-        return this.channel ? this.channel.isConnected() : false;
+        return this.channel?.isConnected ? this.channel.isConnected() : false;
     }
     /** The underlying channel, for advanced use. `null` before `connect()`. */
     get raw() {
         return this.channel;
     }
+    // -- fan-out group messaging -----------------------------------------------
+    /**
+     * Seal `payload` once with the current group key and broadcast it as a
+     * persisted `spaceMessage`. Requires a keyring.
+     */
+    async sendMessage(payload, opts = {}) {
+        const cipher = this.requireCipher(opts.contentType);
+        const message = new Message(payload);
+        const headers = await cipher.seal(message.serialize());
+        const packet = new Packet({
+            subject: opts.channel ?? "default",
+            source: this.deps.myId(),
+            target: this.name,
+            headers,
+        });
+        this.sendRaw({ spaceMessage: packet.serialize() });
+    }
+    /** Subscribe to decrypted fan-out messages. Returns an unsubscribe fn. */
+    onMessage(handler) {
+        const listener = (e) => handler(e.detail);
+        this.events.addEventListener("message", listener);
+        return () => this.events.removeEventListener("message", listener);
+    }
+    /** Subscribe to inbound join requests (for a key-holder to admit). */
+    onJoinRequest(handler) {
+        const listener = (e) => handler(e.detail);
+        this.events.addEventListener("join-request", listener);
+        return () => this.events.removeEventListener("join-request", listener);
+    }
+    /**
+     * Fetch + decrypt persisted history beyond the live backlog.
+     * `before` is an opaque cursor returned as `nextCursor`.
+     */
+    async history(opts = {}) {
+        const cipher = this.requireCipher();
+        const params = new URLSearchParams();
+        if (opts.before)
+            params.set("before", opts.before);
+        if (opts.limit)
+            params.set("limit", String(opts.limit));
+        const url = `${this.deps.httpBaseUrl}/api/spaces/${encodeURIComponent(this.name)}/history` +
+            (params.toString() ? `?${params}` : "");
+        const res = await this.deps.fetch(url);
+        if (!res.ok)
+            throw new Error(`Space.history: ${res.status} ${res.statusText}`);
+        const body = (await res.json());
+        const messages = [];
+        for (const raw of body.messages ?? []) {
+            const decoded = await this.decodeFrame(raw, cipher);
+            if (decoded)
+                messages.push(decoded);
+        }
+        return { messages, nextCursor: body.nextCursor ?? null };
+    }
+    /**
+     * Bring this member's group keys up to date: load from cache, and if we
+     * hold nothing, request a key and poll until one arrives (or timeout).
+     */
+    async join(opts = {}) {
+        const keyring = this.requireKeyring();
+        await this.connect();
+        if (await keyring.loadFromCache())
+            return true;
+        if (keyring.hasAnyKey())
+            return true;
+        await keyring.requestKey();
+        const deadline = Date.now() + (opts.timeoutMs ?? 15000);
+        const pollMs = opts.pollMs ?? 500;
+        // eslint-disable-next-line no-constant-condition
+        while (Date.now() < deadline) {
+            if ((await keyring.pullKeys()) > 0)
+                return true;
+            await delay(pollMs);
+        }
+        return false;
+    }
+    /** Creator path: mint the initial group key, then connect. */
+    async create() {
+        const keyring = this.requireKeyring();
+        await keyring.bootstrapNew();
+        await this.connect();
+        // Admit anyone who requested a key before we were listening.
+        if (this.deps.autoAdmit !== false) {
+            await keyring.admitPending().catch(() => { });
+        }
+    }
+    /** Wrap the group key for a newcomer and post it (key-holder action). */
+    async admit(memberId, identityEcdhPub) {
+        await this.requireKeyring().admit(memberId, identityEcdhPub);
+    }
+    /** Rotate to a fresh epoch and re-wrap to the roster (rotate spaces). */
+    async rotate(roster) {
+        return this.requireKeyring().rotate(roster);
+    }
     // -- room-scoped files (no websocket needed) -------------------------------
-    /** Encrypt + erasure-code + upload `file` to this room's shards. */
     async putFile(file, metadata) {
         return this.fileStorage().writeFileToShards({ data: file, metadata });
     }
-    /** Fetch + decode a file previously shared in this room. */
     async getFile(manifest) {
         return this.fileStorage().readFileFromShards(manifest);
     }
@@ -4847,6 +5119,92 @@ class Room {
         });
         return new FileStorage({ shards });
     }
+    // -- internals -------------------------------------------------------------
+    /** Wire the RAW_FRAME handler that drives fan-out events. */
+    wireFanout() {
+        if (this.rawWired || !this.channel)
+            return;
+        this.rawWired = true;
+        this.channel.on(BroadcastChannelEvents.RAW_FRAME, (e) => {
+            void this.onRawFrame(e.detail);
+        });
+    }
+    async onRawFrame(frame) {
+        const f = frame;
+        if (!f || typeof f !== "object")
+            return;
+        if (typeof f.spaceMessage === "string" && this.cipher) {
+            const decoded = await this.decodeFrame(f.spaceMessage, this.cipher, /*raw*/ true);
+            if (decoded)
+                this.emitEvent("message", decoded);
+            return;
+        }
+        if (f.joinRequest && typeof f.joinRequest === "object") {
+            const req = f.joinRequest;
+            this.emitEvent("join-request", req);
+            // Auto-admit: if we hold the group key, wrap it for the newcomer.
+            if (this.deps.autoAdmit !== false && this.deps.keyring?.hasAnyKey() && req.memberId !== this.deps.myId()) {
+                void this.deps.keyring.admit(req.memberId, req.identityEcdhPub).catch(() => { });
+            }
+            return;
+        }
+        if (f.keyringReady && this.deps.keyring) {
+            // A key was wrapped for us — pull it.
+            void this.deps.keyring.pullKeys().catch(() => { });
+        }
+    }
+    /**
+     * Decode one persisted/broadcast frame into a SpaceMessageEvent.
+     * `isRawFrame` true means `input` is the already-extracted `spaceMessage`
+     * packet string; false means it's the full `{spaceMessage, name, ...}` frame.
+     */
+    async decodeFrame(input, cipher, isRawFrame = false) {
+        try {
+            let packetJson = input;
+            if (!isRawFrame) {
+                const outer = JSON.parse(input);
+                if (typeof outer.spaceMessage !== "string")
+                    return null;
+                packetJson = outer.spaceMessage;
+            }
+            const packet = Packet.deserialize(packetJson);
+            if (!cipher.handles(packet.headers))
+                return null;
+            const serialized = await cipher.open(packet.headers);
+            if (serialized === null)
+                return null; // epoch key we don't hold
+            const message = Message.deserialize(serialized);
+            return {
+                from: packet.source,
+                channel: packet.subject,
+                epoch: Number(packet.headers?.epoch ?? 0),
+                contentType: packet.headers?.contentType,
+                message,
+            };
+        }
+        catch (err) {
+            this.emitEvent("error", err);
+            return null;
+        }
+    }
+    emitEvent(type, detail) {
+        this.events.dispatchEvent(new CustomEvent(type, { detail }));
+    }
+    requireKeyring() {
+        if (!this.deps.keyring) {
+            throw new Error("Space: this operation requires a keyring (open via client.space).");
+        }
+        return this.deps.keyring;
+    }
+    requireCipher(contentType) {
+        if (!this.deps.keyring) {
+            throw new Error("Space: fan-out messaging requires a keyring (open via client.space).");
+        }
+        return contentType ? new SpacePacketCipher(this.deps.keyring, contentType) : this.cipher;
+    }
+}
+function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
 }
 
 /**
@@ -4951,7 +5309,7 @@ class MessageNamespace {
      * higher-level conveniences layered over the same space transport).
      */
     room(roomName) {
-        return new Room({
+        return new Space({
             name: roomName,
             wsBaseUrl: this.deps.wsBaseUrl,
             httpBaseUrl: this.deps.http.baseUrl,
@@ -5027,6 +5385,443 @@ function parseMaybeJson(text) {
     }
 }
 
+/**
+ * SpaceKeyring — the client's view of a space's group keys.
+ *
+ * Holds the per-epoch group keys this member possesses (in memory, optionally
+ * mirrored to PersonalSpace), and orchestrates the server-blind distribution
+ * dance against a {@link KeyringTransport}:
+ *
+ *   - a newcomer posts a join request and pulls the wrapped key blob addressed
+ *     to it, unwrapping with its identity private key;
+ *   - an existing key-holder wraps the group key for a newcomer (ECIES to the
+ *     newcomer's identity public key) and posts the opaque blob;
+ *   - on membership change (rotate spaces) a fresh epoch key is minted and
+ *     re-wrapped to the current roster.
+ *
+ * The server only ever stores opaque {@link WrappedKey} blobs — it cannot read
+ * the group key. Implements {@link EpochKeyProvider} so it can back a
+ * {@link SpacePacketCipher} directly.
+ */
+/**
+ * Reserved member id for the app's "keeper" — a trusted always-available member
+ * (the accelerator's AppDOv1) that holds the group key and re-issues it to
+ * newcomers, so a channel is joinable with no human online. Admitting this id
+ * at channel creation hands the key to the keeper. MUST match the accelerator's
+ * `KEEPER_MEMBER_ID`.
+ */
+const KEEPER_MEMBER_ID = "__keeper__";
+class SpaceKeyring {
+    deps;
+    keys = new Map();
+    epoch = 0;
+    policy;
+    constructor(deps) {
+        this.deps = deps;
+        this.policy = deps.historyPolicy ?? "static";
+    }
+    // -- EpochKeyProvider ------------------------------------------------------
+    currentEpoch() {
+        return this.epoch;
+    }
+    keyForEpoch(epoch) {
+        return this.keys.get(epoch);
+    }
+    hasAnyKey() {
+        return this.keys.size > 0;
+    }
+    // -- lifecycle -------------------------------------------------------------
+    /** Hydrate keys from the PersonalSpace cache, if available. Best-effort —
+     * a cache miss/failure (e.g. not unlocked) must not block joining. */
+    async loadFromCache() {
+        if (!this.deps.cache)
+            return false;
+        let cached;
+        try {
+            cached = await this.deps.cache.loadKeys(this.deps.spaceId);
+        }
+        catch {
+            return false;
+        }
+        if (!cached)
+            return false;
+        for (const [epochStr, b64] of Object.entries(cached)) {
+            this.keys.set(Number(epochStr), fromBase64(b64));
+        }
+        this.epoch = Math.max(0, ...Array.from(this.keys.keys()));
+        return this.keys.size > 0;
+    }
+    async persist() {
+        if (!this.deps.cache)
+            return;
+        const out = {};
+        for (const [epoch, key] of this.keys)
+            out[String(epoch)] = toBase64(key);
+        // Best-effort: caching is an optimization; a write failure (e.g. locked
+        // storage) must not break key acquisition.
+        try {
+            await this.deps.cache.saveKeys(this.deps.spaceId, out);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    /** Creator path: mint epoch-0 group key for a brand-new space. */
+    async bootstrapNew() {
+        this.keys.set(0, generateSpaceKey());
+        this.epoch = 0;
+        await this.persist();
+    }
+    // -- newcomer: request + pull ---------------------------------------------
+    /** Post a join request so an online key-holder can wrap a key for us. */
+    async requestKey(desiredEpoch) {
+        await this.deps.transport.postJoinRequest({
+            memberId: this.deps.memberId,
+            identityEcdhPub: this.deps.identityEcdhPub,
+            desiredEpoch,
+        });
+    }
+    /**
+     * Pull and unwrap any blobs addressed to us. Returns the number of new
+     * epoch keys obtained. Safe to call repeatedly (idempotent).
+     */
+    async pullKeys() {
+        const priv = this.deps.ownPrivateKey();
+        if (!priv)
+            throw new Error("SpaceKeyring: no identity private key to unwrap with");
+        const blobs = await this.deps.transport.fetchBlobs(this.deps.memberId);
+        let added = 0;
+        for (const blob of blobs) {
+            if (this.keys.has(blob.epoch))
+                continue;
+            try {
+                const key = await unwrapSpaceKey(blob, priv);
+                this.keys.set(blob.epoch, key);
+                added++;
+            }
+            catch {
+                // Not for us / tampered — skip this blob.
+            }
+        }
+        if (added > 0) {
+            this.epoch = Math.max(this.epoch, ...Array.from(this.keys.keys()));
+            await this.persist();
+        }
+        return added;
+    }
+    // -- key-holder: admit + rotate -------------------------------------------
+    /**
+     * Wrap our group key(s) for a newcomer and post the blobs. In a `static`
+     * space the newcomer receives every epoch we hold (full history); in a
+     * `rotate` space they receive only the current epoch.
+     */
+    async admit(targetMemberId, identityEcdhPub) {
+        const recipient = await importEcdhPublicKey(identityEcdhPub);
+        const epochs = this.policy === "static"
+            ? Array.from(this.keys.keys())
+            : [this.epoch];
+        for (const epoch of epochs) {
+            const key = this.keys.get(epoch);
+            if (!key)
+                continue;
+            const wrapped = await wrapSpaceKey(key, epoch, recipient);
+            await this.deps.transport.postWrappedKey(targetMemberId, wrapped, this.deps.memberId);
+        }
+    }
+    /**
+     * Admit every outstanding join request (an online key-holder fulfilling
+     * pending newcomers). Returns the ids admitted.
+     */
+    async admitPending() {
+        const pending = await this.deps.transport.fetchPending();
+        const admitted = [];
+        for (const req of pending) {
+            if (req.memberId === this.deps.memberId)
+                continue;
+            await this.admit(req.memberId, req.identityEcdhPub);
+            admitted.push(req.memberId);
+        }
+        return admitted;
+    }
+    /**
+     * Rotate to a fresh epoch (rotate spaces). Mints a new group key, advances
+     * the epoch, and re-wraps it to every member in `roster` (plus ourselves).
+     */
+    async rotate(roster) {
+        const members = roster ?? (await this.deps.transport.fetchRoster());
+        const { epoch: nextEpoch } = await this.deps.transport.rotate(this.epoch + 1);
+        const newKey = generateSpaceKey();
+        this.keys.set(nextEpoch, newKey);
+        this.epoch = nextEpoch;
+        for (const m of members) {
+            if (m.memberId === this.deps.memberId)
+                continue;
+            const recipient = await importEcdhPublicKey(m.identityEcdhPub);
+            const wrapped = await wrapSpaceKey(newKey, nextEpoch, recipient);
+            await this.deps.transport.postWrappedKey(m.memberId, wrapped, this.deps.memberId);
+        }
+        await this.persist();
+        return nextEpoch;
+    }
+}
+
+/**
+ * KeyringClient — HTTP implementation of {@link KeyringTransport} against the
+ * accelerator's per-space keyring endpoints. All blobs are opaque to the
+ * server; this client just moves them.
+ *
+ *   POST /api/spaces/:id/keyring/join-request   { ...JoinRequest }
+ *   GET  /api/spaces/:id/keyring/blobs/:member  -> WrappedKey[]
+ *   POST /api/spaces/:id/keyring/wrap           { targetMemberId, fromMemberId, wrapped }
+ *   GET  /api/spaces/:id/keyring/pending        -> JoinRequest[]
+ *   GET  /api/spaces/:id/keyring/roster         -> { memberId, identityEcdhPub }[]
+ *   POST /api/spaces/:id/keyring/rotate         { nextEpoch } -> { epoch }
+ *   GET  /api/spaces/:id/metadata               -> SpaceMetadata
+ */
+class KeyringClient {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    url(suffix) {
+        return `${this.deps.httpBaseUrl}/api/spaces/${encodeURIComponent(this.deps.spaceId)}${suffix}`;
+    }
+    async post(suffix, body) {
+        const res = await this.deps.fetch(this.url(suffix), {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`KeyringClient POST ${suffix}: ${res.status} ${res.statusText}`);
+        return (await res.json().catch(() => ({})));
+    }
+    async get(suffix) {
+        const res = await this.deps.fetch(this.url(suffix));
+        if (!res.ok)
+            throw new Error(`KeyringClient GET ${suffix}: ${res.status} ${res.statusText}`);
+        return (await res.json());
+    }
+    async postJoinRequest(req) {
+        await this.post("/keyring/join-request", req);
+    }
+    async fetchBlobs(memberId) {
+        const body = await this.get(`/keyring/blobs/${encodeURIComponent(memberId)}`);
+        return body.blobs ?? [];
+    }
+    async postWrappedKey(targetMemberId, wrapped, fromMemberId) {
+        await this.post("/keyring/wrap", { targetMemberId, fromMemberId, wrapped });
+    }
+    async fetchPending() {
+        const body = await this.get("/keyring/pending");
+        return body.pending ?? [];
+    }
+    async fetchRoster() {
+        const body = await this.get("/keyring/roster");
+        return body.roster ?? [];
+    }
+    async rotate(nextEpoch) {
+        return this.post("/keyring/rotate", { nextEpoch });
+    }
+    async fetchMetadata() {
+        try {
+            return await this.get("/metadata");
+        }
+        catch {
+            return null;
+        }
+    }
+}
+
+/**
+ * `client.space` — the fan-out group-encryption surface.
+ *
+ *   const space = await client.space.createSpace({ historyPolicy: "static" });
+ *   await space.sendMessage({ text: "hello" });
+ *   space.onMessage(e => …);
+ *
+ *   const joined = await client.space.joinSpace(space.id); // newcomer
+ *
+ * A space owns a client-generated keypair whose public key is its id, a
+ * symmetric group key distributed server-blind via the keyring, and a
+ * persisted message log. This namespace wires the {@link Space} handle to the
+ * HTTP {@link KeyringClient}, the member's identity keys (from {@link KeyStore},
+ * shared with the Double Ratchet path), and a PersonalSpace-backed key cache.
+ */
+/** Thrown by `joinChannel` when no channel with that name is registered. */
+class ChannelNotFoundError extends Error {
+    channelName;
+    constructor(channelName) {
+        super(`Channel "${channelName}" does not exist. Create it first.`);
+        this.channelName = channelName;
+        this.name = "ChannelNotFoundError";
+    }
+}
+/** Thrown by `createChannel` when the name is already registered. */
+class ChannelExistsError extends Error {
+    channelName;
+    constructor(channelName) {
+        super(`Channel "${channelName}" already exists.`);
+        this.channelName = channelName;
+        this.name = "ChannelExistsError";
+    }
+}
+class SpaceNamespace {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Create a new space: generate its keypair (public key = id), register
+     * metadata, mint the initial group key, and connect. Returns the open Space.
+     */
+    async createSpace(opts = {}) {
+        const historyPolicy = opts.historyPolicy ?? "static";
+        const identity = await generateSpaceIdentity();
+        // Register the space (server records pubkey + policy; the DO is lazy).
+        await this.deps.http.post(`/api/spaces/${encodeURIComponent(identity.id)}/metadata`, { spacePubKey: identity.id, historyPolicy });
+        const space = await this.build(identity.id, historyPolicy);
+        await space.create();
+        return space;
+    }
+    /** Join an existing space by id (its public key). Resolves once a key arrives. */
+    async joinSpace(spaceId, opts = {}) {
+        const policy = await this.fetchPolicy(spaceId);
+        const space = await this.build(spaceId, policy);
+        await space.join({ timeoutMs: opts.timeoutMs });
+        return space;
+    }
+    /** A handle to a space without auto-connecting (uses cached keys on demand). */
+    async get(spaceId, historyPolicy = "static") {
+        return this.build(spaceId, historyPolicy);
+    }
+    // -------------------------------------------------------------------------
+    // Channels — named, app-scoped pointers to spaces. The name → space-id
+    // directory is app-public config (server-readable, scoped to this app via
+    // its key); the channel CONTENTS stay fan-out E2E-encrypted. Lets chat use
+    // human room names (`general`) instead of raw pubkey ids.
+    // -------------------------------------------------------------------------
+    /** List this app's channels (name → space-id) for the key's environment. */
+    async listChannels() {
+        const body = await this.deps.http.get("/api/app/channels");
+        return body.channels ?? [];
+    }
+    /** Resolve a channel name to its space id, or null if it doesn't exist. */
+    async resolveChannel(name) {
+        try {
+            const body = await this.deps.http.get(`/api/app/channels/${encodeURIComponent(name)}`);
+            return body.spaceId ?? null;
+        }
+        catch (err) {
+            if (err instanceof HttpError && err.status === 404)
+                return null;
+            throw err;
+        }
+    }
+    /**
+     * Create a new channel: mint a fan-out space (the caller becomes its first
+     * key-holder) and register `name → spaceId` in the app directory. Throws
+     * {@link ChannelExistsError} if the name is already taken.
+     */
+    async createChannel(name, opts = {}) {
+        const space = await this.createSpace(opts);
+        // Register name → id first so a name clash doesn't leave an admitted keeper.
+        try {
+            await this.deps.http.post("/api/app/channels", { name, spaceId: space.id });
+        }
+        catch (err) {
+            if (err instanceof HttpError && err.status === 409) {
+                throw new ChannelExistsError(name);
+            }
+            throw err;
+        }
+        // Admit the app keeper so the channel is joinable with no member online.
+        // Best-effort: a channel still works (members admit each other) without it.
+        try {
+            const { pubkey } = await this.deps.http.get("/api/app/keeper");
+            if (pubkey && space.keyring)
+                await space.keyring.admit(KEEPER_MEMBER_ID, pubkey);
+        }
+        catch (err) {
+            console.warn("[client.space] keeper admit failed (channel still usable):", err);
+        }
+        return space;
+    }
+    /**
+     * Join an existing channel by name. Throws {@link ChannelNotFoundError} if
+     * no channel with that name is registered (use {@link createChannel} first).
+     */
+    async joinChannel(name, opts = {}) {
+        const spaceId = await this.resolveChannel(name);
+        if (!spaceId)
+            throw new ChannelNotFoundError(name);
+        return this.joinSpace(spaceId, opts);
+    }
+    // -------------------------------------------------------------------------
+    // Internals
+    // -------------------------------------------------------------------------
+    async build(spaceId, historyPolicy) {
+        const memberId = this.myId();
+        const identityEcdhPub = await this.ensureIdentity(memberId);
+        const transport = new KeyringClient({
+            spaceId,
+            httpBaseUrl: this.deps.http.baseUrl,
+            fetch: this.deps.http.fetch,
+        });
+        const keyring = new SpaceKeyring({
+            spaceId,
+            memberId,
+            identityEcdhPub,
+            ownPrivateKey: () => KeyStore.getInstance().getKeyPair(memberId)?.privateKey ?? null,
+            transport,
+            cache: this.deps.cache,
+            historyPolicy,
+        });
+        return new Space({
+            name: spaceId,
+            wsBaseUrl: this.deps.wsBaseUrl,
+            httpBaseUrl: this.deps.http.baseUrl,
+            fetch: this.deps.http.fetch,
+            myId: () => memberId,
+            fetchTicket: () => this.fetchTicket(),
+            keyring,
+            historyPolicy,
+        });
+    }
+    /** Ensure the member has an identity ECDH keypair; return its public key. */
+    async ensureIdentity(memberId) {
+        const store = KeyStore.getInstance();
+        if (!store.getKeyPair(memberId)) {
+            await store.generateOwnKeyPair(memberId);
+        }
+        const pub = store.getKeyPair(memberId).publicKey;
+        return exportEcdhPublicKey(pub);
+    }
+    async fetchPolicy(spaceId) {
+        const meta = await new KeyringClient({
+            spaceId,
+            httpBaseUrl: this.deps.http.baseUrl,
+            fetch: this.deps.http.fetch,
+        }).fetchMetadata();
+        return meta?.historyPolicy ?? "static";
+    }
+    async fetchTicket() {
+        try {
+            const res = await this.deps.http.post("/api/ws-ticket", {});
+            return res?.ticket ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    myId() {
+        const id = this.deps.session.username;
+        if (!id)
+            throw new Error("client.space: not signed in — call client.auth.zk.login() first.");
+        return id;
+    }
+}
+
 /**
  * `Client` — the single entry point to the Muhkoo SDK.
  *
@@ -5067,6 +5862,8 @@ class Client {
     storage;
     /** Realtime messaging — `client.message.subscribe(...)`, etc. */
     message;
+    /** Fan-out group spaces — `client.space.createSpace(...)`, etc. */
+    space;
     session;
     http;
     constructor(options = {}) {
@@ -5087,6 +5884,19 @@ class Client {
         this.auth = new AuthNamespace({ auth: authClient, circuits, session: this.session });
         this.storage = new StorageNamespace({ http: this.http, session: this.session, wsBaseUrl });
         this.message = new MessageNamespace({ http: this.http, session: this.session, wsBaseUrl });
+        // Group keys are cached in the user's PersonalSpace (encrypted at rest
+        // by StorageNamespace), so a returning member hydrates without a fresh
+        // keyring round-trip. The server only ever sees the ciphertext.
+        const spaceKeyCache = {
+            loadKeys: (spaceId) => this.storage.get("space-keys", spaceId),
+            saveKeys: (spaceId, keys) => this.storage.set("space-keys", spaceId, keys),
+        };
+        this.space = new SpaceNamespace({
+            http: this.http,
+            session: this.session,
+            wsBaseUrl,
+            cache: spaceKeyCache,
+        });
     }
     /** The currently signed-in user, or `null`. */
     get user() {
@@ -5816,6 +6626,48 @@ async function parseOrThrow(response, label) {
     return (await response.json());
 }
 
+/**
+ * PacketCipher — the strategy `Network` uses to seal/open a packet's payload.
+ *
+ * `Network` owns the wire shape (Message ↔ Packet, header placement, transport,
+ * reconnect, checksum). The *encryption* is pluggable: the default
+ * {@link DoubleRatchetCipher} reproduces the per-peer Double Ratchet behavior
+ * Network has always had, while the Space layer supplies a group-key cipher.
+ *
+ * The sealed ciphertext always rides in `Packet.headers` (cleartext routing
+ * fields stay readable to the server); `Packet.message` is left undefined on
+ * the wire so the server never sees the real payload.
+ */
+/**
+ * Default cipher: per-peer Double Ratchet. Reproduces Network's original
+ * `{ encrypted: true, cipherMessage: <json> }` header convention exactly so
+ * existing consumers are unaffected.
+ */
+class DoubleRatchetCipher {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async seal(serializedMessage) {
+        const sessionId = this.deps.getSessionId();
+        if (!sessionId) {
+            throw new Error("DoubleRatchetCipher: no active session to seal under");
+        }
+        const cipherMessage = await this.deps.ratchetManager.encrypt(this.deps.clientId, this.deps.serverId, sessionId, serializedMessage, false, // newDhKey — let the ratchet manage key rotation
+        this.deps.sessionType);
+        return { encrypted: true, cipherMessage: JSON.stringify(cipherMessage) };
+    }
+    handles(headers) {
+        return !!(headers?.encrypted && headers?.cipherMessage);
+    }
+    async open(headers) {
+        if (!this.handles(headers))
+            return null;
+        const cipherMessage = JSON.parse(headers.cipherMessage);
+        return this.deps.ratchetManager.decrypt(cipherMessage, this.deps.isClient ?? true);
+    }
+}
+
 function loadRsWasm(imports){return _loadWasmModule(0, null, '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', imports)}
 
 /**
@@ -5837,5 +6689,5 @@ var bundledLoader = /*#__PURE__*/Object.freeze({
     default: loadRsWasm
 });
 
-export { AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, AES_GCM_TAG_BYTES, AuthClient, AuthNamespace, AuthPublicInput, Authenticator, BroadcastChannel, BroadcastChannelEvents, ChunkCipher, Client, DEFAULT_BASE_URL, DoubleRatchet, DoubleRatchetManager, EncryptedSession, EventCore, EventCoreEvents, Field, Field as FieldElement, FileStorage, HashKnowledge, HttpClient, HttpError, KeyStore, LocalStorageSessionStore, Logger, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, PBKDF2_DEFAULT_ITERATIONS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PersonalSpaceClient, Poseidon, PreimagePoK, Ready, ReedSolomonCodec, Retry, Room, SerializeMessage, SessionState, ShardClient, SharedSpaceClient, StorageNamespace, WSTransport, ZkAuth, _accountId, _formatBytes, _messageId, _objectId, _packetId, _socketId, _userId, appLogger$1 as appLogger, assertType, base58Decode, base58Encode, buildCommitment, compilePrograms, concatBytes, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultSessionStore, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, deserialize, encodeToHex, encryptAesGcm, exportPublicKeyBase64, exportPublicKeyHex, fromBase64, fromBase64Url, fromHex, generateAuthProof, generateChecksum, generateId, getIPAddress, getId, getSubtle, initBn128Wasm, initRsWasm, initializeCircuits, isNumber, log, manifestToStat, poseidonHash, quickVerify, randomBytes, serialize, shardHash, signMessage, toBase64, toBase64Url, toField, toHex, unwrapWithPassphrase, utf8Decode, utf8Encode, verify, verifyChecksum, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase };
+export { AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, AES_GCM_TAG_BYTES, AuthClient, AuthNamespace, AuthPublicInput, Authenticator, BroadcastChannel, BroadcastChannelEvents, ChannelExistsError, ChannelNotFoundError, ChunkCipher, Client, DEFAULT_BASE_URL, DoubleRatchet, DoubleRatchetCipher, DoubleRatchetManager, EncryptedSession, EventCore, EventCoreEvents, Field, Field as FieldElement, FileStorage, HashKnowledge, HttpClient, HttpError, KEEPER_MEMBER_ID, KeyStore, KeyringClient, LocalStorageSessionStore, Logger, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, PBKDF2_DEFAULT_ITERATIONS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PersonalSpaceClient, Poseidon, PreimagePoK, Ready, ReedSolomonCodec, Retry, Space as Room, SerializeMessage, SessionState, ShardClient, SharedSpaceClient, Space, SpaceKeyring, SpaceNamespace, SpacePacketCipher, StorageNamespace, WSTransport, ZkAuth, _accountId, _formatBytes, _messageId, _objectId, _packetId, _socketId, _userId, appLogger$1 as appLogger, assertType, base58Decode, base58Encode, buildCommitment, compilePrograms, concatBytes, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultSessionStore, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, deserialize, encodeToHex, encryptAesGcm, exportPublicKeyBase64, exportPublicKeyHex, fromBase64, fromBase64Url, fromHex, generateAuthProof, generateChecksum, generateId, getIPAddress, getId, getSubtle, initBn128Wasm, initRsWasm, initializeCircuits, isNumber, log, manifestToStat, poseidonHash, quickVerify, randomBytes, serialize, shardHash, signMessage, toBase64, toBase64Url, toField, toHex, unwrapWithPassphrase, utf8Decode, utf8Encode, verify, verifyChecksum, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase };
 //# sourceMappingURL=index.js.map