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

package/dist/connect.d.ts

@@ -936,6 +936,22 @@ declare class EncryptedSession {
 interface WSTransportOptions {
     /** WebSocket URL, e.g. `ws://localhost:8787/foo`. */
     url: string;
+    /**
+     * Optional async provider for a FRESH connection URL, called before each
+     * RECONNECT. Use it when the URL carries a single-use/expiring credential
+     * (e.g. a one-time WS upgrade ticket): on reconnect the baked-in ticket is
+     * already consumed/expired, so without this the reconnect is rejected and the
+     * transport burns through its attempts. The initial connect uses `url` as-is.
+     */
+    urlProvider?: () => string | Promise<string>;
+    /**
+     * Stable identifier for this connection (a channel / space / personal-space
+     * id). Lifecycle + MESSAGE events are namespaced by it on the shared
+     * `EventCore` bus so concurrent transports (chat room A, room B, the storage
+     * feed, …) never receive each other's frames. Optional — a unique id is
+     * generated when omitted; pass a semantic one for clearer debugging.
+     */
+    id?: string;
     /** Reconnect automatically after unexpected disconnect (default `true`). */
     autoReconnect?: boolean;
     /** Delay between reconnect attempts in ms (default `3000`). */
@@ -947,12 +963,43 @@ interface WSTransportOptions {
      * throws synchronously. Default `100`.
      */
     maxQueueSize?: number;
+    /**
+     * Heartbeat interval in ms. While connected, a `pingFrame` is sent every
+     * interval to keep the socket warm (long-lived WebSockets get dropped by CF
+     * / intermediaries when idle) and to detect a silently-dead connection.
+     * Default `30000`. Set `0` to disable the heartbeat entirely.
+     */
+    heartbeatInterval?: number;
+    /**
+     * How long (ms) to wait for a `pongFrame` after sending a ping before
+     * treating the connection as dead and forcing a reconnect. Should be well
+     * under `heartbeatInterval`. Default `10000`.
+     */
+    heartbeatTimeout?: number;
+    /** Outbound keep-alive frame. Default `"ping"`. */
+    pingFrame?: string;
+    /**
+     * Inbound keep-alive ack. Matching frames are swallowed (never surfaced as a
+     * `MESSAGE`) and reset the liveness timer. Must match the server's
+     * auto-response. Default `"pong"`.
+     */
+    pongFrame?: string;
 }
 declare class WSTransport extends EventCore {
-    emit: typeof EventCore.emit;
-    on: typeof EventCore.on;
-    off: typeof EventCore.off;
+    /**
+     * Per-instance event scope. `EventCore` is a process-global static emitter,
+     * so without namespacing every WSTransport would hear every other one's
+     * frames. We prefix each event with this transport's `id` and expose
+     * `on`/`off`/`emit` that scope transparently — callers still use the plain
+     * `EventCoreEvents` enum and only ever see their own connection's events.
+     */
+    readonly id: string;
+    readonly emit: (event: EventCoreEvents, data: unknown) => void;
+    readonly on: (event: EventCoreEvents, handler: EventListener | CallableFunction) => void;
+    readonly off: (event: EventCoreEvents, handler: EventListener | CallableFunction) => void;
+    private scopedEvent;
     private url;
+    private urlProvider?;
     private socket;
     private _isConnected;
     private _isConnecting;
@@ -963,6 +1010,12 @@ declare class WSTransport extends EventCore {
     private reconnectTimeout;
     private outboundQueue;
     private maxQueueSize;
+    private heartbeatInterval;
+    private heartbeatTimeout;
+    private pingFrame;
+    private pongFrame;
+    private heartbeatTimer;
+    private pongTimer;
     constructor(opts: WSTransportOptions);
     /** Open the socket. Resolves when CONNECTED fires. Rejects on first error. */
     connect(): Promise<void>;
@@ -977,6 +1030,25 @@ declare class WSTransport extends EventCore {
     isConnecting(): boolean;
     queuedFrames(): number;
     reconnectAttemptCount(): number;
+    /** Begin the keep-alive loop (no-op when disabled). */
+    private startHeartbeat;
+    /** Stop the keep-alive loop and clear any pending liveness deadline. */
+    private stopHeartbeat;
+    /**
+     * Send one ping and arm a liveness deadline. If no `pongFrame` arrives before
+     * `heartbeatTimeout`, the connection is considered dead and we force a
+     * reconnect — this is what catches a silently-dropped TCP connection that
+     * never fired `onclose` (the failure mode that "loses connection with the
+     * Accelerator" on long sessions).
+     */
+    private sendHeartbeat;
+    /**
+     * Tear down a connection we believe is dead and kick off reconnect, without
+     * waiting on the OS/browser to eventually fire `onclose` (which a half-open
+     * socket may never do). We detach the handlers first so the normal close path
+     * can't double-fire the reconnect.
+     */
+    private forceReconnect;
     private scheduleReconnect;
     private flushQueue;
 }
@@ -1382,123 +1454,50 @@ declare class ShardClient {
 }
 
 /**
- * HTTP client for the multi-user `SharedSpaceDO` (Phase B).
- *
- * Mirrors the proven shape of `PersonalSpaceClient` — every gated call:
- *   1. POSTs `/challenge` to get a fresh nonce keyed to the caller's commitment
- *   2. Generates a Groth16 proof for the `preimagePoK` circuit with the nonce
- *      reduced into a BN254 field element as the public signal
- *   3. POSTs the operation with `{ challengeId, proof, publicSignals, ... }`
- *
- * What's different from `PersonalSpaceClient`:
- *   - Addressed by space ID, not user commitment. Multiple users can be
- *     members of the same space.
- *   - The space carries a participants list + ACL (shared types from
- *     `src/types/permissions.ts`). The server checks that the proving
- *     commitment is a participant with the requested permission before each
- *     mutation.
- *   - Stores file manifests (not generic KV blobs). The shape is constrained
- *     by `FileManifest` from `../types`.
- *
- * Wire protocol (this client implements the client side; the server side is
- * the next slice of work in accelerator):
- *
- *   POST /api/spaces                                 create a new space (gated by caller proof)
- *     body: { challengeId, proof, publicSignals, initialAcl? }
- *     returns: { spaceId }
- *
- *   POST /api/spaces/:spaceId/challenge              issue a nonce for the caller
- *     body: { commitment }
- *     returns: { challengeId, nonce }
- *
- *   POST /api/spaces/:spaceId/files                  write a file manifest
- *     body: { challengeId, proof, publicSignals, manifest }
- *     returns: { ok: true, fileId }
- *
- *   POST /api/spaces/:spaceId/files/:fileId/get      read a file manifest
- *     body: { challengeId, proof, publicSignals }
- *     returns: { manifest }
- *
- *   DELETE /api/spaces/:spaceId/files/:fileId        delete a file manifest
- *     body: { challengeId, proof, publicSignals }
- *     returns: { ok: true, existed: boolean }
- *
- *   POST /api/spaces/:spaceId/files/list             list manifests in space
- *     body: { challengeId, proof, publicSignals }
- *     returns: { files: FileStat[] }
+ * HTTP client for the gated file-manifest store on a SharedSpace
+ * (`/api/spaces/:spaceId/files`).
  *
- *   POST /api/spaces/:spaceId/participants           add a participant
- *     body: { challengeId, proof, publicSignals, participant: Participant }
- *     returns: { ok: true }
+ * A "file" in a space is its **manifest** (per-chunk keys + the SHA-256 of each
+ * global shard). The shard bytes live in the open `/api/shards` store; the
+ * manifest is the capability. This client only moves manifests in/out of the
+ * space's gated store.
  *
- *   DELETE /api/spaces/:spaceId/participants/:commitment   remove a participant
- *     body: { challengeId, proof, publicSignals }
- *     returns: { ok: true, existed: boolean }
+ * Authorization is **session-based**, consistent with the rest of the
+ * SharedSpace (keyring, websocket): the SDK's credential-stamping `fetch`
+ * (from {@link HttpClient}) attaches the app key + session token, the platform
+ * validates the session and injects a trusted `X-Muhkoo-User-Context`, and the
+ * DO authorizes on that + channel membership. There is no per-op Groth16 proof.
  *
- *   POST /api/spaces/:spaceId/acl                    set / replace an ACL entry
- *     body: { challengeId, proof, publicSignals, entry: ACLEntry }
- *     returns: { ok: true }
+ * Wire protocol (server: `SharedSpaceDO`):
+ *   POST   /api/spaces/:spaceId/files            body: { manifest }  → { ok, fileId }
+ *   GET    /api/spaces/:spaceId/files                                → { files: FileStat[] }
+ *   GET    /api/spaces/:spaceId/files/:fileId                        → { manifest }
+ *   DELETE /api/spaces/:spaceId/files/:fileId                        → { ok, existed }
  */
 
 interface SharedSpaceClientOptions {
-    /** Base URL of the accelerator. */
+    /** Base URL of the accelerator (e.g. `https://api.muhkoo.dev`). */
     baseUrl: string;
-    /** This caller's Poseidon commitment (decimal string). */
-    commitment: string;
-    /** Private witnesses for the `preimagePoK` circuit. */
-    secret: string;
-    salt: string;
-    ecdsaPub: string;
-    /** Public signal: Poseidon hash of `ecdsaPub`. */
-    ecdsaPubHash: string;
-    /** Compiled circuit assets — same files PersonalSpaceClient uses. */
-    circuits: {
-        wasmUrl: string;
-        zkeyUrl: string;
-    };
-    /** Optional custom fetch (defaults to `globalThis.fetch`). */
+    /**
+     * Credential-stamping fetch — pass {@link HttpClient.fetch} so requests
+     * carry the app key + session token. Defaults to `globalThis.fetch`
+     * (unauthenticated; only useful in tests).
+     */
     fetch?: typeof fetch;
 }
 declare class SharedSpaceClient {
     private readonly baseUrl;
-    private readonly commitment;
-    private readonly secret;
-    private readonly salt;
-    private readonly ecdsaPub;
-    private readonly ecdsaPubHash;
-    private readonly wasmUrl;
-    private readonly zkeyUrl;
     private readonly fetchFn;
     constructor(opts: SharedSpaceClientOptions);
-    /**
-     * Create a brand new space. The caller becomes the owner; `initialAcl`
-     * adds any additional ACL entries up front (e.g. inviting a co-owner at
-     * creation time).
-     */
-    createSpace(initialAcl?: ACLEntry[]): Promise<{
-        spaceId: string;
-    }>;
-    /** Write a file manifest into the space. Requires `write` permission. */
+    /** Write a file manifest into the space. Requires space membership. */
     writeFileManifest(spaceId: string, manifest: FileManifest): Promise<void>;
-    /** Read a file manifest by id. Requires `read` permission. */
+    /** Read a file manifest by id. Requires space membership. */
     readFileManifest(spaceId: string, fileId: string): Promise<FileManifest>;
-    /** Delete a file manifest by id. Requires `delete` permission. */
+    /** Delete a file manifest by id. Requires space membership. */
     deleteFileManifest(spaceId: string, fileId: string): Promise<boolean>;
-    /** List file summaries in the space. Requires `read` permission. */
+    /** List file summaries in the space. Requires space membership. */
     listFiles(spaceId: string): Promise<FileStat[]>;
-    /** Add a participant. Requires `invite` or `admin`. */
-    addParticipant(spaceId: string, participant: Participant): Promise<void>;
-    /** Remove a participant by their public-key identity. Requires `admin`. */
-    removeParticipant(spaceId: string, participantCommitment: string): Promise<boolean>;
-    /** Set / replace an ACL entry. Requires `admin`. */
-    setACLEntry(spaceId: string, entry: ACLEntry): Promise<void>;
-    /** Request a challenge for `spaceId` and generate the matching proof. */
-    private proveFreshChallenge;
-    /**
-     * Hit `/challenge`. The body includes the caller's commitment so the
-     * server can scope the issued nonce to this principal.
-     */
-    private requestChallenge;
+    private filesBase;
     private jsonRequest;
 }
 
@@ -1596,6 +1595,12 @@ interface WriteToShardsInput {
      * resumable uploads: the same id always maps to the same manifest slot.
      */
     fileId?: string;
+    /**
+     * Optional upload-progress callback, invoked after each chunk finishes
+     * (`completed` of `total` chunks). Lets a UI show a progress bar. Called once
+     * with `(0, total)` before the first chunk so a bar can render immediately.
+     */
+    onProgress?: (completed: number, total: number) => void;
 }
 declare class FileStorage {
     private readonly space;
@@ -2158,6 +2163,30 @@ declare class ZkAuth {
      * both the session and the identity are stored on the client.
      */
     login(username: string, password: string, opts?: LoginOptions): Promise<AuthUser>;
+    /**
+     * Silently re-authenticate the current user without prompting for a
+     * password. Only possible while the client is **unlocked** — i.e. the
+     * derived {@link ZkIdentity} (secret + keypairs) is still in memory from a
+     * prior `login()`/`unlock()`. Re-runs the full challenge→proof→authenticate
+     * dance with that in-memory identity and swaps in the fresh token.
+     *
+     * Returns `true` if a new session was minted, `false` if recovery isn't
+     * possible (no active user, or locked — the identity was never derived or
+     * was lost on reload). A `false` result is the app's cue to send the user
+     * back to the login screen.
+     *
+     * Used automatically by the {@link Client} when a token-gated request comes
+     * back `401` (stale/expired token), so transient session expiry self-heals
+     * instead of surfacing errors mid-session.
+     */
+    recover(): Promise<boolean>;
+    /**
+     * Shared sign-in core: prove knowledge of `identity` against a fresh
+     * challenge and persist the resulting session + identity. Used by both
+     * `login()` (identity derived from a password) and `recover()` (identity
+     * already in memory).
+     */
+    private proveAndStore;
     /**
      * Restore a persisted session on boot. Validates the stored token with the
      * accelerator; returns the user when valid, or `null` (and clears the
@@ -2231,6 +2260,18 @@ interface HttpClientOptions {
     getSessionToken?: () => string | null;
     /** Custom fetch — defaults to `globalThis.fetch`. */
     fetch?: typeof fetch;
+    /**
+     * Called when a token-gated request comes back `401` (stale/expired
+     * session). Should attempt to silently re-establish a session and resolve
+     * `true` if it succeeded (the request is then retried once with the fresh
+     * token) or `false` if it couldn't (the `401` propagates as an
+     * {@link HttpError}). Wired by {@link Client} to `auth.zk.recover()`.
+     *
+     * Only consulted by the JSON helpers (`get`/`post`/`del`); the raw
+     * {@link fetch} passes 401s straight through so the auth wire calls that
+     * power recovery itself can't recurse.
+     */
+    onUnauthorized?: () => Promise<boolean>;
 }
 /** Thrown for any non-2xx accelerator response. Carries the HTTP status. */
 declare class HttpError extends Error {
@@ -2242,6 +2283,7 @@ declare class HttpClient {
     readonly baseUrl: string;
     private readonly apiKey;
     private readonly getSessionToken;
+    private readonly onUnauthorized;
     private readonly fetchFn;
     constructor(opts: HttpClientOptions);
     /**
@@ -2252,19 +2294,20 @@ declare class HttpClient {
     readonly fetch: typeof fetch;
     get<T = unknown>(path: string): Promise<T>;
     post<T = unknown>(path: string, body?: unknown): Promise<T>;
+    patch<T = unknown>(path: string, body?: unknown): Promise<T>;
     del<T = unknown>(path: string, body?: unknown): Promise<T>;
     private request;
 }
 
 /**
- * `client.storage` — per-user persistent storage backed by the accelerator's
- * personal space.
+ * `client.kv` — per-user key/value storage backed by the accelerator's personal
+ * space.
  *
- *   await client.storage.set('todos', id, { title, completed })
- *   const todo = await client.storage.get('todos', id)
- *   const ids  = await client.storage.list('todos')
- *   await client.storage.delete('todos', id)
- *   const off  = client.storage.on('change', e => …)   // realtime, cross-device
+ *   await client.kv.set('todos', id, { title, completed })
+ *   const todo = await client.kv.get('todos', id)
+ *   const ids  = await client.kv.list('todos')
+ *   await client.kv.delete('todos', id)
+ *   const off  = client.kv.on('change', e => …)   // realtime, cross-device
  *
  * A *collection* is a key namespace within the user's space; the stored key is
  * `${collection}/${id}`. Operations are authorized by the user's session token
@@ -2272,13 +2315,15 @@ declare class HttpClient {
  *
  * Values are encrypted at rest by default ({@link StorageCipher}, an AES-GCM
  * key derived from the ZK identity); pass `{ encrypt: false }` to store
- * plaintext. The realtime feed rides the personal space's own websocket, so no
- * separate transport is involved.
+ * plaintext. The realtime feed rides the personal space's websocket over a
+ * {@link WSTransport} (heartbeat keep-alive + auto-reconnect, event-namespaced
+ * so it doesn't cross wires with chat/space transports).
  *
- * `query()` is intentionally deferred — see the SDK overhaul plan.
+ * For **files** (blobs), use `client.storage` instead — `client.kv` is for
+ * small structured values. `query()` is intentionally deferred.
  */
 
-interface StorageNamespaceDeps {
+interface KvNamespaceDeps {
     http: HttpClient;
     session: SessionState;
     /** WebSocket base (ws/wss) for the change feed; derived from baseUrl. */
@@ -2295,11 +2340,11 @@ interface StorageChangeEvent<T = unknown> {
     /** The decrypted value for `set`; `null` for `delete`. */
     data: T | null;
 }
-declare class StorageNamespace {
+declare class KvNamespace {
     private readonly deps;
     private cipher;
     private cipherIdentity;
-    constructor(deps: StorageNamespaceDeps);
+    constructor(deps: KvNamespaceDeps);
     /** Store `value` under `collection`/`id` (encrypted at rest by default). */
     set<T = unknown>(collection: string, id: string, value: T, opts?: SetOptions): Promise<void>;
     /** Fetch the value at `collection`/`id`, or `null` if absent. */
@@ -2328,6 +2373,100 @@ declare class StorageNamespace {
     private getCipher;
 }
 
+/**
+ * `client.storage` — file storage. Hides the `FileStorage` / `ShardClient` /
+ * `SharedSpaceClient` primitives behind the unified client.
+ *
+ *   const { stat, manifest } = await client.storage.writeFile({ spaceId, data, metadata })
+ *   const { data }          = await client.storage.readFile(spaceId, fileId)
+ *   const files             = await client.storage.listFiles()          // my shared files
+ *   const files             = await client.storage.listFiles({ spaceId }) // a space's files
+ *   await client.storage.deleteFile(spaceId, fileId)
+ *
+ * Model:
+ *   - **Files are written to a SharedSpace** (never the personal space). A file
+ *     is its manifest (per-chunk keys + global shard hashes); the manifest lives
+ *     in the space's gated, metered `/files` store, the shard ciphertext in the
+ *     global open `/api/shards` store.
+ *   - **The manifest is the capability** — anyone holding it reads the file from
+ *     the global shards, anywhere ({@link readByManifest}). Share a file by
+ *     sharing its manifest.
+ *   - **Personal discovery mirror** — on a successful write the SDK also records
+ *     the manifest in the user's `client.kv` under a reserved collection, so
+ *     {@link listFiles} (no `spaceId`) can show "files I've shared" without
+ *     enumerating spaces. The mirror is unmetered and is NOT a write path.
+ *
+ * For small structured values use `client.kv` instead.
+ */
+
+interface FileNamespaceDeps {
+    http: HttpClient;
+    baseUrl: string;
+    /** Used for the unmetered personal discovery mirror. */
+    kv: KvNamespace;
+    /**
+     * Optional pre-compiled Reed–Solomon WASM module. Defaults to the bundled
+     * loader; pass one where the bundled loader path isn't available (vitest,
+     * deploy-time-precompiled environments). Forwarded to {@link FileStorage}.
+     */
+    rsWasmModule?: WebAssembly.Module;
+}
+interface WriteFileOptions {
+    /** SharedSpace the file is written to (obtain via `client.space`). */
+    spaceId: string;
+    data: Uint8Array | Blob | File;
+    metadata: {
+        name: string;
+        type: string;
+        path?: string;
+        lastModified?: number;
+    };
+}
+declare class StorageNamespace {
+    private readonly deps;
+    private fileStorage;
+    constructor(deps: FileNamespaceDeps);
+    /**
+     * Write a file to a SharedSpace: shard ciphertext → the global store, the
+     * manifest → the space's gated store, and a mirror copy → the caller's
+     * personal index. Returns the `stat` and the `manifest` (share the manifest
+     * to let others read the file).
+     */
+    writeFile(input: WriteFileOptions): Promise<{
+        stat: FileStat;
+        manifest: FileManifest;
+    }>;
+    /** Read a file from its space (resolves the manifest, then the shards). */
+    readFile(spaceId: string, fileId: string): Promise<{
+        data: Uint8Array;
+        stat: FileStat;
+    }>;
+    /**
+     * Read a file straight from a manifest — the capability path. No space
+     * membership needed; this is how a shared file is opened.
+     */
+    readByManifest(manifest: FileManifest): Promise<{
+        data: Uint8Array;
+        stat: FileStat;
+    }>;
+    /**
+     * List files. With no argument, returns the caller's own shared files from
+     * the personal mirror; with `{ spaceId }`, lists that space's files.
+     */
+    listFiles(opts?: {
+        spaceId?: string;
+    }): Promise<FileStat[]>;
+    /** Delete a file from its space and remove the personal mirror entry. */
+    deleteFile(spaceId: string, fileId: string): Promise<boolean>;
+    /** Read a manifest verbatim (e.g. to share a file). */
+    getManifest(spaceId: string, fileId: string): Promise<FileManifest>;
+    private fs;
+    private _shards;
+    private shards;
+    private _space;
+    private space;
+}
+
 /**
  * Shared types for the Space fan-out group-encryption layer.
  *
@@ -2393,6 +2532,23 @@ interface RosterMember {
     /** Base64url-encoded JWK of the member's identity ECDSA public key. */
     identityEcdsaPub?: string;
 }
+/** A shareable invite link to a space. Redeeming it allowlists the holder so
+ *  the keeper admits them. */
+interface InviteLink {
+    /** The capability token; embed in a URL to share. */
+    token: string;
+    /** Member id (username) that created the link. */
+    createdBy?: string;
+    createdAt?: number;
+    /** Epoch ms when the link stops working; 0 = never. */
+    expiresAt?: number;
+    /** Max redemptions; 0 = unlimited. */
+    maxUses?: number;
+    /** Redemptions so far. */
+    uses?: number;
+    /** Access level granted to redeemers ("viewer" | "editor"). */
+    role?: string;
+}
 
 /**
  * PacketCipher — the strategy `Network` uses to seal/open a packet's payload.
@@ -2631,8 +2787,35 @@ interface SpaceMessageEvent {
     channel: string;
     epoch: number;
     contentType?: string;
+    /**
+     * Server storage handle — the monotonic server timestamp this message is
+     * persisted under (`msg:<handle>`). Stable across history replay; pass it to
+     * {@link Space.editMessage} / {@link Space.deleteMessage} to mutate the
+     * persisted entry. Carried on edit events too (same handle as the original).
+     */
+    handle: number;
     message: Message;
 }
+/**
+ * An inbound ephemeral signal — an application broadcast the server relays to
+ * the room but never persists (no history). Rides the generic `pub` relay:
+ * `subject` is an app-defined routing key, `data` is opaque app JSON, and
+ * `from` is the server-authenticated sender. Typing indicators, presence pings,
+ * live cursors, etc. are built on top of this in the app layer — the SDK and
+ * server stay domain-agnostic.
+ */
+interface EphemeralEvent {
+    /** Server-stamped authenticated sender. */
+    from: string;
+    /** Application-defined routing key (e.g. "typing"). */
+    subject: string;
+    /** Opaque application payload. */
+    data: unknown;
+}
+/** A server-authoritative deletion of the persisted message at `handle`. */
+interface MessageDeletedEvent {
+    handle: number;
+}
 interface SpaceDeps {
     /** Transport room id. For fan-out spaces this is the encoded space pubkey. */
     name: string;
@@ -2715,6 +2898,38 @@ declare class Space {
     }): Promise<void>;
     /** Subscribe to decrypted fan-out messages. Returns an unsubscribe fn. */
     onMessage(handler: (e: SpaceMessageEvent) => void): () => void;
+    /**
+     * Edit a persisted message IN PLACE, addressed by its server
+     * {@link SpaceMessageEvent.handle}. Re-seals `payload` and asks the server
+     * to replace the stored entry; the server authorizes against the original
+     * author. Receivers get an {@link onMessageEdited} event carrying the new
+     * content at the same handle. This is a generic persisted-item edit — the
+     * server has no notion of what the payload means.
+     */
+    editMessage(handle: number, payload: unknown, opts?: {
+        channel?: string;
+        contentType?: string;
+    }): Promise<void>;
+    /**
+     * Hard-delete a persisted message by its server {@link SpaceMessageEvent.handle}
+     * — the ciphertext is removed from storage. Server authorizes against the
+     * original author. Receivers get an {@link onMessageDeleted} event.
+     */
+    deleteMessage(handle: number): Promise<void>;
+    /** Subscribe to in-place edits of persisted messages (new content at the same handle). */
+    onMessageEdited(handler: (e: SpaceMessageEvent) => void): () => void;
+    /** Subscribe to deletions of persisted messages. */
+    onMessageDeleted(handler: (e: MessageDeletedEvent) => void): () => void;
+    /**
+     * Broadcast an ephemeral, never-persisted signal to the room over the
+     * generic `pub` relay. `subject` is an app-defined routing key; `data` is
+     * opaque. The transport stays domain-agnostic — app concepts like typing
+     * 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: string, data: unknown): void;
+    /** Subscribe to inbound ephemeral signals. `from` is the authenticated sender. */
+    onEphemeral(handler: (e: EphemeralEvent) => void): () => void;
     /** Subscribe to inbound join requests (for a key-holder to admit). */
     onJoinRequest(handler: (req: JoinRequest) => void): () => void;
     /**
@@ -2747,7 +2962,9 @@ declare class Space {
         memberId: string;
         identityEcdhPub: string;
     }>): Promise<number>;
-    putFile(file: File | Blob | Uint8Array, metadata: SpaceFileMetadata): Promise<{
+    putFile(file: File | Blob | Uint8Array, metadata: SpaceFileMetadata, opts?: {
+        onProgress?: (completed: number, total: number) => void;
+    }): Promise<{
         manifest: FileManifest;
         stat: FileStat;
     }>;
@@ -2759,10 +2976,18 @@ declare class Space {
     /** Wire the RAW_FRAME handler that drives fan-out events. */
     private wireFanout;
     private onRawFrame;
+    /**
+     * Seal `payload` once with the current group key + sign it, returning the
+     * serialized `Packet` string. Shared by send (a new message) and edit
+     * (replacement content for an existing handle). Requires a keyring.
+     */
+    private sealMessage;
     /**
      * Decode one persisted/broadcast frame into a SpaceMessageEvent.
      * `isRawFrame` true means `input` is the already-extracted `spaceMessage`
-     * packet string; false means it's the full `{spaceMessage, name, ...}` frame.
+     * packet string (and `serverTs` carries the message's storage handle from
+     * the enclosing frame); false means `input` is the full
+     * `{spaceMessage, name, timestamp}` frame and the handle is read from it.
      */
     private decodeFrame;
     /**
@@ -2945,6 +3170,40 @@ declare class SpaceNamespace {
     joinChannel(name: string, opts?: {
         timeoutMs?: number;
     }): Promise<Space>;
+    /** Mint a shareable invite link for a space. `opts.expiresInSec` / `maxUses`
+     *  bound it (0/undefined = unlimited); `opts.role` ("viewer"|"editor") is the
+     *  access granted to redeemers (default viewer). Returns the link. */
+    createInviteLink(spaceId: string, opts?: {
+        expiresInSec?: number;
+        maxUses?: number;
+        role?: string;
+    }): Promise<InviteLink>;
+    /** Set a member's role on a space ("viewer" | "editor"). Owner-only. */
+    setMemberRole(spaceId: string, username: string, role: string): Promise<void>;
+    /** Roster with roles (owner/members only). */
+    members(spaceId: string): Promise<Array<{
+        memberId: string;
+        role: string;
+    }>>;
+    /** List a space's active invite links (creator/members only). */
+    listInviteLinks(spaceId: string): Promise<InviteLink[]>;
+    /** Revoke an invite link by token. */
+    revokeInviteLink(spaceId: string, token: string): Promise<void>;
+    /**
+     * Join a space using an invite link: redeem the token (the keeper admits
+     * this member), then connect and resolve once the group key arrives.
+     * Returns the open {@link Space}.
+     */
+    joinByInvite(spaceId: string, token: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<Space>;
+    /** The current member roster of a space (member id → identity public keys). */
+    roster(spaceId: string): Promise<Array<{
+        memberId: string;
+        identityEcdhPub: string;
+        identityEcdsaPub?: string;
+    }>>;
+    private keyringFor;
     private build;
     /** Ensure the member has an identity keypair; return its public ECDH + ECDSA keys. */
     private ensureIdentity;
@@ -2953,6 +3212,236 @@ declare class SpaceNamespace {
     private myId;
 }
 
+/**
+ * `client.agents` — manage an app's **Programmable Agents** (server-side
+ * "virtual users" backed by Workers AI).
+ *
+ *   const { config } = await client.agents.create(appId, {
+ *     handle: '@assistant', displayName: 'Assistant',
+ *     systemPrompt: 'You are a helpful teammate in this Space.',
+ *     triggers: [{ type: 'mention' }],
+ *   });
+ *   await client.agents.enable(appId, config.agentId, spaceId);  // per-Space opt-in
+ *
+ * These are MANAGEMENT calls — the agent itself runs on the accelerator. Only an
+ * app's owner or an editor of its shared Space may create/update/enable an agent
+ * (viewers can read). Authorization rides the user session token; non-owner
+ * editors pass their management Space via `opts.space`.
+ *
+ * v1 is "prompts + persona": a system prompt, a model, named prompt `skills`,
+ * and `triggers` that decide when the agent speaks. No tools, no code.
+ */
+
+type AgentTriggerType = "mention" | "keyword" | "regex" | "always";
+interface AgentTrigger {
+    type: AgentTriggerType;
+    /** Required for `keyword` (case-insensitive substring) and `regex`. */
+    pattern?: string;
+    /** Name of a {@link AgentSkill} to run on match. */
+    skill?: string;
+}
+interface AgentSkill {
+    name: string;
+    prompt: string;
+}
+interface AgentConfig {
+    agentId: string;
+    /** @-mention target, e.g. "@assistant". */
+    handle: string;
+    displayName: string;
+    model: string;
+    systemPrompt: string;
+    skills: AgentSkill[];
+    triggers: AgentTrigger[];
+    /** Space ids this agent is enabled on (per-Space opt-in). */
+    enabledSpaces: string[];
+    caps: {
+        dailyTokenBudget: number;
+    };
+    createdAt: number;
+    updatedAt: number;
+}
+/** The editor-settable fields when creating an agent. */
+interface AgentCreateInput {
+    handle: string;
+    displayName: string;
+    systemPrompt: string;
+    model?: string;
+    skills?: AgentSkill[];
+    triggers?: AgentTrigger[];
+    caps?: {
+        dailyTokenBudget: number;
+    };
+}
+type AgentUpdateInput = Partial<AgentCreateInput>;
+/** Create/get response — the config plus the agent's published identity keys. */
+interface AgentProvisioned {
+    config: AgentConfig;
+    /** The agent's Space member id (`__agent__:<agentId>`). */
+    memberId: string;
+    /** base64url-JWK identity ECDH public key (null until provisioned). */
+    ecdhPub: string | null;
+    /** base64url-JWK identity ECDSA public key — verifies the agent's messages. */
+    ecdsaPub: string | null;
+}
+interface AgentsNamespaceDeps {
+    http: HttpClient;
+}
+/** Common option: a management Space for delegated (non-owner) access. */
+interface AgentScopeOpts {
+    space?: string;
+}
+declare class AgentsNamespace {
+    private readonly deps;
+    constructor(deps: AgentsNamespaceDeps);
+    /** List the app's agents. */
+    list(appId: string, opts?: AgentScopeOpts): Promise<AgentConfig[]>;
+    /** Read one agent (config + identity keys). */
+    get(appId: string, agentId: string, opts?: AgentScopeOpts): Promise<AgentProvisioned>;
+    /** Create an agent (owner/editor only). */
+    create(appId: string, input: AgentCreateInput, opts?: AgentScopeOpts): Promise<AgentProvisioned>;
+    /** Update an agent's editor-settable fields (owner/editor only). */
+    update(appId: string, agentId: string, patch: AgentUpdateInput, opts?: AgentScopeOpts): Promise<{
+        config: AgentConfig;
+    }>;
+    /** Delete an agent (owner/editor only). */
+    delete(appId: string, agentId: string, opts?: AgentScopeOpts): Promise<{
+        deleted: boolean;
+    }>;
+    /** Enable the agent on a Space (per-Space opt-in). */
+    enable(appId: string, agentId: string, spaceId: string, opts?: AgentScopeOpts): Promise<{
+        config: AgentConfig;
+    }>;
+    /** Disable the agent on a Space. */
+    disable(appId: string, agentId: string, spaceId: string, opts?: AgentScopeOpts): Promise<{
+        config: AgentConfig;
+    }>;
+    private path;
+}
+
+/**
+ * `client.functions` — manage an app's **serverless functions** (developer-
+ * authored code that runs on the accelerator).
+ *
+ *   const { config } = await client.functions.deploy(appId, {
+ *     name: 'hello', displayName: 'Hello',
+ *     code: `export default { fetch: () => new Response('hi') }`,
+ *     triggers: { http: { enabled: true } },
+ *   });
+ *   // HTTP-reachable at  hello--<slug>.fns.muhkoo.dev
+ *   await client.functions.enable(appId, config.functionId, spaceId); // Space-bound
+ *
+ * These are MANAGEMENT calls — the function itself runs on the accelerator
+ * (uploaded just-in-time, decrypted only at invocation). Only an app's owner or
+ * an editor of its shared Space may deploy/update/enable (viewers read).
+ * Authorization rides the user session token; non-owner editors pass their
+ * management Space via `opts.space`.
+ *
+ * v1 is "compute-only": a function is an untrusted single-module ES worker
+ * (`export default { fetch }`) with NO platform bindings — it reaches the
+ * platform as an external client (the end-user session is passed through). Two
+ * triggers: `http` (its own subdomain) and `space` (invoked on Space messages,
+ * like a Programmable Agent).
+ */
+
+type FunctionTriggerType = "keyword" | "regex" | "always";
+interface FunctionTrigger {
+    type: FunctionTriggerType;
+    /** Required for `keyword` (case-insensitive substring) and `regex`. */
+    pattern?: string;
+}
+interface FunctionTriggers {
+    /** HTTP-invocable at `<name>--<slug>.fns.<zone>`. */
+    http?: {
+        enabled: boolean;
+        methods?: string[];
+    };
+    /** Invoked on matching Space messages (per-Space opt-in via enable). */
+    space?: {
+        match: FunctionTrigger[];
+    };
+}
+interface FunctionCaps {
+    /** Per-invocation CPU ceiling (ms). */
+    cpuMs: number;
+    /** Per-invocation subrequest ceiling. */
+    subRequests: number;
+    /** Hard daily invocation cap (0 = unlimited). */
+    dailyInvocationBudget: number;
+}
+interface FunctionConfig {
+    functionId: string;
+    /** DNS-safe slug — the function's subdomain label + WfP script name part. */
+    name: string;
+    displayName: string;
+    triggers: FunctionTriggers;
+    /** Space ids this function is enabled on (per-Space opt-in for `space`). */
+    enabledSpaces: string[];
+    caps: FunctionCaps;
+    scriptName: string;
+    /** sha-256 of the last-deployed source. */
+    codeHash?: string;
+    /** When the source was last (re)deployed. */
+    deployedAt?: number;
+    createdAt: number;
+    updatedAt: number;
+}
+/** The editor-settable fields when deploying a function. */
+interface FunctionDeployInput {
+    name: string;
+    displayName: string;
+    /** Raw single-module ES worker source (`export default { fetch }`). */
+    code: string;
+    triggers?: FunctionTriggers;
+    caps?: Partial<FunctionCaps>;
+}
+/** Update input — any subset, including new `code` to redeploy. */
+type FunctionUpdateInput = Partial<FunctionDeployInput>;
+interface FunctionsNamespaceDeps {
+    http: HttpClient;
+}
+/** Common option: a management Space for delegated (non-owner) access. */
+interface FunctionScopeOpts {
+    space?: string;
+}
+declare class FunctionsNamespace {
+    private readonly deps;
+    constructor(deps: FunctionsNamespaceDeps);
+    /** List the app's functions. */
+    list(appId: string, opts?: FunctionScopeOpts): Promise<FunctionConfig[]>;
+    /** Read one function's config. */
+    get(appId: string, functionId: string, opts?: FunctionScopeOpts): Promise<{
+        config: FunctionConfig;
+    }>;
+    /** Read a function's decrypted source (owner/editor; for the editor UI). */
+    code(appId: string, functionId: string, opts?: FunctionScopeOpts): Promise<{
+        functionId: string;
+        code: string;
+        codeHash: string | null;
+    }>;
+    /** Deploy (create) a function (owner/editor only). */
+    deploy(appId: string, input: FunctionDeployInput, opts?: FunctionScopeOpts): Promise<{
+        config: FunctionConfig;
+    }>;
+    /** Update a function's editor-settable fields and/or redeploy its `code`. */
+    update(appId: string, functionId: string, patch: FunctionUpdateInput, opts?: FunctionScopeOpts): Promise<{
+        config: FunctionConfig;
+    }>;
+    /** Delete a function (owner/editor only). */
+    delete(appId: string, functionId: string, opts?: FunctionScopeOpts): Promise<{
+        deleted: boolean;
+    }>;
+    /** Enable the function on a Space (per-Space opt-in for the `space` trigger). */
+    enable(appId: string, functionId: string, spaceId: string, opts?: FunctionScopeOpts): Promise<{
+        config: FunctionConfig;
+    }>;
+    /** Disable the function on a Space. */
+    disable(appId: string, functionId: string, spaceId: string, opts?: FunctionScopeOpts): Promise<{
+        config: FunctionConfig;
+    }>;
+    private path;
+}
+
 /** The hosted Muhkoo Accelerator — the default {@link ClientOptions.baseUrl}. */
 declare const DEFAULT_BASE_URL = "https://api.muhkoo.dev";
 interface ClientOptions {
@@ -2990,19 +3479,48 @@ declare class Client {
     readonly baseUrl: string;
     /** Authentication — `client.auth.zk.login(...)`, etc. */
     readonly auth: AuthNamespace;
-    /** Per-user persistent storage — `client.storage.set(...)`, etc. */
+    /** Per-user key/value storage — `client.kv.set(...)`, etc. */
+    readonly kv: KvNamespace;
+    /** File storage — `client.storage.writeFile(...)`, etc. */
     readonly storage: StorageNamespace;
     /** Realtime messaging — `client.message.subscribe(...)`, etc. */
     readonly message: MessageNamespace;
     /** Fan-out group spaces — `client.space.createSpace(...)`, etc. */
     readonly space: SpaceNamespace;
+    /** Programmable Agents — `client.agents.create(appId, …)`, etc. */
+    readonly agents: AgentsNamespace;
+    /** Serverless functions — `client.functions.deploy(appId, …)`, etc. */
+    readonly functions: FunctionsNamespace;
     private readonly session;
     private readonly http;
+    /** Subscribers notified when a session expires and can't be recovered. */
+    private readonly sessionExpiredHandlers;
+    /** Shared in-flight recovery so a burst of 401s triggers one re-auth. */
+    private recoverInFlight;
     constructor(options?: ClientOptions);
     /** The currently signed-in user, or `null`. */
     get user(): AuthUser | null;
     /** Whether a token-bearing session is active. */
     get isAuthenticated(): boolean;
+    /**
+     * Subscribe to session expiry that couldn't be silently recovered (the
+     * user's identity wasn't in memory to re-prove — typically after a reload
+     * where only the token was persisted, and that token has since gone stale).
+     * This is the signal to send the user back to the login screen.
+     *
+     * Returns an unsubscribe function.
+     *
+     *   const off = client.onSessionExpired(() => router.push('/login'));
+     */
+    onSessionExpired(handler: () => void): () => void;
+    /**
+     * Attempt a silent re-auth of the current user. Concurrent callers share a
+     * single in-flight attempt (a stale token usually 401s several requests at
+     * once — we re-auth once, not once per request). On failure the
+     * session-expired event fires so the app can react. Exposed so apps can
+     * also drive recovery proactively (e.g. on `visibilitychange`).
+     */
+    recoverSession(): Promise<boolean>;
 }
 
 /**
@@ -3040,8 +3558,30 @@ declare class KeyringClient implements KeyringTransport {
         epoch: number;
     }>;
     invite(username: string): Promise<void>;
+    createInviteLink(opts?: {
+        expiresInSec?: number;
+        maxUses?: number;
+        role?: string;
+    }): Promise<InviteLink>;
+    listInviteLinks(): Promise<InviteLink[]>;
+    /** Set a member's role ("viewer" | "editor"). Owner-only on the server. */
+    setMemberRole(username: string, role: string): Promise<void>;
+    /** Roster with roles (owner/members only). */
+    members(): Promise<Array<{
+        memberId: string;
+        role: string;
+    }>>;
+    revokeInviteLink(token: string): Promise<void>;
+    /** Redeem a link: the server allowlists this member and asks the keeper to
+     *  wrap the group key for their identity. Caller must be authenticated. */
+    redeemInvite(req: {
+        token: string;
+        identityEcdhPub: string;
+        identityEcdsaPub?: string;
+        desiredEpoch?: number;
+    }): Promise<void>;
     fetchMetadata(): Promise<SpaceMetadata | null>;
 }
 
-export { AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, AES_GCM_TAG_BYTES, AuthClient, AuthNamespace, AuthPublicInput, Authenticator, BroadcastChannel, BroadcastChannelEvents, ChannelExistsError, ChannelNotFoundError, ChunkCipher, Client, DEFAULT_BASE_URL, DoubleRatchet, DoubleRatchetCipher, DoubleRatchetManager, EncryptedSession, EventCore, EventCoreEvents, Field, Field as FieldElement, FileStorage, HashKnowledge, HttpClient, HttpError, KEEPER_MEMBER_ID, KeyStore, KeyringClient, LocalStorageSessionStore, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, PBKDF2_DEFAULT_ITERATIONS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PersonalSpaceClient, Poseidon, PreimagePoK, ReedSolomonCodec, Space as Room, SerializeMessage, SessionState, ShardClient, SharedSpaceClient, Space, SpaceKeyring, SpaceNamespace, SpacePacketCipher, StorageNamespace, WSTransport, ZkAuth, buildCommitment, compilePrograms, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultSessionStore, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, encodeToHex, encryptAesGcm, exportPublicKeyBase64, exportPublicKeyHex, generateAuthProof, getSubtle, initBn128Wasm, initRsWasm, initializeCircuits, manifestToStat, poseidonHash, quickVerify, randomBytes, shardHash, signMessage, toField, unwrapWithPassphrase, verify, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase };
-export type { ACL, ACLEntry, AuthClientOptions, AuthKeyPair, AuthSuccess, AuthToken, AuthType, AuthUser, Bn128WasmInstance, BroadcastChannelEvent, BroadcastChannelOptions, ChannelLike, ChunkKeyMaterial, ChunkManifest, CipherFrame, CipherMessage, CipherMessageHeader, CircuitBufferConfig, CircuitUrls, ClientOptions, DehydratedKeypair, DehydratedKeys, DoubleRatchetCipherDeps, ECDHCurve, EncodeResult, EpochKeyProvider, FileManifest, FileStat, FileStorageOptions, Groth16Proof, HttpClientOptions, IncomingFrame, KeyExchangeFrame, KeyPair, Keypair, KeyringClientDeps, KeyringTransport, LoginOptions, MessageBody, MessageEvent, MessageHeaders, MessageNamespaceDeps, MessageOptions, MessageSubscription, MuhkooMessageEvent, OAuthProvider, PacketCipher, PacketHeaders, PacketOptions, Participant, Permission, PermissionCheckRequest, PermissionCheckResult, PersonalSpaceClientOptions, PublicKeyJWK, RatchetState, ReceiveResult, RegisterParams, Role, SpaceDeps as RoomDeps, SpaceFileMetadata as RoomFileMetadata, SealedHeaders, Session, SessionOptions, SessionStore, SetOptions, ShardClientOptions, SharedSpaceClientOptions, SnarkProof, SpaceChannelLike, SpaceDeps, SpaceFileMetadata, SpaceKeyCache, SpaceKeyringDeps, SpaceMessageEvent, SpaceNamespaceDeps, StorageChangeEvent, StorageNamespaceDeps, StoredSession, Subscription, UserIdentity, VerificationKey, WSMessage, WSMessageType, WSTransportOptions, WrappedPayload, WriteFileInput, WriteToShardsInput, ZkAuthDeps, ZkAuthenticateRequest, ZkChallengeResponse, ZkCompiled, ZkIdentity, ZkRegisterRequest, ZkRegisterResponse };
+export { AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, AES_GCM_TAG_BYTES, AgentsNamespace, AuthClient, AuthNamespace, AuthPublicInput, Authenticator, BroadcastChannel, BroadcastChannelEvents, ChannelExistsError, ChannelNotFoundError, ChunkCipher, Client, DEFAULT_BASE_URL, DoubleRatchet, DoubleRatchetCipher, DoubleRatchetManager, EncryptedSession, EventCore, EventCoreEvents, Field, Field as FieldElement, FileStorage, FunctionsNamespace, HashKnowledge, HttpClient, HttpError, KEEPER_MEMBER_ID, KeyStore, KeyringClient, KvNamespace, LocalStorageSessionStore, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, PBKDF2_DEFAULT_ITERATIONS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PersonalSpaceClient, Poseidon, PreimagePoK, ReedSolomonCodec, Space as Room, SerializeMessage, SessionState, ShardClient, SharedSpaceClient, Space, SpaceKeyring, SpaceNamespace, SpacePacketCipher, StorageNamespace, WSTransport, ZkAuth, buildCommitment, compilePrograms, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultSessionStore, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, encodeToHex, encryptAesGcm, exportPublicKeyBase64, exportPublicKeyHex, generateAuthProof, getSubtle, initBn128Wasm, initRsWasm, initializeCircuits, manifestToStat, poseidonHash, quickVerify, randomBytes, shardHash, signMessage, toField, unwrapWithPassphrase, verify, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase };
+export type { ACL, ACLEntry, AgentConfig, AgentCreateInput, AgentProvisioned, AgentScopeOpts, AgentSkill, AgentTrigger, AgentTriggerType, AgentUpdateInput, AgentsNamespaceDeps, AuthClientOptions, AuthKeyPair, AuthSuccess, AuthToken, AuthType, AuthUser, Bn128WasmInstance, BroadcastChannelEvent, BroadcastChannelOptions, ChannelLike, ChunkKeyMaterial, ChunkManifest, CipherFrame, CipherMessage, CipherMessageHeader, CircuitBufferConfig, CircuitUrls, ClientOptions, DehydratedKeypair, DehydratedKeys, DoubleRatchetCipherDeps, ECDHCurve, EncodeResult, EphemeralEvent, EpochKeyProvider, FileManifest, FileNamespaceDeps, FileStat, FileStorageOptions, FunctionCaps, FunctionConfig, FunctionDeployInput, FunctionScopeOpts, FunctionTrigger, FunctionTriggerType, FunctionTriggers, FunctionUpdateInput, FunctionsNamespaceDeps, Groth16Proof, HttpClientOptions, IncomingFrame, KeyExchangeFrame, KeyPair, Keypair, KeyringClientDeps, KeyringTransport, KvNamespaceDeps, LoginOptions, MessageBody, MessageDeletedEvent, MessageEvent, MessageHeaders, MessageNamespaceDeps, MessageOptions, MessageSubscription, MuhkooMessageEvent, OAuthProvider, PacketCipher, PacketHeaders, PacketOptions, Participant, Permission, PermissionCheckRequest, PermissionCheckResult, PersonalSpaceClientOptions, PublicKeyJWK, RatchetState, ReceiveResult, RegisterParams, Role, SpaceDeps as RoomDeps, SpaceFileMetadata as RoomFileMetadata, SealedHeaders, Session, SessionOptions, SessionStore, SetOptions, ShardClientOptions, SharedSpaceClientOptions, SnarkProof, SpaceChannelLike, SpaceDeps, SpaceFileMetadata, SpaceKeyCache, SpaceKeyringDeps, SpaceMessageEvent, SpaceNamespaceDeps, StorageChangeEvent, StoredSession, Subscription, UserIdentity, VerificationKey, WSMessage, WSMessageType, WSTransportOptions, WrappedPayload, WriteFileInput, WriteFileOptions, WriteToShardsInput, ZkAuthDeps, ZkAuthenticateRequest, ZkChallengeResponse, ZkCompiled, ZkIdentity, ZkRegisterRequest, ZkRegisterResponse };