@simulatte/doppler 0.1.3 → 0.1.5

package/src/config/merge.js

@@ -1,3 +1,5 @@
+import { chooseDefined, chooseDefinedWithSource } from './merge-helpers.js';
+
 // =============================================================================
 // Merge Implementation
 // =============================================================================
@@ -8,12 +10,7 @@ function overlay(
   runtimeValue,
   sources
 ) {
-  if (runtimeValue !== undefined) {
-    sources.set(path, 'runtime');
-    return runtimeValue;
-  }
-  sources.set(path, 'manifest');
-  return manifestValue;
+  return chooseDefinedWithSource(path, runtimeValue, manifestValue, sources);
 }
 
 function mergeAttention(

package/src/config/presets/models/janus-text.json

@@ -0,0 +1,27 @@
+{
+  "id": "janus_text",
+  "name": "Janus Text Core",
+  "extends": "transformer",
+  "modelType": "transformer",
+
+  "inference": {
+    "normalization": {
+      "rmsNormEps": 1e-6
+    },
+    "rope": {
+      "ropeTheta": 10000
+    }
+  },
+
+  "tokenizer": {
+    "bosToken": "<｜begin▁of▁sentence｜>",
+    "eosTokens": ["<｜end▁of▁sentence｜>"],
+    "addBosToken": true,
+    "addEosToken": false
+  },
+
+  "detection": {
+    "architecturePatterns": ["JanusTextForCausalLM"],
+    "modelTypePatterns": ["janus_text"]
+  }
+}

package/src/config/quantization-contract-check.d.ts

@@ -0,0 +1,12 @@
+export interface QuantizationContractArtifact {
+  schemaVersion: 1;
+  source: 'doppler';
+  ok: boolean;
+  checks: Array<{ id: string; ok: boolean }>;
+  errors: string[];
+  stats: {
+    sampledSizes: number;
+  };
+}
+
+export declare function buildQuantizationContractArtifact(): QuantizationContractArtifact;

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

@@ -0,0 +1,91 @@
+import {
+  K_SCALE_SIZE,
+  Q4K_BLOCK_BYTES,
+  Q6K_BLOCK_BYTES,
+  Q8_0_BLOCK_BYTES,
+  Q8_0_BLOCK_SIZE,
+  QK4_K_BLOCK_SIZE,
+  QK_K,
+  padToQ4KBlock,
+  q4kBlockCount,
+} from './schema/quantization.schema.js';
+import {
+  TILE_SIZES,
+  QUANTIZATION,
+} from '../gpu/kernels/constants.js';
+import * as loaderQuantization from '../loader/quantization-constants.js';
+
+const EXPECTED_CONSTANTS = Object.freeze({
+  QK_K: 256,
+  Q4K_BLOCK_BYTES: 144,
+  Q6K_BLOCK_BYTES: 210,
+  Q8_0_BLOCK_BYTES: 34,
+  Q8_0_BLOCK_SIZE: 32,
+  K_SCALE_SIZE: 12,
+});
+
+export function buildQuantizationContractArtifact() {
+  const errors = [];
+  const checks = [];
+
+  const literalConstantsOk =
+    QK_K === EXPECTED_CONSTANTS.QK_K
+    && Q4K_BLOCK_BYTES === EXPECTED_CONSTANTS.Q4K_BLOCK_BYTES
+    && Q6K_BLOCK_BYTES === EXPECTED_CONSTANTS.Q6K_BLOCK_BYTES
+    && Q8_0_BLOCK_BYTES === EXPECTED_CONSTANTS.Q8_0_BLOCK_BYTES
+    && Q8_0_BLOCK_SIZE === EXPECTED_CONSTANTS.Q8_0_BLOCK_SIZE
+    && K_SCALE_SIZE === EXPECTED_CONSTANTS.K_SCALE_SIZE
+    && QK4_K_BLOCK_SIZE === Q4K_BLOCK_BYTES;
+  if (!literalConstantsOk) {
+    errors.push('[QuantizationContract] schema constants drifted from the expected Q4K/Q6K/Q8 values.');
+  }
+  checks.push({ id: 'quantization.constants.schema', ok: literalConstantsOk });
+
+  const crossModuleOk =
+    loaderQuantization.QK_K === QK_K
+    && loaderQuantization.Q4K_BLOCK_BYTES === Q4K_BLOCK_BYTES
+    && loaderQuantization.Q6K_BLOCK_BYTES === Q6K_BLOCK_BYTES
+    && loaderQuantization.Q8_0_BLOCK_BYTES === Q8_0_BLOCK_BYTES
+    && loaderQuantization.Q8_0_BLOCK_SIZE === Q8_0_BLOCK_SIZE
+    && TILE_SIZES.Q4K_SUPER_BLOCK_SIZE === QK_K
+    && QUANTIZATION.Q4K_BLOCK_BYTES === Q4K_BLOCK_BYTES;
+  if (!crossModuleOk) {
+    errors.push('[QuantizationContract] loader/GPU quantization constants drifted from schema constants.');
+  }
+  checks.push({ id: 'quantization.constants.crossModule', ok: crossModuleOk });
+
+  let padPropertiesOk = true;
+  let q4kCoverageOk = true;
+  let previous = -1;
+  for (let size = 0; size <= QK_K * 2 + 7; size += 1) {
+    const padded = padToQ4KBlock(size);
+    if (padded < size || padded % QK_K !== 0 || padToQ4KBlock(padded) !== padded || padded < previous) {
+      padPropertiesOk = false;
+      break;
+    }
+    previous = padded;
+    if (q4kBlockCount(size) * QK_K < size) {
+      q4kCoverageOk = false;
+      break;
+    }
+  }
+  if (!padPropertiesOk) {
+    errors.push('[QuantizationContract] padToQ4KBlock must be monotone, aligned, and idempotent.');
+  }
+  checks.push({ id: 'quantization.padToQ4KBlock.properties', ok: padPropertiesOk });
+  if (!q4kCoverageOk) {
+    errors.push('[QuantizationContract] q4kBlockCount must cover the requested element count.');
+  }
+  checks.push({ id: 'quantization.q4kBlockCount.coverage', ok: q4kCoverageOk });
+
+  return {
+    schemaVersion: 1,
+    source: 'doppler',
+    ok: errors.length === 0,
+    checks,
+    errors,
+    stats: {
+      sampledSizes: QK_K * 2 + 8,
+    },
+  };
+}

package/src/config/required-inference-fields-contract-check.d.ts

@@ -0,0 +1,24 @@
+export interface RequiredInferenceFieldsContractArtifact {
+  schemaVersion: 1;
+  source: 'doppler';
+  ok: boolean;
+  checks: Array<{ id: string; ok: boolean }>;
+  errors: string[];
+  stats: {
+    fieldCases: number;
+    nullableCases: number;
+    nonNullableCases: number;
+  };
+}
+
+export declare function buildRequiredInferenceFieldsContractArtifact(): RequiredInferenceFieldsContractArtifact;
+
+export interface ManifestRequiredInferenceFieldsArtifact extends RequiredInferenceFieldsContractArtifact {
+  scope: 'manifest';
+  label: string;
+}
+
+export declare function buildManifestRequiredInferenceFieldsArtifact(
+  inference: Record<string, unknown> | null | undefined,
+  label?: string
+): ManifestRequiredInferenceFieldsArtifact;

package/src/config/required-inference-fields-contract-check.js

@@ -0,0 +1,231 @@
+import { validateRequiredInferenceFields } from '../inference/pipelines/text/config.js';
+
+function cloneJson(value) {
+  if (typeof structuredClone === 'function') {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+
+function setPath(root, path, value) {
+  let current = root;
+  for (let i = 0; i < path.length - 1; i += 1) {
+    current = current[path[i]];
+  }
+  current[path[path.length - 1]] = value;
+}
+
+function deletePath(root, path) {
+  let current = root;
+  for (let i = 0; i < path.length - 1; i += 1) {
+    current = current[path[i]];
+  }
+  delete current[path[path.length - 1]];
+}
+
+function createValidInferenceFixture() {
+  return {
+    attention: {
+      queryPreAttnScalar: 256,
+      queryKeyNorm: true,
+      attentionBias: false,
+      causal: true,
+      slidingWindow: null,
+      attnLogitSoftcapping: null,
+    },
+    normalization: {
+      rmsNormWeightOffset: true,
+      rmsNormEps: 1e-6,
+      postAttentionNorm: true,
+      preFeedforwardNorm: true,
+      postFeedforwardNorm: true,
+    },
+    ffn: {
+      activation: 'gelu',
+      gatedActivation: true,
+      swigluLimit: null,
+    },
+    rope: {
+      ropeTheta: 1000000,
+      ropeScalingFactor: 1.0,
+      ropeScalingType: null,
+      ropeLocalTheta: null,
+      yarnBetaFast: null,
+      yarnBetaSlow: null,
+      yarnOriginalMaxPos: null,
+    },
+    output: {
+      tieWordEmbeddings: true,
+      scaleEmbeddings: true,
+      embeddingTranspose: false,
+      finalLogitSoftcapping: null,
+      embeddingVocabSize: null,
+    },
+    layerPattern: {
+      type: 'every_n',
+      globalPattern: null,
+      period: 6,
+      offset: 0,
+    },
+    chatTemplate: {
+      type: null,
+      enabled: true,
+    },
+    defaultKernelPath: 'unit-test',
+  };
+}
+
+const FIELD_CASES = Object.freeze([
+  { kind: 'nonNullable', path: ['attention', 'queryPreAttnScalar'], message: 'attention.queryPreAttnScalar is required' },
+  { kind: 'nonNullable', path: ['attention', 'queryKeyNorm'], message: 'attention.queryKeyNorm is required' },
+  { kind: 'nonNullable', path: ['attention', 'attentionBias'], message: 'attention.attentionBias is required' },
+  { kind: 'nonNullable', path: ['attention', 'causal'], message: 'attention.causal is required' },
+  { kind: 'nullable', path: ['attention', 'slidingWindow'], message: 'attention.slidingWindow must be explicitly set' },
+  { kind: 'nullable', path: ['attention', 'attnLogitSoftcapping'], message: 'attention.attnLogitSoftcapping must be explicitly set' },
+  { kind: 'nonNullable', path: ['normalization', 'rmsNormWeightOffset'], message: 'normalization.rmsNormWeightOffset is required' },
+  { kind: 'nonNullable', path: ['normalization', 'rmsNormEps'], message: 'normalization.rmsNormEps is required' },
+  { kind: 'nonNullable', path: ['normalization', 'postAttentionNorm'], message: 'normalization.postAttentionNorm is required' },
+  { kind: 'nonNullable', path: ['normalization', 'preFeedforwardNorm'], message: 'normalization.preFeedforwardNorm is required' },
+  { kind: 'nonNullable', path: ['normalization', 'postFeedforwardNorm'], message: 'normalization.postFeedforwardNorm is required' },
+  { kind: 'nonNullable', path: ['ffn', 'activation'], message: 'ffn.activation is required' },
+  { kind: 'nonNullable', path: ['ffn', 'gatedActivation'], message: 'ffn.gatedActivation is required' },
+  { kind: 'nullable', path: ['ffn', 'swigluLimit'], message: 'ffn.swigluLimit must be explicitly set' },
+  { kind: 'nonNullable', path: ['rope', 'ropeTheta'], message: 'rope.ropeTheta is required' },
+  { kind: 'nonNullable', path: ['rope', 'ropeScalingFactor'], message: 'rope.ropeScalingFactor is required' },
+  { kind: 'nullable', path: ['rope', 'ropeScalingType'], message: 'rope.ropeScalingType must be explicitly set' },
+  { kind: 'nullable', path: ['rope', 'ropeLocalTheta'], message: 'rope.ropeLocalTheta must be explicitly set' },
+  { kind: 'nullable', path: ['rope', 'yarnBetaFast'], message: 'rope.yarnBetaFast must be explicitly set' },
+  { kind: 'nullable', path: ['rope', 'yarnBetaSlow'], message: 'rope.yarnBetaSlow must be explicitly set' },
+  { kind: 'nullable', path: ['rope', 'yarnOriginalMaxPos'], message: 'rope.yarnOriginalMaxPos must be explicitly set' },
+  { kind: 'nonNullable', path: ['output', 'tieWordEmbeddings'], message: 'output.tieWordEmbeddings is required' },
+  { kind: 'nonNullable', path: ['output', 'scaleEmbeddings'], message: 'output.scaleEmbeddings is required' },
+  { kind: 'nonNullable', path: ['output', 'embeddingTranspose'], message: 'output.embeddingTranspose is required' },
+  { kind: 'nullable', path: ['output', 'finalLogitSoftcapping'], message: 'output.finalLogitSoftcapping must be explicitly set' },
+  { kind: 'nullable', path: ['output', 'embeddingVocabSize'], message: 'output.embeddingVocabSize must be explicitly set' },
+  { kind: 'nonNullable', path: ['layerPattern', 'type'], message: 'layerPattern.type is required' },
+  { kind: 'nullable', path: ['layerPattern', 'globalPattern'], message: 'layerPattern.globalPattern must be explicitly set' },
+  { kind: 'nullable', path: ['layerPattern', 'period'], message: 'layerPattern.period must be explicitly set' },
+  { kind: 'nullable', path: ['layerPattern', 'offset'], message: 'layerPattern.offset must be explicitly set' },
+  { kind: 'nullable', path: ['chatTemplate', 'type'], message: 'chatTemplate.type must be explicitly set' },
+  { kind: 'nonNullable', path: ['chatTemplate', 'enabled'], message: 'chatTemplate.enabled is required' },
+]);
+
+export function buildRequiredInferenceFieldsContractArtifact() {
+  const errors = [];
+  const checks = [];
+  const baseInference = createValidInferenceFixture();
+
+  try {
+    validateRequiredInferenceFields(cloneJson(baseInference), 'required-fields-contract');
+    checks.push({ id: 'requiredInferenceFields.validFixture', ok: true });
+  } catch (error) {
+    errors.push(error instanceof Error ? error.message : String(error));
+    checks.push({ id: 'requiredInferenceFields.validFixture', ok: false });
+  }
+
+  for (const field of FIELD_CASES) {
+    const missingInference = cloneJson(baseInference);
+    if (field.kind === 'nonNullable') {
+      setPath(missingInference, field.path, null);
+    } else {
+      deletePath(missingInference, field.path);
+    }
+    let rejectsAsExpected = false;
+    try {
+      validateRequiredInferenceFields(missingInference, 'required-fields-contract');
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      rejectsAsExpected = message.includes(field.message);
+    }
+    if (!rejectsAsExpected) {
+      errors.push(
+        `[RequiredInferenceFieldsContract] ${field.path.join('.')} did not produce the expected required-field failure.`
+      );
+    }
+    checks.push({
+      id: `requiredInferenceFields.${field.path.join('.')}.rejectsInvalid`,
+      ok: rejectsAsExpected,
+    });
+
+    if (field.kind === 'nullable') {
+      const nullableInference = cloneJson(baseInference);
+      setPath(nullableInference, field.path, null);
+      let nullableAccepted = true;
+      try {
+        validateRequiredInferenceFields(nullableInference, 'required-fields-contract');
+      } catch {
+        nullableAccepted = false;
+      }
+      if (!nullableAccepted) {
+        errors.push(
+          `[RequiredInferenceFieldsContract] ${field.path.join('.')} should allow explicit null but was rejected.`
+        );
+      }
+      checks.push({
+        id: `requiredInferenceFields.${field.path.join('.')}.acceptsNull`,
+        ok: nullableAccepted,
+      });
+    }
+  }
+
+  const customInference = cloneJson(baseInference);
+  customInference.layerPattern.type = 'custom';
+  delete customInference.layerPattern.layerTypes;
+  let customLayerTypesRejected = false;
+  try {
+    validateRequiredInferenceFields(customInference, 'required-fields-contract');
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    customLayerTypesRejected = message.includes('layerPattern.layerTypes must be explicitly set for custom patterns');
+  }
+  if (!customLayerTypesRejected) {
+    errors.push('[RequiredInferenceFieldsContract] custom layerPattern without layerTypes was not rejected.');
+  }
+  checks.push({
+    id: 'requiredInferenceFields.layerPattern.layerTypes.rejectsMissingForCustom',
+    ok: customLayerTypesRejected,
+  });
+
+  return {
+    schemaVersion: 1,
+    source: 'doppler',
+    ok: errors.length === 0,
+    checks,
+    errors,
+    stats: {
+      fieldCases: FIELD_CASES.length,
+      nullableCases: FIELD_CASES.filter((field) => field.kind === 'nullable').length,
+      nonNullableCases: FIELD_CASES.filter((field) => field.kind === 'nonNullable').length,
+    },
+  };
+}
+
+export function buildManifestRequiredInferenceFieldsArtifact(inference, label = 'manifest.inference') {
+  const errors = [];
+  const checks = [];
+  let ok = true;
+  try {
+    validateRequiredInferenceFields(cloneJson(inference), label);
+  } catch (error) {
+    ok = false;
+    errors.push(error instanceof Error ? error.message : String(error));
+  }
+  checks.push({
+    id: `${label}.requiredInferenceFields`,
+    ok,
+  });
+  return {
+    schemaVersion: 1,
+    source: 'doppler',
+    scope: 'manifest',
+    label,
+    ok,
+    checks,
+    errors,
+    stats: {
+      fieldCases: FIELD_CASES.length,
+      nullableCases: FIELD_CASES.filter((field) => field.kind === 'nullable').length,
+      nonNullableCases: FIELD_CASES.filter((field) => field.kind === 'nonNullable').length,
+    },
+  };
+}

package/src/config/schema/browser-suite-metrics.schema.d.ts

@@ -0,0 +1,17 @@
+export interface BrowserSuiteMetricsSchema {
+  schemaVersion: 1;
+  source: 'doppler';
+  suite: string;
+  executionContractArtifact: Record<string, unknown> | null;
+  executionV0GraphContractArtifact: Record<string, unknown> | null;
+  layerPatternContractArtifact: Record<string, unknown> | null;
+  requiredInferenceFieldsArtifact: Record<string, unknown> | null;
+  [key: string]: unknown;
+}
+
+export declare const BROWSER_SUITE_METRICS_SCHEMA_VERSION: 1;
+export declare const DEFAULT_BROWSER_SUITE_METRICS: Readonly<BrowserSuiteMetricsSchema>;
+
+export declare function validateBrowserSuiteMetrics(
+  metrics: Record<string, unknown>
+): BrowserSuiteMetricsSchema;

package/src/config/schema/browser-suite-metrics.schema.js

@@ -0,0 +1,46 @@
+function assertPlainObject(value, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`browser suite metrics: ${label} must be an object.`);
+  }
+}
+
+function assertString(value, label) {
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new Error(`browser suite metrics: ${label} must be a non-empty string.`);
+  }
+}
+
+function assertNullablePlainObject(value, label) {
+  if (value == null) return;
+  assertPlainObject(value, label);
+}
+
+export const BROWSER_SUITE_METRICS_SCHEMA_VERSION = 1;
+
+export const DEFAULT_BROWSER_SUITE_METRICS = Object.freeze({
+  schemaVersion: BROWSER_SUITE_METRICS_SCHEMA_VERSION,
+  source: 'doppler',
+  suite: 'inference',
+  executionContractArtifact: null,
+  executionV0GraphContractArtifact: null,
+  layerPatternContractArtifact: null,
+  requiredInferenceFieldsArtifact: null,
+});
+
+export function validateBrowserSuiteMetrics(metrics) {
+  assertPlainObject(metrics, 'metrics');
+  if (metrics.schemaVersion !== BROWSER_SUITE_METRICS_SCHEMA_VERSION) {
+    throw new Error(
+      `browser suite metrics: schemaVersion must be ${BROWSER_SUITE_METRICS_SCHEMA_VERSION}.`
+    );
+  }
+  if (metrics.source !== 'doppler') {
+    throw new Error('browser suite metrics: source must be "doppler".');
+  }
+  assertString(metrics.suite, 'suite');
+  assertNullablePlainObject(metrics.executionContractArtifact, 'executionContractArtifact');
+  assertNullablePlainObject(metrics.executionV0GraphContractArtifact, 'executionV0GraphContractArtifact');
+  assertNullablePlainObject(metrics.layerPatternContractArtifact, 'layerPatternContractArtifact');
+  assertNullablePlainObject(metrics.requiredInferenceFieldsArtifact, 'requiredInferenceFieldsArtifact');
+  return metrics;
+}

