@simulatte/doppler 0.1.6 → 0.1.7

package/src/config/merge-helpers.js

@@ -15,9 +15,14 @@ export function chooseDefinedWithSource(path, overrideValue, fallbackValue, sour
 }
 
 export function mergeShallowObject(base, override) {
-  if (!override || typeof override !== 'object' || Array.isArray(override)) {
+  if (override === undefined) {
     return base;
   }
+  if (override === null || typeof override !== 'object' || Array.isArray(override)) {
+    throw new Error(
+      'DopplerConfigError: shallow object overrides must be plain objects when provided explicitly.'
+    );
+  }
   return { ...base, ...override };
 }
 
@@ -29,17 +34,133 @@ export function replaceSubtree(overrideValue, fallbackValue) {
   return chooseNullish(overrideValue, fallbackValue);
 }
 
+const DEFAULT_KERNEL_PATH_POLICY = Object.freeze({
+  mode: 'locked',
+  sourceScope: Object.freeze(['model', 'manifest']),
+  onIncompatible: 'error',
+});
+
+const VALID_KERNEL_PATH_POLICY_SOURCES = new Set([
+  'model',
+  'manifest',
+  'config',
+  'execution-v0',
+]);
+
+function normalizeKernelPathPolicyMode(value) {
+  if (value === undefined) {
+    return DEFAULT_KERNEL_PATH_POLICY.mode;
+  }
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === 'locked' || normalized === 'capability-aware') {
+    return normalized;
+  }
+  throw new Error(
+    `DopplerConfigError: runtime.inference.kernelPathPolicy.mode must be "locked" or "capability-aware"; got ${JSON.stringify(value)}.`
+  );
+}
+
+function normalizeKernelPathPolicySource(source) {
+  const normalized = String(source ?? '').trim().toLowerCase();
+  if (!normalized) {
+    throw new Error(
+      'DopplerConfigError: runtime.inference.kernelPathPolicy.sourceScope entries must be non-empty strings.'
+    );
+  }
+  if (normalized === 'runtime') {
+    throw new Error(
+      'DopplerConfigError: runtime.inference.kernelPathPolicy.sourceScope does not accept legacy "runtime". Use "config".'
+    );
+  }
+  if (normalized === 'execution_v0') {
+    throw new Error(
+      'DopplerConfigError: runtime.inference.kernelPathPolicy.sourceScope does not accept legacy "execution_v0". Use "execution-v0".'
+    );
+  }
+  if (!VALID_KERNEL_PATH_POLICY_SOURCES.has(normalized)) {
+    throw new Error(
+      `DopplerConfigError: runtime.inference.kernelPathPolicy.sourceScope entries must be model|manifest|config|execution-v0; got ${JSON.stringify(source)}.`
+    );
+  }
+  return normalized;
+}
+
+function normalizeKernelPathPolicySourceScope(value) {
+  if (value === undefined) {
+    return [...DEFAULT_KERNEL_PATH_POLICY.sourceScope];
+  }
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error(
+      'DopplerConfigError: runtime.inference.kernelPathPolicy.sourceScope must be a non-empty array.'
+    );
+  }
+  return [...new Set(value.map((source) => normalizeKernelPathPolicySource(source)))];
+}
+
+function normalizeKernelPathPolicyOnIncompatible(value) {
+  if (value === undefined) {
+    return DEFAULT_KERNEL_PATH_POLICY.onIncompatible;
+  }
+  const normalized = String(value).trim().toLowerCase();
+  if (normalized === 'error' || normalized === 'remap') {
+    return normalized;
+  }
+  throw new Error(
+    `DopplerConfigError: runtime.inference.kernelPathPolicy.onIncompatible must be "error" or "remap"; got ${JSON.stringify(value)}.`
+  );
+}
+
+function assertKernelPathPolicyObject(value, label) {
+  if (value === undefined) {
+    return;
+  }
+  if (value === null) {
+    throw new Error(`DopplerConfigError: ${label} must not be null.`);
+  }
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(
+      `DopplerConfigError: ${label} must be an object.`
+    );
+  }
+}
+
+function assertKernelPathPolicySourceAliasesCompatible(policy, label) {
+  if (!policy || policy.sourceScope === undefined || policy.allowSources === undefined) {
+    return;
+  }
+
+  const sourceScope = normalizeKernelPathPolicySourceScope(policy.sourceScope);
+  const allowSources = normalizeKernelPathPolicySourceScope(policy.allowSources);
+  const aliasesMatch = sourceScope.length === allowSources.length
+    && sourceScope.every((value, index) => value === allowSources[index]);
+
+  if (!aliasesMatch) {
+    throw new Error(
+      `DopplerConfigError: ${label}.sourceScope and ${label}.allowSources must match exactly when both are provided.`
+    );
+  }
+}
+
 export function mergeKernelPathPolicy(basePolicy, overridePolicy) {
+  assertKernelPathPolicyObject(basePolicy, 'runtime.inference.kernelPathPolicy');
+  assertKernelPathPolicyObject(overridePolicy, 'runtime.inference.kernelPathPolicy');
+  assertKernelPathPolicySourceAliasesCompatible(basePolicy, 'runtime.inference.kernelPathPolicy');
+  assertKernelPathPolicySourceAliasesCompatible(overridePolicy, 'runtime.inference.kernelPathPolicy');
   const base = basePolicy ?? {};
   const override = overridePolicy ?? {};
-  const baseSourceScope = base.sourceScope ?? base.allowSources;
-  const overrideSourceScope = override.sourceScope ?? override.allowSources;
-  const sourceScope = overrideSourceScope ?? baseSourceScope;
+  const sourceScope = normalizeKernelPathPolicySourceScope(
+    override.sourceScope
+    ?? override.allowSources
+    ?? base.sourceScope
+    ?? base.allowSources
+  );
   return {
-    mode: override.mode ?? base.mode,
+    mode: normalizeKernelPathPolicyMode(override.mode ?? base.mode),
     sourceScope,
-    allowSources: sourceScope,
-    onIncompatible: override.onIncompatible ?? base.onIncompatible,
+    allowSources: [...sourceScope],
+    onIncompatible: normalizeKernelPathPolicyOnIncompatible(
+      override.onIncompatible ?? base.onIncompatible
+    ),
   };
 }
 

