@alexislours/ltd-textures 1.0.0

package/README.md

@@ -0,0 +1,55 @@
+# @alexislours/ltd-textures
+
+Tegra/Switch GPU texture toolkit in WebAssembly: block-linear (de)swizzle, BC1/BC3 transcode, sRGB/linear conversion, and image resize. No bundler assumptions, no Vite magic; you bring the wasm bytes and (optionally) a worker factory.
+
+## Install
+
+```sh
+npm install @alexislours/ltd-textures
+```
+
+## Usage
+
+Portable core. Supply the wasm bytes however your environment loads them:
+
+```ts
+import { createUgcWasm } from '@alexislours/ltd-textures';
+
+const wasm = await createUgcWasm({
+  wasm: fetch(new URL('@alexislours/ltd-textures/ugc.wasm', import.meta.url)),
+});
+const rgba = wasm.bc3Decode(blocks, width, height);
+```
+
+Multi-threaded BC encoding is opt-in via a worker factory. Without one, the
+threaded methods transparently fall back to single-threaded encoding:
+
+```ts
+import UgcWorker from '@alexislours/ltd-textures/worker?worker'; // Vite example
+
+const wasm = await createUgcWasm({
+  wasm: fetch(wasmUrl),
+  createWorker: () => new UgcWorker(),
+});
+await wasm.bc1EncodeThreaded(linRgba, srgbRgba, w, h, mode, threads);
+```
+
+In a Vite/webpack browser app, the `./browser` entry resolves the bundled wasm for you:
+
+```ts
+import { loadUgcWasm } from '@alexislours/ltd-textures/browser';
+import UgcWorker from '@alexislours/ltd-textures/worker?worker'; // Vite example
+
+const wasm = await loadUgcWasm({ createWorker: () => new UgcWorker() });
+```
+
+## Entry points
+
+- `.` the portable `createUgcWasm` API plus `Bc1Mode`/`FitMode`/`Matte`.
+- `./browser` convenience loader that fetches the shipped wasm via `import.meta.url`.
+- `./worker` the BC-encode worker entry (instantiate as a module worker).
+- `./ugc.wasm` the prebuilt binary asset.
+
+## License
+
+AGPL-3.0-or-later

package/dist/bridge.d.ts

@@ -0,0 +1,24 @@
+import { Bc1Mode, FitMode, type Matte } from './types.js';
+import { type CreateWorker } from './threadPool.js';
+export interface UgcWasm {
+    bc1Decode(blocks: Uint8Array, w: number, h: number): Uint8Array;
+    bc3Decode(blocks: Uint8Array, w: number, h: number): Uint8Array;
+    bc1Encode(linRgba: Float32Array, srgbRgba: Uint8Array, w: number, h: number, mode: Bc1Mode): Uint8Array;
+    bc1EncodeRgbcx(linRgba: Float32Array, w: number, h: number): Uint8Array;
+    bc3Encode(linRgba: Float32Array, srgbRgba: Uint8Array, w: number, h: number): Uint8Array;
+    bc1EncodeThreaded(linRgba: Float32Array, srgbRgba: Uint8Array, w: number, h: number, mode: Bc1Mode, threads: number): Promise<Uint8Array>;
+    bc3EncodeThreaded(linRgba: Float32Array, srgbRgba: Uint8Array, w: number, h: number, threads: number): Promise<Uint8Array>;
+    deswizzle(swizzled: Uint8Array, width: number, height: number, bpe: number, blockHeight: number): Uint8Array;
+    swizzle(linear: Uint8Array, width: number, height: number, bpe: number, blockHeight: number, base: Uint8Array | null): Uint8Array;
+    srgbToLinearF32(rgba: Uint8Array): Float32Array;
+    linearF32ToU8(linear: Float32Array): Uint8Array;
+    linearU8ToSrgbU8InPlace(rgba: Uint8Array): void;
+    resize(rgba: Uint8Array, srcW: number, srcH: number, dstW: number, dstH: number, fit: FitMode, matte: Matte | null): Uint8Array;
+    terminateThreadPool(): Promise<void>;
+}
+export type WasmSource = ArrayBuffer | Uint8Array | Response | Promise<ArrayBuffer | Uint8Array | Response>;
+export interface CreateUgcWasmOptions {
+    wasm: WasmSource;
+    createWorker?: CreateWorker;
+}
+export declare function createUgcWasm(options: CreateUgcWasmOptions): Promise<UgcWasm>;

package/dist/browser.d.ts

@@ -0,0 +1,6 @@
+import { type UgcWasm } from './bridge.js';
+import type { CreateWorker } from './threadPool.js';
+export interface BrowserLoadOptions {
+    createWorker?: CreateWorker;
+}
+export declare function loadUgcWasm(options?: BrowserLoadOptions): Promise<UgcWasm>;

package/dist/browser.js

@@ -0,0 +1,16 @@
+import {
+  createUgcWasm
+} from "./chunk-Q7WR2GWO.js";
+
+// src/browser.ts
+var WASM_URL = new URL("../build/ugc.wasm", import.meta.url);
+function loadUgcWasm(options = {}) {
+  return createUgcWasm({
+    wasm: fetch(WASM_URL),
+    createWorker: options.createWorker
+  });
+}
+export {
+  loadUgcWasm
+};
+//# sourceMappingURL=browser.js.map

package/dist/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/browser.ts"],"sourcesContent":["import { createUgcWasm, type UgcWasm } from './bridge.js';\nimport type { CreateWorker } from './threadPool.js';\n\nexport interface BrowserLoadOptions {\n  createWorker?: CreateWorker;\n}\n\nconst WASM_URL = new URL('../build/ugc.wasm', import.meta.url);\n\nexport function loadUgcWasm(options: BrowserLoadOptions = {}): Promise<UgcWasm> {\n  return createUgcWasm({\n    wasm: fetch(WASM_URL),\n    createWorker: options.createWorker,\n  });\n}\n"],"mappings":";;;;;AAOA,IAAM,WAAW,IAAI,IAAI,qBAAqB,YAAY,GAAG;AAEtD,SAAS,YAAY,UAA8B,CAAC,GAAqB;AAC9E,SAAO,cAAc;AAAA,IACnB,MAAM,MAAM,QAAQ;AAAA,IACpB,cAAc,QAAQ;AAAA,EACxB,CAAC;AACH;","names":[]}

