p2party 0.14.7 → 0.14.10

package/lib/api/webrtc/interfaces.d.ts

@@ -3,11 +3,20 @@ import type { RatchetState } from "../../cryptography/ratchet";
 import type { RatchetGateLease } from "../../handlers/ratchetGate";
 import type { CoverRuntime } from "../../handlers/coverRuntime";
 import type { SparsePqHealingState } from "../../handlers/pqHealingRuntime";
+import type { PeerHandshakeFailureReason } from "../../reducers/roomSlice";
+import type { PeerSocketGenerationSource } from "./peerSocketGeneration";
 export interface IRTCPeerConnection extends RTCPeerConnection {
     /** The room this transport belongs to. A room/peer pair owns one PC. */
     roomId: string;
     withPeerId: string;
     withPeerPublicKey: string;
+    /**
+     * The peer signaling socket this transport was built against. A different
+     * generation for the same peerId means the peer's session was replaced, and
+     * this transport can never be signalled again (C1). Absent against a
+     * pre-generation server, where it must never be read as a change.
+     */
+    peerSocketGeneration?: string;
     makingOffer: boolean;
     ignoreOffer: boolean;
     receiveMessageModule: LibCrypto;
@@ -16,6 +25,13 @@ export interface IRTCPeerConnection extends RTCPeerConnection {
     mainChannel?: IRTCDataChannel;
     /** Gate ownership captured when this concrete transport is created. */
     ratchetGateLease: RatchetGateLease;
+    /**
+     * Set when this edge's handshake failed for a reason a fresh transport
+     * cannot fix (a wrong PIN, a PIN throttle, a policy/suite mismatch). The
+     * `main` channel's close handler consults it so a terminal failure is never
+     * followed by a re-dial. Cleared only by building a new transport.
+     */
+    handshakeTerminalFailure?: PeerHandshakeFailureReason;
     /**
      * How many times this RTCPeerConnection has been re-bound IN PLACE onto a
      * new remote DTLS certificate since it last authenticated. The re-bind
@@ -88,6 +104,13 @@ export interface IRTCDataChannel extends RTCDataChannel {
      * delete its storage artifacts after the active handler reaches quiescence.
      */
     cancelReceiveTransfer?: () => Promise<void>;
+    /**
+     * Set by any close THIS side initiated (the pre-authentication frame guard,
+     * the transfer's terminal-close runner, the resume path's cleanup). Read by
+     * `isAuthenticatedPeerCancel` so our own close is never reported as the peer
+     * cancelling the transfer (C7).
+     */
+    closedLocally?: boolean;
 }
 export interface IRTCMessage {
     id: string;
@@ -106,6 +129,15 @@ export interface RTCPeerConnectionParams {
     peerPublicKey: string;
     roomId: string;
     rtcConfig?: RTCConfiguration;
+    /** The peer's signaling-socket generation, as last named by the server. */
+    peerSocketGeneration?: string;
+    /**
+     * Which inbound frame named that generation. Only a `connection` frame
+     * proves a fresh remote transport; a roster introduction is record-only
+     * while this side's transport is connected (see peerSocketGeneration).
+     * Omitted means advisory.
+     */
+    peerSocketGenerationSource?: PeerSocketGenerationSource;
 }
 export interface RTCSetDescriptionParams {
     peerId: string;
@@ -138,7 +170,7 @@ export interface RTCOpenChannelParams {
 export interface RTCSendMessageParams {
     /** Random 32-byte lowercase-hex identity allocated by the public API. */
     transferId: string;
-    data: string | File;
+    data?: string | File;
     label: string;
     roomId: string;
     minChunks?: number;

package/lib/api/webrtc/peerSocketGeneration.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Whether a peerId still names the same signaling session.
+ *
+ * The server binds one stable peerId to an identity public key, so a second
+ * tab or a phrase-restored second device reconnects as the SAME peerId and
+ * evicts its predecessor. Without a per-socket generation the edge stayed
+ * bound to the evicted socket: the transport never failed (no SDP, no ICE
+ * event), so nothing rebuilt it, and a responder on the new session creates no
+ * channel and can never offer — the split was permanent (C1).
+ *
+ * "unknown" is the fail-safe verdict: an absent or malformed generation (a
+ * pre-generation server, or a fresh transport that has not recorded one yet)
+ * must behave exactly as 0.14.7 does, never as a teardown trigger. The server
+ * leaves the field empty until a socket has proved ownership of its key and
+ * empties it again whenever a fresh challenge is issued, so "" and undefined
+ * are the same statement: no information.
+ */
+export type PeerSocketGenerationVerdict = "unknown" | "unchanged" | "changed";
+/**
+ * Which inbound frame carried a generation, and therefore how much authority
+ * it has.
+ *
+ * - "connection": the peer's own `connection` frame. It is emitted from one
+ *   place only (handleConnectToPeer's connectWithPeer), and that place is
+ *   reachable only after a FRESH transport has been built — both baseQuery and
+ *   handleConnectToPeer early-return on a live one. A changed generation there
+ *   always means a genuinely new remote transport.
+ * - "roster": a `peers` introduction. The roster is re-requested on join, on
+ *   re-dial AND on reconcile, and a signaling socket now reconnects on its
+ *   own, so a benign reconnect of a healthy session routinely delivers a
+ *   changed generation for an edge that is working perfectly. Acting on that
+ *   is a regression of cluster C4, so it is record-only while the local
+ *   transport is connected.
+ */
+export type PeerSocketGenerationSource = "connection" | "roster";
+export declare const isCanonicalSocketGeneration: (value: unknown) => value is string;
+export declare const comparePeerSocketGeneration: (recorded: string | undefined, observed: unknown) => PeerSocketGenerationVerdict;
+export declare const markPeerSocketGenerationRetired: (roomId: string, peerId: string, generation: unknown) => void;
+export declare const isPeerSocketGenerationRetired: (roomId: string, peerId: string, generation: unknown) => boolean;
+export declare const clearRetiredPeerSocketGenerations: (roomId: string, peerId: string) => void;
+export interface PeerSocketGenerationObservation {
+    roomId: string;
+    peerId: string;
+    /** The generation the local transport was built against, if any. */
+    recorded: string | undefined;
+    /** The generation this frame names for the peer. */
+    observed: unknown;
+    /** Which inbound frame carried it; an unattributed frame is advisory. */
+    source: PeerSocketGenerationSource | undefined;
+    /** The local transport's current state. */
+    connectionState: RTCPeerConnectionState;
+}
+/**
+ * Whether an observed generation is reason enough to retire the local
+ * transport for this edge and rebuild it against the peer's live session.
+ *
+ * Deliberately conservative in two directions. A roster introduction is acted
+ * on only when the local transport is demonstrably not working — a healthy
+ * edge must survive an ordinary signaling reconnect (C4). And a generation
+ * this edge has already retired never triggers a second teardown, however it
+ * arrives.
+ *
+ * "not working" excludes "disconnected". handleConnectToPeer answers that state
+ * with an ICE restart and only tears the edge down if it is still disconnected
+ * 8 s later, and the restart usually succeeds — so a roster frame arriving in
+ * that window would replace a transport that was about to heal itself.
+ */
+export declare const shouldRetireTransportForSocketGeneration: ({ roomId, peerId, recorded, observed, source, connectionState, }: PeerSocketGenerationObservation) => boolean;

package/lib/cryptography/coverCell.d.ts

@@ -5,6 +5,8 @@ export declare const COVER_CELL_PLAINTEXT_BYTES: number;
 export declare const COVER_CELL_BINDING_BYTES = 32;
 export declare const COVER_CELL_ROOT_BYTES = 32;
 export declare const COVER_CELL_TOKEN_BYTES: number;
+/** Bound token lookup/persistence work per authenticated scheduled cell. */
+export declare const MAX_COVER_CHUNK_RECEIPTS = 64;
 export declare const COVER_CELL_MAX_PAYLOAD_BYTES: number;
 export type CoverCellDirection = "initiator-to-responder" | "responder-to-initiator";
 export type CoverCellContent = {
@@ -21,6 +23,11 @@ export type CoverCellContent = {
     readonly subtype: "receipt";
     readonly merkleRoot: Uint8Array;
     readonly token: Uint8Array;
+} | {
+    /** Subtype 4: old clients drop this unknown subtype, never treat it as completion. */
+    readonly subtype: "chunk-receipts";
+    readonly merkleRoot: Uint8Array;
+    readonly tokens: readonly Uint8Array[];
 };
 export type CoverCellErrorCode = "authentication-failed" | "binding-mismatch" | "epoch-mismatch" | "invalid-cell" | "invalid-direction" | "invalid-padding" | "replayed-counter";
 export declare class CoverCellError extends Error {

package/lib/cryptography/emscripten.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Module-scoped EmscriptenModule and factory types from @types/emscripten
+ * 1.41.5 (DefinitelyTyped). All inherited LibCrypto members are retained.
+ * Keeping these types local avoids a required ambient development dependency
+ * and does not merge with a consumer's global Emscripten declarations.
+ * MIT license, Copyright (c) Microsoft Corporation.
+ * See THIRD_PARTY_NOTICES.md for the full upstream license.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any -- Preserve upstream API compatibility. */
+
+// Infers the type only in TypeScript environments where GPU types are available
+type MaybeGPUDevice = Navigator extends {
+  gpu: {
+    requestAdapter(...args: any[]): Promise<null | {
+      requestDevice(...args: any[]): Promise<null | infer T>;
+    }>;
+  };
+}
+  ? T
+  : never;
+
+export interface EmscriptenModule {
+  print(str: string): void;
+  printErr(str: string): void;
+  arguments: string[];
+  environment: "WEB" | "NODE" | "SHELL" | "WORKER";
+  preInit: Array<{ (): void }>;
+  preRun: Array<{ (): void }>;
+  postRun: Array<{ (): void }>;
+  onAbort: { (what: any): void };
+  onRuntimeInitialized: { (): void };
+  preinitializedWebGLContext: WebGLRenderingContext;
+  preinitializedWebGPUDevice: MaybeGPUDevice;
+  noInitialRun: boolean;
+  noExitRuntime: boolean;
+  logReadFiles: boolean;
+  filePackagePrefixURL: string;
+  wasmBinary: ArrayBuffer;
+
+  destroy(object: object): void;
+  getPreloadedPackage(
+    remotePackageName: string,
+    remotePackageSize: number,
+  ): ArrayBuffer;
+  instantiateWasm(
+    imports: WebAssembly.Imports,
+    successCallback: (module: WebAssembly.Instance) => void,
+  ): WebAssembly.Exports | undefined;
+  locateFile(url: string, scriptDirectory: string): string;
+  onCustomMessage(event: MessageEvent): void;
+
+  // USE_TYPED_ARRAYS == 1
+  HEAP: Int32Array;
+  IHEAP: Int32Array;
+  FHEAP: Float64Array;
+
+  // USE_TYPED_ARRAYS == 2
+  HEAP8: Int8Array;
+  HEAP16: Int16Array;
+  HEAP32: Int32Array;
+  HEAPU8: Uint8Array;
+  HEAPU16: Uint16Array;
+  HEAPU32: Uint32Array;
+  HEAPF32: Float32Array;
+  HEAPF64: Float64Array;
+  HEAP64: BigInt64Array;
+  HEAPU64: BigUint64Array;
+
+  TOTAL_STACK: number;
+  TOTAL_MEMORY: number;
+  FAST_MEMORY: number;
+
+  addOnPreRun(cb: () => any): void;
+  addOnInit(cb: () => any): void;
+  addOnPreMain(cb: () => any): void;
+  addOnExit(cb: () => any): void;
+  addOnPostRun(cb: () => any): void;
+
+  preloadedImages: any;
+  preloadedAudios: any;
+
+  _malloc(size: number): number;
+  _free(ptr: number): void;
+}
+
+/**
+ * A factory function is generated when setting the `MODULARIZE` build option
+ * to `1` in your Emscripten build. It return a Promise that resolves to an
+ * initialized, ready-to-call `EmscriptenModule` instance.
+ *
+ * By default, the factory function will be named `Module`. It's recommended to
+ * use the `EXPORT_ES6` option, in which the factory function will be the
+ * default export. If used without `EXPORT_ES6`, the factory function will be a
+ * global variable. You can rename the variable using the `EXPORT_NAME` build
+ * option. It's left to you to declare any global variables as needed in your
+ * application's types.
+ * @param moduleOverrides Default properties for the initialized module.
+ */
+export type EmscriptenModuleFactory<
+  T extends EmscriptenModule = EmscriptenModule,
+> = (moduleOverrides?: Partial<T>) => Promise<T>;

package/lib/cryptography/libcrypto.d.ts

@@ -0,0 +1,181 @@
+import type { EmscriptenModule, EmscriptenModuleFactory } from "./emscripten";
+
+export interface LibCrypto extends EmscriptenModule {
+  wasmMemory: WebAssembly.Memory;
+  /** Web Crypto backed entropy callback supplied by the JavaScript loader. */
+  getRandomValue?(): number;
+
+  _crypto_init(): number;
+
+  _keypair(
+    public_key: number, // Uint8Array,
+    secret_key: number, // Uint8Array
+  ): number;
+
+  _keypair_from_seed(
+    public_key: number, // Uint8Array,
+    secret_key: number, // Uint8Array,
+    seed: number, // Uint8Array,
+  ): number;
+  _keypair_from_secret_key(
+    public_key: number, // Uint8Array,
+    secret_key: number, // Uint8Array,
+  ): number;
+
+  _sign(
+    DATA_LEN: number,
+    data: number, // Uint8Array,
+    secret_key: number, // Uint8Array,
+    signature: number, // Uint8Array,
+  ): number;
+  _verify(
+    DATA_LEN: number,
+    data: number, // Uint8Array,
+    public_key: number, // Uint8Array,
+    signature: number, // Uint8Array,
+  ): number;
+
+  _get_merkle_root(
+    LEAVES_LEN: number,
+    leaves_hashed: number, // Uint8Array.byteOffset
+    root: number, // Uint8Array.byteOffset
+  ): number;
+  _get_merkle_proof(
+    LEAVES_LEN: number,
+    leaves_hashed: number, // Uint8Array.byteOffset
+    element_hash: number, // Uint8Array.byteOffset
+    proof: number, // Uint8Array.byteOffset
+  ): number;
+  _get_merkle_root_from_proof(
+    PROOF_LEN: number,
+    element_hash: number, // Uint8Array.byteOffset
+    proof: number, // Uint8Array.byteOffset
+    root: number, // Uint8Array.byteOffset
+  ): number;
+  _verify_merkle_proof(
+    PROOF_LEN: number,
+    element_hash: number, // Uint8Array.byteOffset
+    root: number, // Uint8Array.byteOffset
+    proof: number, // Uint8Array.byteOffset
+  ): number;
+
+  _argon2(
+    MNEMONIC_LEN: number,
+    seed: number,
+    mnemonic: number,
+    salt: number,
+  ): number;
+
+  // Streaming SHA-512 (plain, no domain separation) — state is a heap
+  // crypto_hash_sha512_state (208 bytes) allocated by JS.
+  _sha512_init(
+    state: number, // Uint8Array.byteOffset (208-byte state)
+  ): number;
+  _sha512_update(
+    state: number, // Uint8Array.byteOffset
+    in_data: number, // Uint8Array.byteOffset
+    in_len: number,
+  ): number;
+  _sha512_final(
+    state: number, // Uint8Array.byteOffset
+    out: number, // Uint8Array.byteOffset (64 bytes)
+  ): number;
+
+  // v3 PAKE + ratchet primitives (pake_ratchet.c)
+  _cpace_ristretto255_from_hash(out: number, hash: number): void;
+  _cpace_ristretto255_scalarmult(
+    out: number,
+    scalar: number,
+    point: number,
+  ): number;
+  _cpace_ristretto255_scalar_random(out: number): void;
+  _x25519_keypair(pk: number, sk: number): number;
+  _x25519_dh(shared: number, sk: number, pk: number): number;
+  _hkdf_sha512_extract(
+    prk: number,
+    salt: number,
+    salt_len: number,
+    ikm: number,
+    ikm_len: number,
+  ): number;
+  _hkdf_sha512_expand(
+    out: number,
+    out_len: number,
+    prk: number,
+    info: number,
+    info_len: number,
+  ): number;
+  _encrypt_chachapoly_symmetric(
+    out: number,
+    data: number,
+    data_len: number,
+    key: number,
+    nonce: number,
+    aad: number,
+    aad_len: number,
+  ): number;
+  _decrypt_chachapoly_symmetric(
+    out: number,
+    ciphertext: number,
+    ciphertext_len: number,
+    key: number,
+    nonce: number,
+    aad: number,
+    aad_len: number,
+  ): number;
+  _carrier_aead_xchacha20poly1305_encrypt(
+    out: number,
+    data: number,
+    data_len: number,
+    key: number,
+    nonce: number,
+    aad: number,
+    aad_len: number,
+  ): number;
+  _carrier_aead_xchacha20poly1305_decrypt(
+    out: number,
+    ciphertext: number,
+    ciphertext_len: number,
+    key: number,
+    nonce: number,
+    aad: number,
+    aad_len: number,
+  ): number;
+  _receive_message_with_key(
+    decrypted: number,
+    message: number,
+    merkle_root: number,
+    message_key: number,
+  ): number;
+
+  // ML-KEM (FIPS 203), deterministic entry points for all standardized
+  // parameter sets. JavaScript supplies cryptographically secure coins;
+  // zero is success and a negative value is failure.
+  _mlkem512_keypair(pk: number, sk: number, coins64: number): number;
+  _mlkem512_encaps(ct: number, ss: number, pk: number, coins32: number): number;
+  _mlkem512_decaps(ss: number, ct: number, sk: number): number;
+  _mlkem768_keypair(pk: number, sk: number, coins64: number): number;
+  _mlkem768_encaps(ct: number, ss: number, pk: number, coins32: number): number;
+  _mlkem768_decaps(ss: number, ct: number, sk: number): number;
+  _mlkem1024_keypair(pk: number, sk: number, coins64: number): number;
+  _mlkem1024_encaps(
+    ct: number,
+    ss: number,
+    pk: number,
+    coins32: number,
+  ): number;
+  _mlkem1024_decaps(ss: number, ct: number, sk: number): number;
+
+  // P2Party-owned one-shot FIPS 202 boundary backed by the implementation
+  // already compiled into the shared ML-KEM-768 unit.
+  _fips202_shake256(
+    out: number,
+    out_len: number,
+    input: number,
+    input_len: number,
+  ): number;
+  _fips202_sha3_256(out: number, input: number, input_len: number): number;
+}
+
+declare const libcrypto: EmscriptenModuleFactory<LibCrypto>;
+export default libcrypto;

package/lib/db/outboxTypes.d.ts

@@ -0,0 +1,135 @@
+import type { Chunk, MessageData } from "./types";
+/** Durable resend metadata; secrets remain exclusively in the ratchet vault. */
+export interface OutboxLease {
+    transferId: string;
+    owner: string;
+    fence: number;
+}
+export interface OutboxRecipient {
+    peerId: string;
+    publicKey: string;
+    delivered: boolean;
+    cancelled?: boolean;
+}
+export interface OutboxManifest {
+    transferId: string;
+    senderPublicKey: string;
+    identityRevision: bigint;
+    roomId: string;
+    roomUrl: string;
+    policyHex: string;
+    channelLabel: string;
+    filename: string;
+    totalSize: number;
+    totalChunks: number;
+    stagedBytes: number;
+    writtenBytes: number;
+    localBytes: number;
+    createdAt: number;
+    updatedAt: number;
+    expiresAt: number;
+    phase: "staging" | "pending" | "sending";
+    merkleRootHex: string;
+    hashHex: string;
+    recipients: OutboxRecipient[];
+    owner: string;
+    fence: number;
+    leaseUntil: number;
+    lastError?: string;
+}
+export interface OutboxCreate {
+    transferId: string;
+    senderPublicKey: string;
+    roomId: string;
+    roomUrl: string;
+    policyHex: string;
+    channelLabel: string;
+    filename: string;
+    totalSize: number;
+    totalChunks: number;
+    stagedBytes: number;
+    recipients: Array<{
+        peerId: string;
+        publicKey: string;
+    }>;
+    owner: string;
+}
+export interface OutboxReceipt {
+    roomId: string;
+    peerId: string;
+    peerPublicKey: string;
+    transferId: string;
+    merkleRootHex: string;
+    chunkIndex?: number;
+    cancelled?: boolean;
+}
+export interface OutboxAckRecord {
+    transferId: string;
+    publicKey: string;
+    bitmap: Uint8Array;
+}
+export type OutboxRequest = {
+    kind: "create";
+    input: OutboxCreate;
+} | {
+    kind: "publish";
+    lease: OutboxLease;
+    merkleRootHex: string;
+    hashHex: string;
+    chunkHashes: ArrayBuffer;
+} | {
+    kind: "claim";
+    transferId: string;
+    owner: string;
+    senderPublicKey: string;
+    roomId: string;
+    roomUrl: string;
+    policyHex: string;
+} | {
+    kind: "selfChunk";
+    lease: OutboxLease;
+    chunk: Chunk;
+} | {
+    kind: "selfMessage";
+    lease: OutboxLease;
+    message: MessageData;
+} | {
+    kind: "renew";
+    lease: OutboxLease;
+} | {
+    kind: "release";
+    lease: OutboxLease;
+    lastError?: string;
+} | {
+    kind: "receipt";
+    receipt: OutboxReceipt;
+} | {
+    kind: "list";
+    senderPublicKey: string;
+    roomId?: string;
+} | {
+    kind: "remove";
+    transferId?: string;
+    roomId?: string;
+    lease?: OutboxLease;
+} | {
+    kind: "sweep";
+};
+export interface OutboxResponse {
+    accepted: boolean;
+    manifest?: OutboxManifest;
+    manifests?: OutboxManifest[];
+    lease?: OutboxLease;
+    chunkHashes?: ArrayBuffer;
+    acknowledgments?: OutboxAckRecord[];
+}
+export interface ReceiveActivity {
+    merkleRoot: string;
+    roomId: string;
+    fromPeerId: string;
+    lastActivityAt: number;
+    /** Deletion fences work queued before the terminal operation. */
+    deletedAt?: number;
+    writeToken?: string;
+    leaseUntil?: number;
+}

package/lib/db/types.d.ts

@@ -1,3 +1,4 @@
+import type { OutboxLease, OutboxRequest, OutboxResponse } from "./outboxTypes";
 import type { Peer } from "../reducers/roomSlice";
 import type { RatchetRootSuite } from "../utils/constants";
 export interface UsernamedPeer extends Peer {
@@ -83,6 +84,16 @@ export interface ReceiveChunk {
     /** Text stays in IndexedDB; files use the OPFS-first receive path. */
     storage: "indexeddb" | "opfs";
 }
+export interface ExpiredReceiveTransfer {
+    merkleRoot: string;
+    roomId: string;
+    fromPeerId: string;
+}
+export interface ReceiveDeleteGuard {
+    roomId: string;
+    fromPeerId: string;
+    incompleteOnly: true;
+}
 export interface ReceiveChunkStoreResult {
     /** True only when this call inserted a previously absent chunk index. */
     stored: boolean;
@@ -216,6 +227,18 @@ export interface PinAttemptState {
     retryAfter: number;
 }
 export type WorkerMessages = {
+    id: number;
+    method: "outboxRequest";
+    args: [request: OutboxRequest];
+} | {
+    id: number;
+    method: "sweepStaleReceives";
+    args: [];
+} | {
+    id: number;
+    method: "sweepStaleReceiveDetails";
+    args: [];
+} | {
     id: number;
     method: "getDBAddressBookEntry";
     args: [peerId?: string, peerPublicKey?: string];
@@ -352,7 +375,7 @@ export type WorkerMessages = {
 } | {
     id: number;
     method: "deleteReceiveTransfer";
-    args: [merkleRootHex: string];
+    args: [merkleRootHex: string, guard?: ReceiveDeleteGuard];
 } | {
     id: number;
     method: "getDBAllNewChunks";
@@ -364,7 +387,7 @@ export type WorkerMessages = {
 } | {
     id: number;
     method: "setDBNewChunk";
-    args: [chunk: NewChunk];
+    args: [chunk: NewChunk, lease?: OutboxLease];
 } | {
     id: number;
     method: "setDBSendQueue";
@@ -466,6 +489,9 @@ export type WorkerMessages = {
     args: [];
 };
 export interface WorkerMethodReturnTypes {
+    outboxRequest: OutboxResponse;
+    sweepStaleReceives: string[];
+    sweepStaleReceiveDetails: ExpiredReceiveTransfer[];
     getDBAddressBookEntry: UsernamedPeer | undefined;
     getAllDBAddressBookEntries: UsernamedPeer[];
     setDBAddressBookEntry: undefined;
@@ -493,7 +519,7 @@ export interface WorkerMethodReturnTypes {
     storeReceiveChunk: ReceiveChunkStoreResult;
     getReceiveFile: File | null;
     closeReceiveFile: undefined;
-    deleteReceiveTransfer: undefined;
+    deleteReceiveTransfer: boolean | undefined;
     getDBAllNewChunks: NewChunk[];
     getDBAllNewChunksCount: number;
     setDBNewChunk: undefined;