raw-webgpu 0.1.0-alpha.1

package/dist/libraw.js

@@ -0,0 +1,2 @@
+async function Module(moduleArg={}){var Module=moduleArg;var ENVIRONMENT_IS_WEB=!!globalThis.window;var ENVIRONMENT_IS_WORKER=!!globalThis.WorkerGlobalScope;var ENVIRONMENT_IS_NODE=globalThis.process?.versions?.node&&globalThis.process?.type!="renderer";var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var _scriptName=import.meta.url;var scriptDirectory="";function locateFile(path){return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){try{scriptDirectory=new URL(".",_scriptName).href}catch{}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=console.log.bind(console);var err=console.error.bind(console);var wasmBinary;var ABORT=false;var EXITSTATUS;var runtimeInitialized=false;function getMemoryBuffer(){return wasmMemory.buffer}function updateMemoryViews(){if(HEAP8?.buffer?.resizable)return;var b=getMemoryBuffer();HEAP8=new Int8Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF64"]=HEAPF64=new Float64Array(b)}function preRun(){}function initRuntime(){runtimeInitialized=true;wasmExports["s"]()}function postRun(){}function abort(what){what=`Aborted(${what})`;err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";if(runtimeInitialized){___trap()}var e=new WebAssembly.RuntimeError(what);throw e}var wasmBinaryFile;function findWasmBinary(){if(Module["locateFile"]){return locateFile("libraw.wasm")}return new URL("libraw.wasm",import.meta.url).href}function getBinarySync(file){if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){var imports={a:wasmImports};return imports}async function createWasm(){function receiveInstance(instance){wasmExports=instance.exports;assignWasmExports(wasmExports);updateMemoryViews();return wasmExports}function receiveInstantiationResult(result){return receiveInstance(result["instance"])}var info=getWasmImports();var instantiateWasm=Module["instantiateWasm"];if(instantiateWasm){return new Promise(resolve=>{instantiateWasm(info,inst=>resolve(receiveInstance(inst)))})}wasmBinaryFile??=findWasmBinary();var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);var exports=receiveInstantiationResult(result);return exports}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var HEAP8;var UTF8Decoder=new TextDecoder;var findStringEnd=(heapOrArray,idx,maxBytesToRead,ignoreNul)=>{var maxIdx=idx+maxBytesToRead;if(ignoreNul)return maxIdx;while(heapOrArray[idx]&&!(idx>=maxIdx))++idx;return idx};var HEAPU8;var UTF8ToString=(ptr,maxBytesToRead,ignoreNul)=>{if(!ptr)return"";var end=findStringEnd(HEAPU8,ptr,maxBytesToRead,ignoreNul);return UTF8Decoder.decode(HEAPU8.subarray(ptr,end))};var SYSCALLS={varargs:undefined,getStr(ptr){var ret=UTF8ToString(ptr);return ret}};function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;return 0}function ___syscall_ioctl(fd,op,varargs){SYSCALLS.varargs=varargs;return 0}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs}var __abort_js=()=>abort("");var runtimeKeepaliveCounter=0;var __emscripten_runtime_keepalive_clear=()=>{runtimeKeepaliveCounter=0};var isLeapYear=year=>year%4===0&&(year%100!==0||year%400===0);var MONTH_DAYS_LEAP_CUMULATIVE=[0,31,60,91,121,152,182,213,244,274,305,335];var MONTH_DAYS_REGULAR_CUMULATIVE=[0,31,59,90,120,151,181,212,243,273,304,334];var ydayFromDate=date=>{var leap=isLeapYear(date.getFullYear());var monthDaysCumulative=leap?MONTH_DAYS_LEAP_CUMULATIVE:MONTH_DAYS_REGULAR_CUMULATIVE;var yday=monthDaysCumulative[date.getMonth()]+date.getDate()-1;return yday};var INT53_MAX=9007199254740992;var INT53_MIN=-9007199254740992;var bigintToI53Checked=num=>num<INT53_MIN||num>INT53_MAX?NaN:Number(num);var HEAP32;function __localtime_js(time,tmPtr){time=bigintToI53Checked(time);var date=new Date(time*1e3);if(isNaN(date.getTime())){return 1}HEAP32[tmPtr>>2]=date.getSeconds();HEAP32[tmPtr+4>>2]=date.getMinutes();HEAP32[tmPtr+8>>2]=date.getHours();HEAP32[tmPtr+12>>2]=date.getDate();HEAP32[tmPtr+16>>2]=date.getMonth();HEAP32[tmPtr+20>>2]=date.getFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getDay();var yday=ydayFromDate(date)|0;HEAP32[tmPtr+28>>2]=yday;HEAP32[tmPtr+36>>2]=-(date.getTimezoneOffset()*60);var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dst=(summerOffset!=winterOffset&&date.getTimezoneOffset()==Math.min(winterOffset,summerOffset))|0;HEAP32[tmPtr+32>>2]=dst;return 0}var __mktime_js=function(tmPtr){var ret=(()=>{var date=new Date(HEAP32[tmPtr+20>>2]+1900,HEAP32[tmPtr+16>>2],HEAP32[tmPtr+12>>2],HEAP32[tmPtr+8>>2],HEAP32[tmPtr+4>>2],HEAP32[tmPtr>>2],0);if(isNaN(date.getTime())){return-1}var dst=HEAP32[tmPtr+32>>2];var guessedOffset=date.getTimezoneOffset();var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dstOffset=Math.min(winterOffset,summerOffset);if(dst<0){dst=Number(summerOffset!=winterOffset&&dstOffset==guessedOffset)}else if(dst>0!=(dstOffset==guessedOffset)){var nonDstOffset=Math.max(winterOffset,summerOffset);var trueOffset=dst>0?dstOffset:nonDstOffset;date.setTime(date.getTime()+(trueOffset-guessedOffset)*6e4);if(isNaN(date.getTime())){return-1}}HEAP32[tmPtr+32>>2]=dst;HEAP32[tmPtr+24>>2]=date.getDay();var yday=ydayFromDate(date)|0;HEAP32[tmPtr+28>>2]=yday;HEAP32[tmPtr>>2]=date.getSeconds();HEAP32[tmPtr+4>>2]=date.getMinutes();HEAP32[tmPtr+8>>2]=date.getHours();HEAP32[tmPtr+12>>2]=date.getDate();HEAP32[tmPtr+16>>2]=date.getMonth();HEAP32[tmPtr+20>>2]=date.getYear();return date.getTime()/1e3})();return BigInt(ret)};var timers={};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var keepRuntimeAlive=()=>true;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){ABORT=true}quit_(code,new ExitStatus(code))};var exitJS=(status,implicit)=>{EXITSTATUS=status;_proc_exit(status)};var _exit=exitJS;var maybeExit=()=>{if(!keepRuntimeAlive()){try{_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(ABORT){return}try{return func()}catch(e){handleException(e)}finally{maybeExit()}};var _emscripten_get_now=()=>performance.now();var __setitimer_js=(which,timeout_ms)=>{if(timers[which]){clearTimeout(timers[which].id);delete timers[which]}if(!timeout_ms)return 0;var id=setTimeout(()=>{delete timers[which];callUserCallback(()=>__emscripten_timeout(which,_emscripten_get_now()))},timeout_ms);timers[which]={id,timeout_ms};return 0};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i<str.length;++i){var u=str.codePointAt(i);if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63;i++}}heap[outIdx]=0;return outIdx-startIdx};var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);var HEAPU32;var __tzset_js=(timezone,daylight,std_name,dst_name)=>{var currentYear=(new Date).getFullYear();var winter=new Date(currentYear,0,1);var summer=new Date(currentYear,6,1);var winterOffset=winter.getTimezoneOffset();var summerOffset=summer.getTimezoneOffset();var stdTimezoneOffset=Math.max(winterOffset,summerOffset);HEAPU32[timezone>>2]=stdTimezoneOffset*60;HEAP32[daylight>>2]=Number(winterOffset!=summerOffset);var extractZone=timezoneOffset=>{var sign=timezoneOffset>=0?"-":"+";var absOffset=Math.abs(timezoneOffset);var hours=String(Math.floor(absOffset/60)).padStart(2,"0");var minutes=String(absOffset%60).padStart(2,"0");return`UTC${sign}${hours}${minutes}`};var winterName=extractZone(winterOffset);var summerName=extractZone(summerOffset);if(summerOffset<winterOffset){stringToUTF8(winterName,std_name,17);stringToUTF8(summerName,dst_name,17)}else{stringToUTF8(winterName,dst_name,17);stringToUTF8(summerName,std_name,17)}};var getHeapMax=()=>2147483648;var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var growMemory=size=>{var oldHeapSize=wasmMemory.buffer.byteLength;var pages=(size-oldHeapSize+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var ENV={};var getExecutableName=()=>thisProgram;var getEnvStrings=()=>{if(!getEnvStrings.strings){var lang=(globalThis.navigator?.language??"C").replace("-","_")+".UTF-8";var env={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:lang,_:getExecutableName()};for(var x in ENV){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(`${x}=${env[x]}`)}getEnvStrings.strings=strings}return getEnvStrings.strings};var _environ_get=(__environ,environ_buf)=>{var bufSize=0;var envp=0;for(var string of getEnvStrings()){var ptr=environ_buf+bufSize;HEAPU32[__environ+envp>>2]=ptr;bufSize+=stringToUTF8(string,ptr,Infinity)+1;envp+=4}return 0};var lengthBytesUTF8=str=>{var len=0;for(var i=0;i<str.length;++i){var c=str.charCodeAt(i);if(c<=127){len++}else if(c<=2047){len+=2}else if(c>=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var _environ_sizes_get=(penviron_count,penviron_buf_size)=>{var strings=getEnvStrings();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;for(var string of strings){bufSize+=lengthBytesUTF8(string)+1}HEAPU32[penviron_buf_size>>2]=bufSize;return 0};var _fd_close=fd=>52;var _fd_read=(fd,iov,iovcnt,pnum)=>52;function _fd_seek(fd,offset,whence,newOffset){offset=bigintToI53Checked(offset);return 70}var printCharBuffers=[null,[],[]];var UTF8ArrayToString=(heapOrArray,idx=0,maxBytesToRead,ignoreNul)=>{var endPtr=findStringEnd(heapOrArray,idx,maxBytesToRead,ignoreNul);return UTF8Decoder.decode(heapOrArray.buffer?heapOrArray.subarray(idx,endPtr):new Uint8Array(heapOrArray.slice(idx,endPtr)))};var printChar=(stream,curr)=>{var buffer=printCharBuffers[stream];if(!curr||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer));buffer.length=0}else{buffer.push(curr)}};var _fd_write=(fd,iov,iovcnt,pnum)=>{var num=0;for(var i=0;i<iovcnt;i++){var ptr=HEAPU32[iov>>2];var len=HEAPU32[iov+4>>2];iov+=8;for(var j=0;j<len;j++){printChar(fd,HEAPU8[ptr+j])}num+=len}HEAPU32[pnum>>2]=num;return 0};var HEAPU16;var HEAPF64;{}Module["UTF8ToString"]=UTF8ToString;var _raw_error,_raw_open,_raw_calibration,_raw_original_offset,_raw_width,_raw_height,_raw_flip,_raw_cpu_demosaic,_raw_float,_raw_daylight_balance,_raw_mosaic,_raw_cfa_size,_raw_cfa,_raw_black,_raw_vignette,_raw_white,_raw_pixels,_raw_free_pixels,_raw_temperature,_raw_tint,_raw_close,_tiff_open,_tiff_error,_tiff_metadata,_tiff_original_offset,_tiff_big_endian,_tiff_pixels,_tiff_profile,_tiff_profile_size,_tiff_close,_malloc,_free,__emscripten_timeout,___trap,memory,__indirect_function_table,wasmMemory;function assignWasmExports(wasmExports){_raw_error=Module["_raw_error"]=wasmExports["t"];_raw_open=Module["_raw_open"]=wasmExports["u"];_raw_calibration=Module["_raw_calibration"]=wasmExports["v"];_raw_original_offset=Module["_raw_original_offset"]=wasmExports["w"];_raw_width=Module["_raw_width"]=wasmExports["x"];_raw_height=Module["_raw_height"]=wasmExports["y"];_raw_flip=Module["_raw_flip"]=wasmExports["z"];_raw_cpu_demosaic=Module["_raw_cpu_demosaic"]=wasmExports["A"];_raw_float=Module["_raw_float"]=wasmExports["B"];_raw_daylight_balance=Module["_raw_daylight_balance"]=wasmExports["C"];_raw_mosaic=Module["_raw_mosaic"]=wasmExports["D"];_raw_cfa_size=Module["_raw_cfa_size"]=wasmExports["E"];_raw_cfa=Module["_raw_cfa"]=wasmExports["F"];_raw_black=Module["_raw_black"]=wasmExports["G"];_raw_vignette=Module["_raw_vignette"]=wasmExports["H"];_raw_white=Module["_raw_white"]=wasmExports["I"];_raw_pixels=Module["_raw_pixels"]=wasmExports["J"];_raw_free_pixels=Module["_raw_free_pixels"]=wasmExports["K"];_raw_temperature=Module["_raw_temperature"]=wasmExports["L"];_raw_tint=Module["_raw_tint"]=wasmExports["M"];_raw_close=Module["_raw_close"]=wasmExports["N"];_tiff_open=Module["_tiff_open"]=wasmExports["O"];_tiff_error=Module["_tiff_error"]=wasmExports["P"];_tiff_metadata=Module["_tiff_metadata"]=wasmExports["Q"];_tiff_original_offset=Module["_tiff_original_offset"]=wasmExports["R"];_tiff_big_endian=Module["_tiff_big_endian"]=wasmExports["S"];_tiff_pixels=Module["_tiff_pixels"]=wasmExports["T"];_tiff_profile=Module["_tiff_profile"]=wasmExports["U"];_tiff_profile_size=Module["_tiff_profile_size"]=wasmExports["V"];_tiff_close=Module["_tiff_close"]=wasmExports["W"];_malloc=Module["_malloc"]=wasmExports["X"];_free=Module["_free"]=wasmExports["Y"];__emscripten_timeout=wasmExports["Z"];___trap=wasmExports["_"];memory=wasmMemory=wasmExports["r"];__indirect_function_table=wasmExports["__indirect_function_table"]}var wasmImports={b:___syscall_fcntl64,h:___syscall_ioctl,p:___syscall_openat,q:__abort_js,l:__emscripten_runtime_keepalive_clear,m:__localtime_js,n:__mktime_js,i:__setitimer_js,o:__tzset_js,j:_emscripten_resize_heap,d:_environ_get,e:_environ_sizes_get,a:_fd_close,g:_fd_read,c:_fd_seek,f:_fd_write,k:_proc_exit};async function run(){preRun();if(ABORT)return;initRuntime();postRun()}var wasmExports;wasmExports=await createWasm();await run();
+;return Module}export default Module;

package/dist/math.d.ts

@@ -0,0 +1,4 @@
+/** Column-major 3x3 matrix as nine numbers, the layout of WGSL mat3x3f. */
+export type Mat3 = readonly number[];
+/** The product a·b, so b applies first. */
+export declare function multiplyMat3(a: Mat3, b: Mat3): number[];

package/dist/tiff/color.d.ts

@@ -0,0 +1,17 @@
+import { type Mat3 } from "../math";
+type Curve = (encoded: number) => number;
+type Profile = {
+    colorants: Mat3;
+    curves: [Curve, Curve, Curve];
+};
+/**
+ * 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.
+ */
+export declare function readProfile(bytes: Uint8Array): Profile | undefined;
+/** ICC curves and camera-independent conversion into linear Rec.2020. */
+export declare function tiffColor(icc: Uint8Array | undefined, linear: boolean): {
+    table: Float32Array<ArrayBuffer>;
+    matrix: number[];
+};
+export {};

package/dist/tiff/index.d.ts

@@ -0,0 +1,7 @@
+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<{
+    texture: GPUTexture;
+    size: [number, number];
+    dispose: () => undefined;
+}>;

package/dist/tiff/upload.d.ts

@@ -0,0 +1,21 @@
+export type TiffPixels = {
+    /** Interleaved samples, one row after another, exactly as the file or the SDK laid them out. */
+    data: Uint8Array;
+    /**
+     * Nine values from native/tiff.cpp: width, height, channels, bytes per sample,
+     * bits per sample (zero for float), orientation, photometric interpretation,
+     * extra-sample kind (1 for associated alpha), row bytes.
+     */
+    metadata: Uint32Array;
+    /** Whether the samples still carry the file's big-endian byte order. */
+    bigEndian: boolean;
+    color: {
+        table: Float32Array;
+        matrix: number[];
+    };
+};
+export declare function uploadTiff(device: GPUDevice, pixels: TiffPixels): Promise<{
+    texture: GPUTexture;
+    size: [number, number];
+    dispose: () => undefined;
+}>;

package/dist/tiff-worker.js

@@ -0,0 +1,181 @@
+// src/math.ts
+function multiplyMat3(a, b) {
+  const result = [];
+  for (let column = 0;column < 3; column++) {
+    const [x, y, z] = b.slice(column * 3, column * 3 + 3);
+    for (let row = 0;row < 3; row++) {
+      result.push(a[row] * x + a[3 + row] * y + a[6 + row] * z);
+    }
+  }
+  return result;
+}
+
+// src/tiff/color.ts
+var tableSize = 1024;
+var d50 = [0.9642, 1, 0.8249];
+var identity = (v) => v;
+var xyzToRec2020 = [
+  1.6472945,
+  -0.6826024,
+  0.0296711,
+  -0.3935777,
+  1.6475829,
+  -0.0629319,
+  -0.2359823,
+  0.0128128,
+  1.253617
+];
+var srgbCurve = (v) => v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+var srgb = {
+  colorants: [
+    0.4361,
+    0.2225,
+    0.0139,
+    0.3851,
+    0.7169,
+    0.0971,
+    0.1431,
+    0.0606,
+    0.7141
+  ],
+  curves: [srgbCurve, srgbCurve, srgbCurve]
+};
+function readProfile(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const text = (at) => String.fromCharCode(...bytes.subarray(at, at + 4));
+  const fixed = (at) => view.getInt32(at) / 65536;
+  if (bytes.length < 132 || text(36) !== "acsp") {
+    return;
+  }
+  const tags = new Map;
+  for (let i = 0, count = view.getUint32(128);i < count; i++) {
+    tags.set(text(132 + i * 12), view.getUint32(136 + i * 12));
+  }
+  const xyz = (name) => {
+    const at = tags.get(name);
+    return at === undefined ? undefined : [fixed(at + 8), fixed(at + 12), fixed(at + 16)];
+  };
+  const curve = (name) => {
+    const at = tags.get(name);
+    if (at === undefined) {
+      return;
+    }
+    if (text(at) === "curv") {
+      const count = view.getUint32(at + 8);
+      const entry = (i) => view.getUint16(at + 12 + 2 * Math.min(i, count - 1)) / 65535;
+      if (count === 0) {
+        return identity;
+      }
+      if (count === 1) {
+        const gamma = view.getUint16(at + 12) / 256;
+        return (x) => x ** gamma;
+      }
+      return (x) => {
+        const position = x * (count - 1);
+        const low = Math.floor(position);
+        return entry(low) + (entry(low + 1) - entry(low)) * (position - low);
+      };
+    }
+    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));
+      if (kind === 0) {
+        return (x) => x ** g;
+      }
+      if (kind <= 2) {
+        return (x) => x >= -b / a ? (a * x + b) ** g + c : c;
+      }
+      return (x) => x >= d ? (a * x + b) ** g + e : c * x + f;
+    }
+  };
+  try {
+    if (text(16) === "GRAY") {
+      const k = curve("kTRC");
+      return k && {
+        colorants: [...d50, 0, 0, 0, 0, 0, 0],
+        curves: [k, k, k]
+      };
+    }
+    const [r, g, b] = [xyz("rXYZ"), xyz("gXYZ"), xyz("bXYZ")];
+    const [rc, gc, bc] = [curve("rTRC"), curve("gTRC"), curve("bTRC")];
+    if (text(16) !== "RGB " || !r || !g || !b || !rc || !gc || !bc) {
+      return;
+    }
+    return {
+      colorants: [...r, ...g, ...b],
+      curves: [rc, gc, bc]
+    };
+  } catch {
+    return;
+  }
+}
+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);
+  if (!table.every(Number.isFinite)) {
+    profile = srgb;
+    table = sampleCurves(profile.curves);
+  }
+  return {
+    table,
+    matrix: multiplyMat3(xyzToRec2020, profile.colorants)
+  };
+}
+
+// src/decode/instantiate.ts
+import createLibRaw from "./libraw.js";
+function instantiateDecoder(module) {
+  return new Promise((resolve, reject) => {
+    createLibRaw({
+      instantiateWasm(imports, ready) {
+        WebAssembly.instantiate(module, imports).then((instance) => ready(instance, module), reject);
+        return {};
+      }
+    }).then(resolve, reject);
+  });
+}
+
+// src/decode/tiff-worker.ts
+self.onmessage = async ({
+  data: { file, module }
+}) => {
+  try {
+    const raw = await instantiateDecoder(module);
+    const bytes = new Uint8Array(await file.arrayBuffer());
+    const pointer = raw._malloc(bytes.length);
+    if (!pointer) {
+      throw Error("Not enough memory to open TIFF.");
+    }
+    let source = 0;
+    try {
+      raw.HEAPU8.set(bytes, pointer);
+      source = raw._tiff_open(pointer, bytes.length);
+      if (!source) {
+        throw Error(raw.UTF8ToString(raw._tiff_error()));
+      }
+      const metadataIndex = raw._tiff_metadata(source) / 4;
+      const metadata = raw.HEAPU32.slice(metadataIndex, metadataIndex + 9);
+      const [, height, , , bitsPerSample, , , , rowBytes] = metadata;
+      const byteLength = height * rowBytes;
+      const originalOffset = raw._tiff_original_offset(source);
+      const pixelPointer = raw._tiff_pixels(source);
+      const data = originalOffset ? bytes.subarray(originalOffset, originalOffset + byteLength) : raw.HEAPU8.slice(pixelPointer, pixelPointer + byteLength);
+      const bigEndian = Boolean(raw._tiff_big_endian(source));
+      const profilePointer = raw._tiff_profile(source);
+      const profileSize = raw._tiff_profile_size(source);
+      const profile = profileSize ? raw.HEAPU8.slice(profilePointer, profilePointer + profileSize) : undefined;
+      const color = tiffColor(profile, bitsPerSample === 0);
+      self.postMessage({ data, metadata, color, bigEndian }, { transfer: [data.buffer, metadata.buffer, color.table.buffer] });
+    } finally {
+      if (source) {
+        raw._tiff_close(source);
+      }
+      raw._free(pointer);
+    }
+  } catch (error) {
+    self.postMessage({
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+};

package/dist/types.d.ts

@@ -0,0 +1,51 @@
+export type WhiteBalance = {
+    temperature: number;
+    tint: number;
+};
+/** Column-major camera RGB to linear Rec.2020/D65, after applying gains. */
+export type Calibration = {
+    gains: number[];
+    matrix: number[];
+};
+export type RawMetadata = {
+    /** Sensor dimensions before applying the LibRaw orientation bitmask. */
+    size: [number, number];
+    /** LibRaw orientation bitmask: 4 transposes, 2 mirrors vertically, 1 mirrors horizontally. */
+    flip: number;
+    /** Row-major repeating CFA: R=0, G=1 or 3, B=2; null means camera RGB. */
+    cfa: number[] | null;
+    /** Square CFA side length; defaults to 2 for Bayer. */
+    cfaSize?: number;
+    /** Black level per CFA color index, in sensor units. */
+    black: number[];
+    /** Saturation level, in sensor units. */
+    white: number;
+    /** Five radial coefficients, two origin coordinates, two coordinate scales. */
+    vignette: number[];
+    demosaic: "gpu" | "cpu" | "none";
+    /** Float samples are already normalized by the DNG SDK. */
+    sampleFormat?: "uint16" | "float32";
+    whiteBalanceOrigin?: "as-shot" | "daylight";
+};
+/** One uint16 sample per mosaic pixel; four uint16 or float32 samples for camera RGB. */
+export type RawPixels = RawMetadata & {
+    data: Uint16Array<ArrayBuffer> | Float32Array<ArrayBuffer>;
+};
+export type RawReply = {
+    /** Present only when the request opened a file. */
+    image?: RawPixels;
+    calibration: Calibration;
+    asShot: WhiteBalance;
+};
+export type LoadOptions = {
+    /** Aborting rejects a pending load with the signal's reason; a loaded source is unaffected. */
+    signal?: AbortSignal;
+};
+export type DevelopOptions = {
+    destination: GPUTexture;
+    calibration: Calibration;
+    /** Exposure in stops, default zero. */
+    exposure?: number;
+    /** If omitted, submit immediately on the consumer's device. */
+    encoder?: GPUCommandEncoder;
+};

package/dist/worker.js

@@ -0,0 +1,116 @@
+// src/decode/instantiate.ts
+import createLibRaw from "./libraw.js";
+function instantiateDecoder(module) {
+  return new Promise((resolve, reject) => {
+    createLibRaw({
+      instantiateWasm(imports, ready) {
+        WebAssembly.instantiate(module, imports).then((instance) => ready(instance, module), reject);
+        return {};
+      }
+    }).then(resolve, reject);
+  });
+}
+
+// src/decode/worker.ts
+var module = Promise.withResolvers();
+var decoder = module.promise.then(instantiateDecoder);
+var source = 0;
+var asShot;
+self.onmessage = async ({
+  data
+}) => {
+  if ("module" in data) {
+    module.resolve(data.module);
+    return;
+  }
+  const { id, value } = data;
+  try {
+    const raw = await decoder;
+    let image;
+    let temperature = 0;
+    let tint = 0;
+    if (value instanceof Blob) {
+      const bytes = new Uint8Array(await value.arrayBuffer());
+      const pointer2 = raw._malloc(bytes.length);
+      if (!pointer2) {
+        throw Error("Not enough memory to open this RAW image.");
+      }
+      try {
+        raw.HEAPU8.set(bytes, pointer2);
+        if (source) {
+          raw._raw_close(source);
+          source = 0;
+        }
+        source = raw._raw_open(pointer2, bytes.length);
+        if (!source) {
+          throw Error(raw.UTF8ToString(raw._raw_error()));
+        }
+        const width = raw._raw_width(source);
+        const height = raw._raw_height(source);
+        const mosaic = Boolean(raw._raw_mosaic(source));
+        const demosaic = raw._raw_cpu_demosaic(source) ? "cpu" : "none";
+        const originalOffset = raw._raw_original_offset(source);
+        const floating = Boolean(raw._raw_float(source));
+        const pixelPointer = raw._raw_pixels(source);
+        const Samples = floating ? Float32Array : Uint16Array;
+        const sampleCount = width * height * (mosaic ? 1 : 4);
+        const blackIndex = raw._raw_black(source) / 8;
+        const cfaIndex = raw._raw_cfa(source) / 4;
+        const cfaSize = raw._raw_cfa_size(source);
+        const vignetteIndex = raw._raw_vignette(source) / 8;
+        image = {
+          size: [width, height],
+          sampleFormat: floating ? "float32" : "uint16",
+          whiteBalanceOrigin: raw._raw_daylight_balance(source) ? "daylight" : "as-shot",
+          demosaic: mosaic ? "gpu" : demosaic,
+          data: originalOffset ? new Uint16Array(bytes.buffer, originalOffset, width * height) : new Samples(raw.HEAPU8.slice(pixelPointer, pixelPointer + sampleCount * Samples.BYTES_PER_ELEMENT).buffer),
+          black: Array.from(raw.HEAPF64.subarray(blackIndex, blackIndex + 4)),
+          white: raw._raw_white(source),
+          flip: raw._raw_flip(source),
+          vignette: Array.from(raw.HEAPF64.subarray(vignetteIndex, vignetteIndex + 9)),
+          cfaSize,
+          cfa: mosaic ? Array.from(raw.HEAPU32.subarray(cfaIndex, cfaIndex + cfaSize * cfaSize)) : null
+        };
+        asShot = {
+          temperature: raw._raw_temperature(source),
+          tint: raw._raw_tint(source)
+        };
+        raw._raw_free_pixels(source);
+      } finally {
+        raw._free(pointer2);
+      }
+    } else if (value.temperature !== asShot.temperature || value.tint !== asShot.tint) {
+      temperature = value.temperature;
+      tint = value.tint;
+    }
+    const pointer = raw._raw_calibration(source, temperature, tint);
+    if (!pointer) {
+      throw Error(raw.UTF8ToString(raw._raw_error()));
+    }
+    const values = raw.HEAPF64.subarray(pointer / 8, pointer / 8 + 12);
+    const reply = {
+      image,
+      asShot,
+      calibration: {
+        gains: Array.from(values.subarray(0, 3)),
+        matrix: [
+          values[3],
+          values[6],
+          values[9],
+          values[4],
+          values[7],
+          values[10],
+          values[5],
+          values[8],
+          values[11]
+        ]
+      }
+    };
+    self.postMessage({ id, ...reply }, { transfer: image ? [image.data.buffer] : [] });
+  } catch (error) {
+    self.postMessage({
+      id,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+};

package/docs/conversion.md

@@ -0,0 +1,52 @@
+# Convert a RAW file to PNG with Bun
+
+This example uses `vgpu/node` for a real GPU device and `pngjs` for encoding. Install those in your script's project with `bun add vgpu pngjs`, alongside the built `raw-webgpu` package. Save the snippet as `convert.ts` and run `bun convert.ts`.
+
+```ts
+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" });
+  try {
+    source.createDevelopPass().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;
+    }
+    await Bun.write("photo.png", PNG.sync.write(image));
+  } finally {
+    output.color.dispose();
+  }
+} finally {
+  decoder.dispose();
+  gpu.dispose();
+}
+```
+
+For JPEG, install `jpeg-js`, import its `encode` function and replace the final write with `await Bun.write("photo.jpg", encode(image, 95).data)`. For BMP, use `bmp-js` instead and call `image.data.swap32()` before encoding because it expects ABGR bytes rather than RGBA.
+
+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.

package/native/bridge.cpp

@@ -0,0 +1,119 @@
+// C entry points called from src/decode/worker.ts; see src/decode/libraw.d.ts for the signatures.
+
+#include "raw.h"
+#include <emscripten/emscripten.h>
+#include <stdexcept>
+#include <string>
+
+static std::string error;
+
+extern "C" {
+
+EMSCRIPTEN_KEEPALIVE const char *raw_error() {
+    return error.c_str();
+}
+
+EMSCRIPTEN_KEEPALIVE Raw *raw_open(void *bytes, unsigned length) {
+    try {
+        auto source = std::make_unique<Raw>();
+        prepare_pixels(source.get(), bytes, length);
+        prepare_calibration(source.get(), bytes, length);
+        pack_pixels(source.get());
+        return source.release();
+    } catch (const std::exception &exception) {
+        error = exception.what();
+    } catch (...) {
+        error = "RAW calibration or decoding failed";
+    }
+    return nullptr;
+}
+
+EMSCRIPTEN_KEEPALIVE double *raw_calibration(Raw *source, double temperature, double tint) {
+    try {
+        return calibrate(source, temperature, tint);
+    } catch (...) {
+        error = "RAW white balance calibration failed";
+        return nullptr;
+    }
+}
+
+EMSCRIPTEN_KEEPALIVE unsigned raw_original_offset(Raw *source) {
+    return source->originalOffset;
+}
+
+EMSCRIPTEN_KEEPALIVE unsigned raw_width(Raw *source) {
+    return source->width;
+}
+
+EMSCRIPTEN_KEEPALIVE unsigned raw_height(Raw *source) {
+    return source->height;
+}
+
+EMSCRIPTEN_KEEPALIVE unsigned raw_flip(Raw *source) {
+    return source->flip;
+}
+
+EMSCRIPTEN_KEEPALIVE unsigned raw_cpu_demosaic(Raw *source) {
+    return source->cpuPrepared && source->sensorMosaic;
+}
+
+EMSCRIPTEN_KEEPALIVE unsigned raw_float(Raw *source) {
+    return !source->prepared.empty();
+}
+
+EMSCRIPTEN_KEEPALIVE unsigned raw_daylight_balance(Raw *source) {
+    return source->daylightBalance;
+}
+
+EMSCRIPTEN_KEEPALIVE unsigned raw_mosaic(Raw *source) {
+    return source->mosaic;
+}
+
+EMSCRIPTEN_KEEPALIVE unsigned raw_cfa_size(Raw *source) {
+    return source->cfaSize;
+}
+
+EMSCRIPTEN_KEEPALIVE unsigned *raw_cfa(Raw *source) {
+    return source->cfa;
+}
+
+EMSCRIPTEN_KEEPALIVE double *raw_black(Raw *source) {
+    return source->black;
+}
+
+EMSCRIPTEN_KEEPALIVE double *raw_vignette(Raw *source) {
+    return source->vignette;
+}
+
+EMSCRIPTEN_KEEPALIVE double raw_white(Raw *source) {
+    return source->white;
+}
+
+// Packed samples: LibRaw's processed image when one was made, else its raw buffer.
+EMSCRIPTEN_KEEPALIVE void *raw_pixels(Raw *source) {
+    if (!source->prepared.empty()) {
+        return source->prepared.data();
+    }
+    return source->decoder.imgdata.image
+               ? static_cast<void *>(source->decoder.imgdata.image)
+               : static_cast<void *>(source->decoder.imgdata.rawdata.raw_image);
+}
+
+// Releases the decoded samples once copied out; calibration stays available.
+EMSCRIPTEN_KEEPALIVE void raw_free_pixels(Raw *source) {
+    source->decoder.recycle();
+    std::vector<float>().swap(source->prepared);
+}
+
+EMSCRIPTEN_KEEPALIVE double raw_temperature(Raw *source) {
+    return source->asShot.Temperature();
+}
+
+EMSCRIPTEN_KEEPALIVE double raw_tint(Raw *source) {
+    return source->asShot.Tint();
+}
+
+EMSCRIPTEN_KEEPALIVE void raw_close(Raw *source) {
+    delete source;
+}
+}