@simulatte/doppler 0.1.6 → 0.1.8

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

@@ -3,6 +3,7 @@ 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';
+import { mergeKernelPathPolicy } from './merge-helpers.js';
 
 // =============================================================================
 // Built-in Kernel Paths (imported at build time)
@@ -454,49 +455,17 @@ export function getKernelPathAttentionVariant(
 
 let activeKernelPath = null;
 let activeKernelPathSource = 'none';
-let activeKernelPathPolicy = {
+const DEFAULT_ACTIVE_KERNEL_PATH_POLICY = {
   mode: 'locked',
   sourceScope: ['model', 'manifest'],
   onIncompatible: 'error',
 };
+let activeKernelPathPolicy = DEFAULT_ACTIVE_KERNEL_PATH_POLICY;
 
-function normalizeKernelPathSource(source) {
-  const normalized = String(source ?? '').trim().toLowerCase();
-  if (normalized === 'runtime') return 'config';
-  if (normalized === 'execution_v0') return 'execution-v0';
-  return normalized;
-}
-
-function normalizeKernelPathPolicy(policy) {
-  if (!policy || typeof policy !== 'object' || Array.isArray(policy)) {
-    return {
-      mode: 'locked',
-      sourceScope: ['model', 'manifest'],
-      onIncompatible: 'error',
-    };
-  }
-  const mode = String(policy.mode ?? '').trim().toLowerCase() === 'capability-aware'
-    ? 'capability-aware'
-    : 'locked';
-  const sourceScope = Array.isArray(policy.sourceScope ?? policy.allowSources)
-    ? (policy.sourceScope ?? policy.allowSources)
-      .map((source) => normalizeKernelPathSource(source))
-      .filter((source) => source.length > 0)
-    : ['model', 'manifest'];
-  const onIncompatible = String(policy.onIncompatible ?? '').trim().toLowerCase() === 'remap'
-    ? 'remap'
-    : 'error';
-  return {
-    mode,
-    sourceScope: sourceScope.length > 0 ? [...new Set(sourceScope)] : ['model', 'manifest'],
-    onIncompatible,
-  };
-}
-
-export function setActiveKernelPath(path, source = 'none', policy = null) {
+export function setActiveKernelPath(path, source = 'none', policy = undefined) {
   activeKernelPath = path;
   activeKernelPathSource = path ? source : 'none';
-  activeKernelPathPolicy = normalizeKernelPathPolicy(policy);
+  activeKernelPathPolicy = mergeKernelPathPolicy(DEFAULT_ACTIVE_KERNEL_PATH_POLICY, policy);
 }
 
 export function getActiveKernelPath() {
@@ -534,6 +503,19 @@ export function isKernelPathFusedQ4K(path = undefined) {
   return kernelSteps.some((step) => step.kernel.includes('fused_matmul_q4'));
 }
 
+export function kernelPathRequiresF32MatmulWeights(path = undefined) {
+  const lookupPath = path === undefined ? activeKernelPath : path;
+  if (!lookupPath) return false;
+  const kernelSteps = [
+    ...(lookupPath.decode?.steps ?? []),
+    ...(lookupPath.prefill?.steps ?? []),
+    ...(lookupPath.preLayer ?? []),
+    ...(lookupPath.postLayer ?? []),
+    ...(lookupPath.layerOverrides?.flatMap((override) => override.steps) ?? []),
+  ];
+  return kernelSteps.some((step) => normalizeKernelFile(step.kernel) === 'matmul_f32.wgsl');
+}
+
 export function isActiveKernelPathFusedQ4K() {
   return isKernelPathFusedQ4K(activeKernelPath);
 }

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

@@ -220,7 +220,7 @@ export const KERNEL_REF_CONTENT_DIGESTS = Object.freeze({
   "topk.wgsl#main": "a18763303cd18e8a020e647f8a52f65403526849faf835d9f9394f634c3c97eb",
   "topk.wgsl#softmax_topk": "95ff3517da909e4bd4d0ff8d85b619bd250522943aeb9276375edc59f67e9604",
   "topk.wgsl#topk_2_small": "289eaa5c4f005e0aaf37dfe5343aeda30d9ab3929979dbf0cc3553f23e136807",
-  "transpose.wgsl#main": "002bce09c48b63ab5017d83f42233340011ac6fc20dae9cd08e3095ae5bf72b2",
+  "transpose.wgsl#main": "8caf8664dfc579b4e92edce50783263c535764006290cc7902108f26586113a2",
   "upsample2d_f16.wgsl#main": "43cee5f2503cb4b6caea45e9842f8961ce313b02eb8ed23a97d6967113ce521c",
   "upsample2d.wgsl#main": "6de9172ad3d6940dd3c94470a105755a33760e66a84d6e9e96ec4d6a07dc4a25"
 });

package/src/config/kernels/registry.js

@@ -4,6 +4,17 @@ let cachedRegistry = null;
 
 let registryUrl = null;
 
+function deepFreeze(value, seen = new WeakSet()) {
+  if (!value || typeof value !== 'object' || seen.has(value)) {
+    return value;
+  }
+  seen.add(value);
+  for (const entry of Object.values(value)) {
+    deepFreeze(entry, seen);
+  }
+  return Object.freeze(value);
+}
+
 export function setRegistryUrl(url) {
   registryUrl = url;
   cachedRegistry = null;
@@ -15,7 +26,9 @@ export async function getRegistry() {
   }
 
   const source = registryUrl || './registry.json';
-  cachedRegistry = await loadJson(source, import.meta.url, 'Failed to load kernel registry');
+  cachedRegistry = deepFreeze(
+    await loadJson(source, import.meta.url, 'Failed to load kernel registry')
+  );
   return cachedRegistry;
 }
 

package/src/config/kernels/registry.json

@@ -2174,7 +2174,7 @@
         }
       ],
       "baseUniforms": {
-        "size": 16,
+        "size": 32,
         "fields": [
           {
             "name": "M",
@@ -2202,7 +2202,9 @@
             1,
             1
           ],
-          "requires": []
+          "requires": [
+            "shader-f16"
+          ]
         },
         "f16": {
           "wgsl": "matmul_gemv_residual_f16.wgsl",
@@ -2377,12 +2379,12 @@
             "offset": 20
           },
           {
-            "name": "_pad0",
+            "name": "rotary_dim",
             "type": "u32",
             "offset": 24
           },
           {
-            "name": "_pad1",
+            "name": "interleaved",
             "type": "u32",
             "offset": 28
           }
@@ -4116,7 +4118,7 @@
         }
       ],
       "baseUniforms": {
-        "size": 16,
+        "size": 32,
         "fields": [
           {
             "name": "num_tokens",
@@ -4320,6 +4322,80 @@
         }
       }
     },
+    "split_qg": {
+      "description": "De-interleave Q and Gate projections from q_proj output for attentionOutputGate models",
+      "baseBindings": [
+        {
+          "index": 0,
+          "name": "uniforms",
+          "type": "uniform"
+        },
+        {
+          "index": 1,
+          "name": "qg_interleaved",
+          "type": "read-only-storage"
+        },
+        {
+          "index": 2,
+          "name": "Q",
+          "type": "storage"
+        },
+        {
+          "index": 3,
+          "name": "G",
+          "type": "storage"
+        }
+      ],
+      "baseUniforms": {
+        "size": 16,
+        "fields": [
+          {
+            "name": "num_tokens",
+            "type": "u32",
+            "offset": 0
+          },
+          {
+            "name": "num_heads",
+            "type": "u32",
+            "offset": 4
+          },
+          {
+            "name": "head_dim",
+            "type": "u32",
+            "offset": 8
+          },
+          {
+            "name": "_pad",
+            "type": "u32",
+            "offset": 12
+          }
+        ]
+      },
+      "variants": {
+        "default": {
+          "wgsl": "split_qg.wgsl",
+          "entryPoint": "main",
+          "workgroup": [
+            256,
+            1,
+            1
+          ],
+          "requires": []
+        },
+        "f16": {
+          "wgsl": "split_qg_f16.wgsl",
+          "entryPoint": "main",
+          "workgroup": [
+            256,
+            1,
+            1
+          ],
+          "requires": [
+            "shader-f16"
+          ]
+        }
+      }
+    },
     "sample": {
       "description": "GPU-side sampling kernels",
       "baseBindings": [

package/src/config/loader.d.ts

@@ -43,7 +43,7 @@ export function resolvePreset(id: string): PresetSchema;
 export function detectPreset(
   config: RawModelConfigSchema,
   architecture?: string
-): string;
+): string | null;
 
 /**
  * Build a fully resolved config by merging:

package/src/config/loader.js

@@ -23,6 +23,7 @@ const mambaPreset = await loadJson('./presets/models/mamba.json', import.meta.ur
 const modernbertPreset = await loadJson('./presets/models/modernbert.json', import.meta.url, 'Failed to load preset');
 const lfm2Preset = await loadJson('./presets/models/lfm2.json', import.meta.url, 'Failed to load preset');
 const qwen3Preset = await loadJson('./presets/models/qwen3.json', import.meta.url, 'Failed to load preset');
+const qwen35Preset = await loadJson('./presets/models/qwen3_5.json', import.meta.url, 'Failed to load preset');
 const kimiK2Preset = await loadJson('./presets/models/kimi-k2.json', import.meta.url, 'Failed to load preset');
 const gptOssPreset = await loadJson('./presets/models/gpt-oss.json', import.meta.url, 'Failed to load preset');
 
@@ -46,6 +47,7 @@ export const PRESET_REGISTRY = {
   modernbert: modernbertPreset,
   lfm2: lfm2Preset,
   qwen3: qwen3Preset,
+  qwen3_5: qwen35Preset,
   kimi_k2: kimiK2Preset,
   gpt_oss: gptOssPreset,
 };
@@ -97,6 +99,7 @@ export const PRESET_DETECTION_ORDER = [
   'gemma3',
   'llama3',
   'lfm2',
+  'qwen3_5',
   'qwen3',
   'kimi_k2',
   'gpt_oss',
@@ -161,8 +164,7 @@ export function detectPreset(
     }
   }
 
-  // Default to transformer
-  return 'transformer';
+  return null;
 }
 
 // =============================================================================
@@ -178,6 +180,17 @@ export function resolveConfig(
     (manifest.config || {}),
     manifest.modelType
   );
+  if (!id) {
+    const modelId = String(manifest?.modelId ?? 'unknown').trim() || 'unknown';
+    const modelType = String(manifest?.config?.model_type ?? 'unknown').trim() || 'unknown';
+    const architecture = String(manifest?.modelType ?? 'unknown').trim() || 'unknown';
+    throw createDopplerError(
+      ERROR_CODES.CONFIG_PRESET_UNKNOWN,
+      `Could not detect a preset for manifest "${modelId}" ` +
+      `(architecture="${architecture}", model_type="${modelType}"). ` +
+      'Provide an explicit presetId instead of relying on the generic transformer fallback.'
+    );
+  }
 
   // Get resolved preset
   const preset = resolvePreset(id);

package/src/config/merge-contract-check.js

@@ -77,6 +77,7 @@ function buildWitnessMergeManifest() {
         embeddingTranspose: false,
         embeddingVocabSize: 1024,
       },
+      pipeline: 'decode-only',
       layerPattern: null,
       chatTemplate: {
         type: 'gemma',
@@ -114,6 +115,13 @@ export function buildMergeContractArtifact() {
       && mergedUndefined._sources.get('inference.defaultKernelPath') === 'manifest',
     `value=${mergedUndefined.inference.defaultKernelPath}, source=${mergedUndefined._sources.get('inference.defaultKernelPath')}`
   );
+  recordCheck(
+    checks,
+    'runtime.mergeConfig.pipeline_preserves_manifest_value',
+    mergedUndefined.inference.pipeline === 'decode-only'
+      && mergedUndefined._sources.get('inference.pipeline') === 'manifest',
+    `value=${String(mergedUndefined.inference.pipeline)}, source=${mergedUndefined._sources.get('inference.pipeline')}`
+  );
 
   const mergedNull = mergeConfig(buildWitnessMergeManifest(), {
     defaultKernelPath: null,
@@ -152,6 +160,42 @@ export function buildMergeContractArtifact() {
     `value=${String(runtimeConfig.runtime.inference.chatTemplate.enabled)}`
   );
 
+  const isolatedConfigA = createDopplerConfig();
+  isolatedConfigA.runtime.inference.compute.activationDtype = 'f32';
+  const isolatedConfigB = createDopplerConfig();
+  recordCheck(
+    checks,
+    'runtime.schema.defaults_are_isolated_per_instance',
+    isolatedConfigB.runtime.inference.compute.activationDtype !== 'f32'
+      && isolatedConfigA.runtime.inference.compute !== isolatedConfigB.runtime.inference.compute,
+    `configA=${isolatedConfigA.runtime.inference.compute.activationDtype}, configB=${isolatedConfigB.runtime.inference.compute.activationDtype}`,
+    'actual'
+  );
+  recordCheck(
+    checks,
+    'runtime.schema.storage.opfs_sync_access_handle_defaults_off',
+    isolatedConfigB.runtime.loading.storage.backend.opfs.useSyncAccessHandle === false,
+    `value=${String(isolatedConfigB.runtime.loading.storage.backend.opfs.useSyncAccessHandle)}`,
+    'actual'
+  );
+
+  const calibrateConfig = createDopplerConfig({
+    runtime: {
+      shared: {
+        tooling: {
+          intent: 'calibrate',
+        },
+      },
+    },
+  });
+  recordCheck(
+    checks,
+    'runtime.schema.calibrate_does_not_mutate_kernel_warmup_defaults',
+    calibrateConfig.runtime.shared.kernelWarmup.prewarm === false,
+    `prewarm=${String(calibrateConfig.runtime.shared.kernelWarmup.prewarm)}`,
+    'actual'
+  );
+
   const overlaySources = new Map();
   const chosenRuntimeValue = chooseDefinedWithSource(
     'inference.defaultKernelPath',
@@ -252,6 +296,24 @@ export function buildMergeContractArtifact() {
     'actual'
   );
 
+  let invalidShallowOverrideError = null;
+  try {
+    mergeShallowObject(
+      { type: 'base', enabled: true },
+      null
+    );
+  } catch (error) {
+    invalidShallowOverrideError = error;
+  }
+  recordCheck(
+    checks,
+    'runtime.mergeShallowObject.invalid_explicit_override_fails_closed',
+    invalidShallowOverrideError instanceof Error
+      && /shallow object overrides must be plain objects/.test(invalidShallowOverrideError.message),
+    `error=${invalidShallowOverrideError?.message ?? 'none'}`,
+    'actual'
+  );
+
   const layeredAttention = mergeLayeredShallowObjects(
     { slidingWindow: 4096, attentionBias: false },
     { slidingWindow: 2048 },
@@ -273,7 +335,7 @@ export function buildMergeContractArtifact() {
       onIncompatible: 'error',
     },
     {
-      allowSources: ['runtime', 'execution-v0'],
+      allowSources: ['config', 'execution-v0'],
       onIncompatible: 'remap',
     }
   );
@@ -283,7 +345,7 @@ export function buildMergeContractArtifact() {
     Array.isArray(mergedKernelPathPolicy.sourceScope)
       && Array.isArray(mergedKernelPathPolicy.allowSources)
       && mergedKernelPathPolicy.sourceScope.length === 2
-      && mergedKernelPathPolicy.sourceScope[0] === 'runtime'
+      && mergedKernelPathPolicy.sourceScope[0] === 'config'
       && mergedKernelPathPolicy.allowSources[1] === 'execution-v0'
       && mergedKernelPathPolicy.onIncompatible === 'remap',
     `sourceScope=${JSON.stringify(mergedKernelPathPolicy.sourceScope)}, allowSources=${JSON.stringify(mergedKernelPathPolicy.allowSources)}`,
@@ -294,7 +356,7 @@ export function buildMergeContractArtifact() {
     runtime: {
       inference: {
         kernelPathPolicy: {
-          allowSources: ['runtime', 'execution-v0'],
+          allowSources: ['config', 'execution-v0'],
         },
       },
     },
@@ -303,7 +365,7 @@ export function buildMergeContractArtifact() {
     checks,
     'runtime.schema.kernelPathPolicy.helper_is_used',
     Array.isArray(runtimeConfigWithKernelPathPolicy.runtime.inference.kernelPathPolicy.sourceScope)
-      && runtimeConfigWithKernelPathPolicy.runtime.inference.kernelPathPolicy.sourceScope[0] === 'runtime'
+      && runtimeConfigWithKernelPathPolicy.runtime.inference.kernelPathPolicy.sourceScope[0] === 'config'
       && runtimeConfigWithKernelPathPolicy.runtime.inference.kernelPathPolicy.allowSources[1] === 'execution-v0',
     `policy=${JSON.stringify(runtimeConfigWithKernelPathPolicy.runtime.inference.kernelPathPolicy)}`,
     'actual'

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,