@interncom/diplomatic 0.22.0 → 0.24.0

package/dist/web/shared/crypto/noble.d.ts

@@ -1,24 +1,17 @@
 import { type X25519Sk } from "./x25519.ts";
 import type { Blake3Opts, DerivationSeed, Hash, ICrypto, KeyPair } from "../types.ts";
-/**
- * ICrypto: noble for XSalsa20 + blake3; WebCrypto Ed25519 + X25519
- * (our scalar; RFC 7748 check before trusting pub/DH).
- */
-export declare class NobleCrypto implements ICrypto {
-    private verifyKeys;
-    genRandomBytes(bytes: number): Promise<Uint8Array>;
-    gen256BitSecureRandomSeed(): Promise<Uint8Array>;
-    encryptXSalsa20Poly1305Combined(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
-    decryptXSalsa20Poly1305Combined(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
-    deriveEd25519KeyPair(derivationSeed: DerivationSeed): Promise<KeyPair>;
-    private importSignKey;
-    private importVerifyKey;
-    signEd25519(message: Uint8Array | string, secKey: Uint8Array): Promise<Uint8Array>;
-    checkSigEd25519(sig: Uint8Array, message: Uint8Array | string, pubKey: Uint8Array): Promise<boolean>;
-    blake3(data: Uint8Array, opts?: Blake3Opts): Promise<Hash>;
-    genX25519(): Promise<{
-        priv: X25519Sk;
-        pub: Uint8Array;
-    }>;
-    x25519Shared(priv: X25519Sk, peerPub: Uint8Array): Promise<Uint8Array>;
-}
+export declare function genRandomBytes(bytes: number): Promise<Uint8Array>;
+export declare function gen256BitSecureRandomSeed(): Promise<Uint8Array>;
+export declare function encryptXSalsa20Poly1305Combined(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+export declare function decryptXSalsa20Poly1305Combined(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+export declare function deriveEd25519KeyPair(derivationSeed: DerivationSeed): Promise<KeyPair>;
+export declare function importVerifyKey(pubKey: Uint8Array): Promise<CryptoKey>;
+export declare function signEd25519(message: Uint8Array | string, secKey: Uint8Array): Promise<Uint8Array>;
+export declare function checkSigEd25519(sig: Uint8Array, message: Uint8Array | string, verifyKey: CryptoKey): Promise<boolean>;
+export declare function blake3(data: Uint8Array, opts?: Blake3Opts): Promise<Hash>;
+export declare function genX25519(): Promise<{
+    priv: X25519Sk;
+    pub: Uint8Array;
+}>;
+export declare function x25519Shared(priv: X25519Sk, peerPub: Uint8Array): Promise<Uint8Array>;
+export declare const noble: ICrypto;

package/dist/web/shared/crypto/pairing.d.ts

@@ -1,6 +1,8 @@
+import type { BundleHost } from "../codecs/bundleHost.ts";
 import { type ValStat } from "../valstat.ts";
+import { type PDK } from "./derivation.ts";
+import type { Enclave } from "./enclave.ts";
 import type { X25519Sk } from "./x25519.ts";
-export declare const SEAL_PAIR_DOMAIN: Uint8Array<ArrayBufferLike>;
 export declare const X25519_PUB_LEN = 32;
 /** respPub (32) ‖ XSalsa nonce (24) ‖ tag (16); plaintext follows in the ct. */
 export declare const DHKE_RESP_MIN: number;
@@ -17,5 +19,20 @@ export declare function asDHKEResp(bytes: Uint8Array): ValStat<DHKEResp>;
 export declare function pairKey(sk: X25519Sk, // local X25519 priv
 peer: Uint8Array, // ECDH peer pub (enroller: dhkeReq; enrollee: respPub)
 reqPub: Uint8Array, // enrollee pub, bound into KDF
-respPub: Uint8Array): Promise<ValStat<Uint8Array>>;
+respPub: Uint8Array): Promise<ValStat<PDK["Pair"]>>;
+export declare function sealPair(dhkeReq: DHKEReq): Promise<ValStat<{
+    key: PDK["Pair"];
+    pub: Uint8Array;
+}>>;
+export declare class PairRequest {
+    #private;
+    private constructor();
+    static create(): Promise<ValStat<PairRequest>>;
+    wipe(): void;
+    dhkeReq(): ValStat<DHKEReq>;
+    finish(dhkeResp: DHKEResp): Promise<ValStat<{
+        enclave: Enclave;
+        hosts: BundleHost[];
+    }>>;
+}
 export {};

package/dist/web/shared/crypto/prf.d.ts

@@ -0,0 +1,52 @@
+import type { SealedMasterKey } from "../seed.ts";
+import { type ValStat } from "../valstat.ts";
+import { type PDK } from "./derivation.ts";
+import { type PrfCeremony, type PrfCreateOpts, type PrfEvalOpts } from "../webauthn/prf.ts";
+/** Options for PRF seal/unseal ceremonies (no raw PRF bytes). */
+export type PasskeyPrfOpts = PrfCreateOpts & {
+    credId?: Uint8Array | readonly Uint8Array[];
+    /** Seal only: create a PRF credential first when no credId is known. */
+    createCredIfNeeded?: boolean;
+};
+/** One binding to try on unseal (cred id + sealed master). */
+export type PrfBinding = {
+    sealedMaster: SealedMasterKey;
+    credId: Uint8Array;
+    /** PRF salt for this cred. Omitted salts use the ceremony salt. */
+    salt?: Uint8Array;
+};
+/** Durable PRF-sealed master + public ceremony facts (never includes PRF output). */
+export type PrfSealedMaster = PrfCeremony & {
+    sealedMaster: SealedMasterKey;
+    salt: Uint8Array;
+};
+/** One existing keyring member used to prove this enclave matches the list. */
+export type BindPrior = {
+    credId: Uint8Array;
+    tag: PDK["BindTag"];
+};
+/** Seal + bind-tag from {@link Enclave.bind} (tag is not a global fingerprint). */
+export type PrfBound = PrfSealedMaster & {
+    tag: PDK["BindTag"];
+};
+type PrfCreateResult = PrfCeremony & {
+    prfEnabled: boolean;
+    prf?: Uint8Array;
+};
+type PrfEvalResult = PrfCeremony & {
+    prf: Uint8Array;
+};
+export declare function createPrfCred(opts?: PrfCreateOpts): Promise<ValStat<PrfCreateResult>>;
+export declare function evalPrf(opts?: PrfEvalOpts): Promise<ValStat<PrfEvalResult>>;
+export declare function sealPRF(opts: PasskeyPrfOpts | undefined): Promise<ValStat<PrfCeremony & {
+    prf: Uint8Array;
+    salt: Uint8Array;
+}>>;
+export declare function unsealPRF(bindings: readonly PrfBinding[], opts: PasskeyPrfOpts & {
+    salt: Uint8Array;
+}): Promise<ValStat<{
+    prf: Uint8Array;
+    credId: Uint8Array;
+    order: readonly PrfBinding[];
+}>>;
+export {};

package/dist/web/shared/crypto/realms.d.ts

@@ -0,0 +1,7 @@
+import { type IKDM } from "../codecs/kdm.ts";
+import { type MasterSeed } from "../seed.ts";
+import { type ValStat } from "../valstat.ts";
+import { type PDK } from "./derivation.ts";
+export declare function deriveRealmKey(parent: MasterSeed, realmKDM: IKDM): Promise<ValStat<PDK["RealmKey"]>>;
+export declare function deriveRealmID(parent: MasterSeed, realmKDM: IKDM): Promise<ValStat<PDK["RealmID"]>>;
+export declare function deriveHostRLM(parent: PDK["RealmID"], hostKDM: IKDM): Promise<ValStat<PDK["HostRLM"]>>;

package/dist/web/shared/crypto/tty.d.ts

@@ -0,0 +1,3 @@
+import { Status } from "../consts.ts";
+import { type ValStat } from "../valstat.ts";
+export declare function dumpToTTY(seed: Uint8Array, fingerprint: () => Promise<ValStat<Uint8Array>>): Promise<Status>;

package/dist/web/shared/endpoint.d.ts

@@ -2,21 +2,20 @@ import { IClock } from "./clock.ts";
 import { Decoder, Encoder } from "./codec.ts";
 import { IAuthTimestamp } from "./codecs/authTimestamp.ts";
 import { Status } from "./consts.ts";
-import { Enclave, type Identity } from "./crypto/enclave.ts";
+import type { BagManager } from "./crypto/bagman.ts";
 import { ICrypto, IProtoHost } from "./types.ts";
 import { ValStat } from "./valstat.ts";
 interface IProtoClient {
     crypto: ICrypto;
-    enclave: Enclave;
     clock: IClock;
 }
-export interface IAuthenticatedEndpoint<ReqItem, Resp> {
-    encodeReq(client: IProtoClient, identity: Identity, authTS: IAuthTimestamp, body: Iterable<ReqItem>, reqEnc: Encoder): Promise<Status>;
+export interface IAuthenticatedEndpoint<ReqInput, Resp> {
+    encodeReq(client: IProtoClient, identity: BagManager, authTS: IAuthTimestamp, body: ReqInput, reqEnc: Encoder): Promise<Status>;
     handleReq(host: IProtoHost, reqDec: Decoder, respEnc: Encoder): Promise<Status>;
     decodeResp(respDec: Decoder): ValStat<Resp>;
 }
 export interface IAuthData {
-    identity: Identity;
+    identity: BagManager;
     authTS: IAuthTimestamp;
 }
 export {};

package/dist/web/shared/exim.d.ts

@@ -1,17 +1,17 @@
-import { Enclave } from "./crypto/enclave.ts";
+import { BagManager } from "./crypto/bagman.ts";
 import { ICrypto, IMessageHead } from "./types.ts";
 import { ValStat } from "./valstat.ts";
 export declare namespace Exim {
     const defaultFileExtension = "dpl";
-    function encodeFile(keyLbl: string, keyIdx: number, msgs: Iterable<{
+    function encodeFile(msgs: Iterable<{
         head: IMessageHead;
         body?: Uint8Array;
-    }>, crypto: ICrypto, enclave: Enclave): Promise<ValStat<Uint8Array>>;
-    function decodeFile(file: Uint8Array, crypto: ICrypto, enclave: Enclave): Promise<ValStat<{
+    }>, crypto: ICrypto, bagMgr: BagManager): Promise<ValStat<Uint8Array>>;
+    function decodeFile(file: Uint8Array, crypto: ICrypto, bagMgr: BagManager): Promise<ValStat<{
         head: IMessageHead;
         body?: Uint8Array;
     }[]>>;
-    function migrateFile(file: Uint8Array, crypto: ICrypto, enclaveIn: Enclave, enclaveOut: Enclave, transform: (msgs: Iterable<{
+    function migrateFile(file: Uint8Array, crypto: ICrypto, bagMgrIn: BagManager, bagMgrOut: BagManager, transform: (msgs: Iterable<{
         head: IMessageHead;
         body?: Uint8Array;
     }>) => Iterable<{

package/dist/web/shared/http.d.ts

@@ -6,66 +6,66 @@ import { ValStat } from "./valstat.ts";
 export declare const api: {
     readonly user: {
         readonly path: "/user";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<never, void>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<void, void>;
         readonly name: APICallName.User;
     };
     readonly push: {
         readonly path: "/push";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./types.ts").IBag, import("./codecs/pushItem.ts").IBagPushItem[]>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./types.ts").IBag[], import("./codecs/pushItem.ts").IBagPushItem[]>;
         readonly name: APICallName.Push;
     };
     readonly peek: {
         readonly path: "/peek";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/peekItem.ts").IBagPeekItem[]>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./api/peek.ts").IPeekCursor, import("./codecs/peekItem.ts").IBagPeekItem[]>;
         readonly name: APICallName.Peek;
     };
     readonly pull: {
         readonly path: "/pull";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/pullItem.ts").IBagPullItem[]>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./api/pull.ts").IPullReq, import("./codecs/pullItem.ts").IBagPullItem[]>;
         readonly name: APICallName.Pull;
     };
 };
 export declare const apiCalls: {
     readonly 0: {
         readonly path: "/user";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<never, void>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<void, void>;
         readonly name: APICallName.User;
     };
     readonly 2: {
         readonly path: "/push";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./types.ts").IBag, import("./codecs/pushItem.ts").IBagPushItem[]>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./types.ts").IBag[], import("./codecs/pushItem.ts").IBagPushItem[]>;
         readonly name: APICallName.Push;
     };
     readonly 1: {
         readonly path: "/peek";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/peekItem.ts").IBagPeekItem[]>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./api/peek.ts").IPeekCursor, import("./codecs/peekItem.ts").IBagPeekItem[]>;
         readonly name: APICallName.Peek;
     };
     readonly 3: {
         readonly path: "/pull";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/pullItem.ts").IBagPullItem[]>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./api/pull.ts").IPullReq, import("./codecs/pullItem.ts").IBagPullItem[]>;
         readonly name: APICallName.Pull;
     };
 };
 export declare const callPaths: {
     readonly "/user": {
         readonly path: "/user";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<never, void>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<void, void>;
         readonly name: APICallName.User;
     };
     readonly "/push": {
         readonly path: "/push";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./types.ts").IBag, import("./codecs/pushItem.ts").IBagPushItem[]>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./types.ts").IBag[], import("./codecs/pushItem.ts").IBagPushItem[]>;
         readonly name: APICallName.Push;
     };
     readonly "/peek": {
         readonly path: "/peek";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/peekItem.ts").IBagPeekItem[]>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./api/peek.ts").IPeekCursor, import("./codecs/peekItem.ts").IBagPeekItem[]>;
         readonly name: APICallName.Peek;
     };
     readonly "/pull": {
         readonly path: "/pull";
-        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<number, import("./codecs/pullItem.ts").IBagPullItem[]>;
+        readonly endpoint: import("./endpoint.ts").IAuthenticatedEndpoint<import("./api/pull.ts").IPullReq, import("./codecs/pullItem.ts").IBagPullItem[]>;
         readonly name: APICallName.Pull;
     };
 };

package/dist/web/shared/storage/memory.d.ts

@@ -1,10 +1,10 @@
 import { type IStorage } from "../types.ts";
 interface IMemoryStorage extends IStorage {
     users: Set<string>;
-    bag: Map<string, Map<number, {
+    bag: Map<string, Map<string, Map<number, {
         headCph: Uint8Array;
         bodyCph: Uint8Array;
-    }>>;
+    }>>>;
 }
 /** Fresh in-memory host storage (isolated bag/user maps). */
 export declare function createMemoryStorage(): IMemoryStorage;

package/dist/web/shared/sync.d.ts

@@ -1,9 +1,9 @@
 import { IBagPeekItem } from "./codecs/peekItem.ts";
-import { Enclave } from "./crypto/enclave.ts";
-import { ICrypto, PublicKey } from "./types.ts";
+import { BagManager } from "./crypto/bagman.ts";
+import { ICrypto } from "./types.ts";
 import { ValStat } from "./valstat.ts";
 export interface IDecryptedBagPeekItem {
     kdm: Uint8Array;
     headEnc: Uint8Array;
 }
-export declare function decryptPeekItem(item: IBagPeekItem, pubKey: PublicKey, enclave: Enclave, crypto: ICrypto): Promise<ValStat<IDecryptedBagPeekItem>>;
+export declare function decryptPeekItem(item: IBagPeekItem, verifyKey: CryptoKey, bagMgr: BagManager, crypto: ICrypto): Promise<ValStat<IDecryptedBagPeekItem>>;

package/dist/web/shared/types.d.ts

@@ -4,6 +4,7 @@ import { IAuthTimestamp } from "./codecs/authTimestamp.ts";
 import type { IBagPeekItem } from "./codecs/peekItem.ts";
 import { IUsageQuota } from "./codecs/usageQuota.ts";
 import { APICallName, Status } from "./consts.ts";
+import type { HostRlm } from "./crypto/derivation.ts";
 import type { ValStat } from "./valstat.ts";
 /** Identity seed brands — defined in seed.ts; re-exported for convenience. */
 export type { MasterSeed, SealedMasterKey } from "./seed.ts";
@@ -75,27 +76,35 @@ export type IDeleteParams = {
     eid: EntityID;
     force?: boolean;
 };
+/** One setBags outcome. Success carries the host seq in that bag's rlm. */
+export type ISetBagResult = {
+    status: Status.Success;
+    seq: number;
+} | {
+    status: Exclude<Status, Status.Success>;
+};
 export interface IStorage {
     addUser: (pubKey: PublicKey) => Promise<ValStat<void>>;
     hasUser: (pubKey: PublicKey) => Promise<ValStat<boolean>>;
     subMeta: (pubKey: PublicKey) => Promise<ValStat<ISubscriptionMetadata>>;
     /**
-     * Store bags for a user. Returns host seq for each bag in order.
-     * Empty list succeeds with []. Implementations must assign contiguous
-     * seqs atomically (transaction / single batch) so concurrent writers
-     * cannot claim the same seq.
+     * Store bags for a user. One result per input bag, same order.
+     * An invalid rlm is InvalidParam for that bag; the others are still stored.
+     * Seqs are contiguous per rlm among stored bags, assigned atomically so
+     * concurrent writers cannot claim the same seq in the same rlm.
+     * Empty list succeeds with []. A storage failure fails the call.
      */
-    setBags: (pubKey: PublicKey, bags: IBag[]) => Promise<ValStat<number[]>>;
+    setBags: (pubKey: PublicKey, bags: IBag[]) => Promise<ValStat<ISetBagResult[]>>;
     /**
-     * Fetch ciphertext bodies for the given host seqs.
-     * Returns only seqs that exist (missing seqs are omitted, not an error).
-     * Empty `seqs` succeeds with [].
+     * Fetch ciphertext bodies for `seqs` in `rlm`.
+     * Missing seqs are omitted. Empty `seqs` succeeds with [].
      */
-    getBodies: (pubKey: PublicKey, seqs: number[]) => Promise<ValStat<{
+    getBodies: (pubKey: PublicKey, rlm: HostRlm, seqs: number[]) => Promise<ValStat<{
         seq: number;
         bodyCph: Uint8Array;
     }[]>>;
-    listHeads: (pubKey: PublicKey, minSeq: number) => Promise<ValStat<IBagPeekItem[]>>;
+    /** Heads in `rlm` with seq greater than minSeq, ordered by seq. */
+    listHeads: (pubKey: PublicKey, rlm: HostRlm, minSeq: number) => Promise<ValStat<IBagPeekItem[]>>;
 }
 export interface KeyPair {
     keyType: "ed25519";
@@ -123,7 +132,8 @@ export type Hash = Uint8Array & {
     readonly [hashSymbol]: true;
 };
 export interface IHostCrypto {
-    checkSigEd25519: (sig: Uint8Array, message: Uint8Array | string, pubKey: PublicKey) => Promise<boolean>;
+    importVerifyKey: (pubKey: PublicKey) => Promise<CryptoKey>;
+    checkSigEd25519: (sig: Uint8Array, message: Uint8Array | string, verifyKey: CryptoKey) => Promise<boolean>;
 }
 /** BLAKE3 hash / MAC / KDF (noble: `key` XOR `context`, not both). */
 export type Blake3Opts = {
@@ -141,11 +151,6 @@ export interface ICrypto extends IHostCrypto {
     signEd25519: (message: Uint8Array | string, secKey: PrivateKey) => Promise<Uint8Array>;
     blake3: (data: Uint8Array, opts?: Blake3Opts) => Promise<Hash>;
 }
-export interface IMsgpackCodec {
-    encode: (source: unknown) => Uint8Array;
-    decode: (packed: ArrayBuffer | Uint8Array) => unknown;
-    decodeAsync: (stream: ReadableStream<Uint8Array>) => Promise<unknown>;
-}
 export interface IProtoHost {
     storage: IStorage;
     crypto: IHostCrypto;
@@ -168,6 +173,9 @@ export interface IPushListener {
     disconnect(): void;
 }
 export interface IBagHeader {
+    /** HostRLM. Covered by sig, with headCph. */
+    rlm: HostRlm;
+    /** Ed25519 over rlm ‖ headCph. First field on the wire. */
     sig: Uint8Array;
     kdm: Uint8Array;
 }

package/dist/web/shared/webauthn/prf.d.ts

@@ -29,6 +29,14 @@ export type PrfEvalOpts = PrfRp & {
     /** One id, or every bound id so a spare key can assert in one get(). */
     credId?: Uint8Array | readonly Uint8Array[];
     salt?: Uint8Array;
+    /**
+     * Salt for each cred when accounts do not share one.
+     * Sent as evalByCredential so the passkey the user picks evals its own.
+     */
+    salts?: readonly {
+        credId: Uint8Array;
+        salt: Uint8Array;
+    }[];
 };
 /** Best-effort: client advertises PRF extension. */
 export declare function prfCapable(): Promise<boolean>;

package/dist/web/state.d.ts

@@ -1,8 +1,7 @@
 import { Status } from "./shared/consts";
-import { EntityID, IMessage, IMsgEntBody, IOp, IStateManager } from "./shared/types";
+import { EntityID, IMessage, IOp, IStateManager } from "./shared/types";
 import { ValStat } from "./shared/valstat";
 import type { Applier } from "./types";
-export declare function isMsgEntBody(bodDec: unknown): bodDec is IMsgEntBody;
 export declare function msgToOp(msg: IMessage): ValStat<IOp>;
 type PeerIngestFn = (eids: Iterable<EntityID>) => Promise<void>;
 export declare class StateManager implements IStateManager {

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

@@ -0,0 +1,30 @@
+import type { IKDM } from "../shared/codecs/kdm";
+import type { HostSeqsUpdate } from "../types";
+import type { IRealm } from "./realm";
+/** One host-realm cursor. The realm KDM plus the newest bag seq. */
+export interface RealmCursor extends IKDM {
+    lastSeq: number;
+}
+declare const downloadKeySymbol: unique symbol;
+/** Key of one queued download: host label, realm, and seq. */
+export type DownloadKey = string & {
+    readonly [downloadKeySymbol]: true;
+};
+type CursorRow = {
+    lastSeq: number;
+    seqs?: RealmCursor[];
+};
+export declare function isDefaultRealm(realm?: IKDM): boolean;
+export declare function sameRealm(a: IKDM, b: IKDM): boolean;
+export declare function realmKey(realm: IKDM): string;
+export declare function cursorOf(row: CursorRow, realm?: IKDM): number;
+export declare function realmKDMs(rows: readonly IRealm[]): IKDM[];
+export declare function realmKDM(label: string | undefined, rows: readonly IRealm[]): IKDM;
+export declare function storedRealm(realm: IKDM): IKDM | undefined;
+export declare function downloadKey(host: string, seq: number, realm?: IKDM): DownloadKey;
+export declare function nextCursor(cur: number, u: HostSeqsUpdate): number | undefined;
+export declare function projectCursors(cursors: readonly RealmCursor[]): {
+    lastSeq: number;
+    seqs?: RealmCursor[];
+};
+export {};

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

@@ -0,0 +1,58 @@
+import { Status } from "../../shared/consts";
+import { Enclave } from "../../shared/crypto/enclave";
+import type { ICrypto } from "../../shared/types";
+import { type ValStat } from "../../shared/valstat";
+import type { PrfRp } from "../../shared/webauthn/prf";
+import type { IAccountStore, SetSeedOpts } from "../../types";
+import { type Keyring, PrfSeedStore, type PrfSeedStoreOpts } from "../../passkey/prf-store";
+import { type KeyTag } from "../keyTag";
+/**
+ * One account: its label, catalog id, database names, key tag, and the
+ * binding that unseals its key.
+ */
+export type Account = {
+    label: string;
+    /** Stable id. Database names are derived from this. */
+    acct?: string;
+    /** Protocol database name. */
+    data?: string;
+    /** EntDB name. Absent until EntDB is opened. */
+    ents?: string;
+    keyTag?: KeyTag;
+    keyring?: Keyring;
+};
+export declare function decodeAccount(raw: unknown): Account | undefined;
+export declare class IDBAccountStore implements IAccountStore {
+    #private;
+    db: IDBDatabase;
+    constructor(db: IDBDatabase, crypto: ICrypto);
+    setCloser(close: () => void): void;
+    /**
+     * Mint an account key with {@link Enclave.fromRandom} and store its key tag.
+     * A blank label is "". A label that already names a key is unchanged.
+     * An existing keyring on that row is kept. musec is wiped.
+     */
+    create(label: string, musec: Uint8Array): Promise<ValStat<Enclave>>;
+    /**
+     * Record the key tag for `opts.label`. Does not open the account.
+     * Durable identity is the account keyring
+     * ({@link openPrfStore} / {@link persistKeyring}), never plain seed.
+     * The row is created on the first save. A later save must match that
+     * account's key tag. `opts.persist` is ignored (kept for API compatibility).
+     *
+     * TODO(passphrase): when PRF is missing, seal under a passphrase KDF
+     * and store that ciphertext on this account row.
+     */
+    save(enclave: Enclave, opts?: SetSeedOpts): Promise<ValStat<Enclave>>;
+    dataName(label: string): Promise<string | undefined>;
+    ensureEnts(label: string): Promise<string>;
+    wipe(): Promise<void>;
+    loadKeyring(label?: string): Promise<Keyring | undefined>;
+    persistKeyring(ring: Keyring | undefined, label?: string): Promise<Status>;
+    hasKeyring(label?: string): Promise<boolean>;
+    unlock(opts: PrfRp): Promise<ValStat<{
+        enclave: Enclave;
+        label: string;
+    }>>;
+    openPrfStore(opts: Omit<PrfSeedStoreOpts, "persistKeyring" | "keyring" | "unlockAccount">, label?: string): Promise<ValStat<PrfSeedStore>>;
+}

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

@@ -0,0 +1 @@
+export declare function entsNameFor(label: string): Promise<string>;

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

@@ -1,9 +1,10 @@
+import type { IKDM } from "../../shared/codecs/kdm";
 import { IDownloadMessage, IDownloadQueue } from "../../types";
 export declare class IDBDownloadQueue implements IDownloadQueue {
-    db: IDBDatabase;
+    private db;
     constructor(db: IDBDatabase);
     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/idb/hosts.d.ts

@@ -1,20 +1,21 @@
+import type { IKDM } from "../../shared/codecs/kdm";
 import { Status } from "../../shared/consts";
 import { IHostConnectionInfo, IHostMetadata } from "../../shared/types";
-import type { HostStatsUpdate, IHostRow, IHostStore } from "../../types";
+import type { HostSeqsUpdate, IHostRow, IHostStore } from "../../types";
 export declare class IDBHostStore implements IHostStore<URL> {
-    db: IDBDatabase;
+    private db;
     constructor(db: IDBDatabase);
     /**
-     * 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 host_seqs.
      */
     add(info: IHostConnectionInfo<URL>): Promise<void>;
-    private put;
-    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<URL> | undefined>;
     set(label: string, meta: IHostMetadata): Promise<Status.Success | Status.NotFound | Status.DatabaseError>;
     del(label: string): Promise<void>;
     list(): Promise<IHostRow<URL>[]>;
     wipe(): Promise<void>;
+    private put;
 }

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

@@ -0,0 +1,2 @@
+export declare function deleteDatabase(name: string): Promise<void>;
+export declare function openAt(name: string, version: number, upgrade: (db: IDBDatabase, tx: IDBTransaction) => void): Promise<IDBDatabase>;

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

@@ -0,0 +1,2 @@
+export declare function openMetaDB(): Promise<IDBDatabase>;
+export declare function openDataDB(name: string): Promise<IDBDatabase>;

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

@@ -3,8 +3,8 @@ import { ICrypto } from "../../shared/types";
 import { EntityID, Hash } from "../../shared/types";
 import { ApldState, IMessageStore, IStorableMessage, IStoredMessage, ListMsgsOpts } from "../../types";
 export declare class IDBMessageStore implements IMessageStore {
+    private db;
     private crypto;
-    db: IDBDatabase;
     constructor(db: IDBDatabase, crypto: ICrypto);
     add(messages: IStorableMessage[]): Promise<Status[]>;
     del(keys: Iterable<Hash>): Promise<void>;

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

@@ -0,0 +1,13 @@
+/** Account catalog. Unlock reads only this database. */
+export declare const META_DB_NAME = "meta";
+export declare const META_DB_VERSION = 1;
+/** Protocol database: archive, queues, hosts, realm counters, host cursors. */
+export declare const DATA_DB_VERSION = 9;
+export declare function mintAcct(): string;
+export declare function dataDbName(acct: string): string;
+export declare function entsDbName(acct: string): string;
+export declare function placeAccount(acct: string | undefined, data: string | undefined): {
+    acct: string;
+    data: string;
+};
+export declare function assignEnts(acct: string, current: string | undefined): string;

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

@@ -0,0 +1,11 @@
+import { Status } from "../../shared/consts";
+import { type IRealm, type IRealmStore } from "../realm";
+/** Realm counters for the open account. The database is that account. */
+export declare class IDBRealmStore implements IRealmStore {
+    private db;
+    constructor(db: IDBDatabase);
+    list(): Promise<IRealm[]>;
+    get(label: string): Promise<IRealm | undefined>;
+    put(label: string, index: number): Promise<Status>;
+    wipe(): Promise<void>;
+}