@simulatte/doppler 0.1.4 → 0.1.5

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,
   };

package/src/config/schema/index.d.ts

@@ -225,6 +225,28 @@ export {
   type ConversionIOSchema,
 } from './conversion.schema.js';
 
+// =============================================================================
+// Browser Suite Metrics Schema
+// =============================================================================
+export {
+  type BrowserSuiteMetricsSchema,
+  BROWSER_SUITE_METRICS_SCHEMA_VERSION,
+  DEFAULT_BROWSER_SUITE_METRICS,
+  validateBrowserSuiteMetrics,
+} from './browser-suite-metrics.schema.js';
+
+// =============================================================================
+// Conversion Report Schema
+// =============================================================================
+export {
+  type ConversionReportResultSchema,
+  type ConversionReportManifestSchema,
+  type ConversionReportSchema,
+  CONVERSION_REPORT_SCHEMA_VERSION,
+  DEFAULT_CONVERSION_REPORT,
+  validateConversionReport,
+} from './conversion-report.schema.js';
+
 // =============================================================================
 // Converter Schema
 // =============================================================================

package/src/config/schema/index.js

@@ -55,6 +55,24 @@ export {
   ConversionStage,
 } from './conversion.schema.js';
 
+// =============================================================================
+// Browser Suite Metrics Schema
+// =============================================================================
+export {
+  BROWSER_SUITE_METRICS_SCHEMA_VERSION,
+  DEFAULT_BROWSER_SUITE_METRICS,
+  validateBrowserSuiteMetrics,
+} from './browser-suite-metrics.schema.js';
+
+// =============================================================================
+// Conversion Report Schema
+// =============================================================================
+export {
+  CONVERSION_REPORT_SCHEMA_VERSION,
+  DEFAULT_CONVERSION_REPORT,
+  validateConversionReport,
+} from './conversion-report.schema.js';
+
 // =============================================================================
 // Converter Schema
 // =============================================================================

package/src/converter/core.d.ts

@@ -27,6 +27,12 @@ import type {
   MoEConfigSchema,
   ConversionInfoSchema,
 } from '../config/schema/index.js';
+import type { ExecutionContractArtifact } from '../config/execution-contract-check.js';
+import type { ExecutionV0GraphContractArtifact } from '../config/execution-v0-graph-contract-check.js';
+import type {
+  ManifestRequiredInferenceFieldsArtifact,
+  RequiredInferenceFieldsContractArtifact,
+} from '../config/required-inference-fields-contract-check.js';
 
 export { generateShardFilename } from '../formats/rdrr/index.js';
 
@@ -144,6 +150,10 @@ export interface ConvertResult {
   shardCount: number;
   tensorCount: number;
   totalSize: number;
+  executionContractArtifact: ExecutionContractArtifact | null;
+  executionV0GraphContractArtifact: ExecutionV0GraphContractArtifact | null;
+  layerPatternContractArtifact: Record<string, unknown> | null;
+  requiredInferenceFieldsArtifact: ManifestRequiredInferenceFieldsArtifact | RequiredInferenceFieldsContractArtifact | null;
 }
 
 /** @deprecated Use ConversionIOSchema from config/schema */

package/src/converter/core.js

@@ -9,15 +9,20 @@ import {
   formatBytes,
 } from '../config/schema/index.js';
 
-import { classifyTensorRole, generateShardFilename } from '../formats/rdrr/index.js';
+import { classifyTensor, classifyTensorRole, generateShardFilename } from '../formats/rdrr/index.js';
 import { log } from '../debug/index.js';
-import { selectRuleValue } from '../rules/rule-registry.js';
+import {
+  getInferenceLayerPatternContractArtifact,
+  selectRuleValue,
+} from '../rules/rule-registry.js';
 import {
   createConverterConfig,
   detectPreset,
   listPresets,
   resolvePreset,
 } from '../config/index.js';
+import { buildExecutionContractArtifact } from '../config/execution-contract-check.js';
+import { buildManifestRequiredInferenceFieldsArtifact } from '../config/required-inference-fields-contract-check.js';
 import { buildManifestInference, inferEmbeddingOutputConfig } from './manifest-inference.js';
 import { resolveEosTokenId } from './tokenizer-utils.js';
 import {
@@ -1128,6 +1133,7 @@ export async function convertModel(model, io, options = {}) {
   }
   const totalTensors = tensors.length;
   const targetQuant = String(options.quantization ?? model.quantization ?? '').trim().toLowerCase();
+  const tensorGroupModelType = String(options.modelType ?? model.modelType ?? 'transformer');
   const q4kLayout = normalizeQ4KLayout(options.quantizationInfo?.layout);
   const quantizeEmbeddings = resolveQuantizeEmbeddings(
     options.quantizationInfo ?? null,
@@ -1251,6 +1257,7 @@ export async function convertModel(model, io, options = {}) {
 
     // Record tensor location
     const role = classifyTensorRole(tensor.name);
+    const group = classifyTensor(tensor.name, tensorGroupModelType);
 
     if (tensorSpans.length === 1) {
       tensorLocations[tensor.name] = {
@@ -1260,6 +1267,7 @@ export async function convertModel(model, io, options = {}) {
         shape: tensor.shape,
         dtype: outDtype,
         role,
+        group,
         ...(outLayout ? { layout: outLayout } : {}),
       };
     } else {
@@ -1269,6 +1277,7 @@ export async function convertModel(model, io, options = {}) {
         shape: tensor.shape,
         dtype: outDtype,
         role,
+        group,
         ...(outLayout ? { layout: outLayout } : {}),
       };
     }
@@ -1327,11 +1336,27 @@ export async function convertModel(model, io, options = {}) {
     totalSize: formatBytes(totalSize),
   });
 
+  const executionContractArtifact = buildExecutionContractArtifact(manifest);
+  const layerPatternContractArtifact = getInferenceLayerPatternContractArtifact();
+  const requiredInferenceFieldsArtifact = manifest?.modelType === 'transformer'
+    && manifest?.inference
+    && typeof manifest.inference === 'object'
+    && manifest.inference.attention
+    && typeof manifest.inference.attention === 'object'
+    ? buildManifestRequiredInferenceFieldsArtifact(
+      manifest?.inference ?? null,
+      `${manifest?.modelId ?? modelId}.inference`
+    )
+    : null;
   return {
     manifest,
     shardCount: shards.length,
     tensorCount: tensors.length,
     totalSize,
+    executionContractArtifact,
+    executionV0GraphContractArtifact: executionContractArtifact?.executionV0?.graph ?? null,
+    layerPatternContractArtifact,
+    requiredInferenceFieldsArtifact,
   };
 }