@synnaxlabs/x 0.55.0 → 0.56.0

package/src/debounce/debounce.ts

@@ -7,38 +7,57 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export const debounce = <F extends (...args: any[]) => void>(
-  func: F,
-  waitFor: number,
-): F => {
-  let timeout: ReturnType<typeof setTimeout> | null = null;
-  if (waitFor === 0) return func;
+import { type CrudeTimeSpan, TimeSpan } from "@/telem/telem";
 
-  const debounced = (...args: Parameters<F>): void => {
-    if (timeout !== null) {
-      clearTimeout(timeout);
-      timeout = null;
-    }
-    timeout = setTimeout(() => func(...args), waitFor);
-  };
-
-  return debounced as F;
-};
+// DebouncedFn is the function returned by debounce. It carries cancel and
+// flush handles so callers (e.g., React cleanup paths) can drop pending
+// invocations or force them to run immediately on demand. Shape matches
+// lodash.debounce.
+export interface DebouncedFn<Args extends unknown[]> {
+  (...args: Args): void;
+  cancel: () => void;
+  flush: () => void;
+}
 
-export const throttle = <F extends (...args: unknown[]) => void>(
-  func: F,
-  waitFor: number,
-): F => {
-  let timeout: ReturnType<typeof setTimeout> | null = null;
-  if (waitFor === 0) return func;
+const noop = (): void => {};
 
-  const throttled = (...args: Parameters<F>): void => {
-    if (timeout === null)
-      timeout = setTimeout(() => {
-        func(...args);
-        timeout = null;
-      }, waitFor);
+export const debounce = <Args extends unknown[]>(
+  func: (...args: Args) => void,
+  waitFor: CrudeTimeSpan,
+): DebouncedFn<Args> => {
+  const debouncePeriod = new TimeSpan(waitFor);
+  if (debouncePeriod.valueOf() <= 0) {
+    const passthrough = ((...args: Args) => func(...args)) as DebouncedFn<Args>;
+    passthrough.cancel = noop;
+    passthrough.flush = noop;
+    return passthrough;
+  }
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  let latestArgs: Args | null = null;
+  const invoke = (): void => {
+    if (latestArgs === null) return;
+    const args = latestArgs;
+    latestArgs = null;
+    func(...args);
   };
-
-  return throttled as F;
+  const debounced = ((...args: Args): void => {
+    latestArgs = args;
+    clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      timeout = undefined;
+      invoke();
+    }, debouncePeriod.milliseconds);
+  }) as DebouncedFn<Args>;
+  debounced.cancel = (): void => {
+    clearTimeout(timeout);
+    timeout = undefined;
+    latestArgs = null;
+  };
+  debounced.flush = (): void => {
+    if (timeout === undefined) return;
+    clearTimeout(timeout);
+    timeout = undefined;
+    invoke();
+  };
+  return debounced;
 };

package/src/deep/copy.spec.ts

@@ -145,4 +145,17 @@ describe("copy", () => {
       expect(copied.uint8).not.toBe(uint8);
     } else expect(Array.from(copied.uint8 as Uint8Array)).toEqual([1, 2, 3]);
   });
+
+  // Mirrors the immer Draft scenario: callers store snapshots of mutable
+  // proxy state in long-lived structures (e.g., undo entries) that outlive
+  // the proxy. The snapshot must own its data so it survives revocation.
+  it("should produce a snapshot detached from a revocable proxy source", () => {
+    const target = { nested: { value: 1 }, list: [1, 2, 3] };
+    const { proxy, revoke } = Proxy.revocable(target, {});
+    const copied = deep.copy(proxy);
+    revoke();
+    expect(copied).toEqual({ nested: { value: 1 }, list: [1, 2, 3] });
+    expect(copied.nested).not.toBe(target.nested);
+    expect(copied.list).not.toBe(target.list);
+  });
 });

package/src/deep/difference.ts

