@simulatte/doppler 0.1.8 → 0.2.0

package/src/gpu/kernels/gptoss_mxfp4_expert_fused.wgsl

@@ -1,127 +0,0 @@
-// gptoss_mxfp4_expert_fused.wgsl
-
-/**
- * GPT-OSS MXFP4 expert dequant kernel with vec4-oriented write path.
- *
- * This keeps the same bind-group contract as dequant_mxfp4_expert_f16.wgsl,
- * but emits f16 and processes contiguous groups to reduce scalar indexing
- * overhead on subgroup-capable backends.
- */
-
-enable f16;
-
-override WORKGROUP_SIZE_EXPERT: u32 = 256u;
-
-struct ExpertUniforms {
-    expert_idx: u32,
-    num_experts: u32,
-    out_dim: u32,
-    num_groups: u32,
-    total_output: u32,
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-}
-
-@group(0) @binding(0) var<uniform> eu: ExpertUniforms;
-@group(0) @binding(1) var<storage, read> expert_blocks: array<u32>;
-@group(0) @binding(2) var<storage, read> expert_scales: array<u32>;
-@group(0) @binding(3) var<storage, read_write> expert_output: array<f16>;
-
-fn unpack_nibble(byte_data: u32, nibble_idx: u32) -> f32 {
-    let byte_idx = nibble_idx / 2u;
-    let is_high = nibble_idx % 2u;
-    let byte_val = (byte_data >> (byte_idx * 8u)) & 0xFFu;
-
-    var nibble: u32;
-    if (is_high == 1u) {
-        nibble = (byte_val >> 4u) & 0xFu;
-    } else {
-        nibble = byte_val & 0xFu;
-    }
-
-    let sign_bit = (nibble >> 3u) & 1u;
-    let exp = (nibble >> 1u) & 3u;
-    let mantissa = nibble & 1u;
-
-    var value: f32;
-    if (exp == 0u) {
-        value = f32(mantissa) * 0.5;
-    } else {
-        let m = 1.0 + f32(mantissa) * 0.5;
-        value = m * pow(2.0, f32(exp) - 1.0);
-    }
-
-    if (sign_bit == 1u) {
-        value = -value;
-    }
-    return value;
-}
-
-fn read_scale(scale_data: u32, idx: u32) -> f32 {
-    let byte_idx = idx % 4u;
-    let scale_byte = (scale_data >> (byte_idx * 8u)) & 0xFFu;
-    if (scale_byte == 0u || scale_byte == 255u) {
-        return 0.0;
-    }
-    return exp2(f32(i32(scale_byte) - 127));
-}
-
-fn compute_output_value(out_elem: u32) -> f16 {
-    let row_idx = out_elem / (eu.num_groups * 32u);
-    let col_idx = out_elem % (eu.num_groups * 32u);
-    let group_in_row = col_idx / 32u;
-    let elem_in_group = col_idx % 32u;
-
-    let expert_offset = eu.expert_idx;
-    let blocks_per_expert = eu.out_dim * eu.num_groups * 4u;
-    let blocks_per_row = eu.num_groups * 4u;
-
-    let block_word_idx = expert_offset * blocks_per_expert
-                       + row_idx * blocks_per_row
-                       + group_in_row * 4u
-                       + (elem_in_group / 8u);
-
-    let block_word = expert_blocks[block_word_idx];
-    let nibble_in_word = elem_in_group % 8u;
-    let nibble_val = unpack_nibble(block_word, nibble_in_word);
-
-    let scales_bytes_per_expert = eu.out_dim * eu.num_groups;
-    let scales_bytes_per_row = eu.num_groups;
-    let scale_byte_offset = expert_offset * scales_bytes_per_expert
-                          + row_idx * scales_bytes_per_row
-                          + group_in_row;
-    let scale_word_idx = scale_byte_offset / 4u;
-    let scale_byte_in_word = scale_byte_offset % 4u;
-    let scale = read_scale(expert_scales[scale_word_idx], scale_byte_in_word);
-
-    return f16(nibble_val * scale);
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE_EXPERT, 1, 1)
-fn main_expert(
-    @builtin(global_invocation_id) global_id: vec3<u32>
-) {
-    let base = global_id.x * 4u;
-
-    if (base >= eu.total_output) {
-        return;
-    }
-
-    expert_output[base] = compute_output_value(base);
-
-    let i1 = base + 1u;
-    if (i1 < eu.total_output) {
-        expert_output[i1] = compute_output_value(i1);
-    }
-
-    let i2 = base + 2u;
-    if (i2 < eu.total_output) {
-        expert_output[i2] = compute_output_value(i2);
-    }
-
-    let i3 = base + 3u;
-    if (i3 < eu.total_output) {
-        expert_output[i3] = compute_output_value(i3);
-    }
-}

