gputex 0.0.3

package/README.md

@@ -0,0 +1,163 @@
+# GPUtex
+
+Runtime GPU texture compression via WebGPU compute shaders. Feed it a PNG/JPG/WebP/AVIF and get back a GPU-compressed texture (BC7, BC5, ASTC 4x4, or BC1) ready for Three.js or React Three Fiber.
+
+⚠️: This is 100% vibe-coded. The code is completely unreviewed, under-tested, it will probably crash on many devices, and this library is very likely to go unmaintained. Do not use for anything important.
+
+## Install
+
+```sh
+npm install gputex
+# or
+pnpm add gputex
+# or
+bun add gputex
+```
+
+`three` is a peer dependency (`>=0.170`).
+
+## Formats
+
+| Format       | Bytes / 4x4 block | Use case                                                  |
+| ------------ | ----------------- | --------------------------------------------------------- |
+| **BC7**      | 16 (8 bpp)        | Color / RGBA on desktop (`texture-compression-bc`)        |
+| **BC5**      | 16 (8 bpp)        | Normal maps — RG only (`texture-compression-bc`)          |
+| **ASTC 4x4** | 16 (8 bpp)        | Color / RGBA on mobile / iOS (`texture-compression-astc`) |
+| **BC1**      | 8 (4 bpp)         | Legacy (never auto-selected)                              |
+
+Format selection is automatic: BC7/BC5 on desktop, ASTC on mobile, uncompressed RGBA8 fallback otherwise.
+
+## Usage
+
+### `compressTexture` — direct API
+
+```ts
+import { compressTexture } from 'gputex'
+
+const { texture, format } = await compressTexture('/cobblestone.avif', {
+  hint: 'color', // 'color' | 'colorWithAlpha' | 'normal'
+  colorSpace: 'srgb',
+  mipmaps: true,
+})
+
+material.map = texture
+```
+
+### `WebGPUCompressedTextureLoader` — Three.js Loader
+
+```ts
+import { WebGPUCompressedTextureLoader } from 'gputex'
+
+const loader = new WebGPUCompressedTextureLoader()
+loader.hint = 'normal'
+loader.mipmaps = true
+const normalMap = await loader.loadAsync('/brick_normal.png')
+material.normalMap = normalMap
+```
+
+### React Three Fiber
+
+The `WebGPUCompressedTextureLoader` works with R3F's `useLoader`:
+
+```tsx
+import { useLoader } from '@react-three/fiber'
+import { WebGPUCompressedTextureLoader } from 'gputex'
+
+function Scene() {
+  const texture = useLoader(WebGPUCompressedTextureLoader, '/cobblestone.avif', loader => {
+    loader.hint = 'color'
+    loader.colorSpace = 'srgb'
+    loader.mipmaps = true
+  })
+
+  return (
+    <mesh>
+      <sphereGeometry args={[1, 64, 32]} />
+      <meshStandardMaterial map={texture} />
+    </mesh>
+  )
+}
+```
+
+For a reusable hook with metadata access:
+
+```tsx
+import { useLayoutEffect } from 'react'
+import { useLoader } from '@react-three/fiber'
+import { WebGPUCompressedTextureLoader } from 'gputex'
+import type { TextureHint } from 'gputex'
+
+function useGputex(url: string, options?: { hint?: TextureHint; colorSpace?: 'srgb' | 'linear'; mipmaps?: boolean }) {
+  const texture = useLoader(WebGPUCompressedTextureLoader, url, loader => {
+    if (options?.hint !== undefined) loader.hint = options.hint
+    if (options?.colorSpace !== undefined) loader.colorSpace = options.colorSpace
+    if (options?.mipmaps !== undefined) loader.mipmaps = options.mipmaps
+  })
+
+  return texture
+}
+
+// Preload textures outside of components
+useGputex.preload = (
+  url: string,
+  options?: { hint?: TextureHint; colorSpace?: 'srgb' | 'linear'; mipmaps?: boolean },
+) => {
+  useLoader.preload(WebGPUCompressedTextureLoader, url, loader => {
+    if (options?.hint !== undefined) loader.hint = options.hint
+    if (options?.colorSpace !== undefined) loader.colorSpace = options.colorSpace
+    if (options?.mipmaps !== undefined) loader.mipmaps = options.mipmaps
+  })
+}
+```
+
+Usage:
+
+```tsx
+// Preload outside the component tree
+useGputex.preload('/cobblestone.avif', { hint: 'color', colorSpace: 'srgb', mipmaps: true })
+
+function Scene() {
+  const texture = useGputex('/cobblestone.avif', { hint: 'color', colorSpace: 'srgb', mipmaps: true })
+
+  return (
+    <mesh>
+      <sphereGeometry args={[1, 64, 32]} />
+      <meshStandardMaterial map={texture} />
+    </mesh>
+  )
+}
+```
+
+### Low-level encoders
+
+Individual encoder classes are exported for direct control:
+
+```ts
+import { BC7Encoder, BC5Encoder, ASTC4x4Encoder, BC1Encoder } from 'gputex'
+
+const encoder = await BC7Encoder.create()
+const { data, width, height } = await encoder.encodeToBytes(imageBitmap)
+encoder.destroy()
+```
+
+## Options
+
+### `compressTexture` options
+
+| Option       | Type                 | Default   | Description                                             |
+| ------------ | -------------------- | --------- | ------------------------------------------------------- |
+| `hint`       | `TextureHint`        | `'color'` | `'color'`, `'colorWithAlpha'`, or `'normal'`            |
+| `colorSpace` | `'srgb' \| 'linear'` | `'srgb'`  | Use the sRGB or linear variant of the chosen format     |
+| `flipY`      | `boolean`            | `true`    | Flip vertically (matches Three.js convention)           |
+| `mipmaps`    | `boolean`            | `false`   | Generate full mip chain down to 1x1                     |
+| `device`     | `GPUDevice`          | —         | Reuse an existing WebGPU device instead of creating one |
+
+## Requirements
+
+- A browser with WebGPU support
+- `texture-compression-bc` (desktop) or `texture-compression-astc` (mobile) for compressed output
+- Falls back to uncompressed RGBA8 when neither is available
+
+## Acknowledgements
+
+The concept of encoding images on the GPU on the fly via compute shaders was first introduced by [spark.js](https://ludicon.com/sparkjs/), which is a much more robust solution for users who can afford its license. GPUtex is not derived from Spark and its encoders have been implemented from scratch using official references, which have been ported to TypeScript, and then converted to WGSL via AI. For any serious production use of GPU-compressed textures, Spark is the recommended choice over GPUtex.

package/dist/index.d.ts

@@ -0,0 +1,332 @@
+import { CompressedPixelFormat, CompressedTexture, Texture, Loader } from 'three';
+
+declare const TextureFormat: {
+    readonly BC1: "BC1";
+    readonly BC1_SRGB: "BC1_SRGB";
+    readonly BC5: "BC5";
+    readonly BC7: "BC7";
+    readonly BC7_SRGB: "BC7_SRGB";
+    readonly ASTC_4x4: "ASTC_4x4";
+    readonly ASTC_4x4_SRGB: "ASTC_4x4_SRGB";
+};
+type TextureFormat = (typeof TextureFormat)[keyof typeof TextureFormat];
+declare const WebGPUFeature: {
+    readonly BC: "texture-compression-bc";
+    readonly ASTC: "texture-compression-astc";
+    readonly ETC2: "texture-compression-etc2";
+};
+type WebGPUFeature = (typeof WebGPUFeature)[keyof typeof WebGPUFeature];
+
+/**
+ * Minimal structural type for the adapter argument: only `.features.has()`
+ * is touched. Lets tests pass a `{ features: new Set(...) }` stub without
+ * constructing a full `GPUAdapter`.
+ */
+interface FeatureProvider {
+    features: {
+        has(name: string): boolean;
+    };
+}
+interface Capabilities {
+    bc: boolean;
+    astc: boolean;
+    etc2: boolean;
+    supportedFormats: TextureFormat[];
+}
+declare function detectCapabilities(adapter: FeatureProvider): Capabilities;
+
+/**
+ * Anything `GPUQueue.copyExternalImageToTexture` accepts. Matches the
+ * WebGPU spec's CopyExternalImageSource set.
+ */
+type EncoderImageSource = ImageBitmap | ImageData | HTMLImageElement | HTMLVideoElement | HTMLCanvasElement | OffscreenCanvas | VideoFrame;
+interface EncoderOptions {
+    device: GPUDevice;
+    adapter?: GPUAdapter;
+    ownsDevice?: boolean;
+}
+interface EncodeCallOptions {
+    /** Tags the output color space. Forced 'linear' for encoders with supportsSrgb=false. */
+    colorSpace?: 'srgb' | 'linear';
+}
+interface EncodeResult {
+    width: number;
+    height: number;
+    paddedWidth: number;
+    paddedHeight: number;
+    data: Uint8Array;
+    texture: CompressedTexture;
+    encodeMs: number;
+}
+/**
+ * Result of a raw bytes-only encode (no wrapping in a `CompressedTexture`).
+ * Used by the mipped encode path to bundle multiple levels into a single
+ * `CompressedTexture` at the end.
+ */
+interface EncodeBytesResult {
+    width: number;
+    height: number;
+    paddedWidth: number;
+    paddedHeight: number;
+    data: Uint8Array;
+    encodeMs: number;
+}
+interface FormatVariant {
+    colorSpace: 'srgb' | 'linear';
+}
+/**
+ * Constructor shape for concrete encoder subclasses; used by the polymorphic
+ * `Encoder.create()` so the static method's return type narrows to the
+ * subclass when you call e.g. `BC1Encoder.create()`.
+ *
+ * `create` is included so generic code holding an `EncoderConstructor`
+ * (like `compressTexture()`'s selected-format branch) can still call
+ * `.create()` without a widening cast.
+ */
+type EncoderConstructor<T extends Encoder = Encoder> = {
+    new (opts: EncoderOptions): T;
+    requiredFeature: GPUFeatureName | null;
+    create(): Promise<T>;
+};
+declare abstract class Encoder {
+    /**
+     * Subclasses set this to the WebGPU feature string the output texture
+     * needs for sampling ('texture-compression-bc' / 'texture-compression-astc').
+     * `null` means no feature is required (e.g. a pure-storage debug pipeline).
+     */
+    static readonly requiredFeature: GPUFeatureName | null;
+    /**
+     * Create an encoder that owns its own WebGPU device. Requests the
+     * subclass's `requiredFeature` if the adapter reports it — missing the
+     * feature is non-fatal at encode time (the storage buffer is still
+     * written), it only prevents the resulting CompressedTexture from being
+     * sampled.
+     *
+     * The `this: EncoderConstructor<T>` annotation lets `BC1Encoder.create()`
+     * return `Promise<BC1Encoder>` instead of `Promise<Encoder>`.
+     */
+    static create<T extends Encoder>(this: EncoderConstructor<T>): Promise<T>;
+    readonly device: GPUDevice;
+    readonly adapter?: GPUAdapter;
+    readonly ownsDevice: boolean;
+    protected _module: GPUShaderModule;
+    protected _pipeline: GPUComputePipeline;
+    constructor({ device, adapter, ownsDevice }: EncoderOptions);
+    protected _buildPipeline(): void;
+    destroy(): void;
+    /** Short lowercase identifier used in GPU object labels and errors. */
+    abstract get label(): string;
+    /** 8 for BC1/BC4, 16 for BC5/BC7/ASTC 4×4. */
+    abstract get bytesPerBlock(): number;
+    /** WGSL `@workgroup_size` dimensions. Default 8×8×1. */
+    get workgroupSize(): readonly [number, number, number];
+    /** Whether this format has an sRGB variant. Default true. */
+    get supportsSrgb(): boolean;
+    /** WGSL compute-shader source. */
+    abstract wgslSource(): string;
+    /** e.g. 'bc1-rgba-unorm-srgb'. */
+    abstract gpuTextureFormat(opts: FormatVariant): GPUTextureFormat;
+    /** Three.js `CompressedPixelFormat` constant for `CompressedTexture`. */
+    abstract threeTextureFormat(opts: FormatVariant): CompressedPixelFormat;
+    /**
+     * True if the device reports the feature the output texture needs.
+     * The encoder itself only writes to a storage buffer, so this is about
+     * whether the result can actually be sampled.
+     */
+    get supportsSampling(): boolean;
+    encode(source: EncoderImageSource, { colorSpace }?: EncodeCallOptions): Promise<EncodeResult>;
+    /**
+     * Encode one image source to raw compressed bytes, skipping the
+     * `CompressedTexture` wrap. Used by the public `encode()` above and by
+     * the mipped encode path in `compressTexture()` so N mip levels end up
+     * in a single `CompressedTexture` instead of N throwaway wrappers.
+     *
+     * Public (not protected) because `compressTexture()` calls it across the
+     * encoder boundary. Still safe to call from outside — it just does
+     * less work than `encode()` and the caller assembles the texture.
+     */
+    encodeToBytes(source: EncoderImageSource, { flipY }?: {
+        flipY?: boolean;
+    }): Promise<EncodeBytesResult>;
+    /**
+     * Assemble a `CompressedTexture` from pre-encoded mip levels. Called
+     * by `compressTexture()` after it has run each level through
+     * `encodeToBytes()`. Centralised here so the single-level and mipped
+     * paths share the same format / colour-space / wrap settings.
+     *
+     * `levels[0]` is the base level; its padded dimensions become the
+     * texture's overall size. Filter setup assumes at least 2 levels →
+     * trilinear; 1 level → bilinear.
+     */
+    buildMippedTexture(levels: readonly EncodeBytesResult[], { colorSpace }?: EncodeCallOptions): CompressedTexture;
+}
+
+declare class BC1Encoder extends Encoder {
+    static readonly requiredFeature: GPUFeatureName;
+    static readonly textureFormats: readonly TextureFormat[];
+    get label(): string;
+    get bytesPerBlock(): number;
+    get supportsSrgb(): boolean;
+    wgslSource(): string;
+    gpuTextureFormat({ colorSpace }: FormatVariant): GPUTextureFormat;
+    threeTextureFormat(): CompressedPixelFormat;
+}
+
+declare class BC5Encoder extends Encoder {
+    static readonly requiredFeature: GPUFeatureName;
+    static readonly textureFormats: readonly TextureFormat[];
+    get label(): string;
+    get bytesPerBlock(): number;
+    get supportsSrgb(): boolean;
+    wgslSource(): string;
+    gpuTextureFormat(): GPUTextureFormat;
+    threeTextureFormat(): CompressedPixelFormat;
+}
+
+declare class BC7Encoder extends Encoder {
+    static readonly requiredFeature: GPUFeatureName;
+    static readonly textureFormats: readonly TextureFormat[];
+    get label(): string;
+    get bytesPerBlock(): number;
+    get supportsSrgb(): boolean;
+    wgslSource(): string;
+    gpuTextureFormat({ colorSpace }: FormatVariant): GPUTextureFormat;
+    threeTextureFormat(): CompressedPixelFormat;
+}
+
+declare class ASTC4x4Encoder extends Encoder {
+    static readonly requiredFeature: GPUFeatureName;
+    static readonly textureFormats: readonly TextureFormat[];
+    get label(): string;
+    get bytesPerBlock(): number;
+    get supportsSrgb(): boolean;
+    wgslSource(): string;
+    gpuTextureFormat({ colorSpace }: FormatVariant): GPUTextureFormat;
+    threeTextureFormat(): CompressedPixelFormat;
+}
+
+/**
+ * How the texture will be used in the renderer. Drives format choice.
+ *   • 'color'          — RGB albedo-like data (alpha optional / ignored).
+ *   • 'colorWithAlpha' — 4-channel RGBA with meaningful alpha.
+ *   • 'normal'         — tangent-space normal map (R=x, G=y, z reconstructed).
+ */
+type TextureHint = 'color' | 'colorWithAlpha' | 'normal';
+interface SelectFormatOptions {
+    /** Pick the sRGB variant when the format has one. Default 'srgb'. */
+    colorSpace?: 'srgb' | 'linear';
+}
+interface FormatSelection {
+    /** null = no compressed path on this adapter; caller should fall back. */
+    format: TextureFormat | null;
+    /** null when `format` is null. */
+    encoderClass: EncoderConstructor | null;
+    /**
+     * True when the chosen path is ASTC *and* the intended use is 'normal'.
+     * ASTC has no 2-channel mode, so the caller must pre-swizzle the
+     * normal map and apply a matching view swizzle in the shader.
+     */
+    astcNormalRemap: boolean;
+}
+declare function selectFormat(adapter: FeatureProvider, hint: TextureHint, options?: SelectFormatOptions): FormatSelection;
+
+/**
+ * Everything `compressTexture()` can take as an image source. A superset
+ * of `EncoderImageSource` (see Encoder.ts) that also accepts URL strings
+ * and Blob / File objects — the common cases in a web app.
+ */
+type CompressTextureSource = string | Blob | File | ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageData;
+interface CompressOptions {
+    /** How the texture will be used. Drives format selection. Default 'color'. */
+    hint?: TextureHint;
+    /** Pick the sRGB or linear variant of the chosen format. Default 'srgb'. */
+    colorSpace?: 'srgb' | 'linear';
+    /** Flip the image vertically before encoding. Default true (matches Three.js convention). */
+    flipY?: boolean;
+    /** Generate a full mip chain down to 1×1 on the CPU, encode every level. */
+    mipmaps?: boolean;
+    /** Reuse an existing device (e.g. Three.js's renderer device) instead
+     *  of creating a new one. When provided, the encoder never destroys it. */
+    device?: GPUDevice;
+    adapter?: GPUAdapter;
+}
+interface CompressResult {
+    /** CompressedTexture on the compressed path; Texture on RGBA8 fallback. */
+    texture: Texture | CompressedTexture;
+    /** The compressed format selected, or null when we fell back to RGBA8. */
+    format: TextureFormat | null;
+    /** True iff we returned an uncompressed Texture because no encoder fit. */
+    fallbackUncompressed: boolean;
+    /**
+     * True iff the chosen format is ASTC and the hint was 'normal'. The
+     * caller must apply the (R, W) → (x, y) swizzle in the material — ASTC
+     * has no 2-channel mode, so normal maps ride the RGBA path.
+     */
+    astcNormalRemap: boolean;
+    width: number;
+    height: number;
+    mipLevels: number;
+    /** Wall-clock time of GPU encoding, summed across mip levels. */
+    encodeMs: number;
+    /** Release the encoder's internal GPU resources. No-op if `device` was
+     *  passed in by the caller. */
+    destroy(): void;
+}
+declare function compressTexture(source: CompressTextureSource, options?: CompressOptions): Promise<CompressResult>;
+
+declare class WebGPUCompressedTextureLoader extends Loader<Texture> {
+    /** Format-selection hint. Default 'color'. */
+    hint: TextureHint;
+    /** Pick the sRGB or linear variant of the chosen format. Default 'srgb'. */
+    colorSpace: 'srgb' | 'linear';
+    /** Flip the image vertically before encoding. Default true (matches Three.js convention). */
+    flipY: boolean;
+    /** Generate + encode a full mip chain. Default false. */
+    mipmaps: boolean;
+    /**
+     * Optional pre-existing WebGPU device. Reusing the renderer's device
+     * avoids spinning up a second WebGPU context for encoding.
+     */
+    device?: GPUDevice;
+    adapter?: GPUAdapter;
+    /**
+     * Most recent full encode result. Useful when the caller wants format
+     * / mipLevels / astcNormalRemap metadata without threading a separate
+     * callback through `load()`. Cleared when a new load starts.
+     */
+    lastResult: CompressResult | null;
+    /**
+     * THREE.Loader contract: returns void, drives callbacks. `loadAsync`
+     * (inherited from the base class) wraps this with Promise semantics.
+     * Errors routed through `manager.itemError` so the LoadingManager's
+     * aggregate state stays accurate.
+     */
+    load(url: string, onLoad?: (texture: Texture) => void, _onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
+}
+
+/** One level of a mip chain. 4 bytes per pixel (RGBA8). */
+interface MipLevel {
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+}
+/**
+ * Produce the full mip chain from a level-0 image. The chain goes down
+ * to a 1×1 level — the standard OpenGL / WebGPU convention — so the
+ * caller gets `floor(log2(max(w, h))) + 1` levels total.
+ *
+ * Levels whose logical dimensions are below the encoder's 4×4 block
+ * grid are still produced here at their true logical size; padding up
+ * to a single block is the encoder's job, not ours.
+ */
+declare function generateMipChain(level0: MipLevel): MipLevel[];
+/**
+ * Pad a mip level up to a multiple of 4 in each dimension using clamp-
+ * to-edge sampling. Used before handing sub-4×4 levels to a block-
+ * compression encoder, which requires at least one full block per level.
+ *
+ * If the input is already block-aligned this returns the input unchanged.
+ */
+declare function padToBlockMultiple(level: MipLevel): MipLevel;
+
+export { ASTC4x4Encoder, BC1Encoder, BC5Encoder, BC7Encoder, type Capabilities, type CompressOptions, type CompressResult, type CompressTextureSource, type EncodeBytesResult, type EncodeCallOptions, type EncodeResult, Encoder, type EncoderConstructor, type EncoderImageSource, type EncoderOptions, type FeatureProvider, type FormatSelection, type FormatVariant, type MipLevel, type SelectFormatOptions, TextureFormat, type TextureHint, WebGPUCompressedTextureLoader, WebGPUFeature, compressTexture, detectCapabilities, generateMipChain, padToBlockMultiple, selectFormat };

package/dist/index.js

@@ -0,0 +1,739 @@
+// src/TextureFormat.ts
+var TextureFormat = {
+  BC1: "BC1",
+  BC1_SRGB: "BC1_SRGB",
+  BC5: "BC5",
+  BC7: "BC7",
+  BC7_SRGB: "BC7_SRGB",
+  ASTC_4x4: "ASTC_4x4",
+  ASTC_4x4_SRGB: "ASTC_4x4_SRGB"
+};
+var WebGPUFeature = {
+  BC: "texture-compression-bc",
+  ASTC: "texture-compression-astc",
+  ETC2: "texture-compression-etc2"
+};
+
+// src/capabilities.ts
+var FORMATS_BY_FEATURE = {
+  [WebGPUFeature.BC]: [
+    TextureFormat.BC1,
+    TextureFormat.BC1_SRGB,
+    TextureFormat.BC5,
+    TextureFormat.BC7,
+    TextureFormat.BC7_SRGB
+  ],
+  [WebGPUFeature.ASTC]: [TextureFormat.ASTC_4x4, TextureFormat.ASTC_4x4_SRGB],
+  // ETC2 has no encoder yet — explicit empty keeps exhaustiveness check.
+  [WebGPUFeature.ETC2]: []
+};
+function detectCapabilities(adapter) {
+  if (!adapter || !adapter.features || typeof adapter.features.has !== "function") {
+    throw new TypeError("detectCapabilities: adapter.features (Set-like) is required");
+  }
+  const has = (f) => adapter.features.has(f);
+  const bc = has(WebGPUFeature.BC);
+  const astc = has(WebGPUFeature.ASTC);
+  const etc2 = has(WebGPUFeature.ETC2);
+  const supportedFormats = [];
+  if (bc) supportedFormats.push(...FORMATS_BY_FEATURE[WebGPUFeature.BC]);
+  if (astc) supportedFormats.push(...FORMATS_BY_FEATURE[WebGPUFeature.ASTC]);
+  return { bc, astc, etc2, supportedFormats };
+}
+
+// src/Encoder.ts
+import {
+  CompressedTexture,
+  LinearFilter,
+  LinearMipmapLinearFilter,
+  LinearSRGBColorSpace,
+  SRGBColorSpace,
+  RepeatWrapping
+} from "three";
+var Encoder = class {
+  /**
+   * Subclasses set this to the WebGPU feature string the output texture
+   * needs for sampling ('texture-compression-bc' / 'texture-compression-astc').
+   * `null` means no feature is required (e.g. a pure-storage debug pipeline).
+   */
+  static requiredFeature = null;
+  /**
+   * Create an encoder that owns its own WebGPU device. Requests the
+   * subclass's `requiredFeature` if the adapter reports it — missing the
+   * feature is non-fatal at encode time (the storage buffer is still
+   * written), it only prevents the resulting CompressedTexture from being
+   * sampled.
+   *
+   * The `this: EncoderConstructor<T>` annotation lets `BC1Encoder.create()`
+   * return `Promise<BC1Encoder>` instead of `Promise<Encoder>`.
+   */
+  static async create() {
+    if (!("gpu" in navigator)) {
+      throw new Error("WebGPU not available in this browser");
+    }
+    const adapter = await navigator.gpu.requestAdapter();
+    if (!adapter) throw new Error("No WebGPU adapter");
+    const requiredFeatures = [];
+    if (this.requiredFeature && adapter.features.has(this.requiredFeature)) {
+      requiredFeatures.push(this.requiredFeature);
+    }
+    const device = await adapter.requestDevice({ requiredFeatures });
+    return new this({ device, adapter, ownsDevice: true });
+  }
+  device;
+  adapter;
+  ownsDevice;
+  // `!:` because these are set in `_buildPipeline()` which the constructor
+  // calls; TypeScript's flow analysis doesn't see through method calls.
+  _module;
+  _pipeline;
+  constructor({ device, adapter, ownsDevice = false }) {
+    this.device = device;
+    this.adapter = adapter;
+    this.ownsDevice = ownsDevice;
+    this._buildPipeline();
+  }
+  _buildPipeline() {
+    const device = this.device;
+    const code = this.wgslSource();
+    this._module = device.createShaderModule({
+      label: `${this.label}-encoder`,
+      code
+    });
+    this._pipeline = device.createComputePipeline({
+      label: `${this.label}-encoder-pipeline`,
+      layout: "auto",
+      compute: { module: this._module, entryPoint: "encode" }
+    });
+  }
+  destroy() {
+    if (this.ownsDevice) this.device.destroy();
+  }
+  /** WGSL `@workgroup_size` dimensions. Default 8×8×1. */
+  get workgroupSize() {
+    return [8, 8, 1];
+  }
+  /** Whether this format has an sRGB variant. Default true. */
+  get supportsSrgb() {
+    return true;
+  }
+  /**
+   * True if the device reports the feature the output texture needs.
+   * The encoder itself only writes to a storage buffer, so this is about
+   * whether the result can actually be sampled.
+   */
+  get supportsSampling() {
+    const feat = this.constructor.requiredFeature;
+    return !feat || this.device.features.has(feat);
+  }
+  // ------------------------------------------------------------------ //
+  // Shared encode() — pad, upload, dispatch, readback, wrap.           //
+  // ------------------------------------------------------------------ //
+  async encode(source, { colorSpace = "srgb" } = {}) {
+    const effectiveSrgb = colorSpace === "srgb" && this.supportsSrgb;
+    const bytes = await this.encodeToBytes(source);
+    const threeFormat = this.threeTextureFormat({ colorSpace: effectiveSrgb ? "srgb" : "linear" });
+    const mip = {
+      data: bytes.data,
+      width: bytes.paddedWidth,
+      height: bytes.paddedHeight
+    };
+    const texture = new CompressedTexture([mip], bytes.paddedWidth, bytes.paddedHeight, threeFormat);
+    texture.colorSpace = effectiveSrgb ? SRGBColorSpace : LinearSRGBColorSpace;
+    texture.magFilter = LinearFilter;
+    texture.minFilter = LinearFilter;
+    texture.generateMipmaps = false;
+    texture.wrapS = texture.wrapT = RepeatWrapping;
+    texture.needsUpdate = true;
+    texture.userData.logicalWidth = bytes.width;
+    texture.userData.logicalHeight = bytes.height;
+    return {
+      width: bytes.width,
+      height: bytes.height,
+      paddedWidth: bytes.paddedWidth,
+      paddedHeight: bytes.paddedHeight,
+      data: bytes.data,
+      texture,
+      encodeMs: bytes.encodeMs
+    };
+  }
+  /**
+   * Encode one image source to raw compressed bytes, skipping the
+   * `CompressedTexture` wrap. Used by the public `encode()` above and by
+   * the mipped encode path in `compressTexture()` so N mip levels end up
+   * in a single `CompressedTexture` instead of N throwaway wrappers.
+   *
+   * Public (not protected) because `compressTexture()` calls it across the
+   * encoder boundary. Still safe to call from outside — it just does
+   * less work than `encode()` and the caller assembles the texture.
+   */
+  async encodeToBytes(source, { flipY = false } = {}) {
+    const device = this.device;
+    const width = source.width;
+    const height = source.height;
+    if (!width || !height) {
+      throw new Error(`${this.label}Encoder: source has no dimensions`);
+    }
+    const paddedWidth = width + 3 & ~3;
+    const paddedHeight = height + 3 & ~3;
+    const blocksX = paddedWidth >> 2;
+    const blocksY = paddedHeight >> 2;
+    const blockCount = blocksX * blocksY;
+    const outByteLen = blockCount * this.bytesPerBlock;
+    const srcTex = device.createTexture({
+      label: `${this.label}-src`,
+      size: [paddedWidth, paddedHeight, 1],
+      format: "rgba8unorm",
+      usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT
+    });
+    device.queue.copyExternalImageToTexture({ source, flipY }, { texture: srcTex }, [width, height, 1]);
+    const dstBuffer = device.createBuffer({
+      label: `${this.label}-dst`,
+      size: outByteLen,
+      usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+    });
+    const paramsBuffer = device.createBuffer({
+      label: `${this.label}-params`,
+      size: 16,
+      usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+    device.queue.writeBuffer(paramsBuffer, 0, new Uint32Array([blocksX, blocksY, paddedWidth, paddedHeight]));
+    const bindGroup = device.createBindGroup({
+      label: `${this.label}-bg`,
+      layout: this._pipeline.getBindGroupLayout(0),
+      entries: [
+        { binding: 0, resource: srcTex.createView() },
+        { binding: 1, resource: { buffer: dstBuffer } },
+        { binding: 2, resource: { buffer: paramsBuffer } }
+      ]
+    });
+    const [wgX, wgY] = this.workgroupSize;
+    const t0 = performance.now();
+    const enc = device.createCommandEncoder({ label: `${this.label}-encode` });
+    const pass = enc.beginComputePass();
+    pass.setPipeline(this._pipeline);
+    pass.setBindGroup(0, bindGroup);
+    pass.dispatchWorkgroups(Math.ceil(blocksX / wgX), Math.ceil(blocksY / wgY), 1);
+    pass.end();
+    const staging = device.createBuffer({
+      label: `${this.label}-staging`,
+      size: outByteLen,
+      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+    });
+    enc.copyBufferToBuffer(dstBuffer, 0, staging, 0, outByteLen);
+    device.queue.submit([enc.finish()]);
+    await staging.mapAsync(GPUMapMode.READ);
+    const data = new Uint8Array(staging.getMappedRange().slice(0));
+    staging.unmap();
+    const encodeMs = performance.now() - t0;
+    srcTex.destroy();
+    dstBuffer.destroy();
+    staging.destroy();
+    paramsBuffer.destroy();
+    return { width, height, paddedWidth, paddedHeight, data, encodeMs };
+  }
+  /**
+   * Assemble a `CompressedTexture` from pre-encoded mip levels. Called
+   * by `compressTexture()` after it has run each level through
+   * `encodeToBytes()`. Centralised here so the single-level and mipped
+   * paths share the same format / colour-space / wrap settings.
+   *
+   * `levels[0]` is the base level; its padded dimensions become the
+   * texture's overall size. Filter setup assumes at least 2 levels →
+   * trilinear; 1 level → bilinear.
+   */
+  buildMippedTexture(levels, { colorSpace = "srgb" } = {}) {
+    if (levels.length === 0) {
+      throw new Error(`${this.label}Encoder.buildMippedTexture: no levels provided`);
+    }
+    const effectiveSrgb = colorSpace === "srgb" && this.supportsSrgb;
+    const threeFormat = this.threeTextureFormat({ colorSpace: effectiveSrgb ? "srgb" : "linear" });
+    const mipmaps = levels.map((l) => ({
+      data: l.data,
+      width: l.paddedWidth,
+      height: l.paddedHeight
+    }));
+    const base = levels[0];
+    const texture = new CompressedTexture(mipmaps, base.paddedWidth, base.paddedHeight, threeFormat);
+    texture.colorSpace = effectiveSrgb ? SRGBColorSpace : LinearSRGBColorSpace;
+    texture.magFilter = LinearFilter;
+    texture.minFilter = levels.length > 1 ? LinearMipmapLinearFilter : LinearFilter;
+    texture.generateMipmaps = false;
+    texture.wrapS = texture.wrapT = RepeatWrapping;
+    texture.needsUpdate = true;
+    texture.userData.logicalWidth = base.width;
+    texture.userData.logicalHeight = base.height;
+    texture.userData.mipLevels = levels.length;
+    return texture;
+  }
+};
+
+// src/BC1Encoder.ts
+import { RGBA_S3TC_DXT1_Format } from "three";
+
+// 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// When color0 > color1 (numeric 16-bit), the 4-color mode is used:\n//   idx 0 -> color0\n//   idx 1 -> color1\n//   idx 2 -> (2*color0 +   color1) / 3\n//   idx 3 -> (  color0 + 2*color1) / 3\n// We always force the 4-color mode here.\n//\n// Algorithm:\n//  1. Compute the bounding box (min/max RGB) of the block.\n//  2. Inset slightly to account for endpoint quantization rounding;\n//     this is a well-known heuristic from rygorous/stb_dxt that\n//     improves quality cheaply.\n//  3. Quantize endpoints to RGB565 and ensure color0 > color1.\n//  4. Reconstruct the 4-color palette in floating point and assign\n//     the closest palette entry to each pixel (full L2 search).\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 = f32((c >> 11u) & 31u);\n  let g = f32((c >>  5u) & 63u);\n  let b = f32( c         & 31u);\n  // Expand to 8-bit then normalize, matching typical BC1 decoder behavior.\n  let r8 = (r * 527.0 + 23.0) / 256.0;   // = round(r * 255 / 31)\n  let g8 = (g * 259.0 + 33.0) / 256.0;   // = round(g * 255 / 63)\n  let b8 = (b * 527.0 + 23.0) / 256.0;\n  return vec3<f32>(r8, g8, b8) / 255.0;\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\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  }\n\n  // Inset the bounding box. The magic constant 1/16 approximates half\n  // the width of an RGB565 quantization cell; insetting by that much\n  // moves the endpoints toward each other so the quantized 4-color\n  // palette covers the real data range more tightly.\n  let inset = (bb_max - bb_min) / 16.0;\n  var hi = clamp(bb_max - inset, vec3<f32>(0.0), vec3<f32>(1.0));\n  var lo = clamp(bb_min + inset, vec3<f32>(0.0), vec3<f32>(1.0));\n\n  var c0 = to565(hi);\n  var c1 = to565(lo);\n\n  // 4-color mode requires c0 > c1. If equal (flat block), we still use\n  // 4-color mode by nudging c1 down when possible; if c1 == 0 the block\n  // is truly black so all indices stay 0 and the decoded value is 0.\n  if (c0 == c1) {\n    if (c1 > 0u) {\n      c1 = c1 - 1u;\n    } else {\n      c0 = c0 + 1u;\n    }\n  } else if (c0 < c1) {\n    let tmp = c0;\n    c0 = c1;\n    c1 = tmp;\n  }\n\n  // Build the palette in the decoded colour space so index selection\n  // matches what the hardware decoder will produce.\n  let p0 = from565(c0);\n  let p1 = from565(c1);\n  let p2 = (2.0 * p0 + p1) * (1.0 / 3.0);\n  let p3 = (p0 + 2.0 * p1) * (1.0 / 3.0);\n\n  var indices: u32 = 0u;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let c = pixels[i];\n    let d0 = dot(c - p0, c - p0);\n    let d1 = dot(c - p1, c - p1);\n    let d2 = dot(c - p2, c - p2);\n    let d3 = dot(c - p3, c - p3);\n\n    var best_d: f32 = d0;\n    var best_i: u32 = 0u;\n    if (d1 < best_d) { best_d = d1; best_i = 1u; }\n    if (d2 < best_d) { best_d = d2; best_i = 2u; }\n    if (d3 < best_d) { best_d = d3; best_i = 3u; }\n\n    indices = indices | (best_i << (i * 2u));\n  }\n\n  let out = block_index * 2u;\n  dst[out]      = c0 | (c1 << 16u);\n  dst[out + 1u] = indices;\n}\n";
+
+// src/BC1Encoder.ts
+var BC1Encoder = class extends Encoder {
+  static requiredFeature = WebGPUFeature.BC;
+  static textureFormats = [TextureFormat.BC1, TextureFormat.BC1_SRGB];
+  get label() {
+    return "bc1";
+  }
+  get bytesPerBlock() {
+    return 8;
+  }
+  get supportsSrgb() {
+    return true;
+  }
+  wgslSource() {
+    return bc1_default;
+  }
+  gpuTextureFormat({ colorSpace }) {
+    return colorSpace === "srgb" ? "bc1-rgba-unorm-srgb" : "bc1-rgba-unorm";
+  }
+  threeTextureFormat() {
+    return RGBA_S3TC_DXT1_Format;
+  }
+};
+
+// src/BC5Encoder.ts
+import { RED_GREEN_RGTC2_Format } from "three";
+
+// src/bc5.wgsl
+var bc5_default = "// BC5 (RGTC2) compute shader encoder.\n//\n// Each invocation encodes one 4x4 pixel block into a 16-byte BC5 block\n// written as 4 x u32 into the destination storage buffer.\n//\n// BC5 = two BC4 blocks concatenated:\n//   block bytes  0..7  : BC4 of R channel (normal.x for tangent-space normals)\n//   block bytes  8..15 : BC4 of G channel (normal.y)\n//\n// Each BC4 half-block (8 bytes):\n//   byte 0     : red0 (8-bit endpoint)\n//   byte 1     : red1 (8-bit endpoint)\n//   bytes 2..7 : 16 \xD7 3-bit indices, LSB-first, pixel 0 at bit 0\n//\n// We always produce the 6-interpolation mode (red0 > red1). See\n// `bc4_ref.js` for the reasoning and the CPU reference this shader is\n// ported from \u2014 the algorithm and edge cases mirror it line-for-line.\n//\n// Pipeline per channel:\n//   1. Load 16 single-channel values, find min/max \u2192 initial endpoints.\n//   2. Quantize to 8-bit. Nudge apart if equal (forces 6-interp mode).\n//   3. Build palette, assign each texel its nearest entry (full L2).\n//   4. One-pass least-squares refinement: solve the 2\xD72 normal equations\n//      for the (r0, r1) that minimizes \u03A3(palette[i_k] \u2212 v_k)\xB2. Accept\n//      only if quantized endpoints still satisfy r0 > r1 AND total\n//      squared error decreased.\n//   5. Pack 2 endpoint bytes + 48 bits of indices into the 8-byte block.\n\nstruct Params {\n  blocks_x: u32,\n  blocks_y: u32,\n  width:    u32,\n  height:   u32,\n};\n\n@group(0) @binding(0) var src_tex: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n@group(0) @binding(2) var<uniform> params: Params;\n\n// 6-interpolation-mode palette weights. palette[j] = W0_6[j]*r0 + W1_6[j]*r1.\n// Expressed as a switch so we don't rely on module-scope const arrays.\nfn w0_6(j: u32) -> f32 {\n  switch j {\n    case 0u:  { return 1.0; }\n    case 1u:  { return 0.0; }\n    case 2u:  { return 6.0 / 7.0; }\n    case 3u:  { return 5.0 / 7.0; }\n    case 4u:  { return 4.0 / 7.0; }\n    case 5u:  { return 3.0 / 7.0; }\n    case 6u:  { return 2.0 / 7.0; }\n    default:  { return 1.0 / 7.0; }   // case 7u\n  }\n}\n\nfn w1_6(j: u32) -> f32 {\n  switch j {\n    case 0u:  { return 0.0; }\n    case 1u:  { return 1.0; }\n    case 2u:  { return 1.0 / 7.0; }\n    case 3u:  { return 2.0 / 7.0; }\n    case 4u:  { return 3.0 / 7.0; }\n    case 5u:  { return 4.0 / 7.0; }\n    case 6u:  { return 5.0 / 7.0; }\n    default:  { return 6.0 / 7.0; }   // case 7u\n  }\n}\n\nfn quantize8(v: f32) -> u32 {\n  // Round-to-nearest, clamp to [0, 255]. floor(x + 0.5) is the same\n  // rounding rule the CPU reference uses.\n  return u32(clamp(floor(v * 255.0 + 0.5), 0.0, 255.0));\n}\n\n// Nearest-palette-index search over the 8-entry palette, returning the\n// index and squared error. `palette` is stored in function memory so we\n// pass by pointer.\nfn nearest_index(v: f32, palette: ptr<function, array<f32, 8>>) -> vec2<f32> {\n  // x = best index (encoded as f32), y = best squared error.\n  var best_j: u32 = 0u;\n  var best_d: f32 = 1e20;\n  for (var j: u32 = 0u; j < 8u; j = j + 1u) {\n    let d  = (*palette)[j] - v;\n    let d2 = d * d;\n    if (d2 < best_d) {\n      best_d = d2;\n      best_j = j;\n    }\n  }\n  return vec2<f32>(f32(best_j), best_d);\n}\n\n// Encode 16 single-channel values into an 8-byte BC4 block, packed as\n// two little-endian u32s (u32[0] = bytes 0..3, u32[1] = bytes 4..7).\nfn encode_bc4(values: ptr<function, array<f32, 16>>) -> vec2<u32> {\n  // ---------------- 1. Initial endpoints: bbox of input ----------------\n  var vmin: f32 = 1.0;\n  var vmax: f32 = 0.0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    vmin = min(vmin, (*values)[k]);\n    vmax = max(vmax, (*values)[k]);\n  }\n  var r0: u32 = quantize8(vmax);\n  var r1: u32 = quantize8(vmin);\n  // Force 6-interp mode: red0 > red1 strictly.\n  if (r0 == r1) {\n    if (r1 > 0u) { r1 = r1 - 1u; }\n    else         { r0 = r0 + 1u; }\n  }\n\n  // ---------------- 2. Initial palette + indices + error --------------\n  var palette: array<f32, 8>;\n  let r0f = f32(r0) / 255.0;\n  let r1f = f32(r1) / 255.0;\n  for (var j: u32 = 0u; j < 8u; j = j + 1u) {\n    palette[j] = w0_6(j) * r0f + w1_6(j) * r1f;\n  }\n  var indices: array<u32, 16>;\n  var err: f32 = 0.0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let sel = nearest_index((*values)[k], &palette);\n    indices[k] = u32(sel.x);\n    err = err + sel.y;\n  }\n\n  var best_r0 = r0;\n  var best_r1 = r1;\n  var best_indices = indices;\n  var best_err = err;\n\n  // ---------------- 3. Refinement: least-squares on (r0, r1) ----------\n  // Normal equations for palette[j] = a_j * r0 + b_j * r1:\n  //   [\u03A3AA  \u03A3AB] [r0]   [\u03A3AV]\n  //   [\u03A3AB  \u03A3BB] [r1] = [\u03A3BV]\n  var sAA: f32 = 0.0; var sBB: f32 = 0.0; var sAB: f32 = 0.0;\n  var sAV: f32 = 0.0; var sBV: f32 = 0.0;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let a = w0_6(indices[k]);\n    let b = w1_6(indices[k]);\n    let v = (*values)[k];\n    sAA = sAA + a * a;\n    sBB = sBB + b * b;\n    sAB = sAB + a * b;\n    sAV = sAV + a * v;\n    sBV = sBV + b * v;\n  }\n  let det = sAA * sBB - sAB * sAB;\n  // Degenerate system \u2192 skip refinement.\n  if (abs(det) > 1e-9) {\n    let new_r0 = clamp((sBB * sAV - sAB * sBV) / det, 0.0, 1.0);\n    let new_r1 = clamp((sAA * sBV - sAB * sAV) / det, 0.0, 1.0);\n    let qR0 = quantize8(new_r0);\n    let qR1 = quantize8(new_r1);\n    // Only accept refinements that stay in 6-interp mode. A refinement\n    // that flips or equalizes the endpoints would change decode mode.\n    if (qR0 > qR1) {\n      var pal2: array<f32, 8>;\n      let r0f2 = f32(qR0) / 255.0;\n      let r1f2 = f32(qR1) / 255.0;\n      for (var j: u32 = 0u; j < 8u; j = j + 1u) {\n        pal2[j] = w0_6(j) * r0f2 + w1_6(j) * r1f2;\n      }\n      var idx2: array<u32, 16>;\n      var err2: f32 = 0.0;\n      for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n        let sel = nearest_index((*values)[k], &pal2);\n        idx2[k] = u32(sel.x);\n        err2 = err2 + sel.y;\n      }\n      if (err2 < best_err) {\n        best_r0 = qR0;\n        best_r1 = qR1;\n        best_indices = idx2;\n        best_err = err2;\n      }\n    }\n  }\n\n  // ---------------- 4. Pack 48-bit index field + 2 endpoint bytes -----\n  // The 48-bit index field spans block bytes 2..7. Split into idx_lo\n  // (low 32 bits of the field) and idx_hi (high 16 bits). An index at\n  // bit position 3k straddles the 32-bit boundary iff 3k < 32 < 3k+3\n  // (only k = 10, 11 straddle: bits 30..32 and 33..35; actually k=10\n  // is bits 30..32, k=11 is 33..35 \u2014 so k=10 straddles). We handle\n  // straddles by writing to both halves.\n  var idx_lo: u32 = 0u;\n  var idx_hi: u32 = 0u;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let bit = 3u * k;\n    let v = best_indices[k] & 7u;\n    if (bit + 3u <= 32u) {\n      idx_lo = idx_lo | (v << bit);\n    } else if (bit >= 32u) {\n      idx_hi = idx_hi | (v << (bit - 32u));\n    } else {\n      // Straddle: low part into idx_lo's top, high part into idx_hi's bottom.\n      idx_lo = idx_lo | (v << bit);\n      idx_hi = idx_hi | (v >> (32u - bit));\n    }\n  }\n\n  // Final u32s, both little-endian:\n  //   u32[0] bytes = red0, red1, idx_lo[7:0], idx_lo[15:8]\n  //   u32[1] bytes = idx_lo[23:16], idx_lo[31:24], idx_hi[7:0], idx_hi[15:8]\n  let out_lo = best_r0 | (best_r1 << 8u) | ((idx_lo & 0xFFFFu) << 16u);\n  let out_hi = (idx_lo >> 16u) | (idx_hi << 16u);\n\n  return vec2<u32>(out_lo, out_hi);\n}\n\n@compute @workgroup_size(8, 8, 1)\nfn encode(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if (gid.x >= params.blocks_x || gid.y >= params.blocks_y) {\n    return;\n  }\n\n  let bx = gid.x;\n  let by = gid.y;\n  let block_index = by * params.blocks_x + bx;\n\n  let base   = vec2<i32>(i32(bx) * 4, i32(by) * 4);\n  let max_xy = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  // Load 4\xD74 RG values, splitting into per-channel arrays so each can\n  // be handed to encode_bc4 independently.\n  var r_values: array<f32, 16>;\n  var g_values: array<f32, 16>;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let lx = i32(i & 3u);\n    let ly = i32(i >> 2u);\n    // Clamp to edge for non-multiple-of-4 input sizes.\n    let p  = clamp(base + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let c  = textureLoad(src_tex, p, 0);\n    r_values[i] = c.r;\n    g_values[i] = c.g;\n  }\n\n  let r_block = encode_bc4(&r_values);\n  let g_block = encode_bc4(&g_values);\n\n  // BC5 block = R half (bytes 0..7) || G half (bytes 8..15) = 4 u32s.\n  let out = block_index * 4u;\n  dst[out + 0u] = r_block.x;\n  dst[out + 1u] = r_block.y;\n  dst[out + 2u] = g_block.x;\n  dst[out + 3u] = g_block.y;\n}\n";
+
+// src/BC5Encoder.ts
+var BC5Encoder = class extends Encoder {
+  static requiredFeature = WebGPUFeature.BC;
+  static textureFormats = [TextureFormat.BC5];
+  get label() {
+    return "bc5";
+  }
+  get bytesPerBlock() {
+    return 16;
+  }
+  get supportsSrgb() {
+    return false;
+  }
+  wgslSource() {
+    return bc5_default;
+  }
+  gpuTextureFormat() {
+    return "bc5-rg-unorm";
+  }
+  threeTextureFormat() {
+    return RED_GREEN_RGTC2_Format;
+  }
+};
+
+// src/BC7Encoder.ts
+import { RGBA_BPTC_Format } from "three";
+
+// src/bc7.wgsl
+var bc7_default = "// BC7 (BPTC) mode 6 compute shader encoder.\n//\n// One invocation per 4\xD74 block. Emits 16 bytes = 4 u32s into the storage\n// buffer at `dst[block_index * 4 .. + 3]`.\n//\n// This shader mirrors `bc7_ref.ts` function-by-function; see that file for\n// the end-to-end algorithm rationale and the full mode 6 bitstream layout\n// (summarised below).\n//\n// MODE 6 LAYOUT (LSB-first, bit 0 = byte 0's bit 0)\n//   bits 0..6    mode field      (0b0000001 \u2014 only bit 6 is 1)\n//   bits 7..13   R0 (7-bit)\n//   bits 14..20  R1\n//   bits 21..27  G0\n//   bits 28..34  G1          \u2190 straddles the word 0 / word 1 boundary\n//   bits 35..41  B0\n//   bits 42..48  B1\n//   bits 49..55  A0\n//   bits 56..62  A1\n//   bit  63      P0 (shared p-bit for endpoint 0)\n//   bit  64      P1\n//   bits 65..67  pixel 0 index (3 bits; anchor, MSB implicit 0)\n//   bits 68..71  pixel 1 index (4 bits)\n//   ...\n//   bits 124..127 pixel 15 index\n//\n// Effective 8-bit endpoint channel = (7_bit_value << 1) | p_bit.\n// Palette[i] = ((64 \u2212 W4[i]) \xD7 e0_8 + W4[i] \xD7 e1_8 + 32) >> 6, integer.\n\nstruct Params {\n  blocks_x: u32,\n  blocks_y: u32,\n  width:    u32,\n  height:   u32,\n};\n\n@group(0) @binding(0) var src_tex: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n@group(0) @binding(2) var<uniform> params: Params;\n\n// Mode 6 interpolation weights (\xD7 1/64), fixed by the spec. Same table as\n// the CPU reference (`W4` in bc7_ref.ts).\nfn w4(i: u32) -> u32 {\n  switch i {\n    case 0u:  { return  0u; }\n    case 1u:  { return  4u; }\n    case 2u:  { return  9u; }\n    case 3u:  { return 13u; }\n    case 4u:  { return 17u; }\n    case 5u:  { return 21u; }\n    case 6u:  { return 26u; }\n    case 7u:  { return 30u; }\n    case 8u:  { return 34u; }\n    case 9u:  { return 38u; }\n    case 10u: { return 43u; }\n    case 11u: { return 47u; }\n    case 12u: { return 51u; }\n    case 13u: { return 55u; }\n    case 14u: { return 60u; }\n    default:  { return 64u; }   // case 15u\n  }\n}\n\n// Hardware-exact integer interpolation.\nfn interp8(e0: u32, e1: u32, w: u32) -> u32 {\n  return ((64u - w) * e0 + w * e1 + 32u) >> 6u;\n}\n\n// f32-normalised [0,1] \u2192 clamped 8-bit.\nfn to8(v: f32) -> u32 {\n  return u32(clamp(floor(v * 255.0 + 0.5), 0.0, 255.0));\n}\n\n// -------------------------- Farthest-pair seed -------------------------- //\n\nstruct PairResult { i0: u32, i1: u32 };\n\n// 4-channel L2 distance squared, u32 domain (bounded by 4 \xD7 255\xB2 = 260 100).\nfn pixel_dist_sq(a: vec4<u32>, b: vec4<u32>) -> u32 {\n  let d = vec4<i32>(a) - vec4<i32>(b);\n  let d2 = d * d;\n  return u32(d2.x + d2.y + d2.z + d2.w);\n}\n\n// O(N\xB2) = 120 comparisons. See bc7_ref.ts `farthestPair` for why bbox\n// corners aren't safe initial endpoints when channels vary in different\n// directions along the data line.\nfn farthest_pair(pixels: ptr<function, array<vec4<u32>, 16>>) -> PairResult {\n  var best_d: u32 = 0u;\n  var best_i: u32 = 0u;\n  var best_j: u32 = 1u;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    for (var j: u32 = i + 1u; j < 16u; j = j + 1u) {\n      let d = pixel_dist_sq((*pixels)[i], (*pixels)[j]);\n      if (d > best_d) { best_d = d; best_i = i; best_j = j; }\n    }\n  }\n  return PairResult(best_i, best_j);\n}\n\n// -------------------------- Palette + assignment ------------------------ //\n\n// Build the 16-entry RGBA palette from 8-bit endpoints.\nfn build_palette_6(e0: vec4<u32>, e1: vec4<u32>, pal: ptr<function, array<vec4<u32>, 16>>) {\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let w = w4(i);\n    (*pal)[i] = vec4<u32>(\n      interp8(e0.x, e1.x, w),\n      interp8(e0.y, e1.y, w),\n      interp8(e0.z, e1.z, w),\n      interp8(e0.w, e1.w, w),\n    );\n  }\n}\n\n// Nearest-palette-entry search for one pixel. Full 16-entry L2 search.\nfn nearest_index_6(pixel: vec4<u32>, pal: ptr<function, array<vec4<u32>, 16>>) -> vec2<u32> {\n  var best_i: u32 = 0u;\n  var best_d: u32 = 0xFFFFFFFFu;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let d = pixel_dist_sq(pixel, (*pal)[i]);\n    if (d < best_d) { best_d = d; best_i = i; }\n  }\n  // x = best index, y = its squared error.\n  return vec2<u32>(best_i, best_d);\n}\n\n// Assign all 16 pixels to nearest palette entries, accumulate total error.\nstruct AssignResult { indices: array<u32, 16>, err: u32 };\n\nfn assign_all(\n  pixels: ptr<function, array<vec4<u32>, 16>>,\n  pal:    ptr<function, array<vec4<u32>, 16>>,\n) -> AssignResult {\n  var out: AssignResult;\n  out.err = 0u;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let sel = nearest_index_6((*pixels)[k], pal);\n    out.indices[k] = sel.x;\n    out.err = out.err + sel.y;\n  }\n  return out;\n}\n\n// -------------------------- Endpoint quantisation ----------------------- //\n\n// Quantize one 8-bit ideal channel to (7-bit value, reconstructed 8-bit)\n// under a fixed p-bit. Matches the CPU reference.\nfn quantize_ch(ideal8: u32, p: u32) -> vec2<u32> {\n  // q7 = round((ideal8 \u2212 p) / 2), clamp to [0, 127].\n  let q = u32(clamp(\n    floor((f32(ideal8) - f32(p)) / 2.0 + 0.5),\n    0.0, 127.0,\n  ));\n  let eff = (q << 1u) | p;\n  return vec2<u32>(q, eff);\n}\n\nstruct QuantPair { seven: vec4<u32>, eight: vec4<u32> };\n\nfn quantize_endpoint(ideal8: vec4<u32>, p: u32) -> QuantPair {\n  let r = quantize_ch(ideal8.x, p);\n  let g = quantize_ch(ideal8.y, p);\n  let b = quantize_ch(ideal8.z, p);\n  let a = quantize_ch(ideal8.w, p);\n  return QuantPair(\n    vec4<u32>(r.x, g.x, b.x, a.x),\n    vec4<u32>(r.y, g.y, b.y, a.y),\n  );\n}\n\n// Try all four p-bit combos (p0, p1) \u2208 {0,1}\xB2 and return the best\n// quantised-endpoint-plus-indices triple.\nstruct BestMode6 {\n  e0_7: vec4<u32>, e1_7: vec4<u32>,\n  p0: u32,         p1: u32,\n  indices: array<u32, 16>,\n  err: u32,\n};\n\nfn try_pbit_combos(\n  pixels: ptr<function, array<vec4<u32>, 16>>,\n  ideal0: vec4<u32>,\n  ideal1: vec4<u32>,\n) -> BestMode6 {\n  var best: BestMode6;\n  best.err = 0xFFFFFFFFu;\n  for (var p0: u32 = 0u; p0 < 2u; p0 = p0 + 1u) {\n    let q0 = quantize_endpoint(ideal0, p0);\n    for (var p1: u32 = 0u; p1 < 2u; p1 = p1 + 1u) {\n      let q1 = quantize_endpoint(ideal1, p1);\n      var pal: array<vec4<u32>, 16>;\n      build_palette_6(q0.eight, q1.eight, &pal);\n      let assigned = assign_all(pixels, &pal);\n      if (assigned.err < best.err) {\n        best.e0_7 = q0.seven;\n        best.e1_7 = q1.seven;\n        best.p0   = p0;\n        best.p1   = p1;\n        best.indices = assigned.indices;\n        best.err  = assigned.err;\n      }\n    }\n  }\n  return best;\n}\n\n// ---------------------- Least-squares endpoint refit -------------------- //\n\n// Channel-independent LSQ fit of (e0, e1) given current indices. Normal\n// equations: see bc7_ref.ts `refitEndpointsMode6`. Returns 8-bit ideal\n// endpoints (before p-bit quantisation). `valid` = false for a degenerate\n// system (all texels on one palette entry).\nstruct RefitResult { e0: vec4<u32>, e1: vec4<u32>, valid: bool };\n\nfn refit_endpoints(\n  pixels: ptr<function, array<vec4<u32>, 16>>,\n  indices: ptr<function, array<u32, 16>>,\n) -> RefitResult {\n  var sAA: f32 = 0.0;\n  var sBB: f32 = 0.0;\n  var sAB: f32 = 0.0;\n  var sAV: vec4<f32> = vec4<f32>(0.0);\n  var sBV: vec4<f32> = vec4<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let i = (*indices)[k];\n    let a = f32(64u - w4(i)) / 64.0;\n    let b = f32(w4(i)) / 64.0;\n    let v = vec4<f32>((*pixels)[k]);\n    sAA = sAA + a * a;\n    sBB = sBB + b * b;\n    sAB = sAB + a * b;\n    sAV = sAV + a * v;\n    sBV = sBV + b * v;\n  }\n  let det = sAA * sBB - sAB * sAB;\n  var out: RefitResult;\n  if (abs(det) < 1e-9) {\n    out.valid = false;\n    return out;\n  }\n  let e0f = (sBB * sAV - sAB * sBV) / det;\n  let e1f = (sAA * sBV - sAB * sAV) / det;\n  out.e0 = vec4<u32>(clamp(round(e0f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.e1 = vec4<u32>(clamp(round(e1f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.valid = true;\n  return out;\n}\n\n// -------------------------- Bit-packing helper -------------------------- //\n\n// Write `n_bits` LSBs of `value` at bit position `pos` in a 128-bit field\n// split across 4 u32s. Straddles the word boundary when necessary.\nfn write_bits(block: ptr<function, array<u32, 4>>, pos: u32, n_bits: u32, value: u32) {\n  let v = value & ((1u << n_bits) - 1u);\n  let word_lo = pos / 32u;\n  let bit_lo = pos % 32u;\n  let bits_in_lo = min(n_bits, 32u - bit_lo);\n\n  let mask_lo = ((1u << bits_in_lo) - 1u) << bit_lo;\n  (*block)[word_lo] = ((*block)[word_lo] & ~mask_lo) | ((v << bit_lo) & mask_lo);\n\n  if (bits_in_lo < n_bits) {\n    let bits_in_hi = n_bits - bits_in_lo;\n    let mask_hi = (1u << bits_in_hi) - 1u;\n    let val_hi = v >> bits_in_lo;\n    (*block)[word_lo + 1u] = ((*block)[word_lo + 1u] & ~mask_hi) | (val_hi & mask_hi);\n  }\n}\n\n// ------------------------------- Entry --------------------------------- //\n\n@compute @workgroup_size(8, 8, 1)\nfn encode(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if (gid.x >= params.blocks_x || gid.y >= params.blocks_y) {\n    return;\n  }\n\n  let bx = gid.x;\n  let by = gid.y;\n  let block_index = by * params.blocks_x + bx;\n\n  let base   = vec2<i32>(i32(bx) * 4, i32(by) * 4);\n  let max_xy = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  // 1. Load 16 RGBA pixels in 8-bit integer domain.\n  var pixels: array<vec4<u32>, 16>;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let lx = i32(i & 3u);\n    let ly = i32(i >> 2u);\n    let p  = clamp(base + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let c  = textureLoad(src_tex, p, 0);\n    pixels[i] = vec4<u32>(to8(c.r), to8(c.g), to8(c.b), to8(c.a));\n  }\n\n  // 2. Farthest-pair \u2192 initial endpoints.\n  let fp = farthest_pair(&pixels);\n  let ideal0_init = pixels[fp.i0];\n  let ideal1_init = pixels[fp.i1];\n\n  // 3. First p-bit search over the farthest-pair seed.\n  var best = try_pbit_combos(&pixels, ideal0_init, ideal1_init);\n\n  // 4. One-pass LSQ refit + second p-bit search; accept if error decreases.\n  let refit = refit_endpoints(&pixels, &best.indices);\n  if (refit.valid) {\n    let cand = try_pbit_combos(&pixels, refit.e0, refit.e1);\n    if (cand.err < best.err) {\n      best = cand;\n    }\n  }\n\n  // 5. Anchor rule \u2014 pixel 0's index MSB must be 0. If not, swap endpoints\n  // and reflect every index (new_i = 15 \u2212 old_i). The decoded palette\n  // reverses, so the reconstructed image is unchanged.\n  if ((best.indices[0] & 0x8u) != 0u) {\n    let tmp7 = best.e0_7; best.e0_7 = best.e1_7; best.e1_7 = tmp7;\n    let tmpP = best.p0;   best.p0   = best.p1;   best.p1   = tmpP;\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n      best.indices[k] = 15u - best.indices[k];\n    }\n  }\n\n  // 6. Pack into 128 bits = 4 u32s.\n  var block: array<u32, 4>;\n  block[0] = 0u; block[1] = 0u; block[2] = 0u; block[3] = 0u;\n\n  var pos: u32 = 0u;\n  // Mode 6: six zero bits followed by a 1 (LSB-first).\n  write_bits(&block, pos, 7u, 0x40u); pos = pos + 7u;\n  // Endpoints: R0, R1, G0, G1, B0, B1, A0, A1 \u2014 7 bits each.\n  write_bits(&block, pos, 7u, best.e0_7.x); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e1_7.x); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e0_7.y); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e1_7.y); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e0_7.z); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e1_7.z); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e0_7.w); pos = pos + 7u;\n  write_bits(&block, pos, 7u, best.e1_7.w); pos = pos + 7u;\n  // P-bits.\n  write_bits(&block, pos, 1u, best.p0); pos = pos + 1u;\n  write_bits(&block, pos, 1u, best.p1); pos = pos + 1u;\n  // Pixel 0: 3-bit anchor (MSB implicit 0).\n  write_bits(&block, pos, 3u, best.indices[0] & 0x7u); pos = pos + 3u;\n  // Pixels 1..15: 4 bits each.\n  for (var k: u32 = 1u; k < 16u; k = k + 1u) {\n    write_bits(&block, pos, 4u, best.indices[k] & 0xFu);\n    pos = pos + 4u;\n  }\n\n  // 7. Store.\n  let out = block_index * 4u;\n  dst[out + 0u] = block[0];\n  dst[out + 1u] = block[1];\n  dst[out + 2u] = block[2];\n  dst[out + 3u] = block[3];\n}\n";
+
+// src/BC7Encoder.ts
+var BC7Encoder = class extends Encoder {
+  static requiredFeature = WebGPUFeature.BC;
+  static textureFormats = [TextureFormat.BC7, TextureFormat.BC7_SRGB];
+  get label() {
+    return "bc7";
+  }
+  get bytesPerBlock() {
+    return 16;
+  }
+  get supportsSrgb() {
+    return true;
+  }
+  wgslSource() {
+    return bc7_default;
+  }
+  gpuTextureFormat({ colorSpace }) {
+    return colorSpace === "srgb" ? "bc7-rgba-unorm-srgb" : "bc7-rgba-unorm";
+  }
+  threeTextureFormat() {
+    return RGBA_BPTC_Format;
+  }
+};
+
+// src/ASTC4x4Encoder.ts
+import { RGBA_ASTC_4x4_Format } from "three";
+
+// src/astc4x4.wgsl
+var astc4x4_default = "// ASTC 4\xD74 LDR compute shader encoder.\n//\n// One invocation per 4\xD74 block. Emits 16 bytes = 4 u32s into the storage\n// buffer at `dst[block_index * 4 .. + 3]`.\n//\n// This shader mirrors `astc4x4_ref.ts` function-by-function; see that\n// file for the end-to-end algorithm rationale and the full block layout\n// / block-mode derivation. A short recap follows.\n//\n// RESTRICTED SUBSET (both CPU ref and this shader):\n//   \u2022 Single partition, no dual-plane\n//   \u2022 CEM 12 (LDR RGBA, direct)\n//   \u2022 Weight grid 4\xD74 (no upsampling), 2-bit weights (QUANT_4)\n//   \u2022 8-bit endpoints (QUANT_256 \u2014 bit-replication is a no-op)\n//\n// BLOCK LAYOUT (128 bits, LSB-first)\n//   bits [10:0]   block mode = 0x042\n//   bits [12:11]  partition count \u2212 1 = 0\n//   bits [16:13]  CEM = 12\n//   bits [80:17]  endpoints: R0 R1 G0 G1 B0 B1 A0 A1 (8-bit each)\n//   bits [95:81]  unused (zero padding)\n//   bits [127:96] 16 \xD7 2-bit weights; for weight k \u2208 [0,15]:\n//                   block_bit(127 \u2212 2k) = weight_k[0]   (LSB)\n//                   block_bit(126 \u2212 2k) = weight_k[1]   (MSB)\n//\n// ENDPOINT ORDERING: after fitting, if sum(e0.rgb) > sum(e1.rgb) we swap\n// endpoints and reflect indices (w' = 3 \u2212 w). This keeps the decoder out\n// of the blue-contraction branch (see CPU ref file header for the full\n// decoder behaviour).\n\nstruct Params {\n  blocks_x: u32,\n  blocks_y: u32,\n  width:    u32,\n  height:   u32,\n};\n\n@group(0) @binding(0) var src_tex: texture_2d<f32>;\n@group(0) @binding(1) var<storage, read_write> dst: array<u32>;\n@group(0) @binding(2) var<uniform> params: Params;\n\n// QUANT_4 weight unquantisation: q \u2208 [0,3] \u2192 unq \u2208 [0, 21, 43, 64].\n// Switch keeps us off a module-scope const array (some backends reject\n// those inside function-call bodies).\nfn weight_unq(i: u32) -> u32 {\n  switch i {\n    case 0u: { return  0u; }\n    case 1u: { return 21u; }\n    case 2u: { return 43u; }\n    default: { return 64u; }  // case 3u\n  }\n}\n\n// Hardware-exact integer interpolation. Identical to BC7's; matches the\n// CPU reference bit-for-bit.\nfn interp8(e0: u32, e1: u32, w: u32) -> u32 {\n  return ((64u - w) * e0 + w * e1 + 32u) >> 6u;\n}\n\n// Normalised [0, 1] \u2192 clamped 8-bit. Same rounding rule (floor(v + 0.5))\n// as the CPU reference's Math.round.\nfn to8(v: f32) -> u32 {\n  return u32(clamp(floor(v * 255.0 + 0.5), 0.0, 255.0));\n}\n\n// 4-channel L2 distance squared in u32 domain. Bounded by 4 \xB7 255\xB2 = 260,100.\nfn pixel_dist_sq(a: vec4<u32>, b: vec4<u32>) -> u32 {\n  let d = vec4<i32>(a) - vec4<i32>(b);\n  let d2 = d * d;\n  return u32(d2.x + d2.y + d2.z + d2.w);\n}\n\n// -------------------------- Farthest-pair seed -------------------------- //\n\nstruct PairResult { i0: u32, i1: u32 };\n\n// O(N\xB2) = 120 comparisons. Same rationale as BC7's `farthest_pair`:\n// bounding-box corners aren't safe initial endpoints when channels vary\n// in different directions along the data line.\nfn farthest_pair(pixels: ptr<function, array<vec4<u32>, 16>>) -> PairResult {\n  var best_d: u32 = 0u;\n  var best_i: u32 = 0u;\n  var best_j: u32 = 1u;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    for (var j: u32 = i + 1u; j < 16u; j = j + 1u) {\n      let d = pixel_dist_sq((*pixels)[i], (*pixels)[j]);\n      if (d > best_d) { best_d = d; best_i = i; best_j = j; }\n    }\n  }\n  return PairResult(best_i, best_j);\n}\n\n// -------------------------- Palette + assignment ------------------------ //\n\n// Build the 4-entry RGBA palette from 8-bit endpoints. Uses the same\n// integer interpolation formula as decode, so assignments made against\n// this palette match the hardware round-trip.\nfn build_palette(\n  e0: vec4<u32>, e1: vec4<u32>,\n  pal: ptr<function, array<vec4<u32>, 4>>,\n) {\n  for (var i: u32 = 0u; i < 4u; i = i + 1u) {\n    let w = weight_unq(i);\n    (*pal)[i] = vec4<u32>(\n      interp8(e0.x, e1.x, w),\n      interp8(e0.y, e1.y, w),\n      interp8(e0.z, e1.z, w),\n      interp8(e0.w, e1.w, w),\n    );\n  }\n}\n\n// Nearest palette entry for a single RGBA pixel. Full 4-way L2 search.\n// Returns (best_index, its squared error).\nfn nearest_index(pixel: vec4<u32>, pal: ptr<function, array<vec4<u32>, 4>>) -> vec2<u32> {\n  var best_i: u32 = 0u;\n  var best_d: u32 = 0xFFFFFFFFu;\n  for (var i: u32 = 0u; i < 4u; i = i + 1u) {\n    let d = pixel_dist_sq(pixel, (*pal)[i]);\n    if (d < best_d) { best_d = d; best_i = i; }\n  }\n  return vec2<u32>(best_i, best_d);\n}\n\n// Assign all 16 texels to nearest palette entries; accumulate squared error.\nstruct AssignResult { indices: array<u32, 16>, err: u32 };\n\nfn assign_all(\n  pixels: ptr<function, array<vec4<u32>, 16>>,\n  pal:    ptr<function, array<vec4<u32>, 4>>,\n) -> AssignResult {\n  var out: AssignResult;\n  out.err = 0u;\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let sel = nearest_index((*pixels)[k], pal);\n    out.indices[k] = sel.x;\n    out.err = out.err + sel.y;\n  }\n  return out;\n}\n\n// ---------------------- Least-squares endpoint refit -------------------- //\n\n// Given current indices, solve the per-channel 2\xD72 normal equations for\n// (e0, e1). See the CPU reference's `refitEndpoints` for the derivation.\n// `valid = false` signals a degenerate system (all texels on one palette\n// entry) and the caller keeps the farthest-pair seed.\nstruct RefitResult { e0: vec4<u32>, e1: vec4<u32>, valid: bool };\n\nfn refit_endpoints(\n  pixels:  ptr<function, array<vec4<u32>, 16>>,\n  indices: ptr<function, array<u32, 16>>,\n) -> RefitResult {\n  var sAA: f32 = 0.0;\n  var sBB: f32 = 0.0;\n  var sAB: f32 = 0.0;\n  var sAV: vec4<f32> = vec4<f32>(0.0);\n  var sBV: vec4<f32> = vec4<f32>(0.0);\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let unq = weight_unq((*indices)[k]);\n    let a = f32(64u - unq) / 64.0;\n    let b = f32(unq)       / 64.0;\n    let v = vec4<f32>((*pixels)[k]);\n    sAA = sAA + a * a;\n    sBB = sBB + b * b;\n    sAB = sAB + a * b;\n    sAV = sAV + a * v;\n    sBV = sBV + b * v;\n  }\n  let det = sAA * sBB - sAB * sAB;\n  var out: RefitResult;\n  if (abs(det) < 1e-9) {\n    out.valid = false;\n    return out;\n  }\n  let e0f = (sBB * sAV - sAB * sBV) / det;\n  let e1f = (sAA * sBV - sAB * sAV) / det;\n  out.e0 = vec4<u32>(clamp(round(e0f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.e1 = vec4<u32>(clamp(round(e1f), vec4<f32>(0.0), vec4<f32>(255.0)));\n  out.valid = true;\n  return out;\n}\n\n// -------------------------- Bit-packing helper -------------------------- //\n\n// Write `n_bits` LSBs of `value` at bit position `pos` of a 128-bit field\n// represented as `array<u32, 4>`. Handles word-boundary straddles.\n// Lifted from the BC7 shader verbatim; the layout contract is identical.\nfn write_bits(block: ptr<function, array<u32, 4>>, pos: u32, n_bits: u32, value: u32) {\n  let v = value & ((1u << n_bits) - 1u);\n  let word_lo = pos / 32u;\n  let bit_lo = pos % 32u;\n  let bits_in_lo = min(n_bits, 32u - bit_lo);\n\n  let mask_lo = ((1u << bits_in_lo) - 1u) << bit_lo;\n  (*block)[word_lo] = ((*block)[word_lo] & ~mask_lo) | ((v << bit_lo) & mask_lo);\n\n  if (bits_in_lo < n_bits) {\n    let bits_in_hi = n_bits - bits_in_lo;\n    let mask_hi = (1u << bits_in_hi) - 1u;\n    let val_hi = v >> bits_in_lo;\n    (*block)[word_lo + 1u] = ((*block)[word_lo + 1u] & ~mask_hi) | (val_hi & mask_hi);\n  }\n}\n\n// ------------------------------- Entry ---------------------------------- //\n\n@compute @workgroup_size(8, 8, 1)\nfn encode(@builtin(global_invocation_id) gid: vec3<u32>) {\n  if (gid.x >= params.blocks_x || gid.y >= params.blocks_y) {\n    return;\n  }\n\n  let bx = gid.x;\n  let by = gid.y;\n  let block_index = by * params.blocks_x + bx;\n\n  let base   = vec2<i32>(i32(bx) * 4, i32(by) * 4);\n  let max_xy = vec2<i32>(i32(params.width) - 1, i32(params.height) - 1);\n\n  // 1. Load 16 RGBA texels in 8-bit integer domain.\n  var pixels: array<vec4<u32>, 16>;\n  for (var i: u32 = 0u; i < 16u; i = i + 1u) {\n    let lx = i32(i & 3u);\n    let ly = i32(i >> 2u);\n    // Clamp to edge for non-multiple-of-4 input sizes.\n    let p  = clamp(base + vec2<i32>(lx, ly), vec2<i32>(0, 0), max_xy);\n    let c  = textureLoad(src_tex, p, 0);\n    pixels[i] = vec4<u32>(to8(c.r), to8(c.g), to8(c.b), to8(c.a));\n  }\n\n  // 2. Farthest-pair seed \u2192 initial endpoints.\n  let fp = farthest_pair(&pixels);\n  var e0 = pixels[fp.i0];\n  var e1 = pixels[fp.i1];\n\n  // 3. Initial assignment against the seed endpoints.\n  var pal: array<vec4<u32>, 4>;\n  build_palette(e0, e1, &pal);\n  var best = assign_all(&pixels, &pal);\n\n  // 4. One LSQ refit pass. Accept only if the squared error strictly\n  //    decreases \u2014 matches the CPU reference.\n  let refit = refit_endpoints(&pixels, &best.indices);\n  if (refit.valid) {\n    var pal2: array<vec4<u32>, 4>;\n    build_palette(refit.e0, refit.e1, &pal2);\n    let cand = assign_all(&pixels, &pal2);\n    if (cand.err < best.err) {\n      e0 = refit.e0;\n      e1 = refit.e1;\n      best = cand;\n    }\n  }\n\n  // 5. Endpoint ordering so the decoder doesn't apply blue contraction.\n  //    Strict '>' avoids a gratuitous swap on ties.\n  let s0 = e0.x + e0.y + e0.z;\n  let s1 = e1.x + e1.y + e1.z;\n  if (s0 > s1) {\n    let tmp = e0; e0 = e1; e1 = tmp;\n    for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n      // w' = 3 \u2212 w reflects the palette; decoded colour unchanged.\n      best.indices[k] = 3u - best.indices[k];\n    }\n  }\n\n  // 6. Pack 128 bits.\n  var block: array<u32, 4>;\n  block[0] = 0u; block[1] = 0u; block[2] = 0u; block[3] = 0u;\n\n  // Config header.\n  write_bits(&block, 0u,  11u, 0x042u);   // block mode: 4\xD74 grid, QUANT_4 weights\n  write_bits(&block, 11u, 2u,  0u);       // partition count \u2212 1\n  write_bits(&block, 13u, 4u,  12u);      // CEM 12: LDR RGBA direct\n\n  // Endpoints in the CEM 12 value order: R0 R1 G0 G1 B0 B1 A0 A1.\n  write_bits(&block, 17u + 0u * 8u, 8u, e0.x);\n  write_bits(&block, 17u + 1u * 8u, 8u, e1.x);\n  write_bits(&block, 17u + 2u * 8u, 8u, e0.y);\n  write_bits(&block, 17u + 3u * 8u, 8u, e1.y);\n  write_bits(&block, 17u + 4u * 8u, 8u, e0.z);\n  write_bits(&block, 17u + 5u * 8u, 8u, e1.z);\n  write_bits(&block, 17u + 6u * 8u, 8u, e0.w);\n  write_bits(&block, 17u + 7u * 8u, 8u, e1.w);\n\n  // Weights at the top of the block. Two 1-bit writes per weight keeps\n  // the LSB-at-127 convention visible at every call site; the cost over\n  // a batched write is negligible next to the full encode.\n  for (var k: u32 = 0u; k < 16u; k = k + 1u) {\n    let w = best.indices[k] & 0x3u;\n    write_bits(&block, 127u - 2u * k, 1u,  w & 1u);\n    write_bits(&block, 126u - 2u * k, 1u, (w >> 1u) & 1u);\n  }\n\n  // 7. Store as 4 u32s.\n  let out = block_index * 4u;\n  dst[out + 0u] = block[0];\n  dst[out + 1u] = block[1];\n  dst[out + 2u] = block[2];\n  dst[out + 3u] = block[3];\n}\n";
+
+// src/ASTC4x4Encoder.ts
+var ASTC4x4Encoder = class extends Encoder {
+  static requiredFeature = WebGPUFeature.ASTC;
+  static textureFormats = [TextureFormat.ASTC_4x4, TextureFormat.ASTC_4x4_SRGB];
+  get label() {
+    return "astc4x4";
+  }
+  get bytesPerBlock() {
+    return 16;
+  }
+  get supportsSrgb() {
+    return true;
+  }
+  wgslSource() {
+    return astc4x4_default;
+  }
+  gpuTextureFormat({ colorSpace }) {
+    return colorSpace === "srgb" ? "astc-4x4-unorm-srgb" : "astc-4x4-unorm";
+  }
+  threeTextureFormat() {
+    return RGBA_ASTC_4x4_Format;
+  }
+};
+
+// src/selectFormat.ts
+function selectFormat(adapter, hint, options = {}) {
+  const { colorSpace = "srgb" } = options;
+  const srgb = colorSpace === "srgb";
+  const caps = detectCapabilities(adapter);
+  if (caps.bc) {
+    if (hint === "normal") {
+      return { format: TextureFormat.BC5, encoderClass: BC5Encoder, astcNormalRemap: false };
+    }
+    return {
+      format: srgb ? TextureFormat.BC7_SRGB : TextureFormat.BC7,
+      encoderClass: BC7Encoder,
+      astcNormalRemap: false
+    };
+  }
+  if (caps.astc) {
+    const format = srgb ? TextureFormat.ASTC_4x4_SRGB : TextureFormat.ASTC_4x4;
+    return {
+      format,
+      encoderClass: ASTC4x4Encoder,
+      astcNormalRemap: hint === "normal"
+    };
+  }
+  return { format: null, encoderClass: null, astcNormalRemap: false };
+}
+
+// src/compressTexture.ts
+import { LinearFilter as LinearFilter2, LinearSRGBColorSpace as LinearSRGBColorSpace2, RepeatWrapping as RepeatWrapping2, SRGBColorSpace as SRGBColorSpace2, Texture } from "three";
+
+// src/mipgen.ts
+function generateMipChain(level0) {
+  if (level0.width < 1 || level0.height < 1) {
+    throw new Error(`generateMipChain: level 0 must be at least 1\xD71, got ${level0.width}\xD7${level0.height}`);
+  }
+  if (level0.data.length !== level0.width * level0.height * 4) {
+    throw new Error(
+      `generateMipChain: level 0 data length ${level0.data.length} does not match ${level0.width}\xD7${level0.height}\xD74 = ${level0.width * level0.height * 4}`
+    );
+  }
+  const chain = [level0];
+  let prev = level0;
+  while (prev.width > 1 || prev.height > 1) {
+    prev = downsample2x(prev);
+    chain.push(prev);
+  }
+  return chain;
+}
+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 sMaxY = src.height - 1;
+  for (let y = 0; y < dstH; y++) {
+    const sy0 = y * 2;
+    const sy1 = Math.min(sy0 + 1, sMaxY);
+    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;
+    }
+  }
+  return { data: dst, width: dstW, height: dstH };
+}
+function padToBlockMultiple(level) {
+  const pw = level.width + 3 & ~3;
+  const ph = level.height + 3 & ~3;
+  if (pw === level.width && ph === level.height) return level;
+  const out = new Uint8ClampedArray(pw * ph * 4);
+  const maxX = level.width - 1;
+  const maxY = level.height - 1;
+  for (let y = 0; y < ph; y++) {
+    const sy = Math.min(y, maxY);
+    for (let x = 0; x < pw; x++) {
+      const sx = Math.min(x, maxX);
+      const si = (sy * level.width + sx) * 4;
+      const di = (y * pw + x) * 4;
+      out[di] = level.data[si];
+      out[di + 1] = level.data[si + 1];
+      out[di + 2] = level.data[si + 2];
+      out[di + 3] = level.data[si + 3];
+    }
+  }
+  return { data: out, width: pw, height: ph };
+}
+
+// src/compressTexture.ts
+async function sourceToBitmap(source) {
+  const opts = {
+    colorSpaceConversion: "none",
+    premultiplyAlpha: "none"
+  };
+  if (typeof source === "string") {
+    const resp = await fetch(source);
+    if (!resp.ok) {
+      throw new Error(`compressTexture: fetch ${source} failed (${resp.status})`);
+    }
+    const blob = await resp.blob();
+    return createImageBitmap(blob, opts);
+  }
+  if (source instanceof Blob) {
+    return createImageBitmap(source, opts);
+  }
+  if (source instanceof ImageBitmap) {
+    return source;
+  }
+  return createImageBitmap(source, opts);
+}
+function bitmapToMipLevel(bitmap, flipY) {
+  const w = bitmap.width, h = bitmap.height;
+  const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(w, h) : Object.assign(document.createElement("canvas"), { width: w, height: h });
+  const ctx = canvas.getContext("2d", { willReadFrequently: true });
+  if (!ctx) {
+    throw new Error("compressTexture: no 2D context available for mip generation");
+  }
+  if (flipY) {
+    ctx.translate(0, h);
+    ctx.scale(1, -1);
+  }
+  ctx.drawImage(bitmap, 0, 0);
+  const imageData = ctx.getImageData(0, 0, w, h);
+  return { data: imageData.data, width: w, height: h };
+}
+function mipLevelToImageData(level) {
+  return new ImageData(level.data, level.width, level.height);
+}
+function wrapUncompressed(bitmap, srgb, flipY) {
+  const tex = new Texture(bitmap);
+  tex.colorSpace = srgb ? SRGBColorSpace2 : LinearSRGBColorSpace2;
+  tex.magFilter = LinearFilter2;
+  tex.minFilter = LinearFilter2;
+  tex.wrapS = tex.wrapT = RepeatWrapping2;
+  tex.generateMipmaps = false;
+  tex.flipY = flipY;
+  tex.needsUpdate = true;
+  return tex;
+}
+async function compressTexture(source, options = {}) {
+  const {
+    hint = "color",
+    colorSpace = "srgb",
+    flipY = true,
+    mipmaps = false,
+    device: providedDevice,
+    adapter: providedAdapter
+  } = options;
+  const srgb = colorSpace === "srgb";
+  const bitmap = await sourceToBitmap(source);
+  if (!("gpu" in navigator)) {
+    console.warn("[compressTexture] WebGPU unavailable; returning uncompressed RGBA8.");
+    const tex = wrapUncompressed(bitmap, srgb, flipY);
+    return {
+      texture: tex,
+      format: null,
+      fallbackUncompressed: true,
+      astcNormalRemap: false,
+      width: bitmap.width,
+      height: bitmap.height,
+      mipLevels: 1,
+      encodeMs: 0,
+      destroy: () => {
+        tex.dispose();
+      }
+    };
+  }
+  const adapter = providedAdapter ?? await navigator.gpu.requestAdapter();
+  if (!adapter) {
+    console.warn("[compressTexture] No WebGPU adapter; returning uncompressed RGBA8.");
+    const tex = wrapUncompressed(bitmap, srgb, flipY);
+    return {
+      texture: tex,
+      format: null,
+      fallbackUncompressed: true,
+      astcNormalRemap: false,
+      width: bitmap.width,
+      height: bitmap.height,
+      mipLevels: 1,
+      encodeMs: 0,
+      destroy: () => {
+        tex.dispose();
+      }
+    };
+  }
+  const selection = selectFormat(adapter, hint, { colorSpace });
+  if (!selection.format || !selection.encoderClass) {
+    console.warn(
+      "[compressTexture] Adapter reports neither texture-compression-bc nor texture-compression-astc; returning uncompressed RGBA8."
+    );
+    const tex = wrapUncompressed(bitmap, srgb, flipY);
+    return {
+      texture: tex,
+      format: null,
+      fallbackUncompressed: true,
+      astcNormalRemap: false,
+      width: bitmap.width,
+      height: bitmap.height,
+      mipLevels: 1,
+      encodeMs: 0,
+      destroy: () => {
+        tex.dispose();
+      }
+    };
+  }
+  let encoder;
+  if (providedDevice) {
+    const EncoderCtor = selection.encoderClass;
+    encoder = new EncoderCtor({ device: providedDevice, adapter, ownsDevice: false });
+  } else {
+    encoder = await selection.encoderClass.create();
+  }
+  try {
+    if (!mipmaps) {
+      const bytes = await encoder.encodeToBytes(bitmap, { flipY });
+      const tex2 = encoder.buildMippedTexture([bytes], { colorSpace });
+      return {
+        texture: tex2,
+        format: selection.format,
+        fallbackUncompressed: false,
+        astcNormalRemap: selection.astcNormalRemap,
+        width: bytes.width,
+        height: bytes.height,
+        mipLevels: 1,
+        encodeMs: bytes.encodeMs,
+        destroy: () => {
+          tex2.dispose();
+          encoder.destroy();
+        }
+      };
+    }
+    const level0 = bitmapToMipLevel(bitmap, flipY);
+    const chain = generateMipChain(level0);
+    const encodedLevels = [];
+    let totalEncodeMs = 0;
+    for (const level of chain) {
+      const padded = padToBlockMultiple(level);
+      const imageData = mipLevelToImageData(padded);
+      const bytes = await encoder.encodeToBytes(imageData);
+      encodedLevels.push(bytes);
+      totalEncodeMs += bytes.encodeMs;
+    }
+    const tex = encoder.buildMippedTexture(encodedLevels, { colorSpace });
+    return {
+      texture: tex,
+      format: selection.format,
+      fallbackUncompressed: false,
+      astcNormalRemap: selection.astcNormalRemap,
+      width: level0.width,
+      height: level0.height,
+      mipLevels: encodedLevels.length,
+      encodeMs: totalEncodeMs,
+      destroy: () => {
+        tex.dispose();
+        encoder.destroy();
+      }
+    };
+  } catch (e) {
+    encoder.destroy();
+    throw e;
+  }
+}
+
+// src/CompressedTextureLoader.ts
+import { Loader } from "three";
+var WebGPUCompressedTextureLoader = class extends Loader {
+  /** Format-selection hint. Default 'color'. */
+  hint = "color";
+  /** Pick the sRGB or linear variant of the chosen format. Default 'srgb'. */
+  colorSpace = "srgb";
+  /** Flip the image vertically before encoding. Default true (matches Three.js convention). */
+  flipY = true;
+  /** Generate + encode a full mip chain. Default false. */
+  mipmaps = false;
+  /**
+   * Optional pre-existing WebGPU device. Reusing the renderer's device
+   * avoids spinning up a second WebGPU context for encoding.
+   */
+  device;
+  adapter;
+  /**
+   * Most recent full encode result. Useful when the caller wants format
+   * / mipLevels / astcNormalRemap metadata without threading a separate
+   * callback through `load()`. Cleared when a new load starts.
+   */
+  lastResult = null;
+  /**
+   * THREE.Loader contract: returns void, drives callbacks. `loadAsync`
+   * (inherited from the base class) wraps this with Promise semantics.
+   * Errors routed through `manager.itemError` so the LoadingManager's
+   * aggregate state stays accurate.
+   */
+  load(url, onLoad, _onProgress, onError) {
+    this.lastResult = null;
+    this.manager.itemStart(url);
+    compressTexture(url, {
+      hint: this.hint,
+      colorSpace: this.colorSpace,
+      flipY: this.flipY,
+      mipmaps: this.mipmaps,
+      device: this.device,
+      adapter: this.adapter
+    }).then(
+      (result) => {
+        this.lastResult = result;
+        const mip0 = result.texture.mipmaps?.[0];
+        result.texture.userData.gputex = {
+          format: result.format,
+          fallbackUncompressed: result.fallbackUncompressed,
+          astcNormalRemap: result.astcNormalRemap,
+          width: result.width,
+          height: result.height,
+          mipLevels: result.mipLevels,
+          encodeMs: result.encodeMs,
+          compressedBytes: result.fallbackUncompressed ? result.width * result.height * 4 : mip0?.data.byteLength ?? 0
+        };
+        onLoad?.(result.texture);
+        this.manager.itemEnd(url);
+      },
+      (err) => {
+        onError?.(err);
+        this.manager.itemError(url);
+        this.manager.itemEnd(url);
+      }
+    );
+  }
+};
+export {
+  ASTC4x4Encoder,
+  BC1Encoder,
+  BC5Encoder,
+  BC7Encoder,
+  Encoder,
+  TextureFormat,
+  WebGPUCompressedTextureLoader,
+  WebGPUFeature,
+  compressTexture,
+  detectCapabilities,
+  generateMipChain,
+  padToBlockMultiple,
+  selectFormat
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "gputex",
+  "version": "0.0.3",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup && cp ../README.md README.md",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.8",
+    "@types/three": "^0.183.1",
+    "@webgpu/types": "^0.1.69",
+    "three": "^0.183.2",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "three": ">=0.170"
+  }
+}