@simulatte/doppler 0.1.3 → 0.1.5

package/src/config/schema/index.d.ts

@@ -225,6 +225,28 @@ export {
   type ConversionIOSchema,
 } from './conversion.schema.js';
 
+// =============================================================================
+// Browser Suite Metrics Schema
+// =============================================================================
+export {
+  type BrowserSuiteMetricsSchema,
+  BROWSER_SUITE_METRICS_SCHEMA_VERSION,
+  DEFAULT_BROWSER_SUITE_METRICS,
+  validateBrowserSuiteMetrics,
+} from './browser-suite-metrics.schema.js';
+
+// =============================================================================
+// Conversion Report Schema
+// =============================================================================
+export {
+  type ConversionReportResultSchema,
+  type ConversionReportManifestSchema,
+  type ConversionReportSchema,
+  CONVERSION_REPORT_SCHEMA_VERSION,
+  DEFAULT_CONVERSION_REPORT,
+  validateConversionReport,
+} from './conversion-report.schema.js';
+
 // =============================================================================
 // Converter Schema
 // =============================================================================

package/src/config/schema/index.js

@@ -55,6 +55,24 @@ export {
   ConversionStage,
 } from './conversion.schema.js';
 
+// =============================================================================
+// Browser Suite Metrics Schema
+// =============================================================================
+export {
+  BROWSER_SUITE_METRICS_SCHEMA_VERSION,
+  DEFAULT_BROWSER_SUITE_METRICS,
+  validateBrowserSuiteMetrics,
+} from './browser-suite-metrics.schema.js';
+
+// =============================================================================
+// Conversion Report Schema
+// =============================================================================
+export {
+  CONVERSION_REPORT_SCHEMA_VERSION,
+  DEFAULT_CONVERSION_REPORT,
+  validateConversionReport,
+} from './conversion-report.schema.js';
+
 // =============================================================================
 // Converter Schema
 // =============================================================================

package/src/converter/core.d.ts

@@ -27,6 +27,12 @@ import type {
   MoEConfigSchema,
   ConversionInfoSchema,
 } from '../config/schema/index.js';
+import type { ExecutionContractArtifact } from '../config/execution-contract-check.js';
+import type { ExecutionV0GraphContractArtifact } from '../config/execution-v0-graph-contract-check.js';
+import type {
+  ManifestRequiredInferenceFieldsArtifact,
+  RequiredInferenceFieldsContractArtifact,
+} from '../config/required-inference-fields-contract-check.js';
 
 export { generateShardFilename } from '../formats/rdrr/index.js';
 
@@ -144,6 +150,10 @@ export interface ConvertResult {
   shardCount: number;
   tensorCount: number;
   totalSize: number;
+  executionContractArtifact: ExecutionContractArtifact | null;
+  executionV0GraphContractArtifact: ExecutionV0GraphContractArtifact | null;
+  layerPatternContractArtifact: Record<string, unknown> | null;
+  requiredInferenceFieldsArtifact: ManifestRequiredInferenceFieldsArtifact | RequiredInferenceFieldsContractArtifact | null;
 }
 
 /** @deprecated Use ConversionIOSchema from config/schema */

package/src/converter/core.js

@@ -9,15 +9,20 @@ import {
   formatBytes,
 } from '../config/schema/index.js';
 
-import { classifyTensorRole, generateShardFilename } from '../formats/rdrr/index.js';
+import { classifyTensor, classifyTensorRole, generateShardFilename } from '../formats/rdrr/index.js';
 import { log } from '../debug/index.js';
-import { selectRuleValue } from '../rules/rule-registry.js';
+import {
+  getInferenceLayerPatternContractArtifact,
+  selectRuleValue,
+} from '../rules/rule-registry.js';
 import {
   createConverterConfig,
   detectPreset,
   listPresets,
   resolvePreset,
 } from '../config/index.js';
