@simulatte/doppler 0.1.8 → 0.2.0

package/src/converter/quantizer.js

@@ -1,429 +0,0 @@
-import { classifyTensorRole } from '../formats/rdrr/index.js';
-import { selectRuleValue } from '../rules/rule-registry.js';
-import {
-  QK_K,
-  K_SCALE_SIZE,
-  QK4_K_BLOCK_SIZE,
-} from '../config/schema/index.js';
-
-// Re-export for backward compatibility
-export { QK_K, K_SCALE_SIZE, QK4_K_BLOCK_SIZE };
-
-export function float32ToFloat16(value) {
-  const floatView = new Float32Array(1);
-  const int32View = new Int32Array(floatView.buffer);
-  floatView[0] = value;
-  const f = int32View[0];
-
-  const sign = (f >> 31) & 0x1;
-  let exp = (f >> 23) & 0xff;
-  let frac = f & 0x7fffff;
-
-  if (exp === 0xff) {
-    return (sign << 15) | 0x7c00 | (frac ? 0x200 : 0);
-  }
-
-  if (exp === 0) {
-    return sign << 15;
-  }
-
-  exp = exp - 127 + 15;
-
-  if (exp >= 31) {
-    return (sign << 15) | 0x7c00;
-  }
-
-  if (exp <= 0) {
-    if (exp < -10) {
-      return sign << 15;
-    }
-    frac = (frac | 0x800000) >> (1 - exp);
-    return (sign << 15) | (frac >> 13);
-  }
-
-  return (sign << 15) | (exp << 10) | (frac >> 13);
-}
-
-export function float16ToFloat32(h) {
-  const sign = (h >> 15) & 0x1;
-  const exp = (h >> 10) & 0x1f;
-  const frac = h & 0x3ff;
-
-  if (exp === 0) {
-    if (frac === 0) {
-      return sign ? -0 : 0;
-    }
-    return (sign ? -1 : 1) * Math.pow(2, -14) * (frac / 1024);
-  }
-
-  if (exp === 31) {
-    return frac ? NaN : (sign ? -Infinity : Infinity);
-  }
-
-  return (sign ? -1 : 1) * Math.pow(2, exp - 15) * (1 + frac / 1024);
-}
-
-function findMinMax(data, offset, length) {
-  let min = Infinity;
-  let max = -Infinity;
-  for (let i = 0; i < length; i++) {
-    const val = data[offset + i];
-    if (val < min) min = val;
-    if (val > max) max = val;
-  }
-  return { min, max };
-}
-
-function quantizeQ4KBlockWithValidLength(data, offset, validLength = QK_K) {
-  const block = new Uint8Array(QK4_K_BLOCK_SIZE);
-  const blockView = new DataView(block.buffer);
-  const clampedValidLength = Math.max(0, Math.min(QK_K, Math.trunc(validLength)));
-
-  const scales = new Float32Array(8);
-  const minOffsets = new Float32Array(8);
-  const quantized = new Uint8Array(256);
-
-  for (let sb = 0; sb < 8; sb++) {
-    const sbOffset = offset + sb * 32;
-    const subblockStart = sb * 32;
-    const validInSubblock = Math.max(0, Math.min(32, clampedValidLength - subblockStart));
-    if (validInSubblock === 0) {
-      scales[sb] = 0;
-      minOffsets[sb] = 0;
-      continue;
-    }
-
-    const { min, max } = findMinMax(data, sbOffset, validInSubblock);
-
-    minOffsets[sb] = -min;
-    const range = max - min;
-    scales[sb] = range > 0 ? range / 15 : 0;
-
-    const invScale = scales[sb] > 0 ? 1 / scales[sb] : 0;
-    for (let i = 0; i < validInSubblock; i++) {
-      const val = data[sbOffset + i];
-      let q = Math.round((val - min) * invScale);
-      q = Math.max(0, Math.min(15, q));
-      quantized[sb * 32 + i] = q;
-    }
-  }
-
-  let maxScale = 0;
-  let maxMinOffset = 0;
-  for (let i = 0; i < 8; i++) {
-    if (scales[i] > maxScale) maxScale = scales[i];
-    if (minOffsets[i] > maxMinOffset) maxMinOffset = minOffsets[i];
-    if (minOffsets[i] < 0) minOffsets[i] = 0;
-  }
-
-  const d = maxScale / 63;
-  const dmin = maxMinOffset / 63;
-
-  blockView.setUint16(0, float32ToFloat16(d), true);
-  blockView.setUint16(2, float32ToFloat16(dmin), true);
-
-  const invD = d > 0 ? 1 / d : 0;
-  const invDmin = dmin > 0 ? 1 / dmin : 0;
-
-  const scaleBits = new Uint8Array(8);
-  const minBits = new Uint8Array(8);
-
-  for (let i = 0; i < 8; i++) {
-    scaleBits[i] = Math.min(63, Math.round(scales[i] * invD));
-    minBits[i] = Math.min(63, Math.round(Math.max(0, minOffsets[i]) * invDmin));
-  }
-
-  for (let i = 0; i < 4; i++) {
-    const scale_lo = scaleBits[i] & 0x3f;
-    const scale_hi_bits = (scaleBits[i + 4] >> 4) & 0x03;
-    block[4 + i] = scale_lo | (scale_hi_bits << 6);
-  }
-
-  for (let i = 0; i < 4; i++) {
-    const min_lo = minBits[i] & 0x3f;
-    const min_hi_bits = (minBits[i + 4] >> 4) & 0x03;
-    block[4 + 4 + i] = min_lo | (min_hi_bits << 6);
-  }
-
-  for (let i = 0; i < 4; i++) {
-    const scale_lo4 = scaleBits[i + 4] & 0x0f;
-    const min_lo4 = minBits[i + 4] & 0x0f;
-    block[4 + 8 + i] = scale_lo4 | (min_lo4 << 4);
-  }
-
-  for (let chunk = 0; chunk < 4; chunk++) {
-    const chunkBase = chunk * 64;
-    const byteBase = 16 + chunk * 32;
-    for (let i = 0; i < 32; i++) {
-      const lo = quantized[chunkBase + i] & 0x0f;
-      const hi = quantized[chunkBase + 32 + i] & 0x0f;
-      block[byteBase + i] = lo | (hi << 4);
-    }
-  }
-
-  return block;
-}
-
-export function quantizeQ4KBlock(data, offset) {
-  return quantizeQ4KBlockWithValidLength(data, offset, QK_K);
-}
-
-function dequantizeQ4KBlock(block) {
-  const blockView = new DataView(block.buffer, block.byteOffset);
-  const result = new Float32Array(256);
-
-  const d = float16ToFloat32(blockView.getUint16(0, true));
-  const dmin = float16ToFloat32(blockView.getUint16(2, true));
-
-  const scaleBits = new Uint8Array(8);
-  const minBits = new Uint8Array(8);
-
-  for (let i = 0; i < 4; i++) {
-    scaleBits[i] = block[4 + i] & 0x3f;
-    scaleBits[i + 4] = ((block[4 + i] >> 6) & 0x03) << 4;
-  }
-
-  for (let i = 0; i < 4; i++) {
-    minBits[i] = block[4 + 4 + i] & 0x3f;
-    minBits[i + 4] = ((block[4 + 4 + i] >> 6) & 0x03) << 4;
-  }
-
-  for (let i = 0; i < 4; i++) {
-    scaleBits[i + 4] |= block[4 + 8 + i] & 0x0f;
-    minBits[i + 4] |= (block[4 + 8 + i] >> 4) & 0x0f;
-  }
-
-  const scales = new Float32Array(8);
-  const minOffsets = new Float32Array(8);
-  for (let i = 0; i < 8; i++) {
-    scales[i] = d * scaleBits[i];
-    minOffsets[i] = dmin * minBits[i];
-  }
-
-  for (let chunk = 0; chunk < 4; chunk++) {
-    const chunkBase = chunk * 64;
-    const byteBase = 16 + chunk * 32;
-    for (let i = 0; i < 32; i++) {
-      const byte = block[byteBase + i];
-      const lo = byte & 0x0f;
-      const hi = (byte >> 4) & 0x0f;
-
-      const sb0 = Math.floor((chunkBase + i) / 32);
-      const sb1 = Math.floor((chunkBase + 32 + i) / 32);
-
-      result[chunkBase + i] = scales[sb0] * lo - minOffsets[sb0];
-      result[chunkBase + 32 + i] = scales[sb1] * hi - minOffsets[sb1];
-    }
-  }
-
-  return result;
-}
-
-
-export function quantizeToQ4KM(data, shape) {
-  const numElements = shape.reduce((a, b) => a * b, 1);
-
-  if (data.length !== numElements) {
-    throw new Error(`Data length ${data.length} doesn't match shape ${shape}`);
-  }
-
-  const numBlocks = Math.ceil(numElements / QK_K);
-  const paddedLength = numBlocks * QK_K;
-  const paddedData = new Float32Array(paddedLength);
-  paddedData.set(data);
-
-  const quantized = new Uint8Array(numBlocks * QK4_K_BLOCK_SIZE);
-
-  for (let b = 0; b < numBlocks; b++) {
-    const block = quantizeQ4KBlock(paddedData, b * QK_K);
-    quantized.set(block, b * QK4_K_BLOCK_SIZE);
-  }
-
-  return {
-    quantized,
-    numBlocks,
-    originalSize: numElements * 4,
-    quantizedSize: quantized.length,
-    compressionRatio: (numElements * 4) / quantized.length,
-  };
-}
-
-
-export function quantizeToQ4KMRowWise(data, shape) {
-  const [rows, cols] = shape;
-  const numElements = rows * cols;
-
-  if (data.length !== numElements) {
-    throw new Error(`Data length ${data.length} doesn't match shape ${shape}`);
-  }
-
-  const blocksPerRow = Math.ceil(cols / QK_K);
-  const totalBlocks = rows * blocksPerRow;
-
-  const quantized = new Uint8Array(totalBlocks * QK4_K_BLOCK_SIZE);
-
-  for (let row = 0; row < rows; row++) {
-    // Quantize each block in this row
-    for (let b = 0; b < blocksPerRow; b++) {
-      const validLength = Math.max(0, Math.min(QK_K, cols - b * QK_K));
-      const srcOffset = row * cols + b * QK_K;
-      const block = quantizeQ4KBlockWithValidLength(data, srcOffset, validLength);
-      const dstOffset = (row * blocksPerRow + b) * QK4_K_BLOCK_SIZE;
-      quantized.set(block, dstOffset);
-    }
-  }
-
-  return {
-    quantized,
-    numBlocks: totalBlocks,
-    originalSize: numElements * 4,
-    quantizedSize: quantized.length,
-    compressionRatio: (numElements * 4) / quantized.length,
-  };
-}
-
-
-export function transposeF32(data, shape) {
-  const [rows, cols] = shape;
-  const transposed = new Float32Array(rows * cols);
-  for (let r = 0; r < rows; r++) {
-    for (let c = 0; c < cols; c++) {
-      transposed[c * rows + r] = data[r * cols + c];
-    }
-  }
-  return transposed;
-}
-
-
-export function quantizeToQ4KMColumnWise(data, shape) {
-  const [rows, cols] = shape;
-
-  // Transpose: W[out, K] -> W^T[K, out]
-  const transposed = transposeF32(data, shape);
-  const transposedShape = [cols, rows];
-
-  // Quantize transposed matrix with row-wise packing
-  const result = quantizeToQ4KMRowWise(transposed, transposedShape);
-
-  return {
-    ...result,
-    transposedShape,
-  };
-}
-
-
-export function getQ4KSize(shape, layout = 'flat') {
-  const numElements = shape.reduce((a, b) => a * b, 1);
-
-  if (layout === 'flat' || shape.length !== 2) {
-    const numBlocks = Math.ceil(numElements / QK_K);
-    return numBlocks * QK4_K_BLOCK_SIZE;
-  }
-
-  const [rows, cols] = shape;
-
-  if (layout === 'row') {
-    const blocksPerRow = Math.ceil(cols / QK_K);
-    return rows * blocksPerRow * QK4_K_BLOCK_SIZE;
-  }
-
-  if (layout === 'col') {
-    // After transpose: [cols, rows], row-wise on that
-    const blocksPerRow = Math.ceil(rows / QK_K);
-    return cols * blocksPerRow * QK4_K_BLOCK_SIZE;
-  }
-
-  return Math.ceil(numElements / QK_K) * QK4_K_BLOCK_SIZE;
-}
-
-export function dequantizeQ4KM(quantized, numBlocks, shape) {
-  const numElements = shape.reduce((a, b) => a * b, 1);
-  const result = new Float32Array(numElements);
-
-  for (let b = 0; b < numBlocks; b++) {
-    const blockOffset = b * QK4_K_BLOCK_SIZE;
-    const block = quantized.slice(blockOffset, blockOffset + QK4_K_BLOCK_SIZE);
-    const dequantized = dequantizeQ4KBlock(block);
-
-    const startIdx = b * QK_K;
-    const copyLen = Math.min(QK_K, numElements - startIdx);
-    for (let i = 0; i < copyLen; i++) {
-      result[startIdx + i] = dequantized[i];
-    }
-  }
-
-  return result;
-}
-
-export function calculateQuantizationError(original, reconstructed) {
-  if (original.length !== reconstructed.length) {
-    throw new Error('Length mismatch');
-  }
-
-  let mse = 0;
-  let maxError = 0;
-  let signalPower = 0;
-
-  for (let i = 0; i < original.length; i++) {
-    const diff = original[i] - reconstructed[i];
-    mse += diff * diff;
-    maxError = Math.max(maxError, Math.abs(diff));
-    signalPower += original[i] * original[i];
-  }
-
-  mse /= original.length;
-  signalPower /= original.length;
-
-  const snr = signalPower > 0 ? 10 * Math.log10(signalPower / mse) : Infinity;
-
-  return { mse, maxError, snr };
-}
-
-export function quantizeF16ToQ4KM(f16Data, shape) {
-  const f32Data = new Float32Array(f16Data.length);
-  for (let i = 0; i < f16Data.length; i++) {
-    f32Data[i] = float16ToFloat32(f16Data[i]);
-  }
-  return quantizeToQ4KM(f32Data, shape);
-}
-
-export function shouldQuantize(tensorName, shape, options = {}) {
-  const { quantizeEmbeddings = false, modulesToNotConvert = null } = options;
-
-  const numElements = shape.reduce((a, b) => a * b, 1);
-  const role = classifyTensorRole(tensorName);
-  const lower = tensorName.toLowerCase();
-  const isBias = lower.endsWith('.bias') || lower.endsWith('_bias');
-
-  const shouldQuantizeByRole = selectRuleValue('converter', 'tensorRoles', 'shouldQuantize', {
-    numElements,
-    role,
-    isBias,
-    quantizeEmbeddings,
-  });
-
-  if (!shouldQuantizeByRole) {
-    return false;
-  }
-
-  // Additional exclusion via modulesToNotConvert patterns
-  if (modulesToNotConvert && Array.isArray(modulesToNotConvert)) {
-    for (const pattern of modulesToNotConvert) {
-      const regexPattern = pattern
-        .replace(/\./g, '\\.')
-        .replace(/\*/g, '\\d+');
-      const regex = new RegExp(regexPattern);
-      if (regex.test(tensorName)) {
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
-export function getQuantizedSize(shape) {
-  const numElements = shape.reduce((a, b) => a * b, 1);
-  const numBlocks = Math.ceil(numElements / QK_K);
-  return numBlocks * QK4_K_BLOCK_SIZE;
-}

package/src/converter/rope-config.d.ts

@@ -1,15 +0,0 @@
-import type { InferenceConfigSchema } from '../config/schema/inference.schema.js';
-import type { ManifestInferenceSchema } from '../config/schema/manifest.schema.js';
-
-/**
- * Build RoPE configuration from preset and HF config.
- *
- * HF rope_scaling is treated as source of truth when present.
- * If absent, Gemma 3 style rope_parameters are mapped from:
- * - full_attention: ropeTheta + global scaling
- * - sliding_attention: ropeLocalTheta + local scaling
- */
-export declare function buildRoPEConfig(
-  presetInference: InferenceConfigSchema,
-  config: Record<string, unknown>
-): ManifestInferenceSchema['rope'];

package/src/converter/rope-config.js

@@ -1,262 +0,0 @@
-import { DEFAULT_MANIFEST_INFERENCE } from '../config/schema/index.js';
-
-function asObject(value) {
-  if (value == null || typeof value !== 'object' || Array.isArray(value)) {
-    return null;
-  }
-  return value;
-}
-
-function asFiniteNumber(value) {
-  if (value == null || value === '') {
-    return null;
-  }
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : null;
-}
-
-function asBoolean(value) {
-  return typeof value === 'boolean' ? value : null;
-}
-
-function asNumberArray(value) {
-  if (!Array.isArray(value)) return null;
-  const normalized = value.map((entry) => asFiniteNumber(entry));
-  if (normalized.some((entry) => entry == null || entry <= 0)) {
-    return null;
-  }
-  return normalized.map((entry) => Math.trunc(entry));
-}
-
-function normalizeRoPEType(value) {
-  if (typeof value !== 'string') return null;
-  const normalized = value.trim().toLowerCase();
-  if (normalized === '' || normalized === 'default' || normalized === 'none') {
-    return null;
-  }
-  return normalized;
-}
-
-function resolveScalingConfig(ropeScalingConfig, options = {}) {
-  const { strictMissingTypeAndFactor = false, sourceLabel = 'HF config' } = options;
-  const scalingTypeRaw = ropeScalingConfig.type ?? ropeScalingConfig.rope_type;
-  const scalingType = normalizeRoPEType(scalingTypeRaw);
-  const factor = asFiniteNumber(ropeScalingConfig.factor);
-
-  if (scalingTypeRaw == null && factor == null) {
-    if (strictMissingTypeAndFactor) {
-      throw new Error(
-        `${sourceLabel} includes rope_scaling but is missing type/rope_type and factor. ` +
-        'Provide a scaling type or factor to build manifest inference.'
-      );
-    }
-    return {
-      ropeScalingType: null,
-      ropeScalingFactor: DEFAULT_MANIFEST_INFERENCE.rope.ropeScalingFactor,
-      yarnBetaFast: null,
-      yarnBetaSlow: null,
-      yarnOriginalMaxPos: null,
-    };
-  }
-
-  let ropeScalingType = scalingType;
-  let ropeScalingFactor = DEFAULT_MANIFEST_INFERENCE.rope.ropeScalingFactor;
-  let yarnBetaFast = null;
-  let yarnBetaSlow = null;
-  let yarnOriginalMaxPos = null;
-
-  if (ropeScalingType == null) {
-    if (factor != null && factor > 0 && factor !== 1.0) {
-      ropeScalingType = 'linear';
-      ropeScalingFactor = factor;
-    }
-  } else if (factor != null && factor > 0) {
-    ropeScalingFactor = factor;
-  }
-
-  if (ropeScalingType === 'yarn') {
-    const betaFast = asFiniteNumber(ropeScalingConfig.beta_fast);
-    const betaSlow = asFiniteNumber(ropeScalingConfig.beta_slow);
-    const origMaxPos = asFiniteNumber(ropeScalingConfig.original_max_position_embeddings);
-    if (betaFast == null || betaSlow == null || origMaxPos == null) {
-      throw new Error(
-        'YARN scaling detected but required params missing in HF config. ' +
-        'YARN requires beta_fast, beta_slow, and original_max_position_embeddings. ' +
-        `Got: beta_fast=${betaFast}, beta_slow=${betaSlow}, original_max_position_embeddings=${origMaxPos}`
-      );
-    }
-    yarnBetaFast = betaFast;
-    yarnBetaSlow = betaSlow;
-    yarnOriginalMaxPos = origMaxPos;
-  }
-
-  return {
-    ropeScalingType,
-    ropeScalingFactor,
-    yarnBetaFast,
-    yarnBetaSlow,
-    yarnOriginalMaxPos,
-  };
-}
-
-function hasScalingDirective(ropeScalingConfig) {
-  if (!ropeScalingConfig) return false;
-  return ropeScalingConfig.type != null
-    || ropeScalingConfig.rope_type != null
-    || ropeScalingConfig.factor != null
-    || ropeScalingConfig.beta_fast != null
-    || ropeScalingConfig.beta_slow != null
-    || ropeScalingConfig.original_max_position_embeddings != null;
-}
-
-function hasMeaningfulScalingConfig(resolvedScaling) {
-  if (!resolvedScaling) return false;
-  return resolvedScaling.ropeScalingType != null
-    || resolvedScaling.ropeScalingFactor !== DEFAULT_MANIFEST_INFERENCE.rope.ropeScalingFactor
-    || resolvedScaling.yarnBetaFast != null
-    || resolvedScaling.yarnBetaSlow != null
-    || resolvedScaling.yarnOriginalMaxPos != null;
-}
-
-function isSameScalingConfig(left, right) {
-  return left.ropeScalingType === right.ropeScalingType
-    && left.ropeScalingFactor === right.ropeScalingFactor
-    && left.yarnBetaFast === right.yarnBetaFast
-    && left.yarnBetaSlow === right.yarnBetaSlow
-    && left.yarnOriginalMaxPos === right.yarnOriginalMaxPos;
-}
-
-function failOnConflictingScaling(sourceLabel, canonicalScaling, candidateScaling) {
-  if (!hasMeaningfulScalingConfig(candidateScaling)) {
-    return;
-  }
-  if (isSameScalingConfig(canonicalScaling, candidateScaling)) {
-    return;
-  }
-  throw new Error(
-    `${sourceLabel} scaling conflicts with top-level rope_scaling. ` +
-    'Doppler treats rope_scaling as highest precedence and cannot safely auto-resolve this mismatch. ' +
-    'Remove one source or align both scaling configs.'
-  );
-}
-
-export function buildRoPEConfig(presetInference, config) {
-  const ropeScaling = asObject(config.rope_scaling);
-  const ropeParameters = asObject(config.rope_parameters);
-  const flatRoPEParameters = (
-    ropeParameters
-      && !asObject(ropeParameters.full_attention)
-      && !asObject(ropeParameters.sliding_attention)
-  )
-    ? ropeParameters
-    : null;
-  const fullAttentionRoPE = asObject(ropeParameters?.full_attention);
-  const slidingAttentionRoPE = asObject(ropeParameters?.sliding_attention);
-  const presetRoPE = presetInference.rope ?? {};
-  const presetAttn = presetInference.attention;
-
-  let globalScaling = {
-    ropeScalingType: presetRoPE.ropeScalingType
-      ?? presetAttn?.ropeScalingType  // Deprecated location
-      ?? null,
-    ropeScalingFactor: presetRoPE.ropeScalingFactor
-      ?? presetAttn?.ropeScalingFactor  // Deprecated location
-      ?? DEFAULT_MANIFEST_INFERENCE.rope.ropeScalingFactor,
-    yarnBetaFast: presetRoPE.yarnBetaFast ?? null,
-    yarnBetaSlow: presetRoPE.yarnBetaSlow ?? null,
-    yarnOriginalMaxPos: presetRoPE.yarnOriginalMaxPos ?? null,
-  };
-
-  if (ropeScaling) {
-    // HF rope_scaling is source of truth when present.
-    globalScaling = resolveScalingConfig(ropeScaling, {
-      strictMissingTypeAndFactor: true,
-      sourceLabel: 'HF config',
-    });
-    if (slidingAttentionRoPE && hasScalingDirective(slidingAttentionRoPE)) {
-      failOnConflictingScaling(
-        'HF config rope_parameters.sliding_attention',
-        globalScaling,
-        resolveScalingConfig(slidingAttentionRoPE, {
-          strictMissingTypeAndFactor: false,
-          sourceLabel: 'HF config rope_parameters.sliding_attention',
-        })
-      );
-    }
-  } else if (fullAttentionRoPE) {
-    // Gemma 3 style rope_parameters uses per-layer-type settings.
-    globalScaling = resolveScalingConfig(fullAttentionRoPE, {
-      strictMissingTypeAndFactor: false,
-      sourceLabel: 'HF config rope_parameters.full_attention',
-    });
-  } else if (flatRoPEParameters) {
-    globalScaling = resolveScalingConfig(flatRoPEParameters, {
-      strictMissingTypeAndFactor: false,
-      sourceLabel: 'HF config rope_parameters',
-    });
-  }
-
-  const hasPresetLocalScaling = presetRoPE.ropeLocalScalingType !== undefined
-    || presetRoPE.ropeLocalScalingFactor !== undefined
-    || presetRoPE.ropeLocalYarnBetaFast !== undefined
-    || presetRoPE.ropeLocalYarnBetaSlow !== undefined
-    || presetRoPE.ropeLocalYarnOriginalMaxPos !== undefined;
-  let localScaling = hasPresetLocalScaling
-    ? {
-        ropeScalingType: presetRoPE.ropeLocalScalingType ?? globalScaling.ropeScalingType,
-        ropeScalingFactor: presetRoPE.ropeLocalScalingFactor ?? globalScaling.ropeScalingFactor,
-        yarnBetaFast: presetRoPE.ropeLocalYarnBetaFast ?? globalScaling.yarnBetaFast,
-        yarnBetaSlow: presetRoPE.ropeLocalYarnBetaSlow ?? globalScaling.yarnBetaSlow,
-        yarnOriginalMaxPos: presetRoPE.ropeLocalYarnOriginalMaxPos ?? globalScaling.yarnOriginalMaxPos,
-      }
-    : { ...globalScaling };
-  if (ropeScaling) {
-    localScaling = { ...globalScaling };
-  } else if (slidingAttentionRoPE) {
-    localScaling = resolveScalingConfig(slidingAttentionRoPE, {
-      strictMissingTypeAndFactor: false,
-      sourceLabel: 'HF config rope_parameters.sliding_attention',
-    });
-  }
-
-  // HF config is source of truth for ropeTheta when provided:
-  // prefer rope_parameters.full_attention.rope_theta, then rope_theta.
-  const ropeTheta = asFiniteNumber(fullAttentionRoPE?.rope_theta)
-    ?? asFiniteNumber(flatRoPEParameters?.rope_theta)
-    ?? asFiniteNumber(config.rope_theta)
-    ?? presetInference.rope?.ropeTheta
-    ?? DEFAULT_MANIFEST_INFERENCE.rope.ropeTheta;
-
-  // For Gemma 3, local sliding attention theta comes from rope_parameters.sliding_attention.
-  const ropeLocalTheta = asFiniteNumber(slidingAttentionRoPE?.rope_theta)
-    ?? presetInference.rope?.ropeLocalTheta
-    ?? null;
-
-  const mropeInterleaved = asBoolean(flatRoPEParameters?.mrope_interleaved)
-    ?? presetInference.rope?.mropeInterleaved
-    ?? DEFAULT_MANIFEST_INFERENCE.rope.mropeInterleaved;
-  const mropeSection = asNumberArray(flatRoPEParameters?.mrope_section)
-    ?? presetInference.rope?.mropeSection
-    ?? null;
-  const partialRotaryFactor = asFiniteNumber(flatRoPEParameters?.partial_rotary_factor)
-    ?? asFiniteNumber(presetInference.rope?.partialRotaryFactor)
-    ?? null;
-
-  return {
-    ropeTheta,
-    ropeLocalTheta,
-    mropeInterleaved,
-    mropeSection,
-    partialRotaryFactor,
-    ropeScalingType: globalScaling.ropeScalingType,
-    ropeScalingFactor: globalScaling.ropeScalingFactor,
-    yarnBetaFast: globalScaling.yarnBetaFast,
-    yarnBetaSlow: globalScaling.yarnBetaSlow,
-    yarnOriginalMaxPos: globalScaling.yarnOriginalMaxPos,
-    ropeLocalScalingType: localScaling.ropeScalingType,
-    ropeLocalScalingFactor: localScaling.ropeScalingFactor,
-    ropeLocalYarnBetaFast: localScaling.yarnBetaFast,
-    ropeLocalYarnBetaSlow: localScaling.yarnBetaSlow,
-    ropeLocalYarnOriginalMaxPos: localScaling.yarnOriginalMaxPos,
-  };
-}