@interncom/diplomatic 0.22.0 → 0.24.0

package/dist/web/stores/idb/store.d.ts

@@ -1,12 +1,12 @@
+import { Status } from "../../shared/consts";
 import { ICrypto } from "../../shared/types";
-import { IStore } from "../../types";
-import { IDBDownloadQueue } from "./dnlds";
-import { IDBHostStore } from "./hosts";
-import { IDBMessageStore } from "./msgs";
-import { IDBSeedStore } from "./seed";
-import { IDBUploadQueue } from "./uplds";
-export declare const SEED_META_TABLE = "seedMeta";
+import { type ValStat } from "../../shared/valstat";
+import { IAccountStore, IDownloadQueue, IHostStore, IMessageStore, IStore, IUploadQueue } from "../../types";
+import type { IRealmStore } from "../realm";
+export declare const ACCOUNTS_TABLE = "accounts";
 export declare const HOSTS_TABLE = "hosts";
+/** Host-realm cursors. Key is host, realm label, realm index. */
+export declare const HOST_SEQS_TABLE = "host_seqs";
 export declare const UPLOAD_QUEUE_TABLE = "uploadQueue";
 export declare const DOWNLOAD_QUEUE_TABLE = "downloadQueue";
 export declare const MESSAGES_TABLE = "messages";
@@ -16,22 +16,29 @@ export declare const MESSAGES_TABLE = "messages";
  * strings keep keys compact.
  */
 export declare const MESSAGES_APLD_INDEX = "apld";
-/** Schema version: v3 adds messages.apld index for the apply queue. */
-export declare const DIPLOMATIC_STORE_DB_VERSION = 3;
-export declare const DIPLOMATIC_STORE_DB_NAME = "diplomatic-store-db";
+/** Realm label. Default-realm rows omit rlm and are not in this index. */
+export declare const MESSAGES_RLM_INDEX = "rlm";
+export declare const REALMS_TABLE = "realms";
 export declare class IDBStore implements IStore<URL> {
-    seed: IDBSeedStore;
-    hosts: IDBHostStore;
-    uploads: IDBUploadQueue;
-    downloads: IDBDownloadQueue;
-    messages: IDBMessageStore;
-    db: IDBDatabase;
-    constructor(db: IDBDatabase, crypto: ICrypto);
+    #private;
+    account: IAccountStore;
+    realms: IRealmStore;
+    hosts: IHostStore<URL>;
+    uploads: IUploadQueue;
+    downloads: IDownloadQueue;
+    messages: IMessageStore;
+    constructor(account: IAccountStore, crypto: ICrypto, lookup?: (label: string) => Promise<string | undefined>, db?: IDBDatabase);
+    bind(label: string): Promise<Status>;
+    prepareWorker(label: string): Promise<ValStat<{
+        data: string;
+        ents: string;
+    }>>;
+    close(): void;
     /**
      * Clear protocol tables only (not seed). Seed is wiped only via
-     * {@link ISeedStore.wipe} when client.wipe({ seed: true }).
+     * {@link IAccountStore.wipe} when client.wipe({ seed: true }).
      */
     wipe(): Promise<void>;
 }
-export declare function openIDBStoreDB(): Promise<IDBDatabase>;
 export declare function openIDBStore(crypto: ICrypto): Promise<IDBStore>;
+export declare function openBoundStore(crypto: ICrypto, data: string): Promise<IDBStore>;

package/dist/web/stores/idb/uplds.d.ts

