@simulatte/doppler 0.1.6 → 0.1.8

package/src/client/doppler-provider/source-runtime.js

@@ -2,6 +2,7 @@ import {
   createConverterConfig,
   HEADER_READ_SIZE,
 } from '../../config/schema/index.js';
+import { DEFAULT_EXECUTION_V0_SESSION_DEFAULTS } from '../../config/schema/execution-v0.schema.js';
 import { extractArchitecture } from '../../converter/core.js';
 import {
   inferSourceWeightQuantization,
@@ -13,9 +14,11 @@ import { parseTransformerModel } from '../../converter/parsers/transformer.js';
 import { parseGGUFHeader } from '../../formats/gguf/types.js';
 import { parseSafetensorsHeader } from '../../formats/safetensors/types.js';
 import { log } from '../../debug/index.js';
+import { computeHash } from '../../storage/shard-manager.js';
 import {
   buildSourceRuntimeBundle,
   createSourceStorageContext,
+  getSourceRuntimeMetadata,
 } from '../../tooling/source-runtime-bundle.js';
 
 const SUPPORTED_SOURCE_DTYPES = new Set([
@@ -42,6 +45,15 @@ const SOURCE_RUNTIME_EXECUTION_OVERRIDE = {
   ],
 };
 
+const SOURCE_RUNTIME_SESSION_DEFAULTS = {
+  compute: {
+    defaults: { ...DEFAULT_EXECUTION_V0_SESSION_DEFAULTS.compute.defaults },
+    kernelProfiles: [],
+  },
+  kvcache: null,
+  decodeLoop: null,
+};
+
 function normalizeRelativePath(value) {
   return String(value || '')
     .replace(/\\/g, '/')
@@ -166,6 +178,14 @@ async function readBridgeRange(bridgeClient, fileEntry, offset, length) {
   return bridgeClient.read(fileEntry.absolutePath, offset, length);
 }
 
+async function readBridgeAllBytes(bridgeClient, fileEntry, label) {
+  const size = Number(fileEntry?.size) || 0;
+  if (size < 0) {
+    throw new Error(`Invalid bridge file size for ${label}.`);
+  }
+  return readBridgeRange(bridgeClient, fileEntry, 0, size);
+}
+
 async function readBridgeTextFile(bridgeClient, fileEntry, label) {
   const size = Number(fileEntry?.size) || 0;
   if (size <= 0) {
@@ -274,7 +294,39 @@ async function parseBridgeSafetensorsModel(bridgeClient, fileIndex) {
         }
         return { path, size: entry.size };
       }),
+    auxiliaryFiles: [
+      { path: 'config.json', size: Number(fileIndex.get('config.json')?.size || 0), kind: 'config' },
+      ...(fileIndex.has('model.safetensors.index.json')
+        ? [{
+          path: 'model.safetensors.index.json',
+          size: Number(fileIndex.get('model.safetensors.index.json')?.size || 0),
+          kind: 'safetensors_index',
+        }]
+        : []),
+      ...(fileIndex.has('tokenizer.json')
+        ? [{
+          path: 'tokenizer.json',
+          size: Number(fileIndex.get('tokenizer.json')?.size || 0),
+          kind: 'tokenizer_json',
+        }]
+        : []),
+      ...(fileIndex.has('tokenizer_config.json')
+        ? [{
+          path: 'tokenizer_config.json',
+          size: Number(fileIndex.get('tokenizer_config.json')?.size || 0),
+          kind: 'tokenizer_config',
+        }]
+        : []),
+      ...(fileIndex.has('tokenizer.model')
+        ? [{
+          path: 'tokenizer.model',
+          size: Number(fileIndex.get('tokenizer.model')?.size || 0),
+          kind: 'tokenizer_model',
+        }]
+        : []),
+    ],
     tokenizerJsonPath: fileIndex.has('tokenizer.json') ? 'tokenizer.json' : null,
+    tokenizerConfigPath: fileIndex.has('tokenizer_config.json') ? 'tokenizer_config.json' : null,
     tokenizerModelPath: fileIndex.has('tokenizer.model') ? 'tokenizer.model' : null,
   };
 }
@@ -339,7 +391,9 @@ async function parseBridgeGGUFModel(bridgeClient, fileIndex, ggufRelativePath) {
     tokenizerConfig: null,
     tokenizerModelName: null,
     sourceFiles: [{ path: ggufRelativePath, size: ggufEntry.size }],
+    auxiliaryFiles: [],
     tokenizerJsonPath: null,
+    tokenizerConfigPath: null,
     tokenizerModelPath: null,
   };
 }
