raw-webgpu 0.1.0-alpha.2 → 0.1.0

package/README.md

@@ -10,15 +10,15 @@ LibRaw, Adobe DNG SDK and libjxl decode files in a WASM worker. Simple TIFF stri
 - GPU Bayer and X-Trans demosaic, with library CPU preparation for special layouts and mandatory DNG corrections.
 - Absolute temperature/tint and initial white-balance restoration without decoding again.
 - HDR output, camera calibration, orientation and explicit resource disposal.
-- Experimental TIFF support with ICC matrix/TRC profiles and alpha.
+- TIFF support with ICC matrix/TRC profiles and alpha.
 
 ## Installation
 
 ```sh
-npm install --save-exact raw-webgpu@0.1.0-alpha.2
+npm install --save-exact raw-webgpu@0.1.0
 ```
 
-WASM, workers and types are included; consumers do not compile C++. Use a WebGPU browser with WASM SIMD/exception support and a bundler that handles worker/WASM asset URLs, such as Vite. Older TypeScript versions may need `@webgpu/types` in `compilerOptions.types`.
+WASM, workers and types are included; consumers do not compile C++. Use a WebGPU browser with WASM SIMD/exception support and a bundler that handles worker/WASM asset URLs, such as Vite. TypeScript 5.9 and newer are tested; with TypeScript 5.9, install `@webgpu/types` and include it in `compilerOptions.types`.
 
 ## Usage
 
@@ -61,15 +61,28 @@ Use separate passes for independent previews or exports. If passing an external
 
 For file export, see the [Bun PNG/JPEG/BMP conversion example](docs/conversion.md).
 
+
+## API contract and support
+
+The supported browser baseline is Chromium with WebGPU. Verified environments are Chromium 151 on macOS with Apple M4 Pro and Linux CI with software rendering, plus Chrome 153 on macOS. Safari, Firefox, mobile browsers and other physical GPUs have not been validated. Tests simulate lower texture/buffer limits; they do not establish a device memory budget. Bun is an additional tested runtime, not a CPU fallback.
+
+- Developed RAW and decoded TIFF output is linear Rec.2020/D65 `rgba16float`, with no display tone curve. HDR values can exceed 1. TIFF alpha is straight. Camera JPEG previews apply their own rendering and are not pixel references for this output.
+- `source.texture` contains sensor or camera-RGB samples, not developed output. Read its format and metadata; do not assume every RAW is a one-channel mosaic. `source.size` is oriented output size; `metadata.size` is the unrotated sample size.
+- Calibration has three RGB gains and a nine-value column-major matrix. Development applies gains before the camera-to-working-space matrix; exposure is in stops. Independent passes can use different calibration without changing the source.
+- A decoder owns its sources, each source owns its passes and worker, and the caller owns destination textures. Disposal is idempotent. Device loss closes the decoder; create another decoder with a new device. Pending loads and calibration requests reject when their owner closes.
+- Abort signals cover loading only, including pending GPU setup. Cancellation rejects with the signal's reason. Invalid or unsupported files reject with an `Error`; message text is diagnostic, not a stable error code. Load completion queues GPU work; wait on the device queue when you need GPU completion.
+
+The public API and output contract are the supported baseline for 0.1.x. Release checks compare synthetic pixels against known color math and demosaic filters, test real workers and resource cleanup, and install the actual npm tarball in a separate consumer using TypeScript 5.9. The retained 30-camera corpus is a manual compatibility/regression check; X-Trans detail and Sigma color remain explicitly experimental in 0.1.0.
+
 ## Limitations and planned work
 
 **X-Trans quality remains experimental.** Two GPU passes reconstruct camera RGB: nearby samples provide an initial estimate, then interpolated R−G and B−G differences recover detail. White balance is applied after this fixed reconstruction; it is not equivalent to running a WB-dependent demosaic again. Further work should improve directional edges and aliasing against the retained LibRaw Markesteijn references.
 
 The camera-RGB cache keeps WB edits fast. A 16 MP image retains about 128 MB of RGB plus the 32 MB mosaic; reconstruction temporarily needs another 128 MB texture. That temporary texture is released after submission.
 
