p2party 0.8.0 → 0.14.2

package/lib/cryptography/pqHealingFrame.d.ts

@@ -0,0 +1,39 @@
+import type { LibCrypto } from "./libcrypto";
+import type { MlKemParameterSet, MlKemSuiteDescriptor } from "./mlkem";
+export declare const PQ_CONTROL_FRAME_HEADER_BYTES: number;
+export declare const PQ_CONTROL_FRAME_PLAINTEXT_BYTES: number;
+export type PqControlDirection = "initiator-to-responder" | "responder-to-initiator";
+export type PqControlFrameErrorCode = "authentication-failed" | "binding-mismatch" | "epoch-mismatch" | "invalid-direction" | "invalid-frame" | "invalid-padding" | "record-mismatch";
+export declare class PqControlFrameError extends Error {
+    readonly code: PqControlFrameErrorCode;
+    constructor(code: PqControlFrameErrorCode, message: string);
+}
+export interface SealPqControlFrameOptions<P extends MlKemParameterSet = MlKemParameterSet> {
+    readonly module: LibCrypto;
+    readonly suite: Readonly<MlKemSuiteDescriptor<P>>;
+    readonly rootKey: Uint8Array;
+    readonly binding: Uint8Array;
+    readonly direction: PqControlDirection;
+    /** Epoch whose PQ root authenticates this frame. */
+    readonly keyEpoch: bigint;
+    /** Exact canonical OFFER, ADVANCE, or 64-byte ACK. */
+    readonly record: Uint8Array;
+}
+export interface OpenPqControlFrameOptions<P extends MlKemParameterSet = MlKemParameterSet> {
+    readonly module: LibCrypto;
+    readonly suite: Readonly<MlKemSuiteDescriptor<P>>;
+    readonly rootKey: Uint8Array;
+    readonly binding: Uint8Array;
+    /** Expected inbound direction; the opposite direction derives another key. */
+    readonly direction: PqControlDirection;
+    /** Exact expected authentication epoch. */
+    readonly keyEpoch: bigint;
+    readonly frame: Uint8Array;
+}
+/** Seal one exact canonical control record into a fixed-size v4 cell. */
+export declare const sealPqControlFrame: <P extends MlKemParameterSet>(options: SealPqControlFrameOptions<P>) => Uint8Array;
+/**
+ * Authenticate a fixed-size cell and return an owned exact canonical record.
+ * The caller supplies the expected edge, direction, suite, root, and epoch.
+ */
+export declare const openPqControlFrame: <P extends MlKemParameterSet>(options: OpenPqControlFrameOptions<P>) => Uint8Array;

package/lib/cryptography/pqMessageKey.d.ts

@@ -0,0 +1,30 @@
+import type { LibCrypto } from "./libcrypto";
+import type { RatchetHeader } from "./ratchet";
+import type { RatchetRootSuite } from "../utils/constants";
+/**
+ * Context authenticated by the hybrid bootstrap and advanced by sparse PQ
+ * healing. `rootKey` is reusable epoch state: this module copies it and never
+ * wipes the caller's live buffer.
+ */
+export interface PqMessageKeyContext {
+    readonly rootKey: Uint8Array;
+    readonly binding: Uint8Array;
+    readonly rootSuite: RatchetRootSuite;
+    readonly epoch: bigint;
+}
+export declare const PQ_MESSAGE_KEY_BYTES: number;
+export declare const PQ_MESSAGE_KEY_ROOT_BYTES = 32;
+export declare const PQ_MESSAGE_KEY_BINDING_BYTES = 32;
+/**
+ * Combine one classical Double-Ratchet message key with the current PQ epoch
+ * root:
+ *
+ *   PRK = HKDF-Extract-SHA512(salt = pqRoot, IKM = classicalMessageKey)
+ *   key = HKDF-Expand-SHA512(PRK, canonicalContext, 32)
+ *
+ * Ownership is deliberate: `classicalMessageKey` is consumed and zeroed on
+ * every success/failure path. The live `context.rootKey` remains reusable; only
+ * an owned copy and the transient PRK are wiped. Callers that need the
+ * classical key for multiple chunks must pass an owned copy on each call.
+ */
+export declare const combinePqMessageKey: (classicalMessageKey: Uint8Array, context: PqMessageKeyContext, header: RatchetHeader, module: LibCrypto) => Uint8Array;

