@synnaxlabs/x 0.55.0 → 0.56.0

package/src/primitive/primitive.spec.ts

@@ -54,13 +54,13 @@ describe("primitive", () => {
 
   describe("isStringer", () => {
     it("should return true for a stringer", () => {
-      expect(primitive.isStringer(new ExampleStringer("cat"))).toEqual(true);
+      expect(primitive.isStringer(new ExampleStringer("cat"))).toBe(true);
     });
     it("should return false for a non-stringer", () => {
-      expect(primitive.isStringer(0)).toEqual(false);
+      expect(primitive.isStringer(0)).toBe(false);
     });
     it("should return false for null", () => {
-      expect(primitive.isStringer(null)).toEqual(false);
+      expect(primitive.isStringer(null)).toBe(false);
     });
   });
 
@@ -178,12 +178,65 @@ describe("primitive", () => {
 
       describe("isCrudeValueExtension", () => {
         it("should return true for a CrudeValueExtension", () => {
-          expect(primitive.isCrudeValueExtension({ value: 12n })).toEqual(true);
+          expect(primitive.isCrudeValueExtension({ value: 12n })).toBe(true);
         });
         it("should return false for a non-CrudeValueExtension", () => {
-          expect(primitive.isCrudeValueExtension(12n)).toEqual(false);
+          expect(primitive.isCrudeValueExtension(12n)).toBe(false);
         });
       });
     });
   });
+
+  describe("isHashable", () => {
+    class HashableThing implements primitive.Hashable {
+      constructor(private readonly v: string) {}
+      hash(): string {
+        return this.v;
+      }
+    }
+
+    it("returns true for an object with a hash() method", () => {
+      expect(primitive.isHashable(new HashableThing("x"))).toBe(true);
+    });
+
+    it("returns true for a plain object literal with a hash function", () => {
+      expect(primitive.isHashable({ hash: () => "x" })).toBe(true);
+    });
+
+    it("narrows the type for downstream calls", () => {
+      const v: unknown = new HashableThing("abc");
+      if (primitive.isHashable(v)) expect(v.hash()).toEqual("abc");
+      else throw new Error("expected isHashable to narrow");
+    });
+
+    it("returns false for null", () => {
+      expect(primitive.isHashable(null)).toBe(false);
+    });
+
+    it("returns false for undefined", () => {
+      expect(primitive.isHashable(undefined)).toBe(false);
+    });
+
+    it("returns false for primitives", () => {
+      expect(primitive.isHashable("x")).toBe(false);
+      expect(primitive.isHashable(42)).toBe(false);
+      expect(primitive.isHashable(42n)).toBe(false);
+      expect(primitive.isHashable(true)).toBe(false);
+    });
+
+    it("returns false for plain objects without a hash function", () => {
+      expect(primitive.isHashable({})).toBe(false);
+      expect(primitive.isHashable({ key: "x" })).toBe(false);
+    });
+
+    it("returns false when hash is not a function", () => {
+      expect(primitive.isHashable({ hash: "not a function" })).toBe(false);
+      expect(primitive.isHashable({ hash: 42 })).toBe(false);
+      expect(primitive.isHashable({ hash: null })).toBe(false);
+    });
+
+    it("returns false for arrays", () => {
+      expect(primitive.isHashable([1, 2, 3])).toBe(false);
+    });
+  });
 });

package/src/primitive/primitive.ts

