@simulatte/doppler 0.1.4 → 0.1.5

package/src/config/kernel-path-contract-check.js

@@ -0,0 +1,479 @@
+import { selectByRules } from '../gpu/kernels/rule-matcher.js';
+
+const SUPPORTED_DTYPES = new Set(['f16', 'f32']);
+const DTYPE_RANK = Object.freeze({
+  f16: 1,
+  f32: 2,
+});
+const DTYPE_BYTES = Object.freeze({
+  f16: 2,
+  f32: 4,
+});
+
+function isPlainObject(value) {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function normalizeKernelPathContractDtype(value, label) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (!SUPPORTED_DTYPES.has(normalized)) {
+    throw new Error(
+      `kernel-path contract: ${label} must be one of ${[...SUPPORTED_DTYPES].join(', ')}.`
+    );
+  }
+  return normalized;
+}
+
+function normalizeRegistryEntry(entry, index) {
+  if (!isPlainObject(entry)) {
+    throw new Error(`kernel-path contract: entries[${index}] must be an object.`);
+  }
+  const id = String(entry.id ?? '').trim();
+  if (!id) {
+    throw new Error(`kernel-path contract: entries[${index}].id is required.`);
+  }
+  const aliasOf = typeof entry.aliasOf === 'string' && entry.aliasOf.trim() !== ''
+    ? entry.aliasOf.trim()
+    : null;
+  const hasFile = typeof entry.file === 'string' && entry.file.trim() !== '';
+  if (!aliasOf && !hasFile) {
+    throw new Error(
+      `kernel-path contract: entries[${index}] must include file or aliasOf.`
+    );
+  }
+  return {
+    id,
+    aliasOf,
+    hasFile,
+  };
+}
+
+function normalizeFallbackMapping(mapping, index) {
+  if (!isPlainObject(mapping)) {
+    throw new Error(`kernel-path contract: fallbackMappings[${index}] must be an object.`);
+  }
+  const primaryKernelPathId = String(mapping.primaryKernelPathId ?? '').trim();
+  const fallbackKernelPathId = String(mapping.fallbackKernelPathId ?? '').trim();
+  if (!primaryKernelPathId) {
+    throw new Error(`kernel-path contract: fallbackMappings[${index}].primaryKernelPathId is required.`);
+  }
+  if (!fallbackKernelPathId) {
+    throw new Error(`kernel-path contract: fallbackMappings[${index}].fallbackKernelPathId is required.`);
+  }
+  return {
+    primaryKernelPathId,
+    fallbackKernelPathId,
+    primaryActivationDtype: normalizeKernelPathContractDtype(
+      mapping.primaryActivationDtype,
+      `fallbackMappings[${index}].primaryActivationDtype`
+    ),
+    fallbackActivationDtype: mapping.fallbackActivationDtype == null
+      ? null
+      : normalizeKernelPathContractDtype(
+        mapping.fallbackActivationDtype,
+        `fallbackMappings[${index}].fallbackActivationDtype`
+      ),
+  };
+}
+
+function normalizeFallbackRule(rule, index) {
+  if (!isPlainObject(rule)) {
+    throw new Error(`kernel-path contract: fallbackRules[${index}] must be an object.`);
+  }
+  const match = isPlainObject(rule.match) ? rule.match : {};
+  const rawKernelPathId = match.kernelPathId;
+  const matchKernelPathId = typeof rawKernelPathId === 'string' && rawKernelPathId.trim() !== ''
+    ? rawKernelPathId.trim()
+    : null;
+  const value = rule.value == null ? null : String(rule.value).trim();
+  if (value === '') {
+    throw new Error(`kernel-path contract: fallbackRules[${index}].value must be null or a non-empty string.`);
+  }
+  return {
+    matchKernelPathId,
+    value,
+    isDefault: Object.keys(match).length === 0,
+  };
+}
+
+function normalizeAutoSelectRule(rule, index) {
+  if (!isPlainObject(rule)) {
+    throw new Error(`kernel-path contract: autoSelectRules[${index}] must be an object.`);
+  }
+  const match = isPlainObject(rule.match) ? rule.match : {};
+  const rawKernelPathRef = match.kernelPathRef;
+  const matchKernelPathRef = typeof rawKernelPathRef === 'string' && rawKernelPathRef.trim() !== ''
+    ? rawKernelPathRef.trim()
+    : null;
+  const allowCapabilityAutoSelection = typeof match.allowCapabilityAutoSelection === 'boolean'
+    ? match.allowCapabilityAutoSelection
+    : null;
+  const hasSubgroups = typeof match.hasSubgroups === 'boolean'
+    ? match.hasSubgroups
+    : null;
+  const value = rule.value;
+  if (typeof value === 'string' && value.trim() !== '') {
+    return {
+      matchKernelPathRef,
+      allowCapabilityAutoSelection,
+      hasSubgroups,
+      valueKind: 'string',
+      value: value.trim(),
+      isDefault: Object.keys(match).length === 0,
+    };
+  }
+  if (isPlainObject(value) && Object.keys(value).length === 1 && typeof value.context === 'string') {
+    return {
+      matchKernelPathRef,
+      allowCapabilityAutoSelection,
+      hasSubgroups,
+      valueKind: 'context',
+      value: value.context.trim(),
+      isDefault: Object.keys(match).length === 0,
+    };
+  }
+  throw new Error(
+    `kernel-path contract: autoSelectRules[${index}].value must be a non-empty string ` +
+    'or a { context: ... } directive.'
+  );
+}
+
+function findAliasCycles(entriesById) {
+  const visited = new Set();
+  const visiting = new Set();
+  const stack = [];
+  const cycles = [];
+
+  function walk(id) {
+    if (visited.has(id)) {
+      return;
+    }
+    if (visiting.has(id)) {
+      const cycleStart = stack.indexOf(id);
+      const cycle = cycleStart >= 0 ? [...stack.slice(cycleStart), id] : [id, id];
+      cycles.push(cycle);
+      return;
+    }
+    visiting.add(id);
+    stack.push(id);
+    const nextId = entriesById.get(id)?.aliasOf ?? null;
+    if (nextId) {
+      walk(nextId);
+    }
+    stack.pop();
+    visiting.delete(id);
+    visited.add(id);
+  }
+
+  for (const id of entriesById.keys()) {
+    walk(id);
+  }
+
+  return cycles;
+}
+
+export function extractKernelPathContractFacts(input, options = {}) {
+  const registryId = String(options.registryId ?? input?.registryId ?? 'kernel-path-registry').trim()
+    || 'kernel-path-registry';
+  const rawEntries = Array.isArray(input)
+    ? input
+    : Array.isArray(input?.entries)
+      ? input.entries
+      : null;
+  if (!rawEntries) {
+    throw new Error('kernel-path contract: entries must be an array or an object with entries.');
+  }
+
+  const entries = rawEntries.map(normalizeRegistryEntry);
+  const seenIds = new Set();
+  for (const entry of entries) {
+    if (seenIds.has(entry.id)) {
+      throw new Error(`kernel-path contract: duplicate registry entry id "${entry.id}".`);
+    }
+    seenIds.add(entry.id);
+  }
+
+  const rawFallbackMappings = Array.isArray(input?.fallbackMappings) ? input.fallbackMappings : [];
+  const fallbackMappings = rawFallbackMappings.map(normalizeFallbackMapping);
+  const rawFallbackRules = Array.isArray(input?.fallbackRules) ? input.fallbackRules : [];
+  const fallbackRules = rawFallbackRules.map(normalizeFallbackRule);
+  const rawAutoSelectRules = Array.isArray(input?.autoSelectRules) ? input.autoSelectRules : [];
+  const autoSelectRules = rawAutoSelectRules.map(normalizeAutoSelectRule);
+
+  return {
+    registryId,
+    entries,
+    fallbackMappings,
+    fallbackRules,
+    autoSelectRules,
+  };
+}
+
+export function validateKernelPathContractFacts(facts) {
+  const errors = [];
+  const checks = [];
+  const registryId = String(facts?.registryId ?? 'kernel-path-registry');
+  const entries = Array.isArray(facts?.entries) ? facts.entries : [];
+  const fallbackMappings = Array.isArray(facts?.fallbackMappings) ? facts.fallbackMappings : [];
+  const fallbackRules = Array.isArray(facts?.fallbackRules) ? facts.fallbackRules : [];
+  const autoSelectRules = Array.isArray(facts?.autoSelectRules) ? facts.autoSelectRules : [];
+  const entriesById = new Map(entries.map((entry) => [entry.id, entry]));
+
+  const missingAliasTargets = entries.filter((entry) => entry.aliasOf && !entriesById.has(entry.aliasOf));
+  for (const entry of missingAliasTargets) {
+    errors.push(
+      `[KernelPathContract] registry entry "${entry.id}" aliases missing target "${entry.aliasOf}".`
+    );
+  }
+  checks.push({
+    id: `${registryId}.aliasTargets`,
+    ok: missingAliasTargets.length === 0,
+  });
+
+  const aliasCycles = findAliasCycles(entriesById);
+  for (const cycle of aliasCycles) {
+    errors.push(`[KernelPathContract] alias cycle detected: ${cycle.join(' -> ')}.`);
+  }
+  checks.push({
+    id: `${registryId}.aliasCycles`,
+    ok: aliasCycles.length === 0,
+  });
+
+  let fallbackTargetErrors = 0;
+  let fallbackDtypeErrors = 0;
+  for (const mapping of fallbackMappings) {
+    if (!entriesById.has(mapping.primaryKernelPathId)) {
+      fallbackTargetErrors += 1;
+      errors.push(
+        `[KernelPathContract] finiteness fallback mapping references unknown primary kernel path ` +
+        `"${mapping.primaryKernelPathId}".`
+      );
+      continue;
+    }
+    if (!entriesById.has(mapping.fallbackKernelPathId) || mapping.fallbackActivationDtype == null) {
+      fallbackTargetErrors += 1;
+      errors.push(
+        `[KernelPathContract] finiteness fallback mapping references unknown fallback kernel path ` +
+        `"${mapping.fallbackKernelPathId}" for "${mapping.primaryKernelPathId}".`
+      );
+      continue;
+    }
+    if (DTYPE_RANK[mapping.fallbackActivationDtype] < DTYPE_RANK[mapping.primaryActivationDtype]) {
+      fallbackDtypeErrors += 1;
+      errors.push(
+        `[KernelPathContract] finiteness fallback "${mapping.primaryKernelPathId}" -> ` +
+        `"${mapping.fallbackKernelPathId}" narrows activation dtype ` +
+        `${mapping.primaryActivationDtype} -> ${mapping.fallbackActivationDtype}.`
+      );
+      continue;
+    }
+    if (DTYPE_BYTES[mapping.fallbackActivationDtype] < DTYPE_BYTES[mapping.primaryActivationDtype]) {
+      fallbackDtypeErrors += 1;
+      errors.push(
+        `[KernelPathContract] finiteness fallback "${mapping.primaryKernelPathId}" -> ` +
+        `"${mapping.fallbackKernelPathId}" reduces bytes per element ` +
+        `${mapping.primaryActivationDtype} -> ${mapping.fallbackActivationDtype}.`
+      );
+    }
+  }
+
+  checks.push({
+    id: `${registryId}.finitenessFallbackTargets`,
+    ok: fallbackTargetErrors === 0,
+  });
+  checks.push({
+    id: `${registryId}.finitenessFallbackDtypes`,
+    ok: fallbackDtypeErrors === 0,
+  });
+
+  let fallbackRuleShapeErrors = 0;
+  let fallbackRuleCoverageErrors = 0;
+  let fallbackRuleTargetErrors = 0;
+  if (fallbackRules.length > 0) {
+    const defaultRules = fallbackRules.filter((rule) => rule.isDefault);
+    if (defaultRules.length !== 1 || defaultRules[0].value !== null || fallbackRules[fallbackRules.length - 1] !== defaultRules[0]) {
+      fallbackRuleShapeErrors += 1;
+      errors.push(
+        '[KernelPathContract] finiteness fallback rules must end with exactly one default `{ match: {}, value: null }` rule.'
+      );
+    }
+    const seenRuleIds = new Set();
+    for (const rule of fallbackRules) {
+      if (rule.isDefault) continue;
+      if (!rule.matchKernelPathId) {
+        fallbackRuleShapeErrors += 1;
+        errors.push('[KernelPathContract] non-default finiteness fallback rules must match on kernelPathId.');
+        continue;
+      }
+      if (seenRuleIds.has(rule.matchKernelPathId)) {
+        fallbackRuleShapeErrors += 1;
+        errors.push(
+          `[KernelPathContract] duplicate finiteness fallback rule for "${rule.matchKernelPathId}".`
+        );
+      }
+      seenRuleIds.add(rule.matchKernelPathId);
+      if (!entriesById.has(rule.matchKernelPathId)) {
+        fallbackRuleTargetErrors += 1;
+        errors.push(
+          `[KernelPathContract] finiteness fallback rule references unknown primary kernel path "${rule.matchKernelPathId}".`
+        );
+      }
+      if (rule.value != null && !entriesById.has(rule.value)) {
+        fallbackRuleTargetErrors += 1;
+        errors.push(
+          `[KernelPathContract] finiteness fallback rule references unknown fallback kernel path "${rule.value}" for "${rule.matchKernelPathId}".`
+        );
+      }
+    }
+    for (const entry of entries) {
+      const selected = selectByRules(
+        fallbackRules.map((rule) => ({
+          match: rule.isDefault ? {} : { kernelPathId: rule.matchKernelPathId },
+          value: rule.value,
+        })),
+        { kernelPathId: entry.id }
+      );
+      if (!(selected === null || (typeof selected === 'string' && selected.length > 0))) {
+        fallbackRuleCoverageErrors += 1;
+        errors.push(
+          `[KernelPathContract] finiteness fallback rules did not yield a valid result for "${entry.id}".`
+        );
+      }
+    }
+  }
+  checks.push({
+    id: `${registryId}.finitenessFallbackRuleShape`,
+    ok: fallbackRuleShapeErrors === 0,
+  });
+  checks.push({
+    id: `${registryId}.finitenessFallbackRuleTargets`,
+    ok: fallbackRuleTargetErrors === 0,
+  });
+  checks.push({
+    id: `${registryId}.finitenessFallbackRuleCoverage`,
+    ok: fallbackRuleCoverageErrors === 0,
+  });
+
+  let autoSelectShapeErrors = 0;
+  let autoSelectTargetErrors = 0;
+  let autoSelectCoverageErrors = 0;
+  if (autoSelectRules.length > 0) {
+    const defaultRules = autoSelectRules.filter((rule) => rule.isDefault);
+    if (
+      defaultRules.length !== 1
+      || defaultRules[0].valueKind !== 'context'
+      || defaultRules[0].value !== 'kernelPathRef'
+      || autoSelectRules[autoSelectRules.length - 1] !== defaultRules[0]
+    ) {
+      autoSelectShapeErrors += 1;
+      errors.push(
+        '[KernelPathContract] autoSelect rules must end with exactly one default `{ match: {}, value: { context: "kernelPathRef" } }` rule.'
+      );
+    }
+    for (const rule of autoSelectRules) {
+      if (rule.isDefault) continue;
+      if (rule.allowCapabilityAutoSelection !== true) {
+        autoSelectShapeErrors += 1;
+        errors.push('[KernelPathContract] non-default autoSelect rules must require allowCapabilityAutoSelection=true.');
+      }
+      if (!rule.matchKernelPathRef) {
+        autoSelectShapeErrors += 1;
+        errors.push('[KernelPathContract] non-default autoSelect rules must match on kernelPathRef.');
+      }
+      if (rule.hasSubgroups == null) {
+        autoSelectShapeErrors += 1;
+        errors.push('[KernelPathContract] non-default autoSelect rules must match on hasSubgroups.');
+      }
+      if (rule.valueKind === 'context') {
+        autoSelectShapeErrors += 1;
+        errors.push('[KernelPathContract] only the default autoSelect rule may use a context directive.');
+      }
+      if (rule.matchKernelPathRef && !entriesById.has(rule.matchKernelPathRef)) {
+        autoSelectTargetErrors += 1;
+        errors.push(
+          `[KernelPathContract] autoSelect rule references unknown kernelPathRef "${rule.matchKernelPathRef}".`
+        );
+      }
+      if (rule.valueKind === 'string' && !entriesById.has(rule.value)) {
+        autoSelectTargetErrors += 1;
+        errors.push(
+          `[KernelPathContract] autoSelect rule remaps to unknown kernel path "${rule.value}".`
+        );
+      }
+    }
+    const resolvedAutoSelectRules = autoSelectRules.map((rule) => ({
+      match: rule.isDefault
+        ? {}
+        : {
+            allowCapabilityAutoSelection: rule.allowCapabilityAutoSelection,
+            hasSubgroups: rule.hasSubgroups,
+            kernelPathRef: rule.matchKernelPathRef,
+          },
+      value: rule.valueKind === 'context'
+        ? { context: rule.value }
+        : rule.value,
+    }));
+    for (const entry of entries) {
+      for (const allowCapabilityAutoSelection of [true, false]) {
+        for (const hasSubgroups of [true, false]) {
+          const selected = selectByRules(resolvedAutoSelectRules, {
+            kernelPathRef: entry.id,
+            allowCapabilityAutoSelection,
+            hasSubgroups,
+          });
+          const resolved = isPlainObject(selected) && selected.context === 'kernelPathRef'
+            ? entry.id
+            : selected;
+          if (typeof resolved !== 'string' || !resolved.length || !entriesById.has(resolved)) {
+            autoSelectCoverageErrors += 1;
+            errors.push(
+              `[KernelPathContract] autoSelect rules did not yield a valid kernel path for ` +
+              `"${entry.id}" (allowCapabilityAutoSelection=${allowCapabilityAutoSelection}, hasSubgroups=${hasSubgroups}).`
+            );
+            break;
+          }
+        }
+      }
+    }
+  }
+  checks.push({
+    id: `${registryId}.autoSelectRuleShape`,
+    ok: autoSelectShapeErrors === 0,
+  });
+  checks.push({
+    id: `${registryId}.autoSelectRuleTargets`,
+    ok: autoSelectTargetErrors === 0,
+  });
+  checks.push({
+    id: `${registryId}.autoSelectRuleCoverage`,
+    ok: autoSelectCoverageErrors === 0,
+  });
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    checks,
+  };
+}
+
+export function buildKernelPathContractArtifact(input, options = {}) {
+  const facts = extractKernelPathContractFacts(input, options);
+  const evaluation = validateKernelPathContractFacts(facts);
+  const aliasEntries = facts.entries.filter((entry) => entry.aliasOf != null).length;
+
+  return {
+    schemaVersion: 1,
+    source: 'doppler',
+    ok: evaluation.ok,
+    checks: evaluation.checks,
+    errors: evaluation.errors,
+    stats: {
+      totalEntries: facts.entries.length,
+      aliasEntries,
+      canonicalEntries: facts.entries.length - aliasEntries,
+      fallbackMappings: facts.fallbackMappings.length,
+      fallbackRules: facts.fallbackRules?.length ?? 0,
+      autoSelectRules: facts.autoSelectRules?.length ?? 0,
+    },
+  };
+}