package/lib/cryptography/random.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Supply Emscripten/libsodium with one Web Crypto backed unsigned word.
+ *
+ * Passing this callback explicitly keeps the generated glue independent of
+ * CommonJS `require("crypto")`, which is unavailable in Node ESM. Browsers,
+ * workers, Node 20+, and Bun all expose the same Web Crypto boundary.
+ */
+export declare const secureRandomUint32: () => number;
+/**
+ * Fill any Uint8Array — including a view into WebAssembly.Memory — without
+ * handing its backing buffer to WebCrypto.
+ *
+ * Chromium 147/149 rejects BufferSource inputs backed by resizable
+ * WebAssembly memory. A fresh length-constructed Uint8Array always owns an
+ * ordinary fixed ArrayBuffer, so WebCrypto fills that temporary and we copy
+ * into the caller's destination. Randomness is secret key material at every
+ * current call site; wipe the temporary on success and failure.
+ *
+ * The optional filler exists for deterministic boundary tests and is not a
+ * protocol entropy-injection API.
+ */
+export declare const fillRandomBytesInto: (destination: Uint8Array, fill?: (temporary: Uint8Array) => void) => void;

package/lib/cryptography/ratchet.d.ts

@@ -0,0 +1,146 @@
+import type { LibCrypto } from "./libcrypto";
+import type { RatchetRootSuite } from "../utils/constants";
+/**
+ * Live Double Ratchet state for one `(roomId, peerPublicKey)` edge. Every key
+ * field is a plain-JS `Uint8Array` secret (the WASM heap holds no ratchet state
+ * — see design §9): `rootKey`, both chain keys, `dhSelfSec`, and each value in
+ * `skipped`. Stage 3 wraps these at rest; here they are live plaintext.
+ *
+ * The ratchet advances **per logical message**, never per chunk. `Ns`/`Nr` are
+ * the send/receive message counters in the current chains; `PN` is the length
+ * of the previous sending chain (folded into inbound headers so the peer can
+ * skip the tail of a superseded chain).
+ */
+export interface RatchetState {
+    /** Authenticated bootstrap-suite provenance; immutable for this edge. */
+    rootSuite: RatchetRootSuite;
+    rootKey: Uint8Array;
+    sendingChainKey: Uint8Array | null;
+    receivingChainKey: Uint8Array | null;
+    dhSelfPub: Uint8Array;
+    dhSelfSec: Uint8Array;
+    dhRemotePub: Uint8Array | null;
+    Ns: number;
+    Nr: number;
+    PN: number;
+    skipped: Map<string, Uint8Array>;
+}
+/**
+ * Cleartext per-message ratchet header. Rides the frame so the receiver can
+ * derive the message key before decrypting: `dhPub` drives the DH ratchet, `N`
+ * is this message's index in the sender's current chain, `PN` is the length of
+ * the sender's previous chain (for skip-on-DH-step).
+ */
+export interface RatchetHeader {
+    dhPub: Uint8Array;
+    N: number;
+    PN: number;
+}
+/**
+ * Serializable projection of a `RatchetState` — maps 1:1 onto the wrapped
+ * secret fields of the `RatchetSession` IndexedDB row (Stage 3). All buffers
+ * are owned copies; the skipped map is flattened to an array keyed by
+ * `(dhPub, n)`.
+ */
+export interface RatchetSessionSecrets {
+    rootSuite: RatchetRootSuite;
+    rootKey: ArrayBuffer;
+    sendingChainKey: ArrayBuffer | null;
+    receivingChainKey: ArrayBuffer | null;
+    dhSelfPub: ArrayBuffer;
+    dhSelfSec: ArrayBuffer;
+    dhRemotePub: ArrayBuffer | null;
+    Ns: number;
+    Nr: number;
+    PN: number;
+    skippedMessageKeys: Array<{
+        dhPub: ArrayBuffer;
+        n: number;
+        messageKey: ArrayBuffer;
+    }>;
+}
+/**
+ * Seed a ratchet from the handshake's 32-byte, transcript-bound hybrid root.
+ *
+ * Initiator/responder asymmetry (must match so the two sides interoperate):
+ *  - The **responder** (`amInitiator=false`, `remoteDhPub=null`) generates its
+ *    DH keypair and stops: both chains stay `null`. After the initiator's
+ *    initial DH pub is authenticated, `primeResponderRatchet` performs the
+ *    receive-side DH step without consuming a message key and opens both
+ *    chains. A lower-level caller that does not prime retains the legacy
+ *    first-inbound-message behavior.
+ *  - The **initiator** (`amInitiator=true`) is handed the responder's
+ *    `dhSelfPub` as `remoteDhPub`, runs one `kdf_rk` over `DH(selfSec, remote)`
+ *    to advance the root and open its **sending** chain immediately, so it can
+ *    send message 0 before ever hearing back. Its receiving chain opens on the
+ *    responder's first reply (a DH step against the responder's fresh pub).
+ */
+export declare const initRatchet: (rootSeed: Uint8Array, amInitiator: boolean, remoteDhPub: Uint8Array | null, module: LibCrypto, rootSuite?: RatchetRootSuite) => RatchetState;
+/**
+ * Advance the sending chain by one message. Returns the message key (caller's to
+ * consume/wipe) and the cleartext header to put on the wire. The consumed chain
+ * key is wiped once its successor is derived.
+ */
+export declare const ratchetEncrypt: (state: RatchetState, module: LibCrypto) => {
+    messageKey: Uint8Array;
+    header: RatchetHeader;
+};
+/**
+ * Complete the responder's handshake-time ratchet bootstrap after the
+ * initiator's initial DH public key has been authenticated by key confirmation.
+ *
+ * This is the receive-side DH step that an unprimed responder would otherwise
+ * perform on the initiator's first message, deliberately stopped before
+ * `kdfCk`: it opens the receiving chain from
+ * `DH(initialResponder, initialInitiator)`, rotates the responder DH keypair,
+ * and opens the sending chain from `DH(rotatedResponder, initialInitiator)`.
+ * Consequently both peers can send message 0 immediately after the handshake,
+ * including simultaneously, without consuming or skipping a message key.
+ */
+export declare const primeResponderRatchet: (state: RatchetState, initiatorDhPub: Uint8Array, module: LibCrypto) => void;
+/**
+ * Advance the receiving side for an inbound header and return its message key.
+ *
+ * CAUTION — this function is UNAUTHENTICATED: it mutates `state` (and may fire
+ * a DH-ratchet step) from the cleartext header alone, before the AEAD tag is
+ * ever checked (authentication happens later, in Stage 5). A duplicate or
+ * replayed message that is NOT a stored skipped key — e.g. a retransmit of a
+ * message from a chain the session has since stepped past — is NOT detected
+ * here: it falls through to the "new peer DH pub" case below and can fire a
+ * spurious backward DH-step, permanently desyncing the session. This is
+ * reachable by our own retransmit/reconcile layer, so callers MUST:
+ *   1. Dedup already-seen `(header.dhPub, header.N)` pairs BEFORE calling this
+ *      function — never invoke it a second time for a message already
+ *      processed.
+ *   2. Call `ratchetDecrypt` on a CLONE of `state` (via
+ *      `deserializeRatchet(serializeRatchet(state))`) and commit that clone as
+ *      the live state ONLY after the returned message key successfully
+ *      authenticates the AEAD ciphertext. If authentication fails, discard the
+ *      clone and leave the live state untouched.
+ * `ratchetDecrypt` itself performs neither dedup nor authentication — the safe
+ * integration of both rules is wired in Stage 4/5, not here.
+ *
+ * Against that (untrusted) header, handles three cases: (a) a stored skipped
+ * key — out-of-order delivery within an already-seen chain, (b) a new peer DH
+ * pub — skip the old chain's tail, then DH-step, (c) a forward message in the
+ * current chain — skip any gap, then derive. The consumed chain key is wiped
+ * once its successor is derived.
+ */
+export declare const ratchetDecrypt: (state: RatchetState, header: RatchetHeader, module: LibCrypto) => Uint8Array;
+/**
+ * Snapshot all live state (including the skipped map + DH keys) to owned
+ * buffers for at-rest persistence. Does NOT wipe the source state — the caller
+ * keeps using it.
+ */
+export declare const serializeRatchet: (state: RatchetState) => RatchetSessionSecrets;
+/** Rebuild a live `RatchetState` from a persisted snapshot. */
+export declare const deserializeRatchet: (s: RatchetSessionSecrets) => RatchetState;
+/** Deep-clone a live ratchet state into independently owned key buffers. */
+export declare const cloneRatchet: (state: RatchetState) => RatchetState;
+/** Wipe every secret-bearing buffer owned by a ratchet state. */
+export declare const wipeRatchet: (state: RatchetState) => void;
+/**
+ * Replace a live state with an independently owned authenticated successor.
+ * The superseded live secrets are wiped before ownership moves from `next`.
+ */
+export declare const adoptRatchet: (live: RatchetState, next: RatchetState) => void;

