@synnaxlabs/client 0.56.1 → 0.57.0

package/src/label/client.ts

@@ -8,17 +8,19 @@
 // included in the file licenses/APL.txt.
 
 import { type UnaryClient } from "@synnaxlabs/freighter";
-import { array } from "@synnaxlabs/x";
+import { array, primitive, zod } from "@synnaxlabs/x";
 import z from "zod";
 
-import { type Key, keyZ, type Label, labelZ, type New, newZ } from "@/label/payload";
+import { LABELED_BY_ONTOLOGY_RELATIONSHIP_TYPE } from "@/label/payload";
+import { matchLabeledBy } from "@/label/store";
+import { type Key, keyZ, type Label, labelZ, type New } from "@/label/types.gen";
 import { ontology } from "@/ontology";
-import { checkForMultipleOrNoResults } from "@/util/retrieve";
+import { query } from "@/query";
 
 export const SET_CHANNEL_NAME = "sy_label_set";
 export const DELETE_CHANNEL_NAME = "sy_label_delete";
 
-const createReqZ = z.object({ labels: newZ.array() });
+const createReqZ = z.object({ labels: labelZ.array() });
 const createResZ = z.object({ labels: labelZ.array() });
 const deleteReqZ = z.object({ keys: keyZ.array() });
 const setReqZ = z.object({
@@ -28,6 +30,7 @@ const setReqZ = z.object({
 });
 
 interface SetReq extends z.infer<typeof setReqZ> {}
+/** Options for `Client.set`. Set `replace` to swap the whole label set at once. */
 export interface SetOptions extends Pick<SetReq, "replace"> {}
 
 const removeReqZ = setReqZ.omit({ replace: true });
@@ -40,77 +43,213 @@ const retrieveRequestZ = z.object({
   searchTerm: z.string().optional(),
   offset: z.int().optional(),
   limit: z.int().optional(),
+  ignoreNotFoundError: z.boolean().optional(),
 });
+const retrieveMultiParamsZ = retrieveRequestZ.or(query.keyListZ(keyZ));
 
-const singleRetrieveArgsZ = z
-  .object({ key: keyZ })
-  .transform(({ key }) => ({ keys: [key] }));
-
-const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveRequestZ]);
-
-export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
-export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
+/** Names one label. */
+export type RetrieveSingleParams = { key: Key };
+/** Everything a multi-label retrieval can filter on, including the resource labeled. */
 export type RetrieveMultipleParams = z.input<typeof retrieveRequestZ>;
+/** Params for a label retrieval, single or multiple. */
+export type RetrieveParams = RetrieveSingleParams | RetrieveMultipleParams;
 
-const retrieveResponseZ = z.object({ labels: array.nullishToEmpty(labelZ) });
+interface RetrieveRequest extends z.infer<typeof retrieveRequestZ> {}
 
