@simulatte/doppler 0.1.4 → 0.1.6

package/src/inference/pipelines/text/layer.js

@@ -259,6 +259,8 @@ export async function processLayerGPU(layerIdx, inputBuffer, numTokens, isPrefil
       attentionOutputGate: config.attentionOutputGate,
       causalAttention: config.causalAttention,
       rmsNormWeightOffset: config.rmsNormWeightOffset,
+      ropeRotaryDim: config.ropeRotaryDim,
+      ropeInterleaved: config.ropeInterleaved,
       tokenIds: context.currentTokenIds ?? null,
       kernelPath: context.kernelPath ?? null,
       disableRoPE,
@@ -661,6 +663,8 @@ async function processLayerPlanGPU(layerIdx, inputBuffer, numTokens, isPrefill,
             attentionOutputGate: config.attentionOutputGate,
             causalAttention: config.causalAttention,
             rmsNormWeightOffset: config.rmsNormWeightOffset,
+            ropeRotaryDim: config.ropeRotaryDim,
+            ropeInterleaved: config.ropeInterleaved,
             tokenIds: context.currentTokenIds ?? null,
             skipInputNorm: step.skipInputNorm === true,
             activationDtype,
@@ -690,6 +694,7 @@ async function processLayerPlanGPU(layerIdx, inputBuffer, numTokens, isPrefill,
               hiddenSize,
               probes: context.debugProbes,
               recorder,
+              dtype: outputDtype,
             });
           }
           break;
@@ -733,6 +738,7 @@ async function processLayerPlanGPU(layerIdx, inputBuffer, numTokens, isPrefill,
               hiddenSize,
               probes: context.debugProbes,
               recorder,
+              dtype: outputDtype,
             });
           }
           break;
@@ -767,6 +773,7 @@ async function processLayerPlanGPU(layerIdx, inputBuffer, numTokens, isPrefill,
               hiddenSize,
               probes: context.debugProbes,
               recorder,
+              dtype: outputDtype,
             });
           }
           break;
@@ -801,6 +808,7 @@ async function processLayerPlanGPU(layerIdx, inputBuffer, numTokens, isPrefill,
               hiddenSize,
               probes: context.debugProbes,
               recorder,
+              dtype: outputDtype,
             });
           }
           break;
@@ -825,6 +833,7 @@ async function processLayerPlanGPU(layerIdx, inputBuffer, numTokens, isPrefill,
               hiddenSize,
               probes: context.debugProbes,
               recorder,
+              dtype: outputDtype,
             });
           }
           break;
@@ -851,6 +860,7 @@ async function processLayerPlanGPU(layerIdx, inputBuffer, numTokens, isPrefill,
               hiddenSize,
               probes: context.debugProbes,
               recorder,
+              dtype: toDtype,
             });
           }
           break;
@@ -880,6 +890,7 @@ async function processLayerPlanGPU(layerIdx, inputBuffer, numTokens, isPrefill,
     hiddenSize,
     probes: context.debugProbes,
     recorder,
+    dtype: getSlotDtype('state') ?? activationDtype,
   });
 
   const computeConfig = context.runtimeComputeConfig ?? null;

package/src/inference/pipelines/text.js

