@simulatte/doppler 0.1.6 → 0.1.7

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,12 +16,12 @@
       ],
       "hf": {
         "repoId": "Clocksmith/rdrr",
-        "revision": "4efe64a914892e98be50842aeb16c3b648cc68a5",
-        "path": "models/gemma-3-270m-it-wq4k-ef16"
+        "revision": "cd6c12be0e83e92d6dbd92598a0aa94391ec7e94",
+        "path": "models/gemma-3-270m-it-q4k-ehf16-af32"
       }
     },
     {
-      "modelId": "google-embeddinggemma-300m-wq4k-ef16",
+      "modelId": "google-embeddinggemma-300m-q4k-ehf16-af32",
       "aliases": [
         "embeddinggemma-300m",
         "google/embeddinggemma-300m",
@@ -31,8 +32,8 @@
       ],
       "hf": {
         "repoId": "Clocksmith/rdrr",
-        "revision": "4efe64a914892e98be50842aeb16c3b648cc68a5",
-        "path": "models/google-embeddinggemma-300m-wq4k-ef16"
+        "revision": "b23aca921ea11729d6f34b9484555968a5ab0e42",
+        "path": "models/google-embeddinggemma-300m-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.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() {

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",

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

@@ -161,8 +161,7 @@ export function detectPreset(
     }
   }
 
-  // Default to transformer
-  return 'transformer';
+  return null;
 }
 
 // =============================================================================
@@ -178,6 +177,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,35 @@ 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'
+  );
+
+  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 +289,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 +328,7 @@ export function buildMergeContractArtifact() {
       onIncompatible: 'error',
     },
     {
-      allowSources: ['runtime', 'execution-v0'],
+      allowSources: ['config', 'execution-v0'],
       onIncompatible: 'remap',
     }
   );
@@ -283,7 +338,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 +349,7 @@ export function buildMergeContractArtifact() {
     runtime: {
       inference: {
         kernelPathPolicy: {
-          allowSources: ['runtime', 'execution-v0'],
+          allowSources: ['config', 'execution-v0'],
         },
       },
     },
@@ -303,7 +358,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'