opencode-tokscope 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/README.md +37 -78
  2. package/dist/tui.js +1766 -326
  3. package/package.json +23 -5
package/dist/tui.js CHANGED
@@ -3,15 +3,572 @@ import {createComponent as _$createComponent5} from "@opentui/solid";
3
3
  import {Plugin} from "@opencode/plugin/tui";
4
4
  import {createSignal as createSignal4} from "solid-js";
5
5
 
6
- // src/page/tokscope.tsx
7
- import {effect as _$effect5} from "@opentui/solid";
8
- import {insertNode as _$insertNode5} from "@opentui/solid";
9
- import {insert as _$insert5} from "@opentui/solid";
10
- import {createComponent as _$createComponent3} from "@opentui/solid";
11
- import {setProp as _$setProp5} from "@opentui/solid";
12
- import {createElement as _$createElement5} from "@opentui/solid";
13
- import {useTerminalDimensions} from "@opentui/solid";
14
- import {createEffect, createMemo as createMemo2, createResource, createSignal, Match, Switch} from "solid-js";
6
+ // src/history/records.ts
7
+ var fieldsOf = function(value) {
8
+ if (typeof value !== "object" || value === null || Array.isArray(value))
9
+ return;
10
+ return value;
11
+ };
12
+ var stringValue = function(value) {
13
+ return typeof value === "string" ? value : undefined;
14
+ };
15
+ var nonEmptyString = function(value) {
16
+ return typeof value === "string" && value.length > 0 ? value : undefined;
17
+ };
18
+ var sessionIDFrom = function(value) {
19
+ return typeof value === "string" && SESSION_ID_PATTERN.test(value) ? value : undefined;
20
+ };
21
+ var finiteNumber = function(value) {
22
+ return typeof value === "number" && Number.isFinite(value) ? value : undefined;
23
+ };
24
+ var nonNegativeNumber = function(value) {
25
+ const parsed = finiteNumber(value);
26
+ return parsed !== undefined && parsed >= 0 ? parsed : undefined;
27
+ };
28
+ var optionalField = function(value, parse) {
29
+ if (value === undefined)
30
+ return { ok: true, value: undefined };
31
+ const parsed = parse(value);
32
+ return parsed === undefined ? { ok: false } : { ok: true, value: parsed };
33
+ };
34
+ var parseRows = function(raw, parse) {
35
+ if (!Array.isArray(raw))
36
+ return;
37
+ const rows = [];
38
+ for (const entry of raw) {
39
+ const row = parse(entry);
40
+ if (row === undefined)
41
+ return;
42
+ rows.push(row);
43
+ }
44
+ return rows;
45
+ };
46
+ var parseSample = function(raw) {
47
+ const source = fieldsOf(raw);
48
+ if (source === undefined)
49
+ return;
50
+ const providerID = nonEmptyString(source.providerID);
51
+ const modelID = nonEmptyString(source.modelID);
52
+ const variant = optionalField(source.variant, stringValue);
53
+ const completedAt = finiteNumber(source.completedAt);
54
+ const rate = nonNegativeNumber(source.rate);
55
+ if (providerID === undefined || modelID === undefined || !variant.ok || completedAt === undefined || rate === undefined) {
56
+ return;
57
+ }
58
+ return { providerID, modelID, variant: variant.value, completedAt, rate };
59
+ };
60
+ var parseUnavailableSample = function(raw) {
61
+ const source = fieldsOf(raw);
62
+ if (source === undefined)
63
+ return;
64
+ const providerID = nonEmptyString(source.providerID);
65
+ const modelID = nonEmptyString(source.modelID);
66
+ const variant = optionalField(source.variant, stringValue);
67
+ const completedAt = finiteNumber(source.completedAt);
68
+ if (providerID === undefined || modelID === undefined || !variant.ok || completedAt === undefined) {
69
+ return;
70
+ }
71
+ return { providerID, modelID, variant: variant.value, completedAt };
72
+ };
73
+ var parseSessionRecord = function(raw) {
74
+ const source = fieldsOf(raw);
75
+ if (source === undefined)
76
+ return;
77
+ const sessionID = sessionIDFrom(source.sessionID);
78
+ const directory = optionalField(source.directory, stringValue);
79
+ const createdAt = finiteNumber(source.createdAt);
80
+ const updatedAt = finiteNumber(source.updatedAt);
81
+ const scannedAtMs = finiteNumber(source.scannedAtMs);
82
+ const signature = stringValue(source.signature);
83
+ const fork = source.fork;
84
+ const complete = source.complete;
85
+ if (sessionID === undefined || !directory.ok || createdAt === undefined || updatedAt === undefined || scannedAtMs === undefined || signature === undefined || typeof fork !== "boolean" || typeof complete !== "boolean") {
86
+ return;
87
+ }
88
+ const samples = parseRows(source.samples, parseSample);
89
+ const unavailable = parseRows(source.unavailable, parseUnavailableSample);
90
+ if (samples === undefined || unavailable === undefined)
91
+ return;
92
+ return {
93
+ sessionID,
94
+ directory: directory.value,
95
+ createdAt,
96
+ updatedAt,
97
+ fork,
98
+ signature,
99
+ scannedAtMs,
100
+ complete,
101
+ samples,
102
+ unavailable
103
+ };
104
+ };
105
+ var parseIndexEntry = function(raw) {
106
+ const source = fieldsOf(raw);
107
+ if (source === undefined)
108
+ return;
109
+ const sessionID = sessionIDFrom(source.sessionID);
110
+ const directory = optionalField(source.directory, stringValue);
111
+ const updatedAt = finiteNumber(source.updatedAt);
112
+ if (sessionID === undefined || !directory.ok || updatedAt === undefined)
113
+ return;
114
+ return { sessionID, directory: directory.value, updatedAt };
115
+ };
116
+ var parseComparisonRow = function(raw) {
117
+ const source = fieldsOf(raw);
118
+ if (source === undefined)
119
+ return;
120
+ const key = nonEmptyString(source.key);
121
+ const providerID = nonEmptyString(source.providerID);
122
+ const modelID = nonEmptyString(source.modelID);
123
+ const calls = nonNegativeNumber(source.calls);
124
+ const unavailable = source.unavailable;
125
+ if (key === undefined || providerID === undefined || modelID === undefined || calls === undefined || typeof unavailable !== "boolean") {
126
+ return;
127
+ }
128
+ let median;
129
+ if (source.median === null)
130
+ median = null;
131
+ else {
132
+ const parsed = finiteNumber(source.median);
133
+ if (parsed === undefined)
134
+ return;
135
+ median = parsed;
136
+ }
137
+ return { key, providerID, modelID, median, calls, unavailable };
138
+ };
139
+ var parseWidgetRow = function(raw) {
140
+ const source = fieldsOf(raw);
141
+ if (source === undefined)
142
+ return;
143
+ const key = nonEmptyString(source.key);
144
+ const providerID = nonEmptyString(source.providerID);
145
+ const modelID = nonEmptyString(source.modelID);
146
+ const median = nonNegativeNumber(source.median);
147
+ const calls = nonNegativeNumber(source.calls);
148
+ if (key === undefined || providerID === undefined || modelID === undefined || median === undefined || calls === undefined) {
149
+ return;
150
+ }
151
+ return { key, providerID, modelID, median, calls };
152
+ };
153
+ function signatureFor(meta) {
154
+ return JSON.stringify([
155
+ meta.id,
156
+ meta.time.created,
157
+ meta.time.updated,
158
+ meta.location?.directory,
159
+ meta.cost,
160
+ meta.tokens,
161
+ meta.fork?.sessionID,
162
+ meta.fork?.boundary
163
+ ]);
164
+ }
165
+ function emptyShard() {
166
+ return {
167
+ schemaVersion: CACHE_SCHEMA_VERSION,
168
+ metricVersion: METRIC_VERSION,
169
+ records: {},
170
+ index: {}
171
+ };
172
+ }
173
+ function parseShard(raw) {
174
+ const source = fieldsOf(raw);
175
+ if (source === undefined)
176
+ return;
177
+ if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
178
+ return;
179
+ if (source.metricVersion !== METRIC_VERSION)
180
+ return;
181
+ const recordsSource = fieldsOf(source.records);
182
+ const indexSource = fieldsOf(source.index);
183
+ if (recordsSource === undefined || indexSource === undefined)
184
+ return;
185
+ const records = {};
186
+ for (const [key, value] of Object.entries(recordsSource)) {
187
+ const record = parseSessionRecord(value);
188
+ if (record === undefined || record.sessionID !== key)
189
+ continue;
190
+ records[key] = record;
191
+ }
192
+ const index = {};
193
+ for (const [key, value] of Object.entries(indexSource)) {
194
+ const entry = parseIndexEntry(value);
195
+ if (entry === undefined || entry.sessionID !== key)
196
+ continue;
197
+ index[key] = entry;
198
+ }
199
+ return { schemaVersion: CACHE_SCHEMA_VERSION, metricVersion: METRIC_VERSION, records, index };
200
+ }
201
+ function parseCoverage(raw) {
202
+ const source = fieldsOf(raw);
203
+ if (source === undefined)
204
+ return;
205
+ if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
206
+ return;
207
+ const directoryFilter = optionalField(source.directoryFilter, stringValue);
208
+ const fullInventoryCompletedAt = optionalField(source.fullInventoryCompletedAt, finiteNumber);
209
+ const recentCatchUpAt = optionalField(source.recentCatchUpAt, finiteNumber);
210
+ if (!directoryFilter.ok || !fullInventoryCompletedAt.ok || !recentCatchUpAt.ok)
211
+ return;
212
+ return {
213
+ schemaVersion: CACHE_SCHEMA_VERSION,
214
+ directoryFilter: directoryFilter.value,
215
+ fullInventoryCompletedAt: fullInventoryCompletedAt.value,
216
+ recentCatchUpAt: recentCatchUpAt.value
217
+ };
218
+ }
219
+ function parseViewSnapshot(raw) {
220
+ const source = fieldsOf(raw);
221
+ if (source === undefined)
222
+ return;
223
+ if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
224
+ return;
225
+ if (source.metricVersion !== METRIC_VERSION)
226
+ return;
227
+ if (!RANGE_FILTERS.includes(source.range))
228
+ return;
229
+ const directoryFilter = optionalField(source.directoryFilter, stringValue);
230
+ const lastCheckedAt = optionalField(source.lastCheckedAt, finiteNumber);
231
+ const savedAtMs = finiteNumber(source.savedAtMs);
232
+ const rows = parseRows(source.rows, parseComparisonRow);
233
+ if (!directoryFilter.ok || !lastCheckedAt.ok || savedAtMs === undefined || rows === undefined)
234
+ return;
235
+ return {
236
+ schemaVersion: CACHE_SCHEMA_VERSION,
237
+ metricVersion: METRIC_VERSION,
238
+ directoryFilter: directoryFilter.value,
239
+ range: source.range,
240
+ rows,
241
+ lastCheckedAt: lastCheckedAt.value,
242
+ savedAtMs
243
+ };
244
+ }
245
+ function parseWidgetSnapshot(raw) {
246
+ const source = fieldsOf(raw);
247
+ if (source === undefined)
248
+ return;
249
+ if (source.schemaVersion !== CACHE_SCHEMA_VERSION)
250
+ return;
251
+ if (source.metricVersion !== METRIC_VERSION)
252
+ return;
253
+ const rows = parseRows(source.rows, parseWidgetRow);
254
+ const savedAtMs = finiteNumber(source.savedAtMs);
255
+ if (rows === undefined || savedAtMs === undefined)
256
+ return;
257
+ return { schemaVersion: CACHE_SCHEMA_VERSION, metricVersion: METRIC_VERSION, rows, savedAtMs };
258
+ }
259
+ function parseTombstones(raw) {
260
+ const source = fieldsOf(raw);
261
+ if (source === undefined)
262
+ return;
263
+ if (!Array.isArray(source.sessionIDs))
264
+ return;
265
+ const sessionIDs = [];
266
+ for (const entry of source.sessionIDs) {
267
+ const sessionID = sessionIDFrom(entry);
268
+ if (sessionID !== undefined)
269
+ sessionIDs.push(sessionID);
270
+ }
271
+ return { sessionIDs };
272
+ }
273
+ function recordFrom(meta, scan, nowMs) {
274
+ return {
275
+ sessionID: meta.id,
276
+ directory: meta.location?.directory,
277
+ createdAt: meta.time.created,
278
+ updatedAt: meta.time.updated,
279
+ fork: meta.fork !== undefined,
280
+ signature: signatureFor(meta),
281
+ scannedAtMs: nowMs,
282
+ complete: true,
283
+ samples: scan.samples,
284
+ unavailable: scan.unavailable
285
+ };
286
+ }
287
+ var CACHE_SCHEMA_VERSION = 1;
288
+ var METRIC_VERSION = 1;
289
+ var SESSION_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
290
+ var RANGE_FILTERS = ["last7", "last30", "last90", "all"];
291
+
292
+ // src/history/durable.ts
293
+ function fnv1a(value) {
294
+ let hash = 2166136261;
295
+ for (let index = 0;index < value.length; index++) {
296
+ hash = Math.imul(hash ^ value.charCodeAt(index), 16777619) >>> 0;
297
+ }
298
+ return hash;
299
+ }
300
+ var shardIndex = function(sessionID) {
301
+ return fnv1a(sessionID) % SHARD_COUNT;
302
+ };
303
+ var shardName = function(index) {
304
+ return `shard:${index}`;
305
+ };
306
+ var shardStorageKey = function(index) {
307
+ return `${SHARD_PREFIX}${index}`;
308
+ };
309
+ var coverageKey = function(directoryFilter) {
310
+ if (directoryFilter === undefined)
311
+ return COVERAGE_ALL_KEY;
312
+ return `${COVERAGE_PREFIX}d${fnv1a(directoryFilter).toString(16).padStart(8, "0")}`;
313
+ };
314
+ var isCoverageKey = function(key) {
315
+ return key === COVERAGE_ALL_KEY || key.startsWith(`${COVERAGE_PREFIX}d`);
316
+ };
317
+ var viewSnapshotKey = function(slot) {
318
+ return `${VIEW_SNAPSHOT_PREFIX}${slot}`;
319
+ };
320
+ var snapshotSlot = function(key) {
321
+ if (!key.startsWith(VIEW_SNAPSHOT_PREFIX))
322
+ return;
323
+ const suffix = key.slice(VIEW_SNAPSHOT_PREFIX.length);
324
+ if (!/^(?:0|[1-9][0-9]*)$/.test(suffix))
325
+ return;
326
+ const slot = Number(suffix);
327
+ return slot < VIEW_SNAPSHOT_LIMIT ? slot : undefined;
328
+ };
329
+ var isSnapshotIndexKey = function(key) {
330
+ return snapshotSlot(key) !== undefined;
331
+ };
332
+ var sameView = function(a, b) {
333
+ return a.directoryFilter === b.directoryFilter && a.range === b.range;
334
+ };
335
+ var replaceDraft = function(draft, value) {
336
+ for (const key of Object.keys(draft))
337
+ delete draft[key];
338
+ Object.assign(draft, value);
339
+ };
340
+ var parseKeyIndex = function(payload, accept) {
341
+ const keys = payload === undefined ? undefined : payload.keys;
342
+ if (!Array.isArray(keys))
343
+ return [];
344
+ const result = [];
345
+ for (const entry of keys) {
346
+ if (typeof entry !== "string" || !accept(entry) || result.includes(entry))
347
+ continue;
348
+ result.push(entry);
349
+ }
350
+ return result;
351
+ };
352
+ var readKeyIndex = function(store, key, accept) {
353
+ return parseKeyIndex(store.read(key), accept);
354
+ };
355
+ var mergeTombstones = function(existing, added) {
356
+ const incoming = new Set(added);
357
+ const merged = existing.filter((sessionID) => !incoming.has(sessionID));
358
+ const seen = new Set;
359
+ for (const sessionID of added) {
360
+ if (seen.has(sessionID))
361
+ continue;
362
+ seen.add(sessionID);
363
+ merged.push(sessionID);
364
+ }
365
+ return merged.slice(-TOMBSTONE_LIMIT);
366
+ };
367
+ function createRepository(store) {
368
+ const readTombstones = () => parseTombstones(store.read(TOMBSTONES_KEY)) ?? { sessionIDs: [] };
369
+ const readSnapshotIndex = () => readKeyIndex(store, SNAPSHOTS_INDEX_KEY, isSnapshotIndexKey);
370
+ const liveSnapshots = (keys) => {
371
+ const live = [];
372
+ for (const key of keys) {
373
+ const slot = snapshotSlot(key);
374
+ if (slot === undefined)
375
+ continue;
376
+ const parsed = parseViewSnapshot(store.read(key));
377
+ if (parsed !== undefined)
378
+ live.push({ key, slot, snapshot: parsed });
379
+ }
380
+ return live;
381
+ };
382
+ return {
383
+ loadAllShards() {
384
+ const shards = new Map;
385
+ for (let index = 0;index < SHARD_COUNT; index++) {
386
+ const shard = parseShard(store.read(shardStorageKey(index)));
387
+ if (shard !== undefined)
388
+ shards.set(shardName(index), shard);
389
+ }
390
+ return shards;
391
+ },
392
+ async putRecords(records2, nowMs) {
393
+ const grouped = new Map;
394
+ for (const record of records2) {
395
+ const index = shardIndex(record.sessionID);
396
+ const group = grouped.get(index);
397
+ if (group === undefined)
398
+ grouped.set(index, [record]);
399
+ else
400
+ group.push(record);
401
+ }
402
+ for (const [index, group] of [...grouped].sort((a, b) => a[0] - b[0])) {
403
+ await store.write(shardStorageKey(index), (draft) => {
404
+ const shard = parseShard(draft) ?? emptyShard();
405
+ for (const record of group) {
406
+ shard.records[record.sessionID] = record;
407
+ shard.index[record.sessionID] = {
408
+ sessionID: record.sessionID,
409
+ directory: record.directory,
410
+ updatedAt: record.updatedAt
411
+ };
412
+ }
413
+ replaceDraft(draft, shard);
414
+ });
415
+ }
416
+ },
417
+ async removeSessions(sessionIDs, nowMs) {
418
+ if (sessionIDs.length === 0)
419
+ return;
420
+ await store.write(TOMBSTONES_KEY, (draft) => replaceDraft(draft, { sessionIDs: mergeTombstones(readTombstones().sessionIDs, sessionIDs) }));
421
+ const grouped = new Map;
422
+ for (const sessionID of sessionIDs) {
423
+ const index = shardIndex(sessionID);
424
+ const group = grouped.get(index);
425
+ if (group === undefined)
426
+ grouped.set(index, [sessionID]);
427
+ else
428
+ group.push(sessionID);
429
+ }
430
+ for (const [index, group] of [...grouped].sort((a, b) => a[0] - b[0])) {
431
+ const key = shardStorageKey(index);
432
+ if (store.read(key) === undefined)
433
+ continue;
434
+ await store.write(key, (draft) => {
435
+ const shard = parseShard(draft) ?? emptyShard();
436
+ for (const sessionID of group) {
437
+ delete shard.records[sessionID];
438
+ delete shard.index[sessionID];
439
+ }
440
+ replaceDraft(draft, shard);
441
+ });
442
+ }
443
+ },
444
+ loadTombstones() {
445
+ return readTombstones();
446
+ },
447
+ async clearTombstones(nowMs) {
448
+ await store.write(TOMBSTONES_KEY, (draft) => replaceDraft(draft, { sessionIDs: [] }));
449
+ },
450
+ readCoverage(directoryFilter) {
451
+ const record = parseCoverage(store.read(coverageKey(directoryFilter)));
452
+ if (record === undefined)
453
+ return;
454
+ return record.directoryFilter === directoryFilter ? record : undefined;
455
+ },
456
+ async writeCoverage(record) {
457
+ const key = coverageKey(record.directoryFilter);
458
+ await store.write(COVERAGE_INDEX_KEY, (draft) => {
459
+ const indexed = parseKeyIndex(draft, isCoverageKey);
460
+ replaceDraft(draft, { keys: indexed.includes(key) ? indexed : [...indexed, key] });
461
+ });
462
+ await store.write(key, (draft) => replaceDraft(draft, record));
463
+ },
464
+ readViewSnapshot(directoryFilter, range) {
465
+ const index = readSnapshotIndex();
466
+ for (let position = index.length - 1;position >= 0; position--) {
467
+ const snapshot = parseViewSnapshot(store.read(index[position]));
468
+ if (snapshot === undefined)
469
+ continue;
470
+ if (snapshot.directoryFilter === directoryFilter && snapshot.range === range)
471
+ return snapshot;
472
+ }
473
+ return;
474
+ },
475
+ async writeViewSnapshot(snapshot) {
476
+ const live = liveSnapshots(readSnapshotIndex());
477
+ const updated = live.filter((entry) => sameView(entry.snapshot, snapshot)).at(-1);
478
+ const kept = live.filter((entry) => !sameView(entry.snapshot, snapshot));
479
+ let slot;
480
+ if (updated !== undefined) {
481
+ slot = updated.slot;
482
+ } else {
483
+ const used = new Set(kept.map((entry) => entry.slot));
484
+ const free = Array.from({ length: VIEW_SNAPSHOT_LIMIT }, (_, candidate) => candidate).find((candidate) => !used.has(candidate));
485
+ if (free !== undefined) {
486
+ slot = free;
487
+ } else {
488
+ slot = kept[0].slot;
489
+ kept.shift();
490
+ }
491
+ }
492
+ const key = viewSnapshotKey(slot);
493
+ await store.write(key, (draft) => replaceDraft(draft, snapshot));
494
+ await store.write(SNAPSHOTS_INDEX_KEY, (draft) => {
495
+ const current = liveSnapshots(parseKeyIndex(draft, isSnapshotIndexKey)).filter((entry) => entry.key !== key && !sameView(entry.snapshot, snapshot)).map((entry) => entry.key);
496
+ replaceDraft(draft, { keys: [...current, key].slice(-VIEW_SNAPSHOT_LIMIT) });
497
+ });
498
+ },
499
+ readWidgetSnapshot() {
500
+ return parseWidgetSnapshot(store.read(WIDGET_SNAPSHOT_KEY));
501
+ },
502
+ async writeWidgetSnapshot(rows, nowMs) {
503
+ const snapshot = {
504
+ schemaVersion: CACHE_SCHEMA_VERSION,
505
+ metricVersion: METRIC_VERSION,
506
+ rows,
507
+ savedAtMs: nowMs
508
+ };
509
+ await store.write(WIDGET_SNAPSHOT_KEY, (draft) => replaceDraft(draft, snapshot));
510
+ },
511
+ async clear() {
512
+ const keys = [
513
+ ...Array.from({ length: SHARD_COUNT }, (_, index) => shardStorageKey(index)),
514
+ TOMBSTONES_KEY,
515
+ COVERAGE_INDEX_KEY,
516
+ ...readKeyIndex(store, COVERAGE_INDEX_KEY, isCoverageKey),
517
+ SNAPSHOTS_INDEX_KEY,
518
+ ...Array.from({ length: VIEW_SNAPSHOT_LIMIT }, (_, slot) => viewSnapshotKey(slot)),
519
+ WIDGET_SNAPSHOT_KEY
520
+ ];
521
+ for (const key of keys) {
522
+ if (store.read(key) === undefined)
523
+ continue;
524
+ await store.write(key, (draft) => replaceDraft(draft, {}));
525
+ }
526
+ }
527
+ };
528
+ }
529
+ var SHARD_COUNT = 64;
530
+ var TOMBSTONE_LIMIT = 1000;
531
+ var VIEW_SNAPSHOT_LIMIT = 8;
532
+ var SHARD_PREFIX = "tks.shard.";
533
+ var COVERAGE_PREFIX = "tks.coverage.";
534
+ var COVERAGE_ALL_KEY = "tks.coverage.all";
535
+ var COVERAGE_INDEX_KEY = "tks.coverage-index";
536
+ var TOMBSTONES_KEY = "tks.tombstones";
537
+ var SNAPSHOTS_INDEX_KEY = "tks.snapshots";
538
+ var VIEW_SNAPSHOT_PREFIX = "tks.snapshot.view.";
539
+ var WIDGET_SNAPSHOT_KEY = "tks.snapshot.widget24h";
540
+
541
+ // src/history/plugin-storage.ts
542
+ import {unwrap} from "solid-js/store";
543
+ function createPluginDurableStore(storage) {
544
+ const entries = new Map;
545
+ const entryOf = (key) => {
546
+ const existing = entries.get(key);
547
+ if (existing !== undefined)
548
+ return existing;
549
+ const [store2, update] = storage.store(`${KEY_PREFIX}${key}`, {
550
+ initial: {}
551
+ });
552
+ const entry = {
553
+ read: () => unwrap(store2),
554
+ write: (mutation) => update(mutation)
555
+ };
556
+ entries.set(key, entry);
557
+ return entry;
558
+ };
559
+ return {
560
+ read(key) {
561
+ return entryOf(key).read();
562
+ },
563
+ write(key, mutate) {
564
+ return entryOf(key).write(mutate);
565
+ }
566
+ };
567
+ }
568
+ var KEY_PREFIX = "history.";
569
+
570
+ // src/history/service.ts
571
+ import {createSignal} from "solid-js";
15
572
 
