@simulatte/doppler 0.1.0

package/src/config/param-validator.js

@@ -0,0 +1,235 @@
+import { log } from '../debug/index.js';
+import { PARAM_CATEGORIES, CategoryRules } from './param-categories.js';
+import { TOOLING_INTENTS, TOOLING_DIAGNOSTICS } from './schema/tooling.schema.js';
+import { validateEcosystemConfig } from './schema/ecosystem.schema.js';
+
+export function validateCallTimeOptions(options) {
+  if (!options) return;
+
+  const violations = [];
+  for (const [key, value] of Object.entries(options)) {
+    if (value === undefined) continue;
+
+    const category = PARAM_CATEGORIES[key];
+    if (!category) continue;
+
+    if (!CategoryRules[category].callTime) {
+      violations.push({ param: key, category });
+    }
+  }
+
+  if (violations.length === 0) return;
+
+  const violation = violations[0];
+  const guidance = violation.category === 'model'
+    ? 'Set via runtime.inference.modelOverrides (experimental) or manifest.'
+    : 'Set via setRuntimeConfig() before generation.';
+
+  throw new Error(
+    `DopplerConfigError: "${violation.param}" is a ${violation.category} param. ` +
+    'Cannot override at call-time.\n' +
+    guidance
+  );
+}
+
+export function validateRuntimeOverrides(overrides) {
+  const modelOverrides = overrides?.inference?.modelOverrides;
+  if (!modelOverrides) return;
+
+  const params = flattenObject(modelOverrides);
+  if (params.length === 0) return;
+
+  log.warn(
+    'Config',
+    `Experimental: Overriding ${params.length} model param(s) via runtime: ${params.join(', ')}. ` +
+      'Manifest values are recommended.'
+  );
+}
+
+export function validateRuntimeConfig(runtimeConfig) {
+  if (!runtimeConfig) return;
+
+  const generation = runtimeConfig.inference?.generation;
+  if (!generation) {
+    throw new Error('DopplerConfigError: runtime.inference.generation is required.');
+  }
+
+  const batching = runtimeConfig.inference?.batching;
+  if (!batching) {
+    throw new Error('DopplerConfigError: runtime.inference.batching is required.');
+  }
+  const compute = runtimeConfig.inference?.compute;
+  if (!compute) {
+    throw new Error('DopplerConfigError: runtime.inference.compute is required.');
+  }
+  const kernelPathPolicy = runtimeConfig.inference?.kernelPathPolicy;
+  if (!kernelPathPolicy) {
+    throw new Error('DopplerConfigError: runtime.inference.kernelPathPolicy is required.');
+  }
+
+  assertNullablePositiveInt('runtime.inference.batching.readbackInterval', batching.readbackInterval);
+  assertNullablePositiveInt('runtime.inference.batching.ringTokens', batching.ringTokens);
+  assertNullablePositiveInt('runtime.inference.batching.ringStop', batching.ringStop);
+  assertNullablePositiveInt('runtime.inference.batching.ringStaging', batching.ringStaging);
+  assertPositiveInt('runtime.inference.compute.deferredRoundingWindowTokens', compute.deferredRoundingWindowTokens);
+  validateKernelPathPolicy('runtime.inference.kernelPathPolicy', kernelPathPolicy);
+  validateRangeAwareSelectiveWidening(
+    'runtime.inference.compute.rangeAwareSelectiveWidening',
+    compute.rangeAwareSelectiveWidening
+  );
+  assertEmbeddingMode('runtime.inference.generation.embeddingMode', generation.embeddingMode);
+
+  validateToolingIntent(runtimeConfig);
+  validateEcosystemConfig(runtimeConfig.shared?.ecosystem);
+
+  const debug = runtimeConfig.shared?.debug;
+  const debugEnabled = isDebugMode(debug);
+  const allowF32Upcast = runtimeConfig.loading?.allowF32UpcastNonMatmul === true;
+  const keepF32Weights = compute.keepF32Weights === true;
+
+  if (!debugEnabled && (allowF32Upcast || keepF32Weights)) {
+    const flags = [];
+    if (allowF32Upcast) flags.push('runtime.loading.allowF32UpcastNonMatmul');
+    if (keepF32Weights) flags.push('runtime.inference.compute.keepF32Weights');
+    throw new Error(
+      'DopplerConfigError: F32 weight upcast/retention is debug-only. ' +
+      `Disable ${flags.join(', ')} or enable runtime.shared.debug.pipeline.enabled ` +
+      'or runtime.shared.debug.trace.enabled (or set log level to debug/verbose).'
+    );
+  }
+}
+
+function validateToolingIntent(runtimeConfig) {
+  const tooling = runtimeConfig.shared?.tooling;
+  const intent = tooling?.intent ?? null;
+  const diagnostics = tooling?.diagnostics ?? null;
+
+  if (intent !== null && !TOOLING_INTENTS.includes(intent)) {
+    throw new Error(
+      `DopplerConfigError: runtime.shared.tooling.intent must be one of ` +
+      `${TOOLING_INTENTS.join(', ')} or null.`
+    );
+  }
+
+  if (diagnostics !== null && !TOOLING_DIAGNOSTICS.includes(diagnostics)) {
+    throw new Error(
+      `DopplerConfigError: runtime.shared.tooling.diagnostics must be one of ` +
+      `${TOOLING_DIAGNOSTICS.join(', ')}.`
+    );
+  }
+
+  if (intent !== 'calibrate') return;
+
+  const debug = runtimeConfig.shared?.debug;
+  const benchmarkRun = runtimeConfig.shared?.benchmark?.run;
+  const violations = [];
+
+  if (debug?.trace?.enabled) violations.push('runtime.shared.debug.trace.enabled');
+  if (debug?.pipeline?.enabled) violations.push('runtime.shared.debug.pipeline.enabled');
+  if (debug?.probes?.length) violations.push('runtime.shared.debug.probes');
+  if (debug?.profiler?.enabled) violations.push('runtime.shared.debug.profiler.enabled');
+  if (benchmarkRun?.debug) violations.push('runtime.shared.benchmark.run.debug');
+  if (benchmarkRun?.profile) violations.push('runtime.shared.benchmark.run.profile');
+  if (benchmarkRun?.captureMemoryTimeSeries) {
+    violations.push('runtime.shared.benchmark.run.captureMemoryTimeSeries');
+  }
+
+  if (violations.length === 0) return;
+
+  throw new Error(
+    'DopplerConfigError: runtime.shared.tooling.intent="calibrate" forbids ' +
+    'investigation instrumentation.\n' +
+    `Disable ${violations.join(', ')} or set runtime.shared.tooling.intent="investigate".\n` +
+    'If this run is launched via "bench", use "debug" for profiling/trace presets because ' +
+    '"bench" enforces intent="calibrate".'
+  );
+}
+
+function flattenObject(obj, prefix = '') {
+  const result = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined || value === null) continue;
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === 'object' && !Array.isArray(value)) {
+      result.push(...flattenObject(value, path));
+    } else {
+      result.push(path);
+    }
+  }
+  return result;
+}
+
+function isDebugMode(debug) {
+  if (!debug) return false;
+  if (debug.pipeline?.enabled) return true;
+  if (debug.trace?.enabled) return true;
+  const level = debug.logLevel?.defaultLogLevel;
+  return level === 'debug' || level === 'verbose';
+}
+
+function assertNullablePositiveInt(label, value) {
+  if (value === undefined) {
+    throw new Error(`DopplerConfigError: ${label} is required.`);
+  }
+  if (value === null) return;
+  if (!Number.isFinite(value) || value <= 0 || Math.floor(value) !== value) {
+    throw new Error(`DopplerConfigError: ${label} must be a positive integer or null.`);
+  }
+}
+
+function assertEmbeddingMode(label, value) {
+  if (value === undefined) {
+    throw new Error(`DopplerConfigError: ${label} is required.`);
+  }
+  if (value !== 'last' && value !== 'mean') {
+    throw new Error(`DopplerConfigError: ${label} must be "last" or "mean".`);
+  }
+}
+
+function assertPositiveInt(label, value) {
+  if (value === undefined) {
+    throw new Error(`DopplerConfigError: ${label} is required.`);
+  }
+  if (!Number.isFinite(value) || value <= 0 || Math.floor(value) !== value) {
+    throw new Error(`DopplerConfigError: ${label} must be a positive integer.`);
+  }
+}
+
+function validateRangeAwareSelectiveWidening(label, value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`DopplerConfigError: ${label} is required.`);
+  }
+  if (value.enabled !== true && value.enabled !== false) {
+    throw new Error(`DopplerConfigError: ${label}.enabled must be boolean.`);
+  }
+  if (value.includeNonFinite !== true && value.includeNonFinite !== false) {
+    throw new Error(`DopplerConfigError: ${label}.includeNonFinite must be boolean.`);
+  }
+  if (!Number.isFinite(value.absThreshold) || value.absThreshold <= 0) {
+    throw new Error(`DopplerConfigError: ${label}.absThreshold must be a positive number.`);
+  }
+}
+
+function validateKernelPathPolicy(label, value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error(`DopplerConfigError: ${label} must be an object.`);
+  }
+  if (value.mode !== 'locked' && value.mode !== 'capability-aware') {
+    throw new Error(`DopplerConfigError: ${label}.mode must be "locked" or "capability-aware".`);
+  }
+  const sourceScope = value.sourceScope ?? value.allowSources;
+  if (!Array.isArray(sourceScope) || sourceScope.length === 0) {
+    throw new Error(`DopplerConfigError: ${label}.sourceScope must be a non-empty array.`);
+  }
+  if (value.onIncompatible !== 'error' && value.onIncompatible !== 'remap') {
+    throw new Error(`DopplerConfigError: ${label}.onIncompatible must be "error" or "remap".`);
+  }
+  const validSources = new Set(['model', 'manifest', 'config', 'runtime', 'execution-v0']);
+  for (const source of sourceScope) {
+    if (!validSources.has(source)) {
+      throw new Error(
+        `DopplerConfigError: ${label}.sourceScope entries must be model|manifest|config|runtime|execution-v0.`
+      );
+    }
+  }
+}

