@simulatte/doppler 0.1.4 → 0.1.5

package/src/inference/pipelines/text/config.d.ts

@@ -210,6 +210,11 @@ export interface ManifestWithInference {
  */
 export function hasManifestInference(manifest: Manifest): manifest is Manifest & { inference: ManifestInferenceSchema };
 
+export function validateRequiredInferenceFields(
+  inf: ManifestInferenceSchema,
+  modelId: string
+): void;
+
 /**
  * Convert MergedConfig to ParsedModelConfig.
  */

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

@@ -129,7 +129,7 @@ export function hasManifestInference(manifest) {
 }
 
 
-function validateRequiredInferenceFields(inf, modelId) {
+export function validateRequiredInferenceFields(inf, modelId) {
   
   const errors = [];
 

package/src/inference/pipelines/text/execution-v0.js

@@ -1,4 +1,12 @@
 import { mergeRuntimeValues } from '../../../config/runtime-merge.js';
+import {
+  buildExecutionV0KernelProfileKey,
+  indexExecutionV0KernelProfiles,
+  normalizeExecutionV0Dtype,
+  resolveExecutionV0KernelProfile,
+  resolveExecutionV0KVIO,
+  resolveExecutionV0Precision,
+} from '../../../config/execution-v0-contract-check.js';
 import {
   EXECUTION_V0_SCHEMA_ID,
   DEFAULT_EXECUTION_V0_POLICIES,
@@ -59,13 +67,9 @@ function cloneJson(value) {
   return JSON.parse(JSON.stringify(value));
 }
 
-function normalizeDtype(value, label) {
-  const normalized = String(value ?? '').trim().toLowerCase();
-  if (normalized !== 'f16' && normalized !== 'f32') {
-    throw new Error(`[ExecutionV0] ${label} must be "f16" or "f32"; got "${value}"`);
-  }
-  return normalized;
-}
+const normalizeDtype = normalizeExecutionV0Dtype;
+const resolvePrecision = resolveExecutionV0Precision;
+const resolveKVIO = resolveExecutionV0KVIO;
 
 function normalizePhase(value, label) {
   const normalized = String(value ?? '').trim().toLowerCase();
@@ -117,10 +121,7 @@ function stepHasLayer(step, layerIdx) {
   return step.layers.includes(layerIdx);
 }
 
-function buildKernelProfileKey(kernelRef) {
-  if (!kernelRef) return null;
-  return `${kernelRef.id}|${kernelRef.version}|${kernelRef.digest}`;
-}
+const buildKernelProfileKey = buildExecutionV0KernelProfileKey;
 
 function normalizeSlot(value, label) {
   if (typeof value !== 'string' || value.trim().length === 0) {
@@ -212,90 +213,10 @@ function hasDefinedPath(root, pathSegments) {
   return current !== undefined;
 }
 
-function indexKernelProfiles(sessionDefaults) {
-  const byKey = new Map();
-  const profiles = sessionDefaults?.compute?.kernelProfiles ?? [];
-  for (const profile of profiles) {
-    assertKernelRef(profile.kernelRef, 'sessionDefaults.compute.kernelProfiles[].kernelRef');
-    byKey.set(buildKernelProfileKey(profile.kernelRef), profile);
-  }
-  return byKey;
-}
+const indexKernelProfiles = indexExecutionV0KernelProfiles;
 
 function resolveProfile(profileIndex, step) {
-  const key = buildKernelProfileKey(step.kernelRef);
-  if (!key) return null;
-  return profileIndex.get(key) ?? null;
-}
-
-function resolvePrecision(step, profile, sessionDefaults) {
-  const defaults = sessionDefaults.compute.defaults;
-  const precision = {
-    inputDtype: step.precision?.inputDtype
-      ?? profile?.precision?.inputDtype
-      ?? null,
-    mathDtype: step.precision?.mathDtype
-      ?? profile?.precision?.mathDtype
-      ?? defaults.mathDtype,
-    accumDtype: step.precision?.accumDtype
-      ?? profile?.precision?.accumDtype
-      ?? defaults.accumDtype,
-    outputDtype: step.precision?.outputDtype
-      ?? profile?.precision?.outputDtype
-      ?? defaults.outputDtype,
-  };
-  const sources = {
-    inputDtype: step.precision?.inputDtype != null
-      ? 'manifest'
-      : profile?.precision?.inputDtype != null
-        ? 'kernelProfile'
-        : 'derived',
-    mathDtype: step.precision?.mathDtype != null
-      ? 'manifest'
-      : profile?.precision?.mathDtype != null
-        ? 'kernelProfile'
-        : 'sessionDefault',
-    accumDtype: step.precision?.accumDtype != null
-      ? 'manifest'
-      : profile?.precision?.accumDtype != null
-        ? 'kernelProfile'
-        : 'sessionDefault',
-    outputDtype: step.precision?.outputDtype != null
-      ? 'manifest'
-      : profile?.precision?.outputDtype != null
-        ? 'kernelProfile'
-        : 'sessionDefault',
-  };
-  return { precision, sources };
-}
-
-function resolveKVIO(step, profile, sessionDefaults) {
-  if (step.kvIO) {
-    return {
-      value: {
-        readDtype: normalizeDtype(step.kvIO.readDtype, `${step.id}.kvIO.readDtype`),
-        writeDtype: normalizeDtype(step.kvIO.writeDtype, `${step.id}.kvIO.writeDtype`),
-      },
-      source: 'manifest',
-    };
-  }
-  if (profile?.kvIO) {
-    return {
-      value: {
-        readDtype: normalizeDtype(profile.kvIO.readDtype, `${step.id}.profile.kvIO.readDtype`),
-        writeDtype: normalizeDtype(profile.kvIO.writeDtype, `${step.id}.profile.kvIO.writeDtype`),
-      },
-      source: 'kernelProfile',
-    };
-  }
-  const kvDtype = normalizeDtype(
-    sessionDefaults?.kvcache?.kvDtype ?? sessionDefaults.compute.defaults.activationDtype,
-    `${step.id}.sessionDefaults.kvcache.kvDtype`
-  );
-  return {
-    value: { readDtype: kvDtype, writeDtype: kvDtype },
-    source: 'sessionDefault',
-  };
+  return resolveExecutionV0KernelProfile(profileIndex, step);
 }
 
 function validateStepShape(step, index) {

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;