@@ -61,6 +61,28 @@ export interface Stringer {
 export const isStringer = (value: unknown): boolean =>
   value != null && typeof value === "object" && "toString" in value;
 
+/**
+ * Hashable is a duck-typed protocol for class instances that can produce a stable,
+ * canonical string representation of themselves. Implementers commit to: (1) the
+ * returned string uniquely identifies the value's logical content, and (2) two
+ * instances representing the same logical value return equal strings.
+ *
+ * Used by cache-key derivation paths (e.g. flux queryCache) so non-primitive query
+ * fields hash to a stable identifier rather than relying on enumerable own-property
+ * iteration, which is fragile for class instances.
+ */
+export interface Hashable {
+  /** @returns a stable, canonical string representation of the value. */
+  hash: () => string;
+}
+
+/** @returns true if the value implements primitive.Hashable, otherwise returns false. */
+export const isHashable = (value: unknown): value is Hashable =>
+  value != null &&
+  typeof value === "object" &&
+  "hash" in value &&
+  typeof value.hash === "function";
+
 /**
  * Type representing zero values for each primitive type
  */

package/src/record/record.spec.ts

@@ -353,6 +353,32 @@ describe("record", () => {
       const obj = { nested: { key: "value" }, arr: [1, 2, 3] };
       expect(record.nullishToEmpty().parse(obj)).toEqual(obj);
     });
+
+    describe("with typed key and value schemas", () => {
+      const schema = record.nullishToEmpty(z.string(), z.number());
+
+      it("should coerce null to empty object", () => {
+        expect(schema.parse(null)).toEqual({});
+      });
+
+      it("should coerce undefined to empty object", () => {
+        expect(schema.parse(undefined)).toEqual({});
+      });
+
+      it("should pass through populated record matching the value schema", () => {
+        expect(schema.parse({ a: 1, b: 2 })).toEqual({ a: 1, b: 2 });
+      });
+
+      it("should reject values that don't match the value schema", () => {
+        expect(() => schema.parse({ a: "not a number" })).toThrow();
+      });
+
+      it("should preserve the inferred typed shape", () => {
+        const parsed = schema.parse({ a: 1 });
+        const value: number = parsed.a;
+        expect(value).toBe(1);
+      });
+    });
   });
 
   describe("omit", () => {

package/src/record/record.ts

@@ -141,6 +141,14 @@ export const omit = <T, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K> =>
   return result;
 };
 
+export interface NullishToEmpty {
+  (): z.ZodType<Unknown>;
+  <K extends z.ZodType<Key>, V extends z.ZodType>(
+    key: K,
+    value: V,
+  ): z.ZodType<Record<z.infer<K>, z.infer<V>>>;
+}
+
 /**
  * For required JSON/record fields: coerces null/undefined to empty object {}.
  * Use when the record must always be present and iterable.
@@ -149,9 +157,16 @@ export const omit = <T, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K> =>
  * - undefined → {}
  * - {} → {}
  * - {data} → {data}
+ *
+ * Without arguments the value type is unknown. Pass key and value zod schemas
+ * to type the resulting record (e.g. for `map<string, Color>` fields).
  */
-export const nullishToEmpty = (): z.ZodType<Unknown> =>
-  z.union([
-    z.union([z.null(), z.undefined()]).transform<Unknown>(() => ({})),
-    unknownZ(),
-  ]);
+export const nullishToEmpty = ((key?: z.ZodType, value?: z.ZodType) => {
+  if (key === undefined || value === undefined)
+    return z
+      .union([z.null().transform<Unknown>(() => ({})), unknownZ()])
+      .default(() => ({}));
+  return z
+    .union([z.null().transform(() => ({})), z.record(key as z.ZodType<Key>, value)])
+    .default(() => ({}));
+}) as NullishToEmpty;

package/src/require/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 require from "@/require/require";

package/src/require/require.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 type Require<T, K extends keyof T> = Pick<Required<T>, K> & Omit<T, K>;

package/src/spatial/base.ts

@@ -9,99 +9,7 @@
 
 import { z } from "zod";
 
-// Tuples
+export * from "@/spatial/types.gen";
 
 export const numberCouple = z.tuple([z.number(), z.number()]);
 export type NumberCouple<T extends number | bigint = number> = [T, T];
-
-// Direction
-
-export const DIRECTIONS = ["x", "y"] as const;
-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 outerLocationZ = z.enum(OUTER_LOCATIONS);
-export type OuterLocation = z.infer<typeof outerLocationZ>;
-
-export const X_LOCATIONS = ["left", "right"] as const;
-export const xLocationZ = z.enum(X_LOCATIONS);
-export type XLocation = z.infer<typeof xLocationZ>;
-
-export const Y_LOCATIONS = ["top", "bottom"] as const;
-export const yLocationZ = z.enum(Y_LOCATIONS);
-export type YLocation = z.infer<typeof yLocationZ>;
-
-export const CENTER_LOCATIONS = ["center"] as const;
-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 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 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 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;
-}
-
-export type CrudeBounds<T extends number | bigint = number> =
-  | Bounds<T>
-  | NumberCouple<T>;
-
-// 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([
-  directionZ,
-  z.enum([...OUTER_LOCATIONS, ...CENTER_LOCATIONS]),
-  z.instanceof(String),
-]);
-export type CrudeLocation = z.infer<typeof crudeLocation>;

package/src/spatial/bounds/bounds.ts

@@ -9,11 +9,11 @@
 
 import { abs, add, equal as mathEqual, min as mathMin, sub } from "@/math/math";
 import { type numeric } from "@/numeric";
