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

package/dist/browser/index.js

@@ -275,6 +275,10 @@ function fromBase64(b64) {
         out[i] = binary.charCodeAt(i);
     return out;
 }
+/** Encode a byte array as a base64url string (no padding). */
+function toBase64Url(bytes) {
+    return toBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
 /** Decode a base64url string (with or without padding) to bytes. */
 function fromBase64Url(b64url) {
     const padded = b64url.replace(/-/g, "+").replace(/_/g, "/") +
@@ -5259,50 +5263,269 @@ class StorageNamespace {
 }
 
 /**
- * `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;
+// ---------------------------------------------------------------------------
+// Sender authentication (ECDSA P-384, matching the Double Ratchet path).
+// A fan-out message is signed by its sender's identity ECDSA key so receivers
+// can verify authorship end-to-end — independent of the relay, which only
+// stamps `source` server-side. SHA-256 hash to match `DoubleRatchet`.
+// ---------------------------------------------------------------------------
+const ECDSA_PARAMS = { name: "ECDSA", namedCurve: "P-384" };
+const ECDSA_SIGN = { name: "ECDSA", hash: "SHA-256" };
+/** Encode an ECDSA public `CryptoKey` as a base64url JWK string. */
+async function exportEcdsaPublicKey(key) {
+    const jwk = await getSubtle().exportKey("jwk", key);
+    return toBase64Url(utf8Encode(JSON.stringify(jwk)));
+}
+/** Decode a base64url JWK string back into an ECDSA verify-only public key. */
+async function importEcdsaPublicKey(encoded) {
+    const jwk = JSON.parse(utf8Decode(fromBase64Url(encoded)));
+    return getSubtle().importKey("jwk", jwk, ECDSA_PARAMS, true, ["verify"]);
+}
+/**
+ * Canonical bytes a sender signs (and a receiver re-derives). Binds the claimed
+ * sender + routing + the sealed ciphertext, so a relay can't relabel `source`
+ * and a member can't reuse another's ciphertext under a new envelope.
+ */
+function canonicalMessage(fields) {
+    return [fields.source, fields.target, fields.subject, fields.epoch, fields.iv, fields.ciphertext].join("\n");
+}
+/** Sign the canonical bytes with the sender's ECDSA identity private key. */
+async function signSpaceMessage(canonical, ecdsaPriv) {
+    const sig = await getSubtle().sign(ECDSA_SIGN, ecdsaPriv, utf8Encode(canonical));
+    return toBase64(new Uint8Array(sig));
+}
+/** Verify a signature over the canonical bytes against the sender's ECDSA key. */
+async function verifySpaceMessage(canonical, sigB64, ecdsaPub) {
+    try {
+        return await getSubtle().verify(ECDSA_SIGN, ecdsaPub, fromBase64(sigB64), utf8Encode(canonical));
+    }
+    catch {
+        return false;
+    }
+}
+/** 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.
+ */
+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 Room {
+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);
@@ -5318,11 +5541,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);
     }
