@simulatte/doppler 0.1.8 → 0.2.0

package/src/inference/pipelines/text/execution-v0-runtime-builders.d.ts

@@ -1,15 +0,0 @@
-export declare function resolveFinitenessFallbackKernelPathId(defaultKernelPathId: string | null): string | null;
-export declare function buildInlineKernelPath(
-  steps: Array<Record<string, unknown>>,
-  sessionDefaults: Record<string, unknown>,
-  modelId: string,
-  numLayers: number,
-  finitenessFallbackKernelPathId?: string | null
-): Record<string, unknown> | null;
-export declare function buildLayerPipelineFromExecution(
-  steps: Array<Record<string, unknown>>
-): Record<string, unknown> | null;
-export declare function buildSessionRuntimePatch(sessionDefaults: Record<string, unknown>): Record<string, unknown>;
-export declare function buildModelRuntimeOverrides(
-  manifestInference: Record<string, unknown> | null | undefined
-): Record<string, unknown> | null;

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

@@ -1,279 +0,0 @@
-import { selectRuleValue } from '../../../rules/rule-registry.js';
-import { cloneJson, isPhaseMatch, normalizeDtype, requireSessionActivationDtype, stepHasLayer } from './execution-v0-contract-helpers.js';
-
-const PIPELINE_COMPATIBLE_OPS = new Set([
-  'save',
-  'load',
-  'conv',
-  'attention',
-  'rmsnorm',
-  'ffn',
-  'residual_add',
-  'cast',
-  'noop',
-]);
-
-function toKernelPathStep(step) {
-  if (step.op === 'cast') return null;
-  if (!step.kernel) return null;
-  return {
-    op: step.op,
-    kernel: step.kernel,
-    entry: step.entry ?? 'main',
-    ...(step.weights ? { weights: step.weights } : {}),
-    ...(step.constants ? { constants: step.constants } : {}),
-  };
-}
-
-function getSectionSteps(steps, section, phase = null) {
-  return steps
-    .filter((step) => step.section === section)
-    .filter((step) => (phase ? isPhaseMatch(step.phase, phase) : true))
-    .map(toKernelPathStep)
-    .filter((step) => step != null);
-}
-
-function buildLayerPhaseSteps(steps, phase, layerIdx) {
-  return steps
-    .filter((step) => step.section === 'layer' && isPhaseMatch(step.phase, phase))
-    .filter((step) => stepHasLayer(step, layerIdx))
-    .map(toKernelPathStep)
-    .filter((step) => step != null);
-}
-
-function getInlineKernelPathSteps(path) {
-  return [
-    ...(path?.preLayer ?? []),
-    ...(path?.decode?.steps ?? []),
-    ...(path?.prefill?.steps ?? []),
-    ...(path?.postLayer ?? []),
-    ...(path?.sampling ?? []),
-    ...(path?.layerOverrides?.flatMap((override) => override.steps ?? []) ?? []),
-  ];
-}
-
-function assertInlineKernelPathSessionCompatibility(path, sessionDefaults) {
-  if (!path) {
-    return;
-  }
-  const activationDtype = normalizeDtype(
-    path.activationDtype ?? requireSessionActivationDtype(sessionDefaults),
-    'inlineKernelPath.activationDtype'
-  );
-  const kvDtype = normalizeDtype(
-    path.kvDtype ?? sessionDefaults?.kvcache?.kvDtype ?? activationDtype,
-    'inlineKernelPath.kvDtype'
-  );
-
-  for (const step of getInlineKernelPathSteps(path)) {
-    const kernel = String(step?.kernel ?? '').trim();
-    if (!kernel.startsWith('attention')) {
-      continue;
-    }
-    if (kernel.includes('_f16kv')) {
-      if (activationDtype !== 'f32' || kvDtype !== 'f16') {
-        throw new Error(
-          `[ExecutionV0] Inline kernelPath attention kernel "${kernel}" requires ` +
-          `activationDtype="f32" and kvcache.kvDtype="f16", but resolved ` +
-          `activationDtype="${activationDtype}" and kvcache.kvDtype="${kvDtype}".`
-        );
-      }
-      continue;
-    }
-    if (kernel.includes('_f16')) {
-      if (activationDtype !== 'f16' || kvDtype !== 'f16') {
-        throw new Error(
-          `[ExecutionV0] Inline kernelPath attention kernel "${kernel}" requires ` +
-          `activationDtype="f16" and kvcache.kvDtype="f16", but resolved ` +
-          `activationDtype="${activationDtype}" and kvcache.kvDtype="${kvDtype}".`
-        );
-      }
-      continue;
-    }
-    if (activationDtype !== 'f32' || kvDtype !== 'f32') {
-      throw new Error(
-        `[ExecutionV0] Inline kernelPath attention kernel "${kernel}" requires ` +
-        `activationDtype="f32" and kvcache.kvDtype="f32", but resolved ` +
-        `activationDtype="${activationDtype}" and kvcache.kvDtype="${kvDtype}".`
-      );
-    }
-  }
-}
-
-export function resolveFinitenessFallbackKernelPathId(defaultKernelPathId) {
-  return defaultKernelPathId
-    ? selectRuleValue(
-      'inference',
-      'kernelPath',
-      'finitenessFallback',
-      { kernelPathId: defaultKernelPathId }
-    )
-    : null;
-}
-
-export function buildInlineKernelPath(
-  steps,
-  sessionDefaults,
-  modelId,
-  numLayers,
-  finitenessFallbackKernelPathId = null
-) {
-  const activationDtype = requireSessionActivationDtype(sessionDefaults);
-  const kvDtype = normalizeDtype(
-    sessionDefaults?.kvcache?.kvDtype ?? activationDtype,
-    'sessionDefaults.kvcache.kvDtype'
-  );
-  const decodeSteps = buildLayerPhaseSteps(steps, 'decode', 0);
-  const prefillSteps = buildLayerPhaseSteps(steps, 'prefill', 0);
-  if (decodeSteps.length === 0 && prefillSteps.length === 0) {
-    return null;
-  }
-
-  const path = {
-    id: `${modelId || 'model'}-execution-v0`,
-    name: 'Execution v0 inline kernel path',
-    description: 'Generated from manifest.inference.execution.steps',
-    activationDtype,
-    kvDtype,
-    ...(typeof finitenessFallbackKernelPathId === 'string' && finitenessFallbackKernelPathId.length > 0
-      ? { finitenessFallbackKernelPathId }
-      : {}),
-    decode: {
-      steps: decodeSteps.length > 0 ? decodeSteps : prefillSteps,
-    },
-    prefill: {
-      steps: prefillSteps.length > 0 ? prefillSteps : decodeSteps,
-    },
-  };
-
-  if (numLayers > 0) {
-    const overrides = [];
-    for (let layerIdx = 0; layerIdx < numLayers; layerIdx++) {
-      const decodeLayerSteps = buildLayerPhaseSteps(steps, 'decode', layerIdx);
-      const prefillLayerSteps = buildLayerPhaseSteps(steps, 'prefill', layerIdx);
-      const hasCustomDecode = JSON.stringify(decodeLayerSteps) !== JSON.stringify(path.decode.steps);
-      const hasCustomPrefill = JSON.stringify(prefillLayerSteps) !== JSON.stringify(path.prefill.steps);
-      if (!hasCustomDecode && !hasCustomPrefill) continue;
-      const mergedLayerSteps = decodeLayerSteps.length > 0
-        ? decodeLayerSteps
-        : prefillLayerSteps;
-      if (mergedLayerSteps.length > 0) {
-        overrides.push({
-          layers: [layerIdx],
-          steps: mergedLayerSteps,
-        });
-      }
-    }
-    if (overrides.length > 0) {
-      path.layerOverrides = overrides;
-    }
-  }
-
-  const preLayer = getSectionSteps(steps, 'preLayer');
-  if (preLayer.length > 0) {
-    path.preLayer = preLayer;
-  }
-  const postLayer = getSectionSteps(steps, 'postLayer');
-  if (postLayer.length > 0) {
-    path.postLayer = postLayer;
-  }
-  const sampling = getSectionSteps(steps, 'sampling', 'decode');
-  if (sampling.length > 0) {
-    path.sampling = sampling;
-  }
-
-  assertInlineKernelPathSessionCompatibility(path, sessionDefaults);
-  return path;
-}
-
-export function buildLayerPipelineFromExecution(steps) {
-  const layerSectionSteps = steps.filter((step) => step.section === 'layer');
-  if (layerSectionSteps.length === 0) {
-    return null;
-  }
-  if (layerSectionSteps.some((step) => !PIPELINE_COMPATIBLE_OPS.has(step.op))) {
-    return null;
-  }
-
-  const layerSteps = layerSectionSteps
-    .map((step) => ({
-      op: step.op,
-      phase: step.phase,
-      src: step.src ?? 'state',
-      dst: step.dst ?? 'state',
-      ...(step.residual !== undefined ? { residual: step.residual } : {}),
-      ...(step.a !== undefined ? { a: step.a } : {}),
-      ...(step.b !== undefined ? { b: step.b } : {}),
-      ...(step.variant !== undefined ? { variant: step.variant } : {}),
-      ...(step.skipInputNorm !== undefined ? { skipInputNorm: step.skipInputNorm } : {}),
-      ...(step.precision?.inputDtype ? { inputDtype: step.precision.inputDtype } : {}),
-      ...(step.precision?.outputDtype ? { outputDtype: step.precision.outputDtype } : {}),
-      ...(step.fromDtype ? { fromDtype: step.fromDtype } : {}),
-      ...(step.toDtype ? { toDtype: step.toDtype } : {}),
-      ...(step.probeStage ? { probeStage: step.probeStage } : {}),
-      ...(step.name ? { name: step.name } : {}),
-      ...(step.weight ? { weight: step.weight } : {}),
-    }));
-
-  return {
-    steps: layerSteps,
-    overrides: [],
-  };
-}
-
-export function buildSessionRuntimePatch(sessionDefaults) {
-  const patch = {};
-  const computeDefaults = sessionDefaults?.compute?.defaults ?? null;
-  const computePatch = {};
-  const sessionComputeDefaultsPatch = {};
-  const activationDtype = computeDefaults?.activationDtype;
-  if (activationDtype) {
-    computePatch.activationDtype = activationDtype;
-  }
-  if (computeDefaults?.mathDtype) {
-    sessionComputeDefaultsPatch.mathDtype = computeDefaults.mathDtype;
-  }
-  if (computeDefaults?.accumDtype) {
-    sessionComputeDefaultsPatch.accumDtype = computeDefaults.accumDtype;
-  }
-  if (computeDefaults?.outputDtype) {
-    sessionComputeDefaultsPatch.outputDtype = computeDefaults.outputDtype;
-  }
-  if (Object.keys(computePatch).length > 0) {
-    patch.compute = computePatch;
-  }
-  if (Object.keys(sessionComputeDefaultsPatch).length > 0) {
-    patch.session = {
-      compute: {
-        defaults: sessionComputeDefaultsPatch,
-      },
-    };
-  }
-  if (sessionDefaults?.kvcache) {
-    patch.kvcache = sessionDefaults.kvcache;
-  }
-  if (sessionDefaults?.decodeLoop) {
-    patch.batching = {
-      batchSize: sessionDefaults.decodeLoop.batchSize,
-      stopCheckMode: sessionDefaults.decodeLoop.stopCheckMode,
-      readbackInterval: sessionDefaults.decodeLoop.readbackInterval,
-      ringTokens: sessionDefaults.decodeLoop.ringTokens,
-      ringStop: sessionDefaults.decodeLoop.ringStop,
-      ringStaging: sessionDefaults.decodeLoop.ringStaging,
-    };
-    if (sessionDefaults.decodeLoop.disableCommandBatching !== undefined) {
-      patch.generation = {
-        disableCommandBatching: sessionDefaults.decodeLoop.disableCommandBatching === true,
-      };
-    }
-  }
-  return patch;
-}
-
-export function buildModelRuntimeOverrides(manifestInference) {
-  const model = manifestInference?.model;
-  if (!model || typeof model !== 'object') {
-    return null;
-  }
-  return cloneJson(model);
-}