package/dist/chunk-Q7WR2GWO.js

@@ -0,0 +1,446 @@
+// src/types.ts
+var Bc1Mode = {
+  Auto: 0,
+  FourColor: 1,
+  ThreeColor: 2
+};
+var FitMode = {
+  Fill: 0,
+  Contain: 1,
+  Cover: 2
+};
+
+// src/threadPool.ts
+var WORKER_INIT_TIMEOUT_MS = 15e3;
+function formatWorkerErrorEvent(e) {
+  const ev = e;
+  const parts = [];
+  if (ev.message) parts.push(ev.message);
+  if (ev.error) {
+    if (ev.error.message && ev.error.message !== ev.message) parts.push(ev.error.message);
+    if (ev.error.stack) parts.push(ev.error.stack);
+  }
+  if (ev.filename) parts.push(`at ${ev.filename}:${ev.lineno}:${ev.colno}`);
+  return parts.length > 0 ? parts.join(" | ") : "unknown worker error";
+}
+function wrapWorker(w) {
+  return {
+    postMessage: (msg, transfer) => w.postMessage(msg, transfer ?? []),
+    setMessageHandler: (cb) => {
+      w.onmessage = (e) => cb(e.data);
+    },
+    setErrorHandler: (cb) => {
+      w.onerror = (e) => cb(formatWorkerErrorEvent(e));
+      w.onmessageerror = () => cb("messageerror");
+    },
+    terminate: () => w.terminate()
+  };
+}
+function createThreadPool(wasmBytes, createWorker) {
+  let pool = null;
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  function rejectAllPending(err) {
+    for (const [id, cb] of pending) {
+      pending.delete(id);
+      cb.reject(err);
+    }
+  }
+  function dispatchListener(msg) {
+    if (msg.type === "done") {
+      const cb = pending.get(msg.id);
+      if (cb) {
+        pending.delete(msg.id);
+        cb.resolve(new Uint8Array(msg.blocks));
+      }
+    } else if (msg.type === "error" && msg.id != null) {
+      const cb = pending.get(msg.id);
+      pending.delete(msg.id);
+      cb?.reject(new Error(msg.error));
+    }
+  }
+  async function bootWorker() {
+    const handle = wrapWorker(createWorker());
+    try {
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          reject(new Error("Worker init timed out"));
+        }, WORKER_INIT_TIMEOUT_MS);
+        const finish = (fn) => {
+          clearTimeout(timer);
+          fn();
+        };
+        handle.setMessageHandler((msg) => {
+          if (msg.type === "ready") {
+            finish(() => {
+              handle.setMessageHandler(dispatchListener);
+              handle.setErrorHandler((err) => rejectAllPending(new Error(`Worker error: ${err}`)));
+              resolve();
+            });
+          } else if (msg.type === "error") {
+            finish(() => reject(new Error(msg.error)));
+          }
+        });
+        handle.setErrorHandler((err) => {
+          finish(() => reject(new Error(`Worker init error: ${err}`)));
+        });
+        handle.postMessage({ type: "init", wasmBytes });
+      });
+    } catch (e) {
+      handle.terminate();
+      throw e;
+    }
+    return handle;
+  }
+  async function ensurePool(threads) {
+    if (pool && pool.length >= threads) return;
+    if (!pool) pool = [];
+    const need = threads - pool.length;
+    if (need <= 0) return;
+    const results = await Promise.allSettled(Array.from({ length: need }, () => bootWorker()));
+    const fulfilled = [];
+    let firstError = null;
+    for (const r of results) {
+      if (r.status === "fulfilled") fulfilled.push(r.value);
+      else if (firstError == null) firstError = r.reason;
+    }
+    if (firstError != null) {
+      for (const h of fulfilled) h.terminate();
+      throw firstError;
+    }
+    pool.push(...fulfilled);
+  }
+  function dispatchEncode(idx, op, linF, srgbU, w, h, mode, transfer) {
+    const id = nextId++;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      pool[idx].postMessage({ type: "encode", id, op, linF, srgbU, w, h, mode }, transfer);
+    });
+  }
+  function partition(blocksY, threads) {
+    const base = Math.floor(blocksY / threads);
+    const extra = blocksY % threads;
+    const out = [];
+    for (let i = 0; i < threads; i++) {
+      const sz = base + (i < extra ? 1 : 0);
+      if (sz > 0) out.push(sz);
+    }
+    return out;
+  }
+  async function encodeThreaded(op, linRgba, srgbRgba, w, h, mode, threads, bytesPerBlock) {
+    if (w % 4 !== 0 || h % 4 !== 0) {
+      throw new Error(`encodeThreaded: width and height must be 4-aligned, got ${w}x${h}`);
+    }
+    await ensurePool(threads);
+    const blocksY = h / 4;
+    const blocksX = w / 4;
+    const sizes = partition(blocksY, threads);
+    const promises = [];
+    let yOff = 0;
+    for (let i = 0; i < sizes.length; i++) {
+      const sliceBlocksY = sizes[i];
+      const slicePxRows = sliceBlocksY * 4;
+      const elemStart = yOff * 4 * w * 4;
+      const elemEnd = (yOff + sliceBlocksY) * 4 * w * 4;
+      const byteStart = yOff * 4 * w * 4;
+      const byteEnd = (yOff + sliceBlocksY) * 4 * w * 4;
+      const linAB = new ArrayBuffer((elemEnd - elemStart) * 4);
+      const linF = new Float32Array(linAB);
+      linF.set(linRgba.subarray(elemStart, elemEnd));
+      const srgbAB = new ArrayBuffer(byteEnd - byteStart);
+      const srgbU = new Uint8Array(srgbAB);
+      srgbU.set(srgbRgba.subarray(byteStart, byteEnd));
+      promises.push(dispatchEncode(i, op, linF, srgbU, w, slicePxRows, mode, [linAB, srgbAB]));
+      yOff += sliceBlocksY;
+    }
+    const parts = await Promise.all(promises);
+    const total = blocksY * blocksX * bytesPerBlock;
+    const out = new Uint8Array(total);
+    let writeOff = 0;
+    for (const p of parts) {
+      out.set(p, writeOff);
+      writeOff += p.byteLength;
+    }
+    return out;
+  }
+  return {
+    bc1Encode(linRgba, srgbRgba, w, h, mode, threads) {
+      return encodeThreaded("bc1", linRgba, srgbRgba, w, h, mode, threads, 8);
+    },
+    bc3Encode(linRgba, srgbRgba, w, h, threads) {
+      return encodeThreaded("bc3", linRgba, srgbRgba, w, h, 0, threads, 16);
+    },
+    async terminate() {
+      rejectAllPending(new Error("Thread pool terminated"));
+      if (!pool) return;
+      for (const w of pool) w.terminate();
+      pool = null;
+    }
+  };
+}
+
+// src/bridge.ts
+function divRoundUp(n, d) {
+  return Math.floor((n + d - 1) / d);
+}
+function paddedSwizzleSize(width, height, bpe, blockHeight) {
+  const widthInGobs = divRoundUp(width * bpe, 64);
+  const paddedHeight = divRoundUp(height, 8 * blockHeight) * (8 * blockHeight);
+  return widthInGobs * paddedHeight * 64;
+}
+var importObject = {
+  env: {
+    abort() {
+      throw new Error("ugc.wasm aborted");
+    }
+  }
+};
+async function toBytes(src) {
+  const s = await src;
+  if (s instanceof ArrayBuffer) return s;
+  if (typeof Response !== "undefined" && s instanceof Response) return await s.arrayBuffer();
+  if (s instanceof Uint8Array) {
+    return s.buffer.slice(s.byteOffset, s.byteOffset + s.byteLength);
+  }
+  throw new Error("createUgcWasm: unsupported wasm source");
+}
+function makeWasm(instance, pool) {
+  const exports = instance.exports;
+  const memory = exports.memory;
+  function u8(ptr, len) {
+    return new Uint8Array(memory.buffer, ptr, len);
+  }
+  function f32(ptr, len) {
+    return new Float32Array(memory.buffer, ptr, len);
+  }
+  function bc1Encode(linRgba, srgbRgba, w, h, mode) {
+    const m = exports.mark();
+    try {
+      const pixels = w * h;
+      const linLen = pixels * 16;
+      const srgbLen = pixels * 4;
+      const outLen = pixels / 16 * 8;
+      const linPtr = exports.alloc(linLen);
+      const srgbPtr = exports.alloc(srgbLen);
+      const outPtr = exports.alloc(outLen);
+      f32(linPtr, pixels * 4).set(linRgba);
+      u8(srgbPtr, srgbLen).set(srgbRgba);
+      exports.bc1Encode(linPtr, srgbPtr, outPtr, w, h, mode);
+      const out = new Uint8Array(outLen);
+      out.set(u8(outPtr, outLen));
+      return out;
+    } finally {
+      exports.release(m);
+    }
+  }
+  function bc3Encode(linRgba, srgbRgba, w, h) {
+    const m = exports.mark();
+    try {
+      const pixels = w * h;
+      const linLen = pixels * 16;
+      const srgbLen = pixels * 4;
+      const outLen = pixels / 16 * 16;
+      const linPtr = exports.alloc(linLen);
+      const srgbPtr = exports.alloc(srgbLen);
+      const outPtr = exports.alloc(outLen);
+      f32(linPtr, pixels * 4).set(linRgba);
+      u8(srgbPtr, srgbLen).set(srgbRgba);
+      exports.bc3Encode(linPtr, srgbPtr, outPtr, w, h);
+      const out = new Uint8Array(outLen);
+      out.set(u8(outPtr, outLen));
+      return out;
+    } finally {
+      exports.release(m);
+    }
+  }
+  return {
+    bc1Decode(blocks, w, h) {
+      const m = exports.mark();
+      try {
+        const inLen = blocks.byteLength;
+        const outLen = w * h * 4;
+        const inPtr = exports.alloc(inLen);
+        const outPtr = exports.alloc(outLen);
+        u8(inPtr, inLen).set(blocks);
+        exports.bc1Decode(inPtr, outPtr, w, h);
+        const out = new Uint8Array(outLen);
+        out.set(u8(outPtr, outLen));
+        return out;
+      } finally {
+        exports.release(m);
+      }
+    },
+    bc3Decode(blocks, w, h) {
+      const m = exports.mark();
+      try {
+        const inLen = blocks.byteLength;
+        const outLen = w * h * 4;
+        const inPtr = exports.alloc(inLen);
+        const outPtr = exports.alloc(outLen);
+        u8(inPtr, inLen).set(blocks);
+        exports.bc3Decode(inPtr, outPtr, w, h);
+        const out = new Uint8Array(outLen);
+        out.set(u8(outPtr, outLen));
+        return out;
+      } finally {
+        exports.release(m);
+      }
+    },
+    bc1Encode,
+    bc1EncodeRgbcx(linRgba, w, h) {
+      const m = exports.mark();
+      try {
+        const pixels = w * h;
+        const linLen = pixels * 16;
+        const outLen = pixels / 16 * 8;
+        const linPtr = exports.alloc(linLen);
+        const outPtr = exports.alloc(outLen);
+        f32(linPtr, pixels * 4).set(linRgba);
+        exports.bc1EncodeRgbcx(linPtr, outPtr, w, h);
+        const out = new Uint8Array(outLen);
+        out.set(u8(outPtr, outLen));
+        return out;
+      } finally {
+        exports.release(m);
+      }
+    },
+    bc3Encode,
+    bc1EncodeThreaded(linRgba, srgbRgba, w, h, mode, threads) {
+      if (pool) return pool.bc1Encode(linRgba, srgbRgba, w, h, mode, threads);
+      return Promise.resolve(bc1Encode(linRgba, srgbRgba, w, h, mode));
+    },
+    bc3EncodeThreaded(linRgba, srgbRgba, w, h, threads) {
+      if (pool) return pool.bc3Encode(linRgba, srgbRgba, w, h, threads);
+      return Promise.resolve(bc3Encode(linRgba, srgbRgba, w, h));
+    },
+    deswizzle(swizzled, width, height, bpe, blockHeight) {
+      const m = exports.mark();
+      try {
+        const inLen = swizzled.byteLength;
+        const outLen = width * height * bpe;
+        const inPtr = exports.alloc(inLen);
+        const outPtr = exports.alloc(outLen);
+        u8(inPtr, inLen).set(swizzled);
+        exports.deswizzleBlockLinear(inPtr, inLen, outPtr, width, height, bpe, blockHeight);
+        const out = new Uint8Array(outLen);
+        out.set(u8(outPtr, outLen));
+        return out;
+      } finally {
+        exports.release(m);
+      }
+    },
+    swizzle(linear, width, height, bpe, blockHeight, base) {
+      const m = exports.mark();
+      try {
+        const inLen = linear.byteLength;
+        const outLen = paddedSwizzleSize(width, height, bpe, blockHeight);
+        const useBase = base != null && base.byteLength === outLen;
+        const baseLen = useBase ? base.byteLength : 0;
+        const inPtr = exports.alloc(inLen);
+        const outPtr = exports.alloc(outLen);
+        const basePtr = useBase ? exports.alloc(baseLen) : 0;
+        u8(inPtr, inLen).set(linear);
+        if (useBase) u8(basePtr, baseLen).set(base);
+        exports.swizzleBlockLinear(
+          inPtr,
+          inLen,
+          outPtr,
+          outLen,
+          width,
+          height,
+          bpe,
+          blockHeight,
+          basePtr,
+          baseLen
+        );
+        const out = new Uint8Array(outLen);
+        out.set(u8(outPtr, outLen));
+        return out;
+      } finally {
+        exports.release(m);
+      }
+    },
+    srgbToLinearF32(rgba) {
+      const m = exports.mark();
+      try {
+        const pixels = rgba.byteLength / 4;
+        const inLen = rgba.byteLength;
+        const outLen = pixels * 16;
+        const inPtr = exports.alloc(inLen);
+        const outPtr = exports.alloc(outLen);
+        u8(inPtr, inLen).set(rgba);
+        exports.srgbU8ToLinearF32(inPtr, outPtr, pixels);
+        const out = new Float32Array(pixels * 4);
+        out.set(f32(outPtr, pixels * 4));
+        return out;
+      } finally {
+        exports.release(m);
+      }
+    },
+    linearF32ToU8(linear) {
+      const m = exports.mark();
+      try {
+        const count = linear.length;
+        const inLen = count * 4;
+        const outLen = count;
+        const inPtr = exports.alloc(inLen);
+        const outPtr = exports.alloc(outLen);
+        f32(inPtr, count).set(linear);
+        exports.linearF32ToLinearU8(inPtr, outPtr, count);
+        const out = new Uint8Array(outLen);
+        out.set(u8(outPtr, outLen));
+        return out;
+      } finally {
+        exports.release(m);
+      }
+    },
+    linearU8ToSrgbU8InPlace(rgba) {
+      const m = exports.mark();
+      try {
+        const len = rgba.byteLength;
+        const ptr = exports.alloc(len);
+        u8(ptr, len).set(rgba);
+        exports.convertLinearU8ToSrgbU8(ptr, len);
+        rgba.set(u8(ptr, len));
+      } finally {
+        exports.release(m);
+      }
+    },
+    resize(rgba, srcW, srcH, dstW, dstH, fit, matte) {
+      const m = exports.mark();
+      try {
+        const inLen = srcW * srcH * 4;
+        const outLen = dstW * dstH * 4;
+        const inPtr = exports.alloc(inLen);
+        const outPtr = exports.alloc(outLen);
+        u8(inPtr, inLen).set(rgba);
+        const mr = matte ? matte.r : 0;
+        const mg = matte ? matte.g : 0;
+        const mb = matte ? matte.b : 0;
+        const ma = matte ? matte.a : 0;
+        exports.resizeRgba(inPtr, srcW, srcH, outPtr, dstW, dstH, fit, mr, mg, mb, ma);
+        const out = new Uint8Array(outLen);
+        out.set(u8(outPtr, outLen));
+        return out;
+      } finally {
+        exports.release(m);
+      }
+    },
+    async terminateThreadPool() {
+      if (pool) await pool.terminate();
+    }
+  };
+}
+async function createUgcWasm(options) {
+  const bytes = await toBytes(options.wasm);
+  const { instance } = await WebAssembly.instantiate(bytes, importObject);
+  const pool = options.createWorker ? createThreadPool(bytes, options.createWorker) : null;
+  return makeWasm(instance, pool);
+}
+
+export {
+  Bc1Mode,
+  FitMode,
+  createUgcWasm
+};
+//# sourceMappingURL=chunk-Q7WR2GWO.js.map

