@synnaxlabs/x 0.42.3 → 0.44.0

package/src/telem/telem.spec.ts

@@ -11,6 +11,7 @@ import { describe, expect, it, test } from "vitest";
 
 import { binary } from "@/binary";
 import {
+  addSamples,
   type CrudeDataType,
   DataType,
   Density,
@@ -25,22 +26,22 @@ import {
 describe("TimeStamp", () => {
   test("construct", () => {
     const ts = new TimeStamp(1000);
-    expect(ts.equals(TimeSpan.MICROSECOND)).toBeTruthy();
+    expect(ts.equals(TimeSpan.MICROSECOND)).toBe(true);
   });
 
   test("construct from NaN", () => {
     const ts = new TimeStamp(NaN);
-    expect(ts.isZero).toBeTruthy();
+    expect(ts.isZero).toBe(true);
   });
 
   test("construct from infinity", () => {
     const ts = new TimeStamp(Infinity);
-    expect(ts.equals(TimeStamp.MAX)).toBeTruthy();
+    expect(ts.equals(TimeStamp.MAX)).toBe(true);
   });
 
   test("construct from negative infinity", () => {
     const ts = new TimeStamp(-Infinity);
-    expect(ts.equals(TimeStamp.MIN)).toBeTruthy();
+    expect(ts.equals(TimeStamp.MIN)).toBe(true);
   });
 
   test("toString", () => {
@@ -59,24 +60,24 @@ describe("TimeStamp", () => {
 
   test("construct from TimeStamp", () => {
     const ts = new TimeStamp(TimeSpan.microseconds(10));
-    expect(ts.equals(TimeSpan.microseconds(10))).toBeTruthy();
+    expect(ts.equals(TimeSpan.microseconds(10))).toBe(true);
   });
 
   test("construct from local TimeZone", () => {
     const ts = new TimeStamp(TimeSpan.microseconds(10), "local");
-    expect(ts.equals(TimeSpan.microseconds(10).add(TimeStamp.utcOffset))).toBeTruthy();
+    expect(ts.equals(TimeSpan.microseconds(10).add(TimeStamp.utcOffset))).toBe(true);
   });
 
   test("construct from time string", () => {
     const ts = new TimeStamp("12:30", "UTC");
     expect(ts.date().getUTCHours()).toEqual(12);
-    expect(ts.equals(TimeSpan.hours(12).add(TimeSpan.minutes(30)))).toBeTruthy();
+    expect(ts.equals(TimeSpan.hours(12).add(TimeSpan.minutes(30)))).toBe(true);
     const ts2 = new TimeStamp("12:30:00.22");
     expect(
       ts2.equals(
         TimeSpan.hours(12).add(TimeSpan.minutes(30).add(TimeSpan.milliseconds(22))),
       ),
-    ).toBeTruthy();
+    ).toBe(true);
     const ts3 = new TimeStamp("12:30:00.22", "local");
     expect(
       ts3.equals(
@@ -84,7 +85,7 @@ describe("TimeStamp", () => {
           .add(TimeSpan.minutes(30).add(TimeSpan.milliseconds(22)))
           .add(TimeStamp.utcOffset),
       ),
-    ).toBeTruthy();
+    ).toBe(true);
   });
 
   test("construct from date", () => {
@@ -108,16 +109,88 @@ describe("TimeStamp", () => {
     expect(ts2.date().getUTCMinutes()).toEqual(0);
   });
 
+  describe("schema", () => {
+    it("should parse bigint", () => {
+      const ts = TimeStamp.z.parse(1000000000n);
+      expect(ts).toBeInstanceOf(TimeStamp);
+      expect(ts.valueOf()).toBe(1000000000n);
+    });
+
+    it("should parse Date object", () => {
+      const date = new Date("2024-01-15T10:30:00.000Z");
+      const ts = TimeStamp.z.parse(date);
+      expect(ts).toBeInstanceOf(TimeStamp);
+      expect(ts.valueOf()).toBe(BigInt(date.getTime()) * 1000000n);
+    });
+
+    it("should parse TimeSpan", () => {
+      const span = new TimeSpan(5000000000n);
+      const ts = TimeStamp.z.parse(span);
+      expect(ts).toBeInstanceOf(TimeStamp);
+      expect(ts.valueOf()).toBe(5000000000n);
+    });
+
+    it("should parse DateComponents array", () => {
+      const ts = TimeStamp.z.parse([2024, 3, 15]);
+      expect(ts).toBeInstanceOf(TimeStamp);
+      const expected = new TimeStamp([2024, 3, 15]);
+      expect(ts.valueOf()).toBe(expected.valueOf());
+    });
+
+    it("should parse DateComponents with missing elements", () => {
+      const ts1 = TimeStamp.z.parse([2024]);
+      expect(ts1).toBeInstanceOf(TimeStamp);
+      expect(ts1.valueOf()).toBe(new TimeStamp([2024, 1, 1]).valueOf());
+
+      const ts2 = TimeStamp.z.parse([2024, 6]);
+      expect(ts2).toBeInstanceOf(TimeStamp);
+      expect(ts2.valueOf()).toBe(new TimeStamp([2024, 6, 1]).valueOf());
+    });
+
+    it("should parse string representation of bigint", () => {
+      const ts = TimeStamp.z.parse("123456789000");
+      expect(ts).toBeInstanceOf(TimeStamp);
+      expect(ts.valueOf()).toBe(123456789000n);
+    });
+
+    it("should parse number", () => {
+      const ts = TimeStamp.z.parse(987654321);
+      expect(ts).toBeInstanceOf(TimeStamp);
+      expect(ts.valueOf()).toBe(987654321n);
+    });
+
+    it("should parse object with value property", () => {
+      const ts = TimeStamp.z.parse({ value: 555555555n });
+      expect(ts).toBeInstanceOf(TimeStamp);
+      expect(ts.valueOf()).toBe(555555555n);
+    });
+
+    it("should pass through existing TimeStamp instance", () => {
+      const original = new TimeStamp(777777777n);
+      const ts = TimeStamp.z.parse(original);
+      expect(ts).toBe(original);
+      expect(ts.valueOf()).toBe(777777777n);
+    });
+
+    it("should handle edge cases", () => {
+      const ts1 = TimeStamp.z.parse(0);
+      expect(ts1.valueOf()).toBe(0n);
+
+      const ts2 = TimeStamp.z.parse(Number.MAX_SAFE_INTEGER);
+      expect(ts2.valueOf()).toBe(BigInt(Number.MAX_SAFE_INTEGER));
+    });
+  });
+
   test("span", () => {
     const ts = new TimeStamp(0);
-    expect(ts.span(new TimeStamp(1000)).equals(TimeSpan.microseconds())).toBeTruthy();
+    expect(ts.span(new TimeStamp(1000)).equals(TimeSpan.microseconds())).toBe(true);
   });
 
   test("range", () => {
     const ts = new TimeStamp(0);
     expect(
       ts.range(new TimeStamp(1000)).equals(new TimeRange(ts, TimeSpan.microseconds())),
-    ).toBeTruthy();
+    ).toBe(true);
   });
 
   test("spanRange", () => {
@@ -126,56 +199,56 @@ describe("TimeStamp", () => {
       ts
         .spanRange(TimeSpan.microseconds())
         .equals(new TimeRange(ts, ts.add(TimeSpan.microseconds()))),
-    ).toBeTruthy();
+    ).toBe(true);
   });
 
   test("isZero", () => {
     const ts = new TimeStamp(0);
-    expect(ts.isZero).toBeTruthy();
+    expect(ts.isZero).toBe(true);
   });
 
   test("after", () => {
     const ts = new TimeStamp(0);
-    expect(ts.after(new TimeStamp(-1))).toBeTruthy();
+    expect(ts.after(new TimeStamp(-1))).toBe(true);
     const ts2 = new TimeStamp(1);
-    expect(ts2.after(new TimeStamp(1))).toBeFalsy();
+    expect(ts2.after(new TimeStamp(1))).toBe(false);
   });
 
   test("before", () => {
     const ts = new TimeStamp(0);
-    expect(ts.before(new TimeStamp(1))).toBeTruthy();
+    expect(ts.before(new TimeStamp(1))).toBe(true);
     const ts2 = new TimeStamp(1);
-    expect(ts2.before(new TimeStamp(1))).toBeFalsy();
+    expect(ts2.before(new TimeStamp(1))).toBe(false);
   });
 
   test("beforeEq", () => {
     const ts = new TimeStamp(0);
-    expect(ts.beforeEq(new TimeStamp(1))).toBeTruthy();
+    expect(ts.beforeEq(new TimeStamp(1))).toBe(true);
     const ts2 = new TimeStamp(1);
-    expect(ts2.beforeEq(new TimeStamp(1))).toBeTruthy();
+    expect(ts2.beforeEq(new TimeStamp(1))).toBe(true);
     const ts3 = new TimeStamp(2);
-    expect(ts3.beforeEq(new TimeStamp(1))).toBeFalsy();
+    expect(ts3.beforeEq(new TimeStamp(1))).toBe(false);
   });
 
   test("afterEq", () => {
     const ts = new TimeStamp(0);
-    expect(ts.afterEq(new TimeStamp(-1))).toBeTruthy();
+    expect(ts.afterEq(new TimeStamp(-1))).toBe(true);
     const ts2 = new TimeStamp(1);
-    expect(ts2.afterEq(new TimeStamp(1))).toBeTruthy();
+    expect(ts2.afterEq(new TimeStamp(1))).toBe(true);
     const ts3 = new TimeStamp(0);
-    expect(ts3.afterEq(new TimeStamp(1))).toBeFalsy();
+    expect(ts3.afterEq(new TimeStamp(1))).toBe(false);
   });
 
   test("add", () => {
     const ts = new TimeStamp(0);
     expect(
       ts.add(TimeSpan.microseconds()).equals(new TimeStamp(TimeSpan.microseconds(1))),
-    ).toBeTruthy();
+    ).toBe(true);
   });
 
   test("sub", () => {
     const ts = new TimeStamp(TimeSpan.microseconds());
-    expect(ts.sub(TimeSpan.microseconds()).equals(new TimeStamp(0))).toBeTruthy();
+    expect(ts.sub(TimeSpan.microseconds()).equals(new TimeStamp(0))).toBe(true);
   });
 
   describe("fString", () => {
@@ -250,7 +323,7 @@ describe("TimeStamp", () => {
       expect(new TimeStamp([2022, 12, 15]).month).toEqual(11);
     });
     test("day", () => {
-      expect(new TimeStamp([2022, 12, 15]).day).toEqual(15);
+      expect(new TimeStamp([2022, 12, 15], "UTC").day).toEqual(15);
     });
   });
 
@@ -346,7 +419,7 @@ describe("TimeStamp", () => {
         `expected ${new TimeSpan(expectedRemainder).toString()} got ${new TimeSpan(
           remainder,
         ).toString()}`,
-      ).toBeTruthy();
+      ).toBe(true);
     });
     test("second", () => {
       const expectedRemainder = TimeSpan.milliseconds(12);
@@ -355,40 +428,66 @@ describe("TimeStamp", () => {
         .add(TimeSpan.minutes(20))
         .add(TimeSpan.milliseconds(12));
       const remainder = ts.remainder(TimeSpan.seconds());
-      expect(remainder.equals(expectedRemainder)).toBeTruthy();
+      expect(remainder.equals(expectedRemainder)).toBe(true);
+    });
+  });
+
+  describe("sort", () => {
+    interface Spec {
+      a: TimeStamp;
+      b: TimeStamp;
+      expected: number;
+    }
+    const TESTS: Spec[] = [
+      {
+        a: TimeStamp.seconds(3),
+        b: TimeStamp.seconds(2),
+        expected: TimeSpan.seconds(1).nanoseconds,
+      },
+      {
+        a: TimeStamp.seconds(2),
+        b: TimeStamp.seconds(3),
+        expected: TimeSpan.seconds(-1).nanoseconds,
+      },
+      { a: TimeStamp.seconds(2), b: TimeStamp.seconds(2), expected: 0 },
+    ];
+    TESTS.forEach(({ a, b, expected }) => {
+      test(`TimeStamp.sort(${a.toString()}, ${b.toString()}) = ${expected}`, () => {
+        expect(TimeStamp.sort(a, b)).toEqual(expected);
+      });
     });
   });
 });
 
 describe("TimeSpan", () => {
   test("construct from static", () => {
-    expect(TimeSpan.nanoseconds(1).equals(1)).toBeTruthy();
-    expect(TimeSpan.microseconds(1).equals(1000)).toBeTruthy();
-    expect(TimeSpan.milliseconds(1).equals(1000000)).toBeTruthy();
-    expect(TimeSpan.seconds(1).equals(1e9)).toBeTruthy();
-    expect(TimeSpan.minutes(1).equals(6e10)).toBeTruthy();
-    expect(TimeSpan.hours(1).equals(36e11)).toBeTruthy();
+    expect(TimeSpan.nanoseconds(1).equals(1)).toBe(true);
+    expect(TimeSpan.microseconds(1).equals(1000)).toBe(true);
+    expect(TimeSpan.milliseconds(1).equals(1000000)).toBe(true);
+    expect(TimeSpan.seconds(1).equals(1e9)).toBe(true);
+    expect(TimeSpan.minutes(1).equals(6e10)).toBe(true);
+    expect(TimeSpan.hours(1).equals(36e11)).toBe(true);
   });
 
   describe("fromMilliseconds", () => {
     it("should interpret a pure number or bigint as milliseconds", () => {
       const ts = TimeSpan.fromMilliseconds(1000);
-      expect(ts.equals(TimeSpan.seconds())).toBeTruthy();
+      expect(ts.equals(TimeSpan.seconds())).toBe(true);
     });
     it("should interpret a TimeSpan as a normal TimeSpan", () => {
       const ts = TimeSpan.fromMilliseconds(TimeSpan.milliseconds(30));
-      expect(ts.equals(TimeSpan.milliseconds(30))).toBeTruthy();
+      expect(ts.equals(TimeSpan.milliseconds(30))).toBe(true);
     });
   });
 
   describe("fromSeconds", () => {
     it("should interpret a pure number or bigint as seconds", () => {
       const ts = TimeSpan.fromSeconds(1);
-      expect(ts.equals(TimeSpan.SECOND)).toBeTruthy();
+      expect(ts.equals(TimeSpan.SECOND)).toBe(true);
     });
     it("should interpret a TimeSpan as a normal TimeSpan", () => {
       const ts = TimeSpan.fromSeconds(TimeSpan.milliseconds(30));
-      expect(ts.equals(TimeSpan.milliseconds(30))).toBeTruthy();
+      expect(ts.equals(TimeSpan.milliseconds(30))).toBe(true);
     });
   });
 
@@ -397,16 +496,16 @@ describe("TimeSpan", () => {
   });
 
   test("isZero", () => {
-    expect(TimeSpan.ZERO.isZero).toBeTruthy();
-    expect(TimeSpan.seconds(1).isZero).toBeFalsy();
+    expect(TimeSpan.ZERO.isZero).toBe(true);
+    expect(TimeSpan.seconds(1).isZero).toBe(false);
   });
 
   test("add", () => {
-    expect(TimeSpan.seconds(1).add(TimeSpan.SECOND).equals(2e9)).toBeTruthy();
+    expect(TimeSpan.seconds(1).add(TimeSpan.SECOND).equals(2e9)).toBe(true);
   });
 
   test("sub", () => {
-    expect(TimeSpan.seconds(1).sub(TimeSpan.SECOND).isZero).toBeTruthy();
+    expect(TimeSpan.seconds(1).sub(TimeSpan.SECOND).isZero).toBe(true);
   });
 
   const TRUNCATE_TESTS = [
@@ -419,7 +518,7 @@ describe("TimeSpan", () => {
       expect(
         ts.truncate(unit).equals(expected),
         `expected ${expected.toString()} got ${ts.truncate(unit).toString()}`,
-      ).toBeTruthy();
+      ).toBe(true);
     });
   });
 
@@ -434,7 +533,7 @@ describe("TimeSpan", () => {
 
   test("remainder", () => {
     REMAINDER_TESTS.forEach(([ts, unit, expected]) => {
-      expect(ts.remainder(unit).equals(expected)).toBeTruthy();
+      expect(ts.remainder(unit).equals(expected)).toBe(true);
     });
   });
 
@@ -463,12 +562,12 @@ describe("TimeSpan", () => {
 });
 
 describe("Rate", () => {
-  test("construct", () => expect(new Rate(1).equals(1)).toBeTruthy());
+  test("construct", () => expect(new Rate(1).equals(1)).toBe(true));
 
-  test("period", () => expect(new Rate(1).period.equals(TimeSpan.SECOND)).toBeTruthy());
+  test("period", () => expect(new Rate(1).period.equals(TimeSpan.SECOND)).toBe(true));
 
   test("period", () =>
-    expect(new Rate(2).period.equals(TimeSpan.milliseconds(500))).toBeTruthy());
+    expect(new Rate(2).period.equals(TimeSpan.milliseconds(500))).toBe(true));
 
   test("sampleCount", () =>
     expect(new Rate(1).sampleCount(TimeSpan.SECOND)).toEqual(1));
@@ -477,22 +576,22 @@ describe("Rate", () => {
     expect(new Rate(1).byteCount(TimeSpan.SECOND, Density.BIT64)).toEqual(8));
 
   test("span", () =>
-    expect(new Rate(1).span(4).equals(TimeSpan.seconds(4))).toBeTruthy());
+    expect(new Rate(1).span(4).equals(TimeSpan.seconds(4))).toBe(true));
 
   test("byteSpan", () =>
     expect(
       new Rate(1).byteSpan(new Size(32), Density.BIT64).equals(TimeSpan.seconds(4)),
-    ).toBeTruthy());
+    ).toBe(true));
 
-  test("Hz", () => expect(Rate.hz(1).equals(1)).toBeTruthy());
-  test("KHz", () => expect(Rate.khz(1).equals(1e3)).toBeTruthy());
+  test("Hz", () => expect(Rate.hz(1).equals(1)).toBe(true));
+  test("KHz", () => expect(Rate.khz(1).equals(1e3)).toBe(true));
 });
 
 describe("TimeRange", () => {
   test("construct", () => {
     const tr = new TimeRange(new TimeStamp(0), new TimeStamp(1000));
-    expect(tr.start.equals(new TimeStamp(0))).toBeTruthy();
-    expect(tr.end.equals(new TimeStamp(1000))).toBeTruthy();
+    expect(tr.start.equals(new TimeStamp(0))).toBe(true);
+    expect(tr.end.equals(new TimeStamp(1000))).toBe(true);
   });
 
   test("construct from object", () => {
@@ -500,69 +599,69 @@ describe("TimeRange", () => {
       start: new TimeStamp(1000),
       end: new TimeStamp(100000),
     });
-    expect(tr.start.equals(new TimeStamp(1000))).toBeTruthy();
-    expect(tr.end.equals(new TimeStamp(100000))).toBeTruthy();
+    expect(tr.start.equals(new TimeStamp(1000))).toBe(true);
+    expect(tr.end.equals(new TimeStamp(100000))).toBe(true);
   });
 
   test("span", () => {
     const tr = new TimeRange(new TimeStamp(0), new TimeStamp(1000));
-    expect(tr.span.equals(TimeSpan.MICROSECOND)).toBeTruthy();
+    expect(tr.span.equals(TimeSpan.MICROSECOND)).toBe(true);
   });
 
   test("isValid", () => {
     const tr = new TimeRange(new TimeStamp(0), new TimeStamp(1000));
-    expect(tr.isValid).toBeTruthy();
+    expect(tr.isValid).toBe(true);
     const tr2 = new TimeRange(new TimeStamp(1000), new TimeStamp(0));
-    expect(tr2.isValid).toBeFalsy();
+    expect(tr2.isValid).toBe(false);
   });
 
   test("isZero", () => {
     const tr = new TimeRange(new TimeStamp(0), new TimeStamp(0));
-    expect(tr.isZero).toBeTruthy();
+    expect(tr.isZero).toBe(true);
     const tr2 = new TimeRange(new TimeStamp(0), new TimeStamp(1000));
-    expect(tr2.isZero).toBeFalsy();
+    expect(tr2.isZero).toBe(false);
   });
 
   test("swap", () => {
     const tr = new TimeRange(new TimeStamp(0), new TimeStamp(1000));
-    expect(
-      tr.swap().equals(new TimeRange(new TimeStamp(1000), new TimeStamp(0))),
-    ).toBeTruthy();
+    expect(tr.swap().equals(new TimeRange(new TimeStamp(1000), new TimeStamp(0)))).toBe(
+      true,
+    );
   });
   describe("contains", () => {
     test("TimeStamp", () => {
       const tr = new TimeRange(new TimeStamp(0), new TimeStamp(1000));
-      expect(tr.contains(new TimeStamp(500))).toBeTruthy();
-      expect(tr.contains(new TimeStamp(1001))).toBeFalsy();
+      expect(tr.contains(new TimeStamp(500))).toBe(true);
+      expect(tr.contains(new TimeStamp(1001))).toBe(false);
     });
     test("TimeRange", () => {
       const tr = new TimeRange(new TimeStamp(0), new TimeStamp(1000));
-      expect(
-        tr.contains(new TimeRange(new TimeStamp(500), new TimeStamp(600))),
-      ).toBeTruthy();
-      expect(
-        tr.contains(new TimeRange(new TimeStamp(500), new TimeStamp(1001))),
-      ).toBeFalsy();
+      expect(tr.contains(new TimeRange(new TimeStamp(500), new TimeStamp(600)))).toBe(
+        true,
+      );
+      expect(tr.contains(new TimeRange(new TimeStamp(500), new TimeStamp(1001)))).toBe(
+        false,
+      );
     });
   });
   describe("overlapsWith", () => {
     it("should return true if the end of one time range is after the start of the next time range", () => {
       const tr = new TimeRange(new TimeStamp(0), new TimeStamp(1000));
       const one = new TimeRange(new TimeStamp(500), new TimeStamp(600));
-      expect(tr.overlapsWith(one)).toBeTruthy();
-      expect(one.overlapsWith(tr)).toBeTruthy();
+      expect(tr.overlapsWith(one)).toBe(true);
+      expect(one.overlapsWith(tr)).toBe(true);
     });
     it("should return false if two time ranges are clearly separate", () => {
       const tr = new TimeRange(new TimeStamp(0), new TimeStamp(1000));
       const one = new TimeRange(new TimeStamp(1001), new TimeStamp(2000));
-      expect(tr.overlapsWith(one)).toBeFalsy();
-      expect(one.overlapsWith(tr)).toBeFalsy();
+      expect(tr.overlapsWith(one)).toBe(false);
+      expect(one.overlapsWith(tr)).toBe(false);
     });
     it("should return false if the end of the first time range is the start of the next time range", () => {
       const tr = new TimeRange(new TimeStamp(0), new TimeStamp(1000));
       const one = new TimeRange(new TimeStamp(1000), new TimeStamp(2000));
-      expect(tr.overlapsWith(one)).toBeFalsy();
-      expect(one.overlapsWith(tr)).toBeFalsy();
+      expect(tr.overlapsWith(one)).toBe(false);
+      expect(one.overlapsWith(tr)).toBe(false);
     });
     it("should return true only if the overlap is within a threshold", () => {
       const tr = new TimeRange(TimeStamp.milliseconds(0), TimeStamp.milliseconds(1000));
@@ -570,13 +669,13 @@ describe("TimeRange", () => {
         TimeStamp.milliseconds(998),
         TimeStamp.milliseconds(2000),
       );
-      expect(tr.overlapsWith(one, TimeSpan.milliseconds(2))).toBeTruthy();
-      expect(one.overlapsWith(tr, TimeSpan.milliseconds(3))).toBeFalsy();
+      expect(tr.overlapsWith(one, TimeSpan.milliseconds(2))).toBe(true);
+      expect(one.overlapsWith(tr, TimeSpan.milliseconds(3))).toBe(false);
     });
     it("should return two for two ZERO time ranges", () => {
       const tr = new TimeRange(TimeStamp.ZERO, TimeStamp.ZERO);
       const one = new TimeRange(TimeStamp.ZERO, TimeStamp.ZERO);
-      expect(tr.overlapsWith(one)).toBeTruthy();
+      expect(tr.overlapsWith(one)).toBe(true);
     });
   });
 
@@ -586,14 +685,14 @@ describe("TimeRange", () => {
       const bound = new TimeRange(TimeSpan.seconds(2), TimeSpan.seconds(3));
       const bounded = tr.boundBy(bound);
       const expected = new TimeRange(TimeSpan.seconds(2), TimeSpan.seconds(3));
-      expect(bounded.equals(expected)).toBeTruthy();
+      expect(bounded.equals(expected)).toBe(true);
     });
     it("should bound the time range even if the start is after the end", () => {
       const tr = new TimeRange(TimeSpan.seconds(4), TimeSpan.seconds(1));
       const bound = new TimeRange(TimeSpan.seconds(2), TimeSpan.seconds(3));
       const bounded = tr.boundBy(bound);
       const expected = new TimeRange(TimeSpan.seconds(3), TimeSpan.seconds(2));
-      expect(bounded.equals(expected)).toBeTruthy();
+      expect(bounded.equals(expected)).toBe(true);
     });
   });
 
@@ -604,8 +703,8 @@ describe("TimeRange", () => {
         TimeSpan.seconds(1),
         TimeSpan.seconds(4).add(TimeSpan.milliseconds(500)),
       );
-      expect(tr.equals(one, TimeSpan.seconds(1))).toBeTruthy();
-      expect(tr.equals(one, TimeSpan.seconds(0))).toBeFalsy();
+      expect(tr.equals(one, TimeSpan.seconds(1))).toBe(true);
+      expect(tr.equals(one, TimeSpan.seconds(0))).toBe(false);
     });
   });
 
@@ -622,15 +721,60 @@ describe("TimeRange", () => {
     const trString = tr.toString();
     expect(trString).toEqual("1970-01-03T00:20:00.283Z - 1970-01-05T00:20:00.283Z");
   });
-});
 
