@synnaxlabs/client 0.49.2 → 0.49.3

package/dist/src/framer/external.d.ts

@@ -2,6 +2,7 @@ export * from './client';
 export * from './frame';
 export * from './iterator';
 export * from './payload';
+export * from './reader';
 export * from './streamer';
 export * from './writer';
 //# sourceMappingURL=external.d.ts.map

package/dist/src/framer/external.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"external.d.ts","sourceRoot":"","sources":["../../../src/framer/external.ts"],"names":[],"mappings":"AASA,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"external.d.ts","sourceRoot":"","sources":["../../../src/framer/external.ts"],"names":[],"mappings":"AASA,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC"}

package/dist/src/framer/iterator.d.ts

@@ -8,6 +8,11 @@ export interface IteratorConfig {
      * resulting from a call to next with {@link AUTO_SPAN}.
      */
     chunkSize?: number;
+    /**
+     * downsampleFactor is the factor to downsample the data by. If downsampleFactor is
+     * less than or equal to 1, no downsampling will be performed.
+     */
+    downsampleFactor?: number;
 }
 /**
  * Used to iterate over a clusters telemetry in time-order. It should not be

package/dist/src/framer/iterator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iterator.d.ts","sourceRoot":"","sources":["../../../src/framer/iterator.ts"],"names":[],"mappings":"AASA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,cAAc,EAGnB,QAAQ,EAET,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,KAAK,EAAU,MAAM,gBAAgB,CAAC;AAG/C,eAAO,MAAM,SAAS,UAAmB,CAAC;AAsC1C,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwC;IAC/D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,KAAK,EAAE,KAAK,CAAC;IAEb,OAAO;IAMP;;;;;;;;;;OAUG;WACU,KAAK,CAChB,EAAE,EAAE,cAAc,EAClB,QAAQ,EAAE,OAAO,CAAC,MAAM,EACxB,SAAS,EAAE,OAAO,CAAC,SAAS,EAC5B,MAAM,EAAE,YAAY,EACpB,IAAI,GAAE,cAAmB,GACxB,OAAO,CAAC,QAAQ,CAAC;IAapB;;;;;;;;;;OAUG;IACG,IAAI,CAAC,IAAI,GAAE,aAAyB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI7D;;;;;;;;;;OAUG;IACG,IAAI,CAAC,IAAI,GAAE,aAAyB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI7D;;;;;;;OAOG;IACG,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAInC;;;;;;OAMG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAIlC;;;;;;;OAOG;IACG,MAAM,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrD;;;;;;;OAOG;IACG,MAAM,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrD;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC;IAI/B;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,CAAC;YAIhD,OAAO;CAStB"}
+{"version":3,"file":"iterator.d.ts","sourceRoot":"","sources":["../../../src/framer/iterator.ts"],"names":[],"mappings":"AASA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,cAAc,EAGnB,QAAQ,EAET,MAAM,eAAe,CAAC;AAGvB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,KAAK,EAAU,MAAM,gBAAgB,CAAC;AAG/C,eAAO,MAAM,SAAS,UAAmB,CAAC;AAuC1C,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwC;IAC/D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,KAAK,EAAE,KAAK,CAAC;IAEb,OAAO;IAMP;;;;;;;;;;OAUG;WACU,KAAK,CAChB,EAAE,EAAE,cAAc,EAClB,QAAQ,EAAE,OAAO,CAAC,MAAM,EACxB,SAAS,EAAE,OAAO,CAAC,SAAS,EAC5B,MAAM,EAAE,YAAY,EACpB,IAAI,GAAE,cAAmB,GACxB,OAAO,CAAC,QAAQ,CAAC;IAcpB;;;;;;;;;;OAUG;IACG,IAAI,CAAC,IAAI,GAAE,aAAyB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI7D;;;;;;;;;;OAUG;IACG,IAAI,CAAC,IAAI,GAAE,aAAyB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI7D;;;;;;;OAOG;IACG,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;IAInC;;;;;;OAMG;IACG,QAAQ,IAAI,OAAO,CAAC,OAAO,CAAC;IAIlC;;;;;;;OAOG;IACG,MAAM,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrD;;;;;;;OAOG;IACG,MAAM,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAIrD;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC;IAI/B;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,CAAC;YAIhD,OAAO;CAStB"}

package/dist/src/framer/reader.d.ts

@@ -1,11 +1,13 @@
 import { WebSocketClient } from '@synnaxlabs/freighter';
 import { CrudeTimeRange } from '@synnaxlabs/x';
 import { channel } from '../channel';
+import { IteratorConfig } from './iterator';
 export interface ReadRequest {
     channels: channel.Params;
     timeRange: CrudeTimeRange;
-    channelNames?: Map<channel.KeyOrName, string>;
+    channelNames?: Record<channel.KeyOrName, string>;
     responseType: "csv";
+    iteratorConfig?: IteratorConfig;
 }
 export declare class Reader {
     private readonly retriever;

package/dist/src/framer/reader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../../src/framer/reader.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,KAAK,cAAc,EAAgB,MAAM,eAAe,CAAC;AAElE,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAKzC,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC;IACzB,SAAS,EAAE,cAAc,CAAC;IAC1B,YAAY,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IAC9C,YAAY,EAAE,KAAK,CAAC;CACrB;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkB;gBAEnC,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,YAAY,EAAE,eAAe;IAKjE,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;CA2BtE"}
+{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../../src/framer/reader.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,KAAK,cAAc,EAAgB,MAAM,eAAe,CAAC;AAElE,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAElE,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC;IACzB,SAAS,EAAE,cAAc,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;IACjD,YAAY,EAAE,KAAK,CAAC;IACpB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkB;gBAEnC,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,YAAY,EAAE,eAAe;IAKjE,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;CAiCtE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/client",
-  "version": "0.49.2",
+  "version": "0.49.3",
   "description": "The Synnax Client Library",
   "keywords": [
     "synnax",
@@ -26,8 +26,8 @@
   "dependencies": {
     "async-mutex": "^0.5.0",
     "zod": "^4.1.12",
-    "@synnaxlabs/freighter": "^0.49.0",
-    "@synnaxlabs/x": "^0.49.2"
+    "@synnaxlabs/x": "^0.49.3",
+    "@synnaxlabs/freighter": "^0.49.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^3.2.4",
@@ -38,8 +38,8 @@
     "vite": "^7.1.12",
     "vitest": "^3.2.4",
     "@synnaxlabs/tsconfig": "^0.43.0",
-    "@synnaxlabs/vite-plugin": "^0.43.0",
-    "eslint-config-synnaxlabs": "^0.43.0"
+    "eslint-config-synnaxlabs": "^0.43.0",
+    "@synnaxlabs/vite-plugin": "^0.43.0"
   },
   "type": "module",
   "types": "dist/src/index.d.ts",

package/src/framer/external.ts

@@ -11,5 +11,6 @@ export * from "@/framer/client";
 export * from "@/framer/frame";
 export * from "@/framer/iterator";
 export * from "@/framer/payload";
+export * from "@/framer/reader";
 export * from "@/framer/streamer";
 export * from "@/framer/writer";

package/src/framer/iterator.spec.ts

@@ -99,4 +99,71 @@ describe("Iterator", () => {
       await iter.close();
     }
   });
+  test("downsample factor 2", async () => {
+    const channels = await newIndexedPair(client);
+    const [idx_ch, data_ch] = channels;
+    const writer = await client.openWriter({ start: TimeStamp.SECOND, channels });
+    await writer.write({
+      [idx_ch.key]: secondsLinspace(1, 8),
+      [data_ch.key]: new Float64Array([1, 2, 3, 4, 5, 6, 7, 8]),
+    });
+    await writer.close();
+    const iter = await client.openIterator(TimeRange.MAX, channels, {
+      downsampleFactor: 2,
+    });
+
+    try {
+      expect(await iter.seekFirst()).toBe(true);
+      expect(await iter.next(AUTO_SPAN)).toBe(true);
+      // [1, 2, 3, 4, 5, 6, 7, 8] downsampled by 2 = [1, 3, 5, 7]
+      expect(iter.value.get(data_ch.key).data).toEqual(new Float64Array([1, 3, 5, 7]));
+      expect(await iter.next(AUTO_SPAN)).toBe(false);
+    } finally {
+      await iter.close();
+    }
+  });
+  test("downsample factor 3", async () => {
+    const channels = await newIndexedPair(client);
+    const [idx_ch, data_ch] = channels;
+    const writer = await client.openWriter({ start: TimeStamp.SECOND, channels });
+    await writer.write({
+      [idx_ch.key]: secondsLinspace(1, 9),
+      [data_ch.key]: new Float64Array([1, 2, 3, 4, 5, 6, 7, 8, 9]),
+    });
+    await writer.close();
+    const iter = await client.openIterator(TimeRange.MAX, channels, {
+      downsampleFactor: 3,
+    });
+
+    try {
+      expect(await iter.seekFirst()).toBe(true);
+      expect(await iter.next(AUTO_SPAN)).toBe(true);
+      // [1, 2, 3, 4, 5, 6, 7, 8, 9] downsampled by 3 = [1, 4, 7]
+      expect(iter.value.get(data_ch.key).data).toEqual(new Float64Array([1, 4, 7]));
+      expect(await iter.next(AUTO_SPAN)).toBe(false);
+    } finally {
+      await iter.close();
+    }
+  });
+  test("no downsample when factor is 1", async () => {
+    const channels = await newIndexedPair(client);
+    const [idx_ch, data_ch] = channels;
+    const writer = await client.openWriter({ start: TimeStamp.SECOND, channels });
+    await writer.write({
+      [idx_ch.key]: secondsLinspace(1, 4),
+      [data_ch.key]: new Float64Array([1, 2, 3, 4]),
+    });
+    await writer.close();
+    const iter = await client.openIterator(TimeRange.MAX, channels, {
+      downsampleFactor: 1,
+    });
+    try {
+      expect(await iter.seekFirst()).toBe(true);
+      expect(await iter.next(AUTO_SPAN)).toBe(true);
+      expect(iter.value.get(data_ch.key).data).toEqual(new Float64Array([1, 2, 3, 4]));
+      expect(await iter.next(AUTO_SPAN)).toBe(false);
+    } finally {
+      await iter.close();
+    }
+  });
 });

package/src/framer/iterator.ts

@@ -51,6 +51,7 @@ const reqZ = z.object({
   stamp: TimeStamp.z.optional(),
   keys: channel.keyZ.array().optional(),
   chunkSize: z.number().optional(),
+  downsampleFactor: z.int().optional(),
 });
 interface Request extends z.infer<typeof reqZ> {}
 
@@ -67,6 +68,11 @@ export interface IteratorConfig {
    * resulting from a call to next with {@link AUTO_SPAN}.
    */
   chunkSize?: number;