@@ -1,7 +1,7 @@
 import { Hash } from "../../shared/types";
 import { IUploadQueue } from "../../types";
 export declare class IDBUploadQueue implements IUploadQueue {
-    db: IDBDatabase;
+    private db;
     constructor(db: IDBDatabase);
     enq(host: string, hshs: Iterable<Hash>): Promise<void>;
     deq(host: string, hshs: Iterable<Hash>): Promise<void>;

package/dist/web/stores/keyTag.d.ts

@@ -0,0 +1,14 @@
+import { type PDK } from "../shared/crypto/derivation";
+import type { Enclave } from "../shared/crypto/enclave";
+import type { ICrypto } from "../shared/types";
+import { type ValStat } from "../shared/valstat";
+/** Nonce plus the fingerprint child that names the master. */
+export type KeyTag = {
+    n: Uint8Array;
+    h: PDK["Fingerprint"];
+};
+export declare function keyTagDigest(enclave: Enclave, nonce: Uint8Array): Promise<ValStat<PDK["Fingerprint"]>>;
+export declare function makeKeyTag(crypto: ICrypto, enclave: Enclave): Promise<ValStat<KeyTag>>;
+export declare function keyTagMatches(enclave: Enclave, tag: KeyTag): Promise<boolean>;
+export declare function decodeKeyTag(raw: unknown): KeyTag | undefined;
+export declare function cloneKeyTag(tag: KeyTag): KeyTag;

package/dist/web/stores/label.d.ts

@@ -0,0 +1,3 @@
+import { type ValStat } from "../shared/valstat";
+export declare function accountLabel(raw: string | undefined): ValStat<string>;
+export declare function singleAccountLabel(current: string | undefined, raw: string | undefined, occupied: boolean): ValStat<string>;

package/dist/web/stores/memory/account.d.ts

@@ -0,0 +1,14 @@
+import type { Enclave } from "../../shared/crypto/enclave";
+import type { ICrypto } from "../../shared/types";
+import { type ValStat } from "../../shared/valstat";
+import type { IAccountStore, SetSeedOpts } from "../../types";
+import { type KeyTag } from "../keyTag";
+/** Account list in memory. One slot per label. The client holds the open account. */
+export declare class MemoryAccountStore implements IAccountStore {
+    #private;
+    constructor(crypto: ICrypto);
+    save(enclave: Enclave, opts?: SetSeedOpts): Promise<ValStat<Enclave>>;
+    wipe(): Promise<void>;
+    /** Test helper: snapshot of one account's key tag. Omitted label is "". */
+    peekKeyTag(label?: string): KeyTag | undefined;
+}

package/dist/web/stores/memory/dnlds.d.ts

@@ -1,8 +1,10 @@
+import type { IKDM } from "../../shared/codecs/kdm";
 import { IDownloadMessage, IDownloadQueue } from "../../types";
+import { type DownloadKey } from "../cursor";
 export declare class MemoryDownloadQueue implements IDownloadQueue {
-    queue: Map<string, IDownloadMessage>;
+    queue: Map<DownloadKey, IDownloadMessage>;
     enq(msgs: Iterable<IDownloadMessage>): Promise<void>;
-    deq(host: string, seqs: Iterable<number>): Promise<void>;
+    deq(host: string, seqs: Iterable<number>, realm?: IKDM): Promise<void>;
     list(): Promise<IDownloadMessage[]>;
     count(): Promise<number>;
     wipe(): Promise<void>;

package/dist/web/stores/memory/hosts.d.ts

@@ -1,18 +1,20 @@
+import type { IKDM } from "../../shared/codecs/kdm";
 import { Status } from "../../shared/consts";
 import { HostHandle, IHostConnectionInfo, IHostMetadata } from "../../shared/types";
-import type { HostStatsUpdate, IHostRow, IHostStore } from "../../types";
+import type { HostSeqsUpdate, IHostRow, IHostStore } from "../../types";
 export declare class MemoryHostStore<Handle extends HostHandle> implements IHostStore<Handle> {
+    #private;
     hosts: Map<string, IHostRow<Handle>>;
     /**
-     * Upsert connection info. Same label + same handle/idx keeps lastSeq and
-     * host meta (safe re-link). Changing handle/idx resets the peek cursor.
+     * Upsert connection info. Same label + same handle/idx keeps cursors and
+     * host meta (safe re-link). Changing handle/idx clears cursors.
      */
     add(info: IHostConnectionInfo<Handle>): Promise<void>;
-    touch(label: string, seq: number): Promise<void>;
-    recordStats(label: string, u: HostStatsUpdate): Promise<void>;
+    touch(label: string, seq: number, realm?: IKDM): Promise<void>;
+    recordSeqs(label: string, u: HostSeqsUpdate, realm?: IKDM): Promise<void>;
     get(label: string): Promise<IHostRow<Handle> | undefined>;
     set(label: string, meta: IHostMetadata): Promise<Status.Success | Status.NotFound>;
     del(label: string): Promise<void>;
-    list(): Promise<MapIterator<IHostRow<Handle>>>;
+    list(): Promise<IHostRow<Handle>[]>;
     wipe(): Promise<void>;
 }

package/dist/web/stores/memory/realms.d.ts

@@ -0,0 +1,10 @@
+import { Status } from "../../shared/consts";
+import { type IRealm, type IRealmStore } from "../realm";
+/** Realm counters in memory. One store is one account. */
+export declare class MemoryRealmStore implements IRealmStore {
+    #private;
+    list(): Promise<IRealm[]>;
+    get(label: string): Promise<IRealm | undefined>;
+    put(label: string, index: number): Promise<Status>;
+    wipe(): Promise<void>;
+}

package/dist/web/stores/memory/store.d.ts

@@ -1,16 +1,20 @@
+import { Status } from "../../shared/consts";
 import { HostHandle, ICrypto } from "../../shared/types";
 import { IStore } from "../../types";
 import { MemoryDownloadQueue } from "./dnlds";
 import { MemoryHostStore } from "./hosts";
 import { MemoryMessageStore } from "./msgs";
-import { MemorySeedStore } from "./seed";
+import { MemoryAccountStore } from "./account";
+import { MemoryRealmStore } from "./realms";
 import { MemoryUploadQueue } from "./uplds";
 export declare class MemoryStore<Handle extends HostHandle> implements IStore<Handle> {
-    seed: MemorySeedStore;
+    account: MemoryAccountStore;
+    realms: MemoryRealmStore;
     hosts: MemoryHostStore<Handle>;
     uploads: MemoryUploadQueue;
     downloads: MemoryDownloadQueue;
     messages: MemoryMessageStore;
     constructor(crypto: ICrypto);
+    bind(): Promise<Status>;
     wipe(): Promise<void>;
 }

package/dist/web/stores/realm.d.ts

@@ -0,0 +1,35 @@
+import { Status } from "../shared/consts";
+import { type ValStat } from "../shared/valstat";
+declare const entRlmSymbol: unique symbol;
+/** Non-empty realm label on an ent or archived message. */
+export type EntRlm = string & {
+    readonly [entRlmSymbol]: true;
+};
+/** One realm. `index` is the current KDM counter; `prior` are older ones. */
+export interface IRealm {
+    label: string;
+    index: number;
+    /** Counters older than `index` whose bags may still exist. */
+    prior?: number[];
+}
+/** Realm label for a row. The default realm ("" or missing) is omitted. */
+export declare function realmLabel(raw: unknown): EntRlm | undefined;
+/** Drops `rlm` when this row is in the default realm. */
+export declare function omitDefaultRealm<T extends {
+    rlm?: EntRlm | string;
+}>(row: T): T;
+export declare function decodeRealm(raw: unknown): IRealm | undefined;
+export declare function advanceRealm(label: string, prev: IRealm | undefined, index: number): ValStat<IRealm>;
+/** Realm counters for one account. The store is that account. */
+export interface IRealmStore {
+    list(): Promise<IRealm[]>;
+    /** One realm, or undefined when this account has no row for the label. */
+    get(label: string): Promise<IRealm | undefined>;
+    /**
+     * Set the current index.
+     * A higher index keeps the previous one in `prior`.
+     */
+    put(label: string, index: number): Promise<Status>;
+    wipe(): Promise<void>;
+}
+export {};

package/dist/web/sync.d.ts

@@ -1,6 +1,7 @@
 import DiplomaticClientAPI from "./shared/client";
+import { type IKDM } from "./shared/codecs/kdm";
 import { Status } from "./shared/consts";
-import { Enclave } from "./shared/crypto/enclave";
+import type { BagManager } from "./shared/crypto/bagman";
 import { Hash, HostHandle, IBag, ICrypto } from "./shared/types";
 import { ValStat } from "./shared/valstat";
 import { ProgressFn } from "./progress";
@@ -20,11 +21,10 @@ export type IPulled = {
     bodyCph?: Uint8Array;
 };
 /** Host connection methods used by sync phases. */
-export type SyncConn<Handle extends HostHandle> = Pick<DiplomaticClientAPI<Handle>, "pull" | "push" | "peek" | "seal" | "identity">;
+export type SyncConn<Handle extends HostHandle> = Pick<DiplomaticClientAPI<Handle>, "pull" | "push" | "peek" | "seal" | "identity" | "hostRlm" | "bagMgrFor" | "bagMgrs">;
 export interface ISyncParams<Handle extends HostHandle> {
     conn: SyncConn<Handle>;
     store: IStore<Handle>;
-    enclave: Enclave;
     host: IHostRow<Handle>;
     crypto: ICrypto;
     /** Soft max sealed-bag bytes per push request. Oversized bags go alone. */
@@ -40,9 +40,11 @@ export interface ISyncParams<Handle extends HostHandle> {
      * Default `defaultPeekConcurrency`. Set 1 for fully serial.
      */
     peekConcurrency?: number;
+    /** Realm for this peek. Push and pull use each item's own realm. */
+    realm?: IKDM;
 }
-/** Push one batch of sealed bags; deq successes; advance lastSeq from store. */
-export declare function pushBatch<Handle extends HostHandle>(conn: Pick<DiplomaticClientAPI<Handle>, "push">, store: IStore<Handle>, hostLabel: string, bags: IBag[], hashes: Hash[]): Promise<Status>;
+/** Push one batch of sealed bags; deq successes; advance that realm's cursor. */
+export declare function pushBatch<Handle extends HostHandle>(conn: Pick<DiplomaticClientAPI<Handle>, "push">, store: IStore<Handle>, hostLabel: string, bags: IBag[], hashes: Hash[], realm?: IKDM): Promise<Status>;
 /** pull: network only. Download-queue items → ciphertext (still enqueued). */
 export declare function pullBodies<Handle extends HostHandle>(conn: Pick<DiplomaticClientAPI<Handle>, "pull">, items: IDownloadMessage[]): Promise<ValStat<IPulled[]>>;
 export type IOpened = {
@@ -54,14 +56,14 @@ export type IOpened = {
  * Bad bags are dequeued and skipped (not retry-able).
  * Does not exec or push.
  */
-export declare function openPulled<Handle extends HostHandle>(store: IStore<Handle>, enclave: Enclave, crypto: ICrypto, items: IPulled[]): Promise<ValStat<IOpened>>;
+export declare function openPulled<Handle extends HostHandle>(store: IStore<Handle>, bagMgrs: readonly BagManager[], crypto: ICrypto, items: IPulled[]): Promise<ValStat<IOpened>>;
 /**
  * Drop download-queue rows whose head matches archive keys we just stored
  * (import / local apply). One list() + batched deq — not per-row messages.has.
  */
 export declare function deqDownloadsForHeadHashes<Handle extends HostHandle>(store: Pick<IStore<Handle>, "downloads">, hashes: Iterable<Hash>, crypto: ICrypto): Promise<void>;
 /** Discover unseen bags and enqueue download work; advance host lastSeq. */
-export declare function syncPeek<Handle extends HostHandle>({ conn, store, enclave, host, crypto, onProgress, peekProgressEvery, peekConcurrency, }: ISyncParams<Handle>): Promise<Status>;
+export declare function syncPeek<Handle extends HostHandle>({ conn, store, host, crypto, onProgress, peekProgressEvery, peekConcurrency, realm: realmArg, }: ISyncParams<Handle>): Promise<Status>;
 /** Seal and upload pending msgs; list once so concurrent enqs wait for next sync. */
 export declare function syncPush<Handle extends HostHandle>({ conn, store, host, maxPushBytes, onProgress }: ISyncParams<Handle>): Promise<Status>;
 /**
@@ -73,22 +75,22 @@ export declare function syncPush<Handle extends HostHandle>({ conn, store, host,
  * All bags are still pulled/opened; EntDB LWW already ignores obsolete ops.
  * Newest-first exec reaches final app state early in a large catch-up.
  */
-export declare function syncPull<Handle extends HostHandle>({ conn, store, enclave, host, crypto, maxPullBytes, onProgress, }: ISyncParams<Handle>, 
+export declare function syncPull<Handle extends HostHandle>({ conn, store, host, crypto, maxPullBytes, onProgress, }: ISyncParams<Handle>, 
 /** After each opened pull batch (e.g. drainApplyQueue / exec). */
 afterOpen?: () => Promise<void>): Promise<Status>;
-export declare function msg2StoredMsgData({ head, body }: IMsgParts): IStoredMessageWrite;
+export declare function msg2StoredMsgData({ head, body }: IMsgParts, realm?: IKDM): IStoredMessageWrite;
 /**
  * notif → open inline bodies into archive; enq incomplete → scheduleSync.
  * `scheduleSync` runs full peek/push/pull (or worker handoff).
  */
-export declare function handleNotif<Handle extends HostHandle>(bytes: Uint8Array, { conn, store, enclave, host, crypto, onProgress, }: ISyncParams<Handle>, scheduleSync: () => void): Promise<void>;
+export declare function handleNotif<Handle extends HostHandle>(bytes: Uint8Array, { conn, store, host, crypto, onProgress, }: ISyncParams<Handle>, scheduleSync: () => void): Promise<void>;
 /**
- * Full host inventory (PEEK from seq 0): set lastSeq; optionally enqueue
- * downloads (msgs on host missing locally) and/or uploads (local msgs missing
- * on host). Returns ephemeral bag tallies + msgcheck (not persisted). Does not
- * pull/push beyond peek — caller should sync() to drain queues.
+ * Full host inventory (PEEK from seq 0 in each realm): set that realm's cursor;
+ * optionally enqueue downloads (msgs on host missing locally) and/or uploads
+ * (local msgs missing on host). Returns ephemeral bag tallies + msgcheck (not
+ * persisted). Does not pull/push beyond peek — caller should sync() to drain.
  *
- * lastSeq is set to the max bag seq in the inventory (0 if empty), including
- * rewind when the host has fewer bags than a prior cursor believed.
+ * Each cursor is the max bag seq in that realm (0 if empty), including rewind
+ * when the host has fewer bags than a prior cursor believed.
  */
 export declare function reconcileHost<Handle extends HostHandle>(params: ISyncParams<Handle>, opts?: ReconcileOpts): Promise<ValStat<ReconcileResult>>;

package/dist/web/types.d.ts

@@ -1,10 +1,13 @@
 import type { SyncProgressEvent } from "./progress";
+import type { IKDM } from "./shared/codecs/kdm";
 import { Status } from "./shared/consts";
 import type { Enclave } from "./shared/crypto/enclave";
+import type { IBlobUpdate, IBlobWrite } from "./shared/blobs";
 import type { EncodedMessage } from "./shared/message";
 import type { EntityID, Hash, HostHandle, IDeleteParams, IEntRev, IHostConnectionInfo, IHostMetadata, IInsertParams, IMessageHead, IOp, IUpdateParams, SerializedContent } from "./shared/types";
 import { ValStat } from "./shared/valstat";
 import { ICrypto } from "./shared/types";
+import { type EntRlm, type IRealm, type IRealmStore } from "./stores/realm";
 export interface IMsgParts {
     head: IMessageHead;
     body?: EncodedMessage;
@@ -36,13 +39,18 @@ export type SetSeedOpts = {
      * When true, request durable storage **if the store supports a non-plaintext
      * durable form** (e.g. passkey largeBlob as IdentityBundle wire).
      * IDB holds the enclave in memory only — durable identity is the PRF keyring
-     * via {@link IDBSeedStore.openPrfStore}, never plain seed.
+     * via {@link IDBAccountStore.openPrfStore}, never plain seed.
      * Default false (session enclave only).
      *
      * Future: when PRF is unavailable, durable path is passphrase-sealed meta
      * (KDF + AEAD inside Enclave), not plain seed on disk.
      */
     persist?: boolean;
+    /**
+     * Account to install into. Omitted means the default account, "".
+     * A new label creates that account. An existing key tag must match.
+     */
+    label?: string;
 };
 /**
  * Selective wipe for {@link IClient.wipe}.
@@ -60,28 +68,44 @@ export type WipeOpts = {
     /** Hosts + upload/download queues. Default true. */
     meta?: boolean;
     /**
-     * Seed / identity ({@link ISeedStore.wipe}). Default **false**.
+     * Seed / identity ({@link IAccountStore.wipe}). Default **false**.
      * When true, passkey stores overwrite largeBlob (UV ceremony).
      */
     seed?: boolean;
 };
-export interface ISeedStore {
-    save: (enclave: Enclave, opts?: SetSeedOpts) => Promise<Enclave>;
-    load: () => Promise<Enclave | void>;
+export interface IAccountStore {
+    /** Record this enclave's key tag under `opts.label`. Does not open the account. */
+    save: (enclave: Enclave, opts?: SetSeedOpts) => Promise<ValStat<Enclave>>;
     /**
-     * Clear durable seed material for this store (IDB row, largeBlob overwrite, …)
-     * and drop the in-memory enclave. Called only when client.wipe({ seed: true }).
+     * Clear durable account material (IDB rows, largeBlob overwrite, …).
+     * Called only when client.wipe({ seed: true }).
      */
     wipe: () => Promise<void>;
 }
+/** Account the client is operating as. */
+export type OpenAccount<H extends HostHandle> = {
+    label: string;
+    enclave: Enclave;
+    /** Host rows as of the last open, link, or unlink. */
+    hosts: IHostRow<H>[];
+    /** Realm rows from the realms table, refreshed with hosts and before sync. */
+    realms: IRealm[];
+};
 export interface IHostRow<Handle extends HostHandle> extends IHostConnectionInfo<Handle>, Partial<IHostMetadata> {
+    /** Default-realm cursor, joined from host_seqs on read. */
     lastSeq: number;
+    /** Other realm cursors, joined from host_seqs on read. */
+    seqs?: {
+        label: string;
+        index: number;
+        lastSeq: number;
+    }[];
 }
 /**
  * Host row cursor write (one store transaction).
  * `lastSeq` only advances unless `setLastSeq` is set.
  */
-export type HostStatsUpdate = {
+export type HostSeqsUpdate = {
     /** New lastSeq if greater than current (incremental peek/push). */
     lastSeq?: number;
     /** Absolute lastSeq, including rewind (full inventory). */
@@ -94,9 +118,9 @@ export interface IHostStore<Handle extends HostHandle> {
     set: (label: string, meta: IHostMetadata) => Promise<Status>;
     list: () => Promise<Iterable<IHostRow<Handle>>>;
     wipe: () => Promise<void>;
-    touch: (label: string, seq: number) => Promise<void>;
-    /** Apply lastSeq updates in one transaction. */
-    recordStats: (label: string, u: HostStatsUpdate) => Promise<void>;
+    touch: (label: string, seq: number, realm?: IKDM) => Promise<void>;
+    /** Apply one host_seqs cursor. The default realm is nullKDM. */
+    recordSeqs: (label: string, u: HostSeqsUpdate, realm?: IKDM) => Promise<void>;
 }
 /** Options for {@link IClient.reconcile}. */
 export type ReconcileOpts = {
@@ -152,10 +176,12 @@ export interface IDownloadMessage {
      * blake3(headEnc). When set with headEnc, open skips re-hashing the head.
      */
     headEncHash?: Hash;
+    /** Realm KDM. Omit for the default realm. */
+    realm?: IKDM;
 }
 export interface IDownloadQueue {
     enq: (msgs: Iterable<IDownloadMessage>) => Promise<void>;
-    deq: (host: string, seqs: Iterable<number>) => Promise<void>;
+    deq: (host: string, seqs: Iterable<number>, realm?: IKDM) => Promise<void>;
     list: () => Promise<Iterable<IDownloadMessage>>;
     count: () => Promise<number>;
     wipe(): Promise<void>;
@@ -180,6 +206,8 @@ export interface IStoredMessageFields {
     /** Msg head typ. Omit when empty (raw). */
     typ?: string;
     body?: EncodedMessage;
+    /** Realm label. Omit for the default realm. */
+    rlm?: EntRlm;
 }
 /**
  * What may come back from storage (pre-apld rows can omit the field).
@@ -194,7 +222,7 @@ export interface IStoredMessageData extends IStoredMessageFields {
 /**
  * Required shape for every put into the message archive (app/API layer).
  * `apld` is required and must be one of the three {@link ApldState} values.
- * Omit optional fields (`off`, `ctr`, `typ`, `body`, `err`) rather than storing empties.
+ * Omit optional fields (`off`, `ctr`, `typ`, `body`, `err`, `rlm`) rather than storing empties.
  */
 export type IStoredMessageWrite = IStoredMessageFields & {
     apld: ApldState;
@@ -211,6 +239,8 @@ export interface IStoredMessage {
     body?: EncodedMessage;
     /** Apply lifecycle — same {@link ApldState} as the archive row. */
     apld: ApldState;
+    /** Realm label. Omitted for the default realm. */
+    rlm?: EntRlm;
     /** Status code when apld is {@link APLD_ERROR}. */
     err?: number;
 }
@@ -276,13 +306,20 @@ export interface IMessageStore {
     wipe(): Promise<void>;
 }
 export interface IStore<Handle extends HostHandle> {
-    seed: ISeedStore;
+    account: IAccountStore;
+    /** Realm counters. Not cleared by {@link IStore.wipe}. */
+    realms: IRealmStore;
     hosts: IHostStore<Handle>;
     uploads: IUploadQueue;
     downloads: IDownloadQueue;
     messages: IMessageStore;
     /**
-     * Clear protocol tables (hosts, queues, messages). Does not call seed.wipe.
+     * Open the protocol database for `label`.
+     * A store with one database returns Success.
+     */
+    bind(label: string): Promise<Status>;
+    /**
+     * Clear protocol tables (hosts, queues, messages). Does not call account.wipe.
      */
     wipe(): Promise<void>;
 }
@@ -294,7 +331,7 @@ export interface IStateEmitter<T> {
 }
 export interface IClient<Handle extends HostHandle> {
     /** Install session enclave (master seed stays inside enclave). */
-    setSeed(enclave: Enclave, opts?: SetSeedOpts): Promise<void>;
+    setSeed(enclave: Enclave, opts?: SetSeedOpts): Promise<Status>;
     link(host: IHostConnectionInfo<Handle>, connect?: boolean): Promise<void>;
     unlink(label: string): Promise<void>;
     /** Linked hosts from the protocol store (handle, label, lastSeq, …). */
@@ -303,12 +340,16 @@ export interface IClient<Handle extends HostHandle> {
     disconnect(): Promise<void>;
     insertRaw(content: SerializedContent, typ?: string): Promise<ValStat<IMessageHead>>;
     updateRaw(prior: IEntRev, content: SerializedContent | undefined, force?: boolean, typ?: string): Promise<ValStat<IMessageHead>>;
-    insert<T = unknown>(op: IInsertParams<T>): Promise<ValStat<IMessageHead>>;
-    update<T = unknown>(op: IUpdateParams<T>): Promise<ValStat<IMessageHead>>;
+    insert(op: IInsertParams<Uint8Array>): Promise<ValStat<IMessageHead>>;
+    update(op: IUpdateParams<Uint8Array>): Promise<ValStat<IMessageHead>>;
     /**
      * Delete by `{ prior }` (preferred) or `{ eid }` (archive lookup).
      */
     delete(op: IDeleteParams): Promise<ValStat<IMessageHead>>;
+    insertBlob(mime: string, bytes: Uint8Array, opts?: IBlobWrite): Promise<ValStat<IMessageHead>>;
+    updateBlob(eid: EntityID, bytes: Uint8Array, opts?: IBlobUpdate): Promise<ValStat<IMessageHead>>;
+    deleteBlob(eid: EntityID): Promise<ValStat<IMessageHead>>;
+    readBlob(eid: EntityID): Promise<ValStat<Uint8Array>>;
     /** Allocate an entity id (optional 8-byte id material; else random). */
     genEID(id?: Uint8Array): Promise<ValStat<EntityID>>;
     sync(): Promise<Status>;

package/dist/web/worker/client.d.ts

@@ -30,6 +30,10 @@ export declare class WorkerClient implements IClient<URL> {
     private store;
     /** Main-thread writer: msg archive + local apply for fast UI. */
     private local;
+    insertBlob: IClient<URL>["insertBlob"];
+    updateBlob: IClient<URL>["updateBlob"];
+    deleteBlob: IClient<URL>["deleteBlob"];
+    readBlob: IClient<URL>["readBlob"];
     private nextId;
     private pending;
     /** Max wait for setSeed worker handshake. */
@@ -78,7 +82,7 @@ export declare class WorkerClient implements IClient<URL> {
      * Persist seed on main, then Enclave.spawnSyncWorker (only worker spawn path).
      * Awaits the worker's setSeed reply (worker boots, then applies seed).
      */
-    setSeed(enclave: Enclave, opts?: SetSeedOpts): Promise<void>;
+    setSeed(enclave: Enclave, opts?: SetSeedOpts): Promise<Status>;
     link(host: IHostConnectionInfo<URL>, connect?: boolean): Promise<void>;
     unlink(label: string): Promise<void>;
     /** Hosts live in shared main IDB (same as local writer). */
@@ -88,8 +92,8 @@ export declare class WorkerClient implements IClient<URL> {
     /** Local UI write on main (cache notifies in apply's sync prefix); sync via worker. */
     insertRaw(content: SerializedContent, typ?: string): Promise<ValStat<IMessageHead>>;
     updateRaw(prior: IEntRev, content: SerializedContent | undefined, force?: boolean, typ?: string): Promise<ValStat<IMessageHead>>;
-    insert<T = unknown>(op: IInsertParams<T>): Promise<ValStat<IMessageHead>>;
-    update<T = unknown>(op: IUpdateParams<T>): Promise<ValStat<IMessageHead>>;
+    insert(op: IInsertParams<Uint8Array>): Promise<ValStat<IMessageHead>>;
+    update(op: IUpdateParams<Uint8Array>): Promise<ValStat<IMessageHead>>;
     delete(op: IDeleteParams): Promise<ValStat<IMessageHead>>;
     genEID(id?: Uint8Array): Promise<ValStat<EntityID>>;
     sync(): Promise<Status>;

package/dist/web/worker/protocol.d.ts

@@ -15,6 +15,12 @@ export type WorkerCmd = {
     op: "setSeed";
     seed: Uint8Array;
     persist?: boolean;
+} | {
+    id: number;
+    op: "bind";
+    label: string;
+    data: string;
+    ents: string;
 } | {
     id: number;
     op: "link";

package/dist/web/worker/runtime.d.ts

@@ -3,14 +3,16 @@ import type { WorkerCmd, WorkerEvent } from "./protocol";
 export type PostFn = (msg: WorkerEvent, transfer?: Transferable[]) => void;
 export declare class WorkerRuntime {
     private client;
+    private store;
     private entDB;
+    private boundLabel;
     private post;
-    /** Resolves when init finishes (success or failure). Cmds wait on this. */
+    /** Resolves when bind finishes (success or failure). Cmds wait on this. */
     private whenReady;
     private resolveReady;
     private rejectReady;
     constructor(post: PostFn);
-    init(): Promise<void>;
+    private bindStores;
     private markReady;
     private failReady;
     private requireClient;