gputex 0.0.5 → 0.1.1

package/dist/index.js

@@ -42,14 +42,39 @@ function detectCapabilities(adapter) {
 }
 
 // src/Encoder.ts
+import { CompressedTexture as CompressedTexture2, LinearFilter as LinearFilter2, LinearSRGBColorSpace as LinearSRGBColorSpace2, SRGBColorSpace as SRGBColorSpace2, RepeatWrapping as RepeatWrapping2 } from "three";
+
+// src/textureAssembly.ts
 import {
   CompressedTexture,
   LinearFilter,
   LinearMipmapLinearFilter,
   LinearSRGBColorSpace,
-  SRGBColorSpace,
-  RepeatWrapping
+  RepeatWrapping,
+  SRGBColorSpace
 } from "three";
+function assembleCompressedTexture(levels, threeFormat, effectiveSrgb) {
+  if (levels.length === 0) {
+    throw new Error("assembleCompressedTexture: no levels provided");
+  }
+  const mipmaps = levels.map((l) => ({
+    data: l.data,
+    width: l.paddedWidth,
+    height: l.paddedHeight
+  }));
+  const base = levels[0];
+  const texture = new CompressedTexture(mipmaps, base.paddedWidth, base.paddedHeight, threeFormat);
+  texture.colorSpace = effectiveSrgb ? SRGBColorSpace : LinearSRGBColorSpace;
+  texture.magFilter = LinearFilter;
+  texture.minFilter = levels.length > 1 ? LinearMipmapLinearFilter : LinearFilter;
+  texture.generateMipmaps = false;
+  texture.wrapS = texture.wrapT = RepeatWrapping;
+  texture.needsUpdate = true;
+  texture.userData.logicalWidth = base.width;
+  texture.userData.logicalHeight = base.height;
+  texture.userData.mipLevels = levels.length;
+  return texture;
+}
 
 // src/workarounds.ts
 function needsWriteTextureWorkaround(adapter) {
@@ -96,6 +121,9 @@ var Encoder = class {
     if (this.requiredFeature && adapter.features.has(this.requiredFeature)) {
       requiredFeatures.push(this.requiredFeature);
     }
+    if (adapter.features.has("shader-f16")) {
+      requiredFeatures.push("shader-f16");
+    }
     const device = await adapter.requestDevice({ requiredFeatures });
     return new this({ device, adapter, ownsDevice: true });
   }
@@ -105,7 +133,14 @@ var Encoder = class {
   // `!:` because these are set in `_buildPipeline()` which the constructor
   // calls; TypeScript's flow analysis doesn't see through method calls.
   _module;
+  // f16 'fast' module — built only when the device supports shader-f16 and the
+  // subclass provides an f16 source. null otherwise (falls back to _module).
+  _moduleF16 = null;
+  _pipelineF16 = null;
+  // Default pipeline (fast). Kept as a field for back-compat; the per-quality
+  // cache below holds the specialised pipelines for encoders that support it.
   _pipeline;
+  _pipelineCache = /* @__PURE__ */ new Map();
   constructor({ device, adapter, ownsDevice = false }) {
     this.device = device;
     this.adapter = adapter;
@@ -119,11 +154,52 @@ var Encoder = class {
       label: `${this.label}-encoder`,
       code
     });
-    this._pipeline = device.createComputePipeline({
-      label: `${this.label}-encoder-pipeline`,
+    if (this._useF16) {
+      this._moduleF16 = device.createShaderModule({
+        label: `${this.label}-encoder-f16`,
+        code: this.wgslSourceFastF16()
+      });
+    }
+    if (this.supportsQuality) {
+      this._pipeline = this._getPipeline("fast");
+    } else {
+      this._pipeline = device.createComputePipeline({
+        label: `${this.label}-encoder-pipeline`,
+        layout: "auto",
+        compute: { module: this._module, entryPoint: "encode" }
+      });
+    }
+  }
+  /**
+   * Pipeline for a given quality level. Encoders that don't declare a
+   * `QUALITY_HIGH` override (`supportsQuality === false`, e.g. BC1) ignore the
+   * argument and reuse the single pipeline. Specialised pipelines are cached.
+   */
+  _getPipeline(quality) {
+    if (!this.supportsQuality) return this._pipeline;
+    if (quality === "fast" && this._moduleF16) {
+      if (!this._pipelineF16) {
+        this._pipelineF16 = this.device.createComputePipeline({
+          label: `${this.label}-encoder-pipeline-fast-f16`,
+          layout: "auto",
+          compute: { module: this._moduleF16, entryPoint: "encode" }
+        });
+      }
+      return this._pipelineF16;
+    }
+    const cached = this._pipelineCache.get(quality);
+    if (cached) return cached;
+    const pipeline = this.device.createComputePipeline({
+      label: `${this.label}-encoder-pipeline-${quality}`,
       layout: "auto",
-      compute: { module: this._module, entryPoint: "encode" }
+      compute: {
+        module: this._module,
+        entryPoint: "encode",
+        constants: { QUALITY_HIGH: quality === "high" ? 1 : 0 }
+      }
     });
+    this._pipelineCache.set(quality, pipeline);
+    return pipeline;
   }
   destroy() {
     if (this.ownsDevice) this.device.destroy();
@@ -136,6 +212,26 @@ var Encoder = class {
   get supportsSrgb() {
     return true;
   }
+  /**
+   * Whether the shader declares a `QUALITY_HIGH` pipeline-overridable constant
+   * (i.e. has distinct fast/high search paths). BC1 is already single-pass and
+   * leaves this false; BC5/BC7/ASTC override it to true.
+   */
+  get supportsQuality() {
+    return false;
+  }
+  /**
+   * Optional f16 WGSL for the 'fast' path. Used only when the device reports the
+   * `shader-f16` feature; the format's f32 `wgslSource()` is the fallback and
+   * `'high'` always uses it. Returns null when there's no f16 variant (BC1).
+   */
+  wgslSourceFastF16() {
+    return null;
+  }
+  /** Whether the f16 fast path is both available and supported on this device. */
+  get _useF16() {
+    return this.wgslSourceFastF16() !== null && this.device.features.has("shader-f16");
+  }
   /**
    * True if the device reports the feature the output texture needs.
    * The encoder itself only writes to a storage buffer, so this is about
@@ -148,21 +244,21 @@ var Encoder = class {
   // ------------------------------------------------------------------ //
   // Shared encode() — pad, upload, dispatch, readback, wrap.           //
   // ------------------------------------------------------------------ //
-  async encode(source, { colorSpace = "srgb" } = {}) {
+  async encode(source, { colorSpace = "srgb", quality = "fast" } = {}) {
     const effectiveSrgb = colorSpace === "srgb" && this.supportsSrgb;
-    const bytes = await this.encodeToBytes(source);
+    const bytes = await this.encodeToBytes(source, { quality });
     const threeFormat = this.threeTextureFormat({ colorSpace: effectiveSrgb ? "srgb" : "linear" });
     const mip = {
       data: bytes.data,
       width: bytes.paddedWidth,
       height: bytes.paddedHeight
     };
-    const texture = new CompressedTexture([mip], bytes.paddedWidth, bytes.paddedHeight, threeFormat);
-    texture.colorSpace = effectiveSrgb ? SRGBColorSpace : LinearSRGBColorSpace;
-    texture.magFilter = LinearFilter;
-    texture.minFilter = LinearFilter;
+    const texture = new CompressedTexture2([mip], bytes.paddedWidth, bytes.paddedHeight, threeFormat);
+    texture.colorSpace = effectiveSrgb ? SRGBColorSpace2 : LinearSRGBColorSpace2;
+    texture.magFilter = LinearFilter2;
+    texture.minFilter = LinearFilter2;
     texture.generateMipmaps = false;
-    texture.wrapS = texture.wrapT = RepeatWrapping;
+    texture.wrapS = texture.wrapT = RepeatWrapping2;
     texture.needsUpdate = true;
     texture.userData.logicalWidth = bytes.width;
     texture.userData.logicalHeight = bytes.height;
@@ -186,7 +282,7 @@ var Encoder = class {
    * encoder boundary. Still safe to call from outside — it just does
    * less work than `encode()` and the caller assembles the texture.
    */
-  async encodeToBytes(source, { flipY = false } = {}) {
+  async encodeToBytes(source, { flipY = false, quality = "fast" } = {}) {
     const device = this.device;
     const width = source.width;
     const height = source.height;
@@ -219,9 +315,10 @@ var Encoder = class {
       usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
     });
     device.queue.writeBuffer(paramsBuffer, 0, new Uint32Array([blocksX, blocksY, paddedWidth, paddedHeight]));
+    const pipeline = this._getPipeline(quality);
     const bindGroup = device.createBindGroup({
       label: `${this.label}-bg`,
-      layout: this._pipeline.getBindGroupLayout(0),
+      layout: pipeline.getBindGroupLayout(0),
       entries: [
         { binding: 0, resource: srcTex.createView() },
         { binding: 1, resource: { buffer: dstBuffer } },
@@ -232,7 +329,7 @@ var Encoder = class {
     const t0 = performance.now();
     const enc = device.createCommandEncoder({ label: `${this.label}-encode` });
     const pass = enc.beginComputePass();
-    pass.setPipeline(this._pipeline);
+    pass.setPipeline(pipeline);
     pass.setBindGroup(0, bindGroup);
     pass.dispatchWorkgroups(Math.ceil(blocksX / wgX), Math.ceil(blocksY / wgY), 1);
     pass.end();
@@ -269,23 +366,7 @@ var Encoder = class {
     }
     const effectiveSrgb = colorSpace === "srgb" && this.supportsSrgb;
     const threeFormat = this.threeTextureFormat({ colorSpace: effectiveSrgb ? "srgb" : "linear" });
-    const mipmaps = levels.map((l) => ({
-      data: l.data,
-      width: l.paddedWidth,
-      height: l.paddedHeight
-    }));
-    const base = levels[0];
-    const texture = new CompressedTexture(mipmaps, base.paddedWidth, base.paddedHeight, threeFormat);
-    texture.colorSpace = effectiveSrgb ? SRGBColorSpace : LinearSRGBColorSpace;
-    texture.magFilter = LinearFilter;
-    texture.minFilter = levels.length > 1 ? LinearMipmapLinearFilter : LinearFilter;
-    texture.generateMipmaps = false;
-    texture.wrapS = texture.wrapT = RepeatWrapping;
-    texture.needsUpdate = true;
-    texture.userData.logicalWidth = base.width;
-    texture.userData.logicalHeight = base.height;
-    texture.userData.mipLevels = levels.length;
-    return texture;
+    return assembleCompressedTexture(levels, threeFormat, effectiveSrgb);
   }
 };
 
@@ -323,7 +404,10 @@ var BC1Encoder = class extends Encoder {
 import { RED_GREEN_RGTC2_Format } from "three";
 
 // src/bc5.wgsl
-var bc5_default = "// BC5 (RGTC2) compute shader encoder.\n//\n// Each invocation encodes one 4x4 pixel block into a 16-byte BC5 block\n// written as 4 x u32 into the destination storage buffer.\n//\n// BC5 = two BC4 blocks concatenated:\n//   block bytes  0..7  : BC4 of R channel (normal.x for tangent-space normals)\n//   block bytes  8..15 : BC4 of G channel (normal.y)\n//\n// Each BC4 half-block (8 bytes):\n//   byte 0     : red0 (8-bit endpoint)\n//   byte 1     : red1 (8-bit endpoint)\n//   bytes 2..7 : 16 \xD7 3-bit indices, LSB-first, pixel 0 at bit 0\n//\n// We always produce the 6-interpolation mode (red0 > red1). See\n// `bc4_ref.js` for the reasoning and the CPU reference this shader is\n// ported from \u2014 the algorithm and edge cases mirror it line-for-line.\n//\n// Pipeline per channel:\n//   1. Load 16 single-channel values, find min/max \u2192 initial endpoints.\n//   2. Quantize to 8-bit. Nudge apart if equal (forces 6-interp mode).\n//   3. Build palette, assign each texel its nearest entry (full L2).\n//   4. One-pass least-squares refinement: solve the 2\xD72 normal equations\n//      for the (r0, r1) that minimizes \u03A3(palette[i_k] \u2212 v_k)\xB2. Accept\n//      only if quantized endpoints still satisfy r0 > r1 AND total\n//      squared error decreased.\n//   5. Pack 2 endpoint bytes + 48 bits of indices into the 8-byte block.\n\nstruct Params {\n  blocks_x: u32,\n  blocks_y: u32,\n  width:    u32,\n  height:   u32,\n};\n\n@group(0) @binding(0) var src_tex: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n@group(0) @binding(2) var<uniform> params: Params;\n\n// 6-interpolation-mode palette weights. palette[j] = W0_6[j]*r0 + W1_6[j]*r1.\n// Expressed as a switch so we don't rely on module-scope const arrays.\nfn w0_6(j: u32) -> f32 {\n  switch j {\n    case 0u:  { return 1.0; }\n    case 1u:  { return 0.0; }\n    case 2u:  { return 6.0 / 7.0; }\n    case 3u:  { return 5.0 / 7.0; }\n    case 4u:  { return 4.0 / 7.0; }\n    case 5u:  { return 3.0 / 7.0; }\n    case 6u:  { return 2.0 / 7.0; }\n    default:  { return 1.0 / 7.0; }   // case 7u\n  }\n}\n\nfn w1_6(j: u32) -> f32 {\n  switch j {\n    case 0u:  { return 0.0; }\n    case 1u:  { return 1.0; }\n    case 2u:  { return 1.0 / 7.0; }\n    case 3u:  { return 2.0 / 7.0; }\n    case 4u:  { return 3.0 / 7.0; }\n    case 5u:  { return 4.0 / 7.0; }\n    case 6u:  { return 5.0 / 7.0; }\n    default:  { return 6.0 / 7.0; }   // case 7u\n  }\n}\n\nfn quantize8(v: f32) -> u32 {\n  // Round-to-nearest, clamp to [0, 255]. floor(x + 0.5) is the same\n  // rounding rule the CPU reference uses.\n  return u32(clamp(floor(v * 255.0 + 0.5), 0.0, 255.0));\n}\n\n// Nearest-palette-index search over the 8-entry palette, returning the\n// index and squared error. `palette` is stored in function memory so we\n// pass by pointer.\nfn nearest_index(v: f32, palette: ptr<function, array<f32, 8>>) -> vec2<f32> {\n  // x = best index (encoded as f32), y = best squared error.\n  var best_j: u32 = 0u;\n  var best_d: f32 = 1e20;\n  for (var j: u32 = 0u; j < 8u; j = j + 1u) {\n    let d  = (*palette)[j] - v;\n    let d2 = d * d;\n    if (d2 < best_d) {\n      best_d = d2;\n      best_j = j;\n    }\n  }\n  return vec2<f32>(f32(best_j), best_d);\n}\n\n// Encode 16 single-channel values into an 8-byte BC4 block, packed as\n// two little-endian u32s (u32[0] = bytes 0..3, u32[1] = bytes 4..7).\nfn encode_bc4(values: ptr<function, array<f32, 16>>) -> vec2<u32> {\n  // ---------------- 1. Initial endpoints: bbox of input ----------------\n  var vmin: f32 = 1.0;\n  var vmax: f32 = 0.0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    vmin = min(vmin, (*values)[k]);\n    vmax = max(vmax, (*values)[k]);\n  }\n  var r0: u32 = quantize8(vmax);\n  var r1: u32 = quantize8(vmin);\n  // Force 6-interp mode: red0 > red1 strictly.\n  if (r0 == r1) {\n    if (r1 > 0u) { r1 = r1 - 1u; }\n    else         { r0 = r0 + 1u; }\n  }\n\n  // ---------------- 2. Initial palette + indices + error --------------\n  var palette: array<f32, 8>;\n  let r0f = f32(r0) / 255.0;\n  let r1f = f32(r1) / 255.0;\n  for (var j: u32 = 0u; j < 8u; j = j + 1u) {\n    palette[j] = w0_6(j) * r0f + w1_6(j) * r1f;\n  }\n  var indices: array<u32, 16>;\n  var err: f32 = 0.0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let sel = nearest_index((*values)[k], &palette);\n    indices[k] = u32(sel.x);\n    err = err + sel.y;\n  }\n\n  var best_r0 = r0;\n  var best_r1 = r1;\n  var best_indices = indices;\n  var best_err = err;\n\n  // ---------------- 3. Refinement: least-squares on (r0, r1) ----------\n  // Normal equations for palette[j] = a_j * r0 + b_j * r1:\n  //   [\u03A3AA  \u03A3AB] [r0]   [\u03A3AV]\n  //   [\u03A3AB  \u03A3BB] [r1] = [\u03A3BV]\n  var sAA: f32 = 0.0; var sBB: f32 = 0.0; var sAB: f32 = 0.0;\n  var sAV: f32 = 0.0; var sBV: f32 = 0.0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let a = w0_6(indices[k]);\n    let b = w1_6(indices[k]);\n    let v = (*values)[k];\n    sAA = sAA + a * a;\n    sBB = sBB + b * b;\n    sAB = sAB + a * b;\n    sAV = sAV + a * v;\n    sBV = sBV + b * v;\n  }\n  let det = sAA * sBB - sAB * sAB;\n  // Degenerate system \u2192 skip refinement.\n  if (abs(det) > 1e-9) {\n    let new_r0 = clamp((sBB * sAV - sAB * sBV) / det, 0.0, 1.0);\n    let new_r1 = clamp((sAA * sBV - sAB * sAV) / det, 0.0, 1.0);\n    let qR0 = quantize8(new_r0);\n    let qR1 = quantize8(new_r1);\n    // Only accept refinements that stay in 6-interp mode. A refinement\n    // that flips or equalizes the endpoints would change decode mode.\n    if (qR0 > qR1) {\n      var pal2: array<f32, 8>;\n      let r0f2 = f32(qR0) / 255.0;\n      let r1f2 = f32(qR1) / 255.0;\n      for (var j: u32 = 0u; j < 8u; j = j + 1u) {\n        pal2[j] = w0_6(j) * r0f2 + w1_6(j) * r1f2;\n      }\n      var idx2: array<u32, 16>;\n      var err2: f32 = 0.0;\n      for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n        let sel = nearest_index((*values)[k], &pal2);\n        idx2[k] = u32(sel.x);\n        err2 = err2 + sel.y;\n      }\n      if (err2 < best_err) {\n        best_r0 = qR0;\n        best_r1 = qR1;\n        best_indices = idx2;\n        best_err = err2;\n      }\n    }\n  }\n\n  // ---------------- 4. Pack 48-bit index field + 2 endpoint bytes -----\n  // The 48-bit index field spans block bytes 2..7. Split into idx_lo\n  // (low 32 bits of the field) and idx_hi (high 16 bits). An index at\n  // bit position 3k straddles the 32-bit boundary iff 3k < 32 < 3k+3\n  // (only k = 10, 11 straddle: bits 30..32 and 33..35; actually k=10\n  // is bits 30..32, k=11 is 33..35 \u2014 so k=10 straddles). We handle\n  // straddles by writing to both halves.\n  var idx_lo: u32 = 0u;\n  var idx_hi: u32 = 0u;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let bit = 3u * k;\n    let v = best_indices[k] & 7u;\n    if (bit + 3u <= 32u) {\n      idx_lo = idx_lo | (v << bit);\n    } else if (bit >= 32u) {\n      idx_hi = idx_hi | (v << (bit - 32u));\n    } else {\n      // Straddle: low part into idx_lo's top, high part into idx_hi's bottom.\n      idx_lo = idx_lo | (v << bit);\n      idx_hi = idx_hi | (v >> (32u - bit));\n    }\n  }\n\n  // Final u32s, both little-endian:\n  //   u32[0] bytes = red0, red1, idx_lo[7:0], idx_lo[15:8]\n  //   u32[1] bytes = idx_lo[23:16], idx_lo[31:24], idx_hi[7:0], idx_hi[15:8]\n  let out_lo = best_r0 | (best_r1 << 8u) | ((idx_lo & 0xFFFFu) << 16u);\n  let out_hi = (idx_lo >> 16u) | (idx_hi << 16u);\n\n  return vec2<u32>(out_lo, out_hi);\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn encode(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if (gid.x >= params.blocks_x || gid.y >= params.blocks_y) {\n    return;\n  }\n\n  let bx = gid.x;\n  let by = gid.y;\n  let block_index = by * params.blocks_x + bx;\n\n  let base   = vec2<i32>(i32(bx) * 4, i32(by) * 4);\n  let max_xy = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  // Load 4\xD74 RG values, splitting into per-channel arrays so each can\n  // be handed to encode_bc4 independently.\n  var r_values: array<f32, 16>;\n  var g_values: array<f32, 16>;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let lx = i32(i & 3u);\n    let ly = i32(i >> 2u);\n    // Clamp to edge for non-multiple-of-4 input sizes.\n    let p  = clamp(base + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let c  = textureLoad(src_tex, p, 0);\n    r_values[i] = c.r;\n    g_values[i] = c.g;\n  }\n\n  let r_block = encode_bc4(&r_values);\n  let g_block = encode_bc4(&g_values);\n\n  // BC5 block = R half (bytes 0..7) || G half (bytes 8..15) = 4 u32s.\n  let out = block_index * 4u;\n  dst[out + 0u] = r_block.x;\n  dst[out + 1u] = r_block.y;\n  dst[out + 2u] = g_block.x;\n  dst[out + 3u] = g_block.y;\n}\n";
+var bc5_default = "// BC5 (RGTC2) compute shader encoder.\n//\n// Each invocation encodes one 4x4 pixel block into a 16-byte BC5 block\n// written as 4 x u32 into the destination storage buffer.\n//\n// BC5 = two BC4 blocks concatenated:\n//   block bytes  0..7  : BC4 of R channel (normal.x for tangent-space normals)\n//   block bytes  8..15 : BC4 of G channel (normal.y)\n//\n// Each BC4 half-block (8 bytes):\n//   byte 0     : red0 (8-bit endpoint)\n//   byte 1     : red1 (8-bit endpoint)\n//   bytes 2..7 : 16 \xD7 3-bit indices, LSB-first, pixel 0 at bit 0\n//\n// We always produce the 6-interpolation mode (red0 > red1). See\n// `bc4_ref.js` for the reasoning and the CPU reference this shader is\n// ported from \u2014 the algorithm and edge cases mirror it line-for-line.\n//\n// Pipeline per channel:\n//   1. Load 16 single-channel values, find min/max \u2192 initial endpoints.\n//   2. Quantize to 8-bit. Nudge apart if equal (forces 6-interp mode).\n//   3. Build palette, assign each texel its nearest entry (full L2).\n//   4. One-pass least-squares refinement: solve the 2\xD72 normal equations\n//      for the (r0, r1) that minimizes \u03A3(palette[i_k] \u2212 v_k)\xB2. Accept\n//      only if quantized endpoints still satisfy r0 > r1 AND total\n//      squared error decreased.\n//   5. Pack 2 endpoint bytes + 48 bits of indices into the 8-byte block.\n//\n// The candidate endpoints/indices/error are tracked in place \u2014 the refit\n// overwrites them only when accepted \u2014 so no 16-entry index array is ever\n// copied across a function return.\n//\n// QUALITY LEVELS (pipeline-overridable constant `QUALITY_HIGH`)\n//   fast (0, default): bbox endpoints + a single nearest-search assignment per\n//     channel. The LSQ refit pass below is the bulk of the kernel and buys\n//     only ~0.36 dB, so it is skipped \u2014 ~3.8\xD7 faster.\n//   high (1): runs the refit, byte-for-byte identical to bc4_ref/bc5_ref.\n\n// 0 = fast (default), 1 = exhaustive/high-quality. Set via pipeline constants.\noverride QUALITY_HIGH: u32 = 0u;\n\nstruct Params {\n  blocks_x: u32,\n  blocks_y: u32,\n  width:    u32,\n  height:   u32,\n};\n\n@group(0) @binding(0) var src_tex: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n@group(0) @binding(2) var<uniform> params: Params;\n\n// 6-interpolation-mode palette weights. palette[j] = W0_6[j]*r0 + W1_6[j]*r1.\n// Expressed as a switch so we don't rely on module-scope const arrays.\nfn w0_6(j: u32) -> f32 {\n  switch j {\n    case 0u:  { return 1.0; }\n    case 1u:  { return 0.0; }\n    case 2u:  { return 6.0 / 7.0; }\n    case 3u:  { return 5.0 / 7.0; }\n    case 4u:  { return 4.0 / 7.0; }\n    case 5u:  { return 3.0 / 7.0; }\n    case 6u:  { return 2.0 / 7.0; }\n    default:  { return 1.0 / 7.0; }   // case 7u\n  }\n}\n\nfn w1_6(j: u32) -> f32 {\n  switch j {\n    case 0u:  { return 0.0; }\n    case 1u:  { return 1.0; }\n    case 2u:  { return 1.0 / 7.0; }\n    case 3u:  { return 2.0 / 7.0; }\n    case 4u:  { return 3.0 / 7.0; }\n    case 5u:  { return 4.0 / 7.0; }\n    case 6u:  { return 5.0 / 7.0; }\n    default:  { return 6.0 / 7.0; }   // case 7u\n  }\n}\n\nfn quantize8(v: f32) -> u32 {\n  // Round-to-nearest, clamp to [0, 255]. floor(x + 0.5) is the same\n  // rounding rule the CPU reference uses.\n  return u32(clamp(floor(v * 255.0 + 0.5), 0.0, 255.0));\n}\n\n// Build the 8-entry palette for endpoints (r0f, r1f) in normalised space.\nfn build_pal(r0f: f32, r1f: f32, pal: ptr<function, array<f32, 8>>) {\n  for (var j: u32 = 0u; j < 8u; j = j + 1u) {\n    (*pal)[j] = w0_6(j) * r0f + w1_6(j) * r1f;\n  }\n}\n\n// Assign each of the 16 values its nearest palette entry (full 8-entry L2),\n// writing indices into `out_idx` and returning the total squared error.\nfn assign_all(\n  values:  ptr<function, array<f32, 16>>,\n  pal:     ptr<function, array<f32, 8>>,\n  out_idx: ptr<function, array<u32, 16>>,\n) -> f32 {\n  var err: f32 = 0.0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let v = (*values)[k];\n    var best_j: u32 = 0u;\n    var best_d: f32 = 1e20;\n    for (var j: u32 = 0u; j < 8u; j = j + 1u) {\n      let d  = (*pal)[j] - v;\n      let d2 = d * d;\n      if (d2 < best_d) {\n        best_d = d2;\n        best_j = j;\n      }\n    }\n    (*out_idx)[k] = best_j;\n    err = err + best_d;\n  }\n  return err;\n}\n\n// Encode 16 single-channel values into an 8-byte BC4 block, packed as\n// two little-endian u32s (u32[0] = bytes 0..3, u32[1] = bytes 4..7).\nfn encode_bc4(values: ptr<function, array<f32, 16>>) -> vec2<u32> {\n  // ---------------- 1. Initial endpoints: bbox of input ----------------\n  var vmin: f32 = 1.0;\n  var vmax: f32 = 0.0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    vmin = min(vmin, (*values)[k]);\n    vmax = max(vmax, (*values)[k]);\n  }\n  var r0: u32 = quantize8(vmax);\n  var r1: u32 = quantize8(vmin);\n  // Force 6-interp mode: red0 > red1 strictly.\n  if (r0 == r1) {\n    if (r1 > 0u) { r1 = r1 - 1u; }\n    else         { r0 = r0 + 1u; }\n  }\n\n  // ---------------- 2. Initial palette + indices + error --------------\n  var pal: array<f32, 8>;\n  build_pal(f32(r0) / 255.0, f32(r1) / 255.0, &pal);\n  var indices: array<u32, 16>;\n  var err = assign_all(values, &pal, &indices);\n\n  // ---------------- 3. Refinement: least-squares on (r0, r1) ----------\n  // High-quality only \u2014 the refit is the bulk of the per-channel cost and the\n  // branch is resolved at pipeline-compile time, so the fast path skips all of\n  // it (the sums loop included), not just the acceptance test.\n  if (QUALITY_HIGH != 0u) {\n    // Normal equations for palette[j] = a_j * r0 + b_j * r1:\n    //   [\u03A3AA  \u03A3AB] [r0]   [\u03A3AV]\n    //   [\u03A3AB  \u03A3BB] [r1] = [\u03A3BV]\n    var sAA: f32 = 0.0; var sBB: f32 = 0.0; var sAB: f32 = 0.0;\n    var sAV: f32 = 0.0; var sBV: f32 = 0.0;\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n      let a = w0_6(indices[k]);\n      let b = w1_6(indices[k]);\n      let v = (*values)[k];\n      sAA = sAA + a * a;\n      sBB = sBB + b * b;\n      sAB = sAB + a * b;\n      sAV = sAV + a * v;\n      sBV = sBV + b * v;\n    }\n    let det = sAA * sBB - sAB * sAB;\n    // Degenerate system \u2192 skip refinement.\n    if (abs(det) > 1e-9) {\n      let new_r0 = clamp((sBB * sAV - sAB * sBV) / det, 0.0, 1.0);\n      let new_r1 = clamp((sAA * sBV - sAB * sAV) / det, 0.0, 1.0);\n      let qR0 = quantize8(new_r0);\n      let qR1 = quantize8(new_r1);\n      // Only accept refinements that stay in 6-interp mode. A refinement\n      // that flips or equalizes the endpoints would change decode mode.\n      if (qR0 > qR1) {\n        build_pal(f32(qR0) / 255.0, f32(qR1) / 255.0, &pal);\n        var idx2: array<u32, 16>;\n        let err2 = assign_all(values, &pal, &idx2);\n        if (err2 < err) {\n          r0 = qR0;\n          r1 = qR1;\n          indices = idx2;\n          err = err2;\n        }\n      }\n    }\n  }\n\n  // ---------------- 4. Pack 48-bit index field + 2 endpoint bytes -----\n  // The 48-bit index field spans block bytes 2..7. Split into idx_lo\n  // (low 32 bits of the field) and idx_hi (high 16 bits). An index at\n  // bit position 3k straddles the 32-bit boundary iff 3k < 32 < 3k+3\n  // (only k = 10, 11 straddle: bits 30..32 and 33..35; actually k=10\n  // is bits 30..32, k=11 is 33..35 \u2014 so k=10 straddles). We handle\n  // straddles by writing to both halves.\n  var idx_lo: u32 = 0u;\n  var idx_hi: u32 = 0u;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let bit = 3u * k;\n    let v = indices[k] & 7u;\n    if (bit + 3u <= 32u) {\n      idx_lo = idx_lo | (v << bit);\n    } else if (bit >= 32u) {\n      idx_hi = idx_hi | (v << (bit - 32u));\n    } else {\n      // Straddle: low part into idx_lo's top, high part into idx_hi's bottom.\n      idx_lo = idx_lo | (v << bit);\n      idx_hi = idx_hi | (v >> (32u - bit));\n    }\n  }\n\n  // Final u32s, both little-endian:\n  //   u32[0] bytes = red0, red1, idx_lo[7:0], idx_lo[15:8]\n  //   u32[1] bytes = idx_lo[23:16], idx_lo[31:24], idx_hi[7:0], idx_hi[15:8]\n  let out_lo = r0 | (r1 << 8u) | ((idx_lo & 0xFFFFu) << 16u);\n  let out_hi = (idx_lo >> 16u) | (idx_hi << 16u);\n\n  return vec2<u32>(out_lo, out_hi);\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn encode(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if (gid.x >= params.blocks_x || gid.y >= params.blocks_y) {\n    return;\n  }\n\n  let bx = gid.x;\n  let by = gid.y;\n  let block_index = by * params.blocks_x + bx;\n\n  let base   = vec2<i32>(i32(bx) * 4, i32(by) * 4);\n  let max_xy = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  // Load 4\xD74 RG values, splitting into per-channel arrays so each can\n  // be handed to encode_bc4 independently.\n  var r_values: array<f32, 16>;\n  var g_values: array<f32, 16>;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let lx = i32(i & 3u);\n    let ly = i32(i >> 2u);\n    // Clamp to edge for non-multiple-of-4 input sizes.\n    let p  = clamp(base + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let c  = textureLoad(src_tex, p, 0);\n    r_values[i] = c.r;\n    g_values[i] = c.g;\n  }\n\n  let r_block = encode_bc4(&r_values);\n  let g_block = encode_bc4(&g_values);\n\n  // BC5 block = R half (bytes 0..7) || G half (bytes 8..15) = 4 u32s.\n  let out = block_index * 4u;\n  dst[out + 0u] = r_block.x;\n  dst[out + 1u] = r_block.y;\n  dst[out + 2u] = g_block.x;\n  dst[out + 3u] = g_block.y;\n}\n";
+
+// src/bc5_fast_f16.wgsl
+var bc5_fast_f16_default = '// bc5 "fast" encoder \u2014 f16 variant (requires the shader-f16 feature).\n// Identical algorithm to the f32 fast path in bc5.wgsl, but the projection +\n// least-squares refit run in f16 ([0,1] domain). On GPUs with 2x f16 throughput\n// (e.g. Apple) this is ~2x faster at the same quality; endpoints are still\n// quantised to exact 8-bit. The host selects this module only when the device\n// reports shader-f16, falling back to bc5.wgsl otherwise. "high" never uses this.\n//\n// BC5 fast path in f16 (two BC4 halves, no refit). f16 halves the per-channel ALU.\nenable f16;\nalias h = f16;\nstruct Params { blocks_x: u32, blocks_y: u32, width: u32, height: u32, };\n@group(0) @binding(0) var src_tex: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n@group(0) @binding(2) var<uniform> params: Params;\nfn w0(j: u32) -> h { switch j { case 0u:{return h(1.0);} case 1u:{return h(0.0);} case 2u:{return h(6.0/7.0);} case 3u:{return h(5.0/7.0);} case 4u:{return h(4.0/7.0);} case 5u:{return h(3.0/7.0);} case 6u:{return h(2.0/7.0);} default:{return h(1.0/7.0);} } }\nfn w1(j: u32) -> h { switch j { case 0u:{return h(0.0);} case 1u:{return h(1.0);} case 2u:{return h(1.0/7.0);} case 3u:{return h(2.0/7.0);} case 4u:{return h(3.0/7.0);} case 5u:{return h(4.0/7.0);} case 6u:{return h(5.0/7.0);} default:{return h(6.0/7.0);} } }\nfn q8(v: h) -> u32 { return u32(clamp(floor(v*h(255.0)+h(0.5)), h(0.0), h(255.0))); }\nfn encode_bc4(values: ptr<function, array<h,16>>) -> vec2<u32> {\n  var vmin=h(1.0); var vmax=h(0.0);\n  for(var k:u32=0u;k<16u;k=k+1u){ vmin=min(vmin,(*values)[k]); vmax=max(vmax,(*values)[k]); }\n  var r0=q8(vmax); var r1=q8(vmin);\n  if(r0==r1){ if(r1>0u){r1=r1-1u;}else{r0=r0+1u;} }\n  var pal: array<h,8>; let r0f=h(f32(r0)/255.0); let r1f=h(f32(r1)/255.0);\n  for(var j:u32=0u;j<8u;j=j+1u){ pal[j]=w0(j)*r0f+w1(j)*r1f; }\n  var indices: array<u32,16>;\n  for(var k:u32=0u;k<16u;k=k+1u){ let v=(*values)[k]; var bj=0u; var bd=h(1e4); for(var j:u32=0u;j<8u;j=j+1u){ let d=pal[j]-v; let d2=d*d; if(d2<bd){bd=d2;bj=j;} } indices[k]=bj; }\n  var lo=0u; var hi=0u;\n  for(var k:u32=0u;k<16u;k=k+1u){ let bit=3u*k; let v=indices[k]&7u;\n    if(bit+3u<=32u){ lo=lo|(v<<bit); } else if(bit>=32u){ hi=hi|(v<<(bit-32u)); } else { lo=lo|(v<<bit); hi=hi|(v>>(32u-bit)); } }\n  return vec2<u32>(r0 | (r1<<8u) | ((lo&0xFFFFu)<<16u), (lo>>16u) | (hi<<16u));\n}\n@compute @workgroup_size(8,8,1)\nfn encode(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if(gid.x>=params.blocks_x||gid.y>=params.blocks_y){return;}\n  let bi=gid.y*params.blocks_x+gid.x;\n  let base=vec2<i32>(i32(gid.x)*4,i32(gid.y)*4); let mx=vec2<i32>(i32(params.width)-1,i32(params.height)-1);\n  var rv: array<h,16>; var gv: array<h,16>;\n  for(var i:u32=0u;i<16u;i=i+1u){ let p=clamp(base+vec2<i32>(i32(i&3u),i32(i>>2u)),vec2<i32>(0),mx); let c=textureLoad(src_tex,p,0); rv[i]=h(c.r); gv[i]=h(c.g); }\n  let rb=encode_bc4(&rv); let gb=encode_bc4(&gv);\n  let o=bi*4u; dst[o]=rb.x; dst[o+1u]=rb.y; dst[o+2u]=gb.x; dst[o+3u]=gb.y;\n}\n';
 
 // src/BC5Encoder.ts
 var BC5Encoder = class extends Encoder {
@@ -338,9 +422,15 @@ var BC5Encoder = class extends Encoder {
   get supportsSrgb() {
     return false;
   }
+  get supportsQuality() {
+    return true;
+  }
   wgslSource() {
     return bc5_default;
   }
+  wgslSourceFastF16() {
+    return bc5_fast_f16_default;
+  }
   gpuTextureFormat() {
     return "bc5-rg-unorm";
   }
@@ -353,7 +443,87 @@ var BC5Encoder = class extends Encoder {
 import { RGBA_BPTC_Format } from "three";
 
 // src/bc7.wgsl
-var bc7_default = "// BC7 (BPTC) mode 6 compute shader encoder.\n//\n// One invocation per 4\xD74 block. Emits 16 bytes = 4 u32s into the storage\n// buffer at `dst[block_index * 4 .. + 3]`.\n//\n// This shader mirrors `bc7_ref.ts` function-by-function; see that file for\n// the end-to-end algorithm rationale and the full mode 6 bitstream layout\n// (summarised below).\n//\n// MODE 6 LAYOUT (LSB-first, bit 0 = byte 0's bit 0)\n//   bits 0..6    mode field      (0b0000001 \u2014 only bit 6 is 1)\n//   bits 7..13   R0 (7-bit)\n//   bits 14..20  R1\n//   bits 21..27  G0\n//   bits 28..34  G1          \u2190 straddles the word 0 / word 1 boundary\n//   bits 35..41  B0\n//   bits 42..48  B1\n//   bits 49..55  A0\n//   bits 56..62  A1\n//   bit  63      P0 (shared p-bit for endpoint 0)\n//   bit  64      P1\n//   bits 65..67  pixel 0 index (3 bits; anchor, MSB implicit 0)\n//   bits 68..71  pixel 1 index (4 bits)\n//   ...\n//   bits 124..127 pixel 15 index\n//\n// Effective 8-bit endpoint channel = (7_bit_value << 1) | p_bit.\n// Palette[i] = ((64 \u2212 W4[i]) \xD7 e0_8 + W4[i] \xD7 e1_8 + 32) >> 6, integer.\n\nstruct Params {\n  blocks_x: u32,\n  blocks_y: u32,\n  width:    u32,\n  height:   u32,\n};\n\n@group(0) @binding(0) var src_tex: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n@group(0) @binding(2) var<uniform> params: Params;\n\n// Mode 6 interpolation weights (\xD7 1/64), fixed by the spec. Same table as\n// the CPU reference (`W4` in bc7_ref.ts).\nfn w4(i: u32) -> u32 {\n  switch i {\n    case 0u:  { return  0u; }\n    case 1u:  { return  4u; }\n    case 2u:  { return  9u; }\n    case 3u:  { return 13u; }\n    case 4u:  { return 17u; }\n    case 5u:  { return 21u; }\n    case 6u:  { return 26u; }\n    case 7u:  { return 30u; }\n    case 8u:  { return 34u; }\n    case 9u:  { return 38u; }\n    case 10u: { return 43u; }\n    case 11u: { return 47u; }\n    case 12u: { return 51u; }\n    case 13u: { return 55u; }\n    case 14u: { return 60u; }\n    default:  { return 64u; }   // case 15u\n  }\n}\n\n// Hardware-exact integer interpolation.\nfn interp8(e0: u32, e1: u32, w: u32) -> u32 {\n  return ((64u - w) * e0 + w * e1 + 32u) >> 6u;\n}\n\n// f32-normalised [0,1] \u2192 clamped 8-bit.\nfn to8(v: f32) -> u32 {\n  return u32(clamp(floor(v * 255.0 + 0.5), 0.0, 255.0));\n}\n\n// -------------------------- Farthest-pair seed -------------------------- //\n\nstruct PairResult { i0: u32, i1: u32 };\n\n// 4-channel L2 distance squared, u32 domain (bounded by 4 \xD7 255\xB2 = 260 100).\nfn pixel_dist_sq(a: vec4<u32>, b: vec4<u32>) -> u32 {\n  let d = vec4<i32>(a) - vec4<i32>(b);\n  let d2 = d * d;\n  return u32(d2.x + d2.y + d2.z + d2.w);\n}\n\n// O(N\xB2) = 120 comparisons. See bc7_ref.ts `farthestPair` for why bbox\n// corners aren't safe initial endpoints when channels vary in different\n// directions along the data line.\nfn farthest_pair(pixels: ptr<function, array<vec4<u32>, 16>>) -> PairResult {\n  var best_d: u32 = 0u;\n  var best_i: u32 = 0u;\n  var best_j: u32 = 1u;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    for (var j: u32 = i + 1u; j < 16u; j = j + 1u) {\n      let d = pixel_dist_sq((*pixels)[i], (*pixels)[j]);\n      if (d > best_d) { best_d = d; best_i = i; best_j = j; }\n    }\n  }\n  return PairResult(best_i, best_j);\n}\n\n// -------------------------- Palette + assignment ------------------------ //\n\n// Build the 16-entry RGBA palette from 8-bit endpoints.\nfn build_palette_6(e0: vec4<u32>, e1: vec4<u32>, pal: ptr<function, array<vec4<u32>, 16>>) {\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let w = w4(i);\n    (*pal)[i] = vec4<u32>(\n      interp8(e0.x, e1.x, w),\n      interp8(e0.y, e1.y, w),\n      interp8(e0.z, e1.z, w),\n      interp8(e0.w, e1.w, w),\n    );\n  }\n}\n\n// Nearest-palette-entry search for one pixel. Full 16-entry L2 search.\nfn nearest_index_6(pixel: vec4<u32>, pal: ptr<function, array<vec4<u32>, 16>>) -> vec2<u32> {\n  var best_i: u32 = 0u;\n  var best_d: u32 = 0xFFFFFFFFu;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let d = pixel_dist_sq(pixel, (*pal)[i]);\n    if (d < best_d) { best_d = d; best_i = i; }\n  }\n  // x = best index, y = its squared error.\n  return vec2<u32>(best_i, best_d);\n}\n\n// Assign all 16 pixels to nearest palette entries, accumulate total error.\nstruct AssignResult { indices: array<u32, 16>, err: u32 };\n\nfn assign_all(\n  pixels: ptr<function, array<vec4<u32>, 16>>,\n  pal:    ptr<function, array<vec4<u32>, 16>>,\n) -> AssignResult {\n  var out: AssignResult;\n  out.err = 0u;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let sel = nearest_index_6((*pixels)[k], pal);\n    out.indices[k] = sel.x;\n    out.err = out.err + sel.y;\n  }\n  return out;\n}\n\n// -------------------------- Endpoint quantisation ----------------------- //\n\n// Quantize one 8-bit ideal channel to (7-bit value, reconstructed 8-bit)\n// under a fixed p-bit. Matches the CPU reference.\nfn quantize_ch(ideal8: u32, p: u32) -> vec2<u32> {\n  // q7 = round((ideal8 \u2212 p) / 2), clamp to [0, 127].\n  let q = u32(clamp(\n    floor((f32(ideal8) - f32(p)) / 2.0 + 0.5),\n    0.0, 127.0,\n  ));\n  let eff = (q << 1u) | p;\n  return vec2<u32>(q, eff);\n}\n\nstruct QuantPair { seven: vec4<u32>, eight: vec4<u32> };\n\nfn quantize_endpoint(ideal8: vec4<u32>, p: u32) -> QuantPair {\n  let r = quantize_ch(ideal8.x, p);\n  let g = quantize_ch(ideal8.y, p);\n  let b = quantize_ch(ideal8.z, p);\n  let a = quantize_ch(ideal8.w, p);\n  return QuantPair(\n    vec4<u32>(r.x, g.x, b.x, a.x),\n    vec4<u32>(r.y, g.y, b.y, a.y),\n  );\n}\n\n// Try all four p-bit combos (p0, p1) \u2208 {0,1}\xB2 and return the best\n// quantised-endpoint-plus-indices triple.\nstruct BestMode6 {\n  e0_7: vec4<u32>, e1_7: vec4<u32>,\n  p0: u32,         p1: u32,\n  indices: array<u32, 16>,\n  err: u32,\n};\n\nfn try_pbit_combos(\n  pixels: ptr<function, array<vec4<u32>, 16>>,\n  ideal0: vec4<u32>,\n  ideal1: vec4<u32>,\n) -> BestMode6 {\n  var best: BestMode6;\n  best.err = 0xFFFFFFFFu;\n  for (var p0: u32 = 0u; p0 < 2u; p0 = p0 + 1u) {\n    let q0 = quantize_endpoint(ideal0, p0);\n    for (var p1: u32 = 0u; p1 < 2u; p1 = p1 + 1u) {\n      let q1 = quantize_endpoint(ideal1, p1);\n      var pal: array<vec4<u32>, 16>;\n      build_palette_6(q0.eight, q1.eight, &pal);\n      let assigned = assign_all(pixels, &pal);\n      if (assigned.err < best.err) {\n        best.e0_7 = q0.seven;\n        best.e1_7 = q1.seven;\n        best.p0   = p0;\n        best.p1   = p1;\n        best.indices = assigned.indices;\n        best.err  = assigned.err;\n      }\n    }\n  }\n  return best;\n}\n\n// ---------------------- Least-squares endpoint refit -------------------- //\n\n// Channel-independent LSQ fit of (e0, e1) given current indices. Normal\n// equations: see bc7_ref.ts `refitEndpointsMode6`. Returns 8-bit ideal\n// endpoints (before p-bit quantisation). `valid` = false for a degenerate\n// system (all texels on one palette entry).\nstruct RefitResult { e0: vec4<u32>, e1: vec4<u32>, valid: bool };\n\nfn refit_endpoints(\n  pixels: ptr<function, array<vec4<u32>, 16>>,\n  indices: ptr<function, array<u32, 16>>,\n) -> RefitResult {\n  var sAA: f32 = 0.0;\n  var sBB: f32 = 0.0;\n  var sAB: f32 = 0.0;\n  var sAV: vec4<f32> = vec4<f32>(0.0);\n  var sBV: vec4<f32> = vec4<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let i = (*indices)[k];\n    let a = f32(64u - w4(i)) / 64.0;\n    let b = f32(w4(i)) / 64.0;\n    let v = vec4<f32>((*pixels)[k]);\n    sAA = sAA + a * a;\n    sBB = sBB + b * b;\n    sAB = sAB + a * b;\n    sAV = sAV + a * v;\n    sBV = sBV + b * v;\n  }\n  let det = sAA * sBB - sAB * sAB;\n  var out: RefitResult;\n  if (abs(det) < 1e-9) {\n    out.valid = false;\n    return out;\n  }\n  let e0f = (sBB * sAV - sAB * sBV) / det;\n  let e1f = (sAA * sBV - sAB * sAV) / det;\n  out.e0 = vec4<u32>(clamp(round(e0f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.e1 = vec4<u32>(clamp(round(e1f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.valid = true;\n  return out;\n}\n\n// -------------------------- Bit-packing helper -------------------------- //\n\n// Write `n_bits` LSBs of `value` at bit position `pos` in a 128-bit field\n// split across 4 u32s. Straddles the word boundary when necessary.\nfn write_bits(block: ptr<function, array<u32, 4>>, pos: u32, n_bits: u32, value: u32) {\n  let v = value & ((1u << n_bits) - 1u);\n  let word_lo = pos / 32u;\n  let bit_lo = pos % 32u;\n  let bits_in_lo = min(n_bits, 32u - bit_lo);\n\n  let mask_lo = ((1u << bits_in_lo) - 1u) << bit_lo;\n  (*block)[word_lo] = ((*block)[word_lo] & ~mask_lo) | ((v << bit_lo) & mask_lo);\n\n  if (bits_in_lo < n_bits) {\n    let bits_in_hi = n_bits - bits_in_lo;\n    let mask_hi = (1u << bits_in_hi) - 1u;\n    let val_hi = v >> bits_in_lo;\n    (*block)[word_lo + 1u] = ((*block)[word_lo + 1u] & ~mask_hi) | (val_hi & mask_hi);\n  }\n}\n\n// ------------------------------- Entry --------------------------------- //\n\n@compute @workgroup_size(8, 8, 1)\nfn encode(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if (gid.x >= params.blocks_x || gid.y >= params.blocks_y) {\n    return;\n  }\n\n  let bx = gid.x;\n  let by = gid.y;\n  let block_index = by * params.blocks_x + bx;\n\n  let base   = vec2<i32>(i32(bx) * 4, i32(by) * 4);\n  let max_xy = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  // 1. Load 16 RGBA pixels in 8-bit integer domain.\n  var pixels: array<vec4<u32>, 16>;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let lx = i32(i & 3u);\n    let ly = i32(i >> 2u);\n    let p  = clamp(base + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let c  = textureLoad(src_tex, p, 0);\n    pixels[i] = vec4<u32>(to8(c.r), to8(c.g), to8(c.b), to8(c.a));\n  }\n\n  // 2. Farthest-pair \u2192 initial endpoints.\n  let fp = farthest_pair(&pixels);\n  let ideal0_init = pixels[fp.i0];\n  let ideal1_init = pixels[fp.i1];\n\n  // 3. First p-bit search over the farthest-pair seed.\n  var best = try_pbit_combos(&pixels, ideal0_init, ideal1_init);\n\n  // 4. One-pass LSQ refit + second p-bit search; accept if error decreases.\n  let refit = refit_endpoints(&pixels, &best.indices);\n  if (refit.valid) {\n    let cand = try_pbit_combos(&pixels, refit.e0, refit.e1);\n    if (cand.err < best.err) {\n      best = cand;\n    }\n  }\n\n  // 5. Anchor rule \u2014 pixel 0's index MSB must be 0. If not, swap endpoints\n  // and reflect every index (new_i = 15 \u2212 old_i). The decoded palette\n  // reverses, so the reconstructed image is unchanged.\n  if ((best.indices[0] & 0x8u) != 0u) {\n    let tmp7 = best.e0_7; best.e0_7 = best.e1_7; best.e1_7 = tmp7;\n    let tmpP = best.p0;   best.p0   = best.p1;   best.p1   = tmpP;\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n      best.indices[k] = 15u - best.indices[k];\n    }\n  }\n\n  // 6. Pack into 128 bits = 4 u32s.\n  var block: array<u32, 4>;\n  block[0] = 0u; block[1] = 0u; block[2] = 0u; block[3] = 0u;\n\n  var pos: u32 = 0u;\n  // Mode 6: six zero bits followed by a 1 (LSB-first).\n  write_bits(&block, pos, 7u, 0x40u); pos = pos + 7u;\n  // Endpoints: R0, R1, G0, G1, B0, B1, A0, A1 \u2014 7 bits each.\n  write_bits(&block, pos, 7u, best.e0_7.x); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e1_7.x); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e0_7.y); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e1_7.y); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e0_7.z); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e1_7.z); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e0_7.w); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e1_7.w); pos = pos + 7u;\n  // P-bits.\n  write_bits(&block, pos, 1u, best.p0); pos = pos + 1u;\n  write_bits(&block, pos, 1u, best.p1); pos = pos + 1u;\n  // Pixel 0: 3-bit anchor (MSB implicit 0).\n  write_bits(&block, pos, 3u, best.indices[0] & 0x7u); pos = pos + 3u;\n  // Pixels 1..15: 4 bits each.\n  for (var k: u32 = 1u; k < 16u; k = k + 1u) {\n    write_bits(&block, pos, 4u, best.indices[k] & 0xFu);\n    pos = pos + 4u;\n  }\n\n  // 7. Store.\n  let out = block_index * 4u;\n  dst[out + 0u] = block[0];\n  dst[out + 1u] = block[1];\n  dst[out + 2u] = block[2];\n  dst[out + 3u] = block[3];\n}\n";
+var bc7_default = "// BC7 (BPTC) mode 6 compute shader encoder.\n//\n// One invocation per 4\xD74 block. Emits 16 bytes = 4 u32s into the storage\n// buffer at `dst[block_index * 4 .. + 3]`.\n//\n// QUALITY LEVELS (pipeline-overridable constant `QUALITY_HIGH`)\n//   fast (0, default): O(N) bounding-box seed \u2192 endpoints fitted by a single\n//     least-squares pass whose normal-equation sums are accumulated *during* a\n//     projection-based index assignment. The 16 palette entries are colinear\n//     (pal[i] = lerp(e0,e1,w[i])), so the nearest index is found by projecting\n//     each pixel onto the endpoint line \u2014 O(1) per pixel, no palette build and\n//     no 16-entry search. Profiled ~20\xD7 faster than `high` for ~0.4 dB PSNR.\n//   high (1): farthest-pair seed, exhaustive p-bit search over all four\n//     (p0,p1) \u2208 {0,1}\xB2 combos, full 16-entry nearest search, one LSQ refit \u2014\n//     byte-for-byte identical to bc7_ref.ts.\n//\n// Both paths run in the i32 domain. The fast path's branch is selected at\n// pipeline-compile time, so the driver eliminates the unused (high) code.\n//\n// MODE 6 LAYOUT (LSB-first, bit 0 = byte 0's bit 0)\n//   bits 0..6    mode field      (0b0000001 \u2014 only bit 6 is 1)\n//   bits 7..13   R0 (7-bit)   bits 14..20 R1   bits 21..27 G0   bits 28..34 G1\n//   bits 35..41  B0   bits 42..48 B1   bits 49..55 A0   bits 56..62 A1\n//   bit  63      P0   bit 64 P1\n//   bits 65..67  pixel 0 index (3 bits; anchor, MSB implicit 0)\n//   bits 68..71  pixel 1 index (4 bits) ... bits 124..127 pixel 15 index\n//\n// Effective 8-bit endpoint channel = (7_bit_value << 1) | p_bit.\n// Palette[i] = ((64 \u2212 W4[i]) \xD7 e0_8 + W4[i] \xD7 e1_8 + 32) >> 6, integer.\n\n// 0 = fast (default), 1 = exhaustive/high-quality. Set via pipeline constants.\noverride QUALITY_HIGH: u32 = 0u;\n\nstruct Params {\n  blocks_x: u32,\n  blocks_y: u32,\n  width:    u32,\n  height:   u32,\n};\n\n@group(0) @binding(0) var src_tex: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n@group(0) @binding(2) var<uniform> params: Params;\n\n// Mode 6 interpolation weights (\xD7 1/64), fixed by the spec (`W4` in bc7_ref.ts).\nfn w4(i: u32) -> u32 {\n  switch i {\n    case 0u:  { return  0u; }\n    case 1u:  { return  4u; }\n    case 2u:  { return  9u; }\n    case 3u:  { return 13u; }\n    case 4u:  { return 17u; }\n    case 5u:  { return 21u; }\n    case 6u:  { return 26u; }\n    case 7u:  { return 30u; }\n    case 8u:  { return 34u; }\n    case 9u:  { return 38u; }\n    case 10u: { return 43u; }\n    case 11u: { return 47u; }\n    case 12u: { return 51u; }\n    case 13u: { return 55u; }\n    case 14u: { return 60u; }\n    default:  { return 64u; }   // case 15u\n  }\n}\n\nfn interp4(e0: vec4<i32>, e1: vec4<i32>, w: i32) -> vec4<i32> {\n  return ((64 - w) * e0 + w * e1 + vec4<i32>(32)) >> vec4<u32>(6u);\n}\n\nfn to8(v: vec4<f32>) -> vec4<i32> {\n  return vec4<i32>(clamp(floor(v * 255.0 + 0.5), vec4<f32>(0.0), vec4<f32>(255.0)));\n}\n\nfn dist2(a: vec4<i32>, b: vec4<i32>) -> i32 {\n  let d = a - b;\n  let e = d * d;\n  return e.x + e.y + e.z + e.w;\n}\n\n// Quantize an 8-bit ideal endpoint to (7-bit value, reconstructed 8-bit) under\n// a fixed p-bit, all four channels at once. q7 = round((ideal8 \u2212 p)/2); used by\n// both paths.\nstruct QuantPair { seven: vec4<i32>, eight: vec4<i32> };\nfn quantize_endpoint(ideal8: vec4<i32>, p: u32) -> QuantPair {\n  let q = vec4<i32>(clamp(\n    floor((vec4<f32>(ideal8) - f32(p)) / 2.0 + 0.5),\n    vec4<f32>(0.0), vec4<f32>(127.0),\n  ));\n  let eff = (q << vec4<u32>(1u)) | vec4<i32>(i32(p));\n  return QuantPair(q, eff);\n}\n\n// ============================ FAST PATH ================================ //\n\n// Endpoint with its chosen p-bit, picked by minimum quantisation error.\nstruct Ep { seven: vec4<i32>, eight: vec4<i32>, p: u32 };\nfn pick_ep(ideal: vec4<i32>) -> Ep {\n  let a = quantize_endpoint(ideal, 0u);\n  let b = quantize_endpoint(ideal, 1u);\n  if (dist2(b.eight, ideal) < dist2(a.eight, ideal)) { return Ep(b.seven, b.eight, 1u); }\n  return Ep(a.seven, a.eight, 0u);\n}\n\n// Projection index assignment. The palette is colinear, so the nearest entry is\n// found by projecting onto the endpoint line \u2014 O(1) per pixel. When `fit`, the\n// LSQ normal-equation sums are accumulated in the same pass for a fused refit\n// (uniform weight i/15 \u2014 within a fraction of a code of the exact w4 table).\nstruct Fit { e0: vec4<i32>, e1: vec4<i32>, valid: bool };\nfn proj_assign(\n  pixels: ptr<function, array<vec4<i32>, 16>>,\n  e0: vec4<i32>, e1: vec4<i32>,\n  out_idx: ptr<function, array<u32, 16>>,\n  fit: bool,\n) -> Fit {\n  var out: Fit;\n  let dir = e1 - e0;\n  let dd = dir.x * dir.x + dir.y * dir.y + dir.z * dir.z + dir.w * dir.w;\n  if (dd == 0) {\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) { (*out_idx)[k] = 0u; }\n    out.valid = false;\n    return out;\n  }\n  let inv = 15.0 / f32(dd);\n  var sAA: f32 = 0.0; var sBB: f32 = 0.0; var sAB: f32 = 0.0;\n  var sAV: vec4<f32> = vec4<f32>(0.0); var sBV: vec4<f32> = vec4<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let q = (*pixels)[k] - e0;\n    let s = clamp(floor(f32(q.x * dir.x + q.y * dir.y + q.z * dir.z + q.w * dir.w) * inv + 0.5), 0.0, 15.0);\n    (*out_idx)[k] = u32(s);\n    if (fit) {\n      let v = vec4<f32>((*pixels)[k]);\n      let b = s / 15.0; let a = 1.0 - b;\n      sAA = sAA + a * a; sBB = sBB + b * b; sAB = sAB + a * b; sAV = sAV + a * v; sBV = sBV + b * v;\n    }\n  }\n  if (!fit) { out.valid = false; return out; }\n  let det = sAA * sBB - sAB * sAB;\n  if (abs(det) < 1e-9) { out.valid = false; return out; }\n  out.e0 = vec4<i32>(clamp(round((sBB * sAV - sAB * sBV) / det), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.e1 = vec4<i32>(clamp(round((sAA * sBV - sAB * sAV) / det), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.valid = true;\n  return out;\n}\n\n// ============================ HIGH PATH ================================ //\n\nstruct Pair { a: vec4<i32>, b: vec4<i32> };\nfn farthest_pair(pixels: ptr<function, array<vec4<i32>, 16>>) -> Pair {\n  var best_d: i32 = 0;\n  var pa = (*pixels)[0];\n  var pb = (*pixels)[1];\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let xi = (*pixels)[i];\n    for (var j: u32 = i + 1u; j < 16u; j = j + 1u) {\n      let d = dist2(xi, (*pixels)[j]);\n      if (d > best_d) { best_d = d; pa = xi; pb = (*pixels)[j]; }\n    }\n  }\n  return Pair(pa, pb);\n}\n\nfn build_palette_6(e0: vec4<i32>, e1: vec4<i32>, pal: ptr<function, array<vec4<i32>, 16>>) {\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    (*pal)[i] = interp4(e0, e1, i32(w4(i)));\n  }\n}\n\nfn assign_all(\n  pixels:  ptr<function, array<vec4<i32>, 16>>,\n  pal:     ptr<function, array<vec4<i32>, 16>>,\n  out_idx: ptr<function, array<u32, 16>>,\n) -> i32 {\n  var err: i32 = 0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let px = (*pixels)[k];\n    var best_i: u32 = 0u;\n    var best_d: i32 = 2147483647;\n    for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n      let d = dist2(px, (*pal)[i]);\n      if (d < best_d) { best_d = d; best_i = i; }\n    }\n    (*out_idx)[k] = best_i;\n    err = err + best_d;\n  }\n  return err;\n}\n\nstruct BestMode6 {\n  e0_7: vec4<i32>, e1_7: vec4<i32>,\n  p0: u32,         p1: u32,\n  indices: array<u32, 16>,\n  err: i32,\n};\n\n// Exhaustive p-bit search (high path); commits to `*best` only on improvement.\nfn try_pbit_combos(\n  pixels: ptr<function, array<vec4<i32>, 16>>,\n  ideal0: vec4<i32>,\n  ideal1: vec4<i32>,\n  best:   ptr<function, BestMode6>,\n) {\n  var local_best = (*best).err;\n  var pal: array<vec4<i32>, 16>;\n  var tmp: array<u32, 16>;\n  for (var p0: u32 = 0u; p0 < 2u; p0 = p0 + 1u) {\n    let q0 = quantize_endpoint(ideal0, p0);\n    for (var p1: u32 = 0u; p1 < 2u; p1 = p1 + 1u) {\n      let q1 = quantize_endpoint(ideal1, p1);\n      build_palette_6(q0.eight, q1.eight, &pal);\n      let err = assign_all(pixels, &pal, &tmp);\n      if (err < local_best) {\n        local_best = err;\n        (*best).e0_7 = q0.seven;\n        (*best).e1_7 = q1.seven;\n        (*best).p0 = p0;\n        (*best).p1 = p1;\n        (*best).indices = tmp;\n        (*best).err = err;\n      }\n    }\n  }\n}\n\n// Exact-weight LSQ refit (high path); matches bc7_ref.ts `refitEndpointsMode6`.\nstruct RefitResult { e0: vec4<i32>, e1: vec4<i32>, valid: bool };\nfn refit_endpoints(\n  pixels: ptr<function, array<vec4<i32>, 16>>,\n  indices: ptr<function, array<u32, 16>>,\n) -> RefitResult {\n  var sAA: f32 = 0.0;\n  var sBB: f32 = 0.0;\n  var sAB: f32 = 0.0;\n  var sAV: vec4<f32> = vec4<f32>(0.0);\n  var sBV: vec4<f32> = vec4<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let i = (*indices)[k];\n    let a = f32(64u - w4(i)) / 64.0;\n    let b = f32(w4(i)) / 64.0;\n    let v = vec4<f32>((*pixels)[k]);\n    sAA = sAA + a * a;\n    sBB = sBB + b * b;\n    sAB = sAB + a * b;\n    sAV = sAV + a * v;\n    sBV = sBV + b * v;\n  }\n  let det = sAA * sBB - sAB * sAB;\n  var out: RefitResult;\n  if (abs(det) < 1e-9) {\n    out.valid = false;\n    return out;\n  }\n  let e0f = (sBB * sAV - sAB * sBV) / det;\n  let e1f = (sAA * sBV - sAB * sAV) / det;\n  out.e0 = vec4<i32>(clamp(round(e0f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.e1 = vec4<i32>(clamp(round(e1f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.valid = true;\n  return out;\n}\n\n// -------------------------- Bit-packing helper -------------------------- //\n\nfn write_bits(block: ptr<function, array<u32, 4>>, pos: u32, n_bits: u32, value: u32) {\n  let v = value & ((1u << n_bits) - 1u);\n  let word_lo = pos / 32u;\n  let bit_lo = pos % 32u;\n  let bits_in_lo = min(n_bits, 32u - bit_lo);\n  let mask_lo = ((1u << bits_in_lo) - 1u) << bit_lo;\n  (*block)[word_lo] = ((*block)[word_lo] & ~mask_lo) | ((v << bit_lo) & mask_lo);\n  if (bits_in_lo < n_bits) {\n    let bits_in_hi = n_bits - bits_in_lo;\n    let mask_hi = (1u << bits_in_hi) - 1u;\n    let val_hi = v >> bits_in_lo;\n    (*block)[word_lo + 1u] = ((*block)[word_lo + 1u] & ~mask_hi) | (val_hi & mask_hi);\n  }\n}\n\n// ------------------------------- Entry --------------------------------- //\n\n@compute @workgroup_size(8, 8, 1)\nfn encode(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if (gid.x >= params.blocks_x || gid.y >= params.blocks_y) {\n    return;\n  }\n\n  let bx = gid.x;\n  let by = gid.y;\n  let block_index = by * params.blocks_x + bx;\n\n  let base   = vec2<i32>(i32(bx) * 4, i32(by) * 4);\n  let max_xy = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  // Load 16 RGBA pixels (8-bit integer domain) and the per-channel bbox.\n  var pixels: array<vec4<i32>, 16>;\n  var lo = vec4<i32>(255);\n  var hi = vec4<i32>(0);\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let lx = i32(i & 3u);\n    let ly = i32(i >> 2u);\n    let p  = clamp(base + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let px = to8(textureLoad(src_tex, p, 0));\n    pixels[i] = px;\n    lo = min(lo, px);\n    hi = max(hi, px);\n  }\n\n  var e0_7: vec4<i32>;\n  var e1_7: vec4<i32>;\n  var p0: u32;\n  var p1: u32;\n  var indices: array<u32, 16>;\n\n  if (QUALITY_HIGH != 0u) {\n    let fp = farthest_pair(&pixels);\n    var best: BestMode6;\n    best.err = 2147483647;\n    try_pbit_combos(&pixels, fp.a, fp.b, &best);\n    let refit = refit_endpoints(&pixels, &best.indices);\n    if (refit.valid) {\n      try_pbit_combos(&pixels, refit.e0, refit.e1, &best);\n    }\n    e0_7 = best.e0_7; e1_7 = best.e1_7; p0 = best.p0; p1 = best.p1; indices = best.indices;\n  } else {\n    var ep0 = pick_ep(lo);\n    var ep1 = pick_ep(hi);\n    let r = proj_assign(&pixels, ep0.eight, ep1.eight, &indices, true);\n    if (r.valid) {\n      ep0 = pick_ep(r.e0);\n      ep1 = pick_ep(r.e1);\n      proj_assign(&pixels, ep0.eight, ep1.eight, &indices, false);\n    }\n    e0_7 = ep0.seven; e1_7 = ep1.seven; p0 = ep0.p; p1 = ep1.p;\n  }\n\n  // Anchor rule \u2014 pixel 0's index MSB must be 0. If not, swap endpoints and\n  // reflect every index (new_i = 15 \u2212 old_i); decoded image is unchanged.\n  if ((indices[0] & 0x8u) != 0u) {\n    let t7 = e0_7; e0_7 = e1_7; e1_7 = t7;\n    let tp = p0;   p0   = p1;   p1   = tp;\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n      indices[k] = 15u - indices[k];\n    }\n  }\n\n  // Pack into 128 bits = 4 u32s.\n  var block: array<u32, 4>;\n  block[0] = 0u; block[1] = 0u; block[2] = 0u; block[3] = 0u;\n  var pos: u32 = 0u;\n  write_bits(&block, pos, 7u, 0x40u); pos = pos + 7u;\n  write_bits(&block, pos, 7u, u32(e0_7.x)); pos = pos + 7u;\n  write_bits(&block, pos, 7u, u32(e1_7.x)); pos = pos + 7u;\n  write_bits(&block, pos, 7u, u32(e0_7.y)); pos = pos + 7u;\n  write_bits(&block, pos, 7u, u32(e1_7.y)); pos = pos + 7u;\n  write_bits(&block, pos, 7u, u32(e0_7.z)); pos = pos + 7u;\n  write_bits(&block, pos, 7u, u32(e1_7.z)); pos = pos + 7u;\n  write_bits(&block, pos, 7u, u32(e0_7.w)); pos = pos + 7u;\n  write_bits(&block, pos, 7u, u32(e1_7.w)); pos = pos + 7u;\n  write_bits(&block, pos, 1u, p0); pos = pos + 1u;\n  write_bits(&block, pos, 1u, p1); pos = pos + 1u;\n  write_bits(&block, pos, 3u, indices[0] & 0x7u); pos = pos + 3u;\n  for (var k: u32 = 1u; k < 16u; k = k + 1u) {\n    write_bits(&block, pos, 4u, indices[k] & 0xFu);\n    pos = pos + 4u;\n  }\n\n  let out = block_index * 4u;\n  dst[out + 0u] = block[0];\n  dst[out + 1u] = block[1];\n  dst[out + 2u] = block[2];\n  dst[out + 3u] = block[3];\n}\n";
+
+// src/bc7_fast_f16.wgsl
+var bc7_fast_f16_default = `// bc7 "fast" encoder \u2014 f16 variant (requires the shader-f16 feature).
+// Identical algorithm to the f32 fast path in bc7.wgsl, but the projection +
+// least-squares refit run in f16 ([0,1] domain). On GPUs with 2x f16 throughput
+// (e.g. Apple) this is ~2x faster at the same quality; endpoints are still
+// quantised to exact 8-bit. The host selects this module only when the device
+// reports shader-f16, falling back to bc7.wgsl otherwise. "high" never uses this.
+//
+// BC7 mode 6 fast path in f16 (Apple GPUs run f16 at 2x). All math in the [0,1]
+// domain so dot products stay well under f16's range; endpoints quantised to
+// 8-bit at the end. Same bbox seed + projection + fused LSQ refit + reproject.
+enable f16;
+struct Params { blocks_x: u32, blocks_y: u32, width: u32, height: u32, };
+@group(0) @binding(0) var src_tex: texture_2d<f32>;
+@group(0) @binding(1) var<storage, read_write> dst: array<u32>;
+@group(0) @binding(2) var<uniform> params: Params;
+alias h = f16;
+alias h4 = vec4<f16>;
+struct Ep { seven: vec4<i32>, eight: h4, p: u32 };
+// quantise an ideal endpoint (h4 in [0,1]) to 7-bit + p-bit; returns 8-bit eff in [0,1].
+fn pick_ep(ideal01: h4) -> Ep {
+  let ideal = ideal01 * h(255.0);
+  let q0 = clamp(floor(ideal * h(0.5) + h(0.5)), h4(0.0), h4(127.0));        // p=0
+  let e0 = q0 * h(2.0);
+  let q1 = clamp(floor((ideal - h(1.0)) * h(0.5) + h(0.5)), h4(0.0), h4(127.0)); // p=1
+  let e1 = q1 * h(2.0) + h(1.0);
+  let d0 = e0 - ideal; let d1 = e1 - ideal;
+  if (dot(d1,d1) < dot(d0,d0)) { return Ep(vec4<i32>(q1), e1 * h(1.0/255.0), 1u); }
+  return Ep(vec4<i32>(q0), e0 * h(1.0/255.0), 0u);
+}
+struct Fit { e0: h4, e1: h4, valid: bool };
+fn proj_assign(pix: ptr<function, array<h4,16>>, e0: h4, e1: h4, out_idx: ptr<function, array<u32,16>>, fit: bool) -> Fit {
+  var out: Fit; let dir = e1 - e0; let dd = dot(dir,dir);
+  if (dd == h(0.0)) { for(var k:u32=0u;k<16u;k=k+1u){(*out_idx)[k]=0u;} out.valid=false; return out; }
+  let inv = h(15.0) / dd;
+  var sAA=h(0.0); var sBB=h(0.0); var sAB=h(0.0); var sAV=h4(0.0); var sBV=h4(0.0);
+  for(var k:u32=0u;k<16u;k=k+1u){
+    let v=(*pix)[k];
+    let s = clamp(floor(dot(v - e0, dir) * inv + h(0.5)), h(0.0), h(15.0));
+    (*out_idx)[k] = u32(s);
+    if(fit){ let b=s*h(1.0/15.0); let a=h(1.0)-b; sAA=sAA+a*a; sBB=sBB+b*b; sAB=sAB+a*b; sAV=sAV+a*v; sBV=sBV+b*v; }
+  }
+  if(!fit){ out.valid=false; return out; }
+  let det = sAA*sBB - sAB*sAB; if (abs(det) < h(0.0001)) { out.valid=false; return out; }
+  out.e0 = clamp((sBB*sAV - sAB*sBV)/det, h4(0.0), h4(1.0));
+  out.e1 = clamp((sAA*sBV - sAB*sAV)/det, h4(0.0), h4(1.0));
+  out.valid=true; return out;
+}
+fn write_bits(block: ptr<function, array<u32,4>>, pos: u32, n_bits: u32, value: u32) {
+  let v=value&((1u<<n_bits)-1u); let wl=pos/32u; let bl=pos%32u; let il=min(n_bits,32u-bl);
+  let ml=((1u<<il)-1u)<<bl; (*block)[wl]=((*block)[wl]&~ml)|((v<<bl)&ml);
+  if(il<n_bits){ let ih=n_bits-il; let mh=(1u<<ih)-1u; (*block)[wl+1u]=((*block)[wl+1u]&~mh)|((v>>il)&mh); }
+}
+@compute @workgroup_size(8,8,1)
+fn encode(@builtin(global_invocation_id) gid: vec3<u32>) {
+  if(gid.x>=params.blocks_x||gid.y>=params.blocks_y){return;}
+  let bi=gid.y*params.blocks_x+gid.x;
+  let base=vec2<i32>(i32(gid.x)*4,i32(gid.y)*4); let mx=vec2<i32>(i32(params.width)-1,i32(params.height)-1);
+  var pix: array<h4,16>; var lo=h4(1.0); var hi=h4(0.0);
+  for(var i:u32=0u;i<16u;i=i+1u){
+    let p=clamp(base+vec2<i32>(i32(i&3u),i32(i>>2u)),vec2<i32>(0),mx);
+    let px=h4(textureLoad(src_tex,p,0)); pix[i]=px; lo=min(lo,px); hi=max(hi,px);
+  }
+  var ep0=pick_ep(lo); var ep1=pick_ep(hi); var indices: array<u32,16>;
+  let r=proj_assign(&pix,ep0.eight,ep1.eight,&indices,true);
+  if(r.valid){ ep0=pick_ep(r.e0); ep1=pick_ep(r.e1); proj_assign(&pix,ep0.eight,ep1.eight,&indices,false); }
+  if((indices[0]&0x8u)!=0u){ let t=ep0; ep0=ep1; ep1=t; for(var k:u32=0u;k<16u;k=k+1u){indices[k]=15u-indices[k];} }
+  var block: array<u32,4>; block[0]=0u;block[1]=0u;block[2]=0u;block[3]=0u; var pos:u32=0u;
+  write_bits(&block,pos,7u,0x40u);pos=pos+7u;
+  write_bits(&block,pos,7u,u32(ep0.seven.x));pos=pos+7u; write_bits(&block,pos,7u,u32(ep1.seven.x));pos=pos+7u;
+  write_bits(&block,pos,7u,u32(ep0.seven.y));pos=pos+7u; write_bits(&block,pos,7u,u32(ep1.seven.y));pos=pos+7u;
+  write_bits(&block,pos,7u,u32(ep0.seven.z));pos=pos+7u; write_bits(&block,pos,7u,u32(ep1.seven.z));pos=pos+7u;
+  write_bits(&block,pos,7u,u32(ep0.seven.w));pos=pos+7u; write_bits(&block,pos,7u,u32(ep1.seven.w));pos=pos+7u;
+  write_bits(&block,pos,1u,ep0.p);pos=pos+1u; write_bits(&block,pos,1u,ep1.p);pos=pos+1u;
+  write_bits(&block,pos,3u,indices[0]&0x7u);pos=pos+3u;
+  for(var k:u32=1u;k<16u;k=k+1u){write_bits(&block,pos,4u,indices[k]&0xFu);pos=pos+4u;}
+  let o=bi*4u; dst[o]=block[0];dst[o+1u]=block[1];dst[o+2u]=block[2];dst[o+3u]=block[3];
+}
+`;
 
 // src/BC7Encoder.ts
 var BC7Encoder = class extends Encoder {
@@ -368,9 +538,15 @@ var BC7Encoder = class extends Encoder {
   get supportsSrgb() {
     return true;
   }
+  get supportsQuality() {
+    return true;
+  }
   wgslSource() {
     return bc7_default;
   }
+  wgslSourceFastF16() {
+    return bc7_fast_f16_default;
+  }
   gpuTextureFormat({ colorSpace }) {
     return colorSpace === "srgb" ? "bc7-rgba-unorm-srgb" : "bc7-rgba-unorm";
   }
@@ -383,7 +559,10 @@ var BC7Encoder = class extends Encoder {
 import { RGBA_ASTC_4x4_Format } from "three";
 
 // src/astc4x4.wgsl
-var astc4x4_default = "// ASTC 4\xD74 LDR compute shader encoder.\n//\n// One invocation per 4\xD74 block. Emits 16 bytes = 4 u32s into the storage\n// buffer at `dst[block_index * 4 .. + 3]`.\n//\n// This shader mirrors `astc4x4_ref.ts` function-by-function; see that\n// file for the end-to-end algorithm rationale and the full block layout\n// / block-mode derivation. A short recap follows.\n//\n// RESTRICTED SUBSET (both CPU ref and this shader):\n//   \u2022 Single partition, no dual-plane\n//   \u2022 CEM 12 (LDR RGBA, direct)\n//   \u2022 Weight grid 4\xD74 (no upsampling), 2-bit weights (QUANT_4)\n//   \u2022 8-bit endpoints (QUANT_256 \u2014 bit-replication is a no-op)\n//\n// BLOCK LAYOUT (128 bits, LSB-first)\n//   bits [10:0]   block mode = 0x042\n//   bits [12:11]  partition count \u2212 1 = 0\n//   bits [16:13]  CEM = 12\n//   bits [80:17]  endpoints: R0 R1 G0 G1 B0 B1 A0 A1 (8-bit each)\n//   bits [95:81]  unused (zero padding)\n//   bits [127:96] 16 \xD7 2-bit weights; for weight k \u2208 [0,15]:\n//                   block_bit(127 \u2212 2k) = weight_k[0]   (LSB)\n//                   block_bit(126 \u2212 2k) = weight_k[1]   (MSB)\n//\n// ENDPOINT ORDERING: after fitting, if sum(e0.rgb) > sum(e1.rgb) we swap\n// endpoints and reflect indices (w' = 3 \u2212 w). This keeps the decoder out\n// of the blue-contraction branch (see CPU ref file header for the full\n// decoder behaviour).\n\nstruct Params {\n  blocks_x: u32,\n  blocks_y: u32,\n  width:    u32,\n  height:   u32,\n};\n\n@group(0) @binding(0) var src_tex: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n@group(0) @binding(2) var<uniform> params: Params;\n\n// QUANT_4 weight unquantisation: q \u2208 [0,3] \u2192 unq \u2208 [0, 21, 43, 64].\n// Switch keeps us off a module-scope const array (some backends reject\n// those inside function-call bodies).\nfn weight_unq(i: u32) -> u32 {\n  switch i {\n    case 0u: { return  0u; }\n    case 1u: { return 21u; }\n    case 2u: { return 43u; }\n    default: { return 64u; }  // case 3u\n  }\n}\n\n// Hardware-exact integer interpolation. Identical to BC7's; matches the\n// CPU reference bit-for-bit.\nfn interp8(e0: u32, e1: u32, w: u32) -> u32 {\n  return ((64u - w) * e0 + w * e1 + 32u) >> 6u;\n}\n\n// Normalised [0, 1] \u2192 clamped 8-bit. Same rounding rule (floor(v + 0.5))\n// as the CPU reference's Math.round.\nfn to8(v: f32) -> u32 {\n  return u32(clamp(floor(v * 255.0 + 0.5), 0.0, 255.0));\n}\n\n// 4-channel L2 distance squared in u32 domain. Bounded by 4 \xB7 255\xB2 = 260,100.\nfn pixel_dist_sq(a: vec4<u32>, b: vec4<u32>) -> u32 {\n  let d = vec4<i32>(a) - vec4<i32>(b);\n  let d2 = d * d;\n  return u32(d2.x + d2.y + d2.z + d2.w);\n}\n\n// -------------------------- Farthest-pair seed -------------------------- //\n\nstruct PairResult { i0: u32, i1: u32 };\n\n// O(N\xB2) = 120 comparisons. Same rationale as BC7's `farthest_pair`:\n// bounding-box corners aren't safe initial endpoints when channels vary\n// in different directions along the data line.\nfn farthest_pair(pixels: ptr<function, array<vec4<u32>, 16>>) -> PairResult {\n  var best_d: u32 = 0u;\n  var best_i: u32 = 0u;\n  var best_j: u32 = 1u;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    for (var j: u32 = i + 1u; j < 16u; j = j + 1u) {\n      let d = pixel_dist_sq((*pixels)[i], (*pixels)[j]);\n      if (d > best_d) { best_d = d; best_i = i; best_j = j; }\n    }\n  }\n  return PairResult(best_i, best_j);\n}\n\n// -------------------------- Palette + assignment ------------------------ //\n\n// Build the 4-entry RGBA palette from 8-bit endpoints. Uses the same\n// integer interpolation formula as decode, so assignments made against\n// this palette match the hardware round-trip.\nfn build_palette(\n  e0: vec4<u32>, e1: vec4<u32>,\n  pal: ptr<function, array<vec4<u32>, 4>>,\n) {\n  for (var i: u32 = 0u; i < 4u; i = i + 1u) {\n    let w = weight_unq(i);\n    (*pal)[i] = vec4<u32>(\n      interp8(e0.x, e1.x, w),\n      interp8(e0.y, e1.y, w),\n      interp8(e0.z, e1.z, w),\n      interp8(e0.w, e1.w, w),\n    );\n  }\n}\n\n// Nearest palette entry for a single RGBA pixel. Full 4-way L2 search.\n// Returns (best_index, its squared error).\nfn nearest_index(pixel: vec4<u32>, pal: ptr<function, array<vec4<u32>, 4>>) -> vec2<u32> {\n  var best_i: u32 = 0u;\n  var best_d: u32 = 0xFFFFFFFFu;\n  for (var i: u32 = 0u; i < 4u; i = i + 1u) {\n    let d = pixel_dist_sq(pixel, (*pal)[i]);\n    if (d < best_d) { best_d = d; best_i = i; }\n  }\n  return vec2<u32>(best_i, best_d);\n}\n\n// Assign all 16 texels to nearest palette entries; accumulate squared error.\nstruct AssignResult { indices: array<u32, 16>, err: u32 };\n\nfn assign_all(\n  pixels: ptr<function, array<vec4<u32>, 16>>,\n  pal:    ptr<function, array<vec4<u32>, 4>>,\n) -> AssignResult {\n  var out: AssignResult;\n  out.err = 0u;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let sel = nearest_index((*pixels)[k], pal);\n    out.indices[k] = sel.x;\n    out.err = out.err + sel.y;\n  }\n  return out;\n}\n\n// ---------------------- Least-squares endpoint refit -------------------- //\n\n// Given current indices, solve the per-channel 2\xD72 normal equations for\n// (e0, e1). See the CPU reference's `refitEndpoints` for the derivation.\n// `valid = false` signals a degenerate system (all texels on one palette\n// entry) and the caller keeps the farthest-pair seed.\nstruct RefitResult { e0: vec4<u32>, e1: vec4<u32>, valid: bool };\n\nfn refit_endpoints(\n  pixels:  ptr<function, array<vec4<u32>, 16>>,\n  indices: ptr<function, array<u32, 16>>,\n) -> RefitResult {\n  var sAA: f32 = 0.0;\n  var sBB: f32 = 0.0;\n  var sAB: f32 = 0.0;\n  var sAV: vec4<f32> = vec4<f32>(0.0);\n  var sBV: vec4<f32> = vec4<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let unq = weight_unq((*indices)[k]);\n    let a = f32(64u - unq) / 64.0;\n    let b = f32(unq)       / 64.0;\n    let v = vec4<f32>((*pixels)[k]);\n    sAA = sAA + a * a;\n    sBB = sBB + b * b;\n    sAB = sAB + a * b;\n    sAV = sAV + a * v;\n    sBV = sBV + b * v;\n  }\n  let det = sAA * sBB - sAB * sAB;\n  var out: RefitResult;\n  if (abs(det) < 1e-9) {\n    out.valid = false;\n    return out;\n  }\n  let e0f = (sBB * sAV - sAB * sBV) / det;\n  let e1f = (sAA * sBV - sAB * sAV) / det;\n  out.e0 = vec4<u32>(clamp(round(e0f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.e1 = vec4<u32>(clamp(round(e1f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.valid = true;\n  return out;\n}\n\n// -------------------------- Bit-packing helper -------------------------- //\n\n// Write `n_bits` LSBs of `value` at bit position `pos` of a 128-bit field\n// represented as `array<u32, 4>`. Handles word-boundary straddles.\n// Lifted from the BC7 shader verbatim; the layout contract is identical.\nfn write_bits(block: ptr<function, array<u32, 4>>, pos: u32, n_bits: u32, value: u32) {\n  let v = value & ((1u << n_bits) - 1u);\n  let word_lo = pos / 32u;\n  let bit_lo = pos % 32u;\n  let bits_in_lo = min(n_bits, 32u - bit_lo);\n\n  let mask_lo = ((1u << bits_in_lo) - 1u) << bit_lo;\n  (*block)[word_lo] = ((*block)[word_lo] & ~mask_lo) | ((v << bit_lo) & mask_lo);\n\n  if (bits_in_lo < n_bits) {\n    let bits_in_hi = n_bits - bits_in_lo;\n    let mask_hi = (1u << bits_in_hi) - 1u;\n    let val_hi = v >> bits_in_lo;\n    (*block)[word_lo + 1u] = ((*block)[word_lo + 1u] & ~mask_hi) | (val_hi & mask_hi);\n  }\n}\n\n// ------------------------------- Entry ---------------------------------- //\n\n@compute @workgroup_size(8, 8, 1)\nfn encode(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if (gid.x >= params.blocks_x || gid.y >= params.blocks_y) {\n    return;\n  }\n\n  let bx = gid.x;\n  let by = gid.y;\n  let block_index = by * params.blocks_x + bx;\n\n  let base   = vec2<i32>(i32(bx) * 4, i32(by) * 4);\n  let max_xy = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  // 1. Load 16 RGBA texels in 8-bit integer domain.\n  var pixels: array<vec4<u32>, 16>;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let lx = i32(i & 3u);\n    let ly = i32(i >> 2u);\n    // Clamp to edge for non-multiple-of-4 input sizes.\n    let p  = clamp(base + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let c  = textureLoad(src_tex, p, 0);\n    pixels[i] = vec4<u32>(to8(c.r), to8(c.g), to8(c.b), to8(c.a));\n  }\n\n  // 2. Farthest-pair seed \u2192 initial endpoints.\n  let fp = farthest_pair(&pixels);\n  var e0 = pixels[fp.i0];\n  var e1 = pixels[fp.i1];\n\n  // 3. Initial assignment against the seed endpoints.\n  var pal: array<vec4<u32>, 4>;\n  build_palette(e0, e1, &pal);\n  var best = assign_all(&pixels, &pal);\n\n  // 4. One LSQ refit pass. Accept only if the squared error strictly\n  //    decreases \u2014 matches the CPU reference.\n  let refit = refit_endpoints(&pixels, &best.indices);\n  if (refit.valid) {\n    var pal2: array<vec4<u32>, 4>;\n    build_palette(refit.e0, refit.e1, &pal2);\n    let cand = assign_all(&pixels, &pal2);\n    if (cand.err < best.err) {\n      e0 = refit.e0;\n      e1 = refit.e1;\n      best = cand;\n    }\n  }\n\n  // 5. Endpoint ordering so the decoder doesn't apply blue contraction.\n  //    Strict '>' avoids a gratuitous swap on ties.\n  let s0 = e0.x + e0.y + e0.z;\n  let s1 = e1.x + e1.y + e1.z;\n  if (s0 > s1) {\n    let tmp = e0; e0 = e1; e1 = tmp;\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n      // w' = 3 \u2212 w reflects the palette; decoded colour unchanged.\n      best.indices[k] = 3u - best.indices[k];\n    }\n  }\n\n  // 6. Pack 128 bits.\n  var block: array<u32, 4>;\n  block[0] = 0u; block[1] = 0u; block[2] = 0u; block[3] = 0u;\n\n  // Config header.\n  write_bits(&block, 0u,  11u, 0x042u);   // block mode: 4\xD74 grid, QUANT_4 weights\n  write_bits(&block, 11u, 2u,  0u);       // partition count \u2212 1\n  write_bits(&block, 13u, 4u,  12u);      // CEM 12: LDR RGBA direct\n\n  // Endpoints in the CEM 12 value order: R0 R1 G0 G1 B0 B1 A0 A1.\n  write_bits(&block, 17u + 0u * 8u, 8u, e0.x);\n  write_bits(&block, 17u + 1u * 8u, 8u, e1.x);\n  write_bits(&block, 17u + 2u * 8u, 8u, e0.y);\n  write_bits(&block, 17u + 3u * 8u, 8u, e1.y);\n  write_bits(&block, 17u + 4u * 8u, 8u, e0.z);\n  write_bits(&block, 17u + 5u * 8u, 8u, e1.z);\n  write_bits(&block, 17u + 6u * 8u, 8u, e0.w);\n  write_bits(&block, 17u + 7u * 8u, 8u, e1.w);\n\n  // Weights at the top of the block. Two 1-bit writes per weight keeps\n  // the LSB-at-127 convention visible at every call site; the cost over\n  // a batched write is negligible next to the full encode.\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let w = best.indices[k] & 0x3u;\n    write_bits(&block, 127u - 2u * k, 1u,  w & 1u);\n    write_bits(&block, 126u - 2u * k, 1u, (w >> 1u) & 1u);\n  }\n\n  // 7. Store as 4 u32s.\n  let out = block_index * 4u;\n  dst[out + 0u] = block[0];\n  dst[out + 1u] = block[1];\n  dst[out + 2u] = block[2];\n  dst[out + 3u] = block[3];\n}\n";
+var astc4x4_default = "// ASTC 4\xD74 LDR compute shader encoder.\n//\n// One invocation per 4\xD74 block. Emits 16 bytes = 4 u32s into the storage\n// buffer at `dst[block_index * 4 .. + 3]`.\n//\n// QUALITY LEVELS (pipeline-overridable constant `QUALITY_HIGH`)\n//   fast (0, default): O(N) bounding-box seed \u2192 endpoints fitted by a single\n//     least-squares pass whose sums are accumulated during a projection-based\n//     weight assignment (the 4 palette entries are colinear, so the nearest is\n//     found by projecting onto the endpoint line \u2014 no per-entry search).\n//     Profiled ~4\xD7 faster than `high` for ~0.36 dB PSNR.\n//   high (1): O(N\xB2) farthest-pair seed, full 4-entry nearest search, one LSQ\n//     refit \u2014 byte-for-byte identical to astc4x4_ref.ts.\n// The fast branch is selected at pipeline-compile time; the driver eliminates\n// the unused (high) code.\n//\n// RESTRICTED SUBSET: single partition, no dual-plane, CEM 12 (LDR RGBA direct),\n// 4\xD74 weight grid with 2-bit weights (QUANT_4), 8-bit endpoints (QUANT_256).\n//\n// BLOCK LAYOUT (128 bits, LSB-first)\n//   bits [10:0]   block mode = 0x042\n//   bits [12:11]  partition count \u2212 1 = 0\n//   bits [16:13]  CEM = 12\n//   bits [80:17]  endpoints: R0 R1 G0 G1 B0 B1 A0 A1 (8-bit each)\n//   bits [127:96] 16 \xD7 2-bit weights; weight k: bit(127\u22122k)=lsb, bit(126\u22122k)=msb\n//\n// ENDPOINT ORDERING: if sum(e0.rgb) > sum(e1.rgb) swap endpoints and reflect\n// indices (w' = 3 \u2212 w) to keep the decoder out of blue contraction.\n\n// 0 = fast (default), 1 = exhaustive/high-quality. Set via pipeline constants.\noverride QUALITY_HIGH: u32 = 0u;\n\nstruct Params {\n  blocks_x: u32,\n  blocks_y: u32,\n  width:    u32,\n  height:   u32,\n};\n\n@group(0) @binding(0) var src_tex: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n@group(0) @binding(2) var<uniform> params: Params;\n\nfn weight_unq(i: u32) -> i32 {\n  switch i {\n    case 0u: { return  0; }\n    case 1u: { return 21; }\n    case 2u: { return 43; }\n    default: { return 64; }  // case 3u\n  }\n}\n\nfn interp4(e0: vec4<i32>, e1: vec4<i32>, w: i32) -> vec4<i32> {\n  return ((64 - w) * e0 + w * e1 + vec4<i32>(32)) >> vec4<u32>(6u);\n}\n\nfn to8(v: vec4<f32>) -> vec4<i32> {\n  return vec4<i32>(clamp(floor(v * 255.0 + 0.5), vec4<f32>(0.0), vec4<f32>(255.0)));\n}\n\nfn dist2(a: vec4<i32>, b: vec4<i32>) -> i32 {\n  let d = a - b;\n  let e = d * d;\n  return e.x + e.y + e.z + e.w;\n}\n\n// ============================ FAST PATH ================================ //\n\n// Projection weight assignment over 4 levels (QUANT_4 \u2248 thirds), with the LSQ\n// normal-equation sums accumulated in the same pass for a fused refit.\nstruct Fit { e0: vec4<i32>, e1: vec4<i32>, valid: bool };\nfn proj_assign(\n  pixels: ptr<function, array<vec4<i32>, 16>>,\n  e0: vec4<i32>, e1: vec4<i32>,\n  out_idx: ptr<function, array<u32, 16>>,\n  fit: bool,\n) -> Fit {\n  var out: Fit;\n  let dir = e1 - e0;\n  let dd = dir.x * dir.x + dir.y * dir.y + dir.z * dir.z + dir.w * dir.w;\n  if (dd == 0) {\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) { (*out_idx)[k] = 0u; }\n    out.valid = false;\n    return out;\n  }\n  let inv = 3.0 / f32(dd);\n  var sAA: f32 = 0.0; var sBB: f32 = 0.0; var sAB: f32 = 0.0;\n  var sAV: vec4<f32> = vec4<f32>(0.0); var sBV: vec4<f32> = vec4<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let q = (*pixels)[k] - e0;\n    let s = clamp(floor(f32(q.x * dir.x + q.y * dir.y + q.z * dir.z + q.w * dir.w) * inv + 0.5), 0.0, 3.0);\n    (*out_idx)[k] = u32(s);\n    if (fit) {\n      let v = vec4<f32>((*pixels)[k]);\n      let b = s / 3.0; let a = 1.0 - b;\n      sAA = sAA + a * a; sBB = sBB + b * b; sAB = sAB + a * b; sAV = sAV + a * v; sBV = sBV + b * v;\n    }\n  }\n  if (!fit) { out.valid = false; return out; }\n  let det = sAA * sBB - sAB * sAB;\n  if (abs(det) < 1e-9) { out.valid = false; return out; }\n  out.e0 = vec4<i32>(clamp(round((sBB * sAV - sAB * sBV) / det), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.e1 = vec4<i32>(clamp(round((sAA * sBV - sAB * sAV) / det), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.valid = true;\n  return out;\n}\n\n// ============================ HIGH PATH ================================ //\n\nstruct Pair { a: vec4<i32>, b: vec4<i32> };\nfn farthest_pair(pixels: ptr<function, array<vec4<i32>, 16>>) -> Pair {\n  var best_d: i32 = 0;\n  var pa = (*pixels)[0];\n  var pb = (*pixels)[1];\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let xi = (*pixels)[i];\n    for (var j: u32 = i + 1u; j < 16u; j = j + 1u) {\n      let d = dist2(xi, (*pixels)[j]);\n      if (d > best_d) { best_d = d; pa = xi; pb = (*pixels)[j]; }\n    }\n  }\n  return Pair(pa, pb);\n}\n\nfn build_palette(e0: vec4<i32>, e1: vec4<i32>, pal: ptr<function, array<vec4<i32>, 4>>) {\n  for (var i: u32 = 0u; i < 4u; i = i + 1u) {\n    (*pal)[i] = interp4(e0, e1, weight_unq(i));\n  }\n}\n\nfn assign_all(\n  pixels:  ptr<function, array<vec4<i32>, 16>>,\n  pal:     ptr<function, array<vec4<i32>, 4>>,\n  out_idx: ptr<function, array<u32, 16>>,\n) -> i32 {\n  var err: i32 = 0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let px = (*pixels)[k];\n    var best_i: u32 = 0u;\n    var best_d: i32 = 2147483647;\n    for (var i: u32 = 0u; i < 4u; i = i + 1u) {\n      let d = dist2(px, (*pal)[i]);\n      if (d < best_d) { best_d = d; best_i = i; }\n    }\n    (*out_idx)[k] = best_i;\n    err = err + best_d;\n  }\n  return err;\n}\n\nstruct RefitResult { e0: vec4<i32>, e1: vec4<i32>, valid: bool };\nfn refit_endpoints(\n  pixels:  ptr<function, array<vec4<i32>, 16>>,\n  indices: ptr<function, array<u32, 16>>,\n) -> RefitResult {\n  var sAA: f32 = 0.0;\n  var sBB: f32 = 0.0;\n  var sAB: f32 = 0.0;\n  var sAV: vec4<f32> = vec4<f32>(0.0);\n  var sBV: vec4<f32> = vec4<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let unq = weight_unq((*indices)[k]);\n    let a = f32(64 - unq) / 64.0;\n    let b = f32(unq)      / 64.0;\n    let v = vec4<f32>((*pixels)[k]);\n    sAA = sAA + a * a;\n    sBB = sBB + b * b;\n    sAB = sAB + a * b;\n    sAV = sAV + a * v;\n    sBV = sBV + b * v;\n  }\n  let det = sAA * sBB - sAB * sAB;\n  var out: RefitResult;\n  if (abs(det) < 1e-9) {\n    out.valid = false;\n    return out;\n  }\n  let e0f = (sBB * sAV - sAB * sBV) / det;\n  let e1f = (sAA * sBV - sAB * sAV) / det;\n  out.e0 = vec4<i32>(clamp(round(e0f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.e1 = vec4<i32>(clamp(round(e1f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.valid = true;\n  return out;\n}\n\n// -------------------------- Bit-packing helper -------------------------- //\n\nfn write_bits(block: ptr<function, array<u32, 4>>, pos: u32, n_bits: u32, value: u32) {\n  let v = value & ((1u << n_bits) - 1u);\n  let word_lo = pos / 32u;\n  let bit_lo = pos % 32u;\n  let bits_in_lo = min(n_bits, 32u - bit_lo);\n  let mask_lo = ((1u << bits_in_lo) - 1u) << bit_lo;\n  (*block)[word_lo] = ((*block)[word_lo] & ~mask_lo) | ((v << bit_lo) & mask_lo);\n  if (bits_in_lo < n_bits) {\n    let bits_in_hi = n_bits - bits_in_lo;\n    let mask_hi = (1u << bits_in_hi) - 1u;\n    let val_hi = v >> bits_in_lo;\n    (*block)[word_lo + 1u] = ((*block)[word_lo + 1u] & ~mask_hi) | (val_hi & mask_hi);\n  }\n}\n\n// ------------------------------- Entry ---------------------------------- //\n\n@compute @workgroup_size(8, 8, 1)\nfn encode(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if (gid.x >= params.blocks_x || gid.y >= params.blocks_y) {\n    return;\n  }\n\n  let bx = gid.x;\n  let by = gid.y;\n  let block_index = by * params.blocks_x + bx;\n\n  let base   = vec2<i32>(i32(bx) * 4, i32(by) * 4);\n  let max_xy = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  var pixels: array<vec4<i32>, 16>;\n  var lo = vec4<i32>(255);\n  var hi = vec4<i32>(0);\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let p = clamp(base + vec2<i32>(i32(i & 3u), i32(i >> 2u)), vec2<i32>(0, 0), max_xy);\n    let px = to8(textureLoad(src_tex, p, 0));\n    pixels[i] = px;\n    lo = min(lo, px);\n    hi = max(hi, px);\n  }\n\n  var e0: vec4<i32>;\n  var e1: vec4<i32>;\n  var indices: array<u32, 16>;\n\n  if (QUALITY_HIGH != 0u) {\n    let fp = farthest_pair(&pixels);\n    e0 = fp.a;\n    e1 = fp.b;\n    var pal: array<vec4<i32>, 4>;\n    build_palette(e0, e1, &pal);\n    var err = assign_all(&pixels, &pal, &indices);\n    let refit = refit_endpoints(&pixels, &indices);\n    if (refit.valid) {\n      build_palette(refit.e0, refit.e1, &pal);\n      var idx2: array<u32, 16>;\n      let err2 = assign_all(&pixels, &pal, &idx2);\n      if (err2 < err) {\n        e0 = refit.e0;\n        e1 = refit.e1;\n        indices = idx2;\n        err = err2;\n      }\n    }\n  } else {\n    e0 = lo;\n    e1 = hi;\n    let r = proj_assign(&pixels, e0, e1, &indices, true);\n    if (r.valid) {\n      e0 = r.e0;\n      e1 = r.e1;\n      proj_assign(&pixels, e0, e1, &indices, false);\n    }\n  }\n\n  // Endpoint ordering so the decoder doesn't apply blue contraction.\n  if (e0.x + e0.y + e0.z > e1.x + e1.y + e1.z) {\n    let tmp = e0; e0 = e1; e1 = tmp;\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n      indices[k] = 3u - indices[k];\n    }\n  }\n\n  var block: array<u32, 4>;\n  block[0] = 0u; block[1] = 0u; block[2] = 0u; block[3] = 0u;\n  write_bits(&block, 0u,  11u, 0x042u);\n  write_bits(&block, 11u, 2u,  0u);\n  write_bits(&block, 13u, 4u,  12u);\n  write_bits(&block, 17u + 0u * 8u, 8u, u32(e0.x));\n  write_bits(&block, 17u + 1u * 8u, 8u, u32(e1.x));\n  write_bits(&block, 17u + 2u * 8u, 8u, u32(e0.y));\n  write_bits(&block, 17u + 3u * 8u, 8u, u32(e1.y));\n  write_bits(&block, 17u + 4u * 8u, 8u, u32(e0.z));\n  write_bits(&block, 17u + 5u * 8u, 8u, u32(e1.z));\n  write_bits(&block, 17u + 6u * 8u, 8u, u32(e0.w));\n  write_bits(&block, 17u + 7u * 8u, 8u, u32(e1.w));\n  var w3: u32 = 0u;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let w = indices[k] & 0x3u;\n    w3 = w3 | ((w & 1u) << (31u - 2u * k)) | (((w >> 1u) & 1u) << (30u - 2u * k));\n  }\n  block[3] = w3;\n\n  let out = block_index * 4u;\n  dst[out + 0u] = block[0];\n  dst[out + 1u] = block[1];\n  dst[out + 2u] = block[2];\n  dst[out + 3u] = block[3];\n}\n";
+
+// src/astc4x4_fast_f16.wgsl
+var astc4x4_fast_f16_default = '// astc4x4 "fast" encoder \u2014 f16 variant (requires the shader-f16 feature).\n// Identical algorithm to the f32 fast path in astc4x4.wgsl, but the projection +\n// least-squares refit run in f16 ([0,1] domain). On GPUs with 2x f16 throughput\n// (e.g. Apple) this is ~2x faster at the same quality; endpoints are still\n// quantised to exact 8-bit. The host selects this module only when the device\n// reports shader-f16, falling back to astc4x4.wgsl otherwise. "high" never uses this.\n//\nenable f16;\nalias h = f16; alias h4 = vec4<f16>;\nstruct Params { blocks_x: u32, blocks_y: u32, width: u32, height: u32, };\n@group(0) @binding(0) var src_tex: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n@group(0) @binding(2) var<uniform> params: Params;\nstruct Fit { e0: h4, e1: h4, valid: bool };\nfn proj(pix: ptr<function, array<h4,16>>, e0: h4, e1: h4, out_idx: ptr<function, array<u32,16>>, fit: bool) -> Fit {\n  var out: Fit; let dir=e1-e0; let dd=dot(dir,dir);\n  if(dd==h(0.0)){ for(var k:u32=0u;k<16u;k=k+1u){(*out_idx)[k]=0u;} out.valid=false; return out; }\n  let inv=h(3.0)/dd;\n  var sAA=h(0.0); var sBB=h(0.0); var sAB=h(0.0); var sAV=h4(0.0); var sBV=h4(0.0);\n  for(var k:u32=0u;k<16u;k=k+1u){ let v=(*pix)[k]; let s=clamp(floor(dot(v-e0,dir)*inv+h(0.5)),h(0.0),h(3.0)); (*out_idx)[k]=u32(s);\n    if(fit){ let b=s*h(1.0/3.0); let a=h(1.0)-b; sAA=sAA+a*a; sBB=sBB+b*b; sAB=sAB+a*b; sAV=sAV+a*v; sBV=sBV+b*v; } }\n  if(!fit){ out.valid=false; return out; }\n  let det=sAA*sBB-sAB*sAB; if(abs(det)<h(0.0001)){out.valid=false;return out;}\n  out.e0=clamp((sBB*sAV-sAB*sBV)/det,h4(0.0),h4(1.0)); out.e1=clamp((sAA*sBV-sAB*sAV)/det,h4(0.0),h4(1.0)); out.valid=true; return out;\n}\nfn write_bits(block: ptr<function, array<u32,4>>, pos: u32, n_bits: u32, value: u32) {\n  let v=value&((1u<<n_bits)-1u); let wl=pos/32u; let bl=pos%32u; let il=min(n_bits,32u-bl);\n  let ml=((1u<<il)-1u)<<bl; (*block)[wl]=((*block)[wl]&~ml)|((v<<bl)&ml);\n  if(il<n_bits){ let ih=n_bits-il; let mh=(1u<<ih)-1u; (*block)[wl+1u]=((*block)[wl+1u]&~mh)|((v>>il)&mh); }\n}\nfn q8(e: h4) -> vec4<i32> { return vec4<i32>(clamp(floor(e*h(255.0)+h(0.5)), h4(0.0), h4(255.0))); }\n@compute @workgroup_size(8,8,1)\nfn encode(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if(gid.x>=params.blocks_x||gid.y>=params.blocks_y){return;}\n  let bi=gid.y*params.blocks_x+gid.x;\n  let base=vec2<i32>(i32(gid.x)*4,i32(gid.y)*4); let mx=vec2<i32>(i32(params.width)-1,i32(params.height)-1);\n  var pix: array<h4,16>; var lo=h4(1.0); var hi=h4(0.0);\n  for(var i:u32=0u;i<16u;i=i+1u){ let p=clamp(base+vec2<i32>(i32(i&3u),i32(i>>2u)),vec2<i32>(0),mx); let px=h4(textureLoad(src_tex,p,0)); pix[i]=px; lo=min(lo,px); hi=max(hi,px); }\n  var e0=lo; var e1=hi; var indices: array<u32,16>;\n  let r=proj(&pix,e0,e1,&indices,true);\n  if(r.valid){ e0=r.e0; e1=r.e1; proj(&pix,e0,e1,&indices,false); }\n  var E0=q8(e0); var E1=q8(e1);\n  if(E0.x+E0.y+E0.z > E1.x+E1.y+E1.z){ let t=E0; E0=E1; E1=t; for(var k:u32=0u;k<16u;k=k+1u){indices[k]=3u-indices[k];} }\n  var block: array<u32,4>; block[0]=0u;block[1]=0u;block[2]=0u;block[3]=0u;\n  write_bits(&block,0u,11u,0x042u); write_bits(&block,11u,2u,0u); write_bits(&block,13u,4u,12u);\n  write_bits(&block,17u,8u,u32(E0.x)); write_bits(&block,25u,8u,u32(E1.x));\n  write_bits(&block,33u,8u,u32(E0.y)); write_bits(&block,41u,8u,u32(E1.y));\n  write_bits(&block,49u,8u,u32(E0.z)); write_bits(&block,57u,8u,u32(E1.z));\n  write_bits(&block,65u,8u,u32(E0.w)); write_bits(&block,73u,8u,u32(E1.w));\n  var w3:u32=0u; for(var k:u32=0u;k<16u;k=k+1u){ let w=indices[k]&3u; w3=w3|((w&1u)<<(31u-2u*k))|(((w>>1u)&1u)<<(30u-2u*k)); } block[3]=w3;\n  let o=bi*4u; dst[o]=block[0];dst[o+1u]=block[1];dst[o+2u]=block[2];dst[o+3u]=block[3];\n}\n';
 
 // src/ASTC4x4Encoder.ts
 var ASTC4x4Encoder = class extends Encoder {
@@ -398,9 +577,15 @@ var ASTC4x4Encoder = class extends Encoder {
   get supportsSrgb() {
     return true;
   }
+  get supportsQuality() {
+    return true;
+  }
   wgslSource() {
     return astc4x4_default;
   }
+  wgslSourceFastF16() {
+    return astc4x4_fast_f16_default;
+  }
   gpuTextureFormat({ colorSpace }) {
     return colorSpace === "srgb" ? "astc-4x4-unorm-srgb" : "astc-4x4-unorm";
   }
@@ -409,6 +594,373 @@ var ASTC4x4Encoder = class extends Encoder {
   }
 };
 
+// src/webgl/glsl/fullscreen.vert.glsl
+var fullscreen_vert_default = "#version 300 es\n// Fullscreen-triangle vertex shader for the WebGL block encoders.\n//\n// Draws a single oversized triangle covering the viewport from gl_VertexID\n// alone \u2014 no vertex buffers / attributes needed (drawArrays(TRIANGLES, 0, 3)).\n// The encoder sets the viewport to (blocks_x \xD7 blocks_y), so each rasterised\n// fragment corresponds to exactly one 4\xD74 output block.\n//\n//   id 0 -> (-1,-1)   id 1 -> ( 3,-1)   id 2 -> (-1, 3)\n\nvoid main() {\n  vec2 p = vec2(float((gl_VertexID << 1) & 2), float(gl_VertexID & 2));\n  gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);\n}\n";
+
+// src/webgl/webglContext.ts
+var CONTEXT_ATTRS = {
+  alpha: false,
+  antialias: false,
+  depth: false,
+  stencil: false,
+  premultipliedAlpha: false,
+  preserveDrawingBuffer: false,
+  // Encoding is GPU-bound; prefer the discrete GPU when the browser exposes a
+  // choice. Ignored where unsupported.
+  powerPreference: "high-performance"
+};
+function createWebGLContext() {
+  if (typeof OffscreenCanvas !== "undefined") {
+    const gl = new OffscreenCanvas(1, 1).getContext("webgl2", CONTEXT_ATTRS);
+    return gl ?? null;
+  }
+  if (typeof document !== "undefined") {
+    return document.createElement("canvas").getContext("webgl2", CONTEXT_ATTRS);
+  }
+  return null;
+}
+var sharedContext;
+function getSharedWebGLContext() {
+  if (sharedContext === void 0 || sharedContext !== null && sharedContext.isContextLost()) {
+    sharedContext = createWebGLContext();
+  }
+  return sharedContext;
+}
+function isWebGLAvailable() {
+  return getSharedWebGLContext() !== null;
+}
+
+// src/webgl/WebGLBlockEncoder.ts
+function compileShader(gl, type, source, label) {
+  const shader = gl.createShader(type);
+  if (!shader) throw new Error(`${label}: gl.createShader failed`);
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const log = gl.getShaderInfoLog(shader);
+    gl.deleteShader(shader);
+    const kind = type === gl.VERTEX_SHADER ? "vertex" : "fragment";
+    throw new Error(`${label}: ${kind} shader compile failed: ${log}`);
+  }
+  return shader;
+}
+var WebGLBlockEncoder = class {
+  /**
+   * Create an encoder on the shared process-wide context (or a caller-supplied
+   * one). Throws when WebGL2 is unavailable. The `this:` annotation lets
+   * `BC7WebGLEncoder.create()` return `BC7WebGLEncoder`.
+   */
+  static create(gl) {
+    const ctx = gl ?? getSharedWebGLContext();
+    if (!ctx) throw new Error("WebGL2 not available in this environment");
+    return new this({ gl: ctx });
+  }
+  gl;
+  // Set in _buildProgram(), which the constructor calls.
+  _program;
+  _vao;
+  _uSrc = null;
+  _uSrcSize = null;
+  _uFlipY = null;
+  constructor({ gl }) {
+    this.gl = gl;
+    this._buildProgram();
+  }
+  _buildProgram() {
+    const gl = this.gl;
+    const program = gl.createProgram();
+    const vao = gl.createVertexArray();
+    if (!program || !vao) throw new Error(`${this.label}: failed to allocate WebGL program/VAO`);
+    const vert = compileShader(gl, gl.VERTEX_SHADER, fullscreen_vert_default, this.label);
+    const frag = compileShader(gl, gl.FRAGMENT_SHADER, this.fragSource(), this.label);
+    gl.attachShader(program, vert);
+    gl.attachShader(program, frag);
+    gl.linkProgram(program);
+    gl.deleteShader(vert);
+    gl.deleteShader(frag);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+      const log = gl.getProgramInfoLog(program);
+      gl.deleteProgram(program);
+      throw new Error(`${this.label}: WebGL program link failed: ${log}`);
+    }
+    this._program = program;
+    this._vao = vao;
+    this._uSrc = gl.getUniformLocation(program, "uSrc");
+    this._uSrcSize = gl.getUniformLocation(program, "uSrcSize");
+    this._uFlipY = gl.getUniformLocation(program, "uFlipY");
+  }
+  /** Release the GL program + VAO. The shared context itself is left intact. */
+  destroy() {
+    const gl = this.gl;
+    if (gl.isContextLost()) return;
+    gl.deleteProgram(this._program);
+    gl.deleteVertexArray(this._vao);
+  }
+  /**
+   * Upload the source image to a freshly created RGBA8 texture bound on unit 0.
+   * Raw pixel sources (ImageData / mip levels) go through the typed-array
+   * overload; DOM sources (ImageBitmap / canvas / image) through the element
+   * overload. No flip / premultiply / colour conversion — flipY is applied in
+   * the shader so each mip level flips by its own height.
+   */
+  _uploadSource(source, width, height) {
+    const gl = this.gl;
+    const tex = gl.createTexture();
+    if (!tex) throw new Error(`${this.label}: gl.createTexture failed`);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+    gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
+    gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+    const raw = source;
+    if (raw.data && ArrayBuffer.isView(raw.data)) {
+      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, raw.data);
+    } else {
+      gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, gl.RGBA, gl.UNSIGNED_BYTE, source);
+    }
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    return tex;
+  }
+  /**
+   * Encode one image source to raw compressed bytes. `flipY` samples the source
+   * bottom-up (matching Three.js's convention) and is applied in the shader;
+   * the high-level mipped path bakes the flip into level 0 and passes false.
+   */
+  encodeToBytes(source, { flipY = false } = {}) {
+    const gl = this.gl;
+    if (gl.isContextLost()) throw new Error(`${this.label}WebGLEncoder: WebGL context lost`);
+    const width = source.width;
+    const height = source.height;
+    if (!width || !height) {
+      throw new Error(`${this.label}WebGLEncoder: source has no dimensions`);
+    }
+    const paddedWidth = width + 3 & ~3;
+    const paddedHeight = height + 3 & ~3;
+    const blocksX = paddedWidth >> 2;
+    const blocksY = paddedHeight >> 2;
+    const blockCount = blocksX * blocksY;
+    const outByteLen = blockCount * this.bytesPerBlock;
+    const t0 = performance.now();
+    const srcTex = this._uploadSource(source, width, height);
+    const outTex = gl.createTexture();
+    const fbo = gl.createFramebuffer();
+    if (!outTex || !fbo) {
+      gl.deleteTexture(srcTex);
+      if (outTex) gl.deleteTexture(outTex);
+      if (fbo) gl.deleteFramebuffer(fbo);
+      throw new Error(`${this.label}: failed to allocate output texture/framebuffer`);
+    }
+    gl.bindTexture(gl.TEXTURE_2D, outTex);
+    gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA32UI, blocksX, blocksY);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
+    gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, outTex, 0);
+    const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
+    if (status !== gl.FRAMEBUFFER_COMPLETE) {
+      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+      gl.deleteFramebuffer(fbo);
+      gl.deleteTexture(outTex);
+      gl.deleteTexture(srcTex);
+      throw new Error(`${this.label}: integer framebuffer incomplete (0x${status.toString(16)})`);
+    }
+    gl.useProgram(this._program);
+    gl.bindVertexArray(this._vao);
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, srcTex);
+    gl.uniform1i(this._uSrc, 0);
+    gl.uniform2i(this._uSrcSize, width, height);
+    gl.uniform1i(this._uFlipY, flipY ? 1 : 0);
+    gl.disable(gl.BLEND);
+    gl.disable(gl.DEPTH_TEST);
+    gl.disable(gl.SCISSOR_TEST);
+    gl.viewport(0, 0, blocksX, blocksY);
+    gl.drawArrays(gl.TRIANGLES, 0, 3);
+    const words = new Uint32Array(blockCount * 4);
+    gl.readPixels(0, 0, blocksX, blocksY, gl.RGBA_INTEGER, gl.UNSIGNED_INT, words);
+    let data;
+    if (this.bytesPerBlock === 16) {
+      data = new Uint8Array(words.buffer, 0, outByteLen);
+    } else {
+      const packed = new Uint32Array(blockCount * 2);
+      for (let k = 0; k < blockCount; k++) {
+        packed[k * 2] = words[k * 4];
+        packed[k * 2 + 1] = words[k * 4 + 1];
+      }
+      data = new Uint8Array(packed.buffer, 0, outByteLen);
+    }
+    const encodeMs = performance.now() - t0;
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    gl.bindVertexArray(null);
+    gl.deleteFramebuffer(fbo);
+    gl.deleteTexture(outTex);
+    gl.deleteTexture(srcTex);
+    return { width, height, paddedWidth, paddedHeight, data, encodeMs };
+  }
+  /** Wrap pre-encoded levels into a CompressedTexture. Shared with the WebGPU path. */
+  buildMippedTexture(levels, { colorSpace = "srgb" } = {}) {
+    if (levels.length === 0) {
+      throw new Error(`${this.label}WebGLEncoder.buildMippedTexture: no levels provided`);
+    }
+    const effectiveSrgb = colorSpace === "srgb" && this.supportsSrgb;
+    return assembleCompressedTexture(levels, this.threeTextureFormat(), effectiveSrgb);
+  }
+};
+
+// src/webgl/BC1WebGLEncoder.ts
+import { RGBA_S3TC_DXT1_Format as RGBA_S3TC_DXT1_Format2 } from "three";
+
+// src/webgl/glsl/bc1.frag.glsl
+var bc1_frag_default = "#version 300 es\n// BC1 (DXT1) fragment-shader encoder \u2014 WebGL2 port of bc1.wgsl.\n//\n// One fragment per 4\xD74 block. Output is the 8-byte BC1 block as 2 \xD7 u32 in\n// outColor.rg (outColor.ba unused); the encoder reads back RGBA32UI and keeps\n// the low two words per block. Algorithm mirrors bc1.wgsl line-for-line:\n// bbox endpoints, 1/16 inset, RGB565 quantisation, forced 4-colour mode, full\n// L2 index search. See bc1.wgsl for the detailed rationale.\n\nprecision highp float;\nprecision highp int;\n\nuniform sampler2D uSrc;\nuniform ivec2 uSrcSize; // original (unpadded) width, height\nuniform int uFlipY;     // 1 = sample bottom-up (matches Three.js flipY)\n\nlayout(location = 0) out uvec4 outColor;\n\nuint to565(vec3 c) {\n  uint r = uint(clamp(floor(c.r * 31.0 + 0.5), 0.0, 31.0));\n  uint g = uint(clamp(floor(c.g * 63.0 + 0.5), 0.0, 63.0));\n  uint b = uint(clamp(floor(c.b * 31.0 + 0.5), 0.0, 31.0));\n  return (r << 11) | (g << 5) | b;\n}\n\nvec3 from565(uint c) {\n  float r = float((c >> 11) & 31u);\n  float g = float((c >> 5) & 63u);\n  float b = float(c & 31u);\n  float r8 = (r * 527.0 + 23.0) / 256.0;\n  float g8 = (g * 259.0 + 33.0) / 256.0;\n  float b8 = (b * 527.0 + 23.0) / 256.0;\n  return vec3(r8, g8, b8) / 255.0;\n}\n\nvoid main() {\n  ivec2 base = ivec2(gl_FragCoord.xy) * 4;\n  ivec2 maxXY = uSrcSize - ivec2(1);\n\n  vec3 pixels[16];\n  vec3 bbMin = vec3(1.0);\n  vec3 bbMax = vec3(0.0);\n  for (int i = 0; i < 16; i++) {\n    ivec2 p = clamp(base + ivec2(i & 3, i >> 2), ivec2(0), maxXY);\n    int sy = (uFlipY != 0) ? (uSrcSize.y - 1 - p.y) : p.y;\n    vec3 c = texelFetch(uSrc, ivec2(p.x, sy), 0).rgb;\n    pixels[i] = c;\n    bbMin = min(bbMin, c);\n    bbMax = max(bbMax, c);\n  }\n\n  // Inset the bounding box by ~half an RGB565 cell (1/16) to tighten the\n  // quantised palette around the real data range.\n  vec3 inset = (bbMax - bbMin) / 16.0;\n  vec3 hi = clamp(bbMax - inset, vec3(0.0), vec3(1.0));\n  vec3 lo = clamp(bbMin + inset, vec3(0.0), vec3(1.0));\n\n  uint c0 = to565(hi);\n  uint c1 = to565(lo);\n\n  // 4-colour mode requires c0 > c1.\n  if (c0 == c1) {\n    if (c1 > 0u) { c1 = c1 - 1u; } else { c0 = c0 + 1u; }\n  } else if (c0 < c1) {\n    uint tmp = c0; c0 = c1; c1 = tmp;\n  }\n\n  vec3 p0 = from565(c0);\n  vec3 p1 = from565(c1);\n  vec3 p2 = (2.0 * p0 + p1) * (1.0 / 3.0);\n  vec3 p3 = (p0 + 2.0 * p1) * (1.0 / 3.0);\n\n  uint indices = 0u;\n  for (int i = 0; i < 16; i++) {\n    vec3 c = pixels[i];\n    float d0 = dot(c - p0, c - p0);\n    float d1 = dot(c - p1, c - p1);\n    float d2 = dot(c - p2, c - p2);\n    float d3 = dot(c - p3, c - p3);\n\n    float bestD = d0;\n    uint bestI = 0u;\n    if (d1 < bestD) { bestD = d1; bestI = 1u; }\n    if (d2 < bestD) { bestD = d2; bestI = 2u; }\n    if (d3 < bestD) { bestD = d3; bestI = 3u; }\n\n    indices = indices | (bestI << (i * 2));\n  }\n\n  outColor = uvec4(c0 | (c1 << 16), indices, 0u, 0u);\n}\n";
+
+// src/webgl/BC1WebGLEncoder.ts
+var BC1WebGLEncoder = class extends WebGLBlockEncoder {
+  get label() {
+    return "bc1";
+  }
+  get bytesPerBlock() {
+    return 8;
+  }
+  get supportsSrgb() {
+    return true;
+  }
+  fragSource() {
+    return bc1_frag_default;
+  }
+  threeTextureFormat() {
+    return RGBA_S3TC_DXT1_Format2;
+  }
+};
+
+// src/webgl/BC5WebGLEncoder.ts
+import { RED_GREEN_RGTC2_Format as RED_GREEN_RGTC2_Format2 } from "three";
+
+// src/webgl/glsl/bc5.frag.glsl
+var bc5_frag_default = "#version 300 es\n// BC5 (RGTC2) fragment-shader encoder \u2014 WebGL2 port of bc5.wgsl (fast path).\n//\n// One fragment per 4\xD74 block \u2192 16-byte BC5 block as 4 \xD7 u32 in outColor.\n// BC5 = two BC4 halves (R then G). This is the *fast* path only: bbox\n// endpoints + a single full-L2 index assignment per channel, no LSQ refit\n// (the WGSL `QUALITY_HIGH` branch). Always emits 6-interpolation mode\n// (red0 > red1). See bc5.wgsl for the full derivation.\n\nprecision highp float;\nprecision highp int;\n\nuniform sampler2D uSrc;\nuniform ivec2 uSrcSize;\nuniform int uFlipY;\n\nlayout(location = 0) out uvec4 outColor;\n\n// 6-interpolation-mode palette weights: pal[j] = W0_6[j]*r0 + W1_6[j]*r1.\nconst float W0_6[8] = float[8](1.0, 0.0, 6.0 / 7.0, 5.0 / 7.0, 4.0 / 7.0, 3.0 / 7.0, 2.0 / 7.0, 1.0 / 7.0);\nconst float W1_6[8] = float[8](0.0, 1.0, 1.0 / 7.0, 2.0 / 7.0, 3.0 / 7.0, 4.0 / 7.0, 5.0 / 7.0, 6.0 / 7.0);\n\nuint quantize8(float v) {\n  return uint(clamp(floor(v * 255.0 + 0.5), 0.0, 255.0));\n}\n\n// Encode 16 single-channel values into an 8-byte BC4 block (two little-endian\n// u32s). Mirrors encode_bc4() in bc5.wgsl with the refit pass omitted.\nuvec2 encodeBC4(float values[16]) {\n  float vmin = 1.0;\n  float vmax = 0.0;\n  for (int k = 0; k < 16; k++) {\n    vmin = min(vmin, values[k]);\n    vmax = max(vmax, values[k]);\n  }\n  uint r0 = quantize8(vmax);\n  uint r1 = quantize8(vmin);\n  if (r0 == r1) {\n    if (r1 > 0u) { r1 = r1 - 1u; } else { r0 = r0 + 1u; }\n  }\n\n  float pal[8];\n  float r0f = float(r0) / 255.0;\n  float r1f = float(r1) / 255.0;\n  for (int j = 0; j < 8; j++) {\n    pal[j] = W0_6[j] * r0f + W1_6[j] * r1f;\n  }\n\n  uint indices[16];\n  for (int k = 0; k < 16; k++) {\n    float v = values[k];\n    uint bestJ = 0u;\n    float bestD = 1e20;\n    for (int j = 0; j < 8; j++) {\n      float d = pal[j] - v;\n      float d2 = d * d;\n      if (d2 < bestD) { bestD = d2; bestJ = uint(j); }\n    }\n    indices[k] = bestJ;\n  }\n\n  // Pack the 48-bit index field (bytes 2..7) split across two u32 halves.\n  uint idxLo = 0u;\n  uint idxHi = 0u;\n  for (int k = 0; k < 16; k++) {\n    uint bit = 3u * uint(k);\n    uint v = indices[k] & 7u;\n    if (bit + 3u <= 32u) {\n      idxLo = idxLo | (v << bit);\n    } else if (bit >= 32u) {\n      idxHi = idxHi | (v << (bit - 32u));\n    } else {\n      idxLo = idxLo | (v << bit);\n      idxHi = idxHi | (v >> (32u - bit));\n    }\n  }\n\n  uint outLo = r0 | (r1 << 8) | ((idxLo & 0xFFFFu) << 16);\n  uint outHi = (idxLo >> 16) | (idxHi << 16);\n  return uvec2(outLo, outHi);\n}\n\nvoid main() {\n  ivec2 base = ivec2(gl_FragCoord.xy) * 4;\n  ivec2 maxXY = uSrcSize - ivec2(1);\n\n  float rValues[16];\n  float gValues[16];\n  for (int i = 0; i < 16; i++) {\n    ivec2 p = clamp(base + ivec2(i & 3, i >> 2), ivec2(0), maxXY);\n    int sy = (uFlipY != 0) ? (uSrcSize.y - 1 - p.y) : p.y;\n    vec4 c = texelFetch(uSrc, ivec2(p.x, sy), 0);\n    rValues[i] = c.r;\n    gValues[i] = c.g;\n  }\n\n  uvec2 rBlock = encodeBC4(rValues);\n  uvec2 gBlock = encodeBC4(gValues);\n  outColor = uvec4(rBlock.x, rBlock.y, gBlock.x, gBlock.y);\n}\n";
+
+// src/webgl/BC5WebGLEncoder.ts
+var BC5WebGLEncoder = class extends WebGLBlockEncoder {
+  get label() {
+    return "bc5";
+  }
+  get bytesPerBlock() {
+    return 16;
+  }
+  get supportsSrgb() {
+    return false;
+  }
+  fragSource() {
+    return bc5_frag_default;
+  }
+  threeTextureFormat() {
+    return RED_GREEN_RGTC2_Format2;
+  }
+};
+
+// src/webgl/BC7WebGLEncoder.ts
+import { RGBA_BPTC_Format as RGBA_BPTC_Format2 } from "three";
+
+// src/webgl/glsl/bc7.frag.glsl
+var bc7_frag_default = "#version 300 es\n// BC7 (BPTC) mode-6 fragment-shader encoder \u2014 WebGL2 port of bc7.wgsl (fast).\n//\n// One fragment per 4\xD74 block \u2192 16-byte block as 4 \xD7 u32 in outColor. Fast path\n// only: O(N) bbox seed \u2192 endpoints fitted by a single least-squares pass whose\n// normal-equation sums are accumulated during a projection-based index\n// assignment (palette is colinear, so the nearest entry is found by projecting\n// onto the endpoint line \u2014 O(1) per pixel). Mirrors the `QUALITY_HIGH == 0`\n// branch of bc7.wgsl; see that file for the mode-6 bit layout and rationale.\n//\n// Determinism note: the WGSL refit uses round() (half-to-even); here we use\n// floor(x + 0.5) for portability. The two differ only at exact .5 ties, a\n// sub-LSB endpoint nudge that is visually identical.\n\nprecision highp float;\nprecision highp int;\n\nuniform sampler2D uSrc;\nuniform ivec2 uSrcSize;\nuniform int uFlipY;\n\nlayout(location = 0) out uvec4 outColor;\n\n// Per-invocation scratch (mirrors the WGSL function-scope arrays passed by ptr).\nivec4 gPixels[16];\nuint gIdx[16];\n\nstruct QuantPair { ivec4 seven; ivec4 eight; };\nstruct Ep { ivec4 seven; ivec4 eight; uint p; };\nstruct Fit { ivec4 e0; ivec4 e1; bool valid; };\n\nivec4 to8(vec4 v) {\n  return ivec4(clamp(floor(v * 255.0 + 0.5), vec4(0.0), vec4(255.0)));\n}\n\nint dist2(ivec4 a, ivec4 b) {\n  ivec4 d = a - b;\n  ivec4 e = d * d;\n  return e.x + e.y + e.z + e.w;\n}\n\n// Quantize an 8-bit ideal endpoint to (7-bit value, reconstructed 8-bit) under\n// a fixed p-bit, all four channels at once.\nQuantPair quantizeEndpoint(ivec4 ideal8, uint p) {\n  ivec4 q = ivec4(clamp(floor((vec4(ideal8) - float(p)) / 2.0 + 0.5), vec4(0.0), vec4(127.0)));\n  // eff = (q << 1) | p. q*2 is even and p \u2208 {0,1}, so q*2 + p is identical and\n  // avoids any vector-shift-by-scalar portability question.\n  ivec4 eff = q * 2 + ivec4(int(p));\n  return QuantPair(q, eff);\n}\n\n// Endpoint with its chosen p-bit, picked by minimum quantisation error.\nEp pickEp(ivec4 ideal) {\n  QuantPair a = quantizeEndpoint(ideal, 0u);\n  QuantPair b = quantizeEndpoint(ideal, 1u);\n  if (dist2(b.eight, ideal) < dist2(a.eight, ideal)) {\n    return Ep(b.seven, b.eight, 1u);\n  }\n  return Ep(a.seven, a.eight, 0u);\n}\n\n// Projection index assignment over gPixels \u2192 gIdx. When `fit`, accumulate the\n// LSQ normal-equation sums in the same pass and return refitted endpoints.\nFit projAssign(ivec4 pe0, ivec4 pe1, bool fit) {\n  Fit res;\n  res.e0 = ivec4(0);\n  res.e1 = ivec4(0);\n  res.valid = false;\n  ivec4 dir = pe1 - pe0;\n  int dd = dir.x * dir.x + dir.y * dir.y + dir.z * dir.z + dir.w * dir.w;\n  if (dd == 0) {\n    for (int k = 0; k < 16; k++) { gIdx[k] = 0u; }\n    return res;\n  }\n  float inv = 15.0 / float(dd);\n  float sAA = 0.0, sBB = 0.0, sAB = 0.0;\n  vec4 sAV = vec4(0.0), sBV = vec4(0.0);\n  for (int k = 0; k < 16; k++) {\n    ivec4 q = gPixels[k] - pe0;\n    float proj = float(q.x * dir.x + q.y * dir.y + q.z * dir.z + q.w * dir.w) * inv;\n    float s = clamp(floor(proj + 0.5), 0.0, 15.0);\n    gIdx[k] = uint(s);\n    if (fit) {\n      vec4 v = vec4(gPixels[k]);\n      float b = s / 15.0;\n      float a = 1.0 - b;\n      sAA += a * a; sBB += b * b; sAB += a * b; sAV += a * v; sBV += b * v;\n    }\n  }\n  if (!fit) { return res; }\n  float det = sAA * sBB - sAB * sAB;\n  if (abs(det) < 1e-9) { return res; }\n  res.e0 = ivec4(clamp(floor((sBB * sAV - sAB * sBV) / det + 0.5), vec4(0.0), vec4(255.0)));\n  res.e1 = ivec4(clamp(floor((sAA * sBV - sAB * sAV) / det + 0.5), vec4(0.0), vec4(255.0)));\n  res.valid = true;\n  return res;\n}\n\nvoid writeBits(inout uint block[4], uint pos, uint nbits, uint value) {\n  uint v = value & ((1u << nbits) - 1u);\n  uint wordLo = pos / 32u;\n  uint bitLo = pos % 32u;\n  uint bitsInLo = min(nbits, 32u - bitLo);\n  uint maskLo = ((1u << bitsInLo) - 1u) << bitLo;\n  block[wordLo] = (block[wordLo] & ~maskLo) | ((v << bitLo) & maskLo);\n  if (bitsInLo < nbits) {\n    uint bitsInHi = nbits - bitsInLo;\n    uint maskHi = (1u << bitsInHi) - 1u;\n    uint valHi = v >> bitsInLo;\n    block[wordLo + 1u] = (block[wordLo + 1u] & ~maskHi) | (valHi & maskHi);\n  }\n}\n\nvoid main() {\n  ivec2 base = ivec2(gl_FragCoord.xy) * 4;\n  ivec2 maxXY = uSrcSize - ivec2(1);\n\n  ivec4 lo = ivec4(255);\n  ivec4 hi = ivec4(0);\n  for (int i = 0; i < 16; i++) {\n    ivec2 p = clamp(base + ivec2(i & 3, i >> 2), ivec2(0), maxXY);\n    int sy = (uFlipY != 0) ? (uSrcSize.y - 1 - p.y) : p.y;\n    ivec4 px = to8(texelFetch(uSrc, ivec2(p.x, sy), 0));\n    gPixels[i] = px;\n    lo = min(lo, px);\n    hi = max(hi, px);\n  }\n\n  Ep ep0 = pickEp(lo);\n  Ep ep1 = pickEp(hi);\n  Fit r = projAssign(ep0.eight, ep1.eight, true);\n  if (r.valid) {\n    ep0 = pickEp(r.e0);\n    ep1 = pickEp(r.e1);\n    projAssign(ep0.eight, ep1.eight, false);\n  }\n  ivec4 e0_7 = ep0.seven;\n  ivec4 e1_7 = ep1.seven;\n  uint p0 = ep0.p;\n  uint p1 = ep1.p;\n\n  // Anchor rule \u2014 pixel 0's index MSB must be 0; otherwise swap endpoints and\n  // reflect every index (decoded image unchanged).\n  if ((gIdx[0] & 0x8u) != 0u) {\n    ivec4 t = e0_7; e0_7 = e1_7; e1_7 = t;\n    uint tp = p0; p0 = p1; p1 = tp;\n    for (int k = 0; k < 16; k++) { gIdx[k] = 15u - gIdx[k]; }\n  }\n\n  uint block[4];\n  block[0] = 0u; block[1] = 0u; block[2] = 0u; block[3] = 0u;\n  uint pos = 0u;\n  writeBits(block, pos, 7u, 0x40u); pos += 7u;\n  writeBits(block, pos, 7u, uint(e0_7.x)); pos += 7u;\n  writeBits(block, pos, 7u, uint(e1_7.x)); pos += 7u;\n  writeBits(block, pos, 7u, uint(e0_7.y)); pos += 7u;\n  writeBits(block, pos, 7u, uint(e1_7.y)); pos += 7u;\n  writeBits(block, pos, 7u, uint(e0_7.z)); pos += 7u;\n  writeBits(block, pos, 7u, uint(e1_7.z)); pos += 7u;\n  writeBits(block, pos, 7u, uint(e0_7.w)); pos += 7u;\n  writeBits(block, pos, 7u, uint(e1_7.w)); pos += 7u;\n  writeBits(block, pos, 1u, p0); pos += 1u;\n  writeBits(block, pos, 1u, p1); pos += 1u;\n  writeBits(block, pos, 3u, gIdx[0] & 0x7u); pos += 3u;\n  for (int k = 1; k < 16; k++) {\n    writeBits(block, pos, 4u, gIdx[k] & 0xFu);\n    pos += 4u;\n  }\n\n  outColor = uvec4(block[0], block[1], block[2], block[3]);\n}\n";
+
+// src/webgl/BC7WebGLEncoder.ts
+var BC7WebGLEncoder = class extends WebGLBlockEncoder {
+  get label() {
+    return "bc7";
+  }
+  get bytesPerBlock() {
+    return 16;
+  }
+  get supportsSrgb() {
+    return true;
+  }
+  fragSource() {
+    return bc7_frag_default;
+  }
+  threeTextureFormat() {
+    return RGBA_BPTC_Format2;
+  }
+};
+
+// src/webgl/ASTC4x4WebGLEncoder.ts
+import { RGBA_ASTC_4x4_Format as RGBA_ASTC_4x4_Format2 } from "three";
+
+// src/webgl/glsl/astc4x4.frag.glsl
+var astc4x4_frag_default = "#version 300 es\n// ASTC 4\xD74 LDR fragment-shader encoder \u2014 WebGL2 port of astc4x4.wgsl (fast).\n//\n// One fragment per 4\xD74 block \u2192 16-byte block as 4 \xD7 u32 in outColor. Restricted\n// subset: single partition, no dual-plane, CEM 12 (LDR RGBA direct), 4\xD74 weight\n// grid with 2-bit weights (QUANT_4), 8-bit endpoints (QUANT_256). Fast path:\n// bbox seed \u2192 one LSQ refit fused into a projection weight assignment (4 colinear\n// levels). Mirrors the `QUALITY_HIGH == 0` branch of astc4x4.wgsl; see that file\n// for the 128-bit block layout.\n//\n// Determinism note: floor(x + 0.5) replaces WGSL round() for the refit endpoints\n// (sub-LSB difference at exact .5 ties only).\n\nprecision highp float;\nprecision highp int;\n\nuniform sampler2D uSrc;\nuniform ivec2 uSrcSize;\nuniform int uFlipY;\n\nlayout(location = 0) out uvec4 outColor;\n\nivec4 gPixels[16];\nuint gIdx[16];\n\nstruct Fit { ivec4 e0; ivec4 e1; bool valid; };\n\nivec4 to8(vec4 v) {\n  return ivec4(clamp(floor(v * 255.0 + 0.5), vec4(0.0), vec4(255.0)));\n}\n\n// Projection weight assignment over 4 levels (QUANT_4 \u2248 thirds), with the LSQ\n// normal-equation sums accumulated in the same pass for a fused refit.\nFit projAssign(ivec4 pe0, ivec4 pe1, bool fit) {\n  Fit res;\n  res.e0 = ivec4(0);\n  res.e1 = ivec4(0);\n  res.valid = false;\n  ivec4 dir = pe1 - pe0;\n  int dd = dir.x * dir.x + dir.y * dir.y + dir.z * dir.z + dir.w * dir.w;\n  if (dd == 0) {\n    for (int k = 0; k < 16; k++) { gIdx[k] = 0u; }\n    return res;\n  }\n  float inv = 3.0 / float(dd);\n  float sAA = 0.0, sBB = 0.0, sAB = 0.0;\n  vec4 sAV = vec4(0.0), sBV = vec4(0.0);\n  for (int k = 0; k < 16; k++) {\n    ivec4 q = gPixels[k] - pe0;\n    float proj = float(q.x * dir.x + q.y * dir.y + q.z * dir.z + q.w * dir.w) * inv;\n    float s = clamp(floor(proj + 0.5), 0.0, 3.0);\n    gIdx[k] = uint(s);\n    if (fit) {\n      vec4 v = vec4(gPixels[k]);\n      float b = s / 3.0;\n      float a = 1.0 - b;\n      sAA += a * a; sBB += b * b; sAB += a * b; sAV += a * v; sBV += b * v;\n    }\n  }\n  if (!fit) { return res; }\n  float det = sAA * sBB - sAB * sAB;\n  if (abs(det) < 1e-9) { return res; }\n  res.e0 = ivec4(clamp(floor((sBB * sAV - sAB * sBV) / det + 0.5), vec4(0.0), vec4(255.0)));\n  res.e1 = ivec4(clamp(floor((sAA * sBV - sAB * sAV) / det + 0.5), vec4(0.0), vec4(255.0)));\n  res.valid = true;\n  return res;\n}\n\nvoid writeBits(inout uint block[4], uint pos, uint nbits, uint value) {\n  uint v = value & ((1u << nbits) - 1u);\n  uint wordLo = pos / 32u;\n  uint bitLo = pos % 32u;\n  uint bitsInLo = min(nbits, 32u - bitLo);\n  uint maskLo = ((1u << bitsInLo) - 1u) << bitLo;\n  block[wordLo] = (block[wordLo] & ~maskLo) | ((v << bitLo) & maskLo);\n  if (bitsInLo < nbits) {\n    uint bitsInHi = nbits - bitsInLo;\n    uint maskHi = (1u << bitsInHi) - 1u;\n    uint valHi = v >> bitsInLo;\n    block[wordLo + 1u] = (block[wordLo + 1u] & ~maskHi) | (valHi & maskHi);\n  }\n}\n\nvoid main() {\n  ivec2 base = ivec2(gl_FragCoord.xy) * 4;\n  ivec2 maxXY = uSrcSize - ivec2(1);\n\n  ivec4 lo = ivec4(255);\n  ivec4 hi = ivec4(0);\n  for (int i = 0; i < 16; i++) {\n    ivec2 p = clamp(base + ivec2(i & 3, i >> 2), ivec2(0), maxXY);\n    int sy = (uFlipY != 0) ? (uSrcSize.y - 1 - p.y) : p.y;\n    ivec4 px = to8(texelFetch(uSrc, ivec2(p.x, sy), 0));\n    gPixels[i] = px;\n    lo = min(lo, px);\n    hi = max(hi, px);\n  }\n\n  ivec4 e0 = lo;\n  ivec4 e1 = hi;\n  Fit r = projAssign(e0, e1, true);\n  if (r.valid) {\n    e0 = r.e0;\n    e1 = r.e1;\n    projAssign(e0, e1, false);\n  }\n\n  // Endpoint ordering so the decoder doesn't apply blue contraction.\n  if (e0.x + e0.y + e0.z > e1.x + e1.y + e1.z) {\n    ivec4 t = e0; e0 = e1; e1 = t;\n    for (int k = 0; k < 16; k++) { gIdx[k] = 3u - gIdx[k]; }\n  }\n\n  uint block[4];\n  block[0] = 0u; block[1] = 0u; block[2] = 0u; block[3] = 0u;\n  writeBits(block, 0u, 11u, 0x042u);\n  writeBits(block, 11u, 2u, 0u);\n  writeBits(block, 13u, 4u, 12u);\n  writeBits(block, 17u + 0u * 8u, 8u, uint(e0.x));\n  writeBits(block, 17u + 1u * 8u, 8u, uint(e1.x));\n  writeBits(block, 17u + 2u * 8u, 8u, uint(e0.y));\n  writeBits(block, 17u + 3u * 8u, 8u, uint(e1.y));\n  writeBits(block, 17u + 4u * 8u, 8u, uint(e0.z));\n  writeBits(block, 17u + 5u * 8u, 8u, uint(e1.z));\n  writeBits(block, 17u + 6u * 8u, 8u, uint(e0.w));\n  writeBits(block, 17u + 7u * 8u, 8u, uint(e1.w));\n\n  uint w3 = 0u;\n  for (int k = 0; k < 16; k++) {\n    uint w = gIdx[k] & 0x3u;\n    w3 = w3 | ((w & 1u) << (31u - 2u * uint(k))) | (((w >> 1u) & 1u) << (30u - 2u * uint(k)));\n  }\n  block[3] = w3;\n\n  outColor = uvec4(block[0], block[1], block[2], block[3]);\n}\n";
+
+// src/webgl/ASTC4x4WebGLEncoder.ts
+var ASTC4x4WebGLEncoder = class extends WebGLBlockEncoder {
+  get label() {
+    return "astc4x4";
+  }
+  get bytesPerBlock() {
+    return 16;
+  }
+  get supportsSrgb() {
+    return true;
+  }
+  fragSource() {
+    return astc4x4_frag_default;
+  }
+  threeTextureFormat() {
+    return RGBA_ASTC_4x4_Format2;
+  }
+};
+
+// src/webgl/webglCapabilities.ts
+function detectWebGLCapabilities(gl) {
+  if (!gl || typeof gl.getExtension !== "function") {
+    throw new TypeError("detectWebGLCapabilities: a WebGL2 context (or { getExtension }) is required");
+  }
+  const has = (name) => gl.getExtension(name) != null;
+  return {
+    bptc: has("EXT_texture_compression_bptc"),
+    rgtc: has("EXT_texture_compression_rgtc"),
+    s3tc: has("WEBGL_compressed_texture_s3tc"),
+    s3tcSrgb: has("WEBGL_compressed_texture_s3tc_srgb"),
+    astc: has("WEBGL_compressed_texture_astc")
+  };
+}
+
+// src/webgl/selectWebGLFormat.ts
+var NONE = { format: null, encoderClass: null, astcNormalRemap: false };
+function selectWebGLFormat(caps, hint, options = {}) {
+  const { colorSpace = "srgb" } = options;
+  const srgb = colorSpace === "srgb";
+  const astc = (astcNormalRemap) => ({
+    format: srgb ? TextureFormat.ASTC_4x4_SRGB : TextureFormat.ASTC_4x4,
+    encoderClass: ASTC4x4WebGLEncoder,
+    astcNormalRemap
+  });
+  if (hint === "normal") {
+    if (caps.rgtc) return { format: TextureFormat.BC5, encoderClass: BC5WebGLEncoder, astcNormalRemap: false };
+    if (caps.astc) return astc(true);
+    return NONE;
+  }
+  if (caps.bptc) {
+    return {
+      format: srgb ? TextureFormat.BC7_SRGB : TextureFormat.BC7,
+      encoderClass: BC7WebGLEncoder,
+      astcNormalRemap: false
+    };
+  }
+  if (caps.astc) return astc(false);
+  if (hint === "color") {
+    if (srgb && caps.s3tcSrgb) {
+      return { format: TextureFormat.BC1_SRGB, encoderClass: BC1WebGLEncoder, astcNormalRemap: false };
+    }
+    if (!srgb && caps.s3tc) {
+      return { format: TextureFormat.BC1, encoderClass: BC1WebGLEncoder, astcNormalRemap: false };
+    }
+  }
+  return NONE;
+}
+
 // src/selectFormat.ts
 function selectFormat(adapter, hint, options = {}) {
   const { colorSpace = "srgb" } = options;
@@ -436,7 +988,7 @@ function selectFormat(adapter, hint, options = {}) {
 }
 
 // src/compressTexture.ts
-import { LinearFilter as LinearFilter2, LinearSRGBColorSpace as LinearSRGBColorSpace2, RepeatWrapping as RepeatWrapping2, SRGBColorSpace as SRGBColorSpace2, Texture } from "three";
+import { LinearFilter as LinearFilter3, LinearSRGBColorSpace as LinearSRGBColorSpace3, RepeatWrapping as RepeatWrapping3, SRGBColorSpace as SRGBColorSpace3, Texture } from "three";
 
 // src/mipgen.ts
 function generateMipChain(level0) {
@@ -546,10 +1098,10 @@ function mipLevelToImageData(level) {
 }
 function wrapUncompressed(bitmap, srgb, flipY) {
   const tex = new Texture(bitmap);
-  tex.colorSpace = srgb ? SRGBColorSpace2 : LinearSRGBColorSpace2;
-  tex.magFilter = LinearFilter2;
-  tex.minFilter = LinearFilter2;
-  tex.wrapS = tex.wrapT = RepeatWrapping2;
+  tex.colorSpace = srgb ? SRGBColorSpace3 : LinearSRGBColorSpace3;
+  tex.magFilter = LinearFilter3;
+  tex.minFilter = LinearFilter3;
+  tex.wrapS = tex.wrapT = RepeatWrapping3;
   tex.generateMipmaps = false;
   tex.flipY = flipY;
   tex.needsUpdate = true;
@@ -561,129 +1113,165 @@ async function compressTexture(source, options = {}) {
     colorSpace = "srgb",
     flipY = true,
     mipmaps = false,
+    quality = "fast",
     device: providedDevice,
     adapter: providedAdapter
   } = options;
   const srgb = colorSpace === "srgb";
   const bitmap = await sourceToBitmap(source);
-  if (!("gpu" in navigator)) {
-    console.warn("[compressTexture] WebGPU unavailable; returning uncompressed RGBA8.");
-    const tex = wrapUncompressed(bitmap, srgb, flipY);
-    return {
-      texture: tex,
-      format: null,
-      fallbackUncompressed: true,
-      astcNormalRemap: false,
-      width: bitmap.width,
-      height: bitmap.height,
-      mipLevels: 1,
-      encodeMs: 0,
-      destroy: () => {
-        tex.dispose();
+  const viaWebGPU = await encodeViaWebGPU();
+  if (viaWebGPU) return viaWebGPU;
+  const viaWebGL = encodeViaWebGL();
+  if (viaWebGL) return viaWebGL;
+  console.warn(
+    "[compressTexture] No compressed path available (WebGPU and WebGL2 both lack a usable compressed-texture format); returning uncompressed RGBA8."
+  );
+  const tex = wrapUncompressed(bitmap, srgb, flipY);
+  return {
+    texture: tex,
+    format: null,
+    fallbackUncompressed: true,
+    backend: "none",
+    astcNormalRemap: false,
+    width: bitmap.width,
+    height: bitmap.height,
+    mipLevels: 1,
+    encodeMs: 0,
+    destroy: () => {
+      tex.dispose();
+    }
+  };
+  async function encodeViaWebGPU() {
+    if (!("gpu" in navigator)) return null;
+    const adapter = providedAdapter ?? await navigator.gpu.requestAdapter();
+    if (!adapter) return null;
+    const selection = selectFormat(adapter, hint, { colorSpace });
+    if (!selection.format || !selection.encoderClass) return null;
+    let encoder;
+    if (providedDevice) {
+      const EncoderCtor = selection.encoderClass;
+      encoder = new EncoderCtor({ device: providedDevice, adapter, ownsDevice: false });
+    } else {
+      encoder = await selection.encoderClass.create();
+    }
+    try {
+      const needsWriteTexture = needsWriteTextureWorkaround(adapter);
+      if (!mipmaps) {
+        let bytes;
+        if (needsWriteTexture) {
+          const level02 = bitmapToMipLevel(bitmap, flipY);
+          const imageData = mipLevelToImageData(level02);
+          bytes = await encoder.encodeToBytes(imageData, { quality });
+        } else {
+          bytes = await encoder.encodeToBytes(bitmap, { flipY, quality });
+        }
+        const tex3 = encoder.buildMippedTexture([bytes], { colorSpace });
+        return {
+          texture: tex3,
+          format: selection.format,
+          fallbackUncompressed: false,
+          backend: "webgpu",
+          astcNormalRemap: selection.astcNormalRemap,
+          width: bytes.width,
+          height: bytes.height,
+          mipLevels: 1,
+          encodeMs: bytes.encodeMs,
+          destroy: () => {
+            tex3.dispose();
+            encoder.destroy();
+          }
+        };
       }
-    };
-  }
-  const adapter = providedAdapter ?? await navigator.gpu.requestAdapter();
-  if (!adapter) {
-    console.warn("[compressTexture] No WebGPU adapter; returning uncompressed RGBA8.");
-    const tex = wrapUncompressed(bitmap, srgb, flipY);
-    return {
-      texture: tex,
-      format: null,
-      fallbackUncompressed: true,
-      astcNormalRemap: false,
-      width: bitmap.width,
-      height: bitmap.height,
-      mipLevels: 1,
-      encodeMs: 0,
-      destroy: () => {
-        tex.dispose();
+      const level0 = bitmapToMipLevel(bitmap, flipY);
+      const chain = generateMipChain(level0);
+      const encodedLevels = [];
+      let totalEncodeMs = 0;
+      for (const level of chain) {
+        const padded = padToBlockMultiple(level);
+        const imageData = mipLevelToImageData(padded);
+        const bytes = await encoder.encodeToBytes(imageData, { quality });
+        encodedLevels.push(bytes);
+        totalEncodeMs += bytes.encodeMs;
       }
-    };
+      const tex2 = encoder.buildMippedTexture(encodedLevels, { colorSpace });
+      return {
+        texture: tex2,
+        format: selection.format,
+        fallbackUncompressed: false,
+        backend: "webgpu",
+        astcNormalRemap: selection.astcNormalRemap,
+        width: level0.width,
+        height: level0.height,
+        mipLevels: encodedLevels.length,
+        encodeMs: totalEncodeMs,
+        destroy: () => {
+          tex2.dispose();
+          encoder.destroy();
+        }
+      };
+    } catch (e) {
+      encoder.destroy();
+      throw e;
+    }
   }
-  const selection = selectFormat(adapter, hint, { colorSpace });
-  if (!selection.format || !selection.encoderClass) {
-    console.warn(
-      "[compressTexture] Adapter reports neither texture-compression-bc nor texture-compression-astc; returning uncompressed RGBA8."
-    );
-    const tex = wrapUncompressed(bitmap, srgb, flipY);
-    return {
-      texture: tex,
-      format: null,
-      fallbackUncompressed: true,
-      astcNormalRemap: false,
-      width: bitmap.width,
-      height: bitmap.height,
-      mipLevels: 1,
-      encodeMs: 0,
-      destroy: () => {
-        tex.dispose();
+  function encodeViaWebGL() {
+    const gl = getSharedWebGLContext();
+    if (!gl) return null;
+    const caps = detectWebGLCapabilities(gl);
+    const selection = selectWebGLFormat(caps, hint, { colorSpace });
+    if (!selection.format || !selection.encoderClass) return null;
+    const encoder = selection.encoderClass.create(gl);
+    try {
+      if (!mipmaps) {
+        const bytes = encoder.encodeToBytes(bitmap, { flipY });
+        const tex3 = encoder.buildMippedTexture([bytes], { colorSpace });
+        return {
+          texture: tex3,
+          format: selection.format,
+          fallbackUncompressed: false,
+          backend: "webgl",
+          astcNormalRemap: selection.astcNormalRemap,
+          width: bytes.width,
+          height: bytes.height,
+          mipLevels: 1,
+          encodeMs: bytes.encodeMs,
+          destroy: () => {
+            tex3.dispose();
+            encoder.destroy();
+          }
+        };
       }
-    };
-  }
-  let encoder;
-  if (providedDevice) {
-    const EncoderCtor = selection.encoderClass;
-    encoder = new EncoderCtor({ device: providedDevice, adapter, ownsDevice: false });
-  } else {
-    encoder = await selection.encoderClass.create();
-  }
-  try {
-    const needsWriteTexture = needsWriteTextureWorkaround(adapter);
-    if (!mipmaps) {
-      let bytes;
-      if (needsWriteTexture) {
-        const level02 = bitmapToMipLevel(bitmap, flipY);
-        const imageData = mipLevelToImageData(level02);
-        bytes = await encoder.encodeToBytes(imageData);
-      } else {
-        bytes = await encoder.encodeToBytes(bitmap, { flipY });
+      const level0 = bitmapToMipLevel(bitmap, flipY);
+      const chain = generateMipChain(level0);
+      const encodedLevels = [];
+      let totalEncodeMs = 0;
+      for (const level of chain) {
+        const padded = padToBlockMultiple(level);
+        const bytes = encoder.encodeToBytes(padded);
+        encodedLevels.push(bytes);
+        totalEncodeMs += bytes.encodeMs;
       }
-      const tex2 = encoder.buildMippedTexture([bytes], { colorSpace });
+      const tex2 = encoder.buildMippedTexture(encodedLevels, { colorSpace });
       return {
         texture: tex2,
         format: selection.format,
         fallbackUncompressed: false,
+        backend: "webgl",
         astcNormalRemap: selection.astcNormalRemap,
-        width: bytes.width,
-        height: bytes.height,
-        mipLevels: 1,
-        encodeMs: bytes.encodeMs,
+        width: level0.width,
+        height: level0.height,
+        mipLevels: encodedLevels.length,
+        encodeMs: totalEncodeMs,
         destroy: () => {
           tex2.dispose();
           encoder.destroy();
         }
       };
+    } catch (e) {
+      encoder.destroy();
+      console.warn("[compressTexture] WebGL fallback encode failed; returning uncompressed RGBA8.", e);
+      return null;
     }
-    const level0 = bitmapToMipLevel(bitmap, flipY);
-    const chain = generateMipChain(level0);
-    const encodedLevels = [];
-    let totalEncodeMs = 0;
-    for (const level of chain) {
-      const padded = padToBlockMultiple(level);
-      const imageData = mipLevelToImageData(padded);
-      const bytes = await encoder.encodeToBytes(imageData);
-      encodedLevels.push(bytes);
-      totalEncodeMs += bytes.encodeMs;
-    }
-    const tex = encoder.buildMippedTexture(encodedLevels, { colorSpace });
-    return {
-      texture: tex,
-      format: selection.format,
-      fallbackUncompressed: false,
-      astcNormalRemap: selection.astcNormalRemap,
-      width: level0.width,
-      height: level0.height,
-      mipLevels: encodedLevels.length,
-      encodeMs: totalEncodeMs,
-      destroy: () => {
-        tex.dispose();
-        encoder.destroy();
-      }
-    };
-  } catch (e) {
-    encoder.destroy();
-    throw e;
   }
 }
 
@@ -698,6 +1286,8 @@ var GputexLoader = class extends Loader {
   flipY = true;
   /** Generate + encode a full mip chain. Default false. */
   mipmaps = false;
+  /** Encode quality / speed trade-off. Default 'fast' (~2–4× faster, ≤0.36 dB). */
+  quality = "fast";
   /**
    * Optional pre-existing WebGPU device. Reusing the renderer's device
    * avoids spinning up a second WebGPU context for encoding.
@@ -724,6 +1314,7 @@ var GputexLoader = class extends Loader {
       colorSpace: this.colorSpace,
       flipY: this.flipY,
       mipmaps: this.mipmaps,
+      quality: this.quality,
       device: this.device,
       adapter: this.adapter
     }).then(
@@ -733,6 +1324,7 @@ var GputexLoader = class extends Loader {
         result.texture.userData.gputex = {
           format: result.format,
           fallbackUncompressed: result.fallbackUncompressed,
+          backend: result.backend,
           astcNormalRemap: result.astcNormalRemap,
           width: result.width,
           height: result.height,
@@ -753,16 +1345,26 @@ var GputexLoader = class extends Loader {
 };
 export {
   ASTC4x4Encoder,
+  ASTC4x4WebGLEncoder,
   BC1Encoder,
+  BC1WebGLEncoder,
   BC5Encoder,
+  BC5WebGLEncoder,
   BC7Encoder,
+  BC7WebGLEncoder,
   Encoder,
   GputexLoader,
   TextureFormat,
+  WebGLBlockEncoder,
   WebGPUFeature,
   compressTexture,
+  createWebGLContext,
   detectCapabilities,
+  detectWebGLCapabilities,
   generateMipChain,
+  getSharedWebGLContext,
+  isWebGLAvailable,
   padToBlockMultiple,
-  selectFormat
+  selectFormat,
+  selectWebGLFormat
 };