@interncom/diplomatic 0.2.5 → 0.2.7

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

@@ -48,8 +48,22 @@ export interface IStorage {
     addUser: (pubKey: PublicKey) => Promise<ValStat<void>>;
     hasUser: (pubKey: PublicKey) => Promise<ValStat<boolean>>;
     subMeta: (pubKey: PublicKey) => Promise<ValStat<ISubscriptionMetadata>>;
-    setBag: (pubKey: PublicKey, bag: IBag) => Promise<ValStat<number>>;
-    getBody: (pubKey: PublicKey, seq: number) => Promise<ValStat<Uint8Array | undefined>>;
+    /**
+     * 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.
+     */
+    setBags: (pubKey: PublicKey, bags: IBag[]) => Promise<ValStat<number[]>>;
+    /**
+     * Fetch ciphertext bodies for the given host seqs.
+     * Returns only seqs that exist (missing seqs are omitted, not an error).
+     * Empty `seqs` succeeds with [].
+     */
+    getBodies: (pubKey: PublicKey, seqs: number[]) => Promise<ValStat<{
+        seq: number;
+        bodyCph: Uint8Array;
+    }[]>>;
     listHeads: (pubKey: PublicKey, minSeq: number) => Promise<ValStat<IBagPeekItem[]>>;
 }
 export interface KeyPair {
@@ -151,6 +165,8 @@ export interface ITransport {
 }
 export interface IStateManager {
     apply: (msgs: IMessage[]) => Promise<Status[]>;
+    /** Drop local application state (e.g. EntDB) and notify subscribers. */
+    clear: () => Promise<Status>;
     on: (type: string, listener: () => void) => void;
     off: (type: string, listener: () => void) => void;
 }

package/dist/web/state.d.ts

@@ -6,10 +6,12 @@ export declare function isMsgEntBody(bodDec: unknown): bodDec is IMsgEntBody;
 export declare function msgToOp(msg: IMessage): ValStat<IOp>;
 export declare class StateManager implements IStateManager {
     applier: Applier;
-    clear: () => Promise<Status>;
     private emitter;
-    constructor(applier: Applier, clear: () => Promise<Status>);
+    private clearer;
+    constructor(applier: Applier, clearer: () => Promise<Status>);
     apply: (msgs: IMessage[]) => Promise<Status[]>;
+    /** Clear underlying store (e.g. EntDB) and notify all type subscribers. */
+    clear: () => Promise<Status>;
     on: (opType: string, listener: () => void) => void;
     off: (opType: string, listener: () => void) => void;
 }

package/dist/web/sync.d.ts

@@ -2,8 +2,12 @@ import DiplomaticClientAPI from "./shared/client";
 import { IClock } from "./shared/clock";
 import { Status } from "./shared/consts";
 import { Enclave } from "./shared/enclave";
-import { HostHandle, ICrypto } from "./shared/types";
-import { IHostRow, IMsgParts, IStore, IStoredMessageData } from "./types";
+import { Hash, HostHandle, IBag, ICrypto } from "./shared/types";
+import { IDownloadMessage, IHostRow, IMsgParts, IStore, IStoredMessageData } from "./types";
+/** Default soft cap for one push/pull request (~1 MiB). Apps with large
+ * payloads (e.g. media) should raise maxPushBytes / maxPullBytes. */
+export declare const defaultMaxPushBytes: number;
+export declare const defaultMaxPullBytes: number;
 export interface ISyncParams<Handle extends HostHandle> {
     conn: DiplomaticClientAPI<Handle>;
     store: IStore<Handle>;
@@ -11,15 +15,26 @@ export interface ISyncParams<Handle extends HostHandle> {
     clock: IClock;
     host: IHostRow<Handle>;
     crypto: ICrypto;
+    /** Soft max sealed-bag bytes per push request. Oversized bags go alone. */
+    maxPushBytes?: number;
+    /** Soft max body bytes (head.len) per pull request. Oversized items go alone. */
+    maxPullBytes?: number;
 }
+/** 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>;
+/** Pull one batch of download-queue items; store, deq, apply. */
+export declare function pullBatch<Handle extends HostHandle>(conn: Pick<DiplomaticClientAPI<Handle>, "pull">, store: IStore<Handle>, enclave: Enclave, hostLabel: string, crypto: ICrypto, items: IDownloadMessage[], apply: (parts: IMsgParts[], options?: {
+    enqueueUpload: boolean;
+    triggerUpload: boolean;
+}) => Promise<Status[]>): Promise<Status>;
 export declare function syncPeek<Handle extends HostHandle>({ conn, store, enclave, host, crypto }: ISyncParams<Handle>): Promise<Status>;
-export declare function syncPush<Handle extends HostHandle>({ conn, store, host }: ISyncParams<Handle>): Promise<Status>;
-export declare function syncPull<Handle extends HostHandle>({ conn, store, enclave, host, crypto }: ISyncParams<Handle>, apply: (parts: IMsgParts[], options?: {
+export declare function syncPush<Handle extends HostHandle>({ conn, store, host, maxPushBytes }: ISyncParams<Handle>): Promise<Status>;
+export declare function syncPull<Handle extends HostHandle>({ conn, store, enclave, host, crypto, maxPullBytes }: ISyncParams<Handle>, apply: (parts: IMsgParts[], options?: {
     enqueueUpload: boolean;
     triggerUpload: boolean;
 }) => Promise<Status[]>): Promise<Status>;
 export declare function msg2StoredMsgData({ head, body }: IMsgParts): IStoredMessageData;
-export declare function handleNotif<Handle extends HostHandle>(bytes: Uint8Array, { conn, store, enclave, host, crypto, clock }: ISyncParams<Handle>, apply: (parts: IMsgParts[], options?: {
+export declare function handleNotif<Handle extends HostHandle>(bytes: Uint8Array, { conn, store, enclave, host, crypto, clock, maxPullBytes, maxPushBytes, }: ISyncParams<Handle>, apply: (parts: IMsgParts[], options?: {
     enqueueUpload: boolean;
     triggerUpload: boolean;
 }) => Promise<Status[]>, scheduleSync: () => void): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interncom/diplomatic",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "type": "module",
   "description": "Secure sync layer and CLI utilities for DIPLOMATIC",
   "files": [