@interncom/diplomatic 0.3.4 → 0.4.0

package/dist/web/progress.d.ts

@@ -2,7 +2,7 @@
  *
  * Exposed only via `IDiplomaticClientXferState.progress` on `client.xferState`
  * (get + listen / `useClientXferState`). There is no separate progress channel. */
-export type SyncPhase = "peek" | "push" | "pull" | "apply" | "import" | "idle";
+export type SyncPhase = "peek" | "pull" | "open" | "exec" | "push" | "import" | "idle";
 export interface SyncProgressEvent {
     phase: SyncPhase;
     /** Host label when the work is host-scoped. */

package/dist/web/sync.d.ts

@@ -1,19 +1,25 @@
 import DiplomaticClientAPI from "./shared/client";
-import { IClock } from "./shared/clock";
 import { Status } from "./shared/consts";
 import { Enclave } from "./shared/enclave";
 import { Hash, HostHandle, IBag, ICrypto } from "./shared/types";
+import { ValStat } from "./shared/valstat";
 import { ProgressFn } from "./progress";
 import { IDownloadMessage, IHostRow, IMsgParts, IStore, type IStoredMessageWrite } 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;
+/** Pull result held in memory until open (not durable). */
+export type IPulled = {
+    dl: IDownloadMessage;
+    bodyCph?: Uint8Array;
+};
+/** Host connection methods used by sync phases. */
+export type SyncConn<Handle extends HostHandle> = Pick<DiplomaticClientAPI<Handle>, "pull" | "push" | "peek" | "seal" | "keys">;
 export interface ISyncParams<Handle extends HostHandle> {
-    conn: DiplomaticClientAPI<Handle>;
+    conn: SyncConn<Handle>;
     store: IStore<Handle>;
     enclave: Enclave;
-    clock: IClock;
     host: IHostRow<Handle>;
     crypto: ICrypto;
     /** Soft max sealed-bag bytes per push request. Oversized bags go alone. */
@@ -27,19 +33,33 @@ export interface ISyncParams<Handle extends HostHandle> {
 }
 /** 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>;
+/** 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 = {
+    parts: IMsgParts[];
+    hashes: Hash[];
+};
+/**
+ * open: decrypt pulled bodies → msg archive (apld=false), deq downloads.
+ * Bad bags are dequeued and skipped (not retry-able).
+ * Does not exec or push.
+ */
+export declare function openPulled<Handle extends HostHandle>(store: IStore<Handle>, enclave: Enclave, crypto: ICrypto, items: IPulled[]): Promise<ValStat<IOpened>>;
+/** Discover unseen bags and enqueue download work; advance host lastSeq. */
 export declare function syncPeek<Handle extends HostHandle>({ conn, store, enclave, host, crypto, onProgress, peekProgressEvery, }: 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>;
-export declare function syncPull<Handle extends HostHandle>({ conn, store, enclave, host, crypto, maxPullBytes, onProgress, }: ISyncParams<Handle>, apply: (parts: IMsgParts[], options?: {
-    enqueueUpload: boolean;
-    triggerUpload: boolean;
-}) => Promise<Status[]>): Promise<Status>;
+/**
+ * Pull + open for one host, depth-1 pipelined:
+ *   await pull(i); start pull(i+1); open(i); afterOpen? (exec)
+ * Ciphertext only in the in-flight Promise, never IDB.
+ */
+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 handleNotif<Handle extends HostHandle>(bytes: Uint8Array, { conn, store, enclave, host, crypto, clock, maxPullBytes, maxPushBytes, onProgress, peekProgressEvery, }: ISyncParams<Handle>, apply: (parts: IMsgParts[], options?: {
-    enqueueUpload: boolean;
-    triggerUpload: boolean;
-}) => Promise<Status[]>, scheduleSync: () => void): Promise<void>;
+/**
+ * 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>;