-RAW coverage depends on camera calibration and sensor layout. Missing as-shot multipliers use a reported daylight fallback; Sigma color remains experimental. Floating-point RAW input, baked white balance and non-three-color sensors have limitations. CPU-prepared sources cannot expose pre-demosaic edits. There is no GPU denoising, highlight reconstruction or CPU rendering fallback.
+RAW coverage depends on camera calibration and sensor layout. Missing as-shot multipliers use a reported daylight fallback; Sigma color remains experimental and can have visible color casts. Floating-point RAW input, baked white balance and non-three-color sensors have limitations. CPU-prepared sources cannot expose pre-demosaic edits. There is no GPU denoising, highlight reconstruction or CPU rendering fallback.
 
-TIFF passes 20 of 24 fixtures; bilevel, palette, float64 and YCbCr JPEG are rejected. Only the first IFD is read, and unsupported ICC profiles fall back to sRGB. Images must fit the GPU's texture limits.
+TIFF passes 20 of 24 fixtures; bilevel, palette, float64 and YCbCr JPEG are rejected. Only the first IFD is read, and unsupported or malformed embedded ICC profiles are rejected. Untagged integer TIFF defaults to sRGB; untagged floating-point TIFF is treated as linear sRGB. Images must fit the GPU's texture limits.
 
 ## Benchmark
 
