@muhkoo/connect 0.8.0-alpha.0 → 0.10.0-alpha.0

package/dist/browser/index.js

@@ -3796,6 +3796,8 @@ class ReedSolomonCodec {
  *                             skip a PUT they'd otherwise dedup-rewrite. The
  *                             server can ignore the optimization if it wants.
  */
+/** Peer head-start (ms) before origin joins the race in {@link ShardClient.getShard}. */
+const HEDGE_MS = 500;
 /**
  * Compute the lowercase hex SHA-256 of `bytes`. Available via WebCrypto in
  * every runtime this SDK targets.
@@ -3814,6 +3816,7 @@ class ShardClient {
     fetchFn;
     cache;
     deferUpload;
+    peers;
     constructor(opts) {
         if (!opts?.baseUrl)
             throw new Error("ShardClient: `baseUrl` is required");
@@ -3831,6 +3834,7 @@ class ShardClient {
         this.fetchFn = f.bind(globalThis);
         this.cache = opts.cache;
         this.deferUpload = opts.deferUpload;
+        this.peers = opts.peers;
     }
     /** Build the URL for a given shard hash — exposed for callers that want to log or pre-resolve. */
     urlForHash(hash) {
@@ -3849,6 +3853,9 @@ class ShardClient {
         // this is safe to keep regardless of upload outcome.
         if (this.cache)
             await this.cache.put(hash, bytes);
+        // Tell the swarm we now hold this block, so peers can pull it from us.
+        if (this.peers)
+            this.peers.announce(hash);
         let response;
         try {
             response = await this.fetchFn(url, {
@@ -3892,15 +3899,63 @@ class ShardClient {
             if (cached)
                 return cached;
         }
+        // No peers → straight to origin.
+        if (!this.peers)
+            return this.fetchFromOrigin(hash);
+        // HEDGED RACE: prefer a peer (saves origin egress) but never let a slow
+        // or missing peer stall delivery — give the peer a short head start, then
+        // start origin in parallel and take whichever returns the block first.
+        const peers = this.peers;
+        return new Promise((resolve, reject) => {
+            let done = false;
+            let originStarted = false;
+            let timer = null;
+            const win = (b) => {
+                if (done)
+                    return;
+                done = true;
+                if (timer)
+                    clearTimeout(timer);
+                resolve(b);
+            };
+            const fail = (e) => {
+                if (!done) {
+                    done = true;
+                    reject(e);
+                }
+            };
+            const startOrigin = () => {
+                if (originStarted || done)
+                    return;
+                originStarted = true;
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+                this.fetchFromOrigin(hash).then(win, fail);
+            };
+            timer = setTimeout(startOrigin, HEDGE_MS);
+            peers.getBlock(hash).then((b) => {
+                if (b) {
+                    if (this.cache)
+                        void this.cache.put(hash, b);
+                    win(b); // peer delivered first
+                }
+                else {
+                    startOrigin(); // peer miss → don't wait out the hedge
+                }
+            }, () => startOrigin());
+        });
+    }
+    /** Fetch a shard from origin. Returns `null` for 404 (or offline when a
+     *  cache is present, so RS recovery can proceed); throws otherwise. */
+    async fetchFromOrigin(hash) {
         const url = this.urlForHash(hash);
         let response;
         try {
             response = await this.fetchFn(url, { method: "GET" });
         }
         catch (err) {
-            // Offline with no cache hit: report the shard as missing so
-            // FileStorage's Reed–Solomon recovery can still reconstruct from the
-            // shards that ARE cached. Rethrow when there's no cache to fall back on.
             if (this.cache)
                 return null;
             throw err;
@@ -3911,8 +3966,7 @@ class ShardClient {
             const text = await safeText(response);
             throw new Error(`ShardClient.getShard(${hash}) failed (${response.status}): ${text}`);
         }
-        const buf = await response.arrayBuffer();
-        const bytes = new Uint8Array(buf);
+        const bytes = new Uint8Array(await response.arrayBuffer());
         if (this.cache)
             void this.cache.put(hash, bytes);
         return bytes;
@@ -4940,7 +4994,7 @@ function base64UrlDecode(s) {
  * expect (and isn't serving a stale cached bundle). Keep this in sync with
  * `package.json` `version`.
  */
-const VERSION = "0.8.0-alpha.0";
+const VERSION = "0.10.0-alpha.0";
 
 /**
  * `HttpClient` — the one place the unified {@link Client} talks to the
@@ -4963,6 +5017,28 @@ const VERSION = "0.8.0-alpha.0";
  * convenience JSON helpers (`get`/`post`/`del`) for code that talks to the
  * accelerator directly.
  */
+/** Per-request timing logs, enabled on staging only (temporary diagnostic). */
+const HTTP_DEBUG = (() => {
+    try {
+        return typeof location !== "undefined" && /(^|\.)staging\./.test(location.hostname);
+    }
+    catch {
+        return false;
+    }
+})();
+/** Short, readable request path (pathname + search) for the timing log. */
+function reqPath(input) {
+    try {
+        const u = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        if (!/^https?:\/\//i.test(u))
+            return u;
+        const parsed = new URL(u);
+        return parsed.pathname + parsed.search;
+    }
+    catch {
+        return "?";
+    }
+}
 /** Thrown for any non-2xx accelerator response. Carries the HTTP status. */
 class HttpError extends Error {
     status;
@@ -5019,7 +5095,14 @@ class HttpClient {
             if (token)
                 headers.set("X-Muhkoo-Session", token);
         }
-        return this.fetchFn(input, { ...init, headers });
+        const finalInit = { ...init, headers };
+        if (!HTTP_DEBUG)
+            return this.fetchFn(input, finalInit);
+        // Staging diagnostic: time every accelerator request (this `fetch` is the
+        // single chokepoint — JSON helpers + the roster/shard fetches ride it).
+        const t = performance.now();
+        const tag = `${init?.method ?? "GET"} ${reqPath(input)}`;
+        return this.fetchFn(input, finalInit).then((res) => { console.info(`[muhkoo:http] ${tag} → ${res.status} ${Math.round(performance.now() - t)}ms`); return res; }, (err) => { console.info(`[muhkoo:http] ${tag} → ERROR ${Math.round(performance.now() - t)}ms`); throw err; });
     };
     /** True when `input` resolves to {@link baseOrigin} (relative URLs always do). */
     isSameOrigin(input) {
@@ -5833,6 +5916,34 @@ class ZkAuth {
             return null;
         }
     }
+    /**
+     * Boot helper — call this once on app start. Restores the session AND, when a
+     * passkey is enrolled, silently unlocks the identity via WebAuthn (recovering
+     * the master seed so the ratchet keypair rehydrates and `client.kv` works).
+     * The seed is never persisted, so a passkey (or password) is the only way to
+     * unlock after a reload — this keeps that off the app's plate.
+     *
+     * Returns `{ user, unlocked }`. When `unlocked` is false (no passkey, the
+     * user cancelled, or the browser required a gesture), prompt for a password
+     * and call {@link unlock}. Apps need no key-management scaffolding beyond this.
+     */
+    async resume() {
+        const user = await this.restore();
+        if (!user)
+            return { user: null, unlocked: false };
+        if (this.deps.session.isUnlocked)
+            return { user, unlocked: true };
+        try {
+            const factors = await this.listFactors();
+            if (factors.some((f) => f.type === "passkey")) {
+                await this.loginWithPasskey(user.username);
+            }
+        }
+        catch {
+            /* no passkey / cancelled / no user gesture — leave locked for a prompt */
+        }
+        return { user, unlocked: this.deps.session.isUnlocked };
+    }
     /**
      * Re-derive identity material for an already-authenticated (restored)
      * session, so the client can decrypt storage and run the ratchet. Verifies
@@ -7037,6 +7148,8 @@ class Space {
     events = new EventTarget();
     rawWired = false;
     catchUpUnsub = null;
+    /** Optional P2P swarm for this Space (block exchange among members). */
+    peerNet = null;
     constructor(deps) {
         this.deps = deps;
         this.name = deps.name;
@@ -7085,6 +7198,9 @@ class Space {
             if (this.deps.keyring) {
                 this.channel.on(BroadcastChannelEvents.CONNECTED, () => {
                     this.channel?.sendRaw({ name: this.deps.myId() });
+                    // Kick P2P peer discovery now the signaling channel is live
+                    // (re-runs on each reconnect to re-form the mesh).
+                    this.peerNet?.start();
                 });
                 this.wireFanout();
                 // Register offline catch-up once: on each reconnect the sync
@@ -7100,6 +7216,27 @@ class Space {
         this.channel?.disconnect();
         this.catchUpUnsub?.();
         this.catchUpUnsub = null;
+        this.peerNet?.close();
+        this.peerNet = null;
+    }
+    /** Attach a P2P swarm so this Space's file reads/writes can use peers. */
+    attachPeerNetwork(net) {
+        this.peerNet = net;
+    }
+    /**
+     * Broadcast an app payload directly to connected Space peers over P2P,
+     * **bypassing the server** — for CRDT ops / high-frequency state (live
+     * cursors, presence, collaborative edits) you don't want to push through the
+     * relay. No-op when no P2P mesh is active (requires `client` `p2p`).
+     * Unlike {@link sendEphemeral} (server-relayed, metered, size-limited), this
+     * is peer-direct and fragments large payloads.
+     */
+    gossipToPeers(data) {
+        this.peerNet?.gossip(data);
+    }
+    /** Subscribe to peer gossip ({@link gossipToPeers}). Returns an unsubscribe fn. */
+    onPeerGossip(handler) {
+        return this.peerNet?.onGossip(handler) ?? (() => { });
     }
     /** Subscribe to a raw channel event. Buffered until `connect()` if early. */
     on(event, handler) {
@@ -7158,18 +7295,23 @@ class Space {
         const hlc = await offline.nextHlc();
         const packet = await this.sealMessage(payload, opts.channel, opts.contentType, clientId);
         const frame = { spaceMessage: packet };
-        await offline.putMessage(this.id, {
+        const entry = {
             handle: provisionalSpaceKey(clientId),
             packet,
             op: "msg",
             clientId,
             hlc,
             pending: true,
-        });
-        if (this.isConnected())
-            this.sendRaw(frame);
-        else
+        };
+        if (this.isConnected()) {
+            this.sendRaw(frame); // send first — don't block the wire on IndexedDB
+            void offline.putMessage(this.id, entry); // optimistic cache off the hot path
+        }
+        else {
+            // Offline: persist the optimistic entry + durable replay queue.
+            void offline.putMessage(this.id, entry);
             await offline.enqueueFrame(this.id, frame, clientId, hlc);
+        }
     }
     /** Subscribe to decrypted fan-out messages. Returns an unsubscribe fn. */
     onMessage(handler) {
@@ -7233,18 +7375,14 @@ class Space {
         const offline = this.deps.offline;
         if (!offline?.enabled || !this.cipher)
             return [];
-        const entries = await offline.loadMessages(this.id);
+        const entries = (await offline.loadMessages(this.id)).filter((e) => !e.deleted && e.packet);
+        // Decode in parallel (already verified when cached → skipVerify).
+        const decodedAll = await Promise.all(entries.map((e) => this.decodeFrame(e.packet, this.cipher, /*isRawFrame*/ true, e.pending ? 0 : Number(e.handle), /*skipVerify*/ true)));
         const out = [];
-        for (const e of entries) {
-            if (e.deleted || !e.packet)
-                continue;
-            // Already verified when first cached → skip re-verification (which
-            // would also fail offline without a warm member directory).
-            const decoded = await this.decodeFrame(e.packet, this.cipher, 
-            /*isRawFrame*/ true, e.pending ? 0 : Number(e.handle), 
-            /*skipVerify*/ true);
+        for (let i = 0; i < decodedAll.length; i++) {
+            const decoded = decodedAll[i];
             if (decoded) {
-                decoded.pending = e.pending;
+                decoded.pending = entries[i].pending;
                 out.push(decoded);
             }
         }
@@ -7269,10 +7407,12 @@ class Space {
      * indicators, presence, or live cursors are built on top of this. No-op if
      * the space isn't connected (ephemeral signals aren't worth queuing).
      */
-    sendEphemeral(subject, data) {
+    sendEphemeral(subject, data, to) {
         if (!this.isConnected())
             return;
-        this.sendRaw({ pub: { subject, data } });
+        // `to` (a member id) lets the server unicast a *directed* ephemeral
+        // instead of broadcasting; omitted ⇒ broadcast to the room (unchanged).
+        this.sendRaw({ pub: to ? { subject, data, to } : { subject, data } });
     }
     /** Subscribe to inbound ephemeral signals. `from` is the authenticated sender. */
     onEphemeral(handler) {
@@ -7299,25 +7439,45 @@ class Space {
             params.set("limit", String(opts.limit));
         const url = `${this.deps.httpBaseUrl}/api/spaces/${encodeURIComponent(this.name)}/history` +
             (params.toString() ? `?${params}` : "");
+        // Temporary staging diagnostic: split fetch / directory / decode time.
+        const dbg = (() => { try {
+            return globalThis.location?.hostname?.includes("staging");
+        }
+        catch {
+            return false;
+        } })();
+        const mark = () => (typeof performance !== "undefined" ? performance.now() : Date.now());
+        const t0 = mark();
         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 tFetch = mark();
         // Warm the member directory once so historical senders' signatures verify.
-        // (refreshDirectory swallows its own transport errors.)
-        await this.deps.keyring?.refreshDirectory();
+        // Force past the cooldown — a history load is an explicit "get fresh".
+        await this.deps.keyring?.refreshDirectory({ force: true });
+        const tDir = mark();
+        // Decode the whole page in PARALLEL — each frame is an AES-GCM decrypt +
+        // ECDSA verify on the WebCrypto thread; doing them sequentially (await
+        // per message) serializes ~100 main↔crypto round-trips and dominates
+        // load time. Promise.all preserves input order.
+        const raws = body.messages ?? [];
+        const decodedAll = await Promise.all(raws.map((raw) => this.decodeFrame(raw, cipher)));
+        if (dbg) {
+            console.info(`[muhkoo:space] history n=${raws.length} | fetch ${Math.round(tFetch - t0)}ms | dir ${Math.round(tDir - tFetch)}ms | decode ${Math.round(mark() - tDir)}ms`);
+        }
         const messages = [];
-        for (const raw of body.messages ?? []) {
-            const decoded = await this.decodeFrame(raw, cipher);
+        for (let i = 0; i < decodedAll.length; i++) {
+            const decoded = decodedAll[i];
             if (!decoded)
                 continue;
             messages.push(decoded);
-            // Warm the offline cache with the inner sealed packet at its handle.
+            // Warm the offline cache off the hot path (best-effort, non-blocking).
             if (this.deps.offline?.enabled) {
                 try {
-                    const outer = JSON.parse(raw);
+                    const outer = JSON.parse(raws[i]);
                     if (typeof outer.spaceMessage === "string") {
-                        await this.cacheFrame(outer.spaceMessage, decoded, "msg");
+                        void this.cacheFrame(outer.spaceMessage, decoded, "msg");
                     }
                 }
                 catch {
@@ -7392,6 +7552,7 @@ class Space {
             fetch: this.deps.fetch,
             cache: this.deps.shardCache,
             deferUpload: this.deps.deferShardUpload,
+            peers: this.peerNet?.exchange,
         });
         return new FileStorage({ shards });
     }
@@ -7413,8 +7574,8 @@ class Space {
             const handle = Number(f.timestamp ?? 0);
             const decoded = await this.decodeFrame(f.spaceMessage, this.cipher, /*raw*/ true, handle);
             if (decoded) {
-                this.emitEvent("message", decoded);
-                await this.cacheFrame(f.spaceMessage, decoded, "msg");
+                this.emitEvent("message", decoded); // UI first
+                void this.cacheFrame(f.spaceMessage, decoded, "msg"); // cache off the hot path
             }
             return;
         }
@@ -7426,7 +7587,7 @@ class Space {
                 const decoded = await this.decodeFrame(e.spaceMessage, this.cipher, /*raw*/ true, Number(e.ts ?? 0));
                 if (decoded) {
                     this.emitEvent("message-edited", decoded);
-                    await this.cacheFrame(e.spaceMessage, decoded, "edit");
+                    void this.cacheFrame(e.spaceMessage, decoded, "edit");
                 }
             }
             return;
@@ -7436,8 +7597,8 @@ class Space {
             const handle = Number(d.ts ?? 0);
             this.emitEvent("message-deleted", { handle });
             if (this.deps.offline?.enabled) {
-                await this.deps.offline.putDeleted(this.id, handle);
-                await this.deps.offline.observeHandle(this.id, handle);
+                // Cache the tombstone off the hot path.
+                void this.deps.offline.putDeleted(this.id, handle).then(() => this.deps.offline?.observeHandle(this.id, handle));
             }
             return;
         }
@@ -7458,7 +7619,7 @@ class Space {
             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();
+            void this.deps.keyring?.refreshDirectory({ force: true });
             if (this.deps.autoAdmit !== false && this.deps.keyring?.hasAnyKey() && req.memberId !== this.deps.myId()) {
                 void this.deps.keyring.admit(req.memberId, req.identityEcdhPub).catch(() => { });
             }
@@ -7608,7 +7769,7 @@ class Space {
         const cursor = await offline.getCursor(this.id);
         let since = String(cursor?.lastSeenHandle ?? 0);
         // Warm the member directory once so historical senders' signatures verify.
-        await this.deps.keyring?.refreshDirectory();
+        await this.deps.keyring?.refreshDirectory({ force: true });
         for (let page = 0; page < 50; page++) {
             const url = `${this.deps.httpBaseUrl}/api/spaces/${encodeURIComponent(this.name)}/history` +
                 `?since=${encodeURIComponent(since)}&limit=100`;
@@ -7871,6 +8032,19 @@ function parseMaybeJson(text) {
  * `KEEPER_MEMBER_ID`.
  */
 const KEEPER_MEMBER_ID = "__keeper__";
+/** Staging-only keyring diagnostics (group-key cache hit/miss, persist, pulls). */
+const KEYRING_DEBUG = (() => {
+    try {
+        return typeof location !== "undefined" && /(^|\.)staging\./.test(location.hostname);
+    }
+    catch {
+        return false;
+    }
+})();
+function klog(msg) {
+    if (KEYRING_DEBUG)
+        console.info(`[muhkoo:keyring] ${msg}`);
+}
 class SpaceKeyring {
     deps;
     keys = new Map();
@@ -7878,6 +8052,14 @@ class SpaceKeyring {
     policy;
     /** Cached member directory: memberId → imported ECDSA verify key. */
     memberEcdsa = new Map();
+    /** Coalesce concurrent roster refreshes (the parallel history/backlog decode
+     *  would otherwise fire one `roster` fetch PER message — a thundering herd). */
+    dirInFlight = null;
+    dirRefreshedAt = 0;
+    /** Min gap between non-forced roster refreshes. A miss that persists within
+     *  this window won't re-fetch (the roster hasn't changed that fast); genuine
+     *  membership changes use `{ force: true }` (join requests / history loads). */
+    static DIR_COOLDOWN_MS = 5000;
     constructor(deps) {
         this.deps = deps;
         this.policy = deps.historyPolicy ?? "static";
@@ -7887,8 +8069,27 @@ class SpaceKeyring {
     ecdsaKeyFor(memberId) {
         return this.memberEcdsa.get(memberId);
     }
-    /** Refresh the member directory (memberId → ECDSA key) from the roster. */
-    async refreshDirectory() {
+    /**
+     * Refresh the member directory (memberId → ECDSA key) from the roster.
+     * Coalesces concurrent callers into ONE fetch, and skips a fetch when one
+     * completed within {@link DIR_COOLDOWN_MS} (unless `force`). Without this, a
+     * page of N messages decoded in parallel — each missing the cold directory —
+     * fires N simultaneous `roster` requests that queue behind the browser's
+     * connection limit and take many seconds.
+     */
+    async refreshDirectory(opts) {
+        if (this.dirInFlight)
+            return this.dirInFlight; // a refresh is already running
+        if (!opts?.force && Date.now() - this.dirRefreshedAt < SpaceKeyring.DIR_COOLDOWN_MS) {
+            return; // refreshed very recently — the roster won't have changed
+        }
+        this.dirInFlight = this.doRefreshDirectory().finally(() => {
+            this.dirRefreshedAt = Date.now();
+            this.dirInFlight = null;
+        });
+        return this.dirInFlight;
+    }
+    async doRefreshDirectory() {
         let roster;
         try {
             roster = await this.deps.transport.fetchRoster();
@@ -7923,34 +8124,63 @@ class SpaceKeyring {
     async loadFromCache() {
         if (!this.deps.cache)
             return false;
+        // The cache entries are ECIES-wrapped to our identity key, so we unwrap
+        // with the keyring's OWN private key — available whenever chat works,
+        // unlike client.kv's StorageCipher which needs the full unlocked identity.
+        const priv = this.deps.ownPrivateKey();
+        if (!priv) {
+            klog("loadFromCache: no private key available yet");
+            return false;
+        }
         let cached;
         try {
             cached = await this.deps.cache.loadKeys(this.deps.spaceId);
         }
-        catch {
+        catch (e) {
+            klog(`loadFromCache: ERROR reading cache — ${e instanceof Error ? e.message : e}`);
             return false;
         }
-        if (!cached)
+        if (!cached) {
+            klog("loadFromCache: cache empty");
+            return false;
+        }
+        for (const [epochStr, serialized] of Object.entries(cached)) {
+            try {
+                const blob = JSON.parse(serialized);
+                this.keys.set(Number(epochStr), await unwrapSpaceKey(blob, priv));
+            }
+            catch {
+                /* stale / old-format entry — skip; we'll re-admit and re-persist */
+            }
+        }
+        if (this.keys.size === 0) {
+            klog("loadFromCache: no usable entries (stale format → will re-admit)");
             return false;
-        for (const [epochStr, b64] of Object.entries(cached)) {
-            this.keys.set(Number(epochStr), fromBase64$1(b64));
         }
         this.epoch = Math.max(0, ...Array.from(this.keys.keys()));
-        return this.keys.size > 0;
+        klog(`loadFromCache: HIT ${this.keys.size} epoch(s), current=${this.epoch}`);
+        return true;
     }
     async persist() {
-        if (!this.deps.cache)
+        if (!this.deps.cache || this.keys.size === 0)
             return;
-        const out = {};
-        for (const [epoch, key] of this.keys)
-            out[String(epoch)] = toBase64$1(key);
-        // Best-effort: caching is an optimization; a write failure (e.g. locked
-        // storage) must not break key acquisition.
+        // Best-effort: caching is an optimization; a write failure must not break
+        // key acquisition.
         try {
+            // Wrap each epoch key to our OWN identity key (ECIES-to-self). The
+            // cache stays server-blind (the kv layer stores it with encrypt:false
+            // — it's already encrypted) AND readable with the keyring private key
+            // alone, so it works while the full identity is locked (post-reload).
+            const selfPub = await importEcdhPublicKey(this.deps.identityEcdhPub);
+            const out = {};
+            for (const [epoch, key] of this.keys) {
+                out[String(epoch)] = JSON.stringify(await wrapSpaceKey(key, epoch, selfPub));
+            }
             await this.deps.cache.saveKeys(this.deps.spaceId, out);
+            klog(`persist: saved ${Object.keys(out).length} epoch(s)`);
         }
-        catch {
-            /* ignore */
+        catch (e) {
+            klog(`persist: FAILED — ${e instanceof Error ? e.message : e}`);
         }
     }
     /** Creator path: mint epoch-0 group key for a brand-new space. */
@@ -7999,8 +8229,24 @@ class SpaceKeyring {
             this.epoch = Math.max(this.epoch, ...Array.from(this.keys.keys()));
             await this.persist();
         }
+        klog(`pullKeys: +${added} epoch(s) (now hold ${this.keys.size}, current=${this.epoch})`);
         return added;
     }
+    /**
+     * Background freshness check for the cache-hit fast path: confirm we hold the
+     * current epoch (picks up a rotation / our removal) WITHOUT the full newcomer
+     * admit handshake. Cheap + idempotent; never blocks first paint. Returns the
+     * number of newly-obtained epoch keys (0 = already current).
+     */
+    async reconcile() {
+        await this.refreshDirectory({ force: true });
+        try {
+            return await this.pullKeys();
+        }
+        catch {
+            return 0; // best-effort — the live keyringReady frame is the backstop
+        }
+    }
     // -- key-holder: admit + rotate -------------------------------------------
     /**
      * Wrap our group key(s) for a newcomer and post the blobs. In a `static`
@@ -8310,6 +8556,861 @@ class SpaceCache {
     }
 }
 
+/**
+ * `ShardCache` — a Cache-API-backed store for file-shard bytes. Shards are
+ * content-addressed (the key IS the SHA-256 of the ciphertext), so caching them
+ * is uniquely safe: a cache hit is self-validating, immutable, and shareable
+ * across files. The Cache API (rather than IndexedDB) is the right home for
+ * large binary blobs — it streams, it's purpose-built for response bodies, and
+ * it has its own eviction.
+ *
+ * Keys are SYNTHETIC absolute URLs (`https://shard.muhkoo.local/<hash>`) rather
+ * than the real shard endpoint, so the cache is addressable by hash alone — the
+ * sync engine can re-PUT a deferred shard knowing only its hash, without
+ * reconstructing the accelerator URL. We never fetch these synthetic URLs; they
+ * exist only as cache keys.
+ *
+ * Every method degrades to a no-op / null where the Cache API is unavailable
+ * (Node, Workers, insecure contexts), so callers don't need to branch.
+ */
+const CACHE_NAME = "muhkoo-shards-v1";
+class ShardCache {
+    static available() {
+        try {
+            return typeof caches !== "undefined";
+        }
+        catch {
+            return false;
+        }
+    }
+    key(hash) {
+        return `https://shard.muhkoo.local/${encodeURIComponent(hash)}`;
+    }
+    open() {
+        return caches.open(CACHE_NAME);
+    }
+    /** Cached shard bytes, or `null` on miss / when unavailable. */
+    async get(hash) {
+        if (!ShardCache.available())
+            return null;
+        try {
+            const cache = await this.open();
+            const res = await cache.match(this.key(hash));
+            if (!res)
+                return null;
+            return new Uint8Array(await res.arrayBuffer());
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Store shard bytes under their hash. Best-effort. */
+    async put(hash, bytes) {
+        if (!ShardCache.available())
+            return;
+        try {
+            const cache = await this.open();
+            await cache.put(this.key(hash), new Response(bytes, {
+                headers: { "content-type": "application/octet-stream" },
+            }));
+        }
+        catch {
+            /* quota / unavailable — degrade to online-only for this shard */
+        }
+    }
+    /** Whether a shard is present in the cache. */
+    async has(hash) {
+        if (!ShardCache.available())
+            return false;
+        try {
+            const cache = await this.open();
+            return Boolean(await cache.match(this.key(hash)));
+        }
+        catch {
+            return false;
+        }
+    }
+}
+
+/**
+ * `PeerExchange` — the thin façade the storage layer consults to try fetching a
+ * block from peers before falling back to origin. It satisfies the structural
+ * `PeerBlockSource` interface that {@link ../storage/transport/ShardClient}
+ * declares (so storage never imports the p2p module — the dependency arrow stays
+ * one-way, p2p → storage).
+ *
+ * It delegates to an {@link EngineHandle} — either an in-process {@link
+ * ./worker/blockEngine.BlockEngine} or the Web Worker proxy — so the same façade
+ * works whether the block engine runs on the main thread or off it.
+ */
+class PeerExchange {
+    engine;
+    timeoutMs;
+    debug;
+    constructor(engine, opts = {}) {
+        this.engine = engine;
+        this.timeoutMs = opts.timeoutMs ?? 2500;
+        this.debug = opts.debug ?? false;
+    }
+    async getBlock(hash, opts) {
+        const bytes = await this.engine.want(hash, opts?.timeoutMs ?? this.timeoutMs);
+        if (this.debug) {
+            console.info(`%c[muhkoo:p2p] ${bytes ? "✓ peer-served" : "✗ miss → origin"} shard ${hash.slice(0, 10)}…`, `color:${bytes ? "#58da7d" : "#888"}`);
+        }
+        return bytes;
+    }
+    announce(hash) {
+        if (this.debug)
+            console.info(`[muhkoo:p2p] announce shard ${hash.slice(0, 10)}…`);
+        this.engine.announce(hash);
+    }
+}
+
+/**
+ * `SpaceSignaler` — WebRTC signaling carried over the Space's existing ephemeral
+ * relay. No new server channel: `Space.sendEphemeral`/`onEphemeral` already
+ * blind-relay `pub` frames stamped with the authenticated sender, so SDP
+ * offers/answers and ICE candidates ride a reserved subject (`__p2p__`) scoped
+ * to Space membership. The sender (`from`) is server-stamped and can't be
+ * spoofed; the payload is opaque to the server.
+ *
+ * Envelopes carry a `to` (a member id, or `"*"` for discovery) so the
+ * accelerator can optionally unicast peer-pair signaling instead of broadcasting
+ * (a small, backward-compatible `pub` enhancement); the client filters by `to`
+ * regardless.
+ */
+const P2P_SUBJECT = "__p2p__";
+class SpaceSignaler {
+    space;
+    myId;
+    constructor(space, myId) {
+        this.space = space;
+        this.myId = myId;
+    }
+    /** Send a signal to one peer (or `"*"`). */
+    send(to, kind, data) {
+        const env = { to, kind, data };
+        // Ask the server to unicast for a directed target; broadcast for "*".
+        // `to` also stays in the envelope so a broadcast-only server still works
+        // (the client filters by it).
+        this.space.sendEphemeral(P2P_SUBJECT, env, to !== "*" ? to : undefined);
+    }
+    /** Announce/withdraw P2P availability to all Space members. */
+    broadcast(kind, data) {
+        this.send("*", kind, data);
+    }
+    /**
+     * Subscribe to inbound signals addressed to us (or broadcast). Skips our own
+     * echoes. Returns an unsubscribe function.
+     */
+    onSignal(cb) {
+        return this.space.onEphemeral((e) => {
+            if (e.subject !== P2P_SUBJECT || e.from === this.myId)
+                return;
+            const env = e.data;
+            if (!env || typeof env.kind !== "string")
+                return;
+            if (env.to !== this.myId && env.to !== "*")
+                return;
+            cb(e.from, env.kind, env.data);
+        });
+    }
+}
+
+/**
+ * `WebRtcTransport` — a {@link ./PeerTransport.PeerTransport} over RTCDataChannels,
+ * signaled by {@link ../signaling/SpaceSignaler}. Runs on the **main thread**
+ * (`RTCPeerConnection` is Window-only — not available in Workers), so the block
+ * engine lives in a Worker and this only shuttles bytes.
+ *
+ * Connection setup uses a deterministic initiator (the peer with the smaller id
+ * dials) to avoid offer/answer glare. STUN handles NAT traversal; there is no
+ * TURN — an unreachable peer simply never connects and the caller falls back to
+ * origin (P2P is best-effort).
+ *
+ * Frames (up to a 4 MiB shard) exceed an RTCDataChannel's max message size, so
+ * each frame is fragmented into `CHUNK`-sized pieces with a 12-byte header
+ * `[msgId u32][index u32][total u32]` and reassembled per peer.
+ */
+const CHUNK = 16 * 1024;
+// [msgId u32][index u32][total u32][channel u32]
+const HEADER$1 = 16;
+/** Pause sends when a channel has this many bytes buffered (backpressure). */
+const MAX_BUFFERED = 4 * 1024 * 1024;
+const DEFAULT_ICE = [{ urls: "stun:stun.cloudflare.com:3478" }];
+class WebRtcTransport {
+    signaler;
+    myId;
+    conns = new Map();
+    msgCbs = new Set();
+    peerCbs = new Set();
+    offSignal;
+    iceServers;
+    maxPeers;
+    nextMsgId = 1;
+    constructor(signaler, myId, opts = {}) {
+        this.signaler = signaler;
+        this.myId = myId;
+        this.iceServers = opts.iceServers ?? DEFAULT_ICE;
+        this.maxPeers = opts.maxPeers ?? 8;
+        this.offSignal = this.signaler.onSignal((from, kind, data) => this.onSignal(from, kind, data));
+    }
+    peers() {
+        return [...this.conns].filter(([, c]) => c.dc?.readyState === "open").map(([id]) => id);
+    }
+    /** Dial a peer (no-op unless we're the deterministic initiator for the pair). */
+    connectTo(peerId) {
+        if (peerId === this.myId || this.conns.has(peerId))
+            return;
+        if (this.conns.size >= this.maxPeers)
+            return; // mesh cap
+        if (this.myId < peerId)
+            void this.initiate(peerId); // smaller id dials
+    }
+    send(peer, data, channel = 0) {
+        const dc = this.conns.get(peer)?.dc;
+        if (dc?.readyState === "open")
+            void this.sendFragmented(dc, data, channel);
+    }
+    broadcast(data, channel = 0) {
+        for (const [, c] of this.conns) {
+            if (c.dc?.readyState === "open")
+                void this.sendFragmented(c.dc, data, channel);
+        }
+    }
+    onMessage(cb) {
+        this.msgCbs.add(cb);
+        return () => this.msgCbs.delete(cb);
+    }
+    onPeerChange(cb) {
+        this.peerCbs.add(cb);
+        return () => this.peerCbs.delete(cb);
+    }
+    close() {
+        this.offSignal();
+        for (const [, c] of this.conns) {
+            try {
+                c.dc?.close();
+            }
+            catch { /* already closing */ }
+            try {
+                c.pc.close();
+            }
+            catch { /* already closing */ }
+        }
+        this.conns.clear();
+        this.msgCbs.clear();
+        this.peerCbs.clear();
+    }
+    // -- internals -----------------------------------------------------------
+    newPc(peerId) {
+        const pc = new RTCPeerConnection({ iceServers: this.iceServers });
+        const conn = { pc, reasm: new Map() };
+        this.conns.set(peerId, conn);
+        pc.onicecandidate = (e) => {
+            if (e.candidate)
+                this.signaler.send(peerId, "ice", e.candidate.toJSON());
+        };
+        pc.onconnectionstatechange = () => {
+            if (["failed", "closed", "disconnected"].includes(pc.connectionState))
+                this.drop(peerId);
+        };
+        pc.ondatachannel = (e) => this.bindChannel(peerId, conn, e.channel);
+        return conn;
+    }
+    async initiate(peerId) {
+        const conn = this.newPc(peerId);
+        const dc = conn.pc.createDataChannel("blocks");
+        this.bindChannel(peerId, conn, dc);
+        const offer = await conn.pc.createOffer();
+        await conn.pc.setLocalDescription(offer);
+        this.signaler.send(peerId, "offer", offer);
+    }
+    bindChannel(peerId, conn, dc) {
+        dc.binaryType = "arraybuffer";
+        conn.dc = dc;
+        dc.onopen = () => this.firePeerChange();
+        dc.onclose = () => this.drop(peerId);
+        dc.onmessage = (e) => this.onChunk(peerId, conn, new Uint8Array(e.data));
+    }
+    async onSignal(from, kind, data) {
+        if (kind === "offer") {
+            if (!this.conns.has(from) && this.conns.size >= this.maxPeers)
+                return; // mesh cap
+            const conn = this.conns.get(from) ?? this.newPc(from);
+            await conn.pc.setRemoteDescription(data);
+            const answer = await conn.pc.createAnswer();
+            await conn.pc.setLocalDescription(answer);
+            this.signaler.send(from, "answer", answer);
+        }
+        else if (kind === "answer") {
+            const conn = this.conns.get(from);
+            if (conn)
+                await conn.pc.setRemoteDescription(data);
+        }
+        else if (kind === "ice") {
+            const conn = this.conns.get(from);
+            if (conn && data) {
+                try {
+                    await conn.pc.addIceCandidate(data);
+                }
+                catch { /* pre-SRD race */ }
+            }
+        }
+        else if (kind === "bye") {
+            this.drop(from);
+        }
+    }
+    drop(peerId) {
+        const conn = this.conns.get(peerId);
+        if (!conn)
+            return;
+        this.conns.delete(peerId);
+        try {
+            conn.dc?.close();
+        }
+        catch { /* already closing */ }
+        try {
+            conn.pc.close();
+        }
+        catch { /* already closing */ }
+        this.firePeerChange();
+    }
+    firePeerChange() {
+        const peers = this.peers();
+        for (const cb of this.peerCbs)
+            cb(peers);
+    }
+    // -- fragmentation -------------------------------------------------------
+    async sendFragmented(dc, data, channel) {
+        const msgId = this.nextMsgId++ >>> 0;
+        const total = Math.max(1, Math.ceil(data.length / CHUNK));
+        for (let i = 0; i < total; i++) {
+            const slice = data.subarray(i * CHUNK, (i + 1) * CHUNK);
+            const frame = new Uint8Array(HEADER$1 + slice.length);
+            const dv = new DataView(frame.buffer);
+            dv.setUint32(0, msgId);
+            dv.setUint32(4, i);
+            dv.setUint32(8, total);
+            dv.setUint32(12, channel);
+            frame.set(slice, HEADER$1);
+            if (dc.bufferedAmount > MAX_BUFFERED)
+                await this.drain(dc);
+            dc.send(frame);
+        }
+    }
+    drain(dc) {
+        return new Promise((resolve) => {
+            dc.bufferedAmountLowThreshold = MAX_BUFFERED / 2;
+            const onLow = () => { dc.removeEventListener("bufferedamountlow", onLow); resolve(); };
+            dc.addEventListener("bufferedamountlow", onLow);
+        });
+    }
+    onChunk(peerId, conn, frame) {
+        if (frame.length < HEADER$1)
+            return;
+        const dv = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+        const msgId = dv.getUint32(0);
+        const index = dv.getUint32(4);
+        const total = dv.getUint32(8);
+        const channel = dv.getUint32(12);
+        const chunk = frame.slice(HEADER$1);
+        let r = conn.reasm.get(msgId);
+        if (!r) {
+            r = { chunks: new Array(total), received: 0, total, size: 0, channel };
+            conn.reasm.set(msgId, r);
+        }
+        if (r.chunks[index])
+            return; // dup
+        r.chunks[index] = chunk;
+        r.received++;
+        r.size += chunk.length;
+        if (r.received < r.total)
+            return;
+        conn.reasm.delete(msgId);
+        const out = new Uint8Array(r.size);
+        let off = 0;
+        for (const c of r.chunks) {
+            if (!c)
+                return; // gap — shouldn't happen on reliable ordered
+            out.set(c, off);
+            off += c.length;
+        }
+        for (const cb of this.msgCbs)
+            cb(peerId, out, r.channel);
+    }
+}
+
+/**
+ * `PeerTransport` — the pluggable wire under the block engine. It moves opaque
+ * frames between Space peers; it knows nothing about blocks, hashes, or the
+ * protocol. {@link ./WebRtcTransport} implements it over RTCDataChannels today;
+ * a future libp2p/Helia transport can implement the same interface without the
+ * block engine or `ShardClient` changing.
+ *
+ * Implementations are responsible for fragmenting/ reassembling frames larger
+ * than the underlying channel's max message size (a 4 MiB shard won't fit in one
+ * `RTCDataChannel.send`); the engine always deals in whole frames.
+ */
+/**
+ * Logical channels multiplexed over the one data link. `0` is block exchange
+ * (the engine), `1` is gossip (app/CRDT data). The tag rides the framing header
+ * so payloads aren't copied to prepend it.
+ */
+const CHANNEL_BLOCK = 0;
+const CHANNEL_GOSSIP = 1;
+
+/**
+ * Bitswap-lite wire protocol for peer block exchange. Four frame types over a
+ * {@link ../transport/PeerTransport} data channel:
+ *
+ *   WANT(hash)         — "does anyone have this block?" / "send it to me"
+ *   HAVE(hash)         — "I hold this block" (announce / reply to a WANT)
+ *   BLOCK(hash, bytes) — the block itself (verified by hash on receipt)
+ *   CANCEL(hash)       — "stop, I got it elsewhere"
+ *
+ * Frames are compact binary so a 4 MiB shard isn't base64-bloated through JSON:
+ *
+ *   byte 0      : type (0 WANT | 1 HAVE | 2 BLOCK | 3 CANCEL)
+ *   bytes 1..33 : 32-byte raw SHA-256 of the block (our shard hash, hex-decoded)
+ *   bytes 33..  : payload (BLOCK only)
+ *
+ * Blocks are AES-GCM ciphertext, so a frame carries nothing readable; the hash
+ * is the capability check (the receiver re-hashes the payload and drops a
+ * mismatch). See {@link ./blockEngine}.
+ */
+var FrameType;
+(function (FrameType) {
+    FrameType[FrameType["WANT"] = 0] = "WANT";
+    FrameType[FrameType["HAVE"] = 1] = "HAVE";
+    FrameType[FrameType["BLOCK"] = 2] = "BLOCK";
+    FrameType[FrameType["CANCEL"] = 3] = "CANCEL";
+})(FrameType || (FrameType = {}));
+const HASH_BYTES = 32;
+const HEADER = 1 + HASH_BYTES; // type + hash
+function hexToBytes(hex) {
+    if (hex.length !== HASH_BYTES * 2) {
+        throw new Error(`protocol: expected a ${HASH_BYTES}-byte hex hash, got ${hex.length / 2} bytes`);
+    }
+    const out = new Uint8Array(HASH_BYTES);
+    for (let i = 0; i < HASH_BYTES; i++)
+        out[i] = parseInt(hex.substr(i * 2, 2), 16);
+    return out;
+}
+const HEX = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+    let s = "";
+    for (let i = 0; i < bytes.length; i++)
+        s += HEX[bytes[i]];
+    return s;
+}
+function header(type, hash, extra = 0) {
+    const buf = new Uint8Array(HEADER + extra);
+    buf[0] = type;
+    buf.set(hexToBytes(hash), 1);
+    return { buf, offset: HEADER };
+}
+function encodeWant(hash) {
+    return header(FrameType.WANT, hash).buf;
+}
+function encodeHave(hash) {
+    return header(FrameType.HAVE, hash).buf;
+}
+function encodeCancel(hash) {
+    return header(FrameType.CANCEL, hash).buf;
+}
+function encodeBlock(hash, payload) {
+    const { buf, offset } = header(FrameType.BLOCK, hash, payload.length);
+    buf.set(payload, offset);
+    return buf;
+}
+function decode(frame) {
+    if (frame.length < HEADER)
+        throw new Error("protocol: frame too short");
+    const type = frame[0];
+    const hash = bytesToHex(frame.subarray(1, HEADER));
+    if (type === FrameType.BLOCK) {
+        // Copy the payload out so it doesn't alias a transferred/pooled buffer.
+        return { type, hash, payload: frame.slice(HEADER) };
+    }
+    return { type, hash };
+}
+
+var protocol = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  get FrameType () { return FrameType; },
+  decode: decode,
+  encodeBlock: encodeBlock,
+  encodeCancel: encodeCancel,
+  encodeHave: encodeHave,
+  encodeWant: encodeWant
+});
+
+/**
+ * `BlockEngine` — the bitswap-lite want/have ledger. Host-agnostic: it speaks
+ * only to a {@link BlockStore} (get/put/has) and an `out` sink that ships
+ * encoded frames to a peer (or `"*"` to broadcast). The host wires `out` and
+ * `handleFrame` to a real transport — on the main thread or inside the Web
+ * Worker (see {@link ./engineClient}) — so this class is pure and unit-testable.
+ *
+ * It never sees keys: blocks are AES-GCM ciphertext, addressed by SHA-256. The
+ * one trust check is integrity — an inbound BLOCK is re-hashed and dropped on
+ * mismatch, so a malicious peer can't poison the store (the requester just
+ * falls back to origin).
+ */
+class BlockEngine {
+    store;
+    out;
+    hash;
+    wants = new Map();
+    constructor(store, out, hash) {
+        this.store = store;
+        this.out = out;
+        this.hash = hash;
+    }
+    /**
+     * Ask the swarm for a block. Resolves with the verified bytes, or `null` on
+     * timeout (caller then falls back to origin). Returns immediately if we
+     * already hold it; concurrent wants for the same hash share one request.
+     */
+    want(hash, timeoutMs) {
+        return new Promise((resolve) => {
+            void this.store.get(hash).then((local) => {
+                if (local)
+                    return resolve(local);
+                const existing = this.wants.get(hash);
+                if (existing) {
+                    existing.resolvers.push(resolve);
+                    return;
+                }
+                const timer = setTimeout(() => {
+                    const w = this.wants.get(hash);
+                    this.wants.delete(hash);
+                    this.out("*", encodeCancel(hash));
+                    w?.resolvers.forEach((r) => r(null));
+                }, timeoutMs);
+                this.wants.set(hash, { resolvers: [resolve], timer });
+                this.out("*", encodeWant(hash));
+            });
+        });
+    }
+    /** Tell the swarm we now hold `hash` (so peers wanting it can pull from us). */
+    announce(hash) {
+        this.out("*", encodeHave(hash));
+    }
+    /** Handle one inbound frame from `peer`. */
+    async handleFrame(peer, frame) {
+        let f;
+        try {
+            f = decode(frame);
+        }
+        catch {
+            return; // malformed — ignore
+        }
+        switch (f.type) {
+            case FrameType.WANT: {
+                const bytes = await this.store.get(f.hash);
+                if (bytes)
+                    this.out(peer, encodeBlock(f.hash, bytes));
+                return;
+            }
+            case FrameType.HAVE: {
+                // A peer announced a block we're still waiting for → pull from them.
+                if (this.wants.has(f.hash))
+                    this.out(peer, encodeWant(f.hash));
+                return;
+            }
+            case FrameType.BLOCK: {
+                const pending = this.wants.get(f.hash);
+                if (!pending || !f.payload)
+                    return; // unsolicited / empty — ignore
+                // Integrity: a peer can't poison the store. Drop a mismatch and
+                // keep waiting (the timeout will fall back to origin).
+                const got = await this.hash(f.payload);
+                if (got !== f.hash)
+                    return;
+                await this.store.put(f.hash, f.payload);
+                this.wants.delete(f.hash);
+                clearTimeout(pending.timer);
+                this.out("*", encodeCancel(f.hash)); // others can stop sending
+                pending.resolvers.forEach((r) => r(f.payload));
+                return;
+            }
+            case FrameType.CANCEL:
+                // We serve WANTs synchronously, so there's nothing in flight to
+                // cancel yet. Reserved for chunked-send cancellation later.
+                return;
+        }
+    }
+    /** Drop all pending waits (resolve null) — on teardown. */
+    close() {
+        for (const [, w] of this.wants) {
+            clearTimeout(w.timer);
+            w.resolvers.forEach((r) => r(null));
+        }
+        this.wants.clear();
+    }
+}
+
+/**
+ * `EngineHost` — the boundary {@link ../PeerNetwork} wires a transport to. It
+ * abstracts *where* the {@link ./blockEngine.BlockEngine} runs:
+ *   - {@link LocalEngineHost} runs it on the calling thread (tests, or a
+ *     fallback when the Web Worker can't be built by a consumer's bundler);
+ *   - the Worker proxy ({@link ./engineClient}) runs it off-thread.
+ *
+ * Either way the host exposes the same surface: drive `want`/`announce`, feed it
+ * inbound frames via `handleFrame`, and receive its outbound frames via
+ * `onOutbound` (which the network forwards to the transport).
+ */
+/** Runs the engine in-process (main thread or test). */
+class LocalEngineHost {
+    engine;
+    cbs = new Set();
+    constructor(store, hasher) {
+        this.engine = new BlockEngine(store, (target, frame) => {
+            for (const cb of this.cbs)
+                cb(target, frame);
+        }, hasher);
+    }
+    want(hash, timeoutMs) {
+        return this.engine.want(hash, timeoutMs);
+    }
+    announce(hash) {
+        this.engine.announce(hash);
+    }
+    handleFrame(peer, frame) {
+        void this.engine.handleFrame(peer, frame);
+    }
+    onOutbound(cb) {
+        this.cbs.add(cb);
+        return () => this.cbs.delete(cb);
+    }
+    close() {
+        this.engine.close();
+        this.cbs.clear();
+    }
+}
+
+/**
+ * `WorkerEngineHost` — the main-thread proxy to a {@link ./blockEngine.BlockEngine}
+ * running inside a dedicated Web Worker (so hashing, blockstore I/O, and the
+ * protocol codec stay off the main thread). It speaks the small message protocol
+ * in {@link ./blockEngine.worker} and satisfies {@link ./engineHost.EngineHost},
+ * so {@link ../PeerNetwork} treats it identically to the in-process host.
+ *
+ * Block bytes cross the worker boundary as **transferable** ArrayBuffers
+ * (zero-copy). Only encrypted blocks ever cross — keys never enter the worker.
+ */
+class WorkerEngineHost {
+    worker;
+    wants = new Map();
+    cbs = new Set();
+    nextId = 1;
+    constructor(worker) {
+        this.worker = worker;
+        this.worker.onmessage = (e) => {
+            const m = e.data;
+            if (m.t === "out") {
+                const frame = new Uint8Array(m.data);
+                for (const cb of this.cbs)
+                    cb(m.target, frame);
+            }
+            else if (m.t === "want-result") {
+                const resolve = this.wants.get(m.id);
+                if (resolve) {
+                    this.wants.delete(m.id);
+                    resolve(m.data ? new Uint8Array(m.data) : null);
+                }
+            }
+        };
+    }
+    want(hash, timeoutMs) {
+        return new Promise((resolve) => {
+            const id = this.nextId++;
+            this.wants.set(id, resolve);
+            this.worker.postMessage({ t: "want", id, hash, timeout: timeoutMs });
+        });
+    }
+    announce(hash) {
+        this.worker.postMessage({ t: "announce", hash });
+    }
+    handleFrame(peer, frame) {
+        // Transfer an exact-size buffer; copy if the view doesn't own the whole buffer.
+        const buf = frame.byteOffset === 0 && frame.byteLength === frame.buffer.byteLength
+            ? frame.buffer
+            : frame.slice().buffer;
+        this.worker.postMessage({ t: "frame", peer, data: buf }, [buf]);
+    }
+    onOutbound(cb) {
+        this.cbs.add(cb);
+        return () => this.cbs.delete(cb);
+    }
+    close() {
+        try {
+            this.worker.postMessage({ t: "close" });
+        }
+        catch { /* already gone */ }
+        this.worker.terminate();
+        this.wants.forEach((r) => r(null));
+        this.wants.clear();
+        this.cbs.clear();
+    }
+}
+
+/**
+ * `PeerNetwork` — the per-Space orchestrator that ties the pieces together on
+ * the main thread:
+ *
+ *   transport (WebRTC)  ⇄  engine host (Worker or in-process)  →  PeerExchange
+ *        ▲                                                            │
+ *        └────────────── signaling over the Space relay ─────────────┘
+ *
+ * It owns one {@link ./transport/WebRtcTransport} + one {@link
+ * ./worker/engineHost.EngineHost}, wires inbound frames to the engine and the
+ * engine's outbound frames back to the transport, runs peer discovery over the
+ * Space's ephemeral channel, and exposes a {@link ./PeerExchange.PeerExchange}
+ * for `ShardClient` to consult. Scope is one Space (private swarm).
+ *
+ * `engineHost` defaults to in-process; pass `workerFactory` to run the block
+ * engine off the main thread (the consumer's bundler resolves the worker URL).
+ */
+/**
+ * Build the engine host, preferring an off-thread Web Worker:
+ *   1. an explicit `workerFactory` (most reliable in app bundlers), else
+ *   2. the bundled worker resolved relative to this module (works where the
+ *      bundler supports `new Worker(new URL(...))`, e.g. Vite builds), else
+ *   3. the in-process engine (always works; tests + non-worker runtimes).
+ * Any worker construction failure degrades to in-process.
+ */
+function buildEngineHost(opts) {
+    try {
+        const worker = opts.workerFactory ? opts.workerFactory() : defaultWorker();
+        if (worker)
+            return new WorkerEngineHost(worker);
+    }
+    catch {
+        /* no Worker global / bundler can't resolve it → in-process */
+    }
+    return new LocalEngineHost(opts.store ?? new ShardCache(), shardHash);
+}
+/** Construct the bundled worker if the runtime + bundler support it, else null. */
+function defaultWorker() {
+    try {
+        if (typeof Worker === "undefined")
+            return null;
+        // The string is resolved by the consumer's bundler relative to the
+        // built connect module (sibling of dist/browser/index.js).
+        return new Worker(new URL("./blockEngine.worker.js", import.meta.url), { type: "module" });
+    }
+    catch {
+        return null;
+    }
+}
+class PeerNetwork {
+    /** Pass this to a `ShardClient` as `peers`. */
+    exchange;
+    transport;
+    host;
+    signaler;
+    offs = [];
+    gossipCbs = new Set();
+    closed = false;
+    constructor(opts) {
+        this.signaler = new SpaceSignaler(opts.space, opts.myId);
+        this.transport =
+            opts.transport ??
+                new WebRtcTransport(this.signaler, opts.myId, {
+                    iceServers: opts.iceServers,
+                    maxPeers: opts.maxPeers,
+                });
+        this.host = buildEngineHost(opts);
+        // Wire transport ⇄ engine, demuxing block (engine) from gossip (app).
+        this.offs.push(this.transport.onMessage((peer, data, channel) => {
+            if (channel === CHANNEL_GOSSIP) {
+                for (const cb of this.gossipCbs)
+                    cb(peer, data);
+            }
+            else {
+                this.host.handleFrame(peer, data);
+            }
+        }));
+        this.offs.push(this.host.onOutbound((target, frame) => target === "*"
+            ? this.transport.broadcast(frame, CHANNEL_BLOCK)
+            : this.transport.send(target, frame, CHANNEL_BLOCK)));
+        // Discovery: a broadcast hello triggers a unicast hello back (so a
+        // newcomer learns existing members); both sides connectTo (the smaller
+        // id actually dials). Deterministic + idempotent.
+        this.offs.push(this.signaler.onSignal((from, kind, data) => {
+            if (kind !== "hello")
+                return;
+            this.transport.connectTo?.(from);
+            if (data?.broadcast) {
+                this.signaler.send(from, "hello", { broadcast: false });
+            }
+        }));
+        this.exchange = new PeerExchange(this.host, { timeoutMs: opts.timeoutMs, debug: opts.debug });
+        if (opts.debug) {
+            console.info("[muhkoo:p2p] mesh attached for space; awaiting peers…");
+            this.offs.push(this.transport.onPeerChange((peers) => console.info(`%c[muhkoo:p2p] connected peers: ${peers.length}`, "color:#58da7d", peers)));
+        }
+    }
+    /**
+     * Begin peer discovery — broadcast a hello so existing members dial us and
+     * we learn them. Call once the signaling channel is live (the Space fires
+     * this on CONNECTED); safe to call again on reconnect.
+     */
+    start() {
+        if (this.closed)
+            return;
+        this.signaler.broadcast("hello", { broadcast: true });
+    }
+    /**
+     * Broadcast an app payload to all connected peers over the gossip channel —
+     * a direct, server-bypassing data path for CRDT ops / high-frequency state
+     * (cursors, presence, collaborative edits). Single-hop (no re-forwarding).
+     */
+    gossip(data) {
+        this.transport.broadcast(data, CHANNEL_GOSSIP);
+    }
+    /** Subscribe to gossip from peers. Returns an unsubscribe function. */
+    onGossip(cb) {
+        this.gossipCbs.add(cb);
+        return () => this.gossipCbs.delete(cb);
+    }
+    /** Connected peer count (open data channels). */
+    peerCount() {
+        return this.transport.peers().length;
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        try {
+            this.signaler.broadcast("bye");
+        }
+        catch { /* socket may be gone */ }
+        for (const off of this.offs)
+            off();
+        this.transport.close();
+        this.host.close();
+    }
+}
+
+/**
+ * Whether this environment can do WebRTC peering. `RTCPeerConnection` is
+ * Window-only (absent in Node/Workers/SSR), so this gates whether a
+ * {@link ./PeerNetwork} can be built at all.
+ */
+function isP2pCapable() {
+    try {
+        return typeof RTCPeerConnection !== "undefined";
+    }
+    catch {
+        return false;
+    }
+}
+
 /**
  * `client.space` — the fan-out group-encryption surface.
  *
@@ -8541,13 +9642,52 @@ class SpaceNamespace {
                 : undefined,
         });
         this.openSpaces.set(spaceId, space);
+        // Attach a private P2P swarm scoped to this Space (block exchange among
+        // members; signaled over the Space relay). Discovery starts on connect.
+        if (this.deps.p2p?.enabled && isP2pCapable()) {
+            space.attachPeerNetwork(new PeerNetwork({
+                space,
+                myId: memberId,
+                workerFactory: this.deps.p2p.workerFactory,
+                iceServers: this.deps.p2p.iceServers,
+                maxPeers: this.deps.p2p.maxPeers,
+                debug: this.deps.p2p.debug,
+            }));
+        }
         return space;
     }
     /** 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);
+            // Unlocked (seed in hand): rehydrate the member's STABLE keypair from
+            // the vault, or provision + persist one on first use. This keeps the
+            // member the same identity across reloads — no re-admit each session,
+            // and the group-key cache round-trips. Best-effort: a personal-space
+            // hiccup falls through to an ephemeral keypair (today's behavior).
+            const seed = this.deps.session.seed;
+            const staging = (() => { try {
+                return typeof location !== "undefined" && /(^|\.)staging\./.test(location.hostname);
+            }
+            catch {
+                return false;
+            } })();
+            if (staging)
+                console.info(`[muhkoo:vault] ensureIdentity: unlocked=${!!seed} vault=${!!this.deps.chatKeys}`);
+            if (this.deps.chatKeys && seed) {
+                try {
+                    await this.deps.chatKeys.ensure(memberId, toBase64$1(seed));
+                }
+                catch (e) {
+                    if (staging)
+                        console.info(`[muhkoo:vault] ensureIdentity: vault.ensure failed — ${e instanceof Error ? e.message : e}`);
+                }
+            }
+            if (!store.getKeyPair(memberId)) {
+                if (staging)
+                    console.info("[muhkoo:vault] ensureIdentity: EPHEMERAL keypair (locked / no vault) → will re-admit");
+                await store.generateOwnKeyPair(memberId);
+            }
         }
         const ecdhPub = await exportEcdhPublicKey(store.getKeyPair(memberId).publicKey);
         const ecdsaPub = await exportEcdsaPublicKey(store.getAuthKeyPair(memberId).publicKey);
@@ -8788,6 +9928,112 @@ class FunctionsNamespace {
     }
 }
 
+/**
+ * `ChatKeyVault` — SDK-owned lifecycle for a member's long-lived ratchet/space
+ * keypair (the connect `KeyStore` entry keyed by the member id / username).
+ *
+ * Historically each app hand-rolled this (see the web app's old
+ * `personal/spaceLoader.ts`): generate a keypair at register, seed-wrap it, and
+ * PUT it to the personal space; on login GET + unwrap + hydrate the `KeyStore`.
+ * That scaffolding now lives here so ANY app gets a **stable** member keypair
+ * across reloads for free — without which the member re-admits to every space on
+ * every load and the group-key cache can never round-trip.
+ *
+ * Security invariant: the wrapping secret is the **master seed** (not the
+ * password), so the blob survives password changes and unlocks under a passkey.
+ * The seed is only ever held in memory (never persisted), so this vault can only
+ * provision/rehydrate while the client is unlocked.
+ */
+/** Staging-only diagnostics: is the member keypair stable across reloads? */
+const VAULT_DEBUG = (() => {
+    try {
+        return typeof location !== "undefined" && /(^|\.)staging\./.test(location.hostname);
+    }
+    catch {
+        return false;
+    }
+})();
+function vlog(msg) {
+    if (VAULT_DEBUG)
+        console.info(`[muhkoo:vault] ${msg}`);
+}
+/** A short, stable fingerprint of the member's current keypair (ecdsa pub). */
+async function fingerprint(memberId) {
+    try {
+        const raw = await KeyStore.getInstance().getRawEcdsaPublicKey(memberId);
+        if (!raw)
+            return "none";
+        let s = 0;
+        for (const b of raw)
+            s = (s * 31 + b) >>> 0;
+        return s.toString(16).padStart(8, "0");
+    }
+    catch {
+        return "err";
+    }
+}
+/** Personal-space key holding the seed-wrapped, dehydrated ratchet keypair. */
+const CHAT_KEYS_KEY = "chat-keys";
+class ChatKeyVault {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    /**
+     * Register-time: ensure a keypair exists for `memberId`, seed-wrap the
+     * dehydrated form, and persist it to the personal space. Idempotent — reuses
+     * an existing in-tab keypair rather than minting a second one.
+     */
+    async provision(memberId, seedSecret) {
+        const ks = KeyStore.getInstance();
+        if (!ks.getKeyPair(memberId)) {
+            try {
+                await ks.generateOwnKeyPair(memberId);
+            }
+            catch (e) {
+                if (!String(e?.message ?? e).includes("already exists"))
+                    throw e;
+            }
+        }
+        const dehydrated = await ks.dehydrateKeyPair(memberId);
+        const plaintext = new TextEncoder().encode(JSON.stringify(dehydrated));
+        await this.store.put(CHAT_KEYS_KEY, await wrapWithPassphrase(seedSecret, plaintext));
+        vlog(`provision: minted+persisted keypair fp=${await fingerprint(memberId)}`);
+    }
+    /**
+     * Sign-in / unlock time: fetch the wrapped blob, unwrap with the seed, and
+     * hydrate the `KeyStore` — restoring the SAME keypair the member had before.
+     * Returns `true` when a keypair is now in hand (already present or hydrated),
+     * `false` when there's no blob yet (a brand-new member → caller provisions).
+     * Throws only on a genuine unwrap failure (wrong secret / tampered blob).
+     */
+    async rehydrate(memberId, seedSecret) {
+        // Already unlocked in this tab — nothing to do.
+        if (KeyStore.getInstance().getKeyPair(memberId)?.privateKey)
+            return true;
+        const wrapped = await this.store.get(CHAT_KEYS_KEY);
+        if (!wrapped) {
+            vlog("rehydrate: no chat-keys blob (new member → will provision)");
+            return false;
+        }
+        const bytes = await unwrapWithPassphrase(seedSecret, wrapped);
+        const dehydrated = JSON.parse(new TextDecoder().decode(bytes));
+        await KeyStore.getInstance().hydrateKeyPair(memberId, dehydrated);
+        vlog(`rehydrate: HIT — restored stable keypair fp=${await fingerprint(memberId)}`);
+        return true;
+    }
+    /**
+     * Ensure a stable keypair is in hand: rehydrate from the vault if a blob
+     * exists, otherwise mint one and persist it (so it's stable next session).
+     * Used at register and lazily when a space is first opened.
+     */
+    async ensure(memberId, seedSecret) {
+        if (await this.rehydrate(memberId, seedSecret))
+            return;
+        await this.provision(memberId, seedSecret);
+    }
+}
+
 /**
  * `HlcTimestamp` — a Hybrid Logical Clock reading, packed into a single
  * lexicographically-sortable string so the whole offline layer (and the
@@ -9304,82 +10550,6 @@ class SnapshotNamespace {
     }
 }
 
-/**
- * `ShardCache` — a Cache-API-backed store for file-shard bytes. Shards are
- * content-addressed (the key IS the SHA-256 of the ciphertext), so caching them
- * is uniquely safe: a cache hit is self-validating, immutable, and shareable
- * across files. The Cache API (rather than IndexedDB) is the right home for
- * large binary blobs — it streams, it's purpose-built for response bodies, and
- * it has its own eviction.
- *
- * Keys are SYNTHETIC absolute URLs (`https://shard.muhkoo.local/<hash>`) rather
- * than the real shard endpoint, so the cache is addressable by hash alone — the
- * sync engine can re-PUT a deferred shard knowing only its hash, without
- * reconstructing the accelerator URL. We never fetch these synthetic URLs; they
- * exist only as cache keys.
- *
- * Every method degrades to a no-op / null where the Cache API is unavailable
- * (Node, Workers, insecure contexts), so callers don't need to branch.
- */
-const CACHE_NAME = "muhkoo-shards-v1";
-class ShardCache {
-    static available() {
-        try {
-            return typeof caches !== "undefined";
-        }
-        catch {
-            return false;
-        }
-    }
-    key(hash) {
-        return `https://shard.muhkoo.local/${encodeURIComponent(hash)}`;
-    }
-    open() {
-        return caches.open(CACHE_NAME);
-    }
-    /** Cached shard bytes, or `null` on miss / when unavailable. */
-    async get(hash) {
-        if (!ShardCache.available())
-            return null;
-        try {
-            const cache = await this.open();
-            const res = await cache.match(this.key(hash));
-            if (!res)
-                return null;
-            return new Uint8Array(await res.arrayBuffer());
-        }
-        catch {
-            return null;
-        }
-    }
-    /** Store shard bytes under their hash. Best-effort. */
-    async put(hash, bytes) {
-        if (!ShardCache.available())
-            return;
-        try {
-            const cache = await this.open();
-            await cache.put(this.key(hash), new Response(bytes, {
-                headers: { "content-type": "application/octet-stream" },
-            }));
-        }
-        catch {
-            /* quota / unavailable — degrade to online-only for this shard */
-        }
-    }
-    /** Whether a shard is present in the cache. */
-    async has(hash) {
-        if (!ShardCache.available())
-            return false;
-        try {
-            const cache = await this.open();
-            return Boolean(await cache.match(this.key(hash)));
-        }
-        catch {
-            return false;
-        }
-    }
-}
-
 /**
  * IndexedDB schema for the offline layer — the single source of truth for the
  * database name, version, and object stores. Bump {@link DB_VERSION} whenever
@@ -10091,17 +11261,46 @@ class Client {
         this.message = new MessageNamespace({ http: this.http, session: this.session, wsBaseUrl });
         // Group keys are cached in the user's PersonalSpace (encrypted at rest
         // by client.kv), so a returning member hydrates without a fresh keyring
-        // round-trip. The server only ever sees the ciphertext.
+        // round-trip. The server only ever sees ciphertext.
+        //
+        // `encrypt: false` is deliberate: the keyring already ECIES-wraps each
+        // key to the member's identity (server-blind), and StorageCipher would
+        // additionally require the FULL unlocked identity (`requireIdentity()`),
+        // which is locked after a page reload — that coupling is exactly why the
+        // cache previously never read or persisted. The wrapped blobs are opaque.
         const spaceKeyCache = {
             loadKeys: (spaceId) => this.kv.get("space-keys", spaceId),
-            saveKeys: (spaceId, keys) => this.kv.set("space-keys", spaceId, keys),
+            saveKeys: (spaceId, keys) => this.kv.set("space-keys", spaceId, keys, { encrypt: false }),
+        };
+        // SDK-owned vault for the member's long-lived ratchet/space keypair.
+        // Stored at the personal-space `chat-keys` key (same key the app used to
+        // manage by hand), seed-wrapped, session-token authed (no snarkjs). This
+        // gives every app a STABLE keypair across reloads — no per-app scaffolding
+        // — so members don't re-admit each load and the group-key cache works.
+        const chatKeyStore = {
+            get: async (key) => {
+                const c = this.session.commitment;
+                if (!c)
+                    return null;
+                const res = await this.http.post(`/api/personal/${encodeURIComponent(c)}/kv/${encodeURIComponent(key)}/get`, {});
+                return (res?.value ?? null);
+            },
+            put: async (key, value) => {
+                const c = this.session.commitment;
+                if (!c)
+                    throw new Error("ChatKeyVault: no session — sign in first.");
+                await this.http.post(`/api/personal/${encodeURIComponent(c)}/kv/${encodeURIComponent(key)}`, { value });
+            },
         };
+        const chatKeys = new ChatKeyVault(chatKeyStore);
         this.space = new SpaceNamespace({
             http: this.http,
             session: this.session,
             wsBaseUrl,
             cache: spaceKeyCache,
             offline: this.offline,
+            p2p: options.p2p,
+            chatKeys,
         });
         this.agents = new AgentsNamespace({ http: this.http });
         this.functions = new FunctionsNamespace({ http: this.http, fnHostSuffix: options.functionsHostSuffix });
@@ -10523,5 +11722,5 @@ var bundledLoader = /*#__PURE__*/Object.freeze({
   default: loadRsWasm
 });
 
-export { AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, AES_GCM_TAG_BYTES, AgentsNamespace, AuthClient, AuthNamespace, AuthPublicInput, Authenticator, BroadcastChannel, BroadcastChannelEvents, ChannelExistsError, ChannelNotFoundError, ChunkCipher, Client, ConnectivityManager, DEFAULT_AUTH_BASE_URL, DEFAULT_BASE_URL, DEFAULT_FN_HOST_SUFFIX, DbCache, DoubleRatchet, DoubleRatchetCipher, DoubleRatchetManager, EncryptedSession, EventCore, EventCoreEvents, Field, Field as FieldElement, FileStorage, FunctionsNamespace, HLC, HashKnowledge, HttpClient, HttpError, IndexedDbStore, KEEPER_MEMBER_ID, KeyStore, KeyringClient, KvCache, KvNamespace, LocalStorageSessionStore, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, MuhkooAgent, MuhkooDB, MuhkooFunction, MuhkooSpace, NoopStore, OfflineLockedError, OfflineManager, OutboundQueue, PBKDF2_DEFAULT_ITERATIONS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PersonalSpaceClient, Poseidon, PreimagePoK, ReedSolomonCodec, Space as Room, SerializeMessage, SessionState, ShardCache, ShardClient, SharedSpaceClient, SnapshotNamespace, Space, SpaceCache, SpaceKeyring, SpaceNamespace, SpacePacketCipher, StorageNamespace, SyncEngine, VaultUnavailableError, WSTransport, ZERO_HLC, ZkAuth, buildCommitment, compareHlc, compilePrograms, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultSessionStore, deleteBeatsWrite, deleteRegister, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, deriveIdentityFromSeed, deriveMasterSeedFromPassword, ejectAgentPrompt, ejectAgentTools, emptyMap, emptyRegister, encodeToHex, encryptAesGcm, exportPublicKeyBase64, exportPublicKeyHex, generateAuthProof, generatePkce, getMuhkooAppDescriptor, getSubtle, initBn128Wasm, initRsWasm, initializeCircuits, isNewer, isOfflineCapable, isProvisional, manifestToStat, materializeRow, mergeMap, mergeMessage, mergeRegister, messageKey, pack, padHandle, poseidonHash, provisionalHandle, quickVerify, randomBytes, randomState, sealSeed, shardHash, signMessage, stableStringify, toField, tombstoneRow, unpack, unsealSeed, unwrapWithPassphrase, verify, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase, writeBeatsTombstone, writeColumns, writeRegister };
+export { AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, AES_GCM_TAG_BYTES, AgentsNamespace, AuthClient, AuthNamespace, AuthPublicInput, Authenticator, BlockEngine, BroadcastChannel, BroadcastChannelEvents, ChannelExistsError, ChannelNotFoundError, ChunkCipher, Client, ConnectivityManager, DEFAULT_AUTH_BASE_URL, DEFAULT_BASE_URL, DEFAULT_FN_HOST_SUFFIX, DbCache, DoubleRatchet, DoubleRatchetCipher, DoubleRatchetManager, EncryptedSession, EventCore, EventCoreEvents, Field, Field as FieldElement, FileStorage, FunctionsNamespace, HLC, HashKnowledge, HttpClient, HttpError, IndexedDbStore, KEEPER_MEMBER_ID, KeyStore, KeyringClient, KvCache, KvNamespace, LocalEngineHost, LocalStorageSessionStore, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, MuhkooAgent, MuhkooDB, MuhkooFunction, MuhkooSpace, NoopStore, OfflineLockedError, OfflineManager, OutboundQueue, P2P_SUBJECT, PBKDF2_DEFAULT_ITERATIONS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PeerExchange, PeerNetwork, PersonalSpaceClient, Poseidon, PreimagePoK, ReedSolomonCodec, Space as Room, SerializeMessage, SessionState, ShardCache, ShardClient, SharedSpaceClient, SnapshotNamespace, Space, SpaceCache, SpaceKeyring, SpaceNamespace, SpacePacketCipher, SpaceSignaler, StorageNamespace, SyncEngine, VaultUnavailableError, WSTransport, WebRtcTransport, WorkerEngineHost, ZERO_HLC, ZkAuth, buildCommitment, compareHlc, compilePrograms, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultSessionStore, deleteBeatsWrite, deleteRegister, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, deriveIdentityFromSeed, deriveMasterSeedFromPassword, ejectAgentPrompt, ejectAgentTools, emptyMap, emptyRegister, encodeToHex, encryptAesGcm, exportPublicKeyBase64, exportPublicKeyHex, generateAuthProof, generatePkce, getMuhkooAppDescriptor, getSubtle, initBn128Wasm, initRsWasm, initializeCircuits, isNewer, isOfflineCapable, isP2pCapable, isProvisional, manifestToStat, materializeRow, mergeMap, mergeMessage, mergeRegister, messageKey, pack, padHandle, poseidonHash, protocol, provisionalHandle, quickVerify, randomBytes, randomState, sealSeed, shardHash, signMessage, stableStringify, toField, tombstoneRow, unpack, unsealSeed, unwrapWithPassphrase, verify, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase, writeBeatsTombstone, writeColumns, writeRegister };
 //# sourceMappingURL=index.js.map