@synnaxlabs/x 0.55.0 → 0.56.0

package/src/telem/telem.spec.ts

@@ -10,7 +10,9 @@
 import { afterEach, beforeEach, describe, expect, it, test } from "vitest";
 
 import { binary } from "@/binary";
+import { primitive } from "@/primitive";
 import {
+  convertDataType,
   type CrudeDataType,
   DataType,
   Density,
@@ -19,7 +21,7 @@ import {
   TimeRange,
   TimeSpan,
   TimeStamp,
-  type TimeStampStringFormat,
+  type TimestampFormat,
 } from "@/telem";
 
 describe("TimeStamp", () => {
@@ -136,7 +138,7 @@ describe("TimeStamp", () => {
       expect(ts.millisecond).toBe(0);
     });
 
-    test("should round-trip when using local tzInfo", () => {
+    test("should round-trip when using local TimeZone", () => {
       const input = "2025-11-03T17:44:45.809";
       const ts1 = new TimeStamp(input, "local");
       const output = ts1.toString("ISO", "local").slice(0, -1);
@@ -539,10 +541,9 @@ describe("TimeStamp", () => {
       .add(TimeSpan.minutes(20))
       .add(TimeSpan.milliseconds(12));
 
-    const FORMAT_TESTS: [TimeStampStringFormat, string][] = [
+    const FORMAT_TESTS: [TimestampFormat, string][] = [
       ["ISO", "2022-12-15T12:20:00.012Z"],
       ["ISODate", "2022-12-15"],
-      ["ISOTime", "12:20:00.012"],
       ["time", "12:20:00"],
       ["preciseTime", "12:20:00.012"],
       ["date", "Dec 15"],
@@ -920,10 +921,10 @@ describe("TimeStamp", () => {
   });
 
   describe("formatBySpan", () => {
-    test("should return 'shortDate' for spans >= 30 days", () => {
+    test("should return 'date' for spans >= 30 days", () => {
       const ts = new TimeStamp([2022, 12, 15], "UTC");
       const span = TimeSpan.days(30);
-      expect(ts.formatBySpan(span)).toBe("shortDate");
+      expect(ts.formatBySpan(span)).toBe("date");
     });
 
     test("should return 'dateTime' for spans >= 1 day", () => {
@@ -944,16 +945,34 @@ describe("TimeStamp", () => {
       expect(ts.formatBySpan(span)).toBe("preciseTime");
     });
 
-    test("should return 'ISOTime' for spans < 1 second", () => {
+    test("should return 'preciseTime' for spans < 1 second", () => {
       const ts = new TimeStamp([2022, 12, 15], "UTC");
       const span = TimeSpan.milliseconds(500);
-      expect(ts.formatBySpan(span)).toBe("ISOTime");
+      expect(ts.formatBySpan(span)).toBe("preciseTime");
     });
 
     test("should work with very small spans", () => {
       const ts = new TimeStamp([2022, 12, 15], "UTC");
       const span = TimeSpan.microseconds(100);
-      expect(ts.formatBySpan(span)).toBe("ISOTime");
+      expect(ts.formatBySpan(span)).toBe("preciseTime");
+    });
+  });
+
+  describe("hash", () => {
+    it("returns the bigint nanosecond value as a string", () => {
+      expect(new TimeStamp(1234567890n).hash()).toBe("1234567890");
+    });
+
+    it("is stable across instances representing the same value", () => {
+      expect(new TimeStamp(42n).hash()).toBe(new TimeStamp(42n).hash());
+    });
+
+    it("differs across distinct values", () => {
+      expect(new TimeStamp(1n).hash()).not.toBe(new TimeStamp(2n).hash());
+    });
+
+    it("satisfies primitive.isHashable", () => {
+      expect(primitive.isHashable(new TimeStamp(0n))).toBe(true);
     });
   });
 });
@@ -1358,6 +1377,20 @@ describe("TimeSpan", () => {
       expect(ts2.valueOf()).toBe(BigInt(Number.MAX_SAFE_INTEGER));
     });
   });
+
+  describe("hash", () => {
+    it("returns the bigint nanosecond value as a string", () => {
+      expect(TimeSpan.milliseconds(500).hash()).toBe("500000000");
+    });
+
+    it("is stable across instances representing the same value", () => {
+      expect(TimeSpan.seconds(1).hash()).toBe(TimeSpan.seconds(1).hash());
+    });
+
+    it("satisfies primitive.isHashable", () => {
+      expect(primitive.isHashable(TimeSpan.ZERO)).toBe(true);
+    });
+  });
 });
 
 describe("Rate", () => {
@@ -1474,6 +1507,20 @@ describe("Rate", () => {
       expect(result.valueOf()).toBe(200);
     });
   });
+
+  describe("hash", () => {
+    it("returns the Hz value as a string", () => {
+      expect(new Rate(100).hash()).toBe("100");
+    });
+
+    it("is stable across instances representing the same value", () => {
+      expect(new Rate(60).hash()).toBe(new Rate(60).hash());
+    });
+
+    it("satisfies primitive.isHashable", () => {
+      expect(primitive.isHashable(new Rate(1))).toBe(true);
+    });
+  });
 });
 
 describe("TimeRange", () => {
@@ -1751,6 +1798,33 @@ describe("TimeRange", () => {
       });
     });
   });
+
+  describe("hash", () => {
+    it("composes the start and end hashes with a dash", () => {
+      const tr = new TimeRange(new TimeStamp(100n), new TimeStamp(200n));
+      expect(tr.hash()).toBe("100-200");
+    });
+
+    it("is stable across instances representing the same range", () => {
+      const a = new TimeRange(new TimeStamp(1n), new TimeStamp(2n));
+      const b = new TimeRange(new TimeStamp(1n), new TimeStamp(2n));
+      expect(a.hash()).toBe(b.hash());
+    });
+
+    it("differs when start or end differs", () => {
+      const base = new TimeRange(new TimeStamp(1n), new TimeStamp(2n));
+      expect(base.hash()).not.toBe(
+        new TimeRange(new TimeStamp(1n), new TimeStamp(3n)).hash(),
+      );
+      expect(base.hash()).not.toBe(
+        new TimeRange(new TimeStamp(0n), new TimeStamp(2n)).hash(),
+      );
+    });
+
+    it("satisfies primitive.isHashable", () => {
+      expect(primitive.isHashable(TimeRange.ZERO)).toBe(true);
+    });
+  });
 });
 
 describe("Density", () => {
@@ -2022,6 +2096,25 @@ describe("DataType", () => {
       });
     });
   });
+
+  describe("hash", () => {
+    it("returns the data type identifier as a string", () => {
+      expect(DataType.FLOAT32.hash()).toBe("float32");
+      expect(DataType.STRING.hash()).toBe("string");
+    });
+
+    it("is stable across instances representing the same data type", () => {
+      expect(new DataType("uint8").hash()).toBe(new DataType("uint8").hash());
+    });
+
+    it("differs across distinct data types", () => {
+      expect(DataType.FLOAT32.hash()).not.toBe(DataType.FLOAT64.hash());
+    });
+
+    it("satisfies primitive.isHashable", () => {
+      expect(primitive.isHashable(DataType.UNKNOWN)).toBe(true);
+    });
+  });
 });
 
 describe("Size", () => {
@@ -2163,3 +2256,29 @@ describe("Size", () => {
     });
   });
 });