package/lib/cryptography/testModule.d.ts

@@ -0,0 +1,7 @@
+import type { LibCrypto } from "./libcrypto";
+/**
+ * Instantiate the locally-built libcrypto.wasm for unit tests, bypassing the
+ * CDN + SRI fetch in wasmLoader.ts. 32 pages == 2 MiB == INITIAL_MEMORY; growth
+ * is off so every op fits the largest-single-op budget.
+ */
+export declare const loadTestModule: () => Promise<LibCrypto>;

package/lib/cryptography/utils.d.ts

@@ -11,4 +11,3 @@ export declare function fisherYatesShuffle<T>(arr: T[]): T[];
  *
  * @returns Promise<T[]>
  */
-//# sourceMappingURL=utils.d.ts.map

package/lib/cryptography/wasmLoader.d.ts

@@ -1,2 +1,7 @@
+/**
+ * Point the browser root at a self-hosted copy of this release's exact WASM.
+ * The build-pinned SRI is still enforced. Configure once, before connect() or
+ * any other operation first loads cryptography.
+ */
+export declare const setWasmSourceUrl: (source: string | URL) => void;
 export declare const wasmLoader: (wasmMemory: WebAssembly.Memory) => Promise<import("./libcrypto").LibCrypto>;
-//# sourceMappingURL=wasmLoader.d.ts.map