package/src/config/platforms/amd-rdna3.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "./platform.schema.json",
+  "id": "amd-rdna3",
+  "name": "AMD RDNA 3",
+  "detection": {
+    "vendor": "amd",
+    "architecture": "rdna3"
+  },
+  "memoryHints": {
+    "preferUnifiedMemory": false,
+    "bufferAlignment": 256,
+    "optimalShardSize": 134217728,
+    "maxBufferPoolSize": 4294967296
+  },
+  "notes": "AMD RX 7900 series - RDNA 3 architecture, subgroups, F16"
+}

package/src/config/platforms/apple-m1.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "./platform.schema.json",
+  "id": "apple-m1",
+  "name": "Apple M1 Series",
+  "detection": {
+    "vendor": "apple",
+    "architecture": "gpu-family-apple-7"
+  },
+  "memoryHints": {
+    "preferUnifiedMemory": true,
+    "bufferAlignment": 256,
+    "optimalShardSize": 67108864,
+    "maxBufferPoolSize": 536870912
+  },
+  "notes": "Apple M1 series (M1, M1 Pro, M1 Max, M1 Ultra) - gpu-family-apple-7, no subgroups in early Chrome versions"
+}

package/src/config/platforms/apple-m2.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "./platform.schema.json",
+  "id": "apple-m2",
+  "name": "Apple M2 Series",
+  "detection": {
+    "vendor": "apple",
+    "architecture": "gpu-family-apple-8"
+  },
+  "memoryHints": {
+    "preferUnifiedMemory": true,
+    "bufferAlignment": 256,
+    "optimalShardSize": 67108864,
+    "maxBufferPoolSize": 1073741824
+  },
+  "notes": "Apple M2 series (M2, M2 Pro, M2 Max, M2 Ultra) - gpu-family-apple-8, subgroups, F16"
+}

