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

package/dist/connect.d.ts

@@ -1152,6 +1152,310 @@ declare class PaymentRequiredError extends HttpError {
     constructor(message: string, code: PaymentRequiredCode, body?: unknown, upgradeUrl?: string);
 }
 
+/**
+ * Wire types for shared folders. These mirror the accelerator's `/api/shares` JSON
+ * (`ShareInfo` in the accelerator's `durable-objects/space/share.ts`).
+ */
+type ShareKind = "public" | "private";
+/** Who may change a file: `own` = its uploader and the owner; `any` = any member (private shares only). */
+type EditPolicy = "own" | "any";
+interface ShareInfo {
+    kind: ShareKind;
+    ownerUsername: string;
+    /** Storage cap in bytes, or null for no cap. */
+    limitBytes: number | null;
+    usedBytes: number;
+    editPolicy: EditPolicy;
+    name: string;
+    /** Set once the share was rotated into another Space; follow `successor`. */
+    closed: {
+        successor: string;
+        at: number;
+    } | null;
+    /** The member list (usernames). */
+    members: string[];
+    /**
+     * Display names by username, for uploaders and admitted members: label files by their `owner` with it. After a
+     * rotation it also holds uploaders not (yet) re-admitted, so it is not the member list.
+     */
+    names: Record<string, string>;
+}
+/** One row of `GET /api/shares`. */
+interface ShareSummary {
+    spaceId: string;
+    kind: ShareKind;
+    owner: string;
+    name: string;
+}
+/** The password verifier the server stores for a public share (`proof` is derived from it). */
+type PasswordVerifier = {
+    salt: string;
+    iterations: number;
+    verifier: string;
+};
+/** `GET /api/shares/:spaceId/public`: what a guest needs before being admitted (app key only, no session). */
+interface SharePublicInfo {
+    kind: "public";
+    name: string;
+    ownerUsername: string;
+    password: {
+        salt: string;
+        iterations: number;
+    };
+    closed: {
+        successor: string;
+        at: number;
+    } | null;
+}
+interface CreateShareBody {
+    spaceId: string;
+    kind: ShareKind;
+    name: string;
+    limitBytes: number | null;
+    editPolicy: EditPolicy;
+    password?: PasswordVerifier;
+}
+/** `POST /api/shares/:spaceId/admit`, sent with the signed-in account's session. */
+interface ShareAdmitBody {
+    /** `passwordProof(password, salt, iterations)` with the share's public salt and iterations. */
+    proof: string;
+    /** The display name shown next to this member's uploads: 1–40 characters after trimming, no control characters. */
+    name: string;
+}
+
+/**
+ * Typed refusals from the shares API. Each extends {@link HttpError}, so code that only knows `HttpError` still
+ * sees the status and body. Codes are the accelerator's wire contract.
+ */
+
+/** 402 `share_full`: the share is at its storage cap. */
+declare class ShareFullError extends HttpError {
+    readonly limitBytes: number;
+    readonly usedBytes: number;
+    /**
+     * How many items of a `Share.writeMany` were not written (the refused one and every one after it). The
+     * server's body has no such field, so it is 0 on an error straight from the wire.
+     */
+    readonly refused: number;
+    constructor(message: string, limitBytes: number, usedBytes: number, 
+    /**
+     * How many items of a `Share.writeMany` were not written (the refused one and every one after it). The
+     * server's body has no such field, so it is 0 on an error straight from the wire.
+     */
+    refused: number, body?: unknown);
+}
+/** 409 `share_closed`: the share was rotated; use `successor` instead. */
+declare class ShareClosedError extends HttpError {
+    readonly successor: string;
+    constructor(message: string, successor: string, body?: unknown);
+}
+/** 403 `share_password`: wrong password. */
+declare class SharePasswordError extends HttpError {
+    constructor(message: string, body?: unknown);
+}
+/** 429 `share_password_rate`: too many wrong passwords. */
+declare class SharePasswordRateError extends HttpError {
+    readonly retryAfterSeconds: number;
+    constructor(message: string, retryAfterSeconds: number, body?: unknown);
+}
+/** 403 `share_member_limit`: the share holds as many members as it allows. */
+declare class ShareMemberLimitError extends HttpError {
+    constructor(message: string, body?: unknown);
+}
+/** 409 `share_space_not_empty`: only an empty Space can become a share. */
+declare class ShareSpaceNotEmptyError extends HttpError {
+    constructor(message: string, body?: unknown);
+}
+/** 409 `share_space_not_ready`: the Space has no `/metadata` yet; create the Space before making it a share. */
+declare class ShareSpaceNotReadyError extends HttpError {
+    constructor(message: string, body?: unknown);
+}
+/** 409 `rotation_mismatch`: a retried rotation asked for other settings than the one in progress. */
+declare class RotationMismatchError extends HttpError {
+    constructor(message: string, body?: unknown);
+}
+/** 409 `rotation_in_progress`: another rotation of this share won; `successor` is its new Space. */
+declare class RotationInProgressError extends HttpError {
+    readonly successor: string;
+    constructor(message: string, successor: string, body?: unknown);
+}
+/**
+ * A rotation (`changePassword` / `removeMember`) claimed `newSpaceId` but its adopt did not finish (network failure
+ * or server error, retried). It is kept on this device: call the same rotation again, or `shares.resumeRotation`,
+ * to finish it into the SAME Space. No other rotation of this share starts until it does.
+ */
+declare class RotationIncompleteError extends Error {
+    readonly from: string;
+    readonly newSpaceId: string;
+    readonly cause?: unknown | undefined;
+    constructor(from: string, newSpaceId: string, cause?: unknown | undefined);
+}
+/** A guest recovery code that does not parse (expected `<username>:<words>`). */
+declare class InvalidRecoveryCodeError extends Error {
+    constructor(message?: string);
+}
+/** `restoreGuest` would replace another guest's login kept on this device; pass `{ replace: true }` to do so. */
+declare class GuestLoginConflictError extends Error {
+    readonly existing: string;
+    constructor(existing: string);
+}
+/**
+ * The typed error for a refused response, or null when it is not a share refusal (the caller then throws what it
+ * threw before). `body` is the parsed JSON or the raw response text. `retryAfterSeconds` is the `Retry-After`
+ * header, used for a 429.
+ */
+declare function shareErrorFrom(status: number, body: unknown, retryAfterSeconds?: number): Error | null;
+
+/**
+ * `HttpClient` — the one place the unified {@link Client} talks to the
+ * accelerator over HTTP.
+ *
+ * Every request carries two independent credentials:
+ *   - the **app key** (`mk_…`) on `X-Muhkoo-Key` — resolves the app /
+ *     developer / env context the accelerator uses for routing + billing;
+ *   - the **user session token** on `X-Muhkoo-Session` (when a user is
+ *     logged in) — the accelerator validates it and injects a trusted
+ *     `X-Muhkoo-User-Context` downstream so per-user spaces can authorize
+ *     the request without a fresh Groth16 proof.
+ *
+ * `X-Muhkoo-Key` is used (rather than `Authorization: Bearer`) because it is
+ * a non-forbidden header that skips the CORS preflight in browsers.
+ *
+ * The class exposes a header-injecting {@link fetch} that can be handed to
+ * lower-level building blocks (`AuthClient`, `PersonalSpaceClient`) so they
+ * keep owning their own wire shapes while still getting the credentials, plus
+ * convenience JSON helpers (`get`/`post`/`del`) for code that talks to the
+ * accelerator directly.
+ */
+interface HttpClientOptions {
+    /** Absolute URL of the accelerator worker (trailing slash optional). */
+    baseUrl: string;
+    /**
+     * App / publishable key, e.g. `mk_test_pk_…`. Sent on every request as
+     * `X-Muhkoo-Key` when present. Transitionally optional (auth + personal
+     * storage still function without it), but the product direction is to
+     * REQUIRE it — it attributes traffic for billing/metering and authorizes
+     * shared-space (messaging) websockets.
+     */
+    apiKey?: string;
+    /**
+     * A scoped, expiring **access token** (`mk_<env>_at_…`) — the non-ZK
+     * machine-to-machine credential. It resolves through the SAME accelerator
+     * path as an app key and rides the same `X-Muhkoo-Key` header; when present
+     * it takes precedence over {@link apiKey}. Use it for server-side / CI
+     * callers that shouldn't carry the app's publishable key.
+     */
+    accessToken?: string;
+    /** Returns the current user session token, or `null` when logged out. */
+    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`) and
+     * {@link HttpClient.fetchWithRecovery}; the raw {@link fetch} passes 401s
+     * straight through so the auth wire calls that power recovery itself
+     * can't recurse.
+     */
+    onUnauthorized?: () => Promise<boolean>;
+}
+
+declare class HttpClient {
+    readonly baseUrl: string;
+    /** Origin of {@link baseUrl} — credentials are only attached same-origin. */
+    private readonly baseOrigin;
+    private readonly apiKey;
+    /** Scoped machine access token — takes precedence over {@link apiKey} on `X-Muhkoo-Key`. */
+    private readonly accessToken;
+    private readonly getSessionToken;
+    private readonly onUnauthorized;
+    private readonly fetchFn;
+    constructor(opts: HttpClientOptions);
+    /**
+     * A `fetch`-compatible function that injects the app key + session token
+     * headers. Hand this to `AuthClient` / `PersonalSpaceClient` so they pick
+     * up credentials without knowing about them.
+     */
+    readonly fetch: typeof fetch;
+    /**
+     * {@link fetch} with the JSON helpers' stale-session recovery: a 401 on a
+     * request made while a session token is held runs `onUnauthorized` once
+     * and, if that recovered, replays the request once with the fresh token.
+     * The final response is returned whatever its status, never thrown. The
+     * replay re-sends `init` as given, so its body must be re-sendable (a
+     * string or bytes, not a stream).
+     */
+    readonly fetchWithRecovery: typeof fetch;
+    /**
+     * A client for the same accelerator and key that never sends a session token and never recovers one. For routes
+     * that need only the app key (a public share's pre-admission info).
+     */
+    withoutSession(): HttpClient;
+    /** True when `input` resolves to {@link baseOrigin} (relative URLs always do). */
+    private isSameOrigin;
+    get<T = unknown>(path: string): Promise<T>;
+    post<T = unknown>(path: string, body?: unknown): Promise<T>;
+    put<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;
+}
+
+/**
+ * `SharesClient` — the thin HTTP layer over the accelerator's `/api/shares` routes. It owns paths, verbs and error
+ * mapping and nothing else; the `Share` object and `client.shares` build on it.
+ *
+ * Every call but `publicInfo` carries the app key and the signed-in session (with the usual stale-session recovery),
+ * including `admit`: a public share's guest is an ordinary account. `publicInfo` needs only the app key and never
+ * sends a session.
+ */
+
+declare class SharesClient {
+    private readonly http;
+    private readonly keyOnlyHttp;
+    constructor(http: HttpClient);
+    create(body: CreateShareBody): Promise<ShareInfo>;
+    list(): Promise<ShareSummary[]>;
+    info(spaceId: string): Promise<ShareInfo>;
+    update(spaceId: string, patch: {
+        limitBytes?: number | null;
+        editPolicy?: EditPolicy;
+    }): Promise<ShareInfo>;
+    /** A public share's name, owner and password salt, read before admission. Publishable key only; never the verifier. */
+    publicInfo(spaceId: string): Promise<SharePublicInfo>;
+    /**
+     * Admit the signed-in account to a public share by proving its password. Afterwards the account is a member:
+     * it sends its own `/keyring/join-request`. Re-admitting the same account only updates its name.
+     */
+    admit(spaceId: string, body: ShareAdmitBody): Promise<void>;
+    removeMember(spaceId: string, username: string): Promise<void>;
+    /** Rotate: `from` is the old share, `newSpaceId` the Space the client made and seeded. */
+    adopt(newSpaceId: string, body: {
+        from: string;
+        password?: PasswordVerifier;
+        remove?: string[];
+    }): Promise<ShareInfo>;
+    private send;
+}
+
+/**
+ * Public-share password proof. The password never leaves the device: the guest sends
+ * `proof = base64(PBKDF2-SHA256(password, salt, iterations, 32 bytes))` and the server stores
+ * `verifier = base64(SHA-256(proof bytes))`. The salt is an opaque string chosen at creation time;
+ * both sides use its UTF-8 bytes.
+ */
+
+declare const SHARE_PASSWORD_ITERATIONS = 310000;
+/** What a guest sends to prove it knows the password. */
+declare function passwordProof(password: string, salt: string, iterations: number): Promise<string>;
+/** What the share owner registers at creation: a fresh salt and the verifier for `password`. */
+declare function newPasswordVerifier(password: string): Promise<PasswordVerifier>;
+
 /**
  * Cloudflare-Workers-compatible Groth16 ZK proof verifier.
  *
@@ -1388,6 +1692,13 @@ type OprfProtocol = typeof OPRF_PROTOCOL_BASE | typeof OPRF_PROTOCOL_POPRF;
  * one meant regex-matching a sentence the server is free to reword. See
  * `VaultUnavailableError`, which still does exactly that for rate limits.
  */
+/** One Google account matched: the single-use token, the Google `sub`, and (when the lookup named it) the username. */
+interface GoogleVerifyOne {
+    verifyToken: string;
+    sub: string;
+    emailHint: string | null;
+    username?: string;
+}
 declare class AuthHttpError extends Error {
     readonly label: string;
     readonly status: number;
@@ -1521,11 +1832,21 @@ declare class AuthClient {
     googleVerify(opts: {
         idToken: string;
         token?: string;
+        username: string;
+    }): Promise<GoogleVerifyOne>;
+    googleVerify(opts: {
+        idToken: string;
+        token: string;
         username?: string;
-    }): Promise<{
-        verifyToken: string;
-        sub: string;
-        emailHint: string | null;
+    }): Promise<GoogleVerifyOne>;
+    googleVerify(opts: {
+        idToken: string;
+    }): Promise<GoogleVerifyOne | {
+        usernames: string[];
+    }>;
+    /** Is `redirectUri` registered for `appId`? (Public; used before sending a user to a logout target.) */
+    redirectCheck(appId: string, redirectUri: string): Promise<{
+        allowed: boolean;
     }>;
     /** Mint a single-use authorization code for an app (called by the hosted page; session-authed). */
     grant(token: string, body: {
@@ -2936,6 +3257,160 @@ declare class ReedSolomonCodec {
  */
 declare function initRsWasm(wasmModule?: WebAssembly.Module): Promise<void>;
 
+/**
+ * `Share` — one shared folder: a folder view over the share Space's file records and the file operations on it.
+ *
+ * The folder tree is built from each file record's `path` (`"a/c/d.jpg"`). An empty folder is a zero-byte record
+ * of type {@link SHARE_DIR_TYPE}; a folder that holds files needs no record of its own.
+ *
+ * Files use the Space file store (`/api/spaces/:id/files`) and the Space's own shard route
+ * (`PUT /api/spaces/:id/shards/:hash`), which is where a share's limit is enforced and its owner billed. The
+ * server stamps each file's uploader on its first write and lists it as `owner`; renaming re-posts the same file
+ * id, so the uploader never changes.
+ *
+ * Every call carries the app key and the signed-in user's session (with the client's stale-session recovery).
+ */
+
+/** The MIME type of an empty-folder record. */
+declare const SHARE_DIR_TYPE = "inode/directory";
+interface ShareEntry {
+    /** Full path inside the share, no leading slash (`"a/c/d.jpg"`). */
+    path: string;
+    name: string;
+    kind: "file" | "dir";
+    /** Bytes; for a folder, the total of the files under it. */
+    size: number;
+    /** Last modified (ms epoch); for a folder, the newest record under it. */
+    mtime: number;
+    /** Who uploaded it (a username). `""` for a legacy file with no recorded uploader, or a folder with no record of its own. */
+    uploader: string;
+    /** The uploader's display name from `ShareInfo.names`, else the username; `"Unknown"` for a legacy file. */
+    uploaderName: string;
+    /**
+     * Whether the server would let the caller change or delete it (it mirrors the server's `canChangeFile`). For a
+     * folder: whether every record under it is changeable, since deleting a folder deletes them all.
+     */
+    canChange: boolean;
+}
+interface ShareOptions {
+    /** The app's HTTP client (app key and the signed-in session). */
+    http: HttpClient;
+    spaceId: string;
+    /** The signed-in caller's username. */
+    me: string;
+    /** A pre-compiled Reed-Solomon module, for runtimes without the bundled loader (Node tests, Workers). */
+    rsWasmModule?: WebAssembly.Module;
+}
+/** A file for {@link Share.adopt}: content already stored, named by its manifest. */
+interface ShareAdoptFile {
+    kind: "file";
+    /** Path inside the share. */
+    path: string;
+    manifest: FileManifest;
+    /** Unique among the items and stable across runs (the VFS file id): names the record when the manifest's id is taken. */
+    key: string;
+}
+/** An item for {@link Share.adopt}: a file, or an empty folder. */
+type ShareAdoptItem = ShareAdoptFile | {
+    kind: "folder";
+    path: string;
+};
+declare class Share {
+    readonly spaceId: string;
+    private readonly http;
+    private readonly me;
+    private readonly files;
+    constructor(opts: ShareOptions);
+    /** The share record (`GET /api/shares/:id`). */
+    info(): Promise<ShareInfo>;
+    /** The entries directly inside `dir` (the root by default): folders first, then by name. */
+    list(dir?: string): Promise<ShareEntry[]>;
+    read(path: string): Promise<Uint8Array>;
+    /**
+     * Upload `data` to `path`, replacing the file already there (same file id, so its uploader is kept; the server
+     * refuses if the caller may not change it). `onProgress` gets the fraction done, 0 to 1.
+     */
+    write(path: string, data: Blob | Uint8Array, opts?: {
+        type?: string;
+        onProgress?: (n: number) => void;
+    }): Promise<ShareEntry>;
+    /**
+     * Upload several files in order. At the first `share_full` it stops and throws a {@link ShareFullError} whose
+     * `refused` is the number of items not written (that one and every one after it).
+     */
+    writeMany(items: Array<{
+        path: string;
+        data: Blob | Uint8Array;
+        type?: string;
+    }>): Promise<ShareEntry[]>;
+    /** Make an empty folder: a zero-byte record of type {@link SHARE_DIR_TYPE}. A folder already there is left alone. */
+    mkdir(path: string): Promise<void>;
+    /**
+     * Delete a file, or a folder and every record under it. Nothing there is not an error. Every record is checked
+     * first: if the caller may not change one of them, nothing is deleted.
+     */
+    delete(path: string): Promise<void>;
+    /**
+     * Move a file or folder by rewriting each record's `path` in place (same file id), so uploaders are unchanged —
+     * except a legacy file with no recorded uploader, which the server stamps to whoever rewrites it, i.e. the
+     * renamer.
+     *
+     * Every record is checked first: if the caller may not change one of them, nothing moves. A folder moves one
+     * record at a time; if that stops part-way (a network failure), the error names what already moved, and
+     * calling the same `rename` again finishes the move.
+     */
+    rename(from: string, to: string): Promise<void>;
+    /**
+     * Put files whose content is already stored into the share without uploading a byte: each file's existing
+     * manifest is posted to the share's file store at `path` (shards are content-addressed and every Space reads
+     * the same shard store; the server charges the share for the bytes it finds stored). For
+     * `client.shares.shareFolder`, which owns the share; not a general upload path.
+     *
+     * Safe to run again over the same items: a file already in the share at its path with the id it was given
+     * (the manifest's id, or `<manifest id>.<key>` when another file in the share has that one) is not posted
+     * again, and a file that moved inside the folder since moves in the share. `onEach(item, posted, recordId)`
+     * runs after each file is in the share, `posted` false when it was there already, `recordId` the id of the
+     * record that holds it; an error from it stops the run. `beforePost(item, recordId)` runs just before each
+     * record (a file's, or an empty folder's) is posted, so a caller can note what it is about to put in the share
+     * before it is there; an error from it stops the run before that post. Empty folders become folder records
+     * unless something is at or below their path already.
+     *
+     * At the first `share_full` it stops with a {@link ShareFullError} whose `refused` is the number of files
+     * not put in the share.
+     */
+    adopt(items: ShareAdoptItem[], onEach?: (item: ShareAdoptFile, posted: boolean, recordId: string) => Promise<void>, beforePost?: (item: ShareAdoptItem, recordId: string) => Promise<void>): Promise<void>;
+    /**
+     * Delete the records with these ids that the caller uploaded and `keep` does not keep. For
+     * `client.shares.shareFolder`, taking back what an earlier run of it put in the share that is no longer in the
+     * folder; not a general delete. A record someone else uploaded (the server's stamped uploader is not the
+     * caller) is never touched, nor is an id not in the share. Returns the ids deleted.
+     */
+    removeAdopted(ids: Iterable<string>, keep?: (record: {
+        id: string;
+        path: string;
+        kind: "file" | "dir";
+    }) => boolean): Promise<string[]>;
+    /** Bytes stored and the limit (null = no limit). */
+    usage(): Promise<{
+        usedBytes: number;
+        limitBytes: number | null;
+    }>;
+    private writeInto;
+    private fileEntry;
+    /** A 403 naming the first of `records` the caller may not change, before anything is sent. */
+    private refuseUnchangeable;
+    /** The server's `canChangeFile`, from the caller's side. */
+    private canChange;
+    private records;
+    private postManifest;
+    private filesBase;
+    /** The app's fetch with the session's stale-session recovery. Bodies here are strings or bytes, so a replay is safe. */
+    private readonly send;
+    /** {@link send} for shard requests: a share refusal (full, closed) is thrown typed; anything else is left to `ShardClient`. */
+    private readonly shardFetch;
+    private json;
+}
+
 /**
  * `SessionState` — the in-memory source of truth for "who is signed in" on a
  * {@link Client}.
@@ -3275,6 +3750,15 @@ declare class HostedAuth {
         prompt?: "login";
         returnTo?: string;
     }): Promise<string>;
+    /**
+     * (App side) Sign the browser out of the hosted page too, then land on
+     * `redirectUri`. The hosted page only honours a `redirectUri` the app has
+     * registered; any other lands on its own page. Redirects the browser.
+     */
+    logout(opts: {
+        appId: string;
+        redirectUri: string;
+    }): void;
     /**
      * (App side) Send the user to centralized account & security management on
      * the hosted page (auth.muhkoo.dev/security) — manage passkeys, recovery
@@ -3555,6 +4039,13 @@ declare class VaultProtocolMismatchError extends Error {
 declare class DeviceRevokedError extends Error {
     constructor();
 }
+/**
+ * `signInWithGoogle` without a username found no Muhkoo account linked to this
+ * Google account. Ask for the username and call again with `{ username }`.
+ */
+declare class GoogleNotLinkedError extends Error {
+    constructor();
+}
 /** What the auth methods resolve to — the stable, non-secret user facts. */
 interface AuthUser {
     username: string;
@@ -3711,6 +4202,18 @@ declare class ZkAuth {
      * factor first.
      */
     loginWithGoogle(username: string, idToken: string, opts?: LoginOptions): Promise<AuthUser>;
+    private completeGoogleLogin;
+    /**
+     * Sign in with Google, naming no account. One linked account completes the
+     * sign-in; several return `{ chooseAccount }` (call again with `{ username }`);
+     * none throws {@link GoogleNotLinkedError}. With `username` this is
+     * {@link loginWithGoogle}.
+     */
+    signInWithGoogle(idToken: string, opts?: {
+        username?: string;
+    } & LoginOptions): Promise<AuthUser | {
+        chooseAccount: string[];
+    }>;
     /**
      * Register a brand-new, **passwordless** account whose only factor is Google.
      * A random master seed is generated and wrapped under the Google-gated key;
@@ -3751,6 +4254,13 @@ declare class ZkAuth {
      * its PRF, unwraps the master seed → identity → session.
      */
     loginWithPasskey(username: string, opts?: LoginOptions): Promise<AuthUser>;
+    /**
+     * Can a passkey unlock `username` from THIS origin? `"usable"`, `"none"` (no
+     * passkey enrolled) or `"other-origin"` (enrolled, but for another host).
+     * The vault answers a decoy for absent accounts, so an unknown username
+     * reads like a real one; callers must still handle a failed prompt.
+     */
+    passkeyStatus(username: string): Promise<"usable" | "none" | "other-origin">;
     /**
      * List the user's enrolled login methods (metadata only). Session-authed.
      * Gated factors (email/google) carry a `masked` display hint
@@ -3870,148 +4380,54 @@ declare class ZkAuth {
      *
      * Establishes the ENCRYPTION identity only. It does not authenticate: pair
      * it with a session token (`sessionStore`) for calls that need one.
-     *
-     * Treat a persisted seed as the master credential it is. It is not scoped
-     * and cannot be revoked server-side the way a session token can — rotating
-     * it means moving the identity.
-     */
-    unlockWithSeed(seedBase64: string): void;
-    /** Poseidon commitment for an identity — the value the server stores. */
-    private commitmentFor;
-    /**
-     * Derive the OPRF-gated wrap key for the password factor: `scrypt(password)`
-     * is blinded, evaluated by the server's secret OPRF key (so it can't be
-     * derived offline), unblinded, then HKDF'd into an AES-GCM key.
-     */
-    private passwordWrapKey;
-    /**
-     * Try to recover the master seed from the password factor.
-     *
-     * Returns `null` only when the vault read SUCCEEDS but the seed can't be
-     * unwrapped — i.e. there's no real factor (a pre-vault/legacy account, whose
-     * read returns a decoy that won't unwrap) or the password is wrong. The caller
-     * then legitimately falls back to the legacy password-derived identity.
-     *
-     * Throws {@link VaultUnavailableError} when the vault itself can't be reached
-     * (network / 5xx / rate-limit) — so a *transient* failure is NOT silently
-     * turned into a legacy fallback (which would surface as "commitment mismatch").
-     */
-    private tryUnlockSeed;
-    /**
-     * Enroll/replace the password factor for `username` — wraps `seed` under the
-     * OPRF-gated key and stores it (needs a session `token`).
-     *
-     * Retries: this is the step that persists the (otherwise in-memory-only)
-     * master seed. If it fails after a fresh registration the account would be
-     * unrecoverable, so we retry a few times before surfacing the error.
-     */
-    private enrollPasswordFactor;
-}
-/** `client.auth` — the auth namespace. Strategies hang off here. */
-declare class AuthNamespace {
-    readonly zk: ZkAuth;
-    /** Centralized hosted auth (auth.muhkoo.dev) — `client.auth.hosted.login(...)`. */
-    readonly hosted: HostedAuth;
-    constructor(deps: ZkAuthDeps & {
-        authBaseUrl: string;
-        apiBaseUrl?: string;
-    });
-    /** Convenience pass-through: the currently signed-in user, or `null`. */
-    get user(): AuthUser | null;
-}
-
-/**
- * `HttpClient` — the one place the unified {@link Client} talks to the
- * accelerator over HTTP.
- *
- * Every request carries two independent credentials:
- *   - the **app key** (`mk_…`) on `X-Muhkoo-Key` — resolves the app /
- *     developer / env context the accelerator uses for routing + billing;
- *   - the **user session token** on `X-Muhkoo-Session` (when a user is
- *     logged in) — the accelerator validates it and injects a trusted
- *     `X-Muhkoo-User-Context` downstream so per-user spaces can authorize
- *     the request without a fresh Groth16 proof.
- *
- * `X-Muhkoo-Key` is used (rather than `Authorization: Bearer`) because it is
- * a non-forbidden header that skips the CORS preflight in browsers.
- *
- * The class exposes a header-injecting {@link fetch} that can be handed to
- * lower-level building blocks (`AuthClient`, `PersonalSpaceClient`) so they
- * keep owning their own wire shapes while still getting the credentials, plus
- * convenience JSON helpers (`get`/`post`/`del`) for code that talks to the
- * accelerator directly.
- */
-interface HttpClientOptions {
-    /** Absolute URL of the accelerator worker (trailing slash optional). */
-    baseUrl: string;
-    /**
-     * App / publishable key, e.g. `mk_test_pk_…`. Sent on every request as
-     * `X-Muhkoo-Key` when present. Transitionally optional (auth + personal
-     * storage still function without it), but the product direction is to
-     * REQUIRE it — it attributes traffic for billing/metering and authorizes
-     * shared-space (messaging) websockets.
-     */
-    apiKey?: string;
-    /**
-     * A scoped, expiring **access token** (`mk_<env>_at_…`) — the non-ZK
-     * machine-to-machine credential. It resolves through the SAME accelerator
-     * path as an app key and rides the same `X-Muhkoo-Key` header; when present
-     * it takes precedence over {@link apiKey}. Use it for server-side / CI
-     * callers that shouldn't carry the app's publishable key.
-     */
-    accessToken?: string;
-    /** Returns the current user session token, or `null` when logged out. */
-    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`) and
-     * {@link HttpClient.fetchWithRecovery}; the raw {@link fetch} passes 401s
-     * straight through so the auth wire calls that power recovery itself
-     * can't recurse.
-     */
-    onUnauthorized?: () => Promise<boolean>;
-}
-
-declare class HttpClient {
-    readonly baseUrl: string;
-    /** Origin of {@link baseUrl} — credentials are only attached same-origin. */
-    private readonly baseOrigin;
-    private readonly apiKey;
-    /** Scoped machine access token — takes precedence over {@link apiKey} on `X-Muhkoo-Key`. */
-    private readonly accessToken;
-    private readonly getSessionToken;
-    private readonly onUnauthorized;
-    private readonly fetchFn;
-    constructor(opts: HttpClientOptions);
+     *
+     * Treat a persisted seed as the master credential it is. It is not scoped
+     * and cannot be revoked server-side the way a session token can — rotating
+     * it means moving the identity.
+     */
+    unlockWithSeed(seedBase64: string): void;
+    /** Poseidon commitment for an identity — the value the server stores. */
+    private commitmentFor;
     /**
-     * A `fetch`-compatible function that injects the app key + session token
-     * headers. Hand this to `AuthClient` / `PersonalSpaceClient` so they pick
-     * up credentials without knowing about them.
+     * Derive the OPRF-gated wrap key for the password factor: `scrypt(password)`
+     * is blinded, evaluated by the server's secret OPRF key (so it can't be
+     * derived offline), unblinded, then HKDF'd into an AES-GCM key.
      */
-    readonly fetch: typeof fetch;
+    private passwordWrapKey;
     /**
-     * {@link fetch} with the JSON helpers' stale-session recovery: a 401 on a
-     * request made while a session token is held runs `onUnauthorized` once
-     * and, if that recovered, replays the request once with the fresh token.
-     * The final response is returned whatever its status, never thrown. The
-     * replay re-sends `init` as given, so its body must be re-sendable (a
-     * string or bytes, not a stream).
+     * Try to recover the master seed from the password factor.
+     *
+     * Returns `null` only when the vault read SUCCEEDS but the seed can't be
+     * unwrapped — i.e. there's no real factor (a pre-vault/legacy account, whose
+     * read returns a decoy that won't unwrap) or the password is wrong. The caller
+     * then legitimately falls back to the legacy password-derived identity.
+     *
+     * Throws {@link VaultUnavailableError} when the vault itself can't be reached
+     * (network / 5xx / rate-limit) — so a *transient* failure is NOT silently
+     * turned into a legacy fallback (which would surface as "commitment mismatch").
      */
-    readonly fetchWithRecovery: typeof fetch;
-    /** True when `input` resolves to {@link baseOrigin} (relative URLs always do). */
-    private isSameOrigin;
-    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;
+    private tryUnlockSeed;
+    /**
+     * Enroll/replace the password factor for `username` — wraps `seed` under the
+     * OPRF-gated key and stores it (needs a session `token`).
+     *
+     * Retries: this is the step that persists the (otherwise in-memory-only)
+     * master seed. If it fails after a fresh registration the account would be
+     * unrecoverable, so we retry a few times before surfacing the error.
+     */
+    private enrollPasswordFactor;
+}
+/** `client.auth` — the auth namespace. Strategies hang off here. */
+declare class AuthNamespace {
+    readonly zk: ZkAuth;
+    /** Centralized hosted auth (auth.muhkoo.dev) — `client.auth.hosted.login(...)`. */
+    readonly hosted: HostedAuth;
+    constructor(deps: ZkAuthDeps & {
+        authBaseUrl: string;
+        apiBaseUrl?: string;
+    });
+    /** Convenience pass-through: the currently signed-in user, or `null`. */
+    get user(): AuthUser | null;
 }
 
 /**
@@ -6324,6 +6740,375 @@ declare class SpaceNamespace {
     private myId;
 }
 
+/**
+ * `client.shares` — shared folders. A share is a Space the server keeps private, with a storage limit its owner pays
+ * for, a file store whose uploaders are stamped server-side, and (for a public share) a password that admits
+ * whoever knows it. The app's keeper holds each share's group key, so shares are not end-to-end encrypted.
+ *
+ *   const share = await client.shares.create({ kind: "public", name: "Wedding", limitBytes: 20e9, password });
+ *   const { share, recovery } = await client.shares.joinWithPassword(spaceId, { password, name: "Gus" });
+ *
+ * Every member, a public share's guests included, is an ordinary Muhkoo account. Someone who opens a public share
+ * signed out gets one quietly: a generated username and a random password they never see, a device login kept on
+ * this device, and a recovery code ({@link GuestRecovery}) that signs them in elsewhere.
+ *
+ * Wire contract: the accelerator's `docs/superpowers/plans/2026-11-06-shared-folders-server-contract.md`. In short:
+ * a share Space is created the way a public Space is (no membership-log genesis), `/metadata` first, the app keeper
+ * seeded, then `POST /api/shares`; a rotation (new password, removed member) is a new Space adopted with
+ * `POST /api/shares/:new/adopt`, never `/keyring/rotate`. An adopt that fails part-way is finished by repeating it
+ * with the same new Space and the same settings, so a pending rotation is kept in the local store until it is done.
+ */
+
+/** How many `closed.successor` links are followed before giving up (a rotation loop, or a very busy share). */
+declare const MAX_SHARE_SUCCESSOR_HOPS = 16;
+/** The default label of the device login a quietly-created guest account keeps on this device (`deviceLabel` sets another). */
+declare const SHARE_GUEST_DEVICE_LABEL = "Shared folder guest";
+/** What signs the same guest in on another device. Show it until the app calls `shares.acknowledgeRecovery()`. */
+interface GuestRecovery {
+    username: string;
+    /** The account's recovery phrase (24 words, space-separated). */
+    phrase: string;
+    /** `username` and `phrase` as one string to type or put in a QR code: see {@link guestRecoveryCode}. */
+    code: string;
+}
+/** A device login for a guest account, kept on the device so the next visit signs in without asking. */
+interface GuestDeviceLogin {
+    username: string;
+    factorId: string;
+    /** Opens the account's seed while the device factor exists: keep it as private as a session token. */
+    deviceKey: string;
+}
+/**
+ * Where `client.shares` keeps its per-device state: the guest device login, an unfinished guest setup, whether the
+ * guest's recovery code is still to be shown, and unfinished rotations. String values; `set` may throw (a full or
+ * blocked storage), `get` should answer null rather than throw.
+ */
+interface SharesLocalStore {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+/** A store that lasts as long as the process (Node, Workers, tests). */
+declare function memorySharesStore(): SharesLocalStore;
+/**
+ * The default store: `localStorage` under `prefix` where there is one (browsers, the same place the session token
+ * lives), else memory. One per app: the Client keys it by the app key and the accelerator.
+ */
+declare function defaultSharesStore(prefix: string): SharesLocalStore;
+/** `<username>:<phrase words joined by "-">`, e.g. `g-abcdefghijkl:alpha-beta-…`. */
+declare function guestRecoveryCode(username: string, phrase: string): string;
+/** Read a {@link guestRecoveryCode}: case-insensitive, words separated by spaces or dashes. */
+declare function parseGuestRecoveryCode(code: string): {
+    username: string;
+    phrase: string;
+};
+/**
+ * The guest recovery an error from `client.shares` carries, or null. Any error thrown after a guest account exists
+ * carries it while it has not been acknowledged, so the app can always show the code.
+ */
+declare function guestRecoveryOf(err: unknown): GuestRecovery | null;
+/** The account calls `client.shares` needs for a quiet guest account: `client.auth.zk` has them all. */
+interface ShareGuestAuth {
+    register(params: {
+        username: string;
+        password: string;
+    }): Promise<AuthUser>;
+    enrollDevice(label: string): Promise<{
+        factorId: string;
+        deviceKey: string;
+    }>;
+    loginWithDevice(username: string, factorId: string, deviceKey: string): Promise<AuthUser>;
+    /** Recover the seed of the signed-in account from a device login (no new session). */
+    unlockWithDevice(username: string, factorId: string, deviceKey: string): Promise<void>;
+    revokeDevice(factorId: string): Promise<boolean>;
+    /** Deterministic from the account seed: calling it again gives the same phrase. */
+    enrollRecoveryPhrase(): Promise<string>;
+    recoverWithPhrase(username: string, phrase: string): Promise<AuthUser>;
+}
+/** The keyring calls `client.shares` makes on a share Space (a {@link SpaceKeyring} has them). */
+interface ShareSpaceKeyring {
+    admit(memberId: string, identityEcdhPub: string): Promise<void>;
+    loadFromCache(): Promise<boolean>;
+    hasAnyKey(): boolean;
+    requestKey(): Promise<void>;
+    pullKeys(): Promise<number>;
+}
+/** A share Space handle (a {@link Space} is one). */
+interface ShareSpaceHandle {
+    readonly id: string;
+    /** Absent while the session is locked. */
+    readonly keyring?: ShareSpaceKeyring;
+    disconnect(): void;
+}
+/** The Space calls `client.shares` makes: `client.space` has them all. */
+interface ShareSpaces {
+    createSpace(opts: {
+        historyPolicy: "static";
+    }): Promise<ShareSpaceHandle>;
+    get(spaceId: string): Promise<ShareSpaceHandle>;
+    joinByInvite(spaceId: string, token: string): Promise<ShareSpaceHandle>;
+}
+interface SharesNamespaceDeps {
+    /** The app's HTTP client (app key and the signed-in session). */
+    http: HttpClient;
+    /** The signed-in username, or null when no one is signed in. */
+    me: () => string | null;
+    /**
+     * Whether the signed-in session holds its seed. A session restored after a reload has a token but no seed
+     * (locked): a guest's device login unlocks it.
+     */
+    unlocked: () => boolean;
+    spaces: ShareSpaces;
+    auth: ShareGuestAuth;
+    store: SharesLocalStore;
+    /** The page invite links point at; default: the current page in a browser. */
+    inviteBase?: () => string | null;
+    /** The wait before the n-th retry of an adopt is `n × retryDelayMs` (default 500). */
+    retryDelayMs?: number;
+    /** A pre-compiled Reed-Solomon module, for runtimes without the bundled loader (Node tests, Workers). */
+    rsWasmModule?: WebAssembly.Module;
+}
+/** {@link SharesNamespace.shareFolder}'s settings for the new share (ignored when an earlier run made it already). */
+interface ShareFolderOptions {
+    kind: ShareKind;
+    /** Storage cap in bytes, or null for none. A folder bigger than this is refused before anything changes. */
+    limitBytes: number | null;
+    editPolicy?: EditPolicy;
+    /** Required for a public share, refused for a private one. */
+    password?: string;
+    /** Default: the folder's name. */
+    name?: string;
+}
+interface CreateShareOptions {
+    kind: ShareKind;
+    name: string;
+    /** Storage cap in bytes, or null for none. */
+    limitBytes: number | null;
+    /** Default `"own"`: members change only their own files (the owner can always change anything). */
+    editPolicy?: EditPolicy;
+    /** Required for a public share, refused for a private one. Never sent: only a salted verifier is. */
+    password?: string;
+}
+declare class SharesNamespace {
+    private readonly deps;
+    /** The `/api/shares` wire client, for calls this namespace does not wrap. */
+    readonly api: SharesClient;
+    /** The recovery phrase as last derived, so it is not re-derived on every call. */
+    private recoveryCache;
+    constructor(deps: SharesNamespaceDeps);
+    /**
+     * Make a share. The Space is created as a public Space would be (no membership-log genesis: the server refuses a
+     * log-enabled Space), the app keeper is given its group key so members can join with the owner offline, then
+     * `POST /api/shares` makes it a share (and private, server-side). A public share sends a salted verifier, never
+     * the password.
+     */
+    create(opts: CreateShareOptions): Promise<Share>;
+    /**
+     * Share a folder of the user's own (`client.vfs`): its files move into a new share, without uploading a byte,
+     * and the folder becomes a link to the share, so the user's tree looks the same. Returns the share.
+     *
+     * 1. The folder's size is checked against `limitBytes` first: over it, {@link ShareFullError} and nothing
+     *    has changed.
+     * 2. The share is made (named after the folder unless `name` is given) and the folder is marked as going
+     *    to it, so a run that stops part-way resumes into the same share.
+     * 3. Each file's existing manifest is posted to the share at its path inside the folder.
+     * 4. Only then is the folder replaced by the link, and only after that is each file's personal reference let
+     *    go of. Until then the owner is billed for both copies. Earlier versions of the files are not carried
+     *    into the share; they are let go of here too.
+     *
+     * Nothing in the folder is removed, and nothing let go of, before step 4; an interrupted run (a closed tab, a
+     * network failure) is finished by calling `shareFolder` again on the same path: it reuses the share (following
+     * it if it was rotated) and skips files already in it. The options are then ignored. A file saved into the
+     * folder while it is being shared is moved too. A file (or empty folder) moved out of the folder or deleted
+     * from it meanwhile - during the run, or between an interrupted run and the one that finishes it - is taken
+     * back out of the share before the folder becomes a link, so the share never holds what the folder no longer
+     * does; a file moved out keeps its personal copy. Only records this flow put in the share are taken back
+     * (their ids are kept on this device, under the share, until the folder is a link): a file another member
+     * uploaded meanwhile is never touched. That list is kept per device: a run finished on another device (or after
+     * this device's storage was cleared) cannot take back what the stopped run posted. The take-back runs before
+     * anything is posted, so what it frees counts toward the share's limit. If the run stopped after the link was in place, calling it again (or
+     * opening the share) lets go of what was left.
+     *
+     * Refused with `VfsConflictError` for what is not a folder of the user's own, `/` and `/Home`, a folder that
+     * holds a link (a share cannot hold another) or an entry this SDK version cannot read.
+     */
+    shareFolder(path: string, opts: ShareFolderOptions): Promise<Share>;
+    /** The shares the signed-in user owns or belongs to, for this app. */
+    list(): Promise<ShareSummary[]>;
+    /**
+     * Open a share as the signed-in user, following `closed.successor` to the current Space, and make sure this
+     * member has the group key (a join request the keeper answers). When the share moved to a Space this user is
+     * not a member of (a public share's password changed), throws {@link ShareClosedError} with that Space as
+     * `successor`: ask for the new password and call {@link joinWithPassword}.
+     *
+     * A guest's recovery code still to be shown is not returned here: read {@link pendingRecovery}.
+     */
+    open(spaceId: string): Promise<Share>;
+    /**
+     * Join a public share with its password. If no one is signed in, the device login kept from an earlier visit
+     * signs in; failing that, a guest account is made quietly. `recovery` is the guest's recovery code while the app
+     * has not called {@link acknowledgeRecovery}: show it, then acknowledge. Any error thrown once the account
+     * exists carries it too ({@link guestRecoveryOf}).
+     *
+     * Follows `closed.successor`, so an old link still reaches the current share. Throws {@link SharePasswordError}
+     * on a wrong password, {@link SharePasswordRateError} after too many, {@link ShareMemberLimitError} when full.
+     */
+    joinWithPassword(spaceId: string, opts: {
+        password: string;
+        name: string;
+        deviceLabel?: string;
+    }): Promise<{
+        share: Share;
+        recovery: GuestRecovery | null;
+    }>;
+    /**
+     * The signed-in guest's recovery code if the app has not yet acknowledged showing it, else null. Survives a
+     * reload: the phrase is derived again from the account (never stored), so it needs the session unlocked.
+     */
+    pendingRecovery(): Promise<GuestRecovery | null>;
+    /** The guest has saved their recovery code: stop returning it. */
+    acknowledgeRecovery(): Promise<void>;
+    /**
+     * Sign a guest in on this device from their recovery code ({@link guestRecoveryCode}), and keep a device login
+     * so the next visit signs in by itself. If another guest's login is kept on this device, throws
+     * {@link GuestLoginConflictError} unless `replace: true`; replacing revokes that login's device factor where it
+     * can.
+     */
+    restoreGuest(code: string, opts?: {
+        replace?: boolean;
+        deviceLabel?: string;
+    }): Promise<AuthUser>;
+    /** Set the storage cap (bytes, or null for none). Owner only. */
+    setLimit(spaceId: string, limitBytes: number | null): Promise<ShareInfo>;
+    /** Who may change a file in a private share: `"own"` (uploader and owner) or `"any"` member. Owner only. */
+    setEditPolicy(spaceId: string, policy: EditPolicy): Promise<ShareInfo>;
+    /** Invite an account by username (owner only). They join by opening the share ({@link open}). */
+    invite(spaceId: string, username: string): Promise<void>;
+    /**
+     * Mint an invite link (owner only): `<base>#/join/<spaceId>/<token>`, where `base` is `opts.baseUrl` or the
+     * current page. The URL is also what an in-person invite's QR code holds. Whoever opens it signs in and calls
+     * {@link joinWithInvite}.
+     */
+    inviteLink(spaceId: string, opts?: {
+        baseUrl?: string;
+    }): Promise<{
+        url: string;
+        token: string;
+    }>;
+    /** Join a private share from an invite link ({@link inviteLink}) as the signed-in user. */
+    joinWithInvite(url: string): Promise<Share>;
+    /**
+     * Change a public share's password. The share moves to a new Space (its files and settings come along; nothing
+     * is uploaded again) and only the owner is carried: everyone else is admitted again with the new password, as
+     * the same account, keeping their files and name. Returns the new share.
+     *
+     * Throws {@link RotationIncompleteError} if the move did not finish; calling this again (or
+     * {@link resumeRotation}) finishes it into the same Space.
+     */
+    changePassword(spaceId: string, password: string): Promise<Share>;
+    /**
+     * Remove a member for good: the share moves to a new Space without them (nothing is uploaded again). On a
+     * public share pass a new `password` too, or they can be admitted again with the old one. Returns the new share.
+     * An unfinished move is handled as in {@link changePassword}.
+     */
+    removeMember(spaceId: string, username: string, opts?: {
+        password?: string;
+    }): Promise<Share>;
+    /**
+     * Finish a rotation of this share that an earlier call (on this device, perhaps before a reload) left unfinished.
+     * Returns the new share, or null when none is pending. Throws {@link RotationIncompleteError} if it still fails.
+     */
+    resumeRotation(spaceId: string): Promise<Share | null>;
+    /**
+     * Forget this share's unfinished rotation without finishing it. Only for a rotation you know can never complete
+     * (its new Space is gone or refused): files the server had not yet copied stay in the closed original Space, and
+     * the next rotation starts from wherever the share now points. Returns whether one was pending.
+     */
+    abandonRotation(spaceId: string): Promise<boolean>;
+    private rotate;
+    /** Send the adopt (with retries on network errors and 5xx); forget the rotation once done or dead. */
+    private finishRotation;
+    /** The unfinished rotation `spaceId` belongs to: as its `from`, its new Space, or a Space before its `from`. */
+    private pendingRotationFor;
+    private loadRotations;
+    private saveRotation;
+    private dropRotation;
+    /**
+     * The share `plan`'s folder is going to: the one an earlier run marked it with (its successor if it was
+     * rotated), else a new one, made only once the folder is known to fit and then marked on the folder.
+     */
+    private shareForFolder;
+    /**
+     * Post every file of `plan` to `share`, and its empty folders. Nothing of the user's is let go of here. Each
+     * record's id is noted in `posted` before it is posted. Returns the ids of the records that hold `plan`'s files.
+     */
+    private moveIntoShare;
+    /**
+     * Delete from `share` each record this flow posted (`posted`) that `plan` no longer has: a file record
+     * `keepFile` does not keep (deleted or moved out of the folder, or left at an old path), an empty-folder record
+     * whose path is no longer a folder in `plan`. Only the caller's own uploads, and only ids in `posted`, are touched.
+     */
+    private takeBackRemoved;
+    private savePending;
+    /**
+     * Let go of the personal reference of each file a `shareFolder` into `spaceId` moved out of the tree - only
+     * once the folder it kept is confirmed to be a link to `spaceId` (until then the folder's entries still name
+     * that content, and their references keep it stored). Each file once; the list shrinks as it goes, so a
+     * repeat never releases one twice. A failed release stays listed for next time: a leak (billed twice) is the
+     * worst case, never a loss. True when there was a list for `spaceId` and the swap was confirmed. `known`: the
+     * list as this run has it (the stored copy may not have been saved).
+     */
+    private drainPending;
+    /**
+     * Create a share Space and seed its keeper; returns its id. The keeper's key is read first, so an app without a
+     * keeper leaves no Space behind. Created with the default (public) visibility: a private Space gets a
+     * membership-log genesis, which a share refuses. The socket the creation opens is closed again: a `Share` works
+     * over HTTP.
+     */
+    private newSeededSpace;
+    /** The app keeper's ECDH public key, or null when the app has none (404). */
+    private keeperPubkey;
+    /** The share's current Space: `spaceId` or where its `closed.successor` chain ends. */
+    private current;
+    /** A public share's current Space and its pre-admission info (salt, iterations), from `GET /public`. */
+    private currentPublic;
+    /**
+     * Make sure the signed-in member holds the share's group key: a key from this device's cache, else a join
+     * request (the keeper wraps the key for a member as it lands) and a few pulls. A locked session (no identity)
+     * skips this: the share's files do not need the group key. A key that has not arrived yet is not an error.
+     */
+    private joinKeys;
+    /** Signed in already; else this device's guest login; else a new guest account. Finishes a half-done setup. */
+    private ensureSignedIn;
+    private createGuestAccount;
+    /**
+     * Finish the steps of a guest account's setup that are not done: the recovery phrase first (so it can always be
+     * shown), then the device login. Each is tried twice. An error carries the recovery when the phrase is known.
+     */
+    private finishGuestSetup;
+    /**
+     * Best-effort revoke of a replaced guest login's device factor. Revoking needs that account's session, so this
+     * signs in as it briefly and then back in as `current` (the guest just restored), whose login is fresh.
+     */
+    private revokeReplacedLogin;
+    /** Delete `key` if its JSON value names `username`. */
+    private deleteIfFor;
+    /**
+     * A session restored without its seed (after a reload) that belongs to this device's guest login: unlock it
+     * with the device login, so the setup can be finished and the recovery phrase derived. A revoked login is
+     * forgotten; any other failure is warned and leaves the session locked.
+     */
+    private unlockSavedGuest;
+    /** `err` with the signed-in guest's unacknowledged recovery attached as `recovery` (see {@link guestRecoveryOf}). */
+    private withRecovery;
+    private readJson;
+    /** Store `value`; a storage failure is reported (warned) and answered with false, not thrown. */
+    private trySave;
+    private keyring;
+    private shareFor;
+    private requireMe;
+}
+
 /**
  * `client.agents` — manage an app's **Programmable Agents** (server-side
  * "virtual users" backed by Workers AI).
@@ -6372,6 +7157,8 @@ interface AgentToolsConfig {
     functions: string[];
     /** Whether the agent may resolve the app's PUBLIC channels. */
     channels: boolean;
+    /** Allowlisted collection names the agent may search with its `search_collection` tool (text-mode collections only, at most 20). */
+    collections?: string[];
     /** Max tool-call rounds per reply (1..6). */
     maxIterations: number;
 }
