@synnaxlabs/client 0.43.0 → 0.44.1

package/src/errors.ts

@@ -8,7 +8,8 @@
 // included in the file licenses/APL.txt.
 
 import { type Middleware, Unreachable } from "@synnaxlabs/freighter";
-import { errors } from "@synnaxlabs/x";
+import { array, errors } from "@synnaxlabs/x";
+import { z } from "zod";
 
 export class SynnaxError extends errors.createTyped("sy") {}
 
@@ -17,14 +18,24 @@ export class SynnaxError extends errors.createTyped("sy") {}
  */
 export class ValidationError extends SynnaxError.sub("validation") {}
 
-export class FieldError extends ValidationError.sub("field") {
-  readonly field: string;
-  readonly message: string;
+export class PathError extends ValidationError.sub("path") {
+  readonly path: string[];
+  readonly error: Error;
+  static readonly encodedSchema = z.object({
+    path: z.string().array(),
+    error: errors.payloadZ,
+  });
+
+  constructor(path: string | string[], error: Error) {
+    const arrPath = array.toArray(path);
+    super(`${arrPath.join(".")}: ${error.message}`);
+    this.path = arrPath.flatMap((p) => p.split("."));
+    this.error = error;
+  }
 
-  constructor(field: string, message: string) {
-    super(`${field}: ${message}`);
-    this.field = field;
-    this.message = message;
+  static decode(payload: errors.Payload): PathError {
+    const decoded = PathError.encodedSchema.parse(JSON.parse(payload.data));
+    return new PathError(decoded.path, errors.decode(decoded.error) as Error);
   }
 }
 
@@ -80,6 +91,12 @@ export class ControlError extends SynnaxError.sub("control") {}
 
 export class UnauthorizedError extends ControlError.sub("unauthorized") {}
 
+export class DisconnectedError extends SynnaxError.sub("disconnected") {
+  constructor(message: string = "Operation failed because no cluster is connected.") {
+    super(message);
+  }
+}
+
 /**
  * Raised when time-series data is not contiguous.
  */
@@ -88,11 +105,7 @@ export class ContiguityError extends SynnaxError.sub("contiguity") {}
 const decode = (payload: errors.Payload): Error | null => {
   if (!payload.type.startsWith(SynnaxError.TYPE)) return null;
   if (payload.type.startsWith(ValidationError.TYPE)) {
-    if (payload.type === FieldError.TYPE) {
-      const values = payload.data.split(": ");
-      if (values.length < 2) return new ValidationError(payload.data);
-      return new FieldError(values[0], values[1]);
-    }
+    if (payload.type === PathError.TYPE) return PathError.decode(payload);
     return new ValidationError(payload.data);
   }
 
@@ -128,7 +141,7 @@ const decode = (payload: errors.Payload): Error | null => {
 };
 
 const encode = (): errors.Payload => {
-  throw new Error("Not implemented");
+  throw new errors.NotImplemented();
 };
 
 errors.register({ encode, decode });
@@ -138,7 +151,7 @@ export const validateFieldNotNull = (
   value: unknown,
   message: string = "must be provided",
 ): void => {
-  if (value == null) throw new FieldError(key, message);
+  if (value == null) throw new PathError(key, new ValidationError(message));
 };
 
 export const errorsMiddleware: Middleware = async (ctx, next) => {

package/src/framer/adapter.spec.ts

@@ -11,11 +11,11 @@ import { DataType, Series, TimeStamp } from "@synnaxlabs/x/telem";
 import { beforeAll, describe, expect, it } from "vitest";
 
 import { type channel } from "@/channel";
-import { WriteAdapter } from "@/framer/adapter";
+import { ReadAdapter, WriteAdapter } from "@/framer/adapter";
 import { Frame } from "@/index";
-import { newClient } from "@/setupspecs";
+import { newTestClient } from "@/testutil/client";
 
-const client = newClient();
+const client = newTestClient();
 
 describe("WriteFrameAdapter", () => {
   let timeCh: channel.Channel;
@@ -160,14 +160,123 @@ describe("WriteFrameAdapter", () => {
     expect(res.get(bigIntCh.key).at(0)).toEqual(12n);
   });
 
-  describe("adaptObjectKeys", () => {
+  describe("adaptParams", () => {
     it("should correctly adapt generic object keys", async () => {
-      const res = await adapter.adaptObjectKeys({
-        [timeCh.name]: 532,
-        [dataCh.name]: 123,
+      const res = await adapter.adaptParams([timeCh.name, dataCh.name]);
+      expect(res).toContain(timeCh.key);
+      expect(res).toContain(dataCh.key);
+    });
+  });
+
+  describe("update", () => {
+    it("should return false when updating with the same channels", async () => {
+      const hasChanged = await adapter.update([timeCh.key, dataCh.key]);
+      expect(hasChanged).toBe(false);
+    });
+
+    it("should return true when adding a new channel", async () => {
+      const newCh = await client.channels.create({
+        name: `new-${Math.random()}-${TimeStamp.now().toString()}`,
+        dataType: DataType.FLOAT32,
+        index: timeCh.key,
+      });
+      const hasChanged = await adapter.update([timeCh.key, dataCh.key, newCh.key]);
+      expect(hasChanged).toBe(true);
+    });
+
+    it("should return true when removing a channel", async () => {
+      const hasChanged = await adapter.update([timeCh.key]);
+      expect(hasChanged).toBe(true);
+    });
+
+    it("should return true when replacing channels", async () => {
+      const newCh = await client.channels.create({
+        name: `replacement-${Math.random()}-${TimeStamp.now().toString()}`,
+        dataType: DataType.FLOAT32,
+        index: timeCh.key,
+      });
+      const hasChanged = await adapter.update([timeCh.key, newCh.key]);
+      expect(hasChanged).toBe(true);
+    });
+
+    it("should return false when updating with same channels in different order", async () => {
+      await adapter.update([timeCh.key, dataCh.key]);
+      const hasChanged = await adapter.update([dataCh.key, timeCh.key]);
+      expect(hasChanged).toBe(false);
+    });
+
+    it("should return false when updating with channel names that resolve to same keys", async () => {
+      await adapter.update([timeCh.key, dataCh.key]);
+      const hasChanged = await adapter.update([timeCh.name, dataCh.name]);
+      expect(hasChanged).toBe(false);
+    });
+  });
+});
+
+describe("ReadAdapter", () => {
+  let timeCh: channel.Channel;
+  let dataCh: channel.Channel;
+  let adapter: ReadAdapter;
+
+  beforeAll(async () => {
+    timeCh = await client.channels.create({
+      name: `read-time-${Math.random()}-${TimeStamp.now().toString()}`,
+      dataType: DataType.TIMESTAMP,
+      isIndex: true,
+    });
+    dataCh = await client.channels.create({
+      name: `read-data-${Math.random()}-${TimeStamp.now().toString()}`,
+      dataType: DataType.FLOAT32,
+      index: timeCh.key,
+    });
+
+    adapter = await ReadAdapter.open(client.channels.retriever, [
+      timeCh.key,
+      dataCh.key,
+    ]);
+  });
+
+  describe("update", () => {
+    it("should return false when updating with the same channels", async () => {
+      const hasChanged = await adapter.update([timeCh.key, dataCh.key]);
+      expect(hasChanged).toBe(false);
+    });
+
+    it("should return true when adding a new channel", async () => {
+      const newCh = await client.channels.create({
+        name: `read-new-${Math.random()}-${TimeStamp.now().toString()}`,
+        dataType: DataType.FLOAT32,
+        index: timeCh.key,
+      });
+      const hasChanged = await adapter.update([timeCh.key, dataCh.key, newCh.key]);
+      expect(hasChanged).toBe(true);
+    });
+
+    it("should return true when removing a channel", async () => {
+      const hasChanged = await adapter.update([timeCh.key]);
+      expect(hasChanged).toBe(true);
+    });
+
+    it("should return true when replacing channels", async () => {
+      const newCh = await client.channels.create({
+        name: `read-replacement-${Math.random()}-${TimeStamp.now().toString()}`,
+        dataType: DataType.FLOAT32,
+        index: timeCh.key,
       });
-      expect(res).toHaveProperty(timeCh.key.toString());
-      expect(res).toHaveProperty(dataCh.key.toString());
+      const hasChanged = await adapter.update([timeCh.key, newCh.key]);
+      expect(hasChanged).toBe(true);
+    });
+
+    it("should return false when updating with same channels in different order", async () => {
+      await adapter.update([timeCh.key, dataCh.key]);
+      const hasChanged = await adapter.update([dataCh.key, timeCh.key]);
+      expect(hasChanged).toBe(false);
+    });
+
+    it("should return false when updating with channel names that resolve to same keys", async () => {
+      await adapter.update([timeCh.key, dataCh.key]);
+      const hasChanged = await adapter.update([timeCh.name, dataCh.name]);
+      expect(hasChanged).toBe(false);
     });
   });
 });

package/src/framer/adapter.ts

@@ -7,6 +7,7 @@
 // License, use of this software will be governed by the Apache License, Version 2.0,
 // included in the file licenses/APL.txt.
 
+import { compare } from "@synnaxlabs/x";
 import { type CrudeSeries, Series } from "@synnaxlabs/x/telem";
 
 import { channel } from "@/channel";
@@ -36,17 +37,20 @@ export class ReadAdapter {
     return adapter;
   }
 
-  async update(channels: channel.Params): Promise<void> {
+  async update(channels: channel.Params): Promise<boolean> {
     const { variant, normalized } = channel.analyzeParams(channels);
     const fetched = await this.retriever.retrieve(normalized);
+    const newKeys = fetched.map((c) => c.key);
+    if (compare.uniqueUnorderedPrimitiveArrays(this.keys, newKeys) === compare.EQUAL)
+      return false;
     this.codec.update(
-      fetched.map((c) => c.key),
+      newKeys,
       fetched.map((c) => c.dataType),
     );
     if (variant === "keys") {
       this.adapter = null;
       this.keys = normalized as channel.Key[];
-      return;
+      return true;
     }
     const a = new Map<channel.Key, channel.Name>();
     this.adapter = a;
@@ -56,6 +60,7 @@ export class ReadAdapter {
       a.set(channel.key, channel.name);
     });
     this.keys = Array.from(this.adapter.keys());
+    return true;
   }
 
   adapt(columnsOrData: Frame): Frame {
@@ -94,24 +99,32 @@ export class WriteAdapter {
     return adapter;
   }
 
-  async adaptObjectKeys<V>(
-    data: Record<channel.KeyOrName, V>,
-  ): Promise<Record<channel.Key, V>> {
-    const out: Record<channel.Key, V> = {};
-    for (const [k, v] of Object.entries(data)) out[await this.adaptToKey(k)] = v;
-    return out;
+  async adaptParams(data: channel.Params): Promise<channel.Keys> {
+    const arrParams = channel.paramsZ.parse(data);
+    const keys = await Promise.all(
+      arrParams.map(async (p) => await this.adaptToKey(p)),
+    );
+    return keys;
   }
 
-  async update(channels: channel.Params): Promise<void> {
+  async update(channels: channel.Params): Promise<boolean> {
     const results = await channel.retrieveRequired(this.retriever, channels);
+    const newKeys = results.map((c) => c.key);
+    const previousKeySet = new Set(this.keys);
+    const newKeySet = new Set(newKeys);
+    const hasAddedKeys = !newKeySet.isSubsetOf(previousKeySet);
+    const hasRemovedKeys = !previousKeySet.isSubsetOf(newKeySet);
+    const hasChanged = hasAddedKeys || hasRemovedKeys;
+    if (!hasChanged) return false;
     this.adapter = new Map<channel.Name, channel.Key>(
       results.map((c) => [c.name, c.key]),
     );
-    this.keys = results.map((c) => c.key);
+    this.keys = newKeys;
     this.codec.update(
       this.keys,
       results.map((c) => c.dataType),
     );
+    return true;
   }
 
   private async fetchChannel(

package/src/framer/client.spec.ts

@@ -10,9 +10,9 @@
 import { TimeSpan, TimeStamp } from "@synnaxlabs/x";
 import { describe, expect, it } from "vitest";
 
-import { newClient } from "@/setupspecs";
+import { newTestClient } from "@/testutil/client";
 
-const client = newClient();
+const client = newTestClient();
 
 describe("Client", () => {
   describe("read + write", () => {
@@ -60,4 +60,127 @@ describe("Client", () => {
       expect(group.name).toEqual("Channels");
     });
   });
+  describe("readLatestN", () => {
+    it("should correctly read the latest N samples from a single channel", async () => {
+      const rand = `${TimeStamp.now().toString()}${Math.random()}`;
+      const time = await client.channels.create({
+        name: `time-${rand}`,
+        dataType: "timestamp",
+        isIndex: true,
+      });
+      const data = await client.channels.create({
+        name: `data-${rand}`,
+        dataType: "float32",
+        index: time.key,
+      });
+      const start = TimeStamp.now();
+      const timeData = [
+        start,
+        start.add(TimeSpan.seconds(1)),
+        start.add(TimeSpan.seconds(2)),
+        start.add(TimeSpan.seconds(3)),
+        start.add(TimeSpan.seconds(4)),
+        start.add(TimeSpan.seconds(5)),
+        start.add(TimeSpan.seconds(6)),
+        start.add(TimeSpan.seconds(7)),
+        start.add(TimeSpan.seconds(8)),
+        start.add(TimeSpan.seconds(9)),
+      ];
+      const dataValues = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+      await client.write(start, { [time.key]: timeData, [data.key]: dataValues });
+
+      const result = await client.readLatest(data.key, 3);
+      expect(Array.from(result)).toEqual([8, 9, 10]);
+    });
+
+    it("should correctly read the latest N samples from multiple channels", async () => {
+      const rand = `${TimeStamp.now().toString()}${Math.random()}`;
+      const time = await client.channels.create({
+        name: `time-${rand}`,
+        dataType: "timestamp",
+        isIndex: true,
+      });
+      const data1 = await client.channels.create({
+        name: `data1-${rand}`,
+        dataType: "float32",
+        index: time.key,
+      });
+      const data2 = await client.channels.create({
+        name: `data2-${rand}`,
+        dataType: "float32",
+        index: time.key,
+      });
+      const start = TimeStamp.now();
+      const timeData = [
+        start,
+        start.add(TimeSpan.seconds(1)),
+        start.add(TimeSpan.seconds(2)),
+        start.add(TimeSpan.seconds(3)),
+        start.add(TimeSpan.seconds(4)),
+        start.add(TimeSpan.seconds(5)),
+        start.add(TimeSpan.seconds(6)),
+        start.add(TimeSpan.seconds(7)),
+        start.add(TimeSpan.seconds(8)),
+        start.add(TimeSpan.seconds(9)),
+      ];
+      const data1Values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+      const data2Values = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
+      await client.write(start, {
+        [time.key]: timeData,
+        [data1.key]: data1Values,
+        [data2.key]: data2Values,
+      });
+
+      const frame = await client.readLatest([time.key, data1.key, data2.key], 3);
+      expect(Array.from(frame.get(data1.key))).toEqual([8, 9, 10]);
+      expect(Array.from(frame.get(data2.key))).toEqual([80, 90, 100]);
+      expect(Array.from(frame.get(time.key))).toEqual([
+        timeData[7].valueOf(),
+        timeData[8].valueOf(),
+        timeData[9].valueOf(),
+      ]);
+    });
+
+    it("should return empty series when no data exists", async () => {
+      const rand = `${TimeStamp.now().toString()}${Math.random()}`;
+      const time = await client.channels.create({
+        name: `time-${rand}`,
+        dataType: "timestamp",
+        isIndex: true,
+      });
+      const data = await client.channels.create({
+        name: `data-${rand}`,
+        dataType: "float32",
+        index: time.key,
+      });
+
+      const result = await client.readLatest(data.key, 5);
+      expect(Array.from(result)).toEqual([]);
+    });
+
+    it("should correctly handle N larger than available data", async () => {
+      const rand = `${TimeStamp.now().toString()}${Math.random()}`;
+      const time = await client.channels.create({
+        name: `time-${rand}`,
+        dataType: "timestamp",
+        isIndex: true,
+      });
+      const data = await client.channels.create({
+        name: `data-${rand}`,
+        dataType: "float32",
+        index: time.key,
+      });
+      const start = TimeStamp.now();
+      const timeData = [
+        start,
+        start.add(TimeSpan.seconds(1)),
+        start.add(TimeSpan.seconds(2)),
+      ];
+      const dataValues = [1, 2, 3];
+      await client.write(start, { [time.key]: timeData, [data.key]: dataValues });
+
+      const result = await client.readLatest(data.key, 10);
+      expect(Array.from(result)).toEqual([1, 2, 3]);
+    });
+  });
 });

package/src/framer/client.ts

@@ -13,32 +13,22 @@ import {
   type CrudeTimeRange,
   type CrudeTimeStamp,
   type MultiSeries,
-  type TimeRange,
+  TimeRange,
   TimeSpan,
 } from "@synnaxlabs/x";
 
 import { channel } from "@/channel";
 import { Deleter } from "@/framer/deleter";
-import { Frame, ONTOLOGY_TYPE } from "@/framer/frame";
-import { Iterator, type IteratorConfig } from "@/framer/iterator";
+import { Frame } from "@/framer/frame";
+import { AUTO_SPAN, Iterator, type IteratorConfig } from "@/framer/iterator";
 import { openStreamer, type Streamer, type StreamerConfig } from "@/framer/streamer";
 import { Writer, type WriterConfig, WriterMode } from "@/framer/writer";
-import { ontology } from "@/ontology";
-
-export const ontologyID = (key: channel.Key): ontology.ID =>
-  new ontology.ID({ type: ONTOLOGY_TYPE, key: key.toString() });
-
-const normalizeConfig = <T extends { channels: channel.Params }>(
-  config: T | channel.Params,
-): T => {
-  if (
-    Array.isArray(config) ||
-    typeof config !== "object" ||
-    (typeof config === "object" && "key" in config)
-  )
-    return { channels: config } as T;
-  return config;
-};
+import { type ontology } from "@/ontology";
+
+export const ontologyID = (key: channel.Key): ontology.ID => ({
+  type: "framer",
+  key: key.toString(),
+});
 
 export class Client {
   private readonly streamClient: WebSocketClient;
@@ -78,25 +68,10 @@ export class Client {
    * writerConfig for more detail.
    * @returns a new {@link Writer}.
    */
-  async openWriter(config: WriterConfig | channel.Params): Promise<Writer> {
-    return await Writer._open(
-      this.retriever,
-      this.streamClient,
-      normalizeConfig<WriterConfig>(config),
-    );
+  async openWriter(config: WriterConfig): Promise<Writer> {
+    return await Writer._open(this.retriever, this.streamClient, config);
   }
 
-  /***
-   * Opens a new streamer on the given channels.
-   *
-   * @param channels - A key, name, list of keys, or list of names of the channels to
-   * stream values from.
-   * @throws a QueryError if any of the given channels do not exist.
-   * @returns a new {@link Streamer} that must be closed when done streaming, otherwise
-   * a network socket will remain open.
-   */
-  async openStreamer(channels: channel.Params): Promise<Streamer>;
-
   /**
    * Opens a new streamer with the provided configuration.
    *
@@ -108,17 +83,8 @@ export class Client {
    * and then will start reading new values.
    *
    */
-  async openStreamer(config: StreamerConfig): Promise<Streamer>;
-
-  /** Overload to provide interface compatibility with @see StreamOpener */
-  async openStreamer(config: StreamerConfig | channel.Params): Promise<Streamer>;
-
-  async openStreamer(config: StreamerConfig | channel.Params): Promise<Streamer> {
-    return await openStreamer(
-      this.retriever,
-      this.streamClient,
-      normalizeConfig<StreamerConfig>(config),
-    );
+  async openStreamer(config: StreamerConfig): Promise<Streamer> {
+    return await openStreamer(this.retriever, this.streamClient, config);
   }
 
   async write(
@@ -205,6 +171,34 @@ export class Client {
     return frame;
   }
 
+  async readLatest(channel: channel.KeyOrName, n: number): Promise<MultiSeries>;
+
+  async readLatest(channels: channel.Params, n: number): Promise<Frame>;
+
+  async readLatest(
+    channels: channel.Params,
+    n: number = 1,
+  ): Promise<MultiSeries | Frame> {
+    const { single } = channel.analyzeParams(channels);
+    const fr = await this.readLatestNFrame(channels, n);
+    if (single) return fr.get(channels as channel.KeyOrName);
+    return fr;
+  }
+
+  private async readLatestNFrame(channels: channel.Params, n: number): Promise<Frame> {
+    const i = await this.openIterator(TimeRange.MAX, channels, { chunkSize: n });
+    const frame = new Frame();
+    if (n > 0)
+      try {
+        await i.seekLast();
+        await i.prev(AUTO_SPAN);
+        frame.push(i.value);
+      } finally {
+        await i.close();
+      }
+    return frame;
+  }
+
   async delete(channels: channel.Params, timeRange: TimeRange): Promise<void> {
     const { normalized, variant } = channel.analyzeParams(channels);
     if (variant === "keys")

package/src/framer/codec.ts

@@ -15,7 +15,7 @@ import {
   TimeRange,
   TimeStamp,
 } from "@synnaxlabs/x";
-import { type z } from "zod/v4";
+import { type z } from "zod";
 
 import { type channel } from "@/channel";
 import { ValidationError } from "@/errors";

package/src/framer/deleter.spec.ts

@@ -11,12 +11,12 @@ import { TimeRange, TimeStamp } from "@synnaxlabs/x/telem";
 import { describe, expect, test } from "vitest";
 
 import { NotFoundError, UnauthorizedError } from "@/errors";
-import { newClient } from "@/setupspecs";
 import { newIndexedPair } from "@/testutil/channels";
+import { newTestClient } from "@/testutil/client";
 import { secondsLinspace } from "@/testutil/telem";
 import { randomSeries } from "@/util/telem";
 
-const client = newClient();
+const client = newTestClient();
 
 describe("Deleter", () => {
   test("Client - basic delete", async () => {

package/src/framer/deleter.ts

@@ -9,7 +9,7 @@
 
 import { sendRequired, type UnaryClient } from "@synnaxlabs/freighter";
 import { TimeRange } from "@synnaxlabs/x";
-import { z } from "zod/v4";
+import { z } from "zod";
 
 import { channel } from "@/channel";
 

package/src/framer/frame.ts

@@ -18,14 +18,11 @@ import {
   TimeRange,
   TimeStamp,
 } from "@synnaxlabs/x/telem";
-import { z } from "zod/v4";
+import { z } from "zod";
 
 import { type channel } from "@/channel";
 import { UnexpectedError, ValidationError } from "@/errors";
 
-export const ONTOLOGY_TYPE = "framer";
-export type OntologyType = typeof ONTOLOGY_TYPE;
-
 type ColumnType = "key" | "name" | null;
 
 export interface Digest extends Record<channel.KeyOrName, SeriesDigest[]> {}

package/src/framer/iterator.spec.ts

@@ -11,12 +11,12 @@ import { TimeRange, TimeSpan, TimeStamp } from "@synnaxlabs/x/telem";
 import { describe, expect, test } from "vitest";
 
 import { AUTO_SPAN } from "@/framer/iterator";
-import { newClient } from "@/setupspecs";
 import { newIndexedPair } from "@/testutil/channels";
+import { newTestClient } from "@/testutil/client";
 import { secondsLinspace } from "@/testutil/telem";
 import { randomSeries } from "@/util/telem";
 
-const client = newClient();
+const client = newTestClient();
 
 describe("Iterator", () => {
   test("happy path", async () => {
@@ -50,7 +50,7 @@ describe("Iterator", () => {
     );
 
     try {
-      expect(await iter.seekFirst()).toBeTruthy();
+      expect(await iter.seekFirst()).toBe(true);
       let c = 0;
       while (await iter.next(TimeSpan.seconds(1))) {
         c++;
@@ -78,24 +78,24 @@ describe("Iterator", () => {
     const iter = await client.openIterator(TimeRange.MAX, channels, { chunkSize: 4 });
 
     try {
-      expect(await iter.seekFirst()).toBeTruthy();
+      expect(await iter.seekFirst()).toBe(true);
 
-      expect(await iter.next(AUTO_SPAN)).toBeTruthy();
+      expect(await iter.next(AUTO_SPAN)).toBe(true);
       expect(iter.value.get(idx_ch.key).data).toEqual(
         new BigInt64Array(secondsLinspace(1, 4).map((v) => v.valueOf())),
       );
 
-      expect(await iter.next(AUTO_SPAN)).toBeTruthy();
+      expect(await iter.next(AUTO_SPAN)).toBe(true);
       expect(iter.value.get(idx_ch.key).data).toEqual(
         new BigInt64Array(secondsLinspace(5, 4).map((v) => v.valueOf())),
       );
 
-      expect(await iter.next(AUTO_SPAN)).toBeTruthy();
+      expect(await iter.next(AUTO_SPAN)).toBe(true);
       expect(iter.value.get(idx_ch.key).data).toEqual(
         new BigInt64Array(secondsLinspace(9, 2).map((v) => v.valueOf())),
       );
 
-      expect(await iter.next(AUTO_SPAN)).toBeFalsy();
+      expect(await iter.next(AUTO_SPAN)).toBe(false);
     } finally {
       await iter.close();
     }