package/src/config/platforms/apple-m3.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "./platform.schema.json",
+  "id": "apple-m3",
+  "name": "Apple M3 Series",
+  "detection": {
+    "vendor": "apple",
+    "architecture": "gpu-family-apple-9"
+  },
+  "memoryHints": {
+    "preferUnifiedMemory": true,
+    "bufferAlignment": 256,
+    "optimalShardSize": 67108864,
+    "maxBufferPoolSize": 2147483648
+  },
+  "notes": "Apple M3 series (M3, M3 Pro, M3 Max, M3 Ultra) - gpu-family-apple-9, subgroups, F16"
+}

package/src/config/platforms/generic.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "./platform.schema.json",
+  "id": "generic",
+  "name": "Generic WebGPU Device",
+  "detection": {},
+  "isGeneric": true,
+  "memoryHints": {
+    "preferUnifiedMemory": false,
+    "bufferAlignment": 256,
+    "optimalShardSize": 67108864,
+    "maxBufferPoolSize": 1073741824
+  },
+  "notes": "Fallback configuration for unknown GPU devices. Uses conservative settings."
+}

package/src/config/platforms/loader.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Platform Loader
+ *
+ * Detects the current GPU platform and loads appropriate configs.
+ * Provides platform metadata and memory hints.
+ *
+ * @module config/platforms/loader
+ */
+
+import type {
+  PlatformSchema,
+  RuntimeCapabilities,
+  ResolvedPlatformConfig,
+  MemoryHintsSchema,
+} from '../schema/platform.schema.js';
+
+/**
+ * Set the base URL for loading platform configs.
+ */
+export function setPlatformsBaseUrl(baseUrl: string): void;
+
+/**
+ * Detect platform from WebGPU adapter info.
+ */
+export function detectPlatform(adapterInfo: GPUAdapterInfo): Promise<PlatformSchema>;
+
+/**
+ * Initialize platform detection with a WebGPU adapter.
+ */
+export function initializePlatform(adapter: GPUAdapter): Promise<ResolvedPlatformConfig>;
+
+/**
+ * Get the current platform (throws if not initialized).
+ */
+export function getPlatform(): PlatformSchema;
+
+/**
+ * Get the current runtime capabilities (throws if not initialized).
+ */
+export function getCapabilities(): RuntimeCapabilities;
+
+/**
+ * Get memory hints for current platform.
+ */
+export function getMemoryHints(): MemoryHintsSchema | undefined;
+
+/**
+ * Check if current platform prefers unified memory strategies.
+ */
+export function prefersUnifiedMemory(): boolean;
+
+/**
+ * Get optimal buffer alignment for current platform.
+ */
+export function getBufferAlignment(): number;
+
+/**
+ * Clear all cached platform data. Useful for hot-reloading.
+ */
+export function clearPlatformCache(): void;
+
+/**
+ * Get resolved platform config with capabilities.
+ */
+export function getResolvedPlatformConfig(): ResolvedPlatformConfig;

