@simulatte/doppler 0.1.9 → 0.2.0

package/src/memory/unified-detect.js

@@ -1,192 +0,0 @@
-
-
-import { log } from '../debug/index.js';
-import { GB } from '../config/schema/index.js';
-
-// ============================================================================
-// Detection Functions
-// ============================================================================
-
-
-async function detectAppleSilicon(adapter) {
-  if (!adapter) return { isApple: false };
-
-  const info = await ( (adapter)).requestAdapterInfo?.() ||  ({});
-  const vendor = (info.vendor || '').toLowerCase();
-  const device = (info.device || '').toLowerCase();
-  const description = (info.description || '').toLowerCase();
-
-  const isApple =
-    vendor.includes('apple') ||
-    device.includes('apple') ||
-    description.includes('apple');
-
-  // Check for M-series chip names
-  const mSeriesMatch = description.match(/m(\d+)/i) || device.match(/m(\d+)/i);
-  const mSeriesGen = mSeriesMatch ? parseInt(mSeriesMatch[1], 10) : null;
-
-  return {
-    isApple,
-    mSeriesGen,
-    vendor: info.vendor,
-    device: info.device,
-    description: info.description,
-  };
-}
-
-
-async function detectAMDUnified(adapter) {
-  if (!adapter) return { isAMDUnified: false };
-
-  const info = await ( (adapter)).requestAdapterInfo?.() ||  ({});
-  const vendor = (info.vendor || '').toLowerCase();
-  const device = (info.device || '').toLowerCase();
-  const description = (info.description || '').toLowerCase();
-  const architecture = (( (info)).architecture || '').toLowerCase();
-
-  // Debug: log what we receive
-  log.debug('UnifiedDetect', 'AMD check', { vendor, device, description, architecture });
-
-  // Check vendor OR architecture for AMD identification
-  // Some drivers report vendor as "unknown" but architecture as "rdna-X"
-  const isAMD = vendor.includes('amd') ||
-                vendor.includes('advanced micro') ||
-                architecture.includes('rdna');
-
-  if (!isAMD) return { isAMDUnified: false };
-
-  // Strix Halo / Ryzen AI Max identifiers
-  const strixPatterns = [
-    'strix',
-    'ryzen ai max',
-    'radeon 8060',
-    'radeon 890m',
-    'gfx1151', // RDNA 3.5 GFX ID
-  ];
-
-  const isStrix = strixPatterns.some(
-    (p) => device.includes(p) || description.includes(p) || architecture.includes(p)
-  );
-
-  // For AMD iGPUs where vendor/device are "unknown", check architecture + buffer limits
-  // RDNA 3/3.5 integrated GPUs in APUs have unified memory
-  // We detect this heuristically: RDNA architecture + large buffer limits
-  const isLikelyIntegrated = architecture.includes('rdna') &&
-    (vendor === 'unknown' || vendor === '');
-
-  return {
-    isAMDUnified: isStrix || isLikelyIntegrated,
-    isStrix,
-    vendor: info.vendor,
-    device: info.device,
-    description: info.description,
-  };
-}
-
-
-function checkUnifiedIndicators(
-  _adapter,
-  device
-) {
-  if (!device) return { largeBuffers: false };
-
-  const limits = device.limits;
-
-  // Unified memory systems typically have very large buffer limits
-  // because VRAM = System RAM
-  const maxBuffer = limits.maxBufferSize || 0;
-  const maxStorage = limits.maxStorageBufferBindingSize || 0;
-
-  // 4GB+ buffer limits suggest unified memory
-  const largeBuffers = maxBuffer >= 4 * GB || maxStorage >= 2 * GB;
-
-  return {
-    largeBuffers,
-    maxBufferSize: maxBuffer,
-    maxStorageBufferBindingSize: maxStorage,
-  };
-}
-
-// ============================================================================
-// Public API
-// ============================================================================
-
-
-export async function detectUnifiedMemory() {
-  // Need WebGPU for detection
-  if (typeof navigator === 'undefined' || !navigator.gpu) {
-    return {
-      isUnified: false,
-      reason: 'WebGPU not available',
-    };
-  }
-
-  try {
-    const adapter = await navigator.gpu.requestAdapter({
-      powerPreference: 'high-performance',
-    });
-
-    if (!adapter) {
-      return {
-        isUnified: false,
-        reason: 'No WebGPU adapter',
-      };
-    }
-
-    // Request device with maximum limits to detect actual hardware capabilities
-    const adapterLimits = adapter.limits;
-    const device = await adapter.requestDevice({
-      requiredLimits: {
-        maxBufferSize: adapterLimits.maxBufferSize,
-        maxStorageBufferBindingSize: adapterLimits.maxStorageBufferBindingSize,
-      }
-    });
-
-    const apple = await detectAppleSilicon(adapter);
-    const amd = await detectAMDUnified(adapter);
-    const limits = checkUnifiedIndicators(adapter, device);
-
-    // Determine if unified
-    // Fallback: macOS + large buffer limits = likely Apple Silicon
-    const isMacOS = navigator.platform?.toLowerCase().includes('mac') ||
-                    navigator.userAgent?.toLowerCase().includes('mac');
-    const hasLargeBuffers = limits.largeBuffers;
-
-    // Apple Silicon: either detected via adapter OR (macOS + large buffers)
-    const isAppleSilicon = apple.isApple || (isMacOS && hasLargeBuffers);
-    const isUnified = isAppleSilicon || amd.isAMDUnified;
-
-    // Estimate available unified memory
-    
-    let estimatedMemoryGB = null;
-    if (isAppleSilicon) {
-      // Apple M-series: estimate based on generation or buffer limits
-      if (apple.mSeriesGen) {
-        estimatedMemoryGB = apple.mSeriesGen >= 4 ? 128 : 64;
-      } else {
-        // Fallback: estimate from max buffer size
-        const maxBufferGB = (limits.maxBufferSize || 0) / GB;
-        estimatedMemoryGB = Math.min(128, Math.max(8, Math.floor(maxBufferGB * 2)));
-      }
-    } else if (amd.isStrix) {
-      // Strix Halo: up to 128GB
-      estimatedMemoryGB = 128;
-    }
-
-    device.destroy();
-
-    return {
-      isUnified,
-      apple,
-      amd,
-      limits,
-      estimatedMemoryGB,
-      reason: isUnified ? 'Unified memory detected' : 'Discrete GPU or unknown',
-    };
-  } catch (err) {
-    return {
-      isUnified: false,
-      reason: `Detection failed: ${ (err).message}`,
-    };
-  }
-}