+
+describe("convertDataType", () => {
+  it("preserves precision when subtracting a bigint offset above 2^53 (INT64 -> FLOAT32)", () => {
+    const offset = 1778020940471336960n;
+    const value = 1778020940471336960n + 137438953472n;
+    const result = convertDataType(DataType.INT64, DataType.FLOAT32, value, offset);
+    expect(result).toBe(137438953472);
+  });
+
+  it("preserves precision when subtracting a bigint offset above 2^53 (TIMESTAMP -> FLOAT32)", () => {
+    const offset = 1778020940471336960n;
+    const value = 1778020940471336960n + 1n;
+    const result = convertDataType(DataType.TIMESTAMP, DataType.FLOAT32, value, offset);
+    expect(result).toBe(1);
+  });
+
+  it("returns a bigint when target uses bigint and source does not", () => {
+    const result = convertDataType(DataType.FLOAT32, DataType.INT64, 100, 10);
+    expect(result).toBe(90n);
+  });
+
+  it("falls back to math.sub when neither source nor target use bigint", () => {
+    const result = convertDataType(DataType.FLOAT32, DataType.FLOAT64, 5.5, 1.5);
+    expect(result).toBe(4);
+  });
+});

package/src/telem/telem.ts

@@ -12,25 +12,11 @@ import { z } from "zod";
 import { math } from "@/math";
 import { primitive } from "@/primitive";
 import { type bounds } from "@/spatial";