package/src/config/schema/conversion-report.schema.d.ts

@@ -0,0 +1,40 @@
+export interface ConversionReportResultSchema {
+  presetId: string | null;
+  modelType: string | null;
+  outputDir: string | null;
+  shardCount: number | null;
+  tensorCount: number | null;
+  totalSize: number | null;
+}
+
+export interface ConversionReportManifestSchema {
+  quantization: string | null;
+  quantizationInfo: Record<string, unknown> | null;
+  inference: {
+    presetId: string | null;
+    schema: string | null;
+    defaultKernelPath: string | null;
+  } | null;
+}
+
+export interface ConversionReportSchema {
+  schemaVersion: 1;
+  suite: 'convert';
+  command: 'convert';
+  modelId: string;
+  timestamp: string;
+  source: 'doppler';
+  result: ConversionReportResultSchema;
+  manifest: ConversionReportManifestSchema | null;
+  executionContractArtifact: Record<string, unknown> | null;
+  executionV0GraphContractArtifact: Record<string, unknown> | null;
+  layerPatternContractArtifact: Record<string, unknown> | null;
+  requiredInferenceFieldsArtifact: Record<string, unknown> | null;
+}
+
+export declare const CONVERSION_REPORT_SCHEMA_VERSION: 1;
+export declare const DEFAULT_CONVERSION_REPORT: ConversionReportSchema;
+
+export declare function validateConversionReport(
+  report: Record<string, unknown>
+): ConversionReportSchema;