package/src/config/platforms/loader.js

@@ -0,0 +1,153 @@
+import { getRuntimeConfig } from '../runtime.js';
+import { loadJson } from '../../utils/load-json.js';
+
+let currentPlatform = null;
+
+let currentCapabilities = null;
+
+const platformCache = new Map();
+
+let platformsBaseUrl = null;
+
+const PLATFORM_FILES = [
+  'apple-m3',
+  'apple-m2',
+  'apple-m1',
+  'nvidia-rtx40',
+  'nvidia-rtx30',
+  'amd-rdna3',
+  'generic',
+];
+
+export function setPlatformsBaseUrl(baseUrl) {
+  platformsBaseUrl = baseUrl;
+  platformCache.clear();
+  currentPlatform = null;
+}
+
+async function loadPlatformConfig(platformId) {
+  if (platformCache.has(platformId)) {
+    return platformCache.get(platformId) || null;
+  }
+
+  try {
+    const baseUrl = platformsBaseUrl || new URL('./', import.meta.url).href;
+    const config = await loadJson(`${platformId}.json`, baseUrl, 'Failed to load platform config');
+    if (!config) {
+      return null;
+    }
+    platformCache.set(platformId, config);
+    return config;
+  } catch {
+    return null;
+  }
+}
+
+export async function detectPlatform(adapterInfo) {
+  const vendor = adapterInfo.vendor?.toLowerCase() || '';
+  const architecture = adapterInfo.architecture?.toLowerCase() || '';
+  const device = adapterInfo.device?.toLowerCase() || '';
+  const description = adapterInfo.description?.toLowerCase() || '';
+
+  for (const platformId of PLATFORM_FILES) {
+    const config = await loadPlatformConfig(platformId);
+    if (!config) continue;
+
+    const detection = config.detection;
+    let matches = true;
+
+    if (detection.vendor && !vendor.includes(detection.vendor.toLowerCase())) {
+      matches = false;
+    }
+    if (detection.architecture && !architecture.includes(detection.architecture.toLowerCase())) {
+      matches = false;
+    }
+    if (detection.device && !device.includes(detection.device.toLowerCase())) {
+      matches = false;
+    }
+    if (detection.description && !description.includes(detection.description.toLowerCase())) {
+      matches = false;
+    }
+
+    if (matches && !config.isGeneric) {
+      currentPlatform = config;
+      return config;
+    }
+  }
+
+  const genericConfig = await loadPlatformConfig('generic');
+  if (genericConfig) {
+    currentPlatform = genericConfig;
+    return genericConfig;
+  }
+
+  const fallback = {
+    id: 'unknown',
+    name: 'Unknown Platform',
+    detection: {},
+    isGeneric: true,
+  };
+  currentPlatform = fallback;
+  return fallback;
+}
+
+export async function initializePlatform(adapter) {
+  const adapterInfo = adapter.info;
+  const platform = await detectPlatform(adapterInfo);
+
+  const features = adapter.features;
+  currentCapabilities = {
+    hasF16: features.has('shader-f16'),
+    hasSubgroups: features.has('subgroups'),
+    subgroupSize: features.has('subgroups') ? 32 : undefined,
+    maxWorkgroupSize: adapter.limits.maxComputeWorkgroupSizeX,
+    maxSharedMemory: adapter.limits.maxComputeWorkgroupStorageSize,
+    maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
+    maxBufferSize: adapter.limits.maxBufferSize,
+  };
+
+  return {
+    platform,
+    capabilities: currentCapabilities,
+  };
+}
+
+export function getPlatform() {
+  if (!currentPlatform) {
+    throw new Error('Platform not initialized. Call initializePlatform() first.');
+  }
+  return currentPlatform;
+}
+
+export function getCapabilities() {
+  if (!currentCapabilities) {
+    throw new Error('Platform not initialized. Call initializePlatform() first.');
+  }
+  return currentCapabilities;
+}
+
+export function getMemoryHints() {
+  return getPlatform().memoryHints;
+}
+
+export function prefersUnifiedMemory() {
+  return getMemoryHints()?.preferUnifiedMemory ?? false;
+}
+
+export function getBufferAlignment() {
+  const fallback = getRuntimeConfig().loading.storage.alignment.bufferAlignmentBytes;
+  return getMemoryHints()?.bufferAlignment ?? fallback;
+}
+
+export function clearPlatformCache() {
+  platformCache.clear();
+  currentPlatform = null;
+  currentCapabilities = null;
+}
+
+export function getResolvedPlatformConfig() {
+  return {
+    platform: getPlatform(),
+    capabilities: getCapabilities(),
+  };
+}