package/src/gpu/kernels/gptoss_router_topk.wgsl

@@ -1,119 +0,0 @@
-// gptoss_router_topk.wgsl
-
-/**
- * GPT-OSS router top-k kernel.
- *
- * Identical bind-group topology to existing topk kernels, but with:
- * - deterministic tie-break by lower expert index,
- * - explicit f16 logits + f16 output weights,
- * - larger default workgroup for high-expert-count routing.
- */
-
-enable f16;
-
-override WORKGROUP_SIZE: u32 = 256u;
-const MAX_WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    num_tokens: u32,
-    num_experts: u32,
-    top_k: u32,
-    normalize: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> probs: array<f16>;
-@group(0) @binding(2) var<storage, read_write> out_indices: array<u32>;
-@group(0) @binding(3) var<storage, read_write> out_weights: array<f16>;
-
-var<workgroup> shared_probs: array<f32, MAX_WORKGROUP_SIZE>;
-var<workgroup> shared_indices: array<u32, MAX_WORKGROUP_SIZE>;
-
-fn is_strictly_better(candidate_prob: f32, candidate_idx: u32, best_prob: f32, best_idx: u32) -> bool {
-    if (candidate_prob > best_prob) {
-        return true;
-    }
-    if (candidate_prob < best_prob) {
-        return false;
-    }
-    return candidate_idx < best_idx;
-}
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn softmax_topk(
-    @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) wg_id: vec3<u32>
-) {
-    let token_idx = wg_id.x;
-    let thread_idx = local_id.x;
-
-    if (token_idx >= u.num_tokens) {
-        return;
-    }
-
-    let num_experts = u.num_experts;
-    let top_k = u.top_k;
-    let base_offset = token_idx * num_experts;
-
-    if (thread_idx < num_experts) {
-        shared_probs[thread_idx] = f32(probs[base_offset + thread_idx]);
-        shared_indices[thread_idx] = thread_idx;
-    }
-    workgroupBarrier();
-
-    if (thread_idx == 0u) {
-        var max_val: f32 = shared_probs[0];
-        for (var i: u32 = 1u; i < num_experts; i = i + 1u) {
-            max_val = max(max_val, shared_probs[i]);
-        }
-
-        var exp_sum: f32 = 0.0;
-        for (var i: u32 = 0u; i < num_experts; i = i + 1u) {
-            let exp_val = exp(shared_probs[i] - max_val);
-            shared_probs[i] = exp_val;
-            exp_sum = exp_sum + exp_val;
-        }
-
-        let inv_exp_sum = select(0.0, 1.0 / exp_sum, exp_sum > 0.0);
-        for (var i: u32 = 0u; i < num_experts; i = i + 1u) {
-            shared_probs[i] = shared_probs[i] * inv_exp_sum;
-        }
-
-        for (var k: u32 = 0u; k < top_k; k = k + 1u) {
-            var best_idx: u32 = k;
-            var best_prob: f32 = shared_probs[k];
-            var best_expert: u32 = shared_indices[k];
-
-            for (var i: u32 = k + 1u; i < num_experts; i = i + 1u) {
-                let candidate_prob = shared_probs[i];
-                let candidate_expert = shared_indices[i];
-                if (is_strictly_better(candidate_prob, candidate_expert, best_prob, best_expert)) {
-                    best_idx = i;
-                    best_prob = candidate_prob;
-                    best_expert = candidate_expert;
-                }
-            }
-
-            if (best_idx != k) {
-                let tmp_prob = shared_probs[k];
-                let tmp_idx = shared_indices[k];
-                shared_probs[k] = shared_probs[best_idx];
-                shared_indices[k] = shared_indices[best_idx];
-                shared_probs[best_idx] = tmp_prob;
-                shared_indices[best_idx] = tmp_idx;
-            }
-        }
-
-        var weight_sum: f32 = 0.0;
-        for (var k: u32 = 0u; k < top_k; k = k + 1u) {
-            weight_sum = weight_sum + shared_probs[k];
-        }
-
-        let out_base = token_idx * top_k;
-        let inv_sum = select(1.0, 1.0 / weight_sum, u.normalize == 1u && weight_sum > 0.0);
-        for (var k: u32 = 0u; k < top_k; k = k + 1u) {
-            out_indices[out_base + k] = shared_indices[k];
-            out_weights[out_base + k] = f16(shared_probs[k] * inv_sum);
-        }
-    }
-}

