@interncom/diplomatic 0.3.4 → 0.4.0

package/dist/web/batch.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Split items into request batches by soft byte budget; oversized alone.
+ *
+ * TODO: async generator instead of materializing all batches up front —
+ * minor here, but we should pipeline everything we can for max performance.
+ */
+export declare function batchByBytes<T>(items: T[], sizeOf: (t: T) => number, limit: number): T[][];

package/dist/web/client.d.ts

@@ -19,16 +19,14 @@ export declare class SyncClient<Handle extends HostHandle> implements IClient<Ha
     private onScheduleSync?;
     connections: Map<string, DiplomaticClientAPI<Handle>>;
     /**
-     * Serializes sync so doSync never overlaps, while coalescing stampedes:
-     * concurrent sync() share one in-flight drain and at most one trailing
-     * pass if more sync was requested mid-flight (see CoalesceTail).
+     * Serializes exec so concurrent drainApplyQueue / apply do not interleave
+     * markApplied (each job runs fully, in order).
      */
-    private syncRuns;
+    private applyChain;
     /**
-     * Serializes application of archived msgs so concurrent apply /
-     * drainApplyQueue do not interleave markApplied (each job runs fully, in order).
+     * Coalesces overlapping sync() (one in flight + trailing pass).
      */
-    private applyChain;
+    private syncRuns;
     clientState: IStateEmitter<IDiplomaticClientState>;
     xferState: IStateEmitter<IDiplomaticClientXferState>;
     /**
@@ -45,7 +43,7 @@ export declare class SyncClient<Handle extends HostHandle> implements IClient<Ha
     /** Latest progress; part of xferState for snapshot + subscribe. */
     private lastProgress;
     /**
-     * Debounced sync after local writes (when not handing off via onScheduleSync).
+     * Debounced full sync after local writes (when not handing off via onScheduleSync).
      */
     private scheduledSync;
     constructor(clock: IClock, state: IStateManager, store: IStore<Handle>, transport: (host: IHostConnectionInfo<Handle>) => ITransport, crypto: ICrypto, forceSkewHandlingByDefault?: boolean, maxPushBytes?: number, maxPullBytes?: number, 
@@ -60,13 +58,12 @@ export declare class SyncClient<Handle extends HostHandle> implements IClient<Ha
     private getClientState;
     private getXferState;
     /**
-     * Persist msgs to the archive as unapplied (apld=false), apply via
-     * IStateManager, mark applied, then optionally enqueue upload.
+     * Persist msgs (apld=false), exec into app state, then optionally enq upload.
      *
-     * Order is intentional for crash safety:
-     * 1) durable archive  2) apply + apld=true  3) upload queue
-     * so we never upload something that never applied, and crash between
-     * 1–2 is recovered by drainApplyQueue.
+     * Order (crash-safe):
+     * 1) durable archive  2) exec + apld=true  3) upload queue
+     * Exec is where the app validates the msg; only successes are pushed.
+     * Crash between 1–2 → drainApplyQueue / exec stage recovers.
      */
     private apply;
     private enqueueApplyJob;
@@ -94,10 +91,8 @@ export declare class SyncClient<Handle extends HostHandle> implements IClient<Ha
     delete(eid: EntityID): Promise<ValStat<IMessageHead>>;
     genEID(id?: Uint8Array): Promise<ValStat<EntityID>>;
     /**
-     * Catch up with hosts (peek → push → pull). Safe under concurrent callers:
-     * overlapping sync() calls coalesce onto one shared run, with a trailing
-     * re-run if anyone requested sync while a run was already in flight.
-     * All waiters resolve with the Status of the final pass of that drain.
+     * Catch up: exec pending → per host peek → push → pull‖open → exec.
+     * Overlapping sync() coalesce (+ trailing if demand mid-flight).
      */
     sync(): Promise<Status>;
     private doSync;
@@ -106,8 +101,7 @@ export declare class SyncClient<Handle extends HostHandle> implements IClient<Ha
         onProgress?: (index: number, total: number, status: Status) => void;
     }) => Promise<Status>;
     /**
-     * After local apply + upload enqueue: either hand off to a peer (worker via
-     * onScheduleSync — debounced there) or debounce sync on this client.
+     * After local exec + upload enqueue: hand off to worker peer or debounce sync.
      */
     private scheduleSync;
     /** Encode the local message archive; used by worker path (main saves file). */