package/src/config/platforms/nvidia-rtx30.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "./platform.schema.json",
+  "id": "nvidia-rtx30",
+  "name": "NVIDIA RTX 30 Series",
+  "detection": {
+    "vendor": "nvidia",
+    "device": "rtx 30"
+  },
+  "memoryHints": {
+    "preferUnifiedMemory": false,
+    "bufferAlignment": 256,
+    "optimalShardSize": 134217728,
+    "maxBufferPoolSize": 4294967296
+  },
+  "notes": "NVIDIA RTX 3090/3080/3070 series - Ampere architecture, subgroups, F16"
+}

package/src/config/platforms/nvidia-rtx40.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "./platform.schema.json",
+  "id": "nvidia-rtx40",
+  "name": "NVIDIA RTX 40 Series",
+  "detection": {
+    "vendor": "nvidia",
+    "device": "rtx 40"
+  },
+  "memoryHints": {
+    "preferUnifiedMemory": false,
+    "bufferAlignment": 256,
+    "optimalShardSize": 134217728,
+    "maxBufferPoolSize": 8589934592
+  },
+  "notes": "NVIDIA RTX 4090/4080/4070 series - Ada Lovelace architecture, subgroups, F16, large VRAM"
+}

package/src/config/presets/kernel-paths/embeddinggemma-f16-f32a.json

