@wowyuarm/dsh-agent-team 0.1.12 → 0.1.13

package/packages/client-agent-team/lib/types/client/scope-coverage.js

@@ -1,64 +0,0 @@
-/**
- * Per-scope coverage of the change versions one surface has already answered.
- *
- * A version is only comparable inside the scope that issued it: the Host
- * answers a workspace scope from the durable ledger position and a presence
- * scope from its process-local wake epoch, which starts low and climbs on every
- * Agent transition. One high-water mark shared by both would therefore let a
- * presence epoch swallow a later, smaller ledger sequence and park the surface
- * on stale data, so coverage and pending versions are kept per scope.
- *
- * One round answers one version per scope. The Host delivers one event to every
- * matching scope, so the first version a round sees in a scope it has not
- * answered yet is that event reaching a second scope, and joins the round
- * already fetching instead of earning a second identical read. A newer version
- * in a scope the round has answered arrived after the round issued its fetch,
- * so it owes one trailing round.
- */
-export class ScopeCoverage {
-    covered = new Map();
-    pending = new Map();
-    /** The scopes the open round has an answer for. */
-    answered = new Set();
-    fetching = false;
-    /** Folds one wake in and answers whether it opens a round. */
-    wake(scope, version) {
-        if (version <= this.coveredOf(scope))
-            return false;
-        if (this.fetching && this.answered.has(scope)) {
-            this.pending.set(scope, Math.max(this.pending.get(scope) ?? 0, version));
-            return false;
-        }
-        this.answered.add(scope);
-        this.covered.set(scope, version);
-        return !this.fetching;
-    }
-    /** Opens a round's fetch window; versions observed from here on are pending. */
-    beginRound() {
-        this.pending.clear();
-        this.fetching = true;
-    }
-    /** Closes a round's fetch window and answers whether a trailing round is owed. */
-    finishRound() {
-        this.fetching = false;
-        this.answered.clear();
-        let owed = false;
-        for (const [scope, version] of this.pending) {
-            if (version <= this.coveredOf(scope))
-                continue;
-            this.covered.set(scope, version);
-            owed = true;
-        }
-        return owed;
-    }
-    /** Drops every observation: a new owner starts with nothing covered. */
-    reset() {
-        this.covered.clear();
-        this.pending.clear();
-        this.answered.clear();
-        this.fetching = false;
-    }
-    coveredOf(scope) {
-        return this.covered.get(scope) ?? 0;
-    }
-}