@interncom/diplomatic 0.2.5 → 0.2.7

package/dist/web/coalesce.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Coalesce concurrent async work into a single in-flight drain, with one
+ * trailing pass when more work is requested while a pass is running.
+ *
+ * Policy:
+ * - At most one `work()` runs at a time (no overlapping executions).
+ * - Concurrent `run()` callers share one Promise and get the same result.
+ * - If `run()` is called during an in-flight pass, `again` is set so that
+ *   after the current pass finishes we run **one** more pass (trailing edge).
+ *   Further calls during that trailing pass can request yet another, etc.
+ * - N stampeding callers during a pass → 1 current pass + ≤1 trailing pass
+ *   per generation, not N serial full runs.
+ * - Errors from `work()` reject the shared Promise; the runner unlocks so a
+ *   later `run()` can start fresh. A trailing request that only set `again`
+ *   before the failure is not auto-retried unless a new `run()` arrives.
+ */
+export declare class CoalesceTail<T> {
+    private inflight;
+    private again;
+    run(work: () => Promise<T>): Promise<T>;
+    /** Wait for any in-flight drain to finish (does not request a new pass). */
+    flush(): Promise<void>;
+    private drain;
+}