@@ -299,9 +299,13 @@ export class InferencePipeline extends PipelineState {
     const maxSeqLen = config.maxSeqLen;
     const ropeBuffers = await initRoPEFrequencies({
       headDim: config.headDim,
+      rotaryDim: config.ropeRotaryDim,
       maxSeqLen,
       ropeTheta: config.ropeTheta,
       ropeLocalTheta: config.ropeLocalTheta,
+      mropeInterleaved: config.ropeInterleaved,
+      mropeSection: config.mropeSection,
+      partialRotaryFactor: config.partialRotaryFactor,
       ropeScale: config.ropeScale,
       ropeLocalScale: config.ropeLocalScale,
       ropeScalingType: config.ropeScalingType,

package/src/inference/tokenizers/bundled.js

@@ -64,6 +64,68 @@ function resolveSpecialTokens(specialTokensRaw, fallbackTokens, vocab) {
   return resolved;
 }
 
+function resolveByteLevelPretokenizerConfig(preTokenizer) {
+  if (!preTokenizer || typeof preTokenizer !== 'object') {
+    return {
+      useByteLevel: false,
+      addPrefixSpace: null,
+    };
+  }
+
+  if (preTokenizer.type === 'ByteLevel') {
+    return {
+      useByteLevel: true,
+      addPrefixSpace: preTokenizer.add_prefix_space === true,
+    };
+  }
+
+  if (preTokenizer.type === 'Sequence' && Array.isArray(preTokenizer.pretokenizers)) {
+    for (const entry of preTokenizer.pretokenizers) {
+      const resolved = resolveByteLevelPretokenizerConfig(entry);
+      if (resolved.useByteLevel) {
+        return resolved;
+      }
+    }
+  }
+
+  return {
+    useByteLevel: false,
+    addPrefixSpace: null,
+  };
+}
+
+function registerAddedTokens(addedTokens, vocab, reverseVocab, patterns, specialTokenIds, derivedSpecialTokens = null) {
+  let maxId = -1;
+  for (const token of addedTokens) {
+    const content = token?.content;
+    const id = typeof token?.id === 'number' ? token.id : parseInt(token?.id, 10);
+    if (!Number.isFinite(id) || !content) continue;
+    if (!vocab.has(content)) {
+      vocab.set(content, id);
+      reverseVocab.set(id, content);
+    }
+    if (id > maxId) maxId = id;
+    if (content.length > 1) {
+      patterns.push({ content, id });
+    }
+    if (token.special) {
+      specialTokenIds.add(id);
+      if (derivedSpecialTokens) {
+        if (derivedSpecialTokens.bos == null && (content === '<bos>' || content === '<s>' || content.includes('bos'))) {
+          derivedSpecialTokens.bos = id;
+        } else if (derivedSpecialTokens.eos == null && (content === '<eos>' || content === '</s>' || content.includes('eos'))) {
+          derivedSpecialTokens.eos = id;
+        } else if (derivedSpecialTokens.pad == null && (content === '<pad>' || content.includes('pad'))) {
+          derivedSpecialTokens.pad = id;
+        } else if (derivedSpecialTokens.unk == null && (content === '<unk>' || content.includes('unk'))) {
+          derivedSpecialTokens.unk = id;
+        }
+      }
+    }
+  }
+  return maxId;
+}
+
 
 export class TransformersTokenizer extends BaseTokenizer {
 
@@ -156,6 +218,10 @@ export class BundledTokenizer extends BaseTokenizer {
   
   #byteDecoder = null;
 
+  #byteEncoder = null;
+
+  #useByteLevelEncoding = false;
+
   
   constructor(config = {}) {
     // BundledTokenizer gets vocabSize from load(), so defer validation
@@ -199,9 +265,20 @@ export class BundledTokenizer extends BaseTokenizer {
     }
 
     this.#byteDecoder = new Map();
+    this.#byteEncoder = new Map();
     for (let i = 0; i < base.length; i++) {
       this.#byteDecoder.set(String.fromCodePoint(chars[i]), base[i]);
+      this.#byteEncoder.set(base[i], String.fromCodePoint(chars[i]));
+    }
+  }
+
+  #encodeByteLevelText(text) {
+    const bytes = new TextEncoder().encode(text);
+    let out = '';
+    for (const byte of bytes) {
+      out += this.#byteEncoder?.get(byte) ?? String.fromCharCode(byte);
     }
+    return out;
   }
 
   
@@ -290,30 +367,16 @@ export class BundledTokenizer extends BaseTokenizer {
       eos: null,
       unk: null,
     };
-    for (const token of addedTokens) {
-      const content = token.content;
-      const id = typeof token.id === 'number' ? token.id : parseInt( (token.id), 10);
-      if (!Number.isFinite(id) || !content) continue;
-      if (!this.#vocab.has(content)) {
-        this.#vocab.set(content, id);
-        this.#reverseVocab.set(id, content);
-      }
-      if (id > maxId) maxId = id;
-      if (token.special) {
-        specialTokenIds.add(id);
-        if (content.length > 1) {
-          specialTokenPatterns.push({ content, id });
-        }
-        if (derivedSpecialTokens.bos == null && (content === '<bos>' || content === '<s>' || content.includes('bos'))) {
-          derivedSpecialTokens.bos = id;
-        } else if (derivedSpecialTokens.eos == null && (content === '<eos>' || content === '</s>' || content.includes('eos'))) {
-          derivedSpecialTokens.eos = id;
-        } else if (derivedSpecialTokens.pad == null && (content === '<pad>' || content.includes('pad'))) {
-          derivedSpecialTokens.pad = id;
-        } else if (derivedSpecialTokens.unk == null && (content === '<unk>' || content.includes('unk'))) {
-          derivedSpecialTokens.unk = id;
-        }
-      }
+    const addedMaxId = registerAddedTokens(
+      addedTokens,
+      this.#vocab,
+      this.#reverseVocab,
+      specialTokenPatterns,
+      specialTokenIds,
+      derivedSpecialTokens
+    );
+    if (addedMaxId > maxId) {
+      maxId = addedMaxId;
     }
 
     const specialTokensRaw = hf.special_tokens_map || hf.specialTokens || hf.special_tokens || null;
@@ -351,6 +414,7 @@ export class BundledTokenizer extends BaseTokenizer {
 
     // Handle behavior flags (use HF config if present, else runtime defaults)
     const runtimeDefaults = getRuntimeConfig().inference.tokenizer;
+    const byteLevelPretokenizer = resolveByteLevelPretokenizerConfig(hf.pre_tokenizer);
     const configuredAddBosToken = this.addBosToken;
     const configuredAddEosToken = this.addEosToken;
     this.addBosToken =
@@ -378,9 +442,16 @@ export class BundledTokenizer extends BaseTokenizer {
     // - runtime config addSpacePrefix (user override or null for auto-detect)
     const decoderPrepend = hf.decoder?.prepend_scheme === 'always' || hf.decoder?.add_prefix_space === true;
     const normalizerPrepend = hf.normalizer?.prepend_scheme === 'always' || hf.normalizer?.add_prefix_space === true;
+    this.#useByteLevelEncoding = byteLevelPretokenizer.useByteLevel;
     const runtimeSpacePrefix = runtimeDefaults.addSpacePrefix;
     // Use explicit runtime config if set (non-null), otherwise auto-detect from tokenizer.json
-    this.#addSpacePrefix = runtimeSpacePrefix ?? model.add_prefix_space ?? model.add_dummy_prefix ?? decoderPrepend ?? normalizerPrepend ?? false;
+    this.#addSpacePrefix = runtimeSpacePrefix
+      ?? byteLevelPretokenizer.addPrefixSpace
+      ?? model.add_prefix_space
+      ?? model.add_dummy_prefix
+      ?? decoderPrepend
+      ?? normalizerPrepend
+      ?? false;
     log.debug('Tokenizer', `addSpacePrefix=${this.#addSpacePrefix} (runtime=${runtimeSpacePrefix}, model=${model.add_prefix_space ?? model.add_dummy_prefix}, decoder=${decoderPrepend}, normalizer=${normalizerPrepend})`);
 
     // Detect space prefix style by checking which WORD tokens exist in vocab
@@ -469,11 +540,47 @@ export class BundledTokenizer extends BaseTokenizer {
       this.#tokenTypes = tokenizerJson.tokenTypes;
     }
 
+    let maxId = -1;
+    for (const id of this.#vocab.values()) {
+      if (Number.isFinite(id) && id > maxId) {
+        maxId = id;
+      }
+    }
+
+    const addedTokens = Array.isArray(tokenizerJson.added_tokens) ? tokenizerJson.added_tokens : [];
+    const tokenPatterns = [];
+    const specialTokenIds = new Set();
+    const derivedSpecialTokens = {
+      pad: null,
+      bos: null,
+      eos: null,
+      unk: null,
+    };
+    const addedMaxId = registerAddedTokens(
+      addedTokens,
+      this.#vocab,
+      this.#reverseVocab,
+      tokenPatterns,
+      specialTokenIds,
+      derivedSpecialTokens
+    );
+    if (addedMaxId > maxId) {
+      maxId = addedMaxId;
+    }
+
     // Set special tokens - support both camelCase and snake_case formats
     const specialTokensRaw =  (tokenizerJson.specialTokens ||  (tokenizerJson).special_tokens);
-    this.specialTokens = resolveSpecialTokens(specialTokensRaw, this.specialTokens, this.#vocab);
+    this.specialTokens = resolveSpecialTokens(
+      specialTokensRaw,
+      {
+        ...derivedSpecialTokens,
+        ...this.specialTokens,
+      },
+      this.#vocab
+    );
     log.debug('Tokenizer', `Special tokens: BOS=${this.specialTokens.bos}, EOS=${this.specialTokens.eos}`);
-    this.#specialTokenIds = new Set();
+    this.#specialTokenIds = specialTokenIds;
+    this.#specialTokenPatterns = tokenPatterns;
     const builtinSpecials = [
       this.specialTokens.pad,
       this.specialTokens.bos,
@@ -485,8 +592,13 @@ export class BundledTokenizer extends BaseTokenizer {
         this.#specialTokenIds.add(id);
       }
     }
+    this.#specialTokenPatterns.sort((a, b) => b.content.length - a.content.length);
+    if (maxId >= 0) {
+      this.vocabSize = Math.max(this.vocabSize, maxId + 1);
+    }
 
     const runtimeDefaults = getRuntimeConfig().inference.tokenizer;
+    const byteLevelPretokenizer = resolveByteLevelPretokenizerConfig(tokenizerJson.pre_tokenizer);
     const configuredAddBosToken = this.addBosToken;
     const configuredAddEosToken = this.addEosToken;
     this.addBosToken =
@@ -505,9 +617,11 @@ export class BundledTokenizer extends BaseTokenizer {
     if (this.addEosToken && this.specialTokens.eos == null) {
       throw new Error('[Tokenizer] addEosToken is enabled but eos token is missing.');
     }
+    this.#useByteLevelEncoding = byteLevelPretokenizer.useByteLevel;
     // NOTE: Default to FALSE - first word shouldn't get space prefix
     // Space prefixes are only for words that follow a space in original text
-    this.#addSpacePrefix = tokenizerJson.addSpacePrefix === true;
+    this.#addSpacePrefix = tokenizerJson.addSpacePrefix === true
+      || byteLevelPretokenizer.addPrefixSpace === true;
 
     // Detect space prefix style based on vocab tokens
     // GPT-style uses 'Ġ' (U+0120), SentencePiece uses '▁' (U+2581)
@@ -548,7 +662,8 @@ export class BundledTokenizer extends BaseTokenizer {
       ids.push(this.specialTokens.bos);
     }
 
-    // Split text around special tokens and tokenize each segment
+    // Split text around literal added tokens and special tokens, then tokenize
+    // the remaining plain-text segments normally.
     const segments = this.#splitOnSpecialTokens(text);
     for (const seg of segments) {
       if (seg.isSpecial && seg.id !== undefined) {
@@ -690,11 +805,19 @@ export class BundledTokenizer extends BaseTokenizer {
     if (text.length === 0) return [];
 
     let normalized = text;
-    if (this.#addSpacePrefix && !normalized.startsWith(' ')) {
-      normalized = ` ${normalized}`;
+    let prefixed;
+    if (this.#useByteLevelEncoding) {
+      if (this.#addSpacePrefix && !normalized.startsWith(' ')) {
+        normalized = ` ${normalized}`;
+      }
+      prefixed = this.#encodeByteLevelText(normalized);
+    } else {
+      if (this.#addSpacePrefix && !normalized.startsWith(' ')) {
+        normalized = ` ${normalized}`;
+      }
+      const sp = this.#spacePrefixChar;
+      prefixed = normalized.replace(/ /g, sp);
     }
-    const sp = this.#spacePrefixChar;
-    const prefixed = normalized.replace(/ /g, sp);
 
     if (this.#mergeRanks.size === 0) {
       return this.#encodeBPEGreedy(prefixed);

package/src/rules/execution-rules-contract-check.d.ts

@@ -0,0 +1,17 @@
+export interface InferenceExecutionRulesContractArtifact {
+  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 buildInferenceExecutionRulesContractArtifact(
+  ruleGroup: Record<string, unknown> | null | undefined
+): InferenceExecutionRulesContractArtifact;

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;