@@ -5331,21 +5555,130 @@ 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 source = this.deps.myId();
+        const subject = opts.channel ?? "default";
+        // Sign the message with our identity ECDSA key so receivers can verify
+        // authorship end-to-end (independent of the relay's `source` stamp).
+        const authPriv = KeyStore.getInstance().getAuthKeyPair(source)?.privateKey;
+        if (authPriv) {
+            const canonical = canonicalMessage({
+                source, target: this.name, subject,
+                epoch: Number(headers.epoch), iv: String(headers.iv), ciphertext: String(headers.ciphertext),
+            });
+            headers.sig = await signSpaceMessage(canonical, authPriv);
+        }
+        const packet = new Packet({ subject, source, 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());
+        // Warm the member directory once so historical senders' signatures verify.
+        // (refreshDirectory swallows its own transport errors.)
+        await this.deps.keyring?.refreshDirectory();
+        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();
+        // Publish our identity in the member directory so peers can verify our
+        // message signatures (the creator never "joins", so register here).
+        await keyring.requestKey().catch(() => { });
+        // 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);
+    }
+    /** Invite a user to this (private) channel's membership allowlist. */
+    async invite(username) {
+        await this.requireKeyring().invite(username);
+    }
+    /** 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);
     }
@@ -5357,6 +5690,129 @@ 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);
+            // A new member appeared — refresh the directory so their future
+            // messages verify, and (if we hold the key) auto-admit them.
+            void this.deps.keyring?.refreshDirectory();
+            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;
+            // Verify sender authenticity end-to-end: the message must be signed
+            // by `source`'s identity ECDSA key (looked up in the member
+            // directory). Drop anything unsigned, signed by an unknown member,
+            // or whose signature doesn't match — this defeats both member
+            // impersonation and a relay rewriting `source`.
+            if (!(await this.verifySender(packet)))
+                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;
+        }
+    }
+    /**
+     * True if `packet` carries a valid signature by `source`'s identity key.
+     * On a directory cache miss, refresh once (a new member may have just
+     * joined) before giving up. Without a keyring (legacy handle) there's
+     * nothing to verify against → reject.
+     */
+    async verifySender(packet) {
+        const keyring = this.deps.keyring;
+        const sig = packet.headers?.sig;
+        if (!keyring || typeof sig !== "string")
+            return false;
+        let key = keyring.ecdsaKeyFor(packet.source);
+        if (!key) {
+            await keyring.refreshDirectory();
+            key = keyring.ecdsaKeyFor(packet.source);
+            if (!key)
+                return false;
+        }
+        const canonical = canonicalMessage({
+            source: packet.source,
+            target: packet.target,
+            subject: packet.subject,
+            epoch: Number(packet.headers?.epoch ?? 0),
+            iv: String(packet.headers?.iv ?? ""),
+            ciphertext: String(packet.headers?.ciphertext ?? ""),
+        });
+        return verifySpaceMessage(canonical, sig, key);
+    }
+    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));
 }
 
 /**
@@ -5461,7 +5917,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,
@@ -5537,6 +5993,486 @@ 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;
+    /** Cached member directory: memberId → imported ECDSA verify key. */
+    memberEcdsa = new Map();
+    constructor(deps) {
+        this.deps = deps;
+        this.policy = deps.historyPolicy ?? "static";
+    }
+    // -- member directory (for verifying sender signatures) -------------------
+    /** The cached ECDSA verify key for a member, if known. */
+    ecdsaKeyFor(memberId) {
+        return this.memberEcdsa.get(memberId);
+    }
+    /** Refresh the member directory (memberId → ECDSA key) from the roster. */
+    async refreshDirectory() {
+        let roster;
+        try {
+            roster = await this.deps.transport.fetchRoster();
+        }
+        catch {
+            return;
+        }
+        for (const m of roster) {
+            if (!m.identityEcdsaPub || this.memberEcdsa.has(m.memberId))
+                continue;
+            try {
+                this.memberEcdsa.set(m.memberId, await importEcdsaPublicKey(m.identityEcdsaPub));
+            }
+            catch {
+                /* skip malformed entries */
+            }
+        }
+    }
+    // -- 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. Also
+     * publishes our identity keys in the member directory (so others can verify
+     * our message signatures, and the keeper can wrap to us).
+     */
+    async requestKey(desiredEpoch) {
+        await this.deps.transport.postJoinRequest({
+            memberId: this.deps.memberId,
+            identityEcdhPub: this.deps.identityEcdhPub,
+            identityEcdsaPub: this.deps.identityEcdsaPub,
+            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;
+    }
+    /** Add `username` to a private channel's membership allowlist (member-only). */
+    async invite(username) {
+        await this.deps.transport.invite(username);
+    }
+}
+
+/**
+ * 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 invite(username) {
+        await this.post("/keyring/invite", { username });
+    }
+    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).
+        // For a private space the server also records the creator (this user) as
+        // its first member — so the metadata POST must carry the user session.
+        await this.deps.http.post(`/api/spaces/${encodeURIComponent(identity.id)}/metadata`, { spacePubKey: identity.id, historyPolicy, visibility: opts.private ? "private" : "public" });
+        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, visibility: opts.private ? "private" : "public" });
+        }
+        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 { ecdhPub, ecdsaPub } = 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: ecdhPub,
+            identityEcdsaPub: ecdsaPub,
+            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 keypair; return its public ECDH + ECDSA keys. */
+    async ensureIdentity(memberId) {
+        const store = KeyStore.getInstance();
+        if (!store.getKeyPair(memberId)) {
+            await store.generateOwnKeyPair(memberId);
+        }
+        const ecdhPub = await exportEcdhPublicKey(store.getKeyPair(memberId).publicKey);
+        const ecdsaPub = await exportEcdsaPublicKey(store.getAuthKeyPair(memberId).publicKey);
+        return { ecdhPub, ecdsaPub };
+    }
+    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.
  *
@@ -5577,6 +6513,8 @@ class Client {
     storage;
     /** Realtime messaging — `client.message.subscribe(...)`, etc. */
     message;
+    /** Fan-out group spaces — `client.space.createSpace(...)`, etc. */
+    space;
     session;
     http;
     constructor(options = {}) {
@@ -5597,6 +6535,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() {
@@ -5608,6 +6559,48 @@ class Client {
     }
 }
 
+/**
+ * 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);
+    }
+}
+
 const appLogger$1 = new Logger("connect", 'ERROR');
 globalThis.appLogger = appLogger$1;
 
@@ -5632,5 +6625,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, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, PBKDF2_DEFAULT_ITERATIONS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PersonalSpaceClient, Poseidon, PreimagePoK, ReedSolomonCodec, Room, SerializeMessage, SessionState, ShardClient, SharedSpaceClient, StorageNamespace, WSTransport, ZkAuth, buildCommitment, compilePrograms, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultSessionStore, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, encodeToHex, encryptAesGcm, exportPublicKeyBase64, exportPublicKeyHex, generateAuthProof, getSubtle, initBn128Wasm, initRsWasm, initializeCircuits, manifestToStat, poseidonHash, quickVerify, randomBytes, shardHash, signMessage, toField, unwrapWithPassphrase, verify, 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, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, PBKDF2_DEFAULT_ITERATIONS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PersonalSpaceClient, Poseidon, PreimagePoK, ReedSolomonCodec, Space as Room, SerializeMessage, SessionState, ShardClient, SharedSpaceClient, Space, SpaceKeyring, SpaceNamespace, SpacePacketCipher, StorageNamespace, WSTransport, ZkAuth, buildCommitment, compilePrograms, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultSessionStore, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, encodeToHex, encryptAesGcm, exportPublicKeyBase64, exportPublicKeyHex, generateAuthProof, getSubtle, initBn128Wasm, initRsWasm, initializeCircuits, manifestToStat, poseidonHash, quickVerify, randomBytes, shardHash, signMessage, toField, unwrapWithPassphrase, verify, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase };
 //# sourceMappingURL=index.js.map