package/src/config/schema/conversion-report.schema.js

@@ -0,0 +1,108 @@
+function assertPlainObject(value, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`conversion report: ${label} must be an object.`);
+  }
+}
+
+function assertString(value, label) {
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new Error(`conversion report: ${label} must be a non-empty string.`);
+  }
+}
+
+function assertNullableString(value, label) {
+  if (value === null || value === undefined) return;
+  assertString(value, label);
+}
+
+function assertNullableFiniteNumber(value, label) {
+  if (value === null || value === undefined) return;
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    throw new Error(`conversion report: ${label} must be a finite number when provided.`);
+  }
+}
+
+function assertNullablePlainObject(value, label) {
+  if (value === null || value === undefined) return;
+  assertPlainObject(value, label);
+}
+
+export const CONVERSION_REPORT_SCHEMA_VERSION = 1;
+
+export const DEFAULT_CONVERSION_REPORT = Object.freeze({
+  schemaVersion: CONVERSION_REPORT_SCHEMA_VERSION,
+  suite: 'convert',
+  command: 'convert',
+  modelId: 'unknown',
+  timestamp: '1970-01-01T00:00:00.000Z',
+  source: 'doppler',
+  result: {
+    presetId: null,
+    modelType: null,
+    outputDir: null,
+    shardCount: null,
+    tensorCount: null,
+    totalSize: null,
+  },
+  manifest: {
+    quantization: null,
+    quantizationInfo: null,
+    inference: {
+      presetId: null,
+      schema: null,
+      defaultKernelPath: null,
+    },
+  },
+  executionContractArtifact: null,
+  executionV0GraphContractArtifact: null,
+  layerPatternContractArtifact: null,
+  requiredInferenceFieldsArtifact: null,
+});
+
+export function validateConversionReport(report) {
+  assertPlainObject(report, 'report');
+  if (report.schemaVersion !== CONVERSION_REPORT_SCHEMA_VERSION) {
+    throw new Error(
+      `conversion report: schemaVersion must be ${CONVERSION_REPORT_SCHEMA_VERSION}.`
+    );
+  }
+  if (report.suite !== 'convert') {
+    throw new Error('conversion report: suite must be "convert".');
+  }
+  if (report.command !== 'convert') {
+    throw new Error('conversion report: command must be "convert".');
+  }
+  if (report.source !== 'doppler') {
+    throw new Error('conversion report: source must be "doppler".');
+  }
+  assertString(report.modelId, 'modelId');
+  assertString(report.timestamp, 'timestamp');
+  assertPlainObject(report.result, 'result');
+  assertNullableString(report.result.presetId, 'result.presetId');
+  assertNullableString(report.result.modelType, 'result.modelType');
+  assertNullableString(report.result.outputDir, 'result.outputDir');
+  assertNullableFiniteNumber(report.result.shardCount, 'result.shardCount');
+  assertNullableFiniteNumber(report.result.tensorCount, 'result.tensorCount');
+  assertNullableFiniteNumber(report.result.totalSize, 'result.totalSize');
+
+  assertNullablePlainObject(report.manifest, 'manifest');
+  if (report.manifest) {
+    assertNullableString(report.manifest.quantization, 'manifest.quantization');
+    assertNullablePlainObject(report.manifest.quantizationInfo, 'manifest.quantizationInfo');
+    assertNullablePlainObject(report.manifest.inference, 'manifest.inference');
+    if (report.manifest.inference) {
+      assertNullableString(report.manifest.inference.presetId, 'manifest.inference.presetId');
+      assertNullableString(report.manifest.inference.schema, 'manifest.inference.schema');
+      assertNullableString(
+        report.manifest.inference.defaultKernelPath,
+        'manifest.inference.defaultKernelPath'
+      );
+    }
+  }
+
+  assertNullablePlainObject(report.executionContractArtifact, 'executionContractArtifact');
+  assertNullablePlainObject(report.executionV0GraphContractArtifact, 'executionV0GraphContractArtifact');
+  assertNullablePlainObject(report.layerPatternContractArtifact, 'layerPatternContractArtifact');
+  assertNullablePlainObject(report.requiredInferenceFieldsArtifact, 'requiredInferenceFieldsArtifact');
+  return report;
+}

