@chenlongapps/opencode-token-usage 0.4.8 → 0.4.10

package/dist/performance.js

@@ -1,30 +1,41 @@
 import { normalize } from "./usage.js";
 export const LIVE_WINDOW_MS = 2_000;
+export const LIVE_MIN_SPAN_MS = 500;
+export const LIVE_SAMPLE_MS = 100;
 export const LIVE_EWMA_ALPHA = 0.35;
 export const LIVE_BYTES_PER_TOKEN = 4;
-/** Raw live throughput from one step's recent observable deltas. */
+/** Quiet streams need a server liveness check, not a maximum tool-wait duration. */
+export const ACTIVITY_CHECK_MS = 60_000;
+/** The first batch is a counter baseline, not bytes generated after its timestamp. */
 export function estimatedLiveTps(samples) {
     if (samples.length < 2)
         return undefined;
     const first = samples[0];
     const last = samples[samples.length - 1];
     const duration = last.time - first.time;
-    if (!Number.isFinite(duration) || duration <= 0)
+    if (!Number.isFinite(duration) || duration < LIVE_MIN_SPAN_MS)
         return undefined;
     let bytes = 0;
+    let time = first.time;
     for (const sample of samples) {
-        if (!Number.isFinite(sample.time) || !Number.isFinite(sample.bytes) || sample.bytes < 0)
+        if (!Number.isFinite(sample.time) || sample.time < time || !Number.isFinite(sample.bytes) || sample.bytes < 0)
             return undefined;
-        bytes += sample.bytes;
+        if (sample.time > first.time)
+            bytes += sample.bytes;
+        time = sample.time;
     }
-    if (bytes <= 0)
+    if (!Number.isFinite(bytes) || bytes <= 0)
         return undefined;
     return (bytes / LIVE_BYTES_PER_TOKEN) / (duration / 1_000);
 }
