@kubun/plugin-p2p 0.11.0 → 0.12.1

package/lib/hub/loopback-log-hub.d.ts

@@ -0,0 +1,20 @@
+import type { HubStore } from '@kumiai/hub-protocol';
+import type { LogHub } from '@kumiai/hub-tunnel';
+/**
+ * An in-process `LogHub` over an in-memory `HubStore` that DELIVERS: a frame
+ * published on a topic is pushed to every OTHER subscriber's `receive` drain, so
+ * a peer bound to this hub wakes on a co-member's publish and pulls the log. The
+ * store owns the log semantics (append, compare-and-set on the head,
+ * `fetchTopic`); this wrapper owns the per-subscriber push fan-out the store has
+ * no notion of.
+ *
+ * The sender is excluded from its own fan-out (a publisher has already adopted
+ * what it published), matching the store's own recipient rule.
+ *
+ * The log is EPHEMERAL. It backs a group with no hub bound, where the device is
+ * the only member and so the only writer: the lane needs something to
+ * compare-and-set a head against, not a durable record. The MLS handle and the
+ * `CommitJournal` survive a restart, persisted elsewhere; these frames are never
+ * replayed, migrated, or served to another member.
+ */
+export declare function createLoopbackLogHub(store?: HubStore): LogHub;

package/lib/hub/loopback-log-hub.js

@@ -0,0 +1,178 @@
+import { createMemoryStore } from '@kumiai/hub-server';
+/**
+ * An in-process `LogHub` over an in-memory `HubStore` that DELIVERS: a frame
+ * published on a topic is pushed to every OTHER subscriber's `receive` drain, so
+ * a peer bound to this hub wakes on a co-member's publish and pulls the log. The
+ * store owns the log semantics (append, compare-and-set on the head,
+ * `fetchTopic`); this wrapper owns the per-subscriber push fan-out the store has
+ * no notion of.
+ *
+ * The sender is excluded from its own fan-out (a publisher has already adopted
+ * what it published), matching the store's own recipient rule.
+ *
+ * The log is EPHEMERAL. It backs a group with no hub bound, where the device is
+ * the only member and so the only writer: the lane needs something to
+ * compare-and-set a head against, not a durable record. The MLS handle and the
+ * `CommitJournal` survive a restart, persisted elsewhere; these frames are never
+ * replayed, migrated, or served to another member.
+ */ export function createLoopbackLogHub(store = createMemoryStore()) {
+    // topicID -> the DIDs subscribed to it.
+    const topicSubscribers = new Map();
+    // subscriberDID -> its live receive sinks (one per open `receive` drain).
+    const sinks = new Map();
+    const deliver = (message)=>{
+        const subscribers = topicSubscribers.get(message.topicID);
+        if (subscribers == null) {
+            return;
+        }
+        for (const subscriberDID of subscribers){
+            if (subscriberDID === message.senderDID) {
+                continue;
+            }
+            for (const push of sinks.get(subscriberDID) ?? []){
+                push(message);
+            }
+        }
+    };
+    return {
+        async subscribe (subscriberDID, topicID, options) {
+            await store.subscribe({
+                subscriberDID,
+                topicID,
+                ...options?.retention != null ? {
+                    retention: options.retention
+                } : {}
+            });
+            let set = topicSubscribers.get(topicID);
+            if (set == null) {
+                set = new Set();
+                topicSubscribers.set(topicID, set);
+            }
+            set.add(subscriberDID);
+        },
+        async unsubscribe (subscriberDID, topicID) {
+            await store.unsubscribe(subscriberDID, topicID);
+            topicSubscribers.get(topicID)?.delete(subscriberDID);
+        },
+        receive (subscriberDID) {
+            const queue = [];
+            let resolveNext;
+            let closed = false;
+            const push = (message)=>{
+                if (closed) {
+                    return;
+                }
+                if (resolveNext != null) {
+                    const resolve = resolveNext;
+                    resolveNext = undefined;
+                    resolve({
+                        value: message,
+                        done: false
+                    });
+                } else {
+                    queue.push(message);
+                }
+            };
+            let set = sinks.get(subscriberDID);
+            if (set == null) {
+                set = new Set();
+                sinks.set(subscriberDID, set);
+            }
+            set.add(push);
+            const remove = ()=>{
+                closed = true;
+                sinks.get(subscriberDID)?.delete(push);
+                if (resolveNext != null) {
+                    const resolve = resolveNext;
+                    resolveNext = undefined;
+                    resolve({
+                        value: undefined,
+                        done: true
+                    });
+                }
+            };
+            const iterator = {
+                next () {
+                    if (queue.length > 0) {
+                        return Promise.resolve({
+                            value: queue.shift(),
+                            done: false
+                        });
+                    }
+                    if (closed) {
+                        return Promise.resolve({
+                            value: undefined,
+                            done: true
+                        });
+                    }
+                    return new Promise((resolve)=>{
+                        resolveNext = resolve;
+                    });
+                },
+                return () {
+                    remove();
+                    return Promise.resolve({
+                        value: undefined,
+                        done: true
+                    });
+                }
+            };
+            return {
+                [Symbol.asyncIterator] () {
+                    return iterator;
+                },
+                return () {
+                    remove();
+                }
+            };
+        },
+        async publish (params) {
+            const result = await store.publish({
+                senderDID: params.senderDID,
+                topicID: params.topicID,
+                payload: params.payload,
+                ...params.retain != null ? {
+                    retain: params.retain
+                } : {},
+                ...'expectedHead' in params ? {
+                    expectedHead: params.expectedHead
+                } : {},
+                ...params.publishID != null ? {
+                    publishID: params.publishID
+                } : {}
+            });
+            // A deduped replay stored nothing and every current subscriber already saw
+            // the original — re-delivering it would apply the same commit twice.
+            if (!result.deduped) {
+                deliver({
+                    sequenceID: result.sequenceID,
+                    senderDID: params.senderDID,
+                    topicID: params.topicID,
+                    payload: params.payload,
+                    // One sequence serves both classes here, so a log frame's own sequenceID is
+                    // its position in the topic's log — the same value `fetchTopic` serves it at.
+                    // A mailbox frame carries no key: it has no place in a log, and a falsy
+                    // placeholder is a position a cursor moves to, skipping every frame below it.
+                    ...params.retain === 'log' ? {
+                        logPosition: result.sequenceID
+                    } : {}
+                });
+            }
+            return {
+                sequenceID: result.sequenceID
+            };
+        },
+        async fetchTopic (params) {
+            return await store.fetchTopic({
+                subscriberDID: params.subscriberDID,
+                topicID: params.topicID,
+                ...params.after != null ? {
+                    after: params.after
+                } : {},
+                ...params.limit != null ? {
+                    limit: params.limit
+                } : {}
+            });
+        }
+    };
+}