-import { type Bounds, boundsZ, type CrudeBounds } from "@/spatial/base";
+import { type Bounds, boundsZ, type NumberCouple } from "@/spatial/base";
 
 export { type Bounds, boundsZ };
 
-export type Crude<T extends numeric.Value = number> = CrudeBounds<T>;
+export type Crude<T extends numeric.Value = number> = Bounds<T> | NumberCouple<T>;
 
 /** Options for the `construct` function. */
 interface ConstructOptions {
@@ -209,7 +209,7 @@ export const clamp = <T extends numeric.Value>(bounds: Crude<T>, target: T): T =
  */
 export const contains = <T extends numeric.Value>(
   bounds: Crude<T>,
-  target: T | CrudeBounds<T>,
+  target: T | Crude<T>,
 ): boolean => {
   const _bounds = construct(bounds);
   if (typeof target === "number" || typeof target === "bigint")
@@ -594,7 +594,7 @@ export const traverse = <T extends numeric.Value = number>(
   if (dir === 0) return start;
 
   let remainingDist = dist;
-  let currentPosition = start as number | bigint;
+  let currentPosition = start;
 
   while (mathEqual(remainingDist, 0) === false) {
     // Find the bound we're currently in or adjacent to
@@ -607,15 +607,15 @@ export const traverse = <T extends numeric.Value = number>(
       const b = _bounds[index];
       let distanceInBound: T;
       if (dir > 0) distanceInBound = sub(b.upper, currentPosition);
-      else distanceInBound = sub(currentPosition, b.lower) as T;
+      else distanceInBound = sub(currentPosition, b.lower);
 
       if (distanceInBound > (0 as T)) {
         const moveDist = mathMin(abs(remainingDist), distanceInBound);
-        currentPosition = add(currentPosition, dir > 0 ? moveDist : -moveDist) as T;
+        currentPosition = add(currentPosition, dir > 0 ? moveDist : -moveDist);
         remainingDist = sub<T>(remainingDist, dir > 0 ? moveDist : -moveDist);
 
         // If we've exhausted the distance, return the current position
-        if (mathEqual(remainingDist, 0)) return currentPosition as T;
+        if (mathEqual(remainingDist, 0)) return currentPosition;
         continue;
       }
     }
@@ -626,17 +626,17 @@ export const traverse = <T extends numeric.Value = number>(
       const nextBounds = _bounds.filter((b) => b.lower > currentPosition);
       if (nextBounds.length > 0) currentPosition = nextBounds[0].lower;
       // No more bounds in this direction
-      else return currentPosition as T;
+      else return currentPosition;
     } else {
       // Move to the previous bound's upper value
       const prevBounds = _bounds.filter((b) => b.upper < currentPosition);
       if (prevBounds.length > 0)
         currentPosition = prevBounds[prevBounds.length - 1].upper;
       // No more bounds in this direction
-      else return currentPosition as T;
+      else return currentPosition;
     }
   }
-  return currentPosition as T;
+  return currentPosition;
 };
 
 /**

package/src/spatial/box/box.ts

@@ -32,7 +32,7 @@ export const domRect = z.object({
 export const box = z.object({
   one: xy.xyZ,
   two: xy.xyZ,
-  root: location.corner,
+  root: location.cornerZ,
 });
 
 export type Box = z.infer<typeof box>;
@@ -50,7 +50,7 @@ export const ZERO = { one: xy.ZERO, two: xy.ZERO, root: location.TOP_LEFT };
  */
 export const DECIMAL = { one: xy.ZERO, two: xy.ONE, root: location.BOTTOM_LEFT };
 
-export const copy = (b: Box, root?: location.CornerXY): Box => ({
+export const copy = (b: Box, root?: location.Corner): Box => ({
   one: b.one,
   two: b.two,
   root: root ?? b.root,
@@ -71,7 +71,7 @@ export const construct = (
   second?: number | xy.XY | dimensions.Dimensions | dimensions.Signed,
   width: number = 0,
   height: number = 0,
-  coordinateRoot?: location.CornerXY,
+  coordinateRoot?: location.Corner,
 ): Box => {
   const b: Box = {
     one: { ...xy.ZERO },
@@ -339,7 +339,7 @@ export const yBounds = (b: Crude): bounds.Bounds => {
   return { lower: b_.one.y, upper: b_.two.y };
 };
 
-export const reRoot = (b: Box, corner: location.CornerXY): Box => copy(b, corner);
+export const reRoot = (b: Box, corner: location.Corner): Box => copy(b, corner);
 
 export const edgePoints = (b: Crude, loc: location.Location): [xy.XY, xy.XY] => {
   const b_ = construct(b);
@@ -461,7 +461,7 @@ export const constructWithAlternateRoot = (
   width: number,
   height: number,
   currRoot: location.XY,
-  newRoot: location.CornerXY,
+  newRoot: location.Corner,
 ): Box => {
   const first = { x, y };
   const second = { x: x + width, y: y + height };

package/src/spatial/direction/direction.ts

@@ -7,30 +7,29 @@
 // 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 {
   type AngularDirection,
-  type CrudeDirection,
-  crudeDirection,
-  type CrudeXDirection,
-  type CrudeYDirection,
+  CENTER_LOCATIONS,
   type Dimension,
   type Direction,
   DIRECTIONS,
   directionZ,
   type Location,
+  OUTER_LOCATIONS,
   type SignedDimension,
   Y_LOCATIONS,
   type YLocation,
-} from "@/spatial/base";
+} from "@/spatial/types.gen";
 
 export { type Direction, DIRECTIONS, directionZ };
 
-export const crude = crudeDirection;
-
-export type Crude = CrudeDirection;
-export type CrudeX = CrudeXDirection;
-export type CrudeY = CrudeYDirection;
 export type Angular = AngularDirection;
+export const crudeZ = z.enum(["x", "y", ...OUTER_LOCATIONS, ...CENTER_LOCATIONS]);
+export type Crude = z.infer<typeof crudeZ>;
+export type CrudeX = "x" | "left" | "right";
+export type CrudeY = "y" | "top" | "bottom";
 
 export const construct = (c: Crude): Direction => {
   if (DIRECTIONS.includes(c as Direction)) return c as Direction;
@@ -38,24 +37,24 @@ export const construct = (c: Crude): Direction => {
   return "x";
 };
 
-export const swap = (direction: CrudeDirection): Direction =>
+export const swap = (direction: Crude): Direction =>
   construct(direction) === "x" ? "y" : "x";
 
-export const dimension = (direction: CrudeDirection): Dimension =>
+export const dimension = (direction: Crude): Dimension =>
   construct(direction) === "x" ? "width" : "height";
 
-export const location = (direction: CrudeDirection): Location =>
+export const location = (direction: Crude): Location =>
   construct(direction) === "x" ? "left" : "top";
 
-export const isDirection = (c: unknown): c is Direction => crude.safeParse(c).success;
+export const isDirection = (c: unknown): c is Direction => crudeZ.safeParse(c).success;
 
-export const signedDimension = (direction: CrudeDirection): SignedDimension =>
+export const signedDimension = (direction: Crude): SignedDimension =>
   construct(direction) === "x" ? "signedWidth" : "signedHeight";
 
-export const isX = (direction: CrudeDirection): direction is CrudeXDirection => {
+export const isX = (direction: Crude): direction is CrudeX => {
   if (direction === "center") return false;
   return construct(direction) === "x";
 };
 
-export const isY = (direction: CrudeDirection): direction is CrudeYDirection =>
+export const isY = (direction: Crude): direction is CrudeY =>
   construct(direction) === "y";

package/src/spatial/external.ts

@@ -13,7 +13,6 @@ export * from "@/spatial/dimensions";
 export * from "@/spatial/direction";
 export * from "@/spatial/location";
 export * from "@/spatial/scale";
-export * as spatial from "@/spatial/spatial";
 export * from "@/spatial/sticky";
-export * from "@/spatial/types.gen";
+export * as spatial from "@/spatial/types.gen";
 export * from "@/spatial/xy";

package/src/spatial/location/location.ts

@@ -15,10 +15,11 @@ import {
   CENTER_LOCATIONS,
   type CenterLocation,
   centerLocationZ,
-  type CrudeLocation,
-  crudeLocation,
+  type CornerLocation,
+  cornerLocationZ,
   type Direction,
   DIRECTIONS,
+  directionZ,
   type Location,
   LOCATIONS,
   locationZ,
@@ -43,15 +44,18 @@ export {
   Y_LOCATIONS,
 };
 
-export const x = xLocationZ;
-export const y = yLocationZ;
-export const center = centerLocationZ;
+export const xZ = xLocationZ;
+export const yZ = yLocationZ;
+export const centerZ = centerLocationZ;
 export const outerZ = outerLocationZ;
+export const cornerZ = cornerLocationZ;
 
 export type X = XLocation;
 export type Y = YLocation;
 export type Outer = OuterLocation;
 export type Center = CenterLocation;
+export type Corner = CornerLocation;
+export type CornerString = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
 
 const SWAPPED: Record<Location, Location> = {
   top: "bottom",
@@ -67,10 +71,12 @@ const ROTATIONS: Record<Outer, Record<AngularDirection, Outer>> = {
   bottom: { clockwise: "right", counterclockwise: "left" },
   left: { clockwise: "bottom", counterclockwise: "top" },
 };
-
-export const crude = crudeLocation;
-
-export type Crude = CrudeLocation;
+export const crudeZ = z.union([
+  directionZ,
+  z.enum([...OUTER_LOCATIONS, ...CENTER_LOCATIONS]),
+  z.instanceof(String),
+]);
+export type Crude = z.infer<typeof crudeZ>;
 
 export const construct = (cl: Crude): Location => {
   if (cl instanceof String) return cl as Location;
@@ -93,16 +99,12 @@ export const xy = z.object({
   x: xLocationZ.or(centerLocationZ),
   y: yLocationZ.or(centerLocationZ),
 });
-export const corner = z.object({ x: xLocationZ, y: yLocationZ });
-
 export type XY = z.infer<typeof xy>;
-export type CornerXY = z.infer<typeof corner>;
-export type CornerXYString = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";
 
-export const TOP_LEFT: CornerXY = Object.freeze({ x: "left", y: "top" });
-export const TOP_RIGHT: CornerXY = Object.freeze({ x: "right", y: "top" });
-export const BOTTOM_LEFT: CornerXY = Object.freeze({ x: "left", y: "bottom" });
-export const BOTTOM_RIGHT: CornerXY = Object.freeze({ x: "right", y: "bottom" });
+export const TOP_LEFT: Corner = Object.freeze({ x: "left", y: "top" });
+export const TOP_RIGHT: Corner = Object.freeze({ x: "right", y: "top" });
+export const BOTTOM_LEFT: Corner = Object.freeze({ x: "left", y: "bottom" });
+export const BOTTOM_RIGHT: Corner = Object.freeze({ x: "right", y: "bottom" });
 export const CENTER: XY = Object.freeze({ x: "center", y: "center" });
 export const TOP_CENTER: XY = Object.freeze({ x: "center", y: "top" });
 export const BOTTOM_CENTER: XY = Object.freeze({ x: "center", y: "bottom" });

package/src/spatial/scale/scale.ts

@@ -417,12 +417,12 @@ export class Scale<T extends numeric.Value = number> {
 export class XY {
   x: Scale<number>;
   y: Scale<number>;
-  currRoot: location.CornerXY | null;
+  currRoot: location.Corner | null;
 
   constructor(
     x: Scale<number> = new Scale<number>(),
     y: Scale<number> = new Scale<number>(),
-    root: location.CornerXY | null = null,
+    root: location.Corner | null = null,
   ) {
     this.x = x;
     this.y = y;

package/src/spatial/sticky/sticky.spec.ts

@@ -134,7 +134,7 @@ describe("sticky", () => {
     ];
     SPECS.forEach(({ value, valid }, i) => {
       test(`xy schema ${i}`, () => {
-        const result = sticky.xy.safeParse(value);
+        const result = sticky.xyZ.safeParse(value);
         expect(result.success).toBe(valid);
       });
     });
@@ -196,7 +196,7 @@ describe("sticky", () => {
     ];
     SPECS.forEach(({ value, valid }, i) => {
       test(`completeXY schema ${i}`, () => {
-        const result = sticky.completeXY.safeParse(value);
+        const result = sticky.completeXYZ.safeParse(value);
         expect(result.success).toBe(valid);
       });
     });

package/src/spatial/sticky/sticky.ts

@@ -7,25 +7,18 @@
 // 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 type z from "zod";
 
 import { box } from "@/spatial/box";
 import { location } from "@/spatial/location";
+import { type StickyXY, stickyXYZ } from "@/spatial/types.gen";
 import { xy as base } from "@/spatial/xy";
 
-export const completeXY = base.xyZ.extend({
-  root: location.corner,
-  units: z.object({
-    x: z.enum(["px", "decimal"]),
-    y: z.enum(["px", "decimal"]),
-  }),
-});
+export const xyZ = stickyXYZ;
+export type XY = StickyXY;
 
-export type CompleteXY = z.infer<typeof completeXY>;
-
-export const xy = completeXY.partial({ root: true, units: true });
-
-export interface XY extends z.infer<typeof xy> {}
+export const completeXYZ = stickyXYZ.required({ root: true, units: true });
+export type CompleteXY = z.infer<typeof completeXYZ>;
 
 interface ToCSSReturn extends Partial<Record<location.Outer, string>> {}