package/src/rules/converter/execution.rules.json

@@ -1,20 +0,0 @@
-{
-  "jobMode": [
-    { "match": { "workers": { "lte": 1 } }, "value": "main" },
-    { "match": { "canChunkRows": true }, "value": "row_chunks" },
-    { "match": {}, "value": "tensor" }
-  ],
-  "rowChunkRows": [
-    { "match": { "canChunkRows": false }, "value": 0 },
-    { "match": { "workers": { "lte": 2 } }, "value": 256 },
-    { "match": { "workers": { "lte": 16 } }, "value": 512 },
-    { "match": {}, "value": 768 }
-  ],
-  "maxInFlightJobs": [
-    { "match": { "workers": { "lte": 2 } }, "value": 4 },
-    { "match": { "workers": { "lte": 4 } }, "value": 8 },
-    { "match": { "workers": { "lte": 8 } }, "value": 16 },
-    { "match": { "workers": { "lte": 16 } }, "value": 24 },
-    { "match": {}, "value": 32 }
-  ]
-}

package/src/rules/converter/tensor-roles.rules.json

@@ -1,13 +0,0 @@
-{
-  "shouldQuantize": [
-    { "match": { "numElements": { "lt": 1024 } }, "value": false },
-    { "match": { "role": "embedding", "quantizeEmbeddings": true }, "value": true },
-    { "match": { "role": "embedding" }, "value": false },
-    { "match": { "role": "lm_head", "quantizeEmbeddings": true }, "value": true },
-    { "match": { "role": "lm_head" }, "value": false },
-    { "match": { "role": "norm" }, "value": false },
-    { "match": { "role": "router" }, "value": false },
-    { "match": { "isBias": true }, "value": false },
-    { "match": {}, "value": true }
-  ]
-}

package/src/rules/converter/tokenizer.rules.json

