@interncom/diplomatic 0.22.0 → 0.23.0

package/dist/web/sync.d.ts

@@ -1,4 +1,5 @@
 import DiplomaticClientAPI from "./shared/client";
+import type { IKDM } from "./shared/codecs/kdm";
 import { Status } from "./shared/consts";
 import { Enclave } from "./shared/crypto/enclave";
 import { Hash, HostHandle, IBag, ICrypto } from "./shared/types";
@@ -20,7 +21,7 @@ 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">;
 export interface ISyncParams<Handle extends HostHandle> {
     conn: SyncConn<Handle>;
     store: IStore<Handle>;
@@ -40,9 +41,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 = {
@@ -61,7 +64,7 @@ export declare function openPulled<Handle extends HostHandle>(store: IStore<Hand
  */
 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, enclave, 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>;
 /**
@@ -76,19 +79,19 @@ export declare function syncPush<Handle extends HostHandle>({ conn, store, host,
 export declare function syncPull<Handle extends HostHandle>({ conn, store, enclave, 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>;
 /**
- * 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,12 @@
 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 { 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 +38,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 +67,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 +117,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 +175,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 +205,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 +221,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 +238,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 +305,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 +330,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, …). */

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

@@ -78,7 +78,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). */

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;