gputex 0.3.4 → 0.5.0

package/dist/index.js

@@ -6,7 +6,9 @@ var TextureFormat = {
   BC7: "BC7",
   BC7_SRGB: "BC7_SRGB",
   ASTC_4x4: "ASTC_4x4",
-  ASTC_4x4_SRGB: "ASTC_4x4_SRGB"
+  ASTC_4x4_SRGB: "ASTC_4x4_SRGB",
+  ETC2_RGB8: "ETC2_RGB8",
+  ETC2_RGB8_SRGB: "ETC2_RGB8_SRGB"
 };
 var WebGPUFeature = {
   BC: "texture-compression-bc",
@@ -24,8 +26,7 @@ var FORMATS_BY_FEATURE = {
     TextureFormat.BC7_SRGB
   ],
   [WebGPUFeature.ASTC]: [TextureFormat.ASTC_4x4, TextureFormat.ASTC_4x4_SRGB],
-  // ETC2 has no encoder yet — explicit empty keeps exhaustiveness check.
-  [WebGPUFeature.ETC2]: []
+  [WebGPUFeature.ETC2]: [TextureFormat.ETC2_RGB8, TextureFormat.ETC2_RGB8_SRGB]
 };
 function detectCapabilities(adapter) {
   if (!adapter || !adapter.features || typeof adapter.features.has !== "function") {
@@ -38,12 +39,23 @@ function detectCapabilities(adapter) {
   const supportedFormats = [];
   if (bc) supportedFormats.push(...FORMATS_BY_FEATURE[WebGPUFeature.BC]);
   if (astc) supportedFormats.push(...FORMATS_BY_FEATURE[WebGPUFeature.ASTC]);
+  if (etc2) supportedFormats.push(...FORMATS_BY_FEATURE[WebGPUFeature.ETC2]);
   return { bc, astc, etc2, supportedFormats };
 }
 
 // src/workarounds.ts
-function uploadSourceTexture(device, srcTex, source, width, height, flipY, useWriteTexture) {
-  if (useWriteTexture && source instanceof ImageData) {
+function uploadSourceTexture(device, srcTex, source, width, height, flipY) {
+  if (source instanceof ImageData && !flipY) {
+    if (srcTex.format === "rg8unorm") {
+      const rgba = source.data;
+      const rg = new Uint8Array(width * height * 2);
+      for (let i = 0; i < width * height; i++) {
+        rg[i * 2] = rgba[i * 4];
+        rg[i * 2 + 1] = rgba[i * 4 + 1];
+      }
+      device.queue.writeTexture({ texture: srcTex }, rg, { bytesPerRow: width * 2 }, [width, height, 1]);
+      return;
+    }
     device.queue.writeTexture({ texture: srcTex }, source.data, { bytesPerRow: width * 4 }, [width, height, 1]);
   } else {
     device.queue.copyExternalImageToTexture({ source, flipY }, { texture: srcTex }, [
@@ -55,6 +67,7 @@ function uploadSourceTexture(device, srcTex, source, width, height, flipY, useWr
 }
 
 // src/Encoder.ts
+var CHAIN_ALIGN = 256;
 var Encoder = class {
   /**
    * Subclasses set this to the WebGPU feature string the output texture
@@ -95,20 +108,16 @@ var Encoder = class {
   adapter;
   ownsDevice;
   disableF16;
-  // f32 module — created lazily by `_ensureModule()`: when the f16 fast
-  // module exists it serves the default path, so parsing/validating the
-  // (larger, dual-quality) f32 source is deferred until 'high' or the
-  // forced-f32 fallback is actually requested. Halves encoder construction
-  // cost on f16 hardware.
-  _module = null;
-  // 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();
+  // The single compute pipeline: built from the f16 module when the device
+  // supports shader-f16 and the subclass provides an f16 source, from the
+  // f32 module otherwise. Both implement the same algorithm. Created with
+  // `createComputePipelineAsync` so shader compilation overlaps whatever
+  // follows construction (image decode, first upload) instead of stalling
+  // the first dispatch; encodes await readiness.
+  _pipelineReady;
+  // Source-preparation pipeline, when the subclass declares one (ETC2's
+  // packed-luma + quadrant-average split). Null for direct-source encoders.
+  _prepPipelineReady = null;
   // -------------------------------------------------------------------- //
   // Per-encoder GPU resource cache. Creating the source texture, output/
   // staging buffers and bind group on every encode costs ~1ms of host time
@@ -118,17 +127,45 @@ var Encoder = class {
   // these; concurrent encodes on the same encoder see `_resourcesBusy` and
   // fall back to transient resources, keeping the API contract unchanged.
   // Buffers are grow-only, the texture is recreated on size change, and the
-  // bind group is cached per pipeline (with `layout: 'auto'` each pipeline
-  // has its own layout) until any bound resource is recreated.
+  // bind group is kept until any bound resource is recreated.
   _cachedSrcTex = null;
   _cachedSrcW = 0;
   _cachedSrcH = 0;
+  // Upload memoisation: the ImageBitmap whose pixels the cached source
+  // texture currently holds. ImageBitmaps are immutable, so encoding the
+  // same bitmap again (benchmark loops, quality-ladder re-encodes, format
+  // A/B) can skip the copyExternalImageToTexture entirely — at 4096² that
+  // upload is ~9 ms, dominating the whole encode. Mutable sources
+  // (ImageData, canvases, video) are never memoised.
+  _cachedSrcSource = null;
+  _cachedSrcFlipY = false;
   _cachedDst = null;
   _cachedStaging = null;
   _cachedParams = null;
   _lastParams = null;
-  _bindGroupCache = /* @__PURE__ */ new Map();
+  _cachedBindGroup = null;
+  _cachedPrepPlanes = null;
+  _cachedPrepBindGroup = null;
   _resourcesBusy = false;
+  /** Set when the active shader declares a @binding(3) sampler (the BC5
+   * kernels read texels through textureGather + clamp-to-edge). */
+  _usesSampler = false;
+  _sampler = null;
+  // Mip-chain cache — the `encodeMipChainToBytes()` counterpart of the
+  // single-shot cache above: per-level source textures + bind groups keyed
+  // on the exact level-size signature, one params buffer holding every
+  // level's uniforms at 256-byte offsets, grow-only output/staging buffers.
+  // Pays off when consecutive chains share dimensions (bulk-loading
+  // same-sized textures through `compressTexture()`).
+  _chainSig = null;
+  _chainTextures = [];
+  _chainPrepPlanes = [];
+  _chainPrepBindGroups = [];
+  _chainParams = null;
+  _chainBindGroups = [];
+  _chainDst = null;
+  _chainStaging = null;
+  _chainBusy = false;
   constructor({ device, adapter, ownsDevice = false, disableF16 = false }) {
     this.device = device;
     this.adapter = adapter;
@@ -138,77 +175,71 @@ var Encoder = class {
   }
   _buildPipeline() {
     const device = this.device;
-    if (this._useF16) {
-      this._moduleF16 = device.createShaderModule({
-        label: `${this.label}-encoder-f16`,
-        code: this.wgslSourceFastF16()
-      });
-    } else {
-      this._ensureModule();
-    }
-    if (this.supportsQuality) {
-      this._pipeline = this._getPipeline("fast");
-    } else {
-      this._pipeline = device.createComputePipeline({
-        label: `${this.label}-encoder-pipeline`,
+    const useF16 = this._useF16;
+    const code = useF16 ? this.wgslSourceFastF16() : this.wgslSource();
+    this._usesSampler = /@binding\(3\)\s+var\s+\w+\s*:\s*sampler\s*;/.test(code);
+    const module = device.createShaderModule({
+      label: `${this.label}-encoder${useF16 ? "-f16" : ""}`,
+      code
+    });
+    const constants = this.pipelineConstants();
+    this._pipelineReady = device.createComputePipelineAsync({
+      label: `${this.label}-encoder-pipeline${useF16 ? "-f16" : ""}`,
+      layout: "auto",
+      compute: { module, entryPoint: "encode", ...constants ? { constants } : {} }
+    });
+    const prepCode = this.wgslPrepSource();
+    if (prepCode) {
+      const prepModule = device.createShaderModule({ label: `${this.label}-prep`, code: prepCode });
+      this._prepPipelineReady = device.createComputePipelineAsync({
+        label: `${this.label}-prep-pipeline`,
         layout: "auto",
-        compute: { module: this._ensureModule(), entryPoint: "encode" }
+        compute: { module: prepModule, entryPoint: "encode" }
       });
-    }
-  }
-  /** The f32 module, parsed on first use (see `_module`). */
-  _ensureModule() {
-    if (!this._module) {
-      this._module = this.device.createShaderModule({
-        label: `${this.label}-encoder`,
-        code: this.wgslSource()
+      this._prepPipelineReady.catch(() => {
       });
     }
-    return this._module;
-  }
-  /**
-   * 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._ensureModule(),
-        entryPoint: "encode",
-        constants: { QUALITY_HIGH: quality === "high" ? 1 : 0 }
-      }
+    this._pipelineReady.catch(() => {
     });
-    this._pipelineCache.set(quality, pipeline);
-    return pipeline;
   }
   destroy() {
     this._cachedSrcTex?.destroy();
+    if (this._cachedPrepPlanes) for (const t of this._cachedPrepPlanes) t.destroy();
+    this._cachedPrepPlanes = null;
+    this._cachedPrepBindGroup = null;
     this._cachedDst?.destroy();
     this._cachedStaging?.destroy();
     this._cachedParams?.destroy();
     this._cachedSrcTex = null;
+    this._cachedSrcSource = null;
     this._cachedDst = null;
     this._cachedStaging = null;
     this._cachedParams = null;
-    this._bindGroupCache.clear();
+    this._cachedBindGroup = null;
+    for (const tex of this._chainTextures) tex.destroy();
+    this._chainTextures = [];
+    for (const planes of this._chainPrepPlanes) for (const t of planes) t.destroy();
+    this._chainPrepPlanes = [];
+    this._chainPrepBindGroups = [];
+    this._chainParams?.destroy();
+    this._chainDst?.destroy();
+    this._chainStaging?.destroy();
+    this._chainParams = null;
+    this._chainDst = null;
+    this._chainStaging = null;
+    this._chainBindGroups = [];
+    this._chainSig = null;
     if (this.ownsDevice) this.device.destroy();
   }
+  /**
+   * Pipeline-creation override constants for the active shader, or
+   * undefined for none. Subclasses expose quality/behaviour toggles this
+   * way so the OFF state is dead-coded by the shader compiler instead of
+   * branched at runtime.
+   */
+  pipelineConstants() {
+    return void 0;
+  }
   /** WGSL `@workgroup_size` dimensions. Default 8×8×1. */
   get workgroupSize() {
     return [8, 8, 1];
@@ -218,25 +249,76 @@ var Encoder = class {
     return true;
   }
   /**
-   * Whether the shader declares a `QUALITY_HIGH` pipeline-overridable constant
-   * (i.e. has distinct fast/high search paths). Default false (e.g. a stub or a
-   * format with a single path); BC1/BC5/BC7/ASTC override it to true.
+   * Format of the single-shot source texture the encode pass samples.
+   * Encoders that read only a channel subset can narrow it to cut DRAM
+   * traffic on the bandwidth-bound compute pass (BC5 reads rg8unorm — half
+   * the bytes of rgba8). Must be valid as a copyExternalImageToTexture
+   * destination and renderable. Chain encodes keep rgba8unorm regardless
+   * (their inputs are RGBA mip levels / texture views); the WGSL is
+   * format-agnostic (`texture_2d<f32>`), so mixing is byte-identical.
    */
-  get supportsQuality() {
-    return false;
+  get srcTextureFormat() {
+    return "rgba8unorm";
   }
   /**
-   * 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.
+   * Optional f16 WGSL variant. Used only when the device reports the
+   * `shader-f16` feature; the format's f32 `wgslSource()` is the automatic
+   * fallback. Returns null when there's no f16 variant.
    */
   wgslSourceFastF16() {
     return null;
   }
-  /** Whether the f16 fast path is both available and supported on this device. */
+  /** Whether the f16 shader is both available and supported on this device. */
   get _useF16() {
     return !this.disableF16 && this.wgslSourceFastF16() !== null && this.device.features.has("shader-f16");
   }
+  // ------------------------------------------------------------------ //
+  // Optional source-preparation pass (null/empty for direct encoders). //
+  // A subclass returning a prep shader gets a two-pass encode: the prep
+  // pass reads the RGBA8 source (binding 0) and writes the prepared
+  // planes as storage textures (plane 0 at binding 1, plane 1 at
+  // binding 3, params at binding 2); the encode pass then reads plane 0
+  // at binding 0 and plane 1 at binding 3 instead of the source.
+  // ------------------------------------------------------------------ //
+  /** WGSL for the preparation pass, or null when the encoder reads the
+   *  RGBA8 source directly. */
+  wgslPrepSource() {
+    return null;
+  }
+  /** Formats and sizes of the prepared planes for a padded source size. */
+  prepPlanes(paddedWidth, paddedHeight) {
+    void paddedWidth;
+    void paddedHeight;
+    return [];
+  }
+  /** Workgroup counts for the prep dispatch. */
+  prepDispatch(blocksX, blocksY) {
+    return [blocksX, blocksY];
+  }
+  /** Create the prepared-plane textures for one padded source size. */
+  _createPrepPlanes(paddedWidth, paddedHeight) {
+    return this.prepPlanes(paddedWidth, paddedHeight).map(
+      (p, i) => this.device.createTexture({
+        label: `${this.label}-prep-${i}`,
+        size: [p.width, p.height, 1],
+        format: p.format,
+        usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING
+      })
+    );
+  }
+  /** Bind group for one prep dispatch. */
+  _createPrepBindGroup(prepPipeline, srcView, planes, params, paramsOffset = 0) {
+    return this.device.createBindGroup({
+      label: `${this.label}-prep-bg`,
+      layout: prepPipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: srcView },
+        { binding: 1, resource: planes[0].createView() },
+        { binding: 2, resource: { buffer: params, offset: paramsOffset, size: 16 } },
+        { binding: 3, resource: planes[1].createView() }
+      ]
+    });
+  }
   /**
    * True if the device reports the feature the output texture needs.
    * The encoder itself only writes to a storage buffer, so this is about
@@ -256,11 +338,7 @@ var Encoder = class {
    * bytes into a `CompressedTexture`; callers targeting another engine feed
    * `data` into that engine's compressed-texture upload directly.
    */
-  async encodeToBytes(source, {
-    flipY = false,
-    quality = "fast",
-    withGpuTime = false
-  } = {}) {
+  async encodeToBytes(source, { flipY = false, withGpuTime = false } = {}) {
     const device = this.device;
     const width = source.width;
     const height = source.height;
@@ -273,12 +351,15 @@ var Encoder = class {
     const blocksY = paddedHeight >> 2;
     const blockCount = blocksX * blocksY;
     const outByteLen = blockCount * this.bytesPerBlock;
+    const pipeline = await this._pipelineReady;
+    const prepPipeline = this._prepPipelineReady ? await this._prepPipelineReady : null;
     const useCache = !this._resourcesBusy;
     if (useCache) this._resourcesBusy = true;
     let srcTex;
     let dstBuffer;
     let paramsBuffer;
     let staging;
+    let transientPrepPlanes = null;
     try {
       let srcTexIsNew = true;
       if (useCache && this._cachedSrcTex && this._cachedSrcW === paddedWidth && this._cachedSrcH === paddedHeight) {
@@ -288,7 +369,7 @@ var Encoder = class {
         srcTex = device.createTexture({
           label: `${this.label}-src`,
           size: [paddedWidth, paddedHeight, 1],
-          format: "rgba8unorm",
+          format: this.srcTextureFormat,
           // RENDER_ATTACHMENT is required by copyExternalImageToTexture
           // (internally a blit) even though we never render into this texture.
           usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT
@@ -300,7 +381,31 @@ var Encoder = class {
           this._cachedSrcH = paddedHeight;
         }
       }
-      uploadSourceTexture(device, srcTex, source, width, height, flipY, source instanceof ImageData);
+      let prepPlanes = null;
+      let prepPlanesNew = false;
+      if (prepPipeline) {
+        if (useCache && !srcTexIsNew && this._cachedPrepPlanes) {
+          prepPlanes = this._cachedPrepPlanes;
+        } else {
+          prepPlanes = this._createPrepPlanes(paddedWidth, paddedHeight);
+          prepPlanesNew = true;
+          if (useCache) {
+            if (this._cachedPrepPlanes) for (const t of this._cachedPrepPlanes) t.destroy();
+            this._cachedPrepPlanes = prepPlanes;
+            this._cachedPrepBindGroup = null;
+          } else {
+            transientPrepPlanes = prepPlanes;
+          }
+        }
+      }
+      const uploadSkippable = !srcTexIsNew && source instanceof ImageBitmap && this._cachedSrcSource === source && this._cachedSrcFlipY === flipY;
+      if (!uploadSkippable) {
+        uploadSourceTexture(device, srcTex, source, width, height, flipY);
+      }
+      if (useCache) {
+        this._cachedSrcSource = source instanceof ImageBitmap ? source : null;
+        this._cachedSrcFlipY = flipY;
+      }
       let dstIsNew = true;
       if (useCache && this._cachedDst && this._cachedDst.size >= outByteLen) {
         dstBuffer = this._cachedDst;
@@ -352,63 +457,74 @@ var Encoder = class {
         });
         device.queue.writeBuffer(paramsBuffer, 0, new Uint32Array([blocksX, blocksY, width, height]));
       }
-      const pipeline = this._getPipeline(quality);
-      if (useCache && (srcTexIsNew || dstIsNew)) this._bindGroupCache.clear();
-      let bindGroup = useCache ? this._bindGroupCache.get(pipeline) : void 0;
+      if (useCache && (srcTexIsNew || dstIsNew || prepPlanesNew)) this._cachedBindGroup = null;
+      let bindGroup = useCache ? this._cachedBindGroup : null;
       if (!bindGroup) {
+        const entries = [
+          { binding: 0, resource: prepPlanes ? prepPlanes[0].createView() : srcTex.createView() },
+          { binding: 1, resource: { buffer: dstBuffer } },
+          { binding: 2, resource: { buffer: paramsBuffer } }
+        ];
+        if (prepPlanes) {
+          entries.push({ binding: 3, resource: prepPlanes[1].createView() });
+        } else if (this._usesSampler) {
+          this._sampler ??= device.createSampler({
+            label: `${this.label}-clamp-sampler`,
+            addressModeU: "clamp-to-edge",
+            addressModeV: "clamp-to-edge"
+          });
+          entries.push({ binding: 3, resource: this._sampler });
+        }
         bindGroup = device.createBindGroup({
           label: `${this.label}-bg`,
           layout: pipeline.getBindGroupLayout(0),
-          entries: [
-            { binding: 0, resource: srcTex.createView() },
-            { binding: 1, resource: { buffer: dstBuffer } },
-            { binding: 2, resource: { buffer: paramsBuffer } }
-          ]
+          entries
         });
-        if (useCache) this._bindGroupCache.set(pipeline, bindGroup);
+        if (useCache) this._cachedBindGroup = bindGroup;
       }
-      const useTimestamps = withGpuTime && device.features.has("timestamp-query");
-      const querySet = useTimestamps ? device.createQuerySet({ type: "timestamp", count: 2 }) : null;
-      const queryBuffer = useTimestamps ? device.createBuffer({
-        label: `${this.label}-ts-resolve`,
-        size: 16,
-        usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC
-      }) : null;
+      let prepBindGroup = useCache && !prepPlanesNew && !srcTexIsNew ? this._cachedPrepBindGroup : null;
+      if (prepPipeline && prepPlanes && !prepBindGroup) {
+        prepBindGroup = this._createPrepBindGroup(prepPipeline, srcTex.createView(), prepPlanes, paramsBuffer);
+        if (useCache) this._cachedPrepBindGroup = prepBindGroup;
+      }
+      const timing = withGpuTime ? this._createTiming() : null;
       const [wgX, wgY] = this.workgroupSize;
       const t0 = performance.now();
       const enc = device.createCommandEncoder({ label: `${this.label}-encode` });
+      if (prepPipeline && prepBindGroup) {
+        const prepPass = enc.beginComputePass(
+          timing ? { timestampWrites: { querySet: timing.querySet, beginningOfPassWriteIndex: 0 } } : void 0
+        );
+        prepPass.setPipeline(prepPipeline);
+        prepPass.setBindGroup(0, prepBindGroup);
+        const [px, py] = this.prepDispatch(blocksX, blocksY);
+        prepPass.dispatchWorkgroups(Math.ceil(px / wgX), Math.ceil(py / wgY), 1);
+        prepPass.end();
+      }
       const pass = enc.beginComputePass(
-        querySet ? { timestampWrites: { querySet, beginningOfPassWriteIndex: 0, endOfPassWriteIndex: 1 } } : void 0
+        timing ? {
+          timestampWrites: {
+            querySet: timing.querySet,
+            ...prepPipeline ? {} : { beginningOfPassWriteIndex: 0 },
+            endOfPassWriteIndex: 1
+          }
+        } : void 0
       );
       pass.setPipeline(pipeline);
       pass.setBindGroup(0, bindGroup);
       pass.dispatchWorkgroups(Math.ceil(blocksX / wgX), Math.ceil(blocksY / wgY), 1);
       pass.end();
-      if (querySet && queryBuffer) enc.resolveQuerySet(querySet, 0, 2, queryBuffer, 0);
       enc.copyBufferToBuffer(dstBuffer, 0, staging, 0, outByteLen);
-      const tsStaging = querySet && queryBuffer ? device.createBuffer({
-        label: `${this.label}-ts-staging`,
-        size: 16,
-        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
-      }) : null;
-      if (tsStaging && queryBuffer) enc.copyBufferToBuffer(queryBuffer, 0, tsStaging, 0, 16);
+      if (timing) {
+        enc.resolveQuerySet(timing.querySet, 0, 2, timing.resolve, 0);
+        enc.copyBufferToBuffer(timing.resolve, 0, timing.staging, 0, 16);
+      }
       device.queue.submit([enc.finish()]);
       await staging.mapAsync(GPUMapMode.READ, 0, outByteLen);
       const data = new Uint8Array(staging.getMappedRange(0, outByteLen).slice(0));
       staging.unmap();
       const encodeMs = performance.now() - t0;
-      let gpuMs;
-      if (tsStaging) {
-        await tsStaging.mapAsync(GPUMapMode.READ);
-        const [begin, end] = new BigUint64Array(tsStaging.getMappedRange().slice(0));
-        tsStaging.unmap();
-        tsStaging.destroy();
-        if (end !== void 0 && begin !== void 0 && end > begin) {
-          gpuMs = Number(end - begin) / 1e6;
-        }
-      }
-      querySet?.destroy();
-      queryBuffer?.destroy();
+      const gpuMs = timing ? await this._readTimingMs(timing) : void 0;
       return { width, height, paddedWidth, paddedHeight, data, encodeMs, gpuMs };
     } finally {
       if (useCache) {
@@ -418,13 +534,441 @@ var Encoder = class {
         dstBuffer?.destroy();
         staging?.destroy();
         paramsBuffer?.destroy();
+        if (transientPrepPlanes) for (const t of transientPrepPlanes) t.destroy();
+      }
+    }
+  }
+  // ------------------------------------------------------------------ //
+  // Whole-chain encode — every level in one submission.                //
+  // ------------------------------------------------------------------ //
+  /**
+   * Encode a whole mip chain in ONE GPU submission. A per-level
+   * `encodeToBytes()` loop costs a full CPU↔GPU round trip per level (a
+   * 1024² chain is 11 levels → 11 `mapAsync` waits with the GPU idle in
+   * between); this path uploads every level, records one dispatch per level
+   * into a single compute pass, copies all outputs into one staging buffer
+   * and maps it once.
+   *
+   * `levels` are raw RGBA8 pixels in base-to-tail order; sizes don't have to
+   * halve level-to-level (each level is padded and clamped independently,
+   * exactly like `encodeToBytes`). Uploads use `writeTexture` — the direct
+   * raw-bytes path, which also sidesteps the broken
+   * `copyExternalImageToTexture` devices (see workarounds.ts). There is no
+   * flip option: bake any vertical flip into level 0 before generating the
+   * chain, as `compressTexture()` does.
+   */
+  async encodeMipChainToBytes(levels, { withGpuTime = false } = {}) {
+    const device = this.device;
+    if (levels.length === 0) {
+      throw new Error(`${this.label}Encoder: encodeMipChainToBytes needs at least one level`);
+    }
+    const pipeline = await this._pipelineReady;
+    const prepPipeline = this._prepPipelineReady ? await this._prepPipelineReady : null;
+    const t0 = performance.now();
+    levels.forEach((level, i) => {
+      if (!level.width || !level.height) {
+        throw new Error(`${this.label}Encoder: mip level ${i} has no dimensions`);
+      }
+      if (level.data.length < level.width * level.height * 4) {
+        throw new Error(
+          `${this.label}Encoder: mip level ${i} has ${level.data.length} bytes, expected ${level.width * level.height * 4}`
+        );
+      }
+    });
+    const { geoms, byteSpan } = this._chainGeometry(levels);
+    const sig = geoms.map((g) => `${g.width}x${g.height}`).join();
+    const useCache = !this._chainBusy;
+    if (useCache) this._chainBusy = true;
+    let textures;
+    let prepPlaneSets;
+    let prepBindGroups;
+    let params;
+    let bindGroups;
+    let dst;
+    let staging;
+    let transientLevelSet = false;
+    try {
+      let dstIsNew = true;
+      if (useCache && this._chainDst && this._chainDst.size >= byteSpan) {
+        dst = this._chainDst;
+        dstIsNew = false;
+      } else {
+        dst = device.createBuffer({
+          label: `${this.label}-chain-dst`,
+          size: byteSpan,
+          usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+        });
+        if (useCache) {
+          this._chainDst?.destroy();
+          this._chainDst = dst;
+        }
+      }
+      if (useCache && !dstIsNew && this._chainSig === sig && this._chainParams) {
+        textures = this._chainTextures;
+        params = this._chainParams;
+        bindGroups = this._chainBindGroups;
+        prepPlaneSets = this._chainPrepPlanes;
+        prepBindGroups = this._chainPrepBindGroups;
+      } else {
+        const texs = geoms.map(
+          (g, i) => device.createTexture({
+            label: `${this.label}-chain-src-${i}`,
+            size: [g.paddedWidth, g.paddedHeight, 1],
+            format: "rgba8unorm",
+            // No RENDER_ATTACHMENT: writeTexture is a plain copy, not the
+            // copyExternalImageToTexture blit.
+            usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING
+          })
+        );
+        textures = texs;
+        params = device.createBuffer({
+          label: `${this.label}-chain-params`,
+          size: geoms.length * CHAIN_ALIGN,
+          usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+        });
+        const paramsData = new Uint32Array(geoms.length * CHAIN_ALIGN / 4);
+        geoms.forEach((g, i) => {
+          paramsData.set([g.blocksX, g.blocksY, g.width, g.height], i * CHAIN_ALIGN / 4);
+        });
+        device.queue.writeBuffer(params, 0, paramsData);
+        if (this._usesSampler) {
+          this._sampler ??= device.createSampler({
+            label: `${this.label}-clamp-sampler`,
+            addressModeU: "clamp-to-edge",
+            addressModeV: "clamp-to-edge"
+          });
+        }
+        const dstBuf = dst;
+        const paramsBuf = params;
+        const planeSets = prepPipeline ? geoms.map((g) => this._createPrepPlanes(g.paddedWidth, g.paddedHeight)) : [];
+        prepPlaneSets = planeSets;
+        prepBindGroups = prepPipeline ? geoms.map(
+          (g, i) => this._createPrepBindGroup(prepPipeline, texs[i].createView(), planeSets[i], paramsBuf, i * CHAIN_ALIGN)
+        ) : [];
+        bindGroups = geoms.map((g, i) => {
+          const entries = [
+            {
+              binding: 0,
+              resource: prepPipeline ? planeSets[i][0].createView() : texs[i].createView()
+            },
+            { binding: 1, resource: { buffer: dstBuf, offset: g.dstOffset, size: g.byteLen } },
+            { binding: 2, resource: { buffer: paramsBuf, offset: i * CHAIN_ALIGN, size: 16 } }
+          ];
+          if (prepPipeline) {
+            entries.push({ binding: 3, resource: planeSets[i][1].createView() });
+          } else if (this._usesSampler) {
+            entries.push({ binding: 3, resource: this._sampler });
+          }
+          return device.createBindGroup({
+            label: `${this.label}-chain-bg-${i}`,
+            layout: pipeline.getBindGroupLayout(0),
+            entries
+          });
+        });
+        if (useCache) {
+          for (const tex of this._chainTextures) tex.destroy();
+          for (const planes of this._chainPrepPlanes) for (const t of planes) t.destroy();
+          this._chainParams?.destroy();
+          this._chainTextures = textures;
+          this._chainPrepPlanes = planeSets;
+          this._chainPrepBindGroups = prepBindGroups;
+          this._chainParams = params;
+          this._chainBindGroups = bindGroups;
+          this._chainSig = sig;
+        } else {
+          transientLevelSet = true;
+        }
+      }
+      if (useCache && this._chainStaging && this._chainStaging.size >= byteSpan) {
+        staging = this._chainStaging;
+      } else {
+        staging = device.createBuffer({
+          label: `${this.label}-chain-staging`,
+          size: byteSpan,
+          usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+        });
+        if (useCache) {
+          this._chainStaging?.destroy();
+          this._chainStaging = staging;
+        }
+      }
+      for (let i = 0; i < levels.length; i++) {
+        const level = levels[i];
+        device.queue.writeTexture({ texture: textures[i] }, level.data, { bytesPerRow: level.width * 4 }, [
+          level.width,
+          level.height,
+          1
+        ]);
+      }
+      return await this._submitChainAndRead(
+        pipeline,
+        geoms,
+        byteSpan,
+        bindGroups,
+        dst,
+        staging,
+        withGpuTime,
+        t0,
+        prepPipeline && prepBindGroups ? { pipeline: prepPipeline, bindGroups: prepBindGroups } : null
+      );
+    } finally {
+      if (useCache) {
+        this._chainBusy = false;
+      } else {
+        dst?.destroy();
+        staging?.destroy();
+      }
+      if (transientLevelSet) {
+        if (textures) for (const tex of textures) tex.destroy();
+        if (prepPlaneSets) for (const planes of prepPlaneSets) for (const t of planes) t.destroy();
+        params?.destroy();
+      }
+    }
+  }
+  /**
+   * Encode every mip level of a GPU-resident texture in one submission —
+   * the zero-CPU-pixels counterpart of `encodeMipChainToBytes()`. Pair it
+   * with `generateGpuMipChain()` (gpuMipgen.ts): upload the image once,
+   * box-filter the chain on the GPU, then encode straight from the
+   * texture's mip views. Pixels never transit the CPU between the source
+   * image and the compressed-bytes readback.
+   *
+   * `srcTex` must be `rgba8unorm` with TEXTURE_BINDING usage; level 0's
+   * dimensions are taken from the texture and lower levels follow the
+   * standard floor-halving chain. Encoded output is identical to feeding
+   * the equivalent CPU chain to `encodeMipChainToBytes()`.
+   */
+  async encodeMipChainFromTexture(srcTex, { withGpuTime = false } = {}) {
+    const device = this.device;
+    const pipeline = await this._pipelineReady;
+    const prepPipeline = this._prepPipelineReady ? await this._prepPipelineReady : null;
+    const t0 = performance.now();
+    const dims = [];
+    for (let i = 0; i < srcTex.mipLevelCount; i++) {
+      dims.push({ width: Math.max(1, srcTex.width >> i), height: Math.max(1, srcTex.height >> i) });
+    }
+    const { geoms, byteSpan } = this._chainGeometry(dims);
+    const useCache = !this._chainBusy;
+    if (useCache) this._chainBusy = true;
+    let dst;
+    let staging;
+    let params;
+    let planeSets = null;
+    try {
+      if (useCache && this._chainDst && this._chainDst.size >= byteSpan) {
+        dst = this._chainDst;
+      } else {
+        dst = device.createBuffer({
+          label: `${this.label}-chain-dst`,
+          size: byteSpan,
+          usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+        });
+        if (useCache) {
+          this._chainDst?.destroy();
+          this._chainDst = dst;
+          this._chainSig = null;
+        }
+      }
+      if (useCache && this._chainStaging && this._chainStaging.size >= byteSpan) {
+        staging = this._chainStaging;
+      } else {
+        staging = device.createBuffer({
+          label: `${this.label}-chain-staging`,
+          size: byteSpan,
+          usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+        });
+        if (useCache) {
+          this._chainStaging?.destroy();
+          this._chainStaging = staging;
+        }
+      }
+      params = device.createBuffer({
+        label: `${this.label}-chain-params`,
+        size: geoms.length * CHAIN_ALIGN,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+      });
+      const paramsData = new Uint32Array(geoms.length * CHAIN_ALIGN / 4);
+      geoms.forEach((g, i) => {
+        paramsData.set([g.blocksX, g.blocksY, g.width, g.height], i * CHAIN_ALIGN / 4);
+      });
+      device.queue.writeBuffer(params, 0, paramsData);
+      if (this._usesSampler) {
+        this._sampler ??= device.createSampler({
+          label: `${this.label}-clamp-sampler`,
+          addressModeU: "clamp-to-edge",
+          addressModeV: "clamp-to-edge"
+        });
+      }
+      const dstBuf = dst;
+      const paramsBuf = params;
+      planeSets = prepPipeline ? geoms.map((g) => this._createPrepPlanes(g.paddedWidth, g.paddedHeight)) : null;
+      const planes = planeSets;
+      const prepBindGroups = prepPipeline && planes ? geoms.map(
+        (_, i) => this._createPrepBindGroup(
+          prepPipeline,
+          srcTex.createView({ baseMipLevel: i, mipLevelCount: 1 }),
+          planes[i],
+          paramsBuf,
+          i * CHAIN_ALIGN
+        )
+      ) : null;
+      const bindGroups = geoms.map((g, i) => {
+        const entries = [
+          {
+            binding: 0,
+            resource: planes ? planes[i][0].createView() : srcTex.createView({ baseMipLevel: i, mipLevelCount: 1 })
+          },
+          { binding: 1, resource: { buffer: dstBuf, offset: g.dstOffset, size: g.byteLen } },
+          { binding: 2, resource: { buffer: paramsBuf, offset: i * CHAIN_ALIGN, size: 16 } }
+        ];
+        if (planes) {
+          entries.push({ binding: 3, resource: planes[i][1].createView() });
+        } else if (this._usesSampler) {
+          entries.push({ binding: 3, resource: this._sampler });
+        }
+        return device.createBindGroup({
+          label: `${this.label}-chain-bg-${i}`,
+          layout: pipeline.getBindGroupLayout(0),
+          entries
+        });
+      });
+      return await this._submitChainAndRead(
+        pipeline,
+        geoms,
+        byteSpan,
+        bindGroups,
+        dst,
+        staging,
+        withGpuTime,
+        t0,
+        prepPipeline && prepBindGroups ? { pipeline: prepPipeline, bindGroups: prepBindGroups } : null
+      );
+    } finally {
+      if (useCache) {
+        this._chainBusy = false;
+      } else {
+        dst?.destroy();
+        staging?.destroy();
+      }
+      params?.destroy();
+      if (planeSets) for (const planes of planeSets) for (const t of planes) t.destroy();
+    }
+  }
+  /** Block-grid geometry + packed output offsets for a chain of levels.
+   *  `byteSpan` is both the dst buffer size and the readback copy size (a
+   *  multiple of 4: byteLen is a multiple of bytesPerBlock ≥ 8, offsets are
+   *  CHAIN_ALIGN-ed). */
+  _chainGeometry(dims) {
+    let dstCursor = 0;
+    const geoms = dims.map(({ width, height }) => {
+      const paddedWidth = width + 3 & ~3;
+      const paddedHeight = height + 3 & ~3;
+      const blocksX = paddedWidth >> 2;
+      const blocksY = paddedHeight >> 2;
+      const byteLen = blocksX * blocksY * this.bytesPerBlock;
+      const dstOffset = dstCursor;
+      dstCursor = Math.ceil((dstCursor + byteLen) / CHAIN_ALIGN) * CHAIN_ALIGN;
+      return { width, height, paddedWidth, paddedHeight, blocksX, blocksY, byteLen, dstOffset };
+    });
+    const last = geoms[geoms.length - 1];
+    return { geoms, byteSpan: last.dstOffset + last.byteLen };
+  }
+  /** Shared chain-encode tail: one compute pass with a dispatch per level,
+   *  one submit, one staging readback sliced into per-level byte arrays. */
+  async _submitChainAndRead(pipeline, geoms, byteSpan, bindGroups, dst, staging, withGpuTime, t0, prep = null) {
+    const device = this.device;
+    const timing = withGpuTime ? this._createTiming() : null;
+    const [wgX, wgY] = this.workgroupSize;
+    const enc = device.createCommandEncoder({ label: `${this.label}-encode-chain` });
+    if (prep) {
+      const prepPass = enc.beginComputePass(
+        timing ? { timestampWrites: { querySet: timing.querySet, beginningOfPassWriteIndex: 0 } } : void 0
+      );
+      prepPass.setPipeline(prep.pipeline);
+      for (let i = 0; i < geoms.length; i++) {
+        const g = geoms[i];
+        prepPass.setBindGroup(0, prep.bindGroups[i]);
+        const [px, py] = this.prepDispatch(g.blocksX, g.blocksY);
+        prepPass.dispatchWorkgroups(Math.ceil(px / wgX), Math.ceil(py / wgY), 1);
       }
+      prepPass.end();
+    }
+    const pass = enc.beginComputePass(
+      timing ? {
+        timestampWrites: {
+          querySet: timing.querySet,
+          ...prep ? {} : { beginningOfPassWriteIndex: 0 },
+          endOfPassWriteIndex: 1
+        }
+      } : void 0
+    );
+    pass.setPipeline(pipeline);
+    for (let i = 0; i < geoms.length; i++) {
+      const g = geoms[i];
+      pass.setBindGroup(0, bindGroups[i]);
+      pass.dispatchWorkgroups(Math.ceil(g.blocksX / wgX), Math.ceil(g.blocksY / wgY), 1);
+    }
+    pass.end();
+    enc.copyBufferToBuffer(dst, 0, staging, 0, byteSpan);
+    if (timing) {
+      enc.resolveQuerySet(timing.querySet, 0, 2, timing.resolve, 0);
+      enc.copyBufferToBuffer(timing.resolve, 0, timing.staging, 0, 16);
+    }
+    device.queue.submit([enc.finish()]);
+    await staging.mapAsync(GPUMapMode.READ, 0, byteSpan);
+    const mapped = staging.getMappedRange(0, byteSpan);
+    const out = geoms.map((g) => ({
+      width: g.width,
+      height: g.height,
+      paddedWidth: g.paddedWidth,
+      paddedHeight: g.paddedHeight,
+      data: new Uint8Array(mapped.slice(g.dstOffset, g.dstOffset + g.byteLen))
+    }));
+    staging.unmap();
+    const encodeMs = performance.now() - t0;
+    const gpuMs = timing ? await this._readTimingMs(timing) : void 0;
+    return { levels: out, encodeMs, gpuMs };
+  }
+  // ------------------------------------------------------------------ //
+  // GPU timing plumbing (timestamp queries)                            //
+  // ------------------------------------------------------------------ //
+  /** Create the query set + resolve/staging buffers for one timed
+   *  submission, or null when the device lacks 'timestamp-query'. */
+  _createTiming() {
+    const device = this.device;
+    if (!device.features.has("timestamp-query")) return null;
+    return {
+      querySet: device.createQuerySet({ type: "timestamp", count: 2 }),
+      resolve: device.createBuffer({
+        label: `${this.label}-ts-resolve`,
+        size: 16,
+        usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC
+      }),
+      staging: device.createBuffer({
+        label: `${this.label}-ts-staging`,
+        size: 16,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+      })
+    };
+  }
+  /** Read back a timed submission's pass duration (ms) and destroy the
+   *  timing objects. Timestamps are u64 nanoseconds. */
+  async _readTimingMs(timing) {
+    await timing.staging.mapAsync(GPUMapMode.READ);
+    const [begin, end] = new BigUint64Array(timing.staging.getMappedRange().slice(0));
+    timing.staging.unmap();
+    timing.staging.destroy();
+    timing.resolve.destroy();
+    timing.querySet.destroy();
+    if (end !== void 0 && begin !== void 0 && end > begin) {
+      return Number(end - begin) / 1e6;
     }
+    return void 0;
   }
 };
 
 // src/bc1.wgsl
-var bc1_default = "// BC1 (DXT1) compute shader encoder.\n//\n// Each invocation encodes one 4x4 pixel block into an 8-byte BC1 block\n// written as 2 x u32 into the destination storage buffer.\n//\n// BC1 block layout (little-endian):\n//   u32[0]: color0 (low 16) | color1 (high 16)   both in RGB565\n//   u32[1]: 16 x 2-bit indices, pixel 0 = bits 0..1, pixel 15 = bits 30..31\n//\n// We always force the 4-color mode (color0 > color1, numeric 16-bit):\n//   idx 0 -> color0\n//   idx 1 -> color1\n//   idx 2 -> (2*color0 +   color1) / 3\n//   idx 3 -> (  color0 + 2*color1) / 3\n//\n// QUALITY LEVELS (pipeline-overridable constant `QUALITY_HIGH`)\n//   fast (0, default): principal-axis endpoint seed (the high path's\n//     covariance power-iteration; inset bbox on degenerate blocks), inset by\n//     ~half a 565 cell along the axis, then ONE fused pass that projects\n//     every pixel onto the decoded-endpoint line (the 4 palette entries are\n//     colinear and evenly spaced, so the nearest entry is the rounded\n//     projection \u2014 no 4-entry search) while accumulating the least-squares\n//     refit sums; the refit endpoints are re-quantised and a final projection\n//     pass assigns the indices, packed on the fly.\n//   high (1): endpoints are seeded from the block's principal colour axis\n//     (covariance power-iteration) as well as the bbox diagonal, each refined by\n//     several least-squares passes with full 4-entry searches; the lower-error\n//     family wins. Mirrors bc1_ref.ts.\n\n// 0 = fast (default), 1 = 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 to565(c: vec3<f32>) -> u32 {\n  // Round-to-nearest quantization into 5-6-5.\n  let r = u32(clamp(floor(c.r * 31.0 + 0.5), 0.0, 31.0));\n  let g = u32(clamp(floor(c.g * 63.0 + 0.5), 0.0, 63.0));\n  let b = u32(clamp(floor(c.b * 31.0 + 0.5), 0.0, 31.0));\n  return (r << 11u) | (g << 5u) | b;\n}\n\nfn from565(c: u32) -> vec3<f32> {\n  let r = (c >> 11u) & 31u;\n  let g = (c >>  5u) & 63u;\n  let b =  c         & 31u;\n  // 5/6-bit -> 8-bit: (x*527+23)>>6 (6-bit: 259/33) \u2014 round-to-nearest\n  // scaling, matching bc1_ref.ts and typical hardware decoders (white ->\n  // 255). Integer u32 math is exact. NOTE: this is NOT plain bit-replication\n  // ((x<<3)|(x>>2)) \u2014 they differ for some codes (e.g. 5-bit 3 -> 25 vs 24).\n  // Selecting indices against this palette is what makes the encoder agree\n  // with what the GPU will actually sample.\n  let r8 = (r * 527u + 23u) >> 6u;\n  let g8 = (g * 259u + 33u) >> 6u;\n  let b8 = (b * 527u + 23u) >> 6u;\n  return vec3<f32>(vec3<u32>(r8, g8, b8)) / 255.0;\n}\n\n// 4-color-mode interpolation weights: palette[j] = wa(j)*c0 + wb(j)*c1.\nfn wa(j: u32) -> f32 {\n  switch j {\n    case 0u:  { return 1.0; }\n    case 1u:  { return 0.0; }\n    case 2u:  { return 2.0 / 3.0; }\n    default:  { return 1.0 / 3.0; }   // case 3u\n  }\n}\nfn wb(j: u32) -> f32 {\n  switch j {\n    case 0u:  { return 0.0; }\n    case 1u:  { return 1.0; }\n    case 2u:  { return 1.0 / 3.0; }\n    default:  { return 2.0 / 3.0; }   // case 3u\n  }\n}\n\nfn build_palette(c0: u32, c1: u32, pal: ptr<function, array<vec3<f32>, 4>>) {\n  let p0 = from565(c0);\n  let p1 = from565(c1);\n  for (var j: u32 = 0u; j < 4u; j = j + 1u) {\n    (*pal)[j] = wa(j) * p0 + wb(j) * p1;\n  }\n}\n\n// Assign each of the 16 pixels its nearest palette entry (full 4-entry L2),\n// writing indices into `out_idx` and returning the total squared error.\nfn assign_indices(\n  pixels:  ptr<function, array<vec3<f32>, 16>>,\n  pal:     ptr<function, array<vec3<f32>, 4>>,\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 c = (*pixels)[k];\n    var best_j: u32 = 0u;\n    var best_d: f32 = 1e30;\n    for (var j: u32 = 0u; j < 4u; j = j + 1u) {\n      let d = (*pal)[j] - c;\n      let d2 = dot(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// One least-squares refit pass: solve the 2x2 normal equations for the endpoint\n// colours that minimise \u03A3\u2016wa\xB7e0 + wb\xB7e1 \u2212 c\u2016\xB2 under the current indices. The\n// three channels share the scalar sums, so it's one 2x2 solve with vec3 RHS.\nstruct RefitResult { e0: vec3<f32>, e1: vec3<f32>, valid: bool };\nfn refit(\n  pixels:  ptr<function, array<vec3<f32>, 16>>,\n  indices: ptr<function, array<u32, 16>>,\n) -> RefitResult {\n  var sAA: f32 = 0.0; var sBB: f32 = 0.0; var sAB: f32 = 0.0;\n  var sAV: vec3<f32> = vec3<f32>(0.0);\n  var sBV: vec3<f32> = vec3<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let a = wa((*indices)[k]);\n    let b = wb((*indices)[k]);\n    let v = (*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  var out: RefitResult;\n  let det = sAA * sBB - sAB * sAB;\n  if (abs(det) < 1e-9) {\n    out.valid = false;\n    return out;\n  }\n  out.e0 = clamp((sBB * sAV - sAB * sBV) / det, vec3<f32>(0.0), vec3<f32>(1.0));\n  out.e1 = clamp((sAA * sBV - sAB * sAV) / det, vec3<f32>(0.0), vec3<f32>(1.0));\n  out.valid = true;\n  return out;\n}\n\n// Candidate solution tracked across endpoint seeds / refit passes.\nstruct Best { c0: u32, c1: u32, indices: array<u32, 16>, err: f32 };\n\n// Quantize (hi, lo) to 565, force 4-color mode, assign indices, then refine with\n// up to `max_refits` least-squares passes. Commits to `*best` only on strict\n// improvement.\nfn fit_from_endpoints(\n  pixels: ptr<function, array<vec3<f32>, 16>>,\n  hi: vec3<f32>,\n  lo: vec3<f32>,\n  max_refits: u32,\n  best: ptr<function, Best>,\n) {\n  var c0 = to565(hi);\n  var c1 = to565(lo);\n  // 4-color mode requires color0 > color1.\n  if (c0 == c1) {\n    if (c1 > 0u) { c1 = c1 - 1u; } else { c0 = c0 + 1u; }\n  } else if (c0 < c1) {\n    let t = c0; c0 = c1; c1 = t;\n  }\n\n  var pal: array<vec3<f32>, 4>;\n  var idx: array<u32, 16>;\n  build_palette(c0, c1, &pal);\n  var err = assign_indices(pixels, &pal, &idx);\n  if (err < (*best).err) {\n    (*best).c0 = c0; (*best).c1 = c1; (*best).indices = idx; (*best).err = err;\n  }\n\n  for (var rp: u32 = 0u; rp < max_refits; rp = rp + 1u) {\n    let r = refit(pixels, &idx);\n    if (!r.valid) { break; }\n    var nc0 = to565(r.e0);\n    var nc1 = to565(r.e1);\n    // A refit that flips/equalises the endpoints would change decode mode;\n    // keep 4-color mode, and stop once it stops moving.\n    if (nc0 < nc1) { let t = nc0; nc0 = nc1; nc1 = t; }\n    if (nc0 == nc1) { break; }\n    if (nc0 == c0 && nc1 == c1) { break; }\n    build_palette(nc0, nc1, &pal);\n    let nerr = assign_indices(pixels, &pal, &idx);\n    c0 = nc0; c1 = nc1; err = nerr;\n    if (nerr < (*best).err) {\n      (*best).c0 = nc0; (*best).c1 = nc1; (*best).indices = idx; (*best).err = nerr;\n    }\n  }\n}\n\n// Principal colour axis via covariance power-iteration, seeded with the bbox\n// diagonal. Returns a unit axis, or vec3(0) for a degenerate (constant) block.\nfn principal_axis(\n  pixels: ptr<function, array<vec3<f32>, 16>>,\n  mean: vec3<f32>,\n  seed: vec3<f32>,\n) -> vec3<f32> {\n  // Symmetric 3x3 covariance, stored as its three rows.\n  var c0v = vec3<f32>(0.0);\n  var c1v = vec3<f32>(0.0);\n  var c2v = vec3<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let d = (*pixels)[k] - mean;\n    c0v = c0v + d.x * d;\n    c1v = c1v + d.y * d;\n    c2v = c2v + d.z * d;\n  }\n  var v = seed;\n  var len = length(v);\n  if (len < 1e-9) { return vec3<f32>(0.0); }\n  v = v / len;\n  for (var iter: u32 = 0u; iter < 8u; iter = iter + 1u) {\n    let nv = vec3<f32>(dot(c0v, v), dot(c1v, v), dot(c2v, v));\n    len = length(nv);\n    if (len < 1e-12) { return vec3<f32>(0.0); }\n    v = nv / len;\n  }\n  return v;\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  var pixels: array<vec3<f32>, 16>;\n  var bb_min = vec3<f32>(1.0, 1.0, 1.0);\n  var bb_max = vec3<f32>(0.0, 0.0, 0.0);\n  var mean = vec3<f32>(0.0);\n\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 textures.\n    let p  = clamp(base + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let c  = textureLoad(src_tex, p, 0).rgb;\n    pixels[i] = c;\n    bb_min = min(bb_min, c);\n    bb_max = max(bb_max, c);\n    mean = mean + c;\n  }\n  mean = mean * (1.0 / 16.0);\n\n  // Inset the bounding box by ~half an RGB565 cell (1/16) so the quantized\n  // 4-color palette covers the real data range more tightly (stb_dxt heuristic).\n  let inset = (bb_max - bb_min) / 16.0;\n  let bbox_hi = clamp(bb_max - inset, vec3<f32>(0.0), vec3<f32>(1.0));\n  let bbox_lo = clamp(bb_min + inset, vec3<f32>(0.0), vec3<f32>(1.0));\n\n  if (QUALITY_HIGH == 0u) {\n    // -------- fast: PCA seed + projection + fused LSQ refit + reprojection\n    // Seed endpoints from the block's principal colour axis (same\n    // power-iteration as the high path). The bbox diagonal is sign-blind: on\n    // anti-correlated channels (normal maps, hue edges) it points across the\n    // data instead of along it, and the LSQ refit \u2014 which fits endpoints\n    // GIVEN the projection indices \u2014 can't recover from a wrong axis.\n    // Degenerate (near-flat) blocks keep the inset-bbox seed.\n    var seed_hi = bbox_hi;\n    var seed_lo = bbox_lo;\n    let axis = principal_axis(&pixels, mean, bb_max - bb_min);\n    if (dot(axis, axis) > 0.0) {\n      var t_min: f32 = 1e30;\n      var t_max: f32 = -1e30;\n      for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n        let t = dot(pixels[k] - mean, axis);\n        t_min = min(t_min, t);\n        t_max = max(t_max, t);\n      }\n      // Inset along the axis by ~half a 565 cell (stb_dxt heuristic,\n      // matching the bbox inset).\n      let pad = (t_max - t_min) / 16.0;\n      seed_hi = clamp(mean + (t_max - pad) * axis, vec3<f32>(0.0), vec3<f32>(1.0));\n      seed_lo = clamp(mean + (t_min + pad) * axis, vec3<f32>(0.0), vec3<f32>(1.0));\n    }\n    var c0 = to565(seed_hi);\n    var c1 = to565(seed_lo);\n    if (c0 == c1) {\n      if (c1 > 0u) { c1 = c1 - 1u; } else { c0 = c0 + 1u; }\n    } else if (c0 < c1) {\n      let t = c0; c0 = c1; c1 = t;\n    }\n    let p0 = from565(c0);\n    let p1 = from565(c1);\n\n    // Fused pass: projection assignment + LSQ sums + the seed solution's\n    // packed indices and squared error. Level \u2192 BC1 index: 0\u21920 (c0), 1\u21922,\n    // 2\u21923, 3\u21921 (c1); as a packed LUT: (0x78 >> 2L) & 3.\n    var idx_bits: u32 = 0u;\n    let dir = p1 - p0;\n    let dd = dot(dir, dir);\n    if (dd > 0.0) {\n      let inv = 3.0 / dd;\n      var sAA: f32 = 0.0; var sBB: f32 = 0.0; var sAB: f32 = 0.0;\n      var sAV = vec3<f32>(0.0); var sBV = vec3<f32>(0.0);\n      var s_min = 3.0; var s_max = 0.0;\n      var seed_err: f32 = 0.0;\n      for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n        let v = pixels[k];\n        let s = clamp(floor(dot(v - p0, dir) * inv + 0.5), 0.0, 3.0);\n        s_min = min(s_min, s); s_max = max(s_max, s);\n        let b = s * (1.0 / 3.0); let a = 1.0 - b;\n        sAA = sAA + a * a; sBB = sBB + b * b; sAB = sAB + a * b;\n        sAV = sAV + a * v; sBV = sBV + b * v;\n        let e = v - (p0 + b * dir);\n        seed_err = seed_err + dot(e, e);\n        idx_bits = idx_bits | (((0x78u >> (u32(s) * 2u)) & 3u) << (k * 2u));\n      }\n      let det = sAA * sBB - sAB * sAB;\n      // Refit only on a well-conditioned system: when every pixel lands on\n      // ONE level (flat blocks \u2014 the 4-colour nudge forces c0 \u2260 c1 even\n      // then) the system is rank-1 and det/numerators are pure float noise;\n      // the solve would return garbage endpoints. With \u22652 levels\n      // det = \u03A3_i<j (b_j \u2212 b_i)\xB2 \u2265 ~1.67, so 1e-3 is a safe guard.\n      if (s_min < s_max && abs(det) > 1e-3) {\n        // Clamp the refit to the block bbox (not [0,1]): on multi-cluster\n        // blocks the unconstrained solve extrapolates far outside the block's\n        // colours and the per-channel clamp then bends the hue \u2014 fringe pixels\n        // decode to colours that exist nowhere in the block. Constraining to\n        // the bbox also measures better in plain SSE (+1.6 dB on the colour\n        // test card), so the accept-if-better guard below keeps more refits.\n        let e0 = clamp((sBB * sAV - sAB * sBV) / det, bb_min, bb_max);\n        let e1 = clamp((sAA * sBV - sAB * sAV) / det, bb_min, bb_max);\n        var nc0 = to565(e0);\n        var nc1 = to565(e1);\n        if (nc0 == nc1) {\n          if (nc1 > 0u) { nc1 = nc1 - 1u; } else { nc0 = nc0 + 1u; }\n        } else if (nc0 < nc1) {\n          let t = nc0; nc0 = nc1; nc1 = t;\n        }\n        let np0 = from565(nc0);\n        let np1 = from565(nc1);\n        let ndir = np1 - np0;\n        let ndd = dot(ndir, ndir);\n        if (ndd > 0.0 && !(nc0 == c0 && nc1 == c1)) {\n          // Reproject against the refit endpoints and accept them only if\n          // the block error actually decreases (the refit minimises a\n          // continuous objective; after 565 quantisation it can lose).\n          let ninv = 3.0 / ndd;\n          var refit_err: f32 = 0.0;\n          var nidx_bits: u32 = 0u;\n          for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n            let v = pixels[k];\n            let s = clamp(floor(dot(v - np0, ndir) * ninv + 0.5), 0.0, 3.0);\n            let e = v - (np0 + s * (1.0 / 3.0) * ndir);\n            refit_err = refit_err + dot(e, e);\n            nidx_bits = nidx_bits | (((0x78u >> (u32(s) * 2u)) & 3u) << (k * 2u));\n          }\n          if (refit_err < seed_err) {\n            c0 = nc0; c1 = nc1;\n            idx_bits = nidx_bits;\n          }\n        }\n      }\n    }\n\n    let out = block_index * 2u;\n    dst[out]      = c0 | (c1 << 16u);\n    dst[out + 1u] = idx_bits;\n    return;\n  }\n\n  // ------------------------------ high --------------------------------- //\n  var best: Best;\n  best.err = 1e30;\n\n  // Seed from the principal colour axis: project all texels onto it, take the\n  // extreme projections as endpoints, inset along the axis. Then also try the\n  // bbox seed and keep whichever family yields the lower error.\n  let axis = principal_axis(&pixels, mean, bb_max - bb_min);\n  if (dot(axis, axis) > 0.0) {\n    var t_min: f32 = 1e30;\n    var t_max: f32 = -1e30;\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n      let t = dot(pixels[k] - mean, axis);\n      t_min = min(t_min, t);\n      t_max = max(t_max, t);\n    }\n    let pad = (t_max - t_min) / 16.0;\n    let pca_hi = clamp(mean + (t_max - pad) * axis, vec3<f32>(0.0), vec3<f32>(1.0));\n    let pca_lo = clamp(mean + (t_min + pad) * axis, vec3<f32>(0.0), vec3<f32>(1.0));\n    fit_from_endpoints(&pixels, pca_hi, pca_lo, 3u, &best);\n  }\n  fit_from_endpoints(&pixels, bbox_hi, bbox_lo, 3u, &best);\n\n  var indices: u32 = 0u;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    indices = indices | ((best.indices[k] & 3u) << (k * 2u));\n  }\n\n  let out = block_index * 2u;\n  dst[out]      = best.c0 | (best.c1 << 16u);\n  dst[out + 1u] = indices;\n}\n";
+var bc1_default = "// BC1 (DXT1) compute shader encoder.\n//\n// Each invocation encodes one 4x4 pixel block into an 8-byte BC1 block\n// written as 2 x u32 into the destination storage buffer. This is the f32\n// fallback; bc1_fast_f16.wgsl is the same algorithm and is preferred when\n// the device reports shader-f16.\n//\n// BC1 block layout (little-endian):\n//   u32[0]: color0 (low 16) | color1 (high 16)   both in RGB565\n//   u32[1]: 16 x 2-bit indices, pixel 0 = bits 0..1, pixel 15 = bits 30..31\n//\n// We always force the 4-color mode (color0 > color1, numeric 16-bit):\n//   idx 0 -> color0\n//   idx 1 -> color1\n//   idx 2 -> (2*color0 +   color1) / 3\n//   idx 3 -> (  color0 + 2*color1) / 3\n//\n// ALGORITHM: principal-axis endpoint seed (covariance power-iteration; inset\n// bbox on degenerate blocks), inset by ~half a 565 cell along the axis, then\n// a fused pass that projects every pixel onto the decoded-endpoint line (the\n// 4 palette entries are colinear and evenly spaced, so the nearest entry is\n// the rounded projection \u2014 no 4-entry search) while accumulating the\n// least-squares refit sums, followed by up to TWO refit rounds (re-quantise,\n// reproject with indices packed on the fly, accept only on lower block\n// error).\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 to565(c: vec3<f32>) -> u32 {\n  // Round-to-nearest quantization into 5-6-5.\n  let r = u32(clamp(floor(c.r * 31.0 + 0.5), 0.0, 31.0));\n  let g = u32(clamp(floor(c.g * 63.0 + 0.5), 0.0, 63.0));\n  let b = u32(clamp(floor(c.b * 31.0 + 0.5), 0.0, 31.0));\n  return (r << 11u) | (g << 5u) | b;\n}\n\nfn from565(c: u32) -> vec3<f32> {\n  let r = (c >> 11u) & 31u;\n  let g = (c >>  5u) & 63u;\n  let b =  c         & 31u;\n  // 5/6-bit -> 8-bit: (x*527+23)>>6 (6-bit: 259/33) \u2014 round-to-nearest\n  // scaling, matching bc1_ref.ts and typical hardware decoders (white ->\n  // 255). Integer u32 math is exact. NOTE: this is NOT plain bit-replication\n  // ((x<<3)|(x>>2)) \u2014 they differ for some codes (e.g. 5-bit 3 -> 25 vs 24).\n  // Selecting indices against this palette is what makes the encoder agree\n  // with what the GPU will actually sample.\n  let r8 = (r * 527u + 23u) >> 6u;\n  let g8 = (g * 259u + 33u) >> 6u;\n  let b8 = (b * 527u + 23u) >> 6u;\n  return vec3<f32>(vec3<u32>(r8, g8, b8)) / 255.0;\n}\n\n// One projection pass against the decoded endpoints of (c0,c1): the packed\n// 2-bit indices, the block's squared error, and the LSQ normal-equation sums\n// of the resulting assignment \u2014 so an accepted refit can seed the next\n// round. Levels s run 0..3 along p0\u2192p1 (palette = p0, p0+\u2153d, p0+\u2154d, p1 \u2014\n// colinear, evenly spaced, so rounding the projection IS the nearest-entry\n// search). Level \u2192 BC1 index: 0\u21920 (c0), 1\u21922 (\u2154c0+\u2153c1), 2\u21923, 3\u21921 (c1); as a\n// packed LUT: (0x78 >> 2L) & 3.\nstruct ProjStats {\n  indices: u32,\n  err: f32,\n  sAA: f32, sBB: f32, sAB: f32,\n  sAV: vec3<f32>, sBV: vec3<f32>,\n  s_min: f32, s_max: f32,\n};\nfn project_stats(pix: ptr<function, array<vec3<f32>, 16>>, c0: u32, c1: u32) -> ProjStats {\n  var out: ProjStats;\n  out.indices = 0u;\n  out.err = 0.0;\n  out.sAA = 0.0; out.sBB = 0.0; out.sAB = 0.0;\n  out.sAV = vec3<f32>(0.0); out.sBV = vec3<f32>(0.0);\n  out.s_min = 3.0; out.s_max = 0.0;\n  let p0 = from565(c0);\n  let p1 = from565(c1);\n  let dir = p1 - p0;\n  let dd = dot(dir, dir);\n  if (dd == 0.0) {\n    // Unreachable for distinct 565 codes (the decode is injective); kept so\n    // a degenerate call still returns a consistent error.\n    out.s_min = 0.0;\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n      let e = (*pix)[k] - p0;\n      out.err = out.err + dot(e, e);\n    }\n    return out;\n  }\n  let inv = 3.0 / dd;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let v = (*pix)[k];\n    let s = clamp(floor(dot(v - p0, dir) * inv + 0.5), 0.0, 3.0);\n    out.s_min = min(out.s_min, s); out.s_max = max(out.s_max, s);\n    let b = s * (1.0 / 3.0); let a = 1.0 - b;\n    out.sAA = out.sAA + a * a; out.sBB = out.sBB + b * b; out.sAB = out.sAB + a * b;\n    out.sAV = out.sAV + a * v; out.sBV = out.sBV + b * v;\n    let e = v - (p0 + b * dir);\n    out.err = out.err + dot(e, e);\n    out.indices = out.indices | (((0x78u >> (u32(s) * 2u)) & 3u) << (k * 2u));\n  }\n  return out;\n}\n\n// Principal colour axis via covariance power-iteration, seeded with the bbox\n// diagonal. Returns a unit axis, or vec3(0) for a degenerate (constant)\n// block. The bbox diagonal alone is sign-blind and points across\n// anti-correlated data (normal maps, hue edges) instead of along it.\nfn principal_axis(\n  pixels: ptr<function, array<vec3<f32>, 16>>,\n  mean: vec3<f32>,\n  seed: vec3<f32>,\n) -> vec3<f32> {\n  // Symmetric 3x3 covariance, stored as its three rows.\n  var c0v = vec3<f32>(0.0);\n  var c1v = vec3<f32>(0.0);\n  var c2v = vec3<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let d = (*pixels)[k] - mean;\n    c0v = c0v + d.x * d;\n    c1v = c1v + d.y * d;\n    c2v = c2v + d.z * d;\n  }\n  var v = seed;\n  var len = length(v);\n  if (len < 1e-9) { return vec3<f32>(0.0); }\n  v = v / len;\n  for (var iter: u32 = 0u; iter < 8u; iter = iter + 1u) {\n    let nv = vec3<f32>(dot(c0v, v), dot(c1v, v), dot(c2v, v));\n    len = length(nv);\n    if (len < 1e-12) { return vec3<f32>(0.0); }\n    v = nv / len;\n  }\n  return v;\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  var pixels: array<vec3<f32>, 16>;\n  var bb_min = vec3<f32>(1.0, 1.0, 1.0);\n  var bb_max = vec3<f32>(0.0, 0.0, 0.0);\n  var mean = vec3<f32>(0.0);\n  var gd = 0.0;\n\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 textures.\n    let p  = clamp(base + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let c  = textureLoad(src_tex, p, 0).rgb;\n    pixels[i] = c;\n    bb_min = min(bb_min, c);\n    bb_max = max(bb_max, c);\n    mean = mean + c;\n    gd = max(gd, max(abs(c.x - c.y), abs(c.x - c.z)));\n  }\n  mean = mean * (1.0 / 16.0);\n  // Exactly-gray blocks free the refit from the bbox clamp (no hue to\n  // protect; smooth gradients want endpoints outside the data range) \u2014\n  // see bc1_fast_f16.wgsl.\n  let gray = gd == 0.0;\n  let lim_lo = select(bb_min, vec3<f32>(0.0), gray);\n  let lim_hi = select(bb_max, vec3<f32>(1.0), gray);\n\n  // Seed endpoints from the block's principal colour axis at the exact\n  // projection extents, inset by ~half a 565 cell along the axis (stb_dxt\n  // heuristic). Degenerate (near-flat) blocks keep the inset-bbox seed.\n  var seed_hi: vec3<f32>;\n  var seed_lo: vec3<f32>;\n  let axis = principal_axis(&pixels, mean, bb_max - bb_min);\n  if (dot(axis, axis) > 0.0) {\n    var t_min: f32 = 1e30;\n    var t_max: f32 = -1e30;\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n      let t = dot(pixels[k] - mean, axis);\n      t_min = min(t_min, t);\n      t_max = max(t_max, t);\n    }\n    let pad = (t_max - t_min) / 16.0;\n    seed_hi = clamp(mean + (t_max - pad) * axis, vec3<f32>(0.0), vec3<f32>(1.0));\n    seed_lo = clamp(mean + (t_min + pad) * axis, vec3<f32>(0.0), vec3<f32>(1.0));\n  } else {\n    let inset = (bb_max - bb_min) / 16.0;\n    seed_hi = clamp(bb_max - inset, vec3<f32>(0.0), vec3<f32>(1.0));\n    seed_lo = clamp(bb_min + inset, vec3<f32>(0.0), vec3<f32>(1.0));\n  }\n  var c0 = to565(seed_hi);\n  var c1 = to565(seed_lo);\n  if (c0 == c1) {\n    if (c1 > 0u) { c1 = c1 - 1u; } else { c0 = c0 + 1u; }\n  } else if (c0 < c1) {\n    let t = c0; c0 = c1; c1 = t;\n  }\n\n  // Fused seed pass, then up to TWO least-squares refit rounds, each\n  // accepted only if the block's squared error actually decreases \u2014 the\n  // refit minimises a continuous objective and can lose after 565\n  // quantisation. Every pass re-accumulates the normal-equation sums, so an\n  // accepted round seeds the next.\n  var cur = project_stats(&pixels, c0, c1);\n  for (var it: u32 = 0u; it < 2u; it = it + 1u) {\n    // Refit only on a well-conditioned system: when every pixel lands on\n    // ONE level (flat blocks \u2014 the 4-colour nudge forces c0 \u2260 c1 even\n    // then) the system is rank-1 and det/numerators are pure float noise;\n    // the solve would return garbage endpoints. With \u22652 levels\n    // det = \u03A3_i<j (b_j \u2212 b_i)\xB2 \u2265 ~1.67, so 1e-3 is a safe guard.\n    if (cur.s_min >= cur.s_max) { break; }\n    let det = cur.sAA * cur.sBB - cur.sAB * cur.sAB;\n    if (abs(det) <= 1e-3) { break; }\n    // Clamp the refit to the block bbox (not [0,1]): on multi-cluster\n    // blocks the unconstrained solve extrapolates far outside the block's\n    // colours and the per-channel clamp then bends the hue \u2014 fringe pixels\n    // decode to colours that exist nowhere in the block. Constraining to\n    // the bbox also measures better in plain SSE (+1.6 dB on the colour\n    // test card), so the accept-if-better guard below keeps more refits.\n    let e0 = clamp((cur.sBB * cur.sAV - cur.sAB * cur.sBV) / det, lim_lo, lim_hi);\n    let e1 = clamp((cur.sAA * cur.sBV - cur.sAB * cur.sAV) / det, lim_lo, lim_hi);\n    var nc0 = to565(e0);\n    var nc1 = to565(e1);\n    if (nc0 == nc1) {\n      if (nc1 > 0u) { nc1 = nc1 - 1u; } else { nc0 = nc0 + 1u; }\n    } else if (nc0 < nc1) {\n      let t = nc0; nc0 = nc1; nc1 = t;\n    }\n    if (nc0 == c0 && nc1 == c1) { break; }\n    let nxt = project_stats(&pixels, nc0, nc1);\n    if (nxt.err >= cur.err) { break; }\n    c0 = nc0;\n    c1 = nc1;\n    cur = nxt;\n  }\n\n  let out = block_index * 2u;\n  dst[out]      = c0 | (c1 << 16u);\n  dst[out + 1u] = cur.indices;\n}\n";
 
 // src/bc1_fast_f16.wgsl
 var bc1_fast_f16_default = `// bc1 "fast" encoder \u2014 f16 variant (requires the shader-f16 feature).
@@ -440,11 +984,13 @@ var bc1_fast_f16_default = `// bc1 "fast" encoder \u2014 f16 variant (requires t
 //   3. ONE fused pass: project every pixel onto the decoded-endpoint line
 //      (the 4 palette entries are colinear and evenly spaced, so the nearest
 //      entry is the rounded projection \u2014 no 4-entry search) while
-//      accumulating the least-squares refit sums, the seed solution's packed
-//      indices and its squared error
-//   4. re-quantise the refit endpoints, reproject (indices packed on the
-//      fly), and accept the refit only if the block error decreases \u2014
-//      flat/single-level blocks skip this pass entirely
+//      accumulating the least-squares refit sums, the packed indices and the
+//      squared error
+//   4. up to TWO refit rounds (mirroring the high path's iterated refits):
+//      re-quantise the refit endpoints, reproject (indices packed on the
+//      fly, sums re-accumulated to seed the next round), and accept each
+//      round only if the block error decreases \u2014 flat/single-level blocks
+//      skip these passes entirely
 //
 // vs the pre-projection fast branch (build palette + full 4-entry search \xD7 3
 // passes + refit sums pass) this does roughly half the ALU per block. The
@@ -492,6 +1038,56 @@ fn order565(a: u32, b: u32) -> vec2<u32> {
   return vec2<u32>(c0, c1);
 }
 
+// One projection pass against the decoded endpoints of (c0,c1): the packed
+// 2-bit indices, the block's squared error, and the LSQ normal-equation sums
+// of the resulting assignment \u2014 so an accepted refit can seed the next
+// round. Levels s run 0..3 along p0\u2192p1 (palette = p0, p0+\u2153d, p0+\u2154d, p1 \u2014
+// colinear, evenly spaced, so rounding the projection IS the nearest-entry
+// search). Level \u2192 BC1 index: 0\u21920 (c0), 1\u21922 (\u2154c0+\u2153c1), 2\u21923, 3\u21921 (c1); as a
+// packed LUT: (0x78 >> 2L) & 3.
+struct Proj {
+  indices: u32,
+  err: h,
+  sAA: h, sBB: h, sAB: h,
+  sAV: h3, sBV: h3,
+  s_min: h, s_max: h,
+};
+fn project_stats(pix: ptr<function, array<h3, 16>>, c0: u32, c1: u32) -> Proj {
+  var out: Proj;
+  out.indices = 0u;
+  out.err = h(0.0);
+  out.sAA = h(0.0); out.sBB = h(0.0); out.sAB = h(0.0);
+  out.sAV = h3(0.0); out.sBV = h3(0.0);
+  out.s_min = h(3.0); out.s_max = h(0.0);
+  let p0 = from565(c0);
+  let p1 = from565(c1);
+  let dir = p1 - p0;
+  let dd = dot(dir, dir);
+  if (dd == h(0.0)) {
+    // Unreachable for distinct 565 codes (the decode is injective); kept so
+    // a degenerate call still returns a consistent error.
+    out.s_min = h(0.0);
+    for (var k: u32 = 0u; k < 16u; k = k + 1u) {
+      let e = (*pix)[k] - p0;
+      out.err = out.err + dot(e, e);
+    }
+    return out;
+  }
+  let inv = h(3.0) / dd;
+  for (var k: u32 = 0u; k < 16u; k = k + 1u) {
+    let v = (*pix)[k];
+    let s = clamp(floor(dot(v - p0, dir) * inv + h(0.5)), h(0.0), h(3.0));
+    out.s_min = min(out.s_min, s); out.s_max = max(out.s_max, s);
+    let b = s * h(1.0 / 3.0); let a = h(1.0) - b;
+    out.sAA = out.sAA + a * a; out.sBB = out.sBB + b * b; out.sAB = out.sAB + a * b;
+    out.sAV = out.sAV + a * v; out.sBV = out.sBV + b * v;
+    let e = v - (p0 + b * dir);
+    out.err = out.err + dot(e, e);
+    out.indices = out.indices | (((0x78u >> (u32(s) * 2u)) & 3u) << (k * 2u));
+  }
+  return out;
+}
+
 @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; }
@@ -503,13 +1099,23 @@ fn encode(@builtin(global_invocation_id) gid: vec3<u32>) {
   var mn = h3(1.0);
   var mxv = h3(0.0);
   var mean = h3(0.0);
+  var gd = h(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 = h3(textureLoad(src_tex, p, 0).rgb);
     pix[i] = px; mn = min(mn, px); mxv = max(mxv, px);
     mean = mean + px;
+    gd = max(gd, max(abs(px.x - px.y), abs(px.x - px.z)));
   }
   mean = mean * h(1.0 / 16.0);
+  // Exactly-gray blocks free the refit from the bbox clamp below: a gray
+  // block has no hue to bend (the clamp's whole purpose), and on smooth
+  // gradients the LSQ optimum often lies OUTSIDE the data range \u2014 endpoints
+  // spread wider than the block so the 1/3-2/3 interpolants land on the
+  // values. Same rationale as the BC5 scalar channels (+0.32 dB there).
+  let gray = gd == h(0.0);
+  let lim_lo = select(mn, h3(0.0), gray);
+  let lim_hi = select(mxv, h3(1.0), gray);
 
   // Seed endpoints from the block's principal colour axis (covariance
   // power-iteration, seeded with the bbox diagonal \u2014 same family as the
@@ -564,35 +1170,15 @@ fn encode(@builtin(global_invocation_id) gid: vec3<u32>) {
   let seed = order565(to565(seed_hi), to565(seed_lo));
   var c0 = seed.x;
   var c1 = seed.y;
-  let p0 = from565(c0);
-  let p1 = from565(c1);
 
-  // Fused pass: projection assignment + LSQ normal-equation sums + the seed
-  // solution's packed indices and squared error. Levels s run 0..3 along
-  // p0\u2192p1 (palette = p0, p0+\u2153d, p0+\u2154d, p1 \u2014 colinear, evenly spaced, so
-  // rounding the projection IS the nearest-entry search). Level \u2192 BC1 index:
-  // 0\u21920 (c0), 1\u21922 (\u2154c0+\u2153c1), 2\u21923, 3\u21921 (c1); as a packed LUT: (0x78 >> 2L) & 3.
-  var indices: u32 = 0u;
-  let dir = p1 - p0;
-  let dd = dot(dir, dir);
-  if (dd > h(0.0)) {
-    let inv = h(3.0) / dd;
-    var sAA = h(0.0); var sBB = h(0.0); var sAB = h(0.0);
-    var sAV = h3(0.0); var sBV = h3(0.0);
-    var s_min = h(3.0); var s_max = h(0.0);
-    var seed_err = h(0.0);
-    for (var k: u32 = 0u; k < 16u; k = k + 1u) {
-      let v = pix[k];
-      let s = clamp(floor(dot(v - p0, dir) * inv + h(0.5)), h(0.0), h(3.0));
-      s_min = min(s_min, s); s_max = max(s_max, s);
-      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;
-      let e = v - (p0 + b * dir);
-      seed_err = seed_err + dot(e, e);
-      indices = indices | (((0x78u >> (u32(s) * 2u)) & 3u) << (k * 2u));
-    }
-    let det = sAA * sBB - sAB * sAB;
+  // Fused seed pass, then up to TWO least-squares refit rounds (mirroring
+  // the high path's iterated refits, at projection cost), each accepted only
+  // if the block's squared error actually decreases \u2014 the refit minimises a
+  // continuous objective and can lose after 565 quantisation. Every pass
+  // re-accumulates the normal-equation sums, so an accepted round seeds the
+  // next.
+  var cur = project_stats(&pix, c0, c1);
+  for (var it: u32 = 0u; it < 2u; it = it + 1u) {
     // Refit only on a well-conditioned system. When every pixel lands on ONE
     // level (flat / near-flat blocks \u2014 note the 4-colour-mode nudge forces
     // c0 \u2260 c1 even for perfectly flat blocks) the system is rank-1: det is 0
@@ -600,45 +1186,30 @@ fn encode(@builtin(global_invocation_id) gid: vec3<u32>) {
     // noise, so the solve returns garbage endpoints. With \u22652 distinct levels
     // det = \u03A3_i<j (b_j \u2212 b_i)\xB2 \u2265 15\xB7(1/3)\xB2 \u2248 1.67, far above the ~0.05 f16
     // noise floor \u2014 0.5 separates the two regimes cleanly.
-    if (s_min < s_max && abs(det) > h(0.5)) {
-      // Clamp the refit to the block bbox (not [0,1]): on multi-cluster
-      // blocks the unconstrained solve extrapolates far outside the block's
-      // colours and the per-channel clamp then bends the hue \u2014 fringe pixels
-      // decode to colours that exist nowhere in the block. Constraining to
-      // the bbox also measures better in plain SSE (+1.6 dB on the colour
-      // test card), so the accept-if-better guard below keeps more refits.
-      let e0 = clamp((sBB * sAV - sAB * sBV) / det, mn, mxv);
-      let e1 = clamp((sAA * sBV - sAB * sAV) / det, mn, mxv);
-      let refit = order565(to565(e0), to565(e1));
-      let np0 = from565(refit.x);
-      let np1 = from565(refit.y);
-      let ndir = np1 - np0;
-      let ndd = dot(ndir, ndir);
-      if (ndd > h(0.0) && !(refit.x == c0 && refit.y == c1)) {
-        // Reproject against the refit endpoints and accept them only if the
-        // block's squared error actually decreases (the refit minimises a
-        // continuous objective; after 565 quantisation it can lose).
-        let ninv = h(3.0) / ndd;
-        var refit_err = h(0.0);
-        var nindices: u32 = 0u;
-        for (var k: u32 = 0u; k < 16u; k = k + 1u) {
-          let v = pix[k];
-          let s = clamp(floor(dot(v - np0, ndir) * ninv + h(0.5)), h(0.0), h(3.0));
-          let e = v - (np0 + s * h(1.0 / 3.0) * ndir);
-          refit_err = refit_err + dot(e, e);
-          nindices = nindices | (((0x78u >> (u32(s) * 2u)) & 3u) << (k * 2u));
-        }
-        if (refit_err < seed_err) {
-          c0 = refit.x; c1 = refit.y;
-          indices = nindices;
-        }
-      }
-    }
+    if (cur.s_min >= cur.s_max) { break; }
+    let det = cur.sAA * cur.sBB - cur.sAB * cur.sAB;
+    if (abs(det) <= h(0.5)) { break; }
+    // Clamp the refit to the block bbox (not [0,1]) \u2014 except for exactly
+    // gray blocks, see the load pass: on multi-cluster blocks the
+    // unconstrained solve extrapolates far outside the block's colours
+    // and the per-channel clamp then bends the hue \u2014 fringe pixels decode to
+    // colours that exist nowhere in the block. Constraining to the bbox also
+    // measures better in plain SSE (+1.6 dB on the colour test card), so the
+    // accept-if-better guard below keeps more refits.
+    let e0 = clamp((cur.sBB * cur.sAV - cur.sAB * cur.sBV) / det, lim_lo, lim_hi);
+    let e1 = clamp((cur.sAA * cur.sBV - cur.sAB * cur.sAV) / det, lim_lo, lim_hi);
+    let rq = order565(to565(e0), to565(e1));
+    if (rq.x == c0 && rq.y == c1) { break; }
+    let nxt = project_stats(&pix, rq.x, rq.y);
+    if (nxt.err >= cur.err) { break; }
+    c0 = rq.x;
+    c1 = rq.y;
+    cur = nxt;
   }
 
   let o = bi * 2u;
   dst[o] = c0 | (c1 << 16u);
-  dst[o + 1u] = indices;
+  dst[o + 1u] = cur.indices;
 }
 `;
 
@@ -655,9 +1226,6 @@ var BC1Encoder = class extends Encoder {
   get supportsSrgb() {
     return true;
   }
-  get supportsQuality() {
-    return true;
-  }
   wgslSource() {
     return bc1_default;
   }
@@ -670,12 +1238,12 @@ var BC1Encoder = class extends Encoder {
 };
 
 // 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//\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 + O(1) projection assignment per texel.\n//     The 8-entry palette in 6-interp mode is colinear and EVENLY spaced from\n//     r0 to r1 (levels 0..7 in palette order 0,2,3,4,5,6,7,1), so the nearest\n//     entry is the rounded projection onto the r0\u2192r1 axis \u2014 no 8-entry\n//     search, and the 3-bit indices are packed on the fly. The LSQ refit sums\n//     are accumulated in the same fused pass; the requantised refit is\n//     accepted only if it lowers the block error (worth ~1.3 dB on the\n//     normal-map card).\n//   high (1): full nearest search + refit, matches 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).\n// vmin/vmax are the channel's min/max, computed in the caller's load loop \u2014\n// fusing that scan there saves a 16-value pass per channel.\nfn encode_bc4(values: ptr<function, array<f32, 16>>, vmin: f32, vmax: f32) -> vec2<u32> {\n  // ---------------- 1. Initial endpoints: bbox of input ----------------\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  if (QUALITY_HIGH == 0u) {\n    // -------- fast: fused projection + LSQ refit, accept-if-better -------\n    // ONE fused pass: level = round(7\xB7(v \u2212 r0)/(r1 \u2212 r0)) projection\n    // assignment (the 8-entry 6-interp palette is colinear and evenly\n    // spaced, so the rounded projection IS the nearest-entry search), the\n    // seed solution's packed indices and squared error, and the least-\n    // squares normal-equation sums. The refit endpoints are re-quantised,\n    // reprojected, and accepted only if the block error decreases \u2014 worth\n    // ~1.3 dB on the normal-map card over the refit-free seed.\n    // Level \u2192 BC4 index LUT (0,2,3,4,5,6,7,1) packed as 3-bit entries in\n    // 0x3F58D0. Pixel k's 3 bits start at bit 3k+16 of the (w0,w1) pair\n    // (bytes 0..1 are the endpoints); k = 5 straddles the word boundary.\n    let r0f = f32(r0) / 255.0;\n    let dir = f32(r1) / 255.0 - r0f;\n    let scale = 7.0 / dir;\n    var w0 = r0 | (r1 << 8u);\n    var w1 = 0u;\n    var sAA = 0.0; var sBB = 0.0; var sAB = 0.0;\n    var sAV = 0.0; var sBV = 0.0;\n    var s_min = 7.0; var s_max = 0.0;\n    var seed_err = 0.0;\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n      let vr = (*values)[k] - r0f;\n      let L = clamp(floor(vr * scale + 0.5), 0.0, 7.0);\n      s_min = min(s_min, L); s_max = max(s_max, L);\n      let b = L * (1.0 / 7.0); let a = 1.0 - b;\n      sAA = sAA + a * a; sBB = sBB + b * b; sAB = sAB + a * b;\n      sAV = sAV + a * vr; sBV = sBV + b * vr;\n      let e = vr - b * dir;\n      seed_err = seed_err + e * e;\n      let idx = (0x3F58D0u >> (u32(L) * 3u)) & 7u;\n      let bit = 3u * k + 16u;\n      if (bit <= 29u) {\n        w0 = w0 | (idx << bit);\n      } else if (bit >= 32u) {\n        w1 = w1 | (idx << (bit - 32u));\n      } else {\n        w0 = w0 | (idx << bit);\n        w1 = w1 | (idx >> (32u - bit));\n      }\n    }\n\n    // Rank-1 guard: with every pixel on ONE level the system is singular\n    // (det is float rounding noise); with \u22652 distinct levels\n    // det = \u03A3_i<j (b_j \u2212 b_i)\xB2 \u2265 15/49 \u2248 0.306.\n    if (s_min < s_max) {\n      let det = sAA * sBB - sAB * sAB;\n      if (abs(det) > 1e-3) {\n        // Clamp the refit to the block's value range (a strict-SSE win vs\n        // clamping to [0,1], same as the other formats' fast paths).\n        let e0 = clamp(r0f + (sBB * sAV - sAB * sBV) / det, vmin, vmax);\n        let e1 = clamp(r0f + (sAA * sBV - sAB * sAV) / det, vmin, vmax);\n        let n0 = quantize8(e0);\n        let n1 = quantize8(e1);\n        // Keep 6-interp mode (r0 > r1 strictly); skip the no-op refit.\n        if (n0 > n1 && !(n0 == r0 && n1 == r1)) {\n          let n0f = f32(n0) / 255.0;\n          let ndir = f32(n1) / 255.0 - n0f;\n          let nscale = 7.0 / ndir;\n          var nw0 = n0 | (n1 << 8u);\n          var nw1 = 0u;\n          var refit_err = 0.0;\n          for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n            let vr = (*values)[k] - n0f;\n            let L = clamp(floor(vr * nscale + 0.5), 0.0, 7.0);\n            let e = vr - L * (1.0 / 7.0) * ndir;\n            refit_err = refit_err + e * e;\n            let idx = (0x3F58D0u >> (u32(L) * 3u)) & 7u;\n            let bit = 3u * k + 16u;\n            if (bit <= 29u) {\n              nw0 = nw0 | (idx << bit);\n            } else if (bit >= 32u) {\n              nw1 = nw1 | (idx << (bit - 32u));\n            } else {\n              nw0 = nw0 | (idx << bit);\n              nw1 = nw1 | (idx >> (32u - bit));\n            }\n          }\n          if (refit_err < seed_err) {\n            return vec2<u32>(nw0, nw1);\n          }\n        }\n      }\n    }\n    return vec2<u32>(w0, w1);\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; the per-channel min/max scan is\n  // fused into the same loop.\n  var r_values: array<f32, 16>;\n  var g_values: array<f32, 16>;\n  var r_min: f32 = 1.0; var r_max: f32 = 0.0;\n  var g_min: f32 = 1.0; var g_max: f32 = 0.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    // 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    r_min = min(r_min, c.r); r_max = max(r_max, c.r);\n    g_min = min(g_min, c.g); g_max = max(g_max, c.g);\n  }\n\n  let r_block = encode_bc4(&r_values, r_min, r_max);\n  let g_block = encode_bc4(&g_values, g_min, g_max);\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. This is the f32\n// fallback; bc5_fast_f16.wgsl is the same algorithm and is preferred when\n// the device reports shader-f16.\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 `bc4_ref.ts`\n// for the reference this encoder is validated against.\n//\n// Same algorithm as bc5_fast_f16.wgsl (see that file for the full notes):\n//   \u2022 both channels processed as vec2 lanes of the fused passes;\n//   \u2022 pass 1 accumulates MOMENTS (\u03A3L, \u03A3L\xB2, \u03A3\u03C1, \u03A3L\u03C1) from which every LSQ\n//     normal-equation sum is an O(1) per-block expression; the rank guard\n//     is the exact 16\xB7\u03A3L\xB2 == (\u03A3L)\xB2 test;\n//   \u2022 the closed-form refit prices the nearest rounding of the solve\n//     through E(\u03B4) = err \u2212 2(\u03B40\xB7sAR + \u03B41\xB7sBR) + \u03B40\xB2sAA + 2\u03B40\u03B41\xB7sAB\n//     + \u03B41\xB2sBB, accept-if-better;\n//   \u2022 pass 2 packs the indices ONCE, against the FINAL endpoints \u2014 full\n//     reprojection quality at parity cost;\n//   \u2022 the 16 texel reads are 8 textureGather fetches (4 quads \xD7 R,G)\n//     through a clamp-to-edge sampler, byte-identical to per-texel loads;\n//   \u2022 3-bit indices accumulate branch-free into two 24-bit words (pixels\n//     0..7 and 8..15) recombined with constant shifts \u2014 no per-pixel\n//     straddle branches.\n// Values are kept in the [0,255] f32 domain throughout.\n//\n// Level \u2192 BC4 index LUT (0,2,3,4,5,6,7,1) packed as 3-bit entries in\n// 0x3F58D0.\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@group(0) @binding(3) var smp: sampler;\n\nconst IDX_LUT: u32 = 0x3F58D0u;\n\n// Closed-form accept-if-better endpoint refinement for one channel \u2014 same\n// as the f16 module's `refine` (both run this per-block step in f32).\n// Endpoints clamp to [0,255], NOT the block's value range: for a scalar\n// channel, endpoints beyond the data range are often genuinely optimal and\n// there is no colour axis to bend.\nfn refine(sAA: f32, sBB: f32, sAB: f32, sAR: f32, sBR: f32, b0: u32, b1: u32, spread: bool) -> vec2<u32> {\n  var out = vec2<u32>(b0, b1);\n  let det = sAA * sBB - sAB * sAB;\n  if (!spread || abs(det) <= 1e-3) { return out; }\n  let b0f = f32(b0);\n  let b1f = f32(b1);\n  let e0 = clamp(b0f + (sBB * sAR - sAB * sBR) / det, 0.0, 255.0);\n  let e1 = clamp(b1f + (sAA * sBR - sAB * sAR) / det, 0.0, 255.0);\n  let q0f = floor(e0 + 0.5);\n  let q1f = floor(e1 + 0.5);\n  let q0 = u32(q0f);\n  let q1 = u32(q1f);\n  if (q0 > q1 && !(q0 == b0 && q1 == b1)) {\n    let dd0 = q0f - b0f;\n    let dd1 = q1f - b1f;\n    let eNew = -2.0 * (dd0 * sAR + dd1 * sBR)\n      + dd0 * dd0 * sAA + 2.0 * dd0 * dd1 * sAB + dd1 * dd1 * sBB;\n    if (eNew < 0.0) {\n      out = vec2<u32>(q0, q1);\n    }\n  }\n  return out;\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  let bi = gid.y * params.blocks_x + gid.x;\n  let base = vec2<i32>(i32(gid.x) * 4, i32(gid.y) * 4);\n\n  // Load 4\xD74 R/G pairs (x = R, y = G throughout), min/max fused in.\n  // Interior blocks read via 8 gathers normalised by the PHYSICAL (padded)\n  // texture size; blocks straddling the source edge of a non-multiple-of-4\n  // image fall back to per-texel loads clamped to the last real texel (the\n  // padding strip is zero-initialised \u2014 see bc5_fast_f16.wgsl).\n  // Gather components: w=(0,0) z=(1,0) x=(0,1) y=(1,1) within each quad.\n  var v: array<vec2<f32>, 16>;\n  var vmin = vec2<f32>(255.0);\n  var vmax = vec2<f32>(0.0);\n  if (u32(base.x) + 4u <= params.width && u32(base.y) + 4u <= params.height) {\n    let inv_size = vec2<f32>(1.0, 1.0) / vec2<f32>(textureDimensions(src_tex));\n    for (var q: u32 = 0u; q < 4u; q = q + 1u) {\n      let qo = vec2<u32>((q & 1u) * 2u, (q >> 1u) * 2u);\n      let cc = (vec2<f32>(base) + vec2<f32>(qo) + vec2<f32>(1.0, 1.0)) * inv_size;\n      let r4 = textureGather(0, src_tex, smp, cc) * 255.0;\n      let g4 = textureGather(1, src_tex, smp, cc) * 255.0;\n      let i = qo.y * 4u + qo.x;\n      let vw = vec2<f32>(r4.w, g4.w);\n      let vz = vec2<f32>(r4.z, g4.z);\n      let vx = vec2<f32>(r4.x, g4.x);\n      let vy = vec2<f32>(r4.y, g4.y);\n      v[i] = vw; v[i + 1u] = vz; v[i + 4u] = vx; v[i + 5u] = vy;\n      vmin = min(min(vmin, min(vw, vz)), min(vx, vy));\n      vmax = max(max(vmax, max(vw, vz)), max(vx, vy));\n    }\n  } else {\n    let mx = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\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), mx);\n      let c = textureLoad(src_tex, p, 0);\n      let val = vec2<f32>(c.r, c.g) * 255.0;\n      v[i] = val; vmin = min(vmin, val); vmax = max(vmax, val);\n    }\n  }\n\n  // Seed endpoints at the exact per-channel extremes (round-to-nearest, the\n  // same rule the CPU reference uses). Flat blocks get nudged apart to keep\n  // the 6-interp mode (r0 > r1 strictly).\n  var r0 = vec2<u32>(clamp(floor(vmax + 0.5), vec2<f32>(0.0), vec2<f32>(255.0)));\n  var r1 = vec2<u32>(clamp(floor(vmin + 0.5), vec2<f32>(0.0), vec2<f32>(255.0)));\n  if (r0.x == r1.x) { if (r1.x > 0u) { r1.x = r1.x - 1u; } else { r0.x = r0.x + 1u; } }\n  if (r0.y == r1.y) { if (r1.y > 0u) { r1.y = r1.y - 1u; } else { r0.y = r0.y + 1u; } }\n\n  let r0f = vec2<f32>(r0);\n  let r1f = vec2<f32>(r1);\n  let dir = r1f - r0f;\n  let scale = vec2<f32>(7.0) / dir;\n\n  // Pass 1, both channels \u2014 MOMENTS only. t = 7(v\u2212r0)/(r1\u2212r0) \u2208 [0,7]\n  // (the seed covers the data), L = round(t), \u03C1 = t \u2212 L.\n  var sL = vec2<f32>(0.0); var sLL = vec2<f32>(0.0);\n  var pR = vec2<f32>(0.0); var pLR = vec2<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let t = (v[k] - r0f) * scale;\n    let L = clamp(floor(t + 0.5), vec2<f32>(0.0), vec2<f32>(7.0));\n    let rho = t - L;\n    sL = sL + L; sLL = sLL + L * L;\n    pR = pR + rho; pLR = pLR + L * rho;\n  }\n\n  // Per-block refit off the moments (see bc5_fast_f16.wgsl for the\n  // identities).\n  let sBB = sLL * (1.0 / 49.0);\n  let sAB = sL * (1.0 / 7.0) - sBB;\n  let sAA = vec2<f32>(16.0) - 2.0 * sL * (1.0 / 7.0) + sBB;\n  let sBR = pLR * dir * (1.0 / 49.0);\n  let sAR = (pR - pLR * (1.0 / 7.0)) * dir * (1.0 / 7.0);\n  let spread = 16.0 * sLL != sL * sL;\n\n  let fx = refine(sAA.x, sBB.x, sAB.x, sAR.x, sBR.x, r0.x, r1.x, spread.x);\n  let fy = refine(sAA.y, sBB.y, sAB.y, sAR.y, sBR.y, r0.y, r1.y, spread.y);\n  let n0 = vec2<u32>(fx.x, fy.x);\n  let n1 = vec2<u32>(fx.y, fy.y);\n\n  // Pass 2, both channels \u2014 pack the shipped indices against the FINAL\n  // endpoints (rejected channels re-derive their seed assignment). iA\n  // holds pixels 0..7 (3 bits each), iB pixels 8..15.\n  let n0f = vec2<f32>(n0);\n  let n1f = vec2<f32>(n1);\n  let scale2 = vec2<f32>(7.0) / (n1f - n0f);\n  var iAx = 0u; var iBx = 0u; var iAy = 0u; var iBy = 0u;\n  for (var k: u32 = 0u; k < 8u; k = k + 1u) {\n    let L = clamp(floor((v[k] - n0f) * scale2 + 0.5), vec2<f32>(0.0), vec2<f32>(7.0));\n    iAx = iAx | (((IDX_LUT >> (u32(L.x) * 3u)) & 7u) << (k * 3u));\n    iAy = iAy | (((IDX_LUT >> (u32(L.y) * 3u)) & 7u) << (k * 3u));\n  }\n  for (var k: u32 = 8u; k < 16u; k = k + 1u) {\n    let L = clamp(floor((v[k] - n0f) * scale2 + 0.5), vec2<f32>(0.0), vec2<f32>(7.0));\n    iBx = iBx | (((IDX_LUT >> (u32(L.x) * 3u)) & 7u) << ((k - 8u) * 3u));\n    iBy = iBy | (((IDX_LUT >> (u32(L.y) * 3u)) & 7u) << ((k - 8u) * 3u));\n  }\n\n  // BC5 block = R half (bytes 0..7) || G half (bytes 8..15) = 4 u32s.\n  let o = bi * 4u;\n  dst[o] = n0.x | (n1.x << 8u) | (iAx << 16u);\n  dst[o + 1u] = (iAx >> 16u) | (iBx << 8u);\n  dst[o + 2u] = n0.y | (n1.y << 8u) | (iAy << 16u);\n  dst[o + 3u] = (iAy >> 16u) | (iBy << 8u);\n}\n";
 
 // src/bc5_fast_f16.wgsl
 var bc5_fast_f16_default = `// bc5 "fast" encoder \u2014 f16 variant (requires the shader-f16 feature).
-// Two BC4 halves (R and G) \u2014 same output family as bc5.wgsl's fast branch,
-// tuned for throughput:
+// Two BC4 halves (R and G) \u2014 same output family as bc5.wgsl, tuned for
+// throughput:
 //
 //   \u2022 The 8-entry palette in 6-interpolation mode is COLINEAR and EVENLY
 //     spaced from r0 to r1 (levels 0..7 in palette order 0,2,3,4,5,6,7,1),
@@ -684,138 +1252,107 @@ var bc5_fast_f16_default = `// bc5 "fast" encoder \u2014 f16 variant (requires t
 //   \u2022 Math runs in the exact-integer [0,255] f16 domain: endpoints and pixel
 //     values are whole numbers \u2264 255 (exact in f16), so the only rounding is
 //     the single 1/(r1\u2212r0) division.
-//   \u2022 ONE fused pass per channel: projection assignment + the least-squares
-//     refit sums + the seed solution's packed indices and squared error. The
-//     refit endpoints are re-quantised, reprojected, and accepted only if
-//     the block error decreases (same accept-if-better family as the BC1
-//     fast path) \u2014 worth ~1.3 dB on the normal-map card.
-//   \u2022 3-bit indices are packed into the 48-bit field on the fly \u2014 no
-//     array<u32,16> private array and no separate packing loop.
-//
-// f16 range notes: value sums accumulate v \u2212 r0 (the affine-basis shift trick
-// from the BC7/ASTC fast paths) scaled by 1/16, and error residuals are
-// scaled by 1/16 before squaring \u2014 worst-case magnitudes stay \u22724k, well
-// inside f16's 65504 max, with rounding a small fraction of a level. The
-// accept-if-better guard makes any residual f16 noise fail-safe (worst case:
-// the refit is rejected and the seed solution ships).
+//   \u2022 BOTH channels ride the same fused passes as vec2<f16> lanes \u2014 each
+//     loop computes projections and moments for R and G at once instead of
+//     two scalar encode_bc4 calls.
+//   \u2022 The 16 texel reads are 8 textureGather fetches (4 quads \xD7 R,G) for
+//     interior blocks \u2014 byte-identical output to per-texel loads, \u22123.6%
+//     GPU on 4096\xB2 (/ab, 2026-07). Blocks straddling the source edge of a
+//     non-multiple-of-4 image use clamped per-texel loads instead: the
+//     upload pads the texture with ZEROS, so a normalised-coordinate
+//     gather there would read padding (or mis-scale against the padded
+//     size) instead of replicating the last real texel.
+//   \u2022 Pass 1 accumulates MOMENTS, not normal-equation sums. With b = L/7
+//     and the level-space residual \u03C1 = t \u2212 L (t = 7(v\u2212r0)/(r1\u2212r0), so the
+//     value-space residual is r = \u03C1\xB7dir/7), every LSQ sum is an O(1)
+//     per-block function of four accumulators:
+//       sBB = \u03A3L\xB2/49       sAB = \u03A3L/7 \u2212 \u03A3L\xB2/49    sAA = 16 \u2212 2\u03A3L/7 + \u03A3L\xB2/49
+//       sBR = \u03A3L\u03C1\xB7dir/49   sAR = (\u03A3\u03C1 \u2212 \u03A3L\u03C1/7)\xB7dir/7
+//     Per-pixel work drops from 5 product-accumulates + 3 temporaries to 4
+//     cheap accumulates (\u03A3L, \u03A3L\xB2, \u03A3\u03C1, \u03A3L\u03C1), and the f16 range analysis
+//     becomes trivial: \u03A3L \u2264 112 and \u03A3L\xB2 \u2264 784 are exact f16 integers,
+//     |\u03C1| \u2264 ~0.5 keeps \u03A3\u03C1/\u03A3L\u03C1 tiny. The per-BLOCK refit math (including
+//     the solve and E(\u03B4) pricing) runs in f32 \u2014 free at block granularity,
+//     and it retires the sum-cancellation worries the old residual-sum
+//     scheme was built around.
+//   \u2022 The rank guard is EXACT: all pixels on one level \u27FA 16\xB7\u03A3L\xB2 == (\u03A3L)\xB2
+//     (integers, so the comparison is precise in f32) \u2014 no lmin/lmax
+//     tracking in the loop.
+//   \u2022 The refit is accepted or rejected CLOSED-FORM, with no trial
+//     projection pass: the solve is e = seed + M\u207B\xB9(sAR,sBR), and the error
+//     of re-quantised endpoints ON THE CURRENT INDICES is
+//       E(\u03B4) = err \u2212 2(\u03B40\xB7sAR + \u03B41\xB7sBR) + \u03B40\xB2sAA + 2\u03B40\u03B41\xB7sAB + \u03B41\xB2sBB
+//     with \u03B4 = quantised endpoint \u2212 base endpoint, compared as the delta
+//     form E \u2212 err < 0. Only the NEAREST rounding of the fractional solve
+//     is priced: pricing all four floor/ceil combinations (the correlated
+//     2-D quadratic's integer optimum isn't always the nearest rounding)
+//     measured \u22640.015 dB on every content class but ~8% GPU on smooth
+//     content, where Apple's lossless texture compression collapses the
+//     read cost and leaves the kernel ALU-bound (/ab 2026-07, rock 4K
+//     displacement: floor 0.61\xD7 of the rgba8-noise floor).
+//   \u2022 Pass 2 packs the indices ONCE, against the FINAL endpoints \u2014 full
+//     reprojection quality. The previous single-pass scheme shipped the
+//     SEED indices with accepted refit endpoints, giving up 0.08..0.19 dB
+//     because a third reprojection loop cost +14% GPU; with the moment
+//     form paying for the second loop, reprojection now measures at PARITY
+//     with that scheme (/ab 2026-07, interleaved: proc 2048\xB2/4096\xB2 and the
+//     rock 4K normal map, all within \xB11%, vs read floor ~2% below).
+//     Measured and NOT taken: a second refit round off pass-2 moments
+//     (+14%, register cliff, \u22480 gain on smooth content \u2014 round 2 only pays
+//     on noise); full normal-equation sums in both passes (+49%).
+//   \u2022 3-bit indices are packed BRANCH-FREE: pixels 0..7 accumulate into a
+//     24-bit word, pixels 8..15 into another, recombined with constant
+//     shifts into the 48-bit field (w0 gets field bits 0..15 above the two
+//     endpoint bytes, w1 gets field bits 16..47) \u2014 no per-pixel straddle
+//     branches.
 //
 // Level \u2192 BC4 index (0\u2192r0 ... 7\u2192r1): 0,2,3,4,5,6,7,1 \u2014 packed 3-bit LUT
 // 0x3F58D0 = sum(idx[L] << 3L).
 //
 // The host selects this module only when the device reports shader-f16,
-// falling back to bc5.wgsl otherwise. "high" never uses this.
+// falling back to bc5.wgsl otherwise.
 enable f16;
 alias h = f16;
+alias h2 = vec2<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;
+@group(0) @binding(3) var smp: sampler;
 
-// Project the 16 values onto the r0\u2192r1 axis, packing the 3-bit indices on the
-// fly (pixel k's index starts at bit 3k of the 48-bit field, i.e. bit 3k+16
-// of the (w0,w1) pair; k = 5 straddles the word boundary) and accumulating
-// the squared error (residuals scaled by 1/16 before squaring). Returns the
-// packed words with the endpoint bytes already in place.
-struct Proj { w0: u32, w1: u32, err: h };
-fn project_pack(values: ptr<function, array<h, 16>>, r0: u32, r1: u32) -> Proj {
-  let r0f = h(f32(r0));
-  let dir = h(f32(r1)) - r0f;
-  let scale = h(7.0) / dir;
-  var out: Proj;
-  out.w0 = r0 | (r1 << 8u);
-  out.w1 = 0u;
-  out.err = h(0.0);
-  for (var k: u32 = 0u; k < 16u; k = k + 1u) {
-    let vr = (*values)[k] - r0f;
-    let L = clamp(floor(vr * scale + h(0.5)), h(0.0), h(7.0));
-    let e = (vr - L * h(1.0 / 7.0) * dir) * h(1.0 / 16.0);
-    out.err = out.err + e * e;
-    let idx = (0x3F58D0u >> (u32(L) * 3u)) & 7u;
-    let bit = 3u * k + 16u;
-    if (bit <= 29u) {
-      out.w0 = out.w0 | (idx << bit);
-    } else if (bit >= 32u) {
-      out.w1 = out.w1 | (idx << (bit - 32u));
-    } else {
-      out.w0 = out.w0 | (idx << bit);
-      out.w1 = out.w1 | (idx >> (32u - bit));
-    }
-  }
-  return out;
-}
-
-// Encode one channel (16 values in exact-integer [0,255] f16) to a BC4 half.
-// vmin/vmax are the channel's min/max, computed in the caller's load loop \u2014
-// fusing that scan there saves a 16-value pass per channel.
-fn encode_bc4(values: ptr<function, array<h, 16>>, vmin: h, vmax: h) -> vec2<u32> {
-  var r0 = u32(vmax); // values are exact integers \u2014 no rounding needed
-  var r1 = u32(vmin);
-  if (r0 == r1) {
-    // Flat block: nudge to keep 6-interp mode (r0 > r1 strictly).
-    if (r1 > 0u) { r1 = r1 - 1u; } else { r0 = r0 + 1u; }
-  }
-
-  // Fused seed pass: projection assignment (level = round(7\xB7(v \u2212 r0)/
-  // (r1 \u2212 r0)), clamped \u2014 |v \u2212 r0| \u2264 r0 \u2212 r1 for in-block values) + packed
-  // indices + seed error + the LSQ normal-equation sums. Value sums
-  // accumulate (v \u2212 r0)/16: the shift keeps the accumulators proportional to
-  // the block's span, the exact power-of-two scale keeps products \u2264 4080.
-  let r0f = h(f32(r0));
-  let dir = h(f32(r1)) - r0f;
-  let scale = h(7.0) / dir;
-  var seed: Proj;
-  seed.w0 = r0 | (r1 << 8u);
-  seed.w1 = 0u;
-  seed.err = h(0.0);
-  var sAA = h(0.0); var sBB = h(0.0); var sAB = h(0.0);
-  var sAV = h(0.0); var sBV = h(0.0);
-  var s_min = h(7.0); var s_max = h(0.0);
-  for (var k: u32 = 0u; k < 16u; k = k + 1u) {
-    let vr = (*values)[k] - r0f;
-    let L = clamp(floor(vr * scale + h(0.5)), h(0.0), h(7.0));
-    s_min = min(s_min, L); s_max = max(s_max, L);
-    let b = L * h(1.0 / 7.0); let a = h(1.0) - b;
-    let vr16 = vr * h(1.0 / 16.0);
-    sAA = sAA + a * a; sBB = sBB + b * b; sAB = sAB + a * b;
-    sAV = sAV + a * vr16; sBV = sBV + b * vr16;
-    let e = vr16 - b * dir * h(1.0 / 16.0);
-    seed.err = seed.err + e * e;
-    let idx = (0x3F58D0u >> (u32(L) * 3u)) & 7u;
-    let bit = 3u * k + 16u;
-    if (bit <= 29u) {
-      seed.w0 = seed.w0 | (idx << bit);
-    } else if (bit >= 32u) {
-      seed.w1 = seed.w1 | (idx << (bit - 32u));
-    } else {
-      // k = 5 straddles the word boundary (bits 31..33).
-      seed.w0 = seed.w0 | (idx << bit);
-      seed.w1 = seed.w1 | (idx >> (32u - bit));
-    }
-  }
+const IDX_LUT: u32 = 0x3F58D0u;
 
-  // LSQ refit, accepted only if the requantised endpoints lower the block
-  // error. Rank-1 guard: with every pixel on ONE level the system is
-  // singular and det is pure f16 rounding noise (\u22720.03); with \u22652 distinct
-  // levels det = \u03A3_i<j (b_j \u2212 b_i)\xB2 \u2265 15/49 \u2248 0.306 \u2014 0.1 separates cleanly.
-  if (s_min < s_max) {
-    let det = sAA * sBB - sAB * sAB;
-    if (abs(det) > h(0.1)) {
-      // \xD716 undoes the accumulator scale; clamp to the block's value range
-      // (a strict-SSE win vs clamping to [0,255], same as the other formats).
-      let e0 = clamp(r0f + (sBB * sAV - sAB * sBV) * h(16.0) / det, vmin, vmax);
-      let e1 = clamp(r0f + (sAA * sBV - sAB * sAV) * h(16.0) / det, vmin, vmax);
-      let n0 = u32(floor(e0 + h(0.5)));
-      let n1 = u32(floor(e1 + h(0.5)));
-      // Keep 6-interp mode (r0 > r1 strictly); skip the no-op refit.
-      if (n0 > n1 && !(n0 == r0 && n1 == r1)) {
-        let refit = project_pack(values, n0, n1);
-        if (refit.err < seed.err) {
-          return vec2<u32>(refit.w0, refit.w1);
-        }
-      }
+// Closed-form accept-if-better endpoint refinement for one channel (f32:
+// per-block O(1) work, so precision is free here). Takes the LSQ sums for
+// the current indices, the current integer endpoints b0 > b1, and the rank
+// guard; prices the nearest rounding of the fractional solve via E(\u03B4) and
+// returns it when it strictly improves and stays in 6-interp mode
+// (q0 > q1), or (b0,b1) unchanged. Endpoints clamp to [0,255], NOT the
+// block's value range: for a scalar channel, endpoints beyond the data
+// range are often genuinely optimal and there is no colour axis to bend
+// (the bbox clamp the colour formats need costs ~0.3 dB here).
+fn refine(sAA: f32, sBB: f32, sAB: f32, sAR: f32, sBR: f32, b0: u32, b1: u32, spread: bool) -> vec2<u32> {
+  var out = vec2<u32>(b0, b1);
+  let det = sAA * sBB - sAB * sAB;
+  if (!spread || abs(det) <= 1e-3) { return out; }
+  let b0f = f32(b0);
+  let b1f = f32(b1);
+  let e0 = clamp(b0f + (sBB * sAR - sAB * sBR) / det, 0.0, 255.0);
+  let e1 = clamp(b1f + (sAA * sBR - sAB * sAR) / det, 0.0, 255.0);
+  let q0f = floor(e0 + 0.5);
+  let q1f = floor(e1 + 0.5);
+  let q0 = u32(q0f);
+  let q1 = u32(q1f);
+  if (q0 > q1 && !(q0 == b0 && q1 == b1)) {
+    let dd0 = q0f - b0f;
+    let dd1 = q1f - b1f;
+    let eNew = -2.0 * (dd0 * sAR + dd1 * sBR)
+      + dd0 * dd0 * sAA + 2.0 * dd0 * dd1 * sAB + dd1 * dd1 * sBB;
+    if (eNew < 0.0) {
+      out = vec2<u32>(q0, q1);
     }
   }
-  return vec2<u32>(seed.w0, seed.w1);
+  return out;
 }
 
 @compute @workgroup_size(8, 8, 1)
@@ -823,23 +1360,110 @@ 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 rv: array<h, 16>;
-  var gv: array<h, 16>;
-  var rmin = h(255.0); var rmax = h(0.0);
-  var gmin = h(255.0); var gmax = h(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 c = textureLoad(src_tex, p, 0);
-    let r = h(c.r * 255.0);
-    let g = h(c.g * 255.0);
-    rv[i] = r; rmin = min(rmin, r); rmax = max(rmax, r);
-    gv[i] = g; gmin = min(gmin, g); gmax = max(gmax, g);
-  }
-  let rb = encode_bc4(&rv, rmin, rmax);
-  let gb = encode_bc4(&gv, gmin, gmax);
+
+  // Load 4\xD74 R/G pairs (x = R, y = G throughout), min/max fused in.
+  // INTERIOR blocks \u2014 every block when the source is a multiple of 4, so
+  // the branch is wavefront-uniform on benchmark-shaped content \u2014 read via
+  // 8 gathers (4 quads \xD7 R,G); the gather point (base+quad+1) normalised by
+  // the PHYSICAL (padded) texture size sits exactly between the quad's
+  // texel centers, and interior quads never touch the zero-initialised
+  // padding strip. Blocks straddling the source edge of a
+  // non-multiple-of-4 image fall back to per-texel loads clamped to the
+  // last real texel (gather cannot replicate an edge texel mid-quad).
+  // Gather components: w=(0,0) z=(1,0) x=(0,1) y=(1,1) within each quad.
+  var v: array<h2, 16>;
+  var vmin = h2(255.0);
+  var vmax = h2(0.0);
+  if (u32(base.x) + 4u <= params.width && u32(base.y) + 4u <= params.height) {
+    let inv_size = vec2<f32>(1.0, 1.0) / vec2<f32>(textureDimensions(src_tex));
+    for (var q: u32 = 0u; q < 4u; q = q + 1u) {
+      let qo = vec2<u32>((q & 1u) * 2u, (q >> 1u) * 2u);
+      let cc = (vec2<f32>(base) + vec2<f32>(qo) + vec2<f32>(1.0, 1.0)) * inv_size;
+      let r4 = textureGather(0, src_tex, smp, cc) * 255.0;
+      let g4 = textureGather(1, src_tex, smp, cc) * 255.0;
+      let i = qo.y * 4u + qo.x;
+      let vw = h2(h(r4.w), h(g4.w));
+      let vz = h2(h(r4.z), h(g4.z));
+      let vx = h2(h(r4.x), h(g4.x));
+      let vy = h2(h(r4.y), h(g4.y));
+      v[i] = vw; v[i + 1u] = vz; v[i + 4u] = vx; v[i + 5u] = vy;
+      vmin = min(min(vmin, min(vw, vz)), min(vx, vy));
+      vmax = max(max(vmax, max(vw, vz)), max(vx, vy));
+    }
+  } else {
+    let mx = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);
+    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);
+      let val = h2(h(c.r * 255.0), h(c.g * 255.0));
+      v[i] = val; vmin = min(vmin, val); vmax = max(vmax, val);
+    }
+  }
+
+  // Seed endpoints at the exact per-channel extremes (values are exact
+  // integers \u2014 no rounding needed). Flat blocks get nudged apart to keep
+  // the 6-interp mode (r0 > r1 strictly).
+  var r0 = vec2<u32>(vmax);
+  var r1 = vec2<u32>(vmin);
+  if (r0.x == r1.x) { if (r1.x > 0u) { r1.x = r1.x - 1u; } else { r0.x = r0.x + 1u; } }
+  if (r0.y == r1.y) { if (r1.y > 0u) { r1.y = r1.y - 1u; } else { r0.y = r0.y + 1u; } }
+
+  let r0f = h2(vec2<f32>(r0));
+  let r1f = h2(vec2<f32>(r1));
+  let dir = r1f - r0f;
+  let scale = h2(7.0) / dir;
+
+  // Pass 1, both channels \u2014 MOMENTS only. t = 7(v\u2212r0)/(r1\u2212r0) \u2208 [0,7]
+  // (the seed covers the data), L = round(t), \u03C1 = t \u2212 L.
+  var sL = h2(0.0); var sLL = h2(0.0); var pR = h2(0.0); var pLR = h2(0.0);
+  for (var k: u32 = 0u; k < 16u; k = k + 1u) {
+    let t = (v[k] - r0f) * scale;
+    let L = clamp(floor(t + h2(0.5)), h2(0.0), h2(7.0));
+    let rho = t - L;
+    sL = sL + L; sLL = sLL + L * L;
+    pR = pR + rho; pLR = pLR + L * rho;
+  }
+
+  // Per-block refit in f32 off the moments (see header for the identities).
+  let sLf = vec2<f32>(sL);
+  let sLLf = vec2<f32>(sLL);
+  let dirf = vec2<f32>(r1) - vec2<f32>(r0);
+  let sBB = sLLf * (1.0 / 49.0);
+  let sAB = sLf * (1.0 / 7.0) - sBB;
+  let sAA = vec2<f32>(16.0) - 2.0 * sLf * (1.0 / 7.0) + sBB;
+  let sBR = vec2<f32>(pLR) * dirf * (1.0 / 49.0);
+  let sAR = (vec2<f32>(pR) - vec2<f32>(pLR) * (1.0 / 7.0)) * dirf * (1.0 / 7.0);
+  let spread = 16.0 * sLLf != sLf * sLf;
+
+  let fx = refine(sAA.x, sBB.x, sAB.x, sAR.x, sBR.x, r0.x, r1.x, spread.x);
+  let fy = refine(sAA.y, sBB.y, sAB.y, sAR.y, sBR.y, r0.y, r1.y, spread.y);
+  let n0 = vec2<u32>(fx.x, fy.x);
+  let n1 = vec2<u32>(fx.y, fy.y);
+
+  // Pass 2, both channels \u2014 pack the shipped indices against the FINAL
+  // endpoints (rejected channels re-derive their seed assignment). iA
+  // holds pixels 0..7 (3 bits each), iB pixels 8..15.
+  let n0f = h2(vec2<f32>(n0));
+  let n1f = h2(vec2<f32>(n1));
+  let scale2 = h2(7.0) / (n1f - n0f);
+  var iAx = 0u; var iBx = 0u; var iAy = 0u; var iBy = 0u;
+  for (var k: u32 = 0u; k < 8u; k = k + 1u) {
+    let L = clamp(floor((v[k] - n0f) * scale2 + h2(0.5)), h2(0.0), h2(7.0));
+    iAx = iAx | (((IDX_LUT >> (u32(L.x) * 3u)) & 7u) << (k * 3u));
+    iAy = iAy | (((IDX_LUT >> (u32(L.y) * 3u)) & 7u) << (k * 3u));
+  }
+  for (var k: u32 = 8u; k < 16u; k = k + 1u) {
+    let L = clamp(floor((v[k] - n0f) * scale2 + h2(0.5)), h2(0.0), h2(7.0));
+    iBx = iBx | (((IDX_LUT >> (u32(L.x) * 3u)) & 7u) << ((k - 8u) * 3u));
+    iBy = iBy | (((IDX_LUT >> (u32(L.y) * 3u)) & 7u) << ((k - 8u) * 3u));
+  }
+
+  // BC5 block = R half (bytes 0..7) || G half (bytes 8..15) = 4 u32s.
   let o = bi * 4u;
-  dst[o] = rb.x; dst[o + 1u] = rb.y; dst[o + 2u] = gb.x; dst[o + 3u] = gb.y;
+  dst[o] = n0.x | (n1.x << 8u) | (iAx << 16u);
+  dst[o + 1u] = (iAx >> 16u) | (iBx << 8u);
+  dst[o + 2u] = n0.y | (n1.y << 8u) | (iAy << 16u);
+  dst[o + 3u] = (iAy >> 16u) | (iBy << 8u);
 }
 `;
 
@@ -856,8 +1480,13 @@ var BC5Encoder = class extends Encoder {
   get supportsSrgb() {
     return false;
   }
-  get supportsQuality() {
-    return true;
+  // BC5 stores only R and G — a two-channel source texture halves the
+  // encode pass's DRAM reads. Measured on the pass (/ab 2026-07): −4% on a
+  // real 4K normal map, −8..−12% on procedural 2048²/4096², and the raw
+  // read floor itself drops 35%, so the win grows as the kernel's ALU
+  // shrinks. Also halves source-texture memory during encodes.
+  get srcTextureFormat() {
+    return "rg8unorm";
   }
   wgslSource() {
     return bc5_default;
@@ -871,202 +1500,25 @@ var BC5Encoder = class extends Encoder {
 };
 
 // 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// QUALITY LEVELS (pipeline-overridable constant `QUALITY_HIGH`)\n//   fast (0, default): principal-axis seed (covariance power-iteration; bbox\n//     on degenerate blocks) at the exact projection extents, quantised\n//     directly \u2014 no LSQ refit; with the seed on the principal axis, mode 6's\n//     16-level palette leaves the refit under 0.15 dB, unlike the 4-level\n//     BC1/ASTC fast paths which keep theirs \u2014 then one pass that projects\n//     each pixel onto the endpoint line (the 16 palette entries are\n//     colinear, so the nearest index is the rounded projection \u2014 no palette\n//     build, no 16-entry search), packed on the fly into two nibble words.\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//     matches bc7_ref.ts up to FP tie-breaks.\n//\n// The fast/high branch is selected at pipeline-compile time, so the driver\n// eliminates the unused code entirely.\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// The block is assembled with straight-line constant shifts (see the layout\n// summary in bc7_fast_f16.wgsl) \u2014 a generic write_bits() helper's dynamic\n// word indexing keeps the output array out of registers.\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// Principal colour axis via power-iteration over precomputed, mean-corrected\n// covariance rows (the moments are accumulated for free in the pixel-load\n// loop), seeded with the bbox diagonal. Returns a unit axis, or vec4(0) for\n// a degenerate (constant) block. Same family as bc1.wgsl's principal_axis;\n// used by the fast path to seed the LSQ fit \u2014 the bbox diagonal is\n// sign-blind and points across anti-correlated data (normal maps, hue edges)\n// instead of along it.\nfn principal_axis4(\n  c0v: vec4<f32>,\n  c1v: vec4<f32>,\n  c2v: vec4<f32>,\n  c3v: vec4<f32>,\n  seed: vec4<f32>,\n) -> vec4<f32> {\n  var v = seed;\n  var len = length(v);\n  if (len < 1e-9) { return vec4<f32>(0.0); }\n  v = v / len;\n  for (var iter: u32 = 0u; iter < 8u; iter = iter + 1u) {\n    let nv = vec4<f32>(dot(c0v, v), dot(c1v, v), dot(c2v, v), dot(c3v, v));\n    len = length(nv);\n    if (len < 1e-12) { return vec4<f32>(0.0); }\n    v = nv / len;\n  }\n  return v;\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// ------------------------------- 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  // with the covariance moments FUSED in: d = px \u2212 pixel0 (first-pixel-\n  // relative, so the sums scale with the block's span; d is integer-valued\n  // and \u2264255, exact in f32). Only the fast branch consumes the moment\n  // accumulators \u2014 the QUALITY_HIGH pipeline dead-code-eliminates them.\n  var pixels: array<vec4<i32>, 16>;\n  var lo = vec4<i32>(255);\n  var hi = vec4<i32>(0);\n  var p0f = vec4<f32>(0.0);\n  var sd = vec4<f32>(0.0);\n  var c0v = vec4<f32>(0.0);\n  var c1v = vec4<f32>(0.0);\n  var c2v = vec4<f32>(0.0);\n  var c3v = vec4<f32>(0.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    if (i == 0u) { p0f = vec4<f32>(px); }\n    let d = vec4<f32>(px) - p0f;\n    sd = sd + d;\n    c0v = c0v + d.x * d;\n    c1v = c1v + d.y * d;\n    c2v = c2v + d.z * d;\n    c3v = c3v + d.w * d;\n  }\n  let mean = p0f + sd * (1.0 / 16.0);\n\n  // Both branches produce: 7-bit endpoints + p-bits, and the 16 4-bit indices\n  // packed LSB-first into two nibble words (pixel k \u2192 bits 4k..4k+3).\n  var e0_7: vec4<i32>;\n  var e1_7: vec4<i32>;\n  var p0: u32;\n  var p1: u32;\n  var ilo: u32 = 0u;\n  var ihi: u32 = 0u;\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;\n    for (var k: u32 = 0u; k < 8u; k = k + 1u) {\n      ilo = ilo | (best.indices[k] << (k * 4u));\n    }\n    for (var k: u32 = 8u; k < 16u; k = k + 1u) {\n      ihi = ihi | (best.indices[k] << ((k - 8u) * 4u));\n    }\n  } else {\n    // Seed endpoints from the block's principal colour axis (covariance\n    // power-iteration; bbox on degenerate blocks) at the exact projection\n    // extents, quantise, and assign indices in one projection pass. No LSQ\n    // refit: with the seed already on the principal axis, mode 6's 16-level\n    // palette leaves the refit \u22640.05 dB on the colour card and \u22640.15 dB on\n    // the normal card \u2014 not worth its two extra 16-pixel passes (the coarse\n    // 4-level BC1/ASTC fast paths DO keep theirs).\n    // Mean-correct the fused moments: C = \u03A3dd\u1D40 \u2212 (\u03A3d)(\u03A3d)\u1D40/16.\n    let sd16 = sd * (1.0 / 16.0);\n    let r0v = c0v - sd.x * sd16;\n    let r1v = c1v - sd.y * sd16;\n    let r2v = c2v - sd.z * sd16;\n    let r3v = c3v - sd.w * sd16;\n    var seed0 = lo;\n    var seed1 = hi;\n    let axis = principal_axis4(r0v, r1v, r2v, r3v, vec4<f32>(hi - lo));\n    if (dot(axis, axis) > 0.0) {\n      // Exact projection extents along the axis. (A Rayleigh-quotient span\n      // estimate was tried in place of this pass \u2014 it saves 16 dots but\n      // costs 0.1\u20130.8 dB and 4\u201310\xD7 on the worst-easy-block gate: \u03C3\n      // misjudges two-cluster and outlier blocks. The pass stays.)\n      var t_min: f32 = 1e30;\n      var t_max: f32 = -1e30;\n      for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n        let t = dot(vec4<f32>(pixels[k]) - mean, axis);\n        t_min = min(t_min, t);\n        t_max = max(t_max, t);\n      }\n      seed0 = vec4<i32>(clamp(round(mean + t_min * axis), vec4<f32>(0.0), vec4<f32>(255.0)));\n      seed1 = vec4<i32>(clamp(round(mean + t_max * axis), vec4<f32>(0.0), vec4<f32>(255.0)));\n    }\n    let ep0 = pick_ep(seed0);\n    let ep1 = pick_ep(seed1);\n    let dir = vec4<f32>(ep1.eight - ep0.eight);\n    let dd = dot(dir, dir);\n    if (dd > 0.0) {\n      let e0f = vec4<f32>(ep0.eight);\n      let inv = 15.0 / dd;\n      for (var k: u32 = 0u; k < 8u; k = k + 1u) {\n        let s = clamp(floor(dot(vec4<f32>(pixels[k]) - e0f, dir) * inv + 0.5), 0.0, 15.0);\n        ilo = ilo | (u32(s) << (k * 4u));\n      }\n      for (var k: u32 = 8u; k < 16u; k = k + 1u) {\n        let s = clamp(floor(dot(vec4<f32>(pixels[k]) - e0f, dir) * inv + 0.5), 0.0, 15.0);\n        ihi = ihi | (u32(s) << ((k - 8u) * 4u));\n      }\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. Swapping endpoints reflects\n  // every index (i \u2192 15\u2212i), which on packed nibbles is a bitwise NOT.\n  if ((ilo & 0x8u) != 0u) {\n    let t7 = e0_7; e0_7 = e1_7; e1_7 = t7;\n    let tp = p0;   p0   = p1;   p1   = tp;\n    ilo = ~ilo; ihi = ~ihi;\n  }\n\n  // Straight-line mode-6 packing (see layout at the top of the file).\n  let e0 = vec4<u32>(e0_7);\n  let e1 = vec4<u32>(e1_7);\n  let w0 = 0x40u | (e0.x << 7u) | (e1.x << 14u) | (e0.y << 21u) | (e1.y << 28u);\n  let w1 = (e1.y >> 4u) | (e0.z << 3u) | (e1.z << 10u) | (e0.w << 17u) | (e1.w << 24u) | (p0 << 31u);\n  let w2 = p1 | ((ilo & 0x7u) << 1u) | (ilo & 0xFFFFFFF0u);\n  let w3 = ihi;\n\n  let out = block_index * 4u;\n  dst[out + 0u] = w0;\n  dst[out + 1u] = w1;\n  dst[out + 2u] = w2;\n  dst[out + 3u] = w3;\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]`. This is the f32 fallback;\n// bc7_fast_f16.wgsl is the same algorithm and is preferred when the device\n// reports shader-f16.\n//\n// ALGORITHM: principal-axis seed (covariance power-iteration; bbox on\n// degenerate blocks) at the exact projection extents, quantised directly \u2014\n// no LSQ refit; with the seed on the principal axis, mode 6's 16-level\n// palette leaves the refit under 0.15 dB, unlike the 4-level BC1/ASTC\n// encoders which keep theirs \u2014 then one pass that projects each pixel onto\n// the endpoint line (the 16 palette entries are colinear, so the nearest\n// index is the rounded projection \u2014 no palette build, no 16-entry search),\n// packed on the fly into two nibble words.\n//\n// A MODE 1 (2-subset) candidate was built and evaluated (2026-07) and\n// dropped: ~+1.3 dB on multi-modal content but up to ~3\xD7 the pass cost on\n// exactly that content \u2014 see bc7_fast_f16.wgsl. The CPU reference decoder\n// keeps mode 1 support (bc7_ref.ts).\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// The block is assembled with straight-line constant shifts (see the layout\n// summary in bc7_fast_f16.wgsl) \u2014 a generic write_bits() helper's dynamic\n// word indexing keeps the output array out of registers.\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 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)\n// under a fixed p-bit, all four channels at once. q7 = round((ideal8 \u2212 p)/2).\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// 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// Principal colour axis via power-iteration over precomputed, mean-corrected\n// covariance rows (the moments are accumulated for free in the pixel-load\n// loop), seeded with the bbox diagonal. Returns a unit axis, or vec4(0) for\n// a degenerate (constant) block. Same family as bc1.wgsl's principal_axis \u2014\n// the bbox diagonal alone is sign-blind and points across anti-correlated\n// data (normal maps, hue edges) instead of along it.\nfn principal_axis4(\n  c0v: vec4<f32>,\n  c1v: vec4<f32>,\n  c2v: vec4<f32>,\n  c3v: vec4<f32>,\n  seed: vec4<f32>,\n) -> vec4<f32> {\n  var v = seed;\n  var len = length(v);\n  if (len < 1e-9) { return vec4<f32>(0.0); }\n  v = v / len;\n  for (var iter: u32 = 0u; iter < 8u; iter = iter + 1u) {\n    let nv = vec4<f32>(dot(c0v, v), dot(c1v, v), dot(c2v, v), dot(c3v, v));\n    len = length(nv);\n    if (len < 1e-12) { return vec4<f32>(0.0); }\n    v = nv / len;\n  }\n  return v;\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  // with the covariance moments FUSED in: d = px \u2212 pixel0 (first-pixel-\n  // relative, so the sums scale with the block's span; d is integer-valued\n  // and \u2264255, exact in f32).\n  var pixels: array<vec4<i32>, 16>;\n  var lo = vec4<i32>(255);\n  var hi = vec4<i32>(0);\n  var gd = 0;\n  var p0f = vec4<f32>(0.0);\n  var sd = vec4<f32>(0.0);\n  var c0v = vec4<f32>(0.0);\n  var c1v = vec4<f32>(0.0);\n  var c2v = vec4<f32>(0.0);\n  var c3v = vec4<f32>(0.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    gd = max(gd, max(abs(px.x - px.y), abs(px.x - px.z)));\n    if (i == 0u) { p0f = vec4<f32>(px); }\n    let d = vec4<f32>(px) - p0f;\n    sd = sd + d;\n    c0v = c0v + d.x * d;\n    c1v = c1v + d.y * d;\n    c2v = c2v + d.z * d;\n    c3v = c3v + d.w * d;\n  }\n  let mean = p0f + sd * (1.0 / 16.0);\n\n  // Seed endpoints from the block's principal colour axis at the exact\n  // projection extents (see header), quantise, and assign indices in one\n  // projection pass.\n  // Mean-correct the fused moments: C = \u03A3dd\u1D40 \u2212 (\u03A3d)(\u03A3d)\u1D40/16.\n  let sd16 = sd * (1.0 / 16.0);\n  let r0v = c0v - sd.x * sd16;\n  let r1v = c1v - sd.y * sd16;\n  let r2v = c2v - sd.z * sd16;\n  let r3v = c3v - sd.w * sd16;\n  var seed0 = lo;\n  var seed1 = hi;\n  // Gray + opaque blocks: the axis is analytically (1,1,1,0)/\u221A3 with\n  // extents at the luma min/max \u2014 skip iteration + extents pass entirely\n  // (see bc7_fast_f16.wgsl).\n  let gray = lo.w == 255 && gd == 0;\n  if (gray) {\n    seed0 = vec4<i32>(lo.x, lo.x, lo.x, 255);\n    seed1 = vec4<i32>(hi.x, hi.x, hi.x, 255);\n  } else {\n    let axis = principal_axis4(r0v, r1v, r2v, r3v, vec4<f32>(hi - lo));\n    if (dot(axis, axis) > 0.0) {\n      // Exact projection extents along the axis. (A Rayleigh-quotient span\n      // estimate was tried in place of this pass \u2014 it saves 16 dots but\n      // costs 0.1\u20130.8 dB and 4\u201310\xD7 on the worst-easy-block gate: \u03C3\n      // misjudges two-cluster and outlier blocks. The pass stays.)\n      var t_min: f32 = 1e30;\n      var t_max: f32 = -1e30;\n      for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n        let t = dot(vec4<f32>(pixels[k]) - mean, axis);\n        t_min = min(t_min, t);\n        t_max = max(t_max, t);\n      }\n      seed0 = vec4<i32>(clamp(round(mean + t_min * axis), vec4<f32>(0.0), vec4<f32>(255.0)));\n      seed1 = vec4<i32>(clamp(round(mean + t_max * axis), vec4<f32>(0.0), vec4<f32>(255.0)));\n    }\n  }\n\n  // The 16 4-bit indices, packed LSB-first into two nibble words\n  // (pixel k \u2192 bits 4k..4k+3).\n  var ilo: u32 = 0u;\n  var ihi: u32 = 0u;\n  var ep0 = pick_ep(seed0);\n  var ep1 = pick_ep(seed1);\n  let dir = vec4<f32>(ep1.eight - ep0.eight);\n  let dd = dot(dir, dir);\n  if (dd > 0.0) {\n    let e0f = vec4<f32>(ep0.eight);\n    let inv = 15.0 / dd;\n    for (var k: u32 = 0u; k < 8u; k = k + 1u) {\n      let s = clamp(floor(dot(vec4<f32>(pixels[k]) - e0f, dir) * inv + 0.5), 0.0, 15.0);\n      ilo = ilo | (u32(s) << (k * 4u));\n    }\n    for (var k: u32 = 8u; k < 16u; k = k + 1u) {\n      let s = clamp(floor(dot(vec4<f32>(pixels[k]) - e0f, dir) * inv + 0.5), 0.0, 15.0);\n      ihi = ihi | (u32(s) << ((k - 8u) * 4u));\n    }\n  }\n  var e0_7 = ep0.seven;\n  var e1_7 = ep1.seven;\n  var p0 = ep0.p;\n  var p1 = ep1.p;\n\n  // Anchor rule \u2014 pixel 0's index MSB must be 0. Swapping endpoints reflects\n  // every index (i \u2192 15\u2212i), which on packed nibbles is a bitwise NOT.\n  if ((ilo & 0x8u) != 0u) {\n    let t7 = e0_7; e0_7 = e1_7; e1_7 = t7;\n    let tp = p0;   p0   = p1;   p1   = tp;\n    ilo = ~ilo; ihi = ~ihi;\n  }\n\n  // Straight-line mode-6 packing (see layout at the top of the file).\n  let e0 = vec4<u32>(e0_7);\n  let e1 = vec4<u32>(e1_7);\n  let w0 = 0x40u | (e0.x << 7u) | (e1.x << 14u) | (e0.y << 21u) | (e1.y << 28u);\n  let w1 = (e1.y >> 4u) | (e0.z << 3u) | (e1.z << 10u) | (e0.w << 17u) | (e1.w << 24u) | (p0 << 31u);\n  let w2 = p1 | ((ilo & 0x7u) << 1u) | (ilo & 0xFFFFFFF0u);\n  let w3 = ihi;\n\n  let out = block_index * 4u;\n  dst[out + 0u] = w0;\n  dst[out + 1u] = w1;\n  dst[out + 2u] = w2;\n  dst[out + 3u] = w3;\n}\n";
 
 // src/bc7_fast_f16.wgsl
-var bc7_fast_f16_default = `// bc7 "fast" encoder \u2014 f16 variant (requires the shader-f16 feature).
-// Same algorithm family as the f32 fast path in bc7.wgsl (principal-axis
-// seed at the exact projection extents \u2192 quantise \u2192 one projection-based
-// index-assignment pass), tuned for throughput:
-//
-//   \u2022 All projection math in f16 ([0,1] domain). ~2\xD7 ALU throughput on
-//     f16-capable GPUs. The projection direction is pre-scaled by 32:
-//     a shallow block (endpoints ~1/255 apart) has dd = dot(dir,dir) \u2248 1.5e-5,
-//     where 15/dd \u2248 10\u2076 overflows f16 (max 65504) to +inf and the products
-//     inside the projection dot are subnormal \u2014 the indices turn to garbage
-//     (visible as banding on smooth gradients). Scaling dir by 32 multiplies
-//     the dots by 32 and dd by 1024; s = dot\xB7(32\xB715/dd\u2083\u2082) is the same
-//     quantity with every intermediate in f16's normal range (worst case
-//     inv = 480/0.0157 \u2248 3.0e4 < 65504).
-//   \u2022 NO least-squares refit, unlike the BC1/BC5/ASTC fast paths: with the
-//     seed already on the principal axis at the exact projection extents,
-//     mode 6's fine 16-level palette leaves the refit \u22640.05 dB on the colour
-//     card and \u22640.15 dB on the normal card \u2014 not worth its two extra
-//     16-pixel passes. The coarse 4-level formats DO need it (dropping it
-//     there costs 0.5\u20131.3 dB).
-//   \u2022 Indices are packed into two u32 nibble words ON THE FLY during the
-//     projection pass \u2014 no array<u32,16> private array. The BC7 anchor
-//     reflection (i \u2192 15\u2212i) is then just a bitwise NOT of both words.
-//   \u2022 The 128-bit block is assembled with straight-line constant shifts
-//     instead of a generic write_bits() helper (whose dynamic word indexing
-//     defeats register promotion of the output array).
-//
-// The host selects this module only when the device reports shader-f16,
-// falling back to bc7.wgsl otherwise. "high" never uses this.
-//
-// MODE 6 BIT LAYOUT (LSB-first): see bc7.wgsl. Summary:
-//   w0: mode(7 bits, 0x40) R0 R1 G0 G1[3:0]
-//   w1: G1[6:4] B0 B1 A0 A1 P0
-//   w2: P1, pixel0 index (3 bits), pixels 1..7 (4 bits each)
-//   w3: pixels 8..15 (4 bits each)
-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>;
-
-// Quantise an ideal endpoint (h4 in [0,1]) to 7-bit + p-bit, choosing the
-// p-bit with the lower quantisation error. \`eight\` is the decoded value the
-// hardware will interpolate with, back in [0,1].
-struct Ep { seven: vec4<u32>, eight: h4, p: u32 };
-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<u32>(q1), e1 * h(1.0 / 255.0), 1u); }
-  return Ep(vec4<u32>(q0), e0 * h(1.0 / 255.0), 0u);
-}
-
-@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);
-
-  // Load pass, with the covariance moments FUSED in (no separate 16-pixel
-  // pass): d = (px \u2212 pixel0)\xB716, relative to the block's first pixel so the
-  // accumulators scale with the block's span \u2014 raw \u03A3v\xB7v\u1D40 moments would
-  // cancel catastrophically in f16 \u2014 and pre-scaled \xD716 so shallow blocks
-  // (span ~1/255 \u2192 d\xB2 \u2248 1e-3) clear the subnormal floor while full-range
-  // sums stay \u22644096. C = \u03A3dd\u1D40 \u2212 (\u03A3d)(\u03A3d)\u1D40/16 is the \xD7256-scaled covariance.
-  var pix: array<h4, 16>;
-  var lo = h4(1.0);
-  var hi = h4(0.0);
-  var p0v = h4(0.0);
-  var sd = h4(0.0);
-  var c0v = h4(0.0);
-  var c1v = h4(0.0);
-  var c2v = h4(0.0);
-  var c3v = 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);
-    if (i == 0u) { p0v = px; }
-    let d = (px - p0v) * h(16.0);
-    sd = sd + d;
-    c0v = c0v + d.x * d;
-    c1v = c1v + d.y * d;
-    c2v = c2v + d.z * d;
-    c3v = c3v + d.w * d;
-  }
-  let mean = p0v + sd * h(1.0 / 256.0);
-  // Mean-correction via sd4\xB7sd4\u1D40 with sd4 = \u03A3d/4: (\u03A3d)(\u03A3d)\u1D40/16 with every
-  // product \u22644096 (a direct \u03A3d\xB7\u03A3d\u1D40 could hit 65536 and overflow f16).
-  let sd4 = sd * h(0.25);
-  c0v = c0v - sd4.x * sd4;
-  c1v = c1v - sd4.y * sd4;
-  c2v = c2v - sd4.z * sd4;
-  c3v = c3v - sd4.w * sd4;
-
-  // Seed endpoints from the block's principal colour axis (covariance
-  // power-iteration, seeded with the bbox diagonal \u2014 same family as the BC1
-  // 'high' path). The bbox diagonal is sign-blind: on anti-correlated
-  // channels (normal maps, hue edges) it points across the data instead of
-  // along it, and the LSQ refit \u2014 which fits endpoints GIVEN the projection
-  // indices \u2014 can't recover from a wrong axis. The iteration renormalises by
-  // the max component (a plain length() of the matvec output could overflow
-  // f16), so only the direction survives.
-  var seed_lo = lo;
-  var seed_hi = hi;
-  var axis = hi - lo;
-  var axis_ok = true;
-  for (var it: u32 = 0u; it < 4u; it = it + 1u) {
-    let nv = h4(dot(c0v, axis), dot(c1v, axis), dot(c2v, axis), dot(c3v, axis));
-    let m = max(max(abs(nv.x), abs(nv.y)), max(abs(nv.z), abs(nv.w)));
-    if (m < h(1e-4)) { axis_ok = false; break; }
-    axis = nv / m;
-  }
-  if (axis_ok) {
-    axis = axis / length(axis);
-    // Exact projection extents along the axis. (A Rayleigh-quotient span
-    // estimate was tried in place of this pass \u2014 it saves 16 dots but costs
-    // 0.1\u20130.8 dB and 4\u201310\xD7 on the worst-easy-block gate: \u03C3 misjudges
-    // two-cluster and outlier blocks and the quantised weight grid can't
-    // recover. The pass stays.)
-    var t_min = h(4.0);
-    var t_max = h(-4.0);
-    for (var k: u32 = 0u; k < 16u; k = k + 1u) {
-      let t = dot(pix[k] - mean, axis);
-      t_min = min(t_min, t);
-      t_max = max(t_max, t);
-    }
-    seed_lo = clamp(mean + t_min * axis, h4(0.0), h4(1.0));
-    seed_hi = clamp(mean + t_max * axis, h4(0.0), h4(1.0));
-  }
-
-  // Fit from the principal-axis seed (bbox on degenerate blocks), then
-  // quantise the refit endpoints. The refit is clamped to the block bbox: on
-  // multi-cluster blocks the unconstrained solve extrapolates far outside
-  // the block's colours and the per-channel [0,1] clamp then bends the hue \u2014
-  // fringe pixels decode to colours that exist nowhere in the block.
-  // Constraining to the bbox also measures better in plain SSE (+1.3 dB on
-  // the colour test card).
-  // Quantise the PCA-extents seed directly \u2014 no LSQ refit (see header).
-  var ep0 = pick_ep(seed_lo);
-  var ep1 = pick_ep(seed_hi);
-
-  // Final projection against the decoded endpoints, packing the 4-bit indices
-  // into two nibble words as we go (pixel k \u2192 bits 4k..4k+3 of ilo/ihi).
-  var ilo: u32 = 0u;
-  var ihi: u32 = 0u;
-  // Same \xD732 pre-scale as proj_fit; distinct quantised endpoints are \u22651/255
-  // apart, i.e. dd\u2083\u2082 \u2265 0.0157, so the flat-block threshold only catches
-  // truly identical endpoints.
-  let dir = (ep1.eight - ep0.eight) * h(32.0);
-  let dd = dot(dir, dir);
-  if (dd >= h(0.008)) {
-    let inv = h(480.0) / dd;
-    for (var k: u32 = 0u; k < 8u; k = k + 1u) {
-      let s = clamp(floor(dot(pix[k] - ep0.eight, dir) * inv + h(0.5)), h(0.0), h(15.0));
-      ilo = ilo | (u32(s) << (k * 4u));
-    }
-    for (var k: u32 = 8u; k < 16u; k = k + 1u) {
-      let s = clamp(floor(dot(pix[k] - ep0.eight, dir) * inv + h(0.5)), h(0.0), h(15.0));
-      ihi = ihi | (u32(s) << ((k - 8u) * 4u));
-    }
-  }
-
-  // Anchor rule \u2014 pixel 0's index MSB must be 0. Swapping endpoints reflects
-  // every index (i \u2192 15\u2212i), which on packed nibbles is a bitwise NOT.
-  if ((ilo & 0x8u) != 0u) {
-    let t = ep0; ep0 = ep1; ep1 = t;
-    ilo = ~ilo; ihi = ~ihi;
-  }
-
-  // Straight-line mode-6 packing (see layout above).
-  let e0 = ep0.seven;
-  let e1 = ep1.seven;
-  let w0 = 0x40u | (e0.x << 7u) | (e1.x << 14u) | (e0.y << 21u) | (e1.y << 28u);
-  let w1 = (e1.y >> 4u) | (e0.z << 3u) | (e1.z << 10u) | (e0.w << 17u) | (e1.w << 24u) | (ep0.p << 31u);
-  let w2 = ep1.p | ((ilo & 0x7u) << 1u) | (ilo & 0xFFFFFFF0u);
-  let w3 = ihi;
-
-  let o = bi * 4u;
-  dst[o] = w0; dst[o + 1u] = w1; dst[o + 2u] = w2; dst[o + 3u] = w3;
-}
-`;
+var bc7_fast_f16_default = "// bc7 \"fast\" encoder \u2014 f16 variant (requires the shader-f16 feature).\n// Same algorithm family as the f32 fast path in bc7.wgsl (principal-axis\n// seed at the exact projection extents \u2192 quantise \u2192 one projection-based\n// index-assignment pass), tuned for throughput:\n//\n//   \u2022 All projection math in f16 ([0,1] domain). ~2\xD7 ALU throughput on\n//     f16-capable GPUs. The projection direction is pre-scaled by 32:\n//     a shallow block (endpoints ~1/255 apart) has dd = dot(dir,dir) \u2248 1.5e-5,\n//     where 15/dd \u2248 10\u2076 overflows f16 (max 65504) to +inf and the products\n//     inside the projection dot are subnormal \u2014 the indices turn to garbage\n//     (visible as banding on smooth gradients). Scaling dir by 32 multiplies\n//     the dots by 32 and dd by 1024; s = dot\xB7(32\xB7L/dd\u2083\u2082) is the same\n//     quantity with every intermediate in f16's normal range (worst case\n//     inv = 480/0.0157 \u2248 3.0e4 < 65504).\n//   \u2022 TWO MODES (mode 4 OPT-IN via the enable_mode4 override constant,\n//     default off and dead-coded at pipeline creation \u2014 see the constant's\n//     comment for the measured cost/benefit), decided per block BEFORE\n//     encoding \u2014 never encoded both:\n//     mode 6 (single RGBA line, 4-bit indices) by default, mode 4 (rotation:\n//     one channel split into its own scalar plane with 3-bit indices, the\n//     remaining three on a 2-bit line) when the principal axis leaves a\n//     large share of the block's variance unexplained \u2014 decorrelated data\n//     (normal maps, channel-packed atlases) where any single 4-D line fails.\n//     The decision reads the covariance already in registers (\u03BB = axis\u1D40Ca,\n//     residual = trace \u2212 \u03BB) and costs no extra pass. An encode-both-and-\n//     compare trial was priced at ~2\xD7 on exactly this content (see the mode\n//     1 postmortem below) \u2014 deciding first keeps it at ~1.2\xD7.\n//   \u2022 The two modes SHARE the per-pixel passes (axis matvecs, projection\n//     extents, the index/weight pass runs once with per-thread level count,\n//     index width and packing split) so warps holding a mix of mode-4 and\n//     mode-6 blocks do not execute two disjoint kernels back to back \u2014 a\n//     first cut with separate per-mode passes measured 1.77\xD7 on normal maps\n//     from exactly that divergence; the only mode-4-extra 16-pixel work is\n//     the cheap scalar-plane pass.\n//   \u2022 GRAY + opaque blocks (every texel R == G == B, A == 1) have their\n//     principal axis analytically: (1,1,1,0)/\u221A3, with projection extents at\n//     the luma min/max. They skip the power iteration AND the extents pass\n//     (\u221234% GPU on roughness/AO/displacement content) and always take\n//     mode 6 \u2014 a gray single line fits gray data exactly.\n//   \u2022 NO least-squares refit, unlike the BC1/BC5/ASTC fast paths: with the\n//     seed already on the principal axis at the exact projection extents,\n//     mode 6's fine 16-level palette leaves the refit \u22640.05 dB on the colour\n//     card, \u22640.15 dB on the normal card and +0.03 dB on the channel-packed\n//     packed-materials atlas \u2014 not worth its two extra 16-pixel passes. The\n//     coarse 4-level formats DO need it (dropping it there costs 0.5\u20131.3 dB).\n//   \u2022 A MODE 1 (2-subset) candidate was built and evaluated (2026-07): it\n//     buys ~+1.3 dB on multi-modal content but its candidate evaluation\n//     costs up to ~3\xD7 the mode-6 pass on exactly that content \u2014 dropped in\n//     favour of the decided (not compared) mode 4 above, which covers the\n//     decorrelated-channel share of that content at a fraction of the cost.\n//     The CPU reference decoder keeps mode 1 support (bc7_ref.ts).\n//   \u2022 Indices are packed into two u32 words ON THE FLY during the\n//     projection pass \u2014 no array<u32,16> private array. The BC7 anchor\n//     reflection is then just a bitwise NOT of the packed words.\n//   \u2022 The 128-bit block is assembled with straight-line constant shifts\n//     instead of a generic write_bits() helper (whose dynamic word indexing\n//     defeats register promotion of the output array).\n//\n// The host selects this module only when the device reports shader-f16,\n// falling back to bc7.wgsl otherwise.\n//\n// MODE 6 BIT LAYOUT (LSB-first): see bc7.wgsl. Summary:\n//   w0: mode(7 bits, 0x40) R0 R1 G0 G1[3:0]\n//   w1: G1[6:4] B0 B1 A0 A1 P0\n//   w2: P1, pixel0 index (3 bits), pixels 1..7 (4 bits each)\n//   w3: pixels 8..15 (4 bits each)\n// MODE 4 BIT LAYOUT (LSB-first): mode 0b00001, rotation @5 (channel swapped\n// with alpha), idxMode @7 (0 = colour \u2192 2-bit set, scalar \u2192 3-bit set),\n// colour endpoints 6\xD75 bits @8, alpha endpoints 2\xD76 @38, 31-bit 2-bit index\n// field @50 (pixel 0 anchored to 1 bit), 47-bit 3-bit index field @81\n// (pixel 0 anchored to 2 bits). Validated bit-exact against hardware\n// bc7-rgba-unorm sampling; decode reference in bc7_ref.ts.\nenable 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;\nalias h = f16;\nalias h4 = vec4<f16>;\n\n// Mode-4 gate: encode mode 4 when the principal axis leaves more than\n// MODE4_THETA of the (\xD7256-scaled) total variance unexplained and the block\n// isn't near-flat. Tuned against per-content mode histograms and PSNR.\nconst MODE4_THETA: f16 = 0.2;\nconst MODE4_FLOOR: f16 = 1.0;\nconst MODE4_CONC: f16 = 0.5;\n\n// OPT-IN adaptive mode 4, folded at pipeline creation (WebGPU override\n// constant; default OFF dead-codes the whole path \u2014 measured at exact par\n// with the mode-6-only kernel). Rationale: the quality is real (+2.5\u20132.9 dB\n// on normal maps, +1.9\u20132.4 on channel-packed atlases) but any warp holding\n// one mode-4 block executes both modes' passes, and content that benefits\n// runs 1.4\u20131.5\xD7; a \u03B8 sweep showed quality and warp-poisoning scale together\n// (no per-block middle ground without subgroup ballots). So the trade is\n// the CALLER's: BC7Encoder({ adaptiveMode4: true }).\noverride enable_mode4: bool = false;\n\n// Quantise an ideal endpoint (h4 in [0,1]) to 7-bit + p-bit, choosing the\n// p-bit with the lower quantisation error. `eight` is the decoded value the\n// hardware will interpolate with, back in [0,1].\nstruct Ep { seven: vec4<u32>, eight: h4, p: u32 };\nfn pick_ep(ideal01: h4) -> Ep {\n  let ideal = ideal01 * h(255.0);\n  let q0 = clamp(floor(ideal * h(0.5) + h(0.5)), h4(0.0), h4(127.0));        // p=0\n  let e0 = q0 * h(2.0);\n  let q1 = clamp(floor((ideal - h(1.0)) * h(0.5) + h(0.5)), h4(0.0), h4(127.0)); // p=1\n  let e1 = q1 * h(2.0) + h(1.0);\n  let d0 = e0 - ideal; let d1 = e1 - ideal;\n  if (dot(d1, d1) < dot(d0, d0)) { return Ep(vec4<u32>(q1), e1 * h(1.0 / 255.0), 1u); }\n  return Ep(vec4<u32>(q0), e0 * h(1.0 / 255.0), 0u);\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) { return; }\n  let bi = gid.y * params.blocks_x + gid.x;\n  let base = vec2<i32>(i32(gid.x) * 4, i32(gid.y) * 4);\n  let mx = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  // Load pass, with the covariance moments FUSED in (no separate 16-pixel\n  // pass): d = (px \u2212 pixel0)\xB716, relative to the block's first pixel so the\n  // accumulators scale with the block's span \u2014 raw \u03A3v\xB7v\u1D40 moments would\n  // cancel catastrophically in f16 \u2014 and pre-scaled \xD716 so shallow blocks\n  // (span ~1/255 \u2192 d\xB2 \u2248 1e-3) clear the subnormal floor while full-range\n  // sums stay \u22644096. C = \u03A3dd\u1D40 \u2212 (\u03A3d)(\u03A3d)\u1D40/16 is the \xD7256-scaled covariance.\n  var pix: array<h4, 16>;\n  var lo = h4(1.0);\n  var hi = h4(0.0);\n  var gd = h(0.0);\n  var p0v = h4(0.0);\n  var sd = h4(0.0);\n  var c0v = h4(0.0);\n  var c1v = h4(0.0);\n  var c2v = h4(0.0);\n  var c3v = h4(0.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), mx);\n    let px = h4(textureLoad(src_tex, p, 0));\n    pix[i] = px; lo = min(lo, px); hi = max(hi, px);\n    gd = max(gd, max(abs(px.x - px.y), abs(px.x - px.z)));\n    if (i == 0u) { p0v = px; }\n    let d = (px - p0v) * h(16.0);\n    sd = sd + d;\n    c0v = c0v + d.x * d;\n    c1v = c1v + d.y * d;\n    c2v = c2v + d.z * d;\n    c3v = c3v + d.w * d;\n  }\n  let mean = p0v + sd * h(1.0 / 256.0);\n  // Mean-correction via sd4\xB7sd4\u1D40 with sd4 = \u03A3d/4: (\u03A3d)(\u03A3d)\u1D40/16 with every\n  // product \u22644096 (a direct \u03A3d\xB7\u03A3d\u1D40 could hit 65536 and overflow f16).\n  let sd4 = sd * h(0.25);\n  c0v = c0v - sd4.x * sd4;\n  c1v = c1v - sd4.y * sd4;\n  c2v = c2v - sd4.z * sd4;\n  c3v = c3v - sd4.w * sd4;\n\n  // Seed endpoints + per-block mode decision (see header).\n  var seed_lo = lo;\n  var seed_hi = hi;\n  var use4 = false;\n  var cmask = h4(1.0);\n  var ch = 0u;\n  if (lo.w == h(1.0) && gd == h(0.0)) {\n    // GRAY + opaque: analytic axis (1,1,1,0)/\u221A3, extents at luma min/max,\n    // always mode 6 \u2014 and a fully specialised tail: gray textures are\n    // warp-uniform, and routing them through the parametric shared loop\n    // below (runtime index width/split) measured +28% on displacement\n    // content purely from the lost constant-shift codegen.\n    var ep0g = pick_ep(h4(lo.x, lo.x, lo.x, h(1.0)));\n    var ep1g = pick_ep(h4(hi.x, hi.x, hi.x, h(1.0)));\n    var ilo = 0u;\n    var ihi = 0u;\n    let dirg = (ep1g.eight - ep0g.eight) * h(32.0);\n    let ddg = dot(dirg, dirg);\n    if (ddg >= h(0.008)) {\n      let invg = h(480.0) / ddg;\n      for (var k: u32 = 0u; k < 8u; k = k + 1u) {\n        let sg = clamp(floor(dot(pix[k] - ep0g.eight, dirg) * invg + h(0.5)), h(0.0), h(15.0));\n        ilo = ilo | (u32(sg) << (k * 4u));\n      }\n      for (var k: u32 = 8u; k < 16u; k = k + 1u) {\n        let sg = clamp(floor(dot(pix[k] - ep0g.eight, dirg) * invg + h(0.5)), h(0.0), h(15.0));\n        ihi = ihi | (u32(sg) << ((k - 8u) * 4u));\n      }\n    }\n    if ((ilo & 0x8u) != 0u) {\n      let t = ep0g; ep0g = ep1g; ep1g = t;\n      ilo = ~ilo; ihi = ~ihi;\n    }\n    let e0g = ep0g.seven;\n    let e1g = ep1g.seven;\n    let og = bi * 4u;\n    dst[og] = 0x40u | (e0g.x << 7u) | (e1g.x << 14u) | (e0g.y << 21u) | (e1g.y << 28u);\n    dst[og + 1u] = (e1g.y >> 4u) | (e0g.z << 3u) | (e1g.z << 10u) | (e0g.w << 17u) | (e1g.w << 24u) | (ep0g.p << 31u);\n    dst[og + 2u] = ep1g.p | ((ilo & 0x7u) << 1u) | (ilo & 0xFFFFFFF0u);\n    dst[og + 3u] = ihi;\n    return;\n  }\n  {\n    var axis = hi - lo;\n    var axis_ok = true;\n    // 8 iterations: 4 was under-converged on noisy 4-D blocks (heavily\n    // downscaled photographic/channel-packed content) \u2014 going to 8 measured\n    // +0.75 dB on the normal card, +0.12 colour, +0.08 packed-materials, and\n    // matches the f32 fallback's iteration count. Four extra 4-dot matvecs\n    // per block are noise next to the index pass.\n    for (var it: u32 = 0u; it < 8u; it = it + 1u) {\n      let nv = h4(dot(c0v, axis), dot(c1v, axis), dot(c2v, axis), dot(c3v, axis));\n      let m = max(max(abs(nv.x), abs(nv.y)), max(abs(nv.z), abs(nv.w)));\n      if (m < h(1e-4)) { axis_ok = false; break; }\n      axis = nv / m;\n    }\n    if (axis_ok) {\n      axis = axis / length(axis);\n      var axisF = axis;\n\n      // Mode decision from the covariance already in registers: \u03BB is the\n      // variance the mode-6 line explains, trace \u2212 \u03BB what it cannot.\n      let Ca = h4(dot(c0v, axis), dot(c1v, axis), dot(c2v, axis), dot(c3v, axis));\n      let lam = dot(Ca, axis);\n      let diag = h4(c0v.x, c1v.y, c2v.z, c3v.w);\n      let trace = diag.x + diag.y + diag.z + diag.w;\n      let resid = trace - lam;\n      let rc = diag - lam * axis * axis;\n      var rbest = rc.x;\n      if (rc.y > rbest) { ch = 1u; rbest = rc.y; }\n      if (rc.z > rbest) { ch = 2u; rbest = rc.z; }\n      if (rc.w > rbest) { ch = 3u; rbest = rc.w; }\n      use4 = enable_mode4 && resid > MODE4_THETA * trace && trace > MODE4_FLOOR && rbest > MODE4_CONC * resid;\n      if (use4) {\n        // The colour plane is the remaining three channels, handled as\n        // masked 4-vectors so every vec4 pass below applies unchanged.\n        // Branchless mask build \u2014 a dynamic component store spills the\n        // vector to scratch on some compilers.\n        cmask = h4(1.0) - h4(h(f32(u32(ch == 0u))), h(f32(u32(ch == 1u))), h(f32(u32(ch == 2u))), h(f32(u32(ch == 3u))));\n        var a3 = (hi - lo) * cmask;\n        var ok3 = true;\n        for (var it: u32 = 0u; it < 2u; it = it + 1u) {\n          let nv = h4(dot(c0v, a3), dot(c1v, a3), dot(c2v, a3), dot(c3v, a3)) * cmask;\n          let m = max(max(abs(nv.x), abs(nv.y)), max(abs(nv.z), abs(nv.w)));\n          if (m < h(1e-4)) { ok3 = false; break; }\n          a3 = nv / m;\n        }\n        if (ok3) {\n          axisF = a3 / length(a3);\n        } else {\n          use4 = false;\n          cmask = h4(1.0);\n        }\n      }\n\n      // Exact projection extents along the fit axis \u2014 ONE shared pass for\n      // both modes (for mode 4 axisF[ch] = 0, so the scalar plane is\n      // invisible to it). (A Rayleigh-quotient span estimate was tried in\n      // place of this pass \u2014 it saves 16 dots but costs 0.1\u20130.8 dB and\n      // 4\u201310\xD7 on the worst-easy-block gate.)\n      var t_min = h(4.0);\n      var t_max = h(-4.0);\n      for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n        let t = dot(pix[k] - mean, axisF);\n        t_min = min(t_min, t);\n        t_max = max(t_max, t);\n      }\n      seed_lo = clamp(mean + t_min * axisF, h4(0.0), h4(1.0));\n      seed_hi = clamp(mean + t_max * axisF, h4(0.0), h4(1.0));\n    }\n  }\n\n  // Endpoints, per mode. d0/d1 are the DECODED values the weight pass\n  // projects against.\n  var ep0: Ep;\n  var ep1: Ep;\n  var q0c = vec4<u32>(0u);\n  var q1c = vec4<u32>(0u);\n  var A0 = 0u;\n  var A1 = 0u;\n  var iA = 0u;\n  var iB = 0u;\n  var d0: h4;\n  var d1: h4;\n  var d0a = h(0.0);\n  var sca = h(0.0);\n  let chs = h4(1.0) - cmask;\n  ep0 = pick_ep(seed_lo);\n  ep1 = pick_ep(seed_hi);\n  d0 = ep0.eight;\n  d1 = ep1.eight;\n  if (use4) {\n    // Scalar plane (3-bit index set): 6-bit endpoints at the channel's\n    // exact extremes. Its projection is FUSED into the shared weight pass\n    // below \u2014 a separate 16-pixel pass here measured +46% on normal maps\n    // (mixed warps paid it wholesale); fused, the marginal cost is one dot\n    // per pixel under a warp-uniform predicate.\n    let a0q = u32(floor(dot(lo, chs) * h(63.0) + h(0.5)));\n    let a1q = u32(floor(dot(hi, chs) * h(63.0) + h(0.5)));\n    A0 = a0q;\n    A1 = a1q;\n    let d0av = h(f32((a0q << 2u) | (a0q >> 4u))) * h(1.0 / 255.0);\n    let d1av = h(f32((a1q << 2u) | (a1q >> 4u))) * h(1.0 / 255.0);\n    let aspan = d1av - d0av;\n    if (aspan > h(0.001)) {\n      d0a = d0av;\n      sca = h(7.0) / aspan;\n    }\n    // Colour plane: 5-bit endpoints from the masked extents seed.\n    q0c = vec4<u32>(clamp(floor(seed_lo * h(31.0) + h(0.5)), h4(0.0), h4(31.0)));\n    q1c = vec4<u32>(clamp(floor(seed_hi * h(31.0) + h(0.5)), h4(0.0), h4(31.0)));\n    d0 = h4(vec4<f32>((q0c << vec4<u32>(3u)) | (q0c >> vec4<u32>(2u)))) * h(1.0 / 255.0) * cmask;\n    d1 = h4(vec4<f32>((q1c << vec4<u32>(3u)) | (q1c >> vec4<u32>(2u)))) * h(1.0 / 255.0) * cmask;\n  }\n\n  // Index/weight pass: per-mode SPECIALISED loops (constant level counts\n  // and shifts, so each unrolls cleanly \u2014 a single parametric loop with\n  // runtime width/split measured +22% on pure mode-6 photo content).\n  // Mixed warps execute both loops; the mode-4 one carries the fused\n  // scalar-plane projection. For mode 4 pix[ch]\xB7dir[ch] = 0, so the\n  // scalar plane never perturbs the colour projection.\n  var a_lo = 0u;\n  var a_hi = 0u;\n  // Same \xD732 pre-scale as the extents math; distinct quantised endpoints\n  // are \u22651/255 apart (dd\u2083\u2082 \u2265 0.0157), so the flat-block threshold only\n  // catches truly identical ones.\n  let dir = (d1 - d0) * h(32.0);\n  let dd = dot(dir, dir);\n  let live = dd >= h(0.008);\n  if (use4) {\n    if (live) {\n      let inv = h(96.0) / dd;\n      for (var k: u32 = 0u; k < 8u; k = k + 1u) {\n        let s = clamp(floor(dot(pix[k] - d0, dir) * inv + h(0.5)), h(0.0), h(3.0));\n        let sv = clamp(floor((dot(pix[k], chs) - d0a) * sca + h(0.5)), h(0.0), h(7.0));\n        a_lo = a_lo | (u32(s) << (k * 2u));\n        iA = iA | (u32(sv) << (k * 3u));\n      }\n      for (var k: u32 = 8u; k < 16u; k = k + 1u) {\n        let s = clamp(floor(dot(pix[k] - d0, dir) * inv + h(0.5)), h(0.0), h(3.0));\n        let sv = clamp(floor((dot(pix[k], chs) - d0a) * sca + h(0.5)), h(0.0), h(7.0));\n        a_lo = a_lo | (u32(s) << (k * 2u));\n        iB = iB | (u32(sv) << ((k - 8u) * 3u));\n      }\n    }\n  } else if (live) {\n    let inv = h(480.0) / dd;\n    for (var k: u32 = 0u; k < 8u; k = k + 1u) {\n      let s = clamp(floor(dot(pix[k] - d0, dir) * inv + h(0.5)), h(0.0), h(15.0));\n      a_lo = a_lo | (u32(s) << (k * 4u));\n    }\n    for (var k: u32 = 8u; k < 16u; k = k + 1u) {\n      let s = clamp(floor(dot(pix[k] - d0, dir) * inv + h(0.5)), h(0.0), h(15.0));\n      a_hi = a_hi | (u32(s) << ((k - 8u) * 4u));\n    }\n  }\n\n  // Anchors + packing. Mode 6 packs unconditionally (one-sided branches\n  // compile better than two-sided divergence); mode-4 threads overwrite.\n  let o = bi * 4u;\n  {\n    var ilo = a_lo;\n    var ihi = a_hi;\n    if ((ilo & 0x8u) != 0u) {\n      let t = ep0; ep0 = ep1; ep1 = t;\n      ilo = ~ilo; ihi = ~ihi;\n    }\n    let e0 = ep0.seven;\n    let e1 = ep1.seven;\n    dst[o] = 0x40u | (e0.x << 7u) | (e1.x << 14u) | (e0.y << 21u) | (e1.y << 28u);\n    dst[o + 1u] = (e1.y >> 4u) | (e0.z << 3u) | (e1.z << 10u) | (e0.w << 17u) | (e1.w << 24u) | (ep0.p << 31u);\n    dst[o + 2u] = ep1.p | ((ilo & 0x7u) << 1u) | (ilo & 0xFFFFFFF0u);\n    dst[o + 3u] = ihi;\n  }\n  if (use4) {\n    // 3-bit anchor: pixel 0's MSB must be 0; reflect = bitwise NOT.\n    if ((iA & 4u) != 0u) {\n      let tA = A0;\n      A0 = A1;\n      A1 = tA;\n      iA = ~iA & 0xFFFFFFu;\n      iB = ~iB & 0xFFFFFFu;\n    }\n    var c2 = a_lo;\n    // 2-bit anchor: pixel 0's MSB must be 0.\n    if ((c2 & 2u) != 0u) {\n      let tq = q0c;\n      q0c = q1c;\n      q1c = tq;\n      c2 = ~c2;\n    }\n    // Rotated-space RGB: position ch carries the original alpha.\n    let R0 = select(q0c.x, q0c.w, ch == 0u);\n    let G0 = select(q0c.y, q0c.w, ch == 1u);\n    let B0 = select(q0c.z, q0c.w, ch == 2u);\n    let R1 = select(q1c.x, q1c.w, ch == 0u);\n    let G1 = select(q1c.y, q1c.w, ch == 1u);\n    let B1 = select(q1c.z, q1c.w, ch == 2u);\n    let rot = (ch + 1u) & 3u;\n    // Index fields drop the anchors' MSBs: 31 bits (2-bit set) and 47 bits\n    // (3-bit set).\n    let field2 = (c2 & 1u) | ((c2 >> 2u) << 1u);\n    let f_lo = (iA & 3u) | ((iA >> 3u) << 2u) | (iB << 23u);\n    let f_hi = iB >> 9u;\n    dst[o] = 0x10u | (rot << 5u) | (R0 << 8u) | (R1 << 13u) | (G0 << 18u) | (G1 << 23u) | (B0 << 28u);\n    dst[o + 1u] = (B0 >> 4u) | (B1 << 1u) | (A0 << 6u) | (A1 << 12u) | ((field2 & 0x3FFFu) << 18u);\n    dst[o + 2u] = (field2 >> 14u) | (f_lo << 17u);\n    dst[o + 3u] = (f_lo >> 15u) | (f_hi << 17u);\n  }\n}\n";
 
 // src/BC7Encoder.ts
 var BC7Encoder = class extends Encoder {
   static requiredFeature = WebGPUFeature.BC;
   static textureFormats = [TextureFormat.BC7, TextureFormat.BC7_SRGB];
+  adaptiveMode4;
+  constructor(opts) {
+    super(opts);
+    this.adaptiveMode4 = opts.adaptiveMode4 === true;
+    if (this.adaptiveMode4) this._buildPipeline();
+  }
+  pipelineConstants() {
+    if (this.adaptiveMode4 && this._useF16) return { enable_mode4: 1 };
+    return void 0;
+  }
   get label() {
     return "bc7";
   }
@@ -1076,9 +1528,6 @@ var BC7Encoder = class extends Encoder {
   get supportsSrgb() {
     return true;
   }
-  get supportsQuality() {
-    return true;
-  }
   wgslSource() {
     return bc7_default;
   }
@@ -1091,35 +1540,60 @@ var BC7Encoder = class extends Encoder {
 };
 
 // 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// QUALITY LEVELS (pipeline-overridable constant `QUALITY_HIGH`)\n//   fast (0, default): principal-axis seed (covariance power-iteration; bbox\n//     on degenerate blocks) \u2192 one fused pass that projects each pixel onto\n//     the endpoint line (the 4 palette entries are colinear, so the nearest\n//     is the rounded projection \u2014 no per-entry search) while accumulating the\n//     least-squares refit sums, then a reprojection against the quantised\n//     refit endpoints with the weights packed on the fly. The endpoint\n//     ordering rule is applied before the weight pass, so no reflection is\n//     needed.\n//   high (1): O(N\xB2) farthest-pair seed, full 4-entry nearest search, one LSQ\n//     refit \u2014 matches astc4x4_ref.ts up to FP tie-breaks.\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// One pass over the block: project every pixel onto the e0\u2192e1 line (4 levels,\n// QUANT_4 \u2248 thirds) and accumulate the least-squares normal-equation sums;\n// solve for the refit endpoints. Weights are not produced here \u2014 the caller\n// reprojects against the quantised refit endpoints anyway.\nstruct Fit { e0: vec4<i32>, e1: vec4<i32>, valid: bool };\nfn proj_fit(pixels: ptr<function, array<vec4<i32>, 16>>, e0: vec4<i32>, e1: vec4<i32>) -> Fit {\n  var out: Fit;\n  out.valid = false;\n  let dir = vec4<f32>(e1 - e0);\n  let dd = dot(dir, dir);\n  if (dd == 0.0) { return out; }\n  let e0f = vec4<f32>(e0);\n  let inv = 3.0 / 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  var s_min = 3.0; var s_max = 0.0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let v = vec4<f32>((*pixels)[k]);\n    let s = clamp(floor(dot(v - e0f, dir) * inv + 0.5), 0.0, 3.0);\n    s_min = min(s_min, s); s_max = max(s_max, s);\n    let b = s * (1.0 / 3.0); let a = 1.0 - b;\n    sAA = sAA + a * a; sBB = sBB + b * b; sAB = sAB + a * b;\n    sAV = sAV + a * v; sBV = sBV + b * v;\n  }\n  // Rank-1 guard: if every pixel projects to ONE level the system is\n  // singular \u2014 det and the numerators are pure float rounding noise and the\n  // solve returns garbage endpoints. With \u22652 levels det \u2265 15\xB7(1/3)\xB2 \u2248 1.67.\n  if (s_min == s_max) { return out; }\n  let det = sAA * sBB - sAB * sAB;\n  if (abs(det) < 1e-3) { 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// Principal colour axis via covariance power-iteration (RGBA, 8-bit integer\n// pixel domain), seeded with the bbox diagonal. Returns a unit axis, or\n// vec4(0) for a degenerate (constant) block. Used by the fast path to seed\n// the LSQ fit \u2014 the bbox diagonal is sign-blind and points across\n// anti-correlated data (normal maps, hue edges) instead of along it.\nfn principal_axis4(\n  pixels: ptr<function, array<vec4<i32>, 16>>,\n  mean: vec4<f32>,\n  seed: vec4<f32>,\n) -> vec4<f32> {\n  var c0v = vec4<f32>(0.0);\n  var c1v = vec4<f32>(0.0);\n  var c2v = vec4<f32>(0.0);\n  var c3v = vec4<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let d = vec4<f32>((*pixels)[k]) - mean;\n    c0v = c0v + d.x * d;\n    c1v = c1v + d.y * d;\n    c2v = c2v + d.z * d;\n    c3v = c3v + d.w * d;\n  }\n  var v = seed;\n  var len = length(v);\n  if (len < 1e-9) { return vec4<f32>(0.0); }\n  v = v / len;\n  for (var iter: u32 = 0u; iter < 8u; iter = iter + 1u) {\n    let nv = vec4<f32>(dot(c0v, v), dot(c1v, v), dot(c2v, v), dot(c3v, v));\n    len = length(nv);\n    if (len < 1e-12) { return vec4<f32>(0.0); }\n    v = nv / len;\n  }\n  return v;\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// ------------------------------- 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  var isum = 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    isum = isum + px;\n  }\n  let mean = vec4<f32>(isum) * (1.0 / 16.0);\n\n  // Both branches produce the final endpoints (already ordered so the\n  // decoder doesn't apply blue contraction) and the packed weight word\n  // (weight k's lsb at bit 31\u22122k, msb at bit 30\u22122k).\n  var e0: vec4<i32>;\n  var e1: vec4<i32>;\n  var w3: u32 = 0u;\n\n  if (QUALITY_HIGH != 0u) {\n    let fp = farthest_pair(&pixels);\n    e0 = fp.a;\n    e1 = fp.b;\n    var indices: array<u32, 16>;\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    // Endpoint ordering, reflecting the assigned weights.\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    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  } else {\n    // Fused LSQ fit seeded from the block's principal colour axis\n    // (covariance power-iteration; bbox on degenerate blocks), quantised\n    // refit endpoints, ordering applied BEFORE the weight pass so no\n    // reflection is needed.\n    // The refit is clamped to the block bbox: on multi-cluster blocks the\n    // unconstrained solve extrapolates far outside the block's colours and the\n    // per-channel [0,255] clamp then bends the hue \u2014 fringe pixels decode to\n    // colours that exist nowhere in the block. Constraining to the bbox also\n    // measures better in plain SSE (+1.8 dB on the colour test card).\n    var seed0 = lo;\n    var seed1 = hi;\n    let axis = principal_axis4(&pixels, mean, vec4<f32>(hi - lo));\n    if (dot(axis, axis) > 0.0) {\n      var t_min: f32 = 1e30;\n      var t_max: f32 = -1e30;\n      for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n        let t = dot(vec4<f32>(pixels[k]) - mean, axis);\n        t_min = min(t_min, t);\n        t_max = max(t_max, t);\n      }\n      seed0 = vec4<i32>(clamp(round(mean + t_min * axis), vec4<f32>(0.0), vec4<f32>(255.0)));\n      seed1 = vec4<i32>(clamp(round(mean + t_max * axis), vec4<f32>(0.0), vec4<f32>(255.0)));\n    }\n    let r = proj_fit(&pixels, seed0, seed1);\n    e0 = lo;\n    e1 = hi;\n    if (r.valid) { e0 = clamp(r.e0, lo, hi); e1 = clamp(r.e1, lo, hi); }\n    if (e0.x + e0.y + e0.z > e1.x + e1.y + e1.z) {\n      let tmp = e0; e0 = e1; e1 = tmp;\n    }\n    let dir = vec4<f32>(e1 - e0);\n    let dd = dot(dir, dir);\n    if (dd > 0.0) {\n      let e0f = vec4<f32>(e0);\n      let inv = 3.0 / dd;\n      for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n        let s = u32(clamp(floor(dot(vec4<f32>(pixels[k]) - e0f, dir) * inv + 0.5), 0.0, 3.0));\n        w3 = w3 | ((s & 1u) << (31u - 2u * k)) | (((s >> 1u) & 1u) << (30u - 2u * k));\n      }\n    }\n  }\n\n  // Straight-line packing: block mode 0x042 @0, partitions\u22121=0 @11, CEM 12\n  // @13, endpoints R0 R1 G0 G1 B0 B1 A0 A1 (8 bits each) from bit 17,\n  // weights in the last word.\n  let E0 = vec4<u32>(e0);\n  let E1 = vec4<u32>(e1);\n  let w0 = 0x042u | (12u << 13u) | (E0.x << 17u) | (E1.x << 25u);\n  let w1 = (E1.x >> 7u) | (E0.y << 1u) | (E1.y << 9u) | (E0.z << 17u) | (E1.z << 25u);\n  let w2 = (E1.z >> 7u) | (E0.w << 1u) | (E1.w << 9u);\n\n  let out = block_index * 4u;\n  dst[out + 0u] = w0;\n  dst[out + 1u] = w1;\n  dst[out + 2u] = w2;\n  dst[out + 3u] = w3;\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]`. This is the f32 fallback;\n// astc4x4_fast_f16.wgsl is the same algorithm and is preferred when the\n// device reports shader-f16.\n//\n// ALGORITHM: per-block class selection, then a single-line fit:\n//   gray + opaque \u2192 CEM 0  (luminance), 5-bit weights, block mode 0x253 \u2014\n//                   scalar path: exact min/max endpoints, 32-level weight\n//                   assignment, no covariance / iteration / refit needed\n//   opaque        \u2192 CEM 8  (RGB),  3-bit weights, block mode 0x053\n//   translucent   \u2192 CEM 12 (RGBA), 2-bit weights, block mode 0x042\n// Colour paths: principal-axis seed (covariance power-iteration; bbox on\n// degenerate blocks) at the exact projection extents \u2192 one fused pass that\n// projects each pixel onto the endpoint line (the palette entries are\n// colinear, so the nearest is the rounded projection \u2014 no per-entry search)\n// while accumulating the least-squares refit sums, then a reprojection\n// against the quantised refit endpoints with the weights packed on the fly.\n// The endpoint ordering rule is applied before the weight pass, so no\n// reflection is needed.\n//\n// RESTRICTED SUBSET + BLOCK LAYOUT: see astc4x4_ref.ts (single partition,\n// no dual-plane, CEM 0/8/12, 8-bit endpoints, plain-bit weight ISE; block\n// mode derivations and the weight-stream bit order are documented there).\n//\n// WEIGHT PLACEMENT: stream bit q (bit j of weight k, q = nBits\xB7k + j) lives\n// at block bit 127 \u2212 q, so a stream word assembled LSB-first maps onto a\n// block word with a single reverseBits().\n//\n// ENDPOINT ORDERING: CEM 8/12 decoders branch into blue contraction when\n// sum(e0.rgb) > sum(e1.rgb); the encoder swaps endpoints up front (weights\n// are assigned after the swap, so no reflection pass). CEM 0 has no rule\n// (L0 \u2264 L1 by construction from min/max).\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 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\n// One pass over the block: project every pixel onto the e0\u2192e1 line\n// (lmax + 1 colinear levels, so the nearest entry is the rounded\n// projection) and accumulate the least-squares normal-equation sums;\n// solve for the refit endpoints. Weights are not produced here \u2014 the\n// caller reprojects against the quantised refit endpoints anyway.\nstruct Fit { e0: vec4<i32>, e1: vec4<i32>, valid: bool, wstream: u32 };\nfn proj_fit(pixels: ptr<function, array<vec4<i32>, 16>>, e0: vec4<i32>, e1: vec4<i32>) -> Fit {\n  var out: Fit;\n  out.valid = false;\n  out.wstream = 0u;\n  let dir = vec4<f32>(e1 - e0);\n  let dd = dot(dir, dir);\n  if (dd == 0.0) { return out; }\n  let e0f = vec4<f32>(e0);\n  let inv = 3.0 / 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  var s_min = 3.0; var s_max = 0.0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let v = vec4<f32>((*pixels)[k]);\n    let s = clamp(floor(dot(v - e0f, dir) * inv + 0.5), 0.0, 3.0);\n    out.wstream = out.wstream | (u32(s) << (2u * k));\n    s_min = min(s_min, s); s_max = max(s_max, s);\n    let b = s * (1.0 / 3.0); let a = 1.0 - b;\n    sAA = sAA + a * a; sBB = sBB + b * b; sAB = sAB + a * b;\n    sAV = sAV + a * v; sBV = sBV + b * v;\n  }\n  // Rank-1 guard: if every pixel projects to ONE level the system is\n  // singular \u2014 det and the numerators are pure float rounding noise and the\n  // solve returns garbage endpoints. With \u22652 levels det \u2265 15\xB7(1/3)\xB2 \u2248 1.67.\n  if (s_min == s_max) { return out; }\n  let det = sAA * sBB - sAB * sAB;\n  if (abs(det) < 1e-3) { 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// Principal colour axis via covariance power-iteration (RGBA, 8-bit integer\n// pixel domain), seeded with the bbox diagonal. Returns a unit axis, or\n// vec4(0) for a degenerate (constant) block. Used to seed the LSQ fit \u2014 the\n// bbox diagonal is sign-blind and points across anti-correlated data (normal\n// maps, hue edges) instead of along it.\nfn principal_axis4(\n  pixels: ptr<function, array<vec4<i32>, 16>>,\n  mean: vec4<f32>,\n  seed: vec4<f32>,\n  iters: u32,\n) -> vec4<f32> {\n  var c0v = vec4<f32>(0.0);\n  var c1v = vec4<f32>(0.0);\n  var c2v = vec4<f32>(0.0);\n  var c3v = vec4<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let d = vec4<f32>((*pixels)[k]) - mean;\n    c0v = c0v + d.x * d;\n    c1v = c1v + d.y * d;\n    c2v = c2v + d.z * d;\n    c3v = c3v + d.w * d;\n  }\n  var v = seed;\n  var len = length(v);\n  if (len < 1e-9) { return vec4<f32>(0.0); }\n  v = v / len;\n  for (var iter: u32 = 0u; iter < iters; iter = iter + 1u) {\n    let nv = vec4<f32>(dot(c0v, v), dot(c1v, v), dot(c2v, v), dot(c3v, v));\n    len = length(nv);\n    if (len < 1e-12) { return vec4<f32>(0.0); }\n    v = nv / len;\n  }\n  return v;\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  var isum = vec4<i32>(0);\n  var gd = 0; // max |R\u2212G|, |R\u2212B| over the block; 0 \u21D4 exactly grayscale\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    isum = isum + px;\n    gd = max(gd, max(abs(px.x - px.y), abs(px.x - px.z)));\n  }\n  let opaque = lo.w == 255;\n\n  var w0: u32; var w1: u32; var w2: u32; var w3: u32;\n\n  if (opaque && gd == 0) {\n    // ---------------- Luminance path: CEM 0, 5-bit weights ----------------\n    // Endpoints at the exact extremes; 32 palette levels make an LSQ refit\n    // unnecessary.\n    let L0 = u32(lo.x);\n    let L1 = u32(hi.x);\n    var s0 = 0u; var s1 = 0u; var s2 = 0u;\n    if (L1 > L0) {\n      let sc = 64.0 / f32(hi.x - lo.x);\n      // Exact nearest entry of the QUANT_32 grid: unq = 2w for w \u2264 15,\n      // 2w + 2 for w \u2265 16 (4-wide gap at the middle, so uniform rounding\n      // is wrong there). Best candidate of each half, keep the closer.\n      for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n        let u = clamp(f32(pixels[k].x - lo.x) * sc, 0.0, 64.0);\n        let wlo = clamp(floor(u * 0.5 + 0.5), 0.0, 15.0);\n        let whi = clamp(floor((u - 2.0) * 0.5 + 0.5), 16.0, 31.0);\n        let pick = abs(u - wlo * 2.0) <= abs(u - (whi * 2.0 + 2.0));\n        let w = u32(select(whi, wlo, pick));\n        // Stream bit q = 5k + j; straddles handled with constant shifts.\n        let off = 5u * k;\n        if (off < 28u) { s0 = s0 | (w << off); }\n        else if (off == 30u) { s0 = s0 | (w << 30u); s1 = s1 | (w >> 2u); }\n        else if (off < 60u) { s1 = s1 | (w << (off - 32u)); }\n        else if (off == 60u) { s1 = s1 | (w << 28u); s2 = s2 | (w >> 4u); }\n        else { s2 = s2 | (w << (off - 64u)); }\n      }\n    }\n    // Mode 0x253, partitions\u22121 = 0, CEM 0, L0 @17, L1 @25 (top bit spills\n    // into w1 bit 0); stream words map onto block words via reverseBits.\n    w0 = 0x253u | (L0 << 17u) | (L1 << 25u);\n    w1 = (L1 >> 7u) | reverseBits(s2);\n    w2 = reverseBits(s1);\n    w3 = reverseBits(s0);\n  } else {\n    // ------------- Colour paths: shared PCA seed ---------------------------\n    let mean = vec4<f32>(isum) * (1.0 / 16.0);\n\n    // Fused LSQ fit seeded from the block's principal colour axis at the\n    // exact projection extents, quantised refit endpoints, ordering applied\n    // BEFORE the weight pass so no reflection is needed.\n    // The refit is clamped to the block bbox: on multi-cluster blocks the\n    // unconstrained solve extrapolates far outside the block's colours and\n    // the per-channel [0,255] clamp then bends the hue \u2014 fringe pixels\n    // decode to colours that exist nowhere in the block. Constraining to\n    // the bbox also measures better in plain SSE (+1.8 dB on the colour\n    // test card).\n    var seed0 = lo;\n    var seed1 = hi;\n    // 8 iterations for opaque blocks (the axis is the endpoint quality\n    // there), 4 for translucent ones whose LSQ refit absorbs residual\n    // axis error (see astc4x4_fast_f16.wgsl).\n    let axis = principal_axis4(&pixels, mean, vec4<f32>(hi - lo), select(4u, 8u, opaque));\n    if (dot(axis, axis) > 0.0) {\n      var t_min: f32 = 1e30;\n      var t_max: f32 = -1e30;\n      for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n        let t = dot(vec4<f32>(pixels[k]) - mean, axis);\n        t_min = min(t_min, t);\n        t_max = max(t_max, t);\n      }\n      seed0 = vec4<i32>(clamp(round(mean + t_min * axis), vec4<f32>(0.0), vec4<f32>(255.0)));\n      seed1 = vec4<i32>(clamp(round(mean + t_max * axis), vec4<f32>(0.0), vec4<f32>(255.0)));\n    }\n    // Opaque blocks (CEM 8, 8-level weights) ship the quantised PCA\n    // extents directly; only the translucent CEM 12 path refits its coarse\n    // 4-level grid (see astc4x4_fast_f16.wgsl for the measured trade).\n    var e0 = lo;\n    var e1 = hi;\n    var fitStream = 0u;\n    var haveFitWeights = false;\n    if (opaque) {\n      // Bbox-clamped like the fit output (see astc4x4_fast_f16.wgsl).\n      e0 = clamp(seed0, lo, hi);\n      e1 = clamp(seed1, lo, hi);\n    } else {\n      let r = proj_fit(&pixels, seed0, seed1);\n      if (r.valid) {\n        e0 = clamp(r.e0, lo, hi);\n        e1 = clamp(r.e1, lo, hi);\n        fitStream = r.wstream;\n        haveFitWeights = true;\n      }\n    }\n    var swapped = false;\n    if (e0.x + e0.y + e0.z > e1.x + e1.y + e1.z) {\n      let tmp = e0; e0 = e1; e1 = tmp;\n      swapped = true;\n    }\n    let E0 = vec4<u32>(e0);\n    let E1 = vec4<u32>(e1);\n\n    // Weight pass against the final endpoints, packing on the fly.\n    let dir = vec4<f32>(e1 - e0);\n    let dd = dot(dir, dir);\n    let e0f = vec4<f32>(e0);\n    if (opaque) {\n      // CEM 8: 3-bit weights, stream bit q = 3k.\n      var s0 = 0u; var s1 = 0u;\n      if (dd > 0.0) {\n        let inv = 7.0 / dd;\n        for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n          let w = u32(clamp(floor(dot(vec4<f32>(pixels[k]) - e0f, dir) * inv + 0.5), 0.0, 7.0));\n          let off = 3u * k;\n          if (off < 30u) { s0 = s0 | (w << off); }\n          else if (off == 30u) { s0 = s0 | (w << 30u); s1 = s1 | (w >> 2u); }\n          else { s1 = s1 | (w << (off - 32u)); }\n        }\n      }\n      // Mode 0x053, CEM 8 @13, endpoints R0 R1 G0 G1 B0 B1 from bit 17.\n      w0 = 0x053u | (8u << 13u) | (E0.x << 17u) | (E1.x << 25u);\n      w1 = (E1.x >> 7u) | (E0.y << 1u) | (E1.y << 9u) | (E0.z << 17u) | (E1.z << 25u);\n      w2 = (E1.z >> 7u) | reverseBits(s1);\n      w3 = reverseBits(s0);\n    } else {\n      // CEM 12: 2-bit weights, stream bit q = 2k (single stream word).\n      // Valid fits ship the fit-pass weights; the blue-contraction swap is\n      // a full reflection w \u2192 3\u2212w = bitwise NOT of the packed stream (see\n      // astc4x4_fast_f16.wgsl for the measured trade).\n      var s0 = 0u;\n      if (haveFitWeights) {\n        s0 = select(fitStream, ~fitStream, swapped);\n      } else if (dd > 0.0) {\n        let inv = 3.0 / dd;\n        for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n          let w = u32(clamp(floor(dot(vec4<f32>(pixels[k]) - e0f, dir) * inv + 0.5), 0.0, 3.0));\n          s0 = s0 | (w << (2u * k));\n        }\n      }\n      // Mode 0x042, CEM 12 @13, endpoints R0 R1 G0 G1 B0 B1 A0 A1 from 17.\n      w0 = 0x042u | (12u << 13u) | (E0.x << 17u) | (E1.x << 25u);\n      w1 = (E1.x >> 7u) | (E0.y << 1u) | (E1.y << 9u) | (E0.z << 17u) | (E1.z << 25u);\n      w2 = (E1.z >> 7u) | (E0.w << 1u) | (E1.w << 9u);\n      w3 = reverseBits(s0);\n    }\n  }\n\n  let out = block_index * 4u;\n  dst[out + 0u] = w0;\n  dst[out + 1u] = w1;\n  dst[out + 2u] = w2;\n  dst[out + 3u] = w3;\n}\n";
 
 // src/astc4x4_fast_f16.wgsl
 var astc4x4_fast_f16_default = `// astc4x4 "fast" encoder \u2014 f16 variant (requires the shader-f16 feature).
-// Same algorithm family as the f32 fast path in astc4x4.wgsl (principal-axis
-// seed \u2192 projection weight assignment with a fused least-squares refit \u2192
-// reproject), tuned for throughput:
+// Same algorithm family as the f32 fallback in astc4x4.wgsl (per-block
+// class selection, principal-axis seed \u2192 projection weight assignment with
+// a fused least-squares refit \u2192 reproject), tuned for throughput:
 //
-//   \u2022 All projection / refit math in f16 ([0,1] domain). The projection
-//     direction is pre-scaled by 32 \u2014 a shallow block (endpoints ~1/255
-//     apart) has dd \u2248 1.5e-5, where 3/dd \u2248 2e5 overflows f16 (max 65504) to
-//     +inf and the projection dots go subnormal, turning weights and the LSQ
-//     refit to garbage (banding on smooth gradients). Scaling dir by 32 puts
-//     every intermediate in f16's normal range; s = dot\xB7(32\xB73/dd\u2083\u2082) is the
-//     same quantity (worst case inv = 96/0.0157 \u2248 6.1e3).
-//   \u2022 The seed pass only accumulates the LSQ sums (no weight output) \u2014 the
-//     final weights come from reprojecting against the refit endpoints.
+//   \u2022 THREE block classes, picked per block from the loaded pixels (the
+//     ASTC bit budget trades endpoint bits against weight bits, so a block
+//     only pays for the channels it uses):
+//       gray + opaque \u2192 CEM 0  (luminance), 5-bit weights, mode 0x253
+//       opaque        \u2192 CEM 8  (RGB),       3-bit weights, mode 0x053
+//       translucent   \u2192 CEM 12 (RGBA),      2-bit weights, mode 0x042
+//     "gray" = every texel R == G == B exactly (f16 equality is exact for
+//     8-bit sources), "opaque" = every texel A == 1. The gray path is
+//     scalar \u2014 no covariance, no power iteration, no 4-D fit \u2014 and runs
+//     [0,255]-integer f16 math like the BC5 kernel (exact endpoints, and
+//     64/span \u2264 64 never overflows f16, unlike a [0,1]-domain 1/dd).
+//   \u2022 All projection / refit math in f16 ([0,1] domain, colour paths).
+//     The projection direction is pre-scaled by 32 \u2014 a shallow block
+//     (endpoints ~1/255 apart) has dd \u2248 1.5e-5, where 3/dd \u2248 2e5 overflows
+//     f16 (max 65504) to +inf and the projection dots go subnormal,
+//     turning weights and the LSQ refit to garbage (banding on smooth
+//     gradients). Scaling dir by 32 puts every intermediate in f16's
+//     normal range; s = dot\xB7(32\xB7L/dd\u2083\u2082) is the same quantity (worst case
+//     for L = 7 levels: inv = 224/0.0157 \u2248 1.4e4).
+//   \u2022 Opaque blocks ship the quantised PCA extents directly (no LSQ fit
+//     pass, 8 power iterations \u2014 see the endpoint-selection comment); only
+//     the translucent CEM 12 path still refits, and its seed pass only
+//     accumulates the LSQ sums \u2014 final weights always come from a
+//     reprojection against the final endpoints.
 //   \u2022 Endpoint ordering (the blue-contraction rule: sum(e0.rgb) must not
 //     exceed sum(e1.rgb)) is applied BEFORE the final projection, so no
 //     weight-reflection pass is needed.
-//   \u2022 Weights are packed into the reversed-bit-order field on the fly, and
-//     the 128-bit block is assembled with straight-line constant shifts
-//     instead of a generic write_bits() helper.
+//   \u2022 Weight streams are accumulated LSB-first into u32 words and placed
+//     into the block's reversed-bit-order field with reverseBits() \u2014
+//     stream bit q lives at block bit 127 \u2212 q, so a whole stream word
+//     maps onto a block word with a single bit reversal.
+//   \u2022 The covariance moments stay in their OWN pass, deliberately: fusing
+//     them into the load loop bc7-style (pixel-0 residuals, with or without
+//     hoisting pixel 0 out of the loop) measured +5% GPU time on 4096\xB2
+//     (/ab A/B, 2026-07, M3) \u2014 the separate loop overlaps the 16 texture
+//     loads' latency better than a longer in-loop dependency chain does.
+//     Per-pass cost on the same rig, for future tuning: covariance+power-
+//     iteration \u2248 18%, LSQ fit pass \u2248 24%, extents pass \u2248 6% of the kernel;
+//     @workgroup_size 16\xD78 measured exactly at par with 8\xD78.
 //
-// RESTRICTED SUBSET + BLOCK LAYOUT: see astc4x4.wgsl (single partition,
-// CEM 12, 8-bit endpoints, 2-bit weights).
+// RESTRICTED SUBSET + BLOCK LAYOUT: see astc4x4_ref.ts (single partition,
+// CEM 0/8/12, 8-bit endpoints, plain-bit weight ISE, block modes
+// 0x253/0x053/0x042).
 //
 // The host selects this module only when the device reports shader-f16,
-// falling back to astc4x4.wgsl otherwise. "high" never uses this.
+// falling back to astc4x4.wgsl otherwise.
 enable f16;
 alias h = f16;
 alias h4 = vec4<f16>;
@@ -1128,10 +1602,15 @@ struct Params { blocks_x: u32, blocks_y: u32, width: u32, height: u32, };
 @group(0) @binding(1) var<storage, read_write> dst: array<u32>;
 @group(0) @binding(2) var<uniform> params: Params;
 
-struct Fit { e0: h4, e1: h4, valid: bool };
+// Fused projection + least-squares refit against the 4-level QUANT_4
+// palette \u2014 only the translucent (CEM 12) path still refits: the 2-bit
+// weight grid is coarse enough to need it, while the opaque paths get
+// more from spending the same time elsewhere (see header).
+struct Fit { e0: h4, e1: h4, valid: bool, wstream: u32 };
 fn proj_fit(pix: ptr<function, array<h4, 16>>, e0: h4, e1: h4) -> Fit {
   var out: Fit;
   out.valid = false;
+  out.wstream = 0u;
   // dir pre-scaled by 32 to keep dd and the projection dots in f16's normal
   // range (see header). Spans below ~0.7 of an 8-bit step (dd\u2083\u2082 < 0.008,
   // possible only for non-8-bit sources) are treated as flat.
@@ -1149,8 +1628,10 @@ fn proj_fit(pix: ptr<function, array<h4, 16>>, e0: h4, e1: h4) -> Fit {
   for (var k: u32 = 0u; k < 16u; k = k + 1u) {
     let vr = (*pix)[k] - e0;
     let s = clamp(floor(dot(vr, dir) * inv + h(0.5)), h(0.0), h(3.0));
+    out.wstream = out.wstream | (u32(s) << (2u * k));
     s_min = min(s_min, s); s_max = max(s_max, s);
-    let b = s * h(1.0 / 3.0); let a = h(1.0) - b;
+    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 * vr; sBV = sBV + b * vr;
   }
@@ -1178,102 +1659,218 @@ fn encode(@builtin(global_invocation_id) gid: vec3<u32>) {
   let base = vec2<i32>(i32(gid.x) * 4, i32(gid.y) * 4);
   let mx = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);
 
+  // Load pass. gd tracks the largest chroma deviation \u2014 0 iff the block is
+  // exactly grayscale (equal 8-bit channels convert to identical f16s).
   var pix: array<h4, 16>;
   var lo = h4(1.0);
   var hi = h4(0.0);
   var mean = h4(0.0);
+  var gd = h(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);
     mean = mean + px;
+    gd = max(gd, max(abs(px.x - px.y), abs(px.x - px.z)));
   }
   mean = mean * h(1.0 / 16.0);
+  let opaque = lo.w == h(1.0);
 
-  // Seed endpoints from the block's principal colour axis (covariance
-  // power-iteration, seeded with the bbox diagonal). The bbox diagonal is
-  // sign-blind: on anti-correlated channels (normal maps, hue edges) it
-  // points across the data instead of along it, and the LSQ refit \u2014 which
-  // fits endpoints GIVEN the projection weights \u2014 can't recover from a wrong
-  // axis. Deviations are pre-scaled \xD716 so covariance entries for shallow
-  // blocks stay in f16's normal range (span ~1/255 \u2192 d\xB2 \u2248 1e-3) while
-  // full-range sums stay \u22644096; the iteration renormalises by the max
-  // component (a plain length() of the matvec output could overflow f16), so
-  // only the direction survives.
-  var seed_lo = lo;
-  var seed_hi = hi;
-  var c0v = h4(0.0);
-  var c1v = h4(0.0);
-  var c2v = h4(0.0);
-  var c3v = h4(0.0);
-  for (var k: u32 = 0u; k < 16u; k = k + 1u) {
-    let d = (pix[k] - mean) * h(16.0);
-    c0v = c0v + d.x * d;
-    c1v = c1v + d.y * d;
-    c2v = c2v + d.z * d;
-    c3v = c3v + d.w * d;
-  }
-  var axis = hi - lo;
-  var axis_ok = true;
-  for (var it: u32 = 0u; it < 4u; it = it + 1u) {
-    let nv = h4(dot(c0v, axis), dot(c1v, axis), dot(c2v, axis), dot(c3v, axis));
-    let m = max(max(abs(nv.x), abs(nv.y)), max(abs(nv.z), abs(nv.w)));
-    if (m < h(1e-4)) { axis_ok = false; break; }
-    axis = nv / m;
-  }
-  if (axis_ok) {
-    axis = axis / length(axis);
-    var t_min = h(4.0);
-    var t_max = h(-4.0);
-    for (var k: u32 = 0u; k < 16u; k = k + 1u) {
-      let t = dot(pix[k] - mean, axis);
-      t_min = min(t_min, t);
-      t_max = max(t_max, t);
+  var w0: u32; var w1: u32; var w2: u32; var w3: u32;
+
+  if (opaque && gd == h(0.0)) {
+    // ---------------- Luminance path: CEM 0, 5-bit weights ----------------
+    // Scalar [0,255]-integer domain. Endpoints at the exact extremes (the
+    // 8-bit values round-trip f16 exactly); 32 palette levels make an LSQ
+    // refit unnecessary.
+    let L0 = u32(floor(lo.x * h(255.0) + h(0.5)));
+    let L1 = u32(floor(hi.x * h(255.0) + h(0.5)));
+    var s0 = 0u; var s1 = 0u; var s2 = 0u;
+    if (L1 > L0) {
+      let l0f = h(f32(L0));
+      let sc = h(64.0) / h(f32(L1 - L0)); // span \u2265 1 \u2192 sc \u2264 64, no overflow
+      // Exact nearest entry of the QUANT_32 grid: unq = 2w for w \u2264 15,
+      // 2w + 2 for w \u2265 16 (the grid has a 4-wide gap at the middle, so
+      // uniform rounding is wrong there). Evaluate the best candidate of
+      // each half and keep the closer.
+      for (var k: u32 = 0u; k < 16u; k = k + 1u) {
+        let v = floor(pix[k].x * h(255.0) + h(0.5)) - l0f; // exact integer
+        let u = clamp(v * sc, h(0.0), h(64.0));
+        let wlo = clamp(floor(u * h(0.5) + h(0.5)), h(0.0), h(15.0));
+        let whi = clamp(floor((u - h(2.0)) * h(0.5) + h(0.5)), h(16.0), h(31.0));
+        let pick = abs(u - wlo * h(2.0)) <= abs(u - (whi * h(2.0) + h(2.0)));
+        let w = u32(select(whi, wlo, pick));
+        // Stream bit q = 5k + j; straddles handled with constant shifts.
+        let off = 5u * k;
+        if (off < 28u) { s0 = s0 | (w << off); }
+        else if (off == 30u) { s0 = s0 | (w << 30u); s1 = s1 | (w >> 2u); }
+        else if (off < 60u) { s1 = s1 | (w << (off - 32u)); }
+        else if (off == 60u) { s1 = s1 | (w << 28u); s2 = s2 | (w >> 4u); }
+        else { s2 = s2 | (w << (off - 64u)); }
+      }
     }
-    seed_lo = clamp(mean + t_min * axis, h4(0.0), h4(1.0));
-    seed_hi = clamp(mean + t_max * axis, h4(0.0), h4(1.0));
-  }
-
-  // The refit is clamped to the block bbox: on multi-cluster blocks the
-  // unconstrained solve extrapolates far outside the block's colours and the
-  // per-channel [0,1] clamp then bends the hue \u2014 fringe pixels decode to
-  // colours that exist nowhere in the block. Constraining to the bbox also
-  // measures better in plain SSE (+1.8 dB on the colour test card).
-  let r = proj_fit(&pix, seed_lo, seed_hi);
-  var e0 = lo;
-  var e1 = hi;
-  if (r.valid) { e0 = clamp(r.e0, lo, hi); e1 = clamp(r.e1, lo, hi); }
-  var E0 = q8(e0);
-  var E1 = q8(e1);
-
-  // Blue-contraction ordering, applied before the weight pass so weights are
-  // already oriented (no reflection needed).
-  if (E0.x + E0.y + E0.z > E1.x + E1.y + E1.z) {
-    let t = E0; E0 = E1; E1 = t;
-  }
-  let d0 = h4(vec4<f32>(E0)) * h(1.0 / 255.0);
-  let d1 = h4(vec4<f32>(E1)) * h(1.0 / 255.0);
-
-  // Weight pass, packing on the fly: weight k's lsb at bit 31\u22122k of the last
-  // word, msb at bit 30\u22122k.
-  var w3: u32 = 0u;
-  // Same \xD732 pre-scale as proj_fit; distinct 8-bit endpoints are \u22651/255
-  // apart (dd\u2083\u2082 \u2265 0.0157), so the threshold only catches identical ones.
-  let dir = (d1 - d0) * h(32.0);
-  let dd = dot(dir, dir);
-  if (dd >= h(0.008)) {
-    let inv = h(96.0) / dd;
+    // Mode 0x253, partitions\u22121 = 0, CEM 0, L0 @17, L1 @25 (top bit spills
+    // into w1 bit 0); stream word q\u2208[0,31] \u2192 block bits 127\u202696 via
+    // reverseBits, q\u2208[32,63] \u2192 95\u202664, q\u2208[64,79] \u2192 63\u202648.
+    w0 = 0x253u | (L0 << 17u) | (L1 << 25u);
+    w1 = (L1 >> 7u) | reverseBits(s2);
+    w2 = reverseBits(s1);
+    w3 = reverseBits(s0);
+  } else {
+    // ------------- Colour paths: shared PCA seed + LSQ refit --------------
+    // Seed endpoints from the block's principal colour axis (covariance
+    // power-iteration, seeded with the bbox diagonal). The bbox diagonal is
+    // sign-blind: on anti-correlated channels (normal maps, hue edges) it
+    // points across the data instead of along it, and the LSQ refit \u2014 which
+    // fits endpoints GIVEN the projection weights \u2014 can't recover from a
+    // wrong axis. Deviations are pre-scaled \xD716 so covariance entries for
+    // shallow blocks stay in f16's normal range (span ~1/255 \u2192 d\xB2 \u2248 1e-3)
+    // while full-range sums stay \u22644096; the iteration renormalises by the
+    // max component (a plain length() of the matvec output could overflow
+    // f16), so only the direction survives.
+    var seed_lo = lo;
+    var seed_hi = hi;
+    var c0v = h4(0.0);
+    var c1v = h4(0.0);
+    var c2v = h4(0.0);
+    var c3v = h4(0.0);
     for (var k: u32 = 0u; k < 16u; k = k + 1u) {
-      let s = u32(clamp(floor(dot(pix[k] - d0, dir) * inv + h(0.5)), h(0.0), h(3.0)));
-      w3 = w3 | ((s & 1u) << (31u - 2u * k)) | (((s >> 1u) & 1u) << (30u - 2u * k));
+      let d = (pix[k] - mean) * h(16.0);
+      c0v = c0v + d.x * d;
+      c1v = c1v + d.y * d;
+      c2v = c2v + d.z * d;
+      c3v = c3v + d.w * d;
     }
-  }
+    var axis = hi - lo;
+    var axis_ok = true;
+    // 4 shared iterations, then 4 more for opaque blocks only \u2014 two
+    // FIXED-bound loops rather than one divergent trip count, so both
+    // unroll. Opaque blocks need the converged axis (it IS the endpoint
+    // quality there; 4 was under-converged on noisy 4-D content), while
+    // translucent blocks' LSQ refit absorbs residual axis error \u2014 their
+    // extra 4 steps measured exactly 0.000 dB on the alpha card for
+    // ~5% GPU.
+    for (var it: u32 = 0u; it < 4u; it = it + 1u) {
+      let nv = h4(dot(c0v, axis), dot(c1v, axis), dot(c2v, axis), dot(c3v, axis));
+      let m = max(max(abs(nv.x), abs(nv.y)), max(abs(nv.z), abs(nv.w)));
+      if (m < h(1e-4)) { axis_ok = false; break; }
+      axis = nv / m;
+    }
+    if (axis_ok && opaque) {
+      for (var it: u32 = 0u; it < 4u; it = it + 1u) {
+        let nv = h4(dot(c0v, axis), dot(c1v, axis), dot(c2v, axis), dot(c3v, axis));
+        let m = max(max(abs(nv.x), abs(nv.y)), max(abs(nv.z), abs(nv.w)));
+        if (m < h(1e-4)) { axis_ok = false; break; }
+        axis = nv / m;
+      }
+    }
+    if (axis_ok) {
+      axis = axis / length(axis);
+      var t_min = h(4.0);
+      var t_max = h(-4.0);
+      for (var k: u32 = 0u; k < 16u; k = k + 1u) {
+        let t = dot(pix[k] - mean, axis);
+        t_min = min(t_min, t);
+        t_max = max(t_max, t);
+      }
+      seed_lo = clamp(mean + t_min * axis, h4(0.0), h4(1.0));
+      seed_hi = clamp(mean + t_max * axis, h4(0.0), h4(1.0));
+    }
+
+    // Endpoint selection. OPAQUE blocks (CEM 8, 8-level weights) quantise
+    // the PCA-extent seed directly, BC7-style \u2014 the LSQ fit pass measured
+    // +26% GPU for \u22120.06..+0.31 dB against the converged 8-step axis
+    // (/ab + PSNR A/B, 2026-07): at 8 weight levels the projection is fine
+    // enough that a good axis, not a refit, carries the quality.
+    // TRANSLUCENT blocks (CEM 12) keep the fit: 4 levels are coarse enough
+    // that dropping it costs 0.5+ dB. Its result is clamped to the block
+    // bbox: on multi-cluster blocks the unconstrained solve extrapolates
+    // far outside the block's colours and the per-channel [0,1] clamp then
+    // bends the hue \u2014 fringe pixels decode to colours that exist nowhere
+    // in the block (and the bbox constraint also measures better in plain
+    // SSE, +1.8 dB on the colour test card).
+    var e0 = lo;
+    var e1 = hi;
+    var fitStream = 0u;
+    var haveFitWeights = false;
+    if (opaque) {
+      // Bbox-clamped like the fit output: on multi-cluster blocks the axis
+      // extents overshoot the data per-channel and decode to colours that
+      // exist nowhere in the block (the odd-size padding gate caught a
+      // \u22123.9 dB crop without this).
+      e0 = clamp(seed_lo, lo, hi);
+      e1 = clamp(seed_hi, lo, hi);
+    } else {
+      let r = proj_fit(&pix, seed_lo, seed_hi);
+      if (r.valid) {
+        e0 = clamp(r.e0, lo, hi);
+        e1 = clamp(r.e1, lo, hi);
+        fitStream = r.wstream;
+        haveFitWeights = true;
+      }
+    }
+    var E0 = q8(e0);
+    var E1 = q8(e1);
+
+    // Blue-contraction ordering, applied before the weight pass so weights
+    // are already oriented (no reflection needed).
+    var swapped = false;
+    if (E0.x + E0.y + E0.z > E1.x + E1.y + E1.z) {
+      let t = E0; E0 = E1; E1 = t;
+      swapped = true;
+    }
+    let d0 = h4(vec4<f32>(E0)) * h(1.0 / 255.0);
+    let d1 = h4(vec4<f32>(E1)) * h(1.0 / 255.0);
 
-  // Straight-line packing: block mode 0x042 @0, partitions\u22121=0 @11, CEM 12
-  // @13, endpoints R0 R1 G0 G1 B0 B1 A0 A1 (8 bits each) from bit 17.
-  let w0 = 0x042u | (12u << 13u) | (E0.x << 17u) | (E1.x << 25u);
-  let w1 = (E1.x >> 7u) | (E0.y << 1u) | (E1.y << 9u) | (E0.z << 17u) | (E1.z << 25u);
-  let w2 = (E1.z >> 7u) | (E0.w << 1u) | (E1.w << 9u);
+    // Weight pass against the decoded endpoints. Same \xD732 pre-scale as
+    // proj_fit; distinct 8-bit endpoints are \u22651/255 apart (dd\u2083\u2082 \u2265 0.0157),
+    // so the flat threshold only catches identical ones.
+    let dir = (d1 - d0) * h(32.0);
+    let dd = dot(dir, dir);
+    if (opaque) {
+      // CEM 8: 3-bit weights, stream bit q = 3k.
+      var s0 = 0u; var s1 = 0u;
+      if (dd >= h(0.008)) {
+        let inv = h(224.0) / dd;
+        for (var k: u32 = 0u; k < 16u; k = k + 1u) {
+          let w = u32(clamp(floor(dot(pix[k] - d0, dir) * inv + h(0.5)), h(0.0), h(7.0)));
+          let off = 3u * k;
+          if (off < 30u) { s0 = s0 | (w << off); }
+          else if (off == 30u) { s0 = s0 | (w << 30u); s1 = s1 | (w >> 2u); }
+          else { s1 = s1 | (w << (off - 32u)); }
+        }
+      }
+      // Mode 0x053, CEM 8 @13, endpoints R0 R1 G0 G1 B0 B1 from bit 17.
+      w0 = 0x053u | (8u << 13u) | (E0.x << 17u) | (E1.x << 25u);
+      w1 = (E1.x >> 7u) | (E0.y << 1u) | (E1.y << 9u) | (E0.z << 17u) | (E1.z << 25u);
+      w2 = (E1.z >> 7u) | reverseBits(s1);
+      w3 = reverseBits(s0);
+    } else {
+      // CEM 12: 2-bit weights, stream bit q = 2k (single stream word).
+      // Valid fits ship the FIT-PASS weights instead of reprojecting \u2014
+      // worth a whole 16-pixel pass for \u22120.09 dB on the alpha card (/ab +
+      // PSNR A/B, 2026-07; the pre-adaptive-CEM encoder rejected this same
+      // trade when EVERY block was CEM 12 \u2014 now only translucent blocks
+      // pay it). The blue-contraction swap is a full reflection w \u2192 3\u2212w,
+      // i.e. bitwise NOT of the packed stream. Invalid fits (rank-1 /
+      // degenerate) fall back to reprojection against the bbox endpoints.
+      var s0 = 0u;
+      if (haveFitWeights) {
+        s0 = select(fitStream, ~fitStream, swapped);
+      } else if (dd >= h(0.008)) {
+        let inv = h(96.0) / dd;
+        for (var k: u32 = 0u; k < 16u; k = k + 1u) {
+          let w = u32(clamp(floor(dot(pix[k] - d0, dir) * inv + h(0.5)), h(0.0), h(3.0)));
+          s0 = s0 | (w << (2u * k));
+        }
+      }
+      // Mode 0x042, CEM 12 @13, endpoints R0 R1 G0 G1 B0 B1 A0 A1 from 17.
+      w0 = 0x042u | (12u << 13u) | (E0.x << 17u) | (E1.x << 25u);
+      w1 = (E1.x >> 7u) | (E0.y << 1u) | (E1.y << 9u) | (E0.z << 17u) | (E1.z << 25u);
+      w2 = (E1.z >> 7u) | (E0.w << 1u) | (E1.w << 9u);
+      w3 = reverseBits(s0);
+    }
+  }
 
   let o = bi * 4u;
   dst[o] = w0; dst[o + 1u] = w1; dst[o + 2u] = w2; dst[o + 3u] = w3;
@@ -1293,9 +1890,6 @@ var ASTC4x4Encoder = class extends Encoder {
   get supportsSrgb() {
     return true;
   }
-  get supportsQuality() {
-    return true;
-  }
   wgslSource() {
     return astc4x4_default;
   }
@@ -1307,6 +1901,36 @@ var ASTC4x4Encoder = class extends Encoder {
   }
 };
 
+// src/etc2.wgsl
+var etc2_default = "// ETC2 RGB8 compute shader encoder.\n//\n// Each invocation encodes one 4x4 pixel block into an 8-byte ETC2 RGB8 block\n// written as 2 x u32 into the destination storage buffer. ETC2 blocks are\n// big-endian on the wire (byte 0 = bits 63..56), so both words are byte-\n// swapped on the way out. The f16 module (etc2_fast_f16.wgsl) is an\n// EXACT-VALUE port \u2014 byte-identical output; see its header.\n//\n// ALGORITHM \u2014 scalar-luma selection (2026-07 rewrite; the original\n// brute-force 8-table \xD7 4-modifier \xD7 vec3-with-clamp search measured\n// 6.0 ms @2048\xB2 on Apple/metal-3, this one ~0.197 ms with the DRAM read\n// floor \u2014 16 loads + store, nothing else \u2014 at ~0.15). This is the SETTLED\n// speed/quality point: the two-candidate scored search below was once\n// swapped for an O(1) hedged pick (\u22124-7% GPU) but cost \u22120.5 dB average \u2014\n// a ~10\xD7 worse dB-per-percent trade than the refit drop \u2014 and was\n// restored. A two-pass prepared-source variant (encode pass 0.115 ms) is\n// in git history: its prep pass is also DRAM-bound and cannot overlap,\n// so the per-texture total regressed. Reading the full RGBA8 source once\n// is this machine's hard floor for any single-pass encoder; the ~0.045\n// above it is the whole algorithm.\n//\n//   \u2022 The ETC1 modifier is a SCALAR shift along (1,1,1), so per texel\n//     err(m) = ||e||\xB2 \u2212 2mD + 3m\xB2 with D = luma(p) \u2212 luma(base), where\n//     luma(x) = x.r+x.g+x.b. Selection therefore needs only |D| threshold\n//     tests: the best table entry is the m with 3m nearest D (A3/B3/THR\n//     below), and \u03A3||e||\xB2 per subblock is O(1) from the load loop's\n//     quadrant sums (\u03A3||p||\xB2 \u2212 2\xB7base\xB7\u03A3p + 8\xB7||base||\xB2). This estimate is\n//     EXACT for unclamped decode and an UPPER BOUND on the true clamped\n//     error (clamping toward [0,255] can only shrink per-channel error),\n//     so every est-based gate is conservative.\n//   \u2022 Flip preselect, O(1): per subblock the residual after PERFECT\n//     continuous luma modulation is within-variance \u2212 (luma variance)/3;\n//     the flip with the smaller summed residual wins and only it is\n//     searched (both-flip est search measured +23% GPU for \u22640.15 dB).\n//     Exact-grayscale blocks have BOTH residuals identically zero (all\n//     variance is along luma), so near-ties fall back to scoring both\n//     flips \u2014 without that, roughness/AO-style content loses ~1.25 dB.\n//   \u2022 Table search is pruned to two candidates \u2014 the table whose LARGE\n//     magnitude covers max|D| and its lower neighbour (outlier hedge).\n//     One candidate loses ~1.2-1.6 dB on photos; all eight gain \u22640.05 dB.\n//   \u2022 NO base refit. The refit family (base \u2190 subblock mean \u2212 mean chosen\n//     modifier) was worth ~0.2 dB on photographic colour (rock-color\n//     33.98 \u2192 33.79 without it) but even its cheapest accepted form cost\n//     ~13% GPU and the exact-accept original ~30% \u2014 dropped 2026-07 as a\n//     deliberate speed/quality trade; see the suite baselines.\n//   \u2022 PLANAR runs unconditionally: with the right-hand sides folded into\n//     the load loop the LSQ solve is O(1) (the Gram inverse of the fixed\n//     sample positions is a constant, det = 25) and its residual is the\n//     closed-form \u03A3||p||\xB2 \u2212 2\xB7\u03B8\xB7rhs + \u03B8\u1D40G\u03B8 evaluated with the QUANTISED,\n//     clamped corners \u2014 exact up to decode's floor-rounding, and crucially\n//     clamp-aware (a continuous-corner estimate mis-picks planar on steep\n//     gradients). Gating planar cost \u22120.31 dB on smooth content for zero\n//     measured speed.\n//   \u2022 T and H modes are decoded by hardware but never emitted \u2014 their win\n//     is limited to two-chroma-cluster blocks (the colour card's per-pixel\n//     chroma checkers are the visible gap) and needs a clustering pass.\n//\n// Numeric notes: texel loads use round(load\xB7255) (integer-exact unorm trip);\n// every m3 in A3/B3 is divisible by 3 so m = m3/3 is exact; est values are\n// integer sums held exactly in f32 (< 2^24).\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\nconst A3  = array<f32, 8>(6.0, 15.0, 27.0, 39.0, 54.0, 72.0, 99.0, 141.0);\nconst B3  = array<f32, 8>(24.0, 51.0, 87.0, 126.0, 180.0, 240.0, 318.0, 549.0);\nconst THR = array<f32, 8>(15.0, 33.0, 57.0, 82.5, 117.0, 156.0, 208.5, 345.0);\n\n// Planar's closed-form estimate models the QUANTISED corners exactly; only\n// decode's floor-rounding (\xB1\xBD per sample) is unmodelled. This small bias\n// keeps near-ties on the predictable ETC1 side.\nconst PLANAR_FUDGE = 8.0;\n\nfn texel_of(flip: u32, sb: u32, i: u32) -> u32 {\n  if (flip == 0u) {\n    return (i >> 1u) * 4u + sb * 2u + (i & 1u);\n  }\n  return (sb * 2u + (i >> 2u)) * 4u + (i & 3u);\n}\n\nfn quant_codes(v: vec3<f32>, max_code: vec3<f32>) -> vec3<u32> {\n  return vec3<u32>(clamp(floor(v * max_code * (1.0 / 255.0) + 0.5), vec3<f32>(0.0), max_code));\n}\n\nfn extend4(c: vec3<u32>) -> vec3<f32> {\n  return vec3<f32>((c << vec3<u32>(4u)) | c);\n}\nfn extend5(c: vec3<u32>) -> vec3<f32> {\n  return vec3<f32>((c << vec3<u32>(3u)) | (c >> vec3<u32>(2u)));\n}\n\nfn signed3(bits: u32) -> i32 {\n  return select(i32(bits), i32(bits) - 8, bits > 3u);\n}\n\nfn bswap(x: u32) -> u32 {\n  return ((x & 0xffu) << 24u) | ((x & 0xff00u) << 8u) | ((x >> 8u) & 0xff00u) | (x >> 24u);\n}\n\nstruct BasePair {\n  codes0: vec3<u32>,\n  codes1: vec3<u32>,\n  ok: bool,\n};\nfn quantise_bases(avg0: vec3<f32>, avg1: vec3<f32>, diff: bool, clamp_delta: bool) -> BasePair {\n  var out: BasePair;\n  out.ok = true;\n  if (!diff) {\n    out.codes0 = quant_codes(avg0, vec3<f32>(15.0));\n    out.codes1 = quant_codes(avg1, vec3<f32>(15.0));\n    return out;\n  }\n  let q0 = vec3<i32>(quant_codes(avg0, vec3<f32>(31.0)));\n  let q1 = vec3<i32>(quant_codes(avg1, vec3<f32>(31.0)));\n  let d = q1 - q0;\n  if (any(d < vec3<i32>(-4)) || any(d > vec3<i32>(3))) {\n    if (!clamp_delta) {\n      out.ok = false;\n      return out;\n    }\n  }\n  out.codes0 = vec3<u32>(q0);\n  out.codes1 = vec3<u32>(q0 + clamp(d, vec3<i32>(-4), vec3<i32>(3)));\n  return out;\n}\n\nstruct SearchOut {\n  table: u32,\n  acc: f32,\n};\nfn sb_table_score(luma: ptr<function, array<f32, 16>>, flip: u32, sb: u32, lb: f32, t: u32) -> f32 {\n  let a3 = A3[t];\n  let b3 = B3[t];\n  let thr = THR[t];\n  var acc = 0.0;\n  for (var i: u32 = 0u; i < 8u; i = i + 1u) {\n    let ad = abs((*luma)[texel_of(flip, sb, i)] - lb);\n    let m3 = select(a3, b3, ad > thr);\n    acc = acc + m3 * (m3 - 2.0 * ad);\n  }\n  return acc;\n}\nfn sb_search(luma: ptr<function, array<f32, 16>>, flip: u32, sb: u32, lb: f32) -> SearchOut {\n  var mx = 0.0;\n  for (var i: u32 = 0u; i < 8u; i = i + 1u) {\n    mx = max(mx, abs((*luma)[texel_of(flip, sb, i)] - lb));\n  }\n  let cover = min(\n    u32(mx > 24.0) + u32(mx > 51.0) + u32(mx > 87.0) + u32(mx > 126.0) +\n    u32(mx > 180.0) + u32(mx > 240.0) + u32(mx > 318.0),\n    7u,\n  );\n  let t_lo = select(cover - 1u, 0u, cover == 0u);\n  let acc_lo = sb_table_score(luma, flip, sb, lb, t_lo);\n  let acc_hi = sb_table_score(luma, flip, sb, lb, cover);\n  var out: SearchOut;\n  let lo_wins = acc_lo <= acc_hi;\n  out.table = select(cover, t_lo, lo_wins);\n  out.acc = select(acc_hi, acc_lo, lo_wins);\n  return out;\n}\n\n// One flip's base quantisation + table search: everything the flip contest\n// and the index derivation need.\nstruct FlipFit {\n  est: f32,\n  diff: bool,\n  bases: BasePair,\n  lb0: f32,\n  lb1: f32,\n  t0: u32,\n  t1: u32,\n};\nfn eval_flip(\n  luma: ptr<function, array<f32, 16>>,\n  flip: u32,\n  sum0: vec3<f32>,\n  sq0: f32,\n  sum1: vec3<f32>,\n  sq1: f32,\n) -> FlipFit {\n  let avg0 = sum0 * 0.125;\n  let avg1 = sum1 * 0.125;\n  let try_diff = quantise_bases(avg0, avg1, true, false);\n  var out: FlipFit;\n  out.diff = try_diff.ok;\n  if (out.diff) {\n    out.bases = try_diff;\n  } else {\n    out.bases = quantise_bases(avg0, avg1, false, false);\n  }\n  var b0: vec3<f32>;\n  var b1: vec3<f32>;\n  if (out.diff) {\n    b0 = extend5(out.bases.codes0);\n    b1 = extend5(out.bases.codes1);\n  } else {\n    b0 = extend4(out.bases.codes0);\n    b1 = extend4(out.bases.codes1);\n  }\n  out.lb0 = b0.r + b0.g + b0.b;\n  out.lb1 = b1.r + b1.g + b1.b;\n  let s0 = sb_search(luma, flip, 0u, out.lb0);\n  let s1 = sb_search(luma, flip, 1u, out.lb1);\n  out.t0 = s0.table;\n  out.t1 = s1.table;\n  out.est = (sq0 - 2.0 * dot(b0, sum0) + 8.0 * dot(b0, b0)) +\n            (sq1 - 2.0 * dot(b1, sum1) + 8.0 * dot(b1, b1)) +\n            (s0.acc + s1.acc) * (1.0 / 3.0);\n  return out;\n}\n\n// Wire indices for a chosen table \u2014 computed ONCE, from the final base.\nfn sb_indices(luma: ptr<function, array<f32, 16>>, flip: u32, sb: u32, lb: f32, t: u32) -> u32 {\n  let thr = THR[t];\n  var indices = 0u;\n  for (var i: u32 = 0u; i < 8u; i = i + 1u) {\n    let d = (*luma)[texel_of(flip, sb, i)] - lb;\n    let large = abs(d) > thr;\n    let neg = d < 0.0;\n    indices = indices | ((select(0u, 1u, large) | select(0u, 2u, neg)) << (i * 2u));\n  }\n  return indices;\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 block_index = gid.y * params.blocks_x + gid.x;\n  let base_xy = vec2<i32>(i32(gid.x) * 4, i32(gid.y) * 4);\n  let max_xy = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  var luma: array<f32, 16>;\n  var qsum: array<vec3<f32>, 4>;\n  var qsq: array<f32, 4>;\n  var qlsq: array<f32, 4>;\n  // Planar right-hand sides, folded into the load: rB = \u03A3 (x/4)\xB7p and\n  // rC = \u03A3 (y/4)\xB7p accumulate unscaled; rA = \u03A3p \u2212 rB \u2212 rC afterwards.\n  var sxp = vec3<f32>(0.0);\n  var syp = vec3<f32>(0.0);\n\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_xy + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let c = round(textureLoad(src_tex, p, 0).rgb * 255.0);\n    let l = c.r + c.g + c.b;\n    luma[i] = l;\n    let q = u32(lx >= 2) | (u32(ly >= 2) << 1u);\n    qsum[q] = qsum[q] + c;\n    qsq[q] = qsq[q] + dot(c, c);\n    qlsq[q] = qlsq[q] + l * l;\n    sxp = sxp + f32(lx) * c;\n    syp = syp + f32(ly) * c;\n  }\n\n  // ----------------------------------------------- flip + base selection --\n  // Flip preselect, O(1) from quadrant sums: per subblock the residual after\n  // PERFECT continuous luma modulation is (\u03A3||p||\xB2 \u2212 ||\u03A3p||\xB2/8) \u2212\n  // (\u03A3\u2113\xB2 \u2212 (\u03A3\u2113)\xB2/8)/3 \u2014 the within-variance minus the (1,1,1)-direction\n  // component the modifier tables can absorb. The flip minimising the summed\n  // residual wins and only it gets the table search \u2014 EXCEPT when the two\n  // residuals are indistinguishable: for exact-grayscale blocks (r=g=b) both\n  // are identically zero, so the contest falls back to scoring both flips\n  // (this recovered \u22121.25 dB on roughness/AO-style content).\n  let sum0a = qsum[0] + qsum[2];\n  let sum1a = qsum[1] + qsum[3];\n  let sq0a = qsq[0] + qsq[2];\n  let sq1a = qsq[1] + qsq[3];\n  let sum0b = qsum[0] + qsum[1];\n  let sum1b = qsum[2] + qsum[3];\n  let sq0b = qsq[0] + qsq[1];\n  let sq1b = qsq[2] + qsq[3];\n  let lsq0a = qlsq[0] + qlsq[2];\n  let lsq1a = qlsq[1] + qlsq[3];\n  let lsq0b = qlsq[0] + qlsq[1];\n  let lsq1b = qlsq[2] + qlsq[3];\n  let res_a = (sq0a - dot(sum0a, sum0a) * 0.125) - (lsq0a - dot(sum0a, vec3<f32>(1.0)) * dot(sum0a, vec3<f32>(1.0)) * 0.125) * (1.0 / 3.0)\n            + (sq1a - dot(sum1a, sum1a) * 0.125) - (lsq1a - dot(sum1a, vec3<f32>(1.0)) * dot(sum1a, vec3<f32>(1.0)) * 0.125) * (1.0 / 3.0);\n  let res_b = (sq0b - dot(sum0b, sum0b) * 0.125) - (lsq0b - dot(sum0b, vec3<f32>(1.0)) * dot(sum0b, vec3<f32>(1.0)) * 0.125) * (1.0 / 3.0)\n            + (sq1b - dot(sum1b, sum1b) * 0.125) - (lsq1b - dot(sum1b, vec3<f32>(1.0)) * dot(sum1b, vec3<f32>(1.0)) * 0.125) * (1.0 / 3.0);\n\n  // Single eval_flip call site (a second inlined copy measured +50% GPU):\n  // attempt 0 scores the primary flip, attempt 1 runs only in the dual\n  // (indistinguishable-residuals) case and scores the other flip.\n  let dual = abs(res_a - res_b) < 1.0;\n  let primary = select(select(0u, 1u, res_b < res_a), 0u, dual);\n  var bflip = primary;\n  var sel: FlipFit;\n  for (var attempt = 0u; attempt < 2u; attempt = attempt + 1u) {\n    if (attempt == 1u && !dual) {\n      break;\n    }\n    let f = select(primary, 1u, attempt == 1u);\n    let cand = eval_flip(\n      &luma,\n      f,\n      select(sum0a, sum0b, f == 1u),\n      select(sq0a, sq0b, f == 1u),\n      select(sum1a, sum1b, f == 1u),\n      select(sq1a, sq1b, f == 1u),\n    );\n    if (attempt == 0u || cand.est < sel.est) {\n      sel = cand;\n      bflip = f;\n    }\n  }\n  let bdiff = sel.diff;\n\n  let best_est = sel.est;\n  let codes0 = sel.bases.codes0;\n  let codes1 = sel.bases.codes1;\n  let t0 = sel.t0;\n  let t1 = sel.t1;\n  let fit0 = sb_indices(&luma, bflip, 0u, sel.lb0, t0);\n  let fit1 = sb_indices(&luma, bflip, 1u, sel.lb1, t1);\n\n  // ------------------------------------------------------------ planar --\n  // Always evaluated: with the rhs folded into the load loop this is O(1),\n  // and gating it on the ETC1 estimate measured \u22120.31 dB on smooth content\n  // for zero speed.\n  let total = qsum[0] + qsum[1] + qsum[2] + qsum[3];\n  let sqtotal = qsq[0] + qsq[1] + qsq[2] + qsq[3];\n  let rB = sxp * 0.25;\n  let rC = syp * 0.25;\n  let rA = total - rB - rC;\n  let po = 0.2875 * rA - 0.0125 * rB - 0.0125 * rC;\n  let ph = -0.0125 * rA + 0.4875 * rB - 0.3125 * rC;\n  let pv = -0.0125 * rA - 0.3125 * rB + 0.4875 * rC;\n  let pmax = vec3<f32>(63.0, 127.0, 63.0);\n  let qo = quant_codes(po, pmax);\n  let qh = quant_codes(ph, pmax);\n  let qv = quant_codes(pv, pmax);\n  // Residual of the plane the hardware will ACTUALLY decode \u2014 the\n  // quantised, clamped corners \u2014 via the normal-equation identity\n  // \u03A3||p \u2212 f||\xB2 = \u03A3||p||\xB2 \u2212 2\xB7\u03B8\xB7rhs + \u03B8\u1D40G\u03B8 (G is the constant Gram matrix\n  // of the fixed sample positions). Estimating with the CONTINUOUS corners\n  // instead is blind to corner clamping and mis-picks planar on steep\n  // gradients (a 1.4-normalised-SSE easy-block artifact on the colour\n  // card). Only decode's floor-rounding stays unmodelled (\u2264 ~12 SSE).\n  let shl = vec3<u32>(2u, 1u, 2u);\n  let shr = vec3<u32>(4u, 6u, 4u);\n  let eo = vec3<f32>((qo << shl) | (qo >> shr));\n  let eh = vec3<f32>((qh << shl) | (qh >> shr));\n  let ev = vec3<f32>((qv << shl) | (qv >> shr));\n  let gram = 3.5 * (eo * eo + eh * eh + ev * ev) + 0.5 * eo * eh + 0.5 * eo * ev + 4.5 * eh * ev;\n  let planar_est = sqtotal - 2.0 * (dot(eo, rA) + dot(eh, rB) + dot(ev, rC)) +\n                   dot(gram, vec3<f32>(1.0)) + PLANAR_FUDGE;\n\n  // ------------------------------------------------------------ packing --\n  var hi: u32;\n  var lo: u32;\n  if (best_est <= planar_est) {\n    if (bdiff) {\n      let d = vec3<u32>(vec3<i32>(codes1) - vec3<i32>(codes0)) & vec3<u32>(7u);\n      hi = (codes0.r << 27u) | (d.r << 24u) | (codes0.g << 19u) | (d.g << 16u) | (codes0.b << 11u) | (d.b << 8u)\n         | (t0 << 5u) | (t1 << 2u) | 2u | bflip;\n    } else {\n      hi = (codes0.r << 28u) | (codes1.r << 24u) | (codes0.g << 20u) | (codes1.g << 16u) | (codes0.b << 12u) | (codes1.b << 8u)\n         | (t0 << 5u) | (t1 << 2u) | bflip;\n    }\n    lo = 0u;\n    for (var sb: u32 = 0u; sb < 2u; sb = sb + 1u) {\n      let indices = select(fit0, fit1, sb == 1u);\n      for (var i: u32 = 0u; i < 8u; i = i + 1u) {\n        let k = texel_of(bflip, sb, i);\n        let wire = (k & 3u) * 4u + (k >> 2u);\n        let idx = (indices >> (i * 2u)) & 3u;\n        lo = lo | ((idx & 1u) << wire) | ((idx >> 1u) << (16u + wire));\n      }\n    }\n  } else {\n    let ro = qo.r; let go = qo.g; let bo = qo.b;\n    let rh = qh.r; let gh = qh.g; let bh = qh.b;\n    let rv = qv.r; let gv = qv.g; let bv = qv.b;\n    let r_sum = i32(ro >> 2u) + signed3(((ro & 3u) << 1u) | (go >> 6u));\n    let r_fix = select(0u, 1u, r_sum < 0);\n    let g_sum = i32((go >> 2u) & 15u) + signed3(((go & 3u) << 1u) | (bo >> 5u));\n    let g_fix = select(0u, 1u, g_sum < 0);\n    let p = (bo >> 3u) & 3u;\n    let q = (bo >> 1u) & 3u;\n    let b_fix3 = select(0u, 7u, p + q >= 4u);\n    let b_fix1 = select(1u, 0u, p + q >= 4u);\n    hi = (r_fix << 31u) | (ro << 25u) | ((go >> 6u) << 24u) | (g_fix << 23u) | ((go & 63u) << 17u)\n       | ((bo >> 5u) << 16u) | (b_fix3 << 13u) | (((bo >> 3u) & 3u) << 11u) | (b_fix1 << 10u)\n       | ((bo & 7u) << 7u) | ((rh >> 1u) << 2u) | 2u | (rh & 1u);\n    lo = (gh << 25u) | (bh << 19u) | (rv << 13u) | (gv << 6u) | bv;\n  }\n\n  let out = block_index * 2u;\n  dst[out]      = bswap(hi);\n  dst[out + 1u] = bswap(lo);\n}\n";
+
+// src/etc2_fast_f16.wgsl
+var etc2_fast_f16_default = "// ETC2 RGB8 compute shader encoder.\n//\n// Each invocation encodes one 4x4 pixel block into an 8-byte ETC2 RGB8 block\n// written as 2 x u32 into the destination storage buffer. ETC2 blocks are\n// big-endian on the wire (byte 0 = bits 63..56), so both words are byte-\n// swapped on the way out. This is that f16 module.\n//\n// EXACT-VALUE f16: unlike the other formats' f16 fast paths (which accept\n// float rounding in a [0,1] domain), every f16 value in this shader is an\n// integer that f16 represents exactly \u2014 lumas and bases (<= 765), D values\n// (|D| <= 765) and thresholds (<= 549) all sit below f16's 2048 integer-\n// exactness limit. Sums of squares, scores and estimates stay f32 (they\n// reach +-5e5..9e6, far past f16's 65504 max). The output is therefore\n// BYTE-IDENTICAL to the f32 module \u2014 verified per-block on the suite\n// textures \u2014 and the two modules share every pin and every test gate.\n//\n// What f16 buys here is register pressure (the luma array halves), not\n// arithmetic rate: on Apple/metal-3 the two modules measure identical\n// (the shader is DRAM-read-bound), but on the mobile GPUs where ETC2 is\n// actually the target format, occupancy from smaller registers is the\n// cheapest speed there is. The COLOUR accumulators deliberately stay f32\n// even though quadrant/pair sums (<= 2040) would be exact in f16: porting\n// them measured 15% SLOWER on Apple (conversion traffic outweighs the\n// register saving). Luma + the table search are the f16 surface.\n//\n// ALGORITHM \u2014 scalar-luma selection (2026-07 rewrite; the original\n// brute-force 8-table \xD7 4-modifier \xD7 vec3-with-clamp search measured\n// 6.0 ms @2048\xB2 on Apple/metal-3, this one ~0.197 ms with the DRAM read\n// floor \u2014 16 loads + store, nothing else \u2014 at ~0.15). This is the SETTLED\n// speed/quality point: the two-candidate scored search below was once\n// swapped for an O(1) hedged pick (\u22124-7% GPU) but cost \u22120.5 dB average \u2014\n// a ~10\xD7 worse dB-per-percent trade than the refit drop \u2014 and was\n// restored. A two-pass prepared-source variant (encode pass 0.115 ms) is\n// in git history: its prep pass is also DRAM-bound and cannot overlap,\n// so the per-texture total regressed. Reading the full RGBA8 source once\n// is this machine's hard floor for any single-pass encoder; the ~0.045\n// above it is the whole algorithm.\n//\n//   \u2022 The ETC1 modifier is a SCALAR shift along (1,1,1), so per texel\n//     err(m) = ||e||\xB2 \u2212 2mD + 3m\xB2 with D = luma(p) \u2212 luma(base), where\n//     luma(x) = x.r+x.g+x.b. Selection therefore needs only |D| threshold\n//     tests: the best table entry is the m with 3m nearest D (A3/B3/THR\n//     below), and \u03A3||e||\xB2 per subblock is O(1) from the load loop's\n//     quadrant sums (\u03A3||p||\xB2 \u2212 2\xB7base\xB7\u03A3p + 8\xB7||base||\xB2). This estimate is\n//     EXACT for unclamped decode and an UPPER BOUND on the true clamped\n//     error (clamping toward [0,255] can only shrink per-channel error),\n//     so every est-based gate is conservative.\n//   \u2022 Flip preselect, O(1): per subblock the residual after PERFECT\n//     continuous luma modulation is within-variance \u2212 (luma variance)/3;\n//     the flip with the smaller summed residual wins and only it is\n//     searched (both-flip est search measured +23% GPU for \u22640.15 dB).\n//     Exact-grayscale blocks have BOTH residuals identically zero (all\n//     variance is along luma), so near-ties fall back to scoring both\n//     flips \u2014 without that, roughness/AO-style content loses ~1.25 dB.\n//   \u2022 Table search is pruned to two candidates \u2014 the table whose LARGE\n//     magnitude covers max|D| and its lower neighbour (outlier hedge).\n//     One candidate loses ~1.2-1.6 dB on photos; all eight gain \u22640.05 dB.\n//   \u2022 NO base refit. The refit family (base \u2190 subblock mean \u2212 mean chosen\n//     modifier) was worth ~0.2 dB on photographic colour (rock-color\n//     33.98 \u2192 33.79 without it) but even its cheapest accepted form cost\n//     ~13% GPU and the exact-accept original ~30% \u2014 dropped 2026-07 as a\n//     deliberate speed/quality trade; see the suite baselines.\n//   \u2022 PLANAR runs unconditionally: with the right-hand sides folded into\n//     the load loop the LSQ solve is O(1) (the Gram inverse of the fixed\n//     sample positions is a constant, det = 25) and its residual is the\n//     closed-form \u03A3||p||\xB2 \u2212 2\xB7\u03B8\xB7rhs + \u03B8\u1D40G\u03B8 evaluated with the QUANTISED,\n//     clamped corners \u2014 exact up to decode's floor-rounding, and crucially\n//     clamp-aware (a continuous-corner estimate mis-picks planar on steep\n//     gradients). Gating planar cost \u22120.31 dB on smooth content for zero\n//     measured speed.\n//   \u2022 T and H modes are decoded by hardware but never emitted \u2014 their win\n//     is limited to two-chroma-cluster blocks (the colour card's per-pixel\n//     chroma checkers are the visible gap) and needs a clustering pass.\n//\n// Numeric notes: texel loads use round(load\xB7255) (integer-exact unorm trip);\n// every m3 in A3/B3 is divisible by 3 so m = m3/3 is exact; est values are\n// integer sums held exactly in f32 (< 2^24).\n\nenable f16;\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\nconst A3  = array<f32, 8>(6.0, 15.0, 27.0, 39.0, 54.0, 72.0, 99.0, 141.0);\nconst B3  = array<f32, 8>(24.0, 51.0, 87.0, 126.0, 180.0, 240.0, 318.0, 549.0);\nconst THR = array<f32, 8>(15.0, 33.0, 57.0, 82.5, 117.0, 156.0, 208.5, 345.0);\n\n// Planar's closed-form estimate models the QUANTISED corners exactly; only\n// decode's floor-rounding (\xB1\xBD per sample) is unmodelled. This small bias\n// keeps near-ties on the predictable ETC1 side.\nconst PLANAR_FUDGE = 8.0;\n\nfn texel_of(flip: u32, sb: u32, i: u32) -> u32 {\n  if (flip == 0u) {\n    return (i >> 1u) * 4u + sb * 2u + (i & 1u);\n  }\n  return (sb * 2u + (i >> 2u)) * 4u + (i & 3u);\n}\n\nfn quant_codes(v: vec3<f32>, max_code: vec3<f32>) -> vec3<u32> {\n  return vec3<u32>(clamp(floor(v * max_code * (1.0 / 255.0) + 0.5), vec3<f32>(0.0), max_code));\n}\n\nfn extend4(c: vec3<u32>) -> vec3<f32> {\n  return vec3<f32>((c << vec3<u32>(4u)) | c);\n}\nfn extend5(c: vec3<u32>) -> vec3<f32> {\n  return vec3<f32>((c << vec3<u32>(3u)) | (c >> vec3<u32>(2u)));\n}\n\nfn signed3(bits: u32) -> i32 {\n  return select(i32(bits), i32(bits) - 8, bits > 3u);\n}\n\nfn bswap(x: u32) -> u32 {\n  return ((x & 0xffu) << 24u) | ((x & 0xff00u) << 8u) | ((x >> 8u) & 0xff00u) | (x >> 24u);\n}\n\nstruct BasePair {\n  codes0: vec3<u32>,\n  codes1: vec3<u32>,\n  ok: bool,\n};\nfn quantise_bases(avg0: vec3<f32>, avg1: vec3<f32>, diff: bool, clamp_delta: bool) -> BasePair {\n  var out: BasePair;\n  out.ok = true;\n  if (!diff) {\n    out.codes0 = quant_codes(avg0, vec3<f32>(15.0));\n    out.codes1 = quant_codes(avg1, vec3<f32>(15.0));\n    return out;\n  }\n  let q0 = vec3<i32>(quant_codes(avg0, vec3<f32>(31.0)));\n  let q1 = vec3<i32>(quant_codes(avg1, vec3<f32>(31.0)));\n  let d = q1 - q0;\n  if (any(d < vec3<i32>(-4)) || any(d > vec3<i32>(3))) {\n    if (!clamp_delta) {\n      out.ok = false;\n      return out;\n    }\n  }\n  out.codes0 = vec3<u32>(q0);\n  out.codes1 = vec3<u32>(q0 + clamp(d, vec3<i32>(-4), vec3<i32>(3)));\n  return out;\n}\n\nstruct SearchOut {\n  table: u32,\n  acc: f32,\n};\n// D-domain values (|D| <= 765, thresholds <= 549) are exact in f16; the\n// score PRODUCTS reach +-5e5 and must be f32.\nfn sb_table_score(luma: ptr<function, array<f16, 16>>, flip: u32, sb: u32, lb: f16, t: u32) -> f32 {\n  let a3 = f16(A3[t]);\n  let b3 = f16(B3[t]);\n  let thr = f16(THR[t]);\n  var acc = 0.0;\n  for (var i: u32 = 0u; i < 8u; i = i + 1u) {\n    let ad = abs((*luma)[texel_of(flip, sb, i)] - lb);\n    let m3 = f32(select(a3, b3, ad > thr));\n    acc = acc + m3 * (m3 - 2.0 * f32(ad));\n  }\n  return acc;\n}\nfn sb_search(luma: ptr<function, array<f16, 16>>, flip: u32, sb: u32, lb: f16) -> SearchOut {\n  var mx: f16 = 0.0;\n  for (var i: u32 = 0u; i < 8u; i = i + 1u) {\n    mx = max(mx, abs((*luma)[texel_of(flip, sb, i)] - lb));\n  }\n  let mxf = f32(mx);\n  let cover = min(\n    u32(mxf > 24.0) + u32(mxf > 51.0) + u32(mxf > 87.0) + u32(mxf > 126.0) +\n    u32(mxf > 180.0) + u32(mxf > 240.0) + u32(mxf > 318.0),\n    7u,\n  );\n  let t_lo = select(cover - 1u, 0u, cover == 0u);\n  let acc_lo = sb_table_score(luma, flip, sb, lb, t_lo);\n  let acc_hi = sb_table_score(luma, flip, sb, lb, cover);\n  var out: SearchOut;\n  let lo_wins = acc_lo <= acc_hi;\n  out.table = select(cover, t_lo, lo_wins);\n  out.acc = select(acc_hi, acc_lo, lo_wins);\n  return out;\n}\n\n// One flip's base quantisation + table search: everything the flip contest\n// and the index derivation need.\nstruct FlipFit {\n  est: f32,\n  diff: bool,\n  bases: BasePair,\n  lb0: f32,\n  lb1: f32,\n  t0: u32,\n  t1: u32,\n};\nfn eval_flip(\n  luma: ptr<function, array<f16, 16>>,\n  flip: u32,\n  sum0: vec3<f32>,\n  sq0: f32,\n  sum1: vec3<f32>,\n  sq1: f32,\n) -> FlipFit {\n  let avg0 = sum0 * 0.125;\n  let avg1 = sum1 * 0.125;\n  let try_diff = quantise_bases(avg0, avg1, true, false);\n  var out: FlipFit;\n  out.diff = try_diff.ok;\n  if (out.diff) {\n    out.bases = try_diff;\n  } else {\n    out.bases = quantise_bases(avg0, avg1, false, false);\n  }\n  var b0: vec3<f32>;\n  var b1: vec3<f32>;\n  if (out.diff) {\n    b0 = extend5(out.bases.codes0);\n    b1 = extend5(out.bases.codes1);\n  } else {\n    b0 = extend4(out.bases.codes0);\n    b1 = extend4(out.bases.codes1);\n  }\n  out.lb0 = b0.r + b0.g + b0.b;\n  out.lb1 = b1.r + b1.g + b1.b;\n  let s0 = sb_search(luma, flip, 0u, f16(out.lb0));\n  let s1 = sb_search(luma, flip, 1u, f16(out.lb1));\n  out.t0 = s0.table;\n  out.t1 = s1.table;\n  out.est = (sq0 - 2.0 * dot(b0, sum0) + 8.0 * dot(b0, b0)) +\n            (sq1 - 2.0 * dot(b1, sum1) + 8.0 * dot(b1, b1)) +\n            (s0.acc + s1.acc) * (1.0 / 3.0);\n  return out;\n}\n\n// Wire indices for a chosen table \u2014 computed ONCE, from the final base.\nfn sb_indices(luma: ptr<function, array<f16, 16>>, flip: u32, sb: u32, lb: f16, t: u32) -> u32 {\n  let thr = f16(THR[t]);\n  var indices = 0u;\n  for (var i: u32 = 0u; i < 8u; i = i + 1u) {\n    let d = (*luma)[texel_of(flip, sb, i)] - lb;\n    let large = abs(d) > thr;\n    let neg = d < 0.0;\n    indices = indices | ((select(0u, 1u, large) | select(0u, 2u, neg)) << (i * 2u));\n  }\n  return indices;\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 block_index = gid.y * params.blocks_x + gid.x;\n  let base_xy = vec2<i32>(i32(gid.x) * 4, i32(gid.y) * 4);\n  let max_xy = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  // Luma lives in f16: every value is an integer <= 765, exact in f16.\n  var luma: array<f16, 16>;\n  var qsum: array<vec3<f32>, 4>;\n  var qsq: array<f32, 4>;\n  var qlsq: array<f32, 4>;\n  // Planar right-hand sides, folded into the load: rB = \u03A3 (x/4)\xB7p and\n  // rC = \u03A3 (y/4)\xB7p accumulate unscaled; rA = \u03A3p \u2212 rB \u2212 rC afterwards.\n  var sxp = vec3<f32>(0.0);\n  var syp = vec3<f32>(0.0);\n\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_xy + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let c = round(textureLoad(src_tex, p, 0).rgb * 255.0);\n    let l = c.r + c.g + c.b;\n    luma[i] = f16(l);\n    let q = u32(lx >= 2) | (u32(ly >= 2) << 1u);\n    qsum[q] = qsum[q] + c;\n    qsq[q] = qsq[q] + dot(c, c);\n    qlsq[q] = qlsq[q] + l * l;\n    sxp = sxp + f32(lx) * c;\n    syp = syp + f32(ly) * c;\n  }\n\n  // ----------------------------------------------- flip + base selection --\n  // Flip preselect, O(1) from quadrant sums: per subblock the residual after\n  // PERFECT continuous luma modulation is (\u03A3||p||\xB2 \u2212 ||\u03A3p||\xB2/8) \u2212\n  // (\u03A3\u2113\xB2 \u2212 (\u03A3\u2113)\xB2/8)/3 \u2014 the within-variance minus the (1,1,1)-direction\n  // component the modifier tables can absorb. The flip minimising the summed\n  // residual wins and only it gets the table search \u2014 EXCEPT when the two\n  // residuals are indistinguishable: for exact-grayscale blocks (r=g=b) both\n  // are identically zero, so the contest falls back to scoring both flips\n  // (this recovered \u22121.25 dB on roughness/AO-style content).\n  let sum0a = qsum[0] + qsum[2];\n  let sum1a = qsum[1] + qsum[3];\n  let sq0a = qsq[0] + qsq[2];\n  let sq1a = qsq[1] + qsq[3];\n  let sum0b = qsum[0] + qsum[1];\n  let sum1b = qsum[2] + qsum[3];\n  let sq0b = qsq[0] + qsq[1];\n  let sq1b = qsq[2] + qsq[3];\n  let lsq0a = qlsq[0] + qlsq[2];\n  let lsq1a = qlsq[1] + qlsq[3];\n  let lsq0b = qlsq[0] + qlsq[1];\n  let lsq1b = qlsq[2] + qlsq[3];\n  let res_a = (sq0a - dot(sum0a, sum0a) * 0.125) - (lsq0a - dot(sum0a, vec3<f32>(1.0)) * dot(sum0a, vec3<f32>(1.0)) * 0.125) * (1.0 / 3.0)\n            + (sq1a - dot(sum1a, sum1a) * 0.125) - (lsq1a - dot(sum1a, vec3<f32>(1.0)) * dot(sum1a, vec3<f32>(1.0)) * 0.125) * (1.0 / 3.0);\n  let res_b = (sq0b - dot(sum0b, sum0b) * 0.125) - (lsq0b - dot(sum0b, vec3<f32>(1.0)) * dot(sum0b, vec3<f32>(1.0)) * 0.125) * (1.0 / 3.0)\n            + (sq1b - dot(sum1b, sum1b) * 0.125) - (lsq1b - dot(sum1b, vec3<f32>(1.0)) * dot(sum1b, vec3<f32>(1.0)) * 0.125) * (1.0 / 3.0);\n\n  // Single eval_flip call site (a second inlined copy measured +50% GPU):\n  // attempt 0 scores the primary flip, attempt 1 runs only in the dual\n  // (indistinguishable-residuals) case and scores the other flip.\n  let dual = abs(res_a - res_b) < 1.0;\n  let primary = select(select(0u, 1u, res_b < res_a), 0u, dual);\n  var bflip = primary;\n  var sel: FlipFit;\n  for (var attempt = 0u; attempt < 2u; attempt = attempt + 1u) {\n    if (attempt == 1u && !dual) {\n      break;\n    }\n    let f = select(primary, 1u, attempt == 1u);\n    let cand = eval_flip(\n      &luma,\n      f,\n      select(sum0a, sum0b, f == 1u),\n      select(sq0a, sq0b, f == 1u),\n      select(sum1a, sum1b, f == 1u),\n      select(sq1a, sq1b, f == 1u),\n    );\n    if (attempt == 0u || cand.est < sel.est) {\n      sel = cand;\n      bflip = f;\n    }\n  }\n  let bdiff = sel.diff;\n\n  let best_est = sel.est;\n  let codes0 = sel.bases.codes0;\n  let codes1 = sel.bases.codes1;\n  let t0 = sel.t0;\n  let t1 = sel.t1;\n  let fit0 = sb_indices(&luma, bflip, 0u, f16(sel.lb0), t0);\n  let fit1 = sb_indices(&luma, bflip, 1u, f16(sel.lb1), t1);\n\n  // ------------------------------------------------------------ planar --\n  // Always evaluated: with the rhs folded into the load loop this is O(1),\n  // and gating it on the ETC1 estimate measured \u22120.31 dB on smooth content\n  // for zero speed.\n  let total = qsum[0] + qsum[1] + qsum[2] + qsum[3];\n  let sqtotal = qsq[0] + qsq[1] + qsq[2] + qsq[3];\n  let rB = sxp * 0.25;\n  let rC = syp * 0.25;\n  let rA = total - rB - rC;\n  let po = 0.2875 * rA - 0.0125 * rB - 0.0125 * rC;\n  let ph = -0.0125 * rA + 0.4875 * rB - 0.3125 * rC;\n  let pv = -0.0125 * rA - 0.3125 * rB + 0.4875 * rC;\n  let pmax = vec3<f32>(63.0, 127.0, 63.0);\n  let qo = quant_codes(po, pmax);\n  let qh = quant_codes(ph, pmax);\n  let qv = quant_codes(pv, pmax);\n  // Residual of the plane the hardware will ACTUALLY decode \u2014 the\n  // quantised, clamped corners \u2014 via the normal-equation identity\n  // \u03A3||p \u2212 f||\xB2 = \u03A3||p||\xB2 \u2212 2\xB7\u03B8\xB7rhs + \u03B8\u1D40G\u03B8 (G is the constant Gram matrix\n  // of the fixed sample positions). Estimating with the CONTINUOUS corners\n  // instead is blind to corner clamping and mis-picks planar on steep\n  // gradients (a 1.4-normalised-SSE easy-block artifact on the colour\n  // card). Only decode's floor-rounding stays unmodelled (\u2264 ~12 SSE).\n  let shl = vec3<u32>(2u, 1u, 2u);\n  let shr = vec3<u32>(4u, 6u, 4u);\n  let eo = vec3<f32>((qo << shl) | (qo >> shr));\n  let eh = vec3<f32>((qh << shl) | (qh >> shr));\n  let ev = vec3<f32>((qv << shl) | (qv >> shr));\n  let gram = 3.5 * (eo * eo + eh * eh + ev * ev) + 0.5 * eo * eh + 0.5 * eo * ev + 4.5 * eh * ev;\n  let planar_est = sqtotal - 2.0 * (dot(eo, rA) + dot(eh, rB) + dot(ev, rC)) +\n                   dot(gram, vec3<f32>(1.0)) + PLANAR_FUDGE;\n\n  // ------------------------------------------------------------ packing --\n  var hi: u32;\n  var lo: u32;\n  if (best_est <= planar_est) {\n    if (bdiff) {\n      let d = vec3<u32>(vec3<i32>(codes1) - vec3<i32>(codes0)) & vec3<u32>(7u);\n      hi = (codes0.r << 27u) | (d.r << 24u) | (codes0.g << 19u) | (d.g << 16u) | (codes0.b << 11u) | (d.b << 8u)\n         | (t0 << 5u) | (t1 << 2u) | 2u | bflip;\n    } else {\n      hi = (codes0.r << 28u) | (codes1.r << 24u) | (codes0.g << 20u) | (codes1.g << 16u) | (codes0.b << 12u) | (codes1.b << 8u)\n         | (t0 << 5u) | (t1 << 2u) | bflip;\n    }\n    lo = 0u;\n    for (var sb: u32 = 0u; sb < 2u; sb = sb + 1u) {\n      let indices = select(fit0, fit1, sb == 1u);\n      for (var i: u32 = 0u; i < 8u; i = i + 1u) {\n        let k = texel_of(bflip, sb, i);\n        let wire = (k & 3u) * 4u + (k >> 2u);\n        let idx = (indices >> (i * 2u)) & 3u;\n        lo = lo | ((idx & 1u) << wire) | ((idx >> 1u) << (16u + wire));\n      }\n    }\n  } else {\n    let ro = qo.r; let go = qo.g; let bo = qo.b;\n    let rh = qh.r; let gh = qh.g; let bh = qh.b;\n    let rv = qv.r; let gv = qv.g; let bv = qv.b;\n    let r_sum = i32(ro >> 2u) + signed3(((ro & 3u) << 1u) | (go >> 6u));\n    let r_fix = select(0u, 1u, r_sum < 0);\n    let g_sum = i32((go >> 2u) & 15u) + signed3(((go & 3u) << 1u) | (bo >> 5u));\n    let g_fix = select(0u, 1u, g_sum < 0);\n    let p = (bo >> 3u) & 3u;\n    let q = (bo >> 1u) & 3u;\n    let b_fix3 = select(0u, 7u, p + q >= 4u);\n    let b_fix1 = select(1u, 0u, p + q >= 4u);\n    hi = (r_fix << 31u) | (ro << 25u) | ((go >> 6u) << 24u) | (g_fix << 23u) | ((go & 63u) << 17u)\n       | ((bo >> 5u) << 16u) | (b_fix3 << 13u) | (((bo >> 3u) & 3u) << 11u) | (b_fix1 << 10u)\n       | ((bo & 7u) << 7u) | ((rh >> 1u) << 2u) | 2u | (rh & 1u);\n    lo = (gh << 25u) | (bh << 19u) | (rv << 13u) | (gv << 6u) | bv;\n  }\n\n  let out = block_index * 2u;\n  dst[out]      = bswap(hi);\n  dst[out + 1u] = bswap(lo);\n}\n";
+
+// src/ETC2Encoder.ts
+var ETC2Encoder = class extends Encoder {
+  static requiredFeature = WebGPUFeature.ETC2;
+  static textureFormats = [TextureFormat.ETC2_RGB8, TextureFormat.ETC2_RGB8_SRGB];
+  get label() {
+    return "etc2";
+  }
+  get bytesPerBlock() {
+    return 8;
+  }
+  get supportsSrgb() {
+    return true;
+  }
+  wgslSource() {
+    return etc2_default;
+  }
+  wgslSourceFastF16() {
+    return etc2_fast_f16_default;
+  }
+  gpuTextureFormat({ colorSpace }) {
+    return colorSpace === "srgb" ? "etc2-rgb8unorm-srgb" : "etc2-rgb8unorm";
+  }
+};
+
 // 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";
 
@@ -1518,7 +2142,7 @@ var WebGLBlockEncoder = class {
 };
 
 // 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 (fast path).\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. This is the *fast* path only (the WGSL\n// `QUALITY_HIGH == 0` branch): principal-axis endpoint seed (covariance\n// power-iteration; inset bbox on degenerate blocks), RGB565 quantisation,\n// forced 4-colour mode, full 4-entry L2 index search, then a single\n// least-squares endpoint refit accepted only when it lowers the block's error.\n// See bc1.wgsl for the full derivation.\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\n// 4-colour-mode interpolation weights: pal[j] = WA[j]*c0 + WB[j]*c1.\nconst float WA[4] = float[4](1.0, 0.0, 2.0 / 3.0, 1.0 / 3.0);\nconst float WB[4] = float[4](0.0, 1.0, 1.0 / 3.0, 2.0 / 3.0);\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  // 5/6-bit \u2192 8-bit. floor((x*527+23)/64) == (x<<3)|(x>>2): exact hardware\n  // bit-replication (white \u2192 255), so index selection matches the GPU decode.\n  float r8 = floor((r * 527.0 + 23.0) / 64.0);\n  float g8 = floor((g * 259.0 + 33.0) / 64.0);\n  float b8 = floor((b * 527.0 + 23.0) / 64.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  vec3 mean = 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    mean += c;\n  }\n  mean /= 16.0;\n\n  // Seed endpoints from the block's principal colour axis (covariance\n  // power-iteration, seeded with the bbox diagonal \u2014 mirrors bc1.wgsl). The\n  // bbox diagonal is sign-blind: on anti-correlated channels (normal maps,\n  // hue edges) it points across the data instead of along it, and the LSQ\n  // refit below \u2014 which fits endpoints GIVEN the indices \u2014 can't recover.\n  // Degenerate (near-flat) blocks keep the inset-bbox seed. Both seeds inset\n  // by ~half an RGB565 cell (1/16) to tighten the quantised palette.\n  vec3 c0v = vec3(0.0);\n  vec3 c1v = vec3(0.0);\n  vec3 c2v = vec3(0.0);\n  for (int k = 0; k < 16; k++) {\n    vec3 d = pixels[k] - mean;\n    c0v += d.x * d;\n    c1v += d.y * d;\n    c2v += d.z * d;\n  }\n  vec3 hi;\n  vec3 lo;\n  vec3 axis = bbMax - bbMin;\n  float alen = length(axis);\n  bool axisOk = alen > 1e-9;\n  if (axisOk) {\n    axis /= alen;\n    for (int it = 0; it < 8; it++) {\n      vec3 nv = vec3(dot(c0v, axis), dot(c1v, axis), dot(c2v, axis));\n      float nlen = length(nv);\n      if (nlen < 1e-12) { axisOk = false; break; }\n      axis = nv / nlen;\n    }\n  }\n  if (axisOk) {\n    float tMin = 1e30;\n    float tMax = -1e30;\n    for (int k = 0; k < 16; k++) {\n      float t = dot(pixels[k] - mean, axis);\n      tMin = min(tMin, t);\n      tMax = max(tMax, t);\n    }\n    float pad = (tMax - tMin) / 16.0;\n    hi = clamp(mean + (tMax - pad) * axis, vec3(0.0), vec3(1.0));\n    lo = clamp(mean + (tMin + pad) * axis, vec3(0.0), vec3(1.0));\n  } else {\n    vec3 inset = (bbMax - bbMin) / 16.0;\n    hi = clamp(bbMax - inset, vec3(0.0), vec3(1.0));\n    lo = clamp(bbMin + inset, vec3(0.0), vec3(1.0));\n  }\n\n  uint c0 = to565(hi);\n  uint c1 = to565(lo);\n  // 4-colour mode requires color0 > color1.\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  // Build the palette in decoded space, assign each pixel its nearest entry.\n  vec3 pal[4];\n  vec3 p0 = from565(c0);\n  vec3 p1 = from565(c1);\n  for (int j = 0; j < 4; j++) pal[j] = WA[j] * p0 + WB[j] * p1;\n\n  uint idx[16];\n  float err = 0.0;\n  for (int k = 0; k < 16; k++) {\n    vec3 c = pixels[k];\n    uint bestJ = 0u;\n    float bestD = 1e30;\n    for (int j = 0; j < 4; j++) {\n      vec3 d = pal[j] - c;\n      float d2 = dot(d, d);\n      if (d2 < bestD) { bestD = d2; bestJ = uint(j); }\n    }\n    idx[k] = bestJ;\n    err += bestD;\n  }\n\n  // One least-squares refit: re-solve the endpoints for the current indices,\n  // re-quantise, re-assign; keep it only if the squared error drops.\n  float sAA = 0.0, sBB = 0.0, sAB = 0.0;\n  vec3 sAV = vec3(0.0), sBV = vec3(0.0);\n  for (int k = 0; k < 16; k++) {\n    float a = WA[int(idx[k])];\n    float b = WB[int(idx[k])];\n    vec3 v = pixels[k];\n    sAA += a * a; sBB += b * b; sAB += a * b; sAV += a * v; sBV += b * v;\n  }\n  float det = sAA * sBB - sAB * sAB;\n  if (abs(det) > 1e-9) {\n    // Clamp the refit to the block bbox (not [0,1]): on multi-cluster blocks\n    // the unconstrained LSQ solve extrapolates far outside the block's colours\n    // and the per-channel clamp then bends the hue \u2014 fringe pixels decode to\n    // colours that exist nowhere in the block. Constraining to the bbox also\n    // measures better in plain SSE (+1.6 dB on the colour test card), so the\n    // accept-if-better guard below keeps more refits.\n    vec3 e0 = clamp((sBB * sAV - sAB * sBV) / det, bbMin, bbMax);\n    vec3 e1 = clamp((sAA * sBV - sAB * sAV) / det, bbMin, bbMax);\n    uint nc0 = to565(e0);\n    uint nc1 = to565(e1);\n    if (nc0 < nc1) { uint t = nc0; nc0 = nc1; nc1 = t; }\n    if (nc0 != nc1 && !(nc0 == c0 && nc1 == c1)) {\n      vec3 q0 = from565(nc0);\n      vec3 q1 = from565(nc1);\n      vec3 pal2[4];\n      for (int j = 0; j < 4; j++) pal2[j] = WA[j] * q0 + WB[j] * q1;\n      uint idx2[16];\n      float nerr = 0.0;\n      for (int k = 0; k < 16; k++) {\n        vec3 c = pixels[k];\n        uint bestJ = 0u;\n        float bestD = 1e30;\n        for (int j = 0; j < 4; j++) {\n          vec3 d = pal2[j] - c;\n          float d2 = dot(d, d);\n          if (d2 < bestD) { bestD = d2; bestJ = uint(j); }\n        }\n        idx2[k] = bestJ;\n        nerr += bestD;\n      }\n      if (nerr < err) {\n        c0 = nc0; c1 = nc1;\n        for (int k = 0; k < 16; k++) idx[k] = idx2[k];\n      }\n    }\n  }\n\n  uint indices = 0u;\n  for (int k = 0; k < 16; k++) indices |= (idx[k] & 3u) << (uint(k) * 2u);\n\n  outColor = uvec4(c0 | (c1 << 16), indices, 0u, 0u);\n}\n";
+var bc1_frag_default = "#version 300 es\n// BC1 (DXT1) fragment-shader encoder \u2014 WebGL2 port of bc1.wgsl (fast path).\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. Same algorithm as bc1.wgsl:\n// principal-axis endpoint seed (covariance\n// power-iteration; inset bbox on degenerate blocks), RGB565 quantisation,\n// forced 4-colour mode, full 4-entry L2 index search, then up to TWO\n// least-squares endpoint refit rounds, each accepted only when it lowers the\n// block's error. See bc1.wgsl for the full derivation.\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\n// 4-colour-mode interpolation weights: pal[j] = WA[j]*c0 + WB[j]*c1.\nconst float WA[4] = float[4](1.0, 0.0, 2.0 / 3.0, 1.0 / 3.0);\nconst float WB[4] = float[4](0.0, 1.0, 1.0 / 3.0, 2.0 / 3.0);\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  // 5/6-bit \u2192 8-bit. floor((x*527+23)/64) == (x<<3)|(x>>2): exact hardware\n  // bit-replication (white \u2192 255), so index selection matches the GPU decode.\n  float r8 = floor((r * 527.0 + 23.0) / 64.0);\n  float g8 = floor((g * 259.0 + 33.0) / 64.0);\n  float b8 = floor((b * 527.0 + 23.0) / 64.0);\n  return vec3(r8, g8, b8) / 255.0;\n}\n\n// Per-invocation scratch (mirrors the WGSL function-scope arrays passed by\n// ptr; GLSL would copy array parameters by value).\nvec3 gPixels[16];\nuint gIdx[16];\n\n// Nearest-palette assignment of gPixels for the decoded palette of (c0,c1),\n// with the block's squared error and the LSQ normal-equation sums of the\n// resulting assignment accumulated in the same pass \u2014 so an accepted refit\n// can seed the next round.\nstruct Assign { float err; float sAA; float sBB; float sAB; vec3 sAV; vec3 sBV; };\nAssign assignStats(uint c0, uint c1, out uint indices[16]) {\n  vec3 p0 = from565(c0);\n  vec3 p1 = from565(c1);\n  vec3 pal[4];\n  for (int j = 0; j < 4; j++) pal[j] = WA[j] * p0 + WB[j] * p1;\n  Assign r = Assign(0.0, 0.0, 0.0, 0.0, vec3(0.0), vec3(0.0));\n  for (int k = 0; k < 16; k++) {\n    vec3 c = gPixels[k];\n    uint bestJ = 0u;\n    float bestD = 1e30;\n    for (int j = 0; j < 4; j++) {\n      vec3 d = pal[j] - c;\n      float d2 = dot(d, d);\n      if (d2 < bestD) { bestD = d2; bestJ = uint(j); }\n    }\n    indices[k] = bestJ;\n    r.err += bestD;\n    float a = WA[int(bestJ)];\n    float b = WB[int(bestJ)];\n    r.sAA += a * a; r.sBB += b * b; r.sAB += a * b; r.sAV += a * c; r.sBV += b * c;\n  }\n  return r;\n}\n\nvoid main() {\n  ivec2 base = ivec2(gl_FragCoord.xy) * 4;\n  ivec2 maxXY = uSrcSize - ivec2(1);\n\n  float gd = 0.0;\n  vec3 bbMin = vec3(1.0);\n  vec3 bbMax = vec3(0.0);\n  vec3 mean = 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    gPixels[i] = c;\n    bbMin = min(bbMin, c);\n    gd = max(gd, max(abs(c.x - c.y), abs(c.x - c.z)));\n    bbMax = max(bbMax, c);\n    mean += c;\n  }\n  mean /= 16.0;\n\n  // Seed endpoints from the block's principal colour axis (covariance\n  // power-iteration, seeded with the bbox diagonal \u2014 mirrors bc1.wgsl). The\n  // bbox diagonal is sign-blind: on anti-correlated channels (normal maps,\n  // hue edges) it points across the data instead of along it, and the LSQ\n  // refit below \u2014 which fits endpoints GIVEN the indices \u2014 can't recover.\n  // Degenerate (near-flat) blocks keep the inset-bbox seed. Both seeds inset\n  // by ~half an RGB565 cell (1/16) to tighten the quantised palette.\n  vec3 c0v = vec3(0.0);\n  vec3 c1v = vec3(0.0);\n  vec3 c2v = vec3(0.0);\n  for (int k = 0; k < 16; k++) {\n    vec3 d = gPixels[k] - mean;\n    c0v += d.x * d;\n    c1v += d.y * d;\n    c2v += d.z * d;\n  }\n  vec3 hi;\n  vec3 lo;\n  vec3 axis = bbMax - bbMin;\n  float alen = length(axis);\n  bool axisOk = alen > 1e-9;\n  if (axisOk) {\n    axis /= alen;\n    for (int it = 0; it < 8; it++) {\n      vec3 nv = vec3(dot(c0v, axis), dot(c1v, axis), dot(c2v, axis));\n      float nlen = length(nv);\n      if (nlen < 1e-12) { axisOk = false; break; }\n      axis = nv / nlen;\n    }\n  }\n  if (axisOk) {\n    float tMin = 1e30;\n    float tMax = -1e30;\n    for (int k = 0; k < 16; k++) {\n      float t = dot(gPixels[k] - mean, axis);\n      tMin = min(tMin, t);\n      tMax = max(tMax, t);\n    }\n    float pad = (tMax - tMin) / 16.0;\n    hi = clamp(mean + (tMax - pad) * axis, vec3(0.0), vec3(1.0));\n    lo = clamp(mean + (tMin + pad) * axis, vec3(0.0), vec3(1.0));\n  } else {\n    vec3 inset = (bbMax - bbMin) / 16.0;\n    hi = clamp(bbMax - inset, vec3(0.0), vec3(1.0));\n    lo = clamp(bbMin + inset, vec3(0.0), vec3(1.0));\n  }\n\n  uint c0 = to565(hi);\n  uint c1 = to565(lo);\n  // 4-colour mode requires color0 > color1.\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  // Seed assignment, then up to TWO least-squares refit rounds (mirroring\n  // bc1.wgsl's fast path), each accepted only if the block's squared error\n  // drops \u2014 the refit minimises a continuous objective and can lose after\n  // 565 quantisation. Every assignment pass re-accumulates the sums, so an\n  // accepted round seeds the next.\n  // Exactly-gray blocks free the refit from the bbox clamp (no hue to\n  // protect; smooth gradients want endpoints outside the data range) \u2014\n  // see bc1_fast_f16.wgsl.\n  vec3 limLo = gd == 0.0 ? vec3(0.0) : bbMin;\n  vec3 limHi = gd == 0.0 ? vec3(1.0) : bbMax;\n  Assign cur = assignStats(c0, c1, gIdx);\n  for (int it = 0; it < 2; it++) {\n    float det = cur.sAA * cur.sBB - cur.sAB * cur.sAB;\n    if (abs(det) <= 1e-9) { break; }\n    // Clamp the refit to the block bbox (not [0,1]): on multi-cluster blocks\n    // the unconstrained LSQ solve extrapolates far outside the block's\n    // colours and the per-channel clamp then bends the hue \u2014 fringe pixels\n    // decode to colours that exist nowhere in the block. Constraining to the\n    // bbox also measures better in plain SSE (+1.6 dB on the colour test\n    // card), so the accept-if-better guard below keeps more refits.\n    vec3 e0 = clamp((cur.sBB * cur.sAV - cur.sAB * cur.sBV) / det, limLo, limHi);\n    vec3 e1 = clamp((cur.sAA * cur.sBV - cur.sAB * cur.sAV) / det, limLo, limHi);\n    uint nc0 = to565(e0);\n    uint nc1 = to565(e1);\n    if (nc0 < nc1) { uint t = nc0; nc0 = nc1; nc1 = t; }\n    if (nc0 == nc1 || (nc0 == c0 && nc1 == c1)) { break; }\n    uint idx2[16];\n    Assign nxt = assignStats(nc0, nc1, idx2);\n    if (nxt.err >= cur.err) { break; }\n    c0 = nc0; c1 = nc1;\n    cur = nxt;\n    for (int k = 0; k < 16; k++) gIdx[k] = idx2[k];\n  }\n\n  uint indices = 0u;\n  for (int k = 0; k < 16; k++) indices |= (gIdx[k] & 3u) << (uint(k) * 2u);\n\n  outColor = uvec4(c0 | (c1 << 16), indices, 0u, 0u);\n}\n";
 
 // src/webgl/BC1WebGLEncoder.ts
 var BC1WebGLEncoder = class extends WebGLBlockEncoder {
@@ -1537,7 +2161,7 @@ var BC1WebGLEncoder = class extends WebGLBlockEncoder {
 };
 
 // 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 full-L2 index assignment per channel with the least-squares\n// refit sums accumulated in the same pass, then one refit accepted only when\n// it lowers the block's error (mirrors bc5.wgsl's fast branch \u2014 worth\n// ~1.3 dB on the normal-map card). 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// Nearest-palette assignment with the LSQ normal-equation sums and total\n// squared error accumulated in the same pass. Sums are only consumed by the\n// caller's refit; err drives the accept-if-better test.\nstruct Assign { float err; float sAA; float sBB; float sAB; float sAV; float sBV; };\nAssign assignAll(float values[16], float pal[8], out uint indices[16]) {\n  Assign r = Assign(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);\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    r.err += bestD;\n    float a = W0_6[int(bestJ)];\n    float b = W1_6[int(bestJ)];\n    r.sAA += a * a; r.sBB += b * b; r.sAB += a * b; r.sAV += a * v; r.sBV += b * v;\n  }\n  return r;\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's fast branch: bbox seed, fused\n// assignment + LSQ sums, refit accepted only if the error drops. vmin/vmax\n// are the channel's min/max, computed in the caller's load loop \u2014 fusing\n// that scan there saves a 16-value pass per channel.\nuvec2 encodeBC4(float values[16], float vmin, float vmax) {\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  Assign seed = assignAll(values, pal, indices);\n\n  // One least-squares refit, accepted only if the requantised endpoints lower\n  // the block error. Clamp to the block's value range (a strict-SSE win vs\n  // clamping to [0,1], same as the other formats' fast paths); keep 6-interp\n  // mode (r0 > r1 strictly).\n  float det = seed.sAA * seed.sBB - seed.sAB * seed.sAB;\n  if (abs(det) > 1e-9) {\n    float e0 = clamp((seed.sBB * seed.sAV - seed.sAB * seed.sBV) / det, vmin, vmax);\n    float e1 = clamp((seed.sAA * seed.sBV - seed.sAB * seed.sAV) / det, vmin, vmax);\n    uint n0 = quantize8(e0);\n    uint n1 = quantize8(e1);\n    if (n0 > n1 && !(n0 == r0 && n1 == r1)) {\n      float pal2[8];\n      float n0f = float(n0) / 255.0;\n      float n1f = float(n1) / 255.0;\n      for (int j = 0; j < 8; j++) {\n        pal2[j] = W0_6[j] * n0f + W1_6[j] * n1f;\n      }\n      uint idx2[16];\n      Assign refit = assignAll(values, pal2, idx2);\n      if (refit.err < seed.err) {\n        r0 = n0; r1 = n1;\n        for (int k = 0; k < 16; k++) indices[k] = idx2[k];\n      }\n    }\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  float rMin = 1.0; float rMax = 0.0;\n  float gMin = 1.0; float gMax = 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    vec4 c = texelFetch(uSrc, ivec2(p.x, sy), 0);\n    rValues[i] = c.r;\n    gValues[i] = c.g;\n    rMin = min(rMin, c.r); rMax = max(rMax, c.r);\n    gMin = min(gMin, c.g); gMax = max(gMax, c.g);\n  }\n\n  uvec2 rBlock = encodeBC4(rValues, rMin, rMax);\n  uvec2 gBlock = encodeBC4(gValues, gMin, gMax);\n  outColor = uvec4(rBlock.x, rBlock.y, gBlock.x, gBlock.y);\n}\n";
+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 full-L2 index assignment per channel with the least-squares\n// refit sums accumulated in the same pass, then one refit accepted\n// CLOSED-FORM when it lowers the block's error on the seed indices \u2014 the\n// accepted endpoints ship with the seed indices, no second assignment pass\n// (mirrors bc5.wgsl; see bc5_fast_f16.wgsl for the measured trade). Always\n// emits 6-interpolation mode (red0 > red1).\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// Nearest-palette assignment with the LSQ normal-equation sums and total\n// squared error accumulated in the same pass. Sums are only consumed by the\n// caller's refit; err drives the accept-if-better test.\nstruct Assign { float err; float sAA; float sBB; float sAB; float sAV; float sBV; };\nAssign assignAll(float values[16], float pal[8], out uint indices[16]) {\n  Assign r = Assign(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);\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    r.err += bestD;\n    float a = W0_6[int(bestJ)];\n    float b = W1_6[int(bestJ)];\n    r.sAA += a * a; r.sBB += b * b; r.sAB += a * b; r.sAV += a * v; r.sBV += b * v;\n  }\n  return r;\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's fast branch: bbox seed, fused\n// assignment + LSQ sums, refit accepted only if the error drops. vmin/vmax\n// are the channel's min/max, computed in the caller's load loop \u2014 fusing\n// that scan there saves a 16-value pass per channel.\nuvec2 encodeBC4(float values[16], float vmin, float vmax) {\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  Assign seed = assignAll(values, pal, indices);\n\n  // One least-squares refit, accepted CLOSED-FORM: with the seed indices\n  // kept, the block error for endpoints (e0, e1) is\n  //   E(e0, e1) = sAA\xB7e0\xB2 + sBB\xB7e1\xB2 + 2(sAB\xB7e0\xB7e1 \u2212 e0\xB7sAV \u2212 e1\xB7sBV) + \u03A3V\xB2\n  // and \u03A3V\xB2 cancels out of the accept comparison, so no second assignment\n  // pass is needed. Clamp to [0,1], NOT the block's value range: for a\n  // scalar channel, endpoints beyond the data range are often genuinely\n  // optimal and there is no colour axis to bend \u2014 the bbox clamp the colour\n  // formats need costs ~0.3 dB here. Keep 6-interp mode (r0 > r1 strictly).\n  float det = seed.sAA * seed.sBB - seed.sAB * seed.sAB;\n  if (abs(det) > 1e-9) {\n    float e0 = clamp((seed.sBB * seed.sAV - seed.sAB * seed.sBV) / det, 0.0, 1.0) * 255.0;\n    float e1 = clamp((seed.sAA * seed.sBV - seed.sAB * seed.sAV) / det, 0.0, 1.0) * 255.0;\n    // Price all four floor/ceil roundings of the fractional solve\n    // closed-form (see bc5_fast_f16.wgsl); keep the best that stays in\n    // 6-interp mode and beats the seed.\n    float quadSeed = seed.sAA * r0f * r0f + seed.sBB * r1f * r1f\n      + 2.0 * (seed.sAB * r0f * r1f - r0f * seed.sAV - r1f * seed.sBV);\n    float bestQuad = quadSeed;\n    uint seed0 = r0;\n    uint seed1 = r1;\n    for (uint m = 0u; m < 4u; m++) {\n      float q0f = clamp(floor(e0) + float(m & 1u), 0.0, 255.0);\n      float q1f = clamp(floor(e1) + float(m >> 1u), 0.0, 255.0);\n      uint n0 = uint(q0f);\n      uint n1 = uint(q1f);\n      if (n0 > n1 && !(n0 == seed0 && n1 == seed1)) {\n        float n0f = q0f / 255.0;\n        float n1f = q1f / 255.0;\n        float quadNew = seed.sAA * n0f * n0f + seed.sBB * n1f * n1f\n          + 2.0 * (seed.sAB * n0f * n1f - n0f * seed.sAV - n1f * seed.sBV);\n        if (quadNew < bestQuad) {\n          bestQuad = quadNew;\n          r0 = n0; r1 = n1;\n        }\n      }\n    }\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  float rMin = 1.0; float rMax = 0.0;\n  float gMin = 1.0; float gMax = 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    vec4 c = texelFetch(uSrc, ivec2(p.x, sy), 0);\n    rValues[i] = c.r;\n    gValues[i] = c.g;\n    rMin = min(rMin, c.r); rMax = max(rMax, c.r);\n    gMin = min(gMin, c.g); gMax = max(gMax, c.g);\n  }\n\n  uvec2 rBlock = encodeBC4(rValues, rMin, rMax);\n  uvec2 gBlock = encodeBC4(gValues, gMin, gMax);\n  outColor = uvec4(rBlock.x, rBlock.y, gBlock.x, gBlock.y);\n}\n";
 
 // src/webgl/BC5WebGLEncoder.ts
 var BC5WebGLEncoder = class extends WebGLBlockEncoder {
@@ -1556,7 +2180,7 @@ var BC5WebGLEncoder = class extends WebGLBlockEncoder {
 };
 
 // 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: principal-axis seed (covariance power-iteration; bbox on degenerate\n// blocks) at the exact projection extents, quantised directly (no LSQ refit \u2014\n// mode 6's 16-level palette leaves it under 0.15 dB) \u2192 one projection-based\n// index-assignment pass (palette is colinear, so the nearest entry is found\n// by projecting onto the endpoint line \u2014 O(1) per pixel). Mirrors the\n// `QUALITY_HIGH == 0` branch of bc7.wgsl; see that file for the mode-6 bit\n// 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// Principal colour axis via power-iteration over precomputed, mean-corrected\n// covariance rows (the moments are accumulated for free in the pixel-load\n// loop), seeded with the bbox diagonal. Returns a unit axis, or vec4(0.0)\n// for a degenerate (constant) block. The bbox diagonal alone is sign-blind\n// and points across anti-correlated data (normal maps, hue edges) instead of\n// along it.\nvec4 principalAxis(vec4 c0v, vec4 c1v, vec4 c2v, vec4 c3v, vec4 seed) {\n  vec4 v = seed;\n  float len = length(v);\n  if (len < 1e-9) { return vec4(0.0); }\n  v /= len;\n  for (int it = 0; it < 8; it++) {\n    vec4 nv = vec4(dot(c0v, v), dot(c1v, v), dot(c2v, v), dot(c3v, v));\n    len = length(nv);\n    if (len < 1e-12) { return vec4(0.0); }\n    v = nv / len;\n  }\n  return v;\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  // Load pass with the covariance moments FUSED in: d = px \u2212 pixel0\n  // (first-pixel-relative, so the sums scale with the block's span).\n  ivec4 lo = ivec4(255);\n  ivec4 hi = ivec4(0);\n  vec4 p0f = vec4(0.0);\n  vec4 sd = vec4(0.0);\n  vec4 c0v = vec4(0.0);\n  vec4 c1v = vec4(0.0);\n  vec4 c2v = vec4(0.0);\n  vec4 c3v = vec4(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    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    if (i == 0) { p0f = vec4(px); }\n    vec4 d = vec4(px) - p0f;\n    sd += d;\n    c0v += d.x * d;\n    c1v += d.y * d;\n    c2v += d.z * d;\n    c3v += d.w * d;\n  }\n  vec4 mean = p0f + sd / 16.0;\n  // Mean-correct the fused moments: C = \u03A3dd\u1D40 \u2212 (\u03A3d)(\u03A3d)\u1D40/16.\n  vec4 sd16 = sd / 16.0;\n  c0v -= sd.x * sd16;\n  c1v -= sd.y * sd16;\n  c2v -= sd.z * sd16;\n  c3v -= sd.w * sd16;\n\n  ivec4 seed0 = lo;\n  ivec4 seed1 = hi;\n  vec4 axis = principalAxis(c0v, c1v, c2v, c3v, vec4(hi - lo));\n  if (dot(axis, axis) > 0.0) {\n    // Exact projection extents along the axis. (A Rayleigh-quotient span\n    // estimate was tried in place of this pass \u2014 it saves 16 dots but costs\n    // 0.1\u20130.8 dB and 4\u201310\xD7 on the worst-easy-block gate: \u03C3 misjudges\n    // two-cluster and outlier blocks. The pass stays.)\n    float tMin = 1e30;\n    float tMax = -1e30;\n    for (int k = 0; k < 16; k++) {\n      float t = dot(vec4(gPixels[k]) - mean, axis);\n      tMin = min(tMin, t);\n      tMax = max(tMax, t);\n    }\n    seed0 = ivec4(clamp(floor(mean + tMin * axis + 0.5), vec4(0.0), vec4(255.0)));\n    seed1 = ivec4(clamp(floor(mean + tMax * axis + 0.5), vec4(0.0), vec4(255.0)));\n  }\n\n  // Quantise the PCA-extents seed directly and assign indices in one\n  // projection pass \u2014 no LSQ refit: with the seed already on the principal\n  // axis, mode 6's 16-level palette leaves the refit under 0.15 dB (the\n  // coarse 4-level BC1/ASTC fast paths DO keep theirs).\n  Ep ep0 = pickEp(seed0);\n  Ep ep1 = pickEp(seed1);\n  projAssign(ep0.eight, ep1.eight, false);\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";
+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: principal-axis seed (covariance power-iteration; bbox on degenerate\n// blocks) at the exact projection extents, quantised directly (no LSQ refit \u2014\n// mode 6's 16-level palette leaves it under 0.15 dB) \u2192 one projection-based\n// index-assignment pass (palette is colinear, so the nearest entry is found\n// by projecting onto the endpoint line \u2014 O(1) per pixel). Same algorithm as\n// 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// Principal colour axis via power-iteration over precomputed, mean-corrected\n// covariance rows (the moments are accumulated for free in the pixel-load\n// loop), seeded with the bbox diagonal. Returns a unit axis, or vec4(0.0)\n// for a degenerate (constant) block. The bbox diagonal alone is sign-blind\n// and points across anti-correlated data (normal maps, hue edges) instead of\n// along it.\nvec4 principalAxis(vec4 c0v, vec4 c1v, vec4 c2v, vec4 c3v, vec4 seed) {\n  vec4 v = seed;\n  float len = length(v);\n  if (len < 1e-9) { return vec4(0.0); }\n  v /= len;\n  for (int it = 0; it < 8; it++) {\n    vec4 nv = vec4(dot(c0v, v), dot(c1v, v), dot(c2v, v), dot(c3v, v));\n    len = length(nv);\n    if (len < 1e-12) { return vec4(0.0); }\n    v = nv / len;\n  }\n  return v;\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  // Load pass with the covariance moments FUSED in: d = px \u2212 pixel0\n  // (first-pixel-relative, so the sums scale with the block's span).\n  ivec4 lo = ivec4(255);\n  ivec4 hi = ivec4(0);\n  vec4 p0f = vec4(0.0);\n  vec4 sd = vec4(0.0);\n  vec4 c0v = vec4(0.0);\n  vec4 c1v = vec4(0.0);\n  vec4 c2v = vec4(0.0);\n  vec4 c3v = vec4(0.0);\n  int gd = 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    gd = max(gd, max(abs(px.x - px.y), abs(px.x - px.z)));\n    if (i == 0) { p0f = vec4(px); }\n    vec4 d = vec4(px) - p0f;\n    sd += d;\n    c0v += d.x * d;\n    c1v += d.y * d;\n    c2v += d.z * d;\n    c3v += d.w * d;\n  }\n  vec4 mean = p0f + sd / 16.0;\n  // Mean-correct the fused moments: C = \u03A3dd\u1D40 \u2212 (\u03A3d)(\u03A3d)\u1D40/16.\n  vec4 sd16 = sd / 16.0;\n  c0v -= sd.x * sd16;\n  c1v -= sd.y * sd16;\n  c2v -= sd.z * sd16;\n  c3v -= sd.w * sd16;\n\n  ivec4 seed0 = lo;\n  ivec4 seed1 = hi;\n  // Gray + opaque blocks: axis is analytically (1,1,1,0)/\u221A3 with extents\n  // at the luma min/max \u2014 skip iteration + extents (see bc7_fast_f16.wgsl).\n  if (lo.w == 255 && gd == 0) {\n    seed0 = ivec4(lo.x, lo.x, lo.x, 255);\n    seed1 = ivec4(hi.x, hi.x, hi.x, 255);\n  } else {\n    vec4 axis = principalAxis(c0v, c1v, c2v, c3v, vec4(hi - lo));\n    if (dot(axis, axis) > 0.0) {\n      // Exact projection extents along the axis. (A Rayleigh-quotient span\n      // estimate was tried in place of this pass \u2014 it saves 16 dots but costs\n      // 0.1\u20130.8 dB and 4\u201310\xD7 on the worst-easy-block gate: \u03C3 misjudges\n      // two-cluster and outlier blocks. The pass stays.)\n      float tMin = 1e30;\n      float tMax = -1e30;\n      for (int k = 0; k < 16; k++) {\n        float t = dot(vec4(gPixels[k]) - mean, axis);\n        tMin = min(tMin, t);\n        tMax = max(tMax, t);\n      }\n      seed0 = ivec4(clamp(floor(mean + tMin * axis + 0.5), vec4(0.0), vec4(255.0)));\n      seed1 = ivec4(clamp(floor(mean + tMax * axis + 0.5), vec4(0.0), vec4(255.0)));\n    }\n  }\n\n  // Quantise the PCA-extents seed directly and assign indices in one\n  // projection pass \u2014 no LSQ refit: with the seed already on the principal\n  // axis, mode 6's 16-level palette leaves the refit under 0.15 dB (the\n  // coarse 4-level BC1/ASTC fast paths DO keep theirs).\n  Ep ep0 = pickEp(seed0);\n  Ep ep1 = pickEp(seed1);\n  projAssign(ep0.eight, ep1.eight, false);\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 {
@@ -1575,7 +2199,7 @@ var BC7WebGLEncoder = class extends WebGLBlockEncoder {
 };
 
 // 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// principal-axis seed (covariance power-iteration; bbox on degenerate blocks)\n// \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// Principal colour axis of gPixels via covariance power-iteration, seeded\n// with the bbox diagonal. Returns a unit axis, or vec4(0.0) for a degenerate\n// (constant) block. The bbox diagonal alone is sign-blind and points across\n// anti-correlated data (normal maps, hue edges) instead of along it.\nvec4 principalAxis(vec4 mean, vec4 seed) {\n  vec4 c0v = vec4(0.0);\n  vec4 c1v = vec4(0.0);\n  vec4 c2v = vec4(0.0);\n  vec4 c3v = vec4(0.0);\n  for (int k = 0; k < 16; k++) {\n    vec4 d = vec4(gPixels[k]) - mean;\n    c0v += d.x * d;\n    c1v += d.y * d;\n    c2v += d.z * d;\n    c3v += d.w * d;\n  }\n  vec4 v = seed;\n  float len = length(v);\n  if (len < 1e-9) { return vec4(0.0); }\n  v /= len;\n  for (int it = 0; it < 8; it++) {\n    vec4 nv = vec4(dot(c0v, v), dot(c1v, v), dot(c2v, v), dot(c3v, v));\n    len = length(nv);\n    if (len < 1e-12) { return vec4(0.0); }\n    v = nv / len;\n  }\n  return v;\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  ivec4 isum = 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    isum += px;\n  }\n  vec4 mean = vec4(isum) / 16.0;\n\n  ivec4 e0 = lo;\n  ivec4 e1 = hi;\n  vec4 axis = principalAxis(mean, vec4(hi - lo));\n  if (dot(axis, axis) > 0.0) {\n    float tMin = 1e30;\n    float tMax = -1e30;\n    for (int k = 0; k < 16; k++) {\n      float t = dot(vec4(gPixels[k]) - mean, axis);\n      tMin = min(tMin, t);\n      tMax = max(tMax, t);\n    }\n    e0 = ivec4(clamp(floor(mean + tMin * axis + 0.5), vec4(0.0), vec4(255.0)));\n    e1 = ivec4(clamp(floor(mean + tMax * axis + 0.5), vec4(0.0), vec4(255.0)));\n  }\n  Fit r = projAssign(e0, e1, true);\n  if (r.valid) {\n    // Clamp the refit to the block bbox: on multi-cluster blocks the\n    // unconstrained LSQ solve extrapolates far outside the block's colours and\n    // the per-channel [0,255] clamp then bends the hue \u2014 fringe pixels decode\n    // to colours that exist nowhere in the block. Constraining to the bbox\n    // also measures better in plain SSE (+1.8 dB on the colour test card).\n    e0 = clamp(r.e0, lo, hi);\n    e1 = clamp(r.e1, lo, hi);\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";
+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.\n// Restricted subset: single partition, no dual-plane, 8-bit endpoints, with\n// the block class picked per block from the content (see astc4x4_ref.ts for\n// layouts and block-mode derivations):\n//   gray + opaque \u2192 CEM 0  (luminance), 5-bit weights, mode 0x253\n//   opaque        \u2192 CEM 8  (RGB),       3-bit weights, mode 0x053\n//   translucent   \u2192 CEM 12 (RGBA),      2-bit weights, mode 0x042\n// Colour paths: principal-axis seed (covariance power-iteration; bbox on\n// degenerate blocks) \u2192 one LSQ refit fused into a projection weight\n// assignment. Mirrors astc4x4.wgsl.\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// GLSL ES 3.00 has no bitfieldReverse; classic 5-step swap. Weight-stream\n// bit q lives at block bit 127 \u2212 q, so a stream word assembled LSB-first\n// maps onto a block word with one reversal (see astc4x4.wgsl).\nuint rev32(uint x) {\n  uint v = x;\n  v = ((v & 0x55555555u) << 1) | ((v >> 1) & 0x55555555u);\n  v = ((v & 0x33333333u) << 2) | ((v >> 2) & 0x33333333u);\n  v = ((v & 0x0F0F0F0Fu) << 4) | ((v >> 4) & 0x0F0F0F0Fu);\n  v = ((v & 0x00FF00FFu) << 8) | ((v >> 8) & 0x00FF00FFu);\n  return (v << 16) | (v >> 16);\n}\n\n// Principal colour axis of gPixels via covariance power-iteration, seeded\n// with the bbox diagonal. Returns a unit axis, or vec4(0.0) for a degenerate\n// (constant) block. The bbox diagonal alone is sign-blind and points across\n// anti-correlated data (normal maps, hue edges) instead of along it.\nvec4 principalAxis(vec4 mean, vec4 seed, int iters) {\n  vec4 c0v = vec4(0.0);\n  vec4 c1v = vec4(0.0);\n  vec4 c2v = vec4(0.0);\n  vec4 c3v = vec4(0.0);\n  for (int k = 0; k < 16; k++) {\n    vec4 d = vec4(gPixels[k]) - mean;\n    c0v += d.x * d;\n    c1v += d.y * d;\n    c2v += d.z * d;\n    c3v += d.w * d;\n  }\n  vec4 v = seed;\n  float len = length(v);\n  if (len < 1e-9) { return vec4(0.0); }\n  v /= len;\n  for (int it = 0; it < iters; it++) {\n    vec4 nv = vec4(dot(c0v, v), dot(c1v, v), dot(c2v, v), dot(c3v, v));\n    len = length(nv);\n    if (len < 1e-12) { return vec4(0.0); }\n    v = nv / len;\n  }\n  return v;\n}\n\n// Projection weight assignment over lmax + 1 colinear levels, with the LSQ\n// normal-equation sums accumulated in the same pass for a fused refit.\nFit projAssign(ivec4 pe0, ivec4 pe1, float lmax, 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 = lmax / 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, lmax);\n    gIdx[k] = uint(s);\n    if (fit) {\n      vec4 v = vec4(gPixels[k]);\n      float b = s / lmax;\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 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  ivec4 isum = ivec4(0);\n  int gd = 0; // max |R\u2212G|, |R\u2212B| over the block; 0 \u21D4 exactly grayscale\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    isum += px;\n    gd = max(gd, max(abs(px.x - px.y), abs(px.x - px.z)));\n  }\n  bool opaque = lo.w == 255;\n\n  uint w0 = 0u; uint w1 = 0u; uint w2 = 0u; uint w3 = 0u;\n\n  if (opaque && gd == 0) {\n    // ---------------- Luminance path: CEM 0, 5-bit weights ----------------\n    // Endpoints at the exact extremes; 32 palette levels make an LSQ refit\n    // unnecessary.\n    uint L0 = uint(lo.x);\n    uint L1 = uint(hi.x);\n    uint s0 = 0u; uint s1 = 0u; uint s2 = 0u;\n    if (L1 > L0) {\n      float sc = 64.0 / float(hi.x - lo.x);\n      // Exact nearest entry of the QUANT_32 grid: unq = 2w for w \u2264 15,\n      // 2w + 2 for w \u2265 16 (4-wide gap at the middle, so uniform rounding\n      // is wrong there). Best candidate of each half, keep the closer.\n      for (int k = 0; k < 16; k++) {\n        float u = clamp(float(gPixels[k].x - lo.x) * sc, 0.0, 64.0);\n        float wlo = clamp(floor(u * 0.5 + 0.5), 0.0, 15.0);\n        float whi = clamp(floor((u - 2.0) * 0.5 + 0.5), 16.0, 31.0);\n        bool pick = abs(u - wlo * 2.0) <= abs(u - (whi * 2.0 + 2.0));\n        uint w = uint(pick ? wlo : whi);\n        // Stream bit q = 5k + j; straddles handled with constant shifts.\n        uint off = 5u * uint(k);\n        if (off < 28u) { s0 |= (w << off); }\n        else if (off == 30u) { s0 |= (w << 30u); s1 |= (w >> 2u); }\n        else if (off < 60u) { s1 |= (w << (off - 32u)); }\n        else if (off == 60u) { s1 |= (w << 28u); s2 |= (w >> 4u); }\n        else { s2 |= (w << (off - 64u)); }\n      }\n    }\n    // Mode 0x253, partitions\u22121 = 0, CEM 0, L0 @17, L1 @25 (top bit spills\n    // into word 1 bit 0); stream words map onto block words via rev32.\n    w0 = 0x253u | (L0 << 17u) | (L1 << 25u);\n    w1 = (L1 >> 7u) | rev32(s2);\n    w2 = rev32(s1);\n    w3 = rev32(s0);\n  } else {\n    // ------------- Colour paths: shared PCA seed ---------------------------\n    vec4 mean = vec4(isum) / 16.0;\n    float lmax = opaque ? 7.0 : 3.0;\n    uint wmax = opaque ? 7u : 3u;\n\n    ivec4 e0 = lo;\n    ivec4 e1 = hi;\n    // 8 iterations for opaque blocks, 4 for translucent (their refit\n    // absorbs residual axis error \u2014 see astc4x4_fast_f16.wgsl).\n    vec4 axis = principalAxis(mean, vec4(hi - lo), opaque ? 8 : 4);\n    if (dot(axis, axis) > 0.0) {\n      float tMin = 1e30;\n      float tMax = -1e30;\n      for (int k = 0; k < 16; k++) {\n        float t = dot(vec4(gPixels[k]) - mean, axis);\n        tMin = min(tMin, t);\n        tMax = max(tMax, t);\n      }\n      e0 = ivec4(clamp(floor(mean + tMin * axis + 0.5), vec4(0.0), vec4(255.0)));\n      e1 = ivec4(clamp(floor(mean + tMax * axis + 0.5), vec4(0.0), vec4(255.0)));\n    }\n    if (opaque) {\n      // CEM 8 ships the quantised PCA extents directly (no LSQ fit \u2014 see\n      // astc4x4_fast_f16.wgsl for the measured trade), bbox-clamped like\n      // the fit output; one assignment pass fills gIdx for the packer.\n      e0 = clamp(e0, lo, hi);\n      e1 = clamp(e1, lo, hi);\n      projAssign(e0, e1, lmax, false);\n    } else {\n      Fit r = projAssign(e0, e1, lmax, true);\n      if (r.valid) {\n        // Clamp the refit to the block bbox: on multi-cluster blocks the\n        // unconstrained LSQ solve extrapolates far outside the block's\n        // colours and the per-channel [0,255] clamp then bends the hue \u2014\n        // fringe pixels decode to colours that exist nowhere in the block.\n        // gIdx keeps the fit-pass weights (assigned against the seed line)\n        // rather than reassigning against the refit endpoints \u2014 see\n        // astc4x4_fast_f16.wgsl for the measured trade.\n        e0 = clamp(r.e0, lo, hi);\n        e1 = clamp(r.e1, lo, hi);\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      ivec4 t = e0; e0 = e1; e1 = t;\n      for (int k = 0; k < 16; k++) { gIdx[k] = wmax - gIdx[k]; }\n    }\n\n    if (opaque) {\n      // CEM 8: 3-bit weights, stream bit q = 3k.\n      uint s0 = 0u; uint s1 = 0u;\n      for (int k = 0; k < 16; k++) {\n        uint w = gIdx[k];\n        uint off = 3u * uint(k);\n        if (off < 30u) { s0 |= (w << off); }\n        else if (off == 30u) { s0 |= (w << 30u); s1 |= (w >> 2u); }\n        else { s1 |= (w << (off - 32u)); }\n      }\n      // Mode 0x053, CEM 8 @13, endpoints R0 R1 G0 G1 B0 B1 from bit 17.\n      w0 = 0x053u | (8u << 13u) | (uint(e0.x) << 17u) | (uint(e1.x) << 25u);\n      w1 = (uint(e1.x) >> 7u) | (uint(e0.y) << 1u) | (uint(e1.y) << 9u)\n         | (uint(e0.z) << 17u) | (uint(e1.z) << 25u);\n      w2 = (uint(e1.z) >> 7u) | rev32(s1);\n      w3 = rev32(s0);\n    } else {\n      // CEM 12: 2-bit weights, stream bit q = 2k (single stream word).\n      uint s0 = 0u;\n      for (int k = 0; k < 16; k++) {\n        s0 |= (gIdx[k] << (2u * uint(k)));\n      }\n      // Mode 0x042, CEM 12 @13, endpoints R0 R1 G0 G1 B0 B1 A0 A1 from 17.\n      w0 = 0x042u | (12u << 13u) | (uint(e0.x) << 17u) | (uint(e1.x) << 25u);\n      w1 = (uint(e1.x) >> 7u) | (uint(e0.y) << 1u) | (uint(e1.y) << 9u)\n         | (uint(e0.z) << 17u) | (uint(e1.z) << 25u);\n      w2 = (uint(e1.z) >> 7u) | (uint(e0.w) << 1u) | (uint(e1.w) << 9u);\n      w3 = rev32(s0);\n    }\n  }\n\n  outColor = uvec4(w0, w1, w2, w3);\n}\n";
 
 // src/webgl/ASTC4x4WebGLEncoder.ts
 var ASTC4x4WebGLEncoder = class extends WebGLBlockEncoder {
@@ -1611,26 +2235,30 @@ function detectWebGLCapabilities(gl) {
 // src/webgl/selectWebGLFormat.ts
 var NONE = { format: null, encoderClass: null, astcNormalRemap: false };
 function selectWebGLFormat(caps, hint, options = {}) {
-  const { colorSpace = "srgb", preferredFormat } = options;
+  const { colorSpace = "srgb", preferredFormat, quality = "high" } = options;
   const srgb = colorSpace === "srgb";
   const astc = (astcNormalRemap) => ({
     format: srgb ? TextureFormat.ASTC_4x4_SRGB : TextureFormat.ASTC_4x4,
     encoderClass: ASTC4x4WebGLEncoder,
     astcNormalRemap
   });
+  const bc1 = () => ({
+    format: srgb ? TextureFormat.BC1_SRGB : TextureFormat.BC1,
+    encoderClass: BC1WebGLEncoder,
+    astcNormalRemap: false
+  });
   if (preferredFormat === "bc1") {
     if (hint !== "color") {
       console.warn(
         `[gputex] preferredFormat 'bc1' ignored for hint '${hint}' \u2014 BC1 has no real alpha channel and is unsuitable for normal maps.`
       );
     } else if (srgb ? caps.s3tcSrgb : caps.s3tc) {
-      return {
-        format: srgb ? TextureFormat.BC1_SRGB : TextureFormat.BC1,
-        encoderClass: BC1WebGLEncoder,
-        astcNormalRemap: false
-      };
+      return bc1();
     }
   }
+  if (quality === "low" && hint === "color" && (srgb ? caps.s3tcSrgb : caps.s3tc)) {
+    return bc1();
+  }
   if (hint === "normal") {
     if (caps.rgtc) return { format: TextureFormat.BC5, encoderClass: BC5WebGLEncoder, astcNormalRemap: false };
     if (caps.astc) return astc(true);
@@ -1644,35 +2272,40 @@ function selectWebGLFormat(caps, hint, options = {}) {
     };
   }
   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 };
-    }
+  if (hint === "color" && (srgb ? caps.s3tcSrgb : caps.s3tc)) {
+    return bc1();
   }
   return NONE;
 }
 
 // src/selectFormat.ts
 function selectFormat(adapter, hint, options = {}) {
-  const { colorSpace = "srgb", preferredFormat } = options;
+  const { colorSpace = "srgb", preferredFormat, quality = "high" } = options;
   const srgb = colorSpace === "srgb";
   const caps = detectCapabilities(adapter);
+  const bc1 = {
+    format: srgb ? TextureFormat.BC1_SRGB : TextureFormat.BC1,
+    encoderClass: BC1Encoder,
+    astcNormalRemap: false
+  };
+  const etc2 = {
+    format: srgb ? TextureFormat.ETC2_RGB8_SRGB : TextureFormat.ETC2_RGB8,
+    encoderClass: ETC2Encoder,
+    astcNormalRemap: false
+  };
   if (preferredFormat === "bc1") {
     if (hint !== "color") {
       console.warn(
         `[gputex] preferredFormat 'bc1' ignored for hint '${hint}' \u2014 BC1 has no real alpha channel and is unsuitable for normal maps.`
       );
     } else if (caps.bc) {
-      return {
-        format: srgb ? TextureFormat.BC1_SRGB : TextureFormat.BC1,
-        encoderClass: BC1Encoder,
-        astcNormalRemap: false
-      };
+      return bc1;
     }
   }
+  if (quality === "low" && hint === "color") {
+    if (caps.bc) return bc1;
+    if (caps.etc2) return etc2;
+  }
   if (caps.bc) {
     if (hint === "normal") {
       return { format: TextureFormat.BC5, encoderClass: BC5Encoder, astcNormalRemap: false };
@@ -1691,6 +2324,9 @@ function selectFormat(adapter, hint, options = {}) {
       astcNormalRemap: hint === "normal"
     };
   }
+  if (caps.etc2 && hint === "color") {
+    return etc2;
+  }
   return { format: null, encoderClass: null, astcNormalRemap: false };
 }
 
@@ -1716,24 +2352,28 @@ function downsample2x(src) {
   const dstW = Math.max(1, src.width >> 1);
   const dstH = Math.max(1, src.height >> 1);
   const dst = new Uint8ClampedArray(dstW * dstH * 4);
-  const sW = src.width;
-  const sMaxX = src.width - 1;
+  const s = src.data;
+  const rowBytes = src.width * 4;
+  const lastColByte = (src.width - 1) * 4;
   const sMaxY = src.height - 1;
+  let o = 0;
   for (let y = 0; y < dstH; y++) {
-    const sy0 = y * 2;
-    const sy1 = Math.min(sy0 + 1, sMaxY);
+    const sy0 = y << 1;
+    const sy1 = sy0 < sMaxY ? sy0 + 1 : sMaxY;
+    const r0 = sy0 * rowBytes;
+    const r1 = sy1 * rowBytes;
     for (let x = 0; x < dstW; x++) {
-      const sx0 = x * 2;
-      const sx1 = Math.min(sx0 + 1, sMaxX);
-      const i00 = (sy0 * sW + sx0) * 4;
-      const i10 = (sy0 * sW + sx1) * 4;
-      const i01 = (sy1 * sW + sx0) * 4;
-      const i11 = (sy1 * sW + sx1) * 4;
-      const o = (y * dstW + x) * 4;
-      dst[o] = src.data[i00] + src.data[i10] + src.data[i01] + src.data[i11] + 2 >> 2;
-      dst[o + 1] = src.data[i00 + 1] + src.data[i10 + 1] + src.data[i01 + 1] + src.data[i11 + 1] + 2 >> 2;
-      dst[o + 2] = src.data[i00 + 2] + src.data[i10 + 2] + src.data[i01 + 2] + src.data[i11 + 2] + 2 >> 2;
-      dst[o + 3] = src.data[i00 + 3] + src.data[i10 + 3] + src.data[i01 + 3] + src.data[i11 + 3] + 2 >> 2;
+      const sx0 = x << 3;
+      const sx1 = sx0 + 4 <= lastColByte ? sx0 + 4 : lastColByte;
+      const i00 = r0 + sx0;
+      const i10 = r0 + sx1;
+      const i01 = r1 + sx0;
+      const i11 = r1 + sx1;
+      dst[o] = s[i00] + s[i10] + s[i01] + s[i11] + 2 >> 2;
+      dst[o + 1] = s[i00 + 1] + s[i10 + 1] + s[i01 + 1] + s[i11 + 1] + 2 >> 2;
+      dst[o + 2] = s[i00 + 2] + s[i10 + 2] + s[i01 + 2] + s[i11 + 2] + 2 >> 2;
+      dst[o + 3] = s[i00 + 3] + s[i10 + 3] + s[i01 + 3] + s[i11 + 3] + 2 >> 2;
+      o += 4;
     }
   }
   return { data: dst, width: dstW, height: dstH };
@@ -1760,6 +2400,97 @@ function padToBlockMultiple(level) {
   return { data: out, width: pw, height: ph };
 }
 
+// src/gpuMipgen.ts
+function gpuMipLevelCount(width, height) {
+  return 32 - Math.clz32(Math.max(width, height));
+}
+var DOWNSAMPLE_WGSL = (
+  /* wgsl */
+  `
+@group(0) @binding(0) var src : texture_2d<f32>;
+@group(0) @binding(1) var dst : texture_storage_2d<rgba8unorm, write>;
+
+// 2x2 box filter, clamp-to-edge fold on odd source dimensions, integer
+// round-to-nearest \u2014 bit-exact with mipgen.ts downsample2x.
+@compute @workgroup_size(8, 8, 1)
+fn downsample(@builtin(global_invocation_id) gid : vec3<u32>) {
+  let dstSize = textureDimensions(dst);
+  if (gid.x >= dstSize.x || gid.y >= dstSize.y) { return; }
+  let srcMax = textureDimensions(src) - vec2<u32>(1u, 1u);
+  let x0 = min(gid.x * 2u, srcMax.x);
+  let x1 = min(gid.x * 2u + 1u, srcMax.x);
+  let y0 = min(gid.y * 2u, srcMax.y);
+  let y1 = min(gid.y * 2u + 1u, srcMax.y);
+  // round() recovers the exact byte values (unorm->f32 conversion is only
+  // correctly-rounded, so a*255 is n +/- ~1e-5 \u2014 floor() would misround
+  // sums divisible by 4 without it).
+  let s = round(textureLoad(src, vec2<u32>(x0, y0), 0) * 255.0) +
+          round(textureLoad(src, vec2<u32>(x1, y0), 0) * 255.0) +
+          round(textureLoad(src, vec2<u32>(x0, y1), 0) * 255.0) +
+          round(textureLoad(src, vec2<u32>(x1, y1), 0) * 255.0);
+  textureStore(dst, gid.xy, floor((s + 2.0) * 0.25) / 255.0);
+}
+`
+);
+var pipelineCache = /* @__PURE__ */ new WeakMap();
+function getDownsamplePipeline(device) {
+  let pipeline = pipelineCache.get(device);
+  if (!pipeline) {
+    pipeline = device.createComputePipelineAsync({
+      label: "gputex-mipgen-pipeline",
+      layout: "auto",
+      compute: {
+        module: device.createShaderModule({ label: "gputex-mipgen", code: DOWNSAMPLE_WGSL }),
+        entryPoint: "downsample"
+      }
+    });
+    pipelineCache.set(device, pipeline);
+    pipeline.catch(() => pipelineCache.delete(device));
+  }
+  return pipeline;
+}
+async function generateGpuMipChain(device, source, { flipY = false } = {}) {
+  const width = source.width;
+  const height = source.height;
+  if (!width || !height) {
+    throw new Error("generateGpuMipChain: source has no dimensions");
+  }
+  const mipLevelCount = gpuMipLevelCount(width, height);
+  const texture = device.createTexture({
+    label: "gputex-mip-chain",
+    size: [width, height, 1],
+    format: "rgba8unorm",
+    mipLevelCount,
+    // COPY_DST + RENDER_ATTACHMENT for copyExternalImageToTexture (a blit
+    // internally), TEXTURE_BINDING for downsample/encoder reads,
+    // STORAGE_BINDING for downsample writes (rgba8unorm write-only storage
+    // is core WebGPU).
+    usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING
+  });
+  device.queue.copyExternalImageToTexture({ source, flipY }, { texture }, [width, height, 1]);
+  const pipeline = await getDownsamplePipeline(device);
+  const enc = device.createCommandEncoder({ label: "gputex-mipgen" });
+  const pass = enc.beginComputePass();
+  pass.setPipeline(pipeline);
+  for (let level = 0; level + 1 < mipLevelCount; level++) {
+    const bindGroup = device.createBindGroup({
+      label: `gputex-mipgen-bg-${level}`,
+      layout: pipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: texture.createView({ baseMipLevel: level, mipLevelCount: 1 }) },
+        { binding: 1, resource: texture.createView({ baseMipLevel: level + 1, mipLevelCount: 1 }) }
+      ]
+    });
+    pass.setBindGroup(0, bindGroup);
+    const dstW = Math.max(1, width >> level + 1);
+    const dstH = Math.max(1, height >> level + 1);
+    pass.dispatchWorkgroups(Math.ceil(dstW / 8), Math.ceil(dstH / 8), 1);
+  }
+  pass.end();
+  device.queue.submit([enc.finish()]);
+  return texture;
+}
+
 // src/svg.ts
 var ROOT_TAG_RE = /<svg(?=[\s/>])[^>]*>/;
 function getAttr(tag, name) {
@@ -1890,6 +2621,7 @@ export {
   BC5WebGLEncoder,
   BC7Encoder,
   BC7WebGLEncoder,
+  ETC2Encoder,
   Encoder,
   TextureFormat,
   WebGLBlockEncoder,
@@ -1897,8 +2629,10 @@ export {
   createWebGLContext,
   detectCapabilities,
   detectWebGLCapabilities,
+  generateGpuMipChain,
   generateMipChain,
   getSharedWebGLContext,
+  gpuMipLevelCount,
   isWebGLAvailable,
   padToBlockMultiple,
   rasterizeSvg,