package/lib/cryptography/x25519.d.ts

@@ -0,0 +1,15 @@
+import type { LibCrypto } from "./libcrypto";
+export interface X25519KeyPair {
+    publicKey: Uint8Array;
+    secretKey: Uint8Array;
+}
+export declare const x25519Keypair: (module: LibCrypto) => X25519KeyPair;
+/**
+ * Async, optional-module wrapper over `x25519Keypair`, mirroring `ed25519.newKeyPair`:
+ * self-loads a LibCrypto module (sizing its own fixed 2 MiB heap) when none is passed,
+ * so identity-generation call sites can mint the dedicated X25519 identity keypair the
+ * same way they call `newKeyPair()`. The keypair is random (`_x25519_keypair` draws its
+ * own entropy); `x25519Keypair` copies the secret out and zero-frees the wasm scratch.
+ */
+export declare const newX25519KeyPair: (module?: LibCrypto) => Promise<X25519KeyPair>;
+export declare const x25519Dh: (secretKey: Uint8Array, publicKey: Uint8Array, module: LibCrypto) => Uint8Array;

package/lib/cryptography/x3dh.d.ts

@@ -0,0 +1,9 @@
+import type { LibCrypto } from "./libcrypto";
+/**
+ * No-PIN identity-mixed ephemeral DH. Mixes
+ *   DH(IK_a, EK_b) || DH(EK_a, IK_b) || DH(EK_a, EK_b)
+ * (initiator orientation) then HKDF-SHA512 to a 32-byte root seed. The responder
+ * passes amInitiator=false; the three DH calls are re-ordered so both sides
+ * concatenate the identical shared values.
+ */
+export declare const deriveInteractive3dhSecret: (idSelfSec: Uint8Array, idPeerPub: Uint8Array, ephSelfSec: Uint8Array, ephPeerPub: Uint8Array, amInitiator: boolean, module: LibCrypto) => Uint8Array;

package/lib/db/api.d.ts

