longpipe 0.0.1

package/dist/index.js

@@ -0,0 +1,1731 @@
+var v=[{model:"xxs",dtype:"f16",resolution:{w:128,h:72},skipFrames:3},{model:"xs",dtype:"f16",resolution:{w:192,h:108},skipFrames:1},{model:"small",dtype:"f16",resolution:{w:256,h:144},skipFrames:1},{model:"compact",dtype:"f16",resolution:{w:256,h:144},skipFrames:1},{model:"medium",dtype:"f16",resolution:{w:256,h:144},skipFrames:1},{model:"large",dtype:"f32",resolution:{w:256,h:144},skipFrames:0},{model:"xl",dtype:"f32",resolution:{w:512,h:288},skipFrames:0}];var w=(...i)=>console.log("[longpipe/adaptive]",...i),Qe=2e3,Ze=1e4,et=30,tt=20,rt=5e3,at=.3,it=15e3,C=class{constructor(t){this.opts=t;this.currentPresetIdx=v.findIndex(e=>e.model===t.initialModel),this.lastSwapAt=performance.now();}opts;timer=null;currentPresetIdx;lastSwapAt=0;overshootStart=0;headroomStart=0;start(){w(`started; backend=${this.opts.backendKind} initial=${this.opts.initialModel} idx=${this.currentPresetIdx}`),this.timer=setInterval(()=>{this.tick().catch(t=>w("tick failed:",t));},Qe);}stop(){this.timer&&clearInterval(this.timer),this.timer=null;}async tick(){if(typeof document<"u"&&document.hidden)return;let t=performance.now();if(t-this.lastSwapAt<Ze)return;let e=await this.opts.getStats();if(e.fps<tt?(this.overshootStart===0&&(this.overshootStart=t),t-this.overshootStart>=rt&&this.tryDowngrade(e.fps)):this.overshootStart=0,this.opts.backendKind==="webgpu"&&e.modelMs>0){let r=1e3/et*at;e.modelMs<r?(this.headroomStart===0&&(this.headroomStart=t),t-this.headroomStart>=it&&this.tryUpgrade(e.modelMs,r)):this.headroomStart=0;}}tryDowngrade(t){if(this.currentPresetIdx<=0)return;let e=this.currentPresetIdx-1;w(`downgrade ${v[this.currentPresetIdx].model} \u2192 ${v[e].model} (fps=${t})`),this.swap(e);}tryUpgrade(t,e){if(this.currentPresetIdx>=v.length-1)return;let r=this.currentPresetIdx+1;w(`upgrade ${v[this.currentPresetIdx].model} \u2192 ${v[r].model} (modelMs=${t.toFixed(1)} < ${e.toFixed(1)})`),this.swap(r);}async swap(t){let e=v[t];this.lastSwapAt=performance.now(),this.overshootStart=0,this.headroomStart=0;try{let r=this.opts.buildWeightsUrl(this.opts.weightsBaseUrl,e.model),a=await fetch(r);if(!a.ok)throw new Error(`weights fetch failed: ${a.status} ${r}`);let o=await a.arrayBuffer();await this.opts.swapPreset(e.model,o),this.currentPresetIdx=t,w(`swap to ${e.model} done`);}catch(r){w("swap failed:",r),this.opts.onError?.({message:`adaptive preset swap failed: ${r.message??String(r)}`,source:"adaptive",recoverable:true,cause:r});}}};async function re(i){let t,e=false;if(i instanceof HTMLVideoElement){if(t=i.currentSrc||i.src,!t)throw new Error("background video: HTMLVideoElement has no src")}else if(i instanceof Blob)t=URL.createObjectURL(i),e=true;else if(typeof i=="string")t=i;else throw new Error("background video: unsupported input shape");let r=document.createElement("video");r.crossOrigin="anonymous",r.muted=true,r.loop=true,r.playsInline=true,r.src=t,await new Promise((p,l)=>{r.addEventListener("loadeddata",()=>p(),{once:true}),r.addEventListener("error",()=>l(new Error(`background video: failed to load ${t}`)),{once:true});});try{await r.play();}catch(p){throw new Error(`background video: play() rejected \u2014 ${p.message}`)}let a=new MessageChannel,o=a.port1,s=a.port2,n=false,u=r.requestVideoFrameCallback?.bind(r);if(u){let p=(l,f)=>{if(!n){try{let b=new VideoFrame(r,{timestamp:f.mediaTime*1e6});o.postMessage({frame:b},[b]);}catch{}u(p);}};u(p);}else {let p=()=>{if(!n){try{let l=new VideoFrame(r,{timestamp:performance.now()*1e3});o.postMessage({frame:l},[l]);}catch{}requestAnimationFrame(p);}};requestAnimationFrame(p);}return {port:s,transferList:[s],cleanup:()=>{n=true,o.close(),r.pause(),r.removeAttribute("src"),r.load(),e&&URL.revokeObjectURL(t);}}}var J=4,X=8,ae=16;async function Q(i){if(typeof i=="string")return i==="none"?{background:{kind:"none"}}:i==="blur"?{background:{kind:"blur",sigma:X}}:{background:{kind:"image",bitmap:await oe(i)}};if(i instanceof ImageBitmap)return {background:{kind:"image",bitmap:i}};if(typeof HTMLImageElement<"u"&&i instanceof HTMLImageElement)return {background:{kind:"image",bitmap:await createImageBitmap(i)}};if(typeof HTMLVideoElement<"u"&&i instanceof HTMLVideoElement)return await ie(i);let t=i;if(t.color)return {background:{kind:"color",rgb:t.color}};if(t.blur!==void 0)return {background:{kind:"blur",sigma:ot(t.blur)}};if(t.image!==void 0)return {background:{kind:"image",bitmap:await st(t.image)}};if(t.video!==void 0)return await ie(t.video);throw new Error(`background: unrecognized input shape \u2014 ${P(i)}`)}async function ie(i){let t;if(typeof i=="string")t=i;else if(typeof HTMLVideoElement<"u"&&i instanceof HTMLVideoElement)t=i;else if(i&&typeof i=="object"&&"data"in i&&"type"in i)t=i.data instanceof Blob?i.data:new Blob([i.data],{type:i.type});else throw new Error(`background.video: unrecognized shape \u2014 ${P(i)}`);let e=await re(t);return {background:{kind:"video",port:e.port},transferList:e.transferList,cleanup:e.cleanup}}function ot(i){if(i===true)return X;if("sigma"in i){if(typeof i.sigma!="number"||!Number.isFinite(i.sigma)||i.sigma<0)throw new Error(`background.blur.sigma must be a non-negative number, got ${i.sigma}`);return i.sigma}if("strength"in i){let t=i.strength;if(typeof t=="number"){let e=Math.max(0,Math.min(1,t));return J+(ae-J)*e}if(t==="low")return J;if(t==="medium")return X;if(t==="high")return ae;throw new Error(`background.blur.strength must be 'low' | 'medium' | 'high' | number, got ${P(t)}`)}throw new Error(`background.blur: must be true, { strength }, or { sigma } \u2014 got ${P(i)}`)}async function st(i){if(i instanceof ImageBitmap)return i;if(typeof HTMLImageElement<"u"&&i instanceof HTMLImageElement)return createImageBitmap(i);if(typeof i=="string")return oe(i);if(i&&typeof i=="object"&&"data"in i&&"type"in i){let t=i.data instanceof Blob?i.data:new Blob([i.data],{type:i.type});return createImageBitmap(t)}throw new Error(`background.image: unrecognized shape \u2014 ${P(i)}`)}async function oe(i){let t=await fetch(i);if(!t.ok)throw new Error(`background: failed to load image from ${i} (HTTP ${t.status})`);let e=await t.blob();return createImageBitmap(e)}function P(i){return i===null?"null":typeof i!="object"?typeof i+"("+String(i)+")":`${i.constructor?.name??"Object"} ${JSON.stringify(i).slice(0,80)}`}function se(){return {input:"MediaStreamTrackProcessor"in self?"mstp":"rvfc-postmessage",output:"MediaStreamTrackGenerator"in self?"mstg":nt()?"transfer-capture":"bitmap-shuttle"}}var T=null;function nt(){return T!==null||(T=!/Firefox/.test(navigator.userAgent)),T}function ne(i,t,e){let r=[i];return e==="passthrough"&&r.push(...t.getAudioTracks()),new MediaStream(r)}var W=(...i)=>console.log("[longpipe/worker_controller]",...i),M=class{worker;listeners=new Map;persistentEvents=new Set;constructor(t){this.worker=t,this.worker.addEventListener("message",this.handleMessage.bind(this)),W("constructed; message listener attached");}handleMessage(t){let{request_id:e,res:r}=t.data,a=this.listeners.get(e);W("msg received: request_id=",e,"handler?",!!a,"persistent?",this.persistentEvents.has(e)),a&&(a(r),this.persistentEvents.has(e)||this.listeners.delete(e));}addPersistentListener(t,e){this.persistentEvents.add(t),this.listeners.set(t,e),W("addPersistentListener:",t);}removePersistentListener(t){this.persistentEvents.delete(t),this.listeners.delete(t);}sendMessage(t,e,r=[]){let a=crypto.randomUUID();return W("sendMessage:",t,"request_id=",a,"transferables=",r.length),new Promise(o=>{this.listeners.set(a,n=>o(n));let s={cmd:t,data:e,request_id:a};this.worker.postMessage(s,r);})}terminate(){this.worker.terminate(),this.listeners.clear(),this.persistentEvents.clear();}};function ue(i){let t=document.createElement("video");t.srcObject=i,t.muted=true,t.autoplay=true,t.playsInline=true,t.play().catch(c=>{console.warn("[input-postmessage/main] video.play() rejected:",c);});let e=t.requestVideoFrameCallback?.bind(t);if(!e)throw new Error("setupPostMessageInput: requestVideoFrameCallback not supported on this browser");let r=new MessageChannel,a=r.port1,o=r.port2,s=false,n=(c,p)=>{if(!s){try{let l=new VideoFrame(t,{timestamp:p.mediaTime*1e6});a.postMessage({frame:l},[l]);}catch(l){console.warn("[input-postmessage/main] VideoFrame() failed; skipping frame:",l);}e(n);}};return e(n),{port:o,transferList:[o],cleanup:()=>{s=true,a.close(),t.srcObject=null,t.pause();}}}function pe(i){let t=i.getVideoTracks();if(t.length===0)throw new Error("setupMstpInput: input MediaStream has no video tracks");let e=t[0],r=self.MediaStreamTrackProcessor;if(!r)throw new Error("setupMstpInput: MediaStreamTrackProcessor not supported on this browser");let o=new r({track:e}).readable;return {readable:o,transferList:[o],cleanup:()=>{o.cancel().catch(()=>{});}}}function le(i,t){switch(i){case "mstp":{let e=pe(t);return {initFields:{inputReadable:e.readable},transferList:e.transferList,cleanup:e.cleanup}}case "rvfc-postmessage":{let e=ue(t);return {initFields:{inputPort:e.port},transferList:e.transferList,cleanup:e.cleanup}}}}function ce(i,t=30){let e=document.createElement("canvas");e.width=i.w,e.height=i.h;let r=e.getContext("bitmaprenderer");if(!r)throw new Error("setupBitmapShuttleOutput: bitmaprenderer context not available");let o=e.captureStream(t).getVideoTracks();if(o.length===0)throw new Error("setupBitmapShuttleOutput: captureStream produced no video tracks");let s=o[0],n=new MessageChannel,u=n.port1,c=n.port2,p=false,l=null,f=()=>{},b=3,U=0;return u.onmessage=I=>{if(p){if(U++,U<b){I.data.bmp.close();return}f();}try{r.transferFromImageBitmap(I.data.bmp);}catch(g){console.warn("[bitmap-shuttle/main] transferFromImageBitmap failed:",g);}},u.start(),{videoTrack:s,port:c,transferList:[c],startPassthrough:I=>{if(p)return;p=true;let g=document.createElement("video");g.srcObject=I,g.muted=true,g.playsInline=true,g.play().catch(()=>{}),l=g;let G="requestVideoFrameCallback"in g?y=>{g.requestVideoFrameCallback(y);}:y=>{requestAnimationFrame(y);},B=()=>{if(p){if(g.videoWidth===0){G(B);return}createImageBitmap(g,{resizeWidth:e.width,resizeHeight:e.height,resizeQuality:"medium"}).then(y=>{if(!p){y.close();return}try{r.transferFromImageBitmap(y);}catch{}G(B);}).catch(()=>{G(B);});}};G(B),f=()=>{p=false,l&&(l.srcObject=null,l.pause(),l=null);};},cleanup:()=>{f(),u.onmessage=null,u.close(),s.stop();}}}function de(){let i=self.MediaStreamTrackGenerator;if(!i)throw new Error("setupMstgOutput: MediaStreamTrackGenerator not supported on this browser");let t=new i({kind:"video"}),e=t.writable;return {videoTrack:t,writable:e,transferList:[e],cleanup:()=>{e.abort().catch(()=>{}),t.stop();}}}function fe(i,t=30){let e=document.createElement("canvas");e.width=i.w,e.height=i.h;let a=e.captureStream(t).getVideoTracks();if(a.length===0)throw new Error("setupTransferCaptureOutput: captureStream produced no video tracks");let o=a[0],s=e.transferControlToOffscreen();return {videoTrack:o,canvas:s,transferList:[s],cleanup:()=>{o.stop();}}}function me(i,t){switch(i){case "mstg":{let e=de();return {videoTrack:e.videoTrack,initFields:{outputWritable:e.writable},transferList:e.transferList,cleanup:e.cleanup}}case "transfer-capture":{let e=fe(t);return {videoTrack:e.videoTrack,initFields:{outputCanvas:e.canvas},transferList:e.transferList,cleanup:e.cleanup}}case "bitmap-shuttle":{let e=ce(t);return {videoTrack:e.videoTrack,initFields:{outputPort:e.port},transferList:e.transferList,startPassthrough:e.startPassthrough,cleanup:e.cleanup}}}}var ut="https://cdn.longpipe.dev/models/v/0.0.1/",pt={background:"blur",preset:"auto",weightsBaseUrl:ut,audio:"passthrough",enabled:true,adaptive:true},ge={w:1280,h:720};function lt(i,t){if(t)return t;let r=i.getVideoTracks()[0]?.getSettings()??{};return {w:r.width||ge.w,h:r.height||ge.h}}function be(i,t){return `${i.replace(/\/$/,"")}/model_${t}.bin`}var Z=class{stream;ready;controller;worker;inputCleanup;outputCleanup;adaptive=null;bgCleanup=null;constructor(t,e){let r={...pt,...e},a=se(),o=le(a.input,t),s=lt(t,r.outputResolution),n=me(a.output,s);this.inputCleanup=o.cleanup,this.outputCleanup=n.cleanup,this.stream=ne(n.videoTrack,t,r.audio),n.startPassthrough?.(t),this.worker=new Worker(new URL("./worker/index.ts",import.meta.url),{type:"module"}),this.controller=new M(this.worker),this.ready=new Promise((p,l)=>{this.controller.addPersistentListener("ready",()=>{console.log("[longpipe/pipeline] ready handler invoked; resolving .ready"),r.onReady?.(),p();}),this.controller.addPersistentListener("error",f=>{console.error(`[longpipe/pipeline] error (${f.source}):`,f.message),f.recoverable||l(new Error(f.message)),r.onError?.(f);});});let u={topology:a,preset:r.preset,enabled:r.enabled,backend:"auto",dtype:"f16",canvasSize:s,...o.initFields,...n.initFields},c=[...o.transferList,...n.transferList];this.bootstrap(u,r.background,c,r.weightsBaseUrl,r.adaptive,r.onError);}async bootstrap(t,e,r,a,o,s){try{console.log("[longpipe/pipeline] normalizing background\u2026");let n=await Q(e);this.bgCleanup=n.cleanup??null;let u={...t,background:n.background},c=[...r,...n.transferList??[]];console.log("[longpipe/pipeline] sending init\u2026");let p=await this.controller.sendMessage("init",u,c);console.log("[longpipe/pipeline] init resolved:",p);let l=be(a,p.resolvedPreset.model);console.log("[longpipe/pipeline] fetching weights:",l);let f=await fetch(l);if(!f.ok)throw new Error(`weights fetch failed: ${f.status} ${l}`);let b=await f.arrayBuffer();console.log("[longpipe/pipeline] weights bytes:",b.byteLength),console.log("[longpipe/pipeline] sending startRender\u2026"),await this.controller.sendMessage("startRender",{weights:b},[b]),console.log("[longpipe/pipeline] startRender resolved; awaiting first frame"),u.preset==="auto"&&o&&(this.adaptive=new C({backendKind:p.resolvedBackend,initialModel:p.resolvedPreset.model,weightsBaseUrl:a,buildWeightsUrl:be,getStats:()=>this.getStats(),swapPreset:async(U,K)=>{await this.controller.sendMessage("setPreset",{preset:U,weights:K},[K]);},onError:s}),this.adaptive.start());}catch(n){console.error("[longpipe/pipeline] bootstrap failed:",n),this.controller.handleMessage.call(this.controller,{data:{request_id:"error",res:{message:n.message??String(n),source:"worker",recoverable:false,cause:n}}});}}then(t,e){return this.ready.then(()=>t?t(this):this,e)}async setBackground(t){let e=await Q(t),r=this.bgCleanup;this.bgCleanup=e.cleanup??null,await this.controller.sendMessage("setBackground",e.background,e.transferList),r?.();}setPreset(t,e){this.controller.sendMessage("setPreset",{preset:t,weights:e});}setEnabled(t){this.controller.sendMessage("setEnabled",{enabled:t});}async getStats(){return this.controller.sendMessage("getStats",{})}destroy(){this.adaptive?.stop(),this.adaptive=null,this.bgCleanup?.(),this.bgCleanup=null,this.controller.sendMessage("destroy",{}),this.controller.terminate(),this.inputCleanup(),this.outputCleanup();}};var x=new Float32Array(1),k=new Uint32Array(x.buffer);function ct(i){x[0]=i;let t=k[0],e=t>>>16&32768,r=t&2147483647,a=(r>>>23)-127+15;if((t&2139095040)===2139095040)return (t&8388607)!==0?e|32256:e|31744;if(a>=31)return e|31744;if(a<=0){if(a<-10)return e;let c=r&8388607|8388608,p=14-a,l=c>>>p,f=c>>>p-1&1,b=(c&(1<<p-1)-1)!==0?1:0;return f&&(b||l&1)&&(l+=1),e|l}let o=r>>>13&1023,s=r>>>12&1,n=(r&4095)!==0?1:0,u=a<<10|o;return s&&(n||o&1)&&(u+=1,(u>>>10&31)===31)?e|31744:e|u}function dt(i){let t=(i&32768)<<16,e=(i&31744)>>>10,r=i&1023;if(e===0){if(r===0)return k[0]=t,x[0];let a=r,o=1;for(;(a&1024)===0;)a<<=1,o-=1;return a&=1023,k[0]=t|o+127-15<<23|a<<13,x[0]}return e===31?(k[0]=t|2139095040|r<<13,x[0]):(k[0]=t|e+127-15<<23|r<<13,x[0])}function he(i){let t=new Uint16Array(i.length);for(let e=0;e<i.length;e++)t[e]=ct(i[e]);return t}function ee(i){let t=new Float32Array(i.length);for(let e=0;e<i.length;e++)t[e]=dt(i[e]);return t}var d=class{constructor(t){this.backend=t;}backend;shader="";pipeline;bindGroup;uniformDefs=[];uniformBuffers={};createUniform(t,e){this.uniformDefs.push({name:t,type:e});}setUniform(t,e){let r=this.backend.device.createBuffer({size:e.byteLength,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST,mappedAtCreation:true});e instanceof Uint32Array?new Uint32Array(r.getMappedRange()).set(e):new Float32Array(r.getMappedRange()).set(e),r.unmap(),this.uniformBuffers[t]=r;}defaultBindGroup(){let t=[],e=0;for(let r of this.inputs)t.push({binding:e++,resource:{buffer:r.buffer}});for(let r of this.weights)t.push({binding:e++,resource:{buffer:r.buffer}});for(let r of this.uniformDefs)t.push({binding:e++,resource:{buffer:this.uniformBuffers[r.name]}});return t.push({binding:e,resource:{buffer:this.output.buffer}}),this.backend.device.createBindGroup({layout:this.pipeline.getBindGroupLayout(0),entries:t})}defaultSetup(){let t=this.backend.device.createShaderModule({code:this.shader});this.pipeline=this.backend.device.createComputePipeline({layout:"auto",compute:{module:t,entryPoint:"main"}}),this.bindGroup=this.defaultBindGroup();}run(){let t=this.backend.device.createCommandEncoder(),e=t.beginComputePass();e.setPipeline(this.pipeline),e.setBindGroup(0,this.bindGroup),e.dispatchWorkgroups(...this.dispatch),e.end(),this.backend.device.queue.submit([t.finish()]);}};var _e=`// Conv2d compute shader \u2014 handles all variants:
+//   1\xD71 (pointwise), 3\xD73, 5\xD75, strided, BN-fused
+//
+// Tensor layout: NHWC with channels in vec4 groups
+//   buffer index = y * out_w * out_groups + x * out_groups + o
+//
+// Weight layout: [K*K][out_groups][in_groups] array of mat4x4
+//   weight index = (ky*kernel_w + kx) * out_groups * in_groups + o * in_groups + i
+//   mat4x4[col][row] = weight(in_channel=col, out_channel=row)
+//   so (mat4x4 * vec4)[r] = sum_c(w(in=c, out=r) * input[c])  \u2014 correct matmul direction
+//
+// Padding model: only \`pad_top\` and \`pad_left\` are applied to the input offset.
+// Asymmetric SAME padding (top<bottom or left<right) is handled implicitly:
+// out-of-bounds reads on the right/bottom side are skipped via the bounds
+// check, so the runner only needs to specify the top/left pad.
+
+struct Params {
+    in_h        : u32,
+    in_w        : u32,
+    out_h       : u32,
+    out_w       : u32,
+    in_groups   : u32,   // in_channels / 4
+    out_groups  : u32,   // out_channels / 4
+    kernel_h    : u32,
+    kernel_w    : u32,
+    stride      : u32,
+    pad_top     : u32,
+    pad_left    : u32,
+    activation  : u32,   // 0 = none, 1 = relu6, 2 = relu
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read>       weight_buf : array<mat4x4<f32>>;
+@group(0) @binding(2) var<storage, read>       bias_buf   : array<vec4<f32>>;
+@group(0) @binding(3) var<uniform>             params     : Params;
+@group(0) @binding(4) var<storage, read_write> output_buf : array<vec4<f32>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;  // output column
+    let y = gid.y;  // output row
+    let o = gid.z;  // output channel group
+
+    if (x >= params.out_w || y >= params.out_h || o >= params.out_groups) {
+        return;
+    }
+
+    let I = params.in_groups;
+    let O = params.out_groups;
+
+    var result = bias_buf[o];
+
+    for (var ky = 0u; ky < params.kernel_h; ky++) {
+        for (var kx = 0u; kx < params.kernel_w; kx++) {
+            let in_y_s = i32(y * params.stride + ky) - i32(params.pad_top);
+            let in_x_s = i32(x * params.stride + kx) - i32(params.pad_left);
+
+            if (in_y_s < 0 || in_x_s < 0 ||
+                u32(in_y_s) >= params.in_h || u32(in_x_s) >= params.in_w) {
+                continue;
+            }
+
+            let in_y = u32(in_y_s);
+            let in_x = u32(in_x_s);
+            let z    = ky * params.kernel_w + kx;
+
+            for (var i = 0u; i < I; i++) {
+                let in_idx = in_y * params.in_w * I + in_x * I + i;
+                let w_idx  = z * O * I + o * I + i;
+                result += weight_buf[w_idx] * input_buf[in_idx];
+            }
+        }
+    }
+
+    if (params.activation == 1u) {
+        result = clamp(result, vec4<f32>(0.0), vec4<f32>(6.0));
+    } else if (params.activation == 2u) {
+        result = max(result, vec4<f32>(0.0));
+    }
+
+    let out_idx = y * params.out_w * O + x * O + o;
+    output_buf[out_idx] = result;
+}
+`;var ve=`enable f16;
+
+// Conv2d \u2014 full f16 variant.
+// All buffers (input, output, weights, bias) are f16. Weights are converted
+// from f32\u2192f16 in JavaScript before upload. mat4x4<f16> * vec4<f16> runs
+// entirely in f16 on hardware that has native f16 ALUs.
+
+struct Params {
+    in_h        : u32,
+    in_w        : u32,
+    out_h       : u32,
+    out_w       : u32,
+    in_groups   : u32,
+    out_groups  : u32,
+    kernel_h    : u32,
+    kernel_w    : u32,
+    stride      : u32,
+    pad_top     : u32,
+    pad_left    : u32,
+    activation  : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f16>>;
+@group(0) @binding(1) var<storage, read>       weight_buf : array<mat4x4<f16>>;
+@group(0) @binding(2) var<storage, read>       bias_buf   : array<vec4<f16>>;
+@group(0) @binding(3) var<uniform>             params     : Params;
+@group(0) @binding(4) var<storage, read_write> output_buf : array<vec4<f16>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;
+    let y = gid.y;
+    let o = gid.z;
+
+    if (x >= params.out_w || y >= params.out_h || o >= params.out_groups) {
+        return;
+    }
+
+    let I = params.in_groups;
+    let O = params.out_groups;
+
+    var result = bias_buf[o];
+
+    for (var ky = 0u; ky < params.kernel_h; ky++) {
+        for (var kx = 0u; kx < params.kernel_w; kx++) {
+            let in_y_s = i32(y * params.stride + ky) - i32(params.pad_top);
+            let in_x_s = i32(x * params.stride + kx) - i32(params.pad_left);
+
+            if (in_y_s < 0 || in_x_s < 0 ||
+                u32(in_y_s) >= params.in_h || u32(in_x_s) >= params.in_w) {
+                continue;
+            }
+
+            let in_y = u32(in_y_s);
+            let in_x = u32(in_x_s);
+            let z    = ky * params.kernel_w + kx;
+
+            for (var i = 0u; i < I; i++) {
+                let in_idx = in_y * params.in_w * I + in_x * I + i;
+                let w_idx  = z * O * I + o * I + i;
+                result += weight_buf[w_idx] * input_buf[in_idx];
+            }
+        }
+    }
+
+    if (params.activation == 1u) {
+        result = clamp(result, vec4<f16>(0.0h), vec4<f16>(6.0h));
+    } else if (params.activation == 2u) {
+        result = max(result, vec4<f16>(0.0h));
+    }
+
+    output_buf[y * params.out_w * O + x * O + o] = result;
+}
+`;function h(i,t,e,r){return typeof r=="number"?Math.floor((i+2*r-t)/e)+1:r==="same"?Math.ceil(i/e):Math.floor((i-t)/e)+1}function gt(i,t,e,r){return Math.floor(Math.max((t-1)*r+e-i,0)/2)}function _(i,t,e,r,a){return typeof i=="number"?i:i==="same"?gt(t,e,r,a):0}function m(i){return i instanceof Float32Array||i instanceof Uint16Array?i:new Float32Array(i)}var S=class extends d{inputs;weights;output;dispatch;shader;constructor(t,e,r,a){super(t),this.shader=t.dtype==="f16"?ve:_e;let o=h(e.h,a.kernel,a.stride,a.padding),s=h(e.w,a.kernel,a.stride,a.padding),n=e.c/4,u=a.outChannels/4,c=_(a.padding,e.h,o,a.kernel,a.stride),p=_(a.padding,e.w,s,a.kernel,a.stride);this.output=t.tensor(o,s,a.outChannels),this.inputs=[e],this.weights=[t.upload(m(r.weights)),t.upload(m(r.bias))],this.createUniform("params","Params"),this.setUniform("params",new Uint32Array([e.h,e.w,o,s,n,u,a.kernel,a.kernel,a.stride,c,p,a.activation==="relu6"?1:0])),this.defaultSetup(),this.dispatch=[Math.ceil(s/8),Math.ceil(o/8),u];}};var ye=`// Depthwise Conv2d \u2014 groups = in_channels (each channel convolved independently).
+//
+// Weight layout: [K*K][channel_groups] array of vec4
+//   weight index = (ky*kernel_w + kx) * channel_groups + c
+//   Each vec4 holds the kernel weight for 4 consecutive channels at one spatial position.
+//   Operation: element-wise multiply (each input channel multiplied by its own weight).
+//
+// Contrast with conv2d.wgsl which uses mat4x4 (dense cross-channel mixing).
+// 4\xD7 smaller weight buffer than a diagonal mat4x4 representation (4 floats vs 16 per group).
+//
+// Padding model: only \`pad_top\` and \`pad_left\` are applied to the input offset.
+// Asymmetric SAME padding is handled implicitly via the in_h/in_w bounds check.
+
+struct Params {
+    in_h           : u32,
+    in_w           : u32,
+    out_h          : u32,
+    out_w          : u32,
+    channel_groups : u32,   // channels / 4
+    kernel_h       : u32,
+    kernel_w       : u32,
+    stride         : u32,
+    pad_top        : u32,
+    pad_left       : u32,
+    apply_relu6    : u32,
+    _pad0          : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read>       weight_buf : array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read>       bias_buf   : array<vec4<f32>>;
+@group(0) @binding(3) var<uniform>             params     : Params;
+@group(0) @binding(4) var<storage, read_write> output_buf : array<vec4<f32>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;  // output column
+    let y = gid.y;  // output row
+    let c = gid.z;  // channel group
+
+    if (x >= params.out_w || y >= params.out_h || c >= params.channel_groups) {
+        return;
+    }
+
+    let C = params.channel_groups;
+
+    var result = bias_buf[c];
+
+    for (var ky = 0u; ky < params.kernel_h; ky++) {
+        for (var kx = 0u; kx < params.kernel_w; kx++) {
+            let in_y_s = i32(y * params.stride + ky) - i32(params.pad_top);
+            let in_x_s = i32(x * params.stride + kx) - i32(params.pad_left);
+
+            if (in_y_s < 0 || in_x_s < 0 ||
+                u32(in_y_s) >= params.in_h || u32(in_x_s) >= params.in_w) {
+                continue;
+            }
+
+            let in_y = u32(in_y_s);
+            let in_x = u32(in_x_s);
+            let z    = ky * params.kernel_w + kx;
+
+            let in_idx = in_y * params.in_w * C + in_x * C + c;
+            let w_idx  = z * C + c;
+            result += weight_buf[w_idx] * input_buf[in_idx];
+        }
+    }
+
+    if (params.apply_relu6 == 1u) {
+        result = clamp(result, vec4<f32>(0.0), vec4<f32>(6.0));
+    }
+
+    let out_idx = y * params.out_w * C + x * C + c;
+    output_buf[out_idx] = result;
+}
+`;var we=`enable f16;
+
+// Depthwise conv2d \u2014 full f16 variant. All buffers f16.
+
+struct Params {
+    in_h           : u32,
+    in_w           : u32,
+    out_h          : u32,
+    out_w          : u32,
+    channel_groups : u32,
+    kernel_h       : u32,
+    kernel_w       : u32,
+    stride         : u32,
+    pad_top        : u32,
+    pad_left       : u32,
+    apply_relu6    : u32,
+    _pad0          : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f16>>;
+@group(0) @binding(1) var<storage, read>       weight_buf : array<vec4<f16>>;
+@group(0) @binding(2) var<storage, read>       bias_buf   : array<vec4<f16>>;
+@group(0) @binding(3) var<uniform>             params     : Params;
+@group(0) @binding(4) var<storage, read_write> output_buf : array<vec4<f16>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;
+    let y = gid.y;
+    let c = gid.z;
+
+    if (x >= params.out_w || y >= params.out_h || c >= params.channel_groups) {
+        return;
+    }
+
+    let C = params.channel_groups;
+
+    var result = bias_buf[c];
+
+    for (var ky = 0u; ky < params.kernel_h; ky++) {
+        for (var kx = 0u; kx < params.kernel_w; kx++) {
+            let in_y_s = i32(y * params.stride + ky) - i32(params.pad_top);
+            let in_x_s = i32(x * params.stride + kx) - i32(params.pad_left);
+
+            if (in_y_s < 0 || in_x_s < 0 ||
+                u32(in_y_s) >= params.in_h || u32(in_x_s) >= params.in_w) {
+                continue;
+            }
+
+            let in_y = u32(in_y_s);
+            let in_x = u32(in_x_s);
+            let z    = ky * params.kernel_w + kx;
+
+            let in_idx = in_y * params.in_w * C + in_x * C + c;
+            let w_idx  = z * C + c;
+            result += weight_buf[w_idx] * input_buf[in_idx];
+        }
+    }
+
+    if (params.apply_relu6 == 1u) {
+        result = clamp(result, vec4<f16>(0.0h), vec4<f16>(6.0h));
+    }
+
+    output_buf[y * params.out_w * C + x * C + c] = result;
+}
+`;var A=class extends d{inputs;weights;output;dispatch;shader;constructor(t,e,r,a){super(t),this.shader=t.dtype==="f16"?we:ye;let o=h(e.h,a.kernel,a.stride,a.padding),s=h(e.w,a.kernel,a.stride,a.padding),n=e.c/4,u=_(a.padding,e.h,o,a.kernel,a.stride),c=_(a.padding,e.w,s,a.kernel,a.stride);this.output=t.tensor(o,s,e.c),this.inputs=[e],this.weights=[t.upload(m(r.weights)),t.upload(m(r.bias))],this.createUniform("params","Params"),this.setUniform("params",new Uint32Array([e.h,e.w,o,s,n,a.kernel,a.kernel,a.stride,u,c,a.activation==="relu6"?1:0,0])),this.defaultSetup(),this.dispatch=[Math.ceil(s/8),Math.ceil(o/8),n];}};var xe=`// Element-wise add of two tensors \u2014 used for residual connections in MBConv blocks.
+// Operates on the flat float buffer directly; layout is irrelevant for a pure element-wise op.
+
+struct Params {
+    size  : u32,   // total number of f32 elements
+    _pad0 : u32,
+    _pad1 : u32,
+    _pad2 : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_a : array<f32>;
+@group(0) @binding(1) var<storage, read>       input_b : array<f32>;
+@group(0) @binding(2) var<uniform>             params  : Params;
+@group(0) @binding(3) var<storage, read_write> output  : array<f32>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let idx = gid.x;
+    if (idx >= params.size) { return; }
+    output[idx] = input_a[idx] + input_b[idx];
+}
+`;var Pe=`enable f16;
+
+// Element-wise add \u2014 full f16 variant.
+// array<f16> is binary-compatible with array<vec4<f16>> written by the f16 conv shaders.
+
+struct Params {
+    size  : u32,
+    _pad0 : u32,
+    _pad1 : u32,
+    _pad2 : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_a : array<f16>;
+@group(0) @binding(1) var<storage, read>       input_b : array<f16>;
+@group(0) @binding(2) var<uniform>             params  : Params;
+@group(0) @binding(3) var<storage, read_write> output  : array<f16>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let idx = gid.x;
+    if (idx >= params.size) { return; }
+    output[idx] = input_a[idx] + input_b[idx];
+}
+`;var O=class extends d{inputs;weights=[];output;dispatch;shader;constructor(t,e,r){super(t),this.shader=t.dtype==="f16"?Pe:xe;let a=e.h*e.w*e.c;this.output=t.tensor(e.h,e.w,e.c),this.inputs=[e,r],this.createUniform("params","Params"),this.setUniform("params",new Uint32Array([a,0,0,0])),this.defaultSetup(),this.dispatch=[Math.ceil(a/256),1,1];}};var ke=`// Element-wise sigmoid: output = 1 / (1 + exp(-x)).
+// Operates on packed vec4 buffers (NHWC layout). exp() and arithmetic are element-wise on vec4.
+
+struct Params {
+    n_groups : u32,   // total vec4 elements (H * W * channel_groups)
+    _pad0    : u32,
+    _pad1    : u32,
+    _pad2    : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f32>>;
+@group(0) @binding(1) var<uniform>             params     : Params;
+@group(0) @binding(2) var<storage, read_write> output_buf : array<vec4<f32>>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let idx = gid.x;
+    if (idx >= params.n_groups) { return; }
+    output_buf[idx] = 1.0 / (1.0 + exp(-input_buf[idx]));
+}
+`;var Ue=`enable f16;
+
+// Sigmoid \u2014 full f16 variant.
+
+struct Params {
+    n_groups : u32,
+    _pad0    : u32,
+    _pad1    : u32,
+    _pad2    : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f16>>;
+@group(0) @binding(1) var<uniform>             params     : Params;
+@group(0) @binding(2) var<storage, read_write> output_buf : array<vec4<f16>>;
+
+@compute @workgroup_size(256)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let idx = gid.x;
+    if (idx >= params.n_groups) { return; }
+    let x = vec4<f32>(input_buf[idx]);
+    output_buf[idx] = vec4<f16>(1.0 / (1.0 + exp(-x)));
+}
+`;var E=class extends d{inputs;weights=[];output;dispatch;shader;constructor(t,e){super(t),this.shader=t.dtype==="f16"?Ue:ke;let r=e.h*e.w*(e.c/4);this.output=t.tensor(e.h,e.w,e.c),this.inputs=[e],this.createUniform("params","Params"),this.setUniform("params",new Uint32Array([r,0,0,0])),this.defaultSetup(),this.dispatch=[Math.ceil(r/256),1,1];}};var Ie=`// Bilinear upsample (arbitrary ratio), align_corners=False (matches PyTorch default).
+// Input/output in NHWC vec4 format: index = y*W*(C/4) + x*(C/4) + c_group.
+// Each thread computes one output pixel for one channel group (vec4 = 4 channels).
+
+struct Params {
+    in_h           : u32,
+    in_w           : u32,
+    out_h          : u32,
+    out_w          : u32,
+    channel_groups : u32,
+    _pad0          : u32,
+    _pad1          : u32,
+    _pad2          : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f32>>;
+@group(0) @binding(1) var<uniform>             params     : Params;
+@group(0) @binding(2) var<storage, read_write> output_buf : array<vec4<f32>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let c  = gid.z;
+
+    if (ox >= params.out_w || oy >= params.out_h || c >= params.channel_groups) {
+        return;
+    }
+
+    let IH = params.in_h;
+    let IW = params.in_w;
+    let C  = params.channel_groups;
+
+    // align_corners=False: src = (out + 0.5) * (in / out) - 0.5
+    let src_x = (f32(ox) + 0.5) * (f32(IW) / f32(params.out_w)) - 0.5;
+    let src_y = (f32(oy) + 0.5) * (f32(IH) / f32(params.out_h)) - 0.5;
+
+    // Clamp to [0, in-1] for border replication. Use i32 intermediates so that
+    // floor() returning -1.0 doesn't produce an invalid u32 conversion.
+    let x0 = u32(clamp(i32(floor(src_x)),     0, i32(IW) - 1));
+    let x1 = u32(clamp(i32(floor(src_x)) + 1, 0, i32(IW) - 1));
+    let y0 = u32(clamp(i32(floor(src_y)),     0, i32(IH) - 1));
+    let y1 = u32(clamp(i32(floor(src_y)) + 1, 0, i32(IH) - 1));
+
+    let wx = src_x - floor(src_x);
+    let wy = src_y - floor(src_y);
+
+    let tl = input_buf[y0 * IW * C + x0 * C + c];
+    let tr = input_buf[y0 * IW * C + x1 * C + c];
+    let bl = input_buf[y1 * IW * C + x0 * C + c];
+    let br = input_buf[y1 * IW * C + x1 * C + c];
+
+    // Bilinear blend \u2014 vec4 ops are element-wise, so all 4 channels blend identically.
+    let result = (1.0 - wy) * ((1.0 - wx) * tl + wx * tr)
+               +        wy  * ((1.0 - wx) * bl + wx * br);
+
+    output_buf[oy * params.out_w * C + ox * C + c] = result;
+}
+`;var Ge=`enable f16;
+
+// Bilinear upsample 2\xD7 \u2014 full f16 variant.
+// Interpolation weights (wx, wy) and intermediate blends computed in f32 for
+// accuracy; result cast to f16 on write.
+
+struct Params {
+    in_h           : u32,
+    in_w           : u32,
+    out_h          : u32,
+    out_w          : u32,
+    channel_groups : u32,
+    _pad0          : u32,
+    _pad1          : u32,
+    _pad2          : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f16>>;
+@group(0) @binding(1) var<uniform>             params     : Params;
+@group(0) @binding(2) var<storage, read_write> output_buf : array<vec4<f16>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let c  = gid.z;
+
+    if (ox >= params.out_w || oy >= params.out_h || c >= params.channel_groups) {
+        return;
+    }
+
+    let IH = params.in_h;
+    let IW = params.in_w;
+    let C  = params.channel_groups;
+
+    let src_x = (f32(ox) + 0.5) * (f32(IW) / f32(params.out_w)) - 0.5;
+    let src_y = (f32(oy) + 0.5) * (f32(IH) / f32(params.out_h)) - 0.5;
+
+    let x0 = u32(clamp(i32(floor(src_x)),     0, i32(IW) - 1));
+    let x1 = u32(clamp(i32(floor(src_x)) + 1, 0, i32(IW) - 1));
+    let y0 = u32(clamp(i32(floor(src_y)),     0, i32(IH) - 1));
+    let y1 = u32(clamp(i32(floor(src_y)) + 1, 0, i32(IH) - 1));
+
+    let wx = src_x - floor(src_x);
+    let wy = src_y - floor(src_y);
+
+    let tl = vec4<f32>(input_buf[y0 * IW * C + x0 * C + c]);
+    let tr = vec4<f32>(input_buf[y0 * IW * C + x1 * C + c]);
+    let bl = vec4<f32>(input_buf[y1 * IW * C + x0 * C + c]);
+    let br = vec4<f32>(input_buf[y1 * IW * C + x1 * C + c]);
+
+    let result = (1.0 - wy) * ((1.0 - wx) * tl + wx * tr)
+               +        wy  * ((1.0 - wx) * bl + wx * br);
+
+    output_buf[oy * params.out_w * C + ox * C + c] = vec4<f16>(result);
+}
+`;var F=class extends d{inputs;weights=[];output;dispatch;shader;constructor(t,e,r){super(t),this.shader=t.dtype==="f16"?Ge:Ie;let a=e.c/4;this.output=t.tensor(r.outH,r.outW,e.c),this.inputs=[e],this.createUniform("params","Params"),this.setUniform("params",new Uint32Array([e.h,e.w,r.outH,r.outW,a,0,0,0])),this.defaultSetup(),this.dispatch=[Math.ceil(r.outW/8),Math.ceil(r.outH/8),a];}};var Be=`// Bicubic upsample (arbitrary scale) \u2014 Keys cubic, a=-0.75 (PyTorch default
+// for mode='bicubic', align_corners=False). Direct 2D, 4\xD74 = 16 taps per
+// output pixel. NHWC vec4 layout: index = y*W*(C/4) + x*(C/4) + c_group.
+
+struct Params {
+    in_h           : u32,
+    in_w           : u32,
+    out_h          : u32,
+    out_w          : u32,
+    channel_groups : u32,
+    _pad0          : u32,
+    _pad1          : u32,
+    _pad2          : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f32>>;
+@group(0) @binding(1) var<uniform>             params     : Params;
+@group(0) @binding(2) var<storage, read_write> output_buf : array<vec4<f32>>;
+
+const A: f32 = -0.75;
+
+fn wcubic(d: f32) -> f32 {
+    let ad = abs(d);
+    if (ad <= 1.0) { return ((A + 2.0) * ad - (A + 3.0)) * ad * ad + 1.0; }
+    if (ad <  2.0) { return ((A * ad - 5.0 * A) * ad + 8.0 * A) * ad - 4.0 * A; }
+    return 0.0;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let c  = gid.z;
+
+    if (ox >= params.out_w || oy >= params.out_h || c >= params.channel_groups) {
+        return;
+    }
+
+    let IH = params.in_h;
+    let IW = params.in_w;
+    let C  = params.channel_groups;
+
+    let src_x = (f32(ox) + 0.5) * (f32(IW) / f32(params.out_w)) - 0.5;
+    let src_y = (f32(oy) + 0.5) * (f32(IH) / f32(params.out_h)) - 0.5;
+
+    let x0 = i32(floor(src_x));
+    let y0 = i32(floor(src_y));
+    let fx = src_x - f32(x0);
+    let fy = src_y - f32(y0);
+
+    var wx: array<f32, 4>;
+    var wy: array<f32, 4>;
+    wx[0] = wcubic(1.0 + fx); wx[1] = wcubic(fx); wx[2] = wcubic(1.0 - fx); wx[3] = wcubic(2.0 - fx);
+    wy[0] = wcubic(1.0 + fy); wy[1] = wcubic(fy); wy[2] = wcubic(1.0 - fy); wy[3] = wcubic(2.0 - fy);
+
+    var acc: vec4<f32> = vec4<f32>(0.0);
+    for (var j: i32 = 0; j < 4; j = j + 1) {
+        let sy = u32(clamp(y0 + j - 1, 0, i32(IH) - 1));
+        for (var i: i32 = 0; i < 4; i = i + 1) {
+            let sx = u32(clamp(x0 + i - 1, 0, i32(IW) - 1));
+            let v  = input_buf[sy * IW * C + sx * C + c];
+            acc = acc + (wx[i] * wy[j]) * v;
+        }
+    }
+
+    output_buf[oy * params.out_w * C + ox * C + c] = acc;
+}
+`;var Ce=`enable f16;
+
+// Bicubic upsample \u2014 full f16 storage variant. Bicubic weights and the per-
+// pixel accumulator are computed in f32 (cheap to keep precision around the
+// kernel arithmetic), then demoted to f16 when written to the output buffer.
+
+struct Params {
+    in_h           : u32,
+    in_w           : u32,
+    out_h          : u32,
+    out_w          : u32,
+    channel_groups : u32,
+    _pad0          : u32,
+    _pad1          : u32,
+    _pad2          : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f16>>;
+@group(0) @binding(1) var<uniform>             params     : Params;
+@group(0) @binding(2) var<storage, read_write> output_buf : array<vec4<f16>>;
+
+const A: f32 = -0.75;
+
+fn wcubic(d: f32) -> f32 {
+    let ad = abs(d);
+    if (ad <= 1.0) { return ((A + 2.0) * ad - (A + 3.0)) * ad * ad + 1.0; }
+    if (ad <  2.0) { return ((A * ad - 5.0 * A) * ad + 8.0 * A) * ad - 4.0 * A; }
+    return 0.0;
+}
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let c  = gid.z;
+
+    if (ox >= params.out_w || oy >= params.out_h || c >= params.channel_groups) {
+        return;
+    }
+
+    let IH = params.in_h;
+    let IW = params.in_w;
+    let C  = params.channel_groups;
+
+    let src_x = (f32(ox) + 0.5) * (f32(IW) / f32(params.out_w)) - 0.5;
+    let src_y = (f32(oy) + 0.5) * (f32(IH) / f32(params.out_h)) - 0.5;
+
+    let x0 = i32(floor(src_x));
+    let y0 = i32(floor(src_y));
+    let fx = src_x - f32(x0);
+    let fy = src_y - f32(y0);
+
+    var wx: array<f32, 4>;
+    var wy: array<f32, 4>;
+    wx[0] = wcubic(1.0 + fx); wx[1] = wcubic(fx); wx[2] = wcubic(1.0 - fx); wx[3] = wcubic(2.0 - fx);
+    wy[0] = wcubic(1.0 + fy); wy[1] = wcubic(fy); wy[2] = wcubic(1.0 - fy); wy[3] = wcubic(2.0 - fy);
+
+    var acc: vec4<f32> = vec4<f32>(0.0);
+    for (var j: i32 = 0; j < 4; j = j + 1) {
+        let sy = u32(clamp(y0 + j - 1, 0, i32(IH) - 1));
+        for (var i: i32 = 0; i < 4; i = i + 1) {
+            let sx = u32(clamp(x0 + i - 1, 0, i32(IW) - 1));
+            let v  = vec4<f32>(input_buf[sy * IW * C + sx * C + c]);
+            acc = acc + (wx[i] * wy[j]) * v;
+        }
+    }
+
+    output_buf[oy * params.out_w * C + ox * C + c] = vec4<f16>(acc);
+}
+`;var V=class extends d{inputs;weights=[];output;dispatch;shader;constructor(t,e,r){super(t),this.shader=t.dtype==="f16"?Ce:Be;let a=e.c/4;this.output=t.tensor(r.outH,r.outW,e.c),this.inputs=[e],this.createUniform("params","Params"),this.setUniform("params",new Uint32Array([e.h,e.w,r.outH,r.outW,a,0,0,0])),this.defaultSetup(),this.dispatch=[Math.ceil(r.outW/8),Math.ceil(r.outH/8),a];}};var Te=`// Channel concatenation: output = cat(A, B, dim=channel).
+// Both A and B must share the same H\xD7W and be in NHWC vec4 format.
+// Output layout: for each (y, x), the first a_groups vec4s come from A,
+// followed by b_groups vec4s from B.
+
+struct Params {
+    height    : u32,
+    width     : u32,
+    a_groups  : u32,  // Ca / 4
+    b_groups  : u32,  // Cb / 4
+    out_groups: u32,  // a_groups + b_groups
+    _pad0     : u32,
+    _pad1     : u32,
+    _pad2     : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_a    : array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read>       input_b    : array<vec4<f32>>;
+@group(0) @binding(2) var<uniform>             params     : Params;
+@group(0) @binding(3) var<storage, read_write> output_buf : array<vec4<f32>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;
+    let y = gid.y;
+    let c = gid.z;  // output channel group
+
+    let W   = params.width;
+    let Ag  = params.a_groups;
+    let Bg  = params.b_groups;
+    let Cg  = params.out_groups;
+
+    if (x >= W || y >= params.height || c >= Cg) {
+        return;
+    }
+
+    let out_idx = y * W * Cg + x * Cg + c;
+
+    if (c < Ag) {
+        output_buf[out_idx] = input_a[y * W * Ag + x * Ag + c];
+    } else {
+        let c_b = c - Ag;
+        output_buf[out_idx] = input_b[y * W * Bg + x * Bg + c_b];
+    }
+}
+`;var We=`enable f16;
+
+// Channel concatenation \u2014 full f16 variant.
+
+struct Params {
+    height    : u32,
+    width     : u32,
+    a_groups  : u32,
+    b_groups  : u32,
+    out_groups: u32,
+    _pad0     : u32,
+    _pad1     : u32,
+    _pad2     : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_a    : array<vec4<f16>>;
+@group(0) @binding(1) var<storage, read>       input_b    : array<vec4<f16>>;
+@group(0) @binding(2) var<uniform>             params     : Params;
+@group(0) @binding(3) var<storage, read_write> output_buf : array<vec4<f16>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;
+    let y = gid.y;
+    let c = gid.z;
+
+    let W  = params.width;
+    let Ag = params.a_groups;
+    let Bg = params.b_groups;
+    let Cg = params.out_groups;
+
+    if (x >= W || y >= params.height || c >= Cg) { return; }
+
+    let out_idx = y * W * Cg + x * Cg + c;
+    if (c < Ag) {
+        output_buf[out_idx] = input_a[y * W * Ag + x * Ag + c];
+    } else {
+        let c_b = c - Ag;
+        output_buf[out_idx] = input_b[y * W * Bg + x * Bg + c_b];
+    }
+}
+`;var L=class extends d{inputs;weights=[];output;dispatch;shader;constructor(t,e,r){super(t),this.shader=t.dtype==="f16"?We:Te;let a=e.c/4,o=r.c/4,s=a+o;this.output=t.tensor(e.h,e.w,e.c+r.c),this.inputs=[e,r],this.createUniform("params","Params"),this.setUniform("params",new Uint32Array([e.h,e.w,a,o,s,0,0,0])),this.defaultSetup(),this.dispatch=[Math.ceil(e.w/8),Math.ceil(e.h/8),s];}};var Me=`// Conv2d + skip add fused.
+// Identical to conv2d.wgsl except skip is an activation input (binding 1),
+// added element-wise to the conv result at write time.
+// Eliminates the separate add dispatch and its intermediate buffer round-trip.
+// Binding order: input(0), skip(1), weights(2), bias(3), params(4), output(5)
+
+struct Params {
+    in_h        : u32,
+    in_w        : u32,
+    out_h       : u32,
+    out_w       : u32,
+    in_groups   : u32,
+    out_groups  : u32,
+    kernel_h    : u32,
+    kernel_w    : u32,
+    stride      : u32,
+    pad_top     : u32,
+    pad_left    : u32,
+    activation  : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read>       skip_buf   : array<vec4<f32>>;
+@group(0) @binding(2) var<storage, read>       weight_buf : array<mat4x4<f32>>;
+@group(0) @binding(3) var<storage, read>       bias_buf   : array<vec4<f32>>;
+@group(0) @binding(4) var<uniform>             params     : Params;
+@group(0) @binding(5) var<storage, read_write> output_buf : array<vec4<f32>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;
+    let y = gid.y;
+    let o = gid.z;
+
+    if (x >= params.out_w || y >= params.out_h || o >= params.out_groups) {
+        return;
+    }
+
+    let I = params.in_groups;
+    let O = params.out_groups;
+
+    var result = bias_buf[o];
+
+    for (var ky = 0u; ky < params.kernel_h; ky++) {
+        for (var kx = 0u; kx < params.kernel_w; kx++) {
+            let in_y_s = i32(y * params.stride + ky) - i32(params.pad_top);
+            let in_x_s = i32(x * params.stride + kx) - i32(params.pad_left);
+
+            if (in_y_s < 0 || in_x_s < 0 ||
+                u32(in_y_s) >= params.in_h || u32(in_x_s) >= params.in_w) {
+                continue;
+            }
+
+            let in_y = u32(in_y_s);
+            let in_x = u32(in_x_s);
+            let z    = ky * params.kernel_w + kx;
+
+            for (var i = 0u; i < I; i++) {
+                let in_idx = in_y * params.in_w * I + in_x * I + i;
+                let w_idx  = z * O * I + o * I + i;
+                result += weight_buf[w_idx] * input_buf[in_idx];
+            }
+        }
+    }
+
+    if (params.activation == 1u) {
+        result = clamp(result, vec4<f32>(0.0), vec4<f32>(6.0));
+    } else if (params.activation == 2u) {
+        result = max(result, vec4<f32>(0.0));
+    }
+
+    let out_idx = y * params.out_w * O + x * O + o;
+    output_buf[out_idx] = result + skip_buf[out_idx];
+}
+`;var Se=`enable f16;
+
+// Conv2d + skip add fused \u2014 full f16 variant.
+
+struct Params {
+    in_h        : u32,
+    in_w        : u32,
+    out_h       : u32,
+    out_w       : u32,
+    in_groups   : u32,
+    out_groups  : u32,
+    kernel_h    : u32,
+    kernel_w    : u32,
+    stride      : u32,
+    pad_top     : u32,
+    pad_left    : u32,
+    activation  : u32,
+}
+
+// Binding order matches conv2d_add.wgsl: input(0), skip(1), weight(2), bias(3),
+// params(4), output(5).
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f16>>;
+@group(0) @binding(1) var<storage, read>       skip_buf   : array<vec4<f16>>;
+@group(0) @binding(2) var<storage, read>       weight_buf : array<mat4x4<f16>>;
+@group(0) @binding(3) var<storage, read>       bias_buf   : array<vec4<f16>>;
+@group(0) @binding(4) var<uniform>             params     : Params;
+@group(0) @binding(5) var<storage, read_write> output_buf : array<vec4<f16>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;
+    let y = gid.y;
+    let o = gid.z;
+
+    if (x >= params.out_w || y >= params.out_h || o >= params.out_groups) {
+        return;
+    }
+
+    let I = params.in_groups;
+    let O = params.out_groups;
+
+    var result = bias_buf[o];
+
+    for (var ky = 0u; ky < params.kernel_h; ky++) {
+        for (var kx = 0u; kx < params.kernel_w; kx++) {
+            let in_y_s = i32(y * params.stride + ky) - i32(params.pad_top);
+            let in_x_s = i32(x * params.stride + kx) - i32(params.pad_left);
+
+            if (in_y_s < 0 || in_x_s < 0 ||
+                u32(in_y_s) >= params.in_h || u32(in_x_s) >= params.in_w) {
+                continue;
+            }
+
+            let in_y = u32(in_y_s);
+            let in_x = u32(in_x_s);
+            let z    = ky * params.kernel_w + kx;
+
+            for (var i = 0u; i < I; i++) {
+                let in_idx = in_y * params.in_w * I + in_x * I + i;
+                let w_idx  = z * O * I + o * I + i;
+                result += weight_buf[w_idx] * input_buf[in_idx];
+            }
+        }
+    }
+
+    if (params.activation == 1u) {
+        result = clamp(result, vec4<f16>(0.0h), vec4<f16>(6.0h));
+    } else if (params.activation == 2u) {
+        result = max(result, vec4<f16>(0.0h));
+    }
+
+    let out_idx = y * params.out_w * O + x * O + o;
+    output_buf[out_idx] = result + skip_buf[out_idx];
+}
+`;var H=class extends d{inputs;weights;output;dispatch;shader;constructor(t,e,r,a,o){super(t),this.shader=t.dtype==="f16"?Se:Me;let s=h(e.h,o.kernel,o.stride,o.padding),n=h(e.w,o.kernel,o.stride,o.padding),u=e.c/4,c=o.outChannels/4,p=_(o.padding,e.h,s,o.kernel,o.stride),l=_(o.padding,e.w,n,o.kernel,o.stride);this.output=t.tensor(s,n,o.outChannels),this.inputs=[e,r],this.weights=[t.upload(m(a.weights)),t.upload(m(a.bias))],this.createUniform("params","Params"),this.setUniform("params",new Uint32Array([e.h,e.w,s,n,u,c,o.kernel,o.kernel,o.stride,p,l,o.activation==="relu6"?1:0])),this.defaultSetup(),this.dispatch=[Math.ceil(n/8),Math.ceil(s/8),c];}};var Ae=`// Bilinear upsample + channel concat fused.
+// input_a is the decoder tensor at small spatial resolution (in_h \xD7 in_w).
+// input_b is the encoder skip feature already at output resolution (out_h \xD7 out_w).
+// For output channels 0..a_groups-1: bilinearly interpolate from input_a.
+// For output channels a_groups..out_groups-1: copy directly from input_b.
+// Eliminates the intermediate upsample buffer and the separate concat dispatch.
+
+struct Params {
+    in_h       : u32,   // input_a spatial height
+    in_w       : u32,   // input_a spatial width
+    out_h      : u32,
+    out_w      : u32,
+    a_groups   : u32,   // input_a channel groups (upsampled)
+    b_groups   : u32,   // input_b channel groups (encoder feature)
+    out_groups : u32,   // a_groups + b_groups
+    _pad0      : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_a    : array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read>       input_b    : array<vec4<f32>>;
+@group(0) @binding(2) var<uniform>             params     : Params;
+@group(0) @binding(3) var<storage, read_write> output_buf : array<vec4<f32>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let c  = gid.z;
+
+    if (ox >= params.out_w || oy >= params.out_h || c >= params.out_groups) { return; }
+
+    let out_idx = oy * params.out_w * params.out_groups + ox * params.out_groups + c;
+
+    if (c < params.a_groups) {
+        let IH = params.in_h;
+        let IW = params.in_w;
+        let AG = params.a_groups;
+
+        let src_x = (f32(ox) + 0.5) * (f32(IW) / f32(params.out_w)) - 0.5;
+        let src_y = (f32(oy) + 0.5) * (f32(IH) / f32(params.out_h)) - 0.5;
+
+        let x0 = u32(clamp(i32(floor(src_x)),     0, i32(IW) - 1));
+        let x1 = u32(clamp(i32(floor(src_x)) + 1, 0, i32(IW) - 1));
+        let y0 = u32(clamp(i32(floor(src_y)),     0, i32(IH) - 1));
+        let y1 = u32(clamp(i32(floor(src_y)) + 1, 0, i32(IH) - 1));
+
+        let wx = src_x - floor(src_x);
+        let wy = src_y - floor(src_y);
+
+        let tl = input_a[y0 * IW * AG + x0 * AG + c];
+        let tr = input_a[y0 * IW * AG + x1 * AG + c];
+        let bl = input_a[y1 * IW * AG + x0 * AG + c];
+        let br = input_a[y1 * IW * AG + x1 * AG + c];
+
+        output_buf[out_idx] = (1.0 - wy) * ((1.0 - wx) * tl + wx * tr)
+                            +        wy  * ((1.0 - wx) * bl + wx * br);
+    } else {
+        let c_b = c - params.a_groups;
+        output_buf[out_idx] = input_b[oy * params.out_w * params.b_groups + ox * params.b_groups + c_b];
+    }
+}
+`;var Oe=`enable f16;
+
+// Bilinear upsample + channel concat fused \u2014 full f16 variant.
+// Bilinear weights (wx, wy) and intermediate blends computed in f32; result cast to f16.
+
+struct Params {
+    in_h       : u32,
+    in_w       : u32,
+    out_h      : u32,
+    out_w      : u32,
+    a_groups   : u32,
+    b_groups   : u32,
+    out_groups : u32,
+    _pad0      : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_a    : array<vec4<f16>>;
+@group(0) @binding(1) var<storage, read>       input_b    : array<vec4<f16>>;
+@group(0) @binding(2) var<uniform>             params     : Params;
+@group(0) @binding(3) var<storage, read_write> output_buf : array<vec4<f16>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let c  = gid.z;
+
+    if (ox >= params.out_w || oy >= params.out_h || c >= params.out_groups) { return; }
+
+    let out_idx = oy * params.out_w * params.out_groups + ox * params.out_groups + c;
+
+    if (c < params.a_groups) {
+        let IH = params.in_h;
+        let IW = params.in_w;
+        let AG = params.a_groups;
+
+        let src_x = (f32(ox) + 0.5) * (f32(IW) / f32(params.out_w)) - 0.5;
+        let src_y = (f32(oy) + 0.5) * (f32(IH) / f32(params.out_h)) - 0.5;
+
+        let x0 = u32(clamp(i32(floor(src_x)),     0, i32(IW) - 1));
+        let x1 = u32(clamp(i32(floor(src_x)) + 1, 0, i32(IW) - 1));
+        let y0 = u32(clamp(i32(floor(src_y)),     0, i32(IH) - 1));
+        let y1 = u32(clamp(i32(floor(src_y)) + 1, 0, i32(IH) - 1));
+
+        let wx = src_x - floor(src_x);
+        let wy = src_y - floor(src_y);
+
+        let tl = vec4<f32>(input_a[y0 * IW * AG + x0 * AG + c]);
+        let tr = vec4<f32>(input_a[y0 * IW * AG + x1 * AG + c]);
+        let bl = vec4<f32>(input_a[y1 * IW * AG + x0 * AG + c]);
+        let br = vec4<f32>(input_a[y1 * IW * AG + x1 * AG + c]);
+
+        let result = (1.0 - wy) * ((1.0 - wx) * tl + wx * tr)
+                   +        wy  * ((1.0 - wx) * bl + wx * br);
+        output_buf[out_idx] = vec4<f16>(result);
+    } else {
+        let c_b = c - params.a_groups;
+        output_buf[out_idx] = input_b[oy * params.out_w * params.b_groups + ox * params.b_groups + c_b];
+    }
+}
+`;var R=class extends d{inputs;weights=[];output;dispatch;shader;constructor(t,e,r,a){super(t),this.shader=t.dtype==="f16"?Oe:Ae;let o=e.c/4,s=r.c/4,n=o+s;this.output=t.tensor(a.outH,a.outW,e.c+r.c),this.inputs=[e,r],this.createUniform("params","Params"),this.setUniform("params",new Uint32Array([e.h,e.w,a.outH,a.outW,o,s,n,0])),this.defaultSetup(),this.dispatch=[Math.ceil(a.outW/8),Math.ceil(a.outH/8),n];}};var Ee=`// Bilinear upsample + 1\xD71 pointwise conv fused.
+// For each output pixel, bilinearly samples the small input for each in_group,
+// immediately applies the 1\xD71 conv weights, and writes the activated result.
+// Eliminates the intermediate full-resolution upsample buffer.
+
+struct Params {
+    in_h       : u32,
+    in_w       : u32,
+    out_h      : u32,
+    out_w      : u32,
+    in_groups  : u32,
+    out_groups : u32,
+    activation : u32,
+    _pad0      : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read>       weight_buf : array<mat4x4<f32>>;
+@group(0) @binding(2) var<storage, read>       bias_buf   : array<vec4<f32>>;
+@group(0) @binding(3) var<uniform>             params     : Params;
+@group(0) @binding(4) var<storage, read_write> output_buf : array<vec4<f32>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let og = gid.z;
+
+    if (ox >= params.out_w || oy >= params.out_h || og >= params.out_groups) { return; }
+
+    let IH = params.in_h;
+    let IW = params.in_w;
+    let IG = params.in_groups;
+
+    let src_x = (f32(ox) + 0.5) * (f32(IW) / f32(params.out_w)) - 0.5;
+    let src_y = (f32(oy) + 0.5) * (f32(IH) / f32(params.out_h)) - 0.5;
+
+    let x0 = u32(clamp(i32(floor(src_x)),     0, i32(IW) - 1));
+    let x1 = u32(clamp(i32(floor(src_x)) + 1, 0, i32(IW) - 1));
+    let y0 = u32(clamp(i32(floor(src_y)),     0, i32(IH) - 1));
+    let y1 = u32(clamp(i32(floor(src_y)) + 1, 0, i32(IH) - 1));
+
+    let wx = src_x - floor(src_x);
+    let wy = src_y - floor(src_y);
+
+    var result = bias_buf[og];
+
+    for (var ig = 0u; ig < IG; ig++) {
+        let tl = input_buf[y0 * IW * IG + x0 * IG + ig];
+        let tr = input_buf[y0 * IW * IG + x1 * IG + ig];
+        let bl = input_buf[y1 * IW * IG + x0 * IG + ig];
+        let br = input_buf[y1 * IW * IG + x1 * IG + ig];
+
+        let sampled = (1.0 - wy) * ((1.0 - wx) * tl + wx * tr)
+                    +        wy  * ((1.0 - wx) * bl + wx * br);
+
+        result += weight_buf[og * IG + ig] * sampled;
+    }
+
+    if (params.activation == 1u) {
+        result = clamp(result, vec4<f32>(0.0), vec4<f32>(6.0));
+    } else if (params.activation == 2u) {
+        result = result * clamp(result + 3.0, vec4<f32>(0.0), vec4<f32>(6.0)) / 6.0;
+    }
+
+    output_buf[oy * params.out_w * params.out_groups + ox * params.out_groups + og] = result;
+}
+`;var Fe=`enable f16;
+
+// Bilinear upsample + 1\xD71 pointwise conv fused \u2014 full f16 variant.
+// Bilinear weights and intermediate blends computed in f32; conv accumulation in f16.
+
+struct Params {
+    in_h       : u32,
+    in_w       : u32,
+    out_h      : u32,
+    out_w      : u32,
+    in_groups  : u32,
+    out_groups : u32,
+    activation : u32,
+    _pad0      : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f16>>;
+@group(0) @binding(1) var<storage, read>       weight_buf : array<mat4x4<f16>>;
+@group(0) @binding(2) var<storage, read>       bias_buf   : array<vec4<f16>>;
+@group(0) @binding(3) var<uniform>             params     : Params;
+@group(0) @binding(4) var<storage, read_write> output_buf : array<vec4<f16>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let og = gid.z;
+
+    if (ox >= params.out_w || oy >= params.out_h || og >= params.out_groups) { return; }
+
+    let IH = params.in_h;
+    let IW = params.in_w;
+    let IG = params.in_groups;
+
+    let src_x = (f32(ox) + 0.5) * (f32(IW) / f32(params.out_w)) - 0.5;
+    let src_y = (f32(oy) + 0.5) * (f32(IH) / f32(params.out_h)) - 0.5;
+
+    let x0 = u32(clamp(i32(floor(src_x)),     0, i32(IW) - 1));
+    let x1 = u32(clamp(i32(floor(src_x)) + 1, 0, i32(IW) - 1));
+    let y0 = u32(clamp(i32(floor(src_y)),     0, i32(IH) - 1));
+    let y1 = u32(clamp(i32(floor(src_y)) + 1, 0, i32(IH) - 1));
+
+    let wx = src_x - floor(src_x);
+    let wy = src_y - floor(src_y);
+
+    var result = bias_buf[og];
+
+    for (var ig = 0u; ig < IG; ig++) {
+        let tl = vec4<f32>(input_buf[y0 * IW * IG + x0 * IG + ig]);
+        let tr = vec4<f32>(input_buf[y0 * IW * IG + x1 * IG + ig]);
+        let bl = vec4<f32>(input_buf[y1 * IW * IG + x0 * IG + ig]);
+        let br = vec4<f32>(input_buf[y1 * IW * IG + x1 * IG + ig]);
+
+        let sampled = vec4<f16>((1.0 - wy) * ((1.0 - wx) * tl + wx * tr)
+                              +        wy  * ((1.0 - wx) * bl + wx * br));
+
+        result += weight_buf[og * IG + ig] * sampled;
+    }
+
+    if (params.activation == 1u) {
+        result = clamp(result, vec4<f16>(0.0h), vec4<f16>(6.0h));
+    } else if (params.activation == 2u) {
+        result = result * clamp(result + 3.0h, vec4<f16>(0.0h), vec4<f16>(6.0h)) / 6.0h;
+    }
+
+    output_buf[oy * params.out_w * params.out_groups + ox * params.out_groups + og] = result;
+}
+`;var z=class extends d{inputs;weights;output;dispatch;shader;constructor(t,e,r,a){super(t),this.shader=t.dtype==="f16"?Fe:Ee;let o=e.c/4,s=a.outChannels/4;this.output=t.tensor(a.outH,a.outW,a.outChannels),this.inputs=[e],this.weights=[t.upload(m(r.weights)),t.upload(m(r.bias))],this.createUniform("params","Params"),this.setUniform("params",new Uint32Array([e.h,e.w,a.outH,a.outW,o,s,a.activation==="relu6"?1:0,0])),this.defaultSetup(),this.dispatch=[Math.ceil(a.outW/8),Math.ceil(a.outH/8),s];}};var Ve=`// Bilinear upsample + sigmoid fused.
+// Identical to bilinear_upsample.wgsl except sigmoid is applied at write time.
+// Eliminates the intermediate full-resolution buffer and the separate sigmoid dispatch.
+
+struct Params {
+    in_h           : u32,
+    in_w           : u32,
+    out_h          : u32,
+    out_w          : u32,
+    channel_groups : u32,
+    _pad0          : u32,
+    _pad1          : u32,
+    _pad2          : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f32>>;
+@group(0) @binding(1) var<uniform>             params     : Params;
+@group(0) @binding(2) var<storage, read_write> output_buf : array<vec4<f32>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let c  = gid.z;
+
+    if (ox >= params.out_w || oy >= params.out_h || c >= params.channel_groups) {
+        return;
+    }
+
+    let IH = params.in_h;
+    let IW = params.in_w;
+    let C  = params.channel_groups;
+
+    let src_x = (f32(ox) + 0.5) * (f32(IW) / f32(params.out_w)) - 0.5;
+    let src_y = (f32(oy) + 0.5) * (f32(IH) / f32(params.out_h)) - 0.5;
+
+    let x0 = u32(clamp(i32(floor(src_x)),     0, i32(IW) - 1));
+    let x1 = u32(clamp(i32(floor(src_x)) + 1, 0, i32(IW) - 1));
+    let y0 = u32(clamp(i32(floor(src_y)),     0, i32(IH) - 1));
+    let y1 = u32(clamp(i32(floor(src_y)) + 1, 0, i32(IH) - 1));
+
+    let wx = src_x - floor(src_x);
+    let wy = src_y - floor(src_y);
+
+    let tl = input_buf[y0 * IW * C + x0 * C + c];
+    let tr = input_buf[y0 * IW * C + x1 * C + c];
+    let bl = input_buf[y1 * IW * C + x0 * C + c];
+    let br = input_buf[y1 * IW * C + x1 * C + c];
+
+    let result = (1.0 - wy) * ((1.0 - wx) * tl + wx * tr)
+               +        wy  * ((1.0 - wx) * bl + wx * br);
+
+    output_buf[oy * params.out_w * C + ox * C + c] = 1.0 / (1.0 + exp(-result));
+}
+`;var Le=`enable f16;
+
+// Bilinear upsample + sigmoid fused \u2014 full f16 variant.
+// Interpolation computed in f32 for accuracy; sigmoid and result cast to f16.
+
+struct Params {
+    in_h           : u32,
+    in_w           : u32,
+    out_h          : u32,
+    out_w          : u32,
+    channel_groups : u32,
+    _pad0          : u32,
+    _pad1          : u32,
+    _pad2          : u32,
+}
+
+@group(0) @binding(0) var<storage, read>       input_buf  : array<vec4<f16>>;
+@group(0) @binding(1) var<uniform>             params     : Params;
+@group(0) @binding(2) var<storage, read_write> output_buf : array<vec4<f16>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let ox = gid.x;
+    let oy = gid.y;
+    let c  = gid.z;
+
+    if (ox >= params.out_w || oy >= params.out_h || c >= params.channel_groups) {
+        return;
+    }
+
+    let IH = params.in_h;
+    let IW = params.in_w;
+    let C  = params.channel_groups;
+
+    let src_x = (f32(ox) + 0.5) * (f32(IW) / f32(params.out_w)) - 0.5;
+    let src_y = (f32(oy) + 0.5) * (f32(IH) / f32(params.out_h)) - 0.5;
+
+    let x0 = u32(clamp(i32(floor(src_x)),     0, i32(IW) - 1));
+    let x1 = u32(clamp(i32(floor(src_x)) + 1, 0, i32(IW) - 1));
+    let y0 = u32(clamp(i32(floor(src_y)),     0, i32(IH) - 1));
+    let y1 = u32(clamp(i32(floor(src_y)) + 1, 0, i32(IH) - 1));
+
+    let wx = src_x - floor(src_x);
+    let wy = src_y - floor(src_y);
+
+    let tl = vec4<f32>(input_buf[y0 * IW * C + x0 * C + c]);
+    let tr = vec4<f32>(input_buf[y0 * IW * C + x1 * C + c]);
+    let bl = vec4<f32>(input_buf[y1 * IW * C + x0 * C + c]);
+    let br = vec4<f32>(input_buf[y1 * IW * C + x1 * C + c]);
+
+    let result = (1.0 - wy) * ((1.0 - wx) * tl + wx * tr)
+               +        wy  * ((1.0 - wx) * bl + wx * br);
+
+    output_buf[oy * params.out_w * C + ox * C + c] = vec4<f16>(1.0 / (1.0 + exp(-result)));
+}
+`;var D=class extends d{inputs;weights=[];output;dispatch;shader;constructor(t,e,r){super(t),this.shader=t.dtype==="f16"?Le:Ve;let a=e.c/4;this.output=t.tensor(r.outH,r.outW,e.c),this.inputs=[e],this.createUniform("params","Params"),this.setUniform("params",new Uint32Array([e.h,e.w,r.outH,r.outW,a,0,0,0])),this.defaultSetup(),this.dispatch=[Math.ceil(r.outW/8),Math.ceil(r.outH/8),a];}};var He=`// Composite an RGBA image over a solid background, gated by a 1-ch alpha.
+// Fragment writes the canvas's swapchain texture (premultiplied output).
+//
+// Caller invariants (matched in CompositeSolidWebGPU):
+//   - image and alpha are NHWC vec4 storage buffers, same h \xD7 w
+//   - canvas.width === image.w, canvas.height === image.h (no resampling)
+
+struct VertexOut {
+    @builtin(position) pos: vec4<f32>,
+};
+
+@vertex
+fn vs(@builtin(vertex_index) vi: u32) -> VertexOut {
+    let verts = array<vec2<f32>, 6>(
+        vec2(-1.0, -1.0), vec2( 1.0, -1.0), vec2(-1.0,  1.0),
+        vec2(-1.0,  1.0), vec2( 1.0, -1.0), vec2( 1.0,  1.0),
+    );
+    var out: VertexOut;
+    out.pos = vec4<f32>(verts[vi], 0.0, 1.0);
+    return out;
+}
+
+struct Params {
+    width:    u32,           // image width in pixels (= canvas width)
+    _pad0:    u32,
+    _pad1:    u32,
+    _pad2:    u32,
+    bgColor:  vec4<f32>,     // .rgb used; .a ignored
+};
+
+@group(0) @binding(0) var<storage, read> image:  array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read> alpha:  array<vec4<f32>>;
+@group(0) @binding(2) var<uniform>       params: Params;
+
+@fragment
+fn fs(in: VertexOut) -> @location(0) vec4<f32> {
+    let x = u32(in.pos.x);
+    let y = u32(in.pos.y);
+    let i = y * params.width + x;
+
+    let fg = image[i].rgb;
+    let a  = alpha[i].r;
+    let rgb = fg * a + params.bgColor.rgb * (1.0 - a);
+    return vec4<f32>(rgb, 1.0);
+}
+`;var Re=`enable f16;
+
+// Composite an RGBA image over a solid background, gated by a 1-ch alpha.
+// f16 variant: image and alpha are stored as f16; values promote to f32 on
+// read and the fragment writes f32 to the canvas swapchain (color attachment
+// format is the swapchain's preferred format, always f32-equivalent).
+//
+// Caller invariants (matched in CompositeSolidWebGPU):
+//   - image and alpha are NHWC vec4 storage buffers, same h \xD7 w
+//   - canvas.width === image.w, canvas.height === image.h (no resampling)
+
+struct VertexOut {
+    @builtin(position) pos: vec4<f32>,
+};
+
+@vertex
+fn vs(@builtin(vertex_index) vi: u32) -> VertexOut {
+    let verts = array<vec2<f32>, 6>(
+        vec2(-1.0, -1.0), vec2( 1.0, -1.0), vec2(-1.0,  1.0),
+        vec2(-1.0,  1.0), vec2( 1.0, -1.0), vec2( 1.0,  1.0),
+    );
+    var out: VertexOut;
+    out.pos = vec4<f32>(verts[vi], 0.0, 1.0);
+    return out;
+}
+
+struct Params {
+    width:    u32,
+    _pad0:    u32,
+    _pad1:    u32,
+    _pad2:    u32,
+    bgColor:  vec4<f32>,
+};
+
+@group(0) @binding(0) var<storage, read> image:  array<vec4<f16>>;
+@group(0) @binding(1) var<storage, read> alpha:  array<vec4<f16>>;
+@group(0) @binding(2) var<uniform>       params: Params;
+
+@fragment
+fn fs(in: VertexOut) -> @location(0) vec4<f32> {
+    let x = u32(in.pos.x);
+    let y = u32(in.pos.y);
+    let i = y * params.width + x;
+
+    let fg = vec3<f32>(image[i].rgb);
+    let a  = f32(alpha[i].r);
+    let rgb = fg * a + params.bgColor.rgb * (1.0 - a);
+    return vec4<f32>(rgb, 1.0);
+}
+`;var N=class{constructor(t,e,r,a){this.backend=t;if(e.h!==r.h||e.w!==r.w)throw new Error(`CompositeSolid: image (${e.h}\xD7${e.w}) and alpha (${r.h}\xD7${r.w}) must match. Run the upscaler first.`);let o=t.device;this.uniformBuffer=o.createBuffer({size:32,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});let s=new ArrayBuffer(32);new Uint32Array(s,0,1)[0]=e.w,new Float32Array(s,16,4).set([a[0],a[1],a[2],0]),o.queue.writeBuffer(this.uniformBuffer,0,s);let n=t.dtype==="f16"?Re:He,u=o.createShaderModule({code:n});this.pipeline=o.createRenderPipeline({layout:"auto",vertex:{module:u,entryPoint:"vs"},fragment:{module:u,entryPoint:"fs",targets:[{format:t.canvasFormat}]},primitive:{topology:"triangle-list"}}),this.bindGroup=o.createBindGroup({layout:this.pipeline.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:e.buffer}},{binding:1,resource:{buffer:r.buffer}},{binding:2,resource:{buffer:this.uniformBuffer}}]});}backend;pipeline;bindGroup;uniformBuffer;outputView=null;setOutput(t){this.outputView=t.createView();}run(){if(!this.outputView)throw new Error("CompositeSolidWebGPU.run() called before setOutput()");let t=this.backend.device.createCommandEncoder(),e=t.beginRenderPass({colorAttachments:[{view:this.outputView,clearValue:[0,0,0,1],loadOp:"clear",storeOp:"store"}]});e.setPipeline(this.pipeline),e.setBindGroup(0,this.bindGroup),e.draw(6),e.end(),this.backend.device.queue.submit([t.finish()]),this.outputView=null;}};var ze=`// Like composite_solid but bg is an NHWC vec4 storage buffer (e.g. virtual
+// background image, or a blurred copy of the input).
+
+struct VertexOut {
+    @builtin(position) pos: vec4<f32>,
+};
+
+@vertex
+fn vs(@builtin(vertex_index) vi: u32) -> VertexOut {
+    let verts = array<vec2<f32>, 6>(
+        vec2(-1.0, -1.0), vec2( 1.0, -1.0), vec2(-1.0,  1.0),
+        vec2(-1.0,  1.0), vec2( 1.0, -1.0), vec2( 1.0,  1.0),
+    );
+    var out: VertexOut;
+    out.pos = vec4<f32>(verts[vi], 0.0, 1.0);
+    return out;
+}
+
+struct Params {
+    width: u32,
+    _pad0: u32,
+    _pad1: u32,
+    _pad2: u32,
+};
+
+@group(0) @binding(0) var<storage, read> image:  array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read> alpha:  array<vec4<f32>>;
+@group(0) @binding(2) var<uniform>       params: Params;
+@group(0) @binding(3) var<storage, read> bg:     array<vec4<f32>>;
+
+@fragment
+fn fs(in: VertexOut) -> @location(0) vec4<f32> {
+    let x = u32(in.pos.x);
+    let y = u32(in.pos.y);
+    let i = y * params.width + x;
+
+    let fg  = image[i].rgb;
+    let a   = alpha[i].r;
+    let bgc = bg[i].rgb;
+    let rgb = fg * a + bgc * (1.0 - a);
+    return vec4<f32>(rgb, 1.0);
+}
+`;var De=`enable f16;
+
+// Like composite_solid_f16 but bg is an NHWC vec4<f16> storage buffer (e.g. a
+// virtual background image, or a blurred copy of the input).
+
+struct VertexOut {
+    @builtin(position) pos: vec4<f32>,
+};
+
+@vertex
+fn vs(@builtin(vertex_index) vi: u32) -> VertexOut {
+    let verts = array<vec2<f32>, 6>(
+        vec2(-1.0, -1.0), vec2( 1.0, -1.0), vec2(-1.0,  1.0),
+        vec2(-1.0,  1.0), vec2( 1.0, -1.0), vec2( 1.0,  1.0),
+    );
+    var out: VertexOut;
+    out.pos = vec4<f32>(verts[vi], 0.0, 1.0);
+    return out;
+}
+
+struct Params {
+    width: u32,
+    _pad0: u32,
+    _pad1: u32,
+    _pad2: u32,
+};
+
+@group(0) @binding(0) var<storage, read> image:  array<vec4<f16>>;
+@group(0) @binding(1) var<storage, read> alpha:  array<vec4<f16>>;
+@group(0) @binding(2) var<uniform>       params: Params;
+@group(0) @binding(3) var<storage, read> bg:     array<vec4<f16>>;
+
+@fragment
+fn fs(in: VertexOut) -> @location(0) vec4<f32> {
+    let x = u32(in.pos.x);
+    let y = u32(in.pos.y);
+    let i = y * params.width + x;
+
+    let fg  = vec3<f32>(image[i].rgb);
+    let a   = f32(alpha[i].r);
+    let bgc = vec3<f32>(bg[i].rgb);
+    let rgb = fg * a + bgc * (1.0 - a);
+    return vec4<f32>(rgb, 1.0);
+}
+`;var $=class{constructor(t,e,r,a){this.backend=t;if(e.h!==r.h||e.w!==r.w||e.h!==a.h||e.w!==a.w)throw new Error(`CompositeImage: image (${e.h}\xD7${e.w}), alpha (${r.h}\xD7${r.w}), and bg (${a.h}\xD7${a.w}) must all match. Run upscaler / resizer first.`);let o=t.device;this.uniformBuffer=o.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});let s=new ArrayBuffer(16);new Uint32Array(s,0,1)[0]=e.w,o.queue.writeBuffer(this.uniformBuffer,0,s);let n=t.dtype==="f16"?De:ze,u=o.createShaderModule({code:n});this.pipeline=o.createRenderPipeline({layout:"auto",vertex:{module:u,entryPoint:"vs"},fragment:{module:u,entryPoint:"fs",targets:[{format:t.canvasFormat}]},primitive:{topology:"triangle-list"}}),this.bindGroup=o.createBindGroup({layout:this.pipeline.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:e.buffer}},{binding:1,resource:{buffer:r.buffer}},{binding:2,resource:{buffer:this.uniformBuffer}},{binding:3,resource:{buffer:a.buffer}}]});}backend;pipeline;bindGroup;uniformBuffer;outputView=null;setOutput(t){this.outputView=t.createView();}run(){if(!this.outputView)throw new Error("CompositeImageWebGPU.run() called before setOutput()");let t=this.backend.device.createCommandEncoder(),e=t.beginRenderPass({colorAttachments:[{view:this.outputView,clearValue:[0,0,0,1],loadOp:"clear",storeOp:"store"}]});e.setPipeline(this.pipeline),e.setBindGroup(0,this.bindGroup),e.draw(6),e.end(),this.backend.device.queue.submit([t.finish()]),this.outputView=null;}};var Ne=`// Like composite_image but bg is sampled bilinearly \u2014 bg may be smaller than
+// (image, alpha). Used by CompositorBlur to skip the final full-res upsample
+// in the blur pyramid and let this shader's own per-pixel scan do the
+// expansion (the work is already happening here for the composite anyway).
+//
+// Layout invariant: image, alpha share output dims (canvas h \xD7 w); bg is
+// at a smaller resolution (bg_h \xD7 bg_w). All NHWC vec4 storage buffers,
+// channelGroups = 1 (RGB padded to vec4).
+
+struct VertexOut {
+    @builtin(position) pos: vec4<f32>,
+};
+
+@vertex
+fn vs(@builtin(vertex_index) vi: u32) -> VertexOut {
+    let verts = array<vec2<f32>, 6>(
+        vec2(-1.0, -1.0), vec2( 1.0, -1.0), vec2(-1.0,  1.0),
+        vec2(-1.0,  1.0), vec2( 1.0, -1.0), vec2( 1.0,  1.0),
+    );
+    var out: VertexOut;
+    out.pos = vec4<f32>(verts[vi], 0.0, 1.0);
+    return out;
+}
+
+struct Params {
+    out_w: u32,
+    out_h: u32,
+    bg_w:  u32,
+    bg_h:  u32,
+};
+
+@group(0) @binding(0) var<storage, read> image:  array<vec4<f32>>;
+@group(0) @binding(1) var<storage, read> alpha:  array<vec4<f32>>;
+@group(0) @binding(2) var<uniform>       params: Params;
+@group(0) @binding(3) var<storage, read> bg:     array<vec4<f32>>;
+
+@fragment
+fn fs(in: VertexOut) -> @location(0) vec4<f32> {
+    let x = u32(in.pos.x);
+    let y = u32(in.pos.y);
+    let i = y * params.out_w + x;
+
+    let fg = image[i].rgb;
+    let a  = alpha[i].r;
+
+    // Bilinear sample bg at the corresponding location. align_corners=False.
+    let src_x = (f32(x) + 0.5) * (f32(params.bg_w) / f32(params.out_w)) - 0.5;
+    let src_y = (f32(y) + 0.5) * (f32(params.bg_h) / f32(params.out_h)) - 0.5;
+    let x0 = u32(clamp(i32(floor(src_x)),     0, i32(params.bg_w) - 1));
+    let x1 = u32(clamp(i32(floor(src_x)) + 1, 0, i32(params.bg_w) - 1));
+    let y0 = u32(clamp(i32(floor(src_y)),     0, i32(params.bg_h) - 1));
+    let y1 = u32(clamp(i32(floor(src_y)) + 1, 0, i32(params.bg_h) - 1));
+    let wx = src_x - floor(src_x);
+    let wy = src_y - floor(src_y);
+
+    let tl = bg[y0 * params.bg_w + x0].rgb;
+    let tr = bg[y0 * params.bg_w + x1].rgb;
+    let bl = bg[y1 * params.bg_w + x0].rgb;
+    let br = bg[y1 * params.bg_w + x1].rgb;
+    let bgc = (1.0 - wy) * ((1.0 - wx) * tl + wx * tr)
+            +        wy  * ((1.0 - wx) * bl + wx * br);
+
+    let rgb = fg * a + bgc * (1.0 - a);
+    return vec4<f32>(rgb, 1.0);
+}
+`;var $e=`enable f16;
+
+// f16 storage variant of composite_image_bilinear. bg is at a smaller
+// resolution and is bilinearly sampled to match (image, alpha) at full res.
+// Computation in f32; storage in f16.
+
+struct VertexOut {
+    @builtin(position) pos: vec4<f32>,
+};
+
+@vertex
+fn vs(@builtin(vertex_index) vi: u32) -> VertexOut {
+    let verts = array<vec2<f32>, 6>(
+        vec2(-1.0, -1.0), vec2( 1.0, -1.0), vec2(-1.0,  1.0),
+        vec2(-1.0,  1.0), vec2( 1.0, -1.0), vec2( 1.0,  1.0),
+    );
+    var out: VertexOut;
+    out.pos = vec4<f32>(verts[vi], 0.0, 1.0);
+    return out;
+}
+
+struct Params {
+    out_w: u32,
+    out_h: u32,
+    bg_w:  u32,
+    bg_h:  u32,
+};
+
+@group(0) @binding(0) var<storage, read> image:  array<vec4<f16>>;
+@group(0) @binding(1) var<storage, read> alpha:  array<vec4<f16>>;
+@group(0) @binding(2) var<uniform>       params: Params;
+@group(0) @binding(3) var<storage, read> bg:     array<vec4<f16>>;
+
+@fragment
+fn fs(in: VertexOut) -> @location(0) vec4<f32> {
+    let x = u32(in.pos.x);
+    let y = u32(in.pos.y);
+    let i = y * params.out_w + x;
+
+    let fg = vec3<f32>(image[i].rgb);
+    let a  = f32(alpha[i].r);
+
+    let src_x = (f32(x) + 0.5) * (f32(params.bg_w) / f32(params.out_w)) - 0.5;
+    let src_y = (f32(y) + 0.5) * (f32(params.bg_h) / f32(params.out_h)) - 0.5;
+    let x0 = u32(clamp(i32(floor(src_x)),     0, i32(params.bg_w) - 1));
+    let x1 = u32(clamp(i32(floor(src_x)) + 1, 0, i32(params.bg_w) - 1));
+    let y0 = u32(clamp(i32(floor(src_y)),     0, i32(params.bg_h) - 1));
+    let y1 = u32(clamp(i32(floor(src_y)) + 1, 0, i32(params.bg_h) - 1));
+    let wx = src_x - floor(src_x);
+    let wy = src_y - floor(src_y);
+
+    let tl = vec3<f32>(bg[y0 * params.bg_w + x0].rgb);
+    let tr = vec3<f32>(bg[y0 * params.bg_w + x1].rgb);
+    let bl = vec3<f32>(bg[y1 * params.bg_w + x0].rgb);
+    let br = vec3<f32>(bg[y1 * params.bg_w + x1].rgb);
+    let bgc = (1.0 - wy) * ((1.0 - wx) * tl + wx * tr)
+            +        wy  * ((1.0 - wx) * bl + wx * br);
+
+    let rgb = fg * a + bgc * (1.0 - a);
+    return vec4<f32>(rgb, 1.0);
+}
+`;var q=class{constructor(t,e,r,a){this.backend=t;if(e.h!==r.h||e.w!==r.w)throw new Error(`CompositeImageBilinear: image (${e.h}\xD7${e.w}) and alpha (${r.h}\xD7${r.w}) must match.`);let o=t.device;this.uniformBuffer=o.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});let s=new ArrayBuffer(16),n=new Uint32Array(s);n[0]=e.w,n[1]=e.h,n[2]=a.w,n[3]=a.h,o.queue.writeBuffer(this.uniformBuffer,0,s);let u=t.dtype==="f16"?$e:Ne,c=o.createShaderModule({code:u});this.pipeline=o.createRenderPipeline({layout:"auto",vertex:{module:c,entryPoint:"vs"},fragment:{module:c,entryPoint:"fs",targets:[{format:t.canvasFormat}]},primitive:{topology:"triangle-list"}}),this.bindGroup=o.createBindGroup({layout:this.pipeline.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:e.buffer}},{binding:1,resource:{buffer:r.buffer}},{binding:2,resource:{buffer:this.uniformBuffer}},{binding:3,resource:{buffer:a.buffer}}]});}backend;pipeline;bindGroup;uniformBuffer;outputView=null;setOutput(t){this.outputView=t.createView();}run(){if(!this.outputView)throw new Error("CompositeImageBilinearWebGPU.run() called before setOutput()");let t=this.backend.device.createCommandEncoder(),e=t.beginRenderPass({colorAttachments:[{view:this.outputView,clearValue:[0,0,0,1],loadOp:"clear",storeOp:"store"}]});e.setPipeline(this.pipeline),e.setBindGroup(0,this.bindGroup),e.draw(6),e.end(),this.backend.device.queue.submit([t.finish()]),this.outputView=null;}};var qe=`// Passthrough "compositor" \u2014 writes the image directly to the canvas
+// swapchain texture with no alpha math and no background. Used by RenderOp
+// when the renderer is in disabled state, so the output canvas reflects
+// the unmodified input frame instead of a stale matted result.
+//
+// Caller invariants (matched in CompositePassthroughWebGPU):
+//   - image is an NHWC vec4 storage buffer
+//   - canvas.width === image.w, canvas.height === image.h (no resampling)
+
+struct VertexOut {
+    @builtin(position) pos: vec4<f32>,
+};
+
+@vertex
+fn vs(@builtin(vertex_index) vi: u32) -> VertexOut {
+    let verts = array<vec2<f32>, 6>(
+        vec2(-1.0, -1.0), vec2( 1.0, -1.0), vec2(-1.0,  1.0),
+        vec2(-1.0,  1.0), vec2( 1.0, -1.0), vec2( 1.0,  1.0),
+    );
+    var out: VertexOut;
+    out.pos = vec4<f32>(verts[vi], 0.0, 1.0);
+    return out;
+}
+
+struct Params {
+    width: u32,
+};
+
+@group(0) @binding(0) var<storage, read> image:  array<vec4<f32>>;
+@group(0) @binding(1) var<uniform>       params: Params;
+
+@fragment
+fn fs(in: VertexOut) -> @location(0) vec4<f32> {
+    let x = u32(in.pos.x);
+    let y = u32(in.pos.y);
+    let i = y * params.width + x;
+    return vec4<f32>(image[i].rgb, 1.0);
+}
+`;var je=`enable f16;
+
+// Passthrough "compositor" \u2014 f16 variant. Image is stored as f16; values
+// promote to f32 on read and the fragment writes f32 to the canvas
+// swapchain (color attachment is the swapchain's preferred f32-equivalent
+// format). See composite_passthrough.wgsl for the f32 version.
+
+struct VertexOut {
+    @builtin(position) pos: vec4<f32>,
+};
+
+@vertex
+fn vs(@builtin(vertex_index) vi: u32) -> VertexOut {
+    let verts = array<vec2<f32>, 6>(
+        vec2(-1.0, -1.0), vec2( 1.0, -1.0), vec2(-1.0,  1.0),
+        vec2(-1.0,  1.0), vec2( 1.0, -1.0), vec2( 1.0,  1.0),
+    );
+    var out: VertexOut;
+    out.pos = vec4<f32>(verts[vi], 0.0, 1.0);
+    return out;
+}
+
+struct Params {
+    width: u32,
+};
+
+@group(0) @binding(0) var<storage, read> image:  array<vec4<f16>>;
+@group(0) @binding(1) var<uniform>       params: Params;
+
+@fragment
+fn fs(in: VertexOut) -> @location(0) vec4<f32> {
+    let x = u32(in.pos.x);
+    let y = u32(in.pos.y);
+    let i = y * params.width + x;
+    return vec4<f32>(vec3<f32>(image[i].rgb), 1.0);
+}
+`;var j=class{constructor(t,e){this.backend=t;let r=t.device;this.uniformBuffer=r.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});let a=new ArrayBuffer(16);new Uint32Array(a,0,1)[0]=e.w,r.queue.writeBuffer(this.uniformBuffer,0,a);let o=t.dtype==="f16"?je:qe,s=r.createShaderModule({code:o});this.pipeline=r.createRenderPipeline({layout:"auto",vertex:{module:s,entryPoint:"vs"},fragment:{module:s,entryPoint:"fs",targets:[{format:t.canvasFormat}]},primitive:{topology:"triangle-list"}}),this.bindGroup=r.createBindGroup({layout:this.pipeline.getBindGroupLayout(0),entries:[{binding:0,resource:{buffer:e.buffer}},{binding:1,resource:{buffer:this.uniformBuffer}}]});}backend;pipeline;bindGroup;uniformBuffer;outputView=null;setOutput(t){this.outputView=t.createView();}run(){if(!this.outputView)throw new Error("CompositePassthroughWebGPU.run() called before setOutput()");let t=this.backend.device.createCommandEncoder(),e=t.beginRenderPass({colorAttachments:[{view:this.outputView,clearValue:[0,0,0,1],loadOp:"clear",storeOp:"store"}]});e.setPipeline(this.pipeline),e.setBindGroup(0,this.bindGroup),e.draw(6),e.end(),this.backend.device.queue.submit([t.finish()]),this.outputView=null;}};var Ye=`// Input op \u2014 sample a regular 2D source texture (RGBA8 unorm) into the NHWC
+// vec4<f32> output buffer at the target resolution. Used for ImageBitmap
+// sources, which are uploaded into a persistent staging texture via
+// copyExternalImageToTexture before each dispatch.
+
+struct Params {
+    out_w : u32,
+    out_h : u32,
+    _pad0 : u32,
+    _pad1 : u32,
+}
+
+@group(0) @binding(0) var                       src_tex     : texture_2d<f32>;
+@group(0) @binding(1) var                       src_sampler : sampler;
+@group(0) @binding(2) var<uniform>              params      : Params;
+@group(0) @binding(3) var<storage, read_write>  output_buf  : array<vec4<f32>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;
+    let y = gid.y;
+    if (x >= params.out_w || y >= params.out_h) { return; }
+
+    let uv = vec2<f32>(
+        (f32(x) + 0.5) / f32(params.out_w),
+        (f32(y) + 0.5) / f32(params.out_h),
+    );
+    let rgba = textureSampleLevel(src_tex, src_sampler, uv, 0.0);
+    output_buf[y * params.out_w + x] = rgba;
+}
+`;var Ke=`enable f16;
+
+// Input op \u2014 f16 storage variant. Source is sampled as vec4<f32>; only the
+// store is demoted to vec4<f16>.
+
+struct Params {
+    out_w : u32,
+    out_h : u32,
+    _pad0 : u32,
+    _pad1 : u32,
+}
+
+@group(0) @binding(0) var                       src_tex     : texture_2d<f32>;
+@group(0) @binding(1) var                       src_sampler : sampler;
+@group(0) @binding(2) var<uniform>              params      : Params;
+@group(0) @binding(3) var<storage, read_write>  output_buf  : array<vec4<f16>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;
+    let y = gid.y;
+    if (x >= params.out_w || y >= params.out_h) { return; }
+
+    let uv = vec2<f32>(
+        (f32(x) + 0.5) / f32(params.out_w),
+        (f32(y) + 0.5) / f32(params.out_h),
+    );
+    let rgba = textureSampleLevel(src_tex, src_sampler, uv, 0.0);
+    output_buf[y * params.out_w + x] = vec4<f16>(rgba);
+}
+`;var Je=`// Input op \u2014 sample a GPUExternalTexture (zero-copy VideoFrame import) into
+// the NHWC vec4<f32> output buffer at the target resolution. Used when the
+// caller passes a VideoFrame to setSource(); requires importExternalTexture
+// to be called in the same task as the dispatch (the texture is invalidated
+// after the current task completes).
+
+struct Params {
+    out_w : u32,
+    out_h : u32,
+    _pad0 : u32,
+    _pad1 : u32,
+}
+
+@group(0) @binding(0) var                       src_tex     : texture_external;
+@group(0) @binding(1) var                       src_sampler : sampler;
+@group(0) @binding(2) var<uniform>              params      : Params;
+@group(0) @binding(3) var<storage, read_write>  output_buf  : array<vec4<f32>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;
+    let y = gid.y;
+    if (x >= params.out_w || y >= params.out_h) { return; }
+
+    let uv = vec2<f32>(
+        (f32(x) + 0.5) / f32(params.out_w),
+        (f32(y) + 0.5) / f32(params.out_h),
+    );
+    let rgba = textureSampleBaseClampToEdge(src_tex, src_sampler, uv);
+    output_buf[y * params.out_w + x] = rgba;
+}
+`;var Xe=`enable f16;
+
+// Input op \u2014 texture_external + f16 storage. Sample in f32, store as f16.
+
+struct Params {
+    out_w : u32,
+    out_h : u32,
+    _pad0 : u32,
+    _pad1 : u32,
+}
+
+@group(0) @binding(0) var                       src_tex     : texture_external;
+@group(0) @binding(1) var                       src_sampler : sampler;
+@group(0) @binding(2) var<uniform>              params      : Params;
+@group(0) @binding(3) var<storage, read_write>  output_buf  : array<vec4<f16>>;
+
+@compute @workgroup_size(8, 8, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let x = gid.x;
+    let y = gid.y;
+    if (x >= params.out_w || y >= params.out_h) { return; }
+
+    let uv = vec2<f32>(
+        (f32(x) + 0.5) / f32(params.out_w),
+        (f32(y) + 0.5) / f32(params.out_h),
+    );
+    let rgba = textureSampleBaseClampToEdge(src_tex, src_sampler, uv);
+    output_buf[y * params.out_w + x] = vec4<f16>(rgba);
+}
+`;var Yt=i=>typeof VideoFrame<"u"&&i instanceof VideoFrame,Y=class{output;device;dtype;sampler;uniformBuffer;dispatch;pipeline2d=null;pipelineExternal=null;stagingTex=null;stagingW=0;stagingH=0;source=null;constructor(t,e,r){this.device=t.device,this.dtype=t.dtype,this.output=t.tensor(e,r,4),this.sampler=this.device.createSampler({magFilter:"linear",minFilter:"linear",addressModeU:"clamp-to-edge",addressModeV:"clamp-to-edge"}),this.uniformBuffer=this.device.createBuffer({size:16,usage:GPUBufferUsage.UNIFORM|GPUBufferUsage.COPY_DST});let a=new ArrayBuffer(16);new Uint32Array(a,0,2).set([r,e]),this.device.queue.writeBuffer(this.uniformBuffer,0,a),this.dispatch=[Math.ceil(r/8),Math.ceil(e/8),1],this.pipeline2d=this.buildPipeline(this.dtype==="f16"?Ke:Ye);}setSource(t){this.source=t;}run(){if(!this.source)throw new Error("InputWebGPU.run() called before setSource()");Yt(this.source)?this.runExternal(this.source):this.run2d(this.source);}run2d(t){this.ensureStagingTexture(t.width,t.height),this.device.queue.copyExternalImageToTexture({source:t,flipY:false},{texture:this.stagingTex},[t.width,t.height]);let e=this.device.createBindGroup({layout:this.pipeline2d.getBindGroupLayout(0),entries:[{binding:0,resource:this.stagingTex.createView()},{binding:1,resource:this.sampler},{binding:2,resource:{buffer:this.uniformBuffer}},{binding:3,resource:{buffer:this.output.buffer}}]});this.dispatchOnce(this.pipeline2d,e);}runExternal(t){this.pipelineExternal||(this.pipelineExternal=this.buildPipeline(this.dtype==="f16"?Xe:Je));let e=this.device.importExternalTexture({source:t}),r=this.device.createBindGroup({layout:this.pipelineExternal.getBindGroupLayout(0),entries:[{binding:0,resource:e},{binding:1,resource:this.sampler},{binding:2,resource:{buffer:this.uniformBuffer}},{binding:3,resource:{buffer:this.output.buffer}}]});this.dispatchOnce(this.pipelineExternal,r);}ensureStagingTexture(t,e){this.stagingTex&&this.stagingW===t&&this.stagingH===e||(this.stagingTex?.destroy(),this.stagingTex=this.device.createTexture({size:[t,e,1],format:"rgba8unorm",usage:GPUTextureUsage.TEXTURE_BINDING|GPUTextureUsage.COPY_DST|GPUTextureUsage.RENDER_ATTACHMENT}),this.stagingW=t,this.stagingH=e);}buildPipeline(t){let e=this.device.createShaderModule({code:t});return this.device.createComputePipeline({layout:"auto",compute:{module:e,entryPoint:"main"}})}dispatchOnce(t,e){let r=this.device.createCommandEncoder(),a=r.beginComputePass();a.setPipeline(t),a.setBindGroup(0,e),a.dispatchWorkgroups(...this.dispatch),a.end(),this.device.queue.submit([r.finish()]);}};var Kt=navigator.gpu?GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_SRC|GPUBufferUsage.COPY_DST:0,te=class i{constructor(t,e,r){this.device=t;this.canvas=e;this.dtype=r;this.bytesPerElement=r==="f16"?2:4;let a=e.getContext("webgpu");if(!a)throw new Error("Failed to get WebGPU context from canvas");this.canvasContext=a,this.canvasFormat=navigator.gpu.getPreferredCanvasFormat(),this.canvasContext.configure({device:t,format:this.canvasFormat,alphaMode:"premultiplied"}),this.ops={Conv2d:(o,s,n)=>new S(this,o,s,n),DepthwiseConv2d:(o,s,n)=>new A(this,o,s,n),Add:(o,s)=>new O(this,o,s),Sigmoid:o=>new E(this,o),BilinearUpsample:(o,s)=>new F(this,o,s),BicubicUpsample:(o,s)=>new V(this,o,s),ChannelConcat:(o,s)=>new L(this,o,s),Conv2dAdd:(o,s,n,u)=>new H(this,o,s,n,u),UpsampleConcat:(o,s,n)=>new R(this,o,s,n),UpsampleConv1x1:(o,s,n)=>new z(this,o,s,n),UpsampleSigmoid:(o,s)=>new D(this,o,s),Input:(o,s)=>new Y(this,o,s)},this.presenters={CompositeSolid:(o,s,n)=>{let u=new N(this,o,s,n);return {run:()=>{u.setOutput(this.getCurrentDisplayTexture()),u.run();}}},CompositeImage:(o,s,n)=>{let u=new $(this,o,s,n);return {run:()=>{u.setOutput(this.getCurrentDisplayTexture()),u.run();}}},CompositeImageBilinear:(o,s,n)=>{let u=new q(this,o,s,n);return {run:()=>{u.setOutput(this.getCurrentDisplayTexture()),u.run();}}},CompositePassthrough:o=>{let s=new j(this,o);return {run:()=>{s.setOutput(this.getCurrentDisplayTexture()),s.run();}}}};}device;canvas;dtype;ops;presenters;canvasContext;canvasFormat;bytesPerElement;static async isAvailable(){return navigator.gpu?await navigator.gpu.requestAdapter()!==null:false}static async hasF16Support(){if(!navigator.gpu)return  false;let t=await navigator.gpu.requestAdapter();return t?t.features.has("shader-f16"):false}static async create(t){let e=t.dtype??"f32",r=t.device;if(r){if(e==="f16"&&!r.features.has("shader-f16"))throw new Error("WebGPU dtype='f16' requested but supplied device lacks `shader-f16`")}else {let a=await navigator.gpu.requestAdapter();if(!a)throw new Error("WebGPU adapter not available");if(e==="f16"&&!a.features.has("shader-f16"))throw new Error("WebGPU dtype='f16' requested but adapter lacks `shader-f16` feature");r=await a.requestDevice({requiredFeatures:e==="f16"?["shader-f16"]:[]});}return new i(r,t.canvas,e)}getCurrentDisplayTexture(){return this.canvasContext.getCurrentTexture()}tensor(t,e,r,a){let s=t*e*r*this.bytesPerElement,n=this.device.createBuffer({size:s,usage:Kt,mappedAtCreation:a!==void 0});if(a!==void 0){let u=n.getMappedRange();this.writeView(u,a),n.unmap();}return {h:t,w:e,c:r,buffer:n}}upload(t){let r=t.length*this.bytesPerElement,a=this.device.createBuffer({size:r,usage:GPUBufferUsage.STORAGE|GPUBufferUsage.COPY_DST,mappedAtCreation:true});return this.writeView(a.getMappedRange(),t),a.unmap(),{buffer:a}}writeView(t,e){let r=this.dtype==="f16",a=e instanceof Uint16Array;if(r===a){r?new Uint16Array(t).set(e):new Float32Array(t).set(e);return}r?new Uint16Array(t).set(he(e)):new Float32Array(t).set(ee(e));}async readback(t){let e=this.device.createBuffer({size:t.buffer.size,usage:GPUBufferUsage.COPY_DST|GPUBufferUsage.MAP_READ}),r=this.device.createCommandEncoder();r.copyBufferToBuffer(t.buffer,0,e,0,t.buffer.size),this.device.queue.submit([r.finish()]),await e.mapAsync(GPUMapMode.READ);let a=e.getMappedRange(),o=this.dtype==="f16"?ee(new Uint16Array(a.slice(0))):new Float32Array(a.slice(0));return e.unmap(),e.destroy(),o}async sync(){await this.device.queue.onSubmittedWorkDone();}destroy(){this.device.destroy();}};export{Z as EffectsPipeline,te as WebGPUBackend};