@simulatte/doppler 0.1.4 → 0.1.5

package/src/rules/layer-pattern-contract-check.js

@@ -0,0 +1,231 @@
+import { selectByRules } from '../gpu/kernels/rule-matcher.js';
+import { computeGlobalLayers } from '../config/schema/inference.schema.js';
+
+function isPlainObject(value) {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function matchesExactObject(actual, expected) {
+  if (!isPlainObject(actual) || !isPlainObject(expected)) {
+    return false;
+  }
+  const actualKeys = Object.keys(actual).sort();
+  const expectedKeys = Object.keys(expected).sort();
+  if (actualKeys.length !== expectedKeys.length) {
+    return false;
+  }
+  for (let i = 0; i < actualKeys.length; i += 1) {
+    if (actualKeys[i] !== expectedKeys[i]) {
+      return false;
+    }
+  }
+  for (const key of expectedKeys) {
+    const expectedValue = expected[key];
+    const actualValue = actual[key];
+    if (isPlainObject(expectedValue)) {
+      if (!matchesExactObject(actualValue, expectedValue)) {
+        return false;
+      }
+      continue;
+    }
+    if (actualValue !== expectedValue) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function expectedPatternKind(context) {
+  if (context.patternType === 'alternating' && context.globalPattern === 'even') {
+    return 'alternating_even';
+  }
+  if (context.patternType === 'alternating' && context.globalPattern === 'odd') {
+    return 'alternating_odd';
+  }
+  if (context.patternType === 'every_n') {
+    return 'every_n';
+  }
+  return null;
+}
+
+function expectedLayerType(context) {
+  if (context.patternKind === 'alternating_even') {
+    return context.isEven ? 'full_attention' : 'sliding_attention';
+  }
+  if (context.patternKind === 'alternating_odd') {
+    return context.isEven ? 'sliding_attention' : 'full_attention';
+  }
+  if (context.patternKind === 'every_n') {
+    return context.isStride ? 'full_attention' : 'sliding_attention';
+  }
+  return null;
+}
+
+function enumeratePatternKindContexts() {
+  const patternTypes = ['alternating', 'every_n', 'custom', null];
+  const globalPatterns = ['even', 'odd', 'every_n', null];
+  const contexts = [];
+  for (const patternType of patternTypes) {
+    for (const globalPattern of globalPatterns) {
+      contexts.push({ patternType, globalPattern });
+    }
+  }
+  return contexts;
+}
+
+function enumerateLayerTypeContexts() {
+  const patternKinds = ['alternating_even', 'alternating_odd', 'every_n'];
+  const booleans = [true, false];
+  const contexts = [];
+  for (const patternKind of patternKinds) {
+    for (const isEven of booleans) {
+      for (const isStride of booleans) {
+        contexts.push({ patternKind, isEven, isStride });
+      }
+    }
+  }
+  return contexts;
+}
+
+function checkRuleShape(rules, expected, label) {
+  if (!Array.isArray(rules)) {
+    return {
+      ok: false,
+      errors: [`[LayerPatternContract] ${label} must be an array.`],
+    };
+  }
+  if (rules.length !== expected.length) {
+    return {
+      ok: false,
+      errors: [`[LayerPatternContract] ${label} must contain exactly ${expected.length} rules; got ${rules.length}.`],
+    };
+  }
+  const errors = [];
+  for (let i = 0; i < expected.length; i += 1) {
+    if (!matchesExactObject(rules[i]?.match, expected[i].match) || rules[i]?.value !== expected[i].value) {
+      errors.push(`[LayerPatternContract] ${label} rule[${i}] drifted from the expected decision table.`);
+      break;
+    }
+  }
+  return {
+    ok: errors.length === 0,
+    errors,
+  };
+}
+
+function checkRuleSemantics(rules, contexts, expectedValue, label) {
+  const errors = [];
+  for (const context of contexts) {
+    const actual = selectByRules(rules, context);
+    const expected = expectedValue(context);
+    if (actual !== expected) {
+      errors.push(
+        `[LayerPatternContract] ${label} mismatched context ${JSON.stringify(context)}: ` +
+        `expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}.`
+      );
+      break;
+    }
+  }
+  return {
+    ok: errors.length === 0,
+    errors,
+    sampledContexts: contexts.length,
+  };
+}
+
+function checkGlobalLayerSemantics() {
+  const checks = [
+    {
+      id: 'inference.layerPattern.computeGlobalLayers.even',
+      actual: computeGlobalLayers({ type: 'alternating', globalPattern: 'even' }, 6),
+      expected: [0, 2, 4],
+    },
+    {
+      id: 'inference.layerPattern.computeGlobalLayers.odd',
+      actual: computeGlobalLayers({ type: 'alternating', globalPattern: 'odd' }, 6),
+      expected: [1, 3, 5],
+    },
+    {
+      id: 'inference.layerPattern.computeGlobalLayers.every_n_offset',
+      actual: computeGlobalLayers({ type: 'every_n', period: 6, offset: 5 }, 12),
+      expected: [5, 11],
+    },
+    {
+      id: 'inference.layerPattern.computeGlobalLayers.every_n_negative_offset',
+      actual: computeGlobalLayers({ type: 'every_n', period: 6, offset: -1 }, 12),
+      expected: [5, 11],
+    },
+  ];
+  const errors = [];
+  const results = [];
+  for (const entry of checks) {
+    const ok = JSON.stringify(entry.actual) === JSON.stringify(entry.expected);
+    results.push({ id: entry.id, ok });
+    if (!ok) {
+      errors.push(
+        `[LayerPatternContract] ${entry.id} expected ${JSON.stringify(entry.expected)}, got ${JSON.stringify(entry.actual)}.`
+      );
+    }
+  }
+  return {
+    checks: results,
+    errors,
+  };
+}
+
+export function buildLayerPatternContractArtifact(ruleGroup) {
+  const errors = [];
+  const checks = [];
+  const patternKindRules = ruleGroup?.patternKind;
+  const layerTypeRules = ruleGroup?.layerType;
+
+  const patternKindShape = checkRuleShape(patternKindRules, [
+    { match: { patternType: 'alternating', globalPattern: 'even' }, value: 'alternating_even' },
+    { match: { patternType: 'alternating', globalPattern: 'odd' }, value: 'alternating_odd' },
+    { match: { patternType: 'every_n' }, value: 'every_n' },
+    { match: {}, value: null },
+  ], 'patternKind');
+  errors.push(...patternKindShape.errors);
+  checks.push({ id: 'inference.layerPattern.patternKind.shape', ok: patternKindShape.ok });
+
+  const patternKindSemantics = Array.isArray(patternKindRules)
+    ? checkRuleSemantics(patternKindRules, enumeratePatternKindContexts(), expectedPatternKind, 'patternKind')
+    : { ok: false, errors: ['[LayerPatternContract] patternKind is unavailable for semantic check.'], sampledContexts: 0 };
+  errors.push(...patternKindSemantics.errors);
+  checks.push({ id: 'inference.layerPattern.patternKind.semantics', ok: patternKindSemantics.ok });
+
+  const layerTypeShape = checkRuleShape(layerTypeRules, [
+    { match: { patternKind: 'alternating_even', isEven: true }, value: 'full_attention' },
+    { match: { patternKind: 'alternating_even' }, value: 'sliding_attention' },
+    { match: { patternKind: 'alternating_odd', isEven: false }, value: 'full_attention' },
+    { match: { patternKind: 'alternating_odd' }, value: 'sliding_attention' },
+    { match: { patternKind: 'every_n', isStride: true }, value: 'full_attention' },
+    { match: { patternKind: 'every_n' }, value: 'sliding_attention' },
+  ], 'layerType');
+  errors.push(...layerTypeShape.errors);
+  checks.push({ id: 'inference.layerPattern.layerType.shape', ok: layerTypeShape.ok });
+
+  const layerTypeSemantics = Array.isArray(layerTypeRules)
+    ? checkRuleSemantics(layerTypeRules, enumerateLayerTypeContexts(), expectedLayerType, 'layerType')
+    : { ok: false, errors: ['[LayerPatternContract] layerType is unavailable for semantic check.'], sampledContexts: 0 };
+  errors.push(...layerTypeSemantics.errors);
+  checks.push({ id: 'inference.layerPattern.layerType.semantics', ok: layerTypeSemantics.ok });
+
+  const globalLayerSemantics = checkGlobalLayerSemantics();
+  errors.push(...globalLayerSemantics.errors);
+  checks.push(...globalLayerSemantics.checks);
+
+  return {
+    schemaVersion: 1,
+    source: 'doppler',
+    ok: errors.length === 0,
+    checks,
+    errors,
+    stats: {
+      patternKindRules: Array.isArray(patternKindRules) ? patternKindRules.length : 0,
+      layerTypeRules: Array.isArray(layerTypeRules) ? layerTypeRules.length : 0,
+      patternKindContexts: patternKindSemantics.sampledContexts,
+      layerTypeContexts: layerTypeSemantics.sampledContexts,
+    },
+  };
+}

package/src/rules/rule-registry.d.ts

@@ -46,3 +46,31 @@ export declare function registerRuleGroup(
   group: RuleGroup,
   rules: Record<string, RuleSet>
 ): void;
+
+export declare function getInferenceExecutionRulesContractArtifact(): {
+  schemaVersion: 1;
+  source: 'doppler';
+  ok: boolean;
+  checks: Array<{ id: string; ok: boolean }>;
+  errors: string[];
+  stats: {
+    decodeRecorderRules: number;
+    batchDecodeRules: number;
+    decodeRecorderContexts: number;
+    batchDecodeContexts: number;
+  };
+};
+
+export declare function getInferenceLayerPatternContractArtifact(): {
+  schemaVersion: 1;
+  source: 'doppler';
+  ok: boolean;
+  checks: Array<{ id: string; ok: boolean }>;
+  errors: string[];
+  stats: {
+    patternKindRules: number;
+    layerTypeRules: number;
+    patternKindContexts: number;
+    layerTypeContexts: number;
+  };
+};

package/src/rules/rule-registry.js

@@ -1,8 +1,11 @@
 import { selectByRules } from '../gpu/kernels/rule-matcher.js';
+import { buildInferenceExecutionRulesContractArtifact } from './execution-rules-contract-check.js';
+import { buildLayerPatternContractArtifact } from './layer-pattern-contract-check.js';
 import { loadJson } from '../utils/load-json.js';
 
 const attentionRules = await loadJson('./kernels/attention.rules.json', import.meta.url, 'Failed to load rules');
 const conv2dRules = await loadJson('./kernels/conv2d.rules.json', import.meta.url, 'Failed to load rules');
+const depthwiseConv2dRules = await loadJson('./kernels/depthwise-conv2d.rules.json', import.meta.url, 'Failed to load rules');
 const dequantRules = await loadJson('./kernels/dequant.rules.json', import.meta.url, 'Failed to load rules');
 const energyRules = await loadJson('./kernels/energy.rules.json', import.meta.url, 'Failed to load rules');
 const fusedFfnRules = await loadJson('./kernels/fused-ffn.rules.json', import.meta.url, 'Failed to load rules');
@@ -10,6 +13,7 @@ const fusedMatmulResidualRules = await loadJson('./kernels/fused-matmul-residual
 const fusedMatmulRmsnormRules = await loadJson('./kernels/fused-matmul-rmsnorm.rules.json', import.meta.url, 'Failed to load rules');
 const gatherRules = await loadJson('./kernels/gather.rules.json', import.meta.url, 'Failed to load rules');
 const geluRules = await loadJson('./kernels/gelu.rules.json', import.meta.url, 'Failed to load rules');
+const groupedPointwiseConv2dRules = await loadJson('./kernels/grouped-pointwise-conv2d.rules.json', import.meta.url, 'Failed to load rules');
 const groupnormRules = await loadJson('./kernels/groupnorm.rules.json', import.meta.url, 'Failed to load rules');
 const kvQuantizeRules = await loadJson('./kernels/kv_quantize.rules.json', import.meta.url, 'Failed to load rules');
 const layernormRules = await loadJson('./kernels/layernorm.rules.json', import.meta.url, 'Failed to load rules');
@@ -18,9 +22,12 @@ const kernelMoeRules = await loadJson('./kernels/moe.rules.json', import.meta.ur
 const kernelMoeGptOssRules = await loadJson('./kernels/moe.rules.gptoss.json', import.meta.url, 'Failed to load rules');
 const modulateRules = await loadJson('./kernels/modulate.rules.json', import.meta.url, 'Failed to load rules');
 const pixelShuffleRules = await loadJson('./kernels/pixel_shuffle.rules.json', import.meta.url, 'Failed to load rules');
+const repeatChannelsRules = await loadJson('./kernels/repeat-channels.rules.json', import.meta.url, 'Failed to load rules');
+const reluRules = await loadJson('./kernels/relu.rules.json', import.meta.url, 'Failed to load rules');
 const residualRules = await loadJson('./kernels/residual.rules.json', import.meta.url, 'Failed to load rules');
 const rmsnormRules = await loadJson('./kernels/rmsnorm.rules.json', import.meta.url, 'Failed to load rules');
 const ropeRules = await loadJson('./kernels/rope.rules.json', import.meta.url, 'Failed to load rules');
+const sanaLinearAttentionRules = await loadJson('./kernels/sana-linear-attention.rules.json', import.meta.url, 'Failed to load rules');
 const sampleRules = await loadJson('./kernels/sample.rules.json', import.meta.url, 'Failed to load rules');
 const scaleRules = await loadJson('./kernels/scale.rules.json', import.meta.url, 'Failed to load rules');
 const siluRules = await loadJson('./kernels/silu.rules.json', import.meta.url, 'Failed to load rules');
@@ -46,6 +53,24 @@ const toolingCommandRuntimeRules = await loadJson(
   import.meta.url,
   'Failed to load rules'
 );
+const INFERENCE_EXECUTION_RULES_CONTRACT_ARTIFACT = buildInferenceExecutionRulesContractArtifact(
+  inferenceExecutionRules
+);
+if (!INFERENCE_EXECUTION_RULES_CONTRACT_ARTIFACT.ok) {
+  throw new Error(
+    `RuleRegistry: inference.execution rules contract failed: ` +
+    `${INFERENCE_EXECUTION_RULES_CONTRACT_ARTIFACT.errors.join(' | ')}`
+  );
+}
+const INFERENCE_LAYER_PATTERN_CONTRACT_ARTIFACT = buildLayerPatternContractArtifact(
+  layerPatternRules
+);
+if (!INFERENCE_LAYER_PATTERN_CONTRACT_ARTIFACT.ok) {
+  throw new Error(
+    `RuleRegistry: inference.layerPattern rules contract failed: ` +
+    `${INFERENCE_LAYER_PATTERN_CONTRACT_ARTIFACT.errors.join(' | ')}`
+  );
+}
 
 const RULE_SETS = {
   shared: {
@@ -54,6 +79,7 @@ const RULE_SETS = {
   kernels: {
     attention: attentionRules,
     conv2d: conv2dRules,
+    depthwiseConv2d: depthwiseConv2dRules,
     dequant: dequantRules,
     energy: energyRules,
     fusedFfn: fusedFfnRules,
@@ -61,6 +87,7 @@ const RULE_SETS = {
     fusedMatmulRmsnorm: fusedMatmulRmsnormRules,
     gather: gatherRules,
     gelu: geluRules,
+    groupedPointwiseConv2d: groupedPointwiseConv2dRules,
     groupnorm: groupnormRules,
     kv_quantize: kvQuantizeRules,
     layernorm: layernormRules,
@@ -69,9 +96,12 @@ const RULE_SETS = {
     moeGptoss: kernelMoeGptOssRules,
     modulate: modulateRules,
     pixel_shuffle: pixelShuffleRules,
+    repeatChannels: repeatChannelsRules,
+    relu: reluRules,
     residual: residualRules,
     rmsnorm: rmsnormRules,
     rope: ropeRules,
+    sanaLinearAttention: sanaLinearAttentionRules,
     sample: sampleRules,
     scale: scaleRules,
     silu: siluRules,
@@ -133,6 +163,14 @@ export function registerRuleGroup(domain, group, rules) {
   RULE_SETS[domain][group] = rules;
 }
 
+export function getInferenceExecutionRulesContractArtifact() {
+  return INFERENCE_EXECUTION_RULES_CONTRACT_ARTIFACT;
+}
+
+export function getInferenceLayerPatternContractArtifact() {
+  return INFERENCE_LAYER_PATTERN_CONTRACT_ARTIFACT;
+}
+
 function resolveRuleValue(value, context) {
   if (Array.isArray(value)) {
     return value.map((entry) => resolveRuleValue(entry, context));

package/src/tooling/conversion-config-materializer.d.ts

@@ -0,0 +1,24 @@
+export declare function extractTensorEntriesFromManifest(
+  manifest: Record<string, unknown>
+): Array<{
+  name: string;
+  dtype: unknown;
+  shape: unknown;
+  role: unknown;
+  layout: unknown;
+}>;
+
+export declare function resolveMaterializedManifestFromConversionConfig(
+  conversionConfigInput: Record<string, unknown>,
+  manifest: Record<string, unknown>
+): {
+  modelId: string;
+  modelType: string;
+  architecture: Record<string, unknown> | null;
+  inference: Record<string, unknown> | null;
+};
+
+export declare function inferConversionConfigModelId(
+  configPath: string,
+  conversionConfigInput: Record<string, unknown>
+): string;

package/src/tooling/conversion-config-materializer.js

@@ -0,0 +1,99 @@
+import path from 'node:path';
+
+import { createConverterConfig } from '../config/schema/index.js';
+import { resolveConversionPlan } from '../converter/conversion-plan.js';
+
+function toSafeString(value) {
+  if (typeof value !== 'string') return '';
+  const trimmed = value.trim();
+  return trimmed || '';
+}
+
+function normalizeQuantizationTag(value) {
+  const raw = toSafeString(value).toUpperCase();
+  if (!raw) return 'f16';
+  if (raw === 'Q4_K_M' || raw === 'Q4_K') return 'q4k';
+  return raw.toLowerCase();
+}
+
+function resolveArchitectureHint(architecture) {
+  if (!architecture) return '';
+  if (typeof architecture === 'string') return architecture;
+  return (
+    toSafeString(architecture.id)
+    || toSafeString(architecture.name)
+    || toSafeString(architecture.type)
+    || ''
+  );
+}
+
+function resolveHeadDim(architecture) {
+  const headDim = Number(architecture?.headDim ?? architecture?.head_dim);
+  return Number.isFinite(headDim) && headDim > 0 ? headDim : null;
+}
+
+function extractSourceQuantization(manifest) {
+  const explicitWeights = toSafeString(manifest?.quantizationInfo?.weights);
+  if (explicitWeights) return explicitWeights;
+  const explicitQuant = toSafeString(manifest?.quantization);
+  if (explicitQuant) return explicitQuant;
+  return 'f16';
+}
+
+function buildRefreshRawConfig(manifest) {
+  const baseConfig = (manifest?.config && typeof manifest.config === 'object')
+    ? { ...manifest.config }
+    : {};
+  const manifestLayerTypes = manifest?.inference?.layerPattern?.layerTypes;
+  if (Array.isArray(manifestLayerTypes) && manifestLayerTypes.length > 0) {
+    return {
+      ...baseConfig,
+      layer_types: [...manifestLayerTypes],
+    };
+  }
+  return baseConfig;
+}
+
+export function extractTensorEntriesFromManifest(manifest) {
+  if (!(manifest?.tensors && typeof manifest.tensors === 'object' && !Array.isArray(manifest.tensors))) {
+    return [];
+  }
+  return Object.entries(manifest.tensors).map(([name, tensor]) => ({
+    name,
+    dtype: tensor?.dtype ?? null,
+    shape: tensor?.shape ?? null,
+    role: tensor?.role ?? null,
+    layout: tensor?.layout ?? null,
+  }));
+}
+
+export function resolveMaterializedManifestFromConversionConfig(conversionConfigInput, manifest) {
+  const converterConfig = createConverterConfig(conversionConfigInput);
+  const tensorEntries = extractTensorEntriesFromManifest(manifest);
+  const architecture = manifest?.architecture && typeof manifest.architecture === 'object'
+    ? manifest.architecture
+    : null;
+  const plan = resolveConversionPlan({
+    rawConfig: buildRefreshRawConfig(manifest),
+    tensors: tensorEntries,
+    converterConfig,
+    sourceQuantization: normalizeQuantizationTag(extractSourceQuantization(manifest)),
+    modelKind: manifest?.modelType === 'diffusion' ? 'diffusion' : 'transformer',
+    architectureHint: resolveArchitectureHint(manifest?.architecture),
+    architectureConfig: architecture,
+    headDim: resolveHeadDim(architecture),
+    presetOverride: converterConfig?.presets?.model || manifest?.inference?.presetId || null,
+  });
+  return {
+    modelId: manifest?.modelId ?? converterConfig?.output?.modelBaseId ?? 'unknown',
+    modelType: manifest?.modelType ?? plan?.modelType ?? 'transformer',
+    architecture: manifest?.architecture ?? null,
+    inference: plan?.manifestInference ?? null,
+  };
+}
+
+export function inferConversionConfigModelId(configPath, conversionConfigInput) {
+  const configuredId = toSafeString(conversionConfigInput?.output?.modelBaseId);
+  if (configuredId) return configuredId;
+  return path.basename(String(configPath), path.extname(String(configPath)));
+}

package/src/tooling/lean-execution-contract-runner.d.ts

@@ -0,0 +1,43 @@
+export interface LeanExecutionContractRunResult {
+  ok: boolean;
+  toolchainRef: string | null;
+  generatedPath: string;
+  moduleName: string;
+  facts: Record<string, unknown>;
+}
+
+export declare function resolveLeanBinary(): string;
+
+export declare function runLeanCheck(options: {
+  sourcePath: string;
+  rootDir: string;
+}): {
+  ok: boolean;
+  toolchainRef: string;
+};
+
+export declare function writeExecutionContractLeanModuleForManifest(
+  manifest: Record<string, unknown>,
+  options?: {
+    rootDir?: string;
+    moduleName?: string;
+    emitPath?: string | null;
+  }
+): {
+  rootDir: string;
+  facts: Record<string, unknown>;
+  moduleName: string;
+  source: string;
+  generatedPath: string;
+  tempDir: string | null;
+};
+
+export declare function runLeanExecutionContractForManifest(
+  manifest: Record<string, unknown>,
+  options?: {
+    rootDir?: string;
+    moduleName?: string;
+    emitPath?: string | null;
+    check?: boolean;
+  }
+): LeanExecutionContractRunResult;

package/src/tooling/lean-execution-contract-runner.js

@@ -0,0 +1,158 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+import {
+  extractExecutionContractFacts,
+  renderExecutionContractLeanModule,
+  sanitizeLeanModuleName,
+} from './lean-execution-contract.js';
+
+export function resolveLeanBinary() {
+  const elanLean = path.join(os.homedir(), '.elan', 'bin', 'lean');
+  if (fs.existsSync(elanLean)) {
+    return elanLean;
+  }
+  const probe = spawnSync('bash', ['-lc', 'command -v lean'], { encoding: 'utf8' });
+  if (probe.status === 0) {
+    const resolved = probe.stdout.trim();
+    if (resolved) {
+      return resolved;
+    }
+  }
+  throw new Error('lean binary not found. Install Lean with elan first.');
+}
+
+function runLeanCommand({ leanBin, toolchainRef, buildDir, rootDir, sourcePath, outputPath }) {
+  const result = spawnSync(
+    leanBin,
+    [`+${toolchainRef}`, '-o', outputPath, sourcePath],
+    {
+      cwd: rootDir,
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        LEAN_PATH: `${buildDir}:${path.join(rootDir, 'lean')}`,
+      },
+    }
+  );
+  if (result.stdout) {
+    process.stdout.write(result.stdout);
+  }
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+  if (result.status !== 0) {
+    throw new Error(`lean exited with status ${result.status}`);
+  }
+}
+
+export function runLeanCheck({ sourcePath, rootDir }) {
+  const toolchainVersion = process.env.DOPPLER_LEAN_VERSION ?? '4.16.0';
+  const toolchainRef = toolchainVersion.startsWith('v')
+    ? `leanprover/lean4:${toolchainVersion}`
+    : `leanprover/lean4:v${toolchainVersion}`;
+  const leanBin = resolveLeanBinary();
+  const buildDir = fs.mkdtempSync(path.join(os.tmpdir(), 'doppler-lean-execution-contract-'));
+  try {
+    fs.mkdirSync(path.join(buildDir, 'Doppler'), { recursive: true });
+    runLeanCommand({
+      leanBin,
+      toolchainRef,
+      buildDir,
+      rootDir,
+      sourcePath: path.join(rootDir, 'lean', 'Doppler', 'Model.lean'),
+      outputPath: path.join(buildDir, 'Doppler', 'Model.olean'),
+    });
+    runLeanCommand({
+      leanBin,
+      toolchainRef,
+      buildDir,
+      rootDir,
+      sourcePath: path.join(rootDir, 'lean', 'Doppler', 'ExecutionContract.lean'),
+      outputPath: path.join(buildDir, 'Doppler', 'ExecutionContract.olean'),
+    });
+    const generatedOutput = path.join(buildDir, 'GeneratedExecutionContractCheck.olean');
+    const result = spawnSync(
+      leanBin,
+      [`+${toolchainRef}`, '-o', generatedOutput, sourcePath],
+      {
+        cwd: rootDir,
+        encoding: 'utf8',
+        env: {
+          ...process.env,
+          LEAN_PATH: `${buildDir}:${path.join(rootDir, 'lean')}`,
+        },
+      }
+    );
+    if (result.stdout) {
+      process.stdout.write(result.stdout);
+    }
+    if (result.stderr) {
+      process.stderr.write(result.stderr);
+    }
+    if (result.status !== 0) {
+      throw new Error(`lean exited with status ${result.status}`);
+    }
+    const overallMatch = result.stdout.match(/executionContractOverall:(pass|fail)/);
+    if (!overallMatch) {
+      throw new Error('unable to parse executionContractOverall from Lean output.');
+    }
+    return { ok: overallMatch[1] === 'pass', toolchainRef };
+  } finally {
+    fs.rmSync(buildDir, { recursive: true, force: true });
+  }
+}
+
+export function writeExecutionContractLeanModuleForManifest(manifest, options = {}) {
+  const rootDir = path.resolve(String(options.rootDir ?? process.cwd()));
+  const facts = extractExecutionContractFacts(manifest);
+  const moduleName = sanitizeLeanModuleName(options.moduleName ?? `${facts.modelId}_ExecutionContractCheck`);
+  const source = renderExecutionContractLeanModule(facts, { moduleName });
+  const tempDir = options.emitPath
+    ? null
+    : fs.mkdtempSync(path.join(rootDir, 'lean', '.generated-'));
+  const generatedPath = options.emitPath
+    ? path.resolve(rootDir, String(options.emitPath))
+    : path.join(tempDir, `${moduleName}.lean`);
+  fs.mkdirSync(path.dirname(generatedPath), { recursive: true });
+  fs.writeFileSync(generatedPath, source);
+  return {
+    rootDir,
+    facts,
+    moduleName,
+    source,
+    generatedPath,
+    tempDir,
+  };
+}
+
+export function runLeanExecutionContractForManifest(manifest, options = {}) {
+  const generated = writeExecutionContractLeanModuleForManifest(manifest, options);
+  try {
+    if (options.check === false) {
+      return {
+        ok: true,
+        toolchainRef: null,
+        generatedPath: generated.generatedPath,
+        moduleName: generated.moduleName,
+        facts: generated.facts,
+      };
+    }
+    const result = runLeanCheck({
+      sourcePath: generated.generatedPath,
+      rootDir: generated.rootDir,
+    });
+    return {
+      ...result,
+      generatedPath: generated.generatedPath,
+      moduleName: generated.moduleName,
+      facts: generated.facts,
+    };
+  } finally {
+    if (!options.emitPath && generated.tempDir) {
+      fs.rmSync(generated.tempDir, { recursive: true, force: true });
+    }
+  }
+}