-export class Client {
+/** Config for {@link Client}. */
+export interface ClientConfig {
+  unary: UnaryClient;
+  cache: query.Cache;
+  ontology: ontology.Client;
+}
+
+/**
+ * Creates, reads, deletes, and attaches labels on a Core. Reach it through
+ * `client.labels`.
+ */
+export class Client extends query.Retriever<typeof retrieveMultiParamsZ, Key, Label> {
   readonly type: string = "label";
-  private readonly client: UnaryClient;
+  /** The label record table; injected into sibling clients at wiring. */
+  readonly store: query.Table<Key, Label>;
+  private readonly cfg: ClientConfig;
+
+  constructor(cfg: ClientConfig) {
+    const { cache, ontology: ontologyClient } = cfg;
+    const { relationships } = ontologyClient.cache;
+    const store = cache.createTable<Key, Label>({
+      name: "labels",
+      fetch: async (keys) =>
+        await this.execRetrieve({ keys, ignoreNotFoundError: true }),
+      listen: [
+        query.createSetListener(SET_CHANNEL_NAME, labelZ),
+        query.createDeleteListener(DELETE_CHANNEL_NAME, keyZ),
+      ],
+    });
+    super(cache, {
+      name: "label",
+      table: store,
+      request: {
+        schema: retrieveMultiParamsZ,
+        fetch: async (req) => await this.execRetrieve(req),
+        matches: (label, req) => this.requestFilter(req)(label),
+        watch: [
+          query.watch(relationships, (event, req: RetrieveRequest) => {
+            if (req.for == null) return null;
+            const rel =
+              event.variant === "set"
+                ? event.value
+                : ontology.relationshipZ.parse(event.key);
+            if (!matchLabeledBy(rel, req.for)) return null;
+            return [rel.to.key];
+          }),
+        ],
+      },
+    });
+    this.cfg = cfg;
+    this.store = store;
+  }
 
-  constructor(client: UnaryClient) {
-    this.client = client;
+  async label(
+    id: ontology.ID,
+    labels: Key[],
+    opts: SetOptions & query.WriteOptions = {},
+  ): Promise<void> {
+    await query.optimistic({
+      rollbacks: [
+        ...(opts.replace === true
+          ? [this.cfg.ontology.cache.relationships.delete((r) => matchLabeledBy(r, id))]
+          : []),
+        ...labels.map((key) => {
+          const rel = labeledByRel(id, key);
+          return this.cfg.ontology.cache.relationships.set(
+            ontology.relationshipToString(rel),
+            rel,
+          );
+        }),
+      ],
+      onOptimistic: opts.onOptimistic,
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/label/set",
+          { id, labels, replace: opts.replace },
+          setReqZ,
+          emptyResZ,
+        ),
+    });
   }
 
-  async retrieve(args: RetrieveSingleParams): Promise<Label>;
-  async retrieve(args: RetrieveMultipleParams): Promise<Label[]>;
-  async retrieve(args: RetrieveArgs): Promise<Label | Label[]> {
-    const isSingle = "key" in args;
-    const res = await this.client.send(
-      "/label/retrieve",
-      args,
-      retrieveArgsZ,
-      retrieveResponseZ,
-    );
-    checkForMultipleOrNoResults("Label", args, res.labels, isSingle);
-    return isSingle ? res.labels[0] : res.labels;
+  async remove(
+    id: ontology.ID,
+    labels: Key[],
+    opts: query.WriteOptions = {},
+  ): Promise<void> {
+    await query.optimistic({
+      rollbacks: [
+        this.cfg.ontology.cache.relationships.delete(
+          (r) => matchLabeledBy(r, id) && labels.includes(r.to.key),
+        ),
+      ],
+      onOptimistic: opts.onOptimistic,
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/label/remove",
+          { id, labels },
+          removeReqZ,
+          emptyResZ,
+        ),
+    });
   }
 
-  async label(id: ontology.ID, labels: Key[], opts: SetOptions = {}): Promise<void> {
-    await this.client.send(
-      "/label/set",
-      { id, labels, replace: opts.replace },
-      setReqZ,
-      emptyResZ,
-    );
+  async create(label: New, opts?: query.WriteOptions<Label[]>): Promise<Label>;
+  async create(labels: New[], opts?: query.WriteOptions<Label[]>): Promise<Label[]>;
+  async create(
+    labels: New | New[],
+    opts: query.WriteOptions<Label[]> = {},
+  ): Promise<Label | Label[]> {
+    const isMany = Array.isArray(labels);
+    const optimistic = array
+      .toArray(labels)
+      .map((l) => zod.parse(labelZ, l, { label: "label" }));
+    const res = await query.optimistic({
+      rollbacks: [this.store.set(optimistic)],
+      onOptimistic: () => opts.onOptimistic?.(optimistic),
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/label/create",
+          { labels: optimistic },
+          createReqZ,
+          createResZ,
+        ),
+    });
+    this.store.set(res.labels);
+    return isMany ? res.labels : res.labels[0];
   }
 
-  async remove(id: ontology.ID, labels: Key[]): Promise<void> {
-    await this.client.send("/label/remove", { id, labels }, removeReqZ, emptyResZ);
+  async delete(keys: Key | Key[], opts: query.WriteOptions = {}): Promise<void> {
+    const keysArr = array.toArray(keys);
+    const drop = () => [
+      this.store.delete(keysArr),
+      this.cfg.ontology.cache.relationships.delete(
+        (r) =>
+          r.type === LABELED_BY_ONTOLOGY_RELATIONSHIP_TYPE &&
+          r.to.type === "label" &&
+          keysArr.includes(r.to.key),
+      ),
+    ];
+    await query.optimistic({
+      rollbacks: drop(),
+      onOptimistic: opts.onOptimistic,
+      commit: async () =>
+        await this.cfg.unary.send(
+          "/label/delete",
+          { keys: keysArr },
+          deleteReqZ,
+          emptyResZ,
+        ),
+    });
+    drop();
   }
 
-  async create(label: New): Promise<Label>;
-  async create(labels: New[]): Promise<Label[]>;
-  async create(labels: New | New[]): Promise<Label | Label[]> {
-    const isMany = Array.isArray(labels);
-    const res = await this.client.send(
-      "/label/create",
-      { labels: array.toArray(labels) },
-      createReqZ,
-      createResZ,
+  private async execRetrieve(params: RetrieveMultipleParams): Promise<Label[]> {
+    const res = await this.cfg.unary.send(
+      "/label/retrieve",
+      params,
+      retrieveRequestZ,
+      retrieveResponseZ,
     );
-    return isMany ? res.labels : res.labels[0];
+    return res.labels;
   }
 
-  async delete(keys: Key | Key[]): Promise<void> {
-    await this.client.send(
-      "/label/delete",
-      { keys: array.toArray(keys) },
-      deleteReqZ,
-      emptyResZ,
+  /**
+   * Client-side matching for a request: key sets, names, and labeled-entity
+   * membership via the relationship table. Server-computed shapes (search,
+   * limit/offset) never reach this filter; they refetch instead.
+   */
+  private requestFilter(req: RetrieveRequest): (l: Label) => boolean {
+    const keySet = primitive.isNonZero(req.keys) ? new Set(req.keys) : undefined;
+    const nameSet = primitive.isNonZero(req.names) ? new Set(req.names) : undefined;
+    return (l) => {
+      if (keySet != null && !keySet.has(l.key)) return false;
+      if (nameSet != null && !nameSet.has(l.name)) return false;
+      if (req.for != null && !this.isLabelOf(req.for, l.key)) return false;
+      return true;
+    };
+  }
+
+  private isLabelOf(id: ontology.ID, key: Key): boolean {
+    return this.cfg.ontology.cache.relationships.has(
+      ontology.relationshipToString(labeledByRel(id, key)),
     );
   }
 }
 
+const retrieveResponseZ = z.object({ labels: labelZ.array().default(() => []) });
+
+const labeledByRel = (id: ontology.ID, key: Key): ontology.Relationship => ({
+  from: id,
+  type: LABELED_BY_ONTOLOGY_RELATIONSHIP_TYPE,
+  to: ontologyID(key),
+});
+
 export const ontologyID = ontology.createIDFactory<Key>("label");
 export const TYPE_ONTOLOGY_ID = ontologyID("");

package/src/label/external.ts

@@ -9,3 +9,5 @@
 
 export * from "@/label/client";
 export * from "@/label/payload";
+export { cachedLabelsOf, matchLabeledBy } from "@/label/store";
+export * from "@/label/types.gen";

package/src/label/payload.ts

@@ -7,15 +7,10 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { label } from "@synnaxlabs/x";
+import { type Key } from "@/label/types.gen";
 
-export type Params = label.Key | label.Key[];
-
-export const keyZ = label.keyZ;
-export type Key = label.Key;
-export const labelZ = label.labelZ;
-export interface Label extends label.Label {}
-export const newZ = label.newZ;
-export interface New extends label.New {}
+/** One or many labels, by key. */
+export type Params = Key | Key[];
 
+/** Relationship type joining a resource to the labels on it. */
 export const LABELED_BY_ONTOLOGY_RELATIONSHIP_TYPE = "labeled_by";

package/src/label/store.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.
+
+import { LABELED_BY_ONTOLOGY_RELATIONSHIP_TYPE } from "@/label/payload";
+import { type Key, type Label } from "@/label/types.gen";
+import { ontology } from "@/ontology";
+import { type query } from "@/query";
+
+/** Reports whether the relationship labels the given ontology ID. */
+export const matchLabeledBy = (rel: ontology.Relationship, id: ontology.ID): boolean =>
+  ontology.matchRelationship(rel, {
+    from: id,
+    type: LABELED_BY_ONTOLOGY_RELATIONSHIP_TYPE,
+  });
+
+/** Returns the cached labels attached to the given ontology ID. */
+export const cachedLabelsOf = (
+  relationships: query.Table<string, ontology.Relationship>,
+  labels: query.Table<Key, Label>,
+  id: ontology.ID,
+): Label[] =>
+  labels.get(relationships.get((r) => matchLabeledBy(r, id)).map((r) => r.to.key));

package/src/label/types.gen.ts

@@ -0,0 +1,31 @@
+// 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 { color, uuid } from "@synnaxlabs/x";
+import { z } from "zod";
+
+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.default(uuid.create),
+  /** 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 interface New extends z.input<typeof labelZ> {}

package/src/labjack/external.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 * from "@/labjack/types.gen";

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

package/src/labjack/types.gen.ts

@@ -0,0 +1,251 @@
+// 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 { id } from "@synnaxlabs/x";
+import { z } from "zod";
+
+import { channel } from "@/channel";
+import { device } from "@/device";
+import { task } from "@/task";
+
+export const TEMPERATURE_UNITS = ["C", "F", "K"] as const;
+export const temperatureUnitsZ = z.enum(TEMPERATURE_UNITS);
+export type TemperatureUnits = z.infer<typeof temperatureUnitsZ>;
+
+export const THERMOCOUPLE_TYPES = [
+  "J",
+  "K",
+  "N",
+  "R",
+  "S",
+  "T",
+  "B",
+  "E",
+  "C",
+] as const;
+export const thermocoupleTypeZ = z.enum(THERMOCOUPLE_TYPES);
+export type ThermocoupleType = z.infer<typeof thermocoupleTypeZ>;
+
+/** BaseReadChannel carries the fields every LabJack read channel shares. */
+export const baseReadChannelZ = z.object({
+  /** key uniquely identifies the channel within the task. */
+  key: z.string().default(id.create),
+  /** name is the human-readable channel name. */
+  name: z.string().default(""),
+  /** disabled is true when the channel is excluded from acquisition. */
+  disabled: z.boolean().default(false),
+  /** channel is the Synnax channel that raw samples are written to. */
+  channel: channel.keyZ.default(0),
+  /** port is the physical port the channel reads from (e.g. 'AIN0', 'DIO4'). */
+  port: z.string().default(""),
+});
+export interface BaseReadChannel extends z.infer<typeof baseReadChannelZ> {}
+
+/** BaseWriteChannel carries the fields every LabJack write channel shares. */
+export const baseWriteChannelZ = z.object({
+  /** key uniquely identifies the channel within the task. */
+  key: z.string().default(id.create),
+  /** disabled is true when the channel is excluded from the task. */
+  disabled: z.boolean().default(false),
+  /** cmdChannel is the Synnax channel commands are read from. */
+  cmdChannel: channel.keyZ.default(0),
+  /** stateChannel is the Synnax channel the output state is written to. */
+  stateChannel: channel.keyZ.default(0),
+  /** cmdChannelName is the human-readable name of the command channel. */
+  cmdChannelName: z.string().default(""),
+  /** stateChannelName is the human-readable name of the state channel. */
+  stateChannelName: z.string().default(""),
+  /** port is the physical port the channel writes to (e.g. 'DAC0', 'DIO4'). */
+  port: z.string().default(""),
+});
+export interface BaseWriteChannel extends z.infer<typeof baseWriteChannelZ> {}
+
+export const scanConfigZ = task.scanConfigZ.extend({
+  tcpScanMultiplier: z.int32().default(10),
+});
+export interface ScanConfig extends z.infer<typeof scanConfigZ> {}
+
+/** LinearScale maps raw values to engineering units with a slope and offset. */
+export const linearScaleZ = z.object({
+  type: z.literal("linear"),
+  /** slope is the multiplier applied to the raw value. */
+  slope: z.number().default(1),
+  /** offset is the offset added after scaling. */
+  offset: z.number().default(0),
+});
+export interface LinearScale extends z.infer<typeof linearScaleZ> {}
+
+/** MapScale maps a raw range linearly onto a scaled range. */
+export const mapScaleZ = z.object({
+  type: z.literal("map"),
+  /** preScaledMin is the lower bound of the raw input range. */
+  preScaledMin: z.number().default(0),
+  /** preScaledMax is the upper bound of the raw input range. */
+  preScaledMax: z.number().default(1),
+  /** scaledMin is the lower bound of the scaled output range. */
+  scaledMin: z.number().default(0),
+  /** scaledMax is the upper bound of the scaled output range. */
+  scaledMax: z.number().default(1),
+});
+export interface MapScale extends z.infer<typeof mapScaleZ> {}
+
+/** NoneScale applies no scaling; the raw value is used directly. */
+export const noneScaleZ = z.object({
+  type: z.literal("none"),
+});
+export interface NoneScale extends z.infer<typeof noneScaleZ> {}
+
+export const SCALE_TYPES = ["linear", "map", "none"] as const;
+export const scaleTypeZ = z.enum(SCALE_TYPES);
+export type ScaleType = z.infer<typeof scaleTypeZ>;
+
+/** Scale determines how raw sensor values are transformed to engineering units. */
+export const scaleZ = z.discriminatedUnion("type", [
+  linearScaleZ,
+  mapScaleZ,
+  noneScaleZ,
+]);
+export type Scale = LinearScale | MapScale | NoneScale;
+
+export const SCALE_SCHEMAS: {
+  [K in ScaleType]: z.ZodType<Extract<Scale, { type: K }>>;
+} = {
+  linear: linearScaleZ,
+  map: mapScaleZ,
+  none: noneScaleZ,
+};
+
+/** AnalogWriteChannel drives an analog output on a DAC port. */
+export const analogWriteChannelZ = baseWriteChannelZ.extend({
+  type: z.literal("analog"),
+  port: z.string().default("DAC0"),
+});
+export interface AnalogWriteChannel extends z.infer<typeof analogWriteChannelZ> {}
+
+/** DigitalWriteChannel drives a digital output line on a DIO port. */
+export const digitalWriteChannelZ = baseWriteChannelZ.extend({
+  type: z.literal("digital"),
+  port: z.string().default("DIO4"),
+});
+export interface DigitalWriteChannel extends z.infer<typeof digitalWriteChannelZ> {}
+
+export const WRITE_CHANNEL_TYPES = ["analog", "digital"] as const;
+export const writeChannelTypeZ = z.enum(WRITE_CHANNEL_TYPES);
+export type WriteChannelType = z.infer<typeof writeChannelTypeZ>;
+
+/**
+ * WriteChannel is a single LabJack write channel. The type field selects the output
+ * mode.
+ */
+export const writeChannelZ = z.discriminatedUnion("type", [
+  analogWriteChannelZ,
+  digitalWriteChannelZ,
+]);
+export type WriteChannel = AnalogWriteChannel | DigitalWriteChannel;
+
+export const WRITE_CHANNEL_SCHEMAS: {
+  [K in WriteChannelType]: z.ZodType<Extract<WriteChannel, { type: K }>>;
+} = {
+  analog: analogWriteChannelZ,
+  digital: digitalWriteChannelZ,
+};
+
+/** AnalogReadChannel reads a voltage from an analog input port. */
+export const analogReadChannelZ = baseReadChannelZ.extend({
+  type: z.literal("analog"),
+  port: z.string().default("AIN0"),
+  /** range is the upper bound of the voltage input range, in Volts. */
+  range: z.number().default(10),
+  /**
+   * negChan is the negative channel for differential readings on T7 devices. 199
+   * selects single-ended.
+   */
+  negChan: z.int32().default(199),
+  /** scale is the scale applied to raw samples after acquisition. */
+  scale: scaleZ.prefault({ type: "none" }),
+});
+export interface AnalogReadChannel extends z.infer<typeof analogReadChannelZ> {}
+
+/** DigitalReadChannel reads a digital input line. */
+export const digitalReadChannelZ = baseReadChannelZ.extend({
+  type: z.literal("digital"),
+  port: z.string().default("DIO4"),
+});
+export interface DigitalReadChannel extends z.infer<typeof digitalReadChannelZ> {}
+
+/** ThermocoupleReadChannel reads temperature from a thermocouple. */
+export const thermocoupleReadChannelZ = baseReadChannelZ.extend({
+  type: z.literal("thermocouple"),
+  /** port is the AIN port the thermocouple's positive lead is wired to. */
+  port: z.string().default("AIN0"),
+  /** thermocoupleType selects the thermocouple alloy type. */
+  thermocoupleType: thermocoupleTypeZ.default("K"),
+  /**
+   * negChan is the AIN port of the thermocouple's negative lead on T7 devices. 199
+   * selects single-ended.
+   */
+  negChan: z.int32().default(199),
+  /**
+   * cjcSource selects the cold-junction-compensation source: the device sensor
+   * ('TEMPERATURE_DEVICE_K'), ambient air ('TEMPERATURE_AIR_K'), or an AIN port (e.g.
+   * 'AIN2').
+   */
+  cjcSource: z.string().default("TEMPERATURE_DEVICE_K"),
+  /** cjcSlope is the CJC voltage-to-temperature slope, in Kelvin per Volt. */
+  cjcSlope: z.number().default(1),
+  /** cjcOffset is the CJC temperature offset, in Kelvins. */
+  cjcOffset: z.number().default(0),
+  /** units are the units of the temperature measurement. */
+  units: temperatureUnitsZ.default("K"),
+  /** scale is the scale applied to raw samples after acquisition. */
+  scale: scaleZ.prefault({ type: "none" }),
+});
+export interface ThermocoupleReadChannel extends z.infer<
+  typeof thermocoupleReadChannelZ
+> {}
+
+export const READ_CHANNEL_TYPES = ["analog", "digital", "thermocouple"] as const;
+export const readChannelTypeZ = z.enum(READ_CHANNEL_TYPES);
+export type ReadChannelType = z.infer<typeof readChannelTypeZ>;
+
+/**
+ * ReadChannel is a single LabJack read channel. The type field selects the input mode
+ * and the fields that accompany it.
+ */
+export const readChannelZ = z.discriminatedUnion("type", [
+  analogReadChannelZ,
+  digitalReadChannelZ,
+  thermocoupleReadChannelZ,
+]);
+export type ReadChannel =
+  AnalogReadChannel | DigitalReadChannel | ThermocoupleReadChannel;
+
+export const READ_CHANNEL_SCHEMAS: {
+  [K in ReadChannelType]: z.ZodType<Extract<ReadChannel, { type: K }>>;
+} = {
+  analog: analogReadChannelZ,
+  digital: digitalReadChannelZ,
+  thermocouple: thermocoupleReadChannelZ,
+};
+
+export const writeConfigZ = task.writeConfigZ.extend({
+  stateRate: z.number().default(10),
+  channels: writeChannelZ.array().default(() => []),
+});
+export interface WriteConfig extends z.infer<typeof writeConfigZ> {}
+
+export const readConfigZ = task.readConfigZ.extend({
+  device: device.keyZ.default(""),
+  channels: readChannelZ.array().default(() => []),
+  deviceScanBacklogWarnOnCount: z.uint32().default(0),
+  ljmScanBacklogWarnOnCount: z.uint32().default(0),
+});
+export interface ReadConfig extends z.infer<typeof readConfigZ> {}