@@ -391,14 +445,7 @@ function createBridgeFileReaders(bridgeClient, fileMap, rootPath) {
       return null;
     }
     const direct = map.get(hint);
-    if (direct) {
-      return direct;
-    }
-    const basename = hint.split('/').pop();
-    if (basename && map.has(basename)) {
-      return map.get(basename);
-    }
-    return null;
+    return direct || null;
   };
 
   const readRange = async (relativePath, offset, length) => {
@@ -432,10 +479,53 @@ function createBridgeFileReaders(bridgeClient, fileMap, rootPath) {
   };
 }
 
+async function addHashesToBridgeFiles(bridgeClient, fileIndex, entries, hashAlgorithm) {
+  const hashedEntries = [];
+  for (const entry of Array.isArray(entries) ? entries : []) {
+    const relativePath = normalizeRelativePath(entry?.path);
+    if (!relativePath) continue;
+    const fileEntry = fileIndex.get(relativePath);
+    if (!fileEntry) {
+      throw new Error(`Missing bridge file entry for "${relativePath}"`);
+    }
+    const bytes = await readBridgeAllBytes(bridgeClient, fileEntry, `bridge source asset (${relativePath})`);
+    hashedEntries.push({
+      ...entry,
+      path: relativePath,
+      size: Number.isFinite(entry?.size) ? Math.max(0, Math.floor(Number(entry.size))) : fileEntry.size,
+      hash: await computeHash(toUint8Array(bytes), hashAlgorithm),
+      hashAlgorithm,
+    });
+  }
+  return hashedEntries;
+}
+
+async function resolveBridgeStorageContext(options = {}) {
+  const bridgeClient = options.bridgeClient;
+  const localPath = options.localPath;
+  const manifest = options.manifest;
+  const sourceRuntime = getSourceRuntimeMetadata(manifest);
+  if (!sourceRuntime) {
+    return null;
+  }
+  const files = await listBridgeFilesRecursive(bridgeClient, localPath);
+  const fileMap = indexBridgeFiles(files);
+  const readers = createBridgeFileReaders(bridgeClient, fileMap, localPath);
+  return createSourceStorageContext({
+    manifest,
+    readRange: readers.readRange,
+    readText: readers.readText,
+    readBinary: readers.readBinary,
+    verifyHashes: options.verifyHashes !== false,
+  });
+}
+
 export async function resolveBridgeSourceRuntimeBundle(options = {}) {
   const bridgeClient = options.bridgeClient;
   const localPath = options.localPath;
   const requestedModelId = options.modelId || null;
+  const verifyHashes = options.verifyHashes !== false;
+  const existingManifest = options.manifest ?? null;
 
   if (!bridgeClient || typeof bridgeClient.read !== 'function' || typeof bridgeClient.list !== 'function') {
     throw new Error('Bridge source runtime requires a connected bridge client with read/list support.');
@@ -444,6 +534,21 @@ export async function resolveBridgeSourceRuntimeBundle(options = {}) {
     throw new Error('Bridge source runtime requires localPath.');
   }
 
+  if (existingManifest && getSourceRuntimeMetadata(existingManifest)) {
+    const storageContext = await resolveBridgeStorageContext({
+      bridgeClient,
+      localPath,
+      manifest: existingManifest,
+      verifyHashes,
+    });
+    return {
+      manifest: existingManifest,
+      storageContext,
+      sourceKind: getSourceRuntimeMetadata(existingManifest)?.sourceKind ?? 'safetensors',
+      sourceRoot: localPath,
+    };
+  }
+
   options.onProgress?.({
     stage: 'source-discovery',
     message: 'Scanning source files via bridge...',
@@ -461,6 +566,7 @@ export async function resolveBridgeSourceRuntimeBundle(options = {}) {
       modelBaseId: requestedModelId || null,
     },
     inference: {
+      sessionDefaults: SOURCE_RUNTIME_SESSION_DEFAULTS,
       execution: SOURCE_RUNTIME_EXECUTION_OVERRIDE,
     },
   });
@@ -476,26 +582,39 @@ export async function resolveBridgeSourceRuntimeBundle(options = {}) {
   });
 
   const modelId = resolveModelIdHint(requestedModelId, plan, parsed.sourceKind);
+  const hashAlgorithm = converterConfig.manifest.hashAlgorithm;
+  const files = await listBridgeFilesRecursive(bridgeClient, localPath);
+  const fileMap = indexBridgeFiles(files);
+  const sourceFiles = await addHashesToBridgeFiles(bridgeClient, fileMap, parsed.sourceFiles, hashAlgorithm);
+  const auxiliaryFiles = await addHashesToBridgeFiles(
+    bridgeClient,
+    fileMap,
+    parsed.auxiliaryFiles,
+    hashAlgorithm
+  );
   const { manifest, shardSources } = await buildSourceRuntimeBundle({
     modelId,
     modelName: modelId,
     modelType: plan.modelType,
+    sourceKind: parsed.sourceKind,
     architecture: parsed.architecture,
     architectureHint: parsed.architectureHint,
     rawConfig: parsed.config,
     inference: plan.manifestInference,
     tensors: parsed.tensors,
-    sourceFiles: parsed.sourceFiles,
+    sourceFiles,
+    auxiliaryFiles,
     sourceQuantization: parsed.sourceQuantization,
     quantizationInfo: plan.quantizationInfo,
-    hashAlgorithm: converterConfig.manifest.hashAlgorithm,
+    hashAlgorithm,
     tokenizerJson: parsed.tokenizerJson,
     tokenizerConfig: parsed.tokenizerConfig,
     tokenizerModelName: parsed.tokenizerModelName,
+    tokenizerJsonPath: parsed.tokenizerJsonPath,
+    tokenizerConfigPath: parsed.tokenizerConfigPath,
+    tokenizerModelPath: parsed.tokenizerModelPath,
   });
 
-  const files = await listBridgeFilesRecursive(bridgeClient, localPath);
-  const fileMap = indexBridgeFiles(files);
   const readers = createBridgeFileReaders(bridgeClient, fileMap, localPath);
   const storageContext = createSourceStorageContext({
     manifest,
@@ -505,7 +624,7 @@ export async function resolveBridgeSourceRuntimeBundle(options = {}) {
     readBinary: readers.readBinary,
     tokenizerJsonPath: parsed.tokenizerJsonPath,
     tokenizerModelPath: parsed.tokenizerModelPath,
-    verifyHashes: false,
+    verifyHashes,
   });
 
   log.info(

package/src/client/doppler-registry.json

@@ -1,13 +1,14 @@
 {
   "version": 1,
-  "source": "Clocksmith/rdrr",
+  "source": "models/catalog.json",
   "models": [
     {
-      "modelId": "gemma-3-270m-it-wq4k-ef16-hf16",
+      "modelId": "gemma-3-270m-it-q4k-ehf16-af32",
       "aliases": [
         "gemma3-270m",
         "google/gemma-3-270m-it",
         "gemma-3-270m-it-wq4k-ef16",
+        "gemma-3-270m-it-wq4k-ef16-hf16",
         "gemma-3-270m-it-wq4k-ef16-hf16-f32"
       ],
       "modes": [
@@ -15,24 +16,8 @@
       ],
       "hf": {
         "repoId": "Clocksmith/rdrr",
-        "revision": "4efe64a914892e98be50842aeb16c3b648cc68a5",
-        "path": "models/gemma-3-270m-it-wq4k-ef16"
-      }
-    },
-    {
-      "modelId": "google-embeddinggemma-300m-wq4k-ef16",
-      "aliases": [
-        "embeddinggemma-300m",
-        "google/embeddinggemma-300m",
-        "google-embeddinggemma-300m-wq4k-ef16"
-      ],
-      "modes": [
-        "embedding"
-      ],
-      "hf": {
-        "repoId": "Clocksmith/rdrr",
-        "revision": "4efe64a914892e98be50842aeb16c3b648cc68a5",
-        "path": "models/google-embeddinggemma-300m-wq4k-ef16"
+        "revision": "ca6f0dbdf3882d3893a65cf48f2bb6f1520df162",
+        "path": "models/gemma-3-270m-it-q4k-ehf16-af32"
       }
     }
   ]

package/src/config/backward-registry-loader.js

@@ -1,8 +1,23 @@
 import { loadJson } from '../utils/load-json.js';
 import { validateBackwardRegistry } from './schema/backward-registry.schema.js';
 
-const backwardRegistryData = await loadJson('./kernels/backward-registry.json', import.meta.url, 'Failed to load json');
+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);
+}
+
+const backwardRegistryData = deepFreeze(
+  validateBackwardRegistry(
+    await loadJson('./kernels/backward-registry.json', import.meta.url, 'Failed to load json')
+  )
+);
 
 export function loadBackwardRegistry() {
-  return validateBackwardRegistry(backwardRegistryData);
+  return backwardRegistryData;
 }

package/src/config/execution-v0-contract-check.js

@@ -1,8 +1,4 @@
-import {
-  DEFAULT_EXECUTION_V0_COMPUTE_DEFAULTS,
-  isExecutionV0Digest,
-  isExecutionV0Semver,
-} from './schema/execution-v0.schema.js';
+import { isExecutionV0Digest, isExecutionV0Semver } from './schema/execution-v0.schema.js';
 
 function normalizeDtype(value, label) {
   const normalized = String(value ?? '').trim().toLowerCase();
@@ -32,6 +28,107 @@ function assertExecutionV0KernelRef(kernelRef, label) {
   }
 }
 
+function requirePlainObject(value, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`[ExecutionV0Contract] ${label} must be an object.`);
+  }
+  return value;
+}
+
+function requireOwnProperty(root, key, label) {
+  if (!Object.prototype.hasOwnProperty.call(root, key)) {
+    throw new Error(`[ExecutionV0Contract] ${label} is required.`);
+  }
+  return root[key];
+}
+
+function requireNullableObject(root, key, label) {
+  const value = requireOwnProperty(root, key, label);
+  if (value === null) {
+    return null;
+  }
+  return requirePlainObject(value, label);
+}
+
+function requireArrayProperty(root, key, label) {
+  const value = requireOwnProperty(root, key, label);
+  if (!Array.isArray(value)) {
+    throw new Error(`[ExecutionV0Contract] ${label} must be an array.`);
+  }
+  return value;
+}
+
+function requireDtypeProperty(root, key, label) {
+  const value = requireOwnProperty(root, key, label);
+  if (value == null) {
+    throw new Error(`[ExecutionV0Contract] ${label} is required.`);
+  }
+  return normalizeDtype(value, label);
+}
+
+function validateExecutionV0SessionDefaults(sessionDefaults = {}) {
+  const normalizedSessionDefaults = requirePlainObject(
+    sessionDefaults,
+    'manifest.inference.sessionDefaults'
+  );
+  const compute = requirePlainObject(
+    requireOwnProperty(normalizedSessionDefaults, 'compute', 'sessionDefaults.compute'),
+    'sessionDefaults.compute'
+  );
+  const computeDefaults = requirePlainObject(
+    requireOwnProperty(compute, 'defaults', 'sessionDefaults.compute.defaults'),
+    'sessionDefaults.compute.defaults'
+  );
+
+  requireDtypeProperty(
+    computeDefaults,
+    'activationDtype',
+    'sessionDefaults.compute.defaults.activationDtype'
+  );
+  requireDtypeProperty(
+    computeDefaults,
+    'mathDtype',
+    'sessionDefaults.compute.defaults.mathDtype'
+  );
+  requireDtypeProperty(
+    computeDefaults,
+    'accumDtype',
+    'sessionDefaults.compute.defaults.accumDtype'
+  );
+  requireDtypeProperty(
+    computeDefaults,
+    'outputDtype',
+    'sessionDefaults.compute.defaults.outputDtype'
+  );
+
+  requireArrayProperty(
+    compute,
+    'kernelProfiles',
+    'sessionDefaults.compute.kernelProfiles'
+  );
+
+  const kvcache = requireNullableObject(
+    normalizedSessionDefaults,
+    'kvcache',
+    'sessionDefaults.kvcache'
+  );
+  if (kvcache !== null) {
+    requireDtypeProperty(
+      kvcache,
+      'kvDtype',
+      'sessionDefaults.kvcache.kvDtype'
+    );
+  }
+
+  requireNullableObject(
+    normalizedSessionDefaults,
+    'decodeLoop',
+    'sessionDefaults.decodeLoop'
+  );
+
+  return normalizedSessionDefaults;
+}
+
 function createPrecisionSources(step, profile) {
   return {
     inputDtype: step.precision?.inputDtype != null
@@ -89,10 +186,10 @@ export function resolveExecutionV0KernelProfile(profileIndex, step) {
 }
 
 export function resolveExecutionV0Precision(step, profile, sessionDefaults = {}) {
-  const defaults = {
-    ...DEFAULT_EXECUTION_V0_COMPUTE_DEFAULTS,
-    ...(sessionDefaults?.compute?.defaults ?? {}),
-  };
+  const defaults = requirePlainObject(
+    sessionDefaults?.compute?.defaults,
+    'sessionDefaults.compute.defaults'
+  );
   const precision = {
     inputDtype: step.precision?.inputDtype
       ?? profile?.precision?.inputDtype
@@ -132,12 +229,12 @@ export function resolveExecutionV0KVIO(step, profile, sessionDefaults = {}) {
       source: 'kernelProfile',
     };
   }
-  const defaults = {
-    ...DEFAULT_EXECUTION_V0_COMPUTE_DEFAULTS,
-    ...(sessionDefaults?.compute?.defaults ?? {}),
-  };
   const kvDtype = normalizeDtype(
-    sessionDefaults?.kvcache?.kvDtype ?? defaults.activationDtype,
+    requireOwnProperty(
+      requireNullableObject(sessionDefaults, 'kvcache', 'sessionDefaults.kvcache') ?? {},
+      'kvDtype',
+      'sessionDefaults.kvcache.kvDtype'
+    ),
     `${step.id}.sessionDefaults.kvcache.kvDtype`
   );
   return {
@@ -155,10 +252,11 @@ export function buildExecutionV0ContractArtifact(manifestInference, options = {}
   const checks = [];
   const errors = [];
   const perStep = {};
-  const sessionDefaults = manifestInference.sessionDefaults ?? {};
+  let sessionDefaults = manifestInference.sessionDefaults ?? {};
   let profileIndex;
 
   try {
+    sessionDefaults = validateExecutionV0SessionDefaults(sessionDefaults);
     profileIndex = indexExecutionV0KernelProfiles(sessionDefaults);
   } catch (error) {
     errors.push(error instanceof Error ? error.message : String(error));

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

@@ -36,6 +36,11 @@ function normalizeRegistryEntry(entry, index) {
     ? 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 not include both file and aliasOf.`
+    );
+  }
   if (!aliasOf && !hasFile) {
     throw new Error(
       `kernel-path contract: entries[${index}] must include file or aliasOf.`
@@ -111,12 +116,16 @@ function normalizeAutoSelectRule(rule, index) {
   const hasSubgroups = typeof match.hasSubgroups === 'boolean'
     ? match.hasSubgroups
     : null;
+  const hasF16 = typeof match.hasF16 === 'boolean'
+    ? match.hasF16
+    : null;
   const value = rule.value;
   if (typeof value === 'string' && value.trim() !== '') {
     return {
       matchKernelPathRef,
       allowCapabilityAutoSelection,
       hasSubgroups,
+      hasF16,
       valueKind: 'string',
       value: value.trim(),
       isDefault: Object.keys(match).length === 0,
@@ -127,6 +136,7 @@ function normalizeAutoSelectRule(rule, index) {
       matchKernelPathRef,
       allowCapabilityAutoSelection,
       hasSubgroups,
+      hasF16,
       valueKind: 'context',
       value: value.context.trim(),
       isDefault: Object.keys(match).length === 0,
@@ -380,9 +390,9 @@ export function validateKernelPathContractFacts(facts) {
         autoSelectShapeErrors += 1;
         errors.push('[KernelPathContract] non-default autoSelect rules must match on kernelPathRef.');
       }
-      if (rule.hasSubgroups == null) {
+      if (rule.hasSubgroups == null && rule.hasF16 == null) {
         autoSelectShapeErrors += 1;
-        errors.push('[KernelPathContract] non-default autoSelect rules must match on hasSubgroups.');
+        errors.push('[KernelPathContract] non-default autoSelect rules must match on hasSubgroups and/or hasF16.');
       }
       if (rule.valueKind === 'context') {
         autoSelectShapeErrors += 1;
@@ -401,36 +411,54 @@ export function validateKernelPathContractFacts(facts) {
         );
       }
     }
-    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,
-    }));
+    const resolvedAutoSelectRules = autoSelectRules.map((rule) => {
+      if (rule.isDefault) {
+        return {
+          match: {},
+          value: rule.valueKind === 'context'
+            ? { context: rule.value }
+            : rule.value,
+        };
+      }
+      const match = {
+        allowCapabilityAutoSelection: rule.allowCapabilityAutoSelection,
+        kernelPathRef: rule.matchKernelPathRef,
+      };
+      if (rule.hasSubgroups != null) {
+        match.hasSubgroups = rule.hasSubgroups;
+      }
+      if (rule.hasF16 != null) {
+        match.hasF16 = rule.hasF16;
+      }
+      return {
+        match,
+        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;
+          for (const hasF16 of [true, false]) {
+            const selected = selectByRules(resolvedAutoSelectRules, {
+              kernelPathRef: entry.id,
+              allowCapabilityAutoSelection,
+              hasSubgroups,
+              hasF16,
+            });
+            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}, hasF16=${hasF16}).`
+              );
+              break;
+            }
           }
         }
       }

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

@@ -134,6 +134,11 @@ export function getKernelPathStrict(): boolean;
  */
 export function isKernelPathFusedQ4K(path?: KernelPathSchema | null): boolean;
 
+/**
+ * Check if a kernel path requires matmul weights to stay in F32.
+ */
+export function kernelPathRequiresF32MatmulWeights(path?: KernelPathSchema | null): boolean;
+
 /**
  * Check if the active kernel path uses fused Q4K matmul.
  */