@synnaxlabs/x 0.53.0 → 0.54.0

package/src/caseconv/caseconv.ts

@@ -7,56 +7,212 @@
 // 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 record } from "@/record";
 
+/**
+ * Global symbol used to mark Zod schemas that should not have their keys converted.
+ * Uses Symbol.for() to ensure the same symbol is used across different module instances.
+ */
+const PRESERVE_CASE_SYMBOL = "synnax.caseconv.preserveCase";
+
+interface ZodDef extends z.core.$ZodTypeDef {
+  innerType?: z.core.SomeType;
+  options?: readonly z.core.SomeType[];
+  in?: z.core.SomeType;
+  out?: z.core.SomeType;
+  element?: z.core.SomeType;
+  shape?: Record<string, z.ZodType>;
+}
+
+interface ZodInternals extends z.core.$ZodTypeInternals {
+  def: ZodDef;
+}
+
+interface ZodSchema extends z.core.$ZodType {
+  [PRESERVE_CASE_SYMBOL]?: boolean;
+  _zod: ZodInternals;
+  shape?: Record<string, z.ZodType>;
+  sourceType?: () => { shape?: Record<string, z.ZodType> } | undefined;
+}
+
+/**
+ * Marks a Zod schema to prevent case conversion of its keys and nested content.
+ * Use this for schemas where keys are semantic values (like OPC UA NodeIds or Modbus channel keys)
+ * rather than property names.
+ *
+ * @param schema - The Zod schema to mark
+ * @returns The same schema with a preserve case marker
+ *
+ * @example
+ * const propertiesZ = z.object({
+ *   read: z.object({
+ *     channels: preserveCase(z.record(z.string(), z.number()))
+ *   })
+ * });
+ */
+export const preserveCase = <T extends z.ZodType>(schema: T): T => {
+  (schema as ZodSchema)[PRESERVE_CASE_SYMBOL] = true;
+  return schema;
+};
+
+/**
+ * Checks if a Zod schema has the preserve case marker.
+ * Traverses through wrapper schemas (optional, nullable, union, transform, etc.)
+ * to find markers on inner schemas.
+ */
+const hasPreserveCaseMarker = (schema: unknown): boolean => {
+  if (schema == null || typeof schema !== "object") return false;
+
+  // Direct marker check
+  if (PRESERVE_CASE_SYMBOL in schema) return true;
+
+  const s = schema as ZodSchema;
+  const def: ZodDef | undefined = s._zod?.def;
+  if (def == null) return false;
+
+  // Traverse through wrappers with innerType (optional, nullable, default, catch)
+  if (def.innerType && hasPreserveCaseMarker(def.innerType)) return true;
+
+  // Traverse through unions - check all options
+  if (def.type === "union" && Array.isArray(def.options))
+    return def.options.some(hasPreserveCaseMarker);
+
+  // Traverse through pipes/transforms - check both ends
+  if (def.type === "pipe")
+    return hasPreserveCaseMarker(def.in) || hasPreserveCaseMarker(def.out);
+
+  return false;
+};
+
+/**
+ * Unwraps an array schema to get its element schema.
+ * Handles direct arrays and unions containing arrays (e.g., from nullishToEmpty).
+ * Returns undefined if the schema is not an array or is undefined.
+ */
+const getArrayElementSchema = (
+  schema: z.ZodType | z.core.SomeType | undefined,
+): z.ZodType | undefined => {
+  if (schema == null) return undefined;
+  const def = (schema as ZodSchema)._zod?.def;
+  if (def?.type === "array" && def.element != null) return def.element as z.ZodType;
+  // Handle union types that may contain arrays (e.g., nullishToEmpty)
+  if (def?.type === "union" && Array.isArray(def.options))
+    for (const option of def.options) {
+      const result = getArrayElementSchema(option);
+      if (result != null) return result;
+    }
+
+  return undefined;
+};
+
+/**
+ * Extracts the shape (field name → ZodType map) from a Zod schema.
+ * Traverses through wrappers (optional, nullable, default, catch, union, pipe)
+ * to find the inner object schema's shape. Returns null for non-object schemas.
+ */
+const getSchemaShape = (
+  schema: z.ZodType | z.core.SomeType | undefined,
+): Record<string, z.ZodType> | null => {
+  if (schema == null) return null;
+  const s = schema as ZodSchema;
+  if (s.shape != null) return s.shape;
+  if (typeof s.sourceType === "function") {
+    const st = s.sourceType();
+    if (st?.shape != null) return st.shape;
+  }
+  const def = s._zod?.def;
+  if (def == null) return null;
+  if (def.innerType != null) return getSchemaShape(def.innerType);
+  if (def.type === "union" && Array.isArray(def.options))
+    for (const option of def.options) {
+      const result = getSchemaShape(option);
+      if (result != null) return result;
+    }
+
+  if (def.type === "pipe") return getSchemaShape(def.in) ?? getSchemaShape(def.out);
+  return null;
+};
+
 const snakeToCamelStr = (str: string): string => {
-  const c = str.replace(/_[a-z]/g, (m) => m[1].toUpperCase());
-  // if both first and second characters are upper case, leave as is
-  // if only first character is upper case, convert to lower case
-  if (c.length > 1 && c[0] === c[0].toUpperCase() && c[1] === c[1].toUpperCase())
-    return c;
-  if (c.length === 0) return c;
-  return c[0].toLowerCase() + c.slice(1);
+  if (str.length === 0) return str;
+  const hasUnderscore = str.indexOf("_") !== -1;
+  const c = hasUnderscore ? str.replace(/_[a-z]/g, (m) => m[1].toUpperCase()) : str;
+  const first = c.charCodeAt(0);
+  if (first < 65 || first > 90) return c; // not uppercase A-Z
+  if (c.length > 1 && c.charCodeAt(1) >= 65 && c.charCodeAt(1) <= 90) return c;
+  return String.fromCharCode(first + 32) + c.slice(1);
 };
