gpu-atlas 0.1.0

package/dist/gpu-atlas.js

@@ -0,0 +1,1938 @@
+const Et = 4, Tt = 2;
+class D extends Error {
+  constructor(t) {
+    super(t), this.name = "WebGPUUnavailable";
+  }
+}
+async function ke(e) {
+  if (typeof navigator > "u" || !navigator.gpu)
+    throw new D("navigator.gpu is missing — this browser has no WebGPU");
+  const t = await navigator.gpu.requestAdapter(
+    e ? { powerPreference: e } : void 0
+  );
+  if (!t)
+    throw new D(
+      "requestAdapter returned null — the WebGPU API exists but no usable adapter does"
+    );
+  const r = await Se(t, e), n = [...t.features], i = Me(t.limits), a = [];
+  let s = await N(t, n, i);
+  if (s || (a.push("requiredLimits (all)"), s = await N(t, n, void 0)), !s) {
+    a.push("requiredFeatures (all)");
+    const u = [];
+    for (const c of n) {
+      const l = await N(t, [...u, c], void 0);
+      l ? (u.push(c), l.destroy()) : a.push(`feature:${c}`);
+    }
+    s = await N(t, u, void 0);
+  }
+  if (!s)
+    throw new D(
+      "requestDevice kept failing — there is an adapter but no device can be created from it"
+    );
+  const o = {
+    features: [...t.features].sort(),
+    limits: i,
+    preferredCanvasFormat: Ee()
+  };
+  return { adapter: t, device: s, identity: r, declared: o, denied: a, lost: s.lost };
+}
+async function N(e, t, r) {
+  try {
+    const n = { requiredFeatures: t };
+    return r && (n.requiredLimits = r), await e.requestDevice(n);
+  } catch {
+    return null;
+  }
+}
+async function Se(e, t) {
+  let r = e.info;
+  if (!r) {
+    const n = e;
+    if (typeof n.requestAdapterInfo == "function")
+      try {
+        r = await n.requestAdapterInfo();
+      } catch {
+        r = void 0;
+      }
+  }
+  return {
+    vendor: r?.vendor ?? "",
+    architecture: r?.architecture ?? "",
+    device: r?.device ?? "",
+    description: r?.description ?? "",
+    // isFallbackAdapter has lived on both the adapter and its info over time.
+    isFallbackAdapter: e.isFallbackAdapter ?? r?.isFallbackAdapter ?? !1,
+    powerPreference: t ?? "default"
+  };
+}
+function Me(e) {
+  const t = {};
+  for (const r of Pe(e)) {
+    const n = e[r];
+    typeof n == "number" && Number.isFinite(n) && (t[r] = n);
+  }
+  return t;
+}
+function Pe(e) {
+  const t = /* @__PURE__ */ new Set();
+  let r = Object.getPrototypeOf(e);
+  for (; r && r !== Object.prototype; ) {
+    for (const n of Object.getOwnPropertyNames(r))
+      n !== "constructor" && t.add(n);
+    r = Object.getPrototypeOf(r);
+  }
+  for (const n of Object.keys(e)) t.add(n);
+  return [...t].sort();
+}
+function Ee() {
+  try {
+    return navigator.gpu.getPreferredCanvasFormat();
+  } catch {
+    return "";
+  }
+}
+async function Te() {
+  const e = typeof navigator < "u" ? navigator.userAgent : "", t = navigator.userAgentData;
+  let r, n, i, a;
+  if (t) {
+    n = t.mobile, r = t.platform;
+    try {
+      const o = await t.getHighEntropyValues(["platformVersion", "fullVersionList"]), c = (o.fullVersionList ?? t.brands)?.find((l) => !/Not.?A.?Brand/i.test(l.brand));
+      c && (i = c.brand, a = c.version), o.platformVersion && (r = `${r} ${o.platformVersion}`);
+    } catch {
+    }
+  }
+  const s = Ae(e);
+  return {
+    // The UA string is parsed above but deliberately not kept: everything the
+    // profile needs from it is already broken out, and the raw value only adds
+    // identifying detail to something people are asked to share.
+    platform: r,
+    browser: i ?? s.browser,
+    browserVersion: a ?? s.version,
+    mobile: n ?? /Mobi|Android|iPhone|iPad/i.test(e),
+    deviceMemoryGB: navigator.deviceMemory,
+    hardwareConcurrency: navigator.hardwareConcurrency,
+    devicePixelRatio: typeof devicePixelRatio == "number" ? devicePixelRatio : 1
+  };
+}
+function Ae(e) {
+  const t = [
+    ["Edge", /Edg(?:e|A|iOS)?\/([\d.]+)/],
+    ["Opera", /OPR\/([\d.]+)/],
+    ["Firefox", /Firefox\/([\d.]+)/],
+    ["Chrome", /(?:Chrome|CriOS)\/([\d.]+)/],
+    ["Safari", /Version\/([\d.]+).*Safari/]
+  ];
+  for (const [r, n] of t) {
+    const i = e.match(n);
+    if (i) return { browser: r, version: i[1] };
+  }
+  return { browser: "unknown", version: "" };
+}
+const d = (e, t, r, n, i) => ({ format: e, kind: "color", texel: t, filterable: r, expect: n, requiresFeature: i }), I = { renderable: !1, blendable: !1, storage: !1 }, A = { renderable: !0, blendable: !0, storage: !1 }, y = { renderable: !0, blendable: !1, storage: !1 }, ae = { renderable: !0, blendable: !0, storage: !0 }, x = { renderable: !0, blendable: !1, storage: !0 }, Be = { renderable: !1, blendable: !1, storage: !0 }, ie = [
+  // ── 8-bit ──
+  d("r8unorm", "f32", !0, A),
+  d("r8snorm", "f32", !0, I),
+  d("r8uint", "u32", !1, y),
+  d("r8sint", "i32", !1, y),
+  // ── 16-bit ──
+  d("r16uint", "u32", !1, y),
+  d("r16sint", "i32", !1, y),
+  d("r16float", "f32", !0, A),
+  d("rg8unorm", "f32", !0, A),
+  d("rg8snorm", "f32", !0, I),
+  d("rg8uint", "u32", !1, y),
+  d("rg8sint", "i32", !1, y),
+  // ── 32-bit ──
+  d("r32uint", "u32", !1, x),
+  d("r32sint", "i32", !1, x),
+  // r32float renders but does not blend without float32-blendable
+  d("r32float", "f32", !1, x),
+  d("rg16uint", "u32", !1, y),
+  d("rg16sint", "i32", !1, y),
+  d("rg16float", "f32", !0, A),
+  d("rgba8unorm", "f32", !0, ae),
+  d("rgba8unorm-srgb", "f32", !0, A),
+  d("rgba8snorm", "f32", !0, Be),
+  d("rgba8uint", "u32", !1, x),
+  d("rgba8sint", "i32", !1, x),
+  d("bgra8unorm", "f32", !0, A),
+  d("bgra8unorm-srgb", "f32", !0, A),
+  d("rgb10a2uint", "u32", !1, y),
+  d("rgb10a2unorm", "f32", !0, A),
+  // rg11b10ufloat rendering sits behind its own feature gate
+  d("rg11b10ufloat", "f32", !0, I),
+  // ── 64-bit ──
+  d("rg32uint", "u32", !1, x),
+  d("rg32sint", "i32", !1, x),
+  d("rg32float", "f32", !1, x),
+  d("rgba16uint", "u32", !1, x),
+  d("rgba16sint", "i32", !1, x),
+  d("rgba16float", "f32", !0, ae),
+  // ── 128-bit ──
+  d("rgba32uint", "u32", !1, x),
+  d("rgba32sint", "i32", !1, x),
+  d("rgba32float", "f32", !1, x),
+  // ── Depth / stencil ──
+  {
+    format: "stencil8",
+    kind: "depth",
+    texel: "u32",
+    filterable: !1,
+    hasStencil: !0,
+    expect: y
+  },
+  {
+    format: "depth16unorm",
+    kind: "depth",
+    texel: "f32",
+    filterable: !1,
+    hasDepth: !0,
+    expect: y
+  },
+  {
+    format: "depth24plus",
+    kind: "depth",
+    texel: "f32",
+    filterable: !1,
+    hasDepth: !0,
+    expect: y
+  },
+  {
+    format: "depth24plus-stencil8",
+    kind: "depth",
+    texel: "f32",
+    filterable: !1,
+    hasDepth: !0,
+    hasStencil: !0,
+    expect: y
+  },
+  {
+    format: "depth32float",
+    kind: "depth",
+    texel: "f32",
+    filterable: !1,
+    hasDepth: !0,
+    expect: y
+  },
+  {
+    format: "depth32float-stencil8",
+    kind: "depth",
+    texel: "f32",
+    filterable: !1,
+    hasDepth: !0,
+    hasStencil: !0,
+    requiresFeature: "depth32float-stencil8",
+    expect: y
+  },
+  // ── Compressed: BC (desktop) ──
+  ...L([
+    "bc1-rgba-unorm",
+    "bc3-rgba-unorm",
+    "bc4-r-unorm",
+    "bc5-rg-unorm",
+    "bc6h-rgb-ufloat",
+    "bc7-rgba-unorm"
+  ], "texture-compression-bc", [4, 4]),
+  // ── Compressed: ETC2 (mobile) ──
+  ...L(
+    ["etc2-rgb8unorm", "etc2-rgba8unorm", "eac-r11unorm"],
+    "texture-compression-etc2",
+    [4, 4]
+  ),
+  // ── Compressed: ASTC (mobile) ──
+  ...L(["astc-4x4-unorm"], "texture-compression-astc", [4, 4]),
+  ...L(["astc-8x8-unorm"], "texture-compression-astc", [8, 8])
+];
+function L(e, t, r) {
+  return e.map((n) => ({
+    format: n,
+    kind: "compressed",
+    texel: "f32",
+    filterable: !0,
+    requiresFeature: t,
+    block: r,
+    expect: I
+  }));
+}
+function $e(e) {
+  return ie.find((t) => t.format === e);
+}
+const se = /* @__PURE__ */ new Set([
+  "r8unorm",
+  "r8snorm",
+  "r8uint",
+  "r8sint",
+  "rg8unorm",
+  "rg8snorm",
+  "rg8uint",
+  "rg8sint",
+  "r16uint",
+  "r16sint",
+  "r16float",
+  "rg16uint",
+  "rg16sint",
+  "rg16float",
+  "rgb10a2unorm",
+  "rgb10a2uint",
+  "rg11b10ufloat"
+]), Re = /* @__PURE__ */ new Set(["r32float", "rg32float", "rgba32float"]);
+function _e(e, t) {
+  const r = { ...e.expect };
+  return t.has("texture-formats-tier1") && se.has(e.format) && (r.storage = !0), t.has("rg11b10ufloat-renderable") && e.format === "rg11b10ufloat" && (r.renderable = !0, r.blendable = !0), t.has("bgra8unorm-storage") && e.format === "bgra8unorm" && (r.storage = !0), t.has("float32-blendable") && Re.has(e.format) && (r.blendable = !0), t.has("texture-formats-tier2") && e.kind === "color" && (r.storage = r.storage || se.has(e.format)), r;
+}
+function Ge(e) {
+  return e.has("texture-formats-tier1") || e.has("texture-formats-tier2");
+}
+function Fe(e) {
+  return e.kind === "depth" ? e.hasDepth ? "depth" : "uint" : e.texel === "u32" ? "uint" : e.texel === "i32" ? "sint" : e.filterable ? "float" : "unfilterable-float";
+}
+function Ue(e) {
+  return e.kind === "depth" && e.hasDepth ? "texture_depth_2d" : `texture_2d<${e.texel}>`;
+}
+const Y = ["validation", "out-of-memory", "internal"];
+async function W(e, t, r = !1) {
+  for (const a of Y) e.pushErrorScope(a);
+  let n = null;
+  const i = [];
+  try {
+    n = await t();
+  } catch (a) {
+    i.push({ kind: "exception", message: X(a) });
+  }
+  if (r && i.length === 0)
+    try {
+      await e.queue.onSubmittedWorkDone();
+    } catch (a) {
+      i.push({ kind: "queue", message: X(a) });
+    }
+  for (let a = Y.length - 1; a >= 0; a--)
+    try {
+      const s = await e.popErrorScope();
+      s && i.push({ kind: Y[a], message: s.message });
+    } catch (s) {
+      i.push({ kind: "scope-unavailable", message: X(s) });
+    }
+  return { value: n, errors: i, ok: i.length === 0 && n !== null };
+}
+async function M(e, t, r = !1) {
+  const n = await W(e, async () => {
+    const i = await t();
+    return i === void 0 ? !0 : i;
+  }, r);
+  return { ok: n.ok, errors: n.errors };
+}
+function _(e, t) {
+  return t.map((r) => ({ ...r, stage: e }));
+}
+function O(e) {
+  return e[0]?.message ?? "no error reported";
+}
+function X(e) {
+  return e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+}
+function v(...e) {
+  for (const t of e)
+    try {
+      t?.destroy?.();
+    } catch {
+    }
+}
+const H = `
+@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f {
+  var p = array<vec2f, 3>(vec2f(-1., -1.), vec2f(3., -1.), vec2f(-1., 3.));
+  return vec4f(p[i], 0., 1.);
+}`;
+async function Ce(e, t, r, n) {
+  const i = r ? ie.filter((u) => r.includes(u.format)) : ie, a = e.createTexture({
+    size: [4, 4],
+    format: "rgba8unorm",
+    usage: GPUTextureUsage.RENDER_ATTACHMENT
+  }), s = { view: a.createView() }, o = [];
+  for (let u = 0; u < i.length; u++)
+    o.push(await Oe(e, i[u], t, s)), n?.((u + 1) / i.length);
+  return v(a), o;
+}
+async function Oe(e, t, r, n) {
+  const i = {
+    format: t.format,
+    requiresFeature: t.requiresFeature,
+    featureDeclared: t.requiresFeature ? r.has(t.requiresFeature) : !0,
+    creatable: !1,
+    sampleable: !1,
+    renderable: !1,
+    blendable: !1,
+    storageWritable: !1,
+    multisample4x: !1,
+    errors: []
+  }, [a, s] = t.block ?? [4, 4], o = await W(
+    e,
+    () => e.createTexture({
+      size: [a, s],
+      format: t.format,
+      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+    })
+  );
+  if (i.creatable = o.ok, !o.ok)
+    return i.errors.push(..._("create", o.errors)), i;
+  const u = o.value, c = await qe(e, t, u, n);
+  if (i.sampleable = c.ok, c.ok || i.errors.push(..._("sample", c.errors)), v(u), t.kind !== "compressed") if (t.kind === "depth") {
+    const l = await Ne(e, t);
+    i.renderable = l.ok, l.ok || i.errors.push(..._("render", l.errors));
+  } else {
+    const l = await ue(e, t, !1);
+    if (i.renderable = l.ok, l.ok || i.errors.push(..._("render", l.errors)), i.renderable) {
+      const f = await ue(e, t, !0);
+      i.blendable = f.ok, f.ok || i.errors.push(..._("blend", f.errors));
+    }
+  }
+  if (t.kind === "color") {
+    const l = await Le(e, t);
+    i.storageWritable = l.ok, l.ok || i.errors.push(..._("storage", l.errors));
+  }
+  if (i.renderable) {
+    const l = await De(e, t);
+    i.multisample4x = l.ok, l.ok || i.errors.push(..._("msaa4x", l.errors));
+  }
+  return i;
+}
+async function qe(e, t, r, n) {
+  const i = t.kind === "compressed", a = Fe(t);
+  return M(e, async () => {
+    const s = [{
+      binding: 0,
+      visibility: GPUShaderStage.FRAGMENT,
+      texture: { sampleType: a, viewDimension: "2d" }
+    }];
+    i && s.push({
+      binding: 1,
+      visibility: GPUShaderStage.FRAGMENT,
+      sampler: { type: t.filterable ? "filtering" : "non-filtering" }
+    });
+    const o = e.createBindGroupLayout({ entries: s }), u = e.createShaderModule({
+      code: H + Ie(t, i)
+    }), c = e.createRenderPipeline({
+      layout: e.createPipelineLayout({ bindGroupLayouts: [o] }),
+      vertex: { module: u, entryPoint: "vs" },
+      fragment: { module: u, entryPoint: "fs", targets: [{ format: "rgba8unorm" }] }
+    }), l = {};
+    t.hasDepth && t.hasStencil && (l.aspect = "depth-only");
+    const f = [
+      { binding: 0, resource: r.createView(l) }
+    ];
+    let p;
+    i && (p = e.createSampler(
+      t.filterable ? { magFilter: "linear", minFilter: "linear" } : {}
+    ), f.push({ binding: 1, resource: p }));
+    const h = e.createBindGroup({ layout: o, entries: f }), w = e.createCommandEncoder(), g = w.beginRenderPass({
+      colorAttachments: [{
+        view: n.view,
+        loadOp: "clear",
+        storeOp: "store",
+        clearValue: { r: 0, g: 0, b: 0, a: 1 }
+      }]
+    });
+    return g.setPipeline(c), g.setBindGroup(0, h), g.draw(3), g.end(), e.queue.submit([w.finish()]), !0;
+  }, !0);
+}
+async function ue(e, t, r) {
+  let n = null;
+  const i = await M(e, async () => {
+    const a = e.createTexture({
+      size: [4, 4],
+      format: t.format,
+      usage: GPUTextureUsage.RENDER_ATTACHMENT
+    }), s = { format: t.format };
+    r && (s.blend = {
+      color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
+      alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
+    });
+    const o = e.createShaderModule({
+      code: H + ye(t)
+    }), u = e.createRenderPipeline({
+      layout: "auto",
+      vertex: { module: o, entryPoint: "vs" },
+      fragment: { module: o, entryPoint: "fs", targets: [s] }
+    }), c = e.createCommandEncoder(), l = c.beginRenderPass({
+      colorAttachments: [{
+        view: a.createView(),
+        loadOp: "clear",
+        storeOp: "store",
+        clearValue: { r: 0, g: 0, b: 0, a: 1 }
+      }]
+    });
+    return l.setPipeline(u), l.draw(3), l.end(), e.queue.submit([c.finish()]), n = a, !0;
+  }, !0);
+  return v(n), i;
+}
+async function Ne(e, t) {
+  let r = null;
+  const n = await M(e, async () => {
+    const i = e.createTexture({
+      size: [4, 4],
+      format: t.format,
+      usage: GPUTextureUsage.RENDER_ATTACHMENT
+    }), a = {
+      format: t.format
+    };
+    t.hasDepth && (a.depthWriteEnabled = !0, a.depthCompare = "always");
+    const s = e.createShaderModule({ code: H }), o = e.createRenderPipeline({
+      layout: "auto",
+      vertex: { module: s, entryPoint: "vs" },
+      depthStencil: a
+    }), u = { view: i.createView() };
+    t.hasDepth && (u.depthClearValue = 1, u.depthLoadOp = "clear", u.depthStoreOp = "store"), t.hasStencil && (u.stencilClearValue = 0, u.stencilLoadOp = "clear", u.stencilStoreOp = "store");
+    const c = e.createCommandEncoder(), l = c.beginRenderPass({
+      colorAttachments: [],
+      depthStencilAttachment: u
+    });
+    return l.setPipeline(o), l.draw(3), l.end(), e.queue.submit([c.finish()]), r = i, !0;
+  }, !0);
+  return v(r), n;
+}
+async function Le(e, t) {
+  let r = null;
+  const n = await M(e, async () => {
+    const i = e.createTexture({
+      size: [4, 4],
+      format: t.format,
+      usage: GPUTextureUsage.STORAGE_BINDING
+    }), a = t.texel === "u32" ? "vec4u" : t.texel === "i32" ? "vec4i" : "vec4f", s = e.createShaderModule({
+      code: `
+@group(0) @binding(0) var t: texture_storage_2d<${t.format}, write>;
+@compute @workgroup_size(1) fn cs() {
+  textureStore(t, vec2i(0, 0), ${a}(${t.texel === "f32" ? "1., 0., 0., 1." : "1, 0, 0, 1"}));
+}`
+    }), o = e.createComputePipeline({
+      layout: "auto",
+      compute: { module: s, entryPoint: "cs" }
+    }), u = e.createBindGroup({
+      layout: o.getBindGroupLayout(0),
+      entries: [{ binding: 0, resource: i.createView() }]
+    }), c = e.createCommandEncoder(), l = c.beginComputePass();
+    return l.setPipeline(o), l.setBindGroup(0, u), l.dispatchWorkgroups(1), l.end(), e.queue.submit([c.finish()]), r = i, !0;
+  }, !0);
+  return v(r), n;
+}
+async function De(e, t) {
+  let r = null;
+  const n = await M(e, async () => {
+    const i = e.createTexture({
+      size: [4, 4],
+      format: t.format,
+      usage: GPUTextureUsage.RENDER_ATTACHMENT,
+      sampleCount: 4
+    }), a = e.createShaderModule({
+      code: H + (t.kind === "depth" ? "" : ye(t))
+    }), s = {
+      layout: "auto",
+      vertex: { module: a, entryPoint: "vs" },
+      multisample: { count: 4 }
+    };
+    if (t.kind === "depth") {
+      const l = { format: t.format };
+      t.hasDepth && (l.depthWriteEnabled = !0, l.depthCompare = "always"), s.depthStencil = l;
+    } else
+      s.fragment = {
+        module: a,
+        entryPoint: "fs",
+        targets: [{ format: t.format }]
+      };
+    const o = e.createRenderPipeline(s), u = e.createCommandEncoder();
+    let c;
+    if (t.kind === "depth") {
+      const l = { view: i.createView() };
+      t.hasDepth && (l.depthClearValue = 1, l.depthLoadOp = "clear", l.depthStoreOp = "discard"), t.hasStencil && (l.stencilClearValue = 0, l.stencilLoadOp = "clear", l.stencilStoreOp = "discard"), c = u.beginRenderPass({ colorAttachments: [], depthStencilAttachment: l });
+    } else
+      c = u.beginRenderPass({
+        colorAttachments: [{
+          view: i.createView(),
+          loadOp: "clear",
+          storeOp: "discard",
+          clearValue: { r: 0, g: 0, b: 0, a: 1 }
+        }]
+      });
+    return c.setPipeline(o), c.draw(3), c.end(), e.queue.submit([u.finish()]), r = i, !0;
+  }, !0);
+  return v(r), n;
+}
+function Ie(e, t) {
+  const n = `@group(0) @binding(0) var t: ${Ue(e)};`, i = t ? "@group(0) @binding(1) var s: sampler;" : "";
+  let a;
+  return t ? a = "return textureSample(t, s, vec2f(0.5, 0.5));" : e.kind === "depth" && e.hasDepth ? a = `let v = textureLoad(t, vec2i(0, 0), 0);
+  return vec4f(v, 0., 0., 1.);` : e.texel === "f32" ? a = "return textureLoad(t, vec2i(0, 0), 0);" : a = `let v = textureLoad(t, vec2i(0, 0), 0);
+  return vec4f(f32(v.x), f32(v.y), f32(v.z), 1.);`, `
+${n}
+${i}
+@fragment fn fs() -> @location(0) vec4f {
+  ${a}
+}`;
+}
+function ye(e) {
+  return e.texel === "u32" ? `
+@fragment fn fs() -> @location(0) vec4u {
+  return vec4u(1u, 0u, 0u, 1u);
+}` : e.texel === "i32" ? `
+@fragment fn fs() -> @location(0) vec4i {
+  return vec4i(1, 0, 0, 1);
+}` : `
+@fragment fn fs() -> @location(0) vec4f {
+  return vec4f(1., 0., 0., 1.);
+}`;
+}
+const G = `
+@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f {
+  var p = array<vec2f, 3>(vec2f(-1., -1.), vec2f(3., -1.), vec2f(-1., 3.));
+  return vec4f(p[i], 0., 1.);
+}`, Q = [
+  {
+    id: "baseline",
+    description: "The simplest possible render pipeline — a reference point for the rest",
+    pipeline: "render",
+    code: `${G}
+@fragment fn fs() -> @location(0) vec4f { return vec4f(1.); }`
+  },
+  {
+    id: "uniform-dynamic-index",
+    description: "Dynamic indexing into a uniform array — backends add clamping code or slow down",
+    pipeline: "render",
+    code: `${G}
+struct Data { items: array<vec4f, 64> };
+@group(0) @binding(0) var<uniform> data: Data;
+@fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+  let i = u32(pos.x) % 64u;
+  return data.items[i];
+}`
+  },
+  {
+    id: "nested-loop-break",
+    description: "Nested loops with conditional breaks — where control flow flattening diverges",
+    pipeline: "render",
+    code: `${G}
+@fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+  var acc = 0.;
+  for (var i = 0u; i < 8u; i++) {
+    for (var j = 0u; j < 8u; j++) {
+      if (f32(i * j) > pos.x) { break; }
+      acc += 0.01;
+    }
+    if (acc > 0.5) { break; }
+  }
+  return vec4f(acc, 0., 0., 1.);
+}`
+  },
+  {
+    id: "function-pointers",
+    description: "Passing var<function> pointers — naga and tint handle this differently",
+    pipeline: "render",
+    code: `${G}
+fn bump(p: ptr<function, vec3f>, amount: f32) {
+  (*p) = (*p) + vec3f(amount);
+}
+@fragment fn fs() -> @location(0) vec4f {
+  var v = vec3f(0.);
+  bump(&v, 0.25);
+  bump(&v, 0.25);
+  return vec4f(v, 1.);
+}`
+  },
+  {
+    id: "workgroup-atomics",
+    description: "Workgroup memory with atomics and barriers",
+    pipeline: "compute",
+    code: `
+var<workgroup> counter: atomic<u32>;
+@group(0) @binding(0) var<storage, read_write> out: array<u32>;
+@compute @workgroup_size(64) fn cs(@builtin(local_invocation_id) lid: vec3u) {
+  if (lid.x == 0u) { atomicStore(&counter, 0u); }
+  workgroupBarrier();
+  atomicAdd(&counter, 1u);
+  workgroupBarrier();
+  if (lid.x == 0u) { out[0] = atomicLoad(&counter); }
+}`
+  },
+  {
+    id: "storage-runtime-array",
+    description: "Runtime-sized array with arrayLength — exercises binding metadata handling",
+    pipeline: "compute",
+    code: `
+@group(0) @binding(0) var<storage, read_write> data: array<f32>;
+@compute @workgroup_size(64) fn cs(@builtin(global_invocation_id) gid: vec3u) {
+  let n = arrayLength(&data);
+  if (gid.x < n) { data[gid.x] = f32(n); }
+}`
+  },
+  {
+    id: "struct-alignment",
+    description: "Nested struct alignment and stride — a classic source of backend layout bugs",
+    pipeline: "compute",
+    code: `
+struct Inner { a: vec3f, b: f32 };
+struct Outer { m: mat4x4f, items: array<Inner, 4>, flag: u32 };
+@group(0) @binding(0) var<storage, read_write> data: Outer;
+@compute @workgroup_size(1) fn cs() {
+  data.items[0].b = data.m[0][0] + f32(data.flag);
+}`
+  },
+  {
+    id: "override-constants",
+    description: "Override constants — pipeline-time specialization, unevenly supported",
+    pipeline: "compute",
+    code: `
+override tileSize: u32 = 8u;
+@group(0) @binding(0) var<storage, read_write> out: array<u32>;
+@compute @workgroup_size(1) fn cs() { out[0] = tileSize; }`
+  },
+  {
+    id: "textureSampleLevel-uniform",
+    description: "Texture sampling under non-uniform control flow — uniformity analysis differs",
+    pipeline: "render",
+    code: `${G}
+@group(0) @binding(0) var t: texture_2d<f32>;
+@group(0) @binding(1) var s: sampler;
+@fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+  var c = vec4f(0.);
+  if (pos.x > 1.) {
+    c = textureSampleLevel(t, s, vec2f(0.5), 0.);
+  }
+  return c;
+}`
+  },
+  {
+    id: "long-unrolled",
+    description: "A large shader — exists to measure compile time",
+    pipeline: "render",
+    code: `${G}
+@fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+  var acc = vec3f(0.);
+  var p = pos.xyz * 0.01;
+${Array.from({ length: 64 }, (e, t) => `  p = fract(p * 1.${t % 9 + 1} + vec3f(${(t * 0.37).toFixed(3)}));
+  acc += p * ${(0.01 + t * 1e-3).toFixed(4)};`).join(`
+`)}
+  return vec4f(acc, 1.);
+}`
+  },
+  {
+    id: "f16-arithmetic",
+    description: "f16 arithmetic via shader-f16 — central to mobile performance, unevenly available",
+    requiresFeature: "shader-f16",
+    pipeline: "render",
+    code: `enable f16;
+${G}
+@fragment fn fs() -> @location(0) vec4f {
+  var v: vec4<f16> = vec4<f16>(0.5h, 0.25h, 0.125h, 1.0h);
+  v = v * 2.0h + vec4<f16>(0.1h);
+  return vec4f(v);
+}`
+  }
+];
+async function ze(e, t, r) {
+  const n = [];
+  for (let i = 0; i < Q.length; i++) {
+    const a = Q[i];
+    if (r?.((i + 1) / Q.length), a.requiresFeature && !t.has(a.requiresFeature)) {
+      n.push({
+        id: a.id,
+        description: a.description,
+        skipped: !0,
+        compiled: !1,
+        pipelineCreated: !1,
+        messages: [{
+          type: "info",
+          message: `skipped: ${a.requiresFeature} not supported`,
+          lineNum: 0
+        }],
+        compileMs: 0
+      });
+      continue;
+    }
+    n.push(await Ve(e, a));
+  }
+  return n;
+}
+async function Ve(e, t) {
+  const r = {
+    id: t.id,
+    description: t.description,
+    skipped: !1,
+    compiled: !1,
+    pipelineCreated: !1,
+    messages: [],
+    compileMs: 0
+  }, n = performance.now(), i = await W(e, () => e.createShaderModule({ code: t.code }));
+  if (!i.ok || !i.value)
+    return r.compileMs = performance.now() - n, r.messages.push(...i.errors.map(ce)), r;
+  let a = null;
+  try {
+    a = await i.value.getCompilationInfo();
+  } catch (o) {
+    r.messages.push({ type: "error", message: String(o), lineNum: 0 });
+  }
+  if (r.compileMs = performance.now() - n, a)
+    for (const o of a.messages)
+      r.messages.push({
+        type: o.type,
+        message: o.message,
+        lineNum: o.lineNum
+      });
+  if (r.compiled = !r.messages.some((o) => o.type === "error"), !r.compiled) return r;
+  const s = await W(e, () => t.pipeline === "compute" ? e.createComputePipelineAsync({
+    layout: "auto",
+    compute: { module: i.value, entryPoint: "cs" }
+  }) : e.createRenderPipelineAsync({
+    layout: "auto",
+    vertex: { module: i.value, entryPoint: "vs" },
+    fragment: {
+      module: i.value,
+      entryPoint: "fs",
+      targets: [{ format: "rgba8unorm" }]
+    }
+  }));
+  return r.pipelineCreated = s.ok, s.ok || r.messages.push(...s.errors.map(ce)), r;
+}
+function ce(e) {
+  return { type: "error", message: e.message, lineNum: 0 };
+}
+const We = 10, Z = [
+  {
+    limit: "maxBufferSize",
+    floor: 256 * 1024 * 1024,
+    test: (e, t) => M(e, () => {
+      const r = e.createBuffer({ size: J(t), usage: GPUBufferUsage.STORAGE });
+      return queueMicrotask(() => v(r)), r;
+    })
+  },
+  {
+    limit: "maxStorageBufferBindingSize",
+    floor: 128 * 1024 * 1024,
+    test: (e, t) => M(e, () => {
+      const r = e.createBuffer({
+        size: J(t),
+        usage: GPUBufferUsage.STORAGE
+      }), n = e.createBindGroupLayout({
+        entries: [{
+          binding: 0,
+          visibility: GPUShaderStage.COMPUTE,
+          buffer: { type: "storage" }
+        }]
+      }), i = e.createBindGroup({
+        layout: n,
+        entries: [{ binding: 0, resource: { buffer: r, size: J(t) } }]
+      });
+      return queueMicrotask(() => v(r)), i;
+    })
+  },
+  {
+    limit: "maxUniformBufferBindingSize",
+    floor: 16 * 1024,
+    test: (e, t) => M(e, () => {
+      const r = e.createBuffer({
+        size: le(t),
+        usage: GPUBufferUsage.UNIFORM
+      }), n = e.createBindGroupLayout({
+        entries: [{
+          binding: 0,
+          visibility: GPUShaderStage.FRAGMENT,
+          buffer: { type: "uniform" }
+        }]
+      }), i = e.createBindGroup({
+        layout: n,
+        entries: [{ binding: 0, resource: { buffer: r, size: le(t) } }]
+      });
+      return queueMicrotask(() => v(r)), i;
+    })
+  },
+  {
+    limit: "maxTextureDimension2D",
+    floor: 2048,
+    test: (e, t) => M(e, () => {
+      const r = e.createTexture({
+        size: [Math.floor(t), 1],
+        format: "rgba8unorm",
+        usage: GPUTextureUsage.TEXTURE_BINDING
+      });
+      return queueMicrotask(() => v(r)), r;
+    })
+  },
+  {
+    limit: "maxTextureArrayLayers",
+    floor: 256,
+    test: (e, t) => M(e, () => {
+      const r = e.createTexture({
+        size: [4, 4, Math.floor(t)],
+        format: "rgba8unorm",
+        usage: GPUTextureUsage.TEXTURE_BINDING,
+        dimension: "2d"
+      });
+      return queueMicrotask(() => v(r)), r;
+    })
+  },
+  {
+    limit: "maxComputeWorkgroupStorageSize",
+    floor: 16 * 1024,
+    test: (e, t) => M(e, async () => {
+      const r = Math.max(1, Math.floor(t / 16)), n = e.createShaderModule({
+        code: `
+var<workgroup> scratch: array<vec4f, ${r}>;
+@group(0) @binding(0) var<storage, read_write> out: array<f32>;
+@compute @workgroup_size(1) fn cs() {
+  scratch[0] = vec4f(1.);
+  out[0] = scratch[0].x;
+}`
+      });
+      return e.createComputePipelineAsync({
+        layout: "auto",
+        compute: { module: n, entryPoint: "cs" }
+      });
+    })
+  },
+  {
+    limit: "maxComputeInvocationsPerWorkgroup",
+    floor: 64,
+    test: (e, t) => M(e, async () => {
+      const r = e.createShaderModule({
+        code: `
+@group(0) @binding(0) var<storage, read_write> out: array<u32>;
+@compute @workgroup_size(${Math.floor(t)}) fn cs(@builtin(local_invocation_id) lid: vec3u) {
+  out[0] = lid.x;
+}`
+      });
+      return e.createComputePipelineAsync({
+        layout: "auto",
+        compute: { module: r, entryPoint: "cs" }
+      });
+    })
+  }
+];
+async function je(e, t, r) {
+  const n = [];
+  for (let i = 0; i < Z.length; i++) {
+    const a = Z[i];
+    r?.((i + 1) / Z.length);
+    const s = t[a.limit];
+    if (typeof s != "number" || s <= 0) continue;
+    const o = await a.test(e, s);
+    if (o.ok) {
+      n.push({
+        limit: a.limit,
+        declared: s,
+        achieved: s,
+        honored: !0
+      });
+      continue;
+    }
+    const u = await He(e, a, Math.min(a.floor, s), s);
+    n.push({
+      limit: a.limit,
+      declared: s,
+      achieved: u,
+      honored: !1,
+      error: o.errors[0] ?? {
+        kind: "validation",
+        message: "refused for an unreported reason",
+        stage: "limit"
+      }
+    });
+  }
+  return n;
+}
+async function He(e, t, r, n) {
+  let i = r, a = (await t.test(e, i)).ok;
+  for (; !a && i > 1; )
+    i = Math.floor(i / 2), a = (await t.test(e, i)).ok;
+  if (!a) return 0;
+  let s = n;
+  for (let o = 0; o < We && s - i > 1; o++) {
+    const u = i + Math.floor((s - i) / 2);
+    (await t.test(e, u)).ok ? i = u : s = u;
+  }
+  return i;
+}
+const J = (e) => Math.floor(e / 4) * 4, le = (e) => Math.floor(e / 16) * 16;
+class j {
+  constructor(t) {
+    this.available = t;
+  }
+  querySet = null;
+  resolveBuf = null;
+  readBuf = null;
+  static create(t) {
+    const r = t.features.has("timestamp-query"), n = new j(r);
+    if (!r) return n;
+    try {
+      n.querySet = t.createQuerySet({ type: "timestamp", count: 2 }), n.resolveBuf = t.createBuffer({
+        size: 16,
+        usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC
+      }), n.readBuf = t.createBuffer({
+        size: 16,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+      });
+    } catch {
+      return n.dispose(), new j(!1);
+    }
+    return n;
+  }
+  /** timestampWrites to put on a render pass descriptor */
+  writes() {
+    if (this.querySet)
+      return {
+        querySet: this.querySet,
+        beginningOfPassWriteIndex: 0,
+        endOfPassWriteIndex: 1
+      };
+  }
+  /** Attach the resolve commands to an encoder whose pass has been recorded */
+  resolve(t) {
+    !this.querySet || !this.resolveBuf || !this.readBuf || (t.resolveQuerySet(this.querySet, 0, 2, this.resolveBuf, 0), this.readBuf.mapState === "unmapped" && t.copyBufferToBuffer(this.resolveBuf, 0, this.readBuf, 0, 16));
+  }
+  /**
+   * Call after submitting. Returns GPU time in nanoseconds, or null if
+   * unreadable. Nanoseconds are kept raw because quantization detection needs
+   * the exact integer the browser reported.
+   */
+  async read() {
+    if (!this.readBuf || this.readBuf.mapState !== "unmapped") return null;
+    try {
+      await this.readBuf.mapAsync(GPUMapMode.READ);
+      const t = new BigInt64Array(this.readBuf.getMappedRange().slice(0));
+      this.readBuf.unmap();
+      const r = Number(t[1] - t[0]);
+      return !Number.isFinite(r) || r < 0 ? null : r;
+    } catch {
+      return null;
+    }
+  }
+  dispose() {
+    try {
+      this.querySet?.destroy();
+    } catch {
+    }
+    try {
+      this.resolveBuf?.destroy();
+    } catch {
+    }
+    try {
+      this.readBuf?.destroy();
+    } catch {
+    }
+    this.querySet = null, this.resolveBuf = null, this.readBuf = null;
+  }
+}
+function Ke(e) {
+  if (e.length === 0) return 0;
+  const t = [...e].sort((n, i) => n - i), r = t.length >> 1;
+  return t.length % 2 ? t[r] : (t[r - 1] + t[r]) / 2;
+}
+function Ye(e) {
+  if (e.length < 2) return 0;
+  const t = e.reduce((n, i) => n + i, 0) / e.length;
+  if (t === 0) return 0;
+  const r = e.reduce((n, i) => n + (i - t) ** 2, 0) / (e.length - 1);
+  return Math.sqrt(r) / t;
+}
+const Xe = 0.9, Qe = 0.02, Ze = 4;
+function Je(e, t) {
+  if (t <= 0 || e.length === 0) return !1;
+  const r = t * Qe;
+  let n = 0;
+  for (const i of e) {
+    const a = i % t;
+    (a <= r || a >= t - r) && n++;
+  }
+  return n / e.length >= Xe;
+}
+function et(e) {
+  const t = e.filter((s) => s > 0 && Number.isFinite(s));
+  if (t.length < Ze) return null;
+  const r = Math.min(...t), n = [...new Set(t)].sort((s, o) => s - o);
+  let i = 1 / 0;
+  for (let s = 1; s < n.length; s++)
+    i = Math.min(i, n[s] - n[s - 1]);
+  const a = Math.min(r, i);
+  return !Number.isFinite(a) || a <= 0 ? null : Je(t, a) ? a : null;
+}
+const P = 1024, tt = 3, ee = 10, rt = 100, nt = 60, ot = 20, fe = 2048, z = `
+@vertex fn vs(@builtin(vertex_index) i: u32) -> @builtin(position) vec4f {
+  var p = array<vec2f, 3>(vec2f(-1., -1.), vec2f(3., -1.), vec2f(-1., 3.));
+  return vec4f(p[i], 0., 1.);
+}`, te = `
+@vertex fn vs() -> @builtin(position) vec4f {
+  return vec4f(2., 2., 0.5, 1.);
+}`, V = `
+@fragment fn fs() -> @location(0) vec4f { return vec4f(0.25, 0.5, 0.75, 1.); }`, re = {
+  color: { srcFactor: "one", dstFactor: "one", operation: "add" },
+  alpha: { srcFactor: "one", dstFactor: "one", operation: "add" }
+}, de = "rgba8unorm";
+function B(e, t, r) {
+  const n = typeof t == "string" ? e.createShaderModule({ code: t }) : t;
+  return e.createRenderPipelineAsync({
+    layout: "auto",
+    vertex: { module: n, entryPoint: "vs" },
+    fragment: {
+      module: n,
+      entryPoint: "fs",
+      targets: [r ? { format: de, blend: r } : { format: de }]
+    }
+  });
+}
+const C = 2e3, pe = 1e5, ne = [
+  {
+    id: "drawcall-overhead",
+    description: "Empty draw calls — browser validation and driver call cost",
+    unitWorkload: C,
+    unit: "draws/s",
+    timingMode: "wall-clock-only",
+    setup: async (e, t) => {
+      const r = await B(e, te + V);
+      return {
+        record(n, i, a) {
+          const s = $(n, t, a);
+          s.setPipeline(r);
+          const o = C * i;
+          for (let u = 0; u < o; u++) s.draw(3);
+          s.end();
+        }
+      };
+    }
+  },
+  {
+    id: "pipeline-switch",
+    description: "Alternating between 8 pipelines per draw — state change cost",
+    unitWorkload: C,
+    unit: "switches/s",
+    timingMode: "wall-clock-only",
+    setup: async (e, t) => {
+      const r = [];
+      for (let n = 0; n < 8; n++)
+        r.push(await B(e, te + `
+@fragment fn fs() -> @location(0) vec4f { return vec4f(${(n / 8).toFixed(3)}, 0.5, 0.75, 1.); }`));
+      return {
+        record(n, i, a) {
+          const s = $(n, t, a), o = C * i;
+          for (let u = 0; u < o; u++)
+            s.setPipeline(r[u & 7]), s.draw(3);
+          s.end();
+        }
+      };
+    }
+  },
+  {
+    id: "bindgroup-switch",
+    description: "Alternating between 64 bind groups per draw — resource binding cost",
+    unitWorkload: C,
+    unit: "binds/s",
+    timingMode: "wall-clock-only",
+    setup: async (e, t) => {
+      const r = await B(e, `
+struct U { tint: vec4f };
+@group(0) @binding(0) var<uniform> u: U;
+${te}
+@fragment fn fs() -> @location(0) vec4f { return u.tint; }`), n = r.getBindGroupLayout(0), i = [], a = [];
+      for (let s = 0; s < 64; s++) {
+        const o = e.createBuffer({
+          size: 16,
+          usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+        });
+        e.queue.writeBuffer(o, 0, new Float32Array([s / 64, 0.5, 0.75, 1])), i.push(o), a.push(e.createBindGroup({
+          layout: n,
+          entries: [{ binding: 0, resource: { buffer: o } }]
+        }));
+      }
+      return {
+        record(s, o, u) {
+          const c = $(s, t, u);
+          c.setPipeline(r);
+          const l = C * o;
+          for (let f = 0; f < l; f++)
+            c.setBindGroup(0, a[f & 63]), c.draw(3);
+          c.end();
+        },
+        dispose: () => v(...i)
+      };
+    }
+  },
+  {
+    id: "fillrate",
+    description: `${P}x${P} fullscreen overdraw, blended — fragment throughput`,
+    unitWorkload: P * P * 8,
+    unit: "MPixel/s",
+    timingMode: "gpu-preferred",
+    setup: async (e, t) => {
+      const r = await B(e, z + V, re);
+      return {
+        record(n, i, a) {
+          const s = $(n, t, a);
+          s.setPipeline(r);
+          const o = 8 * i;
+          for (let u = 0; u < o; u++) s.draw(3);
+          s.end();
+        }
+      };
+    }
+  },
+  {
+    id: "fragment-alu",
+    description: "Heavy per-pixel arithmetic — shader math, separated from fill rate",
+    unitWorkload: P * P,
+    unit: "MPixel/s",
+    timingMode: "gpu-preferred",
+    setup: async (e, t) => {
+      const r = e.createShaderModule({
+        code: z + `
+@fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+  var p = pos.xyz * 0.001;
+  var acc = 0.;
+  for (var i = 0u; i < 64u; i++) {
+    p = fract(p * 1.7 + vec3f(0.31, 0.17, 0.53));
+    acc += dot(p, vec3f(0.33)) * exp(-p.x) + sqrt(abs(p.y));
+  }
+  return vec4f(acc * 0.01, p.y, p.z, 1.);
+}`
+      }), n = await B(e, r, re);
+      return {
+        record(i, a, s) {
+          const o = $(i, t, s);
+          o.setPipeline(n);
+          for (let u = 0; u < a; u++) o.draw(3);
+          o.end();
+        }
+      };
+    }
+  },
+  {
+    id: "triangle-throughput",
+    description: "Many small triangles — geometry throughput",
+    unitWorkload: pe,
+    unit: "MTri/s",
+    timingMode: "gpu-preferred",
+    setup: async (e, t) => {
+      const r = e.createShaderModule({
+        code: `
+@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
+  let tri = vi / 3u;
+  let corner = vi % 3u;
+  // Scatter triangles across a grid — they must stay on screen to avoid culling.
+  let gx = f32(tri % 1000u) / 1000. * 2. - 1.;
+  let gy = f32((tri / 1000u) % 100u) / 100. * 2. - 1.;
+  var off = array<vec2f, 3>(vec2f(0., 0.), vec2f(0.0015, 0.), vec2f(0., 0.0015));
+  return vec4f(gx + off[corner].x, gy + off[corner].y, 0.5, 1.);
+}
+${V}`
+      }), n = await B(e, r);
+      return {
+        record(i, a, s) {
+          const o = $(i, t, s);
+          o.setPipeline(n);
+          for (let u = 0; u < a; u++) o.draw(pe * 3);
+          o.end();
+        }
+      };
+    }
+  },
+  {
+    id: "texture-sampling",
+    description: "32 texture samples per pixel — texture bandwidth",
+    unitWorkload: P * P * 32,
+    unit: "GSample/s",
+    timingMode: "gpu-preferred",
+    setup: async (e, t) => {
+      const r = e.createTexture({
+        size: [512, 512],
+        format: "rgba8unorm",
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+      }), n = new Uint8Array(512 * 512 * 4);
+      for (let u = 0; u < n.length; u++) n[u] = u * 37 & 255;
+      e.queue.writeTexture({ texture: r }, n, { bytesPerRow: 512 * 4 }, [512, 512]);
+      const i = e.createShaderModule({
+        code: `
+@group(0) @binding(0) var t: texture_2d<f32>;
+@group(0) @binding(1) var s: sampler;
+${z}
+@fragment fn fs(@builtin(position) pos: vec4f) -> @location(0) vec4f {
+  var acc = vec4f(0.);
+  let base = pos.xy / ${P}.;
+  for (var i = 0u; i < 32u; i++) {
+    // Spread the coordinates so this does not all sit in cache.
+    let uv = fract(base + vec2f(f32(i) * 0.137, f32(i) * 0.379));
+    acc += textureSampleLevel(t, s, uv, 0.);
+  }
+  return acc * 0.03125;
+}`
+      }), a = await B(e, i, re), s = e.createSampler({ magFilter: "linear", minFilter: "linear" }), o = e.createBindGroup({
+        layout: a.getBindGroupLayout(0),
+        entries: [
+          { binding: 0, resource: r.createView() },
+          { binding: 1, resource: s }
+        ]
+      });
+      return {
+        record(u, c, l) {
+          const f = $(u, t, l);
+          f.setPipeline(a), f.setBindGroup(0, o);
+          for (let p = 0; p < c; p++) f.draw(3);
+          f.end();
+        },
+        dispose: () => v(r)
+      };
+    }
+  }
+];
+function it() {
+  let e = 1 / 0;
+  for (let t = 0; t < 24; t++) {
+    const r = performance.now();
+    let n = r;
+    for (; n === r; ) n = performance.now();
+    e = Math.min(e, n - r);
+  }
+  return Number.isFinite(e) && e > 0 ? e : 0;
+}
+async function at(e, t) {
+  if (!t.available) return null;
+  const r = e.createTexture({
+    size: [256, 256],
+    format: "rgba8unorm",
+    usage: GPUTextureUsage.RENDER_ATTACHMENT
+  }), n = r.createView();
+  let i;
+  try {
+    i = await B(e, z + V);
+  } catch {
+    return v(r), null;
+  }
+  const a = [];
+  let s = 1;
+  for (let o = 0; o < 14; o++) {
+    let u = 0;
+    for (let c = 0; c < 6; c++) {
+      const l = e.createCommandEncoder(), f = t.writes(), p = $(l, n, f);
+      p.setPipeline(i);
+      for (let w = 0; w < s; w++) p.draw(3);
+      p.end(), f && t.resolve(l), e.queue.submit([l.finish()]), await e.queue.onSubmittedWorkDone();
+      const h = await t.read();
+      h !== null && (a.push(h), h > 0 && u++);
+    }
+    if (u >= 4 && new Set(a.filter((c) => c > 0)).size >= 2) break;
+    s *= 4;
+  }
+  return v(r), et(a);
+}
+async function st(e, t, r) {
+  const n = performance.now(), i = j.create(e), a = e.createTexture({
+    size: [P, P],
+    format: "rgba8unorm",
+    usage: GPUTextureUsage.RENDER_ATTACHMENT
+  }), s = a.createView(), o = await at(e, i), u = it(), c = [];
+  for (let l = 0; l < ne.length; l++)
+    c.push(await ut(
+      e,
+      ne[l],
+      s,
+      i,
+      t,
+      o,
+      u
+    )), r?.((l + 1) / ne.length);
+  return i.dispose(), v(a), {
+    results: c,
+    timestampQuery: i.available,
+    timerResolutionNs: o,
+    wallClockResolutionMs: u > 0 ? u : null,
+    totalMs: Math.round(performance.now() - n)
+  };
+}
+async function ut(e, t, r, n, i, a, s) {
+  const o = {
+    id: t.id,
+    description: t.description,
+    medianMs: 0,
+    minMs: 0,
+    variation: 0,
+    timing: "wall-clock",
+    samples: 0,
+    repetitions: 0
+  };
+  let u;
+  try {
+    u = await t.setup(e, r);
+  } catch (l) {
+    return { ...o, failed: `setup failed: ${he(l)}` };
+  }
+  const c = t.timingMode === "gpu-preferred" && n.available;
+  try {
+    for (let m = 0; m < tt; m++) {
+      const S = e.createCommandEncoder();
+      u.record(S, 1), e.queue.submit([S.finish()]);
+    }
+    await e.queue.onSubmittedWorkDone();
+    const l = c ? a ? Math.max(ee, a * rt / 1e6) : ee : Math.max(ee, s * nt);
+    let f = 1;
+    for (let m = 0; m < 8; m++) {
+      const { ms: S } = await me(e, u, f, n, c);
+      if (S >= l || f >= fe) break;
+      const U = S > 1e-3 ? Math.ceil(l / S) : 8;
+      f = Math.min(fe, f * Math.max(2, Math.min(16, U)));
+    }
+    const p = [];
+    let h = 0;
+    for (let m = 0; m < i; m++) {
+      const { ms: S, fromGpu: U } = await me(e, u, f, n, c);
+      p.push(S), U && h++;
+    }
+    if (u.dispose?.(), p.length === 0)
+      return { ...o, failed: "no measurements were obtained" };
+    const w = h > p.length / 2, g = w ? p : ct(p), T = Ke(g), E = t.unitWorkload * f, k = {
+      ...o,
+      medianMs: q(T, 4),
+      minMs: q(Math.min(...g), 4),
+      variation: q(Ye(g), 3),
+      timing: w ? "timestamp-query" : "wall-clock",
+      samples: g.length,
+      repetitions: f
+    }, R = w ? a != null ? a / 1e6 : null : s > 0 ? s : null;
+    if (R) {
+      const m = T / R;
+      k.ticks = q(m, 1), k.quantized = m < ot;
+    }
+    if (T > 0) {
+      const m = E / (T / 1e3);
+      k.throughput = q(lt(m, t.unit), 2), k.throughputUnit = t.unit;
+    }
+    return k;
+  } catch (l) {
+    return u.dispose?.(), { ...o, failed: `run failed: ${he(l)}` };
+  }
+}
+async function me(e, t, r, n, i) {
+  const a = e.createCommandEncoder(), s = i ? n.writes() : void 0, o = performance.now();
+  t.record(a, r, s), s && n.resolve(a), e.queue.submit([a.finish()]), await e.queue.onSubmittedWorkDone();
+  const u = performance.now() - o;
+  if (s) {
+    const c = await n.read();
+    if (c !== null && c > 0) return { ms: c / 1e6, fromGpu: !0 };
+  }
+  return { ms: u, fromGpu: !1 };
+}
+function ct(e) {
+  return e.length < 5 ? e : [...e].sort((r, n) => r - n).slice(1, -1);
+}
+function $(e, t, r) {
+  const n = {
+    colorAttachments: [{
+      view: t,
+      loadOp: "clear",
+      storeOp: "store",
+      clearValue: { r: 0, g: 0, b: 0, a: 1 }
+    }]
+  };
+  return r && (n.timestampWrites = r), e.beginRenderPass(n);
+}
+function lt(e, t) {
+  return t.startsWith("M") ? e / 1e6 : t.startsWith("G") ? e / 1e9 : e;
+}
+function q(e, t) {
+  const r = 10 ** t;
+  return Math.round(e * r) / r;
+}
+function he(e) {
+  return e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+}
+function ft(e, t, r, n, i) {
+  const a = [], s = Ge(i);
+  for (const o of e) {
+    const u = $e(o.format);
+    if (o.featureDeclared && !o.creatable) {
+      a.push({
+        kind: "format-declared-not-usable",
+        subject: o.format,
+        detail: o.requiresFeature ? `${o.requiresFeature} is declared but createTexture fails: ${O(o.errors)}` : `core format, yet createTexture fails: ${O(o.errors)}`,
+        severity: "breaking"
+      });
+      continue;
+    }
+    if (o.creatable && !o.sampleable && a.push({
+      kind: "format-declared-not-usable",
+      subject: o.format,
+      detail: `the texture is created but shader sampling fails: ${O(o.errors)}`,
+      severity: "breaking"
+    }), !o.featureDeclared && o.creatable && a.push({
+      kind: "format-usable-not-declared",
+      subject: o.format,
+      detail: `${o.requiresFeature} is not declared, yet texture creation succeeds`,
+      severity: "note"
+    }), !u || !o.creatable) continue;
+    const c = _e(u, i);
+    c.renderable && !o.renderable && a.push({
+      kind: "format-declared-not-usable",
+      subject: o.format,
+      detail: `should be a valid render target per spec, but the render pass fails: ${O(o.errors)}`,
+      severity: "breaking"
+    }), c.blendable && o.renderable && !o.blendable && a.push({
+      kind: "format-declared-not-usable",
+      subject: o.format,
+      detail: "should support blending per spec, but creating a blend pipeline fails",
+      severity: "degraded"
+    }), c.storage && !o.storageWritable && a.push({
+      kind: "format-declared-not-usable",
+      subject: o.format,
+      detail: `should work as a storage texture per spec, but fails: ${O(o.errors)}`,
+      severity: "breaking"
+    }), !c.storage && o.storageWritable && !s && a.push({
+      kind: "format-usable-not-declared",
+      subject: o.format,
+      detail: "not a storage format per spec, yet it works on this implementation",
+      severity: "note"
+    });
+  }
+  for (const o of r) {
+    if (o.honored) continue;
+    const u = o.declared > 0 ? o.achieved / o.declared : 0;
+    a.push({
+      kind: "limit-not-honored",
+      subject: o.limit,
+      detail: `declares ${be(o.declared)} but only reaches ${be(o.achieved)}` + ` (${(u * 100).toFixed(0)}%). ${o.error?.message ?? ""}`.trimEnd(),
+      // Below half, code written against the declared value simply dies.
+      severity: u < 0.5 ? "breaking" : "degraded"
+    });
+  }
+  for (const o of t)
+    o.skipped || (o.compiled ? o.pipelineCreated || a.push({
+      kind: "shader-pipeline-failure",
+      subject: o.id,
+      detail: `${o.description} — compiled, but pipeline creation failed: ${ge(o)}`,
+      severity: "breaking"
+    }) : a.push({
+      kind: "shader-compile-failure",
+      subject: o.id,
+      detail: `${o.description} — compilation failed: ${ge(o)}`,
+      severity: "breaking"
+    }));
+  if (n)
+    for (const o of n.results)
+      o.failed ? a.push({
+        kind: "performance-cliff",
+        subject: o.id,
+        detail: `the benchmark did not complete: ${o.failed}`,
+        severity: "degraded"
+      }) : o.quantized ? a.push({
+        kind: "performance-cliff",
+        subject: o.id,
+        detail: `the measurement spans only ${o.ticks} timer resolution units, so it sits on the quantization floor. Treat this throughput as a lower bound rather than a measurement`,
+        severity: "note"
+      }) : o.variation > 0.35 && a.push({
+        kind: "performance-cliff",
+        subject: o.id,
+        detail: `variation is ${(o.variation * 100).toFixed(0)}% — likely thermal throttling or external load. This number should not be trusted`,
+        severity: "note"
+      });
+  return a;
+}
+function ge(e) {
+  return e.messages.find((t) => t.type === "error")?.message ?? "no error message";
+}
+function be(e) {
+  return e >= 1024 * 1024 * 1024 ? `${(e / 1024 / 1024 / 1024).toFixed(2)}GB` : e >= 1024 * 1024 ? `${(e / 1024 / 1024).toFixed(1)}MB` : e >= 1024 ? `${(e / 1024).toFixed(1)}KB` : String(e);
+}
+const dt = 16;
+function pt(e) {
+  const t = e.browserVersion.split(".")[0] ?? "";
+  return [
+    e.browser,
+    t,
+    e.vendor,
+    e.architecture,
+    e.device,
+    e.description
+  ].join("|");
+}
+async function ve(e) {
+  const t = pt(e), r = globalThis.crypto?.subtle;
+  if (r)
+    try {
+      const n = await r.digest("SHA-256", new TextEncoder().encode(t));
+      return ht(new Uint8Array(n).subarray(0, dt));
+    } catch {
+    }
+  return mt(t);
+}
+function mt(e) {
+  const r = [2166136261, 16777619, 3421674724, 2216829733];
+  for (let n = 0; n < e.length; n++) {
+    const i = e.charCodeAt(n);
+    for (let a = 0; a < r.length; a++)
+      r[a] ^= i + a * 40503, r[a] = Math.imul(r[a], 16777619) >>> 0;
+  }
+  return r.map((n) => n.toString(16).padStart(8, "0")).join("");
+}
+function ht(e) {
+  let t = "";
+  for (const r of e) t += r.toString(16).padStart(2, "0");
+  return t;
+}
+const F = { formats: 0.25, shaders: 0.1, limits: 0.15, bench: 0.5 };
+async function At(e = {}) {
+  const {
+    powerPreference: t,
+    benchmark: r = !0,
+    onProgress: n,
+    formats: i
+  } = e, a = gt(e.benchSamples ?? 7, 1, 99), s = performance.now(), o = await Te(), u = {
+    schema: 4,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fingerprint: "",
+    environment: o,
+    adapter: null,
+    declared: null,
+    verified: null,
+    benchmarks: null,
+    discrepancies: [],
+    elapsedMs: 0
+  };
+  let c;
+  try {
+    c = await ke(t);
+  } catch (b) {
+    return {
+      ...u,
+      unavailable: b instanceof D ? b.message : oe(b),
+      fingerprint: await ve({
+        browser: o.browser,
+        browserVersion: o.browserVersion,
+        vendor: "",
+        architecture: "",
+        device: "",
+        description: ""
+      }),
+      elapsedMs: performance.now() - s
+    };
+  }
+  const { device: l, identity: f, declared: p, denied: h, lost: w } = c;
+  let g;
+  w.then((b) => {
+    g = `${b.reason}: ${b.message}`;
+  });
+  const T = new Set(p.features);
+  let E = 0;
+  const k = (b, K) => {
+    try {
+      n?.(b, K);
+    } catch {
+    }
+  }, R = (b, K) => (xe) => k(b, E + K * xe), m = {
+    formats: [],
+    shaders: [],
+    limits: [],
+    deviceLost: !1
+  };
+  try {
+    k("formats", E), m.formats = await Ce(
+      l,
+      T,
+      i,
+      R("formats", F.formats)
+    ), E += F.formats, k("shaders", E), m.shaders = await ze(
+      l,
+      T,
+      R("shaders", F.shaders)
+    ), E += F.shaders, k("limits", E), m.limits = await je(
+      l,
+      p.limits,
+      R("limits", F.limits)
+    ), E += F.limits;
+  } catch (b) {
+    m.deviceLost = !0, m.deviceLostReason = g ?? oe(b);
+  }
+  let S = null;
+  if (r && !m.deviceLost) {
+    k("benchmarks", E);
+    try {
+      S = await st(l, a, R("benchmarks", F.bench));
+    } catch (b) {
+      m.deviceLostReason = g ?? oe(b);
+    }
+  }
+  k("done", 1), g && (m.deviceLost = !0, m.deviceLostReason = g);
+  const U = ft(
+    m.formats,
+    m.shaders,
+    m.limits,
+    S,
+    T
+  );
+  for (const b of h)
+    U.push({
+      kind: "limit-not-honored",
+      subject: b,
+      detail: "requestDevice refused values the adapter itself advertised",
+      severity: "degraded"
+    });
+  const we = {
+    ...u,
+    fingerprint: await ve({
+      browser: o.browser,
+      browserVersion: o.browserVersion,
+      vendor: f.vendor,
+      architecture: f.architecture,
+      device: f.device,
+      description: f.description
+    }),
+    adapter: f,
+    declared: p,
+    verified: m,
+    benchmarks: S,
+    discrepancies: U,
+    elapsedMs: Math.round(performance.now() - s)
+  };
+  return l.destroy(), we;
+}
+function gt(e, t, r) {
+  return Number.isFinite(e) ? Math.min(r, Math.max(t, Math.round(e))) : t;
+}
+function oe(e) {
+  return e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+}
+function bt(e) {
+  return {
+    profile: e,
+    features: new Set(e.declared.features),
+    formats: new Map(e.verified.formats.map((t) => [t.format, t])),
+    limits: new Map(e.verified.limits.map((t) => [t.limit, t])),
+    benchmarks: new Map((e.benchmarks?.results ?? []).map((t) => [t.id, t]))
+  };
+}
+const vt = [
+  "creatable",
+  "sampleable",
+  "renderable",
+  "blendable",
+  "storageWritable",
+  "multisample4x"
+], yt = 0.15;
+function Bt(e) {
+  const t = [], r = [], n = [], i = /* @__PURE__ */ new Set();
+  e.forEach((s, o) => {
+    if (s.unavailable) {
+      n.push({ index: o, reason: `WebGPU unavailable: ${s.unavailable}` });
+      return;
+    }
+    if (!s.verified || !s.declared) {
+      n.push({ index: o, reason: "profile has no verified data" });
+      return;
+    }
+    if (i.has(s.fingerprint)) {
+      n.push({
+        index: o,
+        reason: `duplicate of an earlier profile (${s.fingerprint.slice(0, 8)}) — comparison keys values by fingerprint and cannot hold two`
+      });
+      return;
+    }
+    i.add(s.fingerprint);
+    const u = typeof s.schema == "number" ? s.schema : 0;
+    t.push({
+      fingerprint: s.fingerprint,
+      label: wt(s),
+      mobile: s.environment.mobile,
+      index: o,
+      schema: u,
+      staleBenchmarks: u < 2
+    }), r.push(s);
+  });
+  const a = r.map(bt);
+  return {
+    devices: t,
+    ...xt(a),
+    formats: kt(a),
+    limits: St(a),
+    benchmarks: Mt(a),
+    excluded: n
+  };
+}
+function wt(e) {
+  const t = [e.adapter?.vendor, e.adapter?.architecture].filter(Boolean).join(" ") || e.adapter?.description || "unknown GPU", r = [e.environment.browser, Pt(e.environment.browserVersion)].filter(Boolean).join(" ");
+  return r ? `${t} / ${r}` : t;
+}
+function xt(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (const i of e) for (const a of i.features) t.add(a);
+  const r = [], n = [];
+  for (const i of [...t].sort()) {
+    const a = [], s = [];
+    for (const o of e)
+      (o.features.has(i) ? a : s).push(o.profile.fingerprint);
+    s.length === 0 ? n.push(i) : r.push({ feature: i, supportedBy: a, missingFrom: s });
+  }
+  return { features: r, sharedFeatures: n };
+}
+function kt(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (const n of e)
+    for (const i of n.formats.keys()) t.add(i);
+  const r = [];
+  for (const n of [...t].sort())
+    for (const i of vt) {
+      const a = [], s = [];
+      for (const o of e) {
+        const u = o.formats.get(n);
+        u && (u[i] ? a : s).push(o.profile.fingerprint);
+      }
+      a.length > 0 && s.length > 0 && r.push({ format: n, capability: i, supportedBy: a, missingFrom: s });
+    }
+  return r;
+}
+function St(e) {
+  const t = /* @__PURE__ */ new Set();
+  for (const n of e) for (const i of n.limits.keys()) t.add(i);
+  const r = [];
+  for (const n of [...t].sort()) {
+    const i = {};
+    for (const u of e) {
+      const c = u.limits.get(n);
+      c && (i[u.profile.fingerprint] = c.achieved);
+    }
+    const a = Object.values(i);
+    if (a.length < 2) continue;
+    const s = Math.min(...a), o = Math.max(...a);
+    s !== o && r.push({ limit: n, values: i, min: s, max: o, ratio: s > 0 ? o / s : 1 / 0 });
+  }
+  return r.sort((n, i) => i.ratio - n.ratio);
+}
+function Mt(e) {
+  const t = /* @__PURE__ */ new Map();
+  for (const n of e)
+    for (const [i, a] of n.benchmarks)
+      t.has(i) || t.set(i, a);
+  const r = [];
+  for (const [n, i] of t) {
+    const a = {}, s = [];
+    for (const f of e) {
+      const p = f.profile.fingerprint, h = f.benchmarks.get(n);
+      if (!h || h.failed || h.throughput == null) {
+        a[p] = null;
+        continue;
+      }
+      a[p] = h.throughput, ((f.profile.schema ?? 0) < 2 || h.quantized || h.variation > yt) && s.push(p);
+    }
+    const o = Object.entries(a).filter((f) => f[1] != null);
+    let u = null, c = null, l = null;
+    if (o.length >= 2) {
+      const f = [...o].sort((w, g) => g[1] - w[1]);
+      u = f[0][0], c = f[f.length - 1][0];
+      const p = f[0][1], h = f[f.length - 1][1];
+      l = h > 0 ? p / h : null;
+    }
+    r.push({
+      id: n,
+      description: i.description,
+      unit: i.throughputUnit ?? "",
+      values: a,
+      fastest: u,
+      slowest: c,
+      ratio: l,
+      unreliable: s
+    });
+  }
+  return r.sort((n, i) => (i.ratio ?? 0) - (n.ratio ?? 0));
+}
+function $t(e, t = {}) {
+  const r = Math.max(1, t.limit ?? 20), n = [], i = (o) => o.slice(0, 8), a = (o) => ({
+    shown: o.slice(0, r),
+    hidden: Math.max(0, o.length - r)
+  }), s = (o, u) => {
+    o > 0 && n.push(`  ... and ${o} more ${u}`);
+  };
+  n.push("Devices");
+  for (const o of e.devices) {
+    const u = [
+      o.mobile ? "(mobile)" : "",
+      o.staleBenchmarks ? `(schema ${o.schema} - benchmarks not comparable)` : ""
+    ].filter(Boolean).join(" ");
+    n.push(`  ${i(o.fingerprint)}  ${o.label}${u ? "  " + u : ""}`);
+  }
+  if (e.benchmarks.length > 0) {
+    n.push("", "Performance");
+    const { shown: o, hidden: u } = a(e.benchmarks);
+    for (const c of o) {
+      const l = c.ratio ? `${c.ratio.toFixed(1)}x` : "—";
+      n.push(`  ${c.id}  (${c.unit})  gap ${l}`);
+      for (const f of e.devices) {
+        const p = c.values[f.fingerprint], h = c.unreliable.includes(f.fingerprint) ? "  [unreliable]" : "";
+        n.push(`    ${i(f.fingerprint)}  ${p != null ? p.toLocaleString() : "—"}${h}`);
+      }
+    }
+    s(u, "benchmarks");
+  }
+  if (e.features.length > 0) {
+    n.push("", "Features not available everywhere");
+    const { shown: o, hidden: u } = a(e.features);
+    for (const c of o)
+      n.push(`  ${c.feature}  missing on ${c.missingFrom.map(i).join(", ")}`);
+    s(u, "features");
+  }
+  if (e.formats.length > 0) {
+    n.push("", "Format capabilities that differ");
+    const { shown: o, hidden: u } = a(e.formats);
+    for (const c of o)
+      n.push(`  ${c.format}.${c.capability}  missing on ${c.missingFrom.map(i).join(", ")}`);
+    s(u, "format capabilities");
+  }
+  if (e.limits.length > 0) {
+    n.push("", "Limits that differ");
+    const { shown: o, hidden: u } = a(e.limits);
+    for (const c of o) {
+      const l = Number.isFinite(c.ratio) ? `${c.ratio.toFixed(1)}x` : "—", f = e.devices.map((p) => `${i(p.fingerprint)}=${c.values[p.fingerprint]?.toLocaleString() ?? "—"}`).join("  ");
+      n.push(`  ${c.limit}  gap ${l}   ${f}`);
+    }
+    s(u, "limits");
+  }
+  if (e.excluded.length > 0) {
+    n.push("", "Excluded");
+    for (const o of e.excluded) n.push(`  profile #${o.index}: ${o.reason}`);
+  }
+  return n.join(`
+`);
+}
+function Pt(e) {
+  return e.split(".")[0] ?? "";
+}
+function Rt(e) {
+  return e.unavailable !== void 0;
+}
+function _t(e) {
+  return e.discrepancies.filter((t) => t.severity === "breaking");
+}
+function Gt(e) {
+  return (e.verified?.formats ?? []).filter((t) => t.renderable).map((t) => t.format);
+}
+function Ft(e) {
+  return (e.verified?.formats ?? []).filter((t) => t.sampleable).map((t) => t.format);
+}
+function Ut(e, t, r = "render") {
+  const n = e.verified?.formats ?? [];
+  for (const i of t) {
+    const a = n.find((s) => s.format === i);
+    if (a && (r === "render" && a.renderable || r === "sample" && a.sampleable || r === "storage" && a.storageWritable))
+      return i;
+  }
+  return null;
+}
+function Ct(e, t) {
+  return e.benchmarks?.results.find((r) => r.id === t) ?? null;
+}
+export {
+  ie as FORMATS,
+  Tt as MIN_COMPARABLE_BENCHMARK_SCHEMA,
+  Et as SCHEMA_VERSION,
+  Ct as benchmark,
+  _t as breakingIssues,
+  Bt as compareProfiles,
+  wt as describeDevice,
+  $e as findMeta,
+  $t as formatComparison,
+  Rt as isUnavailable,
+  Ut as pickFormat,
+  At as probe,
+  Gt as renderableFormats,
+  Ft as sampleableFormats
+};
+//# sourceMappingURL=gpu-atlas.js.map