gputex 0.5.0 → 0.7.0

package/dist/testing.d.ts

@@ -110,8 +110,10 @@ type ASTC4x4Block = Uint8Array;
  * grayscale + opaque → luminance, opaque → RGB, otherwise RGBA.
  *
  * Algorithm per class:
- *   1. Quantise input to 8-bit; classify.
- *   2. Farthest-pair over the class's channels → initial (e0, e1).
+ *   1. Quantise input to 8-bit; classify (opaque colour tries both CEM 8
+ *      bit budgets and keeps the lower-error one).
+ *   2. Farthest-pair over the class's channels → initial (e0, e1),
+ *      quantised to the class's endpoint range.
  *   3. Assign per-texel indices by nearest palette entry.
  *   4. One LSQ refit pass; accept only if total error strictly decreases.
  *   5. CEM 8/12: flip endpoints (and reflect weights) if
@@ -121,13 +123,14 @@ type ASTC4x4Block = Uint8Array;
 declare function encodeASTC4x4Block(pixels: ASTC4x4Pixels): ASTC4x4Block;
 /**
  * Decode an ASTC 4×4 block produced by this encoder (or by any other
- * encoder that respects our narrow subset: block modes 0x042/0x053/0x253,
- * single partition, CEM 0/8/12 with 8-bit endpoints). Handles the
+ * encoder that respects our narrow subset: block modes 0x042/0x053/0x242/
+ * 0x253, single partition, CEM 0/8/12 — QUANT_192 endpoints with 0x242,
+ * 8-bit endpoints otherwise). Handles the
  * blue-contraction branch even though our encoder doesn't produce it, so
  * externally-supplied blocks round-trip predictably.
  *
  * The CEM is validated against the block mode's expected pairing (we only
- * ever emit the three fixed combinations above).
+ * ever emit the four fixed combinations above).
  *
  * Output: 16 RGBA pixels as 64 floats in [0, 1].
  */

package/dist/testing.js

