@synnaxlabs/x 0.53.0 → 0.54.0

package/src/control/types.gen.ts

@@ -0,0 +1,52 @@
+// 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";
+
+import { zod } from "@/zod";
+
+export const authorityZ = zod.uint8;
+export type Authority = z.infer<typeof authorityZ>;
+
+export enum Concurrency {
+  exclusive = 0,
+  shared = 1,
+}
+export const concurrencyZ = z.enum(Concurrency);
+
+/**
+ * Subject is an entity that can hold control authority over a resource. Typically
+ * represents a user, process, or service.
+ */
+export const subjectZ = z.object({
+  /** key is a unique identifier for the subject. */
+  key: z.string(),
+  /** name is a human-readable name for the subject. */
+  name: z.string(),
+  /**
+   * group optional identifier shared by subjects from the same logical group
+   * (e.g.) all writers from the same Driver rack.
+   */
+  group: z.uint32().optional(),
+});
+export interface Subject extends z.infer<typeof subjectZ> {}
+
+export const stateZ = <R extends z.ZodType>(r: R) =>
+  z.object({
+    subject: subjectZ,
+    resource: r,
+    authority: authorityZ,
+  });
+export interface State<R extends z.ZodType> {
+  subject: Subject;
+  resource: z.infer<R>;
+  authority: Authority;
+}

package/src/deep/merge.ts

@@ -30,7 +30,8 @@ export const override = <T>(base: T, ...overrides: Array<Partial<T>>): T => {
           override(base[key], source[key]);
         } else Object.assign(base, { [key]: source[key] });
       } catch (e) {
-        if (e instanceof TypeError) throw new TypeError(`.${key}: ${e.message}`);
+        if (e instanceof TypeError)
+          throw new TypeError(`.${key}: ${e.message}`, { cause: e });
         throw e;
       }
 

package/src/deep/path.ts

@@ -110,7 +110,7 @@ export const pathsMatch = (path: string, pattern: string): boolean => {
 };
 
 export const getIndex = (part: string): number | null => {
-  const num = parseInt(part);
+  const num = parseInt(part, 10);
   if (isNaN(num) || num < 0 || num.toString() !== part) return null;
   return num;
 };

package/src/deep/remove.ts