package/dist/chunk-Q7WR2GWO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts","../src/threadPool.ts","../src/bridge.ts"],"sourcesContent":["export const Bc1Mode = {\n  Auto: 0,\n  FourColor: 1,\n  ThreeColor: 2,\n} as const;\nexport type Bc1Mode = (typeof Bc1Mode)[keyof typeof Bc1Mode];\n\nexport const FitMode = {\n  Fill: 0,\n  Contain: 1,\n  Cover: 2,\n} as const;\nexport type FitMode = (typeof FitMode)[keyof typeof FitMode];\n\nexport type Matte = { r: number; g: number; b: number; a: number };\n","import { Bc1Mode } from './types.js';\n\nexport type WorkerLike = {\n  postMessage(msg: unknown, transfer?: Transferable[]): void;\n  onmessage: ((e: MessageEvent) => void) | null;\n  onerror: ((e: ErrorEvent) => void) | null;\n  onmessageerror?: ((e: MessageEvent) => void) | null;\n  terminate(): void;\n};\n\nexport type CreateWorker = () => WorkerLike;\n\ntype WorkerHandle = {\n  postMessage(msg: unknown, transfer?: Transferable[]): void;\n  setMessageHandler(cb: (msg: WorkerMessage) => void): void;\n  setErrorHandler(cb: (err: unknown) => void): void;\n  terminate(): void;\n};\n\ntype WorkerMessage =\n  | { type: 'ready' }\n  | { type: 'done'; id: number; blocks: ArrayBuffer }\n  | { type: 'error'; id?: number; error: string };\n\nexport type ThreadPool = {\n  bc1Encode(\n    linRgba: Float32Array,\n    srgbRgba: Uint8Array,\n    w: number,\n    h: number,\n    mode: Bc1Mode,\n    threads: number,\n  ): Promise<Uint8Array>;\n  bc3Encode(\n    linRgba: Float32Array,\n    srgbRgba: Uint8Array,\n    w: number,\n    h: number,\n    threads: number,\n  ): Promise<Uint8Array>;\n  terminate(): Promise<void>;\n};\n\nconst WORKER_INIT_TIMEOUT_MS = 15000;\n\nfunction formatWorkerErrorEvent(e: unknown): string {\n  const ev = e as Partial<ErrorEvent> & { error?: { message?: string; stack?: string } };\n  const parts: string[] = [];\n  if (ev.message) parts.push(ev.message);\n  if (ev.error) {\n    if (ev.error.message && ev.error.message !== ev.message) parts.push(ev.error.message);\n    if (ev.error.stack) parts.push(ev.error.stack);\n  }\n  if (ev.filename) parts.push(`at ${ev.filename}:${ev.lineno}:${ev.colno}`);\n  return parts.length > 0 ? parts.join(' | ') : 'unknown worker error';\n}\n\nfunction wrapWorker(w: WorkerLike): WorkerHandle {\n  return {\n    postMessage: (msg, transfer) => w.postMessage(msg, transfer ?? []),\n    setMessageHandler: (cb) => {\n      w.onmessage = (e: MessageEvent) => cb(e.data as WorkerMessage);\n    },\n    setErrorHandler: (cb) => {\n      w.onerror = (e: unknown) => cb(formatWorkerErrorEvent(e));\n      w.onmessageerror = () => cb('messageerror');\n    },\n    terminate: () => w.terminate(),\n  };\n}\n\nexport function createThreadPool(wasmBytes: ArrayBuffer, createWorker: CreateWorker): ThreadPool {\n  let pool: WorkerHandle[] | null = null;\n  let nextId = 1;\n  type Pending = { resolve: (out: Uint8Array) => void; reject: (err: unknown) => void };\n  const pending = new Map<number, Pending>();\n\n  function rejectAllPending(err: unknown): void {\n    for (const [id, cb] of pending) {\n      pending.delete(id);\n      cb.reject(err);\n    }\n  }\n\n  function dispatchListener(msg: WorkerMessage): void {\n    if (msg.type === 'done') {\n      const cb = pending.get(msg.id);\n      if (cb) {\n        pending.delete(msg.id);\n        cb.resolve(new Uint8Array(msg.blocks));\n      }\n    } else if (msg.type === 'error' && msg.id != null) {\n      const cb = pending.get(msg.id);\n      pending.delete(msg.id);\n      cb?.reject(new Error(msg.error));\n    }\n  }\n\n  async function bootWorker(): Promise<WorkerHandle> {\n    const handle = wrapWorker(createWorker());\n    try {\n      await new Promise<void>((resolve, reject) => {\n        const timer = setTimeout(() => {\n          reject(new Error('Worker init timed out'));\n        }, WORKER_INIT_TIMEOUT_MS);\n        const finish = (fn: () => void): void => {\n          clearTimeout(timer);\n          fn();\n        };\n        handle.setMessageHandler((msg) => {\n          if (msg.type === 'ready') {\n            finish(() => {\n              handle.setMessageHandler(dispatchListener);\n              handle.setErrorHandler((err) => rejectAllPending(new Error(`Worker error: ${err}`)));\n              resolve();\n            });\n          } else if (msg.type === 'error') {\n            finish(() => reject(new Error(msg.error)));\n          }\n        });\n        handle.setErrorHandler((err) => {\n          finish(() => reject(new Error(`Worker init error: ${err}`)));\n        });\n        handle.postMessage({ type: 'init', wasmBytes });\n      });\n    } catch (e) {\n      handle.terminate();\n      throw e;\n    }\n    return handle;\n  }\n\n  async function ensurePool(threads: number): Promise<void> {\n    if (pool && pool.length >= threads) return;\n    if (!pool) pool = [];\n    const need = threads - pool.length;\n    if (need <= 0) return;\n    const results = await Promise.allSettled(Array.from({ length: need }, () => bootWorker()));\n    const fulfilled: WorkerHandle[] = [];\n    let firstError: unknown = null;\n    for (const r of results) {\n      if (r.status === 'fulfilled') fulfilled.push(r.value);\n      else if (firstError == null) firstError = r.reason;\n    }\n    if (firstError != null) {\n      for (const h of fulfilled) h.terminate();\n      throw firstError;\n    }\n    pool.push(...fulfilled);\n  }\n\n  function dispatchEncode(\n    idx: number,\n    op: 'bc1' | 'bc3',\n    linF: Float32Array,\n    srgbU: Uint8Array,\n    w: number,\n    h: number,\n    mode: number,\n    transfer: Transferable[],\n  ): Promise<Uint8Array> {\n    const id = nextId++;\n    return new Promise<Uint8Array>((resolve, reject) => {\n      pending.set(id, { resolve, reject });\n      pool![idx].postMessage({ type: 'encode', id, op, linF, srgbU, w, h, mode }, transfer);\n    });\n  }\n\n  function partition(blocksY: number, threads: number): number[] {\n    const base = Math.floor(blocksY / threads);\n    const extra = blocksY % threads;\n    const out: number[] = [];\n    for (let i = 0; i < threads; i++) {\n      const sz = base + (i < extra ? 1 : 0);\n      if (sz > 0) out.push(sz);\n    }\n    return out;\n  }\n\n  async function encodeThreaded(\n    op: 'bc1' | 'bc3',\n    linRgba: Float32Array,\n    srgbRgba: Uint8Array,\n    w: number,\n    h: number,\n    mode: number,\n    threads: number,\n    bytesPerBlock: number,\n  ): Promise<Uint8Array> {\n    if (w % 4 !== 0 || h % 4 !== 0) {\n      throw new Error(`encodeThreaded: width and height must be 4-aligned, got ${w}x${h}`);\n    }\n    await ensurePool(threads);\n    const blocksY = h / 4;\n    const blocksX = w / 4;\n    const sizes = partition(blocksY, threads);\n    const promises: Promise<Uint8Array>[] = [];\n    let yOff = 0;\n    for (let i = 0; i < sizes.length; i++) {\n      const sliceBlocksY = sizes[i];\n      const slicePxRows = sliceBlocksY * 4;\n      const elemStart = yOff * 4 * w * 4;\n      const elemEnd = (yOff + sliceBlocksY) * 4 * w * 4;\n      const byteStart = yOff * 4 * w * 4;\n      const byteEnd = (yOff + sliceBlocksY) * 4 * w * 4;\n      const linAB = new ArrayBuffer((elemEnd - elemStart) * 4);\n      const linF = new Float32Array(linAB);\n      linF.set(linRgba.subarray(elemStart, elemEnd));\n      const srgbAB = new ArrayBuffer(byteEnd - byteStart);\n      const srgbU = new Uint8Array(srgbAB);\n      srgbU.set(srgbRgba.subarray(byteStart, byteEnd));\n      promises.push(dispatchEncode(i, op, linF, srgbU, w, slicePxRows, mode, [linAB, srgbAB]));\n      yOff += sliceBlocksY;\n    }\n    const parts = await Promise.all(promises);\n    const total = blocksY * blocksX * bytesPerBlock;\n    const out = new Uint8Array(total);\n    let writeOff = 0;\n    for (const p of parts) {\n      out.set(p, writeOff);\n      writeOff += p.byteLength;\n    }\n    return out;\n  }\n\n  return {\n    bc1Encode(linRgba, srgbRgba, w, h, mode, threads) {\n      return encodeThreaded('bc1', linRgba, srgbRgba, w, h, mode, threads, 8);\n    },\n    bc3Encode(linRgba, srgbRgba, w, h, threads) {\n      return encodeThreaded('bc3', linRgba, srgbRgba, w, h, 0, threads, 16);\n    },\n    async terminate() {\n      rejectAllPending(new Error('Thread pool terminated'));\n      if (!pool) return;\n      for (const w of pool) w.terminate();\n      pool = null;\n    },\n  };\n}\n","import { Bc1Mode, FitMode, type Matte } from './types.js';\nimport { createThreadPool, type CreateWorker, type ThreadPool } from './threadPool.js';\n\ninterface UgcWasmExports {\n  memory: WebAssembly.Memory;\n  alloc(size: number): number;\n  mark(): number;\n  release(m: number): void;\n  free(ptr: number): void;\n  deswizzleBlockLinear(\n    srcPtr: number,\n    srcLen: number,\n    dstPtr: number,\n    width: number,\n    height: number,\n    bpe: number,\n    blockHeight: number,\n  ): void;\n  swizzleBlockLinear(\n    srcPtr: number,\n    srcLen: number,\n    dstPtr: number,\n    dstLen: number,\n    width: number,\n    height: number,\n    bpe: number,\n    blockHeight: number,\n    basePtr: number,\n    baseLen: number,\n  ): void;\n  srgbU8ToLinearF32(srcPtr: number, dstPtr: number, pixelCount: number): void;\n  linearF32ToLinearU8(srcPtr: number, dstPtr: number, count: number): void;\n  convertLinearU8ToSrgbU8(rgbaPtr: number, byteLen: number): void;\n  bc1Decode(blocksPtr: number, dstPtr: number, texW: number, texH: number): void;\n  bc3Decode(blocksPtr: number, dstPtr: number, texW: number, texH: number): void;\n  bc1Encode(\n    linRgbaPtr: number,\n    srgbRgbaPtr: number,\n    dstPtr: number,\n    texW: number,\n    texH: number,\n    bc1Mode: number,\n  ): void;\n  bc1EncodeRgbcx(linRgbaPtr: number, dstPtr: number, texW: number, texH: number): void;\n  bc3Encode(\n    linRgbaPtr: number,\n    srgbRgbaPtr: number,\n    dstPtr: number,\n    texW: number,\n    texH: number,\n  ): void;\n  resizeRgba(\n    srcPtr: number,\n    srcW: number,\n    srcH: number,\n    dstPtr: number,\n    dstW: number,\n    dstH: number,\n    fitMode: number,\n    matteR: number,\n    matteG: number,\n    matteB: number,\n    matteA: number,\n  ): void;\n}\n\nexport interface UgcWasm {\n  bc1Decode(blocks: Uint8Array, w: number, h: number): Uint8Array;\n  bc3Decode(blocks: Uint8Array, w: number, h: number): Uint8Array;\n  bc1Encode(\n    linRgba: Float32Array,\n    srgbRgba: Uint8Array,\n    w: number,\n    h: number,\n    mode: Bc1Mode,\n  ): Uint8Array;\n  bc1EncodeRgbcx(linRgba: Float32Array, w: number, h: number): Uint8Array;\n  bc3Encode(linRgba: Float32Array, srgbRgba: Uint8Array, w: number, h: number): Uint8Array;\n  bc1EncodeThreaded(\n    linRgba: Float32Array,\n    srgbRgba: Uint8Array,\n    w: number,\n    h: number,\n    mode: Bc1Mode,\n    threads: number,\n  ): Promise<Uint8Array>;\n  bc3EncodeThreaded(\n    linRgba: Float32Array,\n    srgbRgba: Uint8Array,\n    w: number,\n    h: number,\n    threads: number,\n  ): Promise<Uint8Array>;\n  deswizzle(\n    swizzled: Uint8Array,\n    width: number,\n    height: number,\n    bpe: number,\n    blockHeight: number,\n  ): Uint8Array;\n  swizzle(\n    linear: Uint8Array,\n    width: number,\n    height: number,\n    bpe: number,\n    blockHeight: number,\n    base: Uint8Array | null,\n  ): Uint8Array;\n  srgbToLinearF32(rgba: Uint8Array): Float32Array;\n  linearF32ToU8(linear: Float32Array): Uint8Array;\n  linearU8ToSrgbU8InPlace(rgba: Uint8Array): void;\n  resize(\n    rgba: Uint8Array,\n    srcW: number,\n    srcH: number,\n    dstW: number,\n    dstH: number,\n    fit: FitMode,\n    matte: Matte | null,\n  ): Uint8Array;\n  terminateThreadPool(): Promise<void>;\n}\n\nexport type WasmSource =\n  | ArrayBuffer\n  | Uint8Array\n  | Response\n  | Promise<ArrayBuffer | Uint8Array | Response>;\n\nexport interface CreateUgcWasmOptions {\n  wasm: WasmSource;\n  createWorker?: CreateWorker;\n}\n\nfunction divRoundUp(n: number, d: number): number {\n  return Math.floor((n + d - 1) / d);\n}\n\nfunction paddedSwizzleSize(\n  width: number,\n  height: number,\n  bpe: number,\n  blockHeight: number,\n): number {\n  const widthInGobs = divRoundUp(width * bpe, 64);\n  const paddedHeight = divRoundUp(height, 8 * blockHeight) * (8 * blockHeight);\n  return widthInGobs * paddedHeight * 64;\n}\n\nconst importObject: WebAssembly.Imports = {\n  env: {\n    abort() {\n      throw new Error('ugc.wasm aborted');\n    },\n  },\n};\n\nasync function toBytes(src: WasmSource): Promise<ArrayBuffer> {\n  const s = await src;\n  if (s instanceof ArrayBuffer) return s;\n  if (typeof Response !== 'undefined' && s instanceof Response) return await s.arrayBuffer();\n  if (s instanceof Uint8Array) {\n    return s.buffer.slice(s.byteOffset, s.byteOffset + s.byteLength) as ArrayBuffer;\n  }\n  throw new Error('createUgcWasm: unsupported wasm source');\n}\n\nfunction makeWasm(instance: WebAssembly.Instance, pool: ThreadPool | null): UgcWasm {\n  const exports = instance.exports as unknown as UgcWasmExports;\n  const memory = exports.memory;\n\n  function u8(ptr: number, len: number): Uint8Array {\n    return new Uint8Array(memory.buffer, ptr, len);\n  }\n  function f32(ptr: number, len: number): Float32Array {\n    return new Float32Array(memory.buffer, ptr, len);\n  }\n\n  function bc1Encode(\n    linRgba: Float32Array,\n    srgbRgba: Uint8Array,\n    w: number,\n    h: number,\n    mode: Bc1Mode,\n  ): Uint8Array {\n    const m = exports.mark();\n    try {\n      const pixels = w * h;\n      const linLen = pixels * 16;\n      const srgbLen = pixels * 4;\n      const outLen = (pixels / 16) * 8;\n      const linPtr = exports.alloc(linLen);\n      const srgbPtr = exports.alloc(srgbLen);\n      const outPtr = exports.alloc(outLen);\n      f32(linPtr, pixels * 4).set(linRgba);\n      u8(srgbPtr, srgbLen).set(srgbRgba);\n      exports.bc1Encode(linPtr, srgbPtr, outPtr, w, h, mode);\n      const out = new Uint8Array(outLen);\n      out.set(u8(outPtr, outLen));\n      return out;\n    } finally {\n      exports.release(m);\n    }\n  }\n\n  function bc3Encode(\n    linRgba: Float32Array,\n    srgbRgba: Uint8Array,\n    w: number,\n    h: number,\n  ): Uint8Array {\n    const m = exports.mark();\n    try {\n      const pixels = w * h;\n      const linLen = pixels * 16;\n      const srgbLen = pixels * 4;\n      const outLen = (pixels / 16) * 16;\n      const linPtr = exports.alloc(linLen);\n      const srgbPtr = exports.alloc(srgbLen);\n      const outPtr = exports.alloc(outLen);\n      f32(linPtr, pixels * 4).set(linRgba);\n      u8(srgbPtr, srgbLen).set(srgbRgba);\n      exports.bc3Encode(linPtr, srgbPtr, outPtr, w, h);\n      const out = new Uint8Array(outLen);\n      out.set(u8(outPtr, outLen));\n      return out;\n    } finally {\n      exports.release(m);\n    }\n  }\n\n  return {\n    bc1Decode(blocks, w, h) {\n      const m = exports.mark();\n      try {\n        const inLen = blocks.byteLength;\n        const outLen = w * h * 4;\n        const inPtr = exports.alloc(inLen);\n        const outPtr = exports.alloc(outLen);\n        u8(inPtr, inLen).set(blocks);\n        exports.bc1Decode(inPtr, outPtr, w, h);\n        const out = new Uint8Array(outLen);\n        out.set(u8(outPtr, outLen));\n        return out;\n      } finally {\n        exports.release(m);\n      }\n    },\n    bc3Decode(blocks, w, h) {\n      const m = exports.mark();\n      try {\n        const inLen = blocks.byteLength;\n        const outLen = w * h * 4;\n        const inPtr = exports.alloc(inLen);\n        const outPtr = exports.alloc(outLen);\n        u8(inPtr, inLen).set(blocks);\n        exports.bc3Decode(inPtr, outPtr, w, h);\n        const out = new Uint8Array(outLen);\n        out.set(u8(outPtr, outLen));\n        return out;\n      } finally {\n        exports.release(m);\n      }\n    },\n    bc1Encode,\n    bc1EncodeRgbcx(linRgba, w, h) {\n      const m = exports.mark();\n      try {\n        const pixels = w * h;\n        const linLen = pixels * 16;\n        const outLen = (pixels / 16) * 8;\n        const linPtr = exports.alloc(linLen);\n        const outPtr = exports.alloc(outLen);\n        f32(linPtr, pixels * 4).set(linRgba);\n        exports.bc1EncodeRgbcx(linPtr, outPtr, w, h);\n        const out = new Uint8Array(outLen);\n        out.set(u8(outPtr, outLen));\n        return out;\n      } finally {\n        exports.release(m);\n      }\n    },\n    bc3Encode,\n    bc1EncodeThreaded(linRgba, srgbRgba, w, h, mode, threads) {\n      if (pool) return pool.bc1Encode(linRgba, srgbRgba, w, h, mode, threads);\n      return Promise.resolve(bc1Encode(linRgba, srgbRgba, w, h, mode));\n    },\n    bc3EncodeThreaded(linRgba, srgbRgba, w, h, threads) {\n      if (pool) return pool.bc3Encode(linRgba, srgbRgba, w, h, threads);\n      return Promise.resolve(bc3Encode(linRgba, srgbRgba, w, h));\n    },\n    deswizzle(swizzled, width, height, bpe, blockHeight) {\n      const m = exports.mark();\n      try {\n        const inLen = swizzled.byteLength;\n        const outLen = width * height * bpe;\n        const inPtr = exports.alloc(inLen);\n        const outPtr = exports.alloc(outLen);\n        u8(inPtr, inLen).set(swizzled);\n        exports.deswizzleBlockLinear(inPtr, inLen, outPtr, width, height, bpe, blockHeight);\n        const out = new Uint8Array(outLen);\n        out.set(u8(outPtr, outLen));\n        return out;\n      } finally {\n        exports.release(m);\n      }\n    },\n    swizzle(linear, width, height, bpe, blockHeight, base) {\n      const m = exports.mark();\n      try {\n        const inLen = linear.byteLength;\n        const outLen = paddedSwizzleSize(width, height, bpe, blockHeight);\n        const useBase = base != null && base.byteLength === outLen;\n        const baseLen = useBase ? base!.byteLength : 0;\n        const inPtr = exports.alloc(inLen);\n        const outPtr = exports.alloc(outLen);\n        const basePtr = useBase ? exports.alloc(baseLen) : 0;\n        u8(inPtr, inLen).set(linear);\n        if (useBase) u8(basePtr, baseLen).set(base!);\n        exports.swizzleBlockLinear(\n          inPtr,\n          inLen,\n          outPtr,\n          outLen,\n          width,\n          height,\n          bpe,\n          blockHeight,\n          basePtr,\n          baseLen,\n        );\n        const out = new Uint8Array(outLen);\n        out.set(u8(outPtr, outLen));\n        return out;\n      } finally {\n        exports.release(m);\n      }\n    },\n    srgbToLinearF32(rgba) {\n      const m = exports.mark();\n      try {\n        const pixels = rgba.byteLength / 4;\n        const inLen = rgba.byteLength;\n        const outLen = pixels * 16;\n        const inPtr = exports.alloc(inLen);\n        const outPtr = exports.alloc(outLen);\n        u8(inPtr, inLen).set(rgba);\n        exports.srgbU8ToLinearF32(inPtr, outPtr, pixels);\n        const out = new Float32Array(pixels * 4);\n        out.set(f32(outPtr, pixels * 4));\n        return out;\n      } finally {\n        exports.release(m);\n      }\n    },\n    linearF32ToU8(linear) {\n      const m = exports.mark();\n      try {\n        const count = linear.length;\n        const inLen = count * 4;\n        const outLen = count;\n        const inPtr = exports.alloc(inLen);\n        const outPtr = exports.alloc(outLen);\n        f32(inPtr, count).set(linear);\n        exports.linearF32ToLinearU8(inPtr, outPtr, count);\n        const out = new Uint8Array(outLen);\n        out.set(u8(outPtr, outLen));\n        return out;\n      } finally {\n        exports.release(m);\n      }\n    },\n    linearU8ToSrgbU8InPlace(rgba) {\n      const m = exports.mark();\n      try {\n        const len = rgba.byteLength;\n        const ptr = exports.alloc(len);\n        u8(ptr, len).set(rgba);\n        exports.convertLinearU8ToSrgbU8(ptr, len);\n        rgba.set(u8(ptr, len));\n      } finally {\n        exports.release(m);\n      }\n    },\n    resize(rgba, srcW, srcH, dstW, dstH, fit, matte) {\n      const m = exports.mark();\n      try {\n        const inLen = srcW * srcH * 4;\n        const outLen = dstW * dstH * 4;\n        const inPtr = exports.alloc(inLen);\n        const outPtr = exports.alloc(outLen);\n        u8(inPtr, inLen).set(rgba);\n        const mr = matte ? matte.r : 0;\n        const mg = matte ? matte.g : 0;\n        const mb = matte ? matte.b : 0;\n        const ma = matte ? matte.a : 0;\n        exports.resizeRgba(inPtr, srcW, srcH, outPtr, dstW, dstH, fit, mr, mg, mb, ma);\n        const out = new Uint8Array(outLen);\n        out.set(u8(outPtr, outLen));\n        return out;\n      } finally {\n        exports.release(m);\n      }\n    },\n    async terminateThreadPool() {\n      if (pool) await pool.terminate();\n    },\n  };\n}\n\nexport async function createUgcWasm(options: CreateUgcWasmOptions): Promise<UgcWasm> {\n  const bytes = await toBytes(options.wasm);\n  const { instance } = await WebAssembly.instantiate(bytes, importObject);\n  const pool = options.createWorker ? createThreadPool(bytes, options.createWorker) : null;\n  return makeWasm(instance, pool);\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createUgcWasm, type UgcWasm, type WasmSource, type CreateUgcWasmOptions, } from './bridge.js';
+export { type CreateWorker, type WorkerLike, type ThreadPool } from './threadPool.js';
+export { Bc1Mode, FitMode, type Matte } from './types.js';