package/src/gpu/kernels/grouped_pointwise_conv2d.d.ts

@@ -1,27 +0,0 @@
-import type { Tensor } from '../tensor.js';
-import type { CommandRecorder } from '../command-recorder.js';
-import type { OutputBufferOptions } from './types.js';
-import type { WeightBuffer } from '../weight-buffer.js';
-
-export interface GroupedPointwiseConv2DOptions extends OutputBufferOptions {
-  inChannels: number;
-  outChannels: number;
-  height: number;
-  width: number;
-  groups: number;
-}
-
-export declare function runGroupedPointwiseConv2D(
-  input: Tensor,
-  weight: GPUBuffer | WeightBuffer,
-  bias: GPUBuffer | WeightBuffer | null,
-  options: GroupedPointwiseConv2DOptions
-): Promise<Tensor>;
-
-export declare function recordGroupedPointwiseConv2D(
-  recorder: CommandRecorder,
-  input: Tensor,
-  weight: GPUBuffer | WeightBuffer,
-  bias: GPUBuffer | WeightBuffer | null,
-  options: GroupedPointwiseConv2DOptions
-): Promise<Tensor>;

package/src/gpu/kernels/grouped_pointwise_conv2d.js

@@ -1,103 +0,0 @@
-import { getDevice } from '../device.js';
-import { acquireBuffer, releaseBuffer } from '../../memory/buffer-pool.js';
-import { createTensor, dtypeBytes } from '../tensor.js';
-import { getBuffer } from '../weight-buffer.js';
-import { unifiedKernelWrapper } from './utils.js';
-import { selectRuleValue } from './rule-registry.js';
-import { WORKGROUP_SIZES } from './constants.js';
-
-function selectGroupedPointwiseConv2DVariant(isF16) {
-  return selectRuleValue('groupedPointwiseConv2d', 'variant', { isF16 });
-}
-
-async function _groupedPointwiseConv2D(target, input, weight, bias, options = {}) {
-  const recorder = target && typeof target.beginComputePass === 'function' ? target : null;
-  const device = target?.device || getDevice();
-  const {
-    inChannels,
-    outChannels,
-    height,
-    width,
-    groups,
-    outputBuffer = null,
-  } = options;
-
-  if (
-    !Number.isFinite(inChannels) ||
-    !Number.isFinite(outChannels) ||
-    !Number.isFinite(height) ||
-    !Number.isFinite(width) ||
-    !Number.isFinite(groups)
-  ) {
-    throw new Error('GroupedPointwiseConv2D requires explicit dimensions.');
-  }
-  if (groups <= 0 || inChannels % groups !== 0 || outChannels % groups !== 0) {
-    throw new Error(
-      `GroupedPointwiseConv2D requires inChannels/outChannels divisible by groups. Got ${inChannels}/${outChannels}/${groups}.`
-    );
-  }
-
-  const isF16 = input.dtype === 'f16';
-  const variant = selectGroupedPointwiseConv2DVariant(isF16);
-  const bytesPerElement = dtypeBytes(input.dtype);
-  const outputSize = outChannels * height * width * bytesPerElement;
-  const output = outputBuffer || acquireBuffer(outputSize, undefined, 'grouped_pointwise_conv2d_output');
-  const spatial = height * width;
-
-  const weightBuffer = getBuffer(weight);
-  let biasBuffer = getBuffer(bias);
-  let tempBias = null;
-  if (!biasBuffer) {
-    const biasSize = outChannels * bytesPerElement;
-    tempBias = acquireBuffer(biasSize, undefined, 'grouped_pointwise_conv2d_bias_zero');
-    biasBuffer = tempBias;
-    const paddedSize = Math.ceil(biasSize / 4) * 4;
-    device.queue.writeBuffer(biasBuffer, 0, new Uint8Array(paddedSize));
-  }
-
-  try {
-    await unifiedKernelWrapper(
-      'grouped_pointwise_conv2d',
-      target,
-      variant,
-      [input, weightBuffer, biasBuffer, output],
-      {
-        in_channels: inChannels,
-        out_channels: outChannels,
-        height,
-        width,
-        groups,
-        _pad0: 0,
-        _pad1: 0,
-        _pad2: 0,
-      },
-      [Math.ceil(spatial / WORKGROUP_SIZES.DEFAULT), outChannels, 1]
-    );
-
-    if (tempBias) {
-      if (recorder) {
-        recorder.trackTemporaryBuffer(tempBias);
-      } else {
-        releaseBuffer(tempBias);
-      }
-    }
-
-    return createTensor(output, input.dtype, [outChannels, height, width], 'grouped_pointwise_conv2d_output');
-  } catch (error) {
-    if (tempBias) {
-      releaseBuffer(tempBias);
-    }
-    if (!outputBuffer) {
-      releaseBuffer(output);
-    }
-    throw error;
-  }
-}
-
-export async function runGroupedPointwiseConv2D(input, weight, bias, options = {}) {
-  return _groupedPointwiseConv2D(null, input, weight, bias, options);
-}
-
-export async function recordGroupedPointwiseConv2D(recorder, input, weight, bias, options = {}) {
-  return _groupedPointwiseConv2D(recorder, input, weight, bias, options);
-}