package/src/inference/pipelines/text/execution-v0.d.ts

@@ -1,66 +0,0 @@
-import type {
-  ExecutionV0ConfigSchema,
-  ExecutionV0FieldSourceMap,
-  ExecutionV0PatchSchema,
-  ExecutionV0PoliciesSchema,
-  ExecutionV0SessionDefaultsSchema,
-  ResolvedExecutionV0StepSchema,
-} from '../../../config/schema/execution-v0.schema.js';
-
-export interface CompileExecutionV0Options {
-  manifestInference?: {
-    schema?: string | null;
-    execution?: ExecutionV0ConfigSchema['execution'] | null;
-    sessionDefaults?: ExecutionV0SessionDefaultsSchema | null;
-    model?: Record<string, unknown> | null;
-  } | null;
-  runtimeInference?: {
-    session?: ExecutionV0SessionDefaultsSchema | null;
-    executionPatch?: ExecutionV0PatchSchema | null;
-  } | null;
-  modelId?: string;
-  numLayers?: number;
-}
-
-export interface CompiledExecutionV0RuntimeState {
-  sessionDefaults: ExecutionV0SessionDefaultsSchema;
-  policies: ExecutionV0PoliciesSchema;
-  resolvedSteps: {
-    prefill: ResolvedExecutionV0StepSchema[];
-    decode: ResolvedExecutionV0StepSchema[];
-    all: ResolvedExecutionV0StepSchema[];
-  };
-  resolvedSources: {
-    session: ExecutionV0FieldSourceMap;
-    steps: Record<string, ExecutionV0FieldSourceMap>;
-  };
-  runtimeInferencePatch: Record<string, unknown>;
-}
-
-export interface ApplyExecutionV0RuntimeConfigOptions {
-  runtimeConfig?: {
-    inference?: Record<string, unknown>;
-  } | null;
-  manifest?: {
-    modelId?: string | null;
-    architecture?: {
-      numLayers?: number | null;
-    } | null;
-    inference?: CompileExecutionV0Options['manifestInference'];
-  } | null;
-  modelId?: string;
-  numLayers?: number;
-}
-
-export declare function hasExecutionV0(
-  manifestInference: CompileExecutionV0Options['manifestInference']
-): boolean;
-
-export declare function compileExecutionV0(
-  options?: CompileExecutionV0Options
-): CompiledExecutionV0RuntimeState | null;
-
-export declare function applyExecutionV0RuntimeConfig(options?: ApplyExecutionV0RuntimeConfigOptions): {
-  runtimeConfig: ApplyExecutionV0RuntimeConfigOptions['runtimeConfig'];
-  executionV0State: CompiledExecutionV0RuntimeState | null;
-};

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