package/lib/hub/manager.d.ts

@@ -1,4 +1,5 @@
 import type { StoreProvider } from '@kubun/db';
+import type { Runtime } from '@sozai/runtime';
 export type Hub = {
     id: string;
     label: string | null;
@@ -12,6 +13,12 @@ export type CreateHubParams = {
     url: string;
     label?: string | null;
     serverDID?: string | null;
+    /**
+     * Host runtime, used here to mint the new hub row's id. Propagated from the
+     * caller rather than constructed: this package runs on React Native and in
+     * the browser as well as on node, where node's `crypto` is not available.
+     */
+    runtime: Runtime;
 };
 export type UpdateHubParams = {
     stores: StoreProvider;
@@ -54,46 +61,36 @@ export type ListGroupsByHubParams = {
     stores: StoreProvider;
     hubID: string;
 };
-export type CaptureServerDIDParams = {
-    stores: StoreProvider;
-    hubURL: string;
-    serverDID: string;
-};
 export type UpsertHubParams = {
     stores: StoreProvider;
     url: string;
     serverDID?: string | null;
+    /** As `CreateHubParams.runtime`. */
+    runtime: Runtime;
 };
-export declare class HubServerDIDConflictError extends Error {
-    #private;
-    constructor(params: {
-        hubID: string;
-        url: string;
-        existingServerDID: string;
-        providedServerDID: string;
-    });
-    get hubID(): string;
-    get url(): string;
-    get existingServerDID(): string;
-    get providedServerDID(): string;
-}
+/**
+ * Register a hub by URL, or return the row that URL already has.
+ *
+ * `serverDID` is a cache of the hub's current identity, not a pin, so a provided
+ * DID that differs from the recorded one simply replaces it — a hub redeployed
+ * under a new key is a routine event, and a wrong value here costs one refused
+ * connection, after which the device rediscovers the DID from the hub's `/info`.
+ * A provided null never clears a recorded DID.
+ */
 export declare function createHub(params: CreateHubParams): Promise<Hub>;
 /**
- * Idempotent register-or-pin entry-point. Applies the conflict matrix:
+ * Idempotent register-or-record entry-point. Applies the URL matrix:
  *
  * - URL not registered → insert a fresh row with `serverDID` (or null) and
  *   return it.
- * - existing row, `server_did === null`, provided null → no-op.
- * - existing row, `server_did === null`, provided DID-A → upgrade pin to
- *   DID-A.
- * - existing row, `server_did === DID-A`, provided null or matching DID-A →
- *   no-op (no silent downgrade).
- * - existing row, `server_did === DID-A`, provided DID-B → throws
- *   `HubServerDIDConflictError`. Caller must explicit `updateHub` to change
- *   a pinned DID.
+ * - existing row, provided null → no-op, whatever the row records.
+ * - existing row, provided DID-A matching the record → no-op.
+ * - existing row, provided DID-A differing from the record → record DID-A. The
+ *   recorded DID is a cache of the hub's current identity, so the newest claim
+ *   wins and a wrong one self-corrects from `/info` on the next connect.
  *
  * Unlike `createHub`, `upsertHub` takes no `label` — it is for atomic
- * register+bind paths where the inviter only ships connectivity + pin.
+ * register+bind paths where the inviter only ships connectivity + hub identity.
  */
 export declare function upsertHub(params: UpsertHubParams): Promise<Hub>;
 export declare function updateHub(params: UpdateHubParams): Promise<Hub>;
@@ -104,15 +101,3 @@ export declare function bindHubToGroup(params: BindHubToGroupParams): Promise<bo
 export declare function unbindHubFromGroup(params: UnbindHubFromGroupParams): Promise<boolean>;
 export declare function listHubsByGroup(params: ListHubsByGroupParams): Promise<Array<Hub>>;
 export declare function listGroupsByHub(params: ListGroupsByHubParams): Promise<Array<string>>;
-/**
- * TOFU capture path. Looks up the local hub row by URL and applies the
- * conflict matrix:
- * - URL not registered → no-op, returns `false`.
- * - existing `server_did` is null → upgrade to `serverDID`, returns `true`.
- * - existing `server_did` matches `serverDID` → no-op, returns `false`.
- * - existing `server_did` differs from `serverDID` → throws
- *   `HubServerDIDConflictError`. Pinned-mismatch enforcement (hard-fail
- *   before any message is delivered) lives in the transport wrapper and
- *   surfaces `HubServerDIDMismatchError` to callers.
- */
-export declare function captureServerDID(params: CaptureServerDIDParams): Promise<boolean>;

package/lib/hub/manager.js

@@ -1,30 +1,4 @@
 import { getP2PStore } from '@kubun/store-p2p';
-export class HubServerDIDConflictError extends Error {
-    #hubID;
-    #url;
-    #existingServerDID;
-    #providedServerDID;
-    constructor(params){
-        super(`hub at ${params.url} is pinned to ${params.existingServerDID}; refusing to overwrite with ${params.providedServerDID}`);
-        this.name = 'HubServerDIDConflictError';
-        this.#hubID = params.hubID;
-        this.#url = params.url;
-        this.#existingServerDID = params.existingServerDID;
-        this.#providedServerDID = params.providedServerDID;
-    }
-    get hubID() {
-        return this.#hubID;
-    }
-    get url() {
-        return this.#url;
-    }
-    get existingServerDID() {
-        return this.#existingServerDID;
-    }
-    get providedServerDID() {
-        return this.#providedServerDID;
-    }
-}
 function rowToHub(row) {
     return {
         id: row.id,
@@ -35,61 +9,76 @@ function rowToHub(row) {
         updatedAt: row.updated_at == null ? null : new Date(row.updated_at)
     };
 }
-export async function createHub(params) {
+/**
+ * Return an existing hub row, having replaced its recorded server DID when the
+ * caller supplied a different one. A provided null never clears what is there.
+ */ async function adoptServerDID(store, row, providedDID) {
+    if (providedDID == null || row.server_did === providedDID) {
+        return rowToHub(row);
+    }
+    await store.updateHub(row.id, {
+        server_did: providedDID
+    });
+    const updated = await store.getHub(row.id);
+    if (updated == null) throw new Error('Failed to read hub after adopting a server DID');
+    return rowToHub(updated);
+}
+/**
+ * Register a hub by URL, or return the row that URL already has.
+ *
+ * `serverDID` is a cache of the hub's current identity, not a pin, so a provided
+ * DID that differs from the recorded one simply replaces it — a hub redeployed
+ * under a new key is a routine event, and a wrong value here costs one refused
+ * connection, after which the device rediscovers the DID from the hub's `/info`.
+ * A provided null never clears a recorded DID.
+ */ export async function createHub(params) {
     const store = await getP2PStore(params.stores);
     const providedDID = params.serverDID ?? null;
     const existing = await store.getHubByURL(params.url);
     if (existing != null) {
-        if (existing.server_did != null && providedDID != null && existing.server_did !== providedDID) {
-            throw new HubServerDIDConflictError({
-                hubID: existing.id,
-                url: params.url,
-                existingServerDID: existing.server_did,
-                providedServerDID: providedDID
-            });
-        }
-        if (existing.server_did == null && providedDID != null) {
-            await store.updateHub(existing.id, {
-                server_did: providedDID
-            });
-            const updated = await store.getHub(existing.id);
-            if (updated == null) throw new Error('Failed to read hub after upgrade');
-            return rowToHub(updated);
-        }
-        return rowToHub(existing);
+        return await adoptServerDID(store, existing, providedDID);
+    }
+    const id = params.runtime.getRandomID();
+    try {
+        await store.insertHub({
+            id,
+            label: params.label ?? null,
+            url: params.url,
+            server_did: providedDID
+        });
+    } catch (error) {
+        // The check above and this insert are two statements against a UNIQUE url,
+        // so a concurrent register of the same hub — two groups binding it at once,
+        // an invite's `suggestedHubs` racing a manual add — makes the loser throw out
+        // of a function whose whole contract is idempotence. Adopt the winner's row
+        // instead; a failure that is not the race has no row to find and rethrows.
+        const raced = await store.getHubByURL(params.url);
+        if (raced == null) throw error;
+        return await adoptServerDID(store, raced, providedDID);
     }
-    const id = crypto.randomUUID();
-    await store.insertHub({
-        id,
-        label: params.label ?? null,
-        url: params.url,
-        server_did: providedDID
-    });
     const created = await store.getHub(id);
     if (created == null) throw new Error('Failed to read hub after insert');
     return rowToHub(created);
 }
 /**
- * Idempotent register-or-pin entry-point. Applies the conflict matrix:
+ * Idempotent register-or-record entry-point. Applies the URL matrix:
  *
  * - URL not registered → insert a fresh row with `serverDID` (or null) and
  *   return it.
- * - existing row, `server_did === null`, provided null → no-op.
- * - existing row, `server_did === null`, provided DID-A → upgrade pin to
- *   DID-A.
- * - existing row, `server_did === DID-A`, provided null or matching DID-A →
- *   no-op (no silent downgrade).
- * - existing row, `server_did === DID-A`, provided DID-B → throws
- *   `HubServerDIDConflictError`. Caller must explicit `updateHub` to change
- *   a pinned DID.
+ * - existing row, provided null → no-op, whatever the row records.
+ * - existing row, provided DID-A matching the record → no-op.
+ * - existing row, provided DID-A differing from the record → record DID-A. The
+ *   recorded DID is a cache of the hub's current identity, so the newest claim
+ *   wins and a wrong one self-corrects from `/info` on the next connect.
  *
  * Unlike `createHub`, `upsertHub` takes no `label` — it is for atomic
- * register+bind paths where the inviter only ships connectivity + pin.
+ * register+bind paths where the inviter only ships connectivity + hub identity.
  */ export async function upsertHub(params) {
     return await createHub({
         stores: params.stores,
         url: params.url,
-        serverDID: params.serverDID
+        serverDID: params.serverDID,
+        runtime: params.runtime
     });
 }
 export async function updateHub(params) {
@@ -164,35 +153,3 @@ export async function listGroupsByHub(params) {
     const store = await getP2PStore(params.stores);
     return await store.listGroupIDsByHubID(params.hubID);
 }
-/**
- * TOFU capture path. Looks up the local hub row by URL and applies the
- * conflict matrix:
- * - URL not registered → no-op, returns `false`.
- * - existing `server_did` is null → upgrade to `serverDID`, returns `true`.
- * - existing `server_did` matches `serverDID` → no-op, returns `false`.
- * - existing `server_did` differs from `serverDID` → throws
- *   `HubServerDIDConflictError`. Pinned-mismatch enforcement (hard-fail
- *   before any message is delivered) lives in the transport wrapper and
- *   surfaces `HubServerDIDMismatchError` to callers.
- */ export async function captureServerDID(params) {
-    const store = await getP2PStore(params.stores);
-    const existing = await store.getHubByURL(params.hubURL);
-    if (existing == null) {
-        return false;
-    }
-    if (existing.server_did == null) {
-        await store.updateHub(existing.id, {
-            server_did: params.serverDID
-        });
-        return true;
-    }
-    if (existing.server_did === params.serverDID) {
-        return false;
-    }
-    throw new HubServerDIDConflictError({
-        hubID: existing.id,
-        url: params.hubURL,
-        existingServerDID: existing.server_did,
-        providedServerDID: params.serverDID
-    });
-}

package/lib/hub/peer-scoped-hub-view.d.ts

@@ -0,0 +1,35 @@
+import type { MailboxHub } from '@kumiai/hub-tunnel';
+export type PeerScopedHubViewParams = {
+    /** The device-wide hub (from `createHubLike`) whose drain is shared. */
+    hub: MailboxHub;
+    /** Only frames the hub authenticated as sent by this DID are surfaced. */
+    peerDID: string;
+};
+/**
+ * A view over one device's hub that surfaces only the frames one peer sent.
+ *
+ * Every tunnel responder on a device receives on the same topic — this device's
+ * responder topic for the epoch, shared by its listeners for every co-member —
+ * so the shared drain hands each of them every peer's frames. Two hazards
+ * follow.
+ *
+ * **The filter has to run before the frames are decrypted.** MLS consumes a
+ * per-sender ratchet generation on open, so a responder that opens a frame
+ * addressed to a different peer has DESTROYED it: the responder it belonged to
+ * can never open it, and that peer's request vanishes with no error raised
+ * anywhere. Filtering already-decrypted frames leaves the defect untouched.
+ * Build this view over the device hub and hand the VIEW to the encrypting
+ * transport — never the other way around.
+ *
+ * `senderDID` is the hub's attestation, taken from the signed publisher, not an
+ * MLS-authenticated identity. That is enough: the filter routes, MLS still
+ * authorizes, and a hostile hub could only hide frames it can already drop.
+ *
+ * **`unsubscribe` is dropped.** The responder topic belongs to the (group,
+ * epoch), not to a session: every listener on the device shares it, one per
+ * co-member, and each respawns independently — so a departing transport must not
+ * take it away from them. Releasing it belongs to whoever owns the group's peer.
+ * `subscribe` is
+ * therefore issued once per topic and held for the life of the view.
+ */
+export declare function createPeerScopedHubView({ hub, peerDID }: PeerScopedHubViewParams): MailboxHub;

package/lib/hub/peer-scoped-hub-view.js

@@ -0,0 +1,92 @@
+/**
+ * A view over one device's hub that surfaces only the frames one peer sent.
+ *
+ * Every tunnel responder on a device receives on the same topic — this device's
+ * responder topic for the epoch, shared by its listeners for every co-member —
+ * so the shared drain hands each of them every peer's frames. Two hazards
+ * follow.
+ *
+ * **The filter has to run before the frames are decrypted.** MLS consumes a
+ * per-sender ratchet generation on open, so a responder that opens a frame
+ * addressed to a different peer has DESTROYED it: the responder it belonged to
+ * can never open it, and that peer's request vanishes with no error raised
+ * anywhere. Filtering already-decrypted frames leaves the defect untouched.
+ * Build this view over the device hub and hand the VIEW to the encrypting
+ * transport — never the other way around.
+ *
+ * `senderDID` is the hub's attestation, taken from the signed publisher, not an
+ * MLS-authenticated identity. That is enough: the filter routes, MLS still
+ * authorizes, and a hostile hub could only hide frames it can already drop.
+ *
+ * **`unsubscribe` is dropped.** The responder topic belongs to the (group,
+ * epoch), not to a session: every listener on the device shares it, one per
+ * co-member, and each respawns independently — so a departing transport must not
+ * take it away from them. Releasing it belongs to whoever owns the group's peer.
+ * `subscribe` is
+ * therefore issued once per topic and held for the life of the view.
+ */ export function createPeerScopedHubView({ hub, peerDID }) {
+    const armed = new Set();
+    const view = {
+        publish: (params)=>hub.publish(params),
+        subscribe: async (subscriberDID, topicID, options)=>{
+            if (armed.has(topicID)) {
+                return;
+            }
+            armed.add(topicID);
+            try {
+                await hub.subscribe(subscriberDID, topicID, options);
+            } catch (error) {
+                armed.delete(topicID);
+                throw error;
+            }
+        },
+        unsubscribe: ()=>{},
+        receive: (subscriberDID, options)=>{
+            // Forwarded, not dropped: the transport asks for its own `receiveTopicID`,
+            // and a responder handed the frames of the DIALING role on this same peer
+            // opens them — consuming the ratchet generation the dialer's own session
+            // was waiting on. Sender scope alone cannot tell those two apart.
+            const inner = hub.receive(subscriberDID, options);
+            const innerIterator = inner[Symbol.asyncIterator]();
+            const iterator = {
+                next: async ()=>{
+                    while(true){
+                        const result = await innerIterator.next();
+                        if (result.done === true) {
+                            return {
+                                value: undefined,
+                                done: true
+                            };
+                        }
+                        if (result.value.senderDID === peerDID) {
+                            return result;
+                        }
+                    }
+                },
+                return: ()=>{
+                    void innerIterator.return?.();
+                    return Promise.resolve({
+                        value: undefined,
+                        done: true
+                    });
+                }
+            };
+            return {
+                [Symbol.asyncIterator]: ()=>iterator,
+                return: ()=>{
+                    inner.return?.();
+                },
+                // Forwarded, never synthesized: a frame this view filtered out belongs to
+                // another peer's responder, and acking it here would tell the hub it was
+                // handled by a subscriber that never saw it.
+                ...inner.ack != null ? {
+                    ack: (sequenceID)=>inner.ack?.(sequenceID)
+                } : {}
+            };
+        },
+        ...hub.events != null ? {
+            events: hub.events
+        } : {}
+    };
+    return view;
+}

package/lib/hub/sender-scoped-hub-view.d.ts

@@ -0,0 +1,41 @@
+import type { MailboxHub } from '@kumiai/hub-tunnel';
+import type { DeviceHub } from './hub-like.js';
+export type SenderScopedHubViewParams = {
+    /** The device-wide hub (from `createHubLike`), whose drain every lane shares. */
+    hub: DeviceHub;
+    /** Only frames the hub authenticated as sent by this DID reach the consumer. */
+    peerDID: string;
+    /**
+     * How long a publish on this session may wait for a hub connection before it
+     * is failed. Omitted leaves the device hub's own behaviour, which is to WAIT.
+     *
+     * That wait is right for the lane it was built for: a commit authored while
+     * the hub is away should land when it returns, and the invite lane is built on
+     * it. It is wrong here. A directed session is opened because someone pressed
+     * something, and the device hub's `#ready` awaits one reconnect gate after
+     * another for as long as the hub stays down — so with no hub, `syncPeer`
+     * returned neither a result nor an error, and a screen awaiting it held its
+     * spinner indefinitely.
+     */
+    publishTimeoutMs?: number;
+};
+/**
+ * A view over one device's hub whose drain carries one peer's frames only.
+ *
+ * A device dialing two peers at once receives both answers on the same topic —
+ * its own dialer topic for the (group, epoch) — so an unfiltered drain hands
+ * each session the other's frames. Opening one consumes an MLS ratchet
+ * generation and DESTROYS it for the session it belonged to, which starves that
+ * session to its idle timeout with nothing raised anywhere.
+ *
+ * The filtering is asked of the hub rather than done here: a sink parks a
+ * single waiter, so a view that filtered by calling
+ * `next()` on the consumer's behalf would take that slot and starve the session
+ * it was meant to protect — measurably, even when it drops nothing at all. That
+ * is why this is not {@link createPeerScopedHubView}, which a RESPONDER uses:
+ * a responder's drain is long-lived and shared across its spawns, and it owns
+ * the topic subscription for its whole life. A caller's is neither, so
+ * `subscribe` and `unsubscribe` pass straight through to the session's own
+ * lifecycle.
+ */
+export declare function createSenderScopedHubView({ hub, peerDID, publishTimeoutMs, }: SenderScopedHubViewParams): MailboxHub;