@synnaxlabs/client 0.56.1 → 0.57.0

package/src/framer/client.spec.ts

@@ -1,180 +0,0 @@
-// 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, TimeSpan, TimeStamp } from "@synnaxlabs/x";
-import { describe, expect, it } from "vitest";
-
-import { createTestClient } from "@/testutil/client";
-
-const client = createTestClient();
-
-describe("Client", () => {
-  describe("read + write", () => {
-    it("should correctly write and read a frame of data", async () => {
-      const time = await client.channels.create({
-        name: id.create(),
-        dataType: "timestamp",
-        isIndex: true,
-      });
-      const data = await client.channels.create({
-        name: id.create(),
-        dataType: "float32",
-        index: time.key,
-      });
-      const start = TimeStamp.now();
-      await client.write(start, { [time.key]: [start], [data.key]: [1] });
-      const frame = await client.read({ start, end: start.add(TimeSpan.seconds(1)) }, [
-        time.key,
-        data.key,
-      ]);
-      expect(Array.from(frame.get(time.key))).toEqual([start.valueOf()]);
-      expect(Array.from(frame.get(data.key))).toEqual([1]);
-    });
-    it("should correctly write a single series of data", async () => {
-      const time = await client.channels.create({
-        name: id.create(),
-        dataType: "timestamp",
-        isIndex: true,
-      });
-      const data = await client.channels.create({
-        name: id.create(),
-        dataType: "float32",
-        index: time.key,
-      });
-      const start = TimeStamp.now();
-      await client.write(start, time.key, TimeStamp.now());
-      await client.write(start, data.key, 1);
-    });
-  });
-  describe("retrieveGroup", () => {
-    it("should correctly retrieve the main channel group", async () => {
-      const group = await client.channels.retrieveGroup();
-      expect(group.name).toEqual("Channels");
-    });
-  });
-  describe("readLatestN", () => {
-    it("should correctly read the latest N samples from a single channel", async () => {
-      const time = await client.channels.create({
-        name: id.create(),
-        dataType: "timestamp",
-        isIndex: true,
-      });
-      const data = await client.channels.create({
-        name: id.create(),
-        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 time = await client.channels.create({
-        name: id.create(),
-        dataType: "timestamp",
-        isIndex: true,
-      });
-      const data1 = await client.channels.create({
-        name: id.create(),
-        dataType: "float32",
-        index: time.key,
-      });
-      const data2 = await client.channels.create({
-        name: id.create(),
-        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 time = await client.channels.create({
-        name: id.create(),
-        dataType: "timestamp",
-        isIndex: true,
-      });
-      const data = await client.channels.create({
-        name: id.create(),
-        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 time = await client.channels.create({
-        name: id.create(),
-        dataType: "timestamp",
-        isIndex: true,
-      });
-      const data = await client.channels.create({
-        name: id.create(),
-        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/codec.spec.ts

@@ -1,383 +0,0 @@
-// 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 { type WebsocketMessage } from "@synnaxlabs/freighter";
-import { DataType, Series, TimeStamp } from "@synnaxlabs/x";
-import { describe, expect, it } from "vitest";
-
-import { type channel } from "@/channel";
-import { ValidationError } from "@/errors";
-import { framer } from "@/framer";
-import {
-  Codec,
-  HIGH_PERF_SPECIAL_CHAR,
-  LOW_PERF_SPECIAL_CHAR,
-  WSIteratorCodec,
-  WSWriterCodec,
-} from "@/framer/codec";
-import { Frame } from "@/framer/frame";
-import { type IteratorResponse } from "@/framer/iterator";
-import { IteratorResponseVariant, WriterCommand } from "@/framer/types.gen";
-import { type WriteRequest } from "@/framer/writer";
-
-describe("encoder", () => {
-  describe("base codec", () => {
-    interface Spec {
-      name: string;
-      channels: channel.Key[];
-      dataTypes: DataType[];
-      frame: framer.Frame;
-    }
-
-    const SPECS: Spec[] = [
-      {
-        name: "All Channels Present, In Order",
-        channels: [1, 2, 3],
-        dataTypes: [DataType.INT64, DataType.FLOAT32, DataType.FLOAT64],
-        frame: new framer.Frame(
-          [1, 2, 3],
-          [
-            new Series(new BigInt64Array([1n, 2n, 3n])),
-            new Series(new Float32Array([4, 5, 6])),
-            new Series(new Float64Array([7, 8, 9])),
-          ],
-        ),
-      },
-      {
-        name: "All Channels Present, Out of Order",
-        channels: [3, 1, 2],
-        dataTypes: [DataType.FLOAT64, DataType.INT64, DataType.FLOAT32],
-        frame: new framer.Frame(
-          [2, 3, 1],
-          [
-            new Series(new Float32Array([4, 5, 6])),
-            new Series(new Float64Array([7, 8, 9])),
-            new Series(new BigInt64Array([1n, 2n, 3n])),
-          ],
-        ),
-      },
-      {
-        name: "Some Channels Present, In Order",
-        channels: [1, 2, 3],
-        dataTypes: [DataType.UINT8, DataType.FLOAT32, DataType.FLOAT64],
-        frame: new framer.Frame(
-          [1, 3],
-          [
-            new Series(new Uint8Array([1, 2, 3])),
-            new Series(new Float64Array([7, 8, 9])),
-          ],
-        ),
-      },
-      {
-        name: "Some Channels Present, Out of Order",
-        channels: [1, 2, 3],
-        dataTypes: [DataType.UINT8, DataType.FLOAT32, DataType.FLOAT64],
-        frame: new framer.Frame(
-          [3, 1],
-          [
-            new Series(new Float64Array([7, 8, 9])),
-            new Series(new Uint8Array([1, 2, 3])),
-          ],
-        ),
-      },
-      {
-        name: "Only One Channel Present",
-        channels: [1, 2, 3, 4, 5],
-        dataTypes: [
-          DataType.UINT8,
-          DataType.UINT8,
-          DataType.UINT8,
-          DataType.UINT8,
-          DataType.UINT8,
-        ],
-        frame: new framer.Frame([3], [new Series(new Uint8Array([1, 2, 3, 4, 5]))]),
-      },
-      {
-        name: "All Same Time Range",
-        channels: [1, 2],
-        dataTypes: [DataType.UINT8, DataType.FLOAT32],
-        frame: new framer.Frame(
-          [1, 2],
-          [
-            new Series({
-              dataType: DataType.UINT8,
-              data: new Uint8Array([1]),
-              timeRange: new TimeStamp(0).spanRange(5),
-            }),
-            new Series({
-              dataType: DataType.FLOAT32,
-              data: new Float32Array([1, 2, 3, 4]),
-              timeRange: new TimeStamp(0).spanRange(5),
-            }),
-          ],
-        ),
-      },
-      {
-        name: "All Same Non-Zero Time Range",
-        channels: [1, 2],
-        dataTypes: [DataType.UINT8, DataType.FLOAT32],
-        frame: new framer.Frame(
-          [1, 2],
-          [
-            new Series({
-              dataType: DataType.UINT8,
-              data: new Uint8Array([1]),
-              timeRange: new TimeStamp(1000000000).spanRange(5000000000),
-            }),
-            new Series({
-              dataType: DataType.FLOAT32,
-              data: new Float32Array([1, 2, 3, 4]),
-              timeRange: new TimeStamp(1000000000).spanRange(5000000000),
-            }),
-          ],
-        ),
-      },
-      {
-        name: "Different Non-Zero Time Ranges",
-        channels: [1, 2],
-        dataTypes: [DataType.UINT8, DataType.FLOAT32],
-        frame: new framer.Frame(
-          [1, 2],
-          [
-            new Series({
-              dataType: DataType.UINT8,
-              data: new Uint8Array([1]),
-              timeRange: new TimeStamp(1000000000).spanRange(5000000000),
-            }),
-            new Series({
-              dataType: DataType.FLOAT32,
-              data: new Float32Array([1, 2, 3, 4]),
-              timeRange: new TimeStamp(2000000000).spanRange(3000000000),
-            }),
-          ],
-        ),
-      },
-      {
-        name: "Partial Present, Different Lengths",
-        channels: [1, 2, 3],
-        dataTypes: [DataType.UINT8, DataType.FLOAT32, DataType.FLOAT64],
-        frame: new framer.Frame(
-          [1, 3],
-          [new Series(new Uint8Array([1])), new Series(new Float64Array([1, 2, 3, 4]))],
-        ),
-      },
-      {
-        name: "Same Alignments",
-        channels: [1, 2],
-        dataTypes: [DataType.UINT8, DataType.FLOAT32],
-        frame: new framer.Frame(
-          [1, 2],
-          [
-            new Series({
-              dataType: DataType.UINT8,
-              data: new Uint8Array([1]),
-              alignment: 5n,
-            }),
-            new Series({
-              dataType: DataType.FLOAT32,
-              data: new Uint8Array([1, 2, 3, 4]),
-              alignment: 5n,
-            }),
-          ],
-        ),
-      },
-      {
-        name: "Different Alignments",
-        channels: [1, 2],
-        dataTypes: [DataType.UINT8, DataType.FLOAT32],
-        frame: new Frame(
-          [1, 2],
-          [
-            new Series({
-              dataType: DataType.UINT8,
-              data: new Uint8Array([1]),
-              alignment: 5n,
-            }),
-            new Series({
-              dataType: DataType.FLOAT32,
-              data: new Uint8Array([1, 2, 3, 4]),
-              alignment: 10n,
-            }),
-          ],
-        ),
-      },
-      {
-        name: "Variable Data Types",
-        channels: [1, 2, 3],
-        dataTypes: [DataType.UINT8, DataType.STRING, DataType.JSON],
-        frame: new framer.Frame(
-          [1, 2, 3],
-          [
-            new Series(new Uint8Array([1])),
-            new Series({
-              data: ["one", "two", "three"],
-              dataType: DataType.STRING,
-            }),
-            new Series({
-              data: [{ a: 1 }, { b: 2 }, { c: 3 }],
-              dataType: DataType.JSON,
-            }),
-          ],
-        ),
-      },
-    ];
-
-    SPECS.forEach((spec) => {
-      it(`should encode & decode ${spec.name}`, () => {
-        const codec = new Codec(spec.channels, spec.dataTypes);
-        const encoded = codec.encode(spec.frame.toPayload());
-        const decoded = codec.decode(encoded);
-        decoded.keys.forEach((k, i) => {
-          const dcs = decoded.series[i];
-          const ser = spec.frame.get(k);
-          expect(ser.series.length).toBeGreaterThan(0);
-          const os = ser.series[0];
-          if (dcs.timeRange != null && !dcs.timeRange.span.isZero)
-            expect(dcs.timeRange.toString()).toEqual(os.timeRange?.toString());
-          expect(new Series(dcs).toString()).toEqual(os.toString());
-        });
-      });
-    });
-  });
-
-  describe("dynamic codec", () => {
-    it("should allow the caller to update the codec", () => {
-      const codec = new Codec();
-      codec.update([1], [DataType.INT32]);
-      const encoded = codec.encode(
-        new framer.Frame([1], [new Series(new Int32Array([1, 2, 3]))]),
-      );
-      const decoded1 = new Frame(codec.decode(encoded));
-      expect(Array.from(decoded1.series[0])).toEqual([1, 2, 3]);
-      expect(decoded1.keys[0]).toEqual(1);
-      codec.update([2], [DataType.INT64]);
-      const encoded2 = codec.encode(
-        new framer.Frame([2], [new Series(new BigInt64Array([1n, 2n, 3n]))]),
-      );
-      const decoded2 = new Frame(codec.decode(encoded2));
-      expect(Array.from(decoded2.series[0])).toEqual([1n, 2n, 3n]);
-      expect(decoded2.keys[0]).toEqual(2);
-    });
-
-    it("should throw an error if the codec is not initialized", () => {
-      const codec = new Codec();
-      expect(() =>
-        codec.encode(new framer.Frame([1], [new Series(new Int32Array([1, 2, 3]))])),
-      ).toThrow(ValidationError);
-    });
-
-    it("should use the correct encode/decode state even if the codecs are out of sync", () => {
-      const encoder = new Codec();
-      const decoder = new Codec();
-      encoder.update([1], [DataType.INT32]);
-      decoder.update([1], [DataType.INT32]);
-
-      const fr = new framer.Frame([1], [new Series(new Int32Array([1, 2, 3]))]);
-      let encoded = encoder.encode(fr);
-      let decoded = new Frame(decoder.decode(encoded));
-      expect(decoded.keys[0]).toEqual(1);
-      expect(decoded.series[0].data).toEqual(fr.series[0].data);
-
-      decoder.update([2], [DataType.INT64]);
-      encoded = encoder.encode(fr);
-      decoded = new Frame(decoder.decode(encoded));
-      expect(decoded.keys[0]).toEqual(1);
-      expect(decoded.series[0].data).toEqual(fr.series[0].data);
-
-      encoder.update([2], [DataType.INT64]);
-      expect(() => encoder.encode(fr)).toThrow(ValidationError);
-      const fr2 = new framer.Frame([2], [new Series(new BigInt64Array([1n, 2n, 3n]))]);
-      encoded = encoder.encode(fr2);
-      decoded = new Frame(decoder.decode(encoded));
-      expect(decoded.keys[0]).toEqual(2);
-      expect(decoded.series[0].data).toEqual(fr2.series[0].data);
-    });
-  });
-
-  describe("websocket writer codec", () => {
-    it("should correctly encode and decode a websocket write request", () => {
-      const baseCodec = new Codec([1], [DataType.INT32]);
-      const fr = new framer.Frame([1], [new Series(new Int32Array([1, 2, 3]))]);
-      const writeReq: WriteRequest = {
-        command: WriterCommand.Write,
-        frame: fr.toPayload(),
-      };
-      const msg: WebsocketMessage<WriteRequest> = { type: "data", payload: writeReq };
-      const codec = new WSWriterCodec(baseCodec);
-      const encoded = codec.encode(msg);
-      expect(encoded[0]).toEqual(HIGH_PERF_SPECIAL_CHAR);
-      const decoded = codec.decode(encoded) as WebsocketMessage<WriteRequest>;
-      expect(decoded.payload?.command).toEqual(WriterCommand.Write);
-      const decodedFr = new Frame(decoded.payload?.frame);
-      expect(decodedFr.series[0].data).toEqual(fr.series[0].data);
-    });
-
-    it("should correctly e +d a WS write set authority request", () => {
-      const baseCodec = new Codec([1], [DataType.INT32]);
-      const writeReq: WriteRequest = {
-        command: WriterCommand.SetAuthority,
-        config: { authorities: [123] },
-      };
-      const codec = new WSWriterCodec(baseCodec);
-      const msg: WebsocketMessage<WriteRequest> = { type: "data", payload: writeReq };
-      const encoded = codec.encode(msg);
-      expect(encoded[0]).toEqual(LOW_PERF_SPECIAL_CHAR);
-      const decoded = codec.decode(encoded);
-      expect(decoded).toEqual(msg);
-    });
-  });
-
-  describe("websocket iterator codec", () => {
-    it("should JSON-encode an iterator request without a special char prefix", () => {
-      const baseCodec = new Codec([1], [DataType.INT32]);
-      const codec = new WSIteratorCodec(baseCodec);
-      const msg: WebsocketMessage<unknown> = {
-        type: "data",
-        payload: { command: 1, span: 0 },
-      };
-      const encoded = codec.encode(msg);
-      // Iterator requests are sent as raw JSON; no special-char prefix.
-      // Confirm the first byte is JSON ('{' or '[').
-      expect([0x7b, 0x5b]).toContain(encoded[0]);
-    });
-
-    it("should binary-decode a data variant response and synthesize variant=Data", () => {
-      const baseCodec = new Codec([1], [DataType.INT32]);
-      const fr = new framer.Frame([1], [new Series(new Int32Array([1, 2, 3]))]);
-      const codec = new WSIteratorCodec(baseCodec);
-      const encoded = new Uint8Array(baseCodec.encode(fr.toPayload(), 1));
-      encoded[0] = HIGH_PERF_SPECIAL_CHAR;
-      const decoded = codec.decode(encoded) as WebsocketMessage<IteratorResponse>;
-      expect(decoded.payload?.variant).toEqual(IteratorResponseVariant.Data);
-      const decodedFr = new Frame(decoded.payload?.frame);
-      expect(decodedFr.series[0].data).toEqual(fr.series[0].data);
-    });
-
-    it("should JSON-decode an ack variant response prefixed with the low-perf char", () => {
-      const baseCodec = new Codec([1], [DataType.INT32]);
-      const codec = new WSIteratorCodec(baseCodec);
-      const ackMsg: WebsocketMessage<IteratorResponse> = {
-        type: "data",
-        payload: {
-          variant: IteratorResponseVariant.Ack,
-          ack: true,
-          command: 1,
-        },
-      };
-      // Simulate what the server sends: LOW_PERF_SPECIAL_CHAR + JSON-encoded message.
-      const json = new TextEncoder().encode(JSON.stringify(ackMsg));
-      const encoded = new Uint8Array(json.byteLength + 1);
-      encoded[0] = LOW_PERF_SPECIAL_CHAR;
-      encoded.set(json, 1);
-      const decoded = codec.decode(encoded) as WebsocketMessage<IteratorResponse>;
-      expect(decoded.payload?.variant).toEqual(IteratorResponseVariant.Ack);
-      expect(decoded.payload?.ack).toEqual(true);
-    });
-  });
-});

package/src/framer/deleter.spec.ts

@@ -1,103 +0,0 @@
-// 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 { TimeRange, TimeStamp } from "@synnaxlabs/x";
-import { describe, expect, test } from "vitest";
-
-import { NotFoundError, UnauthorizedError } from "@/errors";
-import { newIndexedPair } from "@/testutil/channels";
-import { createTestClient } from "@/testutil/client";
-import { secondsLinspace } from "@/testutil/telem";
-import { randomSeries } from "@/util/telem";
-
-const client = createTestClient();
-
-describe("Deleter", () => {
-  test("Client - basic delete", async () => {
-    const [indexCh, dataCh] = await newIndexedPair(client);
-    const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    await client.write(TimeStamp.seconds(5), {
-      [indexCh.key]: secondsLinspace(5, 10),
-      [dataCh.key]: data,
-    });
-    const res = await client.read(TimeRange.MAX, dataCh.key);
-    expect(res.data.length).toEqual(10);
-    await client.delete(dataCh.key, TimeStamp.seconds(5).range(TimeStamp.seconds(7)));
-
-    const deletedRes = await client.read(TimeRange.MAX, dataCh.key);
-    expect(deletedRes.data.length).toEqual(8);
-    expect(Array.from(deletedRes)).toEqual([3, 4, 5, 6, 7, 8, 9, 10]);
-  });
-  test("Client - basic delete by name", async () => {
-    const [indexCh, dataCh] = await newIndexedPair(client);
-    const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    await client.write(TimeStamp.seconds(5), {
-      [indexCh.key]: secondsLinspace(5, 10),
-      [dataCh.key]: data,
-    });
-    const res = await client.read(TimeRange.MAX, dataCh.key);
-    expect(res.data.length).toEqual(10);
-    await client.delete(dataCh.name, TimeStamp.seconds(5).range(TimeStamp.seconds(7)));
-
-    const deletedRes = await client.read(TimeRange.MAX, dataCh.key);
-    expect(deletedRes.data.length).toEqual(8);
-    expect(Array.from(deletedRes)).toEqual([3, 4, 5, 6, 7, 8, 9, 10]);
-  });
-  test("Client - delete key not found", async () => {
-    const [indexCh, dataCh] = await newIndexedPair(client);
-    const data = randomSeries(10, dataCh.dataType);
-    await client.write(TimeStamp.seconds(0), {
-      [indexCh.key]: secondsLinspace(0, 10),
-      [dataCh.key]: data,
-    });
-
-    await expect(client.delete([indexCh.key, 1232], TimeRange.MAX)).rejects.toThrow(
-      NotFoundError,
-    );
-
-    const res = await client.read(TimeRange.MAX, dataCh.key);
-    expect(res.data).toEqual(data);
-  });
-
-  test("Client - delete with writer", async () => {
-    const [indexCh] = await newIndexedPair(client);
-
-    const writer = await client.openWriter({
-      start: TimeStamp.seconds(10),
-      channels: [indexCh.key],
-    });
-
-    await expect(
-      client.delete([indexCh.key], TimeStamp.seconds(12).range(TimeStamp.seconds(30))),
-    ).rejects.toThrow(UnauthorizedError);
-
-    await writer.close();
-  });
-
-  test("Client - delete index channel alone", async () => {
-    const [indexCh, dataCh] = await newIndexedPair(client);
-    const index = indexCh;
-    const dat = dataCh;
-    const data = randomSeries(10, dat.dataType);
-
-    const time = BigInt64Array.from({ length: 10 }, (_, i) =>
-      TimeStamp.milliseconds(i).valueOf(),
-    );
-
-    await index.write(0, time);
-    await dat.write(0, data);
-
-    await expect(
-      client.delete(
-        [index.key],
-        TimeStamp.milliseconds(2).range(TimeStamp.milliseconds(5)),
-      ),
-    ).rejects.toThrow();
-  });
-});