@synnaxlabs/x 0.54.2 → 0.56.0

package/src/telem/series.spec.ts

@@ -141,7 +141,7 @@ describe("Series", () => {
       const s = new Series({ data: [{ a: 1, b: "apple" }] });
       expect(s.dataType.equals(DataType.JSON));
       expect(s.length).toEqual(1);
-      expect(s.data.at(-1)).toEqual(10);
+      expect(s.at(0)).toEqual({ a: 1, b: "apple" });
     });
 
     it("should correctly interpret a bigint as an int64", () => {
@@ -214,8 +214,8 @@ describe("Series", () => {
 
     it("should convert encoded keys to snake_case", () => {
       const a = new Series({ data: [{ aB: 1, bC: "apple" }], dataType: DataType.JSON });
-      const strContent = new TextDecoder().decode(a.data);
-      expect(strContent).toBe('{"a_b":1,"b_c":"apple"}\n');
+      expect(a.length).toEqual(1);
+      expect(a.at(0)).toEqual({ aB: 1, bC: "apple" });
     });
 
     it("should throw an error when an empty JS array is provided and no data type is provided", () => {
@@ -369,6 +369,155 @@ describe("Series", () => {
     });
   });
 
+  describe("asString", () => {
+    it("should return the string value for a string series", () => {
+      const series = new Series({
+        data: ["apple", "banana"],
+        dataType: DataType.STRING,
+      });
+      expect(series.asString(0, true)).toEqual("apple");
+      expect(series.asString(1, true)).toEqual("banana");
+    });
+
+    it("should return the raw JSON string without parsing for a JSON series", () => {
+      const series = new Series({
+        data: [{ a_b: 1, c_d: "apple" }],
+        dataType: DataType.JSON,
+      });
+      const result = series.asString(0, true);
+      expect(result).toEqual('{"a_b":1,"c_d":"apple"}');
+    });
+
+    it("should preserve raw snake_case keys while at() converts them to camelCase", () => {
+      const series = new Series({
+        data: [{ user_id: 1, first_name: "alice" }],
+        dataType: DataType.JSON,
+      });
+      expect(series.asString(0, true)).toEqual('{"user_id":1,"first_name":"alice"}');
+      expect(series.at(0, true)).toEqual({ userId: 1, firstName: "alice" });
+    });
+
+    it("should decode UTF-8 bytes for a BYTES series", () => {
+      const payload = new TextEncoder().encode("hello world");
+      const buf = new ArrayBuffer(4 + payload.byteLength);
+      new DataView(buf).setUint32(0, payload.byteLength, true);
+      new Uint8Array(buf).set(payload, 4);
+      const series = new Series({ data: buf, dataType: DataType.BYTES });
+      expect(series.asString(0, true)).toEqual("hello world");
+    });
+
+    it("should emit the U+FFFD replacement character for invalid UTF-8 in a BYTES series", () => {
+      const payload = new Uint8Array([0xff, 0xfe]);
+      const buf = new ArrayBuffer(4 + payload.byteLength);
+      new DataView(buf).setUint32(0, payload.byteLength, true);
+      new Uint8Array(buf).set(payload, 4);
+      const series = new Series({ data: buf, dataType: DataType.BYTES });
+      expect(series.asString(0, true)).toEqual("��");
+    });
+
+    it("should return a string representation for a numeric series", () => {
+      const series = new Series({
+        data: new Float32Array([3.5, 7]),
+        dataType: DataType.FLOAT32,
+      });
+      expect(series.asString(0, true)).toEqual("3.5");
+      expect(series.asString(1, true)).toEqual("7");
+    });
+
+    it("should return the shortest f32-roundtrippable decimal for typical FLOAT32 values", () => {
+      const series = new Series({
+        data: new Float32Array([1.234, 0.1, 100.5, -1.234, 3.14, -0]),
+        dataType: DataType.FLOAT32,
+      });
+      expect(series.asString(0, true)).toEqual("1.234");
+      expect(series.asString(1, true)).toEqual("0.1");
+      expect(series.asString(2, true)).toEqual("100.5");
+      expect(series.asString(3, true)).toEqual("-1.234");
+      expect(series.asString(4, true)).toEqual("3.14");
+      expect(series.asString(5, true)).toEqual("0");
+    });
+
+    it("should stringify integer-valued FLOAT32 values without decimals", () => {
+      const series = new Series({
+        data: new Float32Array([0, 1, -1, 1000000, -1000000]),
+        dataType: DataType.FLOAT32,
+      });
+      expect(series.asString(0, true)).toEqual("0");
+      expect(series.asString(1, true)).toEqual("1");
+      expect(series.asString(2, true)).toEqual("-1");
+      expect(series.asString(3, true)).toEqual("1000000");
+      expect(series.asString(4, true)).toEqual("-1000000");
+    });
+
+    it("should preserve f32 representation for very small FLOAT32 values", () => {
+      const subnormal = Math.fround(1e-40);
+      const series = new Series({
+        data: new Float32Array([Number.MIN_VALUE, subnormal]),
+        dataType: DataType.FLOAT32,
+      });
+      // Number.MIN_VALUE (5e-324) underflows to 0 in f32.
+      expect(series.asString(0, true)).toEqual("0");
+      expect(Math.fround(parseFloat(series.asString(1, true)))).toBe(subnormal);
+    });
+
+    it("should preserve f32 representation for very large FLOAT32 values", () => {
+      const maxF32 = Math.fround(3.4e38);
+      const large = Math.fround(1e30);
+      const series = new Series({
+        data: new Float32Array([maxF32, large]),
+        dataType: DataType.FLOAT32,
+      });
+      expect(Math.fround(parseFloat(series.asString(0, true)))).toBe(maxF32);
+      expect(Math.fround(parseFloat(series.asString(1, true)))).toBe(large);
+    });
+
+    it("should stringify non-finite FLOAT32 values", () => {
+      const series = new Series({
+        data: new Float32Array([NaN, Infinity, -Infinity]),
+        dataType: DataType.FLOAT32,
+      });
+      expect(series.asString(0, true)).toEqual("NaN");
+      expect(series.asString(1, true)).toEqual("Infinity");
+      expect(series.asString(2, true)).toEqual("-Infinity");
+    });
+
+    it("should produce idempotent stringification under FLOAT32 round-trip", () => {
+      const cases = [1.234, 0.1, 100.5, -1.234, 1.2339999675750732, Math.PI, 1e-20];
+      for (const v of cases) {
+        const s1 = new Series({
+          data: new Float32Array([v]),
+          dataType: DataType.FLOAT32,
+        }).asString(0, true);
+        const s2 = new Series({
+          data: new Float32Array([parseFloat(s1)]),
+          dataType: DataType.FLOAT32,
+        }).asString(0, true);
+        expect(s2).toBe(s1);
+      }
+    });
+
+    it("should return undefined when index is out of bounds", () => {
+      const series = new Series({
+        data: ["apple"],
+        dataType: DataType.STRING,
+      });
+      expect(series.asString(5)).toBeUndefined();
+    });
+
+    it("should throw when index is out of bounds and required is true", () => {
+      const series = new Series({
+        data: ["apple"],
+        dataType: DataType.STRING,
+      });
+      expect(() => series.asString(5, true)).toThrow();
+    });
+
+    it("should return the UUID string for a UUID series", () => {
+      const series = new Series({ data: SAMPLE_UUID_BYTES, dataType: DataType.UUID });
+      expect(series.asString(0, true)).toEqual("123e4567-e89b-40d3-8056-426614174000");
+    });
+  });
+
   describe("atAlignment", () => {
     it("should return the value at a particular alignment", () => {
       const series = new Series({
@@ -382,6 +531,40 @@ describe("Series", () => {
     });
   });
 
+  describe("bigint sampleOffset precision", () => {
+    it("preserves precision in at when sampleOffset is a bigint above 2^53", () => {
+      const offset = 1778020940471336960n;
+      const series = new Series({
+        data: new Float32Array([0, 1, 2]),
+        dataType: DataType.FLOAT32,
+        sampleOffset: offset,
+      });
+      expect(series.at(0)).toBe(offset);
+      expect(series.at(1)).toBe(offset + 1n);
+      expect(series.at(2)).toBe(offset + 2n);
+    });
+
+    it("preserves precision in max when sampleOffset is a bigint above 2^53", () => {
+      const offset = 1778020940471336960n;
+      const series = new Series({
+        data: new Float32Array([0, 1, 2]),
+        dataType: DataType.FLOAT32,
+        sampleOffset: offset,
+      });
+      expect(series.max).toBe(offset + 2n);
+    });
+
+    it("preserves precision in min when sampleOffset is a bigint above 2^53", () => {
+      const offset = 1778020940471336960n;
+      const series = new Series({
+        data: new Float32Array([0, 1, 2]),
+        dataType: DataType.FLOAT32,
+        sampleOffset: offset,
+      });
+      expect(series.min).toBe(offset);
+    });
+  });
+
   describe("slice", () => {
     it("should slice a lazy array", () => {
       const a = new Series({
@@ -502,7 +685,7 @@ describe("Series", () => {
     });
 
     it("should recompute the length of a variable density array", () => {
-      const series = Series.alloc({ capacity: 12, dataType: DataType.STRING });
+      const series = Series.alloc({ capacity: 18, dataType: DataType.STRING });
       expect(series.length).toEqual(0);
       const writeOne = new Series({ data: ["apple"] });
       expect(series.write(writeOne)).toEqual(1);
@@ -689,6 +872,54 @@ describe("Series", () => {
         { a: 3, b: "carrot" },
       ]);
     });
+
+    it("should handle a single JSON value", () => {
+      const s = new Series([{ key: "val" }]);
+      expect(s.length).toEqual(1);
+      expect(s.at(0)).toEqual({ key: "val" });
+    });
+
+    it("should handle empty JSON objects", () => {
+      const s = new Series([{}, {}, {}]);
+      expect(s.length).toEqual(3);
+      expect(s.at(0)).toEqual({});
+      expect(s.at(2)).toEqual({});
+    });
+
+    it("should support negative indexing", () => {
+      const s = new Series([{ a: 1 }, { a: 2 }, { a: 3 }]);
+      expect(s.at(-1)).toEqual({ a: 3 });
+      expect(s.at(-2)).toEqual({ a: 2 });
+    });
+
+    it("should handle an empty JSON series", () => {
+      const s = new Series({ data: new ArrayBuffer(0), dataType: DataType.JSON });
+      expect(s.length).toEqual(0);
+      expect(Array.from(s)).toEqual([]);
+    });
+  });
+
+  describe("bytes series", () => {
+    it("should handle an empty bytes series", () => {
+      const s = new Series({ data: new ArrayBuffer(0), dataType: DataType.BYTES });
+      expect(s.length).toEqual(0);
+      expect(Array.from(s)).toEqual([]);
+    });
+
+    it("should correctly compute the length of a bytes series from a length-prefixed buffer", () => {
+      const payload1 = new Uint8Array([1, 2, 3]);
+      const payload2 = new Uint8Array([4, 5]);
+      const totalBytes = 4 + payload1.byteLength + 4 + payload2.byteLength;
+      const buf = new ArrayBuffer(totalBytes);
+      const view = new DataView(buf);
+      const bytes = new Uint8Array(buf);
+      view.setUint32(0, payload1.byteLength, true);
+      bytes.set(payload1, 4);
+      view.setUint32(4 + payload1.byteLength, payload2.byteLength, true);
+      bytes.set(payload2, 4 + payload1.byteLength + 4);
+      const s = new Series({ data: buf, dataType: DataType.BYTES });
+      expect(s.length).toEqual(2);
+    });
   });
 
   describe("binarySearch", () => {

package/src/telem/series.ts

@@ -45,6 +45,17 @@ interface GL {
 
 interface IterableIterator<T> extends Iterator<T>, Iterable<T> {}
 
+/** Shortest decimal string that round-trips through f32 — JS analogue of Go's strconv.FormatFloat(_, 'g', -1, 32). */
+const stringifyFloat32 = (value: number): string => {
+  const f32 = Math.fround(value);
+  if (!Number.isFinite(f32)) return f32.toString();
+  for (let p = 1; p <= 9; p++) {
+    const parsed = parseFloat(f32.toPrecision(p));
+    if (Math.fround(parsed) === f32) return parsed.toString();
+  }
+  return f32.toString();
+};
+
 /** A condensed set of information describing the layout of a series. */
 export interface SeriesDigest {
   key: string;
@@ -114,7 +125,7 @@ const nullArrayZ = z
   .union([z.null(), z.undefined()])
   .transform(() => new Uint8Array().buffer);
 
-const NEW_LINE = 10;
+const UINT32_SIZE = 4;
 
 type JSType = "string" | "number" | "bigint";
 
@@ -193,12 +204,14 @@ export class Series<T extends TelemValue = TelemValue>
     timeRange: TimeRange.z.optional(),
     dataType: DataType.z,
     alignment: z.coerce.bigint().optional(),
-    data: z.union([
-      stringArrayZ,
-      nullArrayZ,
-      z.instanceof(ArrayBuffer),
-      z.instanceof(Uint8Array),
-    ]),
+    data: z
+      .union([
+        stringArrayZ,
+        nullArrayZ,
+        z.instanceof(ArrayBuffer),
+        z.instanceof(Uint8Array),
+      ])
+      .default(() => new Uint8Array().buffer),
     glBufferUsage: glBufferUsageZ.default("static").optional(),
   });
 
@@ -294,7 +307,7 @@ export class Series<T extends TelemValue = TelemValue>
       data,
     } = props;
     if (isSeries(data)) {
-      const data_ = data as Series;
+      const data_ = data;
       this.key = data_.key;
       this.dataType = data_.dataType;
       this.sampleOffset = data_.sampleOffset;
@@ -319,7 +332,7 @@ export class Series<T extends TelemValue = TelemValue>
         "cannot infer data type from an ArrayBuffer instance when constructing a Series. Please provide a data type.",
       );
     else if (isArray || isSingle) {
-      let first: TelemValue | unknown = data as TelemValue;
+      let first: TelemValue | unknown = data;
       if (!isSingle) {
         if (data.length === 0)
           throw new Error(
@@ -358,12 +371,42 @@ export class Series<T extends TelemValue = TelemValue>
         data_ = data_.map((v) => new TimeStamp(v as CrudeTimeStamp).valueOf());
       if (this.dataType.equals(DataType.STRING)) {
         this.cachedLength = data_.length;
-        this._data = new TextEncoder().encode(`${data_.join("\n")}\n`).buffer;
+        const encoded = (data_ as string[]).map((s) => new TextEncoder().encode(s));
+        const totalBytes = encoded.reduce(
+          (acc, e) => acc + UINT32_SIZE + e.byteLength,
+          0,
+        );
+        const buf = new ArrayBuffer(totalBytes);
+        const view = new DataView(buf);
+        const bytes = new Uint8Array(buf);
+        let offset = 0;
+        for (const e of encoded) {
+          view.setUint32(offset, e.byteLength, true);
+          offset += UINT32_SIZE;
+          bytes.set(e, offset);
+          offset += e.byteLength;
+        }
+        this._data = buf;
       } else if (this.dataType.equals(DataType.JSON)) {
         this.cachedLength = data_.length;
-        this._data = new TextEncoder().encode(
-          `${data_.map((d) => binary.JSON_CODEC.encodeString(d)).join("\n")}\n`,
-        ).buffer;
+        const encoded = data_.map((d) =>
+          new TextEncoder().encode(binary.JSON_CODEC.encodeString(d)),
+        );
+        const totalBytes = encoded.reduce(
+          (acc, e) => acc + UINT32_SIZE + e.byteLength,
+          0,
+        );
+        const buf = new ArrayBuffer(totalBytes);
+        const view = new DataView(buf);
+        const bytes = new Uint8Array(buf);
+        let offset = 0;
+        for (const e of encoded) {
+          view.setUint32(offset, e.byteLength, true);
+          offset += UINT32_SIZE;
+          bytes.set(e, offset);
+          offset += e.byteLength;
+        }
+        this._data = buf;
       } else if (this.dataType.usesBigInt && typeof first === "number")
         this._data = new this.dataType.Array(
           data_.map((v) => BigInt(Math.round(v as number))),
@@ -456,14 +499,25 @@ export class Series<T extends TelemValue = TelemValue>
   private writeVariable(other: Series): number {
     if (this.writePos === FULL_BUFFER) return 0;
     const available = this.byteCapacity.valueOf() - this.writePos;
-    const toWrite = other.subBytes(0, available);
-    this.writeToUnderlyingData(toWrite);
-    this.writePos += toWrite.byteLength.valueOf();
-    if (this.cachedLength != null) {
-      this.cachedLength += toWrite.length;
-      this.calculateCachedLength();
+    const otherBuf = other.buffer;
+    const otherByteLen = other.byteLength.valueOf();
+    const view = new DataView(otherBuf);
+    let offset = 0;
+    let samplesWritten = 0;
+    while (offset + UINT32_SIZE <= otherByteLen) {
+      const sampleLen = view.getUint32(offset, true);
+      const recordSize = UINT32_SIZE + sampleLen;
+      if (offset + recordSize > available) break;
+      offset += recordSize;
+      samplesWritten++;
     }
-    return toWrite.length;
+    if (offset === 0) return 0;
+    const toWrite = other.subBytes(0, offset);
+    this.writeToUnderlyingData(toWrite);
+    this.writePos += offset;
+    this.cachedLength = (this.cachedLength ?? 0) + samplesWritten;
+    this._cachedIndexes = undefined;
+    return samplesWritten;
   }
 
   private writeFixed(other: Series): number {
@@ -511,8 +565,21 @@ export class Series<T extends TelemValue = TelemValue>
    * @returns An array of string representations of the series values.
    */
   toStrings(): string[] {
-    if (this.dataType.isVariable)
-      return new TextDecoder().decode(this.underlyingData).split("\n").slice(0, -1);
+    if (this.dataType.isVariable) {
+      const result: string[] = [];
+      const buf = this.buffer;
+      const byteLen = this.byteLength.valueOf();
+      const view = new DataView(buf);
+      const decoder = new TextDecoder();
+      let offset = 0;
+      while (offset + UINT32_SIZE <= byteLen) {
+        const len = view.getUint32(offset, true);
+        offset += UINT32_SIZE;
+        result.push(decoder.decode(new Uint8Array(buf, offset, len)));
+        offset += len;
+      }
+      return result;
+    }
     return Array.from(this).map((d) => d.toString());
   }
 
@@ -560,7 +627,7 @@ export class Series<T extends TelemValue = TelemValue>
 
   /**
    * Returns the number of samples in this array.
-   * For variable length data types, this is calculated by counting newlines.
+   * For variable length data types, this is calculated by scanning uint32 length prefixes.
    * @returns The number of samples in the series.
    */
   get length(): number {
@@ -575,12 +642,18 @@ export class Series<T extends TelemValue = TelemValue>
     if (!this.dataType.isVariable)
       throw new Error("cannot calculate length of a non-variable length data type");
     let cl = 0;
-    const ci: number[] = [0];
-    this.data.forEach((v, i) => {
-      if (v !== NEW_LINE) return;
+    const ci: number[] = [];
+    const buf = this.buffer;
+    const byteLen = this.byteLength.valueOf();
+    const view = new DataView(buf);
+    let offset = 0;
+    while (offset + UINT32_SIZE <= byteLen) {
+      const len = view.getUint32(offset, true);
+      offset += UINT32_SIZE;
+      ci.push(offset);
+      offset += len;
       cl++;
-      ci.push(i + 1);
-    });
+    }
     this._cachedIndexes = ci;
     this.cachedLength = cl;
     return cl;
@@ -634,7 +707,7 @@ export class Series<T extends TelemValue = TelemValue>
       throw new Error("cannot calculate maximum on a variable length data type");
     if (this.writePos === 0) return -Infinity;
     this.cachedMax ??= this.calcRawMax();
-    return math.add(this.cachedMax, this.sampleOffset);
+    return this.applyOffset(this.cachedMax);
   }
 
   private calcRawMin(): math.Numeric {
@@ -660,7 +733,7 @@ export class Series<T extends TelemValue = TelemValue>
       throw new Error("cannot calculate minimum on a variable length data type");
     if (this.writePos === 0) return Infinity;
     this.cachedMin ??= this.calcRawMin();
-    return math.add(this.cachedMin, this.sampleOffset);
+    return this.applyOffset(this.cachedMin);
   }
 
   /** @returns the bounds of the series. */
@@ -717,7 +790,12 @@ export class Series<T extends TelemValue = TelemValue>
   at(index: number, required?: false): T | undefined;
 
   at(index: number, required: boolean = false): T | undefined {
-    if (this.dataType.isVariable) return this.atVariable(index, required ?? false);
+    if (this.dataType.isVariable) {
+      const str = this.atVariable(index, required);
+      if (str == null) return undefined;
+      if (this.dataType.equals(DataType.STRING)) return str as T;
+      return caseconv.snakeToCamel(JSON.parse(str)) as T;
+    }
     if (this.dataType.equals(DataType.UUID)) return this.atUUID(index, required) as T;
     if (index < 0) index = this.length + index;
     const v = this.data[index];
@@ -725,7 +803,16 @@ export class Series<T extends TelemValue = TelemValue>
       if (required === true) throw new Error(`[series] - no value at index ${index}`);
       return undefined;
     }
-    return math.add(v, this.sampleOffset) as T;
+    return this.applyOffset(v) as T;
+  }
+
+  // For huge bigint offsets (i64 timestamps narrowed to float32 for GL), math.add would
+  // coerce through Number() and lose precision above 2^53; do the addition in bigint
+  // space when the offset is a bigint.
+  private applyOffset(v: math.Numeric): math.Numeric {
+    if (typeof this.sampleOffset === "bigint" && typeof v === "number")
+      return BigInt(Math.round(v)) + this.sampleOffset;
+    return math.add(v, this.sampleOffset);
   }
 
   private atUUID(index: number, required: boolean): string | undefined {
@@ -740,33 +827,56 @@ export class Series<T extends TelemValue = TelemValue>
     return uuidString;
   }
 
-  private atVariable(index: number, required: boolean): T | undefined {
+  asString(index: number, required: true): string;
+
+  asString(index: number, required?: false): string | undefined;
+
+  asString(index: number, required: boolean = false): string | undefined {
+    if (this.dataType.isVariable) return this.atVariable(index, required);
+    if (this.dataType.equals(DataType.UUID)) return this.atUUID(index, required);
+    const v = this.at(index, required as true);
+    if (v == null) return undefined;
+    if (this.dataType.equals(DataType.FLOAT32)) return stringifyFloat32(v as number);
+    return String(v);
+  }
+
+  private atVariable(index: number, required: boolean): string | undefined {
     let start = 0;
-    let end = 0;
+    let len = 0;
+    const buf = this.buffer;
+    const view = new DataView(buf);
     if (this._cachedIndexes != null) {
+      if (index < 0) index = this._cachedIndexes.length + index;
+      if (index < 0 || index >= this._cachedIndexes.length) {
+        if (required) throw new Error(`[series] - no value at index ${index}`);
+        return undefined;
+      }
       start = this._cachedIndexes[index];
-      end = this._cachedIndexes[index + 1] - 1;
+      len = view.getUint32(start - UINT32_SIZE, true);
     } else {
       if (index < 0) index = this.length + index;
-      for (let i = 0; i < this.data.length; i++)
-        if (this.data[i] === NEW_LINE) {
-          if (index === 0) {
-            end = i;
-            break;
-          }
-          start = i + 1;
-          index--;
+      const byteLen = this.byteLength.valueOf();
+      let offset = 0;
+      let found = false;
+      while (offset + UINT32_SIZE <= byteLen) {
+        const sampleLen = view.getUint32(offset, true);
+        offset += UINT32_SIZE;
+        if (index === 0) {
+          start = offset;
+          len = sampleLen;
+          found = true;
+          break;
         }
-      if (end === 0) end = this.data.length;
-      if (start >= end || index > 0) {
+        offset += sampleLen;
+        index--;
+      }
+      if (!found) {
         if (required) throw new Error(`[series] - no value at index ${index}`);
         return undefined;
       }
     }
-    const slice = this.data.slice(start, end);
-    if (this.dataType.equals(DataType.STRING))
-      return new TextDecoder().decode(slice) as T;
-    return caseconv.snakeToCamel(JSON.parse(new TextDecoder().decode(slice))) as T;
+    const slice = new Uint8Array(buf, start, len);
+    return new TextDecoder().decode(slice);
   }
 
   /**
@@ -1069,8 +1179,9 @@ class SubIterator<T> implements Iterator<T> {
 
 class StringSeriesIterator implements Iterator<string> {
   private readonly series: Series;
-  private index: number;
+  private byteOffset: number;
   private readonly decoder: TextDecoder;
+  private readonly view: DataView;
 
   constructor(series: Series) {
     if (!series.dataType.isVariable)
@@ -1078,18 +1189,21 @@ class StringSeriesIterator implements Iterator<string> {
         "cannot create a variable series iterator for a non-variable series",
       );
     this.series = series;
-    this.index = 0;
+    this.byteOffset = 0;
     this.decoder = new TextDecoder();
+    this.view = new DataView(series.buffer);
   }
 
   next(): IteratorResult<string> {
-    const start = this.index;
-    const data = this.series.data;
-    while (this.index < data.length && data[this.index] !== NEW_LINE) this.index++;
-    const end = this.index;
-    if (start === end) return { done: true, value: undefined };
-    this.index++;
-    const s = this.decoder.decode(this.series.buffer.slice(start, end));
+    const byteLen = this.series.byteLength.valueOf();
+    if (this.byteOffset + UINT32_SIZE > byteLen)
+      return { done: true, value: undefined };
+    const len = this.view.getUint32(this.byteOffset, true);
+    this.byteOffset += UINT32_SIZE;
+    const s = this.decoder.decode(
+      new Uint8Array(this.series.buffer, this.byteOffset, len),
+    );
+    this.byteOffset += len;
     return { done: false, value: s };
   }
 }