raw-webgpu 0.1.0-alpha.2 → 0.1.1

package/README.md

@@ -1,6 +1,6 @@
 # raw-webgpu
 
-Load camera RAW, DNG and TIFF files into WebGPU textures. Develop into linear Rec.2020 `rgba16float`, with adjustable white balance and exposure.
+Load camera RAW, DNG and TIFF files into WebGPU textures. Develop into linear Rec.2020 or display sRGB, with adjustable white balance and exposure.
 
 LibRaw, Adobe DNG SDK and libjxl decode files in a WASM worker. Simple TIFF strips use original file bytes or browser Deflate; complex layouts retain the SDK fallback. WebGPU handles supported demosaic and color processing. Supply your own `GPUDevice`; no rendering framework or runtime dependencies are required.
 
@@ -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.1
 ```
 
-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
 
@@ -45,6 +45,10 @@ destination.destroy();
 decoder.dispose();
 ```
 
+For direct display, create a pass with `{ outputColorSpace: "srgb", format }`, where `format` matches your sRGB canvas configuration, usually `navigator.gpu.getPreferredCanvasFormat()`. Render to `context.getCurrentTexture()` with the canvas dimensions set to `source.size`. No app shader is needed.
+
+The default is `{ outputColorSpace: "linear-rec2020", format: "rgba16float" }`. Supported formats are `rgba16float`, `rgba8unorm` and `bgra8unorm`. sRGB output converts primaries, clips to [0, 1] and applies the sRGB transfer function on GPU; it does not add a photographic tone curve. Do not apply sRGB encoding again.
+
 For TIFF:
 
 ```ts
@@ -61,15 +65,32 @@ 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).
 
+
+## Minimal website
+
+`web/` is a fullscreen RAW viewer with no app shader or rendering framework. It currently uses a local link: build the library and run `bun link` at the repository root, then `cd web && bun install && bun run dev`. After publishing the new API, pin that npm version in `web/package.json` for standalone deployment. Build with `bun run build` and serve `web/dist/` over HTTPS. Files stay in the browser. With the dev server running, `bun run test:web` from the repository root checks loading through Vite.
+
+## 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.
+
+- Default RAW and decoded TIFF output is linear Rec.2020/D65 `rgba16float`, with no display tone curve. HDR values can exceed 1. RAW passes can instead output encoded sRGB for display. 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 +124,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/develop/gpu.d.ts

@@ -1,8 +1,9 @@
-import type { DevelopOptions, RawPixels } from "../types";
+import type { DevelopOptions, DevelopPassOptions, RawPixels } from "../types";
 export declare function createPipeline(device: GPUDevice): Promise<{
     sensor: GPURenderPipeline;
     camera: GPURenderPipeline;
     refine: GPURenderPipeline;
+    get(entryPoint: string, options: DevelopPassOptions): GPURenderPipeline;
 }>;
 /** Owns the sensor texture and immutable uniforms; each pass owns its calibration buffer. */
 export declare function createGpuSource(device: GPUDevice, pixels: RawPixels, pipeline: Awaited<ReturnType<typeof createPipeline>>): {
@@ -20,7 +21,7 @@ export declare function createGpuSource(device: GPUDevice, pixels: RawPixels, pi
         whiteBalanceOrigin?: "as-shot" | "daylight";
     };
     size: [number, number];
-    createDevelopPass(): {
+    createDevelopPass(options?: DevelopPassOptions): {
         render(options: DevelopOptions): void;
         dispose: () => void;
     };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import type { LoadOptions } from "./types";
-export type { Calibration, DevelopOptions, LoadOptions, RawMetadata, WhiteBalance, } from "./types";
+export type { Calibration, DevelopOptions, DevelopPassOptions, LoadOptions, RawMetadata, WhiteBalance, } from "./types";
 /** Reuses a pipeline on the consumer's device. Each load owns an independent worker and source. */
 export declare function createRawDecoder(device: GPUDevice): {
     load(file: Blob, { signal }?: LoadOptions): Promise<{
@@ -17,7 +17,7 @@ export declare function createRawDecoder(device: GPUDevice): {
             whiteBalanceOrigin?: "as-shot" | "daylight";
         };
         size: [number, number];
-        createDevelopPass(): {
+        createDevelopPass(options?: import("./types").DevelopPassOptions): {
             render(options: import("./types").DevelopOptions): void;
             dispose: () => void;
         };

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
   }) => {
@@ -73,9 +90,24 @@ function createSession(compiled2) {
 }
 
 // src/develop/develop.wgsl
-var develop_default = `// Sensor samples in, unclipped linear Rec.2020 out: normalize, white balance,
+var develop_default = `// Sensor samples in, linear Rec.2020 or display sRGB out: normalize, white balance,
 // demosaic when needed, correct vignetting, convert color and apply exposure.
 
+// Specialization removes display conversion from the default editor pipeline.
+override outputSrgb: bool = false;
+
+fn output(color: vec3f) -> vec4f {
+  if (!outputSrgb) { return vec4f(color, 1.0); }
+  let matrix = mat3x3f(
+    1.660491, -0.124550, -0.018151,
+    -0.587641, 1.132900, -0.100579,
+    -0.072850, -0.008349, 1.118730,
+  );
+  let rgb = clamp(matrix * color, vec3f(0.0), vec3f(1.0));
+  let encoded = select(1.055 * pow(rgb, vec3f(1.0 / 2.4)) - 0.055, 12.92 * rgb, rgb <= vec3f(0.0031308));
+  return vec4f(encoded, 1.0);
+}
+
 struct Sensor {
   black: vec4f,
   patternSize: vec4u,
@@ -201,7 +233,7 @@ fn demosaicPattern(p: vec2i, size: vec2i) -> vec3f {
   let k = vignette.coefficients;
   let gain = 1.0 + r2 * (k.x + r2 * (k.y + r2 * (k.z + r2 * (k.w + r2 * vignette.last))));
 
-  return vec4f(calibration.matrix * camera * gain * calibration.exposure, 1.0);
+  return output(calibration.matrix * camera * gain * calibration.exposure);
 }
 
 @group(0) @binding(5) var cameraSource: texture_2d<f32>;
@@ -244,7 +276,7 @@ fn demosaicPattern(p: vec2i, size: vec2i) -> vec3f {
 // Cached X-Trans camera RGB: subsequent edits only apply per-pixel linear transforms.
 @fragment fn fs_camera(@builtin(position) position: vec4f) -> @location(0) vec4f {
   let camera = textureLoad(cameraSource, vec2i(position.xy), 0).rgb;
-  return vec4f(calibration.matrix * (camera * calibration.gains) * calibration.exposure, 1.0);
+  return output(calibration.matrix * (camera * calibration.gains) * calibration.exposure);
 }
 
 // One triangle covering the whole destination.
@@ -257,20 +289,46 @@ fn demosaicPattern(p: vec2i, size: vec2i) -> vec3f {
 // src/develop/gpu.ts
 async function createPipeline(device) {
   const module = device.createShaderModule({ code: develop_default });
-  function create(entryPoint) {
-    return device.createRenderPipelineAsync({
+  const pipelines = new Map;
+  function descriptor(entryPoint, options = {}) {
+    const { format = "rgba16float", outputColorSpace = "linear-rec2020" } = options;
+    if (!["rgba16float", "rgba8unorm", "bgra8unorm"].includes(format)) {
+      throw Error("RAW output format must be rgba16float, rgba8unorm or bgra8unorm.");
+    }
+    return {
       layout: "auto",
       vertex: { module, entryPoint: "vs_main" },
-      fragment: { module, entryPoint, targets: [{ format: "rgba16float" }] },
+      fragment: {
+        module,
+        entryPoint,
+        targets: [{ format }],
+        constants: { outputSrgb: Number(outputColorSpace === "srgb") }
+      },
       primitive: { topology: "triangle-list" }
-    });
+    };
+  }
+  function key(entryPoint, options = {}) {
+    return `${entryPoint}:${options.format ?? "rgba16float"}:${options.outputColorSpace ?? "linear-rec2020"}`;
   }
-  const [sensor, camera, refine] = await Promise.all([
-    create("fs_main"),
-    create("fs_camera"),
-    create("fs_refine")
-  ]);
-  return { sensor, camera, refine };
+  const [sensor, camera, refine] = await Promise.all(["fs_main", "fs_camera", "fs_refine"].map(async (entryPoint) => {
+    const pipeline = await device.createRenderPipelineAsync(descriptor(entryPoint));
+    pipelines.set(key(entryPoint), pipeline);
+    return pipeline;
+  }));
+  return {
+    sensor,
+    camera,
+    refine,
+    get(entryPoint, options) {
+      const id = key(entryPoint, options);
+      let pipeline = pipelines.get(id);
+      if (!pipeline) {
+        pipeline = device.createRenderPipeline(descriptor(entryPoint, options));
+        pipelines.set(id, pipeline);
+      }
+      return pipeline;
+    }
+  };
 }
 function createUniform(device, data) {
   const buffer = device.createBuffer({
@@ -329,7 +387,7 @@ function createGpuSource(device, pixels, pipeline) {
     texture.destroy();
     cameraTexture?.destroy();
   }
-  function createPass(renderPipeline, entries) {
+  function createPass(renderPipeline, entries, format2 = "rgba16float") {
     if (closed) {
       throw Error("RAW source is closed.");
     }
@@ -355,8 +413,8 @@ function createGpuSource(device, pixels, pipeline) {
           throw Error("RAW development pass is closed.");
         }
         const { destination, calibration, exposure = 0 } = options;
-        if (destination.format !== "rgba16float" || destination.width !== size[0] || destination.height !== size[1]) {
-          throw Error("RAW destination must be an rgba16float texture matching the oriented source size.");
+        if (destination.format !== format2 || destination.width !== size[0] || destination.height !== size[1]) {
+          throw Error(`RAW destination must be a ${format2} texture matching the oriented source size.`);
         }
         calibrationData.set(calibration.gains);
         calibrationData[3] = 2 ** exposure;
@@ -460,13 +518,8 @@ function createGpuSource(device, pixels, pipeline) {
       texture,
       metadata,
       size,
-      createDevelopPass() {
-        if (cameraTexture) {
-          return createPass(pipeline.camera, [
-            { binding: 5, resource: cameraTexture.createView() }
-          ]);
-        }
-        return createPass(pipeline.sensor, sensorEntries);
+      createDevelopPass(options = {}) {
+        return createPass(pipeline.get(cameraTexture ? "fs_camera" : "fs_main", options), cameraTexture ? [{ binding: 5, resource: cameraTexture.createView() }] : sensorEntries, options.format);
       },
       dispose
     };
@@ -539,7 +592,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 +623,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 +645,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 +663,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 +679,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 +701,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 +714,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 +746,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 +767,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/dist/types.d.ts

@@ -41,6 +41,12 @@ export type LoadOptions = {
     /** Aborting rejects a pending load with the signal's reason; a loaded source is unaffected. */
     signal?: AbortSignal;
 };
+export type DevelopPassOptions = {
+    /** Default linear-rec2020 preserves HDR. srgb converts primaries, clips to [0, 1] and encodes sRGB. */
+    outputColorSpace?: "linear-rec2020" | "srgb";
+    /** rgba16float by default; rgba8unorm and bgra8unorm also supported for direct display. */
+    format?: GPUTextureFormat;
+};
 export type DevelopOptions = {
     destination: GPUTexture;
     calibration: Calibration;

package/docs/conversion.md

@@ -7,34 +7,19 @@ import { PNG } from "pngjs";
 import { init, target } from "vgpu/node";
 import { createRawDecoder } from "raw-webgpu";
 
-function srgb(value: number) {
-  const x = Math.max(0, Math.min(1, value));
-  return Math.round(255 * (
-    x <= 0.0031308 ? 12.92 * x : 1.055 * x ** (1 / 2.4) - 0.055
-  ));
-}
-
 const gpu = await init();
 const decoder = createRawDecoder(gpu.gpu);
 try {
   const source = await decoder.load(Bun.file("photo.dng"));
-  const output = target(gpu, { size: source.size, format: "rgba16float" });
+  const output = target(gpu, { size: source.size, format: "rgba8unorm" });
   try {
-    source.createDevelopPass().render({
+    source.createDevelopPass({ outputColorSpace: "srgb", format: "rgba8unorm" }).render({
       destination: output.color.gpu,
       calibration: source.calibration,
     });
 
-    const pixels = await output.readFloats();
     const image = new PNG({ width: source.size[0], height: source.size[1] });
-    for (let i = 0; i < pixels.length; i += 4) {
-      const [r, g, b] = pixels.subarray(i, i + 3);
-      // Linear Rec.2020 → linear sRGB → encoded sRGB.
-      image.data[i] = srgb(1.660491 * r - 0.587641 * g - 0.072850 * b);
-      image.data[i + 1] = srgb(-0.124550 * r + 1.132900 * g - 0.008349 * b);
-      image.data[i + 2] = srgb(-0.018151 * r - 0.100579 * g + 1.118730 * b);
-      image.data[i + 3] = 255;
-    }
+    image.data.set(await output.read());
     await Bun.write("photo.png", PNG.sync.write(image));
   } finally {
     output.color.dispose();
@@ -49,4 +34,4 @@ For JPEG, install `jpeg-js`, import its `encode` function and replace the final
 
 Bun supplies the worker and local file-fetch APIs; Chromium is not required. Plain Node.js is not supported by this snippet. A working GPU backend is required; `vgpu/mock` cannot execute the development shader.
 
-The example uses the initial white balance, develops on GPU, then reads back and converts color on CPU. Output is 8-bit SDR/sRGB with clipping and no photographic tone curve. File encoding belongs to the consuming application; the library does not include image encoders or a conversion helper.
+The example uses the initial white balance, develops and converts to sRGB on GPU, then reads back the encoded bytes. Output is 8-bit SDR/sRGB with clipping and no photographic tone curve. File encoding belongs to the consuming application; the library does not include image encoders or a conversion helper.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "raw-webgpu",
-	"version": "0.1.0-alpha.2",
+	"version": "0.1.1",
 	"description": "Camera RAW, DNG and TIFF decoding with WebGPU development and interactive white balance.",
 	"type": "module",
 	"license": "MIT",
@@ -28,6 +28,7 @@
 		"test": "bun test",
 		"test:gpu": "GPU=1 bun test",
 		"test:browser": "bun tests/browser.ts",
+		"test:web": "bun tests/web.ts",
 		"build:sdk": "bun build.ts && tsc --emitDeclarationOnly",
 		"test:tiff": "bun tests/tiff.browser.ts",
 		"benchmark:tiff": "bun tests/tiff.browser.ts --benchmark",
@@ -45,7 +46,7 @@
 	},
 	"publishConfig": {
 		"access": "public",
-		"tag": "alpha",
+		"tag": "latest",
 		"registry": "https://registry.npmjs.org/"
 	},
 	"keywords": [