@@ -1,35 +1,67 @@
-import type { Chunk, NewChunk, SendQueue } from "./types";
+import type { Chunk, ReceiveChunk, NewChunk, NewChunkSelector, SendQueue, RatchetSession, IdentityEd25519, IdentityX25519 } from "./types";
 export declare const getDBAddressBookEntry: (peerId?: string, peerPublicKey?: string) => Promise<import("./types").UsernamedPeer | undefined>;
 export declare const getAllDBAddressBookEntries: () => Promise<import("./types").UsernamedPeer[]>;
-export declare const setDBAddressBookEntry: (username: string, peerId: string, peerPublicKey: string) => Promise<void>;
+export declare const setDBAddressBookEntry: (username: string, peerId: string, peerPublicKey: string) => Promise<undefined>;
 export declare const deleteDBAddressBookEntry: (username?: string, peerId?: string, peerPublicKey?: string) => Promise<string>;
+/**
+ * Fails CLOSED. This is the sole admission gate on every connection path, and
+ * an indeterminate answer must never be reported as "not blacklisted" — that
+ * would let a storage fault silently readmit every blocked peer. The denial is
+ * scoped to the one peer being checked, so a transient fault cannot lock the
+ * whole room out.
+ */
 export declare const getDBPeerIsBlacklisted: (peerId?: string, peerPublicKey?: string) => Promise<boolean>;
 export declare const getAllDBBlacklisted: () => Promise<import("./types").BlacklistedPeer[]>;
-export declare const setDBPeerInBlacklist: (peerId: string, peerPublicKey: string) => Promise<void>;
-export declare const deleteDBPeerFromBlacklist: (peerId?: string, peerPublicKey?: string) => Promise<void>;
+export declare const setDBPeerInBlacklist: (peerId: string, peerPublicKey: string) => Promise<undefined>;
+export declare const deleteDBPeerFromBlacklist: (peerId?: string, peerPublicKey?: string) => Promise<undefined>;
 export declare const getAllDBUniqueRooms: () => Promise<import("./types").UniqueRoom[]>;
-export declare const setDBUniqueRoom: (roomUrl: string, roomId: string) => Promise<void>;
+export declare const setDBUniqueRoom: (roomUrl: string, roomId: string, roomPolicy: ArrayBuffer) => Promise<undefined>;
 export declare const getDBMessageData: (merkleRootHex?: string, hashHex?: string) => Promise<import("./types").MessageData | undefined>;
 export declare const getDBRoomMessageData: (roomId: string) => Promise<import("./types").MessageData[]>;
+export declare const getDBRoomStats: (roomId: string) => Promise<import("./types").RoomStats>;
 export declare const setDBRoomMessageData: (roomId: string, merkleRootHex: string, sha512Hex: string, fromPeerId: string, chunkSize: number, totalSize: number, messageType: number, // MessageType,
-filename: string, channelLabel: string, timestamp: number) => Promise<void>;
-export declare const getDBChunk: (hashHex: string, chunkIndex: number) => Promise<ArrayBuffer | undefined>;
-export declare const existsDBChunk: (hashHex: string, chunkIndex: number) => Promise<boolean>;
-export declare const getDBNewChunk: (hashHex: string, chunkIndex?: number) => Promise<NewChunk | undefined>;
-export declare const existsDBNewChunk: (hashHex: string, chunkIndex: number) => Promise<boolean>;
+filename: string, channelLabel: string, timestamp: number, transferId?: string) => Promise<undefined>;
+export declare const getDBChunk: (merkleRootHex: string, chunkIndex: number) => Promise<ArrayBuffer | undefined>;
+export declare const existsDBChunk: (merkleRootHex: string, chunkIndex: number) => Promise<boolean>;
+export declare const getDBNewChunk: (transferId: string, chunkIndex: number) => Promise<NewChunk | undefined>;
+export declare const getDBNewChunkByReceipt: (merkleRootHex: string, receiptTokenHex: string) => Promise<NewChunk | undefined>;
+export declare const existsDBNewChunk: (transferId: string, chunkIndex: number) => Promise<boolean>;
 export declare const getDBSendQueue: (label: string, toPeerId: string) => Promise<SendQueue[]>;
 export declare const getDBAllChunks: (merkleRootHex?: string, hashHex?: string) => Promise<Chunk[]>;
+export declare const getDBAllChunkLeafHashes: (merkleRootHex: string) => Promise<import("./types").ChunkLeafHash[]>;
+export declare const assembleToOPFS: (merkleRootHex: string, totalSize: number, filename: string, mimeType: string) => Promise<File | null>;
 export declare const getDBAllChunksCount: (merkleRootHex?: string, hashHex?: string) => Promise<number>;