package/dist/index.js

@@ -0,0 +1,11 @@
+import {
+  Bc1Mode,
+  FitMode,
+  createUgcWasm
+} from "./chunk-Q7WR2GWO.js";
+export {
+  Bc1Mode,
+  FitMode,
+  createUgcWasm
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/threadPool.d.ts

@@ -0,0 +1,15 @@
+import { Bc1Mode } from './types.js';
+export type WorkerLike = {
+    postMessage(msg: unknown, transfer?: Transferable[]): void;
+    onmessage: ((e: MessageEvent) => void) | null;
+    onerror: ((e: ErrorEvent) => void) | null;
+    onmessageerror?: ((e: MessageEvent) => void) | null;
+    terminate(): void;
+};
+export type CreateWorker = () => WorkerLike;
+export type ThreadPool = {
+    bc1Encode(linRgba: Float32Array, srgbRgba: Uint8Array, w: number, h: number, mode: Bc1Mode, threads: number): Promise<Uint8Array>;
+    bc3Encode(linRgba: Float32Array, srgbRgba: Uint8Array, w: number, h: number, threads: number): Promise<Uint8Array>;
+    terminate(): Promise<void>;
+};
+export declare function createThreadPool(wasmBytes: ArrayBuffer, createWorker: CreateWorker): ThreadPool;