Function appendSeries

src/data/createDataStore.ts:198–280

(index: number, newPoints: ReadonlyArray<DataPoint>)

  };

  const appendSeries = (index: number, newPoints: ReadonlyArray<DataPoint>): void => {
    assertNotDisposed();
    if (!newPoints || newPoints.length === 0) return;

    const existing = getSeriesEntry(index);
    const prevPointCount = existing.pointCount;
    const nextPointCount = prevPointCount + newPoints.length;

    const appendPacked =
      existing.xOffset === 0 ? packDataPoints(newPoints) : packDataPointsWithXOffset(newPoints, existing.xOffset);
    const appendBytes = appendPacked.byteLength;

    // Each point is 2 floats (x, y) = 8 bytes.
    const requiredBytes = roundUpToMultipleOf4(nextPointCount * 2 * 4);
    const targetBytes = Math.max(MIN_BUFFER_BYTES, requiredBytes);

    let buffer = existing.buffer;
    let capacityBytes = existing.capacityBytes;

    // Ensure the CPU-side store is updated regardless of GPU growth path.
    const nextData = existing.data;
    nextData.push(...newPoints);

    const maxBufferSize = device.limits.maxBufferSize;

    if (targetBytes > capacityBytes) {
      if (targetBytes > maxBufferSize) {
        throw new Error(
          `DataStore.appendSeries(${index}): required buffer size ${targetBytes} exceeds device.limits.maxBufferSize (${maxBufferSize}).`
        );
      }

      // Replace buffer (no shrink). This is the slow path; we re-upload the full series.
      try {
        buffer.destroy();
      } catch {
        // Ignore destroy errors; we are replacing the buffer anyway.
      }

      const grownCapacityBytes = computeGrownCapacityBytes(capacityBytes, targetBytes);
      capacityBytes = grownCapacityBytes > maxBufferSize ? targetBytes : grownCapacityBytes;

      buffer = device.createBuffer({
        size: capacityBytes,
        usage: GPUBufferUsage.VERTEX | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
      });

      const fullPacked =
        existing.xOffset === 0 ? packDataPoints(nextData) : packDataPointsWithXOffset(nextData, existing.xOffset);
      if (fullPacked.byteLength > 0) {
        device.queue.writeBuffer(buffer, 0, fullPacked.buffer);
      }

      series.set(index, {
        buffer,
        capacityBytes,
        pointCount: nextPointCount,
        hash32: hashFloat32ArrayBits(fullPacked),