-export declare const setDBChunk: (chunk: Chunk) => Promise<void>;
-export declare const getDBAllNewChunks: (hashHex?: string, merkleRootHex?: string) => Promise<NewChunk[]>;
-export declare const getDBAllNewChunksCount: (hashHex: string) => Promise<number>;
-export declare const setDBNewChunk: (chunk: NewChunk) => Promise<void>;
-export declare const setDBSendQueue: (item: SendQueue) => Promise<void>;
+export declare const setDBChunk: (chunk: Chunk) => Promise<undefined>;
+export declare const storeReceiveChunk: (chunk: ReceiveChunk) => Promise<import("./types").ReceiveChunkStoreResult>;
+export declare const getReceiveFile: (merkleRootHex: string, totalSize: number, filename: string, mimeType: string) => Promise<File | null>;
+export declare const closeReceiveFile: (merkleRootHex: string) => Promise<undefined>;
+/**
+ * Atomically retires one inbound transfer behind the same per-Merkle worker
+ * lock used by storeReceiveChunk. This is the cancellation primitive: a chunk
+ * write that was already in flight completes first and is then removed, while
+ * later writes are stopped by the channel's AbortSignal.
+ */
+export declare const deleteReceiveTransfer: (merkleRootHex: string) => Promise<undefined>;
+export declare const getDBAllNewChunks: (selector: NewChunkSelector) => Promise<NewChunk[]>;
+export declare const getDBAllNewChunksCount: (transferId: string) => Promise<number>;
+export declare const setDBNewChunk: (chunk: NewChunk) => Promise<undefined>;
+export declare const setDBSendQueue: (item: SendQueue) => Promise<undefined>;
 export declare const countDBSendQueue: (label: string, toPeerId: string) => Promise<number>;
-export declare const deleteDBChunk: (hashHex: string, chunkIndex?: number) => Promise<void>;
-export declare const deleteDBNewChunk: (merkleRootHex?: string, realChunkHashHex?: string, hashHex?: string, chunkIndex?: number) => Promise<void>;
-export declare const deleteDBMessageData: (merkleRootHex: string) => Promise<void>;
-export declare const deleteDBUniqueRoom: (roomId: string) => Promise<void>;
-export declare const deleteDB: () => Promise<void>;
-export declare const deleteDBSendQueue: (label: string, toPeerId: string, position?: number) => Promise<void>;
-//# sourceMappingURL=api.d.ts.map
+export declare const deleteDBChunk: (hashHex: string, chunkIndex?: number) => Promise<undefined>;
+export declare const deleteDBNewChunk: (selector: NewChunkSelector) => Promise<undefined>;
+export declare const deleteDBMessageData: (merkleRootHex: string) => Promise<undefined>;
+export declare const deleteDBUniqueRoom: (roomId: string) => Promise<undefined>;
+export declare const deleteDB: () => Promise<undefined>;
+export declare const deleteDBSendQueue: (label: string, toPeerId: string, position?: number) => Promise<undefined>;
+export declare const getRatchetSession: (roomId: string, peerPublicKey: string) => Promise<RatchetSession | undefined>;
+export declare const setRatchetSession: (session: RatchetSession) => Promise<undefined>;
+export declare const deleteRatchetSession: (roomId: string, peerPublicKey: string) => Promise<undefined>;
+export declare const getPinAttemptState: (roomId: string, peerIdentityEd25519: string) => Promise<import("./types").PinAttemptState | undefined>;
+export declare const incrementPinAttemptState: (roomId: string, peerIdentityEd25519: string, now: number, maxImmediateAttempts: number, baseMs: number, maxMs: number) => Promise<import("./types").PinAttemptState>;
+export declare const deletePinAttemptState: (roomId: string, peerIdentityEd25519?: string) => Promise<undefined>;
+export declare const getIdentityX25519: () => Promise<IdentityX25519 | undefined>;
+export declare const setIdentityX25519: (identity: IdentityX25519) => Promise<undefined>;
+export declare const deleteIdentityX25519: () => Promise<undefined>;
+export declare const getIdentityEd25519: () => Promise<IdentityEd25519 | undefined>;
+export declare const setIdentityEd25519: (identity: IdentityEd25519) => Promise<undefined>;
+export declare const deleteIdentityEd25519: () => Promise<undefined>;