@@ -103,7 +116,7 @@ The native build downloads checksum-pinned dependencies and caches objects in `.
 
 `test:package` builds a tarball, installs it in a temporary project, checks types and runs RAW/TIFF tests in Chromium with WebGPU. `bun run test:gpu` checks shader pixels; `bun run check` formats and lints.
 
-Publishing runs in GitHub Actions. Merge the version change into `main`, then publish a GitHub prerelease with the matching tag, such as `v0.1.0-alpha.2`. The workflow verifies the tag and commit, installs Emscripten, and runs the package checks before publishing to npm's `alpha` channel. Local publishing is not required.
+Publishing runs in GitHub Actions. Merge the version change into `main`, then publish a GitHub Release with the matching tag, such as `v0.1.0`. The workflow verifies the tag and commit, installs Emscripten, and runs the package checks before publishing to npm. Stable releases use `latest`; `-alpha.N` prereleases use `alpha`. Local publishing is not required.
 
 Configure [npm trusted publishing](https://docs.npmjs.com/trusted-publishers/) once for owner `roprgm`, repository `raw-webgpu`, workflow `publish.yml`, with publishing allowed and no environment name. No npm token secret is needed; npm attaches provenance automatically.
 

package/dist/decode/device.d.ts

@@ -0,0 +1,2 @@
+/** One device-lost subscription; individual loads remove their abort listeners. */
+export declare function deviceSignal(device: GPUDevice): AbortSignal;

package/dist/index.js

@@ -1,3 +1,16 @@
+// src/decode/device.ts
+var signals = new WeakMap;
+function deviceSignal(device) {
+  let signal = signals.get(device);
+  if (!signal) {
+    const controller = new AbortController;
+    device.lost.then(() => controller.abort(Error("WebGPU device was lost.")));
+    signal = controller.signal;
+    signals.set(device, signal);
+  }
+  return signal;
+}
+
 // src/decode/module.ts
 var compiled;
 async function compile() {
@@ -35,7 +48,11 @@ function createSession(compiled2) {
     }
     pending.clear();
   }
-  compiled2.then((module) => worker.postMessage({ module }), (error) => dispose(error instanceof Error ? error : Error(String(error))));
+  compiled2.then((module) => {
+    if (!failure) {
+      worker.postMessage({ module });
+    }
+  }, (error) => dispose(error instanceof Error ? error : Error(String(error))));
   worker.onmessage = ({
     data
   }) => {
@@ -539,7 +556,9 @@ fn oriented(p: vec2u) -> vec2u {
   }
 }
 
-@compute @workgroup_size(16, 16) fn main(@builtin(global_invocation_id) id: vec3u) {
+override workgroupRows: u32 = 16;
+
+@compute @workgroup_size(16, workgroupRows) fn main(@builtin(global_invocation_id) id: vec3u) {
   if id.x >= params.width || id.y >= params.rows { return; }
   let offset = id.y * params.rowBytes + id.x * params.channels * params.bytes;
 
@@ -568,9 +587,14 @@ function createFilledBuffer(device, data, usage) {
     usage,
     mappedAtCreation: true
   });
-  new Uint8Array(result.getMappedRange()).set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
-  result.unmap();
-  return result;
+  try {
+    new Uint8Array(result.getMappedRange()).set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+    result.unmap();
+    return result;
+  } catch (error) {
+    result.destroy();
+    throw error;
+  }
 }
 function createParams(pixels, startRow, rows) {
   const params = new ArrayBuffer(96);
@@ -585,14 +609,16 @@ function createParams(pixels, startRow, rows) {
   }
   return new Uint8Array(params);
 }
-async function uploadTiff(device, pixels) {
+async function uploadTiff(device, pixels, signal) {
+  const workgroupRows = Math.min(16, Math.floor(device.limits.maxComputeInvocationsPerWorkgroup / 16));
   let pending = pipelines.get(device);
   if (!pending) {
     pending = device.createComputePipelineAsync({
       layout: "auto",
       compute: {
         module: device.createShaderModule({ code: upload_default }),
-        entryPoint: "main"
+        entryPoint: "main",
+        constants: { workgroupRows }
       }
     }).catch((error) => {
       pipelines.delete(device);
@@ -601,6 +627,7 @@ async function uploadTiff(device, pixels) {
     pipelines.set(device, pending);
   }
   const pipeline = await pending;
+  signal?.throwIfAborted();
   const { data, metadata, color } = pixels;
   const [width, height, , , , orientation, , , rowBytes] = metadata;
   const size = orientation >= 5 ? [height, width] : [width, height];
@@ -616,13 +643,15 @@ async function uploadTiff(device, pixels) {
     format: "rgba16float",
     usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
   });
-  const curves = createFilledBuffer(device, color.table, GPUBufferUsage.STORAGE);
+  let curves;
   try {
+    curves = createFilledBuffer(device, color.table, GPUBufferUsage.STORAGE);
     for (let y = 0;y < height; y += rowsPerBand) {
       const rows = Math.min(rowsPerBand, height - y);
       const source = createFilledBuffer(device, data.subarray(y * rowBytes, (y + rows) * rowBytes), GPUBufferUsage.STORAGE);
-      const params = createFilledBuffer(device, createParams(pixels, y, rows), GPUBufferUsage.UNIFORM);
+      let params;
       try {
+        params = createFilledBuffer(device, createParams(pixels, y, rows), GPUBufferUsage.UNIFORM);
         const bindings = device.createBindGroup({
           layout: pipeline.getBindGroupLayout(0),
           entries: [
@@ -636,12 +665,12 @@ async function uploadTiff(device, pixels) {
         const pass = encoder.beginComputePass();
         pass.setPipeline(pipeline);
         pass.setBindGroup(0, bindings);
-        pass.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(rows / 16));
+        pass.dispatchWorkgroups(Math.ceil(width / 16), Math.ceil(rows / workgroupRows));
         pass.end();
         device.queue.submit([encoder.finish()]);
       } finally {
         source.destroy();
-        params.destroy();
+        params?.destroy();
       }
     }
     return { texture, size, dispose: () => texture.destroy() };
@@ -649,21 +678,20 @@ async function uploadTiff(device, pixels) {
     texture.destroy();
     throw error;
   } finally {
-    curves.destroy();
+    curves?.destroy();
   }
 }
 
 // src/tiff/index.ts
-async function decodeTiff(device, file, { signal } = {}) {
-  if (signal?.aborted) {
-    throw signal.reason;
-  }
+async function decodeTiff(device, file, { signal: requestedSignal } = {}) {
+  const signal = requestedSignal ? AbortSignal.any([requestedSignal, deviceSignal(device)]) : deviceSignal(device);
+  signal.throwIfAborted();
   const worker = new Worker(new URL("./tiff-worker.js", import.meta.url), {
     type: "module"
   });
   const aborted = Promise.withResolvers();
-  const abort = () => aborted.reject(signal?.reason);
-  signal?.addEventListener("abort", abort);
+  const abort = () => aborted.reject(signal.reason);
+  signal.addEventListener("abort", abort);
   try {
     const module = await Promise.race([compileDecoder(), aborted.promise]);
     const decoded = new Promise((resolve, reject) => {
@@ -682,9 +710,16 @@ async function decodeTiff(device, file, { signal } = {}) {
       worker.postMessage({ file, module });
     });
     const pixels = await Promise.race([decoded, aborted.promise]);
-    return await uploadTiff(device, pixels);
+    const uploading = uploadTiff(device, pixels, signal).then((image) => {
+      if (signal.aborted) {
+        image.dispose();
+        throw signal.reason;
+      }
+      return image;
+    });
+    return await Promise.race([uploading, aborted.promise]);
   } finally {
-    signal?.removeEventListener("abort", abort);
+    signal.removeEventListener("abort", abort);
     worker.terminate();
   }
 }
@@ -696,14 +731,16 @@ function createRawDecoder(device) {
   let closed = false;
   function dispose() {
     closed = true;
+    lost.removeEventListener("abort", dispose);
     for (const close of sources) {
       close();
     }
   }
-  device.lost.then(dispose);
+  const lost = deviceSignal(device);
+  lost.addEventListener("abort", dispose, { once: true });
   return {
     async load(file, { signal } = {}) {
-      if (closed) {
+      if (closed || lost.aborted) {
         throw Error("RAW decoder is closed.");
       }
       if (signal?.aborted) {

package/dist/tiff/color.d.ts

@@ -6,7 +6,7 @@ type Profile = {
 };
 /**
  * Reads a matrix/TRC profile: RGB colorants and a curve per channel, or a single curve for gray.
- * Unsupported lookup-table profiles and malformed profiles fall back to sRGB.
+ * Unsupported lookup-table profiles and malformed profiles are not accepted.
  */
 export declare function readProfile(bytes: Uint8Array): Profile | undefined;
 /** ICC curves and camera-independent conversion into linear Rec.2020. */

package/dist/tiff/index.d.ts

@@ -1,6 +1,6 @@
 import type { LoadOptions } from "../types";
 /** Decode TIFF into an owned linear Rec.2020 RGBA16F texture, with straight alpha. */
-export declare function decodeTiff(device: GPUDevice, file: Blob, { signal }?: LoadOptions): Promise<{
+export declare function decodeTiff(device: GPUDevice, file: Blob, { signal: requestedSignal }?: LoadOptions): Promise<{
     texture: GPUTexture;
     size: [number, number];
     dispose: () => undefined;

package/dist/tiff/upload.d.ts

@@ -14,7 +14,7 @@ export type TiffPixels = {
         matrix: number[];
     };
 };
-export declare function uploadTiff(device: GPUDevice, pixels: TiffPixels): Promise<{
+export declare function uploadTiff(device: GPUDevice, pixels: TiffPixels, signal?: AbortSignal): Promise<{
     texture: GPUTexture;
     size: [number, number];
     dispose: () => undefined;

package/dist/tiff-worker.js

@@ -48,20 +48,38 @@ function readProfile(bytes) {
     return;
   }
   const tags = new Map;
+  if (view.getUint32(128) > (bytes.length - 132) / 12) {
+    return;
+  }
   for (let i = 0, count = view.getUint32(128);i < count; i++) {
-    tags.set(text(132 + i * 12), view.getUint32(136 + i * 12));
+    const at = view.getUint32(136 + i * 12);
+    const size = view.getUint32(140 + i * 12);
+    if (at < 128 || size < 8 || at > bytes.length - size) {
+      return;
+    }
+    tags.set(text(132 + i * 12), { at, size });
+  }
+  if ([...tags.keys()].some((name) => /^(A2B|B2A|D2B|B2D)/.test(name))) {
+    return;
   }
   const xyz = (name) => {
-    const at = tags.get(name);
-    return at === undefined ? undefined : [fixed(at + 8), fixed(at + 12), fixed(at + 16)];
+    const tag = tags.get(name);
+    if (!tag || tag.size < 20 || text(tag.at) !== "XYZ ") {
+      return;
+    }
+    return [fixed(tag.at + 8), fixed(tag.at + 12), fixed(tag.at + 16)];
   };
   const curve = (name) => {
-    const at = tags.get(name);
-    if (at === undefined) {
+    const tag = tags.get(name);
+    if (!tag || tag.size < 12) {
       return;
     }
+    const { at, size } = tag;
     if (text(at) === "curv") {
       const count = view.getUint32(at + 8);
+      if (count > (size - 12) / 2) {
+        return;
+      }
       const entry = (i) => view.getUint16(at + 12 + 2 * Math.min(i, count - 1)) / 65535;
       if (count === 0) {
         return identity;
@@ -78,7 +96,11 @@ function readProfile(bytes) {
     }
     if (text(at) === "para") {
       const kind = view.getUint16(at + 8);
-      const [g, a = 1, b = 0, c = 0, d = 0, e = 0, f = 0] = Array.from({ length: [1, 3, 4, 5, 7][kind] ?? 0 }, (_, i) => fixed(at + 12 + i * 4));
+      const count = [1, 3, 4, 5, 7][kind];
+      if (!count || count > (size - 12) / 4) {
+        return;
+      }
+      const [g, a = 1, b = 0, c = 0, d = 0, e = 0, f = 0] = Array.from({ length: count }, (_, i) => fixed(at + 12 + i * 4));
       if (kind === 0) {
         return (x) => x ** g;
       }
@@ -111,11 +133,13 @@ function readProfile(bytes) {
 }
 var sampleCurves = (curves) => Float32Array.from({ length: 3 * tableSize }, (_, i) => curves[Math.floor(i / tableSize)](i % tableSize / (tableSize - 1)));
 function tiffColor(icc, linear) {
-  let profile = (icc && readProfile(icc)) ?? srgb;
-  let table = sampleCurves(linear ? [identity, identity, identity] : profile.curves);
+  const profile = icc ? readProfile(icc) : srgb;
+  if (!profile) {
+    throw Error("Unsupported or malformed TIFF ICC profile.");
+  }
+  const table = sampleCurves(linear ? [identity, identity, identity] : profile.curves);
   if (!table.every(Number.isFinite)) {
-    profile = srgb;
-    table = sampleCurves(profile.curves);
+    throw Error("Malformed TIFF ICC transfer curve.");
   }
   return {
     table,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "raw-webgpu",
-	"version": "0.1.0-alpha.2",
+	"version": "0.1.0",
 	"description": "Camera RAW, DNG and TIFF decoding with WebGPU development and interactive white balance.",
 	"type": "module",
 	"license": "MIT",
@@ -45,7 +45,7 @@
 	},
 	"publishConfig": {
 		"access": "public",
-		"tag": "alpha",
+		"tag": "latest",
 		"registry": "https://registry.npmjs.org/"
 	},
 	"keywords": [