-export function smoothLiveTps(previous, raw) {
+/** Time-based EWMA: elapsed time determines the weight, never delta count. */
+export function smoothLiveTps(previous, raw, elapsed = LIVE_MIN_SPAN_MS) {
     if (previous === undefined || !Number.isFinite(previous))
         return raw;
-    return previous * (1 - LIVE_EWMA_ALPHA) + raw * LIVE_EWMA_ALPHA;
+    if (!Number.isFinite(elapsed) || elapsed <= 0)
+        return previous;
+    const alpha = 1 - (1 - LIVE_EWMA_ALPHA) ** (elapsed / LIVE_MIN_SPAN_MS);
+    return previous * (1 - alpha) + raw * alpha;
 }
 const finite = (value) => typeof value === "number" && Number.isFinite(value);
 function historicalFirst(message) {
@@ -107,17 +118,20 @@ function performanceWithObservations(prepared, observations) {
 }
 /** Captures streaming performance for every session for one plugin lifetime. */
 export class PerformanceMonitor {
-    retention;
-    now;
     active = new Map();
     observed = new Map();
     listeners = new Set();
     cleanupTimer;
+    synchronization;
     disposed = false;
     unsubscribe;
-    constructor(subscribe, retention = 60_000, now = Date.now) {
-        this.retention = retention;
-        this.now = now;
+    retention;
+    monotonic;
+    readActive;
+    constructor(subscribe, options = {}) {
+        this.retention = options.retention ?? 60_000;
+        this.monotonic = options.monotonic ?? (() => performance.now());
+        this.readActive = options.active;
         this.unsubscribe = subscribe?.(event => this.handle(event));
     }
     listen(listener) {
@@ -131,6 +145,7 @@ export class PerformanceMonitor {
             return;
         this.disposed = true;
         this.unsubscribe?.();
+        this.synchronization?.abort();
         clearTimeout(this.cleanupTimer);
         this.cleanupTimer = undefined;
         this.listeners.clear();
@@ -149,19 +164,113 @@ export class PerformanceMonitor {
         for (const [key, sample] of this.observed)
             if (sample.sessionID === sessionID)
                 this.observed.delete(key);
+        this.scheduleCleanup();
+    }
+    resetLive(step) {
+        step.samples = [];
+        delete step.bucketStarted;
+        delete step.observedAt;
+        delete step.liveTps;
+        delete step.liveDuration;
+        delete step.smoothedAt;
+    }
+    touch(step, created) {
+        step.revision++;
+        step.checkedAt = this.monotonic();
+        if (finite(created))
+            step.latest = Math.max(step.latest, created);
+        // A live event wins over an inactive snapshot taken just before it arrived.
+        if (step.inactive) {
+            delete step.finishedAt;
+            delete step.inactive;
+            const sample = this.observed.get(this.key(step.sessionID, step.messageID));
+            if (sample)
+                delete sample.expiresAt;
+        }
+    }
+    finish(step, inactive = false) {
+        if (step.finishedAt !== undefined && (inactive || !step.inactive))
+            return;
+        step.finishedAt ??= this.monotonic();
+        step.inactive = inactive;
+        step.revision++;
+        const key = this.key(step.sessionID, step.messageID);
+        const sample = this.observed.get(key);
+        if (sample)
+            sample.expiresAt = step.finishedAt + this.retention;
+        this.resetLive(step);
+        this.publish(step.sessionID);
+    }
+    /** One shared, history-free read covers offscreen sessions too. Failures are not idle. */
+    async checkActivity(force = false) {
+        if (this.disposed || !this.readActive)
+            return;
+        if (this.synchronization) {
+            if (!force)
+                return;
+            this.synchronization.abort();
+            this.synchronization = undefined;
+        }
+        const now = this.monotonic();
+        const unfinished = [...this.active.values()].filter(step => step.finishedAt === undefined);
+        if (!unfinished.length || (!force && !unfinished.some(step => now - step.checkedAt >= ACTIVITY_CHECK_MS)))
+            return;
+        // The endpoint is process-wide: use each read for every tracked unfinished step,
+        // rather than issuing one request per staggered session deadline.
+        const candidates = new Map(unfinished.map(step => [step, step.revision]));
+        const request = new AbortController();
+        this.synchronization = request;
+        const signal = AbortSignal.any([request.signal, AbortSignal.timeout(5_000)]);
+        let onAbort = () => { };
+        try {
+            // Also bound readers that fail to cooperate with cancellation.
+            const active = await Promise.race([
+                this.readActive(signal),
+                new Promise((_, reject) => {
+                    onAbort = () => reject(signal.reason);
+                    signal.addEventListener("abort", onAbort, { once: true });
+                    if (signal.aborted)
+                        onAbort();
+                }),
+            ]);
+            if (this.disposed || signal.aborted || this.synchronization !== request)
+                return;
+            for (const [step, revision] of candidates) {
+                if (this.active.get(this.key(step.sessionID, step.messageID)) !== step || step.revision !== revision)
+                    continue;
+                if (!active.has(step.sessionID))
+                    this.finish(step, true);
+            }
+        }
+        catch { /* Preserve quiet tools/retries when server activity is unknown. */ }
+        finally {
+            signal.removeEventListener("abort", onAbort);
+            request.abort();
+            if (this.synchronization === request) {
+                this.synchronization = undefined;
+                for (const [step, revision] of candidates) {
+                    if (step.revision === revision)
+                        step.checkedAt = this.monotonic();
+                }
+                this.scheduleCleanup();
+            }
+        }
     }
     prune() {
-        const now = this.now();
+        const monotonic = this.monotonic();
         const changed = new Set();
         for (const [key, step] of this.active) {
-            if ((step.finishedAt ?? step.reconciledAt) !== undefined
-                && (step.finishedAt ?? step.reconciledAt) + this.retention <= now) {
+            if (step.finishedAt !== undefined && step.finishedAt + this.retention <= monotonic) {
                 this.active.delete(key);
                 changed.add(step.sessionID);
             }
+            else if (step.observedAt !== undefined && monotonic - step.observedAt >= LIVE_WINDOW_MS) {
+                this.resetLive(step);
+                changed.add(step.sessionID);
+            }
         }
         for (const [key, sample] of this.observed) {
-            if (sample.expiresAt !== undefined && sample.expiresAt <= now) {
+            if (sample.expiresAt !== undefined && sample.expiresAt <= monotonic) {
                 this.observed.delete(key);
                 changed.add(sample.sessionID);
             }
@@ -170,17 +279,25 @@ export class PerformanceMonitor {
     }
     scheduleCleanup() {
         clearTimeout(this.cleanupTimer);
-        if (this.disposed || !Number.isFinite(this.retention) || this.retention < 0)
+        this.cleanupTimer = undefined;
+        if (this.disposed)
             return;
         let next = Infinity;
+        const monotonic = this.monotonic();
+        const retain = Number.isFinite(this.retention) && this.retention >= 0;
         for (const step of this.active.values()) {
-            const settled = step.finishedAt ?? step.reconciledAt;
-            if (settled !== undefined)
-                next = Math.min(next, settled + this.retention);
+            if (retain && step.finishedAt !== undefined)
+                next = Math.min(next, step.finishedAt + this.retention - monotonic);
+            if (step.finishedAt === undefined && this.readActive && !this.synchronization) {
+                next = Math.min(next, step.checkedAt + ACTIVITY_CHECK_MS - monotonic);
+            }
+            // Local monotonic age, never client epoch minus a remote event timestamp.
+            if (step.observedAt !== undefined)
+                next = Math.min(next, step.observedAt + LIVE_WINDOW_MS - monotonic);
         }
         for (const sample of this.observed.values()) {
-            if (sample.expiresAt !== undefined)
-                next = Math.min(next, sample.expiresAt);
+            if (retain && sample.expiresAt !== undefined)
+                next = Math.min(next, sample.expiresAt - monotonic);
         }
         if (!Number.isFinite(next))
             return;
@@ -188,8 +305,9 @@ export class PerformanceMonitor {
             this.cleanupTimer = undefined;
             for (const sessionID of this.prune())
                 this.publish(sessionID);
+            void this.checkActivity();
             this.scheduleCleanup();
-        }, Math.max(0, next - this.now()));
+        }, Math.max(0, Math.ceil(next)));
         this.cleanupTimer.unref?.();
     }
     handle(event) {
@@ -197,6 +315,16 @@ export class PerformanceMonitor {
             return false;
         for (const sessionID of this.prune())
             this.publish(sessionID);
+        if (event.type === "server.connected") {
+            // Delivery across a connection gap cannot share a throughput window.
+            for (const step of this.active.values()) {
+                this.resetLive(step);
+                this.publish(step.sessionID);
+            }
+            void this.checkActivity(true);
+            this.scheduleCleanup();
+            return false;
+        }
         const data = (event.data && typeof event.data === "object" ? event.data : {});
         const sessionID = typeof data.sessionID === "string" ? data.sessionID : undefined;
         if (event.type === "session.deleted") {
@@ -204,8 +332,30 @@ export class PerformanceMonitor {
                 this.deleteSession(sessionID);
             return false;
         }
+        if (!sessionID)
+            return false;
+        if (["session.execution.succeeded", "session.execution.failed", "session.execution.interrupted", "session.idle"].includes(event.type)
+            || (event.type === "session.status" && data.status?.type === "idle")) {
+            for (const step of this.active.values()) {
+                if (step.sessionID !== sessionID || !finite(event.created) || event.created < step.latest)
+                    continue;
+                step.latest = event.created;
+                this.finish(step);
+            }
+            this.scheduleCleanup();
+            return false;
+        }
+        if (event.type === "session.execution.started"
+            || (event.type === "session.status" && ["busy", "retry"].includes(String(data.status?.type)))) {
+            for (const step of this.active.values()) {
+                if (step.sessionID === sessionID && finite(event.created) && event.created >= step.latest)
+                    this.touch(step, event.created);
+            }
+            this.scheduleCleanup();
+            return false;
+        }
         const messageID = typeof data.assistantMessageID === "string" ? data.assistantMessageID : undefined;
-        if (!sessionID || !messageID)
+        if (!messageID)
             return false;
         const key = this.key(sessionID, messageID);
         if (event.type === "session.step.started") {
@@ -213,29 +363,65 @@ export class PerformanceMonitor {
                 return false;
             if (this.active.has(key))
                 return false;
+            // A session's foreground steps are serial; missing endings must not accumulate
+            // forever just because the same session continues to run later steps.
+            for (const step of this.active.values()) {
+                if (step.sessionID !== sessionID)
+                    continue;
+                if (step.started > data.started)
+                    return false;
+            }
+            for (const step of this.active.values()) {
+                if (step.sessionID !== sessionID)
+                    continue;
+                step.latest = Math.max(step.latest, data.started);
+                this.finish(step);
+            }
             this.active.set(key, {
                 messageID, sessionID, started: data.started, bytes: 0, samples: [], events: new Set(),
+                checkedAt: this.monotonic(), revision: 0, latest: Math.max(data.started, finite(event.created) ? event.created : data.started),
             });
+            this.scheduleCleanup();
             return false;
         }
         const step = this.active.get(key);
         if (!step)
             return false;
+        if (event.type === "session.retry.scheduled" || (event.type.startsWith("session.tool.") && event.type !== "session.tool.input.delta")) {
+            if (!finite(event.created) || event.created < step.latest)
+                return false;
+            if (event.type === "session.retry.scheduled") {
+                delete step.finishedAt;
+                delete step.inactive;
+                delete step.reconciledAt;
+                delete step.streamed;
+                this.resetLive(step);
+                const sample = this.observed.get(key);
+                if (sample)
+                    delete sample.expiresAt;
+            }
+            this.touch(step, event.created);
+            this.scheduleCleanup();
+            return false;
+        }
         if (event.type === "session.step.streamed") {
             if (!finite(event.created) || event.created < step.started)
                 return false;
+            if (step.streamed !== undefined && event.created <= step.streamed)
+                return false;
             step.streamed = event.created;
+            this.touch(step, event.created);
+            this.scheduleCleanup();
             if (step.bytes > 0)
                 this.publish(sessionID);
             return step.bytes > 0;
         }
         if (event.type === "session.step.ended" || event.type === "session.step.failed") {
-            step.finishedAt = this.now();
-            const sample = this.observed.get(key);
-            if (sample)
-                sample.expiresAt = step.finishedAt + this.retention;
-            if (step.reconciledAt !== undefined)
-                this.active.delete(key);
+            if (finite(event.created) && event.created < step.latest)
+                return false;
+            if (finite(event.created))
+                step.latest = event.created;
+            this.finish(step);
             this.scheduleCleanup();
             return false;
         }
@@ -244,10 +430,15 @@ export class PerformanceMonitor {
             return false;
         if (typeof data.delta !== "string" || data.delta.length === 0 || !finite(event.created) || event.created < step.started)
             return false;
+        if (step.last !== undefined && event.created < step.last)
+            return false;
         if (event.id && step.events.has(event.id))
             return false;
+        if (step.finishedAt !== undefined && !step.inactive)
+            return false;
         if (event.id)
             step.events.add(event.id);
+        this.touch(step, event.created);
         if (step.reconciledAt !== undefined) {
             // A later delta means the snapshot did not represent the final stream.
             delete step.reconciledAt;
@@ -258,41 +449,62 @@ export class PerformanceMonitor {
         }
         const sampleBytes = new TextEncoder().encode(data.delta).byteLength;
         step.bytes += sampleBytes;
-        step.samples.push({ time: event.created, bytes: sampleBytes });
+        if (step.last !== undefined && event.created - step.last >= LIVE_WINDOW_MS)
+            this.resetLive(step);
+        const last = step.samples.at(-1);
+        if (last && step.bucketStarted !== undefined && event.created - step.bucketStarted < LIVE_SAMPLE_MS) {
+            // Include a whole delivery burst in one batch, including the initial baseline.
+            last.time = event.created;
+            last.bytes += sampleBytes;
+        }
+        else {
+            step.bucketStarted = event.created;
+            step.samples.push({ time: event.created, bytes: sampleBytes });
+        }
         const cutoff = event.created - LIVE_WINDOW_MS;
         while (step.samples.length > 0 && step.samples[0].time < cutoff)
             step.samples.shift();
-        // Advance smoothing once per accepted delta, independently of summary readers.
         const raw = estimatedLiveTps(step.samples);
-        if (raw !== undefined)
-            step.liveTps = smoothLiveTps(step.liveTps, raw);
+        if (raw === undefined) {
+            delete step.liveTps;
+            delete step.liveDuration;
+            delete step.smoothedAt;
+        }
+        else if (step.smoothedAt === undefined || event.created - step.smoothedAt >= LIVE_SAMPLE_MS) {
+            step.liveTps = smoothLiveTps(step.liveTps, raw, event.created - (step.smoothedAt ?? event.created));
+            step.liveDuration = event.created - step.samples[0].time;
+            step.smoothedAt = event.created;
+        }
+        step.observedAt = this.monotonic();
         step.last = Math.max(step.last ?? event.created, event.created);
         if (step.first === undefined) {
             step.first = event.created;
             this.observed.set(key, { messageID, sessionID, started: step.started, first: event.created });
         }
+        this.scheduleCleanup();
         this.publish(sessionID);
         return true;
     }
     reconcile(messages, sessionIDs) {
         const sessions = new Set(sessionIDs);
-        const represented = new Set();
+        if (this.disposed)
+            return;
+        const represented = new Map();
         for (const message of messages) {
             if (message.type === "assistant" && (message.tokens || message.time?.streamed !== undefined
                 || message.time?.completed !== undefined))
-                represented.add(message.id);
+                represented.set(message.id, message);
         }
-        for (const [key, step] of this.active) {
+        for (const step of this.active.values()) {
             if (sessions.has(step.sessionID) && represented.has(step.messageID)) {
-                if (step.finishedAt !== undefined)
-                    this.active.delete(key);
-                else {
-                    // A snapshot can arrive before step.ended. Retain the step to attach
-                    // the real expiry later, and set a fallback if that event is lost.
-                    step.reconciledAt ??= this.now();
-                    const sample = this.observed.get(key);
-                    if (sample)
-                        sample.expiresAt ??= step.reconciledAt + this.retention;
+                // streamed/tokens describe the provider boundary, not tool settlement.
+                // Only completion or an authoritative inactive session permits expiry;
+                // a stale pre-retry completion cannot settle newer activity.
+                step.reconciledAt ??= this.monotonic();
+                const completed = represented.get(step.messageID)?.time?.completed;
+                if (finite(completed) && completed >= step.latest) {
+                    step.latest = completed;
+                    this.finish(step);
                 }
             }
         }
@@ -310,15 +522,15 @@ export class PerformanceMonitor {
         // completed provider usage still replaces this estimate via reconcile().
         let weighted = 0;
         let durationTotal = 0;
+        const monotonic = this.monotonic();
         for (const step of this.active.values()) {
             if (!sessions.has(step.sessionID) || step.reconciledAt !== undefined)
                 continue;
-            if (step.liveTps === undefined || step.samples.length < 2)
+            if (step.liveTps === undefined || step.observedAt === undefined
+                || monotonic - step.observedAt >= LIVE_WINDOW_MS)
                 continue;
-            const first = step.samples[0];
-            const last = step.samples[step.samples.length - 1];
-            const duration = last.time - first.time;
-            if (!finite(duration) || duration <= 0)
+            const duration = step.liveDuration;
+            if (!finite(duration) || duration < LIVE_MIN_SPAN_MS)
                 continue;
             weighted += step.liveTps * duration;
             durationTotal += duration;

package/dist/prices.generated.d.ts

@@ -1,5 +1,5 @@
 export declare const GENERATED_PRICE_SNAPSHOT: {
-    readonly verified: "2026-10-08";
+    readonly verified: "2026-10-14";
     readonly source: "https://models.dev/api.json";
     readonly entries: readonly [{
         readonly providerID: "ai21";
@@ -1129,6 +1129,17 @@ export declare const GENERATED_PRICE_SNAPSHOT: {
             };
         }];
         readonly released: "2026-09-02";
+    }, {
+        readonly providerID: "google";
+        readonly id: "gemini-4-argon";
+        readonly prices: readonly [{
+            readonly input: 2;
+            readonly output: 10;
+            readonly cache: {
+                readonly read: 0.1;
+            };
+        }];
+        readonly released: "2026-10-13";
     }, {
         readonly providerID: "google";
         readonly id: "gemini-flash-latest";
@@ -1250,6 +1261,17 @@ export declare const GENERATED_PRICE_SNAPSHOT: {
             };
         }];
         readonly released: "2026-09-02";
+    }, {
+        readonly providerID: "meta";
+        readonly id: "muse-wonder-1.0";
+        readonly prices: readonly [{
+            readonly input: 4;
+            readonly output: 20;
+            readonly cache: {
+                readonly read: 0.2;
+            };
+        }];
+        readonly released: "2026-10-12";
     }, {
         readonly providerID: "minimax";
         readonly id: "minimax-m2";

package/dist/prices.generated.js

@@ -1,5 +1,5 @@
 export const GENERATED_PRICE_SNAPSHOT = {
-    verified: "2026-10-08",
+    verified: "2026-10-14",
     source: "https://models.dev/api.json",
     entries: [
         { "providerID": "ai21", "id": "jamba-large", "prices": [{ "input": 2, "output": 8 }], "released": "2025-07-01" },
@@ -106,6 +106,7 @@ export const GENERATED_PRICE_SNAPSHOT = {
         { "providerID": "google", "id": "gemini-3.6-flash", "prices": [{ "input": 0.75, "output": 3.75, "cache": { "read": 0.075 } }], "released": "2026-07-21" },
         { "providerID": "google", "id": "gemini-3.7-flash", "prices": [{ "input": 0.75, "output": 3.75, "cache": { "read": 0.075 } }], "released": "2026-08-13" },
         { "providerID": "google", "id": "gemini-3.8-flash", "prices": [{ "input": 0.75, "output": 3.75, "cache": { "read": 0.075 } }], "released": "2026-09-02" },
+        { "providerID": "google", "id": "gemini-4-argon", "prices": [{ "input": 2, "output": 10, "cache": { "read": 0.1 } }], "released": "2026-10-13" },
         { "providerID": "google", "id": "gemini-flash-latest", "prices": [{ "input": 0.75, "output": 3.75, "cache": { "read": 0.075 } }], "released": "2026-08-13" },
         { "providerID": "google", "id": "gemini-flash-lite-latest", "prices": [{ "input": 0.3, "output": 2.5, "cache": { "read": 0.03 } }], "released": "2026-07-21" },
         { "providerID": "inception", "id": "mercury-2", "prices": [{ "input": 0.25, "output": 0.75, "cache": { "read": 0.025 } }], "released": "2026-02-24" },
@@ -117,6 +118,7 @@ export const GENERATED_PRICE_SNAPSHOT = {
         { "providerID": "meta", "id": "muse-spark-1.2-contributor", "prices": [{ "input": 0.1, "output": 0.2, "cache": { "read": 0.002 } }], "released": "2026-08-05" },
         { "providerID": "meta", "id": "muse-spark-1.3", "prices": [{ "input": 1.25, "output": 4.25, "cache": { "read": 0.15 } }], "released": "2026-09-02" },
         { "providerID": "meta", "id": "muse-spark-1.3-contributor", "prices": [{ "input": 0.1, "output": 0.2, "cache": { "read": 0.002 } }], "released": "2026-09-02" },
+        { "providerID": "meta", "id": "muse-wonder-1.0", "prices": [{ "input": 4, "output": 20, "cache": { "read": 0.2 } }], "released": "2026-10-12" },
         { "providerID": "minimax", "id": "minimax-m2", "prices": [{ "input": 0.3, "output": 1.2 }], "released": "2025-10-27" },
         { "providerID": "minimax", "id": "minimax-m2.1", "prices": [{ "input": 0.3, "output": 1.2, "cache": { "read": 0.03, "write": 0.375 } }], "released": "2025-12-23" },
         { "providerID": "minimax", "id": "minimax-m2.5", "prices": [{ "input": 0.3, "output": 1.2, "cache": { "read": 0.03, "write": 0.375 } }], "released": "2026-02-12" },

package/dist/pricing.d.ts

@@ -14,7 +14,7 @@ export interface OfficialPriceEntry {
 /** Checked-in data: updating prices is explicit, not a network request at
  * startup, during a refresh, or during an npm build. */
 export declare const OFFICIAL_PRICE_SNAPSHOT: {
-    verified: "2026-10-08";
+    verified: "2026-10-14";
     source: "https://models.dev/api.json";
     entries: OfficialPriceEntry[];
 };

package/dist/runtime-monitor.d.ts

@@ -0,0 +1,34 @@
+export interface RuntimeEvent {
+    type: string;
+    data: unknown;
+    created?: number;
+}
+type Subscribe = (listener: (event: RuntimeEvent) => void) => () => void;
+type Listener = (sessionID?: string) => void;
+type Tick = (now: number | undefined) => void;
+/** Shared server-time anchor and display clock; no wall clock, execution log or periodic reads. */
+export declare class RuntimeMonitor {
+    private readonly monotonic;
+    private anchor;
+    private latest;
+    private stopped;
+    private listeners;
+    private ticks;
+    private timer;
+    private synchronization;
+    private disposed;
+    private readonly unsubscribe;
+    constructor(subscribe?: Subscribe, monotonic?: () => number);
+    now(): number | undefined;
+    /** One optional read-only RPC supplies an anchor even when opening a quiet active tool. */
+    synchronize(read: (signal: AbortSignal) => Promise<unknown>): Promise<void>;
+    listen(listener: Listener): () => void;
+    /** Only views actually projecting a live turn keep this single 500ms ticker alive. */
+    tick(listener: Tick): () => void;
+    canEstimate(sessionID: string, messageID: string): boolean;
+    handle(event: RuntimeEvent): void;
+    dispose(): void;
+    private observe;
+    private publish;
+}
+export {};