@synnaxlabs/client 0.45.0 → 0.46.0

package/src/client.ts

@@ -13,6 +13,7 @@ import { URL } from "@synnaxlabs/x/url";
 import { z } from "zod";
 
 import { access } from "@/access";
+import { arc } from "@/arc";
 import { auth } from "@/auth";
 import { channel } from "@/channel";
 import { connection } from "@/connection";
@@ -26,6 +27,7 @@ import { task } from "@/hardware/task";
 import { label } from "@/label";
 import { ontology } from "@/ontology";
 import { ranger } from "@/ranger";
+import { status } from "@/status";
 import { Transport } from "@/transport";
 import { user } from "@/user";
 import { workspace } from "@/workspace";
@@ -60,14 +62,16 @@ export default class Synnax extends framer.Client {
   readonly ranges: ranger.Client;
   readonly channels: channel.Client;
   readonly auth: auth.Client | undefined;
-  readonly user: user.Client;
+  readonly users: user.Client;
   readonly access: access.Client;
   readonly connectivity: connection.Checker;
   readonly ontology: ontology.Client;
   readonly workspaces: workspace.Client;
   readonly labels: label.Client;
+  readonly statuses: status.Client;
   readonly hardware: hardware.Client;
   readonly control: control.Client;
+  readonly arcs: arc.Client;
   static readonly connectivity = connection.Checker;
   private readonly transport: Transport;
 
@@ -133,6 +137,7 @@ export default class Synnax extends framer.Client {
     this.ontology = new ontology.Client(transport.unary, this);
     const rangeWriter = new ranger.Writer(this.transport.unary);
     this.labels = new label.Client(this.transport.unary);
+    this.statuses = new status.Client(this.transport.unary);
     this.ranges = new ranger.Client(
       this,
       rangeWriter,
@@ -142,7 +147,7 @@ export default class Synnax extends framer.Client {
       this.ontology,
     );
     this.access = new access.Client(this.transport.unary);
-    this.user = new user.Client(this.transport.unary);
+    this.users = new user.Client(this.transport.unary);
     this.workspaces = new workspace.Client(this.transport.unary);
     const devices = new device.Client(this.transport.unary);
     const tasks = new task.Client(
@@ -153,6 +158,7 @@ export default class Synnax extends framer.Client {
     );
     const racks = new rack.Client(this.transport.unary, tasks);
     this.hardware = new hardware.Client(tasks, racks, devices);
+    this.arcs = new arc.Client(this.transport.unary);
   }
 
   get key(): string {

package/src/errors.spec.ts

@@ -64,7 +64,7 @@ test("client", async () => {
     expect(NotFoundError.matches(e)).toBe(true);
   }
   try {
-    await client.workspaces.schematic.retrieve(uuid.create());
+    await client.workspaces.schematics.retrieve({ key: uuid.create() });
   } catch (e) {
     expect(NotFoundError.matches(e)).toBe(true);
   }

package/src/framer/client.ts

@@ -199,16 +199,17 @@ export class Client {
     return frame;
   }
 
-  async delete(channels: channel.Params, timeRange: TimeRange): Promise<void> {
+  async delete(channels: channel.Params, timeRange: CrudeTimeRange): Promise<void> {
     const { normalized, variant } = channel.analyzeParams(channels);
+    const bounds = new TimeRange(timeRange);
     if (variant === "keys")
       return await this.deleter.delete({
         keys: normalized as channel.Key[],
-        bounds: timeRange,
+        bounds,
       });
     return await this.deleter.delete({
       names: normalized as string[],
-      bounds: timeRange,
+      bounds,
     });
   }
 }

package/src/framer/codec.spec.ts

@@ -206,7 +206,7 @@ describe("encoder", () => {
           const ser = spec.frame.get(k);
           expect(ser.series.length).toBeGreaterThan(0);
           const os = ser.series[0];
-          if (dcs.timeRange != null && !dcs.timeRange.isZero)
+          if (dcs.timeRange != null && !dcs.timeRange.span.isZero)
             expect(dcs.timeRange.toString()).toEqual(os.timeRange?.toString());
           expect(new Series(dcs).toString()).toEqual(os.toString());
         });

package/src/hardware/device/client.ts

@@ -22,7 +22,6 @@ import {
 import { keyZ as rackKeyZ } from "@/hardware/rack/payload";
 import { type ontology } from "@/ontology";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
-import { nullableArrayZ } from "@/util/zod";
 
 export const SET_CHANNEL_NAME = "sy_device_set";
 export const DELETE_CHANNEL_NAME = "sy_device_delete";
@@ -50,7 +49,7 @@ const retrieveRequestZ = z.object({
   offset: z.number().optional(),
   includeStatus: z.boolean().optional(),
 });
-const retrieveResZ = z.object({ devices: nullableArrayZ(deviceZ) });
+const retrieveResZ = z.object({ devices: array.nullableZ(deviceZ) });
 
 const singleRetrieveArgsZ = z
   .object({
@@ -62,15 +61,14 @@ const singleRetrieveArgsZ = z
     includeStatus,
   }));
 
-export type SingleRetrieveArgs = z.input<typeof singleRetrieveArgsZ>;
-export type MultiRetrieveArgs = z.input<typeof retrieveRequestZ>;
+export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
+export type RetrieveMultipleParams = z.input<typeof retrieveRequestZ>;
 
 const retrieveArgsZ = z.union([singleRetrieveArgsZ, retrieveRequestZ]);
 
 export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
 
 export class Client {
-  readonly type = "device";
   private readonly client: UnaryClient;
 
   constructor(client: UnaryClient) {
@@ -81,13 +79,13 @@ export class Client {
     Properties extends record.Unknown = record.Unknown,
     Make extends string = string,
     Model extends string = string,
-  >(args: SingleRetrieveArgs): Promise<Device<Properties, Make, Model>>;
+  >(args: RetrieveSingleParams): Promise<Device<Properties, Make, Model>>;
 
   async retrieve<
     Properties extends record.Unknown = record.Unknown,
     Make extends string = string,
     Model extends string = string,
-  >(args: MultiRetrieveArgs): Promise<Array<Device<Properties, Make, Model>>>;
+  >(args: RetrieveMultipleParams): Promise<Array<Device<Properties, Make, Model>>>;
 
   async retrieve<
     Properties extends record.Unknown = record.Unknown,
@@ -138,7 +136,7 @@ export class Client {
     return isSingle ? created[0] : created;
   }
 
-  async delete(keys: string | string[]): Promise<void> {
+  async delete(keys: Key | Key[]): Promise<void> {
     await sendRequired(
       this.client,
       DELETE_ENDPOINT,

package/src/hardware/device/payload.ts

@@ -16,17 +16,18 @@ import { decodeJSONString } from "@/util/decodeJSONString";
 export const keyZ = z.string();
 export type Key = z.infer<typeof keyZ>;
 
-export const statusZ = status.statusZ(z.object({ rack: rackKeyZ, device: keyZ }));
+export const statusDetailsSchema = z.object({ rack: rackKeyZ, device: keyZ });
+export const statusZ = status.statusZ(statusDetailsSchema);
 
 export interface Status extends z.infer<typeof statusZ> {}
 
 export const deviceZ = z.object({
   key: keyZ,
-  rack: rackKeyZ,
-  name: z.string(),
-  make: z.string(),
-  model: z.string(),
-  location: z.string(),
+  rack: rackKeyZ.min(1, "Must select a location to connect from"),
+  name: z.string().min(1, "Name is required"),
+  make: z.string().min(1, "Make is required"),
+  model: z.string().min(1, "Model is required"),
+  location: z.string().min(1, "Location is required"),
   configured: z.boolean().optional(),
   properties: record.unknownZ.or(z.string().transform(decodeJSONString)),
   status: zod.nullToUndefined(statusZ),

package/src/hardware/rack/client.ts

@@ -8,7 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { array } from "@synnaxlabs/x/array";
+import { array } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import {
@@ -23,7 +23,6 @@ import {
 import { type task } from "@/hardware/task";
 import { type ontology } from "@/ontology";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
-import { nullableArrayZ } from "@/util/zod";
 
 const RETRIEVE_ENDPOINT = "/hardware/rack/retrieve";
 const CREATE_ENDPOINT = "/hardware/rack/create";
@@ -43,7 +42,7 @@ const retrieveReqZ = z.object({
   offset: z.number().optional(),
   includeStatus: z.boolean().optional(),
 });
-const retrieveResZ = z.object({ racks: nullableArrayZ(rackZ) });
+const retrieveResZ = z.object({ racks: array.nullableZ(rackZ) });
 
 const singleRetrieveArgsZ = z.union([
   z
@@ -59,11 +58,11 @@ const singleRetrieveArgsZ = z.union([
     })
     .transform(({ name, includeStatus }) => ({ names: [name], includeStatus })),
 ]);
-export type SingleRetrieveArgs = z.input<typeof singleRetrieveArgsZ>;
+export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
 
 const multiRetrieveArgsZ = retrieveReqZ;
 
-export type MultiRetrieveArgs = z.input<typeof multiRetrieveArgsZ>;
+export type RetrieveMultipleParams = z.input<typeof multiRetrieveArgsZ>;
 
 const retrieveArgsZ = z.union([singleRetrieveArgsZ, multiRetrieveArgsZ]);
 
@@ -76,7 +75,6 @@ const deleteReqZ = z.object({ keys: keyZ.array() });
 const deleteResZ = z.object({});
 
 export class Client {
-  readonly type = "rack";
   private readonly client: UnaryClient;
   private readonly tasks: task.Client;
 
@@ -110,8 +108,8 @@ export class Client {
     return isSingle ? sugared[0] : sugared;
   }
 
-  async retrieve(args: SingleRetrieveArgs): Promise<Rack>;
-  async retrieve(args: MultiRetrieveArgs): Promise<Rack[]>;
+  async retrieve(args: RetrieveSingleParams): Promise<Rack>;
+  async retrieve(args: RetrieveMultipleParams): Promise<Rack[]>;
   async retrieve(args: RetrieveArgs): Promise<Rack | Rack[]> {
     const isSingle = "key" in args || "name" in args;
     const res = await sendRequired(

package/src/hardware/rack/payload.ts

@@ -13,7 +13,8 @@ import { z } from "zod";
 export const keyZ = z.uint32();
 export type Key = z.infer<typeof keyZ>;
 
-export const statusZ = status.statusZ(z.object({ rack: keyZ }));
+export const statusDetailsSchema = z.object({ rack: keyZ });
+export const statusZ = status.statusZ(statusDetailsSchema);
 
 export interface Status extends z.infer<typeof statusZ> {}
 

package/src/hardware/task/client.ts

@@ -8,8 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { caseconv, id, strings } from "@synnaxlabs/x";
-import { array } from "@synnaxlabs/x/array";
+import { array, caseconv, id, type record, strings } from "@synnaxlabs/x";
 import { type CrudeTimeSpan, TimeSpan } from "@synnaxlabs/x/telem";
 import { z } from "zod";
 
@@ -29,7 +28,6 @@ import {
 import { type ontology } from "@/ontology";
 import { type ranger } from "@/ranger";
 import { checkForMultipleOrNoResults } from "@/util/retrieve";
-import { nullableArrayZ } from "@/util/zod";
 
 export const STATUS_CHANNEL_NAME = "sy_task_status";
 export const COMMAND_CHANNEL_NAME = "sy_task_cmd";
@@ -44,6 +42,29 @@ const retrieveSnapshottedTo = async (taskKey: Key, ontologyClient: ontology.Clie
   return parents[0];
 };
 
+export interface TaskExecuteCommandParams {
+  type: string;
+  args?: record.Unknown;
+}
+
+export interface ExecuteCommandParams extends TaskExecuteCommandParams {
+  task: Key;
+}
+
+export interface ExecuteCommandsParams {
+  commands: NewCommand[];
+}
+
+export interface TaskExecuteCommandSyncParams extends TaskExecuteCommandParams {
+  timeout?: CrudeTimeSpan;
+}
+
+export interface ExecuteCommandsSyncParams<StatusData extends z.ZodType>
+  extends Omit<ExecuteCommandsSyncInternalParams<StatusData>, "frameClient" | "name"> {}
+
+export interface ExecuteCommandSyncParams<StatusData extends z.ZodType>
+  extends Omit<ExecuteCommandSyncInternalParams<StatusData>, "frameClient" | "name"> {}
+
 export class Task<
   Type extends z.ZodLiteral<string> = z.ZodLiteral<string>,
   Config extends z.ZodType = z.ZodType,
@@ -124,24 +145,24 @@ export class Task<
     return ontologyID(this.key);
   }
 
-  async executeCommand(type: string, args?: {}): Promise<string> {
-    return await executeCommand(this.frameClient, this.key, type, args);
+  async executeCommand(params: TaskExecuteCommandParams): Promise<string> {
+    return await executeCommand({
+      ...params,
+      frameClient: this.frameClient,
+      task: this.key,
+    });
   }
 
   async executeCommandSync(
-    type: string,
-    timeout: CrudeTimeSpan,
-    args?: {},
+    params: TaskExecuteCommandSyncParams,
   ): Promise<Status<StatusData>> {
-    return await executeCommandSync<StatusData>(
-      this.frameClient,
-      this.key,
-      type,
-      timeout,
-      this.name,
-      this.schemas?.statusDataSchema,
-      args,
-    );
+    return await executeCommandSync<StatusData>({
+      ...params,
+      frameClient: this.frameClient,
+      task: this.key,
+      name: this.name,
+      statusDataZ: this.schemas?.statusDataSchema,
+    });
   }
 
   async snapshottedTo(): Promise<ontology.Resource | null> {
@@ -158,6 +179,7 @@ const retrieveReqZ = z.object({
   names: z.string().array().optional(),
   types: z.string().array().optional(),
   includeStatus: z.boolean().optional(),
+  searchTerm: z.string().optional(),
   offset: z.number().optional(),
   limit: z.number().optional(),
 });
@@ -169,11 +191,17 @@ const singleRetrieveArgsZ = z.union([
   z
     .object({ name: z.string(), includeStatus: z.boolean().optional() })
     .transform(({ name, includeStatus }) => ({ names: [name], includeStatus })),
+  z
+    .object({
+      type: z.string(),
+      rack: rackKeyZ.optional(),
+    })
+    .transform(({ type, rack }) => ({ types: [type], rack })),
 ]);
-export type SingleRetrieveArgs = z.input<typeof singleRetrieveArgsZ>;
+export type RetrieveSingleParams = z.input<typeof singleRetrieveArgsZ>;
 
 const multiRetrieveArgsZ = retrieveReqZ;
-export type MultiRetrieveArgs = z.input<typeof multiRetrieveArgsZ>;
+export type RetrieveMultipleParams = z.input<typeof multiRetrieveArgsZ>;
 
 const retrieveArgsZ = z.union([singleRetrieveArgsZ, multiRetrieveArgsZ]);
 export type RetrieveArgs = z.input<typeof retrieveArgsZ>;
@@ -194,7 +222,7 @@ const retrieveResZ = <
   schemas?: Schemas<Type, Config, StatusData>,
 ) =>
   z.object({
-    tasks: nullableArrayZ(taskZ(schemas)),
+    tasks: array.nullableZ(taskZ(schemas)),
   });
 
 export interface RetrieveRequest extends z.infer<typeof retrieveReqZ> {}
@@ -309,17 +337,17 @@ export class Client {
     Config extends z.ZodType,
     StatusData extends z.ZodType,
   >(
-    args: SingleRetrieveArgs & RetrieveSchemas<Type, Config, StatusData>,
+    args: RetrieveSingleParams & RetrieveSchemas<Type, Config, StatusData>,
   ): Promise<Task<Type, Config, StatusData>>;
-  async retrieve(args: SingleRetrieveArgs): Promise<Task>;
+  async retrieve(args: RetrieveSingleParams): Promise<Task>;
   async retrieve<
     Type extends z.ZodLiteral<string>,
     Config extends z.ZodType,
     StatusData extends z.ZodType,
   >(
-    args: MultiRetrieveArgs & RetrieveSchemas<Type, Config, StatusData>,
+    args: RetrieveMultipleParams & RetrieveSchemas<Type, Config, StatusData>,
   ): Promise<Task<Type, Config, StatusData>[]>;
-  async retrieve(args: MultiRetrieveArgs): Promise<Task[]>;
+  async retrieve(args: RetrieveMultipleParams): Promise<Task[]>;
   async retrieve<
     Type extends z.ZodLiteral<string>,
     Config extends z.ZodType,
@@ -330,7 +358,7 @@ export class Client {
   }: RetrieveArgs & RetrieveSchemas<Type, Config, StatusData>): Promise<
     Task<Type, Config, StatusData> | Task<Type, Config, StatusData>[]
   > {
-    const isSingle = "key" in args || "name" in args;
+    const isSingle = singleRetrieveArgsZ.safeParse(args).success;
     const res = await sendRequired(
       this.client,
       RETRIEVE_ENDPOINT,
@@ -409,79 +437,72 @@ export class Client {
     return isSingle ? res[0] : res;
   }
 
-  async executeCommand(task: Key, type: string, args?: {}): Promise<string>;
+  async executeCommand(params: ExecuteCommandParams): Promise<string>;
 
-  async executeCommand(commands: NewCommand[]): Promise<string[]>;
+  async executeCommand(params: ExecuteCommandsParams): Promise<string[]>;
 
   async executeCommand(
-    task: Key | NewCommand[],
-    type?: string,
-    args?: {},
+    params: ExecuteCommandParams | ExecuteCommandsParams,
   ): Promise<string | string[]> {
-    if (Array.isArray(task)) return await executeCommands(this.frameClient, task);
-    if (type == null) throw new Error("Type is required");
-    return await executeCommand(this.frameClient, task, type, args);
+    if ("commands" in params)
+      return await executeCommands({ ...params, frameClient: this.frameClient });
+    return await executeCommand({ ...params, frameClient: this.frameClient });
   }
 
   async executeCommandSync<StatusData extends z.ZodType = z.ZodType>(
-    task: Key,
-    type: string,
-    timeout: CrudeTimeSpan,
-    args?: {},
-    name?: string,
-    statusDataZ?: StatusData,
-  ): Promise<Status<StatusData>>;
-  async executeCommandSync<StatusData extends z.ZodType = z.ZodType>(
-    commands: NewCommand[],
-    timeout: CrudeTimeSpan,
-    statusDataZ?: StatusData,
+    parms: ExecuteCommandsSyncParams<StatusData>,
   ): Promise<Status<StatusData>[]>;
 
   async executeCommandSync<StatusData extends z.ZodType = z.ZodType>(
-    task: Key | NewCommand[],
-    type: string | CrudeTimeSpan,
-    timeout?: CrudeTimeSpan | StatusData,
-    args?: {},
-    name?: string,
-    statusDataZ: StatusData = z.unknown() as unknown as StatusData,
+    parms: ExecuteCommandSyncParams<StatusData>,
+  ): Promise<Status<StatusData>>;
+
+  async executeCommandSync<StatusData extends z.ZodType = z.ZodType>(
+    params:
+      | ExecuteCommandsSyncParams<StatusData>
+      | ExecuteCommandSyncParams<StatusData>,
   ): Promise<Status<StatusData> | Status<StatusData>[]> {
-    if (Array.isArray(task)) {
+    if ("commands" in params) {
       const retrieveNames = async () => {
-        const ts = await this.retrieve({ keys: task.map((t) => t.task) });
+        const { commands } = params;
+        const ts = await this.retrieve({ keys: commands.map((t) => t.task) });
         return ts.map((t) => t.name);
       };
-      return await executeCommandsSync(
-        this.frameClient,
-        task,
-        type as CrudeTimeSpan,
-        statusDataZ,
-        retrieveNames,
-      );
+      return await executeCommandsSync({
+        ...params,
+        frameClient: this.frameClient,
+        name: retrieveNames,
+      });
     }
     const retrieveName = async () => {
+      const { task } = params;
       const t = await this.retrieve({ key: task });
       return t.name;
     };
-    return await executeCommandSync(
-      this.frameClient,
-      task,
-      type as string,
-      timeout as CrudeTimeSpan,
-      name ?? retrieveName,
-      statusDataZ,
-      args,
-    );
+    return await executeCommandSync({
+      frameClient: this.frameClient,
+      name: retrieveName,
+      ...params,
+    });
   }
 }
 
 export const ontologyID = (key: Key): ontology.ID => ({ type: "task", key });
 
-const executeCommand = async (
-  frameClient: framer.Client | null,
-  task: Key,
-  type: string,
-  args?: {},
-): Promise<string> => (await executeCommands(frameClient, [{ args, task, type }]))[0];
+interface ExecuteCommandInternalParams {
+  frameClient: framer.Client | null;
+  task: Key;
+  type: string;
+  args?: {};
+}
+
+const executeCommand = async ({
+  frameClient,
+  task,
+  type,
+  args,
+}: ExecuteCommandInternalParams): Promise<string> =>
+  (await executeCommands({ frameClient, commands: [{ args, task, type }] }))[0];
 
 export interface NewCommand {
   task: Key;
@@ -489,10 +510,15 @@ export interface NewCommand {
   args?: {};
 }
 
-const executeCommands = async (
-  frameClient: framer.Client | null,
-  commands: NewCommand[],
-): Promise<string[]> => {
+interface ExecuteCommandsInternalParams {
+  frameClient: framer.Client | null;
+  commands: NewCommand[];
+}
+
+const executeCommands = async ({
+  frameClient,
+  commands,
+}: ExecuteCommandsInternalParams): Promise<string[]> => {
   if (frameClient == null) throw NOT_CREATED_ERROR;
   const w = await frameClient.openWriter(COMMAND_CHANNEL_NAME);
   const cmds = commands.map((c) => ({ ...c, key: id.create() }));
@@ -501,35 +527,49 @@ const executeCommands = async (
   return cmds.map((c) => c.key);
 };
 
-const executeCommandSync = async <StatusData extends z.ZodType = z.ZodType>(
-  frameClient: framer.Client | null,
-  task: Key,
-  type: string,
-  timeout: CrudeTimeSpan,
-  tskName: string | (() => Promise<string>),
-  statusDataZ: StatusData,
-  args?: {},
-): Promise<Status<StatusData>> =>
+interface ExecuteCommandSyncInternalParams<StatusData extends z.ZodType = z.ZodType>
+  extends Omit<ExecuteCommandsSyncInternalParams<StatusData>, "commands">,
+    TaskExecuteCommandSyncParams {
+  task: Key;
+}
+
+const executeCommandSync = async <StatusData extends z.ZodType = z.ZodType>({
+  frameClient,
+  task,
+  type,
+  timeout,
+  name: taskName,
+  statusDataZ,
+  args,
+}: ExecuteCommandSyncInternalParams<StatusData>): Promise<Status<StatusData>> =>
   (
-    await executeCommandsSync(
+    await executeCommandsSync({
       frameClient,
-      [{ args, task, type }],
+      commands: [{ args, task, type }],
       timeout,
       statusDataZ,
-      tskName,
-    )
+      name: taskName,
+    })
   )[0];
 
-const executeCommandsSync = async <StatusData extends z.ZodType = z.ZodType>(
-  frameClient: framer.Client | null,
-  commands: NewCommand[],
-  timeout: CrudeTimeSpan,
-  statusDataZ: StatusData,
-  tskName: string | string[] | (() => Promise<string | string[]>),
-): Promise<Status<StatusData>[]> => {
+interface ExecuteCommandsSyncInternalParams<StatusData extends z.ZodType = z.ZodType> {
+  frameClient: framer.Client | null;
+  commands: NewCommand[];
+  timeout?: CrudeTimeSpan;
+  statusDataZ: StatusData;
+  name: string | string[] | (() => Promise<string | string[]>);
+}
+
+const executeCommandsSync = async <StatusData extends z.ZodType = z.ZodType>({
+  frameClient,
+  commands,
+  timeout = TimeSpan.seconds(10),
+  statusDataZ,
+  name: taskName,
+}: ExecuteCommandsSyncInternalParams<StatusData>): Promise<Status<StatusData>[]> => {
   if (frameClient == null) throw NOT_CREATED_ERROR;
   const streamer = await frameClient.openStreamer(STATUS_CHANNEL_NAME);
-  const cmdKeys = await executeCommands(frameClient, commands);
+  const cmdKeys = await executeCommands({ frameClient, commands });
   const parsedTimeout = new TimeSpan(timeout);
   let states: Status<StatusData>[] = [];
   let timeoutID: NodeJS.Timeout | undefined;
@@ -537,7 +577,7 @@ const executeCommandsSync = async <StatusData extends z.ZodType = z.ZodType>(
     timeoutID = setTimeout(() => {
       void (async () => {
         const taskKeys = commands.map((c) => c.task);
-        reject(await formatTimeoutError("command", tskName, parsedTimeout, taskKeys));
+        reject(await formatTimeoutError("command", taskName, parsedTimeout, taskKeys));
       })();
     }, parsedTimeout.milliseconds);
   });

package/src/hardware/task/payload.ts

@@ -21,14 +21,14 @@ export const keyZ = z.union([
 ]);
 export type Key = z.infer<typeof keyZ>;
 
-export const statusDetailsZ = <D extends z.ZodType>(data: D) =>
+export const statusDetailsZ = <DataSchema extends z.ZodType>(data: DataSchema) =>
   z.object({ task: keyZ, running: z.boolean(), data });
 
-export type StatusDetails<D extends z.ZodType> = z.infer<
-  ReturnType<typeof statusDetailsZ<D>>
+export type StatusDetails<DataSchema extends z.ZodType> = z.infer<
+  ReturnType<typeof statusDetailsZ<DataSchema>>
 >;
 
-export const statusZ = <D extends z.ZodType>(data: D) =>
+export const statusZ = <DataSchema extends z.ZodType>(data: DataSchema) =>
   status.statusZ(statusDetailsZ(data));
 
 export type Status<StatusData extends z.ZodType = z.ZodUnknown> = z.infer<