package/src/gpu/kernels/grouped_pointwise_conv2d.wgsl

@@ -1,44 +0,0 @@
-override WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    in_channels: u32,
-    out_channels: u32,
-    height: u32,
-    width: u32,
-    groups: u32,
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> input: array<f32>;
-@group(0) @binding(2) var<storage, read> weight: array<f32>;
-@group(0) @binding(3) var<storage, read> bias: array<f32>;
-@group(0) @binding(4) var<storage, read_write> output: array<f32>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let spatial = u.height * u.width;
-    let spatial_idx = gid.x;
-    let out_channel = gid.y;
-    if (spatial_idx >= spatial || out_channel >= u.out_channels) {
-        return;
-    }
-    let y = spatial_idx / u.width;
-    let x = spatial_idx - y * u.width;
-
-    let in_per_group = u.in_channels / u.groups;
-    let out_per_group = u.out_channels / u.groups;
-    let group_idx = out_channel / out_per_group;
-    let in_offset = group_idx * in_per_group;
-
-    var sum: f32 = bias[out_channel];
-    for (var i: u32 = 0u; i < in_per_group; i = i + 1u) {
-        let input_idx = ((in_offset + i) * u.height + y) * u.width + x;
-        let weight_idx = out_channel * in_per_group + i;
-        sum = sum + input[input_idx] * weight[weight_idx];
-    }
-
-    output[out_channel * spatial + spatial_idx] = sum;
-}

package/src/gpu/kernels/grouped_pointwise_conv2d_f16.wgsl

