@muhkoo/connect 0.11.0-alpha.0 → 0.12.0-alpha.0

package/dist/connect.d.ts

@@ -5500,6 +5500,60 @@ declare class AccessTokensNamespace {
  * seam group-sharing hangs off later without re-encrypting the filesystem.
  */
 
+/** Personal-space KV key holding a directory record. */
+declare const dirKey: (id: string) => string;
+/** Personal-space KV key holding one file's prior versions. */
+declare const historyKey: (id: string) => string;
+/** The root directory's id is fixed — it is the one node reached without a parent. */
+declare const ROOT_ID = "root";
+/** HKDF label for the seed-derived root key. Sits alongside `muhkoo-storage-v1`. */
+declare const VFS_ROOT_INFO = "muhkoo-vfs-v1";
+interface FileEntry {
+    kind: "file";
+    /**
+     * Stable identity, independent of name and location. Renaming a file keeps
+     * its id, so its version history follows it rather than being orphaned.
+     */
+    id: string;
+    /** The handle: everything needed to read the current bytes back. */
+    manifest: FileManifest;
+    /** Plaintext byte length. */
+    size: number;
+    mtime: number;
+    /**
+     * Count of prior versions in the file's history record.
+     *
+     * Denormalised on purpose: the file tree wants to show "3 versions" while
+     * listing a directory, and fetching every history record to answer that
+     * would defeat the point of keeping history out of the directory record.
+     */
+    versions?: number;
+}
+interface DirEntry {
+    kind: "dir";
+    /** Record id — `dirKey(id)` locates it. Permanent for the directory's life. */
+    id: string;
+    /** Base64 AES-256 key for that record. See the capability note above. */
+    key: string;
+    mtime: number;
+}
+type Entry = FileEntry | DirEntry;
+/** One directory record, as stored (before encryption). */
+interface DirNode {
+    v: 1;
+    /** Child name → entry. Names are unique within a directory, per filesystem. */
+    entries: Record<string, Entry>;
+    mtime: number;
+}
+/** A file's prior versions, newest first. Fetched only when asked for. */
+interface HistoryRecord {
+    v: 1;
+    versions: Array<{
+        manifest: FileManifest;
+        size: number;
+        mtime: number;
+    }>;
+}
 /** What `stat` and `list` hand back — a path-addressed view of an entry. */
 interface VfsStat {
     path: string;
@@ -5509,6 +5563,14 @@ interface VfsStat {
     mtime: number;
     versions: number;
 }
+/** The encrypted envelope every record is stored in. */
+interface SealedRecord {
+    v: 1;
+    /** Base64 12-byte AES-GCM IV. */
+    iv: string;
+    /** Base64 ciphertext with the 16-byte tag appended. */
+    ct: string;
+}
 /** The personal-space blob store the VFS persists through. */
 interface VfsStore {
     get(key: string): Promise<unknown | null>;
@@ -5517,6 +5579,18 @@ interface VfsStore {
     /** Every key in the store — the personal space is shared, so this is NOT VFS-only. */
     list(): Promise<string[]>;
 }
+/** Raised when the master seed is not held, so the root key cannot be derived. */
+declare class VfsLockedError extends Error {
+    constructor();
+}
+/** Raised for a path that does not exist. */
+declare class VfsNotFoundError extends Error {
+    constructor(path: string);
+}
+/** Raised when an operation would clobber or misuse an existing entry. */
+declare class VfsConflictError extends Error {
+    constructor(message: string);
+}
 
 /**
  * `client.vfs` — a real filesystem over Muhkoo primitives.
@@ -5660,6 +5734,42 @@ declare class VfsNamespace {
     walk(path?: string): Promise<string[]>;
     readFile(path: string): Promise<Uint8Array>;
     readText(path: string): Promise<string>;
+    /**
+     * A file's manifest — the handle itself, without reading the bytes.
+     *
+     * Version control records manifests rather than content, so a commit costs
+     * a hash and a reference, not a copy.
+     */
+    statManifest(path: string): Promise<{
+        manifest: FileManifest;
+        size: number;
+    }>;
+    /**
+     * Read content by its manifest, wherever it came from.
+     *
+     * A merge needs the COMMON ANCESTOR's version of a file, which by definition
+     * is not in the working tree any more. The manifest is the whole capability,
+     * so no path lookup is involved.
+     */
+    readByManifest(manifest: FileManifest): Promise<Uint8Array>;
+    /**
+     * Pin content that something other than the working tree depends on.
+     *
+     * A commit references a manifest, so it is an OWNER of that content — without
+     * a reference of its own, deleting the file from the working tree would free
+     * shards the history still needs, and checking out an older commit would find
+     * the content gone. (It did, in test.)
+     */
+    retainManifest(manifest: FileManifest): Promise<void>;
+    /**
+     * Point a path at content that already exists.
+     *
+     * This is how a checkout restores a file: the bytes are in the shard store
+     * already, so nothing is uploaded or downloaded — only the directory record
+     * changes. Takes a reference, because a second path now depends on those
+     * shards.
+     */
+    writeManifest(path: string, manifest: FileManifest, size: number): Promise<VfsStat>;
     /**
      * Create a directory. `recursive` creates missing parents and tolerates an
      * existing target, matching `mkdir -p`.
@@ -5677,9 +5787,17 @@ declare class VfsNamespace {
     writeFile(path: string, data: Uint8Array | string | Blob, opts?: {
         type?: string;
     }): Promise<VfsStat>;
-    /** Delete a file, or a directory when `recursive`. */
+    /**
+     * Delete a file, or a directory when `recursive`.
+     *
+     * `keepContent` removes the entry WITHOUT releasing its shards. A checkout
+     * needs that: the file is leaving the working tree, but commits still
+     * reference the same manifest, and releasing would free content history
+     * depends on.
+     */
     delete(path: string, opts?: {
         recursive?: boolean;
+        keepContent?: boolean;
     }): Promise<void>;
     /**
      * Move or rename. Works across directories, which is the same operation:
@@ -5773,6 +5891,263 @@ declare class VfsNamespace {
     private pushHistory;
 }
 
+/**
+ * Object model for version control over the VFS. See `docs/VCS_DESIGN.md`.
+ *
+ * Two spaces, deliberately: the WORKING TREE (`/apps/<slug>`) uses mutable
+ * random directory ids so a file write touches one record; the REPOSITORY
+ * (here) is content-addressed so a commit means the same thing forever. Git
+ * makes the same split, for the same reason.
+ */
+
+/** A file in a commit. The manifest IS the content — there are no blob objects. */
+interface TreeFile {
+    kind: "file";
+    manifest: FileManifest;
+    size: number;
+}
+/** A subdirectory, by the hash of its own tree object. */
+interface TreeDir {
+    kind: "tree";
+    hash: string;
+}
+type TreeEntry = TreeFile | TreeDir;
+/**
+ * One directory, frozen.
+ *
+ * Addressed by the hash of its canonical form, so an unchanged directory has
+ * the same hash in every commit containing it — a deep project costs one new
+ * tree per CHANGED directory, not one per commit.
+ */
+interface Tree {
+    v: 1;
+    entries: Record<string, TreeEntry>;
+}
+interface Commit {
+    v: 1;
+    /** Hash of the root tree. */
+    tree: string;
+    /**
+     * Ancestors. An ARRAY because a merge has two; the first commit has none.
+     * Order matters: `parents[0]` is the branch being committed onto.
+     */
+    parents: string[];
+    message: string;
+    author: string;
+    at: number;
+}
+/** Where a branch points, or a specific commit when detached. */
+type Head = {
+    branch: string;
+} | {
+    detached: string;
+};
+/** A single change between two trees. */
+interface Change {
+    path: string;
+    kind: "added" | "removed" | "modified";
+}
+/** A path the merge could not settle on its own. */
+interface Conflict {
+    path: string;
+    /** `binary` cannot be merged at all — the user picks a side. */
+    reason: "content" | "binary" | "modify-delete";
+}
+interface MergeResult {
+    /** "up-to-date" and "fast-forward" do no three-way work at all. */
+    kind: "up-to-date" | "fast-forward" | "merged" | "conflicted";
+    commit?: string;
+    conflicts: Conflict[];
+}
+interface LogEntry {
+    hash: string;
+    message: string;
+    author: string;
+    at: number;
+    parents: string[];
+}
+/** Storage keys. Namespaced per project so repositories cannot collide. */
+declare const objectKey: (slug: string, hash: string) => string;
+declare const refKey: (slug: string, name: string) => string;
+declare const headKey: (slug: string) => string;
+declare const refsIndexKey: (slug: string) => string;
+/** An in-progress merge: what to make the second parent when it is committed. */
+declare const mergeKey: (slug: string) => string;
+declare const DEFAULT_BRANCH = "main";
+declare class VcsError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * `client.vcs` — version control for a project in the VFS.
+ *
+ * Phase 1: objects, commit, log, checkout, diff. Branches and merge build on
+ * this; see `docs/VCS_DESIGN.md` for the whole shape and for why the repository
+ * is content-addressed while the working tree is not.
+ */
+
+interface VcsNamespaceDeps {
+    vfs: VfsNamespace;
+    store: VfsStore;
+    /** The key repository objects are sealed with — the project's own. */
+    key: () => Promise<Uint8Array>;
+    /** Who to record as the author. */
+    author: () => string;
+}
+declare class Repo {
+    private readonly slug;
+    private readonly deps;
+    constructor(slug: string, deps: VcsNamespaceDeps);
+    private get root();
+    /** Store an object, returning its hash and whether it was new. */
+    private put;
+    private get;
+    private head;
+    private setHead;
+    private readRef;
+    private writeRef;
+    /** Every branch name in this repository. */
+    branches(): Promise<string[]>;
+    /** The commit HEAD resolves to, or null in an empty repository. */
+    current(): Promise<string | null>;
+    /**
+     * Freeze the working tree as a commit.
+     *
+     * Trees are written bottom-up so a directory's hash is known before its
+     * parent references it. Nothing is written to the shard store: file entries
+     * carry the manifest the VFS already holds.
+     */
+    commit(message: string, parents?: string[]): Promise<string>;
+    /** Move whatever HEAD points at onto a new commit. */
+    private advance;
+    /** The other side of a merge that stopped for conflicts, if any. */
+    pendingMerge(): Promise<{
+        theirs: string;
+        name: string;
+    } | null>;
+    /** Write a directory and everything under it, returning the tree's hash. */
+    private writeTree;
+    /** Commits reachable from HEAD, newest first. */
+    log(limit?: number): Promise<LogEntry[]>;
+    /**
+     * What changed between two commits.
+     *
+     * Identical subtree hashes prune the walk: an untouched directory is one
+     * comparison regardless of how much is inside it. That is the payoff for
+     * content-addressing the trees.
+     */
+    diff(fromHash: string | null, toHash: string): Promise<Change[]>;
+    private diffTrees;
+    /**
+     * Replace the working tree with a commit's.
+     *
+     * Moves no file content: entries carry manifests the shard store already
+     * holds, so this rewrites directory records only.
+     */
+    /**
+     * What has changed since the last commit.
+     *
+     * Compares the WORKING TREE against HEAD without writing any objects: the
+     * common case is answering "anything to commit?", and a `status` that
+     * quietly stored a tree object every time would litter the repository with
+     * trees for states nobody chose to keep.
+     */
+    status(): Promise<Change[]>;
+    /** The working tree as a path → entry map, mirroring `filesOf`. */
+    private workingFiles;
+    /**
+     * Turn what a person typed into a commit hash.
+     *
+     * Accepts a branch name, `HEAD`, a full or abbreviated hash, and trailing
+     * `^` / `~n` to walk back through parents — so `show abc123^` means "the
+     * commit before that one" the way anyone who has used git expects.
+     */
+    resolve(rev: string): Promise<string>;
+    /** A hash prefix a person typed → the one commit it names. */
+    private expand;
+    /**
+     * Put one file back to the way it was in a commit.
+     *
+     * Scoped to a path on purpose — recovering one file you broke should not
+     * mean rewinding everything else you have done since.
+     */
+    restore(path: string, rev?: string): Promise<void>;
+    checkout(commitHash: string, opts?: {
+        discardChanges?: boolean;
+    }): Promise<void>;
+    /** Make the working tree match a commit, leaving HEAD alone. */
+    private materialise;
+    /** Project-relative path → absolute VFS path. */
+    private abs;
+    private collect;
+    /** Create a branch at a commit (HEAD by default). Does not switch to it. */
+    branch(name: string, at?: string): Promise<string>;
+    /**
+     * Move onto a branch, bringing the working tree with it.
+     *
+     * Unlike {@link checkout}, this ATTACHES head: later commits advance the
+     * branch. Checking out a bare commit deliberately does not, so that
+     * committing from a historical state cannot silently rewrite a branch.
+     */
+    switchTo(name: string, opts?: {
+        discardChanges?: boolean;
+    }): Promise<void>;
+    /**
+     * Refuse to overwrite work that was never recorded.
+     *
+     * Moving between commits REPLACES the working tree, so uncommitted edits
+     * are gone — and unlike an ordinary overwrite, the person did not ask for
+     * anything to be written. Naming the files is the point: "you have changes"
+     * with no list leaves them guessing what they are about to lose.
+     */
+    private guardWorkingTree;
+    /** The branch HEAD is on, or null when detached. */
+    currentBranch(): Promise<string | null>;
+    /**
+     * Merge another branch into the current one.
+     *
+     * Every part of this is client-side by necessity: the server holds
+     * ciphertext and cannot compare versions, so base, ours and theirs are all
+     * fetched and decrypted here.
+     */
+    merge(name: string, opts?: {
+        discardChanges?: boolean;
+    }): Promise<MergeResult>;
+    /** Decide one path. Returns a conflict when it cannot be settled. */
+    private settlePath;
+    private take;
+    /**
+     * The most recent commit reachable from both.
+     *
+     * Walks our ancestry into a set, then theirs breadth-first until it hits it —
+     * so the first match is the nearest, which is what a three-way merge needs.
+     */
+    mergeBase(a: string, b: string): Promise<string | null>;
+    /** Every file in a commit, by path. */
+    private filesOf;
+}
+/**
+ * Version control over the VFS.
+ *
+ * One repository per project, addressed by slug — the same slug the VFS stores
+ * that project's working tree under. `client.vcs.open("my-app")` is the whole
+ * entry point.
+ */
+declare class VcsNamespace {
+    private readonly deps;
+    private readonly repos;
+    constructor(deps: VcsNamespaceOptions);
+    /** The repository for one project. Cheap and cached; creates nothing. */
+    open(slug: string): Repo;
+}
+interface VcsNamespaceOptions {
+    vfs: VfsNamespace;
+    store: VfsStore;
+    /** The in-memory master seed, or null when locked. Read per call. */
+    seed: () => Uint8Array | null;
+    author: () => string;
+}
+
 /** The hosted Muhkoo Accelerator — the default {@link ClientOptions.baseUrl}. */
 declare const DEFAULT_BASE_URL = "https://api.muhkoo.dev";
 /** The hosted auth SPA — the default {@link ClientOptions.authBaseUrl}. */
@@ -5872,6 +6247,8 @@ declare class Client {
     readonly storage: StorageNamespace;
     /** Filesystem over the personal space: directories, versions, real paths. */
     readonly vfs: VfsNamespace;
+    /** Version control over the VFS: commits, branches, merges — per project. */
+    readonly vcs: VcsNamespace;
     /** Realtime messaging — `client.message.subscribe(...)`, etc. */
     readonly message: MessageNamespace;
     /** Fan-out group spaces — `client.space.createSpace(...)`, etc. */
@@ -6065,6 +6442,47 @@ declare function loadDeviceIdentity(): Promise<PersistedDeviceIdentity | null>;
  */
 declare function clearDeviceIdentity(): Promise<void>;
 
+/**
+ * Three-way line merge.
+ *
+ * Given a common ancestor and two descendants, produce the combined text — or
+ * report the regions where both sides changed the same lines differently.
+ *
+ * The server cannot do any of this: it holds ciphertext and cannot compare
+ * versions, so merging is entirely a client concern and has to be exact here.
+ */
+interface MergeRegionConflict {
+    /** 1-based line where the conflict begins in the merged output. */
+    line: number;
+    ours: string[];
+    theirs: string[];
+}
+interface Merge3Result {
+    lines: string[];
+    conflicts: MergeRegionConflict[];
+}
+/**
+ * Merge `ours` and `theirs` over their common ancestor `base`.
+ *
+ * A region where only one side changed takes that side. A region where both
+ * made the SAME change takes it once — two people fixing the same typo is not a
+ * conflict. Only genuinely divergent edits conflict.
+ */
+declare function merge3(base: string[], ours: string[], theirs: string[]): Merge3Result;
+/**
+ * Merge to text, writing conflict markers where the sides diverged.
+ *
+ * Markers rather than a bespoke format: they are what every developer already
+ * knows how to resolve, and resolving becomes ordinary editing.
+ */
+declare function merge3Text(base: string, ours: string, theirs: string, labels?: {
+    ours: string;
+    theirs: string;
+}): {
+    text: string;
+    conflicted: boolean;
+};
+
 /**
  * Passkey factor (M1.1) — WebAuthn with the **PRF extension**.
  *
@@ -7055,5 +7473,5 @@ declare class KeyringClient implements KeyringTransport {
     fetchMetadata(): Promise<SpaceMetadata | null>;
 }
 
-export { ACCESS_TOKEN_SCOPES, AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, AES_GCM_TAG_BYTES, AccessTokensNamespace, AgentsNamespace, AuthClient, AuthNamespace, AuthPublicInput, Authenticator, BlockEngine, BroadcastChannel, BroadcastChannelEvents, ChannelExistsError, ChannelNotFoundError, ChunkCipher, Client, ConnectivityManager, DEFAULT_AUTH_BASE_URL, DEFAULT_BASE_URL, DEFAULT_FN_HOST_SUFFIX, DEVICE_IDENTITY_STORAGE_KEY, DEVICE_KEY_DB_NAME, DbCache, DevicePairingError, DeviceStoreUnavailableError, DoubleRatchet, DoubleRatchetCipher, DoubleRatchetManager, EncryptedSession, EventCore, EventCoreEvents, Field, Field as FieldElement, FileStorage, FunctionsNamespace, HLC, HashKnowledge, HostedAuth, HttpClient, HttpError, IndexedDbStore, KEEPER_MEMBER_ID, KeyStore, KeyringClient, KvCache, KvNamespace, LocalEngineHost, LocalStorageSessionStore, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, MuhkooAgent, MuhkooDB, MuhkooFunction, MuhkooSpace, NoopStore, OfflineLockedError, OfflineManager, OutboundQueue, P2P_SUBJECT, PAIRING_CODE_ALPHABET, PAIRING_CODE_LENGTH, PBKDF2_DEFAULT_ITERATIONS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PasskeyOriginError, PeerExchange, PeerNetwork, PersonalSpaceClient, Poseidon, PreimagePoK, ReauthRequiredError, ReedSolomonCodec, Space as Room, SerializeMessage, SessionState, ShardCache, ShardClient, SharedSpaceClient, SnapshotNamespace, Space, SpaceCache, SpaceKeyring, SpaceNamespace, SpacePacketCipher, SpaceSignaler, StorageNamespace, SyncEngine, VaultUnavailableError, WSTransport, WebRtcTransport, WorkerEngineHost, ZERO_HLC, ZkAuth, buildCommitment, canonicalUserCode, clearDeviceIdentity, compareHlc, compilePrograms, configureDeviceStore, createPasskeyWithPrf, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultRpId, defaultSessionStore, deleteBeatsWrite, deleteRegister, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, deriveIdentityFromSeed, deriveMasterSeedFromPassword, deviceFingerprint, deviceIdentityIsEphemeral, deviceIdentityKey, ejectAgentPrompt, ejectAgentTools, emptyMap, emptyRegister, encodeToHex, encryptAesGcm, evaluatePasskeyPrf, exportPublicKeyBase64, exportPublicKeyHex, formatUserCode, generateAuthProof, generateDevicePairingKeypair, generatePkce, getMuhkooAppDescriptor, getSubtle, hasDeviceIdentity, initBn128Wasm, initRsWasm, initializeCircuits, isNewer, isOfflineCapable, isP2pCapable, isProvisional, loadDeviceIdentity, manifestToStat, materializeRow, mergeMap, mergeMessage, mergeRegister, messageKey, pack, padHandle, pairingVerificationCode, passkeyPrfCapable, passkeySupported, passkeyUsableFromOrigin, persistDeviceIdentity, poseidonHash, protocol, provisionalHandle, quickVerify, randomBytes, randomState, rpIdUsableForOrigin, sealSeed, sealSeedToDevice, shardHash, signMessage, stableStringify, toField, tombstoneRow, unpack, unsealSeed, unsealSeedFromDevice, unwrapWithPassphrase, verify, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase, writeBeatsTombstone, writeColumns, writeRegister };
-export type { ACL, ACLEntry, AccessTokenInfo, AccessTokensNamespaceDeps, AgentConfig, AgentCreateInput, AgentDbToolMode, AgentProvisioned, AgentScopeOpts, AgentSkill, AgentToolsConfig, AgentTrigger, AgentTriggerType, AgentUpdateInput, AgentsNamespaceDeps, AttachedPeerNetwork, AuthClientOptions, AuthKeyPair, AuthSuccess, AuthToken, AuthType, AuthUser, BlockStore, Bn128WasmInstance, BroadcastChannelEvent, BroadcastChannelOptions, CachedSpaceMessage, ChannelLike, ChunkKeyMaterial, ChunkManifest, CipherFrame, CipherMessage, CipherMessageHeader, CircuitBufferConfig, CircuitUrls, ClientOptions, ConnectivityOptions, ConnectivityState, CreateAccessTokenInput, CreatedAccessToken, DbQueryPage, DehydratedKeypair, DehydratedKeys, DeviceBlobStore, DeviceKeyVault, DevicePairingErrorReason, DevicePairingKeypair, DevicePairingPoll, DevicePairingRequest, DevicePairingSession, DoubleRatchetCipherDeps, ECDHCurve, EncodeResult, EngineHandle, EngineHost, EphemeralEvent, EpochKeyProvider, FileManifest, FileNamespaceDeps, FileStat, FileStorageOptions, FunctionCaps, FunctionConfig, FunctionDeployInput, FunctionInvokeOptions, FunctionScopeOpts, FunctionTrigger, FunctionTriggerType, FunctionTriggers, FunctionUpdateInput, FunctionsNamespaceDeps, Groth16Proof, Hasher, HlcParts, HlcState, HostedAuthDeps, HttpClientOptions, IncomingFrame, KeyExchangeFrame, KeyPair, Keypair, KeyringClientDeps, KeyringTransport, KvEntry, KvNamespaceDeps, LoginOptions, LwwMap, LwwRegister, MessageBody, MessageDeletedEvent, MessageEntry, MessageEvent, MessageHeaders, MessageNamespaceDeps, MessageOp, MessageOptions, MessageSubscription, MuhkooAgentMeta, MuhkooAgentToolsConfig, MuhkooAppDescriptor, MuhkooDBAccess, MuhkooDBMeta, MuhkooFunctionMeta, MuhkooKeystoreBridge, MuhkooMessageEvent, MuhkooSpaceMeta, OAuthProvider, OfflineEntry, OfflineManagerDeps, OfflineStore, OutSink, PacketCipher, PacketHeaders, PacketOptions, PairedDevice, Participant, PasskeyEnrollment, PeerBlockSource, PeerExchangeOptions, PeerId, PeerNetworkOptions, PeerTransport, Permission, PermissionCheckRequest, PermissionCheckResult, PersistedDeviceIdentity, PersonalSpaceClientOptions, Pkce, PublicKeyJWK, QueueEntry, RatchetState, ReceiveResult, RegisterParams, Replayer, Role, SpaceDeps as RoomDeps, SpaceFileMetadata as RoomFileMetadata, Scope, SealedHandoff, SealedHeaders, Session, SessionOptions, SessionStore, SetOptions, ShardByteCache, ShardClientOptions, SharedSpaceClientOptions, SignalEnvelope, SignalKind, SignalingSpace, SnapshotNamespaceDeps, SnarkProof, SpaceChannelLike, SpaceCursor, SpaceDeps, SpaceFileMetadata, SpaceKeyCache, SpaceKeyringDeps, SpaceMessageEvent, SpaceNamespaceDeps, SpaceOfflineAdapter, StartDevicePairingOptions, StorageChangeEvent, StoreName, StoredSession, Subscription, UserIdentity, VaultFactor, VerificationKey, WSMessage, WSMessageType, WSTransportOptions, WaitForDevicePairingOptions, WebRtcTransportOptions, WrappedPayload, WriteFileInput, WriteFileOptions, WriteToShardsInput, ZkAuthDeps, ZkAuthenticateRequest, ZkChallengeResponse, ZkCompiled, ZkIdentity, ZkRegisterRequest, ZkRegisterResponse };
+export { ACCESS_TOKEN_SCOPES, AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, AES_GCM_TAG_BYTES, AccessTokensNamespace, AgentsNamespace, AuthClient, AuthNamespace, AuthPublicInput, Authenticator, BlockEngine, BroadcastChannel, BroadcastChannelEvents, ChannelExistsError, ChannelNotFoundError, ChunkCipher, Client, ConnectivityManager, DEFAULT_AUTH_BASE_URL, DEFAULT_BASE_URL, DEFAULT_BRANCH, DEFAULT_FN_HOST_SUFFIX, DEVICE_IDENTITY_STORAGE_KEY, DEVICE_KEY_DB_NAME, DbCache, DevicePairingError, DeviceStoreUnavailableError, DoubleRatchet, DoubleRatchetCipher, DoubleRatchetManager, EncryptedSession, EventCore, EventCoreEvents, Field, Field as FieldElement, FileStorage, FunctionsNamespace, HLC, HashKnowledge, HostedAuth, HttpClient, HttpError, IndexedDbStore, KEEPER_MEMBER_ID, KeyStore, KeyringClient, KvCache, KvNamespace, LocalEngineHost, LocalStorageSessionStore, MemorySessionStore, Message, Message as MessageDefault, MessageNamespace, MuhkooAgent, MuhkooDB, MuhkooFunction, MuhkooSpace, NoopStore, OfflineLockedError, OfflineManager, OutboundQueue, P2P_SUBJECT, PAIRING_CODE_ALPHABET, PAIRING_CODE_LENGTH, PBKDF2_DEFAULT_ITERATIONS, PREIMAGE_POK_VERIFICATION_KEY, Packet, PasskeyOriginError, PeerExchange, PeerNetwork, PersonalSpaceClient, Poseidon, PreimagePoK, ROOT_ID, ReauthRequiredError, ReedSolomonCodec, Repo, Space as Room, SerializeMessage, SessionState, ShardCache, ShardClient, SharedSpaceClient, SnapshotNamespace, Space, SpaceCache, SpaceKeyring, SpaceNamespace, SpacePacketCipher, SpaceSignaler, StorageNamespace, SyncEngine, VFS_ROOT_INFO, VaultUnavailableError, VcsError, VcsNamespace, VfsConflictError, VfsLockedError, VfsNamespace, VfsNotFoundError, WSTransport, WebRtcTransport, WorkerEngineHost, ZERO_HLC, ZkAuth, buildCommitment, canonicalUserCode, clearDeviceIdentity, compareHlc, compilePrograms, configureDeviceStore, createPasskeyWithPrf, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultRpId, defaultSessionStore, deleteBeatsWrite, deleteRegister, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, deriveIdentityFromSeed, deriveMasterSeedFromPassword, deviceFingerprint, deviceIdentityIsEphemeral, deviceIdentityKey, dirKey, ejectAgentPrompt, ejectAgentTools, emptyMap, emptyRegister, encodeToHex, encryptAesGcm, evaluatePasskeyPrf, exportPublicKeyBase64, exportPublicKeyHex, formatUserCode, generateAuthProof, generateDevicePairingKeypair, generatePkce, getMuhkooAppDescriptor, getSubtle, hasDeviceIdentity, headKey, historyKey, initBn128Wasm, initRsWasm, initializeCircuits, isNewer, isOfflineCapable, isP2pCapable, isProvisional, loadDeviceIdentity, manifestToStat, materializeRow, merge3, merge3Text, mergeKey, mergeMap, mergeMessage, mergeRegister, messageKey, objectKey, pack, padHandle, pairingVerificationCode, passkeyPrfCapable, passkeySupported, passkeyUsableFromOrigin, persistDeviceIdentity, poseidonHash, protocol, provisionalHandle, quickVerify, randomBytes, randomState, refKey, refsIndexKey, rpIdUsableForOrigin, sealSeed, sealSeedToDevice, shardHash, signMessage, stableStringify, toField, tombstoneRow, unpack, unsealSeed, unsealSeedFromDevice, unwrapWithPassphrase, verify, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase, writeBeatsTombstone, writeColumns, writeRegister };
+export type { ACL, ACLEntry, AccessTokenInfo, AccessTokensNamespaceDeps, AgentConfig, AgentCreateInput, AgentDbToolMode, AgentProvisioned, AgentScopeOpts, AgentSkill, AgentToolsConfig, AgentTrigger, AgentTriggerType, AgentUpdateInput, AgentsNamespaceDeps, AttachedPeerNetwork, AuthClientOptions, AuthKeyPair, AuthSuccess, AuthToken, AuthType, AuthUser, BlockStore, Bn128WasmInstance, BroadcastChannelEvent, BroadcastChannelOptions, CachedSpaceMessage, Change, ChannelLike, ChunkKeyMaterial, ChunkManifest, CipherFrame, CipherMessage, CipherMessageHeader, CircuitBufferConfig, CircuitUrls, ClientOptions, Commit, Conflict, ConnectivityOptions, ConnectivityState, CreateAccessTokenInput, CreatedAccessToken, DbQueryPage, DehydratedKeypair, DehydratedKeys, DeviceBlobStore, DeviceKeyVault, DevicePairingErrorReason, DevicePairingKeypair, DevicePairingPoll, DevicePairingRequest, DevicePairingSession, DirEntry, DirNode, DoubleRatchetCipherDeps, ECDHCurve, EncodeResult, EngineHandle, EngineHost, Entry, EphemeralEvent, EpochKeyProvider, FileEntry, FileManifest, FileNamespaceDeps, FileStat, FileStorageOptions, FunctionCaps, FunctionConfig, FunctionDeployInput, FunctionInvokeOptions, FunctionScopeOpts, FunctionTrigger, FunctionTriggerType, FunctionTriggers, FunctionUpdateInput, FunctionsNamespaceDeps, Groth16Proof, Hasher, Head, HistoryRecord, HlcParts, HlcState, HostedAuthDeps, HttpClientOptions, IncomingFrame, KeyExchangeFrame, KeyPair, Keypair, KeyringClientDeps, KeyringTransport, KvEntry, KvNamespaceDeps, LogEntry, LoginOptions, LwwMap, LwwRegister, Merge3Result, MergeRegionConflict, MergeResult, MessageBody, MessageDeletedEvent, MessageEntry, MessageEvent, MessageHeaders, MessageNamespaceDeps, MessageOp, MessageOptions, MessageSubscription, MuhkooAgentMeta, MuhkooAgentToolsConfig, MuhkooAppDescriptor, MuhkooDBAccess, MuhkooDBMeta, MuhkooFunctionMeta, MuhkooKeystoreBridge, MuhkooMessageEvent, MuhkooSpaceMeta, OAuthProvider, OfflineEntry, OfflineManagerDeps, OfflineStore, OutSink, PacketCipher, PacketHeaders, PacketOptions, PairedDevice, Participant, PasskeyEnrollment, PeerBlockSource, PeerExchangeOptions, PeerId, PeerNetworkOptions, PeerTransport, Permission, PermissionCheckRequest, PermissionCheckResult, PersistedDeviceIdentity, PersonalSpaceClientOptions, Pkce, PublicKeyJWK, QueueEntry, RatchetState, ReceiveResult, RegisterParams, Replayer, Role, SpaceDeps as RoomDeps, SpaceFileMetadata as RoomFileMetadata, Scope, SealedHandoff, SealedHeaders, SealedRecord, Session, SessionOptions, SessionStore, SetOptions, ShardByteCache, ShardClientOptions, SharedSpaceClientOptions, SignalEnvelope, SignalKind, SignalingSpace, SnapshotNamespaceDeps, SnarkProof, SpaceChannelLike, SpaceCursor, SpaceDeps, SpaceFileMetadata, SpaceKeyCache, SpaceKeyringDeps, SpaceMessageEvent, SpaceNamespaceDeps, SpaceOfflineAdapter, StartDevicePairingOptions, StorageChangeEvent, StoreName, StoredSession, Subscription, Tree, TreeDir, TreeEntry, TreeFile, UserIdentity, VaultFactor, VcsNamespaceDeps, VcsNamespaceOptions, VerificationKey, VfsContentStore, VfsNamespaceDeps, VfsStat, VfsStore, WSMessage, WSMessageType, WSTransportOptions, WaitForDevicePairingOptions, WebRtcTransportOptions, WrappedPayload, WriteFileInput, WriteFileOptions, WriteToShardsInput, ZkAuthDeps, ZkAuthenticateRequest, ZkChallengeResponse, ZkCompiled, ZkIdentity, ZkRegisterRequest, ZkRegisterResponse };