package/lib/db/db.worker.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=db.worker.d.ts.map

package/lib/db/ratchetWrap.d.ts

@@ -0,0 +1,36 @@
+import type { RatchetSession } from "./types";
+export declare const RATCHET_WRAP_VERSION = 2;
+/** Bounded canonical v4 PQ/outbox/active-key checkpoint (plaintext bytes). */
+export declare const MAX_EDGE_CRYPTO_STATE_BYTES: number;
+/**
+ * Best-effort rollback/equivocation detection for one running client context.
+ *
+ * Callers pass an instance to `unwrapRatchetSession`; a successfully
+ * authenticated record may advance `updatedAt`, but may not move backwards or
+ * present different ciphertext at the same timestamp. `forget` is required
+ * when an edge is intentionally deleted/re-established.
+ *
+ * This cannot detect replay of an older *complete* IndexedDB snapshot after a
+ * full browser restart: WebCrypto/IndexedDB expose no trusted monotonic
+ * counter. Durable cross-restart detection needs an independently protected
+ * high-water head (or a remote/trusted anchor), atomically advanced with the
+ * ratchet row. AES-GCM alone cannot provide that property.
+ */
+export declare class RatchetRollbackGuard {
+    #private;
+    acceptAuthenticated(s: RatchetSession): Promise<void>;
+    /**
+     * Advance the in-process high-water mark after, and only after, a local
+     * wrapped row was durably stored. The record's canonical metadata and every
+     * envelope shape/record ID are validated, but the locally produced
+     * ciphertext is intentionally not decrypted.
+     */
+    rememberTrustedWrite(wrapped: RatchetSession): Promise<void>;
+    forget(roomId: string, peerPublicKey: string): void;
+    clear(): void;
+}
+export declare function getWrapKey(): Promise<CryptoKey>;
+export declare function wrapSecret(key: CryptoKey, bytes: ArrayBuffer): Promise<ArrayBuffer>;
+export declare function unwrapSecret(key: CryptoKey, blob: ArrayBuffer): Promise<ArrayBuffer>;
+export declare function wrapRatchetSession(s: RatchetSession, key: CryptoKey): Promise<RatchetSession>;
+export declare function unwrapRatchetSession(s: RatchetSession, key: CryptoKey, rollbackGuard?: RatchetRollbackGuard): Promise<RatchetSession>;

package/lib/db/src/getDB.d.ts

@@ -1,7 +1,7 @@
 import type { DBSchema, IDBPDatabase } from "idb";
-import type { MessageData, Chunk, SendQueue, AddressBook, BlacklistedPeer, UniqueRoom, NewChunk } from "../types";
+import type { MessageData, Chunk, SendQueue, AddressBook, BlacklistedPeer, UniqueRoom, NewChunk, RatchetSession, StoredIdentityX25519, StoredIdentityEd25519, PinAttemptState } from "../types";
 export declare const dbName = "p2party";
-export declare const dbVersion = 16;
+export declare const dbVersion = 19;
 export interface RepoSchema extends DBSchema {
     addressBook: {
         value: AddressBook;
@@ -51,9 +51,10 @@ export interface RepoSchema extends DBSchema {
         value: NewChunk;
         key: [string, number];
         indexes: {
+            transferId: string;
             hash: string;
             merkleRoot: string;
-            realChunkHash: string;
+            receiptScope: [string, string];
         };
     };
     sendQueue: {
@@ -63,6 +64,18 @@ export interface RepoSchema extends DBSchema {
             labelPeer: string;
         };
     };
+    ratchetSessions: {
+        value: RatchetSession;
+        key: [string, string];
+        indexes: {
+            peerId: string;
+            peerPublicKey: string;
+            roomId: string;
+        };
+    };
+    meta: {
+        value: CryptoKey | StoredIdentityX25519 | StoredIdentityEd25519 | PinAttemptState;
+        key: string;
+    };
 }
 export declare function getDB(): Promise<IDBPDatabase<RepoSchema>>;
-//# sourceMappingURL=getDB.d.ts.map