package/src/config/kernel-path-loader.d.ts

@@ -22,6 +22,22 @@ export function getKernelPath(id: string): KernelPathSchema | null;
  */
 export function listKernelPaths(): string[];
 
+export function getKernelPathContractArtifact(): {
+  schemaVersion: 1;
+  source: 'doppler';
+  ok: boolean;
+  checks: Array<{ id: string; ok: boolean }>;
+  errors: string[];
+  stats: {
+    totalEntries: number;
+    aliasEntries: number;
+    canonicalEntries: number;
+    fallbackMappings: number;
+    fallbackRules: number;
+    autoSelectRules: number;
+  };
+};
+
 /**
  * Resolve a kernel path reference to a full schema.
  */

package/src/config/kernel-path-loader.js

@@ -1,6 +1,8 @@
 import { DEFAULT_ENTRY } from './schema/kernel-path.schema.js';
 import { KERNEL_CONFIGS } from '../gpu/kernels/utils.js';
+import { selectByRules } from '../gpu/kernels/rule-matcher.js';
 import { loadJson } from '../utils/load-json.js';
+import { buildKernelPathContractArtifact } from './kernel-path-contract-check.js';
 
 // =============================================================================
 // Built-in Kernel Paths (imported at build time)
@@ -77,6 +79,11 @@ const KERNEL_PATH_REGISTRY_INDEX = new Map(
 );
 
 const KERNEL_PATH_REGISTRY = Object.create(null);