@@ -1,48 +0,0 @@
-// Grouped Pointwise Conv2D Kernel (NCHW, f16)
-
-enable f16;
-
-override WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    in_channels: u32,
-    out_channels: u32,
-    height: u32,
-    width: u32,
-    groups: u32,
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> input: array<f16>;
-@group(0) @binding(2) var<storage, read> weight: array<f16>;
-@group(0) @binding(3) var<storage, read> bias: array<f16>;
-@group(0) @binding(4) var<storage, read_write> output: array<f16>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let spatial = u.height * u.width;
-    let spatial_idx = gid.x;
-    let out_channel = gid.y;
-    if (spatial_idx >= spatial || out_channel >= u.out_channels) {
-        return;
-    }
-    let y = spatial_idx / u.width;
-    let x = spatial_idx - y * u.width;
-
-    let in_per_group = u.in_channels / u.groups;
-    let out_per_group = u.out_channels / u.groups;
-    let group_idx = out_channel / out_per_group;
-    let in_offset = group_idx * in_per_group;
-
-    var sum: f32 = f32(bias[out_channel]);
-    for (var i: u32 = 0u; i < in_per_group; i = i + 1u) {
-        let input_idx = ((in_offset + i) * u.height + y) * u.width + x;
-        let weight_idx = out_channel * in_per_group + i;
-        sum = sum + f32(input[input_idx]) * f32(weight[weight_idx]);
-    }
-
-    output[out_channel * spatial + spatial_idx] = f16(sum);
-}

package/src/gpu/kernels/groupnorm.d.ts

@@ -1,31 +0,0 @@
-import type { Tensor } from '../tensor.js';
-import type { CommandRecorder } from '../command-recorder.js';
-import type { OutputBufferOptions } from './types.js';
-import type { WeightBuffer } from '../weight-buffer.js';
-
-export interface GroupNormOptions extends OutputBufferOptions {
-  channels: number;
-  height: number;
-  width: number;
-  numGroups: number;
-  eps: number;
-}
-
-export interface GroupNormSelectionContext {
-  isF16: boolean;
-}
-
-export declare function runGroupNorm(
-  input: Tensor,
-  weight: GPUBuffer | WeightBuffer,
-  bias: GPUBuffer | WeightBuffer,
-  options: GroupNormOptions
-): Promise<Tensor>;
-
-export declare function recordGroupNorm(
-  recorder: CommandRecorder,
-  input: Tensor,
-  weight: GPUBuffer | WeightBuffer,
-  bias: GPUBuffer | WeightBuffer,
-  options: GroupNormOptions
-): Promise<Tensor>;

package/src/gpu/kernels/groupnorm.js

@@ -1,102 +0,0 @@
-import { acquireBuffer, releaseBuffer } from '../../memory/buffer-pool.js';
-import { createTensor, dtypeBytes } from '../tensor.js';
-import { unifiedKernelWrapper } from './utils.js';
-import { selectRuleValue } from './rule-registry.js';
-import { getBuffer } from '../weight-buffer.js';
-import { WORKGROUP_SIZES } from './constants.js';
-
-function selectGroupNormVariant(stage, isF16) {
-  return selectRuleValue('groupnorm', stage, { isF16 });
-}
-
-function validateOptions(options) {
-  const { channels, height, width, numGroups, eps } = options;
-  if (!Number.isFinite(channels) || !Number.isFinite(height) || !Number.isFinite(width)) {
-    throw new Error('GroupNorm requires channels/height/width.');
-  }
-  if (!Number.isFinite(numGroups) || numGroups <= 0) {
-    throw new Error('GroupNorm requires numGroups > 0.');
-  }
-  if (channels % numGroups !== 0) {
-    throw new Error('GroupNorm requires channels to be divisible by numGroups.');
-  }
-  if (!Number.isFinite(eps)) {
-    throw new Error('GroupNorm requires eps.');
-  }
-}
-
-async function _groupNorm(target, input, weight, bias, options = {}) {
-  const recorder = target && typeof target.beginComputePass === 'function' ? target : null;
-  validateOptions(options);
-
-  const { channels, height, width, numGroups, eps, outputBuffer = null } = options;
-  const isF16 = input.dtype === 'f16';
-  const statsVariant = selectGroupNormVariant('statsVariant', isF16);
-  const applyVariant = selectGroupNormVariant('applyVariant', isF16);
-
-  const uniforms = {
-    channels,
-    height,
-    width,
-    num_groups: numGroups,
-    eps,
-    _pad0: 0,
-    _pad1: 0,
-    _pad2: 0,
-  };
-
-  const statsSize = numGroups * 2 * 4;
-  const statsBuffer = acquireBuffer(statsSize, undefined, 'groupnorm_stats');
-  const bytesPerElement = dtypeBytes(input.dtype);
-  const outputSize = channels * height * width * bytesPerElement;
-  const ownedOutput = outputBuffer ? null : acquireBuffer(outputSize, undefined, 'groupnorm_output');
-  const output = outputBuffer || ownedOutput;
-
-  try {
-    await unifiedKernelWrapper(
-      'groupnorm_stats',
-      target,
-      statsVariant,
-      [input, statsBuffer],
-      uniforms,
-      numGroups
-    );
-
-    const weightBuffer = getBuffer(weight);
-    const biasBuffer = getBuffer(bias);
-
-    const total = channels * height * width;
-    const workgroups = Math.ceil(total / WORKGROUP_SIZES.DEFAULT);
-
-    await unifiedKernelWrapper(
-      'groupnorm_apply',
-      target,
-      applyVariant,
-      [input, statsBuffer, weightBuffer, biasBuffer, output],
-      uniforms,
-      workgroups
-    );
-  } catch (error) {
-    releaseBuffer(statsBuffer);
-    if (ownedOutput) {
-      releaseBuffer(ownedOutput);
-    }
-    throw error;
-  }
-
-  if (recorder) {
-    recorder.trackTemporaryBuffer(statsBuffer);
-  } else {
-    releaseBuffer(statsBuffer);
-  }
-
-  return createTensor(output, input.dtype, [channels, height, width], 'groupnorm_output');
-}
-
-export async function runGroupNorm(input, weight, bias, options = {}) {
-  return _groupNorm(null, input, weight, bias, options);
-}
-
-export async function recordGroupNorm(recorder, input, weight, bias, options = {}) {
-  return _groupNorm(recorder, input, weight, bias, options);
-}