@@ -1,7 +0,0 @@
-{
-  "type": [
-    { "match": { "hasMerges": true }, "value": "bpe" },
-    { "match": { "hasScores": true }, "value": "unigram" },
-    { "match": {}, "value": "bpe" }
-  ]
-}

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

@@ -1,17 +0,0 @@
-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

@@ -1,245 +0,0 @@
-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/inference/attention.rules.json

@@ -1,54 +0,0 @@
-{
-  "useFusedQkv": [
-    { "match": { "hasQkvProj": true, "hasQkvSizes": true, "hasLoRA": false }, "value": true },
-    { "match": {}, "value": false }
-  ],
-  "useFusedOProjResidual": [
-    {
-      "match": {
-        "allowFusedResidual": true,
-        "hasResidual": true,
-        "residualMatches": true,
-        "attnIsF32": true,
-        "hasLoRA": false,
-        "oProjIsF16": true
-      },
-      "value": true
-    },
-    {
-      "match": {
-        "allowFusedResidual": true,
-        "hasResidual": true,
-        "residualMatches": true,
-        "attnIsF16": true,
-        "hasLoRA": false,
-        "oProjIsF16": true
-      },
-      "value": true
-    },
-    { "match": {}, "value": false }
-  ],
-  "attentionKernelVariant": [
-    {
-      "match": {
-        "kvLayout": "tiered",
-        "numTokens": {
-          "gt": 1
-        }
-      },
-      "value": "contiguous"
-    },
-    { "match": { "kvLayout": "bdpa" }, "value": "bdpa" },
-    {
-      "match": {
-        "kvLayout": "tiered",
-        "coldQuantMode": {
-          "neq": "none"
-        }
-      },
-      "value": "tieredQuant"
-    },
-    { "match": { "kvLayout": "tiered" }, "value": "tiered" },
-    { "match": {}, "value": "contiguous" }
-  ]
-}

package/src/rules/inference/config.rules.json

@@ -1,58 +0,0 @@
-{
-  "hiddenActivation": [
-    { "match": { "activation": { "in": ["silu", "swiglu"] } }, "value": "silu" },
-    { "match": { "activation": { "in": ["gelu", "geglu"] } }, "value": "gelu" },
-    { "match": {}, "value": "silu" }
-  ],
-  "tracePath": [
-    { "match": { "useRecorder": true }, "value": "fused" },
-    { "match": {}, "value": "debug-sync" }
-  ],
-  "pipelineModules": [
-    { "match": { "modelTypeLower": { "in": ["diffusion"] } }, "value": ["./diffusion/pipeline.js"] },
-    { "match": { "modelTypeLower": { "in": ["energy"] } }, "value": ["./energy/pipeline.js"] },
-    {
-      "match": {
-        "modelTypeLower": {
-          "in": [
-            "dream_structured",
-            "dream_intent_posterior_head",
-            "dream_d1_to2_bridge",
-            "dream_synthesis",
-            "dream_energy_compose",
-            "structured_json_head",
-            "structured-json-head",
-            "dream-intent-posterior-head",
-            "dream-d1-to2-bridge",
-            "dream-synthesis",
-            "dream-energy-compose"
-          ]
-        }
-      },
-      "value": ["./structured/json-head-pipeline.js"]
-    },
-    {
-      "match": {
-        "modelTypeLower": {
-          "in": [
-            "energy_row_head",
-            "energy-row-head",
-            "dream_energy_head",
-            "dream-energy-head",
-            "d1-to2-bridge-diffusion",
-            "synthesis-mixer-diffusion",
-            "ebrm-diffusion"
-          ]
-        }
-      },
-      "value": ["./energy-head/row-head-pipeline.js"]
-    },
-    { "match": {}, "value": [] }
-  ],
-  "embeddingSemanticStyle": [
-    { "match": { "modelId": { "contains": "embeddinggemma" } }, "value": "embeddinggemma" },
-    { "match": { "presetId": { "in": ["embeddinggemma"] } }, "value": "embeddinggemma" },
-    { "match": { "manifestModelType": { "contains": "embeddinggemma" } }, "value": "embeddinggemma" },
-    { "match": {}, "value": "default" }
-  ]
-}