@simulatte/doppler 0.1.3 → 0.1.5

package/src/rules/execution-rules-contract-check.js

@@ -0,0 +1,245 @@
+import { selectByRules } from '../gpu/kernels/rule-matcher.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 (Array.isArray(expectedValue)) {
+      if (!Array.isArray(actualValue) || actualValue.length !== expectedValue.length) {
+        return false;
+      }
+      for (let i = 0; i < expectedValue.length; i += 1) {
+        if (actualValue[i] !== expectedValue[i]) {
+          return false;
+        }
+      }
+      continue;
+    }
+    if (actualValue !== expectedValue) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function decodeRecorderSemantic(context) {
+  return context.hasDevice === true
+    && context.debug !== true
+    && context.disableCommandBatching !== true
+    && context.kvLayout !== 'bdpa_paged';
+}
+
+function batchDecodeSemantic(context) {
+  return context.batchSize > 1
+    && context.useGPU === true
+    && context.gpuSamplingAvailable === true
+    && context.disableMultiTokenDecode !== true
+    && context.disableCommandBatching !== true
+    && context.isBdpaPagedLayout !== true
+    && context.finitenessFallbackWindowOpen !== true;
+}
+
+function enumerateDecodeRecorderContexts() {
+  const values = [true, false];
+  const kvLayouts = ['bdpa_paged', 'paged', null];
+  const contexts = [];
+  for (const hasDevice of values) {
+    for (const debug of values) {
+      for (const disableCommandBatching of values) {
+        for (const kvLayout of kvLayouts) {
+          contexts.push({
+            hasDevice,
+            debug,
+            disableCommandBatching,
+            kvLayout,
+          });
+        }
+      }
+    }
+  }
+  return contexts;
+}
+
+function enumerateBatchDecodeContexts() {
+  const values = [true, false];
+  const batchSizes = [1, 2];
+  const contexts = [];
+  for (const batchSize of batchSizes) {
+    for (const useGPU of values) {
+      for (const gpuSamplingAvailable of values) {
+        for (const disableMultiTokenDecode of values) {
+          for (const disableCommandBatching of values) {
+            for (const isBdpaPagedLayout of values) {
+              for (const finitenessFallbackWindowOpen of values) {
+                contexts.push({
+                  batchSize,
+                  useGPU,
+                  gpuSamplingAvailable,
+                  disableMultiTokenDecode,
+                  disableCommandBatching,
+                  isBdpaPagedLayout,
+                  finitenessFallbackWindowOpen,
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return contexts;
+}
+
+function checkRuleShape(rules, expectedFirstMatch, label) {
+  if (!Array.isArray(rules)) {
+    return {
+      ok: false,
+      errors: [`[ExecutionRulesContract] ${label} must be an array.`],
+    };
+  }
+  if (rules.length !== 2) {
+    return {
+      ok: false,
+      errors: [`[ExecutionRulesContract] ${label} must contain exactly 2 rules; got ${rules.length}.`],
+    };
+  }
+  const [firstRule, secondRule] = rules;
+  const errors = [];
+  if (!matchesExactObject(firstRule?.match, expectedFirstMatch) || firstRule?.value !== true) {
+    errors.push(`[ExecutionRulesContract] ${label} first rule drifted from the expected enabling predicate.`);
+  }
+  if (!matchesExactObject(secondRule?.match, {}) || secondRule?.value !== false) {
+    errors.push(`[ExecutionRulesContract] ${label} fallback rule must be { match: {}, value: false }.`);
+  }
+  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(
+        `[ExecutionRulesContract] ${label} mismatched context ${JSON.stringify(context)}: ` +
+        `expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}.`
+      );
+      break;
+    }
+  }
+  return {
+    ok: errors.length === 0,
+    errors,
+    sampledContexts: contexts.length,
+  };
+}
+
+export function buildInferenceExecutionRulesContractArtifact(ruleGroup) {
+  const errors = [];
+  const checks = [];
+  const decodeRules = ruleGroup?.decodeRecorderEnabled;
+  const batchRules = ruleGroup?.batchDecodeEnabled;
+
+  const decodeShape = checkRuleShape(
+    decodeRules,
+    {
+      hasDevice: true,
+      debug: false,
+      disableCommandBatching: false,
+      kvLayout: { neq: 'bdpa_paged' },
+    },
+    'decodeRecorderEnabled'
+  );
+  errors.push(...decodeShape.errors);
+  checks.push({
+    id: 'inference.execution.decodeRecorderEnabled.shape',
+    ok: decodeShape.ok,
+  });
+
+  const decodeSemantics = Array.isArray(decodeRules)
+    ? checkRuleSemantics(
+      decodeRules,
+      enumerateDecodeRecorderContexts(),
+      decodeRecorderSemantic,
+      'decodeRecorderEnabled'
+    )
+    : { ok: false, errors: ['[ExecutionRulesContract] decodeRecorderEnabled is unavailable for semantic check.'], sampledContexts: 0 };
+  errors.push(...decodeSemantics.errors);
+  checks.push({
+    id: 'inference.execution.decodeRecorderEnabled.semantics',
+    ok: decodeSemantics.ok,
+  });
+
+  const batchShape = checkRuleShape(
+    batchRules,
+    {
+      batchSize: { gt: 1 },
+      useGPU: true,
+      gpuSamplingAvailable: true,
+      disableMultiTokenDecode: false,
+      disableCommandBatching: false,
+      isBdpaPagedLayout: false,
+      finitenessFallbackWindowOpen: false,
+    },
+    'batchDecodeEnabled'
+  );
+  errors.push(...batchShape.errors);
+  checks.push({
+    id: 'inference.execution.batchDecodeEnabled.shape',
+    ok: batchShape.ok,
+  });
+
+  const batchSemantics = Array.isArray(batchRules)
+    ? checkRuleSemantics(
+      batchRules,
+      enumerateBatchDecodeContexts(),
+      batchDecodeSemantic,
+      'batchDecodeEnabled'
+    )
+    : { ok: false, errors: ['[ExecutionRulesContract] batchDecodeEnabled is unavailable for semantic check.'], sampledContexts: 0 };
+  errors.push(...batchSemantics.errors);
+  checks.push({
+    id: 'inference.execution.batchDecodeEnabled.semantics',
+    ok: batchSemantics.ok,
+  });
+
+  return {
+    schemaVersion: 1,
+    source: 'doppler',
+    ok: errors.length === 0,
+    checks,
+    errors,
+    stats: {
+      decodeRecorderRules: Array.isArray(decodeRules) ? decodeRules.length : 0,
+      batchDecodeRules: Array.isArray(batchRules) ? batchRules.length : 0,
+      decodeRecorderContexts: decodeSemantics.sampledContexts,
+      batchDecodeContexts: batchSemantics.sampledContexts,
+    },
+  };
+}

package/src/rules/kernels/depthwise-conv2d.rules.json

@@ -0,0 +1,6 @@
+{
+  "variant": [
+    { "match": { "isF16": true }, "value": "default_f16" },
+    { "match": {}, "value": "default" }
+  ]
+}

package/src/rules/kernels/grouped-pointwise-conv2d.rules.json

@@ -0,0 +1,6 @@
+{
+  "variant": [
+    { "match": { "isF16": true }, "value": "default_f16" },
+    { "match": {}, "value": "default" }
+  ]
+}

package/src/rules/kernels/relu.rules.json

@@ -0,0 +1,6 @@
+{
+  "variant": [
+    { "match": { "dtype": "f16" }, "value": "default_f16" },
+    { "match": {}, "value": "default" }
+  ]
+}

package/src/rules/kernels/repeat-channels.rules.json

@@ -0,0 +1,6 @@
+{
+  "variant": [
+    { "match": { "dtype": "f16" }, "value": "default_f16" },
+    { "match": {}, "value": "default" }
+  ]
+}

package/src/rules/kernels/sana-linear-attention.rules.json

@@ -0,0 +1,6 @@
+{
+  "variant": [
+    { "match": { "isF16": true }, "value": "default_f16" },
+    { "match": {}, "value": "default" }
+  ]
+}

package/src/rules/layer-pattern-contract-check.d.ts

@@ -0,0 +1,17 @@
+export interface LayerPatternContractArtifact {
+  schemaVersion: 1;
+  source: 'doppler';
+  ok: boolean;
+  checks: Array<{ id: string; ok: boolean }>;
+  errors: string[];
+  stats: {
+    patternKindRules: number;
+    layerTypeRules: number;
+    patternKindContexts: number;
+    layerTypeContexts: number;
+  };
+}
+
+export declare function buildLayerPatternContractArtifact(
+  ruleGroup: Record<string, unknown> | null | undefined
+): LayerPatternContractArtifact;

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;