package/src/gpu/kernels/groupnorm_apply.wgsl

@@ -1,41 +0,0 @@
-// GroupNorm Apply Kernel (NCHW)
-
-override WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    channels: u32,
-    height: u32,
-    width: u32,
-    num_groups: u32,
-    eps: f32,
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> input: array<f32>;
-@group(0) @binding(2) var<storage, read> stats: array<f32>;
-@group(0) @binding(3) var<storage, read> weight: array<f32>;
-@group(0) @binding(4) var<storage, read> bias: array<f32>;
-@group(0) @binding(5) var<storage, read_write> output: array<f32>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let idx = gid.x;
-    let spatial = u.height * u.width;
-    let total = u.channels * spatial;
-    if (idx >= total) {
-        return;
-    }
-
-    let channel = idx / spatial;
-    let channels_per_group = u.channels / u.num_groups;
-    let group = channel / channels_per_group;
-    let stat_idx = group * 2u;
-    let mean = stats[stat_idx];
-    let inv_std = stats[stat_idx + 1u];
-
-    let value = (input[idx] - mean) * inv_std;
-    output[idx] = value * weight[channel] + bias[channel];
-}

package/src/gpu/kernels/groupnorm_apply_f16.wgsl

@@ -1,46 +0,0 @@
-// AUTO-GENERATED from src/gpu/kernels/groupnorm_apply.wgsl.
-// Edit the source kernel and tools/configs/wgsl-variants.js, then run `npm run kernels:generate`.
-// GroupNorm Apply Kernel (NCHW, f16)
-
-enable f16;
-
-override WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    channels: u32,
-    height: u32,
-    width: u32,
-    num_groups: u32,
-    eps: f32,
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> input: array<f16>;
-@group(0) @binding(2) var<storage, read> stats: array<f32>;
-@group(0) @binding(3) var<storage, read> weight: array<f16>;
-@group(0) @binding(4) var<storage, read> bias: array<f16>;
-@group(0) @binding(5) var<storage, read_write> output: array<f16>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let idx = gid.x;
-    let spatial = u.height * u.width;
-    let total = u.channels * spatial;
-    if (idx >= total) {
-        return;
-    }
-
-    let channel = idx / spatial;
-    let channels_per_group = u.channels / u.num_groups;
-    let group = channel / channels_per_group;
-    let stat_idx = group * 2u;
-    let mean = stats[stat_idx];
-    let inv_std = stats[stat_idx + 1u];
-
-    let value = (f32(input[idx]) - mean) * inv_std;
-    let scaled = value * f32(weight[channel]) + f32(bias[channel]);
-    output[idx] = f16(scaled);
-}