@@ -1,255 +0,0 @@
-import { mergeRuntimeValues } from '../../../config/runtime-merge.js';
-import { buildExecutionV0FromKernelPath } from '../../../converter/execution-v0-manifest.js';
-import {
-  DEFAULT_EXECUTION_V0_COMPUTE_DEFAULTS,
-  DEFAULT_EXECUTION_V0_POLICIES,
-  DEFAULT_EXECUTION_V0_SESSION_DEFAULTS,
-} from '../../../config/schema/execution-v0.schema.js';
-import {
-  applyExecutionPatchAtomic,
-  assertExecutionRuntimeOverlay,
-  assertExecutionV0Schema,
-  assertKVLayoutExecutionCompatibility,
-  collectLeafPaths,
-  createInitialSlotDtypes,
-  createSourceTrace,
-  hasDefinedPath,
-  indexKernelProfiles,
-  indexRuntimePatchMeta,
-  normalizeRuntimeSessionForExecutionV0,
-  resolvePhaseSteps,
-  setSourceTrace,
-  validateManifestSessionDefaultsContract,
-  validatePhaseBoundaryCompatibility,
-  validateStepShape,
-  validateUniqueStepIds,
-  cloneJson,
-} from './execution-v0-contract-helpers.js';
-import {
-  buildInlineKernelPath,
-  buildLayerPipelineFromExecution,
-  buildModelRuntimeOverrides,
-  buildSessionRuntimePatch,
-  resolveFinitenessFallbackKernelPathId,
-} from './execution-v0-runtime-builders.js';
-
-export function hasExecutionV0(manifestInference) {
-  return !!manifestInference?.execution && Array.isArray(manifestInference.execution.steps);
-}
-
-export function compileExecutionV0(options = {}) {
-  const manifestInference = options.manifestInference ?? null;
-  if (!hasExecutionV0(manifestInference)) {
-    return null;
-  }
-  assertExecutionV0Schema(manifestInference);
-  validateManifestSessionDefaultsContract(manifestInference);
-
-  const modelId = options.modelId ?? 'model';
-  const numLayers = Number.isInteger(options.numLayers) ? options.numLayers : 0;
-  const runtimeInference = options.runtimeInference ?? {};
-  assertExecutionRuntimeOverlay(runtimeInference);
-  const policies = {
-    ...DEFAULT_EXECUTION_V0_POLICIES,
-    ...(manifestInference.execution?.policies ?? {}),
-  };
-  const normalizedRuntimeSession = normalizeRuntimeSessionForExecutionV0(
-    runtimeInference.session ?? {},
-    manifestInference,
-    DEFAULT_EXECUTION_V0_COMPUTE_DEFAULTS
-  );
-  const sessionDefaults = mergeRuntimeValues(
-    DEFAULT_EXECUTION_V0_SESSION_DEFAULTS,
-    manifestInference.sessionDefaults ?? {}
-  );
-  const resolvedSession = mergeRuntimeValues(
-    sessionDefaults,
-    normalizedRuntimeSession ?? {}
-  );
-
-  const baseSteps = cloneJson(manifestInference.execution.steps ?? []);
-  baseSteps.forEach(validateStepShape);
-  validateUniqueStepIds(baseSteps);
-
-  const patchedSteps = applyExecutionPatchAtomic(baseSteps, runtimeInference.executionPatch ?? null);
-  patchedSteps.forEach(validateStepShape);
-  validateUniqueStepIds(patchedSteps);
-  assertKVLayoutExecutionCompatibility(patchedSteps, resolvedSession);
-  const runtimePatchMeta = indexRuntimePatchMeta(runtimeInference.executionPatch ?? null);
-
-  const manifestSessionDefaults = manifestInference.sessionDefaults ?? {};
-  const sessionSourceByPath = new Map();
-  for (const pathSegments of collectLeafPaths(resolvedSession)) {
-    const path = pathSegments.join('.');
-    const source = hasDefinedPath(runtimeInference.session ?? {}, pathSegments)
-      ? 'runtime.session'
-      : hasDefinedPath(manifestSessionDefaults, pathSegments)
-        ? 'manifest'
-        : 'derived';
-    sessionSourceByPath.set(path, source);
-  }
-
-  const profileIndex = indexKernelProfiles(resolvedSession);
-  const sourceTrace = createSourceTrace();
-  const sessionDefaultSources = {
-    mathDtype: sessionSourceByPath.get('compute.defaults.mathDtype') ?? 'derived',
-    accumDtype: sessionSourceByPath.get('compute.defaults.accumDtype') ?? 'derived',
-    outputDtype: sessionSourceByPath.get('compute.defaults.outputDtype') ?? 'derived',
-    kvDtype: sessionSourceByPath.get('kvcache.kvDtype') ?? 'derived',
-  };
-  const resolvedPrefill = resolvePhaseSteps(
-    'prefill',
-    patchedSteps,
-    resolvedSession,
-    profileIndex,
-    policies,
-    {
-      initialSlotDtypes: createInitialSlotDtypes(resolvedSession),
-      sourceTrace,
-      sessionDefaultSources,
-      runtimePatchMeta,
-    }
-  );
-  const decodeInitialSlotDtypes = createInitialSlotDtypes(resolvedSession);
-  validatePhaseBoundaryCompatibility({
-    steps: patchedSteps,
-    prefillFinalSlotDtypes: resolvedPrefill.finalSlotDtypes,
-    decodeInitialSlotDtypes,
-    sessionDefaults: resolvedSession,
-    profileIndex,
-    policies,
-  });
-  const resolvedDecode = resolvePhaseSteps(
-    'decode',
-    patchedSteps,
-    resolvedSession,
-    profileIndex,
-    policies,
-    {
-      initialSlotDtypes: decodeInitialSlotDtypes,
-      sourceTrace,
-      sessionDefaultSources,
-      runtimePatchMeta,
-    }
-  );
-  const resolvedPrefillSteps = resolvedPrefill.steps;
-  const resolvedDecodeSteps = resolvedDecode.steps;
-  const resolvedSteps = [
-    ...resolvedPrefillSteps,
-    ...resolvedDecodeSteps.filter((step) => step.phase === 'decode'),
-  ];
-
-  const defaultKernelPathId = typeof manifestInference.defaultKernelPath === 'string'
-    && manifestInference.defaultKernelPath.trim().length > 0
-    ? manifestInference.defaultKernelPath.trim()
-    : null;
-  const finitenessFallbackKernelPathId = resolveFinitenessFallbackKernelPathId(defaultKernelPathId);
-
-  const kernelPath = buildInlineKernelPath(
-    patchedSteps,
-    resolvedSession,
-    modelId,
-    numLayers,
-    finitenessFallbackKernelPathId
-  );
-  const layerPipeline = buildLayerPipelineFromExecution(resolvedSteps);
-  const sessionPatch = buildSessionRuntimePatch(resolvedSession);
-  const modelOverrides = buildModelRuntimeOverrides(manifestInference);
-  for (const [path, source] of sessionSourceByPath.entries()) {
-    setSourceTrace(sourceTrace.session, `sessionDefaults.${path}`, source);
-  }
-
-  return {
-    sessionDefaults: resolvedSession,
-    policies,
-    resolvedSteps: {
-      prefill: resolvedPrefillSteps,
-      decode: resolvedDecodeSteps,
-      all: resolvedSteps,
-    },
-    runtimeInferencePatch: {
-      ...sessionPatch,
-      ...(kernelPath ? { kernelPath, kernelPathSource: 'execution-v0' } : {}),
-      ...(layerPipeline ? { pipeline: layerPipeline } : {}),
-      ...(modelOverrides ? { modelOverrides } : {}),
-    },
-    resolvedSources: sourceTrace,
-  };
-}
-
-export function applyExecutionV0RuntimeConfig(options = {}) {
-  const runtimeConfig = options.runtimeConfig ?? null;
-  const manifest = options.manifest ?? null;
-  if (!runtimeConfig || !manifest?.inference) {
-    return { runtimeConfig, executionV0State: null };
-  }
-  if (!hasExecutionV0(manifest.inference)) {
-    return { runtimeConfig, executionV0State: null };
-  }
-
-  const runtimeInference = runtimeConfig.inference ?? {};
-  const kernelPathExecution = runtimeInference.kernelPath !== undefined
-    ? buildExecutionV0FromKernelPath(runtimeInference.kernelPath)
-    : null;
-  const manifestInference = kernelPathExecution
-    ? {
-      ...manifest.inference,
-      ...kernelPathExecution,
-      defaultKernelPath: runtimeInference.kernelPath,
-    }
-    : manifest.inference;
-  const runtimeExecutionOverlay = {
-    ...(runtimeInference.session ? { session: runtimeInference.session } : {}),
-    ...(runtimeInference.executionPatch ? { executionPatch: runtimeInference.executionPatch } : {}),
-  };
-
-  const executionV0State = compileExecutionV0({
-    manifestInference,
-    runtimeInference: runtimeExecutionOverlay,
-    modelId: options.modelId ?? manifest.modelId ?? 'model',
-    numLayers: Number.isInteger(options.numLayers)
-      ? options.numLayers
-      : Number(manifest.architecture?.numLayers ?? 0),
-  });
-  if (!executionV0State) {
-    return { runtimeConfig, executionV0State: null };
-  }
-
-  const compiledKernelPathSource = runtimeInference.kernelPath !== undefined
-    ? 'config'
-    : 'manifest';
-  const runtimeInferencePatch = { ...executionV0State.runtimeInferencePatch };
-  if (runtimeInferencePatch.kernelPathSource) {
-    runtimeInferencePatch.kernelPathSource = compiledKernelPathSource;
-  }
-  if (runtimeInference.kernelPath !== undefined) {
-    delete runtimeInferencePatch.kernelPath;
-    delete runtimeInferencePatch.kernelPathSource;
-  }
-  if (runtimeInferencePatch.modelOverrides) {
-    runtimeInferencePatch.modelOverrides = mergeRuntimeValues(
-      runtimeInferencePatch.modelOverrides,
-      runtimeInference.modelOverrides ?? {}
-    );
-  }
-  if (runtimeInference.kernelPath !== undefined && runtimeInference.compute) {
-    runtimeInferencePatch.compute = mergeRuntimeValues(
-      runtimeInferencePatch.compute ?? {},
-      runtimeInference.compute
-    );
-  }
-  if (runtimeInference.kernelPath !== undefined && runtimeInference.kvcache) {
-    runtimeInferencePatch.kvcache = mergeRuntimeValues(
-      runtimeInferencePatch.kvcache ?? {},
-      runtimeInference.kvcache
-    );
-  }
-
-  return {
-    runtimeConfig: {
-      ...runtimeConfig,
-      inference: mergeRuntimeValues(runtimeConfig.inference, runtimeInferencePatch),
-    },
-    executionV0State,
-  };
-}