package/src/config/merge.d.ts

@@ -54,6 +54,7 @@ export interface MergedInferenceConfig {
   ffn: ManifestFFNSchema;
   rope: ManifestRoPESchema;
   output: ManifestOutputSchema;
+  pipeline: ManifestInferenceSchema['pipeline'];
   layerPattern: ManifestLayerPatternSchema | null;
   chatTemplate: ManifestChatTemplateSchema;
   defaultKernelPath: string | null;

package/src/config/merge.js

@@ -333,12 +333,22 @@ export function mergeConfig(
     sources
   );
 
+  let pipeline = manifestInf.pipeline;
+  const runtimePipeline = runtimeOverrides?.pipeline;
+  if (runtimePipeline !== undefined) {
+    pipeline = runtimePipeline;
+    sources.set('inference.pipeline', 'runtime');
+  } else {
+    sources.set('inference.pipeline', 'manifest');
+  }
+
   const inference = {
     attention: mergeAttention(manifestInf.attention, runtimeOverrides?.attention, sources),
     normalization: mergeNormalization(manifestInf.normalization, runtimeOverrides?.normalization, sources),
     ffn: mergeFFN(manifestInf.ffn, runtimeOverrides?.ffn, sources),
     rope: mergeRoPE(manifestInf.rope, runtimeOverrides?.rope, sources),
     output: mergeOutput(manifestInf.output, runtimeOverrides?.output, sources),
+    pipeline,
     layerPattern,
     chatTemplate,
     defaultKernelPath,

package/src/config/param-validator.js

@@ -2,6 +2,7 @@ import { log } from '../debug/index.js';
 import { PARAM_CATEGORIES, CategoryRules } from './param-categories.js';
 import { TOOLING_INTENTS, TOOLING_DIAGNOSTICS } from './schema/tooling.schema.js';
 import { validateEcosystemConfig } from './schema/ecosystem.schema.js';
+import { isPlainObject } from '../utils/plain-object.js';
 
 export function validateCallTimeOptions(options) {
   if (!options) return;
@@ -33,7 +34,23 @@ export function validateCallTimeOptions(options) {
 }
 
 export function validateRuntimeOverrides(overrides) {
+  if (!isPlainObject(overrides)) {
+    throw new Error('DopplerConfigError: runtime overrides must be an object when provided.');
+  }
+
+  assertRequiredRuntimeOverrideNotNull(overrides, 'shared');
+  assertRequiredRuntimeOverrideNotNull(overrides, 'loading');
+  assertRequiredRuntimeOverrideNotNull(overrides, 'inference');
+  assertRequiredRuntimeOverrideNotNull(overrides, 'emulation');
+  assertRequiredRuntimeOverrideNotNull(overrides?.inference, 'batching', 'runtime.inference');
+  assertRequiredRuntimeOverrideNotNull(overrides?.inference, 'compute', 'runtime.inference');
+  assertRequiredRuntimeOverrideNotNull(overrides?.inference, 'generation', 'runtime.inference');
+  assertRequiredRuntimeOverrideNotNull(overrides?.inference, 'kernelPathPolicy', 'runtime.inference');
+
   const modelOverrides = overrides?.inference?.modelOverrides;
+  if (modelOverrides !== undefined && modelOverrides !== null && !isPlainObject(modelOverrides)) {
+    throw new Error('DopplerConfigError: runtime.inference.modelOverrides must be an object when provided.');
+  }
   if (!modelOverrides) return;
 
   const params = flattenObject(modelOverrides);
@@ -214,6 +231,15 @@ function validateKernelPathPolicy(label, value) {
   if (!value || typeof value !== 'object' || Array.isArray(value)) {
     throw new Error(`DopplerConfigError: ${label} must be an object.`);
   }
+  if (
+    value.sourceScope !== undefined
+    && value.allowSources !== undefined
+    && !arraysEqual(value.sourceScope, value.allowSources)
+  ) {
+    throw new Error(
+      `DopplerConfigError: ${label}.sourceScope and ${label}.allowSources must match exactly when both are provided.`
+    );
+  }
   if (value.mode !== 'locked' && value.mode !== 'capability-aware') {
     throw new Error(`DopplerConfigError: ${label}.mode must be "locked" or "capability-aware".`);
   }
@@ -224,12 +250,31 @@ function validateKernelPathPolicy(label, value) {
   if (value.onIncompatible !== 'error' && value.onIncompatible !== 'remap') {
     throw new Error(`DopplerConfigError: ${label}.onIncompatible must be "error" or "remap".`);
   }
-  const validSources = new Set(['model', 'manifest', 'config', 'runtime', 'execution-v0']);
+  const validSources = new Set(['model', 'manifest', 'config', 'execution-v0']);
   for (const source of sourceScope) {
     if (!validSources.has(source)) {
       throw new Error(
-        `DopplerConfigError: ${label}.sourceScope entries must be model|manifest|config|runtime|execution-v0.`
+        `DopplerConfigError: ${label}.sourceScope entries must be model|manifest|config|execution-v0.`
       );
     }
   }
 }
+
+function assertRequiredRuntimeOverrideNotNull(container, key, prefix = 'runtime') {
+  if (!isPlainObject(container) || !Object.prototype.hasOwnProperty.call(container, key)) {
+    return;
+  }
+  if (container[key] === null) {
+    throw new Error(`DopplerConfigError: ${prefix}.${key} must not be null.`);
+  }
+}
+
+function arraysEqual(left, right) {
+  if (!Array.isArray(left) || !Array.isArray(right)) {
+    return false;
+  }
+  if (left.length !== right.length) {
+    return false;
+  }
+  return left.every((value, index) => value === right[index]);
+}

package/src/config/presets/kernel-paths/{gemma2-q4k-dequant-f32a.json → gemma2-q4k-dequant-f32a-nosubgroups.json}

@@ -1,7 +1,7 @@
 {
-  "id": "gemma2-q4k-dequant-f32a",
-  "name": "Gemma 2 Q4K Dequant (F32 activations)",
-  "description": "Q4K weights dequantized to F16 with F32 activations. Non-fused compatibility path with no subgroup requirement.",
+  "id": "gemma2-q4k-dequant-f32a-nosubgroups",
+  "name": "Gemma 2 Q4K Dequant (F32 activations, no subgroups)",
+  "description": "Q4K weights dequantized to F16 with F32 activations. Non-fused path with no subgroup requirement that still requires shader-f16 kernels.",
   "activationDtype": "f32",
 
   "decode": {

package/src/config/presets/kernel-paths/gemma3-f16-fused-f32a-online-streamingprefill.json

@@ -0,0 +1,223 @@
+{
+    "id": "gemma3-f16-fused-f32a-online-streamingprefill",
+    "name": "Gemma 3 F16 (F32 activations, online, streaming prefill)",
+    "description": "F16 weights with F32 activations, online decode attention, and streaming prefill attention for Gemma 3 stability-sensitive runs.",
+    "activationDtype": "f32",
+    "kvDtype": "f16",
+    "decode": {
+        "steps": [
+            {
+                "op": "input_norm",
+                "kernel": "rmsnorm.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "q_proj",
+                "kernel": "matmul_gemv_subgroup.wgsl",
+                "entry": "main_vec4",
+                "weights": "layer.{L}.self_attn.q_proj"
+            },
+            {
+                "op": "k_proj",
+                "kernel": "matmul_gemv_subgroup.wgsl",
+                "entry": "main_vec4",
+                "weights": "layer.{L}.self_attn.k_proj"
+            },
+            {
+                "op": "v_proj",
+                "kernel": "matmul_gemv_subgroup.wgsl",
+                "entry": "main_vec4",
+                "weights": "layer.{L}.self_attn.v_proj"
+            },
+            {
+                "op": "rope_q",
+                "kernel": "rope.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "rope_k",
+                "kernel": "rope.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "attention",
+                "kernel": "attention_decode_online_f16kv.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "o_proj",
+                "kernel": "matmul_gemv_subgroup.wgsl",
+                "entry": "main_vec4",
+                "weights": "layer.{L}.self_attn.o_proj"
+            },
+            {
+                "op": "attn_residual",
+                "kernel": "residual.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "post_attn_norm",
+                "kernel": "rmsnorm.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "gate_proj",
+                "kernel": "matmul_gemv_subgroup.wgsl",
+                "entry": "main_vec4",
+                "weights": "layer.{L}.mlp.gate_proj"
+            },
+            {
+                "op": "up_proj",
+                "kernel": "matmul_gemv_subgroup.wgsl",
+                "entry": "main_vec4",
+                "weights": "layer.{L}.mlp.up_proj"
+            },
+            {
+                "op": "activation",
+                "kernel": "gelu.wgsl",
+                "entry": "main",
+                "constants": {
+                    "HAS_GATE": true
+                }
+            },
+            {
+                "op": "down_proj",
+                "kernel": "matmul_gemv_subgroup.wgsl",
+                "entry": "main_vec4",
+                "weights": "layer.{L}.mlp.down_proj"
+            },
+            {
+                "op": "ffn_residual",
+                "kernel": "residual.wgsl",
+                "entry": "main"
+            }
+        ]
+    },
+    "prefill": {
+        "steps": [
+            {
+                "op": "input_norm",
+                "kernel": "rmsnorm.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "q_proj",
+                "kernel": "matmul_f16w_f32a_tiled.wgsl",
+                "entry": "main",
+                "weights": "layer.{L}.self_attn.q_proj"
+            },
+            {
+                "op": "k_proj",
+                "kernel": "matmul_f16w_f32a_tiled.wgsl",
+                "entry": "main",
+                "weights": "layer.{L}.self_attn.k_proj"
+            },
+            {
+                "op": "v_proj",
+                "kernel": "matmul_f16w_f32a_tiled.wgsl",
+                "entry": "main",
+                "weights": "layer.{L}.self_attn.v_proj"
+            },
+            {
+                "op": "rope_q",
+                "kernel": "rope.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "rope_k",
+                "kernel": "rope.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "attention",
+                "kernel": "attention_streaming_f16kv.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "o_proj",
+                "kernel": "matmul_f16w_f32a_tiled.wgsl",
+                "entry": "main",
+                "weights": "layer.{L}.self_attn.o_proj"
+            },
+            {
+                "op": "attn_residual",
+                "kernel": "residual.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "post_attn_norm",
+                "kernel": "rmsnorm.wgsl",
+                "entry": "main"
+            },
+            {
+                "op": "gate_proj",
+                "kernel": "matmul_f16w_f32a_tiled.wgsl",
+                "entry": "main",
+                "weights": "layer.{L}.mlp.gate_proj"
+            },
+            {
+                "op": "up_proj",
+                "kernel": "matmul_f16w_f32a_tiled.wgsl",
+                "entry": "main",
+                "weights": "layer.{L}.mlp.up_proj"
+            },
+            {
+                "op": "activation",
+                "kernel": "gelu.wgsl",
+                "entry": "main",
+                "constants": {
+                    "HAS_GATE": true
+                }
+            },
+            {
+                "op": "down_proj",
+                "kernel": "matmul_f16w_f32a_tiled.wgsl",
+                "entry": "main",
+                "weights": "layer.{L}.mlp.down_proj"
+            },
+            {
+                "op": "ffn_residual",
+                "kernel": "residual.wgsl",
+                "entry": "main"
+            }
+        ]
+    },
+    "preLayer": [
+        {
+            "op": "embed",
+            "kernel": "gather.wgsl",
+            "entry": "main",
+            "weights": "embed_tokens"
+        }
+    ],
+    "postLayer": [
+        {
+            "op": "final_norm",
+            "kernel": "rmsnorm.wgsl",
+            "entry": "main"
+        },
+        {
+            "op": "lm_head",
+            "kernel": "matmul_gemv_subgroup.wgsl",
+            "entry": "main_multicol",
+            "weights": "lm_head",
+            "constants": {
+                "MULTICOL_COLS_PER_WG": 64,
+                "MULTICOL_THREADS_PER_COL": 4
+            }
+        },
+        {
+            "op": "lm_head_prefill",
+            "kernel": "matmul_f16w_f32a_tiled.wgsl",
+            "entry": "main",
+            "weights": "lm_head"
+        }
+    ],
+    "sampling": [
+        {
+            "op": "sample",
+            "kernel": "sample.wgsl",
+            "entry": "sample_single_pass"
+        }
+    ]
+}

package/src/config/presets/kernel-paths/{gemma3-q4k-dequant-f32a.json → gemma3-q4k-dequant-f32a-nosubgroups.json}

@@ -1,7 +1,7 @@
 {
-  "id": "gemma3-q4k-dequant-f32a",
-  "name": "Gemma 3 Q4K Dequant (F32 activations)",
-  "description": "Q4K weights dequantized to F16 with F32 activations for improved stability on small Gemma 3 checkpoints.",
+  "id": "gemma3-q4k-dequant-f32a-nosubgroups",
+  "name": "Gemma 3 Q4K Dequant (F32 activations, no subgroups)",
+  "description": "Q4K weights dequantized to F16 with F32 activations. Subgroup-free non-online path for Gemma 3 that still requires shader-f16 kernels.",
   "activationDtype": "f32",
   "kvDtype": "f16",
 

package/src/config/presets/kernel-paths/registry.json

@@ -16,11 +16,18 @@
       "notes": "Default Gemma 2 Q4K dequant path for baseline F16 activation workflows."
     },
     {
-      "id": "gemma2-q4k-dequant-f32a",
-      "file": "gemma2-q4k-dequant-f32a.json",
+      "id": "gemma2-q4k-dequant-f32a-nosubgroups",
+      "file": "gemma2-q4k-dequant-f32a-nosubgroups.json",
       "status": "canonical",
-      "statusReason": "compatibility",
-      "notes": "Subgroup-free Gemma 2 Q4K dequant path with F32 activations."
+      "statusReason": "subgroup-free",
+      "notes": "Subgroup-free Gemma 2 Q4K dequant path with F32 activations. Still requires shader-f16 kernels."
+    },
+    {
+      "id": "gemma2-q4k-dequant-f32a",
+      "aliasOf": "gemma2-q4k-dequant-f32a-nosubgroups",
+      "status": "legacy",
+      "statusReason": "compatibility-alias",
+      "notes": "Legacy alias for gemma2-q4k-dequant-f32a-nosubgroups."
     },
     {
       "id": "gemma2-f16-f16a",
@@ -50,6 +57,13 @@
       "statusReason": "benchmark-probe",
       "notes": "Experimental fused F32 pipeline variant for fast decode."
     },
+    {
+      "id": "gemma3-f16-fused-f32a-online-streamingprefill",
+      "file": "gemma3-f16-fused-f32a-online-streamingprefill.json",
+      "status": "experimental",
+      "statusReason": "stability-probe",
+      "notes": "Gemma 3 F16/F32 online path with streaming prefill attention instead of the small-tile prefill kernel."
+    },
     {
       "id": "gemma3-q4k-dequant-f16a-online",
       "file": "gemma3-q4k-dequant-f16a-online.json",
@@ -58,11 +72,18 @@
       "notes": "Experimental Gemma 3 Q4K path using online decode attention on subgroup-capable GPUs."
     },
     {
-      "id": "gemma3-q4k-dequant-f32a",
-      "file": "gemma3-q4k-dequant-f32a.json",
+      "id": "gemma3-q4k-dequant-f32a-nosubgroups",
+      "file": "gemma3-q4k-dequant-f32a-nosubgroups.json",
       "status": "canonical",
-      "statusReason": "accuracy-first",
-      "notes": "Gemma 3 Q4K dequant path with F32 activation for quality-first runs."
+      "statusReason": "subgroup-free",
+      "notes": "Subgroup-free Gemma 3 Q4K dequant path with F32 activations. Still requires shader-f16 kernels."
+    },
+    {
+      "id": "gemma3-q4k-dequant-f32a",
+      "aliasOf": "gemma3-q4k-dequant-f32a-nosubgroups",
+      "status": "legacy",
+      "statusReason": "compatibility-alias",
+      "notes": "Legacy alias for gemma3-q4k-dequant-f32a-nosubgroups."
     },
     {
       "id": "gemma3-q4k-dequant-f32a-online",

package/src/config/presets/models/gemma2.json

@@ -40,8 +40,8 @@
         "f32": "gemma2-f16-f32a"
       },
       "q4k": {
-        "f16": "gemma2-q4k-dequant-f32a",
-        "f32": "gemma2-q4k-dequant-f32a"
+        "f16": "gemma2-q4k-dequant-f32a-nosubgroups",
+        "f32": "gemma2-q4k-dequant-f32a-nosubgroups"
       }
     }
   },

package/src/config/presets/runtime/experiments/bench/gemma3-bench-q4k.json

@@ -6,7 +6,7 @@
   "owner": "doppler-core",
   "createdAtUtc": "2026-02-25T00:00:00Z",
   "extends": "modes/bench",
-  "model": "gemma-3-1b-it-wq4k-ef16-hf16",
+  "model": "gemma-3-1b-it-q4k-ehf16-af32",
   "runtime": {
     "shared": {
       "benchmark": {

package/src/config/presets/runtime/experiments/debug/gemma3-debug-q4k.json

@@ -7,7 +7,7 @@
   "owner": "doppler-core",
   "createdAtUtc": "2026-02-25T00:00:00Z",
   "extends": "default",
-  "model": "gemma-3-1b-it-wq4k-ef16-hf16",
+  "model": "gemma-3-1b-it-q4k-ehf16-af32",
   "runtime": {
     "shared": {
       "tooling": {

package/src/config/presets/runtime/experiments/verify/gemma3-verify.json

@@ -6,7 +6,7 @@
   "owner": "doppler-core",
   "createdAtUtc": "2026-02-25T00:00:00Z",
   "extends": "modes/bench",
-  "model": "gemma-3-1b-it-wf16-ef16-hf16",
+  "model": "gemma-3-1b-it-f16-af32",
   "runtime": {
     "shared": {
       "tooling": {

package/src/config/presets/runtime/kernels/dequant-f16-q4k.json

@@ -1,20 +1,13 @@
 {
   "id": "kernels/dequant-f16-q4k",
   "name": "dequant-f16-q4k",
-  "description": "Runtime alias preset for Gemma 2 Q4K dequant-to-F16 kernel path.",
+  "description": "Deprecated alias for kernels/gemma2-q4k-dequant-f16a.",
   "intent": "investigate",
-  "stability": "canonical",
+  "stability": "deprecated",
   "owner": "doppler-core",
   "createdAtUtc": "2026-02-25T00:00:00Z",
-  "extends": "default",
-  "runtime": {
-    "inference": {
-      "kernelPath": "gemma2-q4k-dequant-f16a",
-      "kernelPathPolicy": {
-        "mode": "capability-aware",
-        "sourceScope": ["config", "model", "manifest", "execution-v0"],
-        "onIncompatible": "remap"
-      }
-    }
-  }
+  "deprecatedAtUtc": "2026-03-08T00:00:00Z",
+  "replacementId": "kernels/gemma2-q4k-dequant-f16a",
+  "extends": "kernels/gemma2-q4k-dequant-f16a",
+  "runtime": {}
 }