oidn-web 0.3.5 → 0.5.0

package/src/nativeUNet.ts

@@ -0,0 +1,2655 @@
+import { Float16Array } from '@petamoriken/float16';
+import { createFinalRgbShader, sharedMemoryBytes as finalRgbSharedMemoryBytes } from './finalRgbShader.js';
+import {
+  optimizeModelGraph,
+  planModelExecution,
+  type ExecutableModelNode,
+  type ModelExecutionPlan,
+  type ModelValueShape
+} from './graphOptimizer.js';
+import type {
+  Conv2DNodeSpec,
+  UNetModelGraph,
+  ValidatedConvTensor,
+  ValidatedUNetModel
+} from './modelSpec';
+import type { HostTensor } from './tza';
+import {
+  OIDNResourceTracker,
+  type OIDNResourceSnapshot
+} from './resourceTracker.js';
+
+export type NativeUNetPrecision = 'fp32' | 'fp16';
+export type NativeUNetPrecisionSetting = NativeUNetPrecision | 'auto';
+export type NativeUNetKernel =
+  | 'direct'
+  | 'implicit-gemm'
+  | 'spatial'
+  | 'subgroup';
+export type NativeUNetKernelSetting = NativeUNetKernel | 'auto';
+export type NativeUNetGemmWorkgroup = readonly [4 | 8 | 16, 4 | 8];
+
+export interface NativeUNetGemmOptions {
+  /** Internal per-layer tile selection; explicit workgroup sizes remain fixed by default. */
+  tilePolicy?: 'fixed' | 'output-aligned';
+  /** Internal decoder source-branch scheduling experiment. */
+  decoderLoad?: 'per-load' | 'source-first';
+  /** Internal pooling dispatch experiment for the GEMM execution path. */
+  poolLayout?: 'spatial' | 'channels';
+  /** Internal shared-memory padding experiment; does not change storage ABI. */
+  sharedLayout?: 'linear' | 'padded' | 'padded-input' | 'padded-weights';
+  /** Internal loop scheduling experiment; each output keeps the same K order. */
+  accumulationOrder?: 'k-major' | 'row-major';
+  /** Internal final-convolution experiments; retains the original FP16 partial order. */
+  finalLayer?: 'direct' | 'shared-input' | 'shared-input-weights' | 'shared-auto';
+  /** Internal load-layout experiments; packed loads preserve the FP16 storage bits. */
+  loadMode?: 'native' | 'packed-weights' | 'packed-all';
+  /** Incremental addressing (default), or the original analytic path for A/B comparisons. */
+  addressMode?: 'analytic' | 'incremental' | 'base-offset';
+  /** K-major (default) coalesces neighboring output-block loads; output-major preserves the old ABI. */
+  weightLayout?: 'output-major' | 'k-major';
+  /** Register tile height (default 8). The K reduction grouping stays fixed. */
+  rowsPerThread?: 2 | 4 | 8;
+  /** Workgroup width/height (default [8, 8]); width also selects output channel blocks. */
+  workgroupSize?: NativeUNetGemmWorkgroup;
+}
+
+export interface NativeUNetOptions {
+  precision?: NativeUNetPrecisionSetting;
+  /**
+   * Convolution kernel selection. `auto` uses implicit GEMM for FP16/FP32
+   * convolutions and the direct kernel for the final output layer.
+   */
+  kernel?: NativeUNetKernelSetting;
+  /** Optional implicit-GEMM tuning; other convolution kernels ignore it. */
+  gemm?: NativeUNetGemmOptions;
+  /** Maximum number of shape-dependent activation plans retained. */
+  shapeCacheSize?: number;
+}
+
+export interface NativeUNetLayerTiming {
+  id: string;
+  durationMs: number;
+}
+
+export interface NativeUNetExecutionProfile {
+  totalMs: number;
+  layers: NativeUNetLayerTiming[];
+}
+
+interface PackedConvBuffers {
+  weights: GPUBuffer;
+  bias: GPUBuffer;
+  weightLayout: NonNullable<NativeUNetGemmOptions['weightLayout']>;
+}
+
+interface NativePipelineSpec {
+  key: string;
+  code: string;
+  kernel?: NativeUNetKernel;
+}
+
+interface ActivationSlot {
+  buffer: GPUBuffer;
+  capacity: number;
+  activeValue?: string;
+}
+
+interface CachedExecution {
+  plan: ModelExecutionPlan;
+  valueBuffers: Map<string, GPUBuffer>;
+  slots: ActivationSlot[];
+  nodeBindings: GPUBindGroup[];
+  nodePipelines: GPUComputePipeline[];
+  nodeKernels: NativeUNetKernel[];
+  inputPipeline: GPUComputePipeline;
+  inputUniform: GPUBuffer;
+  ownedBuffers: GPUBuffer[];
+  cpuInputBuffers?: GPUBuffer[];
+  cpuReadbackBuffer?: GPUBuffer;
+  lastUsed: number;
+}
+
+interface SharedPipelineCache {
+  ready: Map<string, GPUComputePipeline>;
+  pending: Map<string, Promise<GPUComputePipeline>>;
+}
+
+const pipelineCachesByDevice = new WeakMap<GPUDevice, SharedPipelineCache>();
+
+function sharedPipelineCache(device: GPUDevice) {
+  let cache = pipelineCachesByDevice.get(device);
+  if (!cache) {
+    cache = { ready: new Map(), pending: new Map() };
+    pipelineCachesByDevice.set(device, cache);
+  }
+  return cache;
+}
+
+const WORKGROUP_SIZE = 8;
+const TILED_CONV_K_BLOCKS = 8;
+const SPATIAL_CONV_WORKGROUP = 8;
+const SPATIAL_CONV_PATCH = SPATIAL_CONV_WORKGROUP + 2;
+
+function gemmTile(options: Readonly<Required<NativeUNetGemmOptions>>) {
+  const [workgroupX, workgroupY] = options.workgroupSize;
+  return {
+    workgroupX,
+    workgroupY,
+    rowsPerThread: options.rowsPerThread,
+    tileM: workgroupY * options.rowsPerThread,
+    tileNBlocks: workgroupX,
+    // Keep the half partial accumulation grouping independent of tile tuning.
+    tileKBlocks: TILED_CONV_K_BLOCKS
+  };
+}
+
+// Holes change only workgroup addresses. Cooperative loads still visit the
+// original dense logical tiles and never read the unused padding elements.
+function gemmSharedSizes(options: Readonly<Required<NativeUNetGemmOptions>>) {
+  const tile = gemmTile(options);
+  const paddedInput = options.sharedLayout === 'padded' || options.sharedLayout === 'padded-input';
+  const paddedWeights = options.sharedLayout === 'padded' || options.sharedLayout === 'padded-weights';
+  return {
+    input: tile.tileM * tile.tileKBlocks + (paddedInput ? tile.workgroupY : 0),
+    weights: tile.tileKBlocks * tile.tileNBlocks * (paddedWeights ? 5 : 4)
+  };
+}
+
+function gemmSharedInputIndex(index: string, options: Readonly<Required<NativeUNetGemmOptions>>) {
+  return options.sharedLayout === 'padded' || options.sharedLayout === 'padded-input'
+    ? `(${index}) + (${index}) / ${options.rowsPerThread * TILED_CONV_K_BLOCKS}u`
+    : index;
+}
+
+function gemmSharedWeightIndex(index: string, options: Readonly<Required<NativeUNetGemmOptions>>) {
+  return options.sharedLayout === 'padded' || options.sharedLayout === 'padded-weights'
+    ? `(${index}) + (${index}) / 4u`
+    : index;
+}
+
+function roundUp(value: number, alignment: number) {
+  return Math.ceil(value / alignment) * alignment;
+}
+
+function blocksForChannels(channels: number) {
+  return Math.ceil(channels / 4);
+}
+
+function activationByteSize(
+  shape: ModelValueShape,
+  bytesPerScalar: number
+) {
+  return (
+    shape.width *
+    shape.height *
+    blocksForChannels(shape.channels) *
+    4 *
+    bytesPerScalar
+  );
+}
+
+let float16ToFloat32Lookup: Float32Array | undefined;
+
+function halfBitsToNumber(bits: number) {
+  const sign = bits & 0x8000 ? -1 : 1;
+  const exponent = (bits >>> 10) & 0x1f;
+  const fraction = bits & 0x3ff;
+  if (exponent === 0) {
+    return sign * fraction * 2 ** -24;
+  }
+  if (exponent === 0x1f) {
+    return fraction === 0 ? sign * Infinity : NaN;
+  }
+  return sign * (1 + fraction / 1024) * 2 ** (exponent - 15);
+}
+
+function halfLookup() {
+  if (!float16ToFloat32Lookup) {
+    float16ToFloat32Lookup = new Float32Array(1 << 16);
+    for (let bits = 0; bits < float16ToFloat32Lookup.length; bits++) {
+      float16ToFloat32Lookup[bits] = halfBitsToNumber(bits);
+    }
+  }
+  return float16ToFloat32Lookup;
+}
+
+function tensorFloat32Values(tensor: HostTensor): Float32Array {
+  if (tensor.desc.dataType === 'Float32') {
+    return new Float32Array(
+      tensor.data.buffer,
+      tensor.data.byteOffset,
+      tensor.data.byteLength / 4
+    );
+  }
+  const bits = new Uint16Array(
+    tensor.data.buffer,
+    tensor.data.byteOffset,
+    tensor.data.byteLength / 2
+  );
+  const values = new Float32Array(bits.length);
+  if (bits.length < 4096) {
+    for (let index = 0; index < bits.length; index++) {
+      values[index] = halfBitsToNumber(bits[index]);
+    }
+  } else {
+    const lookup = halfLookup();
+    for (let index = 0; index < bits.length; index++) {
+      values[index] = lookup[bits[index]];
+    }
+  }
+  return values;
+}
+
+function createMappedBuffer(
+  device: GPUDevice,
+  label: string,
+  data: ArrayBufferView,
+  usage: GPUBufferUsageFlags
+) {
+  const size = roundUp(data.byteLength, 4);
+  const buffer = device.createBuffer({
+    label,
+    size,
+    usage,
+    mappedAtCreation: true
+  });
+  new Uint8Array(buffer.getMappedRange()).set(
+    new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+  );
+  buffer.unmap();
+  return buffer;
+}
+
+function createUniformBuffer(
+  device: GPUDevice,
+  label: string,
+  values: readonly number[]
+) {
+  const data = new Uint32Array(roundUp(values.length, 4));
+  data.set(values);
+  return createMappedBuffer(device, label, data, GPUBufferUsage.UNIFORM);
+}
+
+function packConvTensors(
+  device: GPUDevice,
+  id: string,
+  tensors: ValidatedConvTensor,
+  precision: NativeUNetPrecision,
+  weightLayout: NonNullable<NativeUNetGemmOptions['weightLayout']>
+): PackedConvBuffers {
+  const inputBlocks = blocksForChannels(tensors.inputChannels);
+  const outputBlocks = blocksForChannels(tensors.outputChannels);
+  const packedWeightCount =
+    outputBlocks *
+    tensors.kernelHeight *
+    tensors.kernelWidth *
+    inputBlocks *
+    4 *
+    4;
+  const canCopyHalfBits =
+    precision === 'fp16' && tensors.weight.desc.dataType === 'Float16';
+  const packedWeights = canCopyHalfBits
+    ? new Uint16Array(packedWeightCount)
+    : precision === 'fp16'
+      ? new Float16Array(packedWeightCount)
+      : new Float32Array(packedWeightCount);
+  const sourceWeights = canCopyHalfBits
+    ? new Uint16Array(
+        tensors.weight.data.buffer,
+        tensors.weight.data.byteOffset,
+        tensors.weight.data.byteLength / 2
+      )
+    : tensorFloat32Values(tensors.weight);
+
+  for (let outputBlock = 0; outputBlock < outputBlocks; outputBlock++) {
+    for (let y = 0; y < tensors.kernelHeight; y++) {
+      for (let x = 0; x < tensors.kernelWidth; x++) {
+        for (let inputBlock = 0; inputBlock < inputBlocks; inputBlock++) {
+          for (let outputLane = 0; outputLane < 4; outputLane++) {
+            const outputChannel = outputBlock * 4 + outputLane;
+            for (let inputLane = 0; inputLane < 4; inputLane++) {
+              const inputChannel = inputBlock * 4 + inputLane;
+              const packedBlock = weightLayout === 'k-major'
+                ? ((((y * tensors.kernelWidth + x) * inputBlocks + inputBlock) *
+                    outputBlocks + outputBlock) * 16)
+                : ((((outputBlock * tensors.kernelHeight + y) *
+                  tensors.kernelWidth +
+                  x) *
+                  inputBlocks +
+                  inputBlock) *
+                  16);
+              // One vec4 contains the four output lanes for an input lane.
+              // Both layouts preserve the vec4's output lanes and the
+              // convolution's reduction order; only the vec4 address changes.
+              const packedIndex =
+                packedBlock + inputLane * 4 + outputLane;
+              if (
+                outputChannel < tensors.outputChannels &&
+                inputChannel < tensors.inputChannels
+              ) {
+                const sourceIndex =
+                  ((outputChannel * tensors.inputChannels + inputChannel) *
+                    tensors.kernelHeight +
+                    y) *
+                    tensors.kernelWidth +
+                  x;
+                packedWeights[packedIndex] = sourceWeights[sourceIndex];
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Bias stays f32 even for half activations because convolution accumulates
+  // in f32. Padded lanes are zero and never escape the final three channels.
+  const packedBias = new Float32Array(outputBlocks * 4);
+  packedBias.set(tensorFloat32Values(tensors.bias));
+
+  const weights = createMappedBuffer(
+    device,
+    `oidn/${id}/weights/${precision}/${weightLayout}`,
+    packedWeights,
+    GPUBufferUsage.STORAGE
+  );
+  try {
+    return {
+      weights,
+      weightLayout,
+      bias: createMappedBuffer(
+        device,
+        `oidn/${id}/bias`,
+        packedBias,
+        GPUBufferUsage.STORAGE
+      )
+    };
+  } catch (error) {
+    weights.destroy();
+    throw error;
+  }
+}
+
+function storageVecType(precision: NativeUNetPrecision) {
+  return precision === 'fp16' ? 'vec4<f16>' : 'vec4<f32>';
+}
+
+function shaderPreamble(precision: NativeUNetPrecision) {
+  return precision === 'fp16' ? 'enable f16;\n' : '';
+}
+
+function storeExpression(
+  expression: string,
+  outputPrecision: NativeUNetPrecision
+) {
+  return outputPrecision === 'fp16'
+    ? `vec4<f16>(${expression})`
+    : expression;
+}
+
+function activationExpression(
+  expression: string,
+  activation: Conv2DNodeSpec['activation']
+) {
+  return activation === 'relu'
+    ? `max(${expression}, vec4<f32>(0.0))`
+    : expression;
+}
+
+function accumulationCode(
+  inputExpression: string,
+  weightBase: string,
+  precision: NativeUNetPrecision
+) {
+  if (precision === 'fp32') {
+    return /* wgsl */ `
+let inputValue = vec4<f32>(${inputExpression});
+let weightBase = ${weightBase};
+acc = fma(vec4<f32>(weights[weightBase]), vec4<f32>(inputValue.x), acc);
+acc = fma(vec4<f32>(weights[weightBase + 1u]), vec4<f32>(inputValue.y), acc);
+acc = fma(vec4<f32>(weights[weightBase + 2u]), vec4<f32>(inputValue.z), acc);
+acc = fma(vec4<f32>(weights[weightBase + 3u]), vec4<f32>(inputValue.w), acc);
+`;
+  }
+  return /* wgsl */ `
+let inputValue = vec4<f16>(${inputExpression});
+let weightBase = ${weightBase};
+var partial = vec4<f16>(0.0h);
+partial = fma(weights[weightBase], vec4<f16>(inputValue.x), partial);
+partial = fma(weights[weightBase + 1u], vec4<f16>(inputValue.y), partial);
+partial = fma(weights[weightBase + 2u], vec4<f16>(inputValue.z), partial);
+partial = fma(weights[weightBase + 3u], vec4<f16>(inputValue.w), partial);
+acc += vec4<f32>(partial);
+`;
+}
+
+function subgroupAccumulationCode(
+  inputExpression: string,
+  weightBase: string,
+  precision: NativeUNetPrecision
+) {
+  const inputType = precision === 'fp16' ? 'vec4<f16>' : 'vec4<f32>';
+  const accumulator = precision === 'fp16'
+    ? `var partial = vec4<f16>(0.0h);
+partial = fma(subgroupBroadcast(weights[weightBase], 0u), ${inputType}(inputValue.x), partial);
+partial = fma(subgroupBroadcast(weights[weightBase + 1u], 0u), ${inputType}(inputValue.y), partial);
+partial = fma(subgroupBroadcast(weights[weightBase + 2u], 0u), ${inputType}(inputValue.z), partial);
+partial = fma(subgroupBroadcast(weights[weightBase + 3u], 0u), ${inputType}(inputValue.w), partial);
+acc += vec4<f32>(partial);`
+    : `acc = fma(subgroupBroadcast(weights[weightBase], 0u), vec4<f32>(inputValue.x), acc);
+acc = fma(subgroupBroadcast(weights[weightBase + 1u], 0u), vec4<f32>(inputValue.y), acc);
+acc = fma(subgroupBroadcast(weights[weightBase + 2u], 0u), vec4<f32>(inputValue.z), acc);
+acc = fma(subgroupBroadcast(weights[weightBase + 3u], 0u), vec4<f32>(inputValue.w), acc);`;
+  return /* wgsl */ `
+let inputValue = ${inputType}(${inputExpression});
+let weightBase = ${weightBase};
+${accumulator}
+`;
+}
+
+function gemmPackedLoad(
+  precision: NativeUNetPrecision,
+  gemm: Readonly<Required<NativeUNetGemmOptions>>,
+  weights: boolean
+) {
+  return precision === 'fp16' &&
+    (gemm.loadMode === 'packed-all' ||
+      (weights && gemm.loadMode === 'packed-weights'));
+}
+
+// vec2<u32> reinterprets exactly the same eight bytes as vec4<f16>.
+function gemmLoadExpression(expression: string, packed: boolean) {
+  return packed ? `bitcast<vec4<f16>>(${expression})` : expression;
+}
+
+function tiledAccumulationCode(precision: NativeUNetPrecision, gemm: Readonly<Required<NativeUNetGemmOptions>>) {
+  const { rowsPerThread, tileNBlocks, tileKBlocks } = gemmTile(gemm);
+  const inputIndex = gemmSharedInputIndex(`tileSpatial * ${tileKBlocks}u + tileK`, gemm);
+  const weightBase = `(tileK * ${tileNBlocks}u + localId.x) * ${gemm.sharedLayout === 'padded' || gemm.sharedLayout === 'padded-weights' ? 5 : 4}u`;
+  if (gemm.accumulationOrder === 'row-major') {
+    const valueType = storageVecType(precision);
+    const target = precision === 'fp16' ? 'partial' : 'acc[row]';
+    return /* wgsl */ `
+    for (var row = 0u; row < ${rowsPerThread}u; row++) {
+      ${precision === 'fp16' ? 'var partial = vec4<f16>(0.0h);' : ''}
+      let tileSpatial = localId.y * ${rowsPerThread}u + row;
+      for (var tileK = 0u; tileK < ${tileKBlocks}u; tileK++) {
+        let weightBase = ${weightBase};
+        let inputValue = inputTile[${inputIndex}];
+        ${target} = fma(weightTile[weightBase], ${valueType}(inputValue.x), ${target});
+        ${target} = fma(weightTile[weightBase + 1u], ${valueType}(inputValue.y), ${target});
+        ${target} = fma(weightTile[weightBase + 2u], ${valueType}(inputValue.z), ${target});
+        ${target} = fma(weightTile[weightBase + 3u], ${valueType}(inputValue.w), ${target});
+      }
+      ${precision === 'fp16' ? 'acc[row] += vec4<f32>(partial);' : ''}
+    }
+`;
+  }
+  if (precision === 'fp16') {
+    return /* wgsl */ `
+    var partial: array<vec4<f16>, ${rowsPerThread}>;
+    for (var row = 0u; row < ${rowsPerThread}u; row++) {
+      partial[row] = vec4<f16>(0.0h);
+    }
+    for (var tileK = 0u; tileK < ${tileKBlocks}u; tileK++) {
+      let weightBase =
+        ${weightBase};
+      for (var row = 0u; row < ${rowsPerThread}u; row++) {
+        let tileSpatial =
+          localId.y * ${rowsPerThread}u + row;
+        let inputValue =
+          inputTile[${inputIndex}];
+        partial[row] = fma(
+          weightTile[weightBase],
+          vec4<f16>(inputValue.x),
+          partial[row]
+        );
+        partial[row] = fma(
+          weightTile[weightBase + 1u],
+          vec4<f16>(inputValue.y),
+          partial[row]
+        );
+        partial[row] = fma(
+          weightTile[weightBase + 2u],
+          vec4<f16>(inputValue.z),
+          partial[row]
+        );
+        partial[row] = fma(
+          weightTile[weightBase + 3u],
+          vec4<f16>(inputValue.w),
+          partial[row]
+        );
+      }
+    }
+    for (var row = 0u; row < ${rowsPerThread}u; row++) {
+      acc[row] += vec4<f32>(partial[row]);
+    }
+`;
+  }
+  return /* wgsl */ `
+    for (var tileK = 0u; tileK < ${tileKBlocks}u; tileK++) {
+      let weightBase =
+        ${weightBase};
+      for (var row = 0u; row < ${rowsPerThread}u; row++) {
+        let tileSpatial =
+          localId.y * ${rowsPerThread}u + row;
+        let inputValue =
+          inputTile[${inputIndex}];
+        acc[row] = fma(
+          weightTile[weightBase],
+          vec4<f32>(inputValue.x),
+          acc[row]
+        );
+        acc[row] = fma(
+          weightTile[weightBase + 1u],
+          vec4<f32>(inputValue.y),
+          acc[row]
+        );
+        acc[row] = fma(
+          weightTile[weightBase + 2u],
+          vec4<f32>(inputValue.z),
+          acc[row]
+        );
+        acc[row] = fma(
+          weightTile[weightBase + 3u],
+          vec4<f32>(inputValue.w),
+          acc[row]
+        );
+      }
+    }
+`;
+}
+
+function createConvShader(
+  precision: NativeUNetPrecision,
+  outputPrecision: NativeUNetPrecision,
+  activation: Conv2DNodeSpec['activation'],
+  inputBlocks: number,
+  outputBlocks: number
+) {
+  const inputType = storageVecType(precision);
+  const weightType = storageVecType(precision);
+  const outputType = storageVecType(outputPrecision);
+  const stored = storeExpression(
+    activationExpression('acc', activation),
+    outputPrecision
+  );
+
+  return /* wgsl */ `${shaderPreamble(precision)}
+struct Params {
+  inputWidth: u32,
+  inputHeight: u32,
+  outputWidth: u32,
+  outputHeight: u32,
+  inputBlocks: u32,
+  outputBlocks: u32,
+}
+
+@group(0) @binding(0) var<storage, read> inputData: array<${inputType}>;
+@group(0) @binding(1) var<storage, read> weights: array<${weightType}>;
+@group(0) @binding(2) var<storage, read> bias: array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> outputData: array<${outputType}>;
+@group(0) @binding(4) var<uniform> params: Params;
+
+@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  if (gid.x >= params.outputWidth || gid.y >= params.outputHeight || gid.z >= ${outputBlocks}u) {
+    return;
+  }
+  var acc = bias[gid.z];
+  for (var ky = 0u; ky < 3u; ky++) {
+    let inputY = i32(gid.y) + i32(ky) - 1;
+    if (inputY < 0 || inputY >= i32(params.inputHeight)) { continue; }
+    for (var kx = 0u; kx < 3u; kx++) {
+      let inputX = i32(gid.x) + i32(kx) - 1;
+      if (inputX < 0 || inputX >= i32(params.inputWidth)) { continue; }
+      let pixelBase = (u32(inputY) * params.inputWidth + u32(inputX)) * ${inputBlocks}u;
+      for (var inputBlock = 0u; inputBlock < ${inputBlocks}u; inputBlock++) {
+        ${accumulationCode(
+          'inputData[pixelBase + inputBlock]',
+          `((((gid.z * 3u + ky) * 3u + kx) * ${inputBlocks}u + inputBlock) * 4u)`,
+          precision
+        )}
+      }
+    }
+  }
+  let outputIndex = (gid.y * params.outputWidth + gid.x) * ${outputBlocks}u + gid.z;
+  outputData[outputIndex] = ${stored};
+}
+`;
+}
+
+/** Direct convolution with subgroup-wide weight broadcast. */
+function createSubgroupConvShader(
+  precision: NativeUNetPrecision,
+  outputPrecision: NativeUNetPrecision,
+  activation: Conv2DNodeSpec['activation'],
+  inputBlocks: number,
+  outputBlocks: number
+) {
+  const inputType = storageVecType(precision);
+  const weightType = storageVecType(precision);
+  const outputType = storageVecType(outputPrecision);
+  const stored = storeExpression(
+    activationExpression('acc', activation),
+    outputPrecision
+  );
+  return /* wgsl */ `${shaderPreamble(precision)}
+enable subgroups;
+struct Params {
+  inputWidth: u32,
+  inputHeight: u32,
+  outputWidth: u32,
+  outputHeight: u32,
+  inputBlocks: u32,
+  outputBlocks: u32,
+}
+@group(0) @binding(0) var<storage, read> inputData: array<${inputType}>;
+@group(0) @binding(1) var<storage, read> weights: array<${weightType}>;
+@group(0) @binding(2) var<storage, read> bias: array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> outputData: array<${outputType}>;
+@group(0) @binding(4) var<uniform> params: Params;
+
+@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  let outputInBounds =
+    gid.x < params.outputWidth && gid.y < params.outputHeight;
+  var acc = bias[gid.z];
+  for (var ky = 0u; ky < 3u; ky++) {
+    let inputY = i32(gid.y) + i32(ky) - 1;
+    let clampedY = u32(clamp(inputY, 0, i32(params.inputHeight) - 1));
+    for (var kx = 0u; kx < 3u; kx++) {
+      let inputX = i32(gid.x) + i32(kx) - 1;
+      let clampedX = u32(clamp(inputX, 0, i32(params.inputWidth) - 1));
+      let inputInBounds =
+        outputInBounds && inputX >= 0 && inputY >= 0 &&
+        inputX < i32(params.inputWidth) && inputY < i32(params.inputHeight);
+      let pixelBase =
+        (clampedY * params.inputWidth + clampedX) * ${inputBlocks}u;
+      for (var inputBlock = 0u; inputBlock < ${inputBlocks}u; inputBlock++) {
+        ${subgroupAccumulationCode(
+          `select(${inputType}(0.0), inputData[pixelBase + inputBlock], inputInBounds)`,
+          `((((gid.z * 3u + ky) * 3u + kx) * ${inputBlocks}u + inputBlock) * 4u)`,
+          precision
+        )}
+      }
+    }
+  }
+  if (outputInBounds) {
+    let outputIndex =
+      (gid.y * params.outputWidth + gid.x) * ${outputBlocks}u + gid.z;
+    outputData[outputIndex] = ${stored};
+  }
+}
+`;
+}
+
+/**
+ * A 2D convolution tile which loads the complete 3x3 halo into workgroup
+ * memory once. Kernel choice only depends on the operation shape, precision,
+ * and device limits; it is deliberately independent of OIDN model names.
+ */
+function createSpatialConvShader(
+  precision: NativeUNetPrecision,
+  outputPrecision: NativeUNetPrecision,
+  activation: Conv2DNodeSpec['activation'],
+  inputBlocks: number,
+  outputBlocks: number
+) {
+  const inputType = storageVecType(precision);
+  const outputType = storageVecType(outputPrecision);
+  const stored = storeExpression(
+    activationExpression('acc', activation),
+    outputPrecision
+  );
+  const patchValues =
+    SPATIAL_CONV_PATCH * SPATIAL_CONV_PATCH * inputBlocks;
+  const workgroupThreads =
+    SPATIAL_CONV_WORKGROUP * SPATIAL_CONV_WORKGROUP;
+
+  return /* wgsl */ `${shaderPreamble(precision)}
+struct Params {
+  inputWidth: u32,
+  inputHeight: u32,
+  outputWidth: u32,
+  outputHeight: u32,
+  inputBlocks: u32,
+  outputBlocks: u32,
+}
+@group(0) @binding(0) var<storage, read> inputData: array<${inputType}>;
+@group(0) @binding(1) var<storage, read> weights: array<${inputType}>;
+@group(0) @binding(2) var<storage, read> bias: array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> outputData: array<${outputType}>;
+@group(0) @binding(4) var<uniform> params: Params;
+
+var<workgroup> inputPatch: array<${inputType}, ${patchValues}>;
+
+@compute @workgroup_size(${SPATIAL_CONV_WORKGROUP}, ${SPATIAL_CONV_WORKGROUP}, 1)
+fn main(
+  @builtin(local_invocation_id) localId: vec3<u32>,
+  @builtin(workgroup_id) workgroupId: vec3<u32>
+) {
+  let localLinear =
+    localId.y * ${SPATIAL_CONV_WORKGROUP}u + localId.x;
+  for (
+    var loadIndex = localLinear;
+    loadIndex < ${patchValues}u;
+    loadIndex += ${workgroupThreads}u
+  ) {
+    let patchPixel = loadIndex / ${inputBlocks}u;
+    let inputBlock = loadIndex % ${inputBlocks}u;
+    let patchX = patchPixel % ${SPATIAL_CONV_PATCH}u;
+    let patchY = patchPixel / ${SPATIAL_CONV_PATCH}u;
+    let inputX =
+      i32(workgroupId.x * ${SPATIAL_CONV_WORKGROUP}u + patchX) - 1;
+    let inputY =
+      i32(workgroupId.y * ${SPATIAL_CONV_WORKGROUP}u + patchY) - 1;
+    var value = ${inputType}(0.0);
+    if (
+      inputX >= 0 && inputX < i32(params.inputWidth) &&
+      inputY >= 0 && inputY < i32(params.inputHeight)
+    ) {
+      let inputIndex =
+        (u32(inputY) * params.inputWidth + u32(inputX)) *
+        ${inputBlocks}u + inputBlock;
+      value = inputData[inputIndex];
+    }
+    inputPatch[loadIndex] = value;
+  }
+  workgroupBarrier();
+
+  let outputX =
+    workgroupId.x * ${SPATIAL_CONV_WORKGROUP}u + localId.x;
+  let outputY =
+    workgroupId.y * ${SPATIAL_CONV_WORKGROUP}u + localId.y;
+  let outputBlock = workgroupId.z;
+  if (
+    outputX >= params.outputWidth || outputY >= params.outputHeight ||
+    outputBlock >= ${outputBlocks}u
+  ) {
+    return;
+  }
+
+  var acc = bias[outputBlock];
+  for (var ky = 0u; ky < 3u; ky++) {
+    for (var kx = 0u; kx < 3u; kx++) {
+      let patchBase =
+        ((localId.y + ky) * ${SPATIAL_CONV_PATCH}u + localId.x + kx) *
+        ${inputBlocks}u;
+      for (var inputBlock = 0u; inputBlock < ${inputBlocks}u; inputBlock++) {
+        ${accumulationCode(
+          'inputPatch[patchBase + inputBlock]',
+          `((((outputBlock * 3u + ky) * 3u + kx) * ${inputBlocks}u + inputBlock) * 4u)`,
+          precision
+        )}
+      }
+    }
+  }
+  let outputIndex =
+    (outputY * params.outputWidth + outputX) * ${outputBlocks}u + outputBlock;
+  outputData[outputIndex] = ${stored};
+}
+`;
+}
+
+/** Precompute spatial predicates once, then advance the original flattened K order. */
+function tiledAddressCacheCode(inputBlocks: number, decoder: boolean, gemm: Readonly<Required<NativeUNetGemmOptions>>, sources?: { blocks: readonly [number, number]; upsampled: 0 | 1 }) {
+  const { workgroupX, workgroupY, tileM, tileKBlocks } = gemmTile(gemm);
+  const width = decoder ? 'params.outputWidth' : 'params.inputWidth';
+  const height = decoder ? 'params.outputHeight' : 'params.inputHeight';
+  const baseOffset = gemm.addressMode === 'base-offset';
+  // Decoder parity travels in the high mask bits, avoiding extra cached arrays.
+  const baseAssignments = sources
+    ? sources.blocks.map((blocks, source) =>
+        `cachedBase${source}[load] = (${source === sources.upsampled ? 'y / 2u' : 'y'} * params.source${source}Width + ${source === sources.upsampled ? 'x / 2u' : 'x'}) * ${blocks}u;`
+      ).join('\n    ')
+    : `cachedBase0[load] = (y * params.inputWidth + x) * ${inputBlocks}u;`;
+  const loads = tileM * tileKBlocks /
+    (workgroupX * workgroupY);
+  return /* wgsl */ `
+  ${baseOffset ? `var cachedBase0: array<u32, ${loads}>;
+  ${sources ? `var cachedBase1: array<u32, ${loads}>;` : ''}` : `var cachedX: array<u32, ${loads}>;
+  var cachedY: array<u32, ${loads}>;`}
+  var cachedMask: array<u32, ${loads}>;
+  for (var load = 0u; load < ${loads}u; load++) {
+    let loadIndex = localLinear + load * ${workgroupX * workgroupY}u;
+    let spatial = workgroupId.x * ${tileM}u + loadIndex / ${tileKBlocks}u;
+    let x = spatial % params.outputWidth;
+    let y = spatial / params.outputWidth;
+    ${baseOffset ? baseAssignments : `cachedX[load] = x;
+    cachedY[load] = y;`}
+    let columns =
+      select(0u, 0x049u, x > 0u && x - 1u < ${width}) |
+      select(0u, 0x092u, x < ${width}) |
+      select(0u, 0x124u, x + 1u < ${width});
+    let rows =
+      select(0u, 0x007u, y > 0u && y - 1u < ${height}) |
+      select(0u, 0x038u, y < ${height}) |
+      select(0u, 0x1c0u, y + 1u < ${height});
+    cachedMask[load] = select(0u, columns & rows, spatial < spatialCount)${baseOffset && sources ? ' | ((x & 1u) << 9u) | ((y & 1u) << 10u)' : ''};
+  }
+  var channelBlock = (localLinear % ${tileKBlocks}u) % ${inputBlocks}u;
+  var filterPosition = (localLinear % ${tileKBlocks}u) / ${inputBlocks}u;
+`;
+}
+
+function tiledAddressAdvanceCode(inputBlocks: number, gemm: Readonly<Required<NativeUNetGemmOptions>>) {
+  const { tileKBlocks } = gemmTile(gemm);
+  // The remainder is less than inputBlocks, so at most one carry is needed.
+  return /* wgsl */ `
+    channelBlock += ${tileKBlocks % inputBlocks}u;
+    let carry = channelBlock >= ${inputBlocks}u;
+    channelBlock -= select(0u, ${inputBlocks}u, carry);
+    filterPosition += ${Math.floor(tileKBlocks / inputBlocks)}u + select(0u, 1u, carry);
+`;
+}
+
+function tiledIncrementalInputCode(valueType: string, readValue: string, gemm: Readonly<Required<NativeUNetGemmOptions>>) {
+  const { workgroupX, workgroupY, tileM, tileKBlocks } = gemmTile(gemm);
+  const loads = tileM * tileKBlocks /
+    (workgroupX * workgroupY);
+  return /* wgsl */ `
+    let inputBlock = channelBlock;
+    let kernelY = filterPosition / 3u;
+    let kernelX = filterPosition % 3u;
+    for (var load = 0u; load < ${loads}u; load++) {
+      let loadIndex = localLinear + load * ${workgroupX * workgroupY}u;
+      var value = ${valueType}(0.0);
+      if (filterPosition < 9u && (cachedMask[load] & (1u << filterPosition)) != 0u) {
+        ${gemm.addressMode === 'base-offset' ? '' : `let inputX = i32(cachedX[load]) + i32(kernelX) - 1;
+        let inputY = i32(cachedY[load]) + i32(kernelY) - 1;`}
+        ${readValue}
+      }
+      inputTile[${gemmSharedInputIndex('loadIndex', gemm)}] = value;
+    }
+`;
+}
+
+/**
+ * Implicit-GEMM convolution for FP16/FP32. This follows the packed WebGPU
+ * shape: configurable spatial rows and vec4 output blocks per workgroup.
+ * The eight-vec4 K tile stays fixed to preserve FP16 rounding across variants.
+ */
+function createTiledConvShader(
+  precision: NativeUNetPrecision,
+  outputPrecision: NativeUNetPrecision,
+  activation: Conv2DNodeSpec['activation'],
+  inputBlocks: number,
+  outputBlocks: number,
+  gemm: Readonly<Required<NativeUNetGemmOptions>>
+) {
+  const { workgroupX, workgroupY, rowsPerThread, tileM, tileNBlocks, tileKBlocks } = gemmTile(gemm);
+  const { addressMode, weightLayout } = gemm;
+  const inputType = storageVecType(precision);
+  const outputType = storageVecType(outputPrecision);
+  const packedInput = gemmPackedLoad(precision, gemm, false);
+  const packedWeights = gemmPackedLoad(precision, gemm, true);
+  const inputStorageType = packedInput ? 'vec2<u32>' : inputType;
+  const weightStorageType = packedWeights ? 'vec2<u32>' : inputType;
+  const stored = storeExpression(
+    activationExpression('acc', activation),
+    outputPrecision
+  );
+  const workgroupThreads =
+    workgroupX * workgroupY;
+  const inputTileValues = tileM * tileKBlocks;
+  const weightTileValues =
+    tileKBlocks * tileNBlocks * 4;
+  return /* wgsl */ `${shaderPreamble(precision)}
+struct Params {
+  inputWidth: u32,
+  inputHeight: u32,
+  outputWidth: u32,
+  outputHeight: u32,
+  inputBlocks: u32,
+  outputBlocks: u32,
+}
+@group(0) @binding(0) var<storage, read> inputData: array<${inputStorageType}>;
+@group(0) @binding(1) var<storage, read> weights: array<${weightStorageType}>;
+@group(0) @binding(2) var<storage, read> bias: array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> outputData: array<${outputType}>;
+@group(0) @binding(4) var<uniform> params: Params;
+
+var<workgroup> inputTile: array<${inputType}, ${gemmSharedSizes(gemm).input}>;
+var<workgroup> weightTile: array<${inputType}, ${gemmSharedSizes(gemm).weights}>;
+
+@compute @workgroup_size(${workgroupX}, ${workgroupY}, 1)
+fn main(
+  @builtin(local_invocation_id) localId: vec3<u32>,
+  @builtin(workgroup_id) workgroupId: vec3<u32>
+) {
+  let spatialBase =
+    workgroupId.x * ${tileM}u +
+    localId.y * ${rowsPerThread}u;
+  let outputBlock =
+    workgroupId.y * ${tileNBlocks}u + localId.x;
+  let spatialCount = params.outputWidth * params.outputHeight;
+  var acc: array<vec4<f32>, ${rowsPerThread}>;
+  if (outputBlock < ${outputBlocks}u) {
+    for (var row = 0u; row < ${rowsPerThread}u; row++) {
+      acc[row] = bias[outputBlock];
+    }
+  }
+
+  let localLinear =
+    localId.y * ${workgroupX}u + localId.x;
+  ${addressMode !== 'analytic' ? tiledAddressCacheCode(inputBlocks, false, gemm) : ''}
+  let totalK = ${inputBlocks * 9}u;
+  for (var kBase = 0u; kBase < totalK; kBase += ${tileKBlocks}u) {
+    ${addressMode !== 'analytic' ? tiledIncrementalInputCode(inputType, `
+        ${addressMode === 'base-offset' ? `let offset = (i32(kernelY) - 1) * i32(params.inputWidth) + i32(kernelX) - 1;
+        let inputIndex = cachedBase0[load] + u32(offset * ${inputBlocks}) + inputBlock;` : `let inputIndex = (u32(inputY) * params.inputWidth + u32(inputX)) *
+          ${inputBlocks}u + inputBlock;`}
+        value = ${gemmLoadExpression('inputData[inputIndex]', packedInput)};
+    `, gemm) : /* wgsl */ `
+    for (
+      var loadIndex = localLinear;
+      loadIndex < ${inputTileValues}u;
+      loadIndex += ${workgroupThreads}u
+    ) {
+      let tileSpatial = loadIndex / ${tileKBlocks}u;
+      let tileK = loadIndex % ${tileKBlocks}u;
+      let inputSpatialIndex =
+        workgroupId.x * ${tileM}u + tileSpatial;
+      let kIndex = kBase + tileK;
+      var value = ${inputType}(0.0);
+      if (inputSpatialIndex < spatialCount && kIndex < totalK) {
+        let outputY = inputSpatialIndex / params.outputWidth;
+        let outputX = inputSpatialIndex % params.outputWidth;
+        let inputBlock = kIndex % ${inputBlocks}u;
+        let kernelIndex = kIndex / ${inputBlocks}u;
+        let kernelY = kernelIndex / 3u;
+        let kernelX = kernelIndex % 3u;
+        let inputY = i32(outputY) + i32(kernelY) - 1;
+        let inputX = i32(outputX) + i32(kernelX) - 1;
+        if (
+          inputY >= 0 && inputY < i32(params.inputHeight) &&
+          inputX >= 0 && inputX < i32(params.inputWidth)
+        ) {
+          let inputIndex =
+            (u32(inputY) * params.inputWidth + u32(inputX)) *
+            ${inputBlocks}u + inputBlock;
+          value = ${gemmLoadExpression('inputData[inputIndex]', packedInput)};
+        }
+      }
+      inputTile[${gemmSharedInputIndex('loadIndex', gemm)}] = value;
+    }
+    `}
+
+    for (
+      var loadIndex = localLinear;
+      loadIndex < ${weightTileValues}u;
+      loadIndex += ${workgroupThreads}u
+    ) {
+      let tileK = loadIndex / ${tileNBlocks * 4}u;
+      let outputRemainder = loadIndex % ${tileNBlocks * 4}u;
+      let tileOutputBlock = outputRemainder / 4u;
+      let outputLane = outputRemainder % 4u;
+      let loadedOutputBlock =
+        workgroupId.y * ${tileNBlocks}u + tileOutputBlock;
+      let kIndex = kBase + tileK;
+      var value = ${inputType}(0.0);
+      if (loadedOutputBlock < ${outputBlocks}u && kIndex < totalK) {
+        ${weightLayout === 'k-major' ? /* wgsl */ `
+        let weightIndex = (kIndex * ${outputBlocks}u + loadedOutputBlock) * 4u + outputLane;
+        ` : addressMode !== 'analytic' ? /* wgsl */ `
+        let weightIndex = (loadedOutputBlock * ${inputBlocks * 9}u + kIndex) * 4u + outputLane;
+        ` : /* wgsl */ `
+        let inputBlock = kIndex % ${inputBlocks}u;
+        let kernelIndex = kIndex / ${inputBlocks}u;
+        let kernelY = kernelIndex / 3u;
+        let kernelX = kernelIndex % 3u;
+        let weightIndex =
+          ((((loadedOutputBlock * 3u + kernelY) * 3u + kernelX) *
+            ${inputBlocks}u + inputBlock) * 4u + outputLane);
+        `}
+        value = ${gemmLoadExpression('weights[weightIndex]', packedWeights)};
+      }
+      weightTile[${gemmSharedWeightIndex('loadIndex', gemm)}] = value;
+    }
+
+    workgroupBarrier();
+    ${tiledAccumulationCode(precision, gemm)}
+    workgroupBarrier();
+    ${addressMode !== 'analytic' ? tiledAddressAdvanceCode(inputBlocks, gemm) : ''}
+  }
+
+  if (outputBlock < ${outputBlocks}u) {
+    for (var row = 0u; row < ${rowsPerThread}u; row++) {
+      let spatialIndex = spatialBase + row;
+      if (spatialIndex < spatialCount) {
+        let outputIndex = spatialIndex * ${outputBlocks}u + outputBlock;
+        outputData[outputIndex] = ${stored.replaceAll('acc', 'acc[row]')};
+      }
+    }
+  }
+}
+`;
+}
+
+function createFusedConvPoolShader(
+  precision: NativeUNetPrecision,
+  activation: Conv2DNodeSpec['activation'],
+  inputBlocks: number,
+  outputBlocks: number
+) {
+  const valueType = storageVecType(precision);
+  const activated = activationExpression('acc', activation);
+  return /* wgsl */ `${shaderPreamble(precision)}
+struct Params {
+  inputWidth: u32,
+  inputHeight: u32,
+  outputWidth: u32,
+  outputHeight: u32,
+  inputBlocks: u32,
+  outputBlocks: u32,
+}
+@group(0) @binding(0) var<storage, read> inputData: array<${valueType}>;
+@group(0) @binding(1) var<storage, read> weights: array<${valueType}>;
+@group(0) @binding(2) var<storage, read> bias: array<vec4<f32>>;
+@group(0) @binding(3) var<storage, read_write> outputData: array<${valueType}>;
+@group(0) @binding(4) var<uniform> params: Params;
+
+@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  if (gid.x >= params.outputWidth || gid.y >= params.outputHeight || gid.z >= ${outputBlocks}u) {
+    return;
+  }
+  var pooled = vec4<f32>(-3.402823466e+38);
+  for (var py = 0u; py < 2u; py++) {
+    let centerY = gid.y * 2u + py;
+    if (centerY >= params.inputHeight) { continue; }
+    for (var px = 0u; px < 2u; px++) {
+      let centerX = gid.x * 2u + px;
+      if (centerX >= params.inputWidth) { continue; }
+      var acc = bias[gid.z];
+      for (var ky = 0u; ky < 3u; ky++) {
+        let inputY = i32(centerY) + i32(ky) - 1;
+        if (inputY < 0 || inputY >= i32(params.inputHeight)) { continue; }
+        for (var kx = 0u; kx < 3u; kx++) {
+          let inputX = i32(centerX) + i32(kx) - 1;
+          if (inputX < 0 || inputX >= i32(params.inputWidth)) { continue; }
+          let pixelBase = (u32(inputY) * params.inputWidth + u32(inputX)) * ${inputBlocks}u;
+          for (var inputBlock = 0u; inputBlock < ${inputBlocks}u; inputBlock++) {
+            ${accumulationCode(
+              'inputData[pixelBase + inputBlock]',
+              `((((gid.z * 3u + ky) * 3u + kx) * ${inputBlocks}u + inputBlock) * 4u)`,
+              precision
+            )}
+          }
+        }
+      }
+      pooled = max(pooled, ${activated});
+    }
+  }
+  let outputIndex = (gid.y * params.outputWidth + gid.x) * ${outputBlocks}u + gid.z;
+  outputData[outputIndex] = ${storeExpression('pooled', precision)};
+}
+`;
+}
+
+function createMaxPoolShader(
+  precision: NativeUNetPrecision,
+  outputBlocks: number,
+  coalesced: boolean
+) {
+  const valueType = storageVecType(precision);
+  return /* wgsl */ `${shaderPreamble(precision)}
+struct Params {
+  inputWidth: u32,
+  inputHeight: u32,
+  outputWidth: u32,
+  outputHeight: u32,
+  outputBlocks: u32,
+}
+@group(0) @binding(0) var<storage, read> inputData: array<${valueType}>;
+@group(0) @binding(1) var<storage, read_write> outputData: array<${valueType}>;
+@group(0) @binding(2) var<uniform> params: Params;
+
+@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)
+fn main(
+  @builtin(global_invocation_id) gid: vec3<u32>${coalesced ? ',\n  @builtin(num_workgroups) groupCount: vec3<u32>' : ''}
+) {
+  ${coalesced ? `let linearX = gid.x + gid.z * groupCount.x * ${WORKGROUP_SIZE}u;
+  let outputBlock = linearX % ${outputBlocks}u;
+  let outputX = linearX / ${outputBlocks}u;` : `let outputBlock = gid.z;
+  let outputX = gid.x;`}
+  if (
+    outputX >= params.outputWidth ||
+    gid.y >= params.outputHeight ||
+    outputBlock >= ${outputBlocks}u
+  ) {
+    return;
+  }
+  var pooled = vec4<f32>(-3.402823466e+38);
+  for (var py = 0u; py < 2u; py++) {
+    let inputY = gid.y * 2u + py;
+    if (inputY >= params.inputHeight) { continue; }
+    for (var px = 0u; px < 2u; px++) {
+      let inputX = outputX * 2u + px;
+      if (inputX >= params.inputWidth) { continue; }
+      let inputIndex =
+        (inputY * params.inputWidth + inputX) * ${outputBlocks}u + outputBlock;
+      pooled = max(pooled, vec4<f32>(inputData[inputIndex]));
+    }
+  }
+  let outputIndex =
+    (gid.y * params.outputWidth + outputX) * ${outputBlocks}u + outputBlock;
+  outputData[outputIndex] = ${storeExpression('pooled', precision)};
+}
+`;
+}
+
+function createTiledDecoderShader(
+  precision: NativeUNetPrecision,
+  outputPrecision: NativeUNetPrecision,
+  activation: Conv2DNodeSpec['activation'],
+  sourceBlocks: readonly [number, number],
+  upsampledSource: 0 | 1,
+  outputBlocks: number,
+  gemm: Readonly<Required<NativeUNetGemmOptions>>
+) {
+  const { workgroupX, workgroupY, rowsPerThread, tileM, tileNBlocks, tileKBlocks } = gemmTile(gemm);
+  const { addressMode, weightLayout } = gemm;
+  const valueType = storageVecType(precision);
+  const outputType = storageVecType(outputPrecision);
+  const packedInput = gemmPackedLoad(precision, gemm, false);
+  const packedWeights = gemmPackedLoad(precision, gemm, true);
+  const inputStorageType = packedInput ? 'vec2<u32>' : valueType;
+  const weightStorageType = packedWeights ? 'vec2<u32>' : valueType;
+  const inputBlocks = sourceBlocks[0] + sourceBlocks[1];
+  const stored = storeExpression(
+    activationExpression('acc[row]', activation),
+    outputPrecision
+  );
+  const workgroupThreads =
+    workgroupX * workgroupY;
+  const inputTileValues = tileM * tileKBlocks;
+  const weightTileValues =
+    tileKBlocks * tileNBlocks * 4;
+  const sourceRead = (source: 0 | 1, blockExpression: string) => {
+    const sourceX =
+      source === upsampledSource
+        ? 'u32(inputX) / 2u'
+        : 'u32(inputX)';
+    const sourceY =
+      source === upsampledSource
+        ? 'u32(inputY) / 2u'
+        : 'u32(inputY)';
+    return /* wgsl */ `
+          {
+            let sourceBlock = ${blockExpression};
+            ${addressMode === 'base-offset' ? `let dx = ${source === upsampledSource ? '(i32((cachedMask[load] >> 9u) & 1u) + i32(kernelX) - 1) >> 1u' : 'i32(kernelX) - 1'};
+            let dy = ${source === upsampledSource ? '(i32((cachedMask[load] >> 10u) & 1u) + i32(kernelY) - 1) >> 1u' : 'i32(kernelY) - 1'};
+            let offset = (dy * i32(params.source${source}Width) + dx) * ${sourceBlocks[source]};
+            let sourceIndex = cachedBase${source}[load] + u32(offset) + sourceBlock;` : `let sourceX = ${sourceX};
+            let sourceY = ${sourceY};
+            let sourceIndex =
+              (sourceY * params.source${source}Width + sourceX) *
+              ${sourceBlocks[source]}u + sourceBlock;` }
+            value = ${gemmLoadExpression(`input${source}[sourceIndex]`, packedInput)};
+          }`;
+  };
+  return /* wgsl */ `${shaderPreamble(precision)}
+struct Params {
+  outputWidth: u32,
+  outputHeight: u32,
+  outputBlocks: u32,
+  inputBlocks: u32,
+  source0Width: u32,
+  source0Height: u32,
+  source1Width: u32,
+  source1Height: u32,
+}
+@group(0) @binding(0) var<storage, read> input0: array<${inputStorageType}>;
+@group(0) @binding(1) var<storage, read> input1: array<${inputStorageType}>;
+@group(0) @binding(2) var<storage, read> weights: array<${weightStorageType}>;
+@group(0) @binding(3) var<storage, read> bias: array<vec4<f32>>;
+@group(0) @binding(4) var<storage, read_write> outputData: array<${outputType}>;
+@group(0) @binding(5) var<uniform> params: Params;
+
+var<workgroup> inputTile: array<${valueType}, ${gemmSharedSizes(gemm).input}>;
+var<workgroup> weightTile: array<${valueType}, ${gemmSharedSizes(gemm).weights}>;
+
+@compute @workgroup_size(${workgroupX}, ${workgroupY}, 1)
+fn main(
+  @builtin(local_invocation_id) localId: vec3<u32>,
+  @builtin(workgroup_id) workgroupId: vec3<u32>
+) {
+  let spatialBase =
+    workgroupId.x * ${tileM}u +
+    localId.y * ${rowsPerThread}u;
+  let outputBlock =
+    workgroupId.y * ${tileNBlocks}u + localId.x;
+  let spatialCount = params.outputWidth * params.outputHeight;
+  var acc: array<vec4<f32>, ${rowsPerThread}>;
+  if (outputBlock < ${outputBlocks}u) {
+    for (var row = 0u; row < ${rowsPerThread}u; row++) {
+      acc[row] = bias[outputBlock];
+    }
+  }
+
+  let localLinear =
+    localId.y * ${workgroupX}u + localId.x;
+  ${addressMode !== 'analytic' ? tiledAddressCacheCode(inputBlocks, true, gemm, { blocks: sourceBlocks, upsampled: upsampledSource }) : ''}
+  let totalK = ${inputBlocks * 9}u;
+  for (var kBase = 0u; kBase < totalK; kBase += ${tileKBlocks}u) {
+    ${addressMode !== 'analytic' ? (gemm.decoderLoad === 'source-first' ? `
+    if (channelBlock < ${sourceBlocks[0]}u) {
+      ${tiledIncrementalInputCode(valueType, sourceRead(0, 'inputBlock'), gemm)}
+    } else {
+      ${tiledIncrementalInputCode(valueType, sourceRead(1, `inputBlock - ${sourceBlocks[0]}u`), gemm)}
+    }
+    ` : tiledIncrementalInputCode(valueType, `
+        if (inputBlock < ${sourceBlocks[0]}u) {
+          ${sourceRead(0, 'inputBlock')}
+        } else {
+          ${sourceRead(1, `inputBlock - ${sourceBlocks[0]}u`)}
+        }
+    `, gemm)) : /* wgsl */ `
+    for (
+      var loadIndex = localLinear;
+      loadIndex < ${inputTileValues}u;
+      loadIndex += ${workgroupThreads}u
+    ) {
+      let tileSpatial = loadIndex / ${tileKBlocks}u;
+      let tileK = loadIndex % ${tileKBlocks}u;
+      let outputSpatialIndex =
+        workgroupId.x * ${tileM}u + tileSpatial;
+      let kIndex = kBase + tileK;
+      var value = ${valueType}(0.0);
+      if (outputSpatialIndex < spatialCount && kIndex < totalK) {
+        let outputY = outputSpatialIndex / params.outputWidth;
+        let outputX = outputSpatialIndex % params.outputWidth;
+        let inputBlock = kIndex % ${inputBlocks}u;
+        let kernelIndex = kIndex / ${inputBlocks}u;
+        let kernelY = kernelIndex / 3u;
+        let kernelX = kernelIndex % 3u;
+        let inputY = i32(outputY) + i32(kernelY) - 1;
+        let inputX = i32(outputX) + i32(kernelX) - 1;
+        if (
+          inputY >= 0 && inputY < i32(params.outputHeight) &&
+          inputX >= 0 && inputX < i32(params.outputWidth)
+        ) {
+          if (inputBlock < ${sourceBlocks[0]}u) {
+            ${sourceRead(0, 'inputBlock')}
+          } else {
+            ${sourceRead(1, `inputBlock - ${sourceBlocks[0]}u`)}
+          }
+        }
+      }
+      inputTile[${gemmSharedInputIndex('loadIndex', gemm)}] = value;
+    }
+    `}
+
+    for (
+      var loadIndex = localLinear;
+      loadIndex < ${weightTileValues}u;
+      loadIndex += ${workgroupThreads}u
+    ) {
+      let tileK = loadIndex / ${tileNBlocks * 4}u;
+      let outputRemainder = loadIndex % ${tileNBlocks * 4}u;
+      let tileOutputBlock = outputRemainder / 4u;
+      let outputLane = outputRemainder % 4u;
+      let loadedOutputBlock =
+        workgroupId.y * ${tileNBlocks}u + tileOutputBlock;
+      let kIndex = kBase + tileK;
+      var value = ${valueType}(0.0);
+      if (loadedOutputBlock < ${outputBlocks}u && kIndex < totalK) {
+        ${weightLayout === 'k-major' ? /* wgsl */ `
+        let weightIndex = (kIndex * ${outputBlocks}u + loadedOutputBlock) * 4u + outputLane;
+        ` : addressMode !== 'analytic' ? /* wgsl */ `
+        let weightIndex = (loadedOutputBlock * ${inputBlocks * 9}u + kIndex) * 4u + outputLane;
+        ` : /* wgsl */ `
+        let inputBlock = kIndex % ${inputBlocks}u;
+        let kernelIndex = kIndex / ${inputBlocks}u;
+        let kernelY = kernelIndex / 3u;
+        let kernelX = kernelIndex % 3u;
+        let weightIndex =
+          ((((loadedOutputBlock * 3u + kernelY) * 3u + kernelX) *
+            ${inputBlocks}u + inputBlock) * 4u + outputLane);
+        `}
+        value = ${gemmLoadExpression('weights[weightIndex]', packedWeights)};
+      }
+      weightTile[${gemmSharedWeightIndex('loadIndex', gemm)}] = value;
+    }
+
+    workgroupBarrier();
+    ${tiledAccumulationCode(precision, gemm)}
+    workgroupBarrier();
+    ${addressMode !== 'analytic' ? tiledAddressAdvanceCode(inputBlocks, gemm) : ''}
+  }
+
+  if (outputBlock < ${outputBlocks}u) {
+    for (var row = 0u; row < ${rowsPerThread}u; row++) {
+      let spatialIndex = spatialBase + row;
+      if (spatialIndex < spatialCount) {
+        let outputIndex = spatialIndex * ${outputBlocks}u + outputBlock;
+        outputData[outputIndex] = ${stored};
+      }
+    }
+  }
+}
+`;
+}
+
+function createFusedDecoderShader(
+  precision: NativeUNetPrecision,
+  outputPrecision: NativeUNetPrecision,
+  activation: Conv2DNodeSpec['activation'],
+  sourceBlocks: readonly [number, number],
+  upsampledSource: 0 | 1,
+  outputBlocks: number
+) {
+  const valueType = storageVecType(precision);
+  const outputType = storageVecType(outputPrecision);
+  const inputBlocks = sourceBlocks[0] + sourceBlocks[1];
+  const sourceCode = (source: 0 | 1, blockOffset: number) => {
+    const isUpsampled = source === upsampledSource;
+    return /* wgsl */ `
+      {
+        let sourceX = ${isUpsampled ? 'u32(inputX) / 2u' : 'u32(inputX)'};
+        let sourceY = ${isUpsampled ? 'u32(inputY) / 2u' : 'u32(inputY)'};
+        let sourcePixelBase = (sourceY * params.source${source}Width + sourceX) * ${sourceBlocks[source]}u;
+        for (var sourceBlock = 0u; sourceBlock < ${sourceBlocks[source]}u; sourceBlock++) {
+          let inputBlock = ${blockOffset}u + sourceBlock;
+          ${accumulationCode(
+            `input${source}[sourcePixelBase + sourceBlock]`,
+            `((((gid.z * 3u + ky) * 3u + kx) * ${inputBlocks}u + inputBlock) * 4u)`,
+            precision
+          )}
+        }
+      }
+`;
+  };
+  const stored = storeExpression(
+    activationExpression('acc', activation),
+    outputPrecision
+  );
+  return /* wgsl */ `${shaderPreamble(precision)}
+struct Params {
+  outputWidth: u32,
+  outputHeight: u32,
+  outputBlocks: u32,
+  inputBlocks: u32,
+  source0Width: u32,
+  source0Height: u32,
+  source1Width: u32,
+  source1Height: u32,
+}
+@group(0) @binding(0) var<storage, read> input0: array<${valueType}>;
+@group(0) @binding(1) var<storage, read> input1: array<${valueType}>;
+@group(0) @binding(2) var<storage, read> weights: array<${valueType}>;
+@group(0) @binding(3) var<storage, read> bias: array<vec4<f32>>;
+@group(0) @binding(4) var<storage, read_write> outputData: array<${outputType}>;
+@group(0) @binding(5) var<uniform> params: Params;
+
+@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  if (gid.x >= params.outputWidth || gid.y >= params.outputHeight || gid.z >= ${outputBlocks}u) {
+    return;
+  }
+  var acc = bias[gid.z];
+  for (var ky = 0u; ky < 3u; ky++) {
+    let inputY = i32(gid.y) + i32(ky) - 1;
+    if (inputY < 0 || inputY >= i32(params.outputHeight)) { continue; }
+    for (var kx = 0u; kx < 3u; kx++) {
+      let inputX = i32(gid.x) + i32(kx) - 1;
+      if (inputX < 0 || inputX >= i32(params.outputWidth)) { continue; }
+      ${sourceCode(0, 0)}
+      ${sourceCode(1, sourceBlocks[0])}
+    }
+  }
+  let outputIndex = (gid.y * params.outputWidth + gid.x) * ${outputBlocks}u + gid.z;
+  outputData[outputIndex] = ${stored};
+}
+`;
+}
+
+function createSpatialDecoderShader(
+  precision: NativeUNetPrecision,
+  outputPrecision: NativeUNetPrecision,
+  activation: Conv2DNodeSpec['activation'],
+  sourceBlocks: readonly [number, number],
+  upsampledSource: 0 | 1,
+  outputBlocks: number
+) {
+  const valueType = storageVecType(precision);
+  const outputType = storageVecType(outputPrecision);
+  const inputBlocks = sourceBlocks[0] + sourceBlocks[1];
+  const patchValues =
+    SPATIAL_CONV_PATCH * SPATIAL_CONV_PATCH * inputBlocks;
+  const workgroupThreads =
+    SPATIAL_CONV_WORKGROUP * SPATIAL_CONV_WORKGROUP;
+  const stored = storeExpression(
+    activationExpression('acc', activation),
+    outputPrecision
+  );
+  const sourceRead = (source: 0 | 1, blockExpression: string) => {
+    const sourceX =
+      source === upsampledSource ? 'u32(inputX) / 2u' : 'u32(inputX)';
+    const sourceY =
+      source === upsampledSource ? 'u32(inputY) / 2u' : 'u32(inputY)';
+    return /* wgsl */ `
+      let sourceBlock = ${blockExpression};
+      let sourceIndex =
+        (${sourceY} * params.source${source}Width + ${sourceX}) *
+        ${sourceBlocks[source]}u + sourceBlock;
+      value = input${source}[sourceIndex];`;
+  };
+
+  return /* wgsl */ `${shaderPreamble(precision)}
+struct Params {
+  outputWidth: u32,
+  outputHeight: u32,
+  outputBlocks: u32,
+  inputBlocks: u32,
+  source0Width: u32,
+  source0Height: u32,
+  source1Width: u32,
+  source1Height: u32,
+}
+@group(0) @binding(0) var<storage, read> input0: array<${valueType}>;
+@group(0) @binding(1) var<storage, read> input1: array<${valueType}>;
+@group(0) @binding(2) var<storage, read> weights: array<${valueType}>;
+@group(0) @binding(3) var<storage, read> bias: array<vec4<f32>>;
+@group(0) @binding(4) var<storage, read_write> outputData: array<${outputType}>;
+@group(0) @binding(5) var<uniform> params: Params;
+
+var<workgroup> inputPatch: array<${valueType}, ${patchValues}>;
+
+@compute @workgroup_size(${SPATIAL_CONV_WORKGROUP}, ${SPATIAL_CONV_WORKGROUP}, 1)
+fn main(
+  @builtin(local_invocation_id) localId: vec3<u32>,
+  @builtin(workgroup_id) workgroupId: vec3<u32>
+) {
+  let localLinear =
+    localId.y * ${SPATIAL_CONV_WORKGROUP}u + localId.x;
+  for (
+    var loadIndex = localLinear;
+    loadIndex < ${patchValues}u;
+    loadIndex += ${workgroupThreads}u
+  ) {
+    let patchPixel = loadIndex / ${inputBlocks}u;
+    let inputBlock = loadIndex % ${inputBlocks}u;
+    let patchX = patchPixel % ${SPATIAL_CONV_PATCH}u;
+    let patchY = patchPixel / ${SPATIAL_CONV_PATCH}u;
+    let inputX =
+      i32(workgroupId.x * ${SPATIAL_CONV_WORKGROUP}u + patchX) - 1;
+    let inputY =
+      i32(workgroupId.y * ${SPATIAL_CONV_WORKGROUP}u + patchY) - 1;
+    var value = ${valueType}(0.0);
+    if (
+      inputX >= 0 && inputX < i32(params.outputWidth) &&
+      inputY >= 0 && inputY < i32(params.outputHeight)
+    ) {
+      if (inputBlock < ${sourceBlocks[0]}u) {
+        ${sourceRead(0, 'inputBlock')}
+      } else {
+        ${sourceRead(1, `inputBlock - ${sourceBlocks[0]}u`)}
+      }
+    }
+    inputPatch[loadIndex] = value;
+  }
+  workgroupBarrier();
+
+  let outputX =
+    workgroupId.x * ${SPATIAL_CONV_WORKGROUP}u + localId.x;
+  let outputY =
+    workgroupId.y * ${SPATIAL_CONV_WORKGROUP}u + localId.y;
+  let outputBlock = workgroupId.z;
+  if (
+    outputX >= params.outputWidth || outputY >= params.outputHeight ||
+    outputBlock >= ${outputBlocks}u
+  ) {
+    return;
+  }
+
+  var acc = bias[outputBlock];
+  for (var ky = 0u; ky < 3u; ky++) {
+    for (var kx = 0u; kx < 3u; kx++) {
+      let patchBase =
+        ((localId.y + ky) * ${SPATIAL_CONV_PATCH}u + localId.x + kx) *
+        ${inputBlocks}u;
+      for (var inputBlock = 0u; inputBlock < ${inputBlocks}u; inputBlock++) {
+        ${accumulationCode(
+          'inputPatch[patchBase + inputBlock]',
+          `((((outputBlock * 3u + ky) * 3u + kx) * ${inputBlocks}u + inputBlock) * 4u)`,
+          precision
+        )}
+      }
+    }
+  }
+  let outputIndex =
+    (outputY * params.outputWidth + outputX) * ${outputBlocks}u + outputBlock;
+  outputData[outputIndex] = ${stored};
+}
+`;
+}
+
+function createInputPackShader(
+  precision: NativeUNetPrecision,
+  sourceCount: number
+) {
+  const outputType = storageVecType(precision);
+  const inputBindings = Array.from(
+    { length: sourceCount },
+    (_, index) =>
+      `@group(0) @binding(${index}) var<storage, read> input${index}: array<vec4<f32>>;`
+  ).join('\n');
+  const readBranches = Array.from({ length: sourceCount }, (_, index) => {
+    const firstChannel = index * 3;
+    return `if (channel < ${firstChannel + 3}u) { return input${index}[pixel][channel - ${firstChannel}u]; }`;
+  }).join('\n  ');
+  const outputBinding = sourceCount;
+  const paramsBinding = sourceCount + 1;
+  return /* wgsl */ `${shaderPreamble(precision)}
+struct Params {
+  width: u32,
+  height: u32,
+  outputBlocks: u32,
+  inputChannels: u32,
+}
+${inputBindings}
+@group(0) @binding(${outputBinding}) var<storage, read_write> outputData: array<${outputType}>;
+@group(0) @binding(${paramsBinding}) var<uniform> params: Params;
+
+fn readChannel(pixel: u32, channel: u32) -> f32 {
+  ${readBranches}
+  return 0.0;
+}
+
+@compute @workgroup_size(${WORKGROUP_SIZE}, ${WORKGROUP_SIZE}, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+  if (gid.x >= params.width || gid.y >= params.height || gid.z >= params.outputBlocks) {
+    return;
+  }
+  let pixel = gid.y * params.width + gid.x;
+  let firstChannel = gid.z * 4u;
+  let value = vec4<f32>(
+    readChannel(pixel, firstChannel),
+    readChannel(pixel, firstChannel + 1u),
+    readChannel(pixel, firstChannel + 2u),
+    readChannel(pixel, firstChannel + 3u)
+  );
+  outputData[pixel * params.outputBlocks + gid.z] = ${storeExpression('value', precision)};
+}
+`;
+}
+
+function executableInputs(node: ExecutableModelNode): readonly string[] {
+  if (node.op === 'concat') return node.inputs;
+  if (node.op === 'fusedUpsampleConcatConv2d') {
+    return node.inputs.map((input) => input.value);
+  }
+  return [node.input];
+}
+
+export function resolveNativeUNetPrecision(
+  device: GPUDevice,
+  requested: NativeUNetPrecisionSetting = 'auto'
+): NativeUNetPrecision {
+  const hasShaderF16 = device.features.has('shader-f16');
+  if (requested === 'fp16' && !hasShaderF16) {
+    throw new Error(
+      'OIDN FP16 was requested but the GPUDevice does not have shader-f16 enabled'
+    );
+  }
+  if (requested === 'auto') return hasShaderF16 ? 'fp16' : 'fp32';
+  return requested;
+}
+
+/** Native, model-driven OIDN U-Net executor. */
+export class NativeUNetExecutor {
+  readonly precision: NativeUNetPrecision;
+  readonly kernelSetting: NativeUNetKernelSetting;
+  readonly gemm: Readonly<Required<NativeUNetGemmOptions>>;
+  readonly maxSpatialInputBlocks: number;
+  readonly subgroupsAvailable: boolean;
+
+  private _model: UNetModelGraph;
+  private _gemmByOutputBlocks = new Map<number, Readonly<Required<NativeUNetGemmOptions>>>();
+  private _packedConvs = new Map<string, PackedConvBuffers>();
+  private _pipelineCache: Map<string, GPUComputePipeline>;
+  private _pipelinePromises: Map<string, Promise<GPUComputePipeline>>;
+  private _executionCache = new Map<string, CachedExecution>();
+  private _retiredExecutions = new Set<CachedExecution>();
+  private _clock = 0;
+  private _shapeCacheSize: number;
+  private _profileNextExecution = false;
+  private _lastExecutionProfile?: Promise<NativeUNetExecutionProfile>;
+  private _profileOperations = 0;
+  private _resources = new OIDNResourceTracker();
+  private _disposed = false;
+
+  constructor(
+    private _device: GPUDevice,
+    model: ValidatedUNetModel,
+    options: NativeUNetOptions = {}
+  ) {
+    const pipelineCache = sharedPipelineCache(_device);
+    this._pipelineCache = pipelineCache.ready;
+    this._pipelinePromises = pipelineCache.pending;
+    this.precision = resolveNativeUNetPrecision(
+      _device,
+      options.precision ?? 'auto'
+    );
+    this.kernelSetting = options.kernel ?? 'auto';
+    const workgroupSize = options.gemm?.workgroupSize ?? [8, 8];
+    this.gemm = Object.freeze({
+      tilePolicy: options.gemm?.tilePolicy ?? (options.gemm?.workgroupSize ? 'fixed' : 'output-aligned'),
+      decoderLoad: options.gemm?.decoderLoad ?? 'per-load',
+      poolLayout: options.gemm?.poolLayout ?? 'channels',
+      sharedLayout: options.gemm?.sharedLayout ?? (this.precision === 'fp16' ? 'padded-input' : 'padded'),
+      accumulationOrder: options.gemm?.accumulationOrder ?? 'k-major',
+      finalLayer: options.gemm?.finalLayer ?? 'shared-auto',
+      loadMode: options.gemm?.loadMode ?? 'native',
+      addressMode: options.gemm?.addressMode ?? 'incremental',
+      weightLayout: options.gemm?.weightLayout ?? 'k-major',
+      rowsPerThread: options.gemm?.rowsPerThread ?? 8,
+      workgroupSize: Object.freeze([workgroupSize[0], workgroupSize[1]]) as NativeUNetGemmWorkgroup
+    });
+    if (!['fixed', 'output-aligned'].includes(this.gemm.tilePolicy)) {
+      throw new Error(`Unsupported GEMM tile policy: ${this.gemm.tilePolicy}`);
+    }
+    if (!['per-load', 'source-first'].includes(this.gemm.decoderLoad)) {
+      throw new Error(`Unsupported GEMM decoder load: ${this.gemm.decoderLoad}`);
+    }
+    if (!['spatial', 'channels'].includes(this.gemm.poolLayout)) {
+      throw new Error(`Unsupported GEMM pool layout: ${this.gemm.poolLayout}`);
+    }
+    if (!['linear', 'padded', 'padded-input', 'padded-weights'].includes(this.gemm.sharedLayout)) {
+      throw new Error(`Unsupported GEMM shared layout: ${this.gemm.sharedLayout}`);
+    }
+    if (!['k-major', 'row-major'].includes(this.gemm.accumulationOrder)) {
+      throw new Error(`Unsupported GEMM accumulation order: ${this.gemm.accumulationOrder}`);
+    }
+    if (!['direct', 'shared-input', 'shared-input-weights', 'shared-auto'].includes(this.gemm.finalLayer)) {
+      throw new Error(`Unsupported GEMM final layer: ${this.gemm.finalLayer}`);
+    }
+    if (!['native', 'packed-weights', 'packed-all'].includes(this.gemm.loadMode)) {
+      throw new Error(`Unsupported GEMM load mode: ${this.gemm.loadMode}`);
+    }
+    if (!['analytic', 'incremental', 'base-offset'].includes(this.gemm.addressMode)) {
+      throw new Error(`Unsupported GEMM address mode: ${this.gemm.addressMode}`);
+    }
+    if (!['output-major', 'k-major'].includes(this.gemm.weightLayout)) {
+      throw new Error(`Unsupported GEMM weight layout: ${this.gemm.weightLayout}`);
+    }
+    const tile = gemmTile(this.gemm);
+    const tileStorageBytes =
+      (gemmSharedSizes(this.gemm).input + gemmSharedSizes(this.gemm).weights) *
+      4 * (this.precision === 'fp16' ? 2 : 4);
+    if (
+      ![2, 4, 8].includes(tile.rowsPerThread) ||
+      ![4, 8, 16].includes(tile.workgroupX) ||
+      ![4, 8].includes(tile.workgroupY) ||
+      workgroupSize.length !== 2 ||
+      tile.workgroupX > _device.limits.maxComputeWorkgroupSizeX ||
+      tile.workgroupY > _device.limits.maxComputeWorkgroupSizeY ||
+      tile.workgroupX * tile.workgroupY > _device.limits.maxComputeInvocationsPerWorkgroup ||
+      tileStorageBytes > _device.limits.maxComputeWorkgroupStorageSize
+    ) {
+      throw new Error('Unsupported GEMM tile configuration for this GPUDevice');
+    }
+    this.subgroupsAvailable = _device.features.has(
+      'subgroups' as GPUFeatureName
+    );
+    this.maxSpatialInputBlocks =
+      this.precision === 'fp16' &&
+      _device.limits.maxComputeInvocationsPerWorkgroup >=
+        SPATIAL_CONV_WORKGROUP * SPATIAL_CONV_WORKGROUP &&
+      _device.limits.maxComputeWorkgroupSizeX >= SPATIAL_CONV_WORKGROUP &&
+      _device.limits.maxComputeWorkgroupSizeY >= SPATIAL_CONV_WORKGROUP
+        ? Math.floor(
+            _device.limits.maxComputeWorkgroupStorageSize /
+              (SPATIAL_CONV_PATCH * SPATIAL_CONV_PATCH * 4 * 2)
+          )
+        : 0;
+    this._shapeCacheSize = Math.max(1, options.shapeCacheSize ?? 2);
+
+    if (
+      model.inputChannels % 3 !== 0 ||
+      model.inputChannels < 3 ||
+      model.inputChannels > 9
+    ) {
+      throw new Error(
+        `Native OIDN expects 3, 6, or 9 input channels, got ${model.inputChannels}`
+      );
+    }
+    this._model = {
+      spec: model.spec,
+      inputChannels: model.inputChannels,
+      outputChannels: model.outputChannels,
+      channelsByValue: new Map(model.channelsByValue),
+      convChannels: new Map(model.convChannels)
+    };
+    for (const node of optimizeModelGraph(this._model, {
+      fuseConvPool: false
+    }).nodes) {
+      if (
+        node.op !== 'conv2d' &&
+        node.op !== 'maxPool2d' &&
+        node.op !== 'fusedConvReluMaxPool2d' &&
+        node.op !== 'fusedUpsampleConcatConv2d'
+      ) {
+        throw new Error(
+          `Native OIDN descriptor ${model.spec.id} leaves unsupported ` +
+            `${node.op} node ${node.id} after graph optimization`
+        );
+      }
+    }
+    try {
+      for (const [id, tensors] of model.convTensors) {
+        // Kernel selection is shape-independent. Pack only the active layout
+        // for this executor, keeping direct/spatial/subgroup and final weights
+        // in their original ABI without duplicating GPU allocations.
+        const kernel = this._selectConvKernel(
+          blocksForChannels(tensors.inputChannels), id === model.spec.output
+        );
+        const weightLayout = kernel === 'implicit-gemm'
+          ? this.gemm.weightLayout
+          : 'output-major';
+        const packed = packConvTensors(
+          _device, id, tensors, this.precision, weightLayout
+        );
+        this._resources.track('gpu-buffer', packed.weights);
+        this._resources.track('gpu-buffer', packed.bias);
+        this._packedConvs.set(id, packed);
+      }
+    } catch (error) {
+      for (const packed of this._packedConvs.values()) {
+        this._releaseBuffer(packed.weights);
+        this._releaseBuffer(packed.bias);
+      }
+      this._packedConvs.clear();
+      throw error;
+    }
+  }
+
+  private _pipeline(key: string, code: string) {
+    let pipeline = this._pipelineCache.get(key);
+    if (!pipeline) {
+      pipeline = this._device.createComputePipeline({
+        label: `oidn/${key}`,
+        layout: 'auto',
+        compute: {
+          module: this._device.createShaderModule({
+            label: `oidn/${key}`,
+            code
+          }),
+          entryPoint: 'main'
+        }
+      });
+      this._pipelineCache.set(key, pipeline);
+    }
+    return pipeline;
+  }
+
+  private _pipelineAsync(key: string, code: string) {
+    const ready = this._pipelineCache.get(key);
+    if (ready) return Promise.resolve(ready);
+    const pending = this._pipelinePromises.get(key);
+    if (pending) return pending;
+    const promise = this._device.createComputePipelineAsync({
+      label: `oidn/${key}`,
+      layout: 'auto',
+      compute: {
+        module: this._device.createShaderModule({
+          label: `oidn/${key}`,
+          code
+        }),
+        entryPoint: 'main'
+      }
+    }).then((pipeline) => {
+      this._pipelineCache.set(key, pipeline);
+      this._pipelinePromises.delete(key);
+      return pipeline;
+    }, (error) => {
+      this._pipelinePromises.delete(key);
+      throw error;
+    });
+    this._pipelinePromises.set(key, promise);
+    return promise;
+  }
+
+  private _nodePipelineSpec(
+    node: ExecutableModelNode,
+    isFinal: boolean
+  ): NativePipelineSpec {
+    if (node.op === 'conv2d') {
+      const outputPrecision = isFinal ? 'fp32' : this.precision;
+      const inputBlocks = blocksForChannels(
+        this._model.convChannels.get(node.id)!.inputChannels
+      );
+      const outputBlocks = blocksForChannels(
+        this._model.convChannels.get(node.id)!.outputChannels
+      );
+      const gemm = this._gemmForOutput(outputBlocks);
+      const kernel = this._selectConvKernel(inputBlocks, isFinal);
+      const cacheFinalWeights = gemm.finalLayer === 'shared-input-weights' ||
+        (gemm.finalLayer === 'shared-auto' &&
+          finalRgbSharedMemoryBytes(this.precision, inputBlocks, true) <=
+            this._device.limits.maxComputeWorkgroupStorageSize);
+      if (
+        isFinal && this._model.convChannels.get(node.id)!.outputChannels === 3 &&
+        (this.kernelSetting === 'auto' || this.kernelSetting === 'implicit-gemm') &&
+        gemm.finalLayer !== 'direct' &&
+        this._device.limits.maxComputeWorkgroupSizeX >= 8 &&
+        this._device.limits.maxComputeWorkgroupSizeY >= 8 &&
+        this._device.limits.maxComputeInvocationsPerWorkgroup >= 64 &&
+        finalRgbSharedMemoryBytes(this.precision, inputBlocks, cacheFinalWeights) <=
+          this._device.limits.maxComputeWorkgroupStorageSize
+      ) {
+        return {
+          key: `conv-final-rgb/${this.precision}/${node.activation}/in${inputBlocks}/weights-${cacheFinalWeights ? 'shared' : 'storage'}`,
+          kernel: 'direct',
+          code: createFinalRgbShader(this.precision, node.activation, inputBlocks, cacheFinalWeights)
+        };
+      }
+      const key =
+        `conv-${kernel}/${this.precision}/` +
+        `${outputPrecision}/${node.activation}/` +
+        `in${inputBlocks}/out${outputBlocks}` +
+        (kernel === 'implicit-gemm'
+          ? `/address-${gemm.addressMode}/weights-${gemm.weightLayout}-v1` +
+            `/tile-${gemm.workgroupSize.join('x')}-r${gemm.rowsPerThread}/loads-${gemm.loadMode}/shared-${gemm.sharedLayout}/acc-${gemm.accumulationOrder}`
+          : '');
+      return {
+        key,
+        kernel,
+        code: kernel === 'implicit-gemm'
+          ? createTiledConvShader(
+              this.precision,
+              outputPrecision,
+              node.activation,
+              inputBlocks,
+              outputBlocks,
+              gemm
+            )
+          : kernel === 'spatial'
+            ? createSpatialConvShader(
+                this.precision,
+                outputPrecision,
+                node.activation,
+                inputBlocks,
+                outputBlocks
+              )
+            : kernel === 'subgroup'
+              ? createSubgroupConvShader(
+                  this.precision,
+                  outputPrecision,
+                  node.activation,
+                  inputBlocks,
+                  outputBlocks
+                )
+              : createConvShader(
+                  this.precision,
+                  outputPrecision,
+                  node.activation,
+                  inputBlocks,
+                  outputBlocks
+                )
+      };
+    }
+    if (node.op === 'maxPool2d') {
+      const outputBlocks = blocksForChannels(
+        this._model.channelsByValue.get(node.id)!
+      );
+      const coalesced = this._coalescedPool();
+      const key = `max-pool/${this.precision}/out${outputBlocks}/${coalesced ? 'channels' : 'spatial'}`;
+      return {
+        key,
+        kernel: 'direct',
+        code: createMaxPoolShader(this.precision, outputBlocks, coalesced)
+      };
+    }
+    if (node.op === 'fusedConvReluMaxPool2d') {
+      const inputBlocks = blocksForChannels(
+        this._model.convChannels.get(node.conv.id)!.inputChannels
+      );
+      const outputBlocks = blocksForChannels(
+        this._model.convChannels.get(node.conv.id)!.outputChannels
+      );
+      const key =
+        `conv-pool/${this.precision}/${node.conv.activation}/` +
+        `in${inputBlocks}/out${outputBlocks}`;
+      return {
+        key,
+        kernel: 'direct',
+        code: createFusedConvPoolShader(
+          this.precision,
+          node.conv.activation,
+          inputBlocks,
+          outputBlocks
+        )
+      };
+    }
+    if (node.op === 'fusedUpsampleConcatConv2d') {
+      if (node.inputs.length !== 2) {
+        throw new Error(`Native fused decoder ${node.id} requires two inputs`);
+      }
+      const sourceBlocks = node.inputs.map((input) =>
+        blocksForChannels(this._model.channelsByValue.get(input.value)!)
+      ) as [number, number];
+      const upsampledSource = node.inputs.findIndex((input) => input.upsample);
+      if (upsampledSource !== 0 && upsampledSource !== 1) {
+        throw new Error(`Native fused decoder ${node.id} has no upsample input`);
+      }
+      const inputBlocks = sourceBlocks[0] + sourceBlocks[1];
+      const outputPrecision = isFinal ? 'fp32' : this.precision;
+      const selectedKernel = this._selectConvKernel(inputBlocks, isFinal);
+      // The subgroup broadcast path currently targets the common standalone
+      // convolution layout; fused decoder reads use the direct kernel.
+      const kernel = selectedKernel === 'subgroup'
+        ? 'direct'
+        : selectedKernel;
+      const outputBlocks = blocksForChannels(
+        this._model.convChannels.get(node.conv.id)!.outputChannels
+      );
+      const gemm = this._gemmForOutput(outputBlocks);
+      const key =
+        `decoder-${kernel}/${this.precision}/${outputPrecision}/` +
+        `${node.conv.activation}/` +
+        `${sourceBlocks.join('+')}/out${outputBlocks}/up${upsampledSource}` +
+        (kernel === 'implicit-gemm'
+          ? `/address-${gemm.addressMode}/weights-${gemm.weightLayout}-v1` +
+            `/tile-${gemm.workgroupSize.join('x')}-r${gemm.rowsPerThread}/loads-${gemm.loadMode}/shared-${gemm.sharedLayout}/acc-${gemm.accumulationOrder}/decoder-${gemm.decoderLoad}`
+          : '');
+      return {
+        key,
+        kernel,
+        code: kernel === 'implicit-gemm'
+          ? createTiledDecoderShader(
+              this.precision,
+              outputPrecision,
+              node.conv.activation,
+              sourceBlocks,
+              upsampledSource,
+              outputBlocks,
+              gemm
+            )
+          : kernel === 'spatial'
+            ? createSpatialDecoderShader(
+                this.precision,
+                outputPrecision,
+                node.conv.activation,
+                sourceBlocks,
+                upsampledSource,
+                outputBlocks
+              )
+            : createFusedDecoderShader(
+              this.precision,
+              outputPrecision,
+              node.conv.activation,
+              sourceBlocks,
+              upsampledSource,
+              outputBlocks
+            )
+      };
+    }
+    throw new Error(
+      `Native OIDN does not implement unfused ${node.op} node ${node.id}`
+    );
+  }
+
+  // Wider output tiles reuse each input load across twice as many channels.
+  // Require full output blocks and keep the validated base tile as fallback.
+  private _gemmForOutput(outputBlocks: number): Readonly<Required<NativeUNetGemmOptions>> {
+    if (this.gemm.tilePolicy !== 'output-aligned' ||
+        this.gemm.workgroupSize[0] !== 8 || outputBlocks <= 0 || outputBlocks % 16 !== 0) {
+      return this.gemm;
+    }
+    const cached = this._gemmByOutputBlocks.get(outputBlocks);
+    if (cached) return cached;
+    const candidate = Object.freeze({
+      ...this.gemm,
+      workgroupSize: Object.freeze([16, this.gemm.workgroupSize[1]]) as NativeUNetGemmWorkgroup
+    });
+    const tile = gemmTile(candidate);
+    const sizes = gemmSharedSizes(candidate);
+    const limits = this._device.limits;
+    const fits = tile.workgroupX <= limits.maxComputeWorkgroupSizeX &&
+      tile.workgroupY <= limits.maxComputeWorkgroupSizeY &&
+      tile.workgroupX * tile.workgroupY <= limits.maxComputeInvocationsPerWorkgroup &&
+      (sizes.input + sizes.weights) * 4 * (this.precision === 'fp16' ? 2 : 4) <= limits.maxComputeWorkgroupStorageSize;
+    const selected = fits ? candidate : this.gemm;
+    this._gemmByOutputBlocks.set(outputBlocks, selected);
+    return selected;
+  }
+
+  private _coalescedPool() {
+    return this.gemm.poolLayout === 'channels' &&
+      (this.kernelSetting === 'auto' || this.kernelSetting === 'implicit-gemm');
+  }
+
+  private _selectConvKernel(
+    inputBlocks: number,
+    isFinal: boolean
+  ): NativeUNetKernel {
+    const spatialFits =
+      this.precision === 'fp16' &&
+      inputBlocks <= this.maxSpatialInputBlocks;
+    if (this.kernelSetting === 'direct') return 'direct';
+    if (this.kernelSetting === 'spatial') {
+      return spatialFits ? 'spatial' : 'direct';
+    }
+    if (this.kernelSetting === 'implicit-gemm') {
+      return isFinal ? 'direct' : 'implicit-gemm';
+    }
+    if (this.kernelSetting === 'subgroup') {
+      return this.subgroupsAvailable ? 'subgroup' : 'direct';
+    }
+    if (!isFinal) return 'implicit-gemm';
+    return 'direct';
+  }
+
+  private _nodePipeline(node: ExecutableModelNode, isFinal: boolean) {
+    const { key, code } = this._nodePipelineSpec(node, isFinal);
+    return this._pipeline(key, code);
+  }
+
+  /** Compiles all shape-independent kernels before the model reports ready. */
+  async prepare() {
+    if (this._disposed) throw new Error('Native OIDN executor is disposed');
+    const graph = optimizeModelGraph(this._model, { fuseConvPool: false });
+    const sourceCount = this._model.inputChannels / 3;
+    const specs: NativePipelineSpec[] = [
+      {
+        key: `pack/${this.precision}/${sourceCount}`,
+        code: createInputPackShader(this.precision, sourceCount)
+      },
+      ...graph.nodes.map((node) =>
+        this._nodePipelineSpec(node, node.id === graph.spec.output)
+      )
+    ];
+    await Promise.all(
+      specs.map(({ key, code }) => this._pipelineAsync(key, code))
+    );
+  }
+
+  private _createExecution(width: number, height: number): CachedExecution {
+    const plan = planModelExecution(this._model, width, height, {
+      fuseConvPool: false
+    });
+    const valueBuffers = new Map<string, GPUBuffer>();
+    const slots: ActivationSlot[] = [];
+    const lastUses = new Map<string, number>();
+    plan.nodes.forEach((node, index) => {
+      for (const input of executableInputs(node)) lastUses.set(input, index);
+    });
+    lastUses.set(plan.spec.output, plan.nodes.length);
+    const createdBuffers: GPUBuffer[] = [];
+    const own = (buffer: GPUBuffer) => {
+      createdBuffers.push(buffer);
+      return this._resources.track('gpu-buffer', buffer);
+    };
+
+    try {
+      const allocate = (
+        value: string,
+        shape: ModelValueShape,
+        bytesPerScalar: number,
+        index: number
+      ) => {
+      for (const slot of slots) {
+        if (
+          slot.activeValue &&
+          (lastUses.get(slot.activeValue) ?? -1) < index
+        ) {
+          slot.activeValue = undefined;
+        }
+      }
+      const requiredSize = activationByteSize(shape, bytesPerScalar);
+      let slot = slots
+        .filter((candidate) => !candidate.activeValue && candidate.capacity >= requiredSize)
+        .sort((a, b) => a.capacity - b.capacity)[0];
+      if (!slot) {
+        const buffer = own(this._device.createBuffer({
+          label: `oidn/activation/${width}x${height}/${slots.length}`,
+          size: roundUp(requiredSize, 4),
+          usage:
+            GPUBufferUsage.STORAGE |
+            GPUBufferUsage.COPY_SRC |
+            GPUBufferUsage.COPY_DST
+        }));
+        slot = { buffer, capacity: requiredSize };
+        slots.push(slot);
+      }
+      slot.activeValue = value;
+      valueBuffers.set(value, slot.buffer);
+      };
+
+    allocate(
+      plan.spec.input,
+      plan.inputShape,
+      this.precision === 'fp16' ? 2 : 4,
+      -1
+    );
+    plan.plannedNodes.forEach(({ node, outputShape }, index) => {
+      const isFinal = node.id === plan.spec.output;
+      allocate(
+        node.id,
+        outputShape,
+        isFinal || this.precision === 'fp32' ? 4 : 2,
+        index
+      );
+    });
+
+    const inputSourceCount = this._model.inputChannels / 3;
+    const inputKey = `pack/${this.precision}/${inputSourceCount}`;
+    const inputPipeline = this._pipeline(
+      inputKey,
+      createInputPackShader(this.precision, inputSourceCount)
+    );
+    const nodePipelines: GPUComputePipeline[] = [];
+    const nodeKernels: NativeUNetKernel[] = [];
+    const nodeBindings: GPUBindGroup[] = [];
+    const ownedBuffers: GPUBuffer[] = [];
+
+    plan.plannedNodes.forEach(({ node, outputShape }, index) => {
+      const isFinal = node.id === plan.spec.output;
+      const pipelineSpec = this._nodePipelineSpec(node, isFinal);
+      const pipeline = this._pipeline(pipelineSpec.key, pipelineSpec.code);
+      nodePipelines.push(pipeline);
+      nodeKernels.push(pipelineSpec.kernel ?? 'direct');
+      const output = valueBuffers.get(node.id)!;
+      let entries: GPUBindGroupEntry[];
+      let uniformValues: number[];
+      let convId: string;
+
+      if (node.op === 'conv2d') {
+        const inputShape = plan.valueShapes.get(node.input)!;
+        convId = node.id;
+        uniformValues = [
+          inputShape.width,
+          inputShape.height,
+          outputShape.width,
+          outputShape.height,
+          blocksForChannels(inputShape.channels),
+          blocksForChannels(outputShape.channels)
+        ];
+        const packed = this._packedConvs.get(convId)!;
+        entries = [
+          { binding: 0, resource: { buffer: valueBuffers.get(node.input)! } },
+          { binding: 1, resource: { buffer: packed.weights } },
+          { binding: 2, resource: { buffer: packed.bias } },
+          { binding: 3, resource: { buffer: output } }
+        ];
+      } else if (node.op === 'maxPool2d') {
+        const inputShape = plan.valueShapes.get(node.input)!;
+        uniformValues = [
+          inputShape.width,
+          inputShape.height,
+          outputShape.width,
+          outputShape.height,
+          blocksForChannels(outputShape.channels)
+        ];
+        entries = [
+          { binding: 0, resource: { buffer: valueBuffers.get(node.input)! } },
+          { binding: 1, resource: { buffer: output } }
+        ];
+      } else if (node.op === 'fusedConvReluMaxPool2d') {
+        const inputShape = plan.valueShapes.get(node.input)!;
+        convId = node.conv.id;
+        uniformValues = [
+          inputShape.width,
+          inputShape.height,
+          outputShape.width,
+          outputShape.height,
+          blocksForChannels(inputShape.channels),
+          blocksForChannels(outputShape.channels)
+        ];
+        const packed = this._packedConvs.get(convId)!;
+        entries = [
+          { binding: 0, resource: { buffer: valueBuffers.get(node.input)! } },
+          { binding: 1, resource: { buffer: packed.weights } },
+          { binding: 2, resource: { buffer: packed.bias } },
+          { binding: 3, resource: { buffer: output } }
+        ];
+      } else if (node.op === 'fusedUpsampleConcatConv2d') {
+        convId = node.conv.id;
+        const firstShape = plan.valueShapes.get(node.inputs[0].value)!;
+        const secondShape = plan.valueShapes.get(node.inputs[1].value)!;
+        uniformValues = [
+          outputShape.width,
+          outputShape.height,
+          blocksForChannels(outputShape.channels),
+          blocksForChannels(this._model.convChannels.get(convId)!.inputChannels),
+          firstShape.width,
+          firstShape.height,
+          secondShape.width,
+          secondShape.height
+        ];
+        const packed = this._packedConvs.get(convId)!;
+        entries = [
+          {
+            binding: 0,
+            resource: { buffer: valueBuffers.get(node.inputs[0].value)! }
+          },
+          {
+            binding: 1,
+            resource: { buffer: valueBuffers.get(node.inputs[1].value)! }
+          },
+          { binding: 2, resource: { buffer: packed.weights } },
+          { binding: 3, resource: { buffer: packed.bias } },
+          { binding: 4, resource: { buffer: output } }
+        ];
+      } else {
+        throw new Error(`Unexpected native node ${node.op}`);
+      }
+
+      const uniform = own(
+        createUniformBuffer(
+          this._device,
+          `oidn/${node.id}/params/${width}x${height}`,
+          uniformValues
+        )
+      );
+      ownedBuffers.push(uniform);
+      entries.push({ binding: entries.length, resource: { buffer: uniform } });
+      nodeBindings.push(
+        this._device.createBindGroup({
+          label: `oidn/${node.id}/bindings`,
+          layout: pipeline.getBindGroupLayout(0),
+          entries
+        })
+      );
+    });
+
+    const inputUniform = own(
+      createUniformBuffer(
+        this._device,
+        `oidn/input/params/${width}x${height}`,
+        [
+          width,
+          height,
+          blocksForChannels(this._model.inputChannels),
+          this._model.inputChannels
+        ]
+      )
+    );
+    ownedBuffers.push(inputUniform);
+
+      return {
+        plan,
+        valueBuffers,
+        slots,
+        nodeBindings,
+        nodePipelines,
+        nodeKernels,
+        inputPipeline,
+        inputUniform,
+        ownedBuffers,
+        lastUsed: ++this._clock
+      };
+    } catch (error) {
+      for (const buffer of createdBuffers) this._releaseBuffer(buffer);
+      throw error;
+    }
+  }
+
+  private _execution(width: number, height: number) {
+    if (this._disposed) throw new Error('Native OIDN executor is disposed');
+    const key = `${width}x${height}`;
+    let execution = this._executionCache.get(key);
+    if (!execution) {
+      execution = this._createExecution(width, height);
+      this._executionCache.set(key, execution);
+      if (this._executionCache.size > this._shapeCacheSize) {
+        const oldest = [...this._executionCache.entries()]
+          .filter(([candidateKey]) => candidateKey !== key)
+          .sort((a, b) => a[1].lastUsed - b[1].lastUsed)[0];
+        if (oldest) {
+          this._executionCache.delete(oldest[0]);
+          // Commands using an evicted plan may still be submitted. Defer actual
+          // destruction until all work currently on the shared queue completes.
+          this._retiredExecutions.add(oldest[1]);
+          void this._device.queue.onSubmittedWorkDone()
+            .catch(() => undefined)
+            .then(() => {
+              this._retiredExecutions.delete(oldest[1]);
+              this._destroyExecution(oldest[1]);
+            });
+        }
+      }
+    }
+    execution.lastUsed = ++this._clock;
+    return execution;
+  }
+
+  /** Allocates shape-dependent execution resources before interactive use. */
+  prewarm(shapes: readonly { width: number; height: number }[]) {
+    for (const shape of shapes) {
+      this._execution(shape.width, shape.height);
+    }
+  }
+
+  /** Captures per-pass GPU timestamps for the next execute call when supported. */
+  profileNextExecution() {
+    if (!this._device.features.has('timestamp-query')) return false;
+    this._profileNextExecution = true;
+    return true;
+  }
+
+  getLastExecutionProfile() {
+    return this._lastExecutionProfile;
+  }
+
+  execute(inputBuffers: readonly GPUBuffer[], width: number, height: number) {
+    const sourceCount = this._model.inputChannels / 3;
+    if (inputBuffers.length !== sourceCount) {
+      throw new Error(
+        `Native OIDN expected ${sourceCount} input buffers, got ${inputBuffers.length}`
+      );
+    }
+    const execution = this._execution(width, height);
+    const profileLabels = [
+      'input-pack',
+      ...execution.plan.nodes.map((node) => node.id)
+    ];
+    const shouldProfile =
+      this._profileNextExecution &&
+      this._device.features.has('timestamp-query');
+    this._profileNextExecution = false;
+    const queryCount = profileLabels.length * 2;
+    const querySet = shouldProfile
+      ? this._resources.track(
+          'gpu-query-set',
+          this._device.createQuerySet({ type: 'timestamp', count: queryCount })
+        )
+      : undefined;
+    const queryBufferSize = queryCount * 8;
+    let queryResolveBuffer: GPUBuffer | undefined;
+    let queryReadbackBuffer: GPUBuffer | undefined;
+    try {
+      queryResolveBuffer = shouldProfile
+        ? this._resources.track(
+            'gpu-buffer',
+            this._device.createBuffer({
+              label: `oidn/profile/resolve/${width}x${height}`,
+              size: queryBufferSize,
+              usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.COPY_SRC
+            })
+          )
+        : undefined;
+      queryReadbackBuffer = shouldProfile
+        ? this._resources.track(
+            'gpu-buffer',
+            this._device.createBuffer({
+              label: `oidn/profile/readback/${width}x${height}`,
+              size: queryBufferSize,
+              usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+            })
+          )
+        : undefined;
+    } catch (error) {
+      this._releaseBuffer(queryReadbackBuffer);
+      this._releaseBuffer(queryResolveBuffer);
+      this._releaseQuerySet(querySet);
+      throw error;
+    }
+    const passDescriptor = (label: string, index: number) => ({
+      label,
+      ...(querySet
+        ? {
+            timestampWrites: {
+              querySet,
+              beginningOfPassWriteIndex: index * 2,
+              endOfPassWriteIndex: index * 2 + 1
+            }
+          }
+        : {})
+    });
+    try {
+      const encoder = this._device.createCommandEncoder({
+        label: `oidn/native/${width}x${height}`
+      });
+
+    const inputEntries: GPUBindGroupEntry[] = inputBuffers.map(
+      (buffer, binding) => ({ binding, resource: { buffer } })
+    );
+    inputEntries.push({
+      binding: sourceCount,
+      resource: { buffer: execution.valueBuffers.get(execution.plan.spec.input)! }
+    });
+    inputEntries.push({
+      binding: sourceCount + 1,
+      resource: { buffer: execution.inputUniform }
+    });
+    const inputBindings = this._device.createBindGroup({
+      label: 'oidn/input/bindings',
+      layout: execution.inputPipeline.getBindGroupLayout(0),
+      entries: inputEntries
+    });
+    {
+      const pass = encoder.beginComputePass(
+        passDescriptor('oidn/input-pack', 0)
+      );
+      pass.setPipeline(execution.inputPipeline);
+      pass.setBindGroup(0, inputBindings);
+      pass.dispatchWorkgroups(
+        Math.ceil(width / WORKGROUP_SIZE),
+        Math.ceil(height / WORKGROUP_SIZE),
+        blocksForChannels(this._model.inputChannels)
+      );
+      pass.end();
+    }
+
+    execution.plan.plannedNodes.forEach(({ node, outputShape }, index) => {
+      const pass = encoder.beginComputePass(
+        passDescriptor(`oidn/${execution.plan.nodes[index].id}`, index + 1)
+      );
+      pass.setPipeline(execution.nodePipelines[index]);
+      pass.setBindGroup(0, execution.nodeBindings[index]);
+      if (node.op === 'maxPool2d' && this._coalescedPool()) {
+        const groupsX = Math.ceil(
+          outputShape.width * blocksForChannels(outputShape.channels) / WORKGROUP_SIZE
+        );
+        const maxGroups = this._device.limits.maxComputeWorkgroupsPerDimension;
+        // Wide channel rows continue in Z instead of exceeding the X limit.
+        pass.dispatchWorkgroups(
+          Math.min(groupsX, maxGroups),
+          Math.ceil(outputShape.height / WORKGROUP_SIZE),
+          Math.ceil(groupsX / maxGroups)
+        );
+      } else if (execution.nodeKernels[index] === 'implicit-gemm') {
+        const tile = gemmTile(this._gemmForOutput(blocksForChannels(outputShape.channels)));
+        pass.dispatchWorkgroups(
+          Math.ceil(
+            (outputShape.width * outputShape.height) / tile.tileM
+          ),
+          Math.ceil(
+            blocksForChannels(outputShape.channels) / tile.tileNBlocks
+          ),
+          1
+        );
+      } else {
+        pass.dispatchWorkgroups(
+          Math.ceil(outputShape.width / WORKGROUP_SIZE),
+          Math.ceil(outputShape.height / WORKGROUP_SIZE),
+          blocksForChannels(outputShape.channels)
+        );
+      }
+      pass.end();
+    });
+
+    if (querySet) {
+      encoder.resolveQuerySet(
+        querySet,
+        0,
+        queryCount,
+        queryResolveBuffer!,
+        0
+      );
+      encoder.copyBufferToBuffer(
+        queryResolveBuffer!,
+        0,
+        queryReadbackBuffer!,
+        0,
+        queryBufferSize
+      );
+    }
+
+      this._device.queue.submit([encoder.finish()]);
+    } catch (error) {
+      this._releaseBuffer(queryReadbackBuffer);
+      this._releaseBuffer(queryResolveBuffer);
+      this._releaseQuerySet(querySet);
+      throw error;
+    }
+    if (querySet) {
+      this._profileOperations++;
+      this._lastExecutionProfile = (async () => {
+        try {
+          await queryReadbackBuffer!.mapAsync(GPUMapMode.READ);
+          const timestamps = new BigUint64Array(
+            queryReadbackBuffer!.getMappedRange()
+          );
+          const layers = profileLabels.map((id, index) => ({
+            id,
+            durationMs:
+              Number(timestamps[index * 2 + 1] - timestamps[index * 2]) /
+              1_000_000
+          }));
+          return {
+            totalMs: layers.reduce(
+              (sum, layer) => sum + layer.durationMs,
+              0
+            ),
+            layers
+          };
+        } finally {
+          if (queryReadbackBuffer!.mapState === 'mapped') {
+            queryReadbackBuffer!.unmap();
+          }
+          this._releaseQuerySet(querySet);
+          this._releaseBuffer(queryResolveBuffer);
+          this._releaseBuffer(queryReadbackBuffer);
+          this._profileOperations--;
+        }
+      })();
+    }
+    return execution.valueBuffers.get(execution.plan.spec.output)!;
+  }
+
+  /** Executes interleaved CPU image data through the native GPU runtime. */
+  async executeCPU(
+    interleavedInput: Float32Array,
+    width: number,
+    height: number
+  ): Promise<Float32Array> {
+    const expectedLength = width * height * this._model.inputChannels;
+    if (interleavedInput.length !== expectedLength) {
+      throw new Error(
+        `Native OIDN CPU input has ${interleavedInput.length} values, expected ${expectedLength}`
+      );
+    }
+    const execution = this._execution(width, height);
+    const sourceCount = this._model.inputChannels / 3;
+    const pixelCount = width * height;
+    if (!execution.cpuInputBuffers) {
+      execution.cpuInputBuffers = Array.from({ length: sourceCount }, (_, index) => {
+        const buffer = this._device.createBuffer({
+          label: `oidn/cpu-input/${width}x${height}/${index}`,
+          size: pixelCount * 16,
+          usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST
+        });
+        this._resources.track('gpu-buffer', buffer);
+        execution.ownedBuffers.push(buffer);
+        return buffer;
+      });
+      execution.cpuReadbackBuffer = this._device.createBuffer({
+        label: `oidn/cpu-readback/${width}x${height}`,
+        size: pixelCount * 16,
+        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+      });
+      this._resources.track('gpu-buffer', execution.cpuReadbackBuffer);
+      execution.ownedBuffers.push(execution.cpuReadbackBuffer);
+    }
+
+    for (let source = 0; source < sourceCount; source++) {
+      const upload = new Float32Array(pixelCount * 4);
+      for (let pixel = 0; pixel < pixelCount; pixel++) {
+        const inputOffset =
+          pixel * this._model.inputChannels + source * 3;
+        const outputOffset = pixel * 4;
+        upload[outputOffset] = interleavedInput[inputOffset];
+        upload[outputOffset + 1] = interleavedInput[inputOffset + 1];
+        upload[outputOffset + 2] = interleavedInput[inputOffset + 2];
+      }
+      this._device.queue.writeBuffer(
+        execution.cpuInputBuffers[source],
+        0,
+        upload
+      );
+    }
+
+    const output = this.execute(execution.cpuInputBuffers, width, height);
+    const encoder = this._device.createCommandEncoder({
+      label: `oidn/cpu-readback/${width}x${height}`
+    });
+    encoder.copyBufferToBuffer(
+      output,
+      0,
+      execution.cpuReadbackBuffer!,
+      0,
+      pixelCount * 16
+    );
+    this._device.queue.submit([encoder.finish()]);
+    await execution.cpuReadbackBuffer!.mapAsync(GPUMapMode.READ);
+    const rgba = new Float32Array(
+      execution.cpuReadbackBuffer!.getMappedRange()
+    );
+    const rgb = new Float32Array(pixelCount * 3);
+    for (let pixel = 0; pixel < pixelCount; pixel++) {
+      rgb[pixel * 3] = rgba[pixel * 4];
+      rgb[pixel * 3 + 1] = rgba[pixel * 4 + 1];
+      rgb[pixel * 3 + 2] = rgba[pixel * 4 + 2];
+    }
+    execution.cpuReadbackBuffer!.unmap();
+    return rgb;
+  }
+
+  private _releaseBuffer(buffer: GPUBuffer | undefined) {
+    this._resources.release('gpu-buffer', buffer, () => buffer!.destroy());
+  }
+
+  private _releaseQuerySet(querySet: GPUQuerySet | undefined) {
+    this._resources.release(
+      'gpu-query-set',
+      querySet,
+      () => querySet!.destroy()
+    );
+  }
+
+  private _destroyExecution(execution: CachedExecution) {
+    execution.slots.forEach((slot) => this._releaseBuffer(slot.buffer));
+    execution.ownedBuffers.forEach((buffer) => this._releaseBuffer(buffer));
+  }
+
+  getResourceInfo(): OIDNResourceSnapshot {
+    return this._resources.snapshot(
+      this._retiredExecutions.size + this._profileOperations
+    );
+  }
+
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    for (const packed of this._packedConvs.values()) {
+      this._releaseBuffer(packed.weights);
+      this._releaseBuffer(packed.bias);
+    }
+    this._packedConvs.clear();
+    for (const execution of this._executionCache.values()) {
+      this._destroyExecution(execution);
+    }
+    this._executionCache.clear();
+    for (const execution of this._retiredExecutions) {
+      this._destroyExecution(execution);
+    }
+    this._retiredExecutions.clear();
+  }
+}