package/src/inference/pipelines/text/ffn/dense.d.ts

@@ -1,40 +0,0 @@
-/**
- * Dense FFN Operations
- *
- * Handles standard dense (non-MoE) FFN computations including:
- * - Gate/Up -> Activation -> Down projections
- * - Fused FFN variants
- * - Fused Down+Norm optimization
- *
- * @module inference/pipelines/text/ffn/dense
- */
-
-import type { Tensor } from '../../../../gpu/tensor.js';
-import type { LayerContext, LayerWeights } from '../types.js';
-
-/**
- * Run dense (non-MoE) FFN on GPU.
- */
-export declare function runDenseFFNGPU(
-  layerIdx: number,
-  inputTensor: Tensor,
-  numTokens: number,
-  context: LayerContext,
-  layerWeights: LayerWeights | undefined
-): Promise<Tensor>;
-
-/**
- * Run dense FFN with fused down projection + post-FFN norm.
- * Used for sandwich norm architectures when conditions allow fusion.
- */
-export declare function runDenseFFNWithFusedPostNormGPU(
-  layerIdx: number,
-  inputTensor: Tensor,
-  numTokens: number,
-  context: LayerContext,
-  layerWeights: LayerWeights,
-  residualTensor: Tensor,
-  eps: number,
-  transposeB: boolean,
-  outputBuffer?: GPUBuffer | null
-): Promise<Tensor>;