@synnaxlabs/client 0.54.2 → 0.55.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/client",
-  "version": "0.54.2",
+  "version": "0.55.0",
   "description": "The Synnax Client Library",
   "keywords": [
     "synnax",
@@ -26,19 +26,19 @@
   "dependencies": {
     "async-mutex": "^0.5.0",
     "zod": "^4.3.6",
-    "@synnaxlabs/freighter": "^0.54.0",
-    "@synnaxlabs/x": "^0.54.2"
+    "@synnaxlabs/x": "^0.55.0",
+    "@synnaxlabs/freighter": "^0.55.0"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^4.1.2",
-    "@types/node": "^25.5.0",
-    "eslint": "^10.1.0",
+    "@vitest/coverage-v8": "^4.1.4",
+    "@types/node": "^25.6.0",
+    "eslint": "^10.2.1",
     "madge": "^8.0.0",
-    "typescript": "^6.0.2",
-    "vite": "^8.0.3",
-    "vitest": "^4.1.2",
-    "@synnaxlabs/tsconfig": "^0.0.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.8",
+    "vitest": "^4.1.4",
     "@synnaxlabs/eslint-config": "^0.0.0",
+    "@synnaxlabs/tsconfig": "^0.0.0",
     "@synnaxlabs/vite-plugin": "^0.0.0"
   },
   "type": "module",

package/src/arc/arc.spec.ts

@@ -0,0 +1,44 @@
+// 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 { id } from "@synnaxlabs/x";
+import { describe, expect, it } from "vitest";
+
+import { type arc } from "@/arc";
+import { createTestClient } from "@/testutil/client";
+
+const client = createTestClient();
+
+const newTextArc = (name: string): arc.New => ({
+  name,
+  mode: "text",
+  graph: {
+    nodes: [],
+    edges: [],
+    viewport: { position: { x: 0, y: 0 }, zoom: 1 },
+    functions: [],
+  },
+  text: { raw: "" },
+});
+
+describe("arc", () => {
+  describe("retrieve", () => {
+    it("should retrieve arcs by search term", async () => {
+      const prefix = `searchable-arc-${id.create()}`;
+      const names = [`${prefix}-1`, `${prefix}-2`];
+      await client.arcs.create(names.map((name) => newTextArc(name)));
+      await expect
+        .poll(async () => {
+          const results = await client.arcs.retrieve({ searchTerm: prefix });
+          return results.map((a) => a.name).sort();
+        })
+        .toEqual(names);
+    });
+  });
+});

package/src/arc/ir/types.gen.ts

@@ -21,6 +21,20 @@ export enum EdgeKind {
 }
 export const edgeKindZ = z.enum(EdgeKind);
 
+export enum ScopeMode {
+  unspecified = 0,
+  parallel = 1,
+  sequential = 2,
+}
+export const scopeModeZ = z.enum(ScopeMode);
+
+export enum Liveness {
+  unspecified = 0,
+  always = 1,
+  gated = 2,
+}
+export const livenessZ = z.enum(Liveness);
+
 /** Handle is a reference to a specific parameter on a specific node in the dataflow graph. */
 export const handleZ = z.object({
   /** node is the node identifier. */
@@ -47,13 +61,13 @@ export const nodeZ = z.object({
   /** type is the function type being instantiated. */
   type: z.string(),
   /** config contains configuration parameter values. */
-  config: types.paramsZ.optional(),
+  config: types.paramsZ,
   /** inputs contains input parameter type signatures. */
-  inputs: types.paramsZ.optional(),
+  inputs: types.paramsZ,
   /** outputs contains output parameter type signatures. */
-  outputs: types.paramsZ.optional(),
+  outputs: types.paramsZ,
   /** channels contains channel read/write mappings. */
-  channels: types.channelsZ.optional(),
+  channels: types.channelsZ,
 });
 export interface Node extends z.infer<typeof nodeZ> {}
 
@@ -62,13 +76,10 @@ export const authoritiesZ = z.object({
   /** default is the default authority for all write channels not explicitly listed. */
   default: zod.uint8.optional(),
   /** channels maps channel keys to their specific authority values. */
-  channels: z.record(z.uint32(), zod.uint8).optional(),
+  channels: z.record(z.uint32(), zod.uint8),
 });
 export interface Authorities extends z.infer<typeof authoritiesZ> {}
 
-export const stratumZ = array.nullishToEmpty(z.string());
-export type Stratum = z.infer<typeof stratumZ>;
-
 /** Edge is a dataflow connection between node parameters in the Arc graph. */
 export const edgeZ = z.object({
   /** source is the source node parameter producing data. */
@@ -76,10 +87,22 @@ export const edgeZ = z.object({
   /** target is the target node parameter consuming data. */
   target: handleZ,
   /** kind defines execution semantics for this connection. */
-  kind: edgeKindZ.optional(),
+  kind: edgeKindZ,
 });
 export interface Edge extends z.infer<typeof edgeZ> {}
 
+/** Transition is a declarative state-transition rule on a sequential Scope. */
+export const transitionZ = z.object({
+  /** on is the dataflow handle whose truthy value fires this transition. */
+  on: handleZ,
+  /**
+   * targetKey is the sibling step key to activate. Null when the transition
+   * exits the scope, yielding to the parent.
+   */
+  targetKey: z.string().optional(),
+});
+export interface Transition extends z.infer<typeof transitionZ> {}
+
 /**
  * Function is a function template definition with typed parameters, serving as a
  * blueprint for node instantiation.
@@ -90,22 +113,19 @@ export const functionZ = z.object({
   /** body is raw source code for user-defined functions. */
   body: bodyZ.optional(),
   /** config contains configuration parameter definitions. */
-  config: types.paramsZ.optional(),
+  config: types.paramsZ,
   /** inputs contains input parameter definitions. */
-  inputs: types.paramsZ.optional(),
+  inputs: types.paramsZ,
   /** outputs contains output parameter definitions. */
-  outputs: types.paramsZ.optional(),
+  outputs: types.paramsZ,
   /** channels contains channel read/write declarations. */
-  channels: types.channelsZ.optional(),
+  channels: types.channelsZ,
 });
 export interface Function extends z.infer<typeof functionZ> {}
 
 export const nodesZ = array.nullishToEmpty(nodeZ);
 export type Nodes = z.infer<typeof nodesZ>;
 
-export const strataZ = array.nullishToEmpty(stratumZ);
-export type Strata = z.infer<typeof strataZ>;
-
 export const edgesZ = array.nullishToEmpty(edgeZ);
 export type Edges = z.infer<typeof edgesZ>;
 
@@ -113,36 +133,65 @@ export const functionsZ = array.nullishToEmpty(functionZ);
 export type Functions = z.infer<typeof functionsZ>;
 
 /**
- * Stage is a stage in a sequence state machine, containing active nodes and their
- * execution stratification.
+ * Member is a tagged union representing a single child of a Scope. Exactly one
+ * of nodeKey or scope is set. The member's lookup key (used as the
+ * target of `=> name` transitions) is derived from the set variant via
+ * Member.key().
  */
-export const stageZ = z.object({
-  /** key is the stage identifier. */
-  key: z.string(),
-  /** nodes contains node keys active in this stage. */
-  nodes: array.nullishToEmpty(z.string()),
-  /** strata contains execution stratification for nodes in this stage. */
-  strata: strataZ,
+export interface Member {
+  nodeKey?: string;
+  scope?: Scope;
+}
+export const memberZ: z.ZodType<Member> = z.object({
+  /**
+   * nodeKey is the key of the referenced node in IR.nodes. Null when this
+   * member is a nested scope.
+   */
+  nodeKey: z.string().optional(),
+  /** scope is set when this member is a nested scope. */
+  get scope() {
+    return scopeZ.optional();
+  },
 });
-export interface Stage extends z.infer<typeof stageZ> {}
 
 /**
- * Sequence is a state machine defining ordered stages of execution, where entry point
- * is always the first stage.
+ * Scope is the unified Layer 2 execution primitive. Parameterized by mode
+ * (parallel or sequential) and liveness (always-live or gated). Parallel
+ * scopes organize members into strata; sequential scopes run one step
+ * at a time and advance via transitions.
  */
-export const sequenceZ = z.object({
-  /** key is the sequence identifier. */
+export interface Scope {
+  key: string;
+  mode: ScopeMode;
+  liveness: Liveness;
+  activation?: Handle;
+  strata: Members[];
+  steps: Members;
+  transitions: Transition[];
+}
+export const scopeZ: z.ZodType<Scope> = z.object({
+  /** key is the scope identifier. */
   key: z.string(),
-  /** stages contains ordered stages in this sequence. */
-  stages: array.nullishToEmpty(stageZ),
+  /** mode defines whether this scope runs steps in parallel or sequentially. */
+  mode: scopeModeZ,
+  /** liveness defines whether this scope is continuously active or must be activated. */
+  liveness: livenessZ,
+  /** activation is the handle whose truthy value activates a gated scope. Unset for always-live scopes. */
+  activation: handleZ.optional(),
+  /**
+   * strata contains stratified execution layers for parallel scopes. Empty
+   * for sequential scopes. Stratum N depends only on strata 0 to N-1.
+   */
+  get strata() {
+    return array.nullishToEmpty(membersZ);
+  },
+  /** steps contains ordered steps for sequential scopes. Empty for parallel scopes. */
+  get steps() {
+    return membersZ;
+  },
+  /** transitions contains state-transition rules for sequential scopes. Empty for parallel scopes. */
+  transitions: array.nullishToEmpty(transitionZ),
 });
-export interface Sequence extends z.infer<typeof sequenceZ> {}
-
-export const stagesZ = array.nullishToEmpty(stageZ);
-export type Stages = z.infer<typeof stagesZ>;
-
-export const sequencesZ = array.nullishToEmpty(sequenceZ);
-export type Sequences = z.infer<typeof sequencesZ>;
 
 /**
  * IR is the intermediate representation of an Arc program as a dataflow graph
@@ -151,16 +200,21 @@ export type Sequences = z.infer<typeof sequencesZ>;
  */
 export const irZ = z.object({
   /** functions contains function template definitions. */
-  functions: functionsZ.optional(),
+  functions: functionsZ,
   /** nodes contains node instantiations. */
-  nodes: nodesZ.optional(),
+  nodes: nodesZ,
   /** edges contains dataflow connections. */
-  edges: edgesZ.optional(),
-  /** strata contains execution stratification layers. */
-  strata: strataZ.optional(),
-  /** sequences contains state machine definitions. */
-  sequences: sequencesZ.optional(),
+  edges: edgesZ,
   /** authorities contains the static authority declarations for this program. */
-  authorities: authoritiesZ.optional(),
+  authorities: authoritiesZ,
+  /**
+   * root is the top-level execution context. The root is always a
+   * parallel, always-live Scope whose strata mix module-scope
+   * reactive flow with top-level gated scopes.
+   */
+  root: scopeZ,
 });
 export interface IR extends z.infer<typeof irZ> {}
+
+export const membersZ = array.nullishToEmpty(memberZ);
+export type Members = z.infer<typeof membersZ>;

package/src/auth/auth.ts

@@ -8,6 +8,7 @@
 // included in the file licenses/APL.txt.
 
 import { type Middleware, sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
+import { TimeStamp } from "@synnaxlabs/x";
 import { z } from "zod";
 
 import { ExpiredTokenError, InvalidTokenError } from "@/errors";
@@ -16,7 +17,18 @@ import { user } from "@/user";
 const insecureCredentialsZ = z.object({ username: z.string(), password: z.string() });
 interface InsecureCredentials extends z.infer<typeof insecureCredentialsZ> {}
 
-const tokenResponseZ = z.object({ token: z.string(), user: user.userZ });
+const clusterInfoZ = z.object({
+  clusterKey: z.string(),
+  nodeVersion: z.string().optional(),
+  nodeKey: z.number().optional(),
+  nodeTime: TimeStamp.z,
+});
+
+const tokenResponseZ = z.object({
+  token: z.string(),
+  user: user.userZ,
+  clusterInfo: clusterInfoZ.optional(),
+});
 
 const LOGIN_ENDPOINT = "/auth/login";
 

package/src/channel/channel.spec.ts

@@ -226,6 +226,19 @@ describe("Channel", () => {
         async () => await client.channels.retrieve("1-1000"),
       ).rejects.toThrow(NotFoundError);
     });
+    test("retrieve by search term", async () => {
+      const prefix = id.create();
+      const names = [`${prefix}_1`, `${prefix}_2`];
+      await client.channels.create(
+        names.map((name) => ({ name, virtual: true, dataType: DataType.FLOAT32 })),
+      );
+      await expect
+        .poll(async () => {
+          const results = await client.channels.retrieve({ searchTerm: prefix });
+          return results.map((c) => c.name).sort();
+        })
+        .toEqual(names);
+    });
   });
 
   describe("delete", async () => {

package/src/channel/types.gen.ts

@@ -85,8 +85,7 @@ export const payloadZ = z.object({
   isIndex: z.boolean(),
   /**
    * index is the channel used to index this channel's values, associating
-   * each value with a timestamp. If zero, the channel's data will be
-   * indexed using its rate.
+   * each value with a timestamp.
    */
   index: keyZ,
   /** alias is an optional alternate name for the channel within a specific context. */

package/src/client.ts

@@ -45,6 +45,7 @@ export const synnaxParamsZ = z.object({
   username: z.string().min(1, "Username is required"),
   password: z.string().min(1, "Password is required"),
   connectivityPollFrequency: TimeSpan.z.default(TimeSpan.seconds(30)),
+  clockSkewThreshold: TimeSpan.z.default(TimeSpan.seconds(1)),
   secure: z.boolean().default(false),
   name: z.string().optional(),
   retry: breaker.breakerConfigZ.optional(),
@@ -116,6 +117,7 @@ export default class Synnax extends framer.Client {
       username,
       password,
       connectivityPollFrequency,
+      clockSkewThreshold,
       secure,
       retry: breaker,
     } = parsedParams;
@@ -141,6 +143,7 @@ export default class Synnax extends framer.Client {
       connectivityPollFrequency,
       this.clientVersion,
       parsedParams.name,
+      clockSkewThreshold,
     );
     this.control = new control.Client(this);
     this.ontology = new ontology.Client(this.transport.unary);

package/src/connection/checker.ts

@@ -8,7 +8,13 @@
 // included in the file licenses/APL.txt.
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
-import { migrate, TimeSpan } from "@synnaxlabs/x";
+import {
+  ClockSkewCalculator,
+  type CrudeTimeSpan,
+  migrate,
+  TimeSpan,
+  TimeStamp,
+} from "@synnaxlabs/x";
 import { z } from "zod";
 
 export const statusZ = z.enum(["disconnected", "connecting", "connected", "failed"]);
@@ -22,12 +28,15 @@ export const stateZ = z.object({
   clientVersion: z.string(),
   clientServerCompatible: z.boolean(),
   nodeVersion: z.string().optional(),
+  clockSkew: TimeSpan.z.default(TimeSpan.ZERO),
+  clockSkewExceeded: z.boolean().default(false),
 });
 export interface State extends z.infer<typeof stateZ> {}
 
 const responseZ = z.object({
   clusterKey: z.string(),
   nodeVersion: z.string().optional(),
+  nodeTime: TimeStamp.z,
 });
 const requestZ = z.void();
 
@@ -38,6 +47,8 @@ const DEFAULT: State = {
   message: "Disconnected",
   clientServerCompatible: false,
   clientVersion: __VERSION__,
+  clockSkew: TimeSpan.ZERO,
+  clockSkewExceeded: false,
 };
 
 const createWarning = (
@@ -46,16 +57,16 @@ const createWarning = (
   clientIsNewer: boolean,
 ): string => {
   const toUpgrade = clientIsNewer ? "Core" : "client";
-  return `Synnax Core version ${nodeVersion != null ? `${nodeVersion} ` : ""}is too ${clientIsNewer ? "old" : "new"} for client version ${clientVersion}.
+  return `The Synnax Core version ${nodeVersion != null ? `${nodeVersion} ` : ""}is too ${clientIsNewer ? "old" : "new"} for client version ${clientVersion}.
   This may cause compatibility issues. We recommend updating the ${toUpgrade}. For more information, see
-  https://docs.synnaxlabs.com/reference/client/resources/troubleshooting#old-${toUpgrade}-version`;
+  https://docs.synnaxlabs.com/reference/client/resources/troubleshooting#old-${toUpgrade.toLowerCase()}-version`;
 };
 
 /** Polls a synnax cluster for connectivity information. */
 export class Checker {
   static readonly DEFAULT: State = DEFAULT;
   private readonly _state: State;
-  private readonly pollFrequency = TimeSpan.seconds(30);
+  private readonly pollFrequency: TimeSpan;
   private readonly client: UnaryClient;
   private readonly name?: string;
   private interval?: NodeJS.Timeout;
@@ -63,6 +74,9 @@ export class Checker {
   private readonly onChangeHandlers: Array<(state: State) => void> = [];
   static readonly connectionStateZ = stateZ;
   private versionWarned = false;
+  private readonly skewCalc: ClockSkewCalculator;
+  private readonly clockSkewThreshold: TimeSpan;
+  private checking = false;
 
   /**
    * @param client - The transport client to use for connectivity checks.
@@ -74,12 +88,15 @@ export class Checker {
     pollFreq: TimeSpan = TimeSpan.seconds(30),
     clientVersion: string,
     name?: string,
+    clockSkewThreshold: CrudeTimeSpan = TimeSpan.seconds(1),
   ) {
     this._state = { ...DEFAULT };
     this.client = client;
     this.pollFrequency = pollFreq;
     this.clientVersion = clientVersion;
     this.name = name;
+    this.skewCalc = new ClockSkewCalculator();
+    this.clockSkewThreshold = new TimeSpan(clockSkewThreshold).abs();
     void this.check();
     this.start();
   }
@@ -95,7 +112,11 @@ export class Checker {
    */
   async check(): Promise<State> {
     const prevStatus = this._state.status;
+    const prevSkewExceeded = this._state.clockSkewExceeded;
+    const measureSkew = !this.checking;
+    this.checking = true;
     try {
+      if (measureSkew) this.skewCalc.start();
       const res = await sendRequired(
         this.client,
         "/connectivity/check",
@@ -103,6 +124,19 @@ export class Checker {
         requestZ,
         responseZ,
       );
+      if (measureSkew) {
+        this.skewCalc.end(res.nodeTime);
+        this._state.clockSkew = this.skewCalc.skew;
+        this._state.clockSkewExceeded = this.skewCalc.exceeds(this.clockSkewThreshold);
+        if (this._state.clockSkewExceeded) {
+          const direction = this.skewCalc.skew.valueOf() > 0n ? "ahead of" : "behind";
+          console.warn(
+            `Measured excessive clock skew between this host and ` +
+              `the Synnax Core. This host is ${direction} the Synnax Core ` +
+              `by approximately ${this.skewCalc.skew.abs().toString()}.`,
+          );
+        }
+      }
       const nodeVersion = res.nodeVersion;
       const clientVersion = this.clientVersion;
       const warned = this.versionWarned;
@@ -140,8 +174,13 @@ export class Checker {
       this._state.status = "failed";
       this._state.error = err as Error;
       this._state.message = this.state.error?.message;
+    } finally {
+      this.checking = false;
     }
-    if (this.onChangeHandlers.length > 0 && prevStatus !== this._state.status)
+    const changed =
+      prevStatus !== this._state.status ||
+      prevSkewExceeded !== this._state.clockSkewExceeded;
+    if (this.onChangeHandlers.length > 0 && changed)
       this.onChangeHandlers.forEach((handler) => handler(this.state));
     return this.state;
   }

package/src/connection/connection.spec.ts

@@ -7,8 +7,9 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
-import { URL } from "@synnaxlabs/x";
-import { describe, expect, it } from "vitest";
+import { type UnaryClient } from "@synnaxlabs/freighter";
+import { TimeSpan, TimeStamp, URL } from "@synnaxlabs/x";
+import { describe, expect, it, vi } from "vitest";
 import { z } from "zod";
 
 import { auth } from "@/auth";
@@ -87,4 +88,68 @@ describe("connectivity", () => {
       expect(state.clientVersion).toBe("0.0.0");
     });
   });
+  describe("clock skew", () => {
+    const createMockClient = (nodeTime: TimeStamp): UnaryClient => ({
+      send: vi.fn().mockResolvedValue([
+        {
+          clusterKey: "test-cluster",
+          nodeVersion: __VERSION__,
+          nodeTime,
+        },
+        null,
+      ]) as UnaryClient["send"],
+      use: vi.fn(),
+    });
+
+    it("should detect clock skew exceeding threshold", async () => {
+      const farFuture = TimeStamp.now().add(TimeSpan.hours(1));
+      const checker = new connection.Checker(
+        createMockClient(farFuture),
+        TimeSpan.seconds(30),
+        __VERSION__,
+        undefined,
+        TimeSpan.seconds(1),
+      );
+      const state = await checker.check();
+      expect(state.clockSkewExceeded).toBe(true);
+      expect(state.clockSkew.valueOf()).not.toBe(0n);
+      checker.stop();
+    });
+
+    it("should not flag skew within threshold", async () => {
+      const now = TimeStamp.now();
+      const checker = new connection.Checker(
+        createMockClient(now),
+        TimeSpan.seconds(30),
+        __VERSION__,
+        undefined,
+        TimeSpan.seconds(1),
+      );
+      const state = await checker.check();
+      expect(state.clockSkewExceeded).toBe(false);
+      checker.stop();
+    });
+
+    it("should fire onChange when clockSkewExceeded changes", async () => {
+      let callCount = 0;
+      const farFuture = TimeStamp.now().add(TimeSpan.hours(1));
+      const checker = new connection.Checker(
+        createMockClient(farFuture),
+        TimeSpan.seconds(30),
+        __VERSION__,
+        undefined,
+        TimeSpan.seconds(1),
+      );
+      // Wait for the constructor's initial check to complete
+      await checker.check();
+      checker.onChange(() => {
+        callCount++;
+      });
+      // Trigger another check - skewExceeded stays true, status stays connected,
+      // so onChange should not fire
+      await checker.check();
+      expect(callCount).toBe(0);
+      checker.stop();
+    });
+  });
 });

package/src/control/state.ts

@@ -46,13 +46,14 @@ export class StateTracker
   implements observe.ObservableAsyncCloseable<Transfer[]>
 {
   readonly states: Map<channel.Key, State>;
-  private readonly codec: binary.Codec;
+  private readonly codec: binary.JSONCodec;
 
   constructor(streamer: framer.Streamer) {
     super(streamer, (frame) => {
-      const update: Update = this.codec.decode(frame.series[0].buffer, updateZ);
-      this.merge(update);
-      return [update.transfers, true];
+      const raw = Array.from(frame.series[0].as("string"));
+      const updates: Update[] = raw.map((r) => this.codec.decodeString(r, updateZ));
+      updates.forEach((u) => this.merge(u));
+      return [updates.flatMap((u) => u.transfers), true];
     });
     this.states = new Map();
     this.codec = new binary.JSONCodec();

package/src/device/device.spec.ts

@@ -312,11 +312,13 @@ describe("Device", async () => {
       });
 
       it("should retrieve devices by search term", async () => {
-        const result = await client.devices.retrieve({
-          searchTerm: "sensor1",
-        });
-        expect(result.length).toBeGreaterThanOrEqual(2);
-        expect(result.every((d) => d.name.includes("sensor"))).toBe(true);
+        const sensor1 = testDevices.find((d) => d.name === "sensor1")!;
+        await expect
+          .poll(async () => {
+            const result = await client.devices.retrieve({ searchTerm: "sensor1" });
+            return result.find((d) => d.key === sensor1.key);
+          })
+          .toMatchObject({ name: "sensor1", key: sensor1.key });
       });
 
       it("should support pagination with limit and offset", async () => {

package/src/framer/client.ts

@@ -180,6 +180,18 @@ export class Client {
 
   async readLatest(channels: channel.Params, n: number): Promise<Frame>;
 
+  /**
+   * Reads the latest n samples from the given channel(s).
+   *
+   * If fewer than n samples are available, returns only the samples that
+   * exist.
+   *
+   * @param channels - A single channel key/name or an array of channel
+   * keys/names.
+   * @param n - The maximum number of samples to read. Defaults to 1.
+   * @returns A MultiSeries when a single channel is provided, or a Frame when
+   * multiple channels are provided.
+   */
   async readLatest(
     channels: channel.Params,
     n: number = 1,