velo-plot 1.11.1

package/dist/plugins/gpu.js

@@ -0,0 +1,2430 @@
+var L = Object.defineProperty;
+var F = (s, e, t) => e in s ? L(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var c = (s, e, t) => F(s, typeof e != "symbol" ? e + "" : e, t);
+class Te {
+  constructor() {
+    c(this, "entries", /* @__PURE__ */ new Map());
+  }
+  getInfo(e) {
+    return this.entries.get(e);
+  }
+  has(e) {
+    return this.entries.has(e);
+  }
+  keys() {
+    return this.entries.keys();
+  }
+  get size() {
+    return this.entries.size;
+  }
+}
+class Me {
+  constructor() {
+    c(this, "entries", /* @__PURE__ */ new Map());
+  }
+  getInfo(e) {
+    return this.entries.get(e);
+  }
+  has(e) {
+    return this.entries.has(e);
+  }
+  keys() {
+    return this.entries.keys();
+  }
+  get size() {
+    return this.entries.size;
+  }
+}
+function S(s) {
+  return s.variant ? `${s.kind}:${s.variant}` : s.kind;
+}
+class ke {
+  constructor() {
+    c(this, "pipelines", /* @__PURE__ */ new Map());
+  }
+  getOrCreate(e, t) {
+    const i = S(e);
+    if (!this.pipelines.has(i)) {
+      const r = t();
+      this.pipelines.set(i, r);
+    }
+    return this.pipelines.get(i);
+  }
+  has(e) {
+    return this.pipelines.has(S(e));
+  }
+  delete(e) {
+    this.pipelines.delete(S(e));
+  }
+  get size() {
+    return this.pipelines.size;
+  }
+  destroy() {
+    this.pipelines.clear();
+  }
+}
+function U(s) {
+  if (!s)
+    return [1, 0, 0.3, 1];
+  if (Array.isArray(s))
+    return [s[0], s[1], s[2], s[3] ?? 1];
+  const e = s;
+  if (e.startsWith("#")) {
+    const i = e.slice(1);
+    if (i.length === 3) {
+      const r = parseInt(i[0] + i[0], 16) / 255, a = parseInt(i[1] + i[1], 16) / 255, n = parseInt(i[2] + i[2], 16) / 255;
+      return [r, a, n, 1];
+    }
+    if (i.length === 6) {
+      const r = parseInt(i.slice(0, 2), 16) / 255, a = parseInt(i.slice(2, 4), 16) / 255, n = parseInt(i.slice(4, 6), 16) / 255;
+      return [r, a, n, 1];
+    }
+    if (i.length === 8) {
+      const r = parseInt(i.slice(0, 2), 16) / 255, a = parseInt(i.slice(2, 4), 16) / 255, n = parseInt(i.slice(4, 6), 16) / 255, o = parseInt(i.slice(6, 8), 16) / 255;
+      return [r, a, n, o];
+    }
+  }
+  const t = e.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)/);
+  if (t) {
+    const i = parseInt(t[1]) / 255, r = parseInt(t[2]) / 255, a = parseInt(t[3]) / 255, n = t[4] ? parseFloat(t[4]) : 1;
+    return [i, r, a, n];
+  }
+  return [1, 0, 0.3, 1];
+}
+function D(s, e) {
+  const t = U(s.color), i = s.opacity ?? 1, r = [t[0], t[1], t[2], t[3] * i];
+  return e === "scatter" || e === "line+scatter" || e === "step+scatter" ? {
+    color: r,
+    opacity: i,
+    pointSize: s.pointSize ?? 4,
+    symbol: s.symbol ?? "circle"
+  } : {
+    color: r,
+    opacity: i,
+    lineWidth: s.lineWidth ?? 1
+  };
+}
+class M {
+  constructor(e) {
+    c(this, "backend");
+    c(this, "seriesBufferMap", /* @__PURE__ */ new Map());
+    c(this, "seriesStepBufferMap", /* @__PURE__ */ new Map());
+    c(this, "seriesTextureMap", /* @__PURE__ */ new Map());
+    this.backend = e;
+  }
+  /**
+   * Get buffer ID for a series
+   */
+  getBufferId(e) {
+    return this.seriesBufferMap.has(e) || this.seriesBufferMap.set(e, `series:${e}`), this.seriesBufferMap.get(e);
+  }
+  /**
+   * Get step buffer ID for a series
+   */
+  getStepBufferId(e) {
+    return this.seriesStepBufferMap.has(e) || this.seriesStepBufferMap.set(e, `series:${e}:step`), this.seriesStepBufferMap.get(e);
+  }
+  /**
+   * Get texture ID for a series
+   */
+  getTextureId(e) {
+    return this.seriesTextureMap.has(e) || this.seriesTextureMap.set(e, `texture:${e}`), this.seriesTextureMap.get(e);
+  }
+  /**
+   * Update series data in GPU buffers
+   */
+  updateSeries(e) {
+    const t = this.getBufferId(e.id);
+    if (this.backend.createOrUpdateBuffer(t, e.data, { usage: "vertex" }), e.stepData && (e.type === "step" || e.type === "step+scatter")) {
+      const i = this.getStepBufferId(e.id);
+      this.backend.createOrUpdateBuffer(i, e.stepData, { usage: "vertex" });
+    }
+    if (e.type === "heatmap" && e.colormapData) {
+      const i = this.getTextureId(e.id);
+      this.backend.createOrUpdateTexture1D(i, e.colormapData, {
+        width: e.colormapData.length / 4
+      });
+    }
+  }
+  /**
+   * Remove a series from GPU resources
+   */
+  removeSeries(e) {
+    const t = this.seriesBufferMap.get(e);
+    t && (this.backend.deleteBuffer(t), this.seriesBufferMap.delete(e));
+    const i = this.seriesStepBufferMap.get(e);
+    i && (this.backend.deleteBuffer(i), this.seriesStepBufferMap.delete(e));
+    const r = this.seriesTextureMap.get(e);
+    r && (this.backend.deleteTexture(r), this.seriesTextureMap.delete(e));
+  }
+  /**
+   * Build draw list from series array
+   */
+  buildDrawList(e) {
+    const t = [];
+    for (const i of e) {
+      this.updateSeries(i);
+      const r = this.getBufferId(i.id), a = i.data.length / 2, n = {
+        id: i.id,
+        kind: i.type,
+        bufferId: r,
+        count: i.type === "heatmap" ? i.data.length / 3 : a,
+        visible: i.visible,
+        style: D(i.style, i.type),
+        yBounds: i.yBounds
+      };
+      i.stepData && (i.type === "step" || i.type === "step+scatter") && (n.stepBufferId = this.getStepBufferId(i.id), n.stepCount = i.stepData.length / 2), i.type === "heatmap" && (n.textureId = this.getTextureId(i.id), n.style = {
+        zBounds: i.zBounds,
+        colormap: i.colormap
+      }), t.push(n);
+    }
+    return { items: t };
+  }
+  /**
+   * Cleanup all resources
+   */
+  destroy() {
+    for (const e of this.seriesBufferMap.values())
+      this.backend.deleteBuffer(e);
+    for (const e of this.seriesStepBufferMap.values())
+      this.backend.deleteBuffer(e);
+    for (const e of this.seriesTextureMap.values())
+      this.backend.deleteTexture(e);
+    this.seriesBufferMap.clear(), this.seriesStepBufferMap.clear(), this.seriesTextureMap.clear();
+  }
+}
+const I = `
+struct VSOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) color: vec4<f32>,
+};
+
+@vertex
+fn vs_main(
+  @location(0) position: vec2<f32>,
+  @location(1) color: vec4<f32>
+) -> VSOut {
+  var out: VSOut;
+  out.pos = vec4<f32>(position, 0.0, 1.0);
+  out.color = color;
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOut) -> @location(0) vec4<f32> {
+  return in.color;
+}
+`;
+function O(s, e) {
+  const t = s.createShaderModule({ code: I }), i = 6 * 4;
+  return { pipeline: s.createRenderPipeline({
+    layout: "auto",
+    vertex: {
+      module: t,
+      entryPoint: "vs_main",
+      buffers: [
+        {
+          arrayStride: i,
+          attributes: [
+            { shaderLocation: 0, offset: 0, format: "float32x2" },
+            { shaderLocation: 1, offset: 2 * 4, format: "float32x4" }
+          ]
+        }
+      ]
+    },
+    fragment: {
+      module: t,
+      entryPoint: "fs_main",
+      targets: [{ format: e }]
+    },
+    primitive: {
+      topology: "triangle-list",
+      cullMode: "none"
+    }
+  }), vertexStride: i };
+}
+const C = `
+// Uniform buffer for transforms and color
+struct Uniforms {
+  scale: vec2<f32>,
+  translate: vec2<f32>,
+  color: vec4<f32>,
+};
+
+@group(0) @binding(0)
+var<uniform> uniforms: Uniforms;
+
+struct VSInput {
+  @location(0) position: vec2<f32>,
+};
+
+struct VSOutput {
+  @builtin(position) pos: vec4<f32>,
+};
+
+@vertex
+fn vs_main(in: VSInput) -> VSOutput {
+  var out: VSOutput;
+  let transformed = in.position * uniforms.scale + uniforms.translate;
+  out.pos = vec4<f32>(transformed, 0.0, 1.0);
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOutput) -> @location(0) vec4<f32> {
+  return uniforms.color;
+}
+`, w = 2 * 4, z = 32;
+function V(s, e) {
+  const t = s.createShaderModule({ code: C }), i = globalThis.GPUShaderStage, r = globalThis.GPUBufferUsage, a = s.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: i.VERTEX | i.FRAGMENT,
+        buffer: { type: "uniform" }
+      }
+    ]
+  }), n = s.createBuffer({
+    size: z,
+    usage: r.UNIFORM | r.COPY_DST
+  }), o = s.createBindGroup({
+    layout: a,
+    entries: [
+      {
+        binding: 0,
+        resource: { buffer: n }
+      }
+    ]
+  }), u = s.createPipelineLayout({
+    bindGroupLayouts: [a]
+  });
+  return {
+    pipeline: s.createRenderPipeline({
+      layout: u,
+      vertex: {
+        module: t,
+        entryPoint: "vs_main",
+        buffers: [
+          {
+            arrayStride: w,
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x2" }
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: t,
+        entryPoint: "fs_main",
+        targets: [
+          {
+            format: e,
+            blend: {
+              color: {
+                srcFactor: "src-alpha",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              },
+              alpha: {
+                srcFactor: "one",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              }
+            }
+          }
+        ]
+      },
+      primitive: {
+        topology: "line-strip",
+        stripIndexFormat: void 0
+      }
+    }),
+    bindGroupLayout: a,
+    uniformBuffer: n,
+    bindGroup: o,
+    vertexStride: w
+  };
+}
+function W(s, e, t) {
+  const i = new Float32Array([
+    t.scale[0],
+    t.scale[1],
+    t.translate[0],
+    t.translate[1],
+    t.color[0],
+    t.color[1],
+    t.color[2],
+    t.color[3]
+  ]);
+  s.queue.writeBuffer(e, 0, i);
+}
+const N = `
+// Uniform buffer for transforms, color, point properties
+struct Uniforms {
+  scale: vec2<f32>,
+  translate: vec2<f32>,
+  color: vec4<f32>,
+  pointSize: f32,
+  symbol: i32,
+  viewport: vec2<f32>, // viewport dimensions for proper sizing
+};
+
+@group(0) @binding(0)
+var<uniform> uniforms: Uniforms;
+
+struct VSInput {
+  @location(0) position: vec2<f32>,  // point center position
+  @location(1) quadOffset: vec2<f32>, // quad vertex offset (-1 to 1)
+};
+
+struct VSOutput {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) uv: vec2<f32>, // -0.5 to 0.5 for SDF
+};
+
+@vertex
+fn vs_main(in: VSInput) -> VSOutput {
+  var out: VSOutput;
+  
+  // Transform point position to NDC
+  let transformed = in.position * uniforms.scale + uniforms.translate;
+  
+  // Calculate point size in NDC
+  let pointSizeNDC = vec2<f32>(
+    uniforms.pointSize / uniforms.viewport.x * 2.0,
+    uniforms.pointSize / uniforms.viewport.y * 2.0
+  );
+  
+  // Apply quad offset
+  let offset = in.quadOffset * pointSizeNDC * 0.5;
+  
+  out.pos = vec4<f32>(transformed + offset, 0.0, 1.0);
+  out.uv = in.quadOffset * 0.5; // -0.5 to 0.5
+  
+  return out;
+}
+
+// SDF functions
+fn sdCircle(p: vec2<f32>, r: f32) -> f32 {
+  return length(p) - r;
+}
+
+fn sdBox(p: vec2<f32>, b: vec2<f32>) -> f32 {
+  let d = abs(p) - b;
+  return length(max(d, vec2<f32>(0.0))) + min(max(d.x, d.y), 0.0);
+}
+
+fn sdDiamond(p: vec2<f32>, r: f32) -> f32 {
+  return (abs(p.x) + abs(p.y)) - r;
+}
+
+fn sdTriangle(p_in: vec2<f32>, r: f32) -> f32 {
+  let k = sqrt(3.0);
+  var p = p_in;
+  p.x = abs(p.x) - r;
+  p.y = p.y + r / k;
+  if (p.x + k * p.y > 0.0) {
+    p = vec2<f32>(p.x - k * p.y, -k * p.x - p.y) / 2.0;
+  }
+  p.x = p.x - clamp(p.x, -2.0 * r, 0.0);
+  return -length(p) * sign(p.y);
+}
+
+fn sdCross(p: vec2<f32>, r: f32, thickness: f32) -> f32 {
+  let d = abs(p);
+  let s1 = sdBox(d, vec2<f32>(r, thickness));
+  let s2 = sdBox(d, vec2<f32>(thickness, r));
+  return min(s1, s2);
+}
+
+fn sdX(p: vec2<f32>, r: f32, thickness: f32) -> f32 {
+  let c = cos(0.785398);
+  let s = sin(0.785398);
+  let m = mat2x2<f32>(c, -s, s, c);
+  return sdCross(m * p, r, thickness);
+}
+
+fn sdStar(p_in: vec2<f32>, r: f32, rf: f32) -> f32 {
+  let k1 = vec2<f32>(0.80901699, -0.58778525);
+  let k2 = vec2<f32>(-k1.x, k1.y);
+  var p = p_in;
+  p.x = abs(p.x);
+  p = p - 2.0 * max(dot(k1, p), 0.0) * k1;
+  p = p - 2.0 * max(dot(k2, p), 0.0) * k2;
+  p.x = abs(p.x);
+  p.y = p.y - r;
+  let ba = rf * vec2<f32>(-k1.y, k1.x) - vec2<f32>(0.0, 1.0);
+  let h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);
+  return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);
+}
+
+@fragment
+fn fs_main(in: VSOutput) -> @location(0) vec4<f32> {
+  var d: f32 = 0.0;
+  
+  if (uniforms.symbol == 0) {
+    d = sdCircle(in.uv, 0.45);
+  } else if (uniforms.symbol == 1) {
+    d = sdBox(in.uv, vec2<f32>(0.35));
+  } else if (uniforms.symbol == 2) {
+    d = sdDiamond(in.uv, 0.45);
+  } else if (uniforms.symbol == 3) {
+    d = sdTriangle(vec2<f32>(in.uv.x, in.uv.y + 0.1), 0.4);
+  } else if (uniforms.symbol == 4) {
+    d = sdTriangle(vec2<f32>(in.uv.x, -in.uv.y + 0.1), 0.4);
+  } else if (uniforms.symbol == 5) {
+    d = sdCross(in.uv, 0.45, 0.15);
+  } else if (uniforms.symbol == 6) {
+    d = sdX(in.uv, 0.45, 0.15);
+  } else if (uniforms.symbol == 7) {
+    d = sdStar(in.uv, 0.45, 0.4);
+  }
+  
+  if (d > 0.02) {
+    discard;
+  }
+  
+  let alpha = 1.0 - smoothstep(0.0, 0.02, d);
+  return vec4<f32>(uniforms.color.rgb, uniforms.color.a * alpha);
+}
+`, k = 2 * 4, q = 48, A = new Float32Array([
+  -1,
+  -1,
+  // bottom-left
+  1,
+  -1,
+  // bottom-right
+  -1,
+  1,
+  // top-left
+  -1,
+  1,
+  // top-left
+  1,
+  -1,
+  // bottom-right
+  1,
+  1
+  // top-right
+]);
+function Y(s, e) {
+  const t = s.createShaderModule({ code: N }), i = globalThis.GPUShaderStage, r = globalThis.GPUBufferUsage, a = s.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: i.VERTEX | i.FRAGMENT,
+        buffer: { type: "uniform" }
+      }
+    ]
+  }), n = s.createBuffer({
+    size: q,
+    usage: r.UNIFORM | r.COPY_DST
+  }), o = s.createBuffer({
+    size: A.byteLength,
+    usage: r.VERTEX | r.COPY_DST,
+    mappedAtCreation: !0
+  });
+  new Float32Array(o.getMappedRange()).set(A), o.unmap();
+  const u = s.createBindGroup({
+    layout: a,
+    entries: [
+      {
+        binding: 0,
+        resource: { buffer: n }
+      }
+    ]
+  }), l = s.createPipelineLayout({
+    bindGroupLayouts: [a]
+  });
+  return {
+    pipeline: s.createRenderPipeline({
+      layout: l,
+      vertex: {
+        module: t,
+        entryPoint: "vs_main",
+        buffers: [
+          // Point positions (instanced)
+          {
+            arrayStride: k,
+            stepMode: "instance",
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x2" }
+            ]
+          },
+          // Quad vertex offsets (per-vertex)
+          {
+            arrayStride: 8,
+            // 2 floats
+            stepMode: "vertex",
+            attributes: [
+              { shaderLocation: 1, offset: 0, format: "float32x2" }
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: t,
+        entryPoint: "fs_main",
+        targets: [
+          {
+            format: e,
+            blend: {
+              color: {
+                srcFactor: "src-alpha",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              },
+              alpha: {
+                srcFactor: "one",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              }
+            }
+          }
+        ]
+      },
+      primitive: {
+        topology: "triangle-list",
+        cullMode: "none"
+      }
+    }),
+    bindGroupLayout: a,
+    uniformBuffer: n,
+    bindGroup: u,
+    quadBuffer: o,
+    vertexStride: k
+  };
+}
+function X(s, e, t) {
+  const i = new Float32Array([
+    t.scale[0],
+    t.scale[1],
+    t.translate[0],
+    t.translate[1],
+    t.color[0],
+    t.color[1],
+    t.color[2],
+    t.color[3],
+    t.pointSize,
+    t.symbol,
+    // Will be cast to i32 in shader via bitcast
+    t.viewport[0],
+    t.viewport[1]
+  ]);
+  s.queue.writeBuffer(e, 0, i);
+}
+const $ = {
+  circle: 0,
+  square: 1,
+  diamond: 2,
+  triangle: 3,
+  triangleDown: 4,
+  cross: 5,
+  x: 6,
+  star: 7
+}, H = 32;
+function j(s, e) {
+  const t = s.createShaderModule({ code: C }), i = globalThis.GPUShaderStage, r = globalThis.GPUBufferUsage, a = s.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: i.VERTEX | i.FRAGMENT,
+        buffer: { type: "uniform" }
+      }
+    ]
+  }), n = s.createBuffer({
+    size: H,
+    usage: r.UNIFORM | r.COPY_DST
+  }), o = s.createBindGroup({
+    layout: a,
+    entries: [
+      {
+        binding: 0,
+        resource: { buffer: n }
+      }
+    ]
+  }), u = s.createPipelineLayout({
+    bindGroupLayouts: [a]
+  });
+  return {
+    pipeline: s.createRenderPipeline({
+      layout: u,
+      vertex: {
+        module: t,
+        entryPoint: "vs_main",
+        buffers: [
+          {
+            arrayStride: w,
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x2" }
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: t,
+        entryPoint: "fs_main",
+        targets: [
+          {
+            format: e,
+            blend: {
+              color: {
+                srcFactor: "src-alpha",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              },
+              alpha: {
+                srcFactor: "one",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              }
+            }
+          }
+        ]
+      },
+      primitive: {
+        topology: "triangle-strip",
+        // Key difference from line pipeline
+        stripIndexFormat: void 0
+      }
+    }),
+    bindGroupLayout: a,
+    uniformBuffer: n,
+    bindGroup: o,
+    vertexStride: w
+  };
+}
+function Z(s, e, t) {
+  const i = new Float32Array([
+    t.scale[0],
+    t.scale[1],
+    t.translate[0],
+    t.translate[1],
+    t.color[0],
+    t.color[1],
+    t.color[2],
+    t.color[3]
+  ]);
+  s.queue.writeBuffer(e, 0, i);
+}
+const K = `
+// Uniform buffer for transforms and value range
+struct Uniforms {
+  scale: vec2<f32>,
+  translate: vec2<f32>,
+  minValue: f32,
+  maxValue: f32,
+  _padding: vec2<f32>,
+};
+
+@group(0) @binding(0)
+var<uniform> uniforms: Uniforms;
+
+@group(0) @binding(1)
+var colormapSampler: sampler;
+
+@group(0) @binding(2)
+var colormapTexture: texture_1d<f32>;
+
+struct VSInput {
+  @location(0) position: vec2<f32>,
+  @location(1) value: f32,
+};
+
+struct VSOutput {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) value: f32,
+};
+
+@vertex
+fn vs_main(in: VSInput) -> VSOutput {
+  var out: VSOutput;
+  let transformed = in.position * uniforms.scale + uniforms.translate;
+  out.pos = vec4<f32>(transformed, 0.0, 1.0);
+  out.value = in.value;
+  return out;
+}
+
+@fragment
+fn fs_main(in: VSOutput) -> @location(0) vec4<f32> {
+  let range = uniforms.maxValue - uniforms.minValue;
+  var t: f32;
+  if (range != 0.0) {
+    t = (in.value - uniforms.minValue) / range;
+  } else {
+    t = 0.0;
+  }
+  t = clamp(t, 0.0, 1.0);
+  
+  return textureSample(colormapTexture, colormapSampler, t);
+}
+`, G = 3 * 4, Q = 32;
+function J(s, e) {
+  const t = s.createShaderModule({ code: K }), i = globalThis.GPUShaderStage, r = globalThis.GPUBufferUsage, a = s.createBindGroupLayout({
+    entries: [
+      {
+        binding: 0,
+        visibility: i.VERTEX | i.FRAGMENT,
+        buffer: { type: "uniform" }
+      },
+      {
+        binding: 1,
+        visibility: i.FRAGMENT,
+        sampler: {}
+      },
+      {
+        binding: 2,
+        visibility: i.FRAGMENT,
+        texture: {
+          sampleType: "float",
+          viewDimension: "1d"
+        }
+      }
+    ]
+  }), n = s.createBuffer({
+    size: Q,
+    usage: r.UNIFORM | r.COPY_DST
+  }), o = s.createSampler({
+    magFilter: "linear",
+    minFilter: "linear",
+    addressModeU: "clamp-to-edge"
+  }), u = s.createPipelineLayout({
+    bindGroupLayouts: [a]
+  });
+  return {
+    pipeline: s.createRenderPipeline({
+      layout: u,
+      vertex: {
+        module: t,
+        entryPoint: "vs_main",
+        buffers: [
+          {
+            arrayStride: G,
+            attributes: [
+              { shaderLocation: 0, offset: 0, format: "float32x2" },
+              // position
+              { shaderLocation: 1, offset: 8, format: "float32" }
+              // value
+            ]
+          }
+        ]
+      },
+      fragment: {
+        module: t,
+        entryPoint: "fs_main",
+        targets: [
+          {
+            format: e,
+            blend: {
+              color: {
+                srcFactor: "src-alpha",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              },
+              alpha: {
+                srcFactor: "one",
+                dstFactor: "one-minus-src-alpha",
+                operation: "add"
+              }
+            }
+          }
+        ]
+      },
+      primitive: {
+        topology: "triangle-list",
+        cullMode: "none"
+      }
+    }),
+    bindGroupLayout: a,
+    uniformBuffer: n,
+    sampler: o,
+    vertexStride: G
+  };
+}
+function ee(s, e, t, i, r) {
+  return s.createBindGroup({
+    layout: e,
+    entries: [
+      { binding: 0, resource: { buffer: t } },
+      { binding: 1, resource: i },
+      { binding: 2, resource: r.createView() }
+    ]
+  });
+}
+function te(s, e, t) {
+  const i = new Float32Array([
+    t.scale[0],
+    t.scale[1],
+    t.translate[0],
+    t.translate[1],
+    t.minValue,
+    t.maxValue,
+    0,
+    // padding
+    0
+    // padding
+  ]);
+  s.queue.writeBuffer(e, 0, i);
+}
+function ie(s) {
+  const e = s.xMax - s.xMin, t = s.yMax - s.yMin, i = e > 0 ? 2 / e : 1, r = t > 0 ? 2 / t : 1, a = -1 - s.xMin * i, n = -1 - s.yMin * r;
+  return {
+    scale: [i, r],
+    translate: [a, n]
+  };
+}
+function re(s) {
+  const e = (s == null ? void 0 : s.color) ?? [1, 0, 0.3, 1], t = (s == null ? void 0 : s.opacity) ?? 1;
+  return Array.isArray(e) ? [e[0], e[1], e[2], (e[3] ?? 1) * t] : [1, 0, 0.3, t];
+}
+class _ {
+  constructor(e, t = {}) {
+    c(this, "info");
+    c(this, "canvas");
+    c(this, "opts");
+    c(this, "viewport", null);
+    c(this, "adapter");
+    c(this, "device");
+    c(this, "context");
+    c(this, "format", null);
+    c(this, "buffers", /* @__PURE__ */ new Map());
+    c(this, "textures", /* @__PURE__ */ new Map());
+    // Pipelines for different draw types
+    c(this, "trianglePipeline", null);
+    c(this, "linePipeline", null);
+    c(this, "pointPipeline", null);
+    c(this, "bandPipeline", null);
+    c(this, "heatmapPipeline", null);
+    // Heatmap bind groups (per texture)
+    c(this, "heatmapBindGroups", /* @__PURE__ */ new Map());
+    this.canvas = e, this.opts = t, this.info = {
+      type: "webgpu",
+      available: _.isSupported()
+    };
+  }
+  static isSupported() {
+    return typeof globalThis.navigator < "u" && typeof globalThis.navigator.gpu < "u";
+  }
+  async init() {
+    if (!this.info.available)
+      throw new Error("[gpu] WebGPU not supported");
+    const e = globalThis.navigator.gpu;
+    if (this.adapter = await e.requestAdapter({
+      powerPreference: this.opts.powerPreference ?? "high-performance"
+    }), !this.adapter)
+      throw new Error("[gpu] Failed to request WebGPU adapter");
+    this.device = await this.adapter.requestDevice();
+    const t = this.canvas.getContext("webgpu");
+    if (!t)
+      throw new Error("[gpu] Failed to get WebGPU canvas context");
+    this.context = t;
+    const i = this.opts.preferredFormat ?? (e.getPreferredCanvasFormat ? e.getPreferredCanvasFormat() : "bgra8unorm");
+    this.format = i, this.context.configure({
+      device: this.device,
+      format: i,
+      alphaMode: "premultiplied"
+    });
+  }
+  setViewport(e) {
+    this.viewport = e;
+    const t = Math.max(1, Math.floor(e.width * e.dpr)), i = Math.max(1, Math.floor(e.height * e.dpr));
+    this.canvas.width !== t && (this.canvas.width = t), this.canvas.height !== i && (this.canvas.height = i);
+  }
+  createOrUpdateBuffer(e, t, i) {
+    if (!this.device)
+      throw new Error("[gpu] WebGPUBackend not initialized");
+    const r = (i == null ? void 0 : i.usage) ?? "vertex", a = globalThis.GPUBufferUsage;
+    if (!a)
+      throw new Error(
+        "[gpu] GPUBufferUsage not available (missing WebGPU runtime)"
+      );
+    const n = r === "index" ? a.INDEX | a.COPY_DST : r === "uniform" ? a.UNIFORM | a.COPY_DST : a.VERTEX | a.COPY_DST, o = t.byteLength;
+    let u = this.buffers.get(e);
+    if (!u || u.size < o) {
+      if (u)
+        try {
+          u.destroy();
+        } catch {
+        }
+      u = this.device.createBuffer({
+        size: Math.max(4, o),
+        usage: n
+      }), this.buffers.set(e, u);
+    }
+    this.device.queue.writeBuffer(
+      u,
+      0,
+      t.buffer,
+      t.byteOffset,
+      t.byteLength
+    );
+  }
+  deleteBuffer(e) {
+    const t = this.buffers.get(e);
+    if (t) {
+      try {
+        t.destroy();
+      } catch {
+      }
+      this.buffers.delete(e);
+    }
+  }
+  createOrUpdateTexture1D(e, t, i) {
+    if (!this.device)
+      throw new Error("[gpu] WebGPUBackend not initialized");
+    const r = (i == null ? void 0 : i.width) ?? Math.floor(t.length / 4), a = (i == null ? void 0 : i.format) ?? "rgba8unorm", n = globalThis.GPUTextureUsage;
+    if (!n)
+      throw new Error(
+        "[gpu] GPUTextureUsage not available (missing WebGPU runtime)"
+      );
+    let o = this.textures.get(e);
+    o || (o = this.device.createTexture({
+      size: { width: r, height: 1, depthOrArrayLayers: 1 },
+      format: a,
+      dimension: "1d",
+      usage: n.TEXTURE_BINDING | n.COPY_DST
+    }), this.textures.set(e, o), this.heatmapBindGroups.delete(e)), this.device.queue.writeTexture(
+      { texture: o },
+      t,
+      { bytesPerRow: r * 4 },
+      { width: r, height: 1, depthOrArrayLayers: 1 }
+    );
+  }
+  deleteTexture(e) {
+    const t = this.textures.get(e);
+    if (t) {
+      try {
+        t.destroy();
+      } catch {
+      }
+      this.textures.delete(e), this.heatmapBindGroups.delete(e);
+    }
+  }
+  /**
+   * Initialize all pipelines lazily
+   */
+  ensurePipelines() {
+    this.trianglePipeline || (this.trianglePipeline = O(this.device, this.format)), this.linePipeline || (this.linePipeline = V(this.device, this.format)), this.pointPipeline || (this.pointPipeline = Y(this.device, this.format)), this.bandPipeline || (this.bandPipeline = j(this.device, this.format)), this.heatmapPipeline || (this.heatmapPipeline = J(this.device, this.format));
+  }
+  render(e, t) {
+    if (!this.device || !this.context || !this.format)
+      throw new Error("[gpu] WebGPUBackend not initialized");
+    this.viewport || this.setViewport(t.viewport), this.ensurePipelines();
+    const i = this.device.createCommandEncoder(), r = this.context.getCurrentTexture().createView(), a = i.beginRenderPass({
+      colorAttachments: [
+        {
+          view: r,
+          clearValue: {
+            r: t.clearColor[0],
+            g: t.clearColor[1],
+            b: t.clearColor[2],
+            a: t.clearColor[3]
+          },
+          loadOp: "clear",
+          storeOp: "store"
+        }
+      ]
+    }), n = { xMin: -1, xMax: 1, yMin: -1, yMax: 1 };
+    for (const o of e.items) {
+      if (!o.visible) continue;
+      const u = this.buffers.get(o.bufferId);
+      u && this.renderDrawCall(a, o, u, n);
+    }
+    a.end(), this.device.queue.submit([i.finish()]);
+  }
+  /**
+   * Render with explicit bounds (for integration with chart system)
+   */
+  renderWithBounds(e, t, i) {
+    if (!this.device || !this.context || !this.format)
+      throw new Error("[gpu] WebGPUBackend not initialized");
+    this.viewport || this.setViewport(t.viewport), this.ensurePipelines();
+    const r = this.device.createCommandEncoder(), a = this.context.getCurrentTexture().createView(), n = r.beginRenderPass({
+      colorAttachments: [
+        {
+          view: a,
+          clearValue: {
+            r: t.clearColor[0],
+            g: t.clearColor[1],
+            b: t.clearColor[2],
+            a: t.clearColor[3]
+          },
+          loadOp: "clear",
+          storeOp: "store"
+        }
+      ]
+    });
+    for (const o of e.items) {
+      if (!o.visible) continue;
+      const u = this.buffers.get(o.bufferId);
+      if (!u) continue;
+      const l = o.yBounds ? { ...i, yMin: o.yBounds.min, yMax: o.yBounds.max } : i;
+      this.renderDrawCall(n, o, u, l);
+    }
+    n.end(), this.device.queue.submit([r.finish()]);
+  }
+  /**
+   * Render a single draw call
+   */
+  renderDrawCall(e, t, i, r) {
+    const a = ie(r), n = re(t.style);
+    switch (t.kind) {
+      case "triangles":
+      case "bar":
+        this.renderTriangles(e, i, t.count);
+        break;
+      case "line":
+        this.renderLine(e, i, t.count, a, n);
+        break;
+      case "scatter":
+      case "points":
+        this.renderPoints(e, i, t.count, a, n, t.style);
+        break;
+      case "line+scatter":
+        this.renderLine(e, i, t.count, a, n), this.renderPoints(e, i, t.count, a, n, t.style);
+        break;
+      case "step":
+        if (t.stepBufferId && t.stepCount) {
+          const u = this.buffers.get(t.stepBufferId);
+          u && this.renderLine(e, u, t.stepCount, a, n);
+        } else
+          this.renderLine(e, i, t.count, a, n);
+        break;
+      case "step+scatter":
+        if (t.stepBufferId && t.stepCount) {
+          const u = this.buffers.get(t.stepBufferId);
+          u && this.renderLine(e, u, t.stepCount, a, n);
+        } else
+          this.renderLine(e, i, t.count, a, n);
+        this.renderPoints(e, i, t.count, a, n, t.style);
+        break;
+      case "band":
+        const o = [
+          n[0],
+          n[1],
+          n[2],
+          n[3] * 0.4
+        ];
+        this.renderBand(e, i, t.count, a, o);
+        break;
+      case "heatmap":
+        this.renderHeatmap(e, i, t.count, a, t.style, t.textureId);
+        break;
+    }
+  }
+  renderTriangles(e, t, i) {
+    e.setPipeline(this.trianglePipeline.pipeline), e.setVertexBuffer(0, t), e.draw(i);
+  }
+  renderLine(e, t, i, r, a) {
+    W(this.device, this.linePipeline.uniformBuffer, {
+      scale: r.scale,
+      translate: r.translate,
+      color: a
+    }), e.setPipeline(this.linePipeline.pipeline), e.setBindGroup(0, this.linePipeline.bindGroup), e.setVertexBuffer(0, t), e.draw(i);
+  }
+  renderPoints(e, t, i, r, a, n) {
+    var p;
+    const o = ((n == null ? void 0 : n.pointSize) ?? 4) * (((p = this.viewport) == null ? void 0 : p.dpr) ?? 1), u = $[(n == null ? void 0 : n.symbol) ?? "circle"] ?? 0, l = [
+      this.canvas.width,
+      this.canvas.height
+    ];
+    X(this.device, this.pointPipeline.uniformBuffer, {
+      scale: r.scale,
+      translate: r.translate,
+      color: a,
+      pointSize: o,
+      symbol: u,
+      viewport: l
+    }), e.setPipeline(this.pointPipeline.pipeline), e.setBindGroup(0, this.pointPipeline.bindGroup), e.setVertexBuffer(0, t), e.setVertexBuffer(1, this.pointPipeline.quadBuffer), e.draw(6, i);
+  }
+  renderBand(e, t, i, r, a) {
+    Z(this.device, this.bandPipeline.uniformBuffer, {
+      scale: r.scale,
+      translate: r.translate,
+      color: a
+    }), e.setPipeline(this.bandPipeline.pipeline), e.setBindGroup(0, this.bandPipeline.bindGroup), e.setVertexBuffer(0, t), e.draw(i);
+  }
+  renderHeatmap(e, t, i, r, a, n) {
+    if (!n) return;
+    const o = this.textures.get(n);
+    if (!o) return;
+    const u = (a == null ? void 0 : a.zBounds) ?? { min: 0, max: 1 };
+    te(this.device, this.heatmapPipeline.uniformBuffer, {
+      scale: r.scale,
+      translate: r.translate,
+      minValue: u.min,
+      maxValue: u.max
+    });
+    let l = this.heatmapBindGroups.get(n);
+    l || (l = ee(
+      this.device,
+      this.heatmapPipeline.bindGroupLayout,
+      this.heatmapPipeline.uniformBuffer,
+      this.heatmapPipeline.sampler,
+      o
+    ), this.heatmapBindGroups.set(n, l)), e.setPipeline(this.heatmapPipeline.pipeline), e.setBindGroup(0, l), e.setVertexBuffer(0, t), e.draw(i);
+  }
+  destroy() {
+    for (const e of Array.from(this.buffers.keys()))
+      this.deleteBuffer(e);
+    for (const e of Array.from(this.textures.keys()))
+      this.deleteTexture(e);
+    this.trianglePipeline = null, this.linePipeline = null, this.pointPipeline = null, this.bandPipeline = null, this.heatmapPipeline = null, this.heatmapBindGroups.clear(), this.device = void 0, this.adapter = void 0, this.context = void 0, this.format = null;
+  }
+}
+const ae = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WebGPUBackend: _
+}, Symbol.toStringTag, { value: "Module" })), ne = `
+precision highp float;
+attribute vec2 aPosition;
+uniform vec2 uScale;
+uniform vec2 uTranslate;
+
+void main() {
+  vec2 pos = aPosition * uScale + uTranslate;
+  gl_Position = vec4(pos, 0.0, 1.0);
+}
+`, se = `
+precision highp float;
+uniform vec4 uColor;
+
+void main() {
+  gl_FragColor = uColor;
+}
+`, oe = `
+precision highp float;
+attribute vec2 aPosition;
+uniform vec2 uScale;
+uniform vec2 uTranslate;
+uniform float uPointSize;
+
+void main() {
+  vec2 pos = aPosition * uScale + uTranslate;
+  gl_Position = vec4(pos, 0.0, 1.0);
+  gl_PointSize = uPointSize;
+}
+`, ue = `
+precision highp float;
+uniform vec4 uColor;
+uniform int uSymbol;
+
+float sdCircle(vec2 p, float r) {
+  return length(p) - r;
+}
+
+float sdBox(vec2 p, vec2 b) {
+  vec2 d = abs(p) - b;
+  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+
+float sdTriangle(vec2 p, float r) {
+  const float k = sqrt(3.0);
+  p.x = abs(p.x) - r;
+  p.y = p.y + r / k;
+  if (p.x + k * p.y > 0.0) p = vec2(p.x - k * p.y, -k * p.x - p.y) / 2.0;
+  p.x -= clamp(p.x, -2.0 * r, 0.0);
+  return -length(p) * sign(p.y);
+}
+
+float sdDiamond(vec2 p, float r) {
+  return (abs(p.x) + abs(p.y)) - r;
+}
+
+float sdCross(vec2 p, float r, float thickness) {
+  vec2 d = abs(p);
+  float s1 = sdBox(d, vec2(r, thickness));
+  float s2 = sdBox(d, vec2(thickness, r));
+  return min(s1, s2);
+}
+
+float sdX(vec2 p, float r, float thickness) {
+  float c = cos(0.785398);
+  float s = sin(0.785398);
+  mat2 m = mat2(c, -s, s, c);
+  return sdCross(m * p, r, thickness);
+}
+
+float sdStar(vec2 p, float r, float rf) {
+  const vec2 k1 = vec2(0.80901699, -0.58778525);
+  const vec2 k2 = vec2(-k1.x, k1.y);
+  p.x = abs(p.x);
+  p -= 2.0 * max(dot(k1, p), 0.0) * k1;
+  p -= 2.0 * max(dot(k2, p), 0.0) * k2;
+  p.x = abs(p.x);
+  p.y -= r;
+  vec2 ba = rf * vec2(-k1.y, k1.x) - vec2(0, 1);
+  float h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);
+  return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);
+}
+
+void main() {
+  vec2 p = gl_PointCoord - vec2(0.5);
+  float d = 0.0;
+
+  if (uSymbol == 0) {
+    d = sdCircle(p, 0.45);
+  } else if (uSymbol == 1) {
+    d = sdBox(p, vec2(0.35));
+  } else if (uSymbol == 2) {
+    d = sdDiamond(p, 0.45);
+  } else if (uSymbol == 3) {
+    d = sdTriangle(vec2(p.x, p.y + 0.1), 0.4);
+  } else if (uSymbol == 4) {
+    d = sdTriangle(vec2(p.x, -p.y + 0.1), 0.4);
+  } else if (uSymbol == 5) {
+    d = sdCross(p, 0.45, 0.15);
+  } else if (uSymbol == 6) {
+    d = sdX(p, 0.45, 0.15);
+  } else if (uSymbol == 7) {
+    d = sdStar(p, 0.45, 0.4);
+  }
+
+  if (d > 0.02) discard;
+
+  float alpha = 1.0 - smoothstep(0.0, 0.02, d);
+  gl_FragColor = vec4(uColor.rgb, uColor.a * alpha);
+}
+`, le = `
+precision highp float;
+attribute vec2 aPosition;
+attribute float aValue;
+uniform vec2 uScale;
+uniform vec2 uTranslate;
+varying float vValue;
+
+void main() {
+  gl_Position = vec4(aPosition * uScale + uTranslate, 0.0, 1.0);
+  vValue = aValue;
+}
+`, ce = `
+precision highp float;
+varying float vValue;
+uniform float uMinValue;
+uniform float uMaxValue;
+uniform sampler2D uColormap;
+
+void main() {
+  float range = uMaxValue - uMinValue;
+  float t = (vValue - uMinValue) / (range != 0.0 ? range : 1.0);
+  t = clamp(t, 0.0, 1.0);
+  gl_FragColor = texture2D(uColormap, vec2(t, 0.5));
+}
+`;
+function E(s, e, t) {
+  const i = s.createShader(e);
+  if (!i)
+    throw new Error("[WebGL] Failed to create shader");
+  if (s.shaderSource(i, t), s.compileShader(i), !s.getShaderParameter(i, s.COMPILE_STATUS)) {
+    const r = s.getShaderInfoLog(i);
+    throw s.deleteShader(i), new Error(`[WebGL] Shader compilation error: ${r}`);
+  }
+  return i;
+}
+function pe(s, e, t) {
+  const i = s.createProgram();
+  if (!i)
+    throw new Error("[WebGL] Failed to create program");
+  if (s.attachShader(i, e), s.attachShader(i, t), s.linkProgram(i), !s.getProgramParameter(i, s.LINK_STATUS)) {
+    const r = s.getProgramInfoLog(i);
+    throw s.deleteProgram(i), new Error(`[WebGL] Program link error: ${r}`);
+  }
+  return i;
+}
+function T(s, e, t, i, r) {
+  const a = E(s, s.VERTEX_SHADER, e), n = E(s, s.FRAGMENT_SHADER, t), o = pe(s, a, n);
+  s.deleteShader(a), s.deleteShader(n);
+  const u = {};
+  for (const p of i)
+    u[p] = s.getAttribLocation(o, p);
+  const l = {};
+  for (const p of r)
+    l[p] = s.getUniformLocation(o, p);
+  return { program: o, attributes: u, uniforms: l };
+}
+function fe(s) {
+  const e = T(
+    s,
+    ne,
+    se,
+    ["aPosition"],
+    ["uScale", "uTranslate", "uColor"]
+  ), t = T(
+    s,
+    oe,
+    ue,
+    ["aPosition"],
+    ["uScale", "uTranslate", "uColor", "uPointSize", "uSymbol"]
+  ), i = T(
+    s,
+    le,
+    ce,
+    ["aPosition", "aValue"],
+    ["uScale", "uTranslate", "uMinValue", "uMaxValue", "uColormap"]
+  );
+  return { line: e, point: t, heatmap: i };
+}
+function de(s, e) {
+  s.deleteProgram(e.line.program), s.deleteProgram(e.point.program), s.deleteProgram(e.heatmap.program);
+}
+const he = {
+  circle: 0,
+  square: 1,
+  diamond: 2,
+  triangle: 3,
+  triangleDown: 4,
+  cross: 5,
+  x: 6,
+  star: 7
+};
+function me(s) {
+  const e = s.xMax - s.xMin, t = s.yMax - s.yMin, i = e > 0 ? 2 / e : 1, r = t > 0 ? 2 / t : 1, a = -1 - s.xMin * i, n = -1 - s.yMin * r;
+  return {
+    scale: [i, r],
+    translate: [a, n]
+  };
+}
+function ge(s) {
+  const e = (s == null ? void 0 : s.color) ?? [1, 0, 0.3, 1], t = (s == null ? void 0 : s.opacity) ?? 1;
+  return Array.isArray(e) ? [e[0], e[1], e[2], (e[3] ?? 1) * t] : [1, 0, 0.3, t];
+}
+class P {
+  constructor(e, t = {}) {
+    c(this, "info");
+    c(this, "canvas");
+    c(this, "opts");
+    c(this, "gl", null);
+    c(this, "viewport", null);
+    c(this, "dpr", 1);
+    c(this, "programs", null);
+    c(this, "buffers", /* @__PURE__ */ new Map());
+    c(this, "textures", /* @__PURE__ */ new Map());
+    this.canvas = e, this.opts = t, this.info = {
+      type: "webgl",
+      available: P.isSupported()
+    };
+  }
+  static isSupported() {
+    if (typeof document > "u") return !1;
+    try {
+      const e = document.createElement("canvas");
+      return !!(e.getContext("webgl") || e.getContext("experimental-webgl"));
+    } catch {
+      return !1;
+    }
+  }
+  async init() {
+    if (!this.info.available)
+      throw new Error("[gpu] WebGL not supported");
+    const e = this.canvas.getContext("webgl", {
+      alpha: !0,
+      antialias: this.opts.antialias ?? !0,
+      preserveDrawingBuffer: this.opts.preserveDrawingBuffer ?? !0,
+      powerPreference: this.opts.powerPreference ?? "high-performance"
+    });
+    if (!e)
+      throw new Error("[gpu] Failed to get WebGL context");
+    this.gl = e, e.enable(e.BLEND), e.blendFunc(e.SRC_ALPHA, e.ONE_MINUS_SRC_ALPHA), this.programs = fe(e);
+  }
+  setViewport(e) {
+    this.viewport = e, this.dpr = e.dpr;
+    const t = Math.max(1, Math.floor(e.width * e.dpr)), i = Math.max(1, Math.floor(e.height * e.dpr));
+    this.canvas.width !== t && (this.canvas.width = t), this.canvas.height !== i && (this.canvas.height = i), this.gl && this.gl.viewport(0, 0, t, i);
+  }
+  createOrUpdateBuffer(e, t, i) {
+    if (!this.gl)
+      throw new Error("[gpu] WebGLBackend not initialized");
+    const r = this.gl;
+    let a = this.buffers.get(e);
+    a || (a = r.createBuffer(), this.buffers.set(e, a));
+    const n = (i == null ? void 0 : i.usage) === "index" ? r.ELEMENT_ARRAY_BUFFER : r.ARRAY_BUFFER;
+    r.bindBuffer(n, a), r.bufferData(n, t, r.DYNAMIC_DRAW), r.bindBuffer(n, null);
+  }
+  deleteBuffer(e) {
+    if (!this.gl) return;
+    const t = this.buffers.get(e);
+    t && (this.gl.deleteBuffer(t), this.buffers.delete(e));
+  }
+  createOrUpdateTexture1D(e, t, i) {
+    if (!this.gl)
+      throw new Error("[gpu] WebGLBackend not initialized");
+    const r = this.gl, a = (i == null ? void 0 : i.width) ?? Math.floor(t.length / 4);
+    let n = this.textures.get(e);
+    n || (n = r.createTexture(), this.textures.set(e, n)), r.bindTexture(r.TEXTURE_2D, n), r.texImage2D(r.TEXTURE_2D, 0, r.RGBA, a, 1, 0, r.RGBA, r.UNSIGNED_BYTE, t), r.texParameteri(r.TEXTURE_2D, r.TEXTURE_MIN_FILTER, r.LINEAR), r.texParameteri(r.TEXTURE_2D, r.TEXTURE_MAG_FILTER, r.LINEAR), r.texParameteri(r.TEXTURE_2D, r.TEXTURE_WRAP_S, r.CLAMP_TO_EDGE), r.texParameteri(r.TEXTURE_2D, r.TEXTURE_WRAP_T, r.CLAMP_TO_EDGE), r.bindTexture(r.TEXTURE_2D, null);
+  }
+  deleteTexture(e) {
+    if (!this.gl) return;
+    const t = this.textures.get(e);
+    t && (this.gl.deleteTexture(t), this.textures.delete(e));
+  }
+  render(e, t) {
+    this.renderWithBounds(e, t, { xMin: -1, xMax: 1, yMin: -1, yMax: 1 });
+  }
+  renderWithBounds(e, t, i) {
+    if (!this.gl || !this.programs)
+      throw new Error("[gpu] WebGLBackend not initialized");
+    const r = this.gl;
+    this.viewport || this.setViewport(t.viewport), r.clearColor(
+      t.clearColor[0],
+      t.clearColor[1],
+      t.clearColor[2],
+      t.clearColor[3]
+    ), r.clear(r.COLOR_BUFFER_BIT);
+    for (const a of e.items) {
+      if (!a.visible) continue;
+      const n = this.buffers.get(a.bufferId);
+      if (!n) continue;
+      const o = a.yBounds ? { ...i, yMin: a.yBounds.min, yMax: a.yBounds.max } : i;
+      this.renderDrawCall(a, n, o);
+    }
+  }
+  renderDrawCall(e, t, i) {
+    const r = me(i), a = ge(e.style);
+    switch (e.kind) {
+      case "line":
+      case "step":
+        this.renderLine(t, e.count, r, a);
+        break;
+      case "scatter":
+      case "points":
+        this.renderPoints(t, e.count, r, a, e.style);
+        break;
+      case "line+scatter":
+        this.renderLine(t, e.count, r, a), this.renderPoints(t, e.count, r, a, e.style);
+        break;
+      case "step+scatter":
+        if (e.stepBufferId && e.stepCount) {
+          const o = this.buffers.get(e.stepBufferId);
+          o && this.renderLine(o, e.stepCount, r, a);
+        } else
+          this.renderLine(t, e.count, r, a);
+        this.renderPoints(t, e.count, r, a, e.style);
+        break;
+      case "band":
+        const n = [
+          a[0],
+          a[1],
+          a[2],
+          a[3] * 0.4
+        ];
+        this.renderBand(t, e.count, r, n);
+        break;
+      case "triangles":
+      case "bar":
+        this.renderTriangles(t, e.count, r, a);
+        break;
+      case "heatmap":
+        this.renderHeatmap(t, e.count, r, e.style, e.textureId);
+        break;
+    }
+  }
+  renderLine(e, t, i, r) {
+    const a = this.gl, n = this.programs.line;
+    a.useProgram(n.program), a.bindBuffer(a.ARRAY_BUFFER, e), a.enableVertexAttribArray(n.attributes.aPosition), a.vertexAttribPointer(n.attributes.aPosition, 2, a.FLOAT, !1, 0, 0), a.uniform2f(n.uniforms.uScale, i.scale[0], i.scale[1]), a.uniform2f(n.uniforms.uTranslate, i.translate[0], i.translate[1]), a.uniform4f(n.uniforms.uColor, r[0], r[1], r[2], r[3]), a.drawArrays(a.LINE_STRIP, 0, t), a.disableVertexAttribArray(n.attributes.aPosition);
+  }
+  renderPoints(e, t, i, r, a) {
+    const n = this.gl, o = this.programs.point, u = ((a == null ? void 0 : a.pointSize) ?? 4) * this.dpr, l = he[(a == null ? void 0 : a.symbol) ?? "circle"] ?? 0;
+    n.useProgram(o.program), n.bindBuffer(n.ARRAY_BUFFER, e), n.enableVertexAttribArray(o.attributes.aPosition), n.vertexAttribPointer(o.attributes.aPosition, 2, n.FLOAT, !1, 0, 0), n.uniform2f(o.uniforms.uScale, i.scale[0], i.scale[1]), n.uniform2f(o.uniforms.uTranslate, i.translate[0], i.translate[1]), n.uniform4f(o.uniforms.uColor, r[0], r[1], r[2], r[3]), n.uniform1f(o.uniforms.uPointSize, u), n.uniform1i(o.uniforms.uSymbol, l), n.drawArrays(n.POINTS, 0, t), n.disableVertexAttribArray(o.attributes.aPosition);
+  }
+  renderBand(e, t, i, r) {
+    const a = this.gl, n = this.programs.line;
+    a.useProgram(n.program), a.bindBuffer(a.ARRAY_BUFFER, e), a.enableVertexAttribArray(n.attributes.aPosition), a.vertexAttribPointer(n.attributes.aPosition, 2, a.FLOAT, !1, 0, 0), a.uniform2f(n.uniforms.uScale, i.scale[0], i.scale[1]), a.uniform2f(n.uniforms.uTranslate, i.translate[0], i.translate[1]), a.uniform4f(n.uniforms.uColor, r[0], r[1], r[2], r[3]), a.drawArrays(a.TRIANGLE_STRIP, 0, t), a.disableVertexAttribArray(n.attributes.aPosition);
+  }
+  renderTriangles(e, t, i, r) {
+    const a = this.gl, n = this.programs.line;
+    a.useProgram(n.program), a.bindBuffer(a.ARRAY_BUFFER, e), a.enableVertexAttribArray(n.attributes.aPosition), a.vertexAttribPointer(n.attributes.aPosition, 2, a.FLOAT, !1, 0, 0), a.uniform2f(n.uniforms.uScale, i.scale[0], i.scale[1]), a.uniform2f(n.uniforms.uTranslate, i.translate[0], i.translate[1]), a.uniform4f(n.uniforms.uColor, r[0], r[1], r[2], r[3]), a.drawArrays(a.TRIANGLES, 0, t), a.disableVertexAttribArray(n.attributes.aPosition);
+  }
+  renderHeatmap(e, t, i, r, a) {
+    if (!a) return;
+    const n = this.textures.get(a);
+    if (!n) return;
+    const o = this.gl, u = this.programs.heatmap, l = (r == null ? void 0 : r.zBounds) ?? { min: 0, max: 1 };
+    o.useProgram(u.program), o.bindBuffer(o.ARRAY_BUFFER, e), o.enableVertexAttribArray(u.attributes.aPosition), o.vertexAttribPointer(u.attributes.aPosition, 2, o.FLOAT, !1, 12, 0), u.attributes.aValue !== -1 && (o.enableVertexAttribArray(u.attributes.aValue), o.vertexAttribPointer(u.attributes.aValue, 1, o.FLOAT, !1, 12, 8)), o.uniform2f(u.uniforms.uScale, i.scale[0], i.scale[1]), o.uniform2f(u.uniforms.uTranslate, i.translate[0], i.translate[1]), o.uniform1f(u.uniforms.uMinValue, l.min), o.uniform1f(u.uniforms.uMaxValue, l.max), o.activeTexture(o.TEXTURE0), o.bindTexture(o.TEXTURE_2D, n), o.uniform1i(u.uniforms.uColormap, 0), o.drawArrays(o.TRIANGLES, 0, t), o.disableVertexAttribArray(u.attributes.aPosition), u.attributes.aValue !== -1 && o.disableVertexAttribArray(u.attributes.aValue);
+  }
+  destroy() {
+    if (!this.gl) return;
+    const e = this.gl;
+    for (const t of this.buffers.values())
+      e.deleteBuffer(t);
+    this.buffers.clear();
+    for (const t of this.textures.values())
+      e.deleteTexture(t);
+    this.textures.clear(), this.programs && (de(e, this.programs), this.programs = null), this.gl = null;
+  }
+}
+const be = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  WebGLBackend: P
+}, Symbol.toStringTag, { value: "Module" }));
+class ve {
+  constructor(e, t = {}) {
+    c(this, "canvas");
+    c(this, "options");
+    c(this, "backend", null);
+    c(this, "adapter", null);
+    c(this, "dpr");
+    c(this, "isInitialized", !1);
+    c(this, "backendType", null);
+    // Buffer management
+    c(this, "bufferDataMap", /* @__PURE__ */ new Map());
+    c(this, "stepBufferDataMap", /* @__PURE__ */ new Map());
+    c(this, "colormapDataMap", /* @__PURE__ */ new Map());
+    this.canvas = e, this.options = t, this.dpr = window.devicePixelRatio || 1;
+  }
+  /**
+   * Initialize the renderer
+   */
+  async init() {
+    const e = this.options.backend ?? "auto";
+    if ((e === "webgpu" || e === "auto") && _.isSupported())
+      try {
+        const t = new _(this.canvas, {
+          powerPreference: this.options.powerPreference ?? "high-performance"
+        });
+        return await t.init(), this.backend = t, this.backendType = "webgpu", this.adapter = new M(t), this.isInitialized = !0, this.resize(), !0;
+      } catch (t) {
+        console.warn("[GpuRenderer] WebGPU init failed:", t);
+      }
+    if ((e === "webgl" || e === "auto") && P.isSupported())
+      try {
+        const t = new P(this.canvas, {
+          powerPreference: this.options.powerPreference ?? "high-performance"
+        });
+        return await t.init(), this.backend = t, this.backendType = "webgl", this.adapter = new M(t), this.isInitialized = !0, this.resize(), console.info("[GpuRenderer] Using WebGL backend (WebGPU not available)"), !0;
+      } catch (t) {
+        console.warn("[GpuRenderer] WebGL init failed:", t);
+      }
+    return !1;
+  }
+  /**
+   * Check if renderer is available
+   */
+  get available() {
+    return this.isInitialized;
+  }
+  /**
+   * Get the active backend type
+   */
+  get activeBackend() {
+    return this.backendType;
+  }
+  /**
+   * Set device pixel ratio
+   */
+  setDPR(e) {
+    this.dpr = e, this.resize();
+  }
+  /**
+   * Create or update a buffer
+   */
+  createBuffer(e, t) {
+    this.bufferDataMap.set(e, t);
+  }
+  /**
+   * Update a buffer partially
+   */
+  updateBuffer(e, t, i) {
+    const r = this.bufferDataMap.get(e);
+    if (!r) return !1;
+    const a = i / 4;
+    return r.set(t, a), !0;
+  }
+  /**
+   * Get a buffer's data
+   */
+  getBuffer(e) {
+    return this.bufferDataMap.get(e);
+  }
+  /**
+   * Delete a buffer
+   */
+  deleteBuffer(e) {
+    this.bufferDataMap.delete(e), this.backend && this.backend.deleteBuffer(e);
+  }
+  /**
+   * Create or update a step buffer
+   */
+  createStepBuffer(e, t) {
+    this.stepBufferDataMap.set(e, t);
+  }
+  /**
+   * Create colormap texture
+   */
+  createColormapTexture(e, t) {
+    this.colormapDataMap.set(e, t), this.backend && this.backend.createOrUpdateTexture1D(e, t, {
+      width: t.length / 4
+    });
+  }
+  /**
+   * Render a frame
+   */
+  render(e, t) {
+    if (!this.isInitialized || !this.backend) return;
+    const i = this.buildDrawList(e), r = {
+      viewport: {
+        width: this.canvas.clientWidth,
+        height: this.canvas.clientHeight,
+        dpr: this.dpr
+      },
+      clearColor: t.backgroundColor ?? [0.1, 0.1, 0.18, 1],
+      bounds: t.bounds,
+      plotArea: t.plotArea
+    };
+    "renderWithBounds" in this.backend ? this.backend.renderWithBounds(i, r, t.bounds) : this.backend.render(i, r);
+  }
+  /**
+   * Build draw list from series data
+   */
+  buildDrawList(e) {
+    const t = [];
+    for (const i of e) {
+      const r = this.bufferDataMap.get(i.id);
+      if (!r) continue;
+      this.backend.createOrUpdateBuffer(i.id, r, { usage: "vertex" });
+      const a = i.type === "heatmap" ? r.length / 3 : r.length / 2, n = U(i.style.color), o = i.style.opacity ?? 1, u = [
+        n[0],
+        n[1],
+        n[2],
+        n[3] * o
+      ], l = {
+        id: i.id,
+        kind: i.type,
+        bufferId: i.id,
+        count: a,
+        visible: i.visible,
+        yBounds: i.yBounds
+      };
+      if (i.type === "scatter" || i.type === "line+scatter" || i.type === "step+scatter")
+        l.style = {
+          color: u,
+          opacity: o,
+          pointSize: i.style.pointSize ?? 4,
+          symbol: i.style.symbol ?? "circle"
+        };
+      else if (i.type === "heatmap") {
+        l.textureId = `colormap:${i.id}`, l.style = {
+          zBounds: i.zBounds,
+          colormap: i.colormap
+        };
+        const p = this.colormapDataMap.get(i.id);
+        p && this.backend.createOrUpdateTexture1D(l.textureId, p, {
+          width: p.length / 4
+        });
+      } else
+        l.style = {
+          color: u,
+          opacity: o,
+          lineWidth: i.style.lineWidth ?? 1
+        };
+      if ((i.type === "step" || i.type === "step+scatter") && this.stepBufferDataMap.has(i.id)) {
+        const p = this.stepBufferDataMap.get(i.id), f = `${i.id}:step`;
+        this.backend.createOrUpdateBuffer(f, p, { usage: "vertex" }), l.stepBufferId = f, l.stepCount = p.length / 2;
+      }
+      t.push(l);
+    }
+    return { items: t };
+  }
+  /**
+   * Handle canvas resize
+   */
+  resize() {
+    if (!this.backend) return;
+    const e = this.canvas.getBoundingClientRect();
+    this.backend.setViewport({
+      width: e.width,
+      height: e.height,
+      dpr: this.dpr
+    });
+  }
+  /**
+   * Get renderer limits
+   */
+  getLimits() {
+    return {
+      backend: this.backendType,
+      available: this.isInitialized
+    };
+  }
+  /**
+   * Destroy the renderer
+   */
+  destroy() {
+    var e, t;
+    (e = this.adapter) == null || e.destroy(), (t = this.backend) == null || t.destroy(), this.bufferDataMap.clear(), this.stepBufferDataMap.clear(), this.colormapDataMap.clear(), this.adapter = null, this.backend = null, this.isInitialized = !1, this.backendType = null;
+  }
+}
+async function Ae(s, e) {
+  const t = new ve(s, e);
+  return await t.init() ? t : null;
+}
+class Ge {
+  constructor(e) {
+    c(this, "canvas");
+    c(this, "results", []);
+    this.canvas = e ?? document.createElement("canvas"), e || (this.canvas.width = 800, this.canvas.height = 600);
+  }
+  /**
+   * Generate random line data
+   */
+  generateLineData(e) {
+    const t = new Float32Array(e * 2);
+    for (let i = 0; i < e; i++)
+      t[i * 2] = i / (e - 1), t[i * 2 + 1] = Math.random();
+    return t;
+  }
+  /**
+   * Measure frame times
+   */
+  async measureFrameTimes(e, t, i = 10, r) {
+    const a = [];
+    let n = performance.now(), o = 0;
+    const u = performance.now();
+    return new Promise((l) => {
+      const p = () => {
+        const f = performance.now(), h = f - u;
+        if (h >= t + i * 16) {
+          l({ frameTimes: a, duration: h - i * 16 });
+          return;
+        }
+        if (e(), o >= i) {
+          if (a.push(f - n), r) {
+            const d = Math.min(1, h / t);
+            r(d);
+          }
+        } else
+          o++;
+        n = f, requestAnimationFrame(p);
+      };
+      requestAnimationFrame(p);
+    });
+  }
+  /**
+   * Run benchmark with WebGPU backend
+   */
+  async benchmarkWebGPU(e = {}) {
+    const { WebGPUBackend: t } = await Promise.resolve().then(() => ae);
+    if (!t.isSupported())
+      return console.warn("[Benchmark] WebGPU not supported"), null;
+    const i = e.pointCount ?? 1e5, r = e.durationMs ?? 5e3, a = e.warmupFrames ?? 30, n = new t(this.canvas);
+    await n.init(), n.setViewport({
+      width: this.canvas.width,
+      height: this.canvas.height,
+      dpr: 1
+    });
+    const o = this.generateLineData(i);
+    n.createOrUpdateBuffer("bench-line", o, { usage: "vertex" });
+    const u = {
+      items: [{
+        id: "bench-line",
+        kind: "line",
+        bufferId: "bench-line",
+        count: i,
+        visible: !0,
+        style: { color: [0, 0.9, 1, 1] }
+      }]
+    }, l = {
+      viewport: { width: this.canvas.width, height: this.canvas.height, dpr: 1 },
+      clearColor: [0.1, 0.1, 0.15, 1]
+    }, p = { xMin: 0, xMax: 1, yMin: 0, yMax: 1 }, f = () => {
+      n.renderWithBounds(u, l, p);
+    }, { frameTimes: h, duration: d } = await this.measureFrameTimes(
+      f,
+      r,
+      a,
+      e.onProgress
+    );
+    n.destroy();
+    const m = this.calculateResult("webgpu", i, h, d);
+    return this.results.push(m), m;
+  }
+  /**
+   * Run benchmark with WebGL backend
+   */
+  async benchmarkWebGL(e = {}) {
+    const { WebGLBackend: t } = await Promise.resolve().then(() => be);
+    if (!t.isSupported())
+      return console.warn("[Benchmark] WebGL not supported"), null;
+    const i = e.pointCount ?? 1e5, r = e.durationMs ?? 5e3, a = e.warmupFrames ?? 30, n = new t(this.canvas);
+    await n.init(), n.setViewport({
+      width: this.canvas.width,
+      height: this.canvas.height,
+      dpr: 1
+    });
+    const o = this.generateLineData(i);
+    n.createOrUpdateBuffer("bench-line", o, { usage: "vertex" });
+    const u = {
+      items: [{
+        id: "bench-line",
+        kind: "line",
+        bufferId: "bench-line",
+        count: i,
+        visible: !0,
+        style: { color: [0, 0.9, 1, 1] }
+      }]
+    }, l = {
+      viewport: { width: this.canvas.width, height: this.canvas.height, dpr: 1 },
+      clearColor: [0.1, 0.1, 0.15, 1]
+    }, p = { xMin: 0, xMax: 1, yMin: 0, yMax: 1 }, f = () => {
+      n.renderWithBounds(u, l, p);
+    }, { frameTimes: h, duration: d } = await this.measureFrameTimes(
+      f,
+      r,
+      a,
+      e.onProgress
+    );
+    n.destroy();
+    const m = this.calculateResult("webgl", i, h, d);
+    return this.results.push(m), m;
+  }
+  /**
+   * Calculate benchmark result from frame times
+   */
+  calculateResult(e, t, i, r) {
+    if (i.length === 0)
+      return {
+        backend: e,
+        pointCount: t,
+        fps: 0,
+        avgFrameTime: 0,
+        minFrameTime: 0,
+        maxFrameTime: 0,
+        totalFrames: 0,
+        duration: r
+      };
+    const n = i.reduce((l, p) => l + p, 0) / i.length, o = Math.min(...i), u = Math.max(...i);
+    return {
+      backend: e,
+      pointCount: t,
+      fps: Math.round(1e3 / n),
+      avgFrameTime: Math.round(n * 100) / 100,
+      minFrameTime: Math.round(o * 100) / 100,
+      maxFrameTime: Math.round(u * 100) / 100,
+      totalFrames: i.length,
+      duration: Math.round(r)
+    };
+  }
+  /**
+   * Run comparative benchmark
+   */
+  async runComparison(e = {}) {
+    const t = await this.benchmarkWebGPU(e), i = await this.benchmarkWebGL(e);
+    let r = "unknown", a = 1;
+    return t && i ? t.fps > i.fps * 1.05 ? (r = "webgpu", a = t.fps / i.fps) : i.fps > t.fps * 1.05 ? (r = "webgl", a = i.fps / t.fps) : (r = "tie", a = 1) : t ? r = "webgpu" : i && (r = "webgl"), { webgpu: t, webgl: i, winner: r, speedup: Math.round(a * 100) / 100 };
+  }
+  /**
+   * Get all results
+   */
+  getResults() {
+    return [...this.results];
+  }
+  /**
+   * Clear results
+   */
+  clearResults() {
+    this.results = [];
+  }
+  /**
+   * Format result as string
+   */
+  static formatResult(e) {
+    return [
+      `Backend: ${e.backend.toUpperCase()}`,
+      `Points: ${e.pointCount.toLocaleString()}`,
+      `FPS: ${e.fps}`,
+      `Avg Frame: ${e.avgFrameTime}ms`,
+      `Min/Max: ${e.minFrameTime}ms / ${e.maxFrameTime}ms`,
+      `Frames: ${e.totalFrames}`,
+      `Duration: ${e.duration}ms`
+    ].join(" | ");
+  }
+}
+const xe = `
+struct StatsResult {
+  min_val: f32,
+  max_val: f32,
+  sum: f32,
+  sum_sq: f32,
+  count: u32,
+  padding: vec3<u32>,
+}
+
+@group(0) @binding(0) var<storage, read> input_data: array<f32>;
+@group(0) @binding(1) var<storage, read_write> result: StatsResult;
+
+var<workgroup> local_min: array<f32, 256>;
+var<workgroup> local_max: array<f32, 256>;
+var<workgroup> local_sum: array<f32, 256>;
+var<workgroup> local_sum_sq: array<f32, 256>;
+var<workgroup> local_count: array<u32, 256>;
+
+@compute @workgroup_size(256)
+fn main(
+  @builtin(global_invocation_id) global_id: vec3<u32>,
+  @builtin(local_invocation_id) local_id: vec3<u32>,
+  @builtin(workgroup_id) workgroup_id: vec3<u32>
+) {
+  let idx = global_id.x;
+  let lid = local_id.x;
+  let data_len = arrayLength(&input_data);
+  
+  // Initialize local values
+  if (idx < data_len) {
+    let val = input_data[idx];
+    local_min[lid] = val;
+    local_max[lid] = val;
+    local_sum[lid] = val;
+    local_sum_sq[lid] = val * val;
+    local_count[lid] = 1u;
+  } else {
+    local_min[lid] = 3.402823e+38; // f32 max
+    local_max[lid] = -3.402823e+38; // f32 min
+    local_sum[lid] = 0.0;
+    local_sum_sq[lid] = 0.0;
+    local_count[lid] = 0u;
+  }
+  
+  workgroupBarrier();
+  
+  // Parallel reduction
+  for (var stride: u32 = 128u; stride > 0u; stride = stride >> 1u) {
+    if (lid < stride) {
+      local_min[lid] = min(local_min[lid], local_min[lid + stride]);
+      local_max[lid] = max(local_max[lid], local_max[lid + stride]);
+      local_sum[lid] = local_sum[lid] + local_sum[lid + stride];
+      local_sum_sq[lid] = local_sum_sq[lid] + local_sum_sq[lid + stride];
+      local_count[lid] = local_count[lid] + local_count[lid + stride];
+    }
+    workgroupBarrier();
+  }
+  
+  // First thread writes result (atomic for multi-workgroup)
+  if (lid == 0u) {
+    // Use atomics for multi-workgroup reduction
+    // For now, we assume single workgroup or post-process on CPU
+    result.min_val = local_min[0];
+    result.max_val = local_max[0];
+    result.sum = local_sum[0];
+    result.sum_sq = local_sum_sq[0];
+    result.count = local_count[0];
+  }
+}
+`, ye = `
+struct MinMax {
+  min_x: f32,
+  max_x: f32,
+  min_y: f32,
+  max_y: f32,
+}
+
+@group(0) @binding(0) var<storage, read> points: array<vec2<f32>>;
+@group(0) @binding(1) var<storage, read_write> result: MinMax;
+
+var<workgroup> local_min_x: array<f32, 256>;
+var<workgroup> local_max_x: array<f32, 256>;
+var<workgroup> local_min_y: array<f32, 256>;
+var<workgroup> local_max_y: array<f32, 256>;
+
+@compute @workgroup_size(256)
+fn main(
+  @builtin(global_invocation_id) global_id: vec3<u32>,
+  @builtin(local_invocation_id) local_id: vec3<u32>
+) {
+  let idx = global_id.x;
+  let lid = local_id.x;
+  let data_len = arrayLength(&points);
+  
+  if (idx < data_len) {
+    let pt = points[idx];
+    local_min_x[lid] = pt.x;
+    local_max_x[lid] = pt.x;
+    local_min_y[lid] = pt.y;
+    local_max_y[lid] = pt.y;
+  } else {
+    local_min_x[lid] = 3.402823e+38;
+    local_max_x[lid] = -3.402823e+38;
+    local_min_y[lid] = 3.402823e+38;
+    local_max_y[lid] = -3.402823e+38;
+  }
+  
+  workgroupBarrier();
+  
+  for (var stride: u32 = 128u; stride > 0u; stride = stride >> 1u) {
+    if (lid < stride) {
+      local_min_x[lid] = min(local_min_x[lid], local_min_x[lid + stride]);
+      local_max_x[lid] = max(local_max_x[lid], local_max_x[lid + stride]);
+      local_min_y[lid] = min(local_min_y[lid], local_min_y[lid + stride]);
+      local_max_y[lid] = max(local_max_y[lid], local_max_y[lid + stride]);
+    }
+    workgroupBarrier();
+  }
+  
+  if (lid == 0u) {
+    result.min_x = local_min_x[0];
+    result.max_x = local_max_x[0];
+    result.min_y = local_min_y[0];
+    result.max_y = local_max_y[0];
+  }
+}
+`, _e = `
+struct Params {
+  input_count: u32,
+  output_count: u32,
+  bucket_size: u32,
+  padding: u32,
+}
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read> input_points: array<vec2<f32>>;
+@group(0) @binding(2) var<storage, read_write> output_points: array<vec2<f32>>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let bucket_idx = global_id.x;
+  
+  if (bucket_idx >= params.output_count / 2u) {
+    return;
+  }
+  
+  let start = bucket_idx * params.bucket_size;
+  let end = min(start + params.bucket_size, params.input_count);
+  
+  if (start >= params.input_count) {
+    return;
+  }
+  
+  var min_y = input_points[start].y;
+  var max_y = input_points[start].y;
+  var min_idx = start;
+  var max_idx = start;
+  
+  for (var i = start; i < end; i = i + 1u) {
+    let y = input_points[i].y;
+    if (y < min_y) {
+      min_y = y;
+      min_idx = i;
+    }
+    if (y > max_y) {
+      max_y = y;
+      max_idx = i;
+    }
+  }
+  
+  // Output min and max points (preserving x,y pairs)
+  let out_base = bucket_idx * 2u;
+  
+  // Ensure min comes before max in x order
+  if (min_idx <= max_idx) {
+    output_points[out_base] = input_points[min_idx];
+    output_points[out_base + 1u] = input_points[max_idx];
+  } else {
+    output_points[out_base] = input_points[max_idx];
+    output_points[out_base + 1u] = input_points[min_idx];
+  }
+}
+`, Pe = `
+struct Params {
+  data_count: u32,
+  threshold: f32,
+  min_distance: u32,
+  padding: u32,
+}
+
+struct Peak {
+  index: u32,
+  value: f32,
+  is_peak: u32,
+  padding: u32,
+}
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage, read> data: array<f32>;
+@group(0) @binding(2) var<storage, read_write> peaks: array<Peak>;
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+  let idx = global_id.x;
+  
+  if (idx >= params.data_count) {
+    return;
+  }
+  
+  peaks[idx].index = idx;
+  peaks[idx].value = data[idx];
+  peaks[idx].is_peak = 0u;
+  
+  // Skip edges
+  if (idx < params.min_distance || idx >= params.data_count - params.min_distance) {
+    return;
+  }
+  
+  let val = data[idx];
+  
+  // Check if above threshold
+  if (val < params.threshold) {
+    return;
+  }
+  
+  // Check if local maximum
+  var is_max = true;
+  for (var i = 1u; i <= params.min_distance; i = i + 1u) {
+    if (data[idx - i] >= val || data[idx + i] >= val) {
+      is_max = false;
+      break;
+    }
+  }
+  
+  if (is_max) {
+    peaks[idx].is_peak = 1u;
+  }
+}
+`;
+class R {
+  constructor(e = {}) {
+    c(this, "device", null);
+    c(this, "statsPipeline", null);
+    c(this, "minmaxPipeline", null);
+    c(this, "downsamplePipeline", null);
+    c(this, "peaksPipeline", null);
+    c(this, "isInitialized", !1);
+    this.options = e;
+  }
+  /**
+   * Check if GPU compute is available
+   */
+  static isSupported() {
+    return typeof globalThis.navigator < "u" && typeof globalThis.navigator.gpu < "u";
+  }
+  /**
+   * Initialize the compute engine
+   */
+  async init() {
+    if (this.options.device)
+      this.device = this.options.device;
+    else {
+      if (!R.isSupported())
+        throw new Error("[GpuCompute] WebGPU not supported");
+      const t = await globalThis.navigator.gpu.requestAdapter({ powerPreference: "high-performance" });
+      if (!t)
+        throw new Error("[GpuCompute] Failed to get adapter");
+      this.device = await t.requestDevice();
+    }
+    await this.createPipelines(), this.isInitialized = !0;
+  }
+  async createPipelines() {
+    const e = this.device.createShaderModule({ code: xe });
+    this.statsPipeline = await this.device.createComputePipelineAsync({
+      layout: "auto",
+      compute: { module: e, entryPoint: "main" }
+    });
+    const t = this.device.createShaderModule({ code: ye });
+    this.minmaxPipeline = await this.device.createComputePipelineAsync({
+      layout: "auto",
+      compute: { module: t, entryPoint: "main" }
+    });
+    const i = this.device.createShaderModule({ code: _e });
+    this.downsamplePipeline = await this.device.createComputePipelineAsync({
+      layout: "auto",
+      compute: { module: i, entryPoint: "main" }
+    });
+    const r = this.device.createShaderModule({ code: Pe });
+    this.peaksPipeline = await this.device.createComputePipelineAsync({
+      layout: "auto",
+      compute: { module: r, entryPoint: "main" }
+    });
+  }
+  /**
+   * Calculate statistics for a 1D array of values
+   */
+  async calculateStats(e) {
+    if (!this.isInitialized)
+      throw new Error("[GpuCompute] Not initialized");
+    const t = globalThis.GPUBufferUsage, i = this.device.createBuffer({
+      size: e.byteLength,
+      usage: t.STORAGE | t.COPY_DST
+    });
+    this.device.queue.writeBuffer(i, 0, e);
+    const r = this.device.createBuffer({
+      size: 32,
+      usage: t.STORAGE | t.COPY_SRC
+    }), a = this.device.createBuffer({
+      size: 32,
+      usage: t.MAP_READ | t.COPY_DST
+    }), n = this.device.createBindGroup({
+      layout: this.statsPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: i } },
+        { binding: 1, resource: { buffer: r } }
+      ]
+    }), o = this.device.createCommandEncoder(), u = o.beginComputePass();
+    u.setPipeline(this.statsPipeline), u.setBindGroup(0, n);
+    const l = Math.ceil(e.length / 256);
+    u.dispatchWorkgroups(l), u.end(), o.copyBufferToBuffer(r, 0, a, 0, 32), this.device.queue.submit([o.finish()]), await a.mapAsync(globalThis.GPUMapMode.READ);
+    const p = new Float32Array(a.getMappedRange().slice(0));
+    a.unmap(), i.destroy(), r.destroy(), a.destroy();
+    const [f, h, d, m, b] = p, g = Math.floor(b), v = g > 0 ? d / g : 0, x = g > 1 ? (m - d * d / g) / (g - 1) : 0, y = Math.sqrt(Math.max(0, x));
+    return { min: f, max: h, mean: v, std: y, count: g };
+  }
+  /**
+   * Calculate bounds for 2D point data
+   */
+  async calculateBounds(e) {
+    if (!this.isInitialized)
+      throw new Error("[GpuCompute] Not initialized");
+    const t = globalThis.GPUBufferUsage, i = this.device.createBuffer({
+      size: e.byteLength,
+      usage: t.STORAGE | t.COPY_DST
+    });
+    this.device.queue.writeBuffer(i, 0, e);
+    const r = this.device.createBuffer({
+      size: 16,
+      usage: t.STORAGE | t.COPY_SRC
+    }), a = this.device.createBuffer({
+      size: 16,
+      usage: t.MAP_READ | t.COPY_DST
+    }), n = this.device.createBindGroup({
+      layout: this.minmaxPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: i } },
+        { binding: 1, resource: { buffer: r } }
+      ]
+    }), o = this.device.createCommandEncoder(), u = o.beginComputePass();
+    u.setPipeline(this.minmaxPipeline), u.setBindGroup(0, n);
+    const l = e.length / 2, p = Math.ceil(l / 256);
+    u.dispatchWorkgroups(p), u.end(), o.copyBufferToBuffer(r, 0, a, 0, 16), this.device.queue.submit([o.finish()]), await a.mapAsync(globalThis.GPUMapMode.READ);
+    const f = new Float32Array(a.getMappedRange().slice(0));
+    return a.unmap(), i.destroy(), r.destroy(), a.destroy(), {
+      xMin: f[0],
+      xMax: f[1],
+      yMin: f[2],
+      yMax: f[3]
+    };
+  }
+  /**
+   * Downsample point data using min-max algorithm
+   */
+  async downsample(e, t) {
+    if (!this.isInitialized)
+      throw new Error("[GpuCompute] Not initialized");
+    const i = e.length / 2;
+    if (i <= t)
+      return e;
+    const r = globalThis.GPUBufferUsage, a = Math.ceil(t / 2), n = Math.ceil(i / a), o = a * 2, u = new Uint32Array([i, o, n, 0]), l = this.device.createBuffer({
+      size: 16,
+      usage: r.UNIFORM | r.COPY_DST
+    });
+    this.device.queue.writeBuffer(l, 0, u);
+    const p = this.device.createBuffer({
+      size: e.byteLength,
+      usage: r.STORAGE | r.COPY_DST
+    });
+    this.device.queue.writeBuffer(p, 0, e);
+    const f = o * 2 * 4, h = this.device.createBuffer({
+      size: f,
+      usage: r.STORAGE | r.COPY_SRC
+    }), d = this.device.createBuffer({
+      size: f,
+      usage: r.MAP_READ | r.COPY_DST
+    }), m = this.device.createBindGroup({
+      layout: this.downsamplePipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: l } },
+        { binding: 1, resource: { buffer: p } },
+        { binding: 2, resource: { buffer: h } }
+      ]
+    }), b = this.device.createCommandEncoder(), g = b.beginComputePass();
+    g.setPipeline(this.downsamplePipeline), g.setBindGroup(0, m);
+    const v = Math.ceil(a / 64);
+    g.dispatchWorkgroups(v), g.end(), b.copyBufferToBuffer(h, 0, d, 0, f), this.device.queue.submit([b.finish()]), await d.mapAsync(globalThis.GPUMapMode.READ);
+    const x = new Float32Array(d.getMappedRange().slice(0));
+    return d.unmap(), l.destroy(), p.destroy(), h.destroy(), d.destroy(), x;
+  }
+  /**
+   * Detect peaks in 1D data
+   */
+  async detectPeaks(e, t = {}) {
+    if (!this.isInitialized)
+      throw new Error("[GpuCompute] Not initialized");
+    const i = t.threshold ?? 0, r = t.minDistance ?? 1, a = globalThis.GPUBufferUsage, n = new Float32Array([
+      e.length,
+      i,
+      r,
+      0
+      // padding
+    ]), o = this.device.createBuffer({
+      size: 16,
+      usage: a.UNIFORM | a.COPY_DST
+    });
+    this.device.queue.writeBuffer(o, 0, new Uint8Array(n.buffer));
+    const u = this.device.createBuffer({
+      size: e.byteLength,
+      usage: a.STORAGE | a.COPY_DST
+    });
+    this.device.queue.writeBuffer(u, 0, e);
+    const l = e.length * 16, p = this.device.createBuffer({
+      size: l,
+      usage: a.STORAGE | a.COPY_SRC
+    }), f = this.device.createBuffer({
+      size: l,
+      usage: a.MAP_READ | a.COPY_DST
+    }), h = this.device.createBindGroup({
+      layout: this.peaksPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: { buffer: o } },
+        { binding: 1, resource: { buffer: u } },
+        { binding: 2, resource: { buffer: p } }
+      ]
+    }), d = this.device.createCommandEncoder(), m = d.beginComputePass();
+    m.setPipeline(this.peaksPipeline), m.setBindGroup(0, h);
+    const b = Math.ceil(e.length / 64);
+    m.dispatchWorkgroups(b), m.end(), d.copyBufferToBuffer(p, 0, f, 0, l), this.device.queue.submit([d.finish()]), await f.mapAsync(globalThis.GPUMapMode.READ);
+    const g = new ArrayBuffer(l);
+    new Uint8Array(g).set(new Uint8Array(f.getMappedRange())), f.unmap();
+    const v = new DataView(g), x = [];
+    for (let y = 0; y < e.length; y++) {
+      const B = y * 16;
+      v.getUint32(B + 8, !0) && x.push({
+        index: v.getUint32(B, !0),
+        value: v.getFloat32(B + 4, !0)
+      });
+    }
+    return o.destroy(), u.destroy(), p.destroy(), f.destroy(), x;
+  }
+  /**
+   * Cleanup resources
+   */
+  destroy() {
+    this.device = null, this.statsPipeline = null, this.minmaxPipeline = null, this.downsamplePipeline = null, this.peaksPipeline = null, this.isInitialized = !1;
+  }
+}
+const we = {
+  name: "velo-plot-gpu",
+  version: "1.0.0",
+  description: "GPU acceleration and WebGPU support for velo-plot",
+  provides: ["renderer", "compute"],
+  tags: ["gpu", "webgpu", "webgl2", "performance"]
+};
+function Ee(s = {}) {
+  return {
+    manifest: we,
+    onInit(e) {
+    },
+    onDestroy(e) {
+    }
+  };
+}
+export {
+  Te as BaseBufferStore,
+  Me as BaseTextureStore,
+  Ge as GpuBenchmark,
+  R as GpuCompute,
+  ve as GpuRenderer,
+  ke as PipelineCache,
+  Ee as PluginGpu,
+  M as SeriesAdapter,
+  P as WebGLBackend,
+  _ as WebGPUBackend,
+  Ae as createGpuRenderer,
+  Ee as default,
+  U as parseColorToRGBA
+};
+//# sourceMappingURL=gpu.js.map