package/src/config/schema/doppler.schema.js

@@ -3,6 +3,13 @@ import { DEFAULT_INFERENCE_DEFAULTS_CONFIG } from './inference-defaults.schema.j
 import { DEFAULT_SHARED_RUNTIME_CONFIG } from './shared-runtime.schema.js';
 import { DEFAULT_EMULATION_CONFIG, createEmulationConfig } from './emulation.schema.js';
 import { mergeEcosystemConfig } from './ecosystem.schema.js';
+import {
+  chooseNullish,
+  mergeExecutionPatchLists,
+  mergeKernelPathPolicy,
+  mergeShallowObject,
+  replaceSubtree,
+} from '../merge-helpers.js';
 
 // =============================================================================
 // Runtime Config (all non-model-specific settings)
@@ -172,8 +179,6 @@ function mergeInferenceConfig(
   const overrideExecutionPatch = overrides.executionPatch ?? {};
   const baseKernelPathPolicy = base.kernelPathPolicy ?? {};
   const overrideKernelPathPolicy = overrides.kernelPathPolicy ?? {};
-  const baseKernelPathSourceScope = baseKernelPathPolicy.sourceScope ?? baseKernelPathPolicy.allowSources;
-  const overrideKernelPathSourceScope = overrideKernelPathPolicy.sourceScope ?? overrideKernelPathPolicy.allowSources;
   const hasRuntimeKernelProfiles = Object.prototype.hasOwnProperty.call(
     overrideSessionCompute,
     'kernelProfiles'
@@ -236,15 +241,8 @@ function mergeInferenceConfig(
     pipeline: overrides.pipeline ?? base.pipeline,
     kernelPath: overrides.kernelPath ?? base.kernelPath,
     kernelPathSource: overrides.kernelPathSource ?? base.kernelPathSource,
-    kernelPathPolicy: {
-      mode: overrideKernelPathPolicy.mode ?? baseKernelPathPolicy.mode,
-      sourceScope: overrideKernelPathSourceScope ?? baseKernelPathSourceScope,
-      allowSources: overrideKernelPathSourceScope ?? baseKernelPathSourceScope,
-      onIncompatible: overrideKernelPathPolicy.onIncompatible ?? baseKernelPathPolicy.onIncompatible,
-    },
-    chatTemplate: overrides.chatTemplate
-      ? { ...base.chatTemplate, ...overrides.chatTemplate }
-      : base.chatTemplate,
+    kernelPathPolicy: mergeKernelPathPolicy(baseKernelPathPolicy, overrideKernelPathPolicy),
+    chatTemplate: mergeShallowObject(base.chatTemplate, overrides.chatTemplate),
     session: {
       ...baseSession,
       ...overrideSession,
@@ -259,14 +257,10 @@ function mergeInferenceConfig(
           ? { kernelProfiles: overrideSessionCompute.kernelProfiles }
           : { kernelProfiles: baseSessionCompute.kernelProfiles }),
       },
-      kvcache: overrideSession.kvcache ?? baseSession.kvcache,
-      decodeLoop: overrideSession.decodeLoop ?? baseSession.decodeLoop,
-    },
-    executionPatch: {
-      set: overrideExecutionPatch.set ?? baseExecutionPatch.set ?? [],
-      remove: overrideExecutionPatch.remove ?? baseExecutionPatch.remove ?? [],
-      add: overrideExecutionPatch.add ?? baseExecutionPatch.add ?? [],
+      kvcache: replaceSubtree(overrideSession.kvcache, baseSession.kvcache),
+      decodeLoop: replaceSubtree(overrideSession.decodeLoop, baseSession.decodeLoop),
     },
+    executionPatch: mergeExecutionPatchLists(baseExecutionPatch, overrideExecutionPatch),
     // Model-specific inference overrides (merged with manifest.inference at load time)
     modelOverrides: overrides.modelOverrides ?? base.modelOverrides,
   };