-describe("DataType", () => {
-  test("json serialization", () => {
-    const dt = DataType.INT32;
-    const v = JSON.parse(JSON.stringify({ dt }));
-    expect(v.dt === "int32").toBeTruthy();
+  describe("sort", () => {
+    interface Spec {
+      a: TimeRange;
+      b: TimeRange;
+      expected: number;
+    }
+    const TESTS: Spec[] = [
+      { a: new TimeRange(1, 2), b: new TimeRange(2, 3), expected: -1 },
+      { a: new TimeRange(2, 3), b: new TimeRange(1, 2), expected: 1 },
+      { a: new TimeRange(1, 2), b: new TimeRange(1, 2), expected: 0 },
+      { a: new TimeRange(2, 0), b: new TimeRange(1, 1), expected: 1 },
+      { a: new TimeRange(2, 2), b: new TimeRange(3, 0), expected: -1 },
+      { a: new TimeRange(2, 8), b: new TimeRange(2, 9), expected: -1 },
+      { a: new TimeRange(2, 9), b: new TimeRange(2, 8), expected: 1 },
+    ];
+    TESTS.forEach(({ a, b, expected }) => {
+      test(`TimeRange.sort(${a.toString()}, ${b.toString()}) = ${expected}`, () => {
+        expect(TimeRange.sort(a, b)).toEqual(expected);
+      });
+    });
   });
+  describe("numericBounds", () => {
+    it("should return correct numeric bounds for a valid time range", () => {
+      const tr = new TimeRange(TimeSpan.seconds(1), TimeSpan.seconds(4));
+      const bounds = tr.numericBounds;
+      expect(bounds.lower).toBe(tr.start.nanoseconds);
+      expect(bounds.upper).toBe(tr.end.nanoseconds);
+    });
 
+    it("should return correct numeric bounds for an invalid time range", () => {
+      const tr = new TimeRange(TimeSpan.seconds(4), TimeSpan.seconds(1));
+      const bounds = tr.numericBounds;
+      expect(bounds.lower).toBe(tr.start.nanoseconds);
+      expect(bounds.upper).toBe(tr.end.nanoseconds);
+    });
+
+    it("should handle zero time range", () => {
+      const tr = new TimeRange(TimeStamp.ZERO, TimeStamp.ZERO);
+      const bounds = tr.numericBounds;
+      expect(bounds.lower).toBe(0);
+      expect(bounds.upper).toBe(0);
+    });
+
+    it("should handle large time values", () => {
+      const tr = new TimeRange(TimeSpan.days(365), TimeSpan.days(730));
+      const bounds = tr.numericBounds;
+      expect(bounds.lower).toBe(tr.start.nanoseconds);
+      expect(bounds.upper).toBe(tr.end.nanoseconds);
+    });
+  });
+});
+
+describe("DataType", () => {
   describe("isVariable", () => {
     it("should return true if the data type has a variable length", () => {
       expect(DataType.INT32.isVariable).toBe(false);
@@ -680,6 +824,7 @@ describe("DataType", () => {
       }),
     );
   });
+
   describe("canCastTo", () => {
     it("should return true for any two numeric data types", () => {
       const numericTypes = [
@@ -745,3 +890,30 @@ describe("Size", () => {
     });
   });
 });
+
+describe("addSamples", () => {
+  test("adds two numbers", () => {
+    expect(addSamples(1, 2)).toBe(3);
+    expect(addSamples(1.5, 2.5)).toBe(4);
+    expect(addSamples(-1, 1)).toBe(0);
+  });
+
+  test("adds two bigints", () => {
+    expect(addSamples(1n, 2n)).toBe(3n);
+    expect(addSamples(-1n, 1n)).toBe(0n);
+    expect(addSamples(9007199254740991n, 1n)).toBe(9007199254740992n);
+  });
+
+  test("handles mixed numeric types", () => {
+    expect(addSamples(1, 2n)).toBe(3);
+    expect(addSamples(2n, 1)).toBe(3);
+    expect(addSamples(1.5, 2n)).toBe(3.5);
+    expect(addSamples(2n, 1.5)).toBe(3.5);
+  });
+
+  test("handles edge cases", () => {
+    expect(addSamples(0, 0)).toBe(0);
+    expect(addSamples(Number.MAX_SAFE_INTEGER, 1)).toBe(Number.MAX_SAFE_INTEGER + 1);
+    expect(addSamples(Number.MIN_SAFE_INTEGER, -1)).toBe(Number.MIN_SAFE_INTEGER - 1);
+  });
+});