@@ -30,7 +30,7 @@ export const difference = (
         }
         for (let i = 0; i < a.length; i++) compare(a[i], b[i], `${currentPath}[${i}]`);
       } else {
-        const keys = new Set([...Object.keys(a as {}), ...Object.keys(b as {})]);
+        const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
         keys.forEach((key) => {
           compare(
             a[key as keyof typeof a],

package/src/destructor/destructor.ts

@@ -14,3 +14,5 @@ export interface Destructor {
 export interface Async {
   (): Promise<void>;
 }
+
+export const NOOP = () => {};

package/src/errors/errors.spec.ts

@@ -96,6 +96,36 @@ describe("errors", () => {
       const decoded = errors.decode(encoded);
       expect(errors.Unknown.matches(decoded)).toBe(true);
     });
+
+    it("should preserve name and stack across encode/decode for a generic Error", () => {
+      const error = new TypeError("boom");
+      const encoded = errors.encode(error);
+      expect(encoded.name).toEqual("TypeError");
+      expect(encoded.stack).toEqual(error.stack);
+      const decoded = errors.decode(encoded);
+      expect((decoded as Error).name).toEqual("TypeError");
+      expect((decoded as Error).stack).toEqual(error.stack);
+    });
+
+    it("should preserve name and stack when a typed error round-trips through a provider", () => {
+      errors.register({
+        encode: myCustomErrorEncoder,
+        decode: myCustomErrorDecoder,
+      });
+      const error = new ErrorOne("boom");
+      const encoded = errors.encode(error);
+      expect(encoded.name).toEqual(ErrorOne.TYPE);
+      expect(encoded.stack).toEqual(error.stack);
+      const decoded = errors.decode(encoded);
+      expect(ErrorOne.matches(decoded)).toBe(true);
+      expect((decoded as Error).stack).toEqual(error.stack);
+    });
+
+    it("should leave the decoded error untouched when the payload omits name and stack", () => {
+      const decoded = errors.decode({ type: errors.UNKNOWN, data: "no native fields" });
+      expect(decoded).toBeInstanceOf(Error);
+      expect((decoded as Error).message).toEqual("no native fields");
+    });
   });
 
   describe("matches", () => {

package/src/errors/errors.ts

@@ -169,6 +169,18 @@ interface Provider {
   decode: Decoder;
 }
 
+const withNative = (payload: Payload, error: Error): Payload => ({
+  ...payload,
+  name: error.name,
+  stack: error.stack,
+});
+
+const applyNative = (error: Error, payload: Payload): Error => {
+  if (payload.name != null) error.name = payload.name;
+  if (payload.stack != null) error.stack = payload.stack;
+  return error;
+};
+
 class Registry {
   private readonly providers: Provider[] = [];
 
@@ -181,9 +193,10 @@ class Registry {
     if (isTyped(error))
       for (const provider of this.providers) {
         const payload = provider.encode(error);
-        if (payload != null) return payload;
+        if (payload != null) return withNative(payload, error);
       }
-    if (error instanceof Error) return { type: UNKNOWN, data: error.message };
+    if (error instanceof Error)
+      return withNative({ type: UNKNOWN, data: error.message }, error);
     if (typeof error === "string") return { type: UNKNOWN, data: error };
     try {
       return { type: UNKNOWN, data: JSON.stringify(error) };
@@ -194,12 +207,13 @@ class Registry {
 
   decode(payload?: Payload | null): Error | null {
     if (payload == null || payload.type === NONE) return null;
-    if (payload.type === UNKNOWN) return new Unknown(payload.data);
+    if (payload.type === UNKNOWN)
+      return applyNative(new Unknown(payload.data), payload);
     for (const provider of this.providers) {
       const error = provider.decode(payload);
-      if (error != null) return error;
+      if (error != null) return applyNative(error, payload);
     }
-    return new Unknown(payload.data);
+    return applyNative(new Unknown(payload.data), payload);
   }
 }
 
@@ -242,8 +256,16 @@ export const decode = (payload?: Payload | null): Error | null => {
  */
 export class Unknown extends createTyped("unknown") {}
 
-/** Zod schema for validating error payloads */
-export const payloadZ = z.object({ type: z.string(), data: z.string() });
+/** Zod schema for validating error payloads. `name` and `stack` are TypeScript-only
+ * fields; Go and Python don't populate them. They're carried opaquely across the wire
+ * and re-applied to the reconstructed error on decode, which keeps the original error
+ * name (e.g. "TypeError") and stack trace alive across worker / network boundaries. */
+export const payloadZ = z.object({
+  type: z.string(),
+  data: z.string(),
+  name: z.string().optional(),
+  stack: z.string().optional(),
+});
 
 /** Network-portable representation of an error */
 export type Payload = z.infer<typeof payloadZ>;
@@ -251,15 +273,5 @@ export type Payload = z.infer<typeof payloadZ>;
 /** Error for representing the cancellation of an operation */
 export class Canceled extends createTyped("canceled") {}
 
-/** A payload representing a native JavaScript Error */
-export interface NativePayload {
-  /** The name of the error */
-  name: string;
-  /** The message of the error */
-  message: string;
-  /** The stack trace of the error */
-  stack?: string;
-}
-
 /** Error for representing a method that is not implemented */
 export class NotImplemented extends createTyped("not_implemented") {}

package/src/index.ts

@@ -33,10 +33,12 @@ export * from "@/math";
 export * from "@/migrate";
 export * from "@/narrow";
 export * from "@/notation";
+export * from "@/numeric";
 export * from "@/observe";
 export * from "@/optional";
 export * from "@/primitive";
 export * from "@/record";
+export * from "@/require";
 export * from "@/runtime";
 export * from "@/scheduler";
 export * from "@/shallow";
@@ -47,9 +49,10 @@ export * from "@/strings";
 export * from "@/sync";
 export * from "@/telem";
 export * from "@/testutil";
+export * from "@/text";
+export * from "@/throttle";
 export * from "@/types";
 export * from "@/unique";
 export * from "@/url";
 export * from "@/uuid";
-export * from "@/worker";
 export * from "@/zod";

package/src/notation/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 "@/notation/notation";
+export { type Notation, NOTATIONS, notationZ } from "@/notation/types.gen";

package/src/notation/index.ts

@@ -7,4 +7,4 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-export * as notation from "@/notation/notation";
+export * as notation from "@/notation/external";

package/src/notation/notation.spec.ts

@@ -12,12 +12,13 @@ import { describe, expect, it } from "vitest";
 import { notation } from "@/notation";
 
 interface TestCase {
-  number: number;
+  number: number | bigint;
   precision: number;
   expected: Record<notation.Notation, string>;
 }
 
 const TEST_CASES: TestCase[] = [
+  // === Basic positive numbers ===
   {
     number: 12345.678,
     precision: 1,
@@ -28,6 +29,7 @@ const TEST_CASES: TestCase[] = [
     precision: 0,
     expected: { standard: "12346", scientific: "1ᴇ4", engineering: "12ᴇ3" },
   },
+  // === Zero ===
   {
     number: 0,
     precision: 1,
@@ -38,6 +40,18 @@ const TEST_CASES: TestCase[] = [
     precision: 0,
     expected: { standard: "0", scientific: "0ᴇ0", engineering: "0ᴇ0" },
   },
+  // === Negative zero — should render identically to positive zero ===
+  {
+    number: -0,
+    precision: 0,
+    expected: { standard: "0", scientific: "0ᴇ0", engineering: "0ᴇ0" },
+  },
+  {
+    number: -0,
+    precision: 2,
+    expected: { standard: "0.00", scientific: "0.00ᴇ0", engineering: "0.00ᴇ0" },
+  },
+  // === Negative numbers ===
   {
     number: -1234.5678,
     precision: 1,
@@ -48,21 +62,38 @@ const TEST_CASES: TestCase[] = [
     precision: 0,
     expected: { standard: "-1235", scientific: "-1ᴇ3", engineering: "-1ᴇ3" },
   },
+  // === Special values (precision must be ignored) ===
   {
     number: NaN,
     precision: 0,
     expected: { standard: "NaN", scientific: "NaN", engineering: "NaN" },
   },
+  {
+    number: NaN,
+    precision: 4,
+    expected: { standard: "NaN", scientific: "NaN", engineering: "NaN" },
+  },
   {
     number: Infinity,
     precision: 0,
     expected: { standard: "∞", scientific: "∞", engineering: "∞" },
   },
+  {
+    number: Infinity,
+    precision: 4,
+    expected: { standard: "∞", scientific: "∞", engineering: "∞" },
+  },
   {
     number: -Infinity,
     precision: 0,
     expected: { standard: "-∞", scientific: "-∞", engineering: "-∞" },
   },
+  {
+    number: -Infinity,
+    precision: 4,
+    expected: { standard: "-∞", scientific: "-∞", engineering: "-∞" },
+  },
+  // === Small fractional numbers ===
   {
     number: 0.0001234,
     precision: 1,
@@ -73,11 +104,238 @@ const TEST_CASES: TestCase[] = [
     precision: 0,
     expected: { standard: "0", scientific: "1ᴇ-4", engineering: "123ᴇ-6" },
   },
+  // === Negative small fractional numbers ===
+  {
+    number: -0.0001234,
+    precision: 1,
+    expected: { standard: "-0.0", scientific: "-1.2ᴇ-4", engineering: "-123.4ᴇ-6" },
+  },
+  {
+    number: -0.0001234,
+    precision: 0,
+    expected: { standard: "-0", scientific: "-1ᴇ-4", engineering: "-123ᴇ-6" },
+  },
+  // === Number 1 ===
+  {
+    number: 1,
+    precision: 0,
+    expected: { standard: "1", scientific: "1ᴇ0", engineering: "1ᴇ0" },
+  },
+  {
+    number: 1,
+    precision: 2,
+    expected: { standard: "1.00", scientific: "1.00ᴇ0", engineering: "1.00ᴇ0" },
+  },
+  // === Power-of-10 boundaries where engineering and scientific differ ===
+  {
+    number: 10,
+    precision: 0,
+    expected: { standard: "10", scientific: "1ᴇ1", engineering: "10ᴇ0" },
+  },
+  {
+    number: 100,
+    precision: 0,
+    expected: { standard: "100", scientific: "1ᴇ2", engineering: "100ᴇ0" },
+  },
+  {
+    number: 1000,
+    precision: 0,
+    expected: { standard: "1000", scientific: "1ᴇ3", engineering: "1ᴇ3" },
+  },
+  {
+    number: 10000,
+    precision: 0,
+    expected: { standard: "10000", scientific: "1ᴇ4", engineering: "10ᴇ3" },
+  },
+  {
+    number: 100000,
+    precision: 0,
+    expected: { standard: "100000", scientific: "1ᴇ5", engineering: "100ᴇ3" },
+  },
+  {
+    number: 1000000,
+    precision: 0,
+    expected: { standard: "1000000", scientific: "1ᴇ6", engineering: "1ᴇ6" },
+  },
+  // === Negative power-of-10 boundaries (fractions) ===
+  {
+    number: 0.1,
+    precision: 1,
+    expected: { standard: "0.1", scientific: "1.0ᴇ-1", engineering: "100.0ᴇ-3" },
+  },
+  {
+    number: 0.01,
+    precision: 1,
+    expected: { standard: "0.0", scientific: "1.0ᴇ-2", engineering: "10.0ᴇ-3" },
+  },
+  {
+    number: 0.001,
+    precision: 1,
+    expected: { standard: "0.0", scientific: "1.0ᴇ-3", engineering: "1.0ᴇ-3" },
+  },
+  // === Negative power-of-10 boundaries ===
+  {
+    number: -10,
+    precision: 0,
+    expected: { standard: "-10", scientific: "-1ᴇ1", engineering: "-10ᴇ0" },
+  },
+  {
+    number: -100,
+    precision: 0,
+    expected: { standard: "-100", scientific: "-1ᴇ2", engineering: "-100ᴇ0" },
+  },
+  // === Power of 10 with non-zero precision ===
+  {
+    number: 100,
+    precision: 2,
+    expected: { standard: "100.00", scientific: "1.00ᴇ2", engineering: "100.00ᴇ0" },
+  },
+  {
+    number: 1000,
+    precision: 3,
+    expected: { standard: "1000.000", scientific: "1.000ᴇ3", engineering: "1.000ᴇ3" },
+  },
+  // === Rounding overflow — toFixed pushes the mantissa past the canonical upper
+  //     bound (>= 10 for scientific, >= 1000 for engineering). The exponent must be
+  //     bumped so the mantissa stays in the canonical range. ===
+  {
+    number: 9.999,
+    precision: 1,
+    expected: { standard: "10.0", scientific: "1.0ᴇ1", engineering: "10.0ᴇ0" },
+  },
+  {
+    number: 9.999,
+    precision: 0,
+    expected: { standard: "10", scientific: "1ᴇ1", engineering: "10ᴇ0" },
+  },
+  {
+    number: 99.99,
+    precision: 0,
+    expected: { standard: "100", scientific: "1ᴇ2", engineering: "100ᴇ0" },
+  },
+  {
+    number: 999.99,
+    precision: 0,
+    expected: { standard: "1000", scientific: "1ᴇ3", engineering: "1ᴇ3" },
+  },
+  {
+    number: 9999.99,
+    precision: 0,
+    expected: { standard: "10000", scientific: "1ᴇ4", engineering: "10ᴇ3" },
+  },
+  {
+    number: -9.999,
+    precision: 1,
+    expected: { standard: "-10.0", scientific: "-1.0ᴇ1", engineering: "-10.0ᴇ0" },
+  },
+  {
+    number: -999.99,
+    precision: 0,
+    expected: { standard: "-1000", scientific: "-1ᴇ3", engineering: "-1ᴇ3" },
+  },
+  // === Positive bigint ===
+  {
+    number: 1n,
+    precision: 0,
+    expected: { standard: "1", scientific: "1ᴇ0", engineering: "1ᴇ0" },
+  },
+  {
+    number: 1n,
+    precision: 2,
+    expected: { standard: "1.00", scientific: "1.00ᴇ0", engineering: "1.00ᴇ0" },
+  },
+  {
+    number: 1778020940471336960n,
+    precision: 0,
+    expected: {
+      standard: "1778020940471336960",
+      scientific: "2ᴇ18",
+      engineering: "2ᴇ18",
+    },
+  },
+  {
+    number: 1778020940471336960n,
+    precision: 11,
+    expected: {
+      standard: "1778020940471336960.00000000000",
+      scientific: "1.77802094047ᴇ18",
+      engineering: "1.77802094047ᴇ18",
+    },
+  },
+  // === Negative bigint ===
+  {
+    number: -1n,
+    precision: 0,
+    expected: { standard: "-1", scientific: "-1ᴇ0", engineering: "-1ᴇ0" },
+  },
+  {
+    number: -1778020940471336960n,
+    precision: 0,
+    expected: {
+      standard: "-1778020940471336960",
+      scientific: "-2ᴇ18",
+      engineering: "-2ᴇ18",
+    },
+  },
+  {
+    number: -1778020940471336960n,
+    precision: 11,
+    expected: {
+      standard: "-1778020940471336960.00000000000",
+      scientific: "-1.77802094047ᴇ18",
+      engineering: "-1.77802094047ᴇ18",
+    },
+  },
+  // === Zero bigint ===
+  {
+    number: 0n,
+    precision: 0,
+    expected: { standard: "0", scientific: "0ᴇ0", engineering: "0ᴇ0" },
+  },
+  {
+    number: 0n,
+    precision: 11,
+    expected: {
+      standard: "0.00000000000",
+      scientific: "0.00000000000ᴇ0",
+      engineering: "0.00000000000ᴇ0",
+    },
+  },
+  // === Large-magnitude floats expressed with e-notation ===
+  // For values >= 10^21, JS's toFixed delegates to ToString, so standard output
+  // here is itself in e-notation. The scientific and engineering branches keep
+  // their canonical forms.
+  {
+    number: 9e124,
+    precision: 0,
+    expected: { standard: "9e+124", scientific: "9ᴇ124", engineering: "90ᴇ123" },
+  },
+  {
+    number: 9.99e124,
+    precision: 0,
+    expected: { standard: "9.99e+124", scientific: "1ᴇ125", engineering: "100ᴇ123" },
+  },
+  {
+    number: -3e10,
+    precision: 0,
+    expected: { standard: "-30000000000", scientific: "-3ᴇ10", engineering: "-30ᴇ9" },
+  },
+  // === Tiny-magnitude floats expressed with e-notation ===
+  {
+    number: 1e-200,
+    precision: 0,
+    expected: { standard: "0", scientific: "1ᴇ-200", engineering: "10ᴇ-201" },
+  },
+  {
+    number: 5e-50,
+    precision: 0,
+    expected: { standard: "0", scientific: "5ᴇ-50", engineering: "50ᴇ-51" },
+  },
 ];
 
 describe("stringifyNumber", () => {
   TEST_CASES.forEach(({ number, precision, expected }) =>
-    describe(`number: ${number}, precision: ${precision}`, () =>
+    describe(`${typeof number === "bigint" ? "bigint " : ""}number: ${number}, precision: ${precision}`, () =>
       notation.NOTATIONS.forEach((n) =>
         it(`should format correctly in ${n} notation`, () => {
           const result = notation.stringifyNumber(number, precision, n);

package/src/notation/notation.ts

@@ -7,11 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { z } from "zod";
-
-export const NOTATIONS = ["standard", "scientific", "engineering"] as const;
-export const notationZ = z.enum(NOTATIONS);
-export type Notation = z.infer<typeof notationZ>;
+import { type Notation } from "@/notation/types.gen";
 
 /**
  * Converts a number to a string representation with a specified precision and notation.
@@ -25,6 +21,9 @@ export type Notation = z.infer<typeof notationZ>;
  * - If the value is `NaN`, returns "NaN".
  * - If the value is `Infinity`, returns "∞".
  * - If the value is `-Infinity`, returns "-∞".
+ * - Scientific and engineering output is renormalized after rounding so the mantissa
+ *   stays in its canonical range (|m| < 10 for scientific, |m| < 1000 for engineering).
+ *   For example, 9.999 at precision 1 in scientific renders as "1.0ᴇ1", not "10.0ᴇ0".
  *
  * Examples:
  *
@@ -41,10 +40,16 @@ export type Notation = z.infer<typeof notationZ>;
  * ```
  */
 export const stringifyNumber = (
-  value: number,
+  value: number | bigint,
   precision: number,
   notation: Notation,
 ): string => {
+  // Standard notation on bigint must preserve full integer precision; coercing through
+  // Number() would quantize values above 2^53. All other branches are float-mantissa
+  // truncated by definition, so coercing bigint to number is safe.
+  if (typeof value === "bigint" && notation === "standard")
+    return precision === 0 ? value.toString() : `${value}.${"0".repeat(precision)}`;
+  if (typeof value === "bigint") value = Number(value);
   if (Number.isNaN(value)) return "NaN";
   if (value === Infinity) return "∞";
   if (value === -Infinity) return "-∞";
@@ -56,6 +61,19 @@ export const stringifyNumber = (
   let exp: number;
   if (notation === "scientific") exp = Math.floor(Math.log10(Math.abs(value)));
   else exp = Math.floor(Math.log10(Math.abs(value)) / 3) * 3;
-  const mantissa = value / 10 ** exp;
+  let mantissa = value / 10 ** exp;
+  // After rounding via toFixed, the mantissa may have crossed the canonical upper
+  // bound (>= 10 for scientific, >= 1000 for engineering). Predict the rounded
+  // magnitude with Math.round — for non-negative values it matches toFixed's
+  // half-away-from-zero semantics, and we're already taking Math.abs — so we avoid
+  // having to parseFloat the formatted string back into a number. Bump the exponent
+  // if needed so e.g. 9.999 at precision 1 in scientific becomes "1.0ᴇ1" rather
+  // than "10.0ᴇ0".
+  const upperBound = notation === "scientific" ? 10 : 1000;
+  const factor = 10 ** precision;
+  if (Math.round(Math.abs(mantissa) * factor) / factor >= upperBound) {
+    exp += notation === "scientific" ? 1 : 3;
+    mantissa = value / 10 ** exp;
+  }
   return `${mantissa.toFixed(precision)}ᴇ${exp}`;
 };

package/src/notation/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 NOTATIONS = ["standard", "scientific", "engineering"] as const;
+export const notationZ = z.enum(NOTATIONS);
+export type Notation = z.infer<typeof notationZ>;