@@ -21,7 +21,7 @@ export const remove = <V>(obj: V, path: string): void => {
       const lastPart = parts[i];
 
       if (Array.isArray(result)) {
-        const index = parseInt(lastPart);
+        const index = parseInt(lastPart, 10);
         if (!isNaN(index) && index < result.length) {
           result.splice(index, 1);
           return;

package/src/label/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 label from "@/label/label";
+export * as label from "@/label/types.gen";

package/src/label/types.gen.ts

@@ -0,0 +1,35 @@
+// 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";
+
+import { color } from "@/color";
+
+export const keyZ = z.uuid();
+export type Key = z.infer<typeof keyZ>;
+
+/**
+ * Label is a tagging and categorization entity with a name and associated color.
+ * Labels can be attached to resources like ranges for organization and
+ * filtering.
+ */
+export const labelZ = z.object({
+  /** key is the unique identifier for this label. */
+  key: keyZ,
+  /** name is a human-readable name for the label. */
+  name: z.string().min(1),
+  /** color is the display color for visual identification of the label. */
+  color: color.colorZ,
+});
+export interface Label extends z.infer<typeof labelZ> {}
+
+export const newZ = labelZ.partial({ key: true });
+export interface New extends z.input<typeof newZ> {}

package/src/math/constants.ts

@@ -10,6 +10,7 @@
 export const MAX_UINT8 = 2 ** 8 - 1;
 export const MAX_UINT12 = 2 ** 12 - 1;
 export const MAX_UINT16 = 2 ** 16 - 1;
+export const MAX_UINT20 = 2 ** 20 - 1;
 export const MAX_UINT32 = 2 ** 32 - 1;
 export const MAX_UINT64 = 2n ** 64n - 1n;
 export const MAX_UINT64_NUMBER = 2 ** 64 - 1;

package/src/migrate/migrate.ts

@@ -64,8 +64,8 @@ const comparePreRelease = (a: string, b: string): number => {
 
     if (aIsNumeric && bIsNumeric) {
       // Compare numerically
-      const aNum = parseInt(aPart);
-      const bNum = parseInt(bPart);
+      const aNum = parseInt(aPart, 10);
+      const bNum = parseInt(bPart, 10);
       if (aNum < bNum) return compare.LESS_THAN;
       if (aNum > bNum) return compare.GREATER_THAN;
     } else {

package/src/record/record.spec.ts

@@ -74,15 +74,15 @@ describe("record", () => {
     });
     it("should reject symbol keys", () => {
       const symbolKey = Symbol("test");
-      expect(() => record.keyZ.parse(symbolKey)).toThrowError(z.ZodError);
+      expect(() => record.keyZ.parse(symbolKey)).toThrow(z.ZodError);
     });
     it("should reject undefined keys", () => {
       const undefinedKey = undefined;
-      expect(() => record.keyZ.parse(undefinedKey)).toThrowError(z.ZodError);
+      expect(() => record.keyZ.parse(undefinedKey)).toThrow(z.ZodError);
     });
     it("should reject null keys", () => {
       const nullKey = null;
-      expect(() => record.keyZ.parse(nullKey)).toThrowError(z.ZodError);
+      expect(() => record.keyZ.parse(nullKey)).toThrow(z.ZodError);
     });
   });
   describe("unknownZ", () => {
@@ -95,16 +95,16 @@ describe("record", () => {
         2: [1, 2, 3],
         function: () => {},
       };
-      expect(record.unknownZ.parse(validRecord)).toEqual(validRecord);
+      expect(record.unknownZ().parse(validRecord)).toEqual(validRecord);
     });
     it("should reject symbol keys", () => {
       const invalidRecord = { [Symbol("test")]: "value" };
-      expect(() => record.unknownZ.parse(invalidRecord)).toThrowError(z.ZodError);
+      expect(() => record.unknownZ().parse(invalidRecord)).toThrow(z.ZodError);
     });
 
     it("should accept empty objects", () => {
       const emptyRecord = {};
-      expect(record.unknownZ.parse(emptyRecord)).toEqual(emptyRecord);
+      expect(record.unknownZ().parse(emptyRecord)).toEqual(emptyRecord);
     });
 
     it("should accept null and undefined values", () => {
@@ -114,7 +114,7 @@ describe("record", () => {
         string: "value",
       };
 
-      expect(record.unknownZ.parse(recordWithNulls)).toEqual(recordWithNulls);
+      expect(record.unknownZ().parse(recordWithNulls)).toEqual(recordWithNulls);
     });
   });
 
@@ -331,6 +331,30 @@ describe("record", () => {
     });
   });
 
+  describe("nullishToEmpty", () => {
+    it("should coerce null to empty object", () => {
+      expect(record.nullishToEmpty().parse(null)).toEqual({});
+    });
+
+    it("should coerce undefined to empty object", () => {
+      expect(record.nullishToEmpty().parse(undefined)).toEqual({});
+    });
+
+    it("should pass through empty object", () => {
+      expect(record.nullishToEmpty().parse({})).toEqual({});
+    });
+
+    it("should pass through object with data", () => {
+      const obj = { a: 1, b: "hello", c: true };
+      expect(record.nullishToEmpty().parse(obj)).toEqual(obj);
+    });
+
+    it("should pass through object with nested values", () => {
+      const obj = { nested: { key: "value" }, arr: [1, 2, 3] };
+      expect(record.nullishToEmpty().parse(obj)).toEqual(obj);
+    });
+  });
+
   describe("omit", () => {
     type Object = { [key: string]: number };
     it("should return the object if no keys are provided", () =>

package/src/record/record.ts

@@ -23,28 +23,13 @@ export type Key = z.infer<typeof keyZ>;
  * Zod schema for validating unknown records. Accepts objects with string or number keys
  * and unknown values.
  */
-export const unknownZ = z.record(keyZ, z.unknown());
-
-/**
- * For required JSON/record fields: coerces null/undefined to empty object {}.
- * Use when the record must always be present and iterable.
- *
- * - null → {}
- * - undefined → {}
- * - {} → {}
- * - {data} → {data}
- */
-export const nullishToEmpty = (): z.ZodType<Unknown> =>
-  z.union([
-    z.union([z.null(), z.undefined()]).transform<Unknown>(() => ({})),
-    unknownZ,
-  ]);
+export const unknownZ = () => z.record(keyZ, z.unknown());
 
 /**
  * Represents a record with unknown values and string/number keys.
  * This is a generic type for objects where the value types are not known.
  */
-export interface Unknown extends z.infer<typeof unknownZ> {}
+export interface Unknown extends z.infer<ReturnType<typeof unknownZ>> {}
 
 /**
  * Interface for objects that have a key property.
@@ -155,3 +140,18 @@ export const omit = <T, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K> =>
   for (const key of keys) delete result[key];
   return result;
 };
+
+/**
+ * For required JSON/record fields: coerces null/undefined to empty object {}.
+ * Use when the record must always be present and iterable.
+ *
+ * - null → {}
+ * - undefined → {}
+ * - {} → {}
+ * - {data} → {data}
+ */
+export const nullishToEmpty = (): z.ZodType<Unknown> =>
+  z.union([
+    z.union([z.null(), z.undefined()]).transform<Unknown>(() => ({})),
+    unknownZ(),
+  ]);

package/src/spatial/base.ts

@@ -9,63 +9,75 @@
 
 import { z } from "zod";
 
+// Tuples
+
 export const numberCouple = z.tuple([z.number(), z.number()]);
 export type NumberCouple<T extends number | bigint = number> = [T, T];
 
-// Dimensions
-
-export const dimensions = z.object({ width: z.number(), height: z.number() });
-export type Dimensions = z.infer<typeof dimensions>;
-export const signedDimensions = z.object({
-  signedWidth: z.number(),
-  signedHeight: z.number(),
-});
-export type Dimension = "width" | "height";
-export const ALIGNMENTS = ["start", "center", "end"] as const;
-export type SignedDimension = "signedWidth" | "signedHeight";
-
-// XY
-
-export const xy = z.object({ x: z.number(), y: z.number() });
-export type XY = z.infer<typeof xy>;
-export const clientXY = z.object({ clientX: z.number(), clientY: z.number() });
-export type ClientXY = z.infer<typeof clientXY>;
-
 // Direction
 
 export const DIRECTIONS = ["x", "y"] as const;
-export const direction = z.enum(DIRECTIONS);
-export type Direction = z.infer<typeof direction>;
+export const directionZ = z.enum(DIRECTIONS);
+export type Direction = z.infer<typeof directionZ>;
 
 // Location
 
 export const OUTER_LOCATIONS = ["top", "right", "bottom", "left"] as const;
-export const outerLocation = z.enum(OUTER_LOCATIONS);
-export type OuterLocation = (typeof OUTER_LOCATIONS)[number];
+export const outerLocationZ = z.enum(OUTER_LOCATIONS);
+export type OuterLocation = z.infer<typeof outerLocationZ>;
+
 export const X_LOCATIONS = ["left", "right"] as const;
-export const xLocation = z.enum(X_LOCATIONS);
-export type XLocation = (typeof X_LOCATIONS)[number];
+export const xLocationZ = z.enum(X_LOCATIONS);
+export type XLocation = z.infer<typeof xLocationZ>;
+
 export const Y_LOCATIONS = ["top", "bottom"] as const;
-export const yLocation = z.enum(Y_LOCATIONS);
-export type YLocation = (typeof Y_LOCATIONS)[number];
+export const yLocationZ = z.enum(Y_LOCATIONS);
+export type YLocation = z.infer<typeof yLocationZ>;
+
 export const CENTER_LOCATIONS = ["center"] as const;
-export const centerLocation = z.enum(CENTER_LOCATIONS);
-export type CenterLocation = (typeof CENTER_LOCATIONS)[number];
-const LOCATIONS = [...OUTER_LOCATIONS, ...CENTER_LOCATIONS] as const;
-export const location = z.enum(LOCATIONS);
-export type Location = z.infer<typeof location>;
+export const centerLocationZ = z.enum(CENTER_LOCATIONS);
+export type CenterLocation = z.infer<typeof centerLocationZ>;
+
+export const LOCATIONS = ["top", "right", "bottom", "left", "center"] as const;
+export const locationZ = z.enum(LOCATIONS);
+export type Location = z.infer<typeof locationZ>;
 
 // Alignment
 
-export const alignment = z.enum(ALIGNMENTS);
-export type Alignment = (typeof ALIGNMENTS)[number];
+export const ALIGNMENTS = ["start", "center", "end"] as const;
+export const alignmentZ = z.enum(ALIGNMENTS);
+export type Alignment = z.infer<typeof alignmentZ>;
+
+// Order
+
 export const ORDERS = ["first", "last"] as const;
-export const order = z.enum(ORDERS);
-export type Order = (typeof ORDERS)[number];
+export const orderZ = z.enum(ORDERS);
+export type Order = z.infer<typeof orderZ>;
+
+// XY
+
+export const clientXyZ = z.object({ clientX: z.number(), clientY: z.number() });
+export type ClientXY = z.infer<typeof clientXyZ>;
+
+// Dimensions
+
+export const dimensionsZ = z.object({ width: z.number(), height: z.number() });
+export type Dimensions = z.infer<typeof dimensionsZ>;
+
+export const signedDimensionsZ = z.object({
+  signedWidth: z.number(),
+  signedHeight: z.number(),
+});
+export type SignedDimensions = z.infer<typeof signedDimensionsZ>;
+
+export type Dimension = "width" | "height";
+export type SignedDimension = "signedWidth" | "signedHeight";
 
 // Bounds
 
-export const bounds = z.object({ lower: z.number(), upper: z.number() });
+export const boundsZ = z.object({ lower: z.number(), upper: z.number() });
+
+// Generic bounds interface (supports bigint)
 export interface Bounds<T extends number | bigint = number> {
   lower: T;
   upper: T;
@@ -74,10 +86,22 @@ export interface Bounds<T extends number | bigint = number> {
 export type CrudeBounds<T extends number | bigint = number> =
   | Bounds<T>
   | NumberCouple<T>;
-export const crudeDirection = z.enum([...direction.options, ...location.options]);
+
+// Derived/complex types
+
+export const crudeDirection = z.enum([
+  "x",
+  "y",
+  ...OUTER_LOCATIONS,
+  ...CENTER_LOCATIONS,
+]);
 export type CrudeDirection = z.infer<typeof crudeDirection>;
 export type CrudeXDirection = "x" | "left" | "right";
 export type CrudeYDirection = "y" | "top" | "bottom";
 export type AngularDirection = "clockwise" | "counterclockwise";
-export const crudeLocation = z.union([direction, location, z.instanceof(String)]);
+export const crudeLocation = z.union([
+  directionZ,
+  z.enum([...OUTER_LOCATIONS, ...CENTER_LOCATIONS]),
+  z.instanceof(String),
+]);
 export type CrudeLocation = z.infer<typeof crudeLocation>;

package/src/spatial/bounds/bounds.ts

@@ -9,9 +9,9 @@
 
 import { abs, add, equal as mathEqual, min as mathMin, sub } from "@/math/math";
 import { type numeric } from "@/numeric";
-import { type Bounds, bounds, type CrudeBounds } from "@/spatial/base";
+import { type Bounds, boundsZ, type CrudeBounds } from "@/spatial/base";
 
-export { type Bounds, bounds };
+export { type Bounds, boundsZ };
 
 export type Crude<T extends numeric.Value = number> = CrudeBounds<T>;
 

package/src/spatial/box/box.ts

@@ -30,8 +30,8 @@ export const domRect = z.object({
   bottom: z.number(),
 });
 export const box = z.object({
-  one: xy.xy,
-  two: xy.xy,
+  one: xy.xyZ,
+  two: xy.xyZ,
   root: location.corner,
 });
 

package/src/spatial/dimensions/dimensions.ts

@@ -9,12 +9,18 @@
 
 import { z } from "zod";
 
-import { type Dimensions, dimensions, numberCouple, xy } from "@/spatial/base";
+import {
+  type Dimensions,
+  dimensionsZ,
+  numberCouple,
+  type SignedDimensions,
+  signedDimensionsZ,
+} from "@/spatial/base";
+import { xyZ } from "@/spatial/types.gen";
 
-export { type Dimensions, dimensions };
+export { type Dimensions, dimensionsZ, type SignedDimensions, signedDimensionsZ };
 
-export const signed = z.object({ signedWidth: z.number(), signedHeight: z.number() });
-export const crude = z.union([dimensions, signed, xy, numberCouple]);
+export const crude = z.union([dimensionsZ, signedDimensionsZ, xyZ, numberCouple]);
 export type Crude = z.infer<typeof crude>;
 
 export const ZERO = { width: 0, height: 0 };
@@ -29,7 +35,7 @@ export const construct = (width: number | Crude, height?: number): Dimensions =>
   return { ...width };
 };
 
-export type Signed = z.infer<typeof signed>;
+export type Signed = z.infer<typeof signedDimensionsZ>;
 
 export const equals = (ca: Crude, cb?: Crude | null): boolean => {
   if (cb == null) return false;

package/src/spatial/direction/direction.ts

@@ -15,15 +15,15 @@ import {
   type CrudeYDirection,
   type Dimension,
   type Direction,
-  direction,
   DIRECTIONS,
+  directionZ,
   type Location,
   type SignedDimension,
   Y_LOCATIONS,
   type YLocation,
 } from "@/spatial/base";
 
-export { Direction, direction, DIRECTIONS };
+export { type Direction, DIRECTIONS, directionZ };
 
 export const crude = crudeDirection;
 

package/src/spatial/external.ts

@@ -15,4 +15,5 @@ export * from "@/spatial/location";
 export * from "@/spatial/scale";
 export * as spatial from "@/spatial/spatial";
 export * from "@/spatial/sticky";
+export * from "@/spatial/types.gen";
 export * from "@/spatial/xy";

package/src/spatial/location/location.ts

@@ -14,37 +14,39 @@ import {
   type AngularDirection,
   CENTER_LOCATIONS,
   type CenterLocation,
-  centerLocation,
+  centerLocationZ,
   type CrudeLocation,
   crudeLocation,
   type Direction,
   DIRECTIONS,
   type Location,
-  location,
+  LOCATIONS,
+  locationZ,
   OUTER_LOCATIONS,
   type OuterLocation,
-  outerLocation,
+  outerLocationZ,
   X_LOCATIONS,
   type XLocation,
-  xLocation,
+  xLocationZ,
   Y_LOCATIONS,
   type YLocation,
-  yLocation,
+  yLocationZ,
 } from "@/spatial/base";
 
 export {
   CENTER_LOCATIONS,
   type Location,
-  location,
-  outerLocation as outer,
+  LOCATIONS,
+  locationZ,
   OUTER_LOCATIONS,
   X_LOCATIONS,
   Y_LOCATIONS,
 };
 
-export const x = xLocation;
-export const y = yLocation;
-export const center = centerLocation;
+export const x = xLocationZ;
+export const y = yLocationZ;
+export const center = centerLocationZ;
+export const outerZ = outerLocationZ;
 
 export type X = XLocation;
 export type Y = YLocation;
@@ -88,10 +90,10 @@ export const direction = (cl: Crude): Direction => {
 };
 
 export const xy = z.object({
-  x: xLocation.or(centerLocation),
-  y: yLocation.or(centerLocation),
+  x: xLocationZ.or(centerLocationZ),
+  y: yLocationZ.or(centerLocationZ),
 });
-export const corner = z.object({ x: xLocation, y: yLocation });
+export const corner = z.object({ x: xLocationZ, y: yLocationZ });
 
 export type XY = z.infer<typeof xy>;
 export type CornerXY = z.infer<typeof corner>;

package/src/spatial/spatial.ts

@@ -9,9 +9,36 @@
 
 export {
   type Alignment,
-  alignment,
   ALIGNMENTS,
+  alignmentZ,
+  type Bounds,
+  boundsZ,
+  CENTER_LOCATIONS,
+  type CenterLocation,
+  centerLocationZ,
+  type ClientXY,
+  clientXyZ,
+  type Dimensions,
+  dimensionsZ,
+  type Direction,
+  DIRECTIONS,
+  directionZ,
+  type Location,
+  LOCATIONS,
+  locationZ,
   type Order,
-  order,
   ORDERS,
+  orderZ,
+  OUTER_LOCATIONS,
+  type OuterLocation,
+  outerLocationZ,
+  type SignedDimensions,
+  signedDimensionsZ,
+  X_LOCATIONS,
+  type XLocation,
+  xLocationZ,
+  Y_LOCATIONS,
+  type YLocation,
+  yLocationZ,
 } from "@/spatial/base";
+export { type XY, xyZ } from "@/spatial/types.gen";

package/src/spatial/sticky/sticky.ts

@@ -13,7 +13,7 @@ import { box } from "@/spatial/box";
 import { location } from "@/spatial/location";
 import { xy as base } from "@/spatial/xy";
 
-export const completeXY = base.xy.extend({
+export const completeXY = base.xyZ.extend({
   root: location.corner,
   units: z.object({
     x: z.enum(["px", "decimal"]),

package/src/spatial/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 OUTER_LOCATIONS = ["top", "right", "bottom", "left"] as const;
+export const outerLocationZ = z.enum(OUTER_LOCATIONS);
+export type OuterLocation = z.infer<typeof outerLocationZ>;
+
+/**
+ * XY is a 2D coordinate point with x and y values. Used for positioning
+ * elements in two-dimensional space.
+ */
+export const xyZ = z.object({
+  /** x is the horizontal coordinate. */
+  x: z.number(),
+  /** y is the vertical coordinate. */
+  y: z.number(),
+});
+export interface XY extends z.infer<typeof xyZ> {}