+import { buildExecutionContractArtifact } from '../config/execution-contract-check.js';
+import { buildManifestRequiredInferenceFieldsArtifact } from '../config/required-inference-fields-contract-check.js';
 import { buildManifestInference, inferEmbeddingOutputConfig } from './manifest-inference.js';
 import { resolveEosTokenId } from './tokenizer-utils.js';
 import {
@@ -76,7 +81,8 @@ function resolveTokenizerField(tokenizerConfig, ...keys) {
 }
 
 function resolveTokenizerVocabSize(tokenizerConfig, rawConfig, architecture) {
-  const configVocab = rawConfig?.vocab_size ?? rawConfig?.text_config?.vocab_size;
+  const nestedTextConfig = getNestedTextConfig(rawConfig);
+  const configVocab = rawConfig?.vocab_size ?? nestedTextConfig?.vocab_size;
   const tokenizerVocab = tokenizerConfig?.vocab_size ?? tokenizerConfig?.vocabSize;
   const archVocab = architecture?.vocabSize;
   return tokenizerVocab ?? configVocab ?? archVocab ?? null;
@@ -223,21 +229,22 @@ function toFloat32ForQ4K(tensorData, sourceDtype, tensorName) {
 
 function resolveConfigTokenId(rawConfig, key) {
   const direct = rawConfig?.[key];
-  const nested = rawConfig?.text_config?.[key];
+  const nested = getNestedTextConfig(rawConfig)?.[key];
   return resolveTokenizerId(direct ?? nested);
 }
 
 function resolveConfigTokenIds(rawConfig, key) {
   const direct = rawConfig?.[key];
-  const nested = rawConfig?.text_config?.[key];
+  const nested = getNestedTextConfig(rawConfig)?.[key];
   return resolveTokenizerIds(direct ?? nested);
 }
 
 function resolveMoEConfigNumber(rawConfig, ...keys) {
+  const nestedTextConfig = getNestedTextConfig(rawConfig);
   for (const key of keys) {
     const direct = rawConfig?.[key];
     if (Number.isFinite(direct) && direct > 0) return Number(direct);
-    const nested = rawConfig?.text_config?.[key];
+    const nested = nestedTextConfig?.[key];
     if (Number.isFinite(nested) && nested > 0) return Number(nested);
   }
   return null;
@@ -317,7 +324,7 @@ function resolveIntermediateSizeFromTensors(architecture, model, tensorLocations
   if (typeof current !== 'number' || !Number.isFinite(current) || current <= 0) {
     return architecture;
   }
-  const modelType = String(rawConfig?.model_type ?? rawConfig?.text_config?.model_type ?? '').toLowerCase();
+  const modelType = String(rawConfig?.model_type ?? getNestedTextConfig(rawConfig)?.model_type ?? '').toLowerCase();
   if (modelType !== 'lfm2') {
     return architecture;
   }
@@ -359,7 +366,7 @@ function resolveMoEExpertFormat(rawConfig, resolvedModelType, quantizationInfo,
   const modelType = String(
     resolvedModelType ??
     rawConfig?.model_type ??
-    rawConfig?.text_config?.model_type ??
+    getNestedTextConfig(rawConfig)?.model_type ??
     ''
   ).toLowerCase();
   if (modelType.includes('gpt_oss') || modelType.includes('gpt-oss') || modelType.includes('gptoss')) {
@@ -725,9 +732,7 @@ export function extractArchitecture(config, ggufConfig) {
 
   // Try HuggingFace config first
   if (config && Object.keys(config).length > 0) {
-    const textConfig = (
-      config.text_config && typeof config.text_config === 'object' && !Array.isArray(config.text_config)
-    ) ? config.text_config : null;
+    const textConfig = getNestedTextConfig(config);
     const fromConfig = (...keys) => {
       const values = [];
       for (const key of keys) {
@@ -860,6 +865,19 @@ export function extractArchitecture(config, ggufConfig) {
   throw new Error('Missing model config: cannot extract architecture');
 }
 
+function getNestedTextConfig(config) {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    return null;
+  }
+  if (config.text_config && typeof config.text_config === 'object' && !Array.isArray(config.text_config)) {
+    return config.text_config;
+  }
+  if (config.language_config && typeof config.language_config === 'object' && !Array.isArray(config.language_config)) {
+    return config.language_config;
+  }
+  return null;
+}
+
 
 export function buildTensorMap(tensors, shardSize) {
   if (!shardSize || shardSize <= 0) {
@@ -1115,6 +1133,7 @@ export async function convertModel(model, io, options = {}) {
   }
   const totalTensors = tensors.length;
   const targetQuant = String(options.quantization ?? model.quantization ?? '').trim().toLowerCase();
+  const tensorGroupModelType = String(options.modelType ?? model.modelType ?? 'transformer');
   const q4kLayout = normalizeQ4KLayout(options.quantizationInfo?.layout);
   const quantizeEmbeddings = resolveQuantizeEmbeddings(
     options.quantizationInfo ?? null,
@@ -1238,6 +1257,7 @@ export async function convertModel(model, io, options = {}) {
 
     // Record tensor location
     const role = classifyTensorRole(tensor.name);
+    const group = classifyTensor(tensor.name, tensorGroupModelType);
 
     if (tensorSpans.length === 1) {
       tensorLocations[tensor.name] = {
@@ -1247,6 +1267,7 @@ export async function convertModel(model, io, options = {}) {
         shape: tensor.shape,
         dtype: outDtype,
         role,
+        group,
         ...(outLayout ? { layout: outLayout } : {}),
       };
     } else {
@@ -1256,6 +1277,7 @@ export async function convertModel(model, io, options = {}) {
         shape: tensor.shape,
         dtype: outDtype,
         role,
+        group,
         ...(outLayout ? { layout: outLayout } : {}),
       };
     }
@@ -1314,11 +1336,27 @@ export async function convertModel(model, io, options = {}) {
     totalSize: formatBytes(totalSize),
   });
 
+  const executionContractArtifact = buildExecutionContractArtifact(manifest);
+  const layerPatternContractArtifact = getInferenceLayerPatternContractArtifact();
+  const requiredInferenceFieldsArtifact = manifest?.modelType === 'transformer'
+    && manifest?.inference
+    && typeof manifest.inference === 'object'
+    && manifest.inference.attention
+    && typeof manifest.inference.attention === 'object'
+    ? buildManifestRequiredInferenceFieldsArtifact(
+      manifest?.inference ?? null,
+      `${manifest?.modelId ?? modelId}.inference`
+    )
+    : null;
   return {
     manifest,
     shardCount: shards.length,
     tensorCount: tensors.length,
     totalSize,
+    executionContractArtifact,
+    executionV0GraphContractArtifact: executionContractArtifact?.executionV0?.graph ?? null,
+    layerPatternContractArtifact,
+    requiredInferenceFieldsArtifact,
   };
 }
 

package/src/converter/parsers/diffusion.js

@@ -4,6 +4,13 @@ const SD3_LAYOUT = {
   id: 'sd3',
   requiredComponents: ['transformer', 'text_encoder', 'text_encoder_2', 'text_encoder_3', 'vae', 'scheduler'],
   weightedComponents: ['transformer', 'text_encoder', 'text_encoder_2', 'text_encoder_3', 'vae'],
+  matches(modelIndex, components) {
+    return (
+      components.has('text_encoder_2') &&
+      components.has('text_encoder_3') &&
+      getComponentClassName(modelIndex?.transformer) === 'SD3Transformer2DModel'
+    );
+  },
   tokenizerSpecs: [
     {
       modelIndexKey: 'tokenizer',
@@ -66,6 +73,10 @@ const FLUX_LAYOUT = {
   id: 'flux',
   requiredComponents: ['transformer', 'text_encoder', 'vae', 'scheduler'],
   weightedComponents: ['transformer', 'text_encoder', 'vae'],
+  matches(modelIndex) {
+    const transformerClass = getComponentClassName(modelIndex?.transformer);
+    return typeof transformerClass === 'string' && /^Flux/i.test(transformerClass);
+  },
   tokenizerSpecs: [
     {
       modelIndexKey: 'tokenizer',
@@ -91,7 +102,39 @@ const FLUX_LAYOUT = {
   ],
 };
 
-const LAYOUTS = [SD3_LAYOUT, FLUX_LAYOUT];
+const SANA_LAYOUT = {
+  id: 'sana',
+  requiredComponents: ['transformer', 'text_encoder', 'tokenizer', 'vae', 'scheduler'],
+  weightedComponents: ['transformer', 'text_encoder', 'vae'],
+  matches(modelIndex) {
+    return (
+      getComponentClassName(modelIndex?.transformer) === 'SanaTransformer2DModel' &&
+      getComponentClassName(modelIndex?.text_encoder) === 'Gemma2Model'
+    );
+  },
+  tokenizerSpecs: [
+    {
+      modelIndexKey: 'tokenizer',
+      componentId: 'text_encoder',
+      type: 'bundled',
+      assets: [
+        { suffix: 'tokenizer/tokenizer.json', targetName: 'tokenizer_tokenizer.json', kind: 'text', required: true },
+        { suffix: 'tokenizer/tokenizer_config.json', targetName: 'tokenizer_config.json', kind: 'text', required: false },
+        { suffix: 'tokenizer/special_tokens_map.json', targetName: 'tokenizer_special_tokens_map.json', kind: 'text', required: false },
+        { suffix: 'tokenizer/tokenizer.model', targetName: 'tokenizer_tokenizer.model', kind: 'binary', required: false },
+      ],
+      config: {
+        type: 'bundled',
+        tokenizerFile: 'tokenizer_tokenizer.json',
+        configFile: 'tokenizer_config.json',
+        specialTokensFile: 'tokenizer_special_tokens_map.json',
+        sentencePieceFile: 'tokenizer_tokenizer.model',
+      },
+    },
+  ],
+};
+
+const LAYOUTS = [SD3_LAYOUT, FLUX_LAYOUT, SANA_LAYOUT];
 
 function toAbortError(message = 'Cancelled') {
   if (typeof DOMException === 'function') {
@@ -112,12 +155,26 @@ function listModelComponents(modelIndex) {
   return Object.keys(modelIndex || {}).filter((key) => !key.startsWith('_'));
 }
 
+function getComponentClassName(componentEntry) {
+  if (Array.isArray(componentEntry) && componentEntry.length >= 2 && typeof componentEntry[1] === 'string') {
+    return componentEntry[1];
+  }
+  if (componentEntry && typeof componentEntry === 'object' && typeof componentEntry._class_name === 'string') {
+    return componentEntry._class_name;
+  }
+  return null;
+}
+
 export function detectDiffusionLayout(modelIndex) {
   const components = new Set(listModelComponents(modelIndex));
   for (const layout of LAYOUTS) {
-    if (layout.requiredComponents.every((component) => components.has(component))) {
-      return layout;
+    if (!layout.requiredComponents.every((component) => components.has(component))) {
+      continue;
     }
+    if (typeof layout.matches === 'function' && !layout.matches(modelIndex, components)) {
+      continue;
+    }
+    return layout;
   }
   const listed = [...components].sort().join(', ') || '(none)';
   const expected = LAYOUTS
@@ -199,6 +256,9 @@ export async function parseDiffusionModel(adapter) {
   const tensors = [];
 
   for (const componentId of layout.requiredComponents) {
+    if (componentId === 'tokenizer') {
+      continue;
+    }
     const configSuffix = defaultConfigPath(componentId);
     const config = await readJson(configSuffix, `${componentId} config`);
     if (componentId === 'transformer' && config && !config.weight_format) {

package/src/converter/tokenizer-utils.js

@@ -1,4 +1,5 @@
 export function resolveEosTokenId({ config, tokenizer, tokenizerJson }) {
+  const nestedTextConfig = getNestedTextConfig(config);
   const candidateSources = [
     tokenizer?.eosTokenId,
     tokenizer?.eos_token_id,
@@ -7,9 +8,9 @@ export function resolveEosTokenId({ config, tokenizer, tokenizerJson }) {
     tokenizerJson?.special_tokens?.eos,
     tokenizerJson?.special_tokens?.eos_token_id,
     config?.eos_token_id,
-    config?.text_config?.eos_token_id,
+    nestedTextConfig?.eos_token_id,
     config?.eos_token_ids,
-    config?.text_config?.eos_token_ids,
+    nestedTextConfig?.eos_token_ids,
   ];
 
   for (const candidate of candidateSources) {
@@ -23,7 +24,7 @@ export function resolveEosTokenId({ config, tokenizer, tokenizerJson }) {
     tokenizerJson?.specialTokens?.eos_token,
     tokenizerJson?.special_tokens?.eos_token,
     config?.eos_token,
-    config?.text_config?.eos_token,
+    nestedTextConfig?.eos_token,
   ];
 
   for (const candidate of eosTokenStringCandidates) {
@@ -48,6 +49,19 @@ export function resolveEosTokenId({ config, tokenizer, tokenizerJson }) {
   throw new Error('Missing eos_token_id. Provide eos_token_id in config or tokenizer metadata.');
 }
 
+function getNestedTextConfig(config) {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    return null;
+  }
+  if (config.text_config && typeof config.text_config === 'object' && !Array.isArray(config.text_config)) {
+    return config.text_config;
+  }
+  if (config.language_config && typeof config.language_config === 'object' && !Array.isArray(config.language_config)) {
+    return config.language_config;
+  }
+  return null;
+}
+
 function normalizeEosTokenId(value) {
   if (Array.isArray(value)) {
     if (value.length === 0 || value.some((id) => typeof id !== 'number')) {

package/src/formats/rdrr/validation.js

@@ -1,4 +1,5 @@
 import { validateTensorConfigConsistency } from './tensor-config-validator.js';
+import { validateManifestExecutionContract } from '../../config/execution-contract-check.js';
 
 export function validateManifest(manifest) {
   const errors = [];
@@ -196,5 +197,17 @@ export function validateManifest(manifest) {
     }
   }
 
+  if (!isDiffusion && !isEnergy && errors.length === 0) {
+    try {
+      const executionContract = validateManifestExecutionContract(manifest);
+      for (const error of executionContract.errors) {
+        errors.push(error);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`[ExecutionContract] ${message}`);
+    }
+  }
+
   return { valid: errors.length === 0, errors, warnings };
 }

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

@@ -0,0 +1,29 @@
+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 DepthwiseConv2DOptions extends OutputBufferOptions {
+  channels: number;
+  height: number;
+  width: number;
+  kernelH: number;
+  kernelW: number;
+  stride?: number;
+  pad?: number;
+}
+
+export declare function runDepthwiseConv2D(
+  input: Tensor,
+  weight: GPUBuffer | WeightBuffer,
+  bias: GPUBuffer | WeightBuffer | null,
+  options: DepthwiseConv2DOptions
+): Promise<Tensor>;
+
+export declare function recordDepthwiseConv2D(
+  recorder: CommandRecorder,
+  input: Tensor,
+  weight: GPUBuffer | WeightBuffer,
+  bias: GPUBuffer | WeightBuffer | null,
+  options: DepthwiseConv2DOptions
+): Promise<Tensor>;

package/src/gpu/kernels/depthwise_conv2d.js

@@ -0,0 +1,98 @@
+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 selectDepthwiseConv2DVariant(isF16) {
+  return selectRuleValue('depthwiseConv2d', 'variant', { isF16 });
+}
+
+async function _depthwiseConv2D(target, input, weight, bias, options = {}) {
+  const recorder = target && typeof target.beginComputePass === 'function' ? target : null;
+  const device = target?.device || getDevice();
+  const {
+    channels,
+    height,
+    width,
+    kernelH,
+    kernelW,
+    stride = 1,
+    pad = 0,
+    outputBuffer = null,
+  } = options;
+
+  if (
+    !Number.isFinite(channels) ||
+    !Number.isFinite(height) ||
+    !Number.isFinite(width) ||
+    !Number.isFinite(kernelH) ||
+    !Number.isFinite(kernelW)
+  ) {
+    throw new Error('DepthwiseConv2D requires explicit dimensions.');
+  }
+
+  const outHeight = Math.floor((height + pad * 2 - kernelH) / stride) + 1;
+  const outWidth = Math.floor((width + pad * 2 - kernelW) / stride) + 1;
+  if (outHeight <= 0 || outWidth <= 0) {
+    throw new Error(`DepthwiseConv2D invalid output size: ${outHeight}x${outWidth}`);
+  }
+
+  const isF16 = input.dtype === 'f16';
+  const variant = selectDepthwiseConv2DVariant(isF16);
+  const bytesPerElement = dtypeBytes(input.dtype);
+  const outputSize = channels * outHeight * outWidth * bytesPerElement;
+  const output = outputBuffer || acquireBuffer(outputSize, undefined, 'depthwise_conv2d_output');
+
+  const weightBuffer = getBuffer(weight);
+  let biasBuffer = getBuffer(bias);
+  let tempBias = null;
+  if (!biasBuffer) {
+    const biasSize = channels * bytesPerElement;
+    tempBias = acquireBuffer(biasSize, undefined, 'depthwise_conv2d_bias_zero');
+    biasBuffer = tempBias;
+    const paddedSize = Math.ceil(biasSize / 4) * 4;
+    device.queue.writeBuffer(biasBuffer, 0, new Uint8Array(paddedSize));
+  }
+
+  await unifiedKernelWrapper(
+    'depthwise_conv2d',
+    target,
+    variant,
+    [input, weightBuffer, biasBuffer, output],
+    {
+      channels,
+      height,
+      width,
+      out_height: outHeight,
+      out_width: outWidth,
+      kernel_h: kernelH,
+      kernel_w: kernelW,
+      stride,
+      pad,
+      _pad0: 0,
+      _pad1: 0,
+    },
+    Math.ceil((channels * outHeight * outWidth) / WORKGROUP_SIZES.DEFAULT)
+  );
+
+  if (tempBias) {
+    if (recorder) {
+      recorder.trackTemporaryBuffer(tempBias);
+    } else {
+      releaseBuffer(tempBias);
+    }
+  }
+
+  return createTensor(output, input.dtype, [channels, outHeight, outWidth], 'depthwise_conv2d_output');
+}
+
+export async function runDepthwiseConv2D(input, weight, bias, options = {}) {
+  return _depthwiseConv2D(null, input, weight, bias, options);
+}
+
+export async function recordDepthwiseConv2D(recorder, input, weight, bias, options = {}) {
+  return _depthwiseConv2D(recorder, input, weight, bias, options);
+}

package/src/gpu/kernels/depthwise_conv2d.wgsl

@@ -0,0 +1,58 @@
+override WORKGROUP_SIZE: u32 = 256u;
+
+struct Uniforms {
+    channels: u32,
+    height: u32,
+    width: u32,
+    out_height: u32,
+    out_width: u32,
+    kernel_h: u32,
+    kernel_w: u32,
+    stride: u32,
+    pad: 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 idx = gid.x;
+    let out_spatial = u.out_height * u.out_width;
+    let out_size = u.channels * out_spatial;
+    if (idx >= out_size) {
+        return;
+    }
+
+    let channel = idx / out_spatial;
+    let rem = idx - channel * out_spatial;
+    let out_y = rem / u.out_width;
+    let out_x = rem - out_y * u.out_width;
+
+    var sum: f32 = bias[channel];
+    let pad = i32(u.pad);
+
+    for (var ky: u32 = 0u; ky < u.kernel_h; ky = ky + 1u) {
+        let in_y = i32(out_y * u.stride + ky) - pad;
+        if (in_y < 0 || in_y >= i32(u.height)) {
+            continue;
+        }
+        for (var kx: u32 = 0u; kx < u.kernel_w; kx = kx + 1u) {
+            let in_x = i32(out_x * u.stride + kx) - pad;
+            if (in_x < 0 || in_x >= i32(u.width)) {
+                continue;
+            }
+            let input_idx = (channel * u.height + u32(in_y)) * u.width + u32(in_x);
+            let weight_idx = ((channel * u.kernel_h + ky) * u.kernel_w + kx);
+            sum = sum + input[input_idx] * weight[weight_idx];
+        }
+    }
+
+    output[idx] = sum;
+}

package/src/gpu/kernels/depthwise_conv2d_f16.wgsl

@@ -0,0 +1,62 @@
+// Depthwise Conv2D Kernel (NCHW, f16)
+
+enable f16;
+
+override WORKGROUP_SIZE: u32 = 256u;
+
+struct Uniforms {
+    channels: u32,
+    height: u32,
+    width: u32,
+    out_height: u32,
+    out_width: u32,
+    kernel_h: u32,
+    kernel_w: u32,
+    stride: u32,
+    pad: 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 idx = gid.x;
+    let out_spatial = u.out_height * u.out_width;
+    let out_size = u.channels * out_spatial;
+    if (idx >= out_size) {
+        return;
+    }
+
+    let channel = idx / out_spatial;
+    let rem = idx - channel * out_spatial;
+    let out_y = rem / u.out_width;
+    let out_x = rem - out_y * u.out_width;
+
+    var sum: f32 = f32(bias[channel]);
+    let pad = i32(u.pad);
+
+    for (var ky: u32 = 0u; ky < u.kernel_h; ky = ky + 1u) {
+        let in_y = i32(out_y * u.stride + ky) - pad;
+        if (in_y < 0 || in_y >= i32(u.height)) {
+            continue;
+        }
+        for (var kx: u32 = 0u; kx < u.kernel_w; kx = kx + 1u) {
+            let in_x = i32(out_x * u.stride + kx) - pad;
+            if (in_x < 0 || in_x >= i32(u.width)) {
+                continue;
+            }
+            let input_idx = (channel * u.height + u32(in_y)) * u.width + u32(in_x);
+            let weight_idx = ((channel * u.kernel_h + ky) * u.kernel_w + kx);
+            sum = sum + f32(input[input_idx]) * f32(weight[weight_idx]);
+        }
+    }
+
+    output[idx] = f16(sum);
+}