@synnaxlabs/x 0.42.1 → 0.43.0

package/src/color/external.ts

@@ -10,4 +10,3 @@
 export * from "@/color/color";
 export * from "@/color/gradient";
 export * from "@/color/palette";
-export * from "@/color/transformColorsToHex";

package/src/color/gradient.ts

@@ -7,7 +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";
+import { z } from "zod/v4";
 
 import {
   aValue,
@@ -41,38 +41,30 @@ export const fromGradient = (gradient: Gradient, position: number): Color => {
   if (position >= gradient[gradient.length - 1].position)
     return construct(gradient[gradient.length - 1].color);
 
-  // Find the two stops between which the position lies
   for (let i = 0; i < gradient.length - 1; i++) {
     const start = gradient[i];
     const end = gradient[i + 1];
 
-    if (position >= start.position && position <= end.position) {
-      if (position === start.position) return construct(start.color);
-
-      if (position === end.position) return construct(end.color);
-
-      // Interpolate
-      const t = (position - start.position) / (end.position - start.position);
-
-      // Convert colors to RGBA
-      const startColor = construct(start.color);
-      const endColor = construct(end.color);
-
-      const r = Math.round(
-        rValue(startColor) + t * (rValue(endColor) - rValue(startColor)),
-      );
-      const g = Math.round(
-        gValue(startColor) + t * (gValue(endColor) - gValue(startColor)),
-      );
-      const b = Math.round(
-        bValue(startColor) + t * (bValue(endColor) - bValue(startColor)),
-      );
-      const a = aValue(startColor) + t * (aValue(endColor) - aValue(startColor)); // Interpolate alpha directly
-
-      return construct([r, g, b, a]);
-    }
+    if (position < start.position || position > end.position) continue;
+    if (position === start.position) return construct(start.color);
+    if (position === end.position) return construct(end.color);
+    const t = (position - start.position) / (end.position - start.position);
+    const startColor = construct(start.color);
+    const endColor = construct(end.color);
+
+    const r = Math.round(
+      rValue(startColor) + t * (rValue(endColor) - rValue(startColor)),
+    );
+    const g = Math.round(
+      gValue(startColor) + t * (gValue(endColor) - gValue(startColor)),
+    );
+    const b = Math.round(
+      bValue(startColor) + t * (bValue(endColor) - bValue(startColor)),
+    );
+    const a = aValue(startColor) + t * (aValue(endColor) - aValue(startColor));
+
+    return construct([r, g, b, a]);
   }
 
-  // If position didn't match any interval, return the last color
   return construct(gradient[gradient.length - 1].color);
 };

package/src/color/palette.ts

@@ -7,7 +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";
+import { z } from "zod/v4";
 
 import { colorZ } from "@/color/color";
 

package/src/compare/compare.ts

@@ -7,7 +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 { isStringer, type Primitive } from "@/primitive";
+import { primitive } from "@/primitive";
 import { type spatial } from "@/spatial";
 import { unique } from "@/unique";
 
@@ -22,7 +22,7 @@ export type CompareF<T> = (a: T, b: T) => number;
  * @param reverse Whether to reverse the sort order.
  */
 export const newF = <T>(v: T, reverse: boolean = false): CompareF<T> => {
-  const t = isStringer(v) ? "stringer" : typeof v;
+  const t = primitive.isStringer(v) ? "stringer" : typeof v;
   let f: CompareF<T>;
   switch (t) {
     case "string":
@@ -75,7 +75,7 @@ export const newFieldF = <T>(
  * @returns The array with the greater length if the array lengths are not equal. If the
  * arrays are the same length, returns 0 if all elements are equal, otherwise returns -1.
  */
-export const primitiveArrays = <T extends Primitive>(
+export const primitiveArrays = <T extends primitive.Value>(
   a: readonly T[] | T[],
   b: readonly T[] | T[],
 ): number => {
@@ -83,7 +83,7 @@ export const primitiveArrays = <T extends Primitive>(
   return a.every((v, i) => v === b[i]) ? 0 : -1;
 };
 
-export const unorderedPrimitiveArrays = <T extends Primitive>(
+export const unorderedPrimitiveArrays = <T extends primitive.Value>(
   a: readonly T[] | T[],
   b: readonly T[] | T[],
 ): number => {
@@ -95,7 +95,7 @@ export const unorderedPrimitiveArrays = <T extends Primitive>(
   return aSorted.every((v, i) => v === bSorted[i]) ? 0 : -1;
 };
 
-export const uniqueUnorderedPrimitiveArrays = <T extends Primitive>(
+export const uniqueUnorderedPrimitiveArrays = <T extends primitive.Value>(
   a: readonly T[] | T[],
   b: readonly T[] | T[],
 ): number => {

package/src/control/control.ts

@@ -7,7 +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";
+import { z } from "zod/v4";
 
 import { type bounds } from "@/spatial";
 
@@ -32,10 +32,10 @@ export interface Subject {
   key: string;
 }
 
-export const stateZ = <T extends z.ZodTypeAny>(r: T) =>
+export const stateZ = <R extends z.ZodType>(resource: R) =>
   z.object({
     subject: subjectZ,
-    resource: r,
+    resource,
     authority: authorityZ,
   });
 
@@ -60,20 +60,22 @@ interface Release<R> {
   to?: null;
 }
 
-export const releaseZ = z.object({
-  from: stateZ(z.any()),
-  to: z.null(),
-});
+export const releaseZ = <R extends z.ZodType>(resource: R) =>
+  z.object({
+    from: stateZ(resource),
+    to: z.null(),
+  });
 
 interface Acquire<R> {
   from?: null;
   to: State<R>;
 }
 
-export const acquireZ = z.object({
-  from: z.null(),
-  to: stateZ(z.any()),
-});
+export const acquireZ = <R extends z.ZodType>(resource: R) =>
+  z.object({
+    from: z.null(),
+    to: stateZ(resource),
+  });
 
 export type Transfer<R> =
   | {
@@ -83,11 +85,12 @@ export type Transfer<R> =
   | Release<R>
   | Acquire<R>;
 
-export const transferZ = z.union([
-  releaseZ,
-  acquireZ,
-  z.object({
-    from: stateZ(z.any()),
-    to: stateZ(z.any()),
-  }),
-]);
+export const transferZ = <R extends z.ZodType>(resource: R) =>
+  z.union([
+    releaseZ(resource),
+    acquireZ(resource),
+    z.object({
+      from: stateZ(resource),
+      to: stateZ(resource),
+    }),
+  ]);

package/src/debounce/debounce.ts

@@ -25,7 +25,7 @@ export const debounce = <F extends (...args: any[]) => void>(
   return debounced as F;
 };
 
-export const throttle = <F extends (...args: any[]) => void>(
+export const throttle = <F extends (...args: unknown[]) => void>(
   func: F,
   waitFor: number,
 ): F => {

package/src/deep/delete.ts

@@ -10,16 +10,17 @@
 import { type Key } from "@/deep/path";
 
 // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-constraint
-export const deleteD = <T extends any, D extends number = 5>(
+export const deleteD = <T extends unknown, D extends number = 5>(
   target: T,
   ...keys: Array<Key<T, D>>
 ): T => {
   keys.forEach((key) => {
-    let curr: any = target;
+    let curr = target;
     const arr = key.split(".");
     arr.forEach((k, i) => {
-      if (i === arr.length - 1) delete curr[k];
-      else if (k in curr) curr = curr[k];
+      if (typeof curr !== "object" || curr === null) return;
+      if (i === arr.length - 1) delete curr[k as keyof typeof curr];
+      else if (k in curr) curr = curr[k as keyof typeof curr] as T;
     });
   });
   return target;

package/src/deep/difference.ts

@@ -16,7 +16,7 @@ export const difference = (
 ): Record<string, PathValueTuple> => {
   const diffMap: Record<string, PathValueTuple> = {};
 
-  const compare = (a: any, b: any, currentPath: string): void => {
+  const compare = (a: unknown, b: unknown, currentPath: string): void => {
     if (typeof a !== typeof b || a === null || b === null) {
       diffMap[currentPath] = [a, b];
       return;
@@ -32,7 +32,11 @@ export const difference = (
       } else {
         const keys = new Set([...Object.keys(a as {}), ...Object.keys(b as {})]);
         keys.forEach((key) => {
-          compare(a[key], b[key], currentPath !== "" ? `${currentPath}.${key}` : key);
+          compare(
+            a[key as keyof typeof a],
+            b[key as keyof typeof b],
+            currentPath !== "" ? `${currentPath}.${key}` : key,
+          );
         });
       }
     else if (a !== b) diffMap[currentPath] = [a, b];

package/src/deep/equal.spec.ts

@@ -7,7 +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 { describe, expect,it } from "vitest";
+import { describe, expect, it } from "vitest";
 
 import { deep } from "@/deep";
 

package/src/deep/equal.ts

@@ -7,14 +7,14 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { type Primitive } from "@/primitive";
+import { type primitive } from "@/primitive";
 
 interface DeepEqualBaseRecord {
-  equals?: (other: any) => boolean;
+  equals?: (other: unknown) => boolean;
 }
 
 export const equal = <
-  T extends unknown | DeepEqualBaseRecord | DeepEqualBaseRecord[] | Primitive[],
+  T extends unknown | DeepEqualBaseRecord | DeepEqualBaseRecord[] | primitive.Value[],
 >(
   a: T,
   b: T,
@@ -31,7 +31,7 @@ export const equal = <
   }
   if (a == null || b == null || typeof a !== "object" || typeof b !== "object")
     return a === b;
-  if ("equals" in a) return (a.equals as (other: any) => boolean)(b);
+  if ("equals" in a) return (a.equals as (other: unknown) => boolean)(b);
   const aKeys = Object.keys(a);
   const bKeys = Object.keys(b);
   if (aKeys.length !== bKeys.length) return false;
@@ -47,7 +47,7 @@ export const equal = <
   return true;
 };
 
-export const partialEqual = <T extends unknown | DeepEqualBaseRecord | Primitive>(
+export const partialEqual = <T extends unknown | DeepEqualBaseRecord | primitive.Value>(
   base: T,
   partial: Partial<T>,
 ): boolean => {

package/src/deep/merge.spec.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { describe, expect, it } from "vitest";
-import { z } from "zod";
+import { z } from "zod/v4";
 
 import { deep } from "@/deep";
 
@@ -243,6 +243,18 @@ describe("deepMerge", () => {
     });
   });
 
+  it("should work with multiple extensions", () => {
+    const az = z.object({ a: z.number() });
+    const cz = z.object({ c: z.boolean() });
+    const extendedSchema = az.extend(cz);
+    const base = { a: 1 };
+    const override = { b: "2", c: true };
+    expect(deep.overrideValidItems(base, override, extendedSchema)).toEqual({
+      a: 1,
+      c: true,
+    });
+  });
+
   it("should work with intersection", () => {
     const schema1 = z.object({
       a: z.number(),

package/src/deep/merge.ts

@@ -7,7 +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 { type z } from "zod";
+import { type z } from "zod/v4";
 
 import { type Partial } from "@/deep/partial";
 import { isObject } from "@/identity";
@@ -61,12 +61,21 @@ export const overrideValidItems = <A, B>(
     // Iterate over each property in the override object
     for (const key in overrideObj) {
       const overrideValue = overrideObj[key];
-      const shape = currentSchema?.shape;
-      if (shape?.[key]) {
-        const result = shape[key].safeParse(overrideValue);
-        // Check if parsing succeeded
-        if (result.success) baseObj[key] = result.data;
-      } else if (
+      let shape = currentSchema?.shape;
+      if (shape != null)
+        while (shape != null) {
+          if (shape[key] != null) {
+            const result = shape[key].safeParse(overrideValue);
+            // Check if parsing succeeded
+            if (result.success) {
+              baseObj[key] = result.data;
+              break;
+            }
+          }
+          shape = shape.def?.shape;
+        }
+
+      if (
         typeof overrideValue === "object" &&
         !Array.isArray(overrideValue) &&
         overrideValue !== null

package/src/deep/path.ts

@@ -133,7 +133,7 @@ export const get = (<V = unknown, T = UnknownRecord>(
   opts: GetOptions = { optional: false, separator: "." },
 ): V | null => {
   opts.separator ??= ".";
-  const { optional, getter = (obj, key) => (obj)[key] } = opts;
+  const { optional, getter = (obj, key) => obj[key] } = opts;
   const parts = path.split(opts.separator);
   if (parts.length === 1 && parts[0] === "") return obj as unknown as V;
   let result: UnknownRecord = obj as UnknownRecord;

package/src/errors/errors.ts

@@ -7,59 +7,60 @@
 // 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";
+import { z } from "zod/v4";
 
 import { singleton } from "@/singleton";
 
+const ERROR_DISCRIMINATOR = "sy_x_error";
+
 /**
  * @returns general function that returns true if an error matches a set of
  * abstracted criteria
  */
-export type Matcher = (e: string | Error | unknown) => boolean;
+export type Matcher = (e: unknown) => boolean;
 
-/** @description an error type that can match against other errors. */
+/** an error type that can match against other errors. */
 export interface Matchable {
   /**
-   * @returns a function that matches errors of the given type. Returns true if
-   * the provided instance of Error or a string message contains the provided error type.
+   * @returns true if the provided error matches the matchable.
    */
   matches: Matcher;
 }
 
 /**
- * @description an error that has a network-portable type, allowing it to be encoded/
- * decoded by freighter. Also allows for simpler matching using @method matches instead
- * of using instanceof, which has a number of caveats.
+ * An error that has a network-portable type, allowing it to be encoded/decoded into
+ * a JSON representation. Also allows for simpler matching using @method matches instead of using
+ * instanceof, which has a number of caveats.
  */
 export interface Typed extends Error, Matchable {
-  discriminator: "FreighterError";
+  discriminator: typeof ERROR_DISCRIMINATOR;
   /**
-   * @description Returns a unique type identifier for the error. Freighter uses this to
-   * determine the correct decoder to use on the other end of the freighter.
+   * Returns a unique type identifier for the error. The errors package uses this to
+   *  determine the correct decoder to use when encoding/decoding errors.
    */
   type: string;
 }
 
 /**
- * @description a class that, when constructed, implements the TypedError interface.
- * Also provides utilities for matching and creating subclasses.
+ * a class that, when constructed, implements the TypedError interface. Also provides
+ * utilities for matching and creating subclasses.
  */
 export interface TypedClass extends Matchable {
   /**
-   * @description constructs a new TypedError. Identical to the Error constructor.
+   * constructs a new TypedError. Identical to the Error constructor.
    * @param message - the error message.
    * @param options - the error options.
    * @returns a new TypedError.
    */
   new (message?: string, options?: ErrorOptions): Typed;
   /**
-   * @description the type of the error.
+   * the type of the error.
    */
   TYPE: string;
   /**
-   * @description creates a new subclass of the error that extends its type. So if
-   * the type of this class is `dog` and subType is `labrador`, the type of the new
-   * class will be `dog.labrador`.
+   * creates a new subclass of the error that extends its type. So if the type of this
+   * class is `dog` and subType is `labrador`, the type of the new class will be
+   * `dog.labrador`.
    * @param subType - the type of the new error.
    * @returns a new TypedErrorClass.
    */
@@ -92,7 +93,7 @@ const createTypeMatcher =
  */
 export const createTyped = (type: string): TypedClass =>
   class Internal extends Error implements Typed {
-    static readonly discriminator = "FreighterError";
+    static readonly discriminator = ERROR_DISCRIMINATOR;
     readonly discriminator = Internal.discriminator;
 
     static readonly TYPE = type;
@@ -111,50 +112,67 @@ export const createTyped = (type: string): TypedClass =>
   };
 
 /**
- * @description Function that decodes an encoded error payload back into an error object
+ * Function that decodes an encoded error payload back into an error object
  * @param encoded - The encoded error payload to decode
- * @returns The decoded error object or null if the decoder cannot handle this error type
+ * @returns The decoded error object or null if the decoder cannot handle this error
+ * type
  */
 export type Decoder = (encoded: Payload) => Error | null;
 
 /**
- * @description Function that encodes a typed error into a network-portable payload
+ * Function that encodes a typed error into a network-portable payload
  * @param error - The typed error to encode
  * @returns The encoded error payload or null if the encoder cannot handle this error type
  */
 export type Encoder = (error: Typed) => Payload | null;
 
 /**
- * @description Checks if an unknown value is a TypedError
+ * Checks if an unknown value is a TypedError
  * @param error - The value to check
  * @returns True if the value is a TypedError, false otherwise
  */
 export const isTyped = (error: unknown): error is Typed => {
   if (error == null || typeof error !== "object") return false;
   const typedError = error as Typed;
-  if (typedError.discriminator !== "FreighterError") return false;
+  if (typedError.discriminator !== ERROR_DISCRIMINATOR) return false;
   if (!("type" in typedError))
     throw new Error(
-      `Freighter error is missing its type property: ${JSON.stringify(typedError)}`,
+      `X Error is missing its type property: ${JSON.stringify(typedError)}`,
     );
   return true;
 };
 
-/** @description Constant representing an unknown error type */
+/** Constant representing an unknown error type */
 export const UNKNOWN = "unknown";
 
-/** @description Constant representing no error (null) */
+/** Constant representing no error (null) */
 export const NONE = "nil";
 
-interface provider {
+/**
+ * provides custom encoding/decoding mechanisms for specific error
+ * categories.
+ */
+interface Provider {
+  /**
+   * Encodes an error into a primitive payload that can be sent over the network or stored
+   * on disk.
+   * @param error - The error to encode.
+   * @returns The encoded error.
+   */
   encode: Encoder;
+  /**
+   * Decodes an error from a primitive payload that can be sent over the network or stored
+   * on disk.
+   * @param payload - The encoded error.
+   * @returns The decoded error.
+   */
   decode: Decoder;
 }
 
 class Registry {
-  private readonly providers: provider[] = [];
+  private readonly providers: Provider[] = [];
 
-  register(provider: provider): void {
+  register(provider: Provider): void {
     this.providers.push(provider);
   }
 
@@ -195,17 +213,12 @@ const getRegistry = singleton.define("synnax-error-registry", () => new Registry
  * @param encode - A function that encodes the error into a string.
  * @param decode - A function that decodes the error from a string.
  */
-export const register = ({
-  encode,
-  decode,
-}: {
-  encode: Encoder;
-  decode: Decoder;
-}): void => getRegistry().register({ encode, decode });
+export const register = ({ encode, decode }: Provider): void =>
+  getRegistry().register({ encode, decode });
 
 /**
- * Encodes an error into a payload that can be sent between a freighter server
- * and client.
+ * Encodes an error into a primitive payload that can be sent over the network or stored
+ * on disk.
  * @param error - The error to encode.
  * @returns The encoded error.
  */
@@ -225,17 +238,25 @@ export const decode = (payload?: Payload | null): Error | null => {
 };
 
 /**
- * @description Generic error for representing unknown errors
+ * Generic error for representing unknown errors
  */
 export class Unknown extends createTyped("unknown") {}
 
-/** @description Zod schema for validating error payloads */
+/** Zod schema for validating error payloads */
 export const payloadZ = z.object({ type: z.string(), data: z.string() });
 
-/** @description Network-portable representation of an error */
+/** Network-portable representation of an error */
 export type Payload = z.infer<typeof payloadZ>;
 
-/** @description Error for representing the cancellation of an operation */
+/** Error for representing the cancellation of an operation */
 export class Canceled extends createTyped("canceled") {}
 
-export type Return<T> = [T, null] | [null, Error];
+/** 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;
+}

package/src/index.ts

@@ -7,6 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+export * from "@/array";
 export * from "@/binary";
 export * from "@/breaker";
 export * from "@/caseconv";
@@ -21,6 +22,7 @@ export * from "@/destructor";
 export * from "@/errors";
 export * from "@/id";
 export * from "@/identity";
+export * from "@/instance";
 export * from "@/invert";
 export * from "@/jsonrpc";
 export * from "@/kv";
@@ -40,12 +42,13 @@ export * from "@/search";
 export * from "@/shallowCopy";
 export * from "@/sleep";
 export * from "@/spatial";
+export * from "@/status";
 export * from "@/strings";
 export * from "@/sync";
 export * from "@/telem";
-export * from "@/toArray";
 export * from "@/transform";
 export * from "@/unique";
 export * from "@/url";
+export * from "@/uuid";
 export * from "@/worker";
 export * from "@/zod";

package/src/instance/index.ts

@@ -0,0 +1,10 @@
+// Copyright 2025 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 instance from "@/instance/matcher";