+  /**
+   * downsampleFactor is the factor to downsample the data by. If downsampleFactor is
+   * less than or equal to 1, no downsampling will be performed.
+   */
+  downsampleFactor?: number;
 }
 
 /**
@@ -114,6 +120,7 @@ export class Iterator {
       keys: Array.from(adapter.keys),
       bounds: new TimeRange(tr),
       chunkSize: opts.chunkSize ?? 1e5,
+      downsampleFactor: opts.downsampleFactor ?? 1,
     });
     return iter;
   }

package/src/framer/reader.spec.ts

@@ -12,6 +12,7 @@ import { describe, expect, it } from "vitest";
 
 import { type channel } from "@/channel";
 import { createTestClient } from "@/testutil/client";
+import { secondsLinspace } from "@/testutil/telem";
 
 const client = createTestClient();
 
@@ -75,11 +76,11 @@ describe("Reader", () => {
       const stream = await client.read({
         channels: [index.key, data1.key, data2.key],
         timeRange: { start: TimeStamp.seconds(0), end: TimeStamp.seconds(10) },
-        channelNames: new Map([
-          [index.key, "Time"],
-          [data1.key, "Sensor1"],
-          [data2.key, "Sensor2"],
-        ]),
+        channelNames: {
+          [index.key]: "Time",
+          [data1.key]: "Sensor1",
+          [data2.key]: "Sensor2",
+        },
         responseType: "csv",
       });
       const records = await streamToRecords(stream);
@@ -145,12 +146,12 @@ describe("Reader", () => {
       const stream = await client.read({
         channels: [data1.key, data2.key], // Just data channels - indexes auto-included
         timeRange: { start: TimeStamp.seconds(0), end: TimeStamp.seconds(10) },
-        channelNames: new Map([
-          [index1.key, "Time1"],
-          [data1.key, "Data1"],
-          [index2.key, "Time2"],
-          [data2.key, "Data2"],
-        ]),
+        channelNames: {
+          [index1.key]: "Time1",
+          [data1.key]: "Data1",
+          [index2.key]: "Time2",
+          [data2.key]: "Data2",
+        },
         responseType: "csv",
       });
       const records = await streamToRecords(stream);
@@ -164,6 +165,47 @@ describe("Reader", () => {
         ["", "", "6000000000", "600"],
       ]);
     });
+    it("should allow downsampling", async () => {
+      const index = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.TIMESTAMP,
+        isIndex: true,
+      });
+      const data = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.FLOAT64,
+        index: index.key,
+      });
+      const writer = await client.openWriter({
+        start: TimeStamp.seconds(1),
+        channels: [index.key, data.key],
+      });
+      await writer.write({
+        [index.key]: [
+          TimeStamp.seconds(1),
+          TimeStamp.seconds(2),
+          TimeStamp.seconds(3),
+          TimeStamp.seconds(4),
+          TimeStamp.seconds(5),
+        ],
+        [data.key]: [10, 20, 30, 40, 50],
+      });
+      await writer.commit();
+      await writer.close();
+      const stream = await client.read({
+        channels: [data.key],
+        timeRange: { start: TimeStamp.seconds(0), end: TimeStamp.seconds(10) },
+        responseType: "csv",
+        iteratorConfig: { downsampleFactor: 2 },
+      });
+      const records = await streamToRecords(stream);
+      expect(records).toEqual([
+        [index.name, data.name],
+        ["1000000000", "10"],
+        ["3000000000", "30"],
+        ["5000000000", "50"],
+      ]);
+    });
     it("should handle channels at different uneven rates with correct row ordering", async () => {
       const indexFast = await client.channels.create({
         name: id.create(),
@@ -380,7 +422,7 @@ describe("Reader", () => {
       await writer.close();
       const stream = await client.read({
         channels: [data.key],
-        timeRange: { start: TimeStamp.seconds(0), end: TimeStamp.seconds(10) },
+        timeRange: { start: TimeStamp.seconds(0), end: TimeStamp.seconds(100000) },
         responseType: "csv",
       });
       const records = await streamToRecords(stream);
@@ -389,7 +431,133 @@ describe("Reader", () => {
         ["1", "42"],
       ]);
     });
-
+    it("should handle channels across domains with gaps in them", async () => {
+      const index = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.TIMESTAMP,
+        isIndex: true,
+      });
+      const data = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.FLOAT64,
+        index: index.key,
+      });
+      let writer = await client.openWriter({
+        start: TimeStamp.nanoseconds(101),
+        channels: [index.key, data.key],
+      });
+      await writer.write({
+        [index.key]: [
+          TimeStamp.nanoseconds(101),
+          TimeStamp.nanoseconds(102),
+          TimeStamp.nanoseconds(103),
+        ],
+        [data.key]: [10, 11, 12],
+      });
+      await writer.commit();
+      await writer.close();
+      writer = await client.openWriter({
+        start: TimeStamp.nanoseconds(1),
+        channels: [index.key, data.key],
+      });
+      await writer.write({
+        [index.key]: [
+          TimeStamp.nanoseconds(1),
+          TimeStamp.nanoseconds(2),
+          TimeStamp.nanoseconds(3),
+        ],
+        [data.key]: [1, 2, 3],
+      });
+      await writer.commit();
+      await writer.close();
+      const stream = await client.read({
+        channels: [data.key],
+        timeRange: { start: TimeStamp.nanoseconds(3), end: TimeStamp.nanoseconds(103) },
+        responseType: "csv",
+      });
+      const rows = await streamToRecords(stream);
+      expect(rows).toEqual([
+        [index.name, data.name],
+        ["3", "3"],
+        ["101", "10"],
+        ["102", "11"],
+      ]);
+    });
+    it("should handle non-overlapping data across domains", async () => {
+      // first index will get written from times 10-15, second index from times 13-18
+      const index1 = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.TIMESTAMP,
+        isIndex: true,
+      });
+      const index2 = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.TIMESTAMP,
+        isIndex: true,
+      });
+      const data1 = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.FLOAT64,
+        index: index1.key,
+      });
+      const data2 = await client.channels.create({
+        name: id.create(),
+        dataType: DataType.FLOAT64,
+        index: index2.key,
+      });
+      const writer1 = await client.openWriter({
+        start: TimeStamp.nanoseconds(10),
+        channels: [index1.key, data1.key],
+      });
+      await writer1.write({
+        [index1.key]: [
+          TimeStamp.nanoseconds(10),
+          TimeStamp.nanoseconds(11),
+          TimeStamp.nanoseconds(12),
+          TimeStamp.nanoseconds(13),
+          TimeStamp.nanoseconds(14),
+          TimeStamp.nanoseconds(15),
+        ],
+        [data1.key]: [1, 2, 3, 4, 5, 6],
+      });
+      await writer1.commit();
+      await writer1.close();
+      const writer2 = await client.openWriter({
+        start: TimeStamp.nanoseconds(15),
+        channels: [index2.key, data2.key],
+      });
+      await writer2.write({
+        [index2.key]: [
+          TimeStamp.nanoseconds(13),
+          TimeStamp.nanoseconds(14),
+          TimeStamp.nanoseconds(15),
+          TimeStamp.nanoseconds(16),
+          TimeStamp.nanoseconds(17),
+          TimeStamp.nanoseconds(18),
+        ],
+        [data2.key]: [11, 12, 13, 14, 15, 16],
+      });
+      await writer2.commit();
+      await writer2.close();
+      const stream = await client.read({
+        channels: [data1.key, data2.key],
+        timeRange: { start: TimeStamp.nanoseconds(0), end: TimeStamp.nanoseconds(19) },
+        responseType: "csv",
+      });
+      const rows = await streamToRecords(stream);
+      expect(rows).toEqual([
+        [index1.name, data1.name, index2.name, data2.name],
+        ["10", "1", "", ""],
+        ["11", "2", "", ""],
+        ["12", "3", "", ""],
+        ["13", "4", "13", "11"],
+        ["14", "5", "14", "12"],
+        ["15", "6", "15", "13"],
+        ["", "", "16", "14"],
+        ["", "", "17", "15"],
+        ["", "", "18", "16"],
+      ]);
+    });
     it("should handle large dataset requiring multiple iterator calls", async () => {
       // Create 4 groups with different indexes at different rates
       const numGroups = 4;
@@ -558,7 +726,6 @@ describe("Reader", () => {
         const sparseStep = 1_000;
         const sparseSamples = denseSamples / sparseStep;
 
-        // Fast (dense) index + data
         const indexFast = await client.channels.create({
           name: `dense_index_${id.create()}`,
           dataType: DataType.TIMESTAMP,
@@ -570,7 +737,6 @@ describe("Reader", () => {
           index: indexFast.key,
         });
 
-        // Slow (sparse) index + data
         const indexSlow = await client.channels.create({
           name: `sparse_index_${id.create()}`,
           dataType: DataType.TIMESTAMP,
@@ -581,79 +747,59 @@ describe("Reader", () => {
           dataType: DataType.FLOAT64,
           index: indexSlow.key,
         });
-        const baseTime = TimeStamp.seconds(0);
+        const start = TimeStamp.seconds(0);
         const denseWriter = await client.openWriter({
-          start: baseTime,
+          start,
           channels: [indexFast.key, dataFast.key],
         });
 
-        const denseBatchSize = 10_000;
+        const maxBatchSize = 10_000;
         for (
           let batchStart = 1;
           batchStart <= denseSamples;
-          batchStart += denseBatchSize
+          batchStart += maxBatchSize
         ) {
-          const batchEnd = Math.min(batchStart + denseBatchSize - 1, denseSamples);
-          const tsBatch: TimeStamp[] = [];
-          const valBatch: number[] = [];
-
-          for (let i = batchStart; i <= batchEnd; i++) {
-            // baseTime + i ns => underlying raw timestamps ~ [1..1_000_000]
-            tsBatch.push(baseTime.add(TimeSpan.nanoseconds(i)));
-            valBatch.push(i); // arbitrary data value
-          }
-
-          await denseWriter.write({
-            [indexFast.key]: tsBatch,
-            [dataFast.key]: valBatch,
-          });
+          const batchEnd = Math.min(batchStart + maxBatchSize - 1, denseSamples);
+          const batchSize = batchEnd - batchStart + 1;
+          const times = secondsLinspace(batchStart, batchSize);
+          const data = Array.from({ length: batchSize }, (_, i) => i + batchStart);
+          await denseWriter.write({ [indexFast.key]: times, [dataFast.key]: data });
         }
         await denseWriter.commit();
         await denseWriter.close();
 
-        // ---- Write sparse channel: timestamps 1..1_000_000 every 1000 ----
         const sparseWriter = await client.openWriter({
-          start: baseTime,
+          start,
           channels: [indexSlow.key, dataSlow.key],
         });
 
-        const sparseBatchSize = 1000; // at most 1000 sparse points total anyway
         for (
-          let batchStart = 0;
+          let batchStart = 1;
           batchStart < sparseSamples;
-          batchStart += sparseBatchSize
+          batchStart += maxBatchSize
         ) {
-          const batchEnd = Math.min(batchStart + sparseBatchSize, sparseSamples);
-          const tsBatch: TimeStamp[] = [];
-          const valBatch: number[] = [];
-
-          for (let j = batchStart; j < batchEnd; j++) {
-            const logicalTs = (j + 1) * sparseStep; // 1000, 2000, ..., 1_000_000
-            tsBatch.push(baseTime.add(TimeSpan.nanoseconds(logicalTs)));
-            valBatch.push(logicalTs); // arbitrary data value
+          const batchEnd = Math.min(
+            batchStart + (maxBatchSize - 1) * sparseStep,
+            batchStart + sparseSamples * sparseStep,
+          );
+          const times: TimeStamp[] = [];
+          const data: number[] = [];
+
+          for (let j = batchStart; j < batchEnd; j += sparseStep) {
+            times.push(start.add(TimeSpan.seconds(j)));
+            data.push(j); // arbitrary data value
           }
-
-          await sparseWriter.write({
-            [indexSlow.key]: tsBatch,
-            [dataSlow.key]: valBatch,
-          });
+          await sparseWriter.write({ [indexSlow.key]: times, [dataSlow.key]: data });
         }
         await sparseWriter.commit();
         await sparseWriter.close();
 
-        // ---- Export CSV with explicit headers so we know column order ----
         const stream = await client.read({
           channels: [dataFast.key, dataSlow.key],
           timeRange: {
-            start: baseTime,
-            end: baseTime.add(TimeSpan.nanoseconds(denseSamples + 1)),
+            start: TimeStamp.seconds(0),
+            end: start.add(TimeSpan.seconds(denseSamples + 1)),
           },
-          channelNames: new Map([
-            [indexFast.key, "FastTime"],
-            [dataFast.key, "FastValue"],
-            [indexSlow.key, "SlowTime"],
-            [dataSlow.key, "SlowValue"],
-          ]),
           responseType: "csv",
         });
 
@@ -671,9 +817,7 @@ describe("Reader", () => {
           const { done, value } = await reader.read();
           if (done) break;
           chunkCount++;
-
           buffer += decoder.decode(value);
-
           while (true) {
             const idx = buffer.indexOf(delimiter);
             if (idx === -1) break;
@@ -683,26 +827,20 @@ describe("Reader", () => {
             if (isHeader) {
               const headerCols = line.split(",");
               expect(headerCols).toEqual([
-                "FastTime",
-                "FastValue",
-                "SlowTime",
-                "SlowValue",
+                indexFast.name,
+                dataFast.name,
+                indexSlow.name,
+                dataSlow.name,
               ]);
               isHeader = false;
               continue;
             }
 
             totalRows++;
-
             const cols = line.split(",");
             expect(cols).toHaveLength(4);
+            const [fastTsStr, fastValStr, slowTsStr, slowValStr] = cols;
 
-            const fastTsStr = cols[0];
-            const slowTsStr = cols[2];
-            const fastValStr = cols[1];
-            const slowValStr = cols[3];
-
-            // Dense channel should always have a timestamp and value
             expect(fastTsStr).not.toBe("");
             expect(fastValStr).not.toBe("");
 
@@ -710,25 +848,16 @@ describe("Reader", () => {
             if (lastTimestamp !== null) expect(ts).toBeGreaterThan(lastTimestamp);
             lastTimestamp = ts;
 
-            // Sparse channel only has data every 1000 "ticks"
             if (slowValStr !== "") {
               sparseRows++;
               // When sparse has data, its timestamp should match dense's timestamp
               expect(slowTsStr).toBe(fastTsStr);
+              expect(slowValStr).not.toBe("");
             }
           }
         }
-
-        // Handle any final line without trailing CRLF
-        if (buffer.trim().length > 0) if (!isHeader) totalRows++;
-
-        // We should have streamed multiple chunks (proves AUTO_SPAN / multi-frame)
         expect(chunkCount).toBeGreaterThan(1);
-
-        // One row per dense timestamp
         expect(totalRows).toBe(denseSamples);
-
-        // One row per sparse timestamp (merged into dense rows)
         expect(sparseRows).toBe(sparseSamples);
       },
     );