+const KERNEL_PATH_RULES = await loadJson(
+  '../rules/inference/kernel-path.rules.json',
+  import.meta.url,
+  'Failed to load kernel path rules'
+);
 
 const resolveKernelPathConfig = (id, chain = new Set()) => {
   if (KERNEL_PATH_REGISTRY[id] !== undefined) {
@@ -117,6 +124,42 @@ for (const entry of KERNEL_PATH_REGISTRY_ENTRIES) {
   resolveKernelPathConfig(entry.id);
 }
 
+const KERNEL_PATH_FINITENESS_FALLBACK_MAPPINGS = KERNEL_PATH_REGISTRY_ENTRIES
+  .map((entry) => {
+    const fallbackKernelPathId = selectByRules(
+      Array.isArray(KERNEL_PATH_RULES?.finitenessFallback) ? KERNEL_PATH_RULES.finitenessFallback : [],
+      { kernelPathId: entry.id }
+    );
+    if (typeof fallbackKernelPathId !== 'string' || fallbackKernelPathId.length === 0) {
+      return null;
+    }
+    return {
+      primaryKernelPathId: entry.id,
+      fallbackKernelPathId,
+      primaryActivationDtype: KERNEL_PATH_REGISTRY[entry.id]?.activationDtype ?? null,
+      fallbackActivationDtype: KERNEL_PATH_REGISTRY[fallbackKernelPathId]?.activationDtype ?? null,
+    };
+  })
+  .filter(Boolean);
+
+const KERNEL_PATH_CONTRACT_ARTIFACT = buildKernelPathContractArtifact(
+  {
+    registryId: 'builtin-kernel-paths',
+    entries: KERNEL_PATH_REGISTRY_ENTRIES,
+    fallbackMappings: KERNEL_PATH_FINITENESS_FALLBACK_MAPPINGS,
+    fallbackRules: Array.isArray(KERNEL_PATH_RULES?.finitenessFallback)
+      ? KERNEL_PATH_RULES.finitenessFallback
+      : [],
+    autoSelectRules: Array.isArray(KERNEL_PATH_RULES?.autoSelect)
+      ? KERNEL_PATH_RULES.autoSelect
+      : [],
+  }
+);
+
+if (!KERNEL_PATH_CONTRACT_ARTIFACT.ok) {
+  throw new Error(KERNEL_PATH_CONTRACT_ARTIFACT.errors[0]);
+}
+
 // =============================================================================
 // Public API
 // =============================================================================
@@ -129,6 +172,17 @@ export function listKernelPaths() {
   return Object.keys(KERNEL_PATH_REGISTRY);
 }
 
+export function getKernelPathContractArtifact() {
+  return {
+    schemaVersion: KERNEL_PATH_CONTRACT_ARTIFACT.schemaVersion,
+    source: KERNEL_PATH_CONTRACT_ARTIFACT.source,
+    ok: KERNEL_PATH_CONTRACT_ARTIFACT.ok,
+    checks: KERNEL_PATH_CONTRACT_ARTIFACT.checks.map((entry) => ({ ...entry })),
+    errors: [...KERNEL_PATH_CONTRACT_ARTIFACT.errors],
+    stats: { ...KERNEL_PATH_CONTRACT_ARTIFACT.stats },
+  };
+}
+
 export function resolveKernelPath(ref) {
   if (typeof ref === 'string') {
     const path = getKernelPath(ref);

package/src/config/kernels/kernel-ref-digests.js

@@ -57,6 +57,8 @@ export const KERNEL_REF_CONTENT_DIGESTS = Object.freeze({
   "conv2d_f16.wgsl#main": "aa139e9f0270873acbc1c4b3cbacff4d224cae7247b520ec129a4f068eb6ed59",
   "conv2d.wgsl#main": "484a676692d2b8097daeefe42e2296a1f8b3ef11abfd7b41df6cdcdf16b7a8fd",
   "cross_entropy_loss.wgsl#main": "5a48087bdec94184432c90ce5b345e1eadbdfcb13b9793ecee8052bc7392239c",
+  "depthwise_conv2d_f16.wgsl#main": "d5d8d195b1449e39715340af4a0759da4b44b54f6a3cfbdfa6abe743b0f1d002",
+  "depthwise_conv2d.wgsl#main": "e5da160f505e18508619b78ba30f9bde0c84689a166df06cb59ef0e6591c6faf",
   "dequant_f16_out_vec4.wgsl#main_vec4": "61c20e6c71c1c8421b4ec202dbd26292a6300587bd44c314f2a6c6d9d9442c3a",
   "dequant_f16_out.wgsl#main": "94d61843d56f9a3bbc6b7c2b95dc6ecbba3f6a262b2c4086a076f69a8c38ccae",
   "dequant_f16_rowwise.wgsl#main": "f5bf7cef950b52d65cee6121dbaa176244d3221045b3b6386b3be47f23ce17dc",
@@ -116,6 +118,8 @@ export const KERNEL_REF_CONTENT_DIGESTS = Object.freeze({
   "gelu.wgsl#main": "a9007ea08aaff98f9be08f1e0490a6bcf252883eac5513de876ab9ce918865e6",
   "gptoss_mxfp4_expert_fused.wgsl#main_expert": "3159e8cd81da13f909cf905e6d35307fefe1dcbbdf1b2b8e8ff0ce923bd71180",
   "gptoss_router_topk.wgsl#softmax_topk": "86e4ea709c0c0084d09c6a4cd07710dc14f380e03f91b8ed9ec871b310be49f1",
+  "grouped_pointwise_conv2d_f16.wgsl#main": "11bcaefc5929b2e3c1ba338ebea6a28d2cac26553be8b00f51bfddbabf513be7",
+  "grouped_pointwise_conv2d.wgsl#main": "c0d5cdec0743b4ee337a8df95bda442e617c1678e3d1b6e20ec692d500ede50d",
   "groupnorm_apply_f16.wgsl#main": "cfd850b87944ac1c03ba7bd98136db556dadd8a70611e351d82d297299a7cd02",
   "groupnorm_apply.wgsl#main": "b09b8f2f57dcdfa1a0366daa30d3910feb134204652c711d2ba564e566b5a334",
   "groupnorm_stats_f16.wgsl#main": "fb76f78ce668ea8459110335698fe4b09a2425fc71deed3bab67efd7641c3199",
@@ -153,6 +157,10 @@ export const KERNEL_REF_CONTENT_DIGESTS = Object.freeze({
   "moe_offsets.wgsl#build_offsets": "3ea004145fa234659408cdeb0d4d802adff1037c9c5c03af146b3734cc69dd27",
   "pixel_shuffle_f16.wgsl#main": "57903a9c19cecc56371b2198402745127115680d266c3ce609201be9119aa359",
   "pixel_shuffle.wgsl#main": "845b88700b1b46d18cde6f2ec11bb89512c90d7e148763e74ce2a4173fd99b21",
+  "relu_f16.wgsl#main": "fc6134aabe43081b42ce8507d8f374092d0f2e03316aa42c25dd50229dc0ee40",
+  "relu.wgsl#main": "ca2c9bfa0acb9ece3b7e67de5209e00e553602b3917d23aca10338c1e6f01e27",
+  "repeat_channels_f16.wgsl#main": "e7e4d9164752e782d482db40256d0d86d96f784aa7debdb72faf3261b9bdd737",
+  "repeat_channels.wgsl#main": "ad0e34925c8c1173b9f0d92fa6e3808d039f82b3d9ad943b0a75b213ee1776e5",
   "residual_f16_vec4.wgsl#add_vec4": "30e9226fb6636e2f01e65b1dc8e93c8e849a87acec6215342fc114996da1ed41",
   "residual_f16.wgsl#main": "d392433f3065d1caf68b033219f4ffacf022dc1f90fc3cf3fd620e4ba49f3219",
   "residual_vec4.wgsl#add_vec4": "ef011d1683e62887db712da563e783d12fdc80c152955661137d2dca612d7d6a",
@@ -186,6 +194,10 @@ export const KERNEL_REF_CONTENT_DIGESTS = Object.freeze({
   "sample.wgsl#find_topk_phase2": "940b216e605d22096da5aca65950a8030866fc5a39e7fdf484d69a832de1b63a",
   "sample.wgsl#sample_single_pass": "4412357e84113ee2f1bc0dc8bf89e314c2ab482c89c14ca016ea9949d16a9d0c",
   "sample.wgsl#softmax_and_sample": "7172c60e76430fbe130e530e3564b569b45eccf193987b32d6f52bd6bbcc9f08",
+  "sana_linear_attention_apply_f16.wgsl#main": "e47366b94d40c4388e631b5bf93f8d61ef4e52cc65ffcd3b08d9d170616bb138",
+  "sana_linear_attention_apply.wgsl#main": "59cad7974c644fd910af776ad85a9a2c43c00492d4d1152fdc8373ecbb8bba18",
+  "sana_linear_attention_summary_f16.wgsl#main": "e3c040bb6469d37fc78eb22c1cc3e0456301607e461bbcdf5365a583c5d260d2",
+  "sana_linear_attention_summary.wgsl#main": "20c7ecdbcd1c73c0f9937c3cdac07b4b6edfe8618bf6f66281806343fd41b122",
   "scale.wgsl#main": "44ec481452b586307957163e3d65c9d02561d3f2f3db633f906f5488b1ea1ca4",
   "scale.wgsl#main_inplace": "020824c7118a59c461ce81f1c2cd01b7c2a3f1aab326392b7d48d4448a0c2ed1",
   "scatter_add_dynamic_f16_weights.wgsl#scatter_add_dynamic": "42799e745bc445b199b1cbc384bc12bb9372ed1599af3260a803cefc8dd35497",