@@ -0,0 +1,60 @@
+{
+  "id": "embeddinggemma-f16-f32a",
+  "name": "EmbeddingGemma F16 (F32 activations)",
+  "description": "F16 weights with F32 activations for embedding stability.",
+  "activationDtype": "f32",
+
+  "decode": {
+    "steps": [
+      { "op": "input_norm",   "kernel": "rmsnorm.wgsl",         "entry": "main" },
+      { "op": "q_proj",       "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.self_attn.q_proj" },
+      { "op": "k_proj",       "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.self_attn.k_proj" },
+      { "op": "v_proj",       "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.self_attn.v_proj" },
+      { "op": "rope_q",       "kernel": "rope.wgsl",            "entry": "main" },
+      { "op": "rope_k",       "kernel": "rope.wgsl",            "entry": "main" },
+      { "op": "attention",    "kernel": "attention_small.wgsl", "entry": "main" },
+      { "op": "o_proj",       "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.self_attn.o_proj" },
+      { "op": "attn_residual","kernel": "residual.wgsl",        "entry": "main" },
+      { "op": "post_attn_norm","kernel": "rmsnorm.wgsl",        "entry": "main" },
+      { "op": "gate_proj",    "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.mlp.gate_proj" },
+      { "op": "up_proj",      "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.mlp.up_proj" },
+      { "op": "activation",   "kernel": "gelu.wgsl",            "entry": "main", "constants": { "HAS_GATE": true } },
+      { "op": "down_proj",    "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.mlp.down_proj" },
+      { "op": "ffn_residual", "kernel": "residual.wgsl",        "entry": "main" }
+    ]
+  },
+
+  "prefill": {
+    "steps": [
+      { "op": "input_norm",   "kernel": "rmsnorm.wgsl",         "entry": "main" },
+      { "op": "q_proj",       "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.self_attn.q_proj" },
+      { "op": "k_proj",       "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.self_attn.k_proj" },
+      { "op": "v_proj",       "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.self_attn.v_proj" },
+      { "op": "rope_q",       "kernel": "rope.wgsl",            "entry": "main" },
+      { "op": "rope_k",       "kernel": "rope.wgsl",            "entry": "main" },
+      { "op": "attention",    "kernel": "attention_small.wgsl", "entry": "main" },
+      { "op": "o_proj",       "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.self_attn.o_proj" },
+      { "op": "attn_residual","kernel": "residual.wgsl",        "entry": "main" },
+      { "op": "post_attn_norm","kernel": "rmsnorm.wgsl",        "entry": "main" },
+      { "op": "gate_proj",    "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.mlp.gate_proj" },
+      { "op": "up_proj",      "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.mlp.up_proj" },
+      { "op": "activation",   "kernel": "gelu.wgsl",            "entry": "main", "constants": { "HAS_GATE": true } },
+      { "op": "down_proj",    "kernel": "matmul_f16w_f32a.wgsl","entry": "main",  "weights": "layer.{L}.mlp.down_proj" },
+      { "op": "ffn_residual", "kernel": "residual.wgsl",        "entry": "main" }
+    ]
+  },
+
+  "preLayer": [
+    { "op": "embed", "kernel": "gather.wgsl", "entry": "main", "weights": "embed_tokens" }
+  ],
+
+  "postLayer": [
+    { "op": "final_norm", "kernel": "rmsnorm.wgsl", "entry": "main" },
+    { "op": "lm_head", "kernel": "matmul_f16w_f32a.wgsl", "entry": "main", "weights": "lm_head" },
+    { "op": "lm_head_prefill", "kernel": "matmul_f16w_f32a.wgsl", "entry": "main", "weights": "lm_head" }
+  ],
+
+  "sampling": [
+    { "op": "sample", "kernel": "sample.wgsl", "entry": "sample_single_pass" }
+  ]
+}