@@ -922,33 +922,49 @@ function decodeBC7Block(block) {
 // src/astc4x4_ref.ts
 var BLOCK_MODE_4x4_2BIT = 66;
 var BLOCK_MODE_4x4_3BIT = 83;
+var BLOCK_MODE_4x4_4BIT = 578;
 var BLOCK_MODE_4x4_5BIT = 595;
 var CEM_LUM_DIRECT = 0;
 var CEM_RGB_DIRECT = 8;
 var CEM_RGBA_DIRECT = 12;
 var WEIGHT_UNQ_4 = [0, 21, 43, 64];
 var WEIGHT_UNQ_8 = [0, 9, 18, 27, 37, 46, 55, 64];
+var WEIGHT_UNQ_16 = Array.from({ length: 16 }, (_, w) => {
+  const u = w << 2 | w >> 2;
+  return u > 32 ? u + 1 : u;
+});
 var WEIGHT_UNQ_32 = Array.from({ length: 32 }, (_, w) => w <= 15 ? 2 * w : 2 * w + 2);
 var CLASS_LUM = {
   cem: CEM_LUM_DIRECT,
   blockMode: BLOCK_MODE_4x4_5BIT,
   channels: [0],
   weightBits: 5,
-  unq: WEIGHT_UNQ_32
+  unq: WEIGHT_UNQ_32,
+  endpointRange: 256
 };
 var CLASS_RGB = {
   cem: CEM_RGB_DIRECT,
   blockMode: BLOCK_MODE_4x4_3BIT,
   channels: [0, 1, 2],
   weightBits: 3,
-  unq: WEIGHT_UNQ_8
+  unq: WEIGHT_UNQ_8,
+  endpointRange: 256
+};
+var CLASS_RGB_Q192 = {
+  cem: CEM_RGB_DIRECT,
+  blockMode: BLOCK_MODE_4x4_4BIT,
+  channels: [0, 1, 2],
+  weightBits: 4,
+  unq: WEIGHT_UNQ_16,
+  endpointRange: 192
 };
 var CLASS_RGBA = {
   cem: CEM_RGBA_DIRECT,
   blockMode: BLOCK_MODE_4x4_2BIT,
   channels: [0, 1, 2, 3],
   weightBits: 2,
-  unq: WEIGHT_UNQ_4
+  unq: WEIGHT_UNQ_4,
+  endpointRange: 256
 };
 function clamp2(v, lo, hi) {
   return v < lo ? lo : v > hi ? hi : v;
@@ -959,6 +975,84 @@ function to82(v) {
 function interp16(e0, e1, w) {
   return (64 - w) * e0 * 257 + w * e1 * 257 + 32 >> 6;
 }
+function unq192(value) {
+  const trit = value >> 6;
+  const bits = value & 63;
+  const A = bits & 1 ? 511 : 0;
+  const f = bits >> 5 & 1;
+  const B = (bits >> 1 & 31) << 4 | f;
+  const T = (trit * 5 + B ^ A) & 511;
+  return (A & 128 | T >> 2) & 255;
+}
+var Q192_VALUE_OF = (() => {
+  const t = new Int16Array(256).fill(-1);
+  for (let v = 0; v < 192; v++) t[unq192(v)] = v;
+  return t;
+})();
+function nearest192(x) {
+  const v = clamp2(Math.round(x), 0, 255);
+  if (Q192_VALUE_OF[v] >= 0) return v;
+  const lo = v - 1;
+  const hi = v + 1;
+  const loOk = lo >= 0 && Q192_VALUE_OF[lo] >= 0;
+  const hiOk = hi <= 255 && Q192_VALUE_OF[hi] >= 0;
+  if (loOk && hiOk) return x - lo <= hi - x ? lo : hi;
+  if (loOk) return x - lo <= 2 ? lo : v + 2;
+  return hiOk ? hi : v - 2;
+}
+function decodeTrits(T) {
+  const bit = (x, i) => x >> i & 1;
+  let C;
+  let t3;
+  let t4;
+  if ((T >> 2 & 7) === 7) {
+    C = (T >> 5 & 7) << 2 | T & 3;
+    t4 = 2;
+    t3 = 2;
+  } else {
+    C = T & 31;
+    if ((T >> 5 & 3) === 3) {
+      t4 = 2;
+      t3 = bit(T, 7);
+    } else {
+      t4 = bit(T, 7);
+      t3 = T >> 5 & 3;
+    }
+  }
+  let t0;
+  let t1;
+  let t2;
+  if ((C & 3) === 3) {
+    t2 = 2;
+    t1 = bit(C, 4);
+    t0 = bit(C, 3) << 1 | bit(C, 2) & ~bit(C, 3) & 1;
+  } else if ((C >> 2 & 3) === 3) {
+    t2 = 2;
+    t1 = 2;
+    t0 = C & 3;
+  } else {
+    t2 = bit(C, 4);
+    t1 = C >> 2 & 3;
+    t0 = bit(C, 1) << 1 | bit(C, 0) & ~bit(C, 1) & 1;
+  }
+  return [t0, t1, t2, t3, t4];
+}
+function encodeTrits(t0, t1, t2, t3, t4) {
+  let C;
+  if (t2 === 2 && t1 === 2) C = 12 | t0;
+  else if (t2 === 2) C = t1 << 4 | t0 << 2 | 3;
+  else C = t2 << 4 | t1 << 2 | t0;
+  if (t3 === 2 && t4 === 2) return C >> 2 << 5 | 7 << 2 | C & 3;
+  if (t4 === 2) return t3 << 7 | 3 << 5 | C;
+  return t4 << 7 | t3 << 5 | C;
+}
+var TRIT_SLICES = [
+  [0, 2],
+  [2, 2],
+  [4, 1],
+  [5, 2],
+  [7, 1]
+];
 var BitWriter1282 = class {
   bits = 0n;
   write(pos, nBits, value) {
@@ -1070,39 +1164,61 @@ function refitEndpoints2(vals, C, indices, unq) {
   }
   return { e0, e1 };
 }
-function encodeASTC4x4Block(pixels) {
-  if (pixels.length !== 64) {
-    throw new Error(`encodeASTC4x4Block: expected 64 values (16 RGBA), got ${pixels.length}`);
-  }
-  const pixels8 = new Uint8Array(64);
-  for (let k = 0; k < 64; k++) pixels8[k] = to82(pixels[k]);
-  let gray = true;
-  let opaque = true;
-  for (let k = 0; k < 16; k++) {
-    const r = pixels8[k * 4];
-    if (pixels8[k * 4 + 1] !== r || pixels8[k * 4 + 2] !== r) gray = false;
-    if (pixels8[k * 4 + 3] !== 255) opaque = false;
-  }
-  const cls = opaque ? gray ? CLASS_LUM : CLASS_RGB : CLASS_RGBA;
+function quantEndpoint(cls, e) {
+  return cls.endpointRange === 192 ? e.map(nearest192) : e.map((v) => clamp2(Math.round(v), 0, 255));
+}
+function fitClass(cls, pixels8) {
   const C = cls.channels.length;
   const vals = new Float64Array(16 * C);
   for (let k = 0; k < 16; k++) {
     for (let c = 0; c < C; c++) vals[k * C + c] = pixels8[k * 4 + cls.channels[c]];
   }
   const fp = farthestPair2(vals, C);
-  let e0 = Array.from({ length: C }, (_, c) => vals[fp.i0 * C + c]);
-  let e1 = Array.from({ length: C }, (_, c) => vals[fp.i1 * C + c]);
+  let e0 = quantEndpoint(
+    cls,
+    Array.from({ length: C }, (_, c) => vals[fp.i0 * C + c])
+  );
+  let e1 = quantEndpoint(
+    cls,
+    Array.from({ length: C }, (_, c) => vals[fp.i1 * C + c])
+  );
   let { indices, err } = totalSqError(vals, C, e0, e1, cls.unq);
   const refit = refitEndpoints2(vals, C, indices, cls.unq);
   if (refit) {
-    const second = totalSqError(vals, C, refit.e0, refit.e1, cls.unq);
+    const r0 = quantEndpoint(cls, refit.e0);
+    const r1 = quantEndpoint(cls, refit.e1);
+    const second = totalSqError(vals, C, r0, r1, cls.unq);
     if (second.err < err) {
-      e0 = refit.e0;
-      e1 = refit.e1;
+      e0 = r0;
+      e1 = r1;
       indices = second.indices;
       err = second.err;
     }
   }
+  return { e0, e1, indices, err };
+}
+function encodeASTC4x4Block(pixels) {
+  if (pixels.length !== 64) {
+    throw new Error(`encodeASTC4x4Block: expected 64 values (16 RGBA), got ${pixels.length}`);
+  }
+  const pixels8 = new Uint8Array(64);
+  for (let k = 0; k < 64; k++) pixels8[k] = to82(pixels[k]);
+  let gray = true;
+  let opaque = true;
+  for (let k = 0; k < 16; k++) {
+    const r = pixels8[k * 4];
+    if (pixels8[k * 4 + 1] !== r || pixels8[k * 4 + 2] !== r) gray = false;
+    if (pixels8[k * 4 + 3] !== 255) opaque = false;
+  }
+  const classes = opaque ? gray ? [CLASS_LUM] : [CLASS_RGB, CLASS_RGB_Q192] : [CLASS_RGBA];
+  let best = null;
+  for (const cls2 of classes) {
+    const fit = fitClass(cls2, pixels8);
+    if (!best || fit.err < best.err) best = { cls: cls2, ...fit };
+  }
+  const { cls } = best;
+  let { e0, e1, indices } = best;
+  const C = cls.channels.length;
   {
     const nSum = Math.min(C, 3);
     let s0 = 0;
@@ -1128,9 +1244,29 @@ function packBlock3(cls, e0, e1, indices) {
   bw.write(0, 11, cls.blockMode);
   bw.write(11, 2, 0);
   bw.write(13, 4, cls.cem);
-  for (let c = 0; c < e0.length; c++) {
-    bw.write(17 + c * 16, 8, e0[c]);
-    bw.write(25 + c * 16, 8, e1[c]);
+  const values = [];
+  for (let c = 0; c < e0.length; c++) values.push(e0[c], e1[c]);
+  if (cls.endpointRange === 192) {
+    let pos = 17;
+    for (let g = 0; g < values.length; g += 5) {
+      const grp = values.slice(g, g + 5).map((v) => {
+        const q = Q192_VALUE_OF[v];
+        if (q < 0) throw new Error(`packBlock: ${v} is not a QUANT_192 level`);
+        return q;
+      });
+      const t = [0, 0, 0, 0, 0];
+      grp.forEach((q, i) => t[i] = q >> 6);
+      const T = encodeTrits(t[0], t[1], t[2], t[3], t[4]);
+      grp.forEach((q, i) => {
+        bw.write(pos, 6, q & 63);
+        pos += 6;
+        const [start, count] = TRIT_SLICES[i];
+        bw.write(pos, count, T >> start & (1 << count) - 1);
+        pos += count;
+      });
+    }
+  } else {
+    values.forEach((v, i) => bw.write(17 + i * 8, 8, v));
   }
   for (let k = 0; k < 16; k++) {
     const w = indices[k];
@@ -1140,19 +1276,20 @@ function packBlock3(cls, e0, e1, indices) {
   }
   return bw.toBytes();
 }
-var CLASS_BY_MODE = {
-  [BLOCK_MODE_4x4_2BIT]: CLASS_RGBA,
-  [BLOCK_MODE_4x4_3BIT]: CLASS_RGB,
-  [BLOCK_MODE_4x4_5BIT]: CLASS_LUM
+var CLASS_BY_MODE_CEM = {
+  [`${BLOCK_MODE_4x4_2BIT}:${CEM_RGBA_DIRECT}`]: CLASS_RGBA,
+  [`${BLOCK_MODE_4x4_3BIT}:${CEM_RGB_DIRECT}`]: CLASS_RGB,
+  [`${BLOCK_MODE_4x4_4BIT}:${CEM_RGB_DIRECT}`]: CLASS_RGB_Q192,
+  [`${BLOCK_MODE_4x4_5BIT}:${CEM_LUM_DIRECT}`]: CLASS_LUM
 };
+var SUPPORTED_MODES = /* @__PURE__ */ new Set([BLOCK_MODE_4x4_2BIT, BLOCK_MODE_4x4_3BIT, BLOCK_MODE_4x4_4BIT, BLOCK_MODE_4x4_5BIT]);
 function decodeASTC4x4Block(block) {
   if (block.length !== 16) {
     throw new Error(`decodeASTC4x4Block: expected 16 bytes, got ${block.length}`);
   }
   const br = new BitReader1282(block);
   const mode = br.read(0, 11);
-  const cls = CLASS_BY_MODE[mode];
-  if (!cls) {
+  if (!SUPPORTED_MODES.has(mode)) {
     throw new Error(`decodeASTC4x4Block: unsupported block mode 0x${mode.toString(16)}`);
   }
   const partCount = br.read(11, 2);
@@ -1160,12 +1297,31 @@ function decodeASTC4x4Block(block) {
     throw new Error(`decodeASTC4x4Block: multi-partition blocks not supported (count=${partCount + 1})`);
   }
   const cem = br.read(13, 4);
-  if (cem !== cls.cem) {
-    throw new Error(`decodeASTC4x4Block: expected CEM ${cls.cem} with block mode 0x${mode.toString(16)}, got ${cem}`);
+  const cls = CLASS_BY_MODE_CEM[`${mode}:${cem}`];
+  if (!cls) {
+    throw new Error(`decodeASTC4x4Block: unsupported CEM ${cem} with block mode 0x${mode.toString(16)}`);
   }
   const nVals = cls.channels.length * 2;
   const v = [];
-  for (let i = 0; i < nVals; i++) v.push(br.read(17 + i * 8, 8));
+  if (cls.endpointRange === 192) {
+    let pos = 17;
+    for (let g = 0; g < nVals; g += 5) {
+      const n = Math.min(5, nVals - g);
+      const bits = [];
+      let T = 0;
+      for (let i = 0; i < n; i++) {
+        bits.push(br.read(pos, 6));
+        pos += 6;
+        const [start, count] = TRIT_SLICES[i];
+        T |= br.read(pos, count) << start;
+        pos += count;
+      }
+      const t = decodeTrits(T);
+      for (let i = 0; i < n; i++) v.push(unq192(t[i] << 6 | bits[i]));
+    }
+  } else {
+    for (let i = 0; i < nVals; i++) v.push(br.read(17 + i * 8, 8));
+  }
   let e0;
   let e1;
   if (cls.cem === CEM_LUM_DIRECT) {

package/dist/three.d.ts

@@ -1,139 +1,18 @@
-import { TextureHint, PreferredFormat, FormatQuality, SvgRasterSize, TextureFormat, Encoder, EncoderImageSource } from './index.js';
-export { ASTC4x4Encoder, ASTC4x4WebGLEncoder, BC1Encoder, BC1WebGLEncoder, BC5Encoder, BC5WebGLEncoder, BC7Encoder, BC7EncoderOptions, BC7WebGLEncoder, Capabilities, ETC2Encoder, EncodeBytesResult, EncodeCallOptions, EncodeMipChainResult, EncodedLevelBytes, EncoderConstructor, EncoderOptions, ExtensionProvider, FeatureProvider, FormatSelection, FormatVariant, MipLevel, RasterizeSvgOptions, RawPixelSource, SelectFormatOptions, WebGLBlockEncoder, WebGLCapabilities, WebGLEncodeBytesResult, WebGLEncoderConstructor, WebGLEncoderImageSource, WebGLEncoderOptions, WebGLFormatSelection, WebGPUFeature, createWebGLContext, detectCapabilities, detectWebGLCapabilities, generateGpuMipChain, generateMipChain, getSharedWebGLContext, gpuMipLevelCount, isWebGLAvailable, padToBlockMultiple, rasterizeSvg, selectFormat, selectWebGLFormat } from './index.js';
+import { CompressResult as CompressResult$1, CompressTextureSource, CompressOptions, TextureHint, PreferredFormat, FormatQuality, SvgRasterSize, TextureFormat, Encoder, EncoderImageSource } from './index.js';
+export { ASTC4x4Encoder, ASTC4x4WebGLEncoder, BC1Encoder, BC1WebGLEncoder, BC5Encoder, BC5WebGLEncoder, BC7Encoder, BC7EncoderOptions, BC7WebGLEncoder, Capabilities, ETC2Encoder, EncodeBytesResult, EncodeCallOptions, EncodeMipChainResult, EncodedLevelBytes, EncoderConstructor, EncoderOptions, ExtensionProvider, FeatureProvider, FormatSelection, FormatVariant, MipLevel, RasterizeSvgOptions, RawPixelSource, SelectFormatOptions, WebGLBlockEncoder, WebGLCapabilities, WebGLEncodeBytesResult, WebGLEncoderConstructor, WebGLEncoderImageSource, WebGLEncoderOptions, WebGLFormatSelection, WebGPUFeature, clearTranscodeCache, compressTextureToBytes, createWebGLContext, detectCapabilities, detectWebGLCapabilities, generateGpuMipChain, generateMipChain, getSharedWebGLContext, gpuMipLevelCount, isWebGLAvailable, padToBlockMultiple, rasterizeSvg, releaseSharedGpuResources, selectFormat, selectWebGLFormat, setTranscodeCacheLimit } from './index.js';
 import { Texture, CompressedTexture, Loader, CompressedPixelFormat } from 'three';
 
-/**
- * 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.
- *
- * SVG works through all of these: a URL to an `.svg` file, a string of
- * inline SVG markup (detected by a leading `<`), an SVG Blob/File, or an
- * HTMLImageElement whose src is SVG. Vector sources are rasterised to RGBA
- * before encoding — see the `svgSize` option.
- */
-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;
-    /**
-     * Prefer a specific format over the default choice when the device
-     * supports it; falls back to the normal selection (BC7 → ASTC → ETC2 →
-     * RGBA8) when it doesn't. Currently only 'bc1': half the memory of BC7
-     * for opaque colour textures, at lower quality. Only honoured with
-     * `hint: 'color'` — BC1 can't carry real alpha or normal maps.
-     */
-    preferredFormat?: PreferredFormat;
-    /**
-     * Memory/fidelity trade-off for opaque colour textures. Default 'high'
-     * (BC7 / ASTC 4×4, 1 byte/pixel). 'low' picks the 4-bpp formats when the
-     * device has one — BC1 on desktop-class GPUs, ETC2 RGB8 on mobile-class
-     * ones — halving GPU memory at visibly lower quality on smooth content.
-     * Ignored for `hint: 'colorWithAlpha'` and `hint: 'normal'` (the 4-bpp
-     * formats can't carry them). On the WebGL fallback tier only BC1 is
-     * available at 'low'.
-     */
-    quality?: FormatQuality;
-    /** Pick the sRGB or linear variant of the chosen format. Default 'srgb'. */
-    colorSpace?: 'srgb' | 'linear';
-    /**
-     * Rasterisation size for SVG sources. A number scales the SVG so its
-     * longest side matches (aspect ratio preserved); `{ width, height }`
-     * rasterises at exactly that size. Default: the SVG's intrinsic size
-     * (absolute width/height attributes, else the viewBox dimensions).
-     * Ignored for non-SVG sources.
-     */
-    svgSize?: SvgRasterSize;
-    /** 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. WebGPU path only. When provided, the encoder
-     *  never destroys it. */
-    device?: GPUDevice;
-    adapter?: GPUAdapter;
-    /**
-     * Keep the compressed bytes in a session-scoped in-memory LRU and reuse
-     * them on repeat calls, skipping BOTH the image decode and the encode —
-     * the dominant costs. Re-loading a texture later in the session (e.g.
-     * two worlds sharing an atlas) becomes a few ms. Keyed by source
-     * identity + selected format + encode options; capped at 256 MiB of
-     * compressed bytes by default (`setTranscodeCacheLimit()` to tune) and
-     * never touches persistent storage. Default false.
-     *
-     * URL and Blob/File sources get an identity automatically (URL string or
-     * content hash). Pixel sources (ImageBitmap, canvas, ImageData) are only
-     * cached when `cacheKey` is provided.
-     */
-    cache?: boolean;
-    /**
-     * Explicit cache identity for the source, overriding the derived one.
-     * Use when you already know a stable name (e.g. an asset path) and want
-     * to skip content hashing, or to make pixel sources cacheable.
-     */
-    cacheKey?: string;
-}
-interface CompressResult {
-    /** CompressedTexture on a compressed path; Texture on RGBA8 fallback. */
+/** A `compressTexture()` result: a ready-to-use texture plus the same encode
+ *  metadata `compressTextureToBytes()` returns (minus the raw `levels`). */
+interface CompressResult extends Omit<CompressResult$1, 'levels' | 'fallbackBitmap'> {
+    /** `CompressedTexture` on a compressed path; a plain `Texture` on the 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;
-    /**
-     * Which backend produced the result. 'webgpu' = compute path, 'webgl' =
-     * fragment-shader fallback, 'none' = uncompressed RGBA8.
-     */
-    backend: 'webgpu' | 'webgl' | 'none';
-    /**
-     * 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;
-    /**
-     * Wall-clock time to turn the source into decoded RGBA pixels: fetch /
-     * base64 decode, image decode, SVG rasterisation. Usually the dominant
-     * cost for large images — when a load feels slower than `encodeMs`
-     * suggests, this is where the time went.
-     */
-    decodeMs: number;
-    /** Wall-clock time of the whole `compressTexture()` call: decode + CPU
-     *  mip generation + encode + texture assembly. */
-    totalMs: number;
-    /** True when the result came from the in-memory transcode cache (the
-     *  `cache` option) — no decode or encode ran; decodeMs/encodeMs are 0. */
-    cacheHit: boolean;
-    /** Dispose the texture and release GPU resources owned by this call.
-     *  On the default path (no `device`/`adapter` option) the encoder and
-     *  device are shared across `compressTexture()` calls and survive this —
-     *  release those with `releaseSharedGpuResources()`. */
+    /** Dispose the texture. The shared encoder/device survive — release those
+     *  with `releaseSharedGpuResources()`. */
     destroy(): void;
 }
-/**
- * Destroy the WebGPU device and encoders that `compressTexture()` shares
- * across calls (created lazily when neither the `device` nor the `adapter`
- * option is passed). Safe to call at any time — in-flight encodes on the
- * shared device will fail, and the next `compressTexture()` call recreates
- * everything. No-op when nothing is cached.
- */
-declare function releaseSharedGpuResources(): void;
 declare function compressTexture(source: CompressTextureSource, options?: CompressOptions): Promise<CompressResult>;
 
-/**
- * Cap the cache's total compressed payload in bytes (default 256 MiB).
- * Lower it to evict immediately; 0 disables caching entirely.
- */
-declare function setTranscodeCacheLimit(bytes: number): void;
-/** Drop every cached transcode. Textures already built from entries are unaffected. */
-declare function clearTranscodeCache(): void;
-
 declare class GputexLoader extends Loader<Texture> {
     /** Format-selection hint. Default 'color'. */
     hint: TextureHint;
@@ -230,4 +109,4 @@ interface EncodeToTextureOptions {
  */
 declare function encodeToTexture(encoder: Encoder, source: EncoderImageSource, { colorSpace, flipY }?: EncodeToTextureOptions): Promise<EncodeResult>;
 
-export { type CompressOptions, type CompressResult, type CompressTextureSource, type EncodeResult, type EncodeToTextureOptions, Encoder, EncoderImageSource, FormatQuality, GputexLoader, PreferredFormat, SvgRasterSize, TextureFormat, TextureHint, buildCompressedTexture, clearTranscodeCache, compressTexture, encodeToTexture, releaseSharedGpuResources, setTranscodeCacheLimit, threeFormatFor };
+export { CompressOptions, type CompressResult, CompressTextureSource, type EncodeResult, type EncodeToTextureOptions, Encoder, EncoderImageSource, FormatQuality, GputexLoader, PreferredFormat, SvgRasterSize, TextureFormat, TextureHint, buildCompressedTexture, compressTexture, encodeToTexture, threeFormatFor };