@@ -6775,6 +7562,233 @@ declare class AppNamespace {
     access(): Promise<AppAccess>;
 }
 
+/**
+ * `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.
+ */
+
+/** A ready notice: the entries of one upsert call are now searchable. */
+interface VectorReadyEvent {
+    collection: string;
+    ids: string[];
+    mutationId: string;
+}
+/**
+ * A wait for a write ran out of time. The write itself was accepted; check
+ * {@link VectorCollection.status} later with `mutationId`.
+ */
+declare class VectorWaitTimeoutError extends Error {
+    readonly mutationId: string;
+    constructor(mutationId: string, timeoutMs: number);
+}
+type WaitOptions = {
+    space?: Space;
+    timeoutMs?: number;
+};
+type VectorAudience = "everyone" | "writer";
+type VectorNotify = false | {
+    space?: string;
+    audience?: VectorAudience;
+};
+interface VectorEntryInput {
+    id: string;
+    text?: string;
+    vector?: number[];
+    data?: Record<string, unknown>;
+    storeText?: boolean;
+}
+interface VectorUpsertOptions {
+    notify?: VectorNotify;
+}
+interface VectorWriteResult {
+    mutationId: string;
+    count: number;
+}
+interface VectorQueryInput {
+    text?: string;
+    vector?: number[];
+    topK?: number;
+    filter?: Record<string, unknown>;
+    includeData?: boolean;
+    includeText?: boolean;
+}
+interface VectorMatch {
+    id: string;
+    score: number;
+    data?: Record<string, unknown>;
+    text?: string;
+}
+interface VectorEntry {
+    id: string;
+    data: Record<string, unknown>;
+    text?: string;
+    vector?: number[];
+}
+type VectorWriteState = "pending" | "done" | "unknown";
+interface VectorsNamespaceDeps {
+    http: HttpClient;
+}
+/** A handle on one collection. Cheap to make; holds no state beyond its name. */
+declare class VectorCollection {
+    private readonly http;
+    readonly name: string;
+    private readonly base;
+    constructor(http: HttpClient, name: string);
+    /** Add or replace entries. Returns once accepted; see {@link status}. */
+    upsert(entries: VectorEntryInput[], opts?: VectorUpsertOptions): Promise<VectorWriteResult>;
+    /** Nearest entries to a text or a vector. */
+    query(input: VectorQueryInput): Promise<VectorMatch[]>;
+    /** Entries by id. Writes still pending are not returned. */
+    get(ids: string[], opts?: {
+        includeVector?: boolean;
+    }): Promise<VectorEntry[]>;
+    /** Remove entries by id. Asynchronous, like {@link upsert}. */
+    delete(ids: string[]): Promise<VectorWriteResult>;
+    /** The state of a write: `pending`, `done`, or `unknown` (never seen or expired). */
+    status(mutationId: string): Promise<VectorWriteState>;
+    /**
+     * 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: Space, handler: (e: VectorReadyEvent) => void): () => void;
+    /**
+     * 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: string, opts?: WaitOptions): Promise<void>;
+    /**
+     * {@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.
+     */
+    upsertAndWait(entries: VectorEntryInput[], opts?: VectorUpsertOptions & WaitOptions): Promise<VectorWriteResult>;
+    private wait;
+}
+interface VectorFieldDefinition {
+    name: string;
+    type: "string" | "number" | "boolean";
+}
+type VectorCollectionDefinition = {
+    mode: "text";
+    model?: string;
+    metric?: "cosine" | "euclidean" | "dot-product";
+    fields?: VectorFieldDefinition[];
+    access?: "app" | "backend";
+} | {
+    mode: "vectors";
+    dimensions: number;
+    metric?: "cosine" | "euclidean" | "dot-product";
+    fields?: VectorFieldDefinition[];
+    access?: "app" | "backend";
+};
+interface VectorNotices {
+    spaces: string[];
+    defaultSpace: string | null;
+}
+interface VectorEnvInfo {
+    status: "creating" | "ready" | "failed" | "dropping";
+    entries: number | null;
+    notices: VectorNotices;
+    error: string | null;
+}
+interface VectorCollectionInfo {
+    name: string;
+    mode: "text" | "vectors";
+    model: string | null;
+    dimensions: number;
+    metric: string;
+    fields: VectorFieldDefinition[];
+    access: "app" | "backend";
+    createdAt: number;
+    status: "creating" | "ready" | "failed" | "dropping";
+    envs: {
+        live: VectorEnvInfo;
+        test: VectorEnvInfo;
+    };
+}
+/** A collection's creation failed; `info.envs.*.error` says why. */
+declare class VectorCollectionFailedError extends Error {
+    readonly info: VectorCollectionInfo;
+    constructor(info: VectorCollectionInfo);
+}
+declare class VectorsNamespace {
+    private readonly deps;
+    constructor(deps: VectorsNamespaceDeps);
+    /** A handle on the named collection, made fresh on each call. */
+    collection(name: string): VectorCollection;
+    /** The app's collections, sorted by name. */
+    listCollections(appId: string): Promise<VectorCollectionInfo[]>;
+    /** One collection. A missing or badly named one is 404 `collection_not_found`. */
+    getCollection(appId: string, name: string): Promise<VectorCollectionInfo>;
+    /**
+     * 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: string, name: string, definition: VectorCollectionDefinition): Promise<VectorCollectionInfo>;
+    /**
+     * 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.
+     */
+    dropCollection(appId: string, name: string): Promise<void>;
+    /** Set which Spaces receive ready notices for one environment. */
+    setNotices(appId: string, name: string, env: "live" | "test", notices: VectorNotices): Promise<VectorNotices & {
+        env: "live" | "test";
+    }>;
+    /**
+     * 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: string, name: string, opts?: {
+        timeoutMs?: number;
+    }): Promise<VectorCollectionInfo>;
+    private ownerPath;
+}
+
 /**
  * Wire types for the VFS metadata layer.
  *
@@ -6871,8 +7885,37 @@ interface DirEntry {
      * storage cost, never a loss.
      */
     moving?: true;
+    /**
+     * Set while `client.shares.shareFolder` is moving this folder's files into the share named here, until the
+     * folder is replaced by a link to it. A run that stops part-way resumes into the same share. An SDK from
+     * before shares keeps the field (entries are written back whole) and otherwise ignores it.
+     */
+    sharing?: {
+        spaceId: string;
+    };
+}
+/**
+ * A link: a name in the user's own tree that stands for a shared folder (a share), the way a symlink stands for
+ * a directory. Paths below it are served by that share; the link itself holds nothing of the user's, so deleting
+ * or moving it touches only the link.
+ *
+ * Added after `file` and `dir` without a new record version (`DirNode.v` stays 1): an SDK from before links
+ * sees an entry kind it does not know, hides it, writes it back unchanged with every write of the directory, and
+ * refuses to put anything else at its name with `mkdir`, `rename` or `copy`.
+ */
+interface LinkEntry {
+    kind: "link";
+    /** Stable identity, like a file's or a directory's. Never a store key: a link has no record of its own. */
+    id: string;
+    /** The share's Space. */
+    target: {
+        spaceId: string;
+    };
+    mtime: number;
+    /** See `DirEntry.moving`. */
+    moving?: true;
 }