16
573
  // src/filters.ts
17
574
  function rangeStartMs(range, nowMs) {
@@ -29,22 +586,6 @@ function rangeStartMs(range, nowMs) {
29
586
  var DEFAULT_FILTERS = { scope: "all", range: "last30", reasoning: "all" };
30
587
  var DAY_MS = 86400000;
31
588
 
32
- // src/format.ts
33
- function formatRate(median) {
34
- return `${median.toFixed(1)} tok/s`;
35
- }
36
- function formatDayLabel(date) {
37
- const [year, month, day] = date.split("-").map(Number);
38
- return new Intl.DateTimeFormat("en-US", { month: "short", day: "numeric" }).format(new Date(year, month - 1, day));
39
- }
40
- function formatCoverage(measured, unavailable) {
41
- return unavailable > 0 ? `${measured} measured calls; ${unavailable} unavailable` : `${measured} measured calls`;
42
- }
43
- function modelDisplayName(models, providerID, modelID) {
44
- const match = models?.find((model) => model.id === modelID && model.providerID === providerID);
45
- return match?.name ?? `${providerID}/${modelID}`;
46
- }
47
-
48
589
  // src/metric.ts
49
590
  function classifyAssistant(message) {
50
591
  if (message.error !== undefined)
@@ -85,8 +626,10 @@ function classifyAssistant(message) {
85
626
  }
86
627
 
87
628
  // src/harvest.ts
88
- async function collectMeasurements(client, options = {}) {
629
+ async function listSessions(client, options) {
89
630
  const sessions = [];
631
+ const fromMs = options.fromMs;
632
+ const seenCursors = new Set;
90
633
  let sessionCursor;
91
634
  do {
92
635
  const page = await client.session.list(sessionCursor === undefined ? {
@@ -95,168 +638,1068 @@ async function collectMeasurements(client, options = {}) {
95
638
  ...options.directory === undefined ? {} : { directory: options.directory }
96
639
  } : { limit: SESSION_PAGE_SIZE, cursor: sessionCursor });
97
640
  sessions.push(...page.data);
641
+ const stalePage = fromMs !== undefined && page.data.length > 0 && page.data.every((session) => session.time.updated < fromMs);
642
+ if (stalePage)
643
+ return { sessions, boundaryReached: true };
98
644
  sessionCursor = page.cursor.next ?? undefined;
645
+ if (sessionCursor !== undefined) {
646
+ if (seenCursors.has(sessionCursor))
647
+ throw new Error("repeated cursor");
648
+ seenCursors.add(sessionCursor);
649
+ }
99
650
  } while (sessionCursor !== undefined);
100
- const inRange = sessions.filter((session) => (options.fromMs === undefined || session.time.updated >= options.fromMs) && (options.directory === undefined || session.location?.directory === undefined || session.location.directory === options.directory));
651
+ return { sessions, boundaryReached: true };
652
+ }
653
+ function inRangeSamples(result, fromMs) {
654
+ if (fromMs === undefined)
655
+ return result;
656
+ return {
657
+ samples: result.samples.filter((sample) => sample.completedAt >= fromMs),
658
+ unavailable: result.unavailable.filter((sample) => sample.completedAt >= fromMs)
659
+ };
660
+ }
661
+ function collectVariants(samples, unavailable) {
662
+ const variantSet = new Set;
663
+ for (const sample of samples)
664
+ if (sample.variant !== undefined)
665
+ variantSet.add(sample.variant);
666
+ for (const sample of unavailable)
667
+ if (sample.variant !== undefined)
668
+ variantSet.add(sample.variant);
669
+ return [...variantSet].sort();
670
+ }
671
+ async function scanMessages(client, session) {
101
672
  const samples = [];
102
673
  const unavailable = [];
103
- const inRangeAt = (completedAt) => options.fromMs === undefined || completedAt >= options.fromMs;
104
- let scanned = 0;
105
- let nextSession = 0;
106
- const concurrency = Math.max(1, Math.min(options.concurrency ?? DEFAULT_CONCURRENCY, inRange.length));
107
- const worker = async () => {
108
- while (true) {
109
- const index = nextSession++;
110
- if (index >= inRange.length)
674
+ const seenCursors = new Set;
675
+ let messageCursor;
676
+ do {
677
+ const page = await client.message.list(messageCursor === undefined ? { sessionID: session.id, limit: MESSAGE_PAGE_SIZE, order: "desc", type: "assistant" } : { sessionID: session.id, limit: MESSAGE_PAGE_SIZE, type: "assistant", cursor: messageCursor });
678
+ for (const message of page.data) {
679
+ if (message.type !== "assistant")
680
+ continue;
681
+ if (session.fork !== undefined && message.time.created < session.time.created)
682
+ continue;
683
+ const result = classifyAssistant(message);
684
+ if (result.kind === "measured")
685
+ samples.push(result.sample);
686
+ else if (result.kind === "unavailable")
687
+ unavailable.push(result.sample);
688
+ }
689
+ messageCursor = page.cursor.next ?? undefined;
690
+ if (messageCursor !== undefined) {
691
+ if (seenCursors.has(messageCursor))
692
+ throw new Error("repeated cursor");
693
+ seenCursors.add(messageCursor);
694
+ }
695
+ } while (messageCursor !== undefined);
696
+ return { samples, unavailable };
697
+ }
698
+ var SESSION_PAGE_SIZE = 100;
699
+ var MESSAGE_PAGE_SIZE = 200;
700
+
701
+ // src/stats.ts
702
+ function median(values) {
703
+ if (values.length === 0)
704
+ return null;
705
+ const sorted = [...values].sort((a, b) => a - b);
706
+ const middle = Math.floor(sorted.length / 2);
707
+ if (sorted.length % 2 === 1)
708
+ return sorted[middle];
709
+ return (sorted[middle - 1] + sorted[middle]) / 2;
710
+ }
711
+ function applyReasoningFilter(samples, unavailable, filter) {
712
+ if (filter === "all")
713
+ return { samples, unavailable };
714
+ const matches = (variant) => filter === "unknown" ? variant === undefined : variant === filter;
715
+ return {
716
+ samples: samples.filter((sample) => matches(sample.variant)),
717
+ unavailable: unavailable.filter((sample) => matches(sample.variant))
718
+ };
719
+ }
720
+ function rowKey(providerID, modelID) {
721
+ return `${providerID}/${modelID}`;
722
+ }
723
+ function comparisonRows(samples, unavailable) {
724
+ const groups = new Map;
725
+ const ensure = (providerID, modelID) => {
726
+ const key = rowKey(providerID, modelID);
727
+ let group = groups.get(key);
728
+ if (group === undefined) {
729
+ group = { providerID, modelID, rates: [], unavailable: 0 };
730
+ groups.set(key, group);
731
+ }
732
+ return group;
733
+ };
734
+ for (const sample of samples)
735
+ ensure(sample.providerID, sample.modelID).rates.push(sample.rate);
736
+ for (const sample of unavailable)
737
+ ensure(sample.providerID, sample.modelID).unavailable++;
738
+ const rows = [...groups].map(([key, group]) => {
739
+ const measured = group.rates.length > 0;
740
+ return {
741
+ key,
742
+ providerID: group.providerID,
743
+ modelID: group.modelID,
744
+ median: measured ? median(group.rates) : null,
745
+ calls: group.rates.length,
746
+ unavailable: !measured && group.unavailable > 0
747
+ };
748
+ });
749
+ return rows.sort((a, b) => {
750
+ const unavailableOrder = Number(a.unavailable) - Number(b.unavailable);
751
+ if (unavailableOrder !== 0)
752
+ return unavailableOrder;
753
+ const medianOrder = (b.median ?? Number.NEGATIVE_INFINITY) - (a.median ?? Number.NEGATIVE_INFINITY);
754
+ if (medianOrder !== 0)
755
+ return medianOrder;
756
+ if (b.calls !== a.calls)
757
+ return b.calls - a.calls;
758
+ return a.key.localeCompare(b.key);
759
+ });
760
+ }
761
+ var dayStart = function(epochMs) {
762
+ const date = new Date(epochMs);
763
+ return new Date(date.getFullYear(), date.getMonth(), date.getDate());
764
+ };
765
+ function localDayKey(epochMs) {
766
+ const date = new Date(epochMs);
767
+ const month = String(date.getMonth() + 1).padStart(2, "0");
768
+ const day = String(date.getDate()).padStart(2, "0");
769
+ return `${date.getFullYear()}-${month}-${day}`;
770
+ }
771
+ function dailySeries(samples, key, fromMs, nowMs) {
772
+ const matching = samples.filter((sample) => rowKey(sample.providerID, sample.modelID) === key);
773
+ const startMs = fromMs ?? (matching.length > 0 ? Math.min(...matching.map((sample) => sample.completedAt)) : nowMs);
774
+ const byDay = new Map;
775
+ for (const sample of matching) {
776
+ const day = localDayKey(sample.completedAt);
777
+ const rates = byDay.get(day);
778
+ if (rates === undefined)
779
+ byDay.set(day, [sample.rate]);
780
+ else
781
+ rates.push(sample.rate);
782
+ }
783
+ const points = [];
784
+ const end = dayStart(nowMs);
785
+ for (const cursor = dayStart(startMs);cursor.getTime() <= end.getTime(); cursor.setDate(cursor.getDate() + 1)) {
786
+ const date = localDayKey(cursor.getTime());
787
+ const rates = byDay.get(date);
788
+ points.push({
789
+ date,
790
+ median: rates === undefined ? null : median(rates),
791
+ calls: rates?.length ?? 0
792
+ });
793
+ }
794
+ return points;
795
+ }
796
+ function windowRange(length, selected, size) {
797
+ const span = Math.max(0, Math.min(size, length));
798
+ if (span === 0)
799
+ return { start: 0, end: 0 };
800
+ const clamped = Math.max(0, Math.min(selected, length - 1));
801
+ const start = Math.max(0, Math.min(clamped - Math.floor(span / 2), length - span));
802
+ return { start, end: start + span };
803
+ }
804
+ function dayWindow(series, selected, width) {
805
+ return windowRange(series.length, selected, width);
806
+ }
807
+ function barLevels(series, rows) {
808
+ const max = Math.max(0, ...series.map((point) => point.median ?? 0));
809
+ return series.map((point) => {
810
+ if (point.median === null || max <= 0)
811
+ return null;
812
+ return Math.max(1, Math.round(point.median / max * rows));
813
+ });
814
+ }
815
+
816
+ // src/sidebar/rank.ts
817
+ function widgetRows(samples, nowMs) {
818
+ const since = nowMs - WIDGET_WINDOW_MS;
819
+ const groups = new Map;
820
+ for (const sample of samples) {
821
+ if (sample.completedAt <= since || sample.completedAt > nowMs)
822
+ continue;
823
+ const key = rowKey(sample.providerID, sample.modelID);
824
+ let group = groups.get(key);
825
+ if (group === undefined) {
826
+ group = { providerID: sample.providerID, modelID: sample.modelID, rates: [] };
827
+ groups.set(key, group);
828
+ }
829
+ group.rates.push(sample.rate);
830
+ }
831
+ const rows = [];
832
+ for (const [key, group] of groups) {
833
+ if (group.rates.length < WIDGET_MIN_CALLS)
834
+ continue;
835
+ const value = median(group.rates);
836
+ if (value === null)
837
+ continue;
838
+ rows.push({
839
+ key,
840
+ providerID: group.providerID,
841
+ modelID: group.modelID,
842
+ median: value,
843
+ calls: group.rates.length
844
+ });
845
+ }
846
+ rows.sort((a, b) => {
847
+ const medianOrder = b.median - a.median;
848
+ if (medianOrder !== 0)
849
+ return medianOrder;
850
+ if (b.calls !== a.calls)
851
+ return b.calls - a.calls;
852
+ return a.key.localeCompare(b.key);
853
+ });
854
+ return rows.slice(0, WIDGET_MAX_ENTRIES);
855
+ }
856
+ var WIDGET_WINDOW_MS = 86400000;
857
+ var WIDGET_MIN_CALLS = 3;
858
+ var WIDGET_MAX_ENTRIES = 3;
859
+
860
+ // src/history/service.ts
861
+ var matchesScope = function(sessionDirectory, directoryFilter) {
862
+ if (directoryFilter === undefined)
863
+ return true;
864
+ return sessionDirectory === undefined || sessionDirectory === directoryFilter;
865
+ };
866
+ var isNotFound = function(error) {
867
+ if (typeof error !== "object" || error === null)
868
+ return false;
869
+ const fields = error;
870
+ if (fields.status === 404 || fields.statusCode === 404)
871
+ return true;
872
+ if (fields.cause?.status === 404)
873
+ return true;
874
+ return typeof fields.message === "string" && /(?:^|\D)404(?:\D|$)/.test(fields.message);
875
+ };
876
+ function createHistoryService(deps) {
877
+ const client = deps.client;
878
+ const now = deps.now;
879
+ const concurrency = Math.max(1, deps.concurrency ?? 8);
880
+ const records3 = new Map;
881
+ const index = new Map;
882
+ const tombstones = new Set;
883
+ const coverage = new Map;
884
+ const views = new Map;
885
+ const passes = new Map;
886
+ const statuses = new Map;
887
+ const work = new Map;
888
+ const dirty = new Set;
889
+ const scanTokens = new Map;
890
+ let holds = 0;
891
+ let timerCancel;
892
+ let auditCancel;
893
+ let burstCancel;
894
+ let burstStartedAt;
895
+ let flushInFlight;
896
+ let resetGeneration = 0;
897
+ let pendingRecords = [];
898
+ let persistence = "ok";
899
+ let widgetPublished = false;
900
+ let hydrated = false;
901
+ const storedWidget = deps.repository.readWidgetSnapshot();
902
+ const [widgetState, setWidgetState] = createSignal(storedWidget === undefined ? { status: "loading", rows: [], stale: false } : { status: "ready", rows: storedWidget.rows, stale: true });
903
+ if (storedWidget !== undefined)
904
+ widgetPublished = true;
905
+ rememberTombstones();
906
+ function rememberTombstones() {
907
+ for (const sessionID of deps.repository.loadTombstones().sessionIDs)
908
+ tombstones.add(sessionID);
909
+ }
910
+ function hydrateShards() {
911
+ if (hydrated)
912
+ return;
913
+ hydrated = true;
914
+ for (const shard of deps.repository.loadAllShards().values()) {
915
+ for (const entry of Object.values(shard.index)) {
916
+ if (!tombstones.has(entry.sessionID))
917
+ index.set(entry.sessionID, entry);
918
+ }
919
+ for (const record of Object.values(shard.records)) {
920
+ if (!tombstones.has(record.sessionID))
921
+ records3.set(record.sessionID, record);
922
+ }
923
+ }
924
+ }
925
+ function forgetSession(sessionID) {
926
+ records3.delete(sessionID);
927
+ index.delete(sessionID);
928
+ dirty.delete(sessionID);
929
+ pendingRecords = pendingRecords.filter((record) => record.sessionID !== sessionID);
930
+ }
931
+ function workOf(sessionID) {
932
+ const existing = work.get(sessionID);
933
+ if (existing !== undefined)
934
+ return existing;
935
+ const fresh = { revision: 0, covered: 0, inFlight: false, pending: false, followUp: false };
936
+ work.set(sessionID, fresh);
937
+ return fresh;
938
+ }
939
+ function scanTokenOf(sessionID) {
940
+ return scanTokens.get(sessionID) ?? 0;
941
+ }
942
+ function coverageFor(directory) {
943
+ const key = directoryKeyOf(directory);
944
+ const cached = coverage.get(key);
945
+ if (cached !== undefined)
946
+ return cached;
947
+ const stored = deps.repository.readCoverage(directory);
948
+ if (stored !== undefined)
949
+ coverage.set(key, stored);
950
+ return stored;
951
+ }
952
+ function statusFor(directory) {
953
+ const key = directoryKeyOf(directory);
954
+ let status = statuses.get(key);
955
+ if (status === undefined) {
956
+ status = { refreshing: false, failed: false, publishedAt: undefined, publishCancel: undefined };
957
+ statuses.set(key, status);
958
+ }
959
+ return status;
960
+ }
961
+ function viewsOf(directory) {
962
+ const matching = [];
963
+ for (const entry of views.values()) {
964
+ if (entry.request.directory === directory)
965
+ matching.push(entry);
966
+ }
967
+ return matching;
968
+ }
969
+ function requestedDirectories() {
970
+ const directories = [];
971
+ for (const entry of views.values()) {
972
+ if (!directories.some((directory) => directory === entry.request.directory)) {
973
+ directories.push(entry.request.directory);
974
+ }
975
+ }
976
+ if (directories.length === 0 && holds > 0)
977
+ directories.push(undefined);
978
+ return directories;
979
+ }
980
+ function affectedDirectories(sessionDirectory) {
981
+ return requestedDirectories().filter((directory) => matchesScope(sessionDirectory, directory));
982
+ }
983
+ function countIndex(directory) {
984
+ let count = 0;
985
+ for (const entry of index.values())
986
+ if (matchesScope(entry.directory, directory))
987
+ count += 1;
988
+ return count;
989
+ }
990
+ function liveView(request) {
991
+ const fromMs = rangeStartMs(request.range, now());
992
+ const samples = [];
993
+ const unavailable = [];
994
+ for (const entry of index.values()) {
995
+ if (!matchesScope(entry.directory, request.directory))
996
+ continue;
997
+ if (fromMs !== undefined && entry.updatedAt < fromMs)
998
+ continue;
999
+ const record = records3.get(entry.sessionID);
1000
+ if (record === undefined)
1001
+ continue;
1002
+ const inRange = inRangeSamples(record, fromMs);
1003
+ samples.push(...inRange.samples);
1004
+ unavailable.push(...inRange.unavailable);
1005
+ }
1006
+ return { samples, unavailable };
1007
+ }
1008
+ function buildState(request, kind, lastCheckedAt, refreshing, refreshFailed) {
1009
+ const data = liveView(request);
1010
+ const hasData = data.samples.length > 0 || data.unavailable.length > 0;
1011
+ return {
1012
+ kind: kind === "partial" && !hasData ? "loading" : kind,
1013
+ samples: data.samples,
1014
+ unavailable: data.unavailable,
1015
+ variants: collectVariants(data.samples, data.unavailable),
1016
+ scanned: countIndex(request.directory),
1017
+ lastCheckedAt,
1018
+ refreshing,
1019
+ refreshFailed,
1020
+ persistence
1021
+ };
1022
+ }
1023
+ function publishViews(directory, mode) {
1024
+ const status = statusFor(directory);
1025
+ for (const entry of viewsOf(directory)) {
1026
+ const kind = mode === "ready" ? "ready" : mode === "failure" ? "error" : "partial";
1027
+ entry.publish(buildState(entry.request, kind, entry.lastCheckedAt, mode !== "ready", mode === "failure" || status.failed));
1028
+ }
1029
+ if (mode === "failure")
1030
+ publishWidgetFailure();
1031
+ else
1032
+ publishWidget(mode === "ready");
1033
+ }
1034
+ function publishWidget(persist) {
1035
+ const nowMs = now();
1036
+ const rows = widgetRows(allSamples(), nowMs);
1037
+ widgetPublished = true;
1038
+ setWidgetState({ status: "ready", rows, stale: false });
1039
+ if (persist)
1040
+ persistWidget(rows, nowMs);
1041
+ }
1042
+ function publishWidgetFailure() {
1043
+ const current = widgetState();
1044
+ setWidgetState(widgetPublished ? { status: "ready", rows: current.rows, stale: true } : { status: "error", rows: [], stale: false });
1045
+ }
1046
+ async function persistWidget(rows, nowMs) {
1047
+ try {
1048
+ await deps.repository.writeWidgetSnapshot(rows, nowMs);
1049
+ } catch {
1050
+ persistence = "unavailable";
1051
+ }
1052
+ }
1053
+ function allSamples() {
1054
+ const samples = [];
1055
+ for (const record of records3.values())
1056
+ samples.push(...record.samples);
1057
+ return samples;
1058
+ }
1059
+ async function flushRecords() {
1060
+ if (pendingRecords.length === 0)
1061
+ return;
1062
+ const generation = resetGeneration;
1063
+ const batch = pendingRecords;
1064
+ pendingRecords = [];
1065
+ const flush = (async () => {
1066
+ try {
1067
+ await deps.repository.putRecords(batch, now());
1068
+ persistence = "ok";
1069
+ } catch {
1070
+ if (generation === resetGeneration)
1071
+ pendingRecords = [...batch, ...pendingRecords];
1072
+ persistence = "unavailable";
1073
+ }
1074
+ })();
1075
+ flushInFlight = flush;
1076
+ try {
1077
+ await flush;
1078
+ } finally {
1079
+ if (flushInFlight === flush)
1080
+ flushInFlight = undefined;
1081
+ }
1082
+ }
1083
+ async function readMeta(sessionID) {
1084
+ const get = client.session.get;
1085
+ if (get === undefined)
1086
+ return;
1087
+ try {
1088
+ return await get.call(client.session, { sessionID });
1089
+ } catch {
1090
+ return;
1091
+ }
1092
+ }
1093
+ async function scanSession(meta) {
1094
+ if (tombstones.has(meta.id)) {
1095
+ forgetSession(meta.id);
1096
+ return { meta: undefined, requeue: false, discarded: true };
1097
+ }
1098
+ const state = workOf(meta.id);
1099
+ if (state.inFlight) {
1100
+ state.followUp = true;
1101
+ return;
1102
+ }
1103
+ state.inFlight = true;
1104
+ const revision = state.revision;
1105
+ const generation = resetGeneration;
1106
+ const token = scanTokenOf(meta.id);
1107
+ const current = () => generation === resetGeneration && scanTokenOf(meta.id) === token;
1108
+ try {
1109
+ const fresh = await readMeta(meta.id) ?? meta;
1110
+ if (!current())
1111
+ return { meta: undefined, requeue: false, discarded: true };
1112
+ const scan = await scanMessages(client, fresh);
1113
+ if (!current())
1114
+ return { meta: undefined, requeue: false, discarded: true };
1115
+ const after = await readMeta(meta.id) ?? fresh;
1116
+ if (!current())
1117
+ return { meta: undefined, requeue: false, discarded: true };
1118
+ if (tombstones.has(fresh.id)) {
1119
+ forgetSession(fresh.id);
1120
+ return { meta: after, requeue: false, discarded: true };
1121
+ }
1122
+ const record = recordFrom(fresh, scan, now());
1123
+ records3.set(record.sessionID, record);
1124
+ index.set(record.sessionID, {
1125
+ sessionID: record.sessionID,
1126
+ directory: record.directory,
1127
+ updatedAt: record.updatedAt
1128
+ });
1129
+ pendingRecords.push(record);
1130
+ return { meta: after, requeue: signatureFor(after) !== signatureFor(fresh), discarded: false };
1131
+ } finally {
1132
+ state.inFlight = false;
1133
+ state.covered = Math.max(state.covered, revision);
1134
+ if (state.followUp || state.revision > state.covered) {
1135
+ state.followUp = false;
1136
+ scheduleSessionScan(meta.id);
1137
+ }
1138
+ }
1139
+ }
1140
+ function cancelPublish(directory) {
1141
+ const status = statuses.get(directoryKeyOf(directory));
1142
+ if (status?.publishCancel === undefined)
1143
+ return;
1144
+ status.publishCancel();
1145
+ status.publishCancel = undefined;
1146
+ }
1147
+ function cancelPublications() {
1148
+ for (const status of statuses.values()) {
1149
+ if (status.publishCancel === undefined)
1150
+ continue;
1151
+ status.publishCancel();
1152
+ status.publishCancel = undefined;
1153
+ }
1154
+ }
1155
+ function schedulePublish(directory) {
1156
+ const status = statusFor(directory);
1157
+ if (status.publishCancel !== undefined)
1158
+ return;
1159
+ const elapsed = now() - (status.publishedAt ?? now());
1160
+ status.publishCancel = deps.delay(() => {
1161
+ status.publishCancel = undefined;
1162
+ publishDeferred(directory);
1163
+ }, Math.max(0, PUBLISH_INTERVAL_MS - elapsed));
1164
+ }
1165
+ async function publishDeferred(directory) {
1166
+ try {
1167
+ await flushRecords();
1168
+ publishViews(directory, "progress");
1169
+ statusFor(directory).publishedAt = now();
1170
+ } catch {
1171
+ }
1172
+ }
1173
+ async function publishProgress(directory) {
1174
+ const status = statusFor(directory);
1175
+ if (status.publishedAt !== undefined && now() - status.publishedAt < PUBLISH_INTERVAL_MS) {
1176
+ schedulePublish(directory);
1177
+ return;
1178
+ }
1179
+ await flushRecords();
1180
+ publishViews(directory, "progress");
1181
+ status.publishedAt = now();
1182
+ }
1183
+ async function drain(directory, items, onRequeue) {
1184
+ let cursor = 0;
1185
+ let abandoned = false;
1186
+ const worker = async () => {
1187
+ for (;; ) {
1188
+ if (holds === 0) {
1189
+ abandoned = true;
1190
+ return;
1191
+ }
1192
+ const position = cursor;
1193
+ cursor += 1;
1194
+ if (position >= items.length)
1195
+ return;
1196
+ const outcome = await scanSession(items[position]);
1197
+ if (outcome?.requeue === true && outcome.meta !== undefined)
1198
+ onRequeue(outcome.meta);
1199
+ await publishProgress(directory);
1200
+ }
1201
+ };
1202
+ const workers = Math.min(concurrency, Math.max(1, items.length));
1203
+ await Promise.all(Array.from({ length: workers }, () => worker()));
1204
+ return abandoned;
1205
+ }
1206
+ async function commitCoverage(directory, startedAt, inventory, previous) {
1207
+ const next = {
1208
+ schemaVersion: CACHE_SCHEMA_VERSION,
1209
+ directoryFilter: directory,
1210
+ fullInventoryCompletedAt: inventory ? startedAt : previous?.fullInventoryCompletedAt,
1211
+ recentCatchUpAt: startedAt
1212
+ };
1213
+ try {
1214
+ await deps.repository.writeCoverage(next);
1215
+ coverage.set(directoryKeyOf(directory), next);
1216
+ } catch {
1217
+ persistence = "unavailable";
1218
+ }
1219
+ }
1220
+ async function publishReady(directory) {
1221
+ cancelPublish(directory);
1222
+ await flushRecords();
1223
+ const checkedAt = now();
1224
+ for (const entry of viewsOf(directory)) {
1225
+ const data = liveView(entry.request);
1226
+ entry.lastCheckedAt = checkedAt;
1227
+ const snapshot = {
1228
+ schemaVersion: CACHE_SCHEMA_VERSION,
1229
+ metricVersion: METRIC_VERSION,
1230
+ directoryFilter: entry.request.directory,
1231
+ range: entry.request.range,
1232
+ rows: comparisonRows(data.samples, data.unavailable),
1233
+ lastCheckedAt: checkedAt,
1234
+ savedAtMs: checkedAt
1235
+ };
1236
+ try {
1237
+ await deps.repository.writeViewSnapshot(snapshot);
1238
+ } catch {
1239
+ persistence = "unavailable";
1240
+ }
1241
+ }
1242
+ statusFor(directory).publishedAt = checkedAt;
1243
+ publishViews(directory, "ready");
1244
+ }
1245
+ async function probeSession(sessionID) {
1246
+ const get = client.session.get;
1247
+ if (get === undefined)
1248
+ return "unknown";
1249
+ try {
1250
+ await get.call(client.session, { sessionID });
1251
+ return "present";
1252
+ } catch (error) {
1253
+ return isNotFound(error) ? "missing" : "unknown";
1254
+ }
1255
+ }
1256
+ async function verifyInventory(listed, known) {
1257
+ if (client.session.get === undefined)
1258
+ return;
1259
+ const tombstoned = [...tombstones];
1260
+ let removed = false;
1261
+ let verified = true;
1262
+ for (const sessionID of known) {
1263
+ if (listed.has(sessionID) || tombstones.has(sessionID))
1264
+ continue;
1265
+ const state = await probeSession(sessionID);
1266
+ if (state === "missing") {
1267
+ await deleteSession(sessionID);
1268
+ removed = true;
1269
+ } else if (state === "unknown") {
1270
+ verified = false;
1271
+ }
1272
+ }
1273
+ if (removed || !verified)
1274
+ return;
1275
+ for (const sessionID of tombstoned) {
1276
+ if (await probeSession(sessionID) !== "missing") {
1277
+ verified = false;
1278
+ break;
1279
+ }
1280
+ }
1281
+ if (!verified || tombstoned.length === 0)
1282
+ return;
1283
+ try {
1284
+ await deps.repository.clearTombstones(now());
1285
+ tombstones.clear();
1286
+ } catch {
1287
+ persistence = "unavailable";
1288
+ }
1289
+ }
1290
+ async function deleteSession(sessionID) {
1291
+ scanTokens.set(sessionID, scanTokenOf(sessionID) + 1);
1292
+ tombstones.add(sessionID);
1293
+ const directory = records3.get(sessionID)?.directory ?? index.get(sessionID)?.directory;
1294
+ forgetSession(sessionID);
1295
+ try {
1296
+ await deps.repository.removeSessions([sessionID], now());
1297
+ } catch {
1298
+ persistence = "unavailable";
1299
+ }
1300
+ await publishSessionWork([directory], "settled");
1301
+ }
1302
+ function unsettled() {
1303
+ for (const state of work.values()) {
1304
+ if (state.inFlight || state.pending || state.followUp || state.revision > state.covered)
1305
+ return true;
1306
+ }
1307
+ return false;
1308
+ }
1309
+ async function publishSessionWork(sessionDirectories, mode) {
1310
+ const targets = new Set;
1311
+ for (const sessionDirectory of sessionDirectories) {
1312
+ for (const directory of affectedDirectories(sessionDirectory))
1313
+ targets.add(directory);
1314
+ }
1315
+ if (targets.size === 0) {
1316
+ await flushRecords();
1317
+ publishWidget(false);
1318
+ return;
1319
+ }
1320
+ for (const directory of targets) {
1321
+ if (mode === "settled" && !statusFor(directory).refreshing && !unsettled()) {
1322
+ await publishReady(directory);
1323
+ } else {
1324
+ await publishProgress(directory);
1325
+ }
1326
+ }
1327
+ }
1328
+ function publishSessionFailure(sessionDirectory) {
1329
+ const targets = affectedDirectories(sessionDirectory);
1330
+ if (targets.length === 0) {
1331
+ publishWidgetFailure();
1332
+ return;
1333
+ }
1334
+ for (const directory of targets) {
1335
+ const status = statusFor(directory);
1336
+ status.refreshing = true;
1337
+ status.failed = true;
1338
+ publishViews(directory, "failure");
1339
+ }
1340
+ }
1341
+ async function scanOne(sessionID) {
1342
+ const meta = await readMeta(sessionID);
1343
+ if (meta === undefined)
1344
+ return { scanned: false, directory: undefined };
1345
+ const directory = meta.location?.directory;
1346
+ if (tombstones.has(sessionID)) {
1347
+ forgetSession(sessionID);
1348
+ return { scanned: false, directory };
1349
+ }
1350
+ try {
1351
+ await scanSession(meta);
1352
+ return { scanned: true, directory };
1353
+ } catch {
1354
+ publishSessionFailure(directory);
1355
+ return { scanned: false, directory };
1356
+ }
1357
+ }
1358
+ function scheduleSessionScan(sessionID) {
1359
+ const state = workOf(sessionID);
1360
+ if (state.pending || state.inFlight) {
1361
+ if (state.revision > state.covered)
1362
+ state.followUp = true;
1363
+ return;
1364
+ }
1365
+ if (state.revision <= state.covered)
1366
+ return;
1367
+ state.pending = true;
1368
+ Promise.resolve().then(async () => {
1369
+ state.pending = false;
1370
+ const result = await scanOne(sessionID);
1371
+ if (!result.scanned)
1372
+ return;
1373
+ await publishSessionWork([result.directory], "progress");
1374
+ }).catch(() => {
1375
+ }).finally(() => {
1376
+ state.pending = false;
1377
+ });
1378
+ }
1379
+ function scheduleDirtyFlush() {
1380
+ if (holds === 0 || dirty.size === 0)
1381
+ return;
1382
+ const at = now();
1383
+ if (burstStartedAt === undefined)
1384
+ burstStartedAt = at;
1385
+ burstCancel?.();
1386
+ burstCancel = undefined;
1387
+ const remaining = Math.max(0, burstStartedAt + MAX_SCHEDULE_DELAY_MS - at);
1388
+ burstCancel = deps.delay(() => {
1389
+ burstCancel = undefined;
1390
+ flushDirty();
1391
+ }, Math.min(DIRTY_DEBOUNCE_MS, remaining));
1392
+ }
1393
+ function flushDirty() {
1394
+ burstStartedAt = undefined;
1395
+ if (holds === 0)
1396
+ return;
1397
+ const sessions = [...dirty];
1398
+ dirty.clear();
1399
+ for (const sessionID of sessions) {
1400
+ const state = workOf(sessionID);
1401
+ state.revision += 1;
1402
+ scheduleSessionScan(sessionID);
1403
+ }
1404
+ }
1405
+ function markDirty(sessionID) {
1406
+ if (tombstones.has(sessionID))
1407
+ return;
1408
+ dirty.add(sessionID);
1409
+ scheduleDirtyFlush();
1410
+ }
1411
+ function auditCandidates() {
1412
+ return [...index.values()].filter((entry) => !tombstones.has(entry.sessionID)).map((entry) => ({ entry, scannedAt: records3.get(entry.sessionID)?.scannedAtMs ?? 0 })).sort((left, right) => left.scannedAt - right.scannedAt || left.entry.sessionID.localeCompare(right.entry.sessionID)).slice(0, AUDIT_BATCH_SESSIONS).map((candidate) => candidate.entry.sessionID);
1413
+ }
1414
+ async function runAudit() {
1415
+ if (holds === 0)
1416
+ return;
1417
+ const directories = [];
1418
+ for (const sessionID of auditCandidates()) {
1419
+ if (holds === 0)
1420
+ break;
1421
+ const result = await scanOne(sessionID);
1422
+ if (result.scanned)
1423
+ directories.push(result.directory);
1424
+ }
1425
+ if (directories.length > 0)
1426
+ await publishSessionWork(directories, "settled");
1427
+ }
1428
+ async function runPass(directory) {
1429
+ hydrateShards();
1430
+ const status = statusFor(directory);
1431
+ status.refreshing = true;
1432
+ const startedAt = now();
1433
+ const generation = resetGeneration;
1434
+ const previous = coverageFor(directory);
1435
+ const inventory = previous?.fullInventoryCompletedAt === undefined || startedAt - previous.fullInventoryCompletedAt > INVENTORY_MIN_INTERVAL_MS;
1436
+ try {
1437
+ const listing = await listSessions(client, inventory || previous?.recentCatchUpAt === undefined ? { directory } : { directory, fromMs: previous.recentCatchUpAt });
1438
+ if (generation !== resetGeneration) {
1439
+ status.refreshing = true;
1440
+ return;
1441
+ }
1442
+ rememberTombstones();
1443
+ const known = [];
1444
+ if (inventory) {
1445
+ for (const entry of index.values()) {
1446
+ if (tombstones.has(entry.sessionID))
1447
+ continue;
1448
+ if (!matchesScope(entry.directory, directory))
1449
+ continue;
1450
+ known.push(entry.sessionID);
1451
+ }
1452
+ }
1453
+ const listed = new Set;
1454
+ const queue = [];
1455
+ for (const meta of listing.sessions) {
1456
+ listed.add(meta.id);
1457
+ if (tombstones.has(meta.id)) {
1458
+ forgetSession(meta.id);
1459
+ continue;
1460
+ }
1461
+ const existing = records3.get(meta.id);
1462
+ if (existing !== undefined && existing.signature === signatureFor(meta))
1463
+ continue;
1464
+ queue.push(meta);
1465
+ }
1466
+ if (inventory)
1467
+ await verifyInventory(listed, known);
1468
+ const requeue = [];
1469
+ const abandoned = await drain(directory, queue, (meta) => {
1470
+ if (!requeue.some((item) => item.id === meta.id))
1471
+ requeue.push(meta);
1472
+ });
1473
+ if (abandoned) {
1474
+ cancelPublish(directory);
1475
+ return;
1476
+ }
1477
+ const abandonedAgain = await drain(directory, requeue, () => {
1478
+ });
1479
+ if (abandonedAgain) {
1480
+ cancelPublish(directory);
1481
+ return;
1482
+ }
1483
+ if (generation !== resetGeneration) {
1484
+ status.refreshing = true;
1485
+ return;
1486
+ }
1487
+ await flushRecords();
1488
+ if (generation !== resetGeneration) {
1489
+ status.refreshing = true;
1490
+ return;
1491
+ }
1492
+ await commitCoverage(directory, startedAt, inventory, previous);
1493
+ if (generation !== resetGeneration) {
1494
+ status.refreshing = true;
1495
+ return;
1496
+ }
1497
+ status.refreshing = false;
1498
+ status.failed = false;
1499
+ await publishReady(directory);
1500
+ } catch {
1501
+ if (generation !== resetGeneration) {
1502
+ status.refreshing = true;
1503
+ return;
1504
+ }
1505
+ status.refreshing = true;
1506
+ status.failed = true;
1507
+ cancelPublish(directory);
1508
+ publishViews(directory, "failure");
1509
+ }
1510
+ }
1511
+ function ensurePass(directory) {
1512
+ const key = directoryKeyOf(directory);
1513
+ const slot = passes.get(key);
1514
+ if (slot?.inFlight === true) {
1515
+ slot.queued = true;
1516
+ return;
1517
+ }
1518
+ const next = { inFlight: true, queued: false };
1519
+ passes.set(key, next);
1520
+ runPass(directory).finally(() => {
1521
+ next.inFlight = false;
1522
+ if (next.queued) {
1523
+ next.queued = false;
1524
+ ensurePass(directory);
1525
+ }
1526
+ });
1527
+ }
1528
+ function schedulePass(directory) {
1529
+ if (holds === 0)
1530
+ return;
1531
+ Promise.resolve().then(() => {
1532
+ if (holds === 0 || !requestedDirectories().some((requested) => requested === directory))
1533
+ return;
1534
+ ensurePass(directory);
1535
+ });
1536
+ }
1537
+ function startTimers() {
1538
+ if (timerCancel !== undefined)
1539
+ return;
1540
+ timerCancel = deps.setTimer(() => {
1541
+ if (holds === 0)
111
1542
  return;
112
- const session = inRange[index];
113
- let messageCursor;
114
- do {
115
- const page = await client.message.list(messageCursor === undefined ? { sessionID: session.id, limit: MESSAGE_PAGE_SIZE, order: "desc", type: "assistant" } : { sessionID: session.id, limit: MESSAGE_PAGE_SIZE, type: "assistant", cursor: messageCursor });
116
- for (const message of page.data) {
117
- if (message.type !== "assistant")
118
- continue;
119
- if (session.fork !== undefined && message.time.created < session.time.created)
120
- continue;
121
- const result = classifyAssistant(message);
122
- if (result.kind === "measured" && inRangeAt(result.sample.completedAt))
123
- samples.push(result.sample);
124
- else if (result.kind === "unavailable" && inRangeAt(result.sample.completedAt))
125
- unavailable.push(result.sample);
126
- }
127
- messageCursor = page.cursor.next ?? undefined;
128
- } while (messageCursor !== undefined);
129
- scanned++;
130
- options.onProgress?.({ sessionsScanned: scanned });
1543
+ for (const directory of requestedDirectories())
1544
+ ensurePass(directory);
1545
+ }, RECENT_CATCHUP_MS);
1546
+ auditCancel = deps.setTimer(() => {
1547
+ runAudit().catch(() => {
1548
+ });
1549
+ }, AUDIT_INTERVAL_MS);
1550
+ scheduleDirtyFlush();
1551
+ for (const directory of requestedDirectories())
1552
+ schedulePass(directory);
1553
+ }
1554
+ function stopTimers() {
1555
+ cancelPublications();
1556
+ burstCancel?.();
1557
+ burstCancel = undefined;
1558
+ burstStartedAt = undefined;
1559
+ if (auditCancel !== undefined) {
1560
+ auditCancel();
1561
+ auditCancel = undefined;
131
1562
  }
132
- };
133
- await Promise.all(Array.from({ length: concurrency }, worker));
134
- const variantSet = new Set;
135
- for (const sample of samples)
136
- if (sample.variant !== undefined)
137
- variantSet.add(sample.variant);
138
- for (const sample of unavailable)
139
- if (sample.variant !== undefined)
140
- variantSet.add(sample.variant);
141
- return { samples, unavailable, variants: [...variantSet].sort() };
142
- }
143
- var SESSION_PAGE_SIZE = 100;
144
- var MESSAGE_PAGE_SIZE = 200;
145
- var DEFAULT_CONCURRENCY = 8;
146
-
147
- // src/stats.ts
148
- function median(values) {
149
- if (values.length === 0)
150
- return null;
151
- const sorted = [...values].sort((a, b) => a - b);
152
- const middle = Math.floor(sorted.length / 2);
153
- if (sorted.length % 2 === 1)
154
- return sorted[middle];
155
- return (sorted[middle - 1] + sorted[middle]) / 2;
156
- }
157
- function applyReasoningFilter(samples, unavailable, filter) {
158
- if (filter === "all")
159
- return { samples, unavailable };
160
- const matches = (variant) => filter === "unknown" ? variant === undefined : variant === filter;
161
- return {
162
- samples: samples.filter((sample) => matches(sample.variant)),
163
- unavailable: unavailable.filter((sample) => matches(sample.variant))
164
- };
165
- }
166
- function rowKey(providerID, modelID) {
167
- return `${providerID}/${modelID}`;
168
- }
169
- function comparisonRows(samples, unavailable) {
170
- const groups = new Map;
171
- const ensure = (providerID, modelID) => {
172
- const key = rowKey(providerID, modelID);
173
- let group = groups.get(key);
174
- if (group === undefined) {
175
- group = { providerID, modelID, rates: [], unavailable: 0 };
176
- groups.set(key, group);
1563
+ if (timerCancel !== undefined) {
1564
+ timerCancel();
1565
+ timerCancel = undefined;
177
1566
  }
178
- return group;
179
- };
180
- for (const sample of samples)
181
- ensure(sample.providerID, sample.modelID).rates.push(sample.rate);
182
- for (const sample of unavailable)
183
- ensure(sample.providerID, sample.modelID).unavailable++;
184
- const rows = [...groups].map(([key, group]) => {
185
- const measured = group.rates.length > 0;
186
- return {
187
- key,
188
- providerID: group.providerID,
189
- modelID: group.modelID,
190
- median: measured ? median(group.rates) : null,
191
- calls: group.rates.length,
192
- unavailable: !measured && group.unavailable > 0
1567
+ }
1568
+ function view(request) {
1569
+ const key = viewKeyOf(request);
1570
+ const existing = views.get(key);
1571
+ if (existing !== undefined)
1572
+ return existing.accessor;
1573
+ const snapshot = deps.repository.readViewSnapshot(request.directory, request.range);
1574
+ const lastCheckedAt = snapshot?.lastCheckedAt;
1575
+ hydrateShards();
1576
+ const [state, setState] = createSignal(buildState(request, snapshot === undefined ? "loading" : "cached", lastCheckedAt, true, false));
1577
+ views.set(key, { request, accessor: state, publish: setState, lastCheckedAt });
1578
+ schedulePass(request.directory);
1579
+ return state;
1580
+ }
1581
+ function hold() {
1582
+ holds += 1;
1583
+ if (holds === 1)
1584
+ startTimers();
1585
+ let released = false;
1586
+ return () => {
1587
+ if (released)
1588
+ return;
1589
+ released = true;
1590
+ holds -= 1;
1591
+ if (holds === 0)
1592
+ stopTimers();
193
1593
  };
194
- });
195
- return rows.sort((a, b) => {
196
- const unavailableOrder = Number(a.unavailable) - Number(b.unavailable);
197
- if (unavailableOrder !== 0)
198
- return unavailableOrder;
199
- const medianOrder = (b.median ?? Number.NEGATIVE_INFINITY) - (a.median ?? Number.NEGATIVE_INFINITY);
200
- if (medianOrder !== 0)
201
- return medianOrder;
202
- if (b.calls !== a.calls)
203
- return b.calls - a.calls;
204
- return a.key.localeCompare(b.key);
205
- });
206
- }
207
- var dayStart = function(epochMs) {
208
- const date = new Date(epochMs);
209
- return new Date(date.getFullYear(), date.getMonth(), date.getDate());
210
- };
211
- function localDayKey(epochMs) {
212
- const date = new Date(epochMs);
213
- const month = String(date.getMonth() + 1).padStart(2, "0");
214
- const day = String(date.getDate()).padStart(2, "0");
215
- return `${date.getFullYear()}-${month}-${day}`;
216
- }
217
- function dailySeries(samples, key, fromMs, nowMs) {
218
- const matching = samples.filter((sample) => rowKey(sample.providerID, sample.modelID) === key);
219
- const startMs = fromMs ?? (matching.length > 0 ? Math.min(...matching.map((sample) => sample.completedAt)) : nowMs);
220
- const byDay = new Map;
221
- for (const sample of matching) {
222
- const day = localDayKey(sample.completedAt);
223
- const rates = byDay.get(day);
224
- if (rates === undefined)
225
- byDay.set(day, [sample.rate]);
226
- else
227
- rates.push(sample.rate);
228
1594
  }
229
- const points = [];
230
- const end = dayStart(nowMs);
231
- for (const cursor = dayStart(startMs);cursor.getTime() <= end.getTime(); cursor.setDate(cursor.getDate() + 1)) {
232
- const date = localDayKey(cursor.getTime());
233
- const rates = byDay.get(date);
234
- points.push({
235
- date,
236
- median: rates === undefined ? null : median(rates),
237
- calls: rates?.length ?? 0
1595
+ function refreshNow() {
1596
+ for (const directory of requestedDirectories())
1597
+ ensurePass(directory);
1598
+ }
1599
+ async function reset() {
1600
+ resetGeneration += 1;
1601
+ cancelPublications();
1602
+ burstCancel?.();
1603
+ burstCancel = undefined;
1604
+ burstStartedAt = undefined;
1605
+ dirty.clear();
1606
+ records3.clear();
1607
+ index.clear();
1608
+ tombstones.clear();
1609
+ coverage.clear();
1610
+ pendingRecords = [];
1611
+ widgetPublished = false;
1612
+ setWidgetState({ status: "loading", rows: [], stale: false });
1613
+ for (const status of statuses.values()) {
1614
+ status.refreshing = true;
1615
+ status.failed = false;
1616
+ status.publishedAt = undefined;
1617
+ }
1618
+ for (const entry of views.values()) {
1619
+ entry.lastCheckedAt = undefined;
1620
+ entry.publish(buildState(entry.request, "loading", undefined, true, false));
1621
+ }
1622
+ try {
1623
+ await flushInFlight;
1624
+ await deps.repository.clear();
1625
+ } catch {
1626
+ persistence = "unavailable";
1627
+ }
1628
+ for (const directory of requestedDirectories())
1629
+ ensurePass(directory);
1630
+ }
1631
+ function subscribeToEvents() {
1632
+ deps.subscribeEvents((event) => {
1633
+ const sessionID = event.data?.sessionID;
1634
+ if (typeof sessionID !== "string" || sessionID.length === 0)
1635
+ return;
1636
+ if (event.type === DELETED_EVENT_TYPE) {
1637
+ deleteSession(sessionID).catch(() => {
1638
+ });
1639
+ return;
1640
+ }
1641
+ if (!DIRTY_EVENT_TYPES.has(event.type))
1642
+ return;
1643
+ markDirty(sessionID);
238
1644
  });
239
1645
  }
240
- return points;
1646
+ subscribeToEvents();
1647
+ return { view, widget: () => widgetState, hold, refreshNow, reset };
241
1648
  }
242
- function windowRange(length, selected, size) {
243
- const span = Math.max(0, Math.min(size, length));
244
- if (span === 0)
245
- return { start: 0, end: 0 };
246
- const clamped = Math.max(0, Math.min(selected, length - 1));
247
- const start = Math.max(0, Math.min(clamped - Math.floor(span / 2), length - span));
248
- return { start, end: start + span };
1649
+ var DIRTY_DEBOUNCE_MS = 250;
1650
+ var MAX_SCHEDULE_DELAY_MS = 1000;
1651
+ var PUBLISH_INTERVAL_MS = 250;
1652
+ var RECENT_CATCHUP_MS = 60000;
1653
+ var INVENTORY_MIN_INTERVAL_MS = 600000;
1654
+ var AUDIT_INTERVAL_MS = 60000;
1655
+ var AUDIT_BATCH_SESSIONS = 20;
1656
+ var DIRTY_EVENT_TYPES = new Set([
1657
+ "session.step.ended",
1658
+ "session.step.failed",
1659
+ "session.execution.succeeded",
1660
+ "session.execution.failed",
1661
+ "session.execution.interrupted",
1662
+ "session.created",
1663
+ "session.forked",
1664
+ "session.moved",
1665
+ "session.revert.staged",
1666
+ "session.revert.committed",
1667
+ "session.compaction.ended",
1668
+ "session.compaction.failed",
1669
+ "session.usage.recorded"
1670
+ ]);
1671
+ var DELETED_EVENT_TYPE = "session.deleted";
1672
+ var viewKeyOf = (request) => JSON.stringify([request.directory, request.range]);
1673
+ var directoryKeyOf = (directory) => JSON.stringify(directory ?? null);
1674
+
1675
+ // src/page/tokscope.tsx
1676
+ import {effect as _$effect5} from "@opentui/solid";
1677
+ import {insertNode as _$insertNode5} from "@opentui/solid";
1678
+ import {insert as _$insert5} from "@opentui/solid";
1679
+ import {createComponent as _$createComponent3} from "@opentui/solid";
1680
+ import {setProp as _$setProp5} from "@opentui/solid";
1681
+ import {createElement as _$createElement5} from "@opentui/solid";
1682
+ import {useTerminalDimensions} from "@opentui/solid";
1683
+ import {createEffect, createMemo as createMemo2, createSignal as createSignal2, Match, Show as Show3, Switch} from "solid-js";
1684
+
1685
+ // src/format.ts
1686
+ function formatRate(median2) {
1687
+ return `${median2.toFixed(1)} tok/s`;
249
1688
  }
250
- function dayWindow(series, selected, width) {
251
- return windowRange(series.length, selected, width);
1689
+ function formatDayLabel(date) {
1690
+ const [year, month, day] = date.split("-").map(Number);
1691
+ return new Intl.DateTimeFormat("en-US", { month: "short", day: "numeric" }).format(new Date(year, month - 1, day));
252
1692
  }
253
- function barLevels(series, rows) {
254
- const max = Math.max(0, ...series.map((point) => point.median ?? 0));
255
- return series.map((point) => {
256
- if (point.median === null || max <= 0)
257
- return null;
258
- return Math.max(1, Math.round(point.median / max * rows));
259
- });
1693
+ function formatCoverage(measured, unavailable) {
1694
+ return unavailable > 0 ? `${measured} measured calls; ${unavailable} unavailable` : `${measured} measured calls`;
1695
+ }
1696
+ function formatHm(ms) {
1697
+ const date = new Date(ms);
1698
+ return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
1699
+ }
1700
+ function modelDisplayName(models, providerID, modelID) {
1701
+ const match = models?.find((model) => model.id === modelID && model.providerID === providerID);
1702
+ return match?.name ?? `${providerID}/${modelID}`;
260
1703
  }
261
1704
 
262
1705
  // src/page/header.tsx
@@ -319,6 +1762,48 @@ function Header(props) {
319
1762
  })();
320
1763
  }
321
1764
 
1765
+ // src/page/heading-status.ts
1766
+ var withPersistence = function(message, view) {
1767
+ return view.persistence === "unavailable" ? message + NOT_SAVED_SUFFIX : message;
1768
+ };
1769
+ var hasData = function(view) {
1770
+ return view.samples.length > 0 || view.unavailable.length > 0;
1771
+ };
1772
+ function partialMessage(view) {
1773
+ return withPersistence("History loading \u2014 results incomplete", view);
1774
+ }
1775
+ function cachedMessage(view) {
1776
+ const base = view.lastCheckedAt === undefined ? "Cached \xB7 refreshing\u2026" : `Cached \xB7 last checked ${formatHm(view.lastCheckedAt)} \xB7 refreshing\u2026`;
1777
+ return withPersistence(base, view);
1778
+ }
1779
+ function refreshFailedMessage(view) {
1780
+ return withPersistence("Refresh failed \u2014 showing cached results", view);
1781
+ }
1782
+ function bannerMessage(view) {
1783
+ switch (view.kind) {
1784
+ case "partial":
1785
+ return partialMessage(view);
1786
+ case "cached":
1787
+ return cachedMessage(view);
1788
+ case "error":
1789
+ return hasData(view) ? refreshFailedMessage(view) : undefined;
1790
+ default:
1791
+ return;
1792
+ }
1793
+ }
1794
+ function footerStatusSuffix(view) {
1795
+ switch (view.kind) {
1796
+ case "ready":
1797
+ return view.lastCheckedAt === undefined ? SHARED_CACHE_SUFFIX : ` \xB7 checked ${formatHm(view.lastCheckedAt)}${SHARED_CACHE_SUFFIX}`;
1798
+ case "cached":
1799
+ return SHARED_CACHE_SUFFIX;
1800
+ default:
1801
+ return "";
1802
+ }
1803
+ }
1804
+ var NOT_SAVED_SUFFIX = " \xB7 Cache not saved";
1805
+ var SHARED_CACHE_SUFFIX = " \xB7 cache: shared";
1806
+
322
1807
  // src/page/selection.ts
323
1808
  function nextSelection(keys, current, delta) {
324
1809
  if (keys.length === 0)
@@ -344,6 +1829,14 @@ function pickPageState(result, samples, unavailable) {
344
1829
  return "unmeasurable";
345
1830
  return "empty";
346
1831
  }
1832
+ function pickViewPageState(view) {
1833
+ if (view.kind === "loading")
1834
+ return "loading";
1835
+ const content = pickPageState({ error: undefined }, view.samples, view.unavailable);
1836
+ if (view.kind === "error" && content === "empty")
1837
+ return "error";
1838
+ return content;
1839
+ }
347
1840
 
348
1841
  // src/page/states.tsx
349
1842
  import {createTextNode as _$createTextNode2} from "@opentui/solid";
@@ -661,46 +2154,26 @@ function TrendPanel(props) {
661
2154
  function TokscopePage(props) {
662
2155
  const theme = props.context.theme;
663
2156
  const dimensions = useTerminalDimensions();
664
- const openedAt = Date.now();
665
2157
  props.context.data.location.model.sync();
666
2158
  props.context.data.location.provider.sync();
667
- const [filters2, setFilters] = createSignal({
2159
+ const [filters3, setFilters] = createSignal2({
668
2160
  ...DEFAULT_FILTERS
669
2161
  });
670
- const [scanned, setScanned] = createSignal(0);
671
- const [selectedKey, setSelectedKey] = createSignal(undefined);
672
- const [selectedDay, setSelectedDay] = createSignal(0);
2162
+ const [selectedKey, setSelectedKey] = createSignal2(undefined);
2163
+ const [selectedDay, setSelectedDay] = createSignal2(0);
673
2164
  const directory = () => props.context.location?.directory ?? props.context.data.location.default().directory;
674
- const [result, {
675
- refetch
676
- }] = createResource(() => `${filters2().scope}:${filters2().range}`, async (key) => {
677
- const [scope, range] = key.split(":");
678
- setScanned(0);
679
- return collectMeasurements(props.context.client, {
680
- directory: scope === "project" ? directory() : undefined,
681
- fromMs: rangeStartMs(range, openedAt),
682
- onProgress: (info) => setScanned(info.sessionsScanned)
683
- });
684
- });
685
- const filtered = createMemo2(() => {
686
- const value = result();
687
- if (value === undefined)
688
- return {
689
- samples: [],
690
- unavailable: []
691
- };
692
- return applyReasoningFilter(value.samples, value.unavailable, filters2().reasoning);
693
- });
694
- const pageState = createMemo2(() => {
695
- if (result.loading)
696
- return "loading";
697
- return pickPageState({
698
- error: result.error
699
- }, filtered().samples, filtered().unavailable);
700
- });
2165
+ const state2 = () => props.service.view({
2166
+ directory: filters3().scope === "project" ? directory() : undefined,
2167
+ range: filters3().range
2168
+ })();
2169
+ const referenceNow = () => state2().lastCheckedAt ?? Date.now();
2170
+ const filtered = createMemo2(() => applyReasoningFilter(state2().samples, state2().unavailable, filters3().reasoning));
2171
+ const pageState = createMemo2(() => pickViewPageState(state2()));
701
2172
  const rows = createMemo2(() => comparisonRows(filtered().samples, filtered().unavailable));
702
2173
  createEffect(() => {
703
2174
  const list = rows();
2175
+ if (list.some((row) => row.key === selectedKey()))
2176
+ return;
704
2177
  setSelectedKey(list[0]?.key);
705
2178
  });
706
2179
  const moveSelection = (delta) => setSelectedKey(nextSelection(rows().map((row) => row.key), selectedKey(), delta));
@@ -709,13 +2182,19 @@ function TokscopePage(props) {
709
2182
  const key = selectedKey();
710
2183
  if (key === undefined)
711
2184
  return [];
712
- return dailySeries(filtered().samples, key, rangeStartMs(filters2().range, openedAt), openedAt);
2185
+ const nowMs = referenceNow();
2186
+ return dailySeries(filtered().samples, key, rangeStartMs(filters3().range, nowMs), nowMs);
713
2187
  });
2188
+ let anchoredKey;
714
2189
  createEffect(() => {
715
- selectedKey();
2190
+ const key = selectedKey();
716
2191
  const points = series();
2192
+ const current = selectedDay();
2193
+ if (key === anchoredKey && current < points.length)
2194
+ return;
717
2195
  const last = points.findLastIndex((point) => point.calls > 0);
718
2196
  setSelectedDay(last === -1 ? Math.max(0, points.length - 1) : last);
2197
+ anchoredKey = key;
719
2198
  });
720
2199
  const moveDay = (delta) => setSelectedDay((current) => Math.max(0, Math.min(current + delta, Math.max(0, series().length - 1))));
721
2200
  const rowLabel = () => {
@@ -731,13 +2210,13 @@ function TokscopePage(props) {
731
2210
  title: "All settings",
732
2211
  value: "all"
733
2212
  }];
734
- const value = result();
735
- for (const variant of value?.variants ?? [])
2213
+ const value = state2();
2214
+ for (const variant of value.variants)
736
2215
  options.push({
737
2216
  title: variant,
738
2217
  value: variant
739
2218
  });
740
- const hasUnknown = value !== undefined && [...value.samples, ...value.unavailable].some((item) => item.variant === undefined);
2219
+ const hasUnknown = [...value.samples, ...value.unavailable].some((item) => item.variant === undefined);
741
2220
  if (hasUnknown)
742
2221
  options.push({
743
2222
  title: "unknown",
@@ -748,7 +2227,7 @@ function TokscopePage(props) {
748
2227
  const pickScope = async () => {
749
2228
  const chosen = await props.context.ui.dialog.select({
750
2229
  title: "Scope",
751
- current: filters2().scope,
2230
+ current: filters3().scope,
752
2231
  options: SCOPE_OPTIONS
753
2232
  });
754
2233
  if (chosen !== undefined)
@@ -760,7 +2239,7 @@ function TokscopePage(props) {
760
2239
  const pickRange = async () => {
761
2240
  const chosen = await props.context.ui.dialog.select({
762
2241
  title: "Time range",
763
- current: filters2().range,
2242
+ current: filters3().range,
764
2243
  options: RANGE_OPTIONS
765
2244
  });
766
2245
  if (chosen !== undefined)
@@ -772,7 +2251,7 @@ function TokscopePage(props) {
772
2251
  const pickReasoning = async () => {
773
2252
  const chosen = await props.context.ui.dialog.select({
774
2253
  title: "Reasoning setting",
775
- current: filters2().reasoning,
2254
+ current: filters3().reasoning,
776
2255
  options: reasoningOptions()
777
2256
  });
778
2257
  if (chosen !== undefined)
@@ -826,8 +2305,8 @@ function TokscopePage(props) {
826
2305
  bind: "enter",
827
2306
  title: "retry",
828
2307
  run: () => {
829
- if (pageState() === "error")
830
- refetch();
2308
+ if (state2().kind === "error")
2309
+ props.service.refreshNow();
831
2310
  }
832
2311
  }]
833
2312
  }));
@@ -846,9 +2325,20 @@ function TokscopePage(props) {
846
2325
  return props.context;
847
2326
  },
848
2327
  get filters() {
849
- return filters2();
2328
+ return filters3();
850
2329
  }
851
2330
  }), _el$2);
2331
+ _$insert5(_el$, _$createComponent3(Show3, {
2332
+ get when() {
2333
+ return bannerMessage(state2());
2334
+ },
2335
+ children: (message) => (() => {
2336
+ var _el$5 = _$createElement5("text");
2337
+ _$insert5(_el$5, message);
2338
+ _$effect5((_$p) => _$setProp5(_el$5, "fg", state2().kind === "error" ? theme.text.feedback.error.base : theme.text.muted, _$p));
2339
+ return _el$5;
2340
+ })()
2341
+ }), _el$2);
852
2342
  _$setProp5(_el$2, "flexGrow", 1);
853
2343
  _$setProp5(_el$2, "flexDirection", "column");
854
2344
  _$setProp5(_el$2, "gap", 1);
@@ -864,7 +2354,7 @@ function TokscopePage(props) {
864
2354
  return props.context;
865
2355
  },
866
2356
  get sessions() {
867
- return scanned();
2357
+ return state2().scanned;
868
2358
  }
869
2359
  });
870
2360
  }
@@ -889,7 +2379,7 @@ function TokscopePage(props) {
889
2379
  return props.context;
890
2380
  },
891
2381
  get filters() {
892
- return filters2();
2382
+ return filters3();
893
2383
  }
894
2384
  });
895
2385
  }
@@ -944,10 +2434,10 @@ function TokscopePage(props) {
944
2434
  return rowLabel();
945
2435
  },
946
2436
  get rangeLabel() {
947
- return rangeLabel(filters2().range);
2437
+ return rangeLabel(filters3().range);
948
2438
  },
949
2439
  get reasoningLabel() {
950
- return reasoningLabel(filters2().reasoning);
2440
+ return reasoningLabel(filters3().reasoning);
951
2441
  },
952
2442
  get width() {
953
2443
  return Math.max(20, dimensions().width - 2);
@@ -958,7 +2448,7 @@ function TokscopePage(props) {
958
2448
  })];
959
2449
  }
960
2450
  }));
961
- _$insert5(_el$4, () => "\u2191\u2193 select \xB7 enter trend \xB7 \u2190\u2192 day \xB7 s scope \xB7 t range \xB7 r reasoning \xB7 esc back" + coverage());
2451
+ _$insert5(_el$4, () => HELP_LINE + coverage() + footerStatusSuffix(state2()));
962
2452
  _$effect5((_p$) => {
963
2453
  var _v$ = theme.background.base, _v$2 = theme.text.muted;
964
2454
  _v$ !== _p$.e && (_p$.e = _$setProp5(_el$, "backgroundColor", _v$, _p$.e));
@@ -991,104 +2481,16 @@ var RANGE_OPTIONS = [{
991
2481
  title: "All history",
992
2482
  value: "all"
993
2483
  }];
2484
+ var HELP_LINE = "\u2191\u2193 select \xB7 enter trend \xB7 \u2190\u2192 day \xB7 s scope \xB7 t range \xB7 r reasoning \xB7 esc back \xB7 reset history in palette";
994
2485
 
995
2486
  // src/sidebar/store.ts
996
- import {createSignal as createSignal2} from "solid-js";
997
-
998
- // src/sidebar/rank.ts
999
- function widgetRows(samples, nowMs) {
1000
- const since = nowMs - WIDGET_WINDOW_MS;
1001
- const groups = new Map;
1002
- for (const sample of samples) {
1003
- if (sample.completedAt <= since || sample.completedAt > nowMs)
1004
- continue;
1005
- const key = rowKey(sample.providerID, sample.modelID);
1006
- let group = groups.get(key);
1007
- if (group === undefined) {
1008
- group = { providerID: sample.providerID, modelID: sample.modelID, rates: [] };
1009
- groups.set(key, group);
1010
- }
1011
- group.rates.push(sample.rate);
1012
- }
1013
- const rows = [];
1014
- for (const [key, group] of groups) {
1015
- if (group.rates.length < WIDGET_MIN_CALLS)
1016
- continue;
1017
- const value = median(group.rates);
1018
- if (value === null)
1019
- continue;
1020
- rows.push({
1021
- key,
1022
- providerID: group.providerID,
1023
- modelID: group.modelID,
1024
- median: value,
1025
- calls: group.rates.length
1026
- });
1027
- }
1028
- rows.sort((a, b) => {
1029
- const medianOrder = b.median - a.median;
1030
- if (medianOrder !== 0)
1031
- return medianOrder;
1032
- if (b.calls !== a.calls)
1033
- return b.calls - a.calls;
1034
- return a.key.localeCompare(b.key);
1035
- });
1036
- return rows.slice(0, WIDGET_MAX_ENTRIES);
1037
- }
1038
- var WIDGET_WINDOW_MS = 86400000;
1039
- var WIDGET_MIN_CALLS = 3;
1040
- var WIDGET_MAX_ENTRIES = 3;
1041
-
1042
- // src/sidebar/store.ts
1043
- function createWidgetStore(deps) {
1044
- const [state2, setState] = createSignal2({ status: "loading", rows: [], stale: false });
1045
- let inFlight = false;
1046
- let pending = false;
1047
- let resolvers = [];
1048
- async function runOnce() {
1049
- const nowMs = deps.now();
1050
- try {
1051
- const result = await collectMeasurements(deps.client, { fromMs: nowMs - WIDGET_WINDOW_MS });
1052
- setState({ status: "ready", rows: widgetRows(result.samples, nowMs), stale: false });
1053
- } catch {
1054
- const previous = state2();
1055
- setState(previous.rows.length > 0 ? { status: "ready", rows: previous.rows, stale: true } : { status: "error", rows: [], stale: false });
1056
- }
1057
- }
1058
- async function drain() {
1059
- inFlight = true;
1060
- do {
1061
- pending = false;
1062
- await runOnce();
1063
- } while (pending);
1064
- inFlight = false;
1065
- const waiting = resolvers;
1066
- resolvers = [];
1067
- for (const resolve of waiting)
1068
- resolve();
1069
- }
1070
- function refresh() {
1071
- return new Promise((resolve) => {
1072
- resolvers.push(resolve);
1073
- if (inFlight) {
1074
- pending = true;
1075
- return;
1076
- }
1077
- drain();
1078
- });
1079
- }
1080
- function attach() {
1081
- const detachEvent = deps.onEvent(() => void refresh());
1082
- const detachTimer = deps.setTimer(() => void refresh(), WIDGET_REFRESH_MS);
1083
- refresh();
1084
- return () => {
1085
- detachEvent();
1086
- detachTimer();
1087
- };
1088
- }
1089
- return { state: state2, refresh, attach };
2487
+ function createWidgetStore(service) {
2488
+ return {
2489
+ state: () => service.widget()(),
2490
+ refresh: () => service.refreshNow(),
2491
+ attach: () => service.hold()
2492
+ };
1090
2493
  }
1091
- var WIDGET_REFRESH_MS = 60000;
1092
2494
 
1093
2495
  // src/sidebar/widget.tsx
1094
2496
  import {insertNode as _$insertNode6} from "@opentui/solid";
@@ -1100,7 +2502,7 @@ import {use as _$use} from "@opentui/solid";
1100
2502
  import {createElement as _$createElement6} from "@opentui/solid";
1101
2503
  import {TextAttributes as TextAttributes4} from "@opentui/core";
1102
2504
  import {useTerminalDimensions as useTerminalDimensions2} from "@opentui/solid";
1103
- import {createEffect as createEffect2, createMemo as createMemo3, createSignal as createSignal3, For as For3, onCleanup, onMount, Show as Show3} from "solid-js";
2505
+ import {createEffect as createEffect2, createMemo as createMemo3, createSignal as createSignal3, For as For3, onCleanup, onMount, Show as Show4} from "solid-js";
1104
2506
 
1105
2507
  // src/sidebar/layout.ts
1106
2508
  var unitLine = function(width) {
@@ -1260,7 +2662,7 @@ function TokscopeSidebar(props) {
1260
2662
  }, _el$);
1261
2663
  _$setProp6(_el$, "flexDirection", "column");
1262
2664
  _$setProp6(_el$, "width", "100%");
1263
- _$insert6(_el$, _$createComponent4(Show3, {
2665
+ _$insert6(_el$, _$createComponent4(Show4, {
1264
2666
  get when() {
1265
2667
  return view2();
1266
2668
  },
@@ -1294,7 +2696,7 @@ function TokscopeSidebar(props) {
1294
2696
  _$effect6((_$p) => _$setProp6(_el$7, "fg", theme.text.muted, _$p));
1295
2697
  return _el$7;
1296
2698
  })()
1297
- }), _$createComponent4(Show3, {
2699
+ }), _$createComponent4(Show4, {
1298
2700
  get when() {
1299
2701
  return current.status === "loading";
1300
2702
  },
@@ -1304,7 +2706,7 @@ function TokscopeSidebar(props) {
1304
2706
  _$effect6((_$p) => _$setProp6(_el$2, "fg", theme.text.muted, _$p));
1305
2707
  return _el$2;
1306
2708
  }
1307
- }), _$createComponent4(Show3, {
2709
+ }), _$createComponent4(Show4, {
1308
2710
  get when() {
1309
2711
  return current.status === "error";
1310
2712
  },
@@ -1314,12 +2716,12 @@ function TokscopeSidebar(props) {
1314
2716
  _$effect6((_$p) => _$setProp6(_el$3, "fg", theme.text.feedback.error.base, _$p));
1315
2717
  return _el$3;
1316
2718
  }
1317
- }), _$createComponent4(Show3, {
2719
+ }), _$createComponent4(Show4, {
1318
2720
  get when() {
1319
2721
  return current.status === "ready";
1320
2722
  },
1321
2723
  get children() {
1322
- return _$createComponent4(Show3, {
2724
+ return _$createComponent4(Show4, {
1323
2725
  get when() {
1324
2726
  return current.lines.length > 0;
1325
2727
  },
@@ -1377,19 +2779,36 @@ var tui_default = Plugin.define({
1377
2779
  name: "tokscope"
1378
2780
  });
1379
2781
  };
1380
- const store2 = createWidgetStore({
2782
+ let unsubscribeEvents;
2783
+ const service2 = createHistoryService({
1381
2784
  client: context.client,
1382
- onEvent: (handler) => context.data.on("session.step.ended", handler),
2785
+ repository: createRepository(createPluginDurableStore(context.storage)),
2786
+ subscribeEvents: (handler) => {
2787
+ unsubscribeEvents = context.data.listen(({
2788
+ details
2789
+ }) => handler({
2790
+ type: details.type,
2791
+ data: details.data
2792
+ }));
2793
+ return unsubscribeEvents;
2794
+ },
1383
2795
  setTimer: (callback, ms) => {
1384
2796
  const id = setInterval(callback, ms);
1385
2797
  return () => clearInterval(id);
1386
2798
  },
2799
+ delay: (callback, ms) => {
2800
+ const id = setTimeout(callback, ms);
2801
+ return () => clearTimeout(id);
2802
+ },
1387
2803
  now: () => Date.now()
1388
2804
  });
2805
+ const release = service2.hold();
2806
+ const store3 = createWidgetStore(service2);
1389
2807
  context.ui.router.register({
1390
2808
  name: "tokscope",
1391
2809
  render: () => _$createComponent5(TokscopePage, {
1392
2810
  context,
2811
+ service: service2,
1393
2812
  onClose: () => context.ui.router.navigate(previous())
1394
2813
  })
1395
2814
  });
@@ -1397,7 +2816,7 @@ var tui_default = Plugin.define({
1397
2816
  append: "sidebar.content",
1398
2817
  render: () => _$createComponent5(TokscopeSidebar, {
1399
2818
  context,
1400
- store: store2,
2819
+ store: store3,
1401
2820
  open: openTokscope
1402
2821
  })
1403
2822
  });
@@ -1415,11 +2834,32 @@ var tui_default = Plugin.define({
1415
2834
  },
1416
2835
  palette: true,
1417
2836
  run: openTokscope
2837
+ }, {
2838
+ id: "tokscope.resetHistory",
2839
+ title: "Tokscope: reset history cache",
2840
+ group: "System",
2841
+ palette: true,
2842
+ run: async () => {
2843
+ const confirmed = await context.ui.dialog.confirm({
2844
+ title: "Reset Tokscope history cache",
2845
+ message: "Delete the shared Tokscope history cache and rebuild it from the server?",
2846
+ label: {
2847
+ confirm: "Reset",
2848
+ cancel: "Cancel"
2849
+ }
2850
+ });
2851
+ if (confirmed === true)
2852
+ await service2.reset();
2853
+ }
1418
2854
  }]
1419
2855
  }));
1420
2856
  return null;
1421
2857
  }
1422
2858
  });
2859
+ return () => {
2860
+ unsubscribeEvents?.();
2861
+ release();
2862
+ };
1423
2863
  }
1424
2864
  });
1425
2865
  export {