The best way to control Claude Code, Codex and more from any computer or phone

main
ts 709 lines 22.5 KB
Raw
1 import {
2 USAGE_CONTRACT_VERSION,
3 USAGE_MERGE_COMPATIBLE_SINCE,
4 type EnvironmentId,
5 type UsageBucket,
6 type UsageDay,
7 type UsageProviderKind,
8 UsageSummary,
9 } from "@t3tools/contracts";
10 import { describe, expect, it } from "vite-plus/test";
11 import * as Schema from "effect/Schema";
12
13 import { isModelCostUnknown, mergeUsage, type EnvironmentUsage } from "./usageMerge.ts";
14
15 const decodeSummary = Schema.decodeUnknownSync(UsageSummary);
16
17 function bucket(overrides: Partial<UsageBucket> = {}): UsageBucket {
18 return {
19 day: "2026-08-07" as UsageDay,
20 provider: "claude",
21 model: "claude-fable-5",
22 totals: {
23 uncachedInputTokens: 100,
24 cachedInputTokens: 1000,
25 cacheCreationTokens: 10,
26 outputTokens: 50,
27 reasoningTokens: 0,
28 },
29 costUsd: 10,
30 cacheSavingsUsd: 2,
31 costSource: "modelPriced",
32 records: 5,
33 unpricedRecords: 0,
34 sessions: 1,
35 ...overrides,
36 };
37 }
38
39 function summary(
40 buckets: readonly UsageBucket[],
41 sources: readonly {
42 provider: UsageProviderKind;
43 hostId: string;
44 homePath: string;
45 volumeId?: string;
46 physicalSourceId?: string;
47 distinctSessions?: number;
48 }[],
49 contractVersion: number = USAGE_CONTRACT_VERSION,
50 ): UsageSummary {
51 return {
52 contractVersion,
53 readAt: "2026-08-07T00:00:00.000Z",
54 timeZone: "UTC",
55 sinceDay: "2026-08-01" as UsageDay,
56 untilDay: "2026-08-31" as UsageDay,
57 buckets,
58 sources: sources.map((source) => ({
59 fingerprint: {
60 hostId: source.hostId,
61 provider: source.provider,
62 resolvedHomePath: source.homePath,
63 volumeId: source.volumeId ?? `vol-${source.hostId}`,
64 ...(source.physicalSourceId === undefined
65 ? {}
66 : { physicalSourceId: source.physicalSourceId }),
67 },
68 status: "ok" as const,
69 scannedFiles: 1,
70 skippedFiles: 0,
71 malformedRecords: 0,
72 distinctSessions: source.distinctSessions ?? 1,
73 message: null,
74 })),
75 pricing: { status: "fresh", source: "litellm", fetchedAt: null, knownModels: 10 },
76 scanDurationMs: 1,
77 };
78 }
79
80 function environment(id: string, usageSummary: UsageSummary): EnvironmentUsage {
81 return { environmentId: id as EnvironmentId, label: id, summary: usageSummary };
82 }
83
84 describe("mergeUsage", () => {
85 it("counts a Cursor account once across servers while retaining each server's other providers", () => {
86 const account = {
87 provider: "cursor" as const,
88 hostId: "cursor.com",
89 homePath: "cursor-account:account-hash",
90 volumeId: "account-hash",
91 };
92 const merged = mergeUsage(
93 [
94 environment(
95 "mac",
96 summary([bucket({ provider: "cursor", sourcePath: account.homePath })], [account]),
97 ),
98 environment(
99 "linux",
100 summary(
101 [
102 bucket({ provider: "cursor", sourcePath: account.homePath }),
103 bucket({ provider: "opencode", sourcePath: "/opencode" }),
104 ],
105 [account, { provider: "opencode", hostId: "linux", homePath: "/opencode" }],
106 ),
107 ),
108 ],
109 USAGE_CONTRACT_VERSION,
110 );
111 expect(
112 merged.providers.map((provider) => [provider.provider, provider.costUsd]).sort(),
113 ).toEqual([
114 ["cursor", 10],
115 ["opencode", 10],
116 ]);
117 expect(merged.duplicateSources).toHaveLength(1);
118 });
119
120 it("counts a shared transcript directory once", () => {
121 const shared = { provider: "claude" as const, hostId: "mac", homePath: "/home/theo/.claude" };
122 const merged = mergeUsage(
123 [
124 environment("env-a", summary([bucket()], [shared])),
125 environment("env-b", summary([bucket()], [shared])),
126 ],
127 USAGE_CONTRACT_VERSION,
128 );
129
130 expect(merged.costUsd).toBe(10);
131 expect(merged.records).toBe(5);
132 expect(merged.sessions).toBe(1);
133 expect(merged.duplicateSources).toHaveLength(1);
134 expect(merged.contributingEnvironments).toEqual(["env-a"]);
135 });
136
137 it("drops only the duplicated provider, keeping the environment's other one", () => {
138 const sharedClaude = {
139 provider: "claude" as const,
140 hostId: "mac",
141 homePath: "/home/theo/.claude",
142 };
143 const merged = mergeUsage(
144 [
145 environment("env-a", summary([bucket()], [sharedClaude])),
146 environment(
147 "env-b",
148 summary(
149 [bucket(), bucket({ provider: "codex", model: "gpt-5.6-sol", costUsd: 4 })],
150 [sharedClaude, { provider: "codex", hostId: "mac", homePath: "/home/theo/.codex" }],
151 ),
152 ),
153 ],
154 USAGE_CONTRACT_VERSION,
155 );
156
157 expect(merged.costUsd).toBe(14);
158 expect(merged.providers.map((provider) => provider.provider).sort()).toEqual([
159 "claude",
160 "codex",
161 ]);
162 expect(merged.sessions).toBe(2);
163 expect(
164 Object.fromEntries(
165 merged.providers.map((provider) => [provider.provider, provider.sessions]),
166 ),
167 ).toEqual({ claude: 1, codex: 1 });
168 });
169
170 it("counts overlapping provider roots once while keeping each environment's unique root", () => {
171 const source = (homePath: string) => ({
172 provider: "opencode" as const,
173 hostId: "host",
174 homePath,
175 });
176 const usage = (sourcePath: string, costUsd: number) =>
177 bucket({ provider: "opencode", sourcePath, costUsd });
178 const merged = mergeUsage(
179 [
180 environment(
181 "env-a",
182 summary([usage("/shared", 10), usage("/a", 2)], [source("/shared"), source("/a")]),
183 ),
184 environment(
185 "env-b",
186 summary([usage("/shared", 10), usage("/b", 3)], [source("/shared"), source("/b")]),
187 ),
188 ],
189 USAGE_CONTRACT_VERSION,
190 );
191 expect(merged.costUsd).toBe(15);
192 expect(merged.sessions).toBe(3);
193 });
194
195 it("uses the newest scan when environments share the same transcript directory", () => {
196 const source = { provider: "claude" as const, hostId: "mac", homePath: "/home/theo/.claude" };
197 const environments = [
198 environment("env-a", summary([bucket({ costUsd: 4, records: 2 })], [source])),
199 environment("env-b", {
200 ...summary([bucket()], [source]),
201 readAt: "2026-08-07T01:00:00.000Z",
202 }),
203 ];
204
205 for (const ordered of [environments, environments.toReversed()]) {
206 const merged = mergeUsage(ordered, USAGE_CONTRACT_VERSION);
207 expect(merged.costUsd).toBe(10);
208 expect(merged.records).toBe(5);
209 expect(merged.sessions).toBe(1);
210 expect(merged.contributingEnvironments).toEqual(["env-b"]);
211 expect(merged.duplicateSources).toEqual(["env-a: /home/theo/.claude"]);
212 }
213 });
214
215 it("prefers a complete scan over a newer partial scan of the same directory", () => {
216 const source = { provider: "claude" as const, hostId: "mac", homePath: "/home/theo/.claude" };
217 const incomplete = summary([bucket({ costUsd: 4, records: 2 })], [source]);
218 const partial = environment("new", {
219 ...incomplete,
220 readAt: "2026-08-07T01:00:00.000Z",
221 sources: incomplete.sources.map((entry) => ({ ...entry, status: "partial" as const })),
222 });
223 const complete = environment("old", summary([bucket()], [source]));
224
225 for (const ordered of [
226 [partial, complete],
227 [complete, partial],
228 ]) {
229 const merged = mergeUsage(ordered, USAGE_CONTRACT_VERSION);
230 expect(merged.costUsd).toBe(10);
231 expect(merged.contributingEnvironments).toEqual(["old"]);
232 expect(merged.duplicateSources).toEqual(["new: /home/theo/.claude"]);
233 }
234 expect(mergeUsage([partial], USAGE_CONTRACT_VERSION).costUsd).toBe(4);
235 });
236
237 it("keeps new cells from a later partial scan without recounting older cells", () => {
238 const source = { provider: "claude" as const, hostId: "mac", homePath: "/home/theo/.claude" };
239 const complete = environment(
240 "old",
241 summary([bucket()], [source], USAGE_MERGE_COMPATIBLE_SINCE),
242 );
243 const partialSummary = summary(
244 [
245 bucket({ sourcePath: source.homePath, costUsd: 4, records: 2 }),
246 bucket({
247 day: "2026-08-08" as UsageDay,
248 sourcePath: source.homePath,
249 costUsd: 3,
250 records: 1,
251 }),
252 ],
253 [{ ...source, distinctSessions: 2 }],
254 );
255 const partial = environment("new", {
256 ...partialSummary,
257 readAt: "2026-08-08T01:00:00.000Z",
258 sources: partialSummary.sources.map((entry) => ({ ...entry, status: "partial" as const })),
259 });
260
261 for (const ordered of [
262 [complete, partial],
263 [partial, complete],
264 ]) {
265 const merged = mergeUsage(ordered, USAGE_CONTRACT_VERSION);
266 expect(merged.costUsd).toBe(13);
267 expect(merged.records).toBe(6);
268 expect(merged.sessions).toBe(2);
269 expect(merged.daily.map(({ day, costUsd }) => [day, costUsd])).toEqual([
270 ["2026-08-07", 10],
271 ["2026-08-08", 3],
272 ]);
273 expect(merged.contributingEnvironments).toEqual(
274 ordered.map(({ environmentId }) => environmentId),
275 );
276 expect(merged.duplicateSources).toEqual(["new: /home/theo/.claude"]);
277 }
278
279 const filtered = environment("new", {
280 ...partial.summary,
281 modelFilter: { exclude: [{ model: "claude-fable-5" }] },
282 });
283 const merged = mergeUsage([complete, filtered], USAGE_CONTRACT_VERSION);
284 expect(merged.costUsd).toBe(10);
285 expect(merged.sessions).toBe(1);
286 });
287
288 it("retains a complete cell when a larger partial cell may have skipped old records", () => {
289 const source = { provider: "claude" as const, hostId: "mac", homePath: "/home/theo/.claude" };
290 const complete = environment("old", summary([bucket()], [source]));
291 const partialSummary = summary(
292 [
293 bucket({
294 costUsd: 4,
295 records: 6,
296 totals: {
297 uncachedInputTokens: 80,
298 cachedInputTokens: 500,
299 cacheCreationTokens: 10,
300 outputTokens: 30,
301 reasoningTokens: 0,
302 },
303 }),
304 ],
305 [{ ...source, distinctSessions: 2 }],
306 );
307 const partial = environment("new", {
308 ...partialSummary,
309 readAt: "2026-08-07T01:00:00.000Z",
310 sources: partialSummary.sources.map((entry) => ({ ...entry, status: "partial" as const })),
311 });
312
313 const merged = mergeUsage([complete, partial], USAGE_CONTRACT_VERSION);
314 expect(merged.costUsd).toBe(10);
315 expect(merged.totalTokens).toBe(1160);
316 expect(merged.records).toBe(5);
317 expect(merged.sessions).toBe(1);
318 expect(merged.contributingEnvironments).toEqual(["old"]);
319 });
320
321 it("identifies an environment reporting an older contract version", () => {
322 const merged = mergeUsage(
323 [
324 environment(
325 "env-a",
326 summary([bucket()], [{ provider: "claude", hostId: "mac", homePath: "/a" }]),
327 ),
328 environment(
329 "env-b",
330 summary(
331 [bucket()],
332 [{ provider: "claude", hostId: "linux", homePath: "/b" }],
333 USAGE_MERGE_COMPATIBLE_SINCE - 1,
334 ),
335 ),
336 ],
337 USAGE_CONTRACT_VERSION,
338 );
339
340 expect(merged.costUsd).toBe(10);
341 expect(merged.contractMismatches).toEqual([
342 {
343 environmentId: "env-b",
344 direction: "serverBehind",
345 contractVersion: USAGE_MERGE_COMPATIBLE_SINCE - 1,
346 },
347 ]);
348 });
349
350 it("identifies an environment reporting a newer contract version", () => {
351 const merged = mergeUsage(
352 [
353 environment(
354 "env-a",
355 summary(
356 [bucket()],
357 [{ provider: "claude", hostId: "mac", homePath: "/a" }],
358 USAGE_CONTRACT_VERSION + 1,
359 ),
360 ),
361 ],
362 USAGE_CONTRACT_VERSION,
363 );
364
365 expect(merged.costUsd).toBe(0);
366 expect(merged.contractMismatches).toEqual([
367 {
368 environmentId: "env-a",
369 direction: "clientBehind",
370 contractVersion: USAGE_CONTRACT_VERSION + 1,
371 },
372 ]);
373 });
374
375 it("keeps the previous compatible contract version so additive provider expansions still merge", () => {
376 const merged = mergeUsage(
377 [
378 environment(
379 "env-a",
380 summary(
381 [bucket({ costUsd: 10 })],
382 [{ provider: "claude", hostId: "mac", homePath: "/a" }],
383 ),
384 ),
385 environment(
386 "env-b",
387 summary(
388 [bucket({ costUsd: 4, provider: "codex", model: "gpt-5.6-sol" })],
389 [{ provider: "codex", hostId: "linux", homePath: "/b" }],
390 USAGE_CONTRACT_VERSION - 1,
391 ),
392 ),
393 ],
394 USAGE_CONTRACT_VERSION,
395 );
396
397 expect(merged.costUsd).toBe(14);
398 expect(merged.contractMismatches).toEqual([]);
399 });
400
401 it("keeps known usage when newer providers and bucket variants cannot be decoded", () => {
402 const known = summary([bucket()], [{ provider: "claude", hostId: "mac", homePath: "/a" }]);
403 const decoded = decodeSummary({
404 ...known,
405 buckets: [
406 ...known.buckets,
407 { ...bucket(), provider: "future-provider", costUsd: 100 },
408 { ...bucket(), costSource: "future-pricing", costUsd: 200 },
409 ],
410 sources: [
411 ...known.sources,
412 {
413 ...known.sources[0],
414 fingerprint: {
415 ...known.sources[0]?.fingerprint,
416 provider: "future-provider",
417 },
418 },
419 ],
420 });
421 expect(decoded).toEqual(known);
422 const merged = mergeUsage([environment("env-a", decoded)], USAGE_CONTRACT_VERSION);
423 expect(merged.costUsd).toBe(10);
424 expect(merged.totalTokens).toBe(1160);
425 expect(merged.contractMismatches).toEqual([]);
426 });
427
428 it("normalizes model names during decoding before grouping usage", () => {
429 const decoded = decodeSummary(
430 summary(
431 [
432 bucket({ provider: "codex", model: " gpt-5 " }),
433 bucket({ provider: "codex", model: "gpt-5" }),
434 ],
435 [{ provider: "codex", hostId: "mac", homePath: "/a" }],
436 ),
437 );
438
439 expect(decoded.buckets.map((entry) => entry.model)).toEqual(["gpt-5", "gpt-5"]);
440 const merged = mergeUsage([environment("env-a", decoded)], USAGE_CONTRACT_VERSION);
441 expect(merged.models).toHaveLength(1);
442 expect(merged.models[0]).toMatchObject({ model: "gpt-5", costUsd: 20, totalTokens: 2320 });
443 });
444
445 it("marks a model with no known rates as unpriced rather than free", () => {
446 const merged = mergeUsage(
447 [
448 environment(
449 "env-a",
450 summary(
451 [
452 bucket({ costUsd: 75 }),
453 bucket({
454 provider: "codex",
455 model: "unknown-model",
456 costUsd: 0,
457 costSource: "unpriced",
458 unpricedRecords: 5,
459 }),
460 ],
461 [
462 { provider: "claude", hostId: "mac", homePath: "/a/.claude" },
463 { provider: "codex", hostId: "mac", homePath: "/a/.codex" },
464 ],
465 ),
466 ),
467 ],
468 USAGE_CONTRACT_VERSION,
469 );
470
471 expect(merged.models.find((model) => model.model === "unknown-model")?.unpricedRecords).toBe(5);
472 expect(merged.models.filter(isModelCostUnknown).map((model) => model.model)).toEqual([
473 "unknown-model",
474 ]);
475 });
476
477 it("splits cost by category and speed, counting older servers as unsplit standard cost", () => {
478 const merged = mergeUsage(
479 [
480 environment(
481 "env-a",
482 summary(
483 [
484 bucket({
485 costUsd: 10,
486 categoryCostUsd: { input: 1, cacheRead: 2, cacheWrite: 3, output: 4 },
487 fastCostUsd: 6,
488 speedPremiumUsd: 3,
489 }),
490 bucket({
491 provider: "codex",
492 model: "unknown-model",
493 costUsd: 0,
494 costSource: "unpriced",
495 unpricedRecords: 5,
496 }),
497 bucket({
498 provider: "codex",
499 model: "partly-reported",
500 costUsd: 0,
501 unpricedRecords: 4,
502 }),
503 ],
504 [
505 { provider: "claude", hostId: "mac", homePath: "/a/.claude" },
506 { provider: "codex", hostId: "mac", homePath: "/a/.codex" },
507 ],
508 ),
509 ),
510 environment(
511 "env-b",
512 summary(
513 [bucket({ costUsd: 5 })],
514 [{ provider: "claude", hostId: "linux", homePath: "/b/.claude" }],
515 USAGE_MERGE_COMPATIBLE_SINCE,
516 ),
517 ),
518 ],
519 USAGE_CONTRACT_VERSION,
520 );
521
522 expect(merged.categoryCost).toEqual({
523 input: 1,
524 cacheRead: 2,
525 cacheWrite: 3,
526 output: 4,
527 unsplit: 5,
528 });
529 expect(merged.speedCost).toEqual({ standard: 9, fast: 6, ultrafast: 0, premium: 3 });
530 expect(merged.models.map(({ model, unpricedTokens }) => [model, unpricedTokens])).toEqual([
531 ["claude-fable-5", 0],
532 ["unknown-model", 1160],
533 ["partly-reported", 928],
534 ]);
535 });
536
537 it("keeps two machines apart when hostname and home path collide", () => {
538 const shape = { provider: "claude" as const, hostId: "mac", homePath: "/Users/theo/.claude" };
539 const merged = mergeUsage(
540 [
541 environment("env-a", summary([bucket()], [{ ...shape, volumeId: "16777220:1234" }])),
542 environment("env-b", summary([bucket()], [{ ...shape, volumeId: "16777221:9999" }])),
543 ],
544 USAGE_CONTRACT_VERSION,
545 );
546
547 expect(merged.costUsd).toBe(20);
548 expect(merged.duplicateSources).toHaveLength(0);
549 });
550
551 describe("one directory seen from both sides of a Windows and WSL boundary", () => {
552 // Fingerprints the reporter captured for one NTFS directory, read natively by
553 // Windows and through the drvfs mount by WSL. Path and dev:ino both differ.
554 const physicalSourceId = "physical-claude-projects";
555 const windows = {
556 provider: "claude" as const,
557 hostId: "MainPC",
558 homePath: "C:\\Users\\user\\.claude\\projects",
559 volumeId: "1280555009:3659174697951285",
560 physicalSourceId,
561 distinctSessions: 142,
562 };
563 const wsl = {
564 provider: "claude" as const,
565 hostId: "MainPC",
566 homePath: "/mnt/c/Users/user/.claude/projects",
567 volumeId: "112:3659174697951287",
568 physicalSourceId,
569 distinctSessions: 142,
570 };
571
572 it("counts it once, whichever scan is newer", () => {
573 const environments = [
574 environment(
575 "windows",
576 summary([bucket({ sourcePath: windows.homePath, records: 22433 })], [windows]),
577 ),
578 environment("wsl", {
579 ...summary([bucket({ sourcePath: wsl.homePath, records: 22432 })], [wsl]),
580 readAt: "2026-08-07T00:05:00.000Z",
581 }),
582 ];
583
584 for (const ordered of [environments, environments.toReversed()]) {
585 const merged = mergeUsage(ordered, USAGE_CONTRACT_VERSION);
586 expect(merged.sessions).toBe(142);
587 expect(merged.records).toBe(22432);
588 expect(merged.costUsd).toBe(10);
589 expect(merged.contributingEnvironments).toEqual(["wsl"]);
590 expect(merged.duplicateSources).toEqual([`windows: ${windows.homePath}`]);
591 }
592 });
593
594 it("keeps only new cells from a later partial scan through the other side", () => {
595 const complete = environment(
596 "windows",
597 summary([bucket({ sourcePath: windows.homePath })], [windows]),
598 );
599 const partialSummary = summary(
600 [
601 bucket({ sourcePath: wsl.homePath, costUsd: 4, records: 2 }),
602 bucket({ day: "2026-08-08" as UsageDay, sourcePath: wsl.homePath, costUsd: 3 }),
603 ],
604 [{ ...wsl, distinctSessions: 143 }],
605 );
606 const partial = environment("wsl", {
607 ...partialSummary,
608 readAt: "2026-08-08T01:00:00.000Z",
609 sources: partialSummary.sources.map((entry) => ({ ...entry, status: "partial" as const })),
610 });
611
612 const merged = mergeUsage([complete, partial], USAGE_CONTRACT_VERSION);
613 expect(merged.costUsd).toBe(13);
614 expect(merged.sessions).toBe(143);
615 expect(merged.daily.map(({ day, costUsd }) => [day, costUsd])).toEqual([
616 ["2026-08-07", 10],
617 ["2026-08-08", 3],
618 ]);
619 });
620
621 it("counts it once when one server reaches it through two mounts", () => {
622 const secondMount = { ...wsl, homePath: "/mnt/win/Users/user/.claude/projects" };
623 const merged = mergeUsage(
624 [
625 environment(
626 "wsl",
627 summary(
628 [
629 bucket({ sourcePath: wsl.homePath }),
630 bucket({
631 day: "2026-08-08" as UsageDay,
632 sourcePath: secondMount.homePath,
633 costUsd: 3,
634 }),
635 ],
636 [wsl, secondMount],
637 ),
638 ),
639 ],
640 USAGE_CONTRACT_VERSION,
641 );
642
643 expect(merged.costUsd).toBe(10);
644 expect(merged.sessions).toBe(142);
645 expect(merged.daily.map(({ day }) => day)).toEqual(["2026-08-07"]);
646 expect(merged.duplicateSources).toEqual([`wsl: ${secondMount.homePath}`]);
647 });
648
649 it("still counts a shared directory once when only one server reports physical identity", () => {
650 const { physicalSourceId: _omitted, ...legacy } = windows;
651 const merged = mergeUsage(
652 [
653 environment("desktop", summary([bucket({ sourcePath: windows.homePath })], [windows])),
654 environment("standalone", summary([bucket({ sourcePath: legacy.homePath })], [legacy])),
655 ],
656 USAGE_CONTRACT_VERSION,
657 );
658
659 expect(merged.costUsd).toBe(10);
660 expect(merged.sessions).toBe(142);
661 expect(merged.duplicateSources).toHaveLength(1);
662 });
663
664 it("counts it once when two desktop installs with different scopes read it", () => {
665 const merged = mergeUsage(
666 [
667 environment("packaged", summary([bucket({ sourcePath: windows.homePath })], [windows])),
668 environment(
669 "dev-build",
670 summary(
671 [bucket({ sourcePath: windows.homePath })],
672 [{ ...windows, physicalSourceId: "physical-other-scope" }],
673 ),
674 ),
675 ],
676 USAGE_CONTRACT_VERSION,
677 );
678
679 expect(merged.costUsd).toBe(10);
680 expect(merged.sessions).toBe(142);
681 expect(merged.duplicateSources).toHaveLength(1);
682 });
683 });
684
685 it("totals sessions from per-directory distinct counts, not per-bucket sums", () => {
686 const merged = mergeUsage(
687 [
688 environment(
689 "env-a",
690 summary(
691 [bucket({ day: "2026-08-06" as UsageDay }), bucket({ day: "2026-08-07" as UsageDay })],
692 [
693 {
694 provider: "claude",
695 hostId: "mac",
696 homePath: "/a/.claude",
697 distinctSessions: 1,
698 },
699 ],
700 ),
701 ),
702 ],
703 USAGE_CONTRACT_VERSION,
704 );
705
706 expect(merged.sessions).toBe(1);
707 expect(merged.providers[0]?.sessions).toBe(1);
708 });
709 });