-type Entry = FileEntry | DirEntry;
+type Entry = FileEntry | DirEntry | LinkEntry;
 /** One directory record, as stored (before encryption). */
 interface DirNode {
     v: 1;
@@ -6893,10 +7936,14 @@ interface HistoryRecord {
 interface VfsStat {
     path: string;
     name: string;
-    kind: "file" | "dir";
+    kind: "file" | "dir" | "link";
     size: number;
     mtime: number;
     versions: number;
+    /** For a link: the share it stands for. */
+    target?: {
+        spaceId: string;
+    };
 }
 /** The encrypted envelope every record is stored in. */
 interface SealedRecord {
@@ -7092,6 +8139,28 @@ interface VfsCoordinator {
     holdMoving(id: string, shared?: boolean): Promise<(() => void) | null>;
 }
 
+/**
+ * The shares mount: how the VFS serves `/Home/Shared` and paths through a link.
+ *
+ * A share is its own Space with its own file records, not a subtree of anyone's personal tree. So nothing here
+ * reads or writes a directory record: every path below `/Home/Shared/<name>`, or below a link, becomes a call on
+ * that share's `Share` (list, read, write, mkdir, delete, rename), and a share's tree comes back as `VfsStat`s.
+ * `VfsNamespace` decides which paths come here (see `VfsNamespace.route`); this file never touches the personal
+ * store, so nothing a share does can reach the user's own files.
+ *
+ * `/Home/Shared` itself is built from the server's membership records (`shares.list()`), never stored.
+ */
+
+/** The part of a `Share` the VFS uses. `info` is read to make sure a share kept open has not been closed. */
+type MountedShare = Pick<Share, "spaceId" | "info" | "list" | "read" | "write" | "mkdir" | "delete" | "rename">;
+/** Where the shares come from: `client.shares`. */
+interface SharesSource {
+    list(): Promise<ShareSummary[]>;
+    open(spaceId: string): Promise<MountedShare>;
+    /** The signed-in username, so that the user's own shares get the plain names. Null when unknown. */
+    me?: () => string | null;
+}
+
 /**
  * `client.vfs` — a real filesystem over Muhkoo primitives.
  *
@@ -7195,6 +8264,13 @@ interface VfsNamespaceDeps {
      * namespace only. See `VfsCoordinator`.
      */
     coordinator?: VfsCoordinator;
+    /**
+     * The signed-in user's shares (`client.shares`). With it, `/Home/Shared` lists them and paths below
+     * `/Home/Shared/<name>`, or below a link, are served by the share; `/Home` is the user's own `/Home` folder
+     * with `Shared` added. Without it - a CLI or a test with no shares - a link is listed, moved, copied and
+     * deleted like any entry, but nothing below it can be reached.
+     */
+    shares?: SharesSource;
 }
 declare class VfsNamespace {
     private readonly deps;
@@ -7316,6 +8392,8 @@ declare class VfsNamespace {
     private readonly historyLimit;
     private readonly maxEntries;
     private readonly maxPathChars;
+    /** `/Home/Shared` and the shares below it and below links. See `sharesMount.ts`. */
+    private readonly mount;
     constructor(deps: VfsNamespaceDeps);
     /**
      * The working directory relative paths resolve against.
@@ -7364,9 +8442,15 @@ declare class VfsNamespace {
      */
     watch(handler: () => void): () => void;
     exists(path: string): Promise<boolean>;
+    private existsReal;
     stat(path: string): Promise<VfsStat>;
-    /** Immediate children of a directory. One record fetch. */
+    private statReal;
+    /**
+     * Immediate children of a directory. One record fetch. A link is listed as `kind: "link"` with its
+     * `target`; listing the link's own path lists the share it stands for.
+     */
     list(path?: string): Promise<VfsStat[]>;
+    private listReal;
     /**
      * A directory's entries in listing order: directories first, then by name.
      * Shared by `list` and `walk`, so a walk's output order is exactly the order
@@ -7405,9 +8489,22 @@ declare class VfsNamespace {
      * whole walk beside the whole commit, and a map of one beside a map of
      * the other, ran a 512MB heap out of memory inside the default budgets.
      * The same guards and budgets as `walk`, which is built on this.
+     *
+     * A link is visited as `kind: "link"` (with a null manifest) and not walked into: it is the user's entry,
+     * while what is below it is a share's. A walk of `/Home` covers only the user's own `/Home` folder, not
+     * `/Home/Shared`.
+     *
+     * Throws VfsConflictError for a path at a link, at `/Home/Shared` or inside a share: a share's files are not
+     * content handles of the user's, so there is no manifest to hand over, and a caller that reads a null
+     * manifest as "a directory" - version control does - would record a tree with no files in it. `walk` and
+     * `walkEntries` do walk shares.
      */
     eachEntry(path: string, visit: (stat: VfsStat, manifest: FileManifest | null) => void): Promise<void>;
+    /** `eachEntry`, and with `intoShares` (for `walkEntries`) also a walk of a share: every file's manifest null. */
+    private visitTree;
+    private eachReal;
     readFile(path: string): Promise<Uint8Array>;
+    private readFileReal;
     readText(path: string): Promise<string>;
     /**
      * A file's manifest — the handle itself, without reading the bytes.
@@ -7445,6 +8542,7 @@ declare class VfsNamespace {
      * shards.
      */
     writeManifest(path: string, manifest: FileManifest, size: number): Promise<VfsStat>;
+    private writeManifestReal;
     /**
      * Create a directory. `recursive` creates missing parents and tolerates an
      * existing target, matching `mkdir -p`.
@@ -7452,6 +8550,7 @@ declare class VfsNamespace {
     mkdir(path: string, opts?: {
         recursive?: boolean;
     }): Promise<void>;
+    private mkdirReal;
     /**
      * Refuse now what creating these directories with `mkdir -p` would refuse
      * part way: one deeper than MAX_DEPTH, or a name on the way held by an
@@ -7462,6 +8561,7 @@ declare class VfsNamespace {
      * not refused: such an operation removes those first.
      */
     assertCreatable(dirs: Iterable<string>): Promise<void>;
+    private assertCreatableReal;
     /**
      * Write a file, creating parent directories as needed.
      *
@@ -7473,6 +8573,7 @@ declare class VfsNamespace {
         type?: string;
         onProgress?: (done: number, total: number) => void;
     }): Promise<VfsStat>;
+    private writeFileReal;
     /**
      * Delete a file, or a directory when `recursive`.
      *
@@ -7485,6 +8586,12 @@ declare class VfsNamespace {
         recursive?: boolean;
         keepContent?: boolean;
     }): Promise<void>;
+    /**
+     * `swap`: instead of deleting the folder, put `swap.link` in its place (see `finishSharing`). Everything else
+     * a recursive delete does to keep a concurrent move or write from being lost is the same; what it would let
+     * go of, or detach unread, it refuses instead.
+     */
+    private deleteReal;
     /**
      * Move or rename. Works across directories, which is the same operation:
      * detach the entry from one parent and attach it to another.
@@ -7495,6 +8602,7 @@ declare class VfsNamespace {
      * first: what is below must still be inside MAX_DEPTH once it is moved.
      */
     rename(from: string, to: string): Promise<void>;
+    private renameReal;
     /**
      * Refuse to move the directory at `src` to `dst` when something in it
      * would then be deeper than MAX_DEPTH from the root. Writes nothing.
@@ -7519,6 +8627,7 @@ declare class VfsNamespace {
      * onto the other.
      */
     copy(from: string, to: string): Promise<VfsStat>;
+    private copyReal;
     /**
      * Paths matching a glob, relative to the whole filesystem.
      *
@@ -7564,6 +8673,106 @@ declare class VfsNamespace {
      * undoable rather than a one-way door.
      */
     restore(path: string, index?: number): Promise<VfsStat>;
+    private restoreReal;
+    /**
+     * Put a link to a share at `path` in the user's own files. Paths below it are then served by that share,
+     * as paths below `/Home/Shared/<name>` are. The link holds nothing else: deleting it, moving it or copying it
+     * touches only the link, never the share.
+     *
+     * Throws VfsConflictError when anything is at `path` already (including an entry this version cannot read),
+     * and for a place a link cannot go: `/Home/Shared`, `/Home`, or inside a share.
+     */
+    link(path: string, spaceId: string): Promise<void>;
+    /** The share a link at `path` stands for. VfsConflictError when what is there is not a link. */
+    readLink(path: string): Promise<{
+        spaceId: string;
+    }>;
+    /** `readLink`, with the link entry's own id (for `client.shares.shareFolder`: see `sharingAccess.ts`). */
+    private readLinkEntry;
+    /**
+     * Read a folder of the user's own for sharing: every file below it with its manifest, the empty folders, and
+     * the share an unfinished earlier run was moving it into. Changes nothing.
+     *
+     * Refused (VfsConflictError) for anything a share cannot take whole: not a folder; `/`, `/Home`, a link, or
+     * a place in a share; a folder holding a link, an entry this version cannot read, or one half of a move that
+     * did not finish; a folder or file named in two places inside it.
+     */
+    private sharingPlan;
+    /**
+     * Mark the folder at `path` (still the folder `dirId`) as being moved into the share `spaceId`, so a run that
+     * stops part-way resumes into the same share. Replaces an earlier mark (a share that moved on to a successor).
+     */
+    private markSharing;
+    /**
+     * The last step of sharing a folder: replace the folder at `path` - still the folder `dirId`, still marked as
+     * going to `spaceId` - with a link to that share, then remove its records. Each file's current content is
+     * NOT let go of here: the files whose records were removed are returned (`detached`) for the caller to let
+     * go of. What is let go of here is each such file's earlier versions, which a share does not keep, and its
+     * history record. A record that, read again from the store just before its removal, holds anything not in
+     * `moved` (another device wrote into it) is left in place and listed in `kept`.
+     *
+     * Refused with VfsConflictError, changing nothing, unless the folder holds exactly what `moved` lists: a file
+     * saved, changed, moved out or deleted since (by its id and manifest id), a new empty folder, a link, an
+     * entry this version cannot read, or a move that did not finish. Read the folder again first.
+     */
+    private finishSharing;
+    /**
+     * Whether `path` is a link, `/Home/Shared`, or inside a share - somewhere the user's own files are not, and
+     * that only `list`, `stat`, `readFile`, `writeFile`, `mkdir`, `delete`, `rename`, `copy` and walks serve.
+     * True for a link even with no shares wired. Version control refuses a project there.
+     */
+    inShare(path: string): Promise<boolean>;
+    /**
+     * Where `path` leads, with shares wired.
+     *
+     * - `/Home` is virtual for reads: the user's own `/Home` folder (if there is one) plus `Shared`. For a write
+     *   (`write`), it is that real folder, made when first written into. A real `/Home` that is not a folder is
+     *   just that entry.
+     * - `/Home/Shared` lists the shares; `/Home/Shared/<name>/...` is inside the share listed as `<name>`
+     *   (VfsNotFoundError when there is none). The user's own `/Home/Shared`, if they have one, is reached as
+     *   `/Home/Shared (yours)` (see `sharedAlias`).
+     * - A path that passes through a link is inside that link's share. `follow` also follows a link AT the path
+     *   (list, walk, read, cd); without it the path is the link itself (stat, delete, rename, writeFile).
+     * - Anything else is the user's own tree, unchanged.
+     *
+     * Records that cannot be read on the way are left to the operation to report, as it always has.
+     *
+     * A write (`write`, unless `guard` is false - a copy's source is only read) to `/Home/Shared/<X>/...` is
+     * refused when the user's own `/Home/Shared` holds `<X>`: until shares came, that path WAS their folder, and
+     * a mount, a script or a bookmark that still means it would otherwise write personal files into a share, or
+     * delete a share's files. Reads still go to the share.
+     */
+    private route;
+    /** The first link among the first `upto` names of `parts`, followed from the root, and where it is. */
+    private linkOnTheWay;
+    /**
+     * The user's own `/Home/Shared` holds `name`: refuse a write to `target`, which is `/Home/Shared/<name>/...`.
+     * See `route`.
+     */
+    private refuseStaleSharedPath;
+    /**
+     * Both ends of a move or a copy. A destination in `/Home/Shared` that names no share is across a boundary.
+     * `sourceIsRead`: a copy, whose source is only read.
+     */
+    private routeEnds;
+    /**
+     * `path` in the user's own tree, for an operation that has no meaning in a share (`what` says why). Without
+     * shares, the path as it is.
+     */
+    private ownPath;
+    /** `/Home` is the Home folder: only a folder may be moved or copied there. */
+    private refuseNonDirAtHome;
+    /** The user's own `/Home` entry, and its record when it is a folder. */
+    private realHome;
+    /**
+     * The name the user's own `/Home/Shared` is shown and reached under - `Shared (yours)`, or the first of
+     * `Shared (yours 2)`, `Shared (yours 3)`... not taken in `/Home` - or null when they have none.
+     */
+    private sharedAlias;
+    /** Rewrites a stat of the user's own `/Home/Shared`, or of anything in it, to the path it is shown under. */
+    private shownPaths;
+    /** `/Home`'s listing: the user's own `/Home` folder, if any, and `Shared`. */
+    private listHome;
     private expectFile;
     /** Resolve a path to its entry, or null. Root has no entry of its own. */
     private find;
@@ -7825,6 +9034,17 @@ declare class VfsNamespace {
      * elsewhere is kept, and so is a file.
      */
     private purge;
+    /**
+     * Remove the records of a folder that has just been replaced by a link to the share its files went to (see
+     * `finishSharing`), and return the files whose records went, for the caller to let go of their content.
+     *
+     * Each record is read again from the store, past the cache, just before it is removed: the checks before the
+     * swap looked at this device's copies, and another device may have written into one since. A record that now
+     * holds anything not in `moved` (or cannot be read) is left in place, with a warning, and its files are not
+     * returned. Otherwise each file's earlier versions are let go of and its history record removed. Best-effort,
+     * like `purge`: a failure leaks storage, never loses anything.
+     */
+    private purgeShared;
     /**
      * Unmark what is left of an interrupted move once a delete has removed
      * the other copy. Marked, a file keeps every version that falls off its
@@ -8064,6 +9284,12 @@ declare class Repo {
     private readonly maxTreeDepth;
     constructor(slug: string, deps: VcsNamespaceDeps);
     private get root();
+    /**
+     * Refuse a project whose working tree is a link or inside a shared folder. A share's files have no content
+     * handles the repository could record, so a commit there would hold no files, and a checkout of it would
+     * delete every file in the share.
+     */
+    private assertOwnTree;
     /** Store an object, returning its hash and whether it was new. */
     private put;
     /** Does this stored record open to an object with this hash? */
@@ -8323,6 +9549,12 @@ interface ClientOptions {
     sessionStore?: SessionStore;
     /** Custom fetch — defaults to `globalThis.fetch`. */
     fetch?: typeof fetch;
+    /**
+     * Where `client.shares` keeps its per-device state: the device login of a guest account it made (see
+     * {@link SharesNamespace.joinWithPassword}), an unfinished guest setup or rotation. Defaults to `localStorage`
+     * in a browser (keyed by the app key and accelerator), memory elsewhere.
+     */
+    sharesStore?: SharesLocalStore;
     /** Optional log level for the SDK logger. */
     logLevel?: string;
     /**
@@ -8387,6 +9619,8 @@ declare class Client {
     readonly message: MessageNamespace;
     /** Fan-out group spaces — `client.space.createSpace(...)`, etc. */
     readonly space: SpaceNamespace;
+    /** Shared folders — `client.shares.create(...)`, `client.shares.joinWithPassword(...)`, etc. */
+    readonly shares: SharesNamespace;
     /** Trust records shared by every Space: pins and per-Space log heads (design §3.4, §6.9). */
     readonly trust: {
         readonly persistent: boolean;
@@ -8401,6 +9635,8 @@ declare class Client {
     readonly accessTokens: AccessTokensNamespace;
     /** This app — `client.app.access()`: may the signed-in user add data here? */
     readonly app: AppNamespace;
+    /** Vector search — `client.vectors.collection("docs").query({ text })`, plus owner management of collections. */
+    readonly vectors: VectorsNamespace;
     /** Offline cache + sync — `client.offline.status`, `client.offline.snapshot`, etc. */
     readonly offline: OfflineManager;
     private readonly session;
@@ -9687,7 +10923,7 @@ declare function getId(row: {
  * expect (and isn't serving a stale cached bundle). Keep this in sync with
  * `package.json` `version`.
  */
-declare const VERSION = "0.15.0-alpha.10";
+declare const VERSION = "0.15.0-alpha.12";
 
 /**
  * The SDK's process-global logger.
@@ -9719,5 +10955,5 @@ declare global {
 }
 declare const appLogger: InstanceType<typeof Logger>;
 
-export { ACCESS_TOKEN_SCOPES, AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, 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, HLC, HashKnowledge, HostedAuth, HttpClient, HttpError, IdentityLockedError, IdentityUnavailableError, IndexedDbStore, KEEPER_MEMBER_ID, KeyStore, KeyringClient, KeyringHttpError, KvCache, KvNamespace, LocalEngineHost, LocalStorageSessionStore, Logger, 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, SerializeMessage, SessionState, ShardCache, ShardClient, SharedSpaceClient, 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, assertType, base58Decode, base58Encode, buildCommitment, canonicalUserCode, clearDeviceIdentity, compareHlc, compilePrograms, concatBytes, configureDeviceStore, createPasskeyWithPrf, decodeFromHex, decorators, decryptAesGcm, defaultCircuitUrls, defaultRpId, defaultSessionStore, deleteBeatsWrite, deleteRegister, deriveAesKeyFromPassphrase, deriveBitsHkdf, deriveIdentity, deriveIdentityFromSeed, deriveMasterSeedFromPassword, deserialize, deviceFingerprint, deviceIdentityIsEphemeral, deviceIdentityKey, dirKey, ejectAgentPrompt, ejectAgentTools, emptyMap, emptyRegister, encodeToHex, encryptAesGcm, evaluatePasskeyPrf, exportPublicKeyBase64, exportPublicKeyHex, formatUserCode, fromBase64, fromBase64Url, fromHex, generateAuthProof, generateChecksum, generateDevicePairingKeypair, generateId, generatePkce, getIPAddress, getId, getMuhkooAppDescriptor, getSubtle, hasDeviceIdentity, headKey, historyKey, initBn128Wasm, initRsWasm, initializeCircuits, isNewer, isNumber, isOfflineCapable, isP2pCapable, isProvisional, isSameOriginPath, loadDeviceIdentity, log, 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, serialize, shardHash, signMessage, stableStringify, toBase64, toBase64Url, toField, toHex, tombstoneRow, unpack, unsealSeed, unsealSeedFromDevice, unwrapWithPassphrase, utf8Decode, utf8Encode, verify, verifyChecksum, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase, writeBeatsTombstone, writeColumns, writeRegister };
-export type { ACL, ACLEntry, AccessTokenInfo, AccessTokensNamespaceDeps, AdmissionState, AgentConfig, AgentCreateInput, AgentDbToolMode, AgentProvisioned, AgentScopeOpts, AgentSkill, AgentToolsConfig, AgentTrigger, AgentTriggerType, AgentUpdateInput, AgentsNamespaceDeps, AppAccess, AppNamespaceDeps, AttachedPeerNetwork, AuthClientOptions, AuthKeyPair, AuthSuccess, AuthToken, AuthType, AuthUser, BlockStore, Bn128WasmInstance, BroadcastChannelEvent, BroadcastChannelOptions, CachedSpaceMessage, Change, ChannelLike, ChatKeyCert, ChunkKeyMaterial, ChunkManifest, CipherFrame, CipherMessage, CipherMessageHeader, CircuitBufferConfig, CircuitIntegrity, CircuitUrls, ClientOptions, Commit, Conflict, ConnectivityOptions, ConnectivityState, CreateAccessTokenInput, CreatedAccessToken, DbFilterOp, DbNamespaceDeps, DbQuery, DbQueryPage, DbQueryResult, DbWhereCondition, 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, MemberView, MembershipEntry, 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, PaymentRequiredCode, PeerBlockSource, PeerExchangeOptions, PeerId, PeerNetworkOptions, PeerTransport, Permission, PermissionCheckRequest, PermissionCheckResult, PersistedDeviceIdentity, PersonalSpaceClientOptions, Pkce, PublicKeyJWK, QueueEntry, RatchetState, ReceiveResult, RegisterParams, Replayer, Role$1 as 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, SpaceTrustCode, 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 };
+export { ACCESS_TOKEN_SCOPES, AES_GCM_IV_BYTES, AES_GCM_KEY_BYTES, 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, 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, assertType, base58Decode, base58Encode, buildCommitment, canonicalUserCode, clearDeviceIdentity, compareHlc, compilePrograms, 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, 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, toBase64Url, toField, toHex, tombstoneRow, unpack, unsealSeed, unsealSeedFromDevice, unwrapWithPassphrase, utf8Decode, utf8Encode, verify, verifyChecksum, verifyGroth16, verifyHashKnowledge, verifyPreimagePoK, wrapWithPassphrase, writeBeatsTombstone, writeColumns, writeRegister };
+export type { ACL, ACLEntry, AccessTokenInfo, AccessTokensNamespaceDeps, AdmissionState, AgentConfig, AgentCreateInput, AgentDbToolMode, AgentProvisioned, AgentScopeOpts, AgentSkill, AgentToolsConfig, AgentTrigger, AgentTriggerType, AgentUpdateInput, AgentsNamespaceDeps, AppAccess, AppNamespaceDeps, AttachedPeerNetwork, AuthClientOptions, AuthKeyPair, AuthSuccess, AuthToken, AuthType, AuthUser, BlockStore, Bn128WasmInstance, BroadcastChannelEvent, BroadcastChannelOptions, CachedSpaceMessage, Change, ChannelLike, ChatKeyCert, ChunkKeyMaterial, ChunkManifest, CipherFrame, CipherMessage, CipherMessageHeader, CircuitBufferConfig, CircuitIntegrity, CircuitUrls, ClientOptions, Commit, Conflict, ConnectivityOptions, ConnectivityState, CreateAccessTokenInput, CreateShareBody, CreateShareOptions, CreatedAccessToken, DbFilterOp, DbNamespaceDeps, DbQuery, DbQueryPage, DbQueryResult, DbWhereCondition, DehydratedKeypair, DehydratedKeys, DeviceBlobStore, DeviceKeyVault, DevicePairingErrorReason, DevicePairingKeypair, DevicePairingPoll, DevicePairingRequest, DevicePairingSession, DirEntry, DirNode, DoubleRatchetCipherDeps, ECDHCurve, EditPolicy, EncodeResult, EngineHandle, EngineHost, Entry, EphemeralEvent, EpochKeyProvider, FileEntry, FileManifest, FileNamespaceDeps, FileStat, FileStorageOptions, FunctionCaps, FunctionConfig, FunctionDeployInput, FunctionInvokeOptions, FunctionScopeOpts, FunctionTrigger, FunctionTriggerType, FunctionTriggers, FunctionUpdateInput, FunctionsNamespaceDeps, Groth16Proof, GuestDeviceLogin, GuestRecovery, Hasher, Head, HistoryRecord, HlcParts, HlcState, HostedAuthDeps, HttpClientOptions, IncomingFrame, KeyExchangeFrame, KeyPair, Keypair, KeyringClientDeps, KeyringTransport, KvEntry, KvNamespaceDeps, LinkEntry, LogEntry, LoginOptions, LwwMap, LwwRegister, MemberView, MembershipEntry, 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, PasswordVerifier, PaymentRequiredCode, PeerBlockSource, PeerExchangeOptions, PeerId, PeerNetworkOptions, PeerTransport, Permission, PermissionCheckRequest, PermissionCheckResult, PersistedDeviceIdentity, PersonalSpaceClientOptions, Pkce, PublicKeyJWK, QueueEntry, RatchetState, ReceiveResult, RegisterParams, Replayer, Role$1 as Role, SpaceDeps as RoomDeps, SpaceFileMetadata as RoomFileMetadata, Scope, SealedHandoff, SealedHeaders, SealedRecord, Session, SessionOptions, SessionStore, SetOptions, ShardByteCache, ShardClientOptions, ShareAdmitBody, ShareAdoptFile, ShareAdoptItem, ShareEntry, ShareFolderOptions, ShareGuestAuth, ShareInfo, ShareKind, ShareOptions, SharePublicInfo, ShareSpaceHandle, ShareSpaceKeyring, ShareSpaces, ShareSummary, SharedSpaceClientOptions, SharesLocalStore, SharesNamespaceDeps, SignalEnvelope, SignalKind, SignalingSpace, SnapshotNamespaceDeps, SnarkProof, SpaceChannelLike, SpaceCursor, SpaceDeps, SpaceFileMetadata, SpaceKeyCache, SpaceKeyringDeps, SpaceMessageEvent, SpaceNamespaceDeps, SpaceOfflineAdapter, SpaceTrustCode, StartDevicePairingOptions, StorageChangeEvent, StoreName, StoredSession, Subscription, Tree, TreeDir, TreeEntry, TreeFile, UserIdentity, VaultFactor, VcsNamespaceDeps, VcsNamespaceOptions, VectorAudience, VectorCollectionDefinition, VectorCollectionInfo, VectorEntry, VectorEntryInput, VectorEnvInfo, VectorFieldDefinition, VectorMatch, VectorNotices, VectorNotify, VectorQueryInput, VectorReadyEvent, VectorUpsertOptions, VectorWriteResult, VectorWriteState, VectorsNamespaceDeps, VerificationKey, VfsContentStore, VfsNamespaceDeps, VfsStat, VfsStore, WSMessage, WSMessageType, WSTransportOptions, WaitForDevicePairingOptions, WebRtcTransportOptions, WrappedPayload, WriteFileInput, WriteFileOptions, WriteToShardsInput, ZkAuthDeps, ZkAuthenticateRequest, ZkChallengeResponse, ZkCompiled, ZkIdentity, ZkRegisterRequest, ZkRegisterResponse };