@muhkoo/connect 0.15.0-alpha.11 → 0.15.0-alpha.12

package/README.md

@@ -4,7 +4,7 @@ Client SDK for the Muhkoo Accelerator. The headline surface is a single
 **`Client`** that hangs everything off its namespaces —
 `client.auth` / `client.kv` / `client.db` / `client.storage` / `client.vfs` /
 `client.vcs` / `client.message` / `client.space` / `client.agents` /
-`client.functions` / `client.accessTokens` / `client.offline` — backed by
+`client.functions` / `client.accessTokens` / `client.vectors` / `client.offline` — backed by
 end-to-end-encrypted messaging (fan-out group channels with history, plus Double
 Ratchet + ECDH P-384 for direct messages), ZK identity + personal/shared spaces,
 server-side Programmable Agents, developer-authored serverless functions, and an
@@ -25,7 +25,8 @@ See [`CHANGELOG.md`](./CHANGELOG.md) for what's new.
   (pub/sub + E2E direct messages), `space` (fan-out group channels with
   history), `agents` (server-side Programmable Agents), `functions`
   (developer-authored serverless functions), `accessTokens` (scoped machine
-  credentials), and `offline` (CRDT sync). This is the supported surface;
+  credentials), `vectors` (vector search over the app's collections), and
+  `offline` (CRDT sync). This is the supported surface;
   everything below is a building block it composes.
 
 - **App-describing decorators** — `@MuhkooAgent` / `@MuhkooSpace` / `@MuhkooDB` /
@@ -444,6 +445,48 @@ cause. The limits, messages and every behaviour change are listed under
 *Filesystem and version control* in [`API_REFERENCE.md`](./API_REFERENCE.md);
 [`CHANGELOG.md`](./CHANGELOG.md) says why each one changed.
 
+### Vector search (`client.vectors`)
+
+Collections hold entries you search by meaning. In text mode Muhkoo makes the
+vectors from your text; in vectors mode you send your own. The store is
+**server-readable**: Muhkoo can read entries, text and data, so don't put
+anything there you need kept from the server. The app owner creates collections
+(`client.vectors.createCollection(appId, name, definition)` then
+`waitForCollection`, which waits up to 10 minutes) or in the portal.
+
+```ts
+const docs = client.vectors.collection("docs");
+
+// Writes are accepted at once and become searchable shortly after,
+// usually within a minute or two.
+const { mutationId } = await docs.upsert([
+    { id: "a", text: "How to reset a password", data: { category: "help" } },
+]);
+await docs.waitFor(mutationId); // polls status; waits up to 5 minutes
+
+const matches = await docs.query({ text: "forgot my password", topK: 5, filter: { category: "help" } });
+
+// To wait on a ready notice instead of polling, the Space must be registered
+// as a notice Space for the environment. The app owner does this once:
+const space = await client.space.joinChannel("docs-updates");
+await client.vectors.setNotices(appId, "docs", "live", { spaces: [space.id], defaultSpace: space.id });
+
+// Name it with `notify` (or rely on the defaultSpace) and listen on it.
+await docs.upsertAndWait([{ id: "b", text: "Changing your email" }], {
+    space,
+    notify: { space: space.id },
+});
+```
+
+The server sends the ready notice only to a registered notice Space: the one named
+in `notify.space`, or the environment's `defaultSpace`. Naming a Space that isn't
+registered fails the upsert with a 400 `notice_space_not_registered`. Any other
+Space you pass as `space` never receives the notice, so the wait still completes,
+by polling, usually within a minute or two.
+
+A wait that runs out throws `VectorWaitTimeoutError` (with the `mutationId`); the
+write itself still went through, and `docs.status(mutationId)` tells you later.
+
 > The sections below document the lower-level building blocks the client is
 > composed from (`BroadcastChannel`, `EncryptedSession`, `PersonalSpaceClient`,
 > the Groth16 verifier, …). Reach for them directly only when you need control

package/dist/browser/index.js

@@ -7692,7 +7692,7 @@ function manifestStat(m) {
  * expect (and isn't serving a stale cached bundle). Keep this in sync with
  * `package.json` `version`.
  */
-const VERSION = "0.15.0-alpha.11";
+const VERSION = "0.15.0-alpha.12";
 
 /**
  * `HttpClient` — the one place the unified {@link Client} talks to the
@@ -7851,6 +7851,9 @@ class HttpClient {
     post(path, body) {
         return this.request("POST", path, body);
     }
+    put(path, body) {
+        return this.request("PUT", path, body);
+    }
     patch(path, body) {
         return this.request("PATCH", path, body);
     }
@@ -16904,6 +16907,343 @@ class AppNamespace {
     }
 }
 
+/**
+ * `client.vectors` — vector search over the app's collections. A developer
+ * defines a collection (text or vectors mode, filterable fields, access) in the
+ * Muhkoo portal or CLI; this namespace reads and writes its entries:
+ *
+ *   const docs = client.vectors.collection('docs');
+ *   const { mutationId } = await docs.upsert([
+ *     { id: 'doc-1', text: 'How to reset your password…', data: { category: 'faq' } },
+ *   ]);
+ *   const state   = await docs.status(mutationId);   // 'pending' | 'done' | 'unknown'
+ *   const matches = await docs.query({ text: 'forgot password', topK: 5, filter: { category: 'faq' } });
+ *   const [entry] = await docs.get(['doc-1']);
+ *   await docs.delete(['doc-1']);
+ *
+ * Writes are asynchronous: upsert and delete return a `mutationId` at once, and
+ * entries usually become searchable within one to two minutes. `get` returns
+ * only entries whose writes have finished, never ones still pending.
+ *
+ * Entries are server-readable: Muhkoo stores the text, vectors and data you send
+ * so it can embed and search them. Don't put anything in a collection that the
+ * platform must not see.
+ *
+ * Authorization is the app key ({@link HttpClient} stamps it on every request);
+ * the app and environment come from the key. Server errors (`{ error, code }`)
+ * reach callers as {@link HttpError}; the SDK does no validation of its own.
+ */
+const READY_SENDER = "__muhkoo__";
+const READY_SUBJECT = "muhkoo.vectors.ready";
+const DEFAULT_WAIT_TIMEOUT_MS = 300_000;
+const POLL_FIRST_MS = 250;
+const POLL_MAX_MS = 4_000;
+const POLL_CONNECTED_MS = 5_000;
+/**
+ * A wait for a write ran out of time. The write itself was accepted; check
+ * {@link VectorCollection.status} later with `mutationId`.
+ */
+class VectorWaitTimeoutError extends Error {
+    mutationId;
+    constructor(mutationId, timeoutMs) {
+        super(`Timed out after ${timeoutMs} ms waiting for mutation ${mutationId}`);
+        this.name = "VectorWaitTimeoutError";
+        this.mutationId = mutationId;
+    }
+}
+function isReadyEvent(data) {
+    if (!data || typeof data !== "object")
+        return false;
+    const d = data;
+    return (typeof d.collection === "string" &&
+        typeof d.mutationId === "string" &&
+        Array.isArray(d.ids) &&
+        d.ids.every((id) => typeof id === "string"));
+}
+/** A handle on one collection. Cheap to make; holds no state beyond its name. */
+class VectorCollection {
+    http;
+    name;
+    base;
+    constructor(http, name) {
+        this.http = http;
+        this.name = name;
+        this.base = `/api/vectors/${encodeURIComponent(name)}`;
+    }
+    /** Add or replace entries. Returns once accepted; see {@link status}. */
+    upsert(entries, opts) {
+        const body = { entries };
+        if (opts?.notify !== undefined)
+            body.notify = opts.notify;
+        return this.http.post(`${this.base}/upsert`, body);
+    }
+    /** Nearest entries to a text or a vector. */
+    async query(input) {
+        const res = await this.http.post(`${this.base}/query`, input);
+        return res.matches;
+    }
+    /** Entries by id. Writes still pending are not returned. */
+    async get(ids, opts) {
+        const body = { ids };
+        if (opts?.includeVector !== undefined)
+            body.includeVector = opts.includeVector;
+        const res = await this.http.post(`${this.base}/get`, body);
+        return res.entries;
+    }
+    /** Remove entries by id. Asynchronous, like {@link upsert}. */
+    delete(ids) {
+        return this.http.post(`${this.base}/delete`, { ids });
+    }
+    /** The state of a write: `pending`, `done`, or `unknown` (never seen or expired). */
+    async status(mutationId) {
+        const res = await this.http.get(`${this.base}/status?mutation=${encodeURIComponent(mutationId)}`);
+        return res.state;
+    }
+    /**
+     * Listen on an open Space for this collection's ready notices. Only notices
+     * the platform sent (sender `__muhkoo__`) reach `handler`; a member who
+     * publishes the same subject is ignored. Needs an unlocked session, since a
+     * Space without its keys emits no ephemeral events. Returns the unsubscribe.
+     */
+    onReady(space, handler) {
+        return space.onEphemeral((e) => {
+            if (e.from !== READY_SENDER || e.subject !== READY_SUBJECT)
+                return;
+            if (!isReadyEvent(e.data) || e.data.collection !== this.name)
+                return;
+            handler({ collection: e.data.collection, ids: e.data.ids, mutationId: e.data.mutationId });
+        });
+    }
+    /**
+     * Resolve once a write is searchable: on its ready notice (with `space`) or
+     * when {@link status} answers `done`. Status is polled underneath either way,
+     * because notices are best effort.
+     *
+     * The notice only arrives if `space` is a registered notice Space for the
+     * environment (see {@link VectorsNamespace.setNotices}) and the write named
+     * it in `notify.space` or it is the environment's `defaultSpace`. Any other
+     * Space never receives the notice, and the wait falls back to polling,
+     * usually finishing within a minute or two.
+     *
+     * Rejects with an `Error` ("Unknown mutation <id>") if status answers
+     * `unknown`, and with {@link VectorWaitTimeoutError} after `timeoutMs`
+     * (default 300,000 ms).
+     */
+    waitFor(mutationId, opts) {
+        const space = opts?.space;
+        const subscribe = space
+            ? (onHit) => this.onReady(space, (e) => { if (e.mutationId === mutationId)
+                onHit(); })
+            : undefined;
+        return this.wait(mutationId, opts, subscribe);
+    }
+    /**
+     * {@link upsert}, then {@link waitFor} its mutation. With `space`, listens
+     * before sending, so a notice that beats the HTTP response still counts.
+     * The notice reaches `space` only if it is a registered notice Space named
+     * in `notify.space` or set as the environment's `defaultSpace`; naming an
+     * unregistered Space fails the upsert with a 400
+     * `notice_space_not_registered`. Otherwise the wait completes by polling.
+     * An upsert error is rethrown at once.
+     */
+    async upsertAndWait(entries, opts) {
+        const space = opts?.space;
+        if (!space) {
+            const result = await this.upsert(entries, opts);
+            await this.wait(result.mutationId, opts, undefined);
+            return result;
+        }
+        const seen = new Set();
+        let target = null;
+        let hit = null;
+        const unsubscribe = this.onReady(space, (e) => {
+            if (target === null)
+                seen.add(e.mutationId);
+            else if (e.mutationId === target)
+                hit?.();
+        });
+        try {
+            const result = await this.upsert(entries, opts);
+            target = result.mutationId;
+            const already = seen.has(result.mutationId);
+            seen.clear();
+            const subscribe = (onHit) => {
+                hit = onHit;
+                return () => { hit = null; };
+            };
+            if (!already)
+                await this.wait(result.mutationId, opts, subscribe);
+            return result;
+        }
+        finally {
+            unsubscribe();
+        }
+    }
+    wait(mutationId, opts, subscribe) {
+        const timeoutMs = opts?.timeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+        const space = opts?.space;
+        return new Promise((resolve, reject) => {
+            let finished = false;
+            let pollTimer;
+            let backoff = POLL_FIRST_MS;
+            const subscription = {};
+            const finish = (err) => {
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(deadline);
+                if (pollTimer !== undefined)
+                    clearTimeout(pollTimer);
+                subscription.off?.();
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            };
+            const schedule = () => {
+                if (finished)
+                    return;
+                let delay;
+                if (space?.isConnected()) {
+                    delay = POLL_CONNECTED_MS;
+                }
+                else {
+                    delay = backoff;
+                    backoff = Math.min(backoff * 2, POLL_MAX_MS);
+                }
+                pollTimer = setTimeout(poll, delay);
+            };
+            const poll = async () => {
+                pollTimer = undefined;
+                let state = null;
+                try {
+                    state = await this.status(mutationId);
+                }
+                catch {
+                    state = null; // retried at the same cadence
+                }
+                if (finished)
+                    return;
+                if (state === "done")
+                    finish();
+                else if (state === "unknown")
+                    finish(new Error(`Unknown mutation ${mutationId}`));
+                else
+                    schedule();
+            };
+            const deadline = setTimeout(() => finish(new VectorWaitTimeoutError(mutationId, timeoutMs)), timeoutMs);
+            subscription.off = subscribe?.(() => finish());
+            if (finished) {
+                subscription.off?.();
+                return;
+            }
+            schedule();
+        });
+    }
+}
+/** A collection's creation failed; `info.envs.*.error` says why. */
+class VectorCollectionFailedError extends Error {
+    info;
+    constructor(info) {
+        const reason = info.envs?.live?.error ?? info.envs?.test?.error;
+        super(`Collection ${info.name} failed${reason ? `: ${reason}` : ""}`);
+        this.name = "VectorCollectionFailedError";
+        this.info = info;
+    }
+}
+const COLLECTION_POLL_MS = 2_000;
+const DEFAULT_COLLECTION_TIMEOUT_MS = 600_000;
+class VectorsNamespace {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** A handle on the named collection, made fresh on each call. */
+    collection(name) {
+        return new VectorCollection(this.deps.http, name);
+    }
+    // Owner management. Authorized by the developer session (owner only, like
+    // the database tables API), not the app key.
+    /** The app's collections, sorted by name. */
+    async listCollections(appId) {
+        const res = await this.deps.http.get(this.ownerPath(appId));
+        return res.collections;
+    }
+    /** One collection. A missing or badly named one is 404 `collection_not_found`. */
+    getCollection(appId, name) {
+        return this.deps.http.get(this.ownerPath(appId, name));
+    }
+    /**
+     * Create a collection. Asynchronous: it answers with status `creating`; use
+     * {@link waitForCollection} to wait for `ready`. Repeating it with the same
+     * definition returns the existing collection; a different definition is
+     * 409 `collection_exists`. Definitions never change: drop and recreate.
+     */
+    createCollection(appId, name, definition) {
+        return this.deps.http.put(this.ownerPath(appId, name), definition);
+    }
+    /**
+     * Drop a collection and its entries in both environments. Asynchronous; the
+     * collection shows status `dropping` until it is gone. Safe to repeat: a 503
+     * `vectors_unavailable` means the drop couldn't start, and calling again is
+     * the remedy.
+     */
+    async dropCollection(appId, name) {
+        await this.deps.http.del(this.ownerPath(appId, name));
+    }
+    /** Set which Spaces receive ready notices for one environment. */
+    setNotices(appId, name, env, notices) {
+        return this.deps.http.patch(`${this.ownerPath(appId, name)}/notices?env=${encodeURIComponent(env)}`, notices);
+    }
+    /**
+     * Poll {@link getCollection} every 2 s until status is `ready`. Rejects with
+     * {@link VectorCollectionFailedError} on `failed`, and with
+     * `Error("Timed out waiting for collection <name>")` after `timeoutMs`
+     * (default 600,000 ms: creation waits for filter fields to settle).
+     */
+    waitForCollection(appId, name, opts) {
+        const timeoutMs = opts?.timeoutMs ?? DEFAULT_COLLECTION_TIMEOUT_MS;
+        return new Promise((resolve, reject) => {
+            let finished = false;
+            let pollTimer;
+            const done = (fn) => {
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(deadline);
+                if (pollTimer !== undefined)
+                    clearTimeout(pollTimer);
+                fn();
+            };
+            const poll = async () => {
+                pollTimer = undefined;
+                let info;
+                try {
+                    info = await this.getCollection(appId, name);
+                }
+                catch (err) {
+                    done(() => reject(err));
+                    return;
+                }
+                if (finished)
+                    return;
+                if (info.status === "ready")
+                    done(() => resolve(info));
+                else if (info.status === "failed")
+                    done(() => reject(new VectorCollectionFailedError(info)));
+                else
+                    pollTimer = setTimeout(poll, COLLECTION_POLL_MS);
+            };
+            const deadline = setTimeout(() => done(() => reject(new Error(`Timed out waiting for collection ${name}`))), timeoutMs);
+            void poll();
+        });
+    }
+    ownerPath(appId, name) {
+        const base = `/api/apps/${encodeURIComponent(appId)}/vectors/collections`;
+        return name === undefined ? base : `${base}/${encodeURIComponent(name)}`;
+    }
+}
+
 /**
  * POST /api/auth/identity (SpecA §4.1 as amended by CS-7). An unknown name
  * answers a deterministic decoy, so a lookup never says whether an account
@@ -24799,6 +25139,8 @@ class Client {
     accessTokens;
     /** This app — `client.app.access()`: may the signed-in user add data here? */
     app;
+    /** Vector search — `client.vectors.collection("docs").query({ text })`, plus owner management of collections. */
+    vectors;
     /** Offline cache + sync — `client.offline.status`, `client.offline.snapshot`, etc. */
     offline;
     session;
@@ -25071,6 +25413,7 @@ class Client {
         this.agents = new AgentsNamespace({ http: this.http });
         this.functions = new FunctionsNamespace({ http: this.http, fnHostSuffix: options.functionsHostSuffix });
         this.accessTokens = new AccessTokensNamespace({ http: this.http });
+        this.vectors = new VectorsNamespace({ http: this.http });
         // Each "allowed" sends what the offline queue kept after a refusal for
         // payment, without waiting for the next reconnect.
         this.app = new AppNamespace({ http: this.http, onAllowed: () => this.offline.resume() });
@@ -25494,5 +25837,5 @@ var bundledLoader = /*#__PURE__*/Object.freeze({
   default: loadRsWasm
 });
 
-export { ACCESS_TOKEN_SCOPES, AES_GCM_IV_BYTES$1 as AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, AES_GCM_TAG_BYTES$1 as AES_GCM_TAG_BYTES, AccessTokensNamespace, AdmissionDeniedError, AgentsNamespace, AppNamespace, AuthClient, AuthHttpError, AuthNamespace, AuthPublicInput, Authenticator, BlockEngine, BroadcastChannel, BroadcastChannelEvents, ChannelExistsError, ChannelNotFoundError, ChunkCipher, CircuitIntegrityError, Client, ConnectivityManager, DEFAULT_AUTH_BASE_URL, DEFAULT_BASE_URL, DEFAULT_BRANCH, DEFAULT_FN_HOST_SUFFIX, DEVICE_IDENTITY_STORAGE_KEY, DEVICE_KEY_DB_NAME, DbCache, DbNamespace, DbTable, DevicePairingError, DeviceRevokedError, DeviceStoreUnavailableError, DoubleRatchet, DoubleRatchetCipher, DoubleRatchetManager, EncryptedSession, EventCore, EventCoreEvents, Field, Field as FieldElement, FileStorage, FunctionsNamespace, GoogleNotLinkedError, GuestLoginConflictError, HLC, HashKnowledge, HostedAuth, HttpClient, HttpError, IdentityLockedError, IdentityUnavailableError, IndexedDbStore, InvalidRecoveryCodeError, KEEPER_MEMBER_ID$1 as KEEPER_MEMBER_ID, KeyStore, KeyringClient, KeyringHttpError, KvCache, KvNamespace, LocalEngineHost, LocalStorageSessionStore, Logger, MAX_SHARE_SUCCESSOR_HOPS, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, MuhkooAgent, MuhkooDB, MuhkooFunction, MuhkooSpace, NOT_MEMBER_CLOSE_CODE, NOT_MEMBER_RECHECK_MS, NoopStore, OfflineLockedError, OfflineManager, OutboundQueue, P2P_SUBJECT, PAIRING_CODE_ALPHABET, PAIRING_CODE_LENGTH, PBKDF2_DEFAULT_ITERATIONS, PINNED_CIRCUIT_DIGESTS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PasskeyOriginError, PaymentRequiredError, PeerExchange, PeerNetwork, PersonalSpaceClient, Poseidon, PreimagePoK, ROOT_ID, Ready, ReauthRequiredError, ReedSolomonCodec, Repo, Retry, Space as Room, RotationInProgressError, RotationIncompleteError, RotationMismatchError, SHARE_DIR_TYPE, SHARE_GUEST_DEVICE_LABEL, SHARE_PASSWORD_ITERATIONS, SerializeMessage, SessionState, ShardCache, ShardClient, Share, ShareClosedError, ShareFullError, ShareMemberLimitError, SharePasswordError, SharePasswordRateError, ShareSpaceNotEmptyError, ShareSpaceNotReadyError, SharedSpaceClient, SharesClient, SharesNamespace, SnapshotNamespace, Space, SpaceCache, SpaceKeyring, SpaceNamespace, SpacePacketCipher, SpaceSignaler, SpaceTrustError, StorageNamespace, SyncEngine, VERSION, VFS_ROOT_INFO, VaultProtocolMismatchError, VaultUnavailableError, VcsError, VcsNamespace, VfsConflictError, VfsCorruptRecordError, VfsLimitError, VfsLockedError, VfsNamespace, VfsNotFoundError, WSTransport, WebRtcTransport, WorkerEngineHost, ZERO_HLC, ZkAuth, _accountId, _formatBytes, _messageId, _objectId, _packetId, _socketId, _userId, appLogger$1 as appLogger, assertType, base58Decode, base58Encode, buildCommitment, canonicalUserCode, clearDeviceIdentity, compareHlc, compilePrograms, concatBytes$1 as concatBytes, configureDeviceStore, createPasskeyWithPrf, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultRpId, defaultSessionStore, defaultSharesStore, deleteBeatsWrite, deleteRegister, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, deriveIdentityFromSeed, deriveMasterSeedFromPassword, deserialize, deviceFingerprint, deviceIdentityIsEphemeral, deviceIdentityKey, dirKey, ejectAgentPrompt, ejectAgentTools, emptyMap, emptyRegister, encodeToHex, encryptAesGcm, evaluatePasskeyPrf, exportPublicKeyBase64, exportPublicKeyHex, formatUserCode, fromBase64$2 as fromBase64, fromBase64Url, fromHex, generateAuthProof, generateChecksum, generateDevicePairingKeypair, generateId, generatePkce, getIPAddress, getId, getMuhkooAppDescriptor, getSubtle, guestRecoveryCode, guestRecoveryOf, hasDeviceIdentity, headKey, historyKey, initBn128Wasm, initRsWasm, initializeCircuits, isNewer, isNumber, isOfflineCapable, isP2pCapable, isProvisional, isSameOriginPath, loadDeviceIdentity, log, manifestToStat, materializeRow, memorySharesStore, merge3, merge3Text, mergeKey, mergeMap, mergeMessage, mergeRegister, messageKey, newPasswordVerifier, objectKey, pack, padHandle, pairingVerificationCode, parseGuestRecoveryCode, passkeyPrfCapable, passkeySupported, passkeyUsableFromOrigin, passwordProof, persistDeviceIdentity, poseidonHash, protocol, provisionalHandle, quickVerify, randomBytes, randomState, refKey, refsIndexKey, rpIdUsableForOrigin, sealSeed, sealSeedToDevice, serialize, shardHash, shareErrorFrom, signMessage, stableStringify, toBase64$2 as toBase64, toBase64Url, toField, toHex, tombstoneRow, unpack, unsealSeed, unsealSeedFromDevice, unwrapWithPassphrase, utf8Decode, utf8Encode, verify, verifyChecksum, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase, writeBeatsTombstone, writeColumns, writeRegister };
+export { ACCESS_TOKEN_SCOPES, AES_GCM_IV_BYTES$1 as AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, AES_GCM_TAG_BYTES$1 as AES_GCM_TAG_BYTES, AccessTokensNamespace, AdmissionDeniedError, AgentsNamespace, AppNamespace, AuthClient, AuthHttpError, AuthNamespace, AuthPublicInput, Authenticator, BlockEngine, BroadcastChannel, BroadcastChannelEvents, ChannelExistsError, ChannelNotFoundError, ChunkCipher, CircuitIntegrityError, Client, ConnectivityManager, DEFAULT_AUTH_BASE_URL, DEFAULT_BASE_URL, DEFAULT_BRANCH, DEFAULT_FN_HOST_SUFFIX, DEVICE_IDENTITY_STORAGE_KEY, DEVICE_KEY_DB_NAME, DbCache, DbNamespace, DbTable, DevicePairingError, DeviceRevokedError, DeviceStoreUnavailableError, DoubleRatchet, DoubleRatchetCipher, DoubleRatchetManager, EncryptedSession, EventCore, EventCoreEvents, Field, Field as FieldElement, FileStorage, FunctionsNamespace, GoogleNotLinkedError, GuestLoginConflictError, HLC, HashKnowledge, HostedAuth, HttpClient, HttpError, IdentityLockedError, IdentityUnavailableError, IndexedDbStore, InvalidRecoveryCodeError, KEEPER_MEMBER_ID$1 as KEEPER_MEMBER_ID, KeyStore, KeyringClient, KeyringHttpError, KvCache, KvNamespace, LocalEngineHost, LocalStorageSessionStore, Logger, MAX_SHARE_SUCCESSOR_HOPS, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, MuhkooAgent, MuhkooDB, MuhkooFunction, MuhkooSpace, NOT_MEMBER_CLOSE_CODE, NOT_MEMBER_RECHECK_MS, NoopStore, OfflineLockedError, OfflineManager, OutboundQueue, P2P_SUBJECT, PAIRING_CODE_ALPHABET, PAIRING_CODE_LENGTH, PBKDF2_DEFAULT_ITERATIONS, PINNED_CIRCUIT_DIGESTS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PasskeyOriginError, PaymentRequiredError, PeerExchange, PeerNetwork, PersonalSpaceClient, Poseidon, PreimagePoK, ROOT_ID, Ready, ReauthRequiredError, ReedSolomonCodec, Repo, Retry, Space as Room, RotationInProgressError, RotationIncompleteError, RotationMismatchError, SHARE_DIR_TYPE, SHARE_GUEST_DEVICE_LABEL, SHARE_PASSWORD_ITERATIONS, SerializeMessage, SessionState, ShardCache, ShardClient, Share, ShareClosedError, ShareFullError, ShareMemberLimitError, SharePasswordError, SharePasswordRateError, ShareSpaceNotEmptyError, ShareSpaceNotReadyError, SharedSpaceClient, SharesClient, SharesNamespace, SnapshotNamespace, Space, SpaceCache, SpaceKeyring, SpaceNamespace, SpacePacketCipher, SpaceSignaler, SpaceTrustError, StorageNamespace, SyncEngine, VERSION, VFS_ROOT_INFO, VaultProtocolMismatchError, VaultUnavailableError, VcsError, VcsNamespace, VectorCollection, VectorCollectionFailedError, VectorWaitTimeoutError, VectorsNamespace, VfsConflictError, VfsCorruptRecordError, VfsLimitError, VfsLockedError, VfsNamespace, VfsNotFoundError, WSTransport, WebRtcTransport, WorkerEngineHost, ZERO_HLC, ZkAuth, _accountId, _formatBytes, _messageId, _objectId, _packetId, _socketId, _userId, appLogger$1 as appLogger, assertType, base58Decode, base58Encode, buildCommitment, canonicalUserCode, clearDeviceIdentity, compareHlc, compilePrograms, concatBytes$1 as concatBytes, configureDeviceStore, createPasskeyWithPrf, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultRpId, defaultSessionStore, defaultSharesStore, deleteBeatsWrite, deleteRegister, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, deriveIdentityFromSeed, deriveMasterSeedFromPassword, deserialize, deviceFingerprint, deviceIdentityIsEphemeral, deviceIdentityKey, dirKey, ejectAgentPrompt, ejectAgentTools, emptyMap, emptyRegister, encodeToHex, encryptAesGcm, evaluatePasskeyPrf, exportPublicKeyBase64, exportPublicKeyHex, formatUserCode, fromBase64$2 as fromBase64, fromBase64Url, fromHex, generateAuthProof, generateChecksum, generateDevicePairingKeypair, generateId, generatePkce, getIPAddress, getId, getMuhkooAppDescriptor, getSubtle, guestRecoveryCode, guestRecoveryOf, hasDeviceIdentity, headKey, historyKey, initBn128Wasm, initRsWasm, initializeCircuits, isNewer, isNumber, isOfflineCapable, isP2pCapable, isProvisional, isSameOriginPath, loadDeviceIdentity, log, manifestToStat, materializeRow, memorySharesStore, merge3, merge3Text, mergeKey, mergeMap, mergeMessage, mergeRegister, messageKey, newPasswordVerifier, objectKey, pack, padHandle, pairingVerificationCode, parseGuestRecoveryCode, passkeyPrfCapable, passkeySupported, passkeyUsableFromOrigin, passwordProof, persistDeviceIdentity, poseidonHash, protocol, provisionalHandle, quickVerify, randomBytes, randomState, refKey, refsIndexKey, rpIdUsableForOrigin, sealSeed, sealSeedToDevice, serialize, shardHash, shareErrorFrom, signMessage, stableStringify, toBase64$2 as toBase64, toBase64Url, toField, toHex, tombstoneRow, unpack, unsealSeed, unsealSeedFromDevice, unwrapWithPassphrase, utf8Decode, utf8Encode, verify, verifyChecksum, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase, writeBeatsTombstone, writeColumns, writeRegister };
 //# sourceMappingURL=index.js.map