+
 /**
  * Convert string keys in an object to snake_case format.
  * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned.
  * @param opt: (optional) Options parameter, default is non-recursive.
+ * @param schema: (optional) Zod schema to check for preserve case markers
  */
 const createConverter = (
   f: (v: string) => string,
 ): (<V>(obj: V, opt?: Options) => V) => {
   const converter = <V>(obj: V, opt: Options = defaultOptions): V => {
-    if (typeof obj === "string") return f(obj) as any;
-    if (Array.isArray(obj)) return obj.map((v) => converter(v, opt)) as V;
+    if (typeof obj === "string") return f(obj) as V;
+    if (Array.isArray(obj)) {
+      const elementSchema = getArrayElementSchema(opt.schema);
+      const elemOpt: Options = {
+        recursive: opt.recursive,
+        recursiveInArray: opt.recursiveInArray,
+        schema: elementSchema,
+      };
+      return obj.map((v) => converter(v, elemOpt)) as V;
+    }
     if (!isValidObject(obj)) return obj;
-    opt = validateOptions(opt);
+
+    if (opt.schema != null && hasPreserveCaseMarker(opt.schema)) return obj;
+
+    const recursive = opt.recursive ?? true;
+    const recursiveInArray = opt.recursiveInArray ?? recursive;
+    const schema = opt.schema;
     const res: record.Unknown = {};
     const anyObj = obj as record.Unknown;
     if ("toJSON" in anyObj && typeof anyObj.toJSON === "function")
       return converter(anyObj.toJSON(), opt);
-    Object.keys(anyObj).forEach((key) => {
+
+    const shape = getSchemaShape(schema);
+    const childOpt: Options = { recursive, recursiveInArray, schema: undefined };
+    const keys = Object.keys(anyObj);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
       let value = anyObj[key];
       const nkey = f(key);
-      if (opt.recursive)
+
+      // Look up schema using BOTH original key and converted key since:
+      // - For snakeToCamel: schema has camelCase keys, input has snake_case, nkey is camelCase (matches)
+      // - For camelToSnake: schema has camelCase keys, input has camelCase, nkey is snake_case (key matches)
+      const propSchema: z.ZodType | undefined =
+        shape != null ? (shape[key] ?? shape[nkey] ?? undefined) : undefined;
+
+      if (recursive)
         if (isValidObject(value)) {
-          if (!belongToTypes(value)) value = converter(value, opt);
-        } else if (opt.recursiveInArray && isArrayObject(value))
-          value = [...(value as unknown[])].map((v) => {
-            let ret = v;
+          if (!isPreservedType(value)) {
+            childOpt.schema = propSchema;
+            value = converter(value, childOpt);
+          }
+        } else if (recursiveInArray && Array.isArray(value)) {
+          const elementSchema = getArrayElementSchema(propSchema);
+          childOpt.schema = elementSchema;
+          value = (value as unknown[]).map((v) => {
             if (isValidObject(v)) {
-              // object in array
-              if (!belongToTypes(ret)) ret = converter(v, opt);
-            } else if (isArrayObject(v)) {
-              // array in array
-              // workaround by using an object holding array value
-              const temp: record.Unknown = converter({ key: v }, opt);
-              ret = temp.key;
+              if (!isPreservedType(v)) return converter(v, childOpt);
+            } else if (Array.isArray(v)) {
+              const temp: record.Unknown = converter({ key: v }, childOpt);
+              return temp.key;
             }
-            return ret;
+            return v;
           });
+        }
+
       res[nkey] = value;
-    });
+    }
 
     return res as V;
   };
@@ -113,33 +269,22 @@ export const capitalize = (str: string): string => {
  * Example Date, RegExp. These types will be right-hand side of 'instanceof' operator.
  */
 export interface Options {
-  recursive: boolean;
+  recursive?: boolean;
   recursiveInArray?: boolean;
+  schema?: z.ZodType;
 }
 
-const keepTypesOnRecursion = [Number, String, Uint8Array];
-
-/**
- * Default options for convert function. This option is not recursive.
- */
 const defaultOptions: Options = {
   recursive: true,
   recursiveInArray: true,
+  schema: undefined,
 };
 
-const validateOptions = (opt: Options = defaultOptions): Options => {
-  if (opt.recursive == null) opt = defaultOptions;
-  else opt.recursiveInArray ??= false;
-  return opt;
-};
-
-const isArrayObject = (obj: unknown): boolean => obj != null && Array.isArray(obj);
-
 const isValidObject = (obj: unknown): boolean =>
   obj != null && typeof obj === "object" && !Array.isArray(obj);
 
-const belongToTypes = (obj: unknown): boolean =>
-  keepTypesOnRecursion.some((type) => obj instanceof type);
+const isPreservedType = (obj: unknown): boolean =>
+  obj instanceof Uint8Array || obj instanceof Number || obj instanceof String;
 
 /**
  * Converts a string to kebab-case.

package/src/color/color.spec.ts

@@ -24,7 +24,7 @@ describe("color.Color", () => {
       expect(color.rValue(c)).toEqual(122);
       expect(color.gValue(c)).toEqual(44);
       expect(color.bValue(c)).toEqual(38);
-      expect(color.aValue(c)).toEqual(0.5);
+      expect(color.aValue(c)).toBeCloseTo(0.5);
     });
 
     describe("from eight digit hex", () => {
@@ -33,14 +33,14 @@ describe("color.Color", () => {
         expect(color.rValue(c)).toEqual(122);
         expect(color.gValue(c)).toEqual(44);
         expect(color.bValue(c)).toEqual(38);
-        expect(color.aValue(c)).toEqual(1);
+        expect(color.aValue(c)).toBeCloseTo(1);
       });
       test("case 2", () => {
         const c = color.construct("#7a2c2605");
         expect(color.rValue(c)).toEqual(122);
         expect(color.gValue(c)).toEqual(44);
         expect(color.bValue(c)).toEqual(38);
-        expect(color.aValue(c)).toEqual(5 / 255);
+        expect(color.aValue(c)).toBeCloseTo(5 / 255);
       });
     });
 
@@ -55,7 +55,7 @@ describe("color.Color", () => {
       expect(color.rValue(c)).toEqual(122);
       expect(color.gValue(c)).toEqual(44);
       expect(color.bValue(c)).toEqual(38);
-      expect(color.aValue(c)).toEqual(0.5);
+      expect(color.aValue(c)).toBeCloseTo(0.5);
     });
     test("from c", () => {
       const c = color.construct(color.construct("#7a2c26"));
@@ -69,7 +69,7 @@ describe("color.Color", () => {
       expect(color.rValue(c)).toEqual(122);
       expect(color.gValue(c)).toEqual(44);
       expect(color.bValue(c)).toEqual(38);
-      expect(color.aValue(c)).toEqual(0.5);
+      expect(color.aValue(c)).toBeCloseTo(0.5);
     });
 
     test("from rgba struct", () => {
@@ -105,16 +105,20 @@ describe("color.Color", () => {
     });
   });
 
-  describe("to RGBA255", () => {
+  describe("to RGBA", () => {
     test("with alpha", () => {
       const c = color.construct("#7a2c26", 0.5);
-      const expected = [122, 44, 38, 0.5];
-      expect(color.construct(c)).toEqual(expected);
+      expect(c[0]).toEqual(122);
+      expect(c[1]).toEqual(44);
+      expect(c[2]).toEqual(38);
+      expect(c[3]).toBeCloseTo(0.5);
     });
     test("without alpha", () => {
       const c = color.construct("#7a2c26");
-      const expected = [122, 44, 38, 1];
-      expect(color.construct(c)).toEqual(expected);
+      expect(c[0]).toEqual(122);
+      expect(c[1]).toEqual(44);
+      expect(c[2]).toEqual(38);
+      expect(c[3]).toBeCloseTo(1);
     });
   });
 
@@ -319,7 +323,7 @@ describe("color.Color", () => {
       const semiTransparent: color.HSLA = [0, 100, 50, 0.5]; // Semi-transparent red
 
       expect(color.fromHSLA(transparent)[3]).toEqual(0);
-      expect(color.fromHSLA(semiTransparent)[3]).toEqual(0.5);
+      expect(color.fromHSLA(semiTransparent)[3]).toBeCloseTo(0.5);
     });
   });
 
@@ -362,8 +366,8 @@ describe("color.Color", () => {
         // we use toBeCloseTo for HSL values with precision 0
         for (let i = 0; i < 3; i++) expect(result[i]).toBeCloseTo(expected[i], 0);
 
-        // Alpha should match exactly
-        expect(result[3]).toEqual(expected[3]);
+        // Alpha should match
+        expect(result[3]).toBeCloseTo(expected[3]);
       });
     });
 
@@ -375,7 +379,7 @@ describe("color.Color", () => {
 
       for (let i = 0; i < 3; i++) expect(result[i]).toBeCloseTo(expected[i], 0);
 
-      expect(result[3]).toEqual(expected[3]);
+      expect(result[3]).toBeCloseTo(expected[3]);
     });
 
     test("handles RGB array input", () => {
@@ -386,7 +390,7 @@ describe("color.Color", () => {
 
       for (let i = 0; i < 3; i++) expect(result[i]).toBeCloseTo(expected[i], 0);
 
-      expect(result[3]).toEqual(1); // Default alpha
+      expect(result[3]).toBeCloseTo(1); // Default alpha
     });
 
     test("preserves original color after round-trip conversion", () => {
@@ -408,8 +412,8 @@ describe("color.Color", () => {
         // Compare RGB values with some tolerance for rounding
         for (let i = 0; i < 3; i++) expect(converted[i]).toBeCloseTo(original[i], 0);
 
-        // Alpha should match exactly
-        expect(converted[3]).toEqual(original[3]);
+        // Alpha should match
+        expect(converted[3]).toBeCloseTo(original[3]);
       }
     });
 
@@ -422,7 +426,7 @@ describe("color.Color", () => {
       expect(result[0]).toEqual(0); // Hue
       expect(result[1]).toEqual(0); // Saturation
       expect(result[2]).toBeCloseTo(39, 0); // Lightness ~39%
-      expect(result[3]).toEqual(1); // Alpha
+      expect(result[3]).toBeCloseTo(1); // Alpha
     });
   });
 
@@ -431,28 +435,40 @@ describe("color.Color", () => {
       const rgb: color.RGB = [255, 0, 0];
       const result = color.setAlpha(rgb, 0.5);
 
-      expect(result).toEqual([255, 0, 0, 0.5]);
+      expect(result[0]).toEqual(255);
+      expect(result[1]).toEqual(0);
+      expect(result[2]).toEqual(0);
+      expect(result[3]).toBeCloseTo(0.5);
     });
 
     test("sets alpha on RGBA color", () => {
       const rgba: color.RGBA = [0, 255, 0, 1];
       const result = color.setAlpha(rgba, 0.3);
 
-      expect(result).toEqual([0, 255, 0, 0.3]);
+      expect(result[0]).toEqual(0);
+      expect(result[1]).toEqual(255);
+      expect(result[2]).toEqual(0);
+      expect(result[3]).toBeCloseTo(0.3);
     });
 
     test("sets alpha on hex color", () => {
       const hex = "#0000ff";
       const result = color.setAlpha(hex, 0.7);
 
-      expect(result).toEqual([0, 0, 255, 0.7]);
+      expect(result[0]).toEqual(0);
+      expect(result[1]).toEqual(0);
+      expect(result[2]).toEqual(255);
+      expect(result[3]).toBeCloseTo(0.7);
     });
 
     test("overrides existing alpha in RGBA color", () => {
       const rgba: color.RGBA = [128, 128, 128, 0.2];
       const result = color.setAlpha(rgba, 0.8);
 
-      expect(result).toEqual([128, 128, 128, 0.8]);
+      expect(result[0]).toEqual(128);
+      expect(result[1]).toEqual(128);
+      expect(result[2]).toEqual(128);
+      expect(result[3]).toBeCloseTo(0.8);
     });
 
     test("handles alpha value of 0", () => {
@@ -466,19 +482,14 @@ describe("color.Color", () => {
       const color1 = color.construct("#ff0000", 0.5);
       const result = color.setAlpha(color1, 1);
 
-      expect(result[3]).toEqual(1);
+      expect(result[3]).toBeCloseTo(1);
     });
 
-    test("converts percentage (>1) alpha values to 0-1 range", () => {
+    test("accepts alpha values in 0-1 range", () => {
       const color1 = color.construct("#ff0000");
-      const result = color.setAlpha(color1, 50);
+      const result = color.setAlpha(color1, 0.5);
 
-      expect(result[3]).toEqual(0.5);
-    });
-
-    test("throws error for alpha values > 100", () => {
-      const color1 = color.construct("#ff0000");
-      expect(() => color.setAlpha(color1, 101)).toThrow();
+      expect(result[3]).toBeCloseTo(0.5);
     });
 
     test("preserves RGB values when setting alpha", () => {
@@ -518,7 +529,9 @@ describe("color.Color", () => {
 
     test("converts hex with alpha to CSS rgba string", () => {
       const hex = "#ff000080";
-      expect(color.rgbaCSS(hex)).toEqual("rgba(255, 0, 0, 0.5019607843137255)");
+      const result = color.rgbaCSS(hex);
+      // Alpha 0x80 = 128/255 ≈ 0.502
+      expect(result).toMatch(/rgba\(255, 0, 0, 0\.5\d*\)/);
     });
 
     test("handles Color object", () => {
@@ -604,7 +617,7 @@ describe("color.Color", () => {
 
     test("eight-digit hex and RGBA with same values are equal", () => {
       const c1 = "#ff000080";
-      const c2: color.RGBA = [255, 0, 0, 0.5019607843137255];
+      const c2: color.RGBA = [255, 0, 0, 128 / 255];
       expect(color.equals(c1, c2)).toBe(true);
     });
 
@@ -652,7 +665,9 @@ describe("color.Color", () => {
 
     test("handles eight-digit hex with alpha", () => {
       const hex = "#00ff0080";
-      expect(color.cssString(hex)).toEqual("rgba(0, 255, 0, 0.5019607843137255)");
+      const result = color.cssString(hex);
+      // Alpha 0x80 = 128/255 ≈ 0.502
+      expect(result).toMatch(/rgba\(0, 255, 0, 0\.5\d*\)/);
     });
 
     test("handles Color object", () => {
@@ -711,7 +726,7 @@ describe("color.Color", () => {
     });
 
     test("rejects invalid RGBA arrays", () => {
-      expect(color.isCrude([255, 0, 0, 1.1])).toBe(false);
+      expect(color.isCrude([255, 0, 0, 1.5])).toBe(false);
       expect(color.isCrude([255, 0, 0, -0.1])).toBe(false);
     });
 
@@ -754,7 +769,7 @@ describe("color.Color", () => {
       expect(color.isColor([255, 0, 0, 0, 0])).toBe(false); // Too many elements
       expect(color.isColor([255, 0, -1, 1])).toBe(false); // Negative value
       expect(color.isColor([255, 0, 256, 1])).toBe(false); // Value > 255
-      expect(color.isColor([255, 0, 0, 1.1])).toBe(false); // Alpha > 1
+      expect(color.isColor([255, 0, 0, 1.5])).toBe(false); // Alpha > 1
       expect(color.isColor([255, 0, 0, -0.1])).toBe(false); // Alpha < 0
     });
 

package/src/color/color.ts

@@ -9,25 +9,24 @@
 
 import { z } from "zod";
 
+import { zod } from "@/zod";
+
 /** A regex to match hex colors. */
 const hexRegex = /^#?([0-9a-f]{6}|[0-9a-f]{8})$/i;
 
 /** A zod schema for a hex color. */
 const hexZ = z.string().regex(hexRegex);
 /** A zod schema for an RGB value. */
-const rgbValueZ = z.number().min(0).max(255);
+const rgbValueZ = zod.uint8;
 /** A zod schema for an alpha value between 0 and 1. */
 const alphaZ = z.number().min(0).max(1);
 /** A zod schema for an RGBA color. */
 const rgbaZ = z.tuple([rgbValueZ, rgbValueZ, rgbValueZ, alphaZ]);
 /** A zod schema for an RGB color. */
 const rgbZ = z.tuple([rgbValueZ, rgbValueZ, rgbValueZ]);
-/** A zod schema for a legacy color object. */
 const legacyObjectZ = z.object({ rgba255: rgbaZ });
 /** A zod schema for an RGBA struct (r, g, b, a fields). */
 const rgbaStructZ = z.object({ r: rgbValueZ, g: rgbValueZ, b: rgbValueZ, a: alphaZ });
-/** An RGBA struct with named fields. */
-export type RGBAStruct = z.infer<typeof rgbaStructZ>;
 /** A zod schema for a hue value between 0 and 360. */
 const hueZ = z.number().min(0).max(360);
 /** A zod schema for a saturation value between 0 and 100. */
@@ -48,7 +47,8 @@ export type Hex = z.infer<typeof hexZ>;
 
 /** A legacy color object. Used for backwards compatibility. */
 type LegacyObject = z.infer<typeof legacyObjectZ>;
-
+/** A color in RGBA format as a struct. */
+type RGBAStruct = z.infer<typeof rgbaStructZ>;
 /** A zod schema for a crude color representation. */
 export const crudeZ = z.union([hexZ, rgbZ, rgbaZ, hslaZ, legacyObjectZ, rgbaStructZ]);
 /**
@@ -203,8 +203,7 @@ export const hsla = (color: Crude): HSLA => rgbaToHSLA(construct(color));
 /**
  * @returns A new color with the given alpha.
  * @param color - The color to set the alpha value on.
- * @param alpha - The alpha value to set. If the value is greater than 1, it will be
- * divided by 100.
+ * @param alpha - The alpha value to set (0-1).
  */
 export const setAlpha = (color: Crude, alpha: number): Color => {
   const [r, g, b] = construct(color);
@@ -353,7 +352,7 @@ export const fromCSS = (cssColor: string): Color | undefined => {
     );
     if (match) {
       const [, r, g, b, a] = match;
-      return [parseInt(r), parseInt(g), parseInt(b), a ? parseFloat(a) : 1];
+      return [parseInt(r, 10), parseInt(g, 10), parseInt(b, 10), a ? parseFloat(a) : 1];
     }
   }
   if (NAMED[trimmed]) return fromHex(NAMED[trimmed]);

package/src/control/control.ts

@@ -9,11 +9,9 @@
 
 import { z } from "zod";
 
+import { type Authority, type State, stateZ } from "@/control/types.gen";
 import { type bounds } from "@/spatial";
 
-export const authorityZ = z.int().min(0).max(255);
-export type Authority = z.infer<typeof authorityZ>;
-
 export const ABSOLUTE_AUTHORITY: Authority = 255;
 export const ZERO_AUTHORITY: Authority = 0;
 
@@ -22,31 +20,8 @@ export const AUTHORITY_BOUNDS: bounds.Bounds<Authority> = {
   upper: ABSOLUTE_AUTHORITY + 1,
 };
 
-export const subjectZ = z.object({
-  name: z.string(),
-  key: z.string(),
-});
-
-export interface Subject {
-  name: string;
-  key: string;
-}
-
-export const stateZ = <R extends z.ZodType>(resource: R) =>
-  z.object({
-    subject: subjectZ,
-    resource,
-    authority: authorityZ,
-  });
-
-export interface State<R> {
-  subject: Subject;
-  resource: R;
-  authority: Authority;
-}
-
 export const filterTransfersByChannelKey =
-  <R>(...resources: R[]) =>
+  <R extends z.ZodType>(...resources: z.infer<R>[]) =>
   (transfers: Transfer<R>[]): Transfer<R>[] =>
     transfers.filter((t) => {
       let ok = false;
@@ -55,7 +30,7 @@ export const filterTransfersByChannelKey =
       return ok;
     });
 
-interface Release<R> {
+interface Release<R extends z.ZodType> {
   from: State<R>;
   to?: null;
 }
@@ -63,21 +38,21 @@ interface Release<R> {
 export const releaseZ = <R extends z.ZodType>(resource: R) =>
   z.object({
     from: stateZ(resource),
-    to: z.null(),
+    to: z.null().optional(),
   });
 
-interface Acquire<R> {
+interface Acquire<R extends z.ZodType> {
   from?: null;
   to: State<R>;
 }
 
 export const acquireZ = <R extends z.ZodType>(resource: R) =>
   z.object({
-    from: z.null(),
+    from: z.null().optional(),
     to: stateZ(resource),
   });
 
-export type Transfer<R> =
+export type Transfer<R extends z.ZodType> =
   | {
       from: State<R>;
       to: State<R>;

package/src/{label/label.ts → control/external.ts}

@@ -7,16 +7,5 @@
 // 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 { color } from "@/color";
-
-export const keyZ = z.uuid();
-export type Key = z.infer<typeof keyZ>;
-
-export const labelZ = z.object({
-  key: keyZ,
-  name: z.string().min(1),
-  color: color.colorZ,
-});
-export interface Label extends z.infer<typeof labelZ> {}
+export * from "@/control/control";
+export * from "@/control/types.gen";

package/src/control/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 control from "@/control/control";
+export * as control from "@/control/external";