-
-/** Time zone specification when working with time stamps. */
-export type TZInfo = "UTC" | "local";
+import { type TimestampFormat, type TimeZone } from "@/telem/types.gen";
 
 const SIMPLE_DAYS_IN_YEAR = 365;
 const SIMPLE_DAYS_IN_MONTH = 30;
 
-/** Different string formats for time stamps. */
-export type TimeStampStringFormat =
-  | "ISO"
-  | "ISODate"
-  | "ISOTime"
-  | "time"
-  | "preciseTime"
-  | "date"
-  | "preciseDate"
-  | "shortDate"
-  | "dateTime";
-
 /** Different string formats for time spans. */
 export type TimeSpanStringFormat = "full" | "semantic";
 
@@ -79,35 +65,42 @@ UTC timestamp. Synnax uses a nanosecond precision int64 timestamp.
  *
  * 1. A number representing the number of nanoseconds since the Unix epoch.
  * 2. A JavaScript Date object.
- * 3. An array of numbers satisfying the DateComponents type, where the first element is the
- *   year, the second is the month, and the third is the day. To increase resolution
- *   when using this method, use the add method. It's important to note that this initializes
- *   a timestamp at midnight UTC, regardless of the timezone specified.
- * 4. An ISO compliant date or date time string. The time zone component is ignored.
+ * 3. An array of numbers satisfying the DateComponents type, where the first element is
+ *    the year, the second is the month, and the third is the day. To increase
+ *    resolution when using this method, use the add method. It's important to note that
+ *    this initializes a timestamp at midnight UTC, regardless of the TimeZone
+ *    specified.
+ * 4. An ISO compliant date or date time string. The TimeZone component is ignored.
  *
- * @param tzInfo - The timezone to use when parsing the timestamp. This can be either "UTC" or
- * "local". This parameter is ignored if the value is a Date object or a DateComponents array.
+ * @param timeZone - The TimeZone to use when parsing the TimeStamp. This can be either
+ * "UTC" or "local". This parameter is ignored if the value is a Date object or a
+ * DateComponents array.
  *
  * @example ts = new TimeStamp(1 * TimeSpan.HOUR) // 1 hour after the Unix epoch
- * @example ts = new TimeStamp([2021, 1, 1]) // 1/1/2021 at midnight UTC
- * @example ts = new TimeStamp([2021, 1, 1]).add(1 * TimeSpan.HOUR) // 1/1/2021 at 1am UTC
- * @example ts = new TimeStamp("2021-01-01T12:30:00Z") // 1/1/2021 at 12:30pm UTC
+ * @example ts = new TimeStamp([2021, 1, 1]) // 1/1/2021 midnight UTC
+ * @example ts = new TimeStamp([2021, 1, 1]).add(1 * TimeSpan.HOUR) // 1/1/2021 1am UTC
+ * @example ts = new TimeStamp("2021-01-01T12:30:00Z") // 1/1/2021 12:30pm UTC
  */
 export class TimeStamp
   extends primitive.ValueExtension<bigint>
-  implements primitive.Stringer
+  implements primitive.Stringer, primitive.Hashable
 {
-  constructor(value?: CrudeTimeStamp, tzInfo: TZInfo = "UTC") {
+  /** @returns the bigint nanosecond value as a string for stable hashing. */
+  hash(): string {
+    return this.value.toString();
+  }
+
+  constructor(value?: CrudeTimeStamp, timeZone: TimeZone = "UTC") {
     if (value == null) super(TimeStamp.now().valueOf());
     else if (value instanceof Date)
       super(BigInt(value.getTime()) * TimeStamp.MILLISECOND.valueOf());
     else if (typeof value === "string")
-      super(TimeStamp.parseDateTimeString(value, tzInfo).valueOf());
+      super(TimeStamp.parseDateTimeString(value, timeZone).valueOf());
     else if (Array.isArray(value)) super(TimeStamp.parseDate(value));
     else {
       let offset = 0n;
       if (value instanceof Number) value = value.valueOf();
-      if (tzInfo === "local") offset = TimeStamp.utcOffset.valueOf();
+      if (timeZone === "local") offset = TimeStamp.utcOffset.valueOf();
       if (typeof value === "number")
         if (isFinite(value))
           if (value === math.MAX_INT64_NUMBER) value = math.MAX_INT64;
@@ -138,7 +131,7 @@ export class TimeStamp
     return this.value;
   }
 
-  private static parseTimeString(time: string, tzInfo: TZInfo = "UTC"): bigint {
+  private static parseTimeString(time: string, timeZone: TimeZone = "UTC"): bigint {
     const [hours, minutes, mbeSeconds] = time.split(":");
     let seconds = "00";
     let milliseconds: string | undefined = "00";
@@ -147,13 +140,13 @@ export class TimeStamp
       .add(TimeStamp.minutes(parseInt(minutes ?? "00", 10)))
       .add(TimeStamp.seconds(parseInt(seconds ?? "00", 10)))
       .add(TimeStamp.milliseconds(parseInt(milliseconds ?? "00", 10)));
-    if (tzInfo === "local") base = base.add(TimeStamp.utcOffset);
+    if (timeZone === "local") base = base.add(TimeStamp.utcOffset);
     return base.valueOf();
   }
 
-  private static parseDateTimeString(str: string, tzInfo: TZInfo = "UTC"): bigint {
+  private static parseDateTimeString(str: string, timeZone: TimeZone = "UTC"): bigint {
     if (!str.includes("/") && !str.includes("-"))
-      return TimeStamp.parseTimeString(str, tzInfo);
+      return TimeStamp.parseTimeString(str, timeZone);
 
     const isDateTimeLocal =
       str.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?$/) != null;
@@ -170,7 +163,7 @@ export class TimeStamp
       }
 
       const d =
-        tzInfo === "local"
+        timeZone === "local"
           ? new Date(datePart.replace("T", " "))
           : new Date(`${datePart}Z`);
 
@@ -181,17 +174,17 @@ export class TimeStamp
     }
 
     const d = new Date(str);
-    // Essential to note that this makes the date midnight in UTC! Not local!
-    // As a result, we need to add the tzInfo offset back in.
+    // Essential to note that this makes the date midnight in UTC! Not local! As a
+    // result, we need to add the timeZone offset back in.
     if (!str.includes(":")) d.setUTCHours(0, 0, 0, 0);
     return new TimeStamp(
       BigInt(d.getTime()) * TimeStamp.MILLISECOND.valueOf(),
-      tzInfo,
+      timeZone,
     ).valueOf();
   }
 
-  private toISOString(tzInfo: TZInfo = "UTC"): string {
-    if (tzInfo === "UTC") return this.date().toISOString();
+  private toISOString(timeZone: TimeZone = "UTC"): string {
+    if (timeZone === "UTC") return this.date().toISOString();
     const d = this.date();
     const offset = new TimeSpan(
       BigInt(d.getTimezoneOffset()) * TimeStamp.MINUTE.valueOf(),
@@ -199,8 +192,11 @@ export class TimeStamp
     return this.sub(offset).date().toISOString();
   }
 
-  private timeString(milliseconds: boolean = false, tzInfo: TZInfo = "UTC"): string {
-    const iso = this.toISOString(tzInfo);
+  private timeString(
+    milliseconds: boolean = false,
+    timeZone: TimeZone = "UTC",
+  ): string {
+    const iso = this.toISOString(timeZone);
     return milliseconds ? iso.slice(11, 23) : iso.slice(11, 19);
   }
 
@@ -639,27 +635,25 @@ export class TimeStamp
    * Returns a string representation of the TimeStamp.
    *
    * @param format - Optional format for the string representation. Defaults to "ISO".
-   * @param tzInfo - Optional timezone info. Defaults to "UTC".
+   * @param timeZone - Optional TimeZone. Defaults to "UTC".
    * @returns A string representation of the TimeStamp.
    */
-  toString(format: TimeStampStringFormat = "ISO", tzInfo: TZInfo = "UTC"): string {
+  toString(format: TimestampFormat = "ISO", timeZone: TimeZone = "UTC"): string {
     switch (format) {
       case "ISODate":
-        return this.toISOString(tzInfo).slice(0, 10);
-      case "ISOTime":
-        return this.toISOString(tzInfo).slice(11, 23);
+        return this.toISOString(timeZone).slice(0, 10);
       case "time":
-        return this.timeString(false, tzInfo);
+        return this.timeString(false, timeZone);
       case "preciseTime":
-        return this.timeString(true, tzInfo);
+        return this.timeString(true, timeZone);
       case "date":
         return this.dateString();
       case "preciseDate":
-        return `${this.dateString()} ${this.timeString(true, tzInfo)}`;
+        return `${this.dateString()} ${this.timeString(true, timeZone)}`;
       case "dateTime":
-        return `${this.dateString()} ${this.timeString(false, tzInfo)}`;
+        return `${this.dateString()} ${this.timeString(false, timeZone)}`;
       default:
-        return this.toISOString(tzInfo);
+        return this.toISOString(timeZone);
     }
   }
 
@@ -697,22 +691,19 @@ export class TimeStamp
    * Determines the appropriate string format based on the span magnitude.
    *
    * @param span - The span that provides context for format selection
-   * @returns The appropriate TimeStampStringFormat
+   * @returns The appropriate TimestampFormat
    *
    * Rules:
-   * - For spans >= 30 days: "shortDate" (e.g., "Nov 5")
+   * - For spans >= 30 days: "date" (e.g., "Nov 5")
    * - For spans >= 1 day: "dateTime" (e.g., "Nov 5 14:23:45")
    * - For spans >= 1 hour: "time" (e.g., "14:23:45")
-   * - For spans >= 1 second: "preciseTime" (e.g., "14:23:45.123")
-   * - For spans < 1 second: "ISOTime" (full precision time)
+   * - For spans < 1 hour: "preciseTime" (e.g., "14:23:45.123")
    */
-  formatBySpan(span: TimeSpan): TimeStampStringFormat {
-    if (span.greaterThanOrEqual(TimeSpan.days(30))) return "shortDate";
+  formatBySpan(span: TimeSpan): TimestampFormat {
+    if (span.greaterThanOrEqual(TimeSpan.days(30))) return "date";
     if (span.greaterThanOrEqual(TimeSpan.DAY)) return "dateTime";
     if (span.greaterThanOrEqual(TimeSpan.HOUR)) return "time";
-    if (span.greaterThanOrEqual(TimeSpan.SECOND)) return "preciseTime";
-
-    return "ISOTime";
+    return "preciseTime";
   }
 
   /**
@@ -760,56 +751,56 @@ export class TimeStamp
    * @param value - The number of nanoseconds.
    * @returns A TimeStamp representing the given number of nanoseconds.
    */
-  static nanoseconds(value: number, tzInfo: TZInfo = "UTC"): TimeStamp {
-    return new TimeStamp(value, tzInfo);
+  static nanoseconds(value: number, timeZone: TimeZone = "UTC"): TimeStamp {
+    return new TimeStamp(value, timeZone);
   }
 
   /** One nanosecond after the unix epoch */
   static readonly NANOSECOND = TimeStamp.nanoseconds(1);
 
   /** @returns a new TimeStamp n microseconds after the unix epoch */
-  static microseconds(value: number, tzInfo: TZInfo = "UTC"): TimeStamp {
-    return TimeStamp.nanoseconds(value * 1000, tzInfo);
+  static microseconds(value: number, timeZone: TimeZone = "UTC"): TimeStamp {
+    return TimeStamp.nanoseconds(value * 1000, timeZone);
   }
 
   /** One microsecond after the unix epoch */
   static readonly MICROSECOND = TimeStamp.microseconds(1);
 
   /** @returns a new TimeStamp n milliseconds after the unix epoch */
-  static milliseconds(value: number, tzInfo: TZInfo = "UTC"): TimeStamp {
-    return TimeStamp.microseconds(value * 1000, tzInfo);
+  static milliseconds(value: number, timeZone: TimeZone = "UTC"): TimeStamp {
+    return TimeStamp.microseconds(value * 1000, timeZone);
   }
 
   /** One millisecond after the unix epoch */
   static readonly MILLISECOND = TimeStamp.milliseconds(1);
 
   /** @returns a new TimeStamp n seconds after the unix epoch */
-  static seconds(value: number, tzInfo: TZInfo = "UTC"): TimeStamp {
-    return TimeStamp.milliseconds(value * 1000, tzInfo);
+  static seconds(value: number, timeZone: TimeZone = "UTC"): TimeStamp {
+    return TimeStamp.milliseconds(value * 1000, timeZone);
   }
 
   /** One second after the unix epoch */
   static readonly SECOND = TimeStamp.seconds(1);
 
   /** @returns a new TimeStamp n minutes after the unix epoch */
-  static minutes(value: number, tzInfo: TZInfo = "UTC"): TimeStamp {
-    return TimeStamp.seconds(value * 60, tzInfo);
+  static minutes(value: number, timeZone: TimeZone = "UTC"): TimeStamp {
+    return TimeStamp.seconds(value * 60, timeZone);
   }
 
   /** One minute after the unix epoch */
   static readonly MINUTE = TimeStamp.minutes(1);
 
   /** @returns a new TimeStamp n hours after the unix epoch */
-  static hours(value: number, tzInfo: TZInfo = "UTC"): TimeStamp {
-    return TimeStamp.minutes(value * 60, tzInfo);
+  static hours(value: number, timeZone: TimeZone = "UTC"): TimeStamp {
+    return TimeStamp.minutes(value * 60, timeZone);
   }
 
   /** One hour after the unix epoch */
   static readonly HOUR = TimeStamp.hours(1);
 
   /** @returns a new TimeStamp n days after the unix epoch */
-  static days(value: number, tzInfo: TZInfo = "UTC"): TimeStamp {
-    return TimeStamp.hours(value * 24, tzInfo);
+  static days(value: number, timeZone: TimeZone = "UTC"): TimeStamp {
+    return TimeStamp.hours(value * 24, timeZone);
   }
 
   /** One day after the unix epoch */
@@ -852,7 +843,7 @@ export class TimeStamp
 /** TimeSpan represents a nanosecond precision duration. */
 export class TimeSpan
   extends primitive.ValueExtension<bigint>
-  implements primitive.Stringer
+  implements primitive.Stringer, primitive.Hashable
 {
   constructor(value: CrudeTimeSpan) {
     if (typeof value === "number") value = Math.trunc(value.valueOf());
@@ -898,6 +889,11 @@ export class TimeSpan
     return this.value;
   }
 
+  /** @returns the bigint nanosecond value as a string for stable hashing. */
+  hash(): string {
+    return this.value.toString();
+  }
+
   /**
    * Checks if the TimeSpan is less than another TimeSpan.
    *
@@ -1310,13 +1306,18 @@ export class TimeSpan
 /** Rate represents a data rate in Hz. */
 export class Rate
   extends primitive.ValueExtension<number>
-  implements primitive.Stringer
+  implements primitive.Stringer, primitive.Hashable
 {
   constructor(value: CrudeRate) {
     if (primitive.isCrudeValueExtension<number>(value)) value = value.value;
     super(value.valueOf());
   }
 
+  /** @returns the Hz value as a string for stable hashing. */
+  hash(): string {
+    return this.value.toString();
+  }
+
   /** @returns a pretty string representation of the rate in the format "X Hz". */
   toString(): string {
     return `${this.valueOf()} Hz`;
@@ -1549,7 +1550,12 @@ export class Density
  * @property start - A TimeStamp representing the start of the range.
  * @property end - A Timestamp representing the end of the range.
  */
-export class TimeRange implements primitive.Stringer {
+export class TimeRange implements primitive.Stringer, primitive.Hashable {
+  /** @returns a stable hash composed of the start and end timestamps. */
+  hash(): string {
+    return `${this.start.hash()}-${this.end.hash()}`;
+  }
+
   /**
    * The starting TimeStamp of the TimeRange.
    *
@@ -1823,8 +1829,13 @@ export class TimeRange implements primitive.Stringer {
 /** DataType is a string that represents a data type. */
 export class DataType
   extends primitive.ValueExtension<string>
-  implements primitive.Stringer
+  implements primitive.Stringer, primitive.Hashable
 {
+  /** @returns the data type identifier as a string for stable hashing. */
+  hash(): string {
+    return this.value;
+  }
+
   constructor(value: CrudeDataType) {
     if (primitive.isCrudeValueExtension<string>(value)) value = value.value;
     if (
@@ -2418,7 +2429,8 @@ export const convertDataType = (
   value: math.Numeric,
   offset: math.Numeric = 0,
 ): math.Numeric => {
-  if (source.usesBigInt && !target.usesBigInt) return Number(value) - Number(offset);
+  if (source.usesBigInt && !target.usesBigInt)
+    return Number(BigInt(value.valueOf()) - BigInt(offset.valueOf()));
   if (!source.usesBigInt && target.usesBigInt)
     return BigInt(value.valueOf()) - BigInt(offset.valueOf());
   return math.sub(value, offset);

package/src/telem/types.gen.ts

@@ -0,0 +1,28 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { z } from "zod";
+
+export const TIMESTAMP_FORMATS = [
+  "ISO",
+  "ISODate",
+  "time",
+  "preciseTime",
+  "date",
+  "preciseDate",
+  "dateTime",
+] as const;
+export const timestampFormatZ = z.enum(TIMESTAMP_FORMATS);
+export type TimestampFormat = z.infer<typeof timestampFormatZ>;
+
+export const TIME_ZONES = ["local", "UTC"] as const;
+export const timeZoneZ = z.enum(TIME_ZONES);
+export type TimeZone = z.infer<typeof timeZoneZ>;

package/src/text/external.ts

@@ -0,0 +1,11 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export * from "@/text/types";
+export * from "@/text/types.gen";

package/src/text/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+export * as text from "@/text/external";

package/src/text/types.gen.ts

@@ -0,0 +1,16 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+// Code generated by Oracle. DO NOT EDIT.
+
+import { z } from "zod";
+
+export const LEVELS = ["h1", "h2", "h3", "h4", "h5", "p", "small"] as const;
+export const levelZ